public override void OnArrayTypeReference(Boo.Lang.Compiler.Ast.ArrayTypeReference node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.ArrayTypeReference")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.IsPointer)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "IsPointer"), Serialize(node.IsPointer))); } if (ShouldSerialize(node.ElementType)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "ElementType"), Serialize(node.ElementType))); } if (ShouldSerialize(node.Rank)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Rank"), Serialize(node.Rank))); } Push(mie); }
/// <summary> /// Initializes a new instance of the ConstructorInitializerStatement class. /// </summary> /// <param name="proxy">Proxy object for the statement.</param> /// <param name="expression">The expression within this statement.</param> internal ConstructorInitializerStatement(CodeUnitProxy proxy, MethodInvocationExpression expression) : base(proxy, StatementType.ConstructorInitializer) { Param.AssertNotNull(proxy, "proxy"); Param.AssertNotNull(expression, "expression"); this.expression.Value = expression; }
/// <summary> /// Initializes a new instance of the ConstructorInitializerStatement class. /// </summary> /// <param name="tokens"> /// The list of tokens that form the statement. /// </param> /// <param name="expression"> /// The expression within this statement. /// </param> internal ConstructorInitializerStatement(CsTokenList tokens, MethodInvocationExpression expression) : base(StatementType.ConstructorInitializer, tokens) { Param.AssertNotNull(tokens, "tokens"); Param.AssertNotNull(expression, "expression"); this.expression = expression; this.AddExpression(expression); }
/// <summary> /// Handles the replacement of the <paramref name="invocation" />'s arguments. /// </summary> public void AddArgumentReplacements(MethodInvocationExpression invocation) { var methodBody = invocation.Method.MethodBody; var parameters = methodBody.Parameters.ToArray(); var arguments = invocation.Arguments.ToArray(); Assert.That(parameters.Length == arguments.Length, "Parameters and arguments don't match up."); for (var i = 0; i < parameters.Length; ++i) { if (arguments[i].RefKind != RefKind.None || !VariableAccessClassifier.Classify(methodBody.Body, parameters[i]).IsWritten()) AddVariableReplacement(parameters[i], arguments[i].Expression); } }
/// <summary> /// Visits an element of type <see cref="MethodInvocationExpression" />. /// </summary> /// <param name="expression">The <see cref="MethodInvocationExpression" /> instance that should be visited.</param> protected internal override BoundNode VisitMethodInvocationExpression(MethodInvocationExpression expression) { var body = expression.Method.MethodBody.Body; var returnStatement = body.Statements[0] as ReturnStatement; Requires.That(returnStatement != null, "Detected an invalid invocation of method '{0}' declared by '{1}' within the formula: The invoked method does not " + "consist of a single return statement only.", expression.Method.MethodInfo, expression.Method.MethodInfo.DeclaringType.FullName); _variableReplacer.AddArgumentReplacements(expression); var replacedBody = (Expression)_variableReplacer.Visit(returnStatement.Expression); return Visit(replacedBody); }
public override void OnArrayLiteralExpression(Boo.Lang.Compiler.Ast.ArrayLiteralExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.ArrayLiteralExpression")); if (ShouldSerialize(node.Items)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Items"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.ExpressionCollection", node.Items))); } if (ShouldSerialize(node.Type)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Type"), Serialize(node.Type))); } Push(mie); }
internal void SerializeSpliceTypeReference(Boo.Lang.Compiler.Ast.SpliceTypeReference node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.SpliceTypeReference")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.IsPointer)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "IsPointer"), Serialize(node.IsPointer))); } if (ShouldSerialize(node.Expression)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Expression"), Serialize(node.Expression))); } Push(mie); }
override public void OnConditionalExpression(Boo.Lang.Compiler.Ast.ConditionalExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.ConditionalExpression")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Condition)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Condition"), Serialize(node.Condition))); } if (ShouldSerialize(node.TrueValue)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "TrueValue"), Serialize(node.TrueValue))); } if (ShouldSerialize(node.FalseValue)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "FalseValue"), Serialize(node.FalseValue))); } Push(mie); }
public override void Visit(MethodInvocationExpression node) { CannotOptimize(node); }
override public void OnBlockExpression(Boo.Lang.Compiler.Ast.BlockExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.BlockExpression")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Parameters)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Parameters"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.ParameterDeclarationCollection", node.Parameters))); } if (ShouldSerialize(node.ReturnType)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "ReturnType"), Serialize(node.ReturnType))); } if (ShouldSerialize(node.Body)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Body"), Serialize(node.Body))); } Push(mie); }
override public void OnField(Boo.Lang.Compiler.Ast.Field node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.Field")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Modifiers)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Modifiers"), Serialize(node.Modifiers))); } if (ShouldSerialize(node.Name)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Name"), Serialize(node.Name))); } if (ShouldSerialize(node.Attributes)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Attributes"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.AttributeCollection", node.Attributes))); } if (ShouldSerialize(node.Type)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Type"), Serialize(node.Type))); } if (ShouldSerialize(node.Initializer)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Initializer"), Serialize(node.Initializer))); } if (ShouldSerialize(node.IsVolatile)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "IsVolatile"), Serialize(node.IsVolatile))); } Push(mie); }
override public void OnStatementTypeMember(Boo.Lang.Compiler.Ast.StatementTypeMember node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.StatementTypeMember")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Modifiers)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Modifiers"), Serialize(node.Modifiers))); } if (ShouldSerialize(node.Name)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Name"), Serialize(node.Name))); } if (ShouldSerialize(node.Attributes)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Attributes"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.AttributeCollection", node.Attributes))); } if (ShouldSerialize(node.Statement)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Statement"), Serialize(node.Statement))); } Push(mie); }
override public void OnSlicingExpression(Boo.Lang.Compiler.Ast.SlicingExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.SlicingExpression")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Target)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Target"), Serialize(node.Target))); } if (ShouldSerialize(node.Indices)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Indices"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.SliceCollection", node.Indices))); } Push(mie); }
protected override bool ExpandExtension(ref MethodInvocationExpression extension, MacroStatement macro, MacroStatement parent, ref Statement expansion) { extension.Arguments.Add(macro.Arguments[0]); return(true); }
private MethodInvocationExpression CreateGetEnumeratorInvocation(MethodInvocationExpression enumerableConstructorInvocation) { return(CodeBuilder.CreateMethodInvocation( enumerableConstructorInvocation, GetGetEnumeratorEntity())); }
public override void Visit(MethodInvocationExpression methodInvocationExpression) { base.Visit(methodInvocationExpression); AddReference(GetDeclarationContainer(), (Node)methodInvocationExpression.TypeInference.Declaration); }
protected virtual void ExpandQuackInvocation(MethodInvocationExpression node) { ExpandQuackInvocation(node, RuntimeServices_Invoke); }
// MyCollection list = new MyCollection() { 1, { 2, 2 } , 3 }; // // == // // MyCollection temp = new MyCollection(); // temp.Add(1); // temp.Add(2, 2); // temp.Add(3); // MyCollection list = temp; protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount) { result = null; replacedStatementsCount = 0; ObjectCreationExpression objectCreation; Expression assignee; if (!TryGetObjectCreation(statements, startIndex, out objectCreation, out assignee)) { return(false); } if (objectCreation.Initializer != null && objectCreation.Initializer.InitializerType != InitializerType.CollectionInitializer) { return(false); } if (!ImplementsInterface(objectCreation.Type, "System.Collections.IEnumerable")) { return(false); } ExpressionCollection addedExpressions = new ExpressionCollection(); for (int i = startIndex + 1; i < statements.Count; i++) { Expression expression; if (!TryGetNextExpression(statements[i], out expression)) { break; } if (expression.CodeNodeType != CodeNodeType.MethodInvocationExpression) { break; } MethodInvocationExpression methodInvocation = (expression as MethodInvocationExpression); MethodDefinition methodDefinition = methodInvocation.MethodExpression.MethodDefinition; if (!CompareTargets(assignee, methodInvocation.MethodExpression.Target)) { break; } if (methodDefinition.Name != "Add") { break; } if (methodInvocation.Arguments.Count == 0) { break; } else if (methodInvocation.Arguments.Count == 1) { addedExpressions.Add(methodInvocation.Arguments[0].Clone()); } else { ExpressionCollection currentArguments = new ExpressionCollection( methodInvocation.Arguments.Select(x => x.Clone())); BlockExpression blockExpression = new BlockExpression(currentArguments, null); addedExpressions.Add(blockExpression); } } if (addedExpressions.Count == 0) { return(false); } if (objectCreation.Initializer == null) { var initializer = new InitializerExpression(addedExpressions, InitializerType.CollectionInitializer); initializer.IsMultiLine = true; objectCreation.Initializer = initializer; } else { foreach (var item in addedExpressions) { objectCreation.Initializer.Expressions.Add(item); } } result = statements[startIndex]; replacedStatementsCount = addedExpressions.Count + 1; return(true); }
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, INamingScope namingScope) { var invocationType = invocation; var genericArguments = Type.EmptyTypes; var constructor = invocation.GetConstructors()[0]; IExpression proxiedMethodTokenExpression; if (MethodToOverride.IsGenericMethod) { // Not in the cache: generic method genericArguments = emitter.MethodBuilder.GetGenericArguments(); proxiedMethodTokenExpression = new MethodTokenExpression(MethodToOverride.MakeGenericMethod(genericArguments)); if (invocationType.IsGenericTypeDefinition) { // bind generic method arguments to invocation's type arguments invocationType = invocationType.MakeGenericType(genericArguments); constructor = TypeBuilder.GetConstructor(invocationType, constructor); } } else { var proxiedMethodToken = @class.CreateStaticField(namingScope.GetUniqueName("token_" + MethodToOverride.Name), typeof(MethodInfo)); @class.ClassConstructor.CodeBuilder.AddStatement(new AssignStatement(proxiedMethodToken, new MethodTokenExpression(MethodToOverride))); proxiedMethodTokenExpression = proxiedMethodToken; } var methodInterceptors = SetMethodInterceptors(@class, namingScope, emitter, proxiedMethodTokenExpression); var dereferencedArguments = IndirectReference.WrapIfByRef(emitter.Arguments); var hasByRefArguments = HasByRefArguments(emitter.Arguments); var arguments = GetCtorArguments(@class, proxiedMethodTokenExpression, dereferencedArguments, methodInterceptors); var ctorArguments = ModifyArguments(@class, arguments); var invocationLocal = emitter.CodeBuilder.DeclareLocal(invocationType); emitter.CodeBuilder.AddStatement(new AssignStatement(invocationLocal, new NewInstanceExpression(constructor, ctorArguments))); if (MethodToOverride.ContainsGenericParameters) { EmitLoadGenericMethodArguments(emitter, MethodToOverride.MakeGenericMethod(genericArguments), invocationLocal); } if (hasByRefArguments) { emitter.CodeBuilder.AddStatement(new TryStatement()); } var proceed = new MethodInvocationExpression(invocationLocal, InvocationMethods.Proceed); emitter.CodeBuilder.AddStatement(proceed); if (hasByRefArguments) { emitter.CodeBuilder.AddStatement(new FinallyStatement()); } GeneratorUtil.CopyOutAndRefParameters(dereferencedArguments, invocationLocal, MethodToOverride, emitter); if (hasByRefArguments) { emitter.CodeBuilder.AddStatement(new EndExceptionBlockStatement()); } if (MethodToOverride.ReturnType != typeof(void)) { var getRetVal = new MethodInvocationExpression(invocationLocal, InvocationMethods.GetReturnValue); // Emit code to ensure a value type return type is not null, otherwise the cast will cause a null-deref if (emitter.ReturnType.IsValueType && !emitter.ReturnType.IsNullableType()) { LocalReference returnValue = emitter.CodeBuilder.DeclareLocal(typeof(object)); emitter.CodeBuilder.AddStatement(new AssignStatement(returnValue, getRetVal)); emitter.CodeBuilder.AddStatement(new IfNullExpression(returnValue, new ThrowStatement(typeof(InvalidOperationException), "Interceptors failed to set a return value, or swallowed the exception thrown by the target"))); } // Emit code to return with cast from ReturnValue emitter.CodeBuilder.AddStatement(new ReturnStatement(new ConvertExpression(emitter.ReturnType, getRetVal))); } else { emitter.CodeBuilder.AddStatement(new ReturnStatement()); } return(emitter); }
internal void SerializeSpliceParameterDeclaration(Boo.Lang.Compiler.Ast.SpliceParameterDeclaration node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.SpliceParameterDeclaration")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Name)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Name"), Serialize(node.Name))); } if (ShouldSerialize(node.Type)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Type"), Serialize(node.Type))); } if (ShouldSerialize(node.Modifiers)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Modifiers"), Serialize(node.Modifiers))); } if (ShouldSerialize(node.Attributes)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Attributes"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.AttributeCollection", node.Attributes))); } if (ShouldSerialize(node.ParameterDeclaration)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "ParameterDeclaration"), Serialize(node.ParameterDeclaration))); } if (ShouldSerialize(node.NameExpression)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "NameExpression"), Serialize(node.NameExpression))); } Push(mie); }
override public void OnExtendedGeneratorExpression(Boo.Lang.Compiler.Ast.ExtendedGeneratorExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.ExtendedGeneratorExpression")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Items)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Items"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.GeneratorExpressionCollection", node.Items))); } Push(mie); }
public override void OnMethodInvocationExpression(MethodInvocationExpression node) { base.OnMethodInvocationExpression(node); node.ExpressionType = _replacer.MapType(node.ExpressionType); }
override public void OnCustomStatement(Boo.Lang.Compiler.Ast.CustomStatement node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.CustomStatement")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Modifier)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Modifier"), Serialize(node.Modifier))); } Push(mie); }
override public void Apply(Boo.Lang.Compiler.Ast.Node node) { string name; Node parent; string errorMessage = null; ParameterDeclaration pd = node as ParameterDeclaration; if (pd != null) { name = pd.Name; parent = pd.ParentNode; } else { Property prop = node as Property; if (prop != null && prop.Setter != null) { name = "value"; parent = prop.Setter; } else { InvalidNodeForAttribute("ParameterDeclaration or Property"); return; } } string exceptionClass = null; StatementModifier modifier = null; if (null == _condition) { exceptionClass = "ArgumentNullException"; modifier = new StatementModifier( StatementModifierType.If, new BinaryExpression(BinaryOperatorType.ReferenceEquality, new ReferenceExpression(name), new NullLiteralExpression())); } else { exceptionClass = "ArgumentException"; modifier = new StatementModifier( StatementModifierType.Unless, _condition); errorMessage = "Expected: " + _condition.ToString(); } MethodInvocationExpression x = new MethodInvocationExpression(); x.Target = new MemberReferenceExpression( new ReferenceExpression("System"), exceptionClass); if (null != errorMessage) { x.Arguments.Add(new StringLiteralExpression(errorMessage)); } x.Arguments.Add(new StringLiteralExpression(name)); RaiseStatement rs = new RaiseStatement(x, modifier); rs.LexicalInfo = LexicalInfo; Method method = parent as Method; if (null != method) { method.Body.Statements.Insert(0, rs); } else { Property property = (Property)parent; if (null != property.Getter) { property.Getter.Body.Statements.Insert(0, rs); } if (null != property.Setter) { property.Setter.Body.Statements.Insert(0, rs.CloneNode()); } } }
override public void OnImport(Boo.Lang.Compiler.Ast.Import node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.Import")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Expression)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Expression"), Serialize(node.Expression))); } if (ShouldSerialize(node.AssemblyReference)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "AssemblyReference"), Serialize(node.AssemblyReference))); } if (ShouldSerialize(node.Alias)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Alias"), Serialize(node.Alias))); } Push(mie); }
protected virtual void PrepareConstructorCalls() { _stateMachineConstructorInvocation = CodeBuilder.CreateGenericConstructorInvocation( (IType)_stateMachineClass.ClassDefinition.Entity, GetStateMachineGenericParams()); }
override public void OnEvent(Boo.Lang.Compiler.Ast.Event node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.Event")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Modifiers)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Modifiers"), Serialize(node.Modifiers))); } if (ShouldSerialize(node.Name)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Name"), Serialize(node.Name))); } if (ShouldSerialize(node.Attributes)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Attributes"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.AttributeCollection", node.Attributes))); } if (ShouldSerialize(node.Add)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Add"), Serialize(node.Add))); } if (ShouldSerialize(node.Remove)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Remove"), Serialize(node.Remove))); } if (ShouldSerialize(node.Raise)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Raise"), Serialize(node.Raise))); } if (ShouldSerialize(node.Type)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Type"), Serialize(node.Type))); } Push(mie); }
public override void VisitMethodInvocationExpression(MethodInvocationExpression node) { TrySetMethodInvocationPendingName(node.MethodExpression); ClearPendingForSuggestion(); base.VisitMethodInvocationExpression(node); }
override public void LeaveMethodInvocationExpression(MethodInvocationExpression node) { OnExpression(node); }
public override ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node) { dummyVar0 = this.VisitMethodInvocationExpression(node); this.FixArguments(node.get_MethodExpression().get_Method(), node.get_Arguments()); return(node); }
/// <summary> /// Initializes a new instance of the <see cref="CompileExpression"/> class. /// </summary> /// <param name="profile"> /// The profile. /// </param> /// <param name="function"> /// The function. /// </param> public CompileExpression(string profile, MethodInvocationExpression function) { Profile = new Identifier(profile); Function = function; }
public static Expression dependencies(MethodInvocationExpression addDependencyMethod) { return(addDependencyMethod); }
private bool CheckTheFinallyClause(BlockStatement theFinally) { //At most the finally can be: bool cond = flag != false; if(cond) { Monitor.Exit(...); } int statementsCount = theFinally.Statements.Count; if (statementsCount > 2 && statementsCount == 0) { return(false); } MethodInvocationExpression theMethodInvocation = null; if (this.lockType == LockType.WithFlag) { VariableReference theConditionVariable = null; if (statementsCount == 2) { if (theFinally.Statements[0].CodeNodeType != CodeNodeType.ExpressionStatement) { return(false); } BinaryExpression theConditionAssignExpression = (theFinally.Statements[0] as ExpressionStatement).Expression as BinaryExpression; if (theConditionAssignExpression == null || !theConditionAssignExpression.IsAssignmentExpression || theConditionAssignExpression.Left.CodeNodeType != CodeNodeType.VariableReferenceExpression) { return(false); } theConditionVariable = (theConditionAssignExpression.Left as VariableReferenceExpression).Variable; } if (statementsCount == 0) { return(false); } IfStatement theIf = theFinally.Statements[statementsCount - 1] as IfStatement; if (theIf == null) { return(false); } if (theConditionVariable != null && (theIf.Condition.CodeNodeType != CodeNodeType.UnaryExpression || (theIf.Condition as UnaryExpression).Operator != UnaryOperator.LogicalNot || (theIf.Condition as UnaryExpression).Operand.CodeNodeType != CodeNodeType.VariableReferenceExpression || ((theIf.Condition as UnaryExpression).Operand as VariableReferenceExpression).Variable != theConditionVariable)) { return(false); } return(CheckTheIfStatement(theIf)); } else //LockType.Simple { if (statementsCount > 1 || theFinally.Statements[0].CodeNodeType != CodeNodeType.ExpressionStatement) { return(false); } theMethodInvocation = (theFinally.Statements[0] as ExpressionStatement).Expression as MethodInvocationExpression; return(CheckTheMethodInvocation(theMethodInvocation, "Exit")); } }
public static Expression get_from(MethodInvocationExpression get) { return(get); }
override public void OnBinaryExpression(Boo.Lang.Compiler.Ast.BinaryExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.BinaryExpression")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Operator)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Operator"), Serialize(node.Operator))); } if (ShouldSerialize(node.Left)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Left"), Serialize(node.Left))); } if (ShouldSerialize(node.Right)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Right"), Serialize(node.Right))); } Push(mie); }
public virtual T VisitMethodInvocationExpression(MethodInvocationExpression methodInvocationExpression) { return(VisitChildren(methodInvocationExpression)); }
override public void OnDoubleLiteralExpression(Boo.Lang.Compiler.Ast.DoubleLiteralExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.DoubleLiteralExpression")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Value)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Value"), Serialize(node.Value))); } if (ShouldSerialize(node.IsSingle)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "IsSingle"), Serialize(node.IsSingle))); } Push(mie); }
private static Expression GetQueryExpression(ActionFlowGraph afg) { IDictionary <int, Expression> variables = new Dictionary <int, Expression>(); ActionBlock block = afg.Blocks[0]; while (block != null) { switch (block.ActionType) { case ActionType.Invoke: InvokeActionBlock invokeBlock = (InvokeActionBlock)block; MethodInvocationExpression invocation = invokeBlock.Expression; if (IsActivateInvocation(invocation) || IsNoSideEffectIndirectActivationInvocation(invocation)) { block = invokeBlock.Next; break; } UnsupportedExpression(invocation); break; case ActionType.ConditionalBranch: UnsupportedPredicate("Conditional blocks are not supported."); break; case ActionType.Branch: block = ((BranchActionBlock)block).Target; break; case ActionType.Assign: { AssignActionBlock assignBlock = (AssignActionBlock)block; AssignExpression assign = assignBlock.AssignExpression; VariableReferenceExpression variable = assign.Target as VariableReferenceExpression; if (null == variable) { UnsupportedExpression(assign); } else { if (variables.ContainsKey(variable.Variable.Index)) { UnsupportedExpression(assign.Expression); } variables.Add(variable.Variable.Index, assign.Expression); block = assignBlock.Next; } break; } case ActionType.Return: { Expression expression = ((ReturnActionBlock)block).Expression; VariableReferenceExpression variable = expression as VariableReferenceExpression; return(null == variable ? expression : variables[variable.Variable.Index]); } } } return(null); }
internal void SerializeSpliceMemberReferenceExpression(Boo.Lang.Compiler.Ast.SpliceMemberReferenceExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.SpliceMemberReferenceExpression")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Target)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Target"), Serialize(node.Target))); } if (ShouldSerialize(node.NameExpression)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "NameExpression"), Serialize(node.NameExpression))); } Push(mie); }
protected override MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter @class, ProxyGenerationOptions options, INamingScope namingScope) { var invocationType = invocation; Trace.Assert(MethodToOverride.IsGenericMethod == invocationType.IsGenericTypeDefinition()); var genericArguments = TypeExtender.EmptyTypes; var constructor = invocation.GetConstructors()[0]; Expression proxiedMethodTokenExpression; if (MethodToOverride.IsGenericMethod) { // bind generic method arguments to invocation's type arguments genericArguments = emitter.MethodBuilder.GetGenericArguments(); invocationType = invocationType.MakeGenericType(genericArguments); constructor = TypeBuilder.GetConstructor(invocationType, constructor); // Not in the cache: generic method proxiedMethodTokenExpression = new MethodTokenExpression(MethodToOverride.MakeGenericMethod(genericArguments)); } else { var proxiedMethodToken = @class.CreateStaticField(namingScope.GetUniqueName("token_" + MethodToOverride.Name), typeof(MethodInfo)); @class.ClassConstructor.CodeBuilder.AddStatement(new AssignStatement(proxiedMethodToken, new MethodTokenExpression(MethodToOverride))); proxiedMethodTokenExpression = proxiedMethodToken.ToExpression(); } var dereferencedArguments = IndirectReference.WrapIfByRef(emitter.Arguments); var hasByRefArguments = HasByRefArguments(emitter.Arguments); var arguments = GetCtorArguments(@class, namingScope, proxiedMethodTokenExpression, dereferencedArguments); var ctorArguments = ModifyArguments(@class, arguments); var invocationLocal = emitter.CodeBuilder.DeclareLocal(invocationType); emitter.CodeBuilder.AddStatement(new AssignStatement(invocationLocal, new NewInstanceExpression(constructor, ctorArguments))); if (MethodToOverride.ContainsGenericParameters) { EmitLoadGenricMethodArguments(emitter, MethodToOverride.MakeGenericMethod(genericArguments), invocationLocal); } if (hasByRefArguments) { emitter.CodeBuilder.AddStatement(new TryStatement()); } var proceed = new ExpressionStatement(new MethodInvocationExpression(invocationLocal, InvocationMethods.Proceed)); emitter.CodeBuilder.AddStatement(proceed); if (hasByRefArguments) { emitter.CodeBuilder.AddStatement(new FinallyStatement()); } GeneratorUtil.CopyOutAndRefParameters(dereferencedArguments, invocationLocal, MethodToOverride, emitter); if (hasByRefArguments) { emitter.CodeBuilder.AddStatement(new EndExceptionBlockStatement()); } if (MethodToOverride.ReturnType != typeof(void)) { // Emit code to return with cast from ReturnValue // @mbrit - 2012-05-31 - see the note associated with the GetReturnValueForWinRt declaration // for more information on this... var useWinRtGenericHandler = false; #if NETFX_CORE if (emitter.ReturnType == typeof(int) || emitter.ReturnType == typeof(bool)) { useWinRtGenericHandler = true; } #endif if (!(useWinRtGenericHandler)) { var getRetVal = new MethodInvocationExpression(invocationLocal, InvocationMethods.GetReturnValue); emitter.CodeBuilder.AddStatement(new ReturnStatement(new ConvertExpression(emitter.ReturnType, getRetVal))); } else { #if NETFX_CORE var grvArgs = new Type[] { emitter.ReturnType }; var grvCall = InvocationMethods.GetReturnValueForWinRt.MakeGenericMethod(grvArgs); var getRetVal = new MethodInvocationExpression(invocationLocal, grvCall); emitter.CodeBuilder.AddStatement(new ReturnStatement(getRetVal)); #endif } } else { emitter.CodeBuilder.AddStatement(new ReturnStatement()); } return(emitter); }
override public void OnCollectionInitializationExpression(Boo.Lang.Compiler.Ast.CollectionInitializationExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.CollectionInitializationExpression")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Collection)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Collection"), Serialize(node.Collection))); } if (ShouldSerialize(node.Initializer)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Initializer"), Serialize(node.Initializer))); } Push(mie); }
/// <summary> /// Optimize the <c>for item in range()</c> construct /// </summary> /// <param name="node">the for statement to check</param> private void CheckForItemInRangeLoop(ForStatement node) { MethodInvocationExpression mi = node.Iterator as MethodInvocationExpression; if (null == mi) { return; } if (!IsRangeInvocation(mi)) { return; } DeclarationCollection declarations = node.Declarations; if (declarations.Count != 1) { return; } ExpressionCollection args = mi.Arguments; Block body = new Block(node.LexicalInfo); Expression min; Expression max; Expression step; if (args.Count == 1) { min = CodeBuilder.CreateIntegerLiteral(0); max = args[0]; step = CodeBuilder.CreateIntegerLiteral(1); } else if (args.Count == 2) { min = args[0]; max = args[1]; step = CodeBuilder.CreateIntegerLiteral(1); } else { min = args[0]; max = args[1]; step = args[2]; } InternalLocal numVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); Expression numRef = CodeBuilder.CreateReference(numVar); // __num = <min> body.Add( CodeBuilder.CreateAssignment( numRef, min)); Expression endRef; if (max.NodeType == NodeType.IntegerLiteralExpression) { endRef = max; } else { InternalLocal endVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); endRef = CodeBuilder.CreateReference(endVar); // __end = <end> body.Add( CodeBuilder.CreateAssignment( endRef, max)); } if (args.Count == 1) { if (max.NodeType == NodeType.IntegerLiteralExpression) { if (((IntegerLiteralExpression)max).Value < 0) { // raise ArgumentOutOfRangeException("max") (if <max> < 0) Statement statement = CodeBuilder.RaiseException( body.LexicalInfo, TypeSystemServices.Map(System_ArgumentOutOfRangeException_ctor), CodeBuilder.CreateStringLiteral("max")); body.Add(statement); } } else { IfStatement ifStatement = new IfStatement(body.LexicalInfo); ifStatement.TrueBlock = new Block(); // raise ArgumentOutOfRangeException("max") if __end < 0 Statement statement = CodeBuilder.RaiseException( body.LexicalInfo, TypeSystemServices.Map(System_ArgumentOutOfRangeException_ctor), CodeBuilder.CreateStringLiteral("max")); ifStatement.Condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, endRef, CodeBuilder.CreateIntegerLiteral(0)); ifStatement.TrueBlock.Add(statement); body.Add(ifStatement); } } Expression stepRef; switch (args.Count) { case 1: stepRef = CodeBuilder.CreateIntegerLiteral(1); break; case 2: if ((min.NodeType == NodeType.IntegerLiteralExpression) && (max.NodeType == NodeType.IntegerLiteralExpression) && (((IntegerLiteralExpression)max).Value < ((IntegerLiteralExpression)min).Value)) { // __step = -1 stepRef = CodeBuilder.CreateIntegerLiteral(-1); } else if ((min.NodeType == NodeType.IntegerLiteralExpression) && (max.NodeType == NodeType.IntegerLiteralExpression)) { // __step = 1 stepRef = CodeBuilder.CreateIntegerLiteral(1); } else { InternalLocal stepVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); stepRef = CodeBuilder.CreateReference(stepVar); // __step = 1 body.Add( CodeBuilder.CreateAssignment( stepRef, CodeBuilder.CreateIntegerLiteral(1))); // __step = -1 if __end < __num IfStatement ifStatement = new IfStatement(node.LexicalInfo); ifStatement.Condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, endRef, numRef); ifStatement.TrueBlock = new Block(); ifStatement.TrueBlock.Add( CodeBuilder.CreateAssignment( stepRef, CodeBuilder.CreateIntegerLiteral(-1))); body.Add(ifStatement); } break; default: if (step.NodeType == NodeType.IntegerLiteralExpression) { stepRef = step; } else { InternalLocal stepVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); stepRef = CodeBuilder.CreateReference(stepVar); // __step = <step> body.Add( CodeBuilder.CreateAssignment( stepRef, step)); } break; } if (args.Count == 3) { Expression condition = null; bool run = false; if (step.NodeType == NodeType.IntegerLiteralExpression) { if (((IntegerLiteralExpression)step).Value < 0) { if ((max.NodeType == NodeType.IntegerLiteralExpression) && (min.NodeType == NodeType.IntegerLiteralExpression)) { run = (((IntegerLiteralExpression)max).Value > ((IntegerLiteralExpression)min).Value); } else { condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.GreaterThan, endRef, numRef); } } else { if ((max.NodeType == NodeType.IntegerLiteralExpression) && (min.NodeType == NodeType.IntegerLiteralExpression)) { run = (((IntegerLiteralExpression)max).Value < ((IntegerLiteralExpression)min).Value); } else { condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, endRef, numRef); } } } else { if ((max.NodeType == NodeType.IntegerLiteralExpression) && (min.NodeType == NodeType.IntegerLiteralExpression)) { if (((IntegerLiteralExpression)max).Value < ((IntegerLiteralExpression)min).Value) { condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.GreaterThan, stepRef, CodeBuilder.CreateIntegerLiteral(0)); } else { condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, stepRef, CodeBuilder.CreateIntegerLiteral(0)); } } else { condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.Or, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.And, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, stepRef, CodeBuilder.CreateIntegerLiteral(0)), CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.GreaterThan, endRef, numRef)), CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.And, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.GreaterThan, stepRef, CodeBuilder.CreateIntegerLiteral(0)), CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.LessThan, endRef, numRef))); } } // raise ArgumentOutOfRangeException("step") if (__step < 0 and __end > __begin) or (__step > 0 and __end < __begin) Statement statement = CodeBuilder.RaiseException( body.LexicalInfo, TypeSystemServices.Map(System_ArgumentOutOfRangeException_ctor), CodeBuilder.CreateStringLiteral("step")); if (condition != null) { IfStatement ifStatement = new IfStatement(body.LexicalInfo); ifStatement.TrueBlock = new Block(); ifStatement.Condition = condition; ifStatement.TrueBlock.Add(statement); body.Add(ifStatement); } else if (run) { body.Add(statement); } // __end = __num + __step * cast(int, Math.Ceiling((__end - __num)/cast(double, __step))) if ((step.NodeType == NodeType.IntegerLiteralExpression) && (max.NodeType == NodeType.IntegerLiteralExpression) && (min.NodeType == NodeType.IntegerLiteralExpression)) { int stepVal = (int)((IntegerLiteralExpression)step).Value; int maxVal = (int)((IntegerLiteralExpression)max).Value; int minVal = (int)((IntegerLiteralExpression)min).Value; endRef = CodeBuilder.CreateIntegerLiteral( minVal + stepVal * (int)System.Math.Ceiling((maxVal - minVal) / ((double)stepVal))); } else { Expression endBak = endRef; if (max.NodeType == NodeType.IntegerLiteralExpression) { InternalLocal endVar = CodeBuilder.DeclareTempLocal( _currentMethod, TypeSystemServices.IntType); endRef = CodeBuilder.CreateReference(endVar); } body.Add( CodeBuilder.CreateAssignment( endRef, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.IntType, BinaryOperatorType.Addition, numRef, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.IntType, BinaryOperatorType.Multiply, stepRef, CodeBuilder.CreateCast( TypeSystemServices.IntType, CodeBuilder.CreateMethodInvocation( TypeSystemServices.Map(System_Math_Ceiling), CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.DoubleType, BinaryOperatorType.Division, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.IntType, BinaryOperatorType.Subtraction, endBak, numRef), CodeBuilder.CreateCast( TypeSystemServices.DoubleType, stepRef)))))))); } } // while __num != __end: WhileStatement ws = new WhileStatement(node.LexicalInfo); BinaryOperatorType op = BinaryOperatorType.Inequality; if (stepRef.NodeType == NodeType.IntegerLiteralExpression) { if (((IntegerLiteralExpression)stepRef).Value > 0) { op = BinaryOperatorType.LessThan; } else { op = BinaryOperatorType.GreaterThan; } } ws.Condition = CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, op, numRef, endRef); ws.Condition.LexicalInfo = node.LexicalInfo; // item = __num ws.Block.Add( CodeBuilder.CreateAssignment( CodeBuilder.CreateReference((InternalLocal)declarations[0].Entity), numRef)); Block rawBlock = new Block(); rawBlock["checked"] = false; // __num += __step rawBlock.Add( CodeBuilder.CreateAssignment( numRef, CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.IntType, BinaryOperatorType.Addition, numRef, stepRef))); ws.Block.Add(rawBlock as Statement); // <block> ws.Block.Add(node.Block); body.Add(ws); ReplaceCurrentNode(body); }
override public void OnSlice(Boo.Lang.Compiler.Ast.Slice node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.Slice")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Begin)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Begin"), Serialize(node.Begin))); } if (ShouldSerialize(node.End)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "End"), Serialize(node.End))); } if (ShouldSerialize(node.Step)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Step"), Serialize(node.Step))); } Push(mie); }
bool IsInsideWithBlock(MethodInvocationExpression expression) { return(expression.ParentNode is WithMacro.WithBinaryExpression); }
override public void OnTryCastExpression(Boo.Lang.Compiler.Ast.TryCastExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.TryCastExpression")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Target)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Target"), Serialize(node.Target))); } if (ShouldSerialize(node.Type)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Type"), Serialize(node.Type))); } Push(mie); }
public virtual ICodeNode VisitMethodInvocationExpression(MethodInvocationExpression node) { node.MethodExpression = (MethodReferenceExpression)Visit(node.MethodExpression); node.Arguments = (ExpressionCollection)Visit(node.Arguments); return(node); }
override public void OnCustomExpression(Boo.Lang.Compiler.Ast.CustomExpression node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.CustomExpression")); mie.Arguments.Add(Serialize(node.LexicalInfo)); Push(mie); }
private ICodeNode VisitCtorExpression(MethodInvocationExpression node) { node.Arguments = (ExpressionCollection)Visit(node.Arguments); return(node); }
override public void OnGenericTypeDefinitionReference(Boo.Lang.Compiler.Ast.GenericTypeDefinitionReference node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.GenericTypeDefinitionReference")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.IsPointer)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "IsPointer"), Serialize(node.IsPointer))); } if (ShouldSerialize(node.Name)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Name"), Serialize(node.Name))); } if (ShouldSerialize(node.GenericPlaceholders)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "GenericPlaceholders"), Serialize(node.GenericPlaceholders))); } Push(mie); }
protected virtual bool ExpandExtension(ref MethodInvocationExpression extension, MacroStatement macro, MacroStatement parent, ref Statement expansion) { return(true); }
override public void OnEnumDefinition(Boo.Lang.Compiler.Ast.EnumDefinition node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.EnumDefinition")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Modifiers)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Modifiers"), Serialize(node.Modifiers))); } if (ShouldSerialize(node.Name)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Name"), Serialize(node.Name))); } if (ShouldSerialize(node.Attributes)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Attributes"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.AttributeCollection", node.Attributes))); } if (ShouldSerialize(node.Members)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Members"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.TypeMemberCollection", node.Members))); } if (ShouldSerialize(node.BaseTypes)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "BaseTypes"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.TypeReferenceCollection", node.BaseTypes))); } if (ShouldSerialize(node.GenericParameters)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "GenericParameters"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.GenericParameterDeclarationCollection", node.GenericParameters))); } Push(mie); }
private void FixAsyncMethodBody(MethodInvocationExpression stateMachineConstructorInvocation) { var method = _method.Method; // If the async method's result type is a type parameter of the method, then the AsyncTaskMethodBuilder<T> // needs to use the method's type parameters inside the rewritten method body. All other methods generated // during async rewriting are members of the synthesized state machine struct, and use the type parameters // structs type parameters. AsyncMethodBuilderMemberCollection methodScopeAsyncMethodBuilderMemberCollection; if (!AsyncMethodBuilderMemberCollection.TryCreate( TypeSystemServices, method, MethodGenArg(false), out methodScopeAsyncMethodBuilderMemberCollection)) { throw new NotImplementedException("Custom async patterns are not supported"); } var bodyBuilder = new Block(); var builderVariable = CodeBuilder.DeclareTempLocal(method, methodScopeAsyncMethodBuilderMemberCollection.BuilderType); var stateMachineType = stateMachineConstructorInvocation.ExpressionType; var stateMachineVariable = CodeBuilder.DeclareLocal( method, UniqueName("async"), stateMachineType); bodyBuilder.Add(CodeBuilder.CreateAssignment( CodeBuilder.CreateLocalReference(stateMachineVariable), stateMachineConstructorInvocation)); // local.$builder = System.Runtime.CompilerServices.AsyncTaskMethodBuilder<typeArgs>.Create(); bodyBuilder.Add( CodeBuilder.CreateAssignment( CodeBuilder.CreateMemberReference( CodeBuilder.CreateLocalReference(stateMachineVariable), ExternalFieldEntity((IField)_asyncMethodBuilderField.Entity, stateMachineType)), CodeBuilder.CreateMethodInvocation(methodScopeAsyncMethodBuilderMemberCollection.CreateBuilder))); // local.$stateField = NotStartedStateMachine bodyBuilder.Add( CodeBuilder.CreateAssignment( CodeBuilder.CreateMemberReference( CodeBuilder.CreateLocalReference(stateMachineVariable), ExternalFieldEntity(_state, stateMachineType)), CodeBuilder.CreateIntegerLiteral(StateMachineStates.NotStartedStateMachine))); bodyBuilder.Add( CodeBuilder.CreateAssignment( CodeBuilder.CreateLocalReference(builderVariable), CodeBuilder.CreateMemberReference( CodeBuilder.CreateLocalReference(stateMachineVariable), ExternalFieldEntity((IField)_asyncMethodBuilderField.Entity, stateMachineType)))); // local.$builder.Start(ref local) -- binding to the method AsyncTaskMethodBuilder<typeArgs>.Start() bodyBuilder.Add( CodeBuilder.CreateMethodInvocation( CodeBuilder.CreateLocalReference(builderVariable), methodScopeAsyncMethodBuilderMemberCollection.Start.GenericInfo.ConstructMethod(stateMachineType), CodeBuilder.CreateLocalReference(stateMachineVariable))); var methodBuilderField = stateMachineType.ConstructedInfo == null ? (IField)_asyncMethodBuilderField.Entity : stateMachineType.ConstructedInfo.Map((IField)_asyncMethodBuilderField.Entity); bodyBuilder.Add(method.ReturnType.Entity == TypeSystemServices.VoidType ? new ReturnStatement() : new ReturnStatement( CodeBuilder.CreateMethodInvocation( CodeBuilder.CreateMemberReference( CodeBuilder.CreateLocalReference(stateMachineVariable), methodBuilderField), methodScopeAsyncMethodBuilderMemberCollection.Task.GetGetMethod()))); _method.Method.Body = bodyBuilder; }
override public void OnProperty(Boo.Lang.Compiler.Ast.Property node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.Property")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Modifiers)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Modifiers"), Serialize(node.Modifiers))); } if (ShouldSerialize(node.Name)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Name"), Serialize(node.Name))); } if (ShouldSerialize(node.Attributes)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Attributes"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.AttributeCollection", node.Attributes))); } if (ShouldSerialize(node.Parameters)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Parameters"), SerializeCollection(node, "Boo.Lang.Compiler.Ast.ParameterDeclarationCollection", node.Parameters))); } if (ShouldSerialize(node.Getter)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Getter"), Serialize(node.Getter))); } if (ShouldSerialize(node.Setter)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Setter"), Serialize(node.Setter))); } if (ShouldSerialize(node.Type)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Type"), Serialize(node.Type))); } if (ShouldSerialize(node.ExplicitInfo)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "ExplicitInfo"), Serialize(node.ExplicitInfo))); } Push(mie); }
public override void VisitMethodInvocationExpression(MethodInvocationExpression node) { this.VisitMethodInvocationExpression(node); this.CheckArguments(node.get_MethodExpression().get_Method().get_Parameters(), node.get_Arguments()); return; }
override public void OnLocal(Boo.Lang.Compiler.Ast.Local node) { MethodInvocationExpression mie = new MethodInvocationExpression( node.LexicalInfo, CreateReference(node, "Boo.Lang.Compiler.Ast.Local")); mie.Arguments.Add(Serialize(node.LexicalInfo)); if (ShouldSerialize(node.Name)) { mie.NamedArguments.Add( new ExpressionPair( CreateReference(node, "Name"), Serialize(node.Name))); } Push(mie); }
protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocation, ParameterInfo[] parameters, MethodEmitter invokeMethodOnTarget, Reference targetField) { var callbackMethod = GetCallbackMethod(invocation); if (callbackMethod == null) { EmitCallThrowOnNoTarget(invokeMethodOnTarget); return; } if (canChangeTarget) { EmitCallEnsureValidTarget(invokeMethodOnTarget); } var args = new Expression[parameters.Length]; // Idea: instead of grab parameters one by one // we should grab an array var byRefArguments = new Dictionary <int, LocalReference>(); for (var i = 0; i < parameters.Length; i++) { var param = parameters[i]; var paramType = invocation.GetClosedParameterType(param.ParameterType); if (paramType.IsByRef) { var localReference = invokeMethodOnTarget.CodeBuilder.DeclareLocal(paramType.GetElementType()); invokeMethodOnTarget.CodeBuilder .AddStatement( new AssignStatement(localReference, new ConvertExpression(paramType.GetElementType(), new MethodInvocationExpression(SelfReference.Self, InvocationMethods.GetArgumentValue, new LiteralIntExpression(i))))); var byRefReference = new ByRefReference(localReference); args[i] = new ReferenceExpression(byRefReference); byRefArguments[i] = localReference; } else { args[i] = new ConvertExpression(paramType, new MethodInvocationExpression(SelfReference.Self, InvocationMethods.GetArgumentValue, new LiteralIntExpression(i))); } } if (byRefArguments.Count > 0) { invokeMethodOnTarget.CodeBuilder.AddStatement(new TryStatement()); } var methodOnTargetInvocationExpression = GetCallbackMethodInvocation(invocation, args, callbackMethod, targetField, invokeMethodOnTarget); LocalReference returnValue = null; if (callbackMethod.ReturnType != typeof(void)) { var returnType = invocation.GetClosedParameterType(callbackMethod.ReturnType); returnValue = invokeMethodOnTarget.CodeBuilder.DeclareLocal(returnType); invokeMethodOnTarget.CodeBuilder.AddStatement(new AssignStatement(returnValue, methodOnTargetInvocationExpression)); } else { invokeMethodOnTarget.CodeBuilder.AddStatement(new ExpressionStatement(methodOnTargetInvocationExpression)); } AssignBackByRefArguments(invokeMethodOnTarget, byRefArguments); if (callbackMethod.ReturnType != typeof(void)) { var setRetVal = new MethodInvocationExpression(SelfReference.Self, InvocationMethods.SetReturnValue, new ConvertExpression(typeof(object), returnValue.Type, returnValue.ToExpression())); invokeMethodOnTarget.CodeBuilder.AddStatement(new ExpressionStatement(setRetVal)); } invokeMethodOnTarget.CodeBuilder.AddStatement(new ReturnStatement()); }
/// <summary> /// Reads a method access expression. /// </summary> /// <param name="methodName">The name of the method being called.</param> /// <param name="previousPrecedence">The precedence of the previous expression.</param> /// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param> /// <returns>Returns the expression.</returns> private MethodInvocationExpression GetMethodInvocationExpression( Expression methodName, ExpressionPrecedence previousPrecedence, bool unsafeCode) { Param.AssertNotNull(methodName, "methodName"); Param.Ignore(previousPrecedence); Param.Ignore(unsafeCode); MethodInvocationExpression expression = null; if (this.CheckPrecedence(previousPrecedence, ExpressionPrecedence.Primary)) { // The next symbol will be the opening parenthesis. Bracket openParenthesis = this.GetBracketToken(CsTokenType.OpenParenthesis, SymbolType.OpenParenthesis); Node<CsToken> openParenthesisNode = this.tokens.InsertLast(openParenthesis); // Get the argument list now. IList<Expression> argumentList = this.GetArgumentList(SymbolType.CloseParenthesis, unsafeCode); // Get the closing parenthesis. Bracket closeParenthesis = this.GetBracketToken(CsTokenType.CloseParenthesis, SymbolType.CloseParenthesis); Node<CsToken> closeParenthesisNode = this.tokens.InsertLast(closeParenthesis); openParenthesis.MatchingBracketNode = closeParenthesisNode; closeParenthesis.MatchingBracketNode = openParenthesisNode; // Pull out the first token from the method name. Debug.Assert(methodName.Tokens.First != null, "The method name should not be empty"); Node<CsToken> firstTokenNode = methodName.Tokens.First; // Create the token list for the method invocation expression. CsTokenList partialTokens = new CsTokenList(this.tokens, firstTokenNode, this.tokens.Last); // Create and return the expression. expression = new MethodInvocationExpression(partialTokens, methodName, argumentList); } return expression; }
ClassDefinition CreateAdaptor(ICallableType to, ICallableType from) { BooClassBuilder adaptor = CodeBuilder.CreateClass("$adaptor$" + from.Name + "$" + to.Name + "$" + _adaptors.Count); adaptor.AddBaseType(TypeSystemServices.ObjectType); adaptor.Modifiers = TypeMemberModifiers.Final | TypeMemberModifiers.Internal; Field callable = adaptor.AddField("$from", from); BooMethodBuilder constructor = adaptor.AddConstructor(); ParameterDeclaration param = constructor.AddParameter("from", from); constructor.Body.Add( CodeBuilder.CreateSuperConstructorInvocation(TypeSystemServices.ObjectType)); constructor.Body.Add( CodeBuilder.CreateAssignment( CodeBuilder.CreateReference(callable), CodeBuilder.CreateReference(param))); CallableSignature signature = to.GetSignature(); BooMethodBuilder invoke = adaptor.AddMethod("Invoke", signature.ReturnType); foreach (IParameter parameter in signature.Parameters) { invoke.AddParameter(parameter.Name, parameter.Type, parameter.IsByRef); } MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation( CodeBuilder.CreateReference(callable), GetInvokeMethod(from)); int fromParameterCount = from.GetSignature().Parameters.Length; for (int i = 0; i < fromParameterCount; ++i) { mie.Arguments.Add( CodeBuilder.CreateReference(invoke.Parameters[i])); } if (signature.ReturnType != TypeSystemServices.VoidType && from.GetSignature().ReturnType != TypeSystemServices.VoidType) { invoke.Body.Add(new ReturnStatement(mie)); } else { invoke.Body.Add(mie); } BooMethodBuilder adapt = adaptor.AddMethod("Adapt", to); adapt.Modifiers = TypeMemberModifiers.Static | TypeMemberModifiers.Public; param = adapt.AddParameter("from", from); adapt.Body.Add( new ReturnStatement( CodeBuilder.CreateConstructorInvocation( to.GetConstructors().First(), CodeBuilder.CreateConstructorInvocation( (IConstructor)constructor.Entity, CodeBuilder.CreateReference(param)), CodeBuilder.CreateAddressOfExpression(invoke.Entity)))); var collector = new GenericTypeCollector(this.CodeBuilder); collector.Process(adaptor.ClassDefinition); RegisterAdaptor(to, from, adaptor.ClassDefinition); return(adaptor.ClassDefinition); }
protected internal override void VisitMethodInvocationExpression(MethodInvocationExpression expression) { _expr = Ssm.CreateCall(expression.Method.Name, expression.Method.MethodInfo.DeclaringType.FullName, expression.Method.MethodInfo.GetParameters().Select(p => Transform(p.ParameterType)), expression.Method.MethodInfo.GetParameters().Select(p => { if (p.IsOut) return Ssm.ParamDir.Out; if (p.ParameterType.IsByRef) return Ssm.ParamDir.InOut; return Ssm.ParamDir.In; }), Transform(expression.Method.MethodInfo.ReturnType), expression.Arguments.Select(GetTransformed)); if (expression.Method.DeclaringObject == _this) return; var component = (ComponentMetadata)expression.Method.DeclaringObject; var field = Ssm.Var.NewField(component.Name, Ssm.Type.NewClassType(component.GetType().FullName)); _expr = Ssm.Expr.NewMemberExpr(field, _expr); }
/* * The following pattern matches BlockStatements with similar content * { * stackVariable6 = exception_0 as Exception; * if (stackVariable6 != null) * { * ProjectData.SetProjectError(stackVariable6); * ex = stackVariable6; * stackVariable15 = Program.Bool() && b is int; * } * else * { * stackVariable15 = false; * } * stackVariable15; * } * - stackVariable6 = exception_0 as Exception; - the VariableDeclarationExpression is build using this variable reference * - Program.Bool() && b is int - The filter expression * - ex = stackVariable6; - Not required line, if present the variable reference is used to build the VariableDeclarationExpression * - ProjectData.SetProjectError(stackVariable6); - Not required line. It is generated by the VB compiler. It could be after ex = stackVariable6; */ public static bool TryMatch(BlockStatement filter, out VariableDeclarationExpression variableDeclaration, out Expression filterExpression) { variableDeclaration = null; filterExpression = null; if (!TryMatchVariableDeclaration(filter, out variableDeclaration)) { return(false); } // Save cast of the exception // If-else statement for the filter expression // Variable reference of the result of the filter block if (filter.Statements.Count != 3) { return(false); } IfStatement ifStatement = filter.Statements[1] as IfStatement; if (ifStatement == null) { return(false); } BlockStatement exceptionAssignmentBlock = null; BlockStatement negativeFilterResultAssignmentBlock = null; if ((ifStatement.Condition as BinaryExpression).Operator == BinaryOperator.ValueInequality) { exceptionAssignmentBlock = ifStatement.Then; negativeFilterResultAssignmentBlock = ifStatement.Else; } else { exceptionAssignmentBlock = ifStatement.Else; negativeFilterResultAssignmentBlock = ifStatement.Then; } ExpressionStatement exceptionAssignmentStatement = null; ExpressionStatement methodInvocationStatement = null; if ((exceptionAssignmentBlock.Statements.Count != 1 && exceptionAssignmentBlock.Statements.Count != 2 && exceptionAssignmentBlock.Statements.Count != 3) || negativeFilterResultAssignmentBlock.Statements.Count != 1) { return(false); } if (exceptionAssignmentBlock.Statements.Count == 2) { ExpressionStatement firstThenStatement = exceptionAssignmentBlock.Statements[0] as ExpressionStatement; if (firstThenStatement == null) { return(false); } if (firstThenStatement.Expression.CodeNodeType == CodeNodeType.BinaryExpression) { exceptionAssignmentStatement = firstThenStatement; } else if (firstThenStatement.Expression.CodeNodeType == CodeNodeType.MethodInvocationExpression) { methodInvocationStatement = firstThenStatement; } else { return(false); } } else if (exceptionAssignmentBlock.Statements.Count == 3) { ExpressionStatement firstThenStatement = exceptionAssignmentBlock.Statements[0] as ExpressionStatement; ExpressionStatement secondThenStatement = exceptionAssignmentBlock.Statements[1] as ExpressionStatement; if (firstThenStatement == null || secondThenStatement == null) { return(false); } if (firstThenStatement.Expression.CodeNodeType == CodeNodeType.BinaryExpression && secondThenStatement.Expression.CodeNodeType == CodeNodeType.MethodInvocationExpression) { exceptionAssignmentStatement = firstThenStatement; methodInvocationStatement = secondThenStatement; } else if (firstThenStatement.Expression.CodeNodeType == CodeNodeType.MethodInvocationExpression && secondThenStatement.Expression.CodeNodeType == CodeNodeType.BinaryExpression) { methodInvocationStatement = firstThenStatement; exceptionAssignmentStatement = secondThenStatement; } else { return(false); } } if (exceptionAssignmentStatement != null) { BinaryExpression exceptionAssignment = exceptionAssignmentStatement.Expression as BinaryExpression; if (exceptionAssignment == null || !exceptionAssignment.IsAssignmentExpression || exceptionAssignment.ExpressionType.FullName != variableDeclaration.ExpressionType.FullName) { return(false); } VariableReferenceExpression left = exceptionAssignment.Left as VariableReferenceExpression; VariableReferenceExpression right = exceptionAssignment.Right as VariableReferenceExpression; if (left == null || right == null) { return(false); } } if (methodInvocationStatement != null) { MethodInvocationExpression methodInvocation = methodInvocationStatement.Expression as MethodInvocationExpression; if (methodInvocation == null || methodInvocation.MethodExpression.Method.FullName != "System.Void Microsoft.VisualBasic.CompilerServices.ProjectData::SetProjectError(System.Exception)") { return(false); } } ExpressionStatement lastExpressionStatement = filter.Statements[2] as ExpressionStatement; if (lastExpressionStatement == null) { return(false); } VariableReferenceExpression lastExpression = lastExpressionStatement.Expression as VariableReferenceExpression; if (lastExpression == null) { return(false); } if (!TryMatchFilterExpression(ifStatement, variableDeclaration.Variable.VariableType, lastExpression, out filterExpression)) { return(false); } return(true); }