public static bool TryBind(SyntaxTreeNode node, BindingContext bindingContext, TypeDescription expectedType, out Expression boundExpression, out Exception bindingError)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
if (expectedType == null)
{
throw new ArgumentNullException("expectedType");
}
if (TryBindMethodCall(node, bindingContext, expectedType, out boundExpression, out bindingError))
{
return(true);
}
var targetNode = node.GetExpression(throwOnError: true);
var arguments = node.GetArguments(throwOnError: false);
var target = default(Expression);
if (AnyBinder.TryBind(targetNode, bindingContext, TypeDescription.ObjectType, out target, out bindingError) == false)
{
return(false);
}
Debug.Assert(target != null, "target != null");
var typeDescription = TypeDescription.GetTypeDescription(target.Type);
if (typeDescription.IsDelegate == false)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETOINVOKENONDELEG, target.Type), node);
return(false);
}
var methodDescription = typeDescription.GetMembers(Constants.DELEGATE_INVOKE_NAME).FirstOrDefault(m => m.IsMethod && !m.IsStatic);
if (methodDescription == null)
{
throw new MissingMethodException(string.Format(Properties.Resources.EXCEPTION_BIND_MISSINGMETHOD, target.Type.FullName, Constants.DELEGATE_INVOKE_NAME));
}
var expressionQuality = 0.0f;
if (methodDescription.TryMakeCall(target, arguments, bindingContext, out boundExpression, out expressionQuality) == false)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETOBINDDELEG, target.Type, methodDescription), node);
return(false);
}
return(true);
}
private static bool TryBindTarget(SyntaxTreeNode node, BindingContext bindingContext, out Expression target, out Type type, out Exception bindingError)
{
type = null;
target = null;
bindingError = null;
// target is passed as Expression from InvokeBinder
var targetObj = default(object);
if (node.TryGetValue(Constants.EXPRESSION_ATTRIBUTE, out targetObj))
{
if (targetObj is Expression)
{
target = (Expression)targetObj;
type = target.Type;
return(true);
}
else if (targetObj is Type)
{
target = null;
type = (Type)targetObj;
return(true);
}
}
var targetNode = node.GetExpression(throwOnError: false);
if (targetNode == null)
{
if (bindingContext.Global == null)
{
var methodName = node.GetMethodName(throwOnError: false);
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETORESOLVENAME, methodName ?? "<unknown>"), node);
return(false);
}
target = bindingContext.Global;
type = target.Type;
}
else if (bindingContext.TryResolveType(targetNode, out type))
{
target = null;
}
else
{
if (TryBind(targetNode, bindingContext, TypeDescription.ObjectType, out target, out bindingError) == false)
{
return(false);
}
type = target.Type;
}
return(true);
}
private static void RenderArrayLength(SyntaxTreeNode syntaxTree, StringBuilder builder, bool checkedScope)
{
if (syntaxTree == null)
{
throw new ArgumentNullException("syntaxTree");
}
if (builder == null)
{
throw new ArgumentNullException("builder");
}
Render(syntaxTree.GetExpression(throwOnError: true), builder, false, checkedScope);
builder.Append(".Length");
}
private static void RenderPropertyOrField(SyntaxTreeNode syntaxTree, StringBuilder builder, bool checkedScope)
{
if (syntaxTree == null)
{
throw new ArgumentNullException("syntaxTree");
}
if (builder == null)
{
throw new ArgumentNullException("builder");
}
var target = syntaxTree.GetExpression(throwOnError: false);
var propertyOrFieldName = syntaxTree.GetMemberName(throwOnError: true);
var useNullPropagation = syntaxTree.GetUseNullPropagation(throwOnError: false);
var arguments = syntaxTree.GetArguments(throwOnError: false);
if (target != null)
{
Render(target, builder, false, checkedScope);
if (useNullPropagation)
{
builder.Append("?.");
}
else
{
builder.Append(".");
}
}
builder.Append(propertyOrFieldName);
if (arguments != null && arguments.Count > 0)
{
builder.Append("<");
for (var i = 0; i < arguments.Count; i++)
{
if (i != 0)
{
builder.Append(",");
}
var typeArgument = default(SyntaxTreeNode);
if (arguments.TryGetValue(i, out typeArgument))
{
Render(typeArgument, builder, true, checkedScope);
}
}
builder.Append(">");
}
}
private static void RenderLambda(SyntaxTreeNode syntaxTree, StringBuilder builder, bool wrapped, bool checkedScope)
{
if (syntaxTree == null)
{
throw new ArgumentException("syntaxTree");
}
if (builder == null)
{
throw new ArgumentException("builder");
}
if (!wrapped)
{
builder.Append("(");
}
var arguments = syntaxTree.GetArguments(throwOnError: false);
var body = syntaxTree.GetExpression(throwOnError: true);
if (arguments.Count != 1)
{
builder.Append("(");
}
var firstParam = true;
foreach (var param in arguments.Values)
{
if (firstParam == false)
{
builder.Append(", ");
}
Render(param, builder, true, checkedScope);
firstParam = false;
}
if (arguments.Count != 1)
{
builder.Append(")");
}
builder.Append(" => ");
Render(body, builder, false, checkedScope);
if (!wrapped)
{
builder.Append(")");
}
}
public static bool TryBind(SyntaxTreeNode node, BindingContext bindingContext, TypeDescription expectedType, out Expression boundExpression, out Exception bindingError)
{
bindingError = null;
boundExpression = null;
bindingError = null;
var operandNode = node.GetExpression(throwOnError: true);
var operand = default(Expression);
if (AnyBinder.TryBindInNewScope(operandNode, bindingContext, TypeDescription.ObjectType, out operand, out bindingError) == false)
{
return(false);
}
boundExpression = Expression.Quote(operand);
return(true);
}
private static void RenderInvokeOrIndex(SyntaxTreeNode syntaxTree, StringBuilder builder, bool checkedScope)
{
if (syntaxTree == null)
{
throw new ArgumentNullException("syntaxTree");
}
if (builder == null)
{
throw new ArgumentNullException("builder");
}
var expressionType = syntaxTree.GetExpressionType(throwOnError: true);
var target = syntaxTree.GetExpression(throwOnError: true);
var arguments = syntaxTree.GetArguments(throwOnError: false);
var useNullPropagation = syntaxTree.GetUseNullPropagation(throwOnError: false);
Render(target, builder, false, checkedScope);
builder.Append(expressionType == Constants.DELEGATE_INVOKE_NAME ? "(" : (useNullPropagation ? "?[" : "["));
RenderArguments(arguments, builder, checkedScope);
builder.Append(expressionType == Constants.DELEGATE_INVOKE_NAME ? ")" : "]");
}
public static bool TryBind(SyntaxTreeNode node, BindingContext bindingContext, TypeDescription expectedType, out Expression boundExpression, out Exception bindingError)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
if (expectedType == null)
{
throw new ArgumentNullException("expectedType");
}
boundExpression = null;
bindingError = null;
var expressionNode = node.GetExpression(throwOnError: true);
return(AnyBinder.TryBindInNewScope(expressionNode, bindingContext, expectedType, out boundExpression, out bindingError));
}
public static bool TryBind(SyntaxTreeNode node, BindingContext bindingContext, TypeDescription expectedType, out Expression boundExpression, out Exception bindingError)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
if (expectedType == null)
{
throw new ArgumentNullException("expectedType");
}
boundExpression = null;
bindingError = null;
var target = default(Expression);
var targetNode = node.GetExpression(throwOnError: false);
var propertyOrFieldName = node.GetPropertyOrFieldName(throwOnError: true);
var useNullPropagation = node.GetUseNullPropagation(throwOnError: false);
var targetType = default(Type);
var isStatic = false;
if (bindingContext.TryResolveType(targetNode, out targetType))
{
target = null;
isStatic = true;
}
else if (targetNode == null)
{
target = bindingContext.Global;
targetType = target != null ? target.Type : null;
isStatic = false;
switch (propertyOrFieldName)
{
case Constants.VALUE_NULL_STRING:
boundExpression = ExpressionUtils.NullConstant;
return(true);
case Constants.VALUE_TRUE_STRING:
boundExpression = ExpressionUtils.TrueConstant;
return(true);
case Constants.VALUE_FALSE_STRING:
boundExpression = ExpressionUtils.TrueConstant;
return(false);
default:
if (bindingContext.TryGetParameter(propertyOrFieldName, out boundExpression))
{
return(true);
}
break;
}
}
else if (AnyBinder.TryBind(targetNode, bindingContext, TypeDescription.ObjectType, out target, out bindingError))
{
Debug.Assert(target != null, "target != null");
targetType = target.Type;
isStatic = false;
}
else
{
target = null;
targetType = null;
}
if (target == null && targetType == null)
{
if (bindingError == null)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETORESOLVENAME, propertyOrFieldName), node);
}
return(false);
}
Debug.Assert(targetType != null, "type != null");
var targetTypeDescription = TypeDescription.GetTypeDescription(targetType);
if (isStatic && targetTypeDescription.IsEnum)
{
var fieldMemberDescription = targetTypeDescription.GetMembers(propertyOrFieldName).FirstOrDefault(m => m.IsStatic);
if (fieldMemberDescription == null)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETORESOLVEMEMBERONTYPE, propertyOrFieldName, targetType), node);
return(false);
}
boundExpression = fieldMemberDescription.ConstantValueExpression;
}
else
{
foreach (var member in targetTypeDescription.GetMembers(propertyOrFieldName))
{
if (member.IsStatic != isStatic || member.IsPropertyOrField == false)
{
continue;
}
if (member.TryMakeAccessor(target, out boundExpression))
{
break;
}
}
}
if (boundExpression == null)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETORESOLVEMEMBERONTYPE, propertyOrFieldName, targetType), node);
return(false);
}
if (useNullPropagation && isStatic)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETOAPPLYNULLCONDITIONALOPERATORONTYPEREF, targetType));
return(false);
}
if (useNullPropagation && targetTypeDescription.CanBeNull)
{
bindingContext.RegisterNullPropagationTarget(target);
}
return(true);
}
public static bool TryBind(SyntaxTreeNode node, BindingContext bindingContext, TypeDescription expectedType, out Expression boundExpression, out Exception bindingError)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
if (expectedType == null)
{
throw new ArgumentNullException("expectedType");
}
boundExpression = null;
bindingError = null;
var expressionType = node.GetExpressionType(throwOnError: true);
var operandNode = node.GetExpression(throwOnError: true);
var operand = default(Expression);
var methodName = node.GetMethodName(throwOnError: false);
var methodMember = default(MemberDescription);
if (AnyBinder.TryBindInNewScope(operandNode, bindingContext, TypeDescription.ObjectType, out operand, out bindingError) == false)
{
return(false);
}
if (methodName != null)
{
bindingContext.TryResolveMember(methodName, out methodMember);
}
Debug.Assert(operand != null, "operand != null");
switch (expressionType)
{
case Constants.EXPRESSION_TYPE_NEGATE:
if (ExpressionUtils.TryPromoteUnaryOperation(ref operand, ExpressionType.Negate, out boundExpression) == false)
{
// fixing b_u_g in mono expression compiler: Negate on float or double = exception
if (operand.Type == typeof(double) || operand.Type == typeof(float))
{
boundExpression = Expression.Multiply(operand, operand.Type == typeof(float) ? ExpressionUtils.NegativeSingle : ExpressionUtils.NegativeDouble);
}
else
{
boundExpression = Expression.Negate(operand, methodMember);
}
}
break;
case Constants.EXPRESSION_TYPE_NEGATE_CHECKED:
if (ExpressionUtils.TryPromoteUnaryOperation(ref operand, ExpressionType.NegateChecked, out boundExpression) == false)
{
// fixing b_u_g in mono expression compiler: Negate on float or double = exception
if (operand.Type == typeof(double) || operand.Type == typeof(float))
{
boundExpression = Expression.Multiply(operand, operand.Type == typeof(float) ? ExpressionUtils.NegativeSingle : ExpressionUtils.NegativeDouble);
}
else
{
boundExpression = Expression.NegateChecked(operand, methodMember);
}
}
break;
case Constants.EXPRESSION_TYPE_COMPLEMENT:
case Constants.EXPRESSION_TYPE_NOT:
if (ExpressionUtils.TryPromoteUnaryOperation(ref operand, ExpressionType.Not, out boundExpression) == false)
{
boundExpression = Expression.Not(operand, methodMember);
}
break;
case Constants.EXPRESSION_TYPE_UNARY_PLUS:
if (ExpressionUtils.TryPromoteUnaryOperation(ref operand, ExpressionType.UnaryPlus, out boundExpression) == false)
{
boundExpression = Expression.UnaryPlus(operand, methodMember);
}
break;
case Constants.EXPRESSION_TYPE_ARRAY_LENGTH:
boundExpression = Expression.ArrayLength(operand);
break;
default:
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNKNOWNEXPRTYPE, expressionType), node);
return(false);
}
return(true);
}
private static void RenderTypeBinary(SyntaxTreeNode syntaxTree, StringBuilder builder, bool wrapped, bool checkedScope)
{
if (syntaxTree == null)
{
throw new ArgumentNullException("syntaxTree");
}
if (builder == null)
{
throw new ArgumentNullException("builder");
}
var expressionType = syntaxTree.GetExpressionType(throwOnError: true);
var typeName = syntaxTree.GetTypeName(throwOnError: true);
var target = syntaxTree.GetExpression(throwOnError: true);
var checkedOperation = expressionType == Constants.EXPRESSION_TYPE_CONVERT_CHECKED ? true :
expressionType == Constants.EXPRESSION_TYPE_CONVERT ? false : checkedScope;
var closeParent = false;
if (checkedOperation && !checkedScope)
{
builder.Append("checked(");
checkedScope = true;
closeParent = true;
}
else if (!checkedOperation && checkedScope)
{
builder.Append("unchecked(");
checkedScope = false;
closeParent = true;
}
else if (!wrapped)
{
builder.Append("(");
closeParent = true;
}
switch (expressionType)
{
case Constants.EXPRESSION_TYPE_CONVERT:
case Constants.EXPRESSION_TYPE_CONVERT_CHECKED:
builder.Append("(");
RenderTypeName(typeName, builder);
builder.Append(")");
Render(target, builder, false, checkedOperation);
break;
case Constants.EXPRESSION_TYPE_TYPE_IS:
Render(target, builder, false, checkedScope);
builder.Append(" is ");
RenderTypeName(typeName, builder);
break;
case Constants.EXPRESSION_TYPE_TYPE_AS:
Render(target, builder, false, checkedScope);
builder.Append(" as ");
RenderTypeName(typeName, builder);
break;
default: throw new InvalidOperationException(string.Format(Properties.Resources.EXCEPTION_BIND_UNKNOWNEXPRTYPE, expressionType));
}
if (closeParent)
{
builder.Append(")");
}
}
public static bool TryBind(SyntaxTreeNode node, BindingContext bindingContext, TypeDescription expectedType, out Expression boundExpression, out Exception bindingError)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
if (expectedType == null)
{
throw new ArgumentNullException("expectedType");
}
boundExpression = null;
bindingError = null;
var target = default(Expression);
var arguments = node.GetArguments(throwOnError: false);
var methodName = node.GetMethodName(throwOnError: true);
var useNullPropagation = node.GetUseNullPropagation(throwOnError: false);
var methodMember = default(MemberDescription);
if (bindingContext.TryResolveMember(methodName, out methodMember))
{
if (methodMember.IsMethod == false)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_CALLMEMBERISNOTMETHOD, methodMember.Name, methodMember.DeclaringType), node);
return(false);
}
var targetNode = node.GetExpression(throwOnError: true);
if (AnyBinder.TryBind(targetNode, bindingContext, TypeDescription.ObjectType, out target, out bindingError) == false)
{
return(false);
}
float methodQuality;
if (methodMember.TryMakeCall(target, arguments, bindingContext, out boundExpression, out methodQuality) == false)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETOBINDMETHOD, methodMember.Name, target.Type, arguments.Count), node);
return(false);
}
return(true);
}
var methodRef = default(TypeReference);
if (BindingContext.TryGetMethodReference(methodName, out methodRef) == false)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETORESOLVENAME, methodName), node);
return(false);
}
var targetType = default(Type);
if (TryBindTarget(node, bindingContext, out target, out targetType, out bindingError) == false)
{
return(false);
}
var isStatic = target == null;
var selectedMethodQuality = MemberDescription.QUALITY_INCOMPATIBLE;
var hasGenericParameters = methodRef.IsGenericType;
var genericArguments = default(Type[]);
if (hasGenericParameters)
{
genericArguments = new Type[methodRef.TypeArguments.Count];
for (var i = 0; i < genericArguments.Length; i++)
{
var typeArgument = methodRef.TypeArguments[i];
if (bindingContext.TryResolveType(typeArgument, out genericArguments[i]) == false)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETORESOLVETYPE, typeArgument), node);
return(false);
}
}
}
var targetTypeDescription = TypeDescription.GetTypeDescription(targetType);
var foundMethod = default(MethodInfo);
foreach (var memberDescription in targetTypeDescription.GetMembers(methodRef.Name))
{
if (memberDescription.IsMethod == false)
{
continue;
}
var methodDescription = memberDescription;
var method = (MethodInfo)memberDescription;
foundMethod = foundMethod ?? method;
if (method.IsStatic != isStatic || method.IsGenericMethod != hasGenericParameters)
{
continue;
}
if (hasGenericParameters && memberDescription.GenericArgumentsCount != methodRef.TypeArguments.Count)
{
continue;
}
if (hasGenericParameters)
{
try
{
methodDescription = methodDescription.MakeGenericMethod(genericArguments);
method = methodDescription;
}
catch (ArgumentException exception)
{
bindingError = exception;
continue; /* An element of typeArguments does not satisfy the constraints specified for the corresponding type parameter of the current generic method definition. */
}
}
var methodQuality = 0.0f;
var methodCallExpression = default(Expression);
if (methodDescription.TryMakeCall(target, arguments, bindingContext, out methodCallExpression, out methodQuality) == false)
{
continue;
}
if (float.IsNaN(methodQuality) || methodQuality <= selectedMethodQuality)
{
continue;
}
boundExpression = methodCallExpression;
selectedMethodQuality = methodQuality;
if (Math.Abs(methodQuality - MemberDescription.QUALITY_EXACT_MATCH) < float.Epsilon)
{
break; // best match
}
}
if (bindingError != null)
{
return(false);
}
if (boundExpression == null)
{
if (foundMethod != null)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETOBINDMETHOD, methodRef.Name, targetType, arguments.Count), node);
}
else
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETOBINDCALL, methodRef.Name, targetType, arguments.Count), node);
}
return(false);
}
if (useNullPropagation && target == null)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETOAPPLYNULLCONDITIONALOPERATORONTYPEREF, targetType));
return(false);
}
if (useNullPropagation && targetTypeDescription.CanBeNull)
{
bindingContext.RegisterNullPropagationTarget(target);
}
if (targetTypeDescription.IsAssignableFrom(typeof(Type)) &&
bindingContext.IsKnownType(typeof(Type)) == false &&
(bindingContext.IsKnownType(targetType) == false || methodRef.Name.Equals("InvokeMember", StringComparison.Ordinal)))
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_RESTRICTED_MEMBER_INVOCATION, methodName, targetType, typeof(ITypeResolver)), node);
return(false);
}
return(true);
}
public static bool TryBind(SyntaxTreeNode node, BindingContext bindingContext, TypeDescription expectedType, out Expression boundExpression, out Exception bindingError)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
if (expectedType == null)
{
throw new ArgumentNullException("expectedType");
}
boundExpression = null;
bindingError = null;
// try get type of lambda from node
var lambdaTypeName = node.GetTypeName(throwOnError: false);
var lambdaType = default(Type);
if (lambdaTypeName != null)
{
if (bindingContext.TryResolveType(lambdaTypeName, out lambdaType) == false)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETORESOLVETYPE, lambdaTypeName), node);
return(false);
}
else
{
expectedType = TypeDescription.GetTypeDescription(lambdaType);
}
}
if (expectedType.HasGenericParameters || !expectedType.IsDelegate)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_VALIDDELEGATETYPEISEXPECTED, expectedType.ToString()));
return(false);
}
var expressionType = node.GetExpressionType(throwOnError: true);
var bodyNode = node.GetExpression(throwOnError: true);
var argumentsTree = node.GetArguments(throwOnError: false);
var lambdaInvokeMethod = expectedType.GetMembers(Constants.DELEGATE_INVOKE_NAME).FirstOrDefault(m => m.IsMethod && !m.IsStatic);
if (lambdaInvokeMethod == null)
{
bindingError = new MissingMethodException(string.Format(Resources.EXCEPTION_BIND_MISSINGMETHOD, expectedType.ToString(), Constants.DELEGATE_INVOKE_NAME));
return(false);
}
if (lambdaInvokeMethod.GetParametersCount() != argumentsTree.Count)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_INVALIDLAMBDAARGUMENTS, expectedType));
return(false);
}
var argumentNames = new string[argumentsTree.Count];
for (var i = 0; i < argumentNames.Length; i++)
{
var argumentNameTree = default(SyntaxTreeNode);
var argumentNameTreeType = default(string);
if (argumentsTree.TryGetValue(i, out argumentNameTree) == false ||
argumentNameTree == null ||
(argumentNameTreeType = argumentNameTree.GetExpressionType(throwOnError: true)) == null ||
(argumentNameTreeType == Constants.EXPRESSION_TYPE_PROPERTY_OR_FIELD ||
argumentNameTreeType == Constants.EXPRESSION_TYPE_MEMBER_RESOLVE ||
argumentNameTreeType == Constants.EXPRESSION_TYPE_PARAMETER) == false)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_MISSINGATTRONNODE, Constants.EXPRESSION_ATTRIBUTE, expressionType), node);
return(false);
}
argumentNames[i] = argumentNameTree.GetMemberName(throwOnError: true);
}
var lambdaParameters = new ParameterExpression[argumentsTree.Count];
for (var i = 0; i < argumentsTree.Count; i++)
{
lambdaParameters[i] = Expression.Parameter(lambdaInvokeMethod.GetParameter(i).ParameterType, argumentNames[i]);
}
var currentParameters = bindingContext.Parameters;
var newParameters = new List <ParameterExpression>(lambdaParameters.Length + currentParameters.Count);
// add all lambda's parameters
newParameters.AddRange(lambdaParameters);
// add closure parameters
foreach (var parameterExpr in currentParameters)
{
if (Array.IndexOf(argumentNames, parameterExpr.Name) < 0)
{
newParameters.Add(parameterExpr);
}
}
var nestedBindingContext = bindingContext.CreateNestedContext(newParameters.AsReadOnly(), lambdaInvokeMethod.ResultType);
var body = default(Expression);
if (AnyBinder.TryBindInNewScope(bodyNode, nestedBindingContext, TypeDescription.GetTypeDescription(lambdaInvokeMethod.ResultType), out body, out bindingError) == false)
{
return(false);
}
Debug.Assert(body != null, "body != null");
boundExpression = Expression.Lambda(expectedType, body, lambdaParameters);
return(true);
}
public static bool TryBind(SyntaxTreeNode node, BindingContext bindingContext, TypeDescription expectedType, out Expression boundExpression, out Exception bindingError)
{
boundExpression = null;
bindingError = null;
var useNullPropagation = node.GetUseNullPropagation(throwOnError: false);
var arguments = node.GetArguments(throwOnError: true);
var targetNode = node.GetExpression(throwOnError: true);
var target = default(Expression);
if (AnyBinder.TryBind(targetNode, bindingContext, TypeDescription.ObjectType, out target, out bindingError) == false)
{
return(false);
}
Debug.Assert(target != null, "target != null");
var targetTypeDescription = TypeDescription.GetTypeDescription(target.Type);
if (target.Type.IsArray)
{
var indexType = TypeDescription.Int32Type;
var indexingExpressions = new Expression[arguments.Count];
for (var i = 0; i < indexingExpressions.Length; i++)
{
var argument = default(SyntaxTreeNode);
if (arguments.TryGetValue(i, out argument) == false)
{
bindingError = new ExpressionParserException(string.Format(Resources.EXCEPTION_BIND_MISSINGMETHODPARAMETER, i), node);
return(false);
}
if (AnyBinder.TryBindInNewScope(argument, bindingContext, indexType, out indexingExpressions[i], out bindingError) == false)
{
return(false);
}
Debug.Assert(indexingExpressions[i] != null, "indexingExpressions[i] != null");
}
try
{
if (indexingExpressions.Length == 1)
{
boundExpression = Expression.ArrayIndex(target, indexingExpressions[0]);
}
else
{
boundExpression = Expression.ArrayIndex(target, indexingExpressions);
}
}
catch (Exception exception)
{
bindingError = new ExpressionParserException(exception.Message, exception, node);
return(false);
}
}
else
{
var selectedIndexerQuality = MemberDescription.QUALITY_INCOMPATIBLE;
foreach (var indexer in targetTypeDescription.Indexers)
{
var indexerQuality = MemberDescription.QUALITY_INCOMPATIBLE;
var indexerCall = default(Expression);
if (indexer.TryMakeCall(target, arguments, bindingContext, out indexerCall, out indexerQuality) == false)
{
continue;
}
if (indexerQuality <= selectedIndexerQuality)
{
continue;
}
boundExpression = indexerCall;
selectedIndexerQuality = indexerQuality;
}
}
if (boundExpression == null)
{
bindingError = new ExpressionParserException(string.Format(Resources.EXCEPTION_BIND_UNABLETOBINDINDEXER, target.Type), node);
return(false);
}
if (useNullPropagation && targetTypeDescription.CanBeNull)
{
bindingContext.RegisterNullPropagationTarget(target);
}
return(true);
}
public static bool TryBindMethodCall(SyntaxTreeNode node, BindingContext bindingContext, TypeDescription expectedType, out Expression boundExpression, out Exception bindingError)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
if (expectedType == null)
{
throw new ArgumentNullException("expectedType");
}
// bindingError could return null from this method
bindingError = null;
boundExpression = null;
var methodNameNode = node.GetExpression(throwOnError: true);
var methodNameNodeType = methodNameNode.GetExpressionType(throwOnError: true);
if (methodNameNodeType != Constants.EXPRESSION_TYPE_PROPERTY_OR_FIELD &&
methodNameNodeType != Constants.EXPRESSION_TYPE_MEMBER_RESOLVE)
{
return(false);
}
var methodTargetNode = methodNameNode.GetExpression(throwOnError: false);
var methodTarget = default(Expression);
var type = default(Type);
var typeReference = default(TypeReference);
var isStatic = false;
if (methodTargetNode == null && bindingContext.Global != null)
{
methodTarget = bindingContext.Global;
type = methodTarget.Type;
isStatic = false;
}
else if (methodTargetNode == null)
{
var methodName = methodNameNode.GetMemberName(throwOnError: false);
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETORESOLVENAME, methodName ?? "<unknown>"), node);
return(false);
}
else if (BindingContext.TryGetTypeReference(methodTargetNode, out typeReference) && bindingContext.TryResolveType(typeReference, out type))
{
isStatic = true;
}
else if (AnyBinder.TryBind(methodTargetNode, bindingContext, TypeDescription.ObjectType, out methodTarget, out bindingError))
{
Debug.Assert(methodTarget != null, "methodTarget != null");
isStatic = false;
type = methodTarget.Type;
}
else
{
if (typeReference != null && bindingError == null)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETORESOLVETYPE, typeReference), node);
}
return(false);
}
var methodRef = default(TypeReference);
if (type == null || BindingContext.TryGetMethodReference(methodNameNode, out methodRef) == false)
{
return(false);
}
var typeDescription = TypeDescription.GetTypeDescription(type);
foreach (var member in typeDescription.GetMembers(methodRef.Name))
{
if (member.IsMethod == false || member.IsStatic != isStatic)
{
continue;
}
var callNode = new SyntaxTreeNode(new Dictionary <string, object>
{
{ Constants.EXPRESSION_ATTRIBUTE, methodTarget ?? (object)type },
{ Constants.ARGUMENTS_ATTRIBUTE, node.GetValueOrDefault(Constants.ARGUMENTS_ATTRIBUTE, default(object)) },
{ Constants.METHOD_ATTRIBUTE, methodRef },
{ Constants.USE_NULL_PROPAGATION_ATTRIBUTE, methodNameNode.GetValueOrDefault(Constants.USE_NULL_PROPAGATION_ATTRIBUTE, default(object)) },
{ Constants.EXPRESSION_POSITION, methodNameNode.GetPosition(throwOnError: false) }
});
return(CallBinder.TryBind(callNode, bindingContext, expectedType, out boundExpression, out bindingError));
}
return(false);
}
public static bool TryBind(SyntaxTreeNode node, BindingContext bindingContext, TypeDescription expectedType, out Expression boundExpression, out Exception bindingError)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
if (expectedType == null)
{
throw new ArgumentNullException("expectedType");
}
boundExpression = null;
bindingError = null;
var expressionType = node.GetExpressionType(throwOnError: true);
var targetNode = node.GetExpression(throwOnError: true);
var typeName = node.GetTypeName(throwOnError: true);
var type = default(Type);
if (bindingContext.TryResolveType(typeName, out type) == false)
{
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNABLETORESOLVETYPE, typeName), node);
return(false);
}
var target = default(Expression);
if (AnyBinder.TryBindInNewScope(targetNode, bindingContext, TypeDescription.ObjectType, out target, out bindingError) == false)
{
return(false);
}
Debug.Assert(target != null, "target != null");
switch (expressionType)
{
case Constants.EXPRESSION_TYPE_TYPE_IS:
boundExpression = Expression.TypeIs(target, type);
break;
case Constants.EXPRESSION_TYPE_TYPE_AS:
boundExpression = Expression.TypeAs(target, type);
break;
case Constants.EXPRESSION_TYPE_CONVERT:
boundExpression = Expression.Convert(target, type);
break;
case Constants.EXPRESSION_TYPE_CONVERT_CHECKED:
boundExpression = Expression.ConvertChecked(target, type);
break;
default:
boundExpression = null;
bindingError = new ExpressionParserException(string.Format(Properties.Resources.EXCEPTION_BIND_UNKNOWNEXPRTYPE, expressionType), node);
return(false);
}
return(true);
}
