public override ICompilationResult GetResult()
{
var baseResult = base.GetResult();
var resultExpression = myReturnStatement.Value;
if (resultExpression == null || myReturnStatement.Value == null)
{
return(baseResult);
}
var result = MyChildToResult[myReturnStatement.Value];
var resWithGetter = (result as IExpressionCompilationResult).TryConvertToGetter(MyParams);
var reference = resWithGetter.GetReference();
if (reference == null)
{
return(new ElementCompilationResult());
}
var assignment = new ReturnStatement(GetLocation(myReturnStatement), reference);
var instruction = new Instruction(assignment, MyParams.GetNewInstructionId());
return(new ElementCompilationResult(GetInstructionsConnectedSequentially(new List <IInstructionsContainer> {
resWithGetter, instruction
})));
}
public override ICompilationResult GetResult()
{
if (!(base.GetResult() is ExpressionCompilationResult resultWithGetter))
{
return(new ElementCompilationResult());
}
var reference = resultWithGetter.GetReference();
if (reference == null)
{
return(new ElementCompilationResult());
}
var assignment = new ReturnStatement(GetLocation(myArrowExpressionClause), reference);
var instruction = new Instruction(assignment, MyParams.GetNewInstructionId());
var instructionBlock = GetInstructionsConnectedSequentially(new List <IInstructionsContainer> {
resultWithGetter, instruction
});
if (IsMethod)
{
MyParams.GetCurrentMethod().FillWithInstructions(instructionBlock);
MyParams.FinishCurrentMethod();
return(new ElementCompilationResult());
}
return(new ExpressionCompilationResult(instructionBlock, GetLocation(myArrowExpressionClause), reference: myReference));
}
public override ICompilationResult GetResult()
{
var variableInitializer = myLocalVariableDeclaration.Initial;
if (variableInitializer == null)
{
return(new ElementCompilationResult());
}
if (!(MyChildToResult[variableInitializer] is IExpressionCompilationResult
initialValueCompilationResult))
{
throw MyParams.CreateException("initial value of variable is not an expression");
}
// call getter
var initialValueReference = initialValueCompilationResult.GetReference();
if (initialValueReference == null)
{
return(new ElementCompilationResult());
}
var location = GetLocation(myLocalVariableDeclaration);
var assignmentStatement = new AssignmentStatement(location, initialValueReference, myLocalVariableReference);
var instruction = new Instruction(assignmentStatement, MyParams.GetNewInstructionId());
var containingType = myLocalVariableDeclaration.DeclaredElement.Type;
myLocalVariableReference.DefaultType = containingType.IsClassType() ? new ClassId(containingType.ToString()) : null;
return(new ElementCompilationResult(GetInstructionsConnectedSequentially(
new IInstructionsContainer[] { initialValueCompilationResult, instruction })));
}
public override ICompilationResult GetResult()
{
var location = GetLocation(myAssignmentExpression);
var sourceExpression = myAssignmentExpression.Source;
if (sourceExpression == null)
{
return(new ElementCompilationResult());
}
;
var assignmentSource = MyChildToResult[sourceExpression];
if (!(assignmentSource is IExpressionCompilationResult source))
{
throw MyParams.CreateException($"source of assignment is not an expression");
}
// need getter
source = source.TryConvertToGetter(MyParams);
var sourceOfAssignment = source.GetReference();
var referenceToTarget = myAssignmentExpression.Dest;
if (referenceToTarget == null)
{
return(new ElementCompilationResult());
}
;
var assignmentTarget = MyChildToResult[referenceToTarget];
if (!(assignmentTarget is IExpressionCompilationResult target))
{
throw MyParams.CreateException($"target of assignment is not an expression");
}
// !! setter
var targetReference = target.GetReference();
if (sourceOfAssignment == null || targetReference == null)
{
return(new ExpressionCompilationResult());
}
var instructions = new List <IInstructionsContainer> {
source
};
// divide assignment on 2 parts: a = b ->> newVar = b; a = newVar
if (sourceOfAssignment is ClassMemberReference)
{
var extraVariable = MyParams.LocalVariableIndexer.GetNextVariable();
var extraAssignment = new AssignmentStatement(location, sourceOfAssignment, extraVariable);
var extraInstruction = new Instruction(extraAssignment, MyParams.GetNewInstructionId());
instructions.Add(extraInstruction);
sourceOfAssignment = extraVariable;
}
var withSetter = target.TryGetSetter(MyParams, sourceOfAssignment);
if (withSetter != null)
{
instructions.Add(withSetter);
return(new ExpressionCompilationResult(GetInstructionsConnectedSequentially(instructions), location, withSetter.GetReference()));
}
instructions.Add(target);
//!!! workaround for "this = x;"
if (!(targetReference is ClassReference))
{
if (!(targetReference is ClassFieldReference || targetReference is LocalVariableReference))
{
throw MyParams.CreateException($"assignment to {target.GetType()}");
}
var mainAssignmentStatement = new AssignmentStatement(location, sourceOfAssignment, targetReference);
var instruction = new Instruction(mainAssignmentStatement, MyParams.GetNewInstructionId());
instructions.Add(instruction);
}
return(new ExpressionCompilationResult(GetInstructionsConnectedSequentially(instructions), location, targetReference));
}
public override ICompilationResult GetResult()
{
var location = GetLocation(myInvocationExpression);
var argumentListResult =
MyChildToResult[myInvocationExpression.ArgumentList] as ArgumentListCompilationResult;
var invokedExpressionCompilationResult = MyChildToResult[myInvocationExpression.InvokedExpression];
var delegateParameters = new Dictionary <int, Reference>();
var arguments = new Dictionary <ParameterIndex, Reference>();
foreach (var(inParameter, result) in argumentListResult.ArgumentsResults)
{
// call getter
var passedVariable = result.GetReference();
if (passedVariable != null)
{
arguments.Add(inParameter, passedVariable);
}
}
var argumentsInstructionBlock = GetInstructionsConnectedSequentially(argumentListResult.ArgumentsResults.Select(kv => kv.Value));
if (!(invokedExpressionCompilationResult is IExpressionCompilationResult expressionCompilationResult))
{
throw MyParams.CreateException("invoked expression result in not an expression compilation result");
}
var returnedValues = GetVariablePairsFromInvoked(myInvocationExpression.InvokedExpression);
// call getter
var expressionResult = expressionCompilationResult.TryConvertToGetter(MyParams);
var invokedVar = expressionResult.GetReference();
InvocationStatement fakeInvocation = null;
var needToInvoke = true;
if (invokedVar != null)
{
InvocationTarget invocationTarget;
switch (invokedVar)
{
case LocalVariableReference localVariableReference:
invocationTarget = new LocalVariableTarget(localVariableReference);
break;
case LocalFunctionReference localFunctionReference:
invocationTarget = new LocalFunctionTarget(localFunctionReference);
MyParams.CheckExistenceOfLocalFunction(localFunctionReference);
break;
case ClassMethodReference classMethodReference:
invocationTarget = new ClassMethodTarget(classMethodReference);
if (myInvocationExpression.Reference == null)
{
throw MyParams.CreateException("invocation reference is null");
}
if (myInvocationExpression.Reference.Resolve().DeclaredElement == null ||
myInvocationExpression.Reference.Resolve().DeclaredElement.GetType().ToString() != "JetBrains.ReSharper.Psi.CSharp.Impl.DeclaredElement.CSharpMethod")
{
needToInvoke = false;
if (arguments.TryGetValue(new ParameterIndex(0), out var reference) &&
reference is LocalFunctionReference funRef)
{
fakeInvocation = new InvocationStatement(location,
new LocalFunctionTarget(funRef),
new Dictionary <ParameterIndex, Reference>(),
new Dictionary <ParameterIndex, Reference>());
}
}
break;
case ClassFieldReference classFieldReference:
invocationTarget = new ClassFieldTarget(classFieldReference);
break;
case ClassPropertyReference classPropertyReference:
Trace.Assert(false, "invocation target is property");
invocationTarget = new ClassPropertyTarget(classPropertyReference);
break;
default:
throw MyParams.CreateException($"{invokedVar.GetType()}: unsupported reference type to invoke");
}
// if (invocationTarget is ClassMethodTarget classMethodTarget &&
// CompilerUtils.IsAddToCollectionMethod(classMethodTarget))
// {
// myInvocationExpression.InvokedExpression.
// var statement = new InvocationStatement(location,
// invocationTarget,
// arguments,
// returnedValues);
//
// }
myReference = returnedValues[ParameterIndex.ReturnValueIndex];
var summaryBlock = GetInstructionsConnectedSequentially(new List <IInstructionsContainer>
{
expressionResult, argumentsInstructionBlock
});
if (needToInvoke || fakeInvocation != null)
{
var statement = fakeInvocation ?? new InvocationStatement(location,
invocationTarget,
arguments,
returnedValues);
var invocationInstruction = new Instruction(statement, MyParams.GetNewInstructionId());
summaryBlock = GetInstructionsConnectedSequentially(new List <IInstructionsContainer>
{
summaryBlock, invocationInstruction
});
}
return(new ExpressionCompilationResult(summaryBlock, location, reference: myReference));
}
return(new ExpressionCompilationResult(expressionResult.GetInstructionBlock(), location, reference: myReference));
}
public override ICompilationResult GetResult()
{
IReference reference;
var location = GetLocation(myObjectCreationExpression);
switch (myObjectCreationExpression.TypeUsage)
{
case IUserTypeUsage userDeclaredTypeUsage:
reference = userDeclaredTypeUsage.ScalarTypeName.Reference;
break;
case IPredefinedTypeUsage predefinedDeclaredTypeUsage:
reference = predefinedDeclaredTypeUsage.ScalarPredefinedTypeName.Reference;
break;
case IDynamicTypeUsage dynamicDeclaredTypeUsage:
throw MyParams.CreateException("found dynamicDeclaredTypeUsage");
case ITupleTypeUsage tupleDeclaredTypeUsage:
throw MyParams.CreateException("found tupleDeclaredTypeUsage");
break;
default:
throw MyParams.CreateException($"{myObjectCreationExpression.TypeUsage.GetType()} is unexpected type");
}
var declaredElement = reference.Resolve().DeclaredElement;
if (declaredElement == null)
{
return(new ExpressionCompilationResult(new InstructionBlock(), location));
}
if (!(declaredElement is ITypeElement typeElement))
{
throw MyParams.CreateException("In object creation declared element " + declaredElement.GetElementType().PresentableName + " is not a type element");
}
var classRef = typeElement.GetClassReference();
var constructor = myObjectCreationExpression.ConstructorReference.Resolve().DeclaredElement as IConstructor;
if (constructor == null)
{
return(new ExpressionCompilationResult(new InstructionBlock(), location, reference: classRef));
}
var invokedFun = new ClassMethodTarget(new ClassMethodReference(classRef, constructor.GetNameWithHash()));
var passedParameters = new Dictionary <ParameterIndex, Reference>();
if (myObjectCreationExpression.ArgumentList != null)
{
if (MyChildToResult[myObjectCreationExpression.ArgumentList] is ArgumentListCompilationResult
argumentListResult)
{
foreach (var(inParameter, result) in argumentListResult.ArgumentsResults)
{
// call getter
var passedVariable = result.GetReference();
if (passedVariable != null)
{
passedParameters.Add(inParameter, passedVariable);
}
}
}
}
var returnedValues = GetVariablePairsFromInvoked(myObjectCreationExpression);
var statement = new InvocationStatement(location, invokedFun, passedParameters, returnedValues, true);
var instruction = new Instruction(statement, MyParams.GetNewInstructionId());
var returned = (LocalVariableReference)statement.ReturnedValues[new ParameterIndex(-1)];
returned.DefaultType = classRef.ClassId;
return(new ExpressionCompilationResult(new InstructionBlock(instruction), location, reference: returned));
}
