public override ExpressionNode VisitMethodInvocationExpression(MethodInvocationExpression expression) { base.VisitMethodInvocationExpression(expression); bool isReflectionBinding = expression.Method is ReflectionMethodBinding; if (!isReflectionBinding) { _ilEmitContext.AddParameter(expression, expression.Method, typeof (MethodBinding)); object[] args = new object[expression.Arguments.Length]; _ilEmitContext.AddParameter(expression, args, typeof(object[])); } return expression; }
public override AstElement Clone(Dictionary<AstElement, AstElement> alreadyClonedElements) { MethodInvocationExpression result = new MethodInvocationExpression(); result.Target = (ExpressionNode)_target.Clone(alreadyClonedElements); result.Name = _name; result.NameSourceRange = _nameSourceRange; result._arguments = new ExpressionNode[_arguments.Length]; for (int i = 0; i < _arguments.Length; i++) result._arguments[i] = (ExpressionNode)_arguments[i].Clone(alreadyClonedElements); result._method = _method; return result; }
private static bool VisitMethodInvocationExpression(MethodInvocationExpression node1, MethodInvocationExpression node2) { if (node2 == null) return false; if (node1.Arguments.Length != node2.Arguments.Length || node1.Name != node2.Name) return false; if (!Visit(node1.Target, node2.Target)) return false; for (int i = 0; i < node1.Arguments.Length; i++) if (!Visit(node1.Arguments[i], node2.Arguments[i])) return false; return true; }
public override ExpressionNode VisitMethodInvocationExpression(MethodInvocationExpression expression) { bool parenthesesNeeded = expression.Target is OperatorExpression || expression.Target is CaseExpression || expression.Target is IsNullExpression; if (parenthesesNeeded) _writer.Write("("); Visit(expression.Target); if (parenthesesNeeded) _writer.Write(")"); _writer.Write("."); _writer.WriteIdentifier(expression.Name); _writer.Write("("); for (int i = 0; i < expression.Arguments.Length; i++) { if (i > 0) _writer.Write(","); Visit(expression.Arguments[i]); } _writer.Write(")"); return expression; }
private ExpressionNode ParseMemberExpression() { ExpressionNode leftSide = ParsePrimaryExpression(); while (_token.Id == TokenId.Dot) { NextToken(); _rangeRecorder.Begin(); Identifier memberName = ParseIdentifier(); SourceRange memberNameSourceRange = _rangeRecorder.End(); if (_token.Id != TokenId.LeftParentheses) { PropertyAccessExpression result = new PropertyAccessExpression(); result.Target = leftSide; result.Name = memberName; result.NameSourceRange = memberNameSourceRange; leftSide = result; } else { ExpressionNode[] arguments = ParseExpressionList(); MethodInvocationExpression result = new MethodInvocationExpression(); result.Target = leftSide; result.Name = memberName; result.NameSourceRange = memberNameSourceRange; result.Arguments = arguments; leftSide = result; } } return leftSide; }
public virtual ExpressionNode VisitMethodInvocationExpression(MethodInvocationExpression expression) { expression.Target = VisitExpression(expression.Target); for (int i = 0; i < expression.Arguments.Length; i++) expression.Arguments[i] = VisitExpression(expression.Arguments[i]); return expression; }
public override ExpressionNode VisitMethodInvocationExpression(MethodInvocationExpression expression) { Visit(expression.Target); // Since arguments with null values don't answer the question whether the whole method invocation // is null we must not visit the arguments. return expression; }
public override ExpressionNode VisitMethodInvocationExpression(MethodInvocationExpression expression) { // First the target and all parameters must be resolved. base.VisitMethodInvocationExpression(expression); // If the type of the target could not be resolved we cannot resolve the method. if (expression.Target.ExpressionType == null) return expression; // If the type of any argument could not be resolved we cannot resolve the method. foreach (ExpressionNode argument in expression.Arguments) { if (argument.ExpressionType == null) return expression; } // Build argument type array. Type[] argumentTypes = new Type[expression.Arguments.Length]; for (int i = 0; i < argumentTypes.Length; i++) argumentTypes[i] = expression.Arguments[i].ExpressionType; expression.Method = ResolveMethod(expression.Target.ExpressionType, expression.Name, argumentTypes); if (expression.Method == null) { ErrorReporter.UndeclaredMethod(expression.NameSourceRange, expression.Target.ExpressionType, expression.Name, argumentTypes); } else { // Convert all arguments if necessary Type[] parameterTypes = expression.Method.GetParameterTypes(); for (int i = 0; i < expression.Arguments.Length; i++) expression.Arguments[i] = Binder.ConvertExpressionIfRequired(expression.Arguments[i], parameterTypes[i]); } return expression; }
public override ExpressionNode VisitMethodInvocationExpression(MethodInvocationExpression expression) { ReflectionMethodBinding reflectionMethodBinding = expression.Method as ReflectionMethodBinding; if (reflectionMethodBinding != null) { EmitCall(reflectionMethodBinding.Method, expression.Target, expression.Arguments); _ilEmitContext.ILGenerator.EmitCall(OpCodes.Call, _unifyNullsMethod, null); } else { int instanceArgIndex = DeclareLocal(); int[] argLocalIndexes = new int[expression.Arguments.Length]; for (int i = 0; i < expression.Arguments.Length; i++) argLocalIndexes[i] = DeclareLocal(); Visit(expression.Target); _ilEmitContext.ILGenerator.Emit(OpCodes.Stloc, instanceArgIndex); for (int i = 0; i < expression.Arguments.Length; i++) { Visit(expression.Arguments[i]); _ilEmitContext.ILGenerator.Emit(OpCodes.Stloc, argLocalIndexes[i]); } Label loadNullLabel = _ilEmitContext.ILGenerator.DefineLabel(); Label finishLabel = _ilEmitContext.ILGenerator.DefineLabel(); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, instanceArgIndex); _ilEmitContext.ILGenerator.Emit(OpCodes.Brfalse, loadNullLabel); for (int i = 0; i < expression.Arguments.Length; i++) { _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, argLocalIndexes[i]); _ilEmitContext.ILGenerator.Emit(OpCodes.Brfalse, loadNullLabel); } ILParameterDeclaration customMethodBinding = _ilEmitContext.GetParameters(expression)[0]; ILParameterDeclaration argsArray = _ilEmitContext.GetParameters(expression)[1]; int argsArrayIndex = DeclareLocal(); EmitLoadParameter(argsArray); _ilEmitContext.ILGenerator.Emit(OpCodes.Stloc, argsArrayIndex); for (int i = 0; i < expression.Arguments.Length; i++) { _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, argsArrayIndex); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldc_I4, i); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, argLocalIndexes[i]); _ilEmitContext.ILGenerator.Emit(OpCodes.Stelem_Ref); } EmitLoadParameter(customMethodBinding); EmitThisArgumentPointer(typeof(MethodBinding)); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, instanceArgIndex); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, argsArrayIndex); _ilEmitContext.ILGenerator.EmitCall(OpCodes.Callvirt, _methodBindingInvokeMethod, null); _ilEmitContext.ILGenerator.EmitCall(OpCodes.Call, _unifyNullsMethod, null); _ilEmitContext.ILGenerator.Emit(OpCodes.Br, finishLabel); _ilEmitContext.ILGenerator.MarkLabel(loadNullLabel); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldnull); _ilEmitContext.ILGenerator.MarkLabel(finishLabel); } return expression; }
public override ExpressionNode VisitMethodInvocationExpression(MethodInvocationExpression expression) { base.VisitMethodInvocationExpression(expression); // Constant folding must not be applied if the method is non-deterministic. if (!expression.Method.IsDeterministic) return expression; // Check if target is a constant or even null. ConstantExpression targetAsConstant = expression.Target as ConstantExpression; if (targetAsConstant == null) return expression; if (targetAsConstant.IsNullValue) return LiteralExpression.FromTypedNull(expression.ExpressionType); // Check if all arguments are constants or at least one argument // is null. ConstantExpression[] constantArguments = new ConstantExpression[expression.Arguments.Length]; bool allArgumentsAreConstants = true; for (int i = 0; i < constantArguments.Length; i++) { constantArguments[i] = expression.Arguments[i] as ConstantExpression; if (constantArguments[i] == null) { // Ok, one argument is not a constant // But don't stop: If an argument is null we can still calculate the result! allArgumentsAreConstants = false; } else if (constantArguments[i].IsNullValue) { // We found a null. That means the invocation will also yield null. return LiteralExpression.FromTypedNull(expression.ExpressionType); } } if (allArgumentsAreConstants) { try { return LiteralExpression.FromTypedValue(expression.GetValue(), expression.ExpressionType); } catch (RuntimeException ex) { _errorReporter.CannotFoldConstants(ex); } } return expression; }
public override ExpressionNode VisitMethodInvocationExpression(MethodInvocationExpression expression) { ReflectionMethodBinding reflectionMethodBinding = expression.Method as ReflectionMethodBinding; if (reflectionMethodBinding != null) { EmitCall(reflectionMethodBinding.Method, expression.Target, expression.Arguments); _ilEmitContext.ILGenerator.EmitCall(OpCodes.Call, _unifyNullsMethod, null); } else { int instanceArgIndex = DeclareLocal(); int[] argLocalIndexes = new int[expression.Arguments.Length]; for (int i = 0; i < expression.Arguments.Length; i++) { argLocalIndexes[i] = DeclareLocal(); } Visit(expression.Target); _ilEmitContext.ILGenerator.Emit(OpCodes.Stloc, instanceArgIndex); for (int i = 0; i < expression.Arguments.Length; i++) { Visit(expression.Arguments[i]); _ilEmitContext.ILGenerator.Emit(OpCodes.Stloc, argLocalIndexes[i]); } Label loadNullLabel = _ilEmitContext.ILGenerator.DefineLabel(); Label finishLabel = _ilEmitContext.ILGenerator.DefineLabel(); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, instanceArgIndex); _ilEmitContext.ILGenerator.Emit(OpCodes.Brfalse, loadNullLabel); for (int i = 0; i < expression.Arguments.Length; i++) { _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, argLocalIndexes[i]); _ilEmitContext.ILGenerator.Emit(OpCodes.Brfalse, loadNullLabel); } ILParameterDeclaration customMethodBinding = _ilEmitContext.GetParameters(expression)[0]; ILParameterDeclaration argsArray = _ilEmitContext.GetParameters(expression)[1]; int argsArrayIndex = DeclareLocal(); EmitLoadParameter(argsArray); _ilEmitContext.ILGenerator.Emit(OpCodes.Stloc, argsArrayIndex); for (int i = 0; i < expression.Arguments.Length; i++) { _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, argsArrayIndex); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldc_I4, i); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, argLocalIndexes[i]); _ilEmitContext.ILGenerator.Emit(OpCodes.Stelem_Ref); } EmitLoadParameter(customMethodBinding); EmitThisArgumentPointer(typeof(MethodBinding)); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, instanceArgIndex); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, argsArrayIndex); _ilEmitContext.ILGenerator.EmitCall(OpCodes.Callvirt, _methodBindingInvokeMethod, null); _ilEmitContext.ILGenerator.EmitCall(OpCodes.Call, _unifyNullsMethod, null); _ilEmitContext.ILGenerator.Emit(OpCodes.Br, finishLabel); _ilEmitContext.ILGenerator.MarkLabel(loadNullLabel); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldnull); _ilEmitContext.ILGenerator.MarkLabel(finishLabel); } return(expression); }
public override ExpressionNode VisitMethodInvocationExpression(MethodInvocationExpression expression) { _xmlWriter.WriteStartElement("functionInvocationExpression"); _xmlWriter.WriteAttributeString("identifier", expression.Name.ToSource()); WriteTypeAttribute(expression.ExpressionType); WriteAstNode("target", expression.Target); for (int i = 0; i < expression.Arguments.Length; i++) { _xmlWriter.WriteStartElement("argument"); _xmlWriter.WriteAttributeString("index", XmlConvert.ToString(i)); Visit(expression.Arguments[i]); _xmlWriter.WriteEndElement(); } _xmlWriter.WriteEndElement(); return expression; }