private CodeExpression ParseUnadornedMethodInvoke(ParserContext parserContext, string methodName, bool assignIsEquality)
{
System.Diagnostics.Debug.Assert(parserContext.CurrentToken.TokenID == TokenID.LParen);
Type thisType = Validator.ThisType;
// Start of a method call parameter list.
int lparenPosition = parserContext.CurrentToken.StartPosition;
parserContext.NextToken();
if (parserContext.CurrentToken.TokenID == TokenID.EndOfInput && parserContext.provideIntellisense)
{
parserContext.SetMethodCompletions(thisType, thisType, methodName, true, true, validation);
return null;
}
List<CodeExpression> arguments = ParseArgumentList(parserContext);
// Binding flags include all public & non-public, all instance, and all static.
// All are possible candidates for unadorned method references.
BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Instance;
ValidationError error = null;
RuleMethodInvokeExpressionInfo methodInvokeInfo = validation.ResolveMethod(thisType, methodName, bindingFlags, arguments, out error);
if (methodInvokeInfo == null)
throw new RuleSyntaxException(error.ErrorNumber, error.ErrorText, lparenPosition);
MethodInfo mi = methodInvokeInfo.MethodInfo;
CodeExpression primaryExpr = null;
if (mi.IsStatic)
primaryExpr = new CodeTypeReferenceExpression(thisType);
else
primaryExpr = new CodeThisReferenceExpression();
CodeExpression postfixExpr = new CodeMethodInvokeExpression(primaryExpr, methodName, arguments.ToArray());
parserContext.exprPositions[postfixExpr] = lparenPosition;
ValidateExpression(parserContext, postfixExpr, assignIsEquality, ValueCheck.Read);
return postfixExpr;
}
private CodeExpression ParseMethodInvoke(ParserContext parserContext, CodeExpression postfixExpr, string methodName, bool assignIsEquality)
{
int startPosition = parserContext.CurrentToken.StartPosition;
parserContext.NextToken();
if ((parserContext.CurrentToken.TokenID == TokenID.EndOfInput) && parserContext.provideIntellisense)
{
bool includeStatic = postfixExpr is CodeTypeReferenceExpression;
parserContext.SetMethodCompletions(this.validation.ExpressionInfo(postfixExpr).ExpressionType, this.validation.ThisType, methodName, includeStatic, !includeStatic, this.validation);
return null;
}
List<CodeExpression> list = this.ParseArgumentList(parserContext);
postfixExpr = new CodeMethodInvokeExpression(postfixExpr, methodName, list.ToArray());
parserContext.exprPositions[postfixExpr] = startPosition;
this.ValidateExpression(parserContext, postfixExpr, assignIsEquality, ValueCheck.Read);
return postfixExpr;
}
private CodeExpression ParseMethodInvoke(ParserContext parserContext, CodeExpression postfixExpr, string methodName, bool assignIsEquality)
{
System.Diagnostics.Debug.Assert(parserContext.CurrentToken.TokenID == TokenID.LParen);
// Start of a method call parameter list.
int lparenPosition = parserContext.CurrentToken.StartPosition;
parserContext.NextToken();
if (parserContext.CurrentToken.TokenID == TokenID.EndOfInput && parserContext.provideIntellisense)
{
bool isStatic = postfixExpr is CodeTypeReferenceExpression;
parserContext.SetMethodCompletions(validation.ExpressionInfo(postfixExpr).ExpressionType, validation.ThisType, methodName, isStatic, !isStatic, validation);
return null;
}
List<CodeExpression> arguments = ParseArgumentList(parserContext);
postfixExpr = new CodeMethodInvokeExpression(postfixExpr, methodName, arguments.ToArray());
parserContext.exprPositions[postfixExpr] = lparenPosition;
ValidateExpression(parserContext, postfixExpr, assignIsEquality, ValueCheck.Read);
return postfixExpr;
}
private CodeExpression ParseUnadornedMethodInvoke(ParserContext parserContext, string methodName, bool assignIsEquality)
{
Type thisType = this.Validator.ThisType;
int startPosition = parserContext.CurrentToken.StartPosition;
parserContext.NextToken();
if ((parserContext.CurrentToken.TokenID == TokenID.EndOfInput) && parserContext.provideIntellisense)
{
parserContext.SetMethodCompletions(thisType, thisType, methodName, true, true, this.validation);
return null;
}
List<CodeExpression> argumentExprs = this.ParseArgumentList(parserContext);
BindingFlags methodBindingFlags = BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
ValidationError error = null;
RuleMethodInvokeExpressionInfo info = this.validation.ResolveMethod(thisType, methodName, methodBindingFlags, argumentExprs, out error);
if (info == null)
{
throw new RuleSyntaxException(error.ErrorNumber, error.ErrorText, startPosition);
}
MethodInfo methodInfo = info.MethodInfo;
CodeExpression targetObject = null;
if (methodInfo.IsStatic)
{
targetObject = new CodeTypeReferenceExpression(thisType);
}
else
{
targetObject = new CodeThisReferenceExpression();
}
CodeExpression expression = new CodeMethodInvokeExpression(targetObject, methodName, argumentExprs.ToArray());
parserContext.exprPositions[expression] = startPosition;
this.ValidateExpression(parserContext, expression, assignIsEquality, ValueCheck.Read);
return expression;
}