public override ICompilationResult GetResult() { if (MyChildToResult[myElementAccessExpression.Operand] is ExpressionCompilationResult expressionCompilationResult) { var argumentsResults = MyChildToResult[myElementAccessExpression.ArgumentList]; var argumentListResult = argumentsResults as ArgumentListCompilationResult; var singleArgument = argumentListResult.ArgumentsResults[new ParameterIndex(0)]; var argumentBlock = singleArgument.TryConvertToGetter(MyParams); var argumentReference = argumentBlock.GetReference(); // call getter var operandBlock = expressionCompilationResult.TryConvertToGetter(MyParams); var operandReference = operandBlock.GetReference(); if (operandReference == null) { throw MyParams.CreateException($"null reference result in element access target"); } return(new ElementAccessCompilationResult( GetInstructionsConnectedSequentially(new [] { argumentBlock, operandBlock }), argumentReference, GetLocation(myElementAccessExpression), operandReference)); } return(base.GetResult()); }
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 VariableDeclarationCompiler(IVariableDeclaration variableDeclaration, AbstractILCompilerParams @params) : base(@params) { myVariableDeclaration = variableDeclaration; var variableName = myVariableDeclaration.DeclaredName; try { MyParams.LocalVariableIndexer.GetNextVariable(variableName); } catch (Exception e) { throw MyParams.CreateException($"var stacks exception"); } }
public override ICompilationResult GetResult() { if (myPropertyDeclaration.DeclaredElement == null) { throw MyParams.CreateException($"declaredElement of property is null"); } // var accesors = MyResults.Where(result => result is AccessorDeclarationCompilationResult).Cast<AccessorDeclarationCompilationResult>().ToList(); // if (!accesors.IsEmpty()) // { // if (!accesors.Exists(x => x.KindOfAccesor == AccessorKind.GETTER)) // { // MyParams.CreateFakeProperty($"get_{myPropertyDeclaration.DeclaredElement.ShortName}"); // } // if (!accesors.Exists(x => x.KindOfAccesor == AccessorKind.SETTER)) // { // MyParams.CreateFakeProperty($"set_{myPropertyDeclaration.DeclaredElement.ShortName}"); // } // } return(new ElementCompilationResult()); }
public ArrowExpressionClauseCompiler(IArrowExpressionClause arrowExpressionClause, AbstractILCompilerParams @params) : base(@params) { myArrowExpressionClause = arrowExpressionClause; switch (myArrowExpressionClause.Parent) { case IPropertyDeclaration propertyDeclaration: var name = $"get_{propertyDeclaration.DeclaredName}"; MyParams.CreateMethod(null, name); IsMethod = true; break; case IMethodDeclaration _: case ILocalFunctionDeclaration _: case IAccessorDeclaration _: case IConstructorDeclaration _: case IIndexerDeclaration _: IsMethod = false; break; default: throw MyParams.CreateException( $"parent of ArrowExpression is {myArrowExpressionClause.Parent?.GetType()}"); } }
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() { // TODO: refactor var resultsWithoutTypeParameter = MyChildToResult.Where(kvp => !(kvp.Key is ITypeArgumentList)) .Select(kvp => kvp.Value) .ToList(); var instructionBlock0 = GetInstructionsConnectedSequentially(resultsWithoutTypeParameter); var reference0 = GetReferenceFromResults(resultsWithoutTypeParameter); var withOutGetter = new ExpressionCompilationResult(instructionBlock0, null, reference0); // var resultWithGetter = withOutGetter.TryConvertToGetter(MyParams); var instructions = resultWithGetter.GetInstructionBlock(); var childReference = resultWithGetter.GetReference(); var declaredElement = myReferenceExpression.Reference.Resolve().DeclaredElement; if (declaredElement == null) { return(new ExpressionCompilationResult(instructions, GetLocation(myReferenceExpression))); } var referenceName = declaredElement.GetNameWithHash(); switch (declaredElement) { case IField field: var defaultFieldType = field.Type.IsClassType() ? new ClassId(field.Type.ToString()) : null; myReference = new ClassFieldReference(GetReferenceToOwner(childReference), referenceName, defaultFieldType); break; case ILocalFunctionDeclaration _: if (childReference != null) { throw MyParams.CreateException($"local function invocation({referenceName}) has owner({childReference})"); } myReference = new ClassMethodReference(new ClassReference(new ClassId(MyParams.GetOwnerForLocalFunction())), referenceName); break; case IMethod _: myReference = new ClassMethodReference(GetReferenceToOwner(childReference), referenceName); break; case IProperty _: myReference = new ClassPropertyReference(GetReferenceToOwner(childReference), referenceName); break; case IParameter param: var owner = param.ContainingParametersOwner ?? throw MyParams.CreateException("method parameter's owner is null"); var parameterNumber = owner.Parameters.IndexOf(param); var defaultType = param.Type.IsClassType() ? new ClassId(param.Type.ToString()) : null; myReference = new LocalVariableReference(parameterNumber, defaultType); break; case IClass @class: myReference = @class.GetClassReference(); break; case IStruct @struct: myReference = @struct.GetClassReference(); break; case IEnum @enum: myReference = @enum.GetClassReference(); break; case IExternAlias _: case INamespace _: myReference = null; break; case IInterface @interface: myReference = @interface.GetClassReference(); break; case IEvent @event: myReference = new ClassFieldReference(GetReferenceToOwner(childReference), referenceName); break; case IAnonymousTypeProperty _: //todo break; case ITypeParameter _: //todo break; // case ISingleVariableDesignation _: // case ILocalConstantDeclaration _: // case ILocalVariableDeclaration _: // case ICatchVariableDeclaration _: case IVariableDeclaration variableDeclaration: if (childReference != null) { throw MyParams.CreateException(""); } myReference = MyParams.LocalVariableIndexer.GetVariableIndex(referenceName); ((LocalVariableReference)myReference).DefaultType = variableDeclaration.Type.IsClassType() ? new ClassId(variableDeclaration.Type.ToString()) : null; break; case IDelegate @delegate: myReference = new ClassMethodReference(GetReferenceToOwner(childReference), referenceName); break; default: { throw MyParams.CreateException($"unsupported reference type {declaredElement.GetType()}"); // reference to method or field // var nameOfIdentifier = myReferenceExpression.NameIdentifier.Name; // // if (myReferenceExpression.FirstChild != null) // { // if (MyChildToResult[myReferenceExpression.FirstChild] is IExpressionCompilationResult varOwner) // { // myReference = new ClassMemberReference(varOwner.GetReference(), nameOfIdentifier); // } // else // { // throw MyParams.GetException("Owner of class member is not an expression"); // } // } // else // { // throw MyParams.GetException("Class member has no no owner"); // } // // break; } } if (myReference is LocalVariableReference localVariable) { } return(new ExpressionCompilationResult(instructions, GetLocation(myReferenceExpression), 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)); }