private InvocationExpressionNode ParseInvocationExpression(ExpressionNode left)
{
InvocationExpressionNode ret = NewNode <InvocationExpressionNode>();
NextToken();
List <ExpressionNode> Arguments = new List <ExpressionNode>();
bool first = true;
while (Token != TokenType.RPAREN)
{
if (first)
{
first = false;
}
else
{
ExpectToken(TokenType.COMMA);
NextToken();
}
Arguments.Add(ParseExpression(1));
}
NextToken();
ret.Callee = left;
ret.Arguments = Arguments.ToArray();
return(ret);
}
protected override Expression VisitMethodCall(MethodCallExpression methodCallExpression)
{
if (methodCallExpression.Method.DeclaringType == typeof(Queryable))
{
var methodDeclaration = new InvocationExpressionNode(methodCallExpression.Method.Name);
LambdaExpression lambda;
AddChild(methodDeclaration);
methodDeclaration.Target = (ExpressionNode)this.VisitNode(methodCallExpression.Arguments[0]);
if (methodCallExpression.Arguments.Count > 1)
{
lambda = (LambdaExpression)StripQuotes(methodCallExpression.Arguments[1]);
methodDeclaration.Arguments.Add((ExpressionNode)this.VisitNode(lambda.Body));
}
return(methodCallExpression);
}
else
{
DebugUtils.Break();
}
throw new NotSupportedException(string.Format("The method '{0}' is not supported", methodCallExpression.Method.Name));
}
protected override Void handleInvocation(InvocationExpressionNode invocation, Set <TypeInfo> dependencies, bool nested)
{
handleExpression(invocation.TargetObject, dependencies, nested);
foreach (var e in invocation.Arguments)
{
handleExpression(e, dependencies, true);
}
return(null);
}
private Expression CompileInvocationExpression(InvocationExpressionNode node)
{
Expression[] Arguments = new Expression[node.Arguments.Length];
for (int i = 0; i < Arguments.Length; i++)
{
Arguments[i] = CompileExpression(node.Arguments[i], ValueTypes.BOXED);
}
if (node.Callee.Type == ExpressionNodeType.OBJECT_LOOKUP)
{
return(CompileBoundInvocationExpression((node.Callee as ObjectLookupExpression).Object, (node.Callee as ObjectLookupExpression).Lookup, Arguments));
}
Expression left = CompileExpression(node.Callee, ValueTypes.DELEGATE);
return(Expression.Invoke(left, Expression.Constant(null, typeof(W_Object)), Expression.NewArrayInit(typeof(W_Type), Arguments)));
}
protected override AssignmentState handleInvocation(InvocationExpressionNode invocation, HashSet <StatementNode> visited,
bool nested)
{
var info = invocation.getUserData(typeof(ExpressionInfo));
if (!info.Method.IsExcludedFromCompilation)
{
if (handleExpression(invocation.TargetObject, visited, true) == AssignmentState.Assigned)
{
return(AssignmentState.Assigned);
}
foreach (var arg in invocation.Arguments)
{
if (handleExpression(arg, visited, true) == AssignmentState.Assigned)
{
return(AssignmentState.Assigned);
}
}
}
return(AssignmentState.NotAssigned);
}
private void WriteInvocationExpression(InvocationExpressionNode expression)
{
WriteExpression(expression.Expression);
WriteArgumentList(expression.ArgumentList);
}
