internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList<Expression> parameters, bool[] hasBeenUsed) {
if (_tmp == null) {
_tmp = parameterBinder.GetTemporary(Type, "outParam");
}
return Ast.Block(Ast.Assign(_tmp, base.ToExpression(parameterBinder, parameters, hasBeenUsed)), _tmp);
}
internal override Expression ToExpression(ParameterBinder parameterBinder, IList<ArgBuilder> args, IList<Expression> parameters, Expression ret) {
if (_returnArgs.Count == 1) {
if (_returnArgs[0] == -1) {
return ret;
}
return Ast.Block(ret, args[_returnArgs[0]].ToReturnExpression(parameterBinder));
}
Expression[] retValues = new Expression[_returnArgs.Count];
int rIndex = 0;
bool usesRet = false;
foreach (int index in _returnArgs) {
if (index == -1) {
usesRet = true;
retValues[rIndex++] = ret;
} else {
retValues[rIndex++] = args[index].ToReturnExpression(parameterBinder);
}
}
Expression retArray = AstUtils.NewArrayHelper(typeof(object), retValues);
if (!usesRet) {
retArray = Ast.Block(ret, retArray);
}
return parameterBinder.Binder.GetByRefArrayExpression(retArray);
}
internal override Expression ToReturnExpression(ParameterBinder parameterBinder) {
if (_isRef) {
return _tmp;
}
return GetDefaultValue();
}
protected internal override Func<object[], object> ToDelegate(ParameterBinder parameterBinder, IList<DynamicMetaObject> knownTypes, bool[] hasBeenUsed) {
int index = GetKeywordIndex(knownTypes.Count);
hasBeenUsed[index] = true;
var target = _builder.ToDelegate(parameterBinder, new DynamicMetaObject[] { knownTypes[index] }, new bool[1]);
return (args) => target(new object[] { args[index] });
}
protected internal override Func<object[], object> ToDelegate(ParameterBinder parameterBinder, IList<DynamicMetaObject> knownTypes, bool[] hasBeenUsed) {
object val = ParameterInfo.DefaultValue;
if (val is Missing) {
val = CompilerHelpers.GetMissingValue(ParameterInfo.ParameterType);
}
Debug.Assert(val != Missing.Value);
return (args) => val;
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList <Expression> parameters, bool[] hasBeenUsed)
{
if (_tmp == null)
{
_tmp = parameterBinder.GetTemporary(Type, "outParam");
}
return(Ast.Block(Ast.Assign(_tmp, base.ToExpression(parameterBinder, parameters, hasBeenUsed)), _tmp));
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList<Expression> parameters, bool[] hasBeenUsed) {
Expression res = Ast.Call(
typeof(BinderOps).GetMethod("MakeSymbolDictionary"),
Ast.NewArrayInit(typeof(string), ConstantNames()),
AstUtils.NewArrayHelper(typeof(object), GetParameters(parameters, hasBeenUsed))
);
return res;
}
internal override Expression ToReturnExpression(ParameterBinder parameterBinder)
{
if (_isRef)
{
return(_tmp);
}
return(GetDefaultValue());
}
/// <summary>
/// Performs binding against a set of overloaded methods using the specified arguments. All arguments
/// are treated as positional arguments.
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="targets">The methods to be called</param>
/// <param name="args">The arguments for the call</param>
/// <returns>A meta object which results from the call.</returns>
public DynamicMetaObject CallMethod(ParameterBinder parameterBinder, IList<MethodBase> targets, IList<DynamicMetaObject> args) {
return CallMethod(
parameterBinder,
targets,
args,
new CallSignature(args.Count),
BindingRestrictions.Empty
);
}
internal override Expression UpdateFromReturn(ParameterBinder parameterBinder, IList<Expression> parameters) {
return Expression.Assign(
Expression.Field(
Expression.Convert(parameters[Index], Type),
Type.GetField("Value")
),
_tmp
);
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList<Expression> parameters, bool[] hasBeenUsed) {
if (_isRef) {
if (_tmp == null) {
_tmp = parameterBinder.GetTemporary(_parameterType, "outParam");
}
return _tmp;
}
return GetDefaultValue();
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList <Expression> parameters, bool[] hasBeenUsed)
{
Expression res = Ast.Call(
typeof(BinderOps).GetMethod("MakeSymbolDictionary"),
Ast.NewArrayInit(typeof(SymbolId), ConstantNames()),
AstUtils.NewArrayHelper(typeof(object), GetParameters(parameters, hasBeenUsed))
);
return(res);
}
internal override Expression UpdateFromReturn(ParameterBinder parameterBinder, IList <Expression> parameters)
{
return(Expression.Assign(
Expression.Field(
Expression.Convert(parameters[Index], Type),
Type.GetField("Value")
),
_tmp
));
}
private Expression[] GetArgumentExpressions(ParameterBinder parameterBinder, IList <Expression> parameters, out bool[] usageMarkers, out Expression[] spilledArgs)
{
int minPriority = Int32.MaxValue;
int maxPriority = Int32.MinValue;
foreach (ArgBuilder ab in _argBuilders)
{
minPriority = System.Math.Min(minPriority, ab.Priority);
maxPriority = System.Math.Max(maxPriority, ab.Priority);
}
var args = new Expression[_argBuilders.Count];
Expression[] actualArgs = null;
usageMarkers = new bool[parameters.Count];
for (int priority = minPriority; priority <= maxPriority; priority++)
{
for (int i = 0; i < _argBuilders.Count; i++)
{
if (_argBuilders[i].Priority == priority)
{
args[i] = _argBuilders[i].ToExpression(parameterBinder, parameters, usageMarkers);
// see if this has a temp that needs to be passed as the actual argument
Expression byref = _argBuilders[i].ByRefArgument;
if (byref != null)
{
if (actualArgs == null)
{
actualArgs = new Expression[_argBuilders.Count];
}
actualArgs[i] = byref;
}
}
}
}
if (actualArgs != null)
{
for (int i = 0, n = args.Length; i < n; i++)
{
if (args[i] != null && actualArgs[i] == null)
{
actualArgs[i] = parameterBinder.GetTemporary(args[i].Type, null);
args[i] = Expression.Assign(actualArgs[i], args[i]);
}
}
spilledArgs = RemoveNulls(args);
return(RemoveNulls(actualArgs));
}
spilledArgs = null;
return(RemoveNulls(args));
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList<Expression> parameters, bool[] hasBeenUsed) {
List<Expression> elems = new List<Expression>(_count);
for (int i = _start; i < _start + _count; i++) {
if (!hasBeenUsed[i]) {
elems.Add(parameterBinder.ConvertExpression(parameters[i], ParameterInfo, _elementType));
hasBeenUsed[i] = true;
}
}
return Ast.NewArrayInit(_elementType, elems);
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList<Expression> parameters, bool[] hasBeenUsed) {
object val = ParameterInfo.DefaultValue;
if (val is Missing) {
val = CompilerHelpers.GetMissingValue(ParameterInfo.ParameterType);
}
if (ParameterInfo.ParameterType.IsByRef) {
return Ast.Constant(val, ParameterInfo.ParameterType.GetElementType());
}
return parameterBinder.ConvertExpression(Ast.Constant(val), ParameterInfo, ParameterInfo.ParameterType);
}
/// <summary>
/// Gets an Expression which calls the binding target if the method binding succeeded.
///
/// Throws InvalidOperationException if the binding failed.
///
/// OBSOLETE
/// </summary>
public Expression MakeExpression(ParameterBinder parameterBinder, IList <Expression> parameters)
{
ContractUtils.RequiresNotNull(parameterBinder, "parameterBinder");
ContractUtils.RequiresNotNull(parameters, "parameters");
if (_target == null)
{
throw new InvalidOperationException("An expression cannot be produced because the method binding was unsuccessful.");
}
return(_target.MakeExpression(parameterBinder, parameters, ArgumentTests));
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList <Expression> parameters, bool[] hasBeenUsed)
{
if (_isRef)
{
if (_tmp == null)
{
_tmp = parameterBinder.GetTemporary(_parameterType, "outParam");
}
return(_tmp);
}
return(GetDefaultValue());
}
/// <summary>
/// Performs binding against a set of overloaded methods using the specified arguments. All arguments
/// are treated as positional arguments.
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="targets">The methods to be called</param>
/// <param name="args">The arguments for the call</param>
/// <param name="maxLevel">The maximum narrowing level for arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <param name="minLevel">The minimum narrowing level for the arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <returns>A meta object which results from the call.</returns>
public DynamicMetaObject CallMethod(ParameterBinder parameterBinder, IList<MethodBase> targets, IList<DynamicMetaObject> args, NarrowingLevel minLevel, NarrowingLevel maxLevel) {
return CallWorker(
parameterBinder,
targets,
args,
new CallSignature(args.Count),
CallTypes.None,
BindingRestrictions.Empty,
minLevel,
maxLevel,
null
);
}
/// <summary>
/// Provides default binding for performing a call on the specified meta objects.
/// </summary>
/// <param name="signature">The signature describing the call</param>
/// <param name="target">The meta object to be called.</param>
/// <param name="args">
/// Additional meta objects are the parameters for the call as specified by the CallSignature in the CallAction.
/// </param>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <returns>A MetaObject representing the call or the error.</returns>
public DynamicMetaObject Call(CallSignature signature, ParameterBinder parameterBinder, DynamicMetaObject target, params DynamicMetaObject[] args) {
ContractUtils.RequiresNotNullItems(args, "args");
ContractUtils.RequiresNotNull(parameterBinder, "parameterBinder");
TargetInfo targetInfo = GetTargetInfo(signature, target, args);
if (targetInfo != null) {
// we're calling a well-known MethodBase
return MakeMetaMethodCall(signature, parameterBinder, targetInfo);
} else {
// we can't call this object
return MakeCannotCallRule(target, target.LimitType);
}
}
private static Expression ConvertToHelper(ParameterBinder parameterBinder, Expression value, Type type)
{
if (type == value.Type)
{
return(value);
}
if (type.IsAssignableFrom(value.Type))
{
return(AstUtils.Convert(value, type));
}
return(parameterBinder.GetDynamicConversion(value, type));
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList <Expression> parameters, bool[] hasBeenUsed)
{
List <Expression> elems = new List <Expression>(_count);
for (int i = _start; i < _start + _count; i++)
{
if (!hasBeenUsed[i])
{
elems.Add(parameterBinder.ConvertExpression(parameters[i], ParameterInfo, _elementType));
hasBeenUsed[i] = true;
}
}
return(Ast.NewArrayInit(_elementType, elems));
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList <Expression> parameters, bool[] hasBeenUsed)
{
object val = ParameterInfo.DefaultValue;
if (val is Missing)
{
val = CompilerHelpers.GetMissingValue(ParameterInfo.ParameterType);
}
if (ParameterInfo.ParameterType.IsByRef)
{
return(Ast.Constant(val, ParameterInfo.ParameterType.GetElementType()));
}
return(parameterBinder.ConvertExpression(Ast.Constant(val), ParameterInfo, ParameterInfo.ParameterType));
}
/// <summary>
/// Gets an Expression which calls the binding target if the method binding succeeded.
///
/// Throws InvalidOperationException if the binding failed.
/// </summary>
public Expression MakeExpression(ParameterBinder parameterBinder)
{
ContractUtils.RequiresNotNull(parameterBinder, "parameterBinder");
if (_target == null)
{
throw new InvalidOperationException("An expression cannot be produced because the method binding was unsuccessful.");
}
else if (_restrictedArgs == null)
{
throw new InvalidOperationException("An expression cannot be produced because the method binding was done with Expressions, not MetaObject's");
}
Expression[] exprs = new Expression[_restrictedArgs.Length];
for (int i = 0; i < exprs.Length; i++)
{
exprs[i] = _restrictedArgs[i].Expression;
}
return(_target.MakeExpression(parameterBinder, exprs));
}
/// <summary>
/// Creates a call to this MethodTarget with the specified parameters. Casts are inserted to force
/// the types to the provided known types.
///
/// TODO: Remove RuleBuilder and knownTypes once we're fully meta
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="parameters">The explicit arguments</param>
/// <param name="knownTypes">If non-null, the type for each element in parameters</param>
/// <returns></returns>
internal Expression MakeExpression(ParameterBinder parameterBinder, IList <Expression> parameters, IList <Type> knownTypes)
{
Debug.Assert(knownTypes == null || parameters.Count == knownTypes.Count);
IList <Expression> args = parameters;
if (knownTypes != null)
{
args = new Expression[parameters.Count];
for (int i = 0; i < args.Count; i++)
{
args[i] = parameters[i];
if (knownTypes[i] != null && !knownTypes[i].IsAssignableFrom(parameters[i].Type))
{
args[i] = Ast.Convert(parameters[i], CompilerHelpers.GetVisibleType(knownTypes[i]));
}
}
}
return(MakeExpression(parameterBinder, args));
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList<Expression> parameters, bool[] hasBeenUsed) {
if (_tmp == null) {
_tmp = parameterBinder.GetTemporary(_elementType, "outParam");
}
hasBeenUsed[Index] = true;
Type boxType = typeof(StrongBox<>).MakeGenericType(_elementType);
return Expression.Condition(
Expression.TypeIs(parameters[Index], Type),
Expression.Assign(
_tmp,
Expression.Field(
AstUtils.Convert(parameters[Index], boxType),
boxType.GetField("Value")
)
),
Expression.Call(
typeof(RuntimeHelpers).GetMethod("IncorrectBoxType").MakeGenericMethod(_elementType),
AstUtils.Convert(parameters[Index], typeof(object))
)
);
}
internal override Expression ToExpression(ParameterBinder parameterBinder, IList <ArgBuilder> args, IList <Expression> parameters, Expression ret)
{
if (_returnArgs.Count == 1)
{
if (_returnArgs[0] == -1)
{
return(ret);
}
return(Ast.Block(ret, args[_returnArgs[0]].ToReturnExpression(parameterBinder)));
}
Expression[] retValues = new Expression[_returnArgs.Count];
int rIndex = 0;
bool usesRet = false;
foreach (int index in _returnArgs)
{
if (index == -1)
{
usesRet = true;
retValues[rIndex++] = ret;
}
else
{
retValues[rIndex++] = args[index].ToReturnExpression(parameterBinder);
}
}
Expression retArray = AstUtils.NewArrayHelper(typeof(object), retValues);
if (!usesRet)
{
retArray = Ast.Block(ret, retArray);
}
return(parameterBinder.Binder.GetByRefArrayExpression(retArray));
}
private DynamicMetaObject MakeMetaMethodCall(CallSignature signature, ParameterBinder parameterBinder, TargetInfo targetInfo) {
BindingRestrictions restrictions = BindingRestrictions.Combine(targetInfo.Arguments).Merge(targetInfo.Restrictions);
if (targetInfo.Instance != null) {
restrictions = targetInfo.Instance.Restrictions.Merge(restrictions);
}
if (targetInfo.Instance != null) {
return CallInstanceMethod(
parameterBinder,
targetInfo.Targets,
targetInfo.Instance,
targetInfo.Arguments,
signature,
restrictions
);
}
return CallMethod(
parameterBinder,
targetInfo.Targets,
targetInfo.Arguments,
signature,
restrictions);
}
private DynamicMetaObject CallWorker(ParameterBinder parameterBinder, IList<MethodBase> targets, IList<DynamicMetaObject> args, CallSignature signature, CallTypes callType, BindingRestrictions restrictions, NarrowingLevel minLevel, NarrowingLevel maxLevel, string name, out BindingTarget target) {
ContractUtils.RequiresNotNull(parameterBinder, "parameterBinder");
ContractUtils.RequiresNotNullItems(args, "args");
ContractUtils.RequiresNotNullItems(targets, "targets");
ContractUtils.RequiresNotNull(restrictions, "restrictions");
DynamicMetaObject[] finalArgs;
SymbolId[] argNames;
if (callType == CallTypes.ImplicitInstance) {
GetArgumentNamesAndTypes(signature, ArrayUtils.RemoveFirst(args), out argNames, out finalArgs);
finalArgs = ArrayUtils.Insert(args[0], finalArgs);
} else {
GetArgumentNamesAndTypes(signature, args, out argNames, out finalArgs);
}
// attempt to bind to an individual method
MethodBinder binder = MethodBinder.MakeBinder(
this,
name ?? GetTargetName(targets),
targets,
argNames,
minLevel,
maxLevel);
target = binder.MakeBindingTarget(callType, finalArgs);
if (target.Success) {
// if we succeed make the target for the rule
return new DynamicMetaObject(
target.MakeExpression(parameterBinder),
restrictions.Merge(MakeSplatTests(callType, signature, args).Merge(BindingRestrictions.Combine(target.RestrictedArguments)))
);
}
// make an error rule
return MakeInvalidParametersRule(callType, signature, this, args, restrictions, target);
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList<Expression> parameters, bool[] hasBeenUsed) {
Debug.Assert(BuilderExpectsSingleParameter(_builder));
int index = GetKeywordIndex(parameters.Count);
hasBeenUsed[index] = true;
return _builder.ToExpression(parameterBinder, new Expression[] { parameters[index] }, new bool[1]);
}
private static Expression ConvertToHelper(ParameterBinder parameterBinder, Expression value, Type type) {
if (type == value.Type) {
return value;
}
if (type.IsAssignableFrom(value.Type)) {
return AstUtils.Convert(value, type);
}
return parameterBinder.GetDynamicConversion(value, type);
}
internal Expression MakeExpression(ParameterBinder parameterBinder, IList <Expression> parameters)
{
bool[] usageMarkers;
Expression[] spilledArgs;
Expression[] args = GetArgumentExpressions(parameterBinder, parameters, out usageMarkers, out spilledArgs);
MethodBase mb = Method;
MethodInfo mi = mb as MethodInfo;
Expression ret, call;
if (!mb.IsPublic || (mb.DeclaringType != null && !mb.DeclaringType.IsVisible))
{
if (mi != null)
{
mi = CompilerHelpers.GetCallableMethod(mi, _binder._binder.PrivateBinding);
if (mi != null)
{
mb = mi;
}
}
}
ConstructorInfo ci = mb as ConstructorInfo;
Debug.Assert(mi != null || ci != null);
if (mb.IsPublic && (mb.DeclaringType == null || mb.DeclaringType.IsVisible))
{
// public method
if (mi != null)
{
Expression instance = mi.IsStatic ? null : _instanceBuilder.ToExpression(parameterBinder, parameters, usageMarkers);
call = AstUtils.SimpleCallHelper(instance, mi, args);
}
else
{
call = AstUtils.SimpleNewHelper(ci, args);
}
}
else
{
// Private binding, invoke via reflection
if (mi != null)
{
Expression instance = mi.IsStatic ? Ast.Constant(null) : _instanceBuilder.ToExpression(parameterBinder, parameters, usageMarkers);
Debug.Assert(instance != null, "Can't skip instance expression");
call = Ast.Call(
typeof(BinderOps).GetMethod("InvokeMethod"),
Ast.Constant(mi),
AstUtils.Convert(instance, typeof(object)),
AstUtils.NewArrayHelper(typeof(object), args)
);
}
else
{
call = Ast.Call(
typeof(BinderOps).GetMethod("InvokeConstructor"),
Ast.Constant(ci),
AstUtils.NewArrayHelper(typeof(object), args)
);
}
}
if (spilledArgs != null)
{
call = Expression.Block(spilledArgs.AddLast(call));
}
ret = _returnBuilder.ToExpression(parameterBinder, _argBuilders, parameters, call);
List <Expression> updates = null;
for (int i = 0; i < _argBuilders.Count; i++)
{
Expression next = _argBuilders[i].UpdateFromReturn(parameterBinder, parameters);
if (next != null)
{
if (updates == null)
{
updates = new List <Expression>();
}
updates.Add(next);
}
}
if (updates != null)
{
if (ret.Type != typeof(void))
{
ParameterExpression temp = Ast.Variable(ret.Type, "$ret");
updates.Insert(0, Ast.Assign(temp, ret));
updates.Add(temp);
ret = Ast.Block(new [] { temp }, updates.ToArray());
}
else
{
updates.Insert(0, ret);
ret = Ast.Convert(
Ast.Block(updates.ToArray()),
typeof(void)
);
}
}
if (parameterBinder.Temps != null)
{
ret = Ast.Block(parameterBinder.Temps, ret);
}
return(ret);
}
/// <summary> /// Provides the Expression which provides the value to be passed to the argument. /// If <c>null</c> is returned the argument is skipped (not passed to the callee). /// </summary> internal protected abstract Expression ToExpression(ParameterBinder parameterBinder, IList <Expression> parameters, bool[] hasBeenUsed);
/// <summary>
/// If the argument produces a return value (e.g. a ref or out value) this provides
/// the additional value to be returned.
/// </summary>
internal virtual Expression ToReturnExpression(ParameterBinder parameterBinder)
{
throw new InvalidOperationException();
}
/// <summary>
/// Performs binding against a set of overloaded methods using the specified arguments. The arguments are
/// consumed as specified by the CallSignature object.
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="targets">The methods to be called</param>
/// <param name="args">The arguments for the call</param>
/// <param name="signature">The call signature which specified how the arguments will be consumed</param>
/// <param name="restrictions">Additional restrictions which should be applied to the resulting MetaObject.</param>
/// <param name="maxLevel">The maximum narrowing level for arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <param name="minLevel">The minimum narrowing level for the arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <param name="target">The resulting binding target which can be used for producing error information.</param>
/// <param name="name">The name of the method or null to use the name from targets.</param>
/// <returns>A meta object which results from the call.</returns>
public DynamicMetaObject CallMethod(ParameterBinder parameterBinder, IList<MethodBase> targets, IList<DynamicMetaObject> args, CallSignature signature, BindingRestrictions restrictions, NarrowingLevel minLevel, NarrowingLevel maxLevel, string name, out BindingTarget target) {
return CallWorker(
parameterBinder,
targets,
args,
signature,
CallTypes.None,
restrictions,
minLevel,
maxLevel,
name,
out target
);
}
internal override Expression UpdateFromReturn(ParameterBinder parameterBinder, IList<Expression> parameters) {
return _builder.UpdateFromReturn(parameterBinder, new Expression[] { parameters[GetKeywordIndex(parameters.Count)] });
}
/// <summary>
/// Performs binding against a set of overloaded methods using the specified arguments and the specified
/// instance argument. The arguments are consumed as specified by the CallSignature object.
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="targets">The methods to be called</param>
/// <param name="args">The arguments for the call</param>
/// <param name="signature">The call signature which specified how the arguments will be consumed</param>
/// <param name="restrictions">Additional restrictions which should be applied to the resulting MetaObject.</param>
/// <param name="instance">The instance which will be provided for dispatching to an instance method.</param>
/// <param name="maxLevel">The maximum narrowing level for arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <param name="minLevel">The minimum narrowing level for the arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <param name="target">The resulting binding target which can be used for producing error information.</param>
/// <param name="name">The name of the method or null to use the name from targets.</param>
/// <returns>A meta object which results from the call.</returns>
public DynamicMetaObject CallInstanceMethod(ParameterBinder parameterBinder, IList<MethodBase> targets, DynamicMetaObject instance, IList<DynamicMetaObject> args, CallSignature signature, BindingRestrictions restrictions, NarrowingLevel minLevel, NarrowingLevel maxLevel, string name, out BindingTarget target) {
return CallWorker(
parameterBinder,
targets,
ArrayUtils.Insert(instance, args),
signature,
CallTypes.ImplicitInstance,
restrictions,
minLevel,
maxLevel,
name,
out target
);
}
protected override Expression ToExpression(ParameterBinder/*!*/ parameterBinder, IList<Expression>/*!*/ parameters, bool[]/*!*/ hasBeenUsed) {
return AstUtils.Constant(Activator.CreateInstance(ParameterInfo.ParameterType, ((RubyParameterBinder)parameterBinder).Context));
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList <Expression> parameters, bool[] hasBeenUsed)
{
return(Expression.Constant(Activator.CreateInstance(ParameterInfo.ParameterType)));
}
internal override Expression ToExpression(ParameterBinder parameterBinder, IList <ArgBuilder> args, IList <Expression> parameters, Expression ret)
{
List <Expression> sets = new List <Expression>();
ParameterExpression tmp = parameterBinder.GetTemporary(ret.Type, "val");
sets.Add(
Ast.Assign(tmp, ret)
);
for (int i = 0; i < _indexesUsed.Length; i++)
{
Expression value = parameters[parameters.Count - _kwArgCount + _indexesUsed[i]];
switch (_membersSet[i].MemberType)
{
case MemberTypes.Field:
FieldInfo fi = (FieldInfo)_membersSet[i];
if (!fi.IsLiteral && !fi.IsInitOnly)
{
sets.Add(
Ast.Assign(
Ast.Field(tmp, fi),
ConvertToHelper(parameterBinder, value, fi.FieldType)
)
);
}
else
{
// call a helper which throws the error but "returns object"
sets.Add(
Ast.Convert(
Ast.Call(
typeof(ScriptingRuntimeHelpers).GetMethod("ReadOnlyAssignError"),
Ast.Constant(true),
Ast.Constant(fi.Name)
),
fi.FieldType
)
);
}
break;
case MemberTypes.Property:
PropertyInfo pi = (PropertyInfo)_membersSet[i];
if (pi.GetSetMethod(_privateBinding) != null)
{
sets.Add(
Ast.Assign(
Ast.Property(tmp, pi),
ConvertToHelper(parameterBinder, value, pi.PropertyType)
)
);
}
else
{
// call a helper which throws the error but "returns object"
sets.Add(
Ast.Convert(
Ast.Call(
typeof(ScriptingRuntimeHelpers).GetMethod("ReadOnlyAssignError"),
Ast.Constant(false),
Ast.Constant(pi.Name)
),
pi.PropertyType
)
);
}
break;
}
}
sets.Add(
tmp
);
Expression newCall = Ast.Block(
sets.ToArray()
);
return(_builder.ToExpression(parameterBinder, args, parameters, newCall));
}
private DynamicMetaObject CallWorker(ParameterBinder parameterBinder, IList<MethodBase> targets, IList<DynamicMetaObject> args, CallSignature signature, CallTypes callType, BindingRestrictions restrictions, NarrowingLevel minLevel, NarrowingLevel maxLevel, string name) {
BindingTarget dummy;
return CallWorker(parameterBinder, targets, args, signature, callType, restrictions, minLevel, maxLevel, name, out dummy);
}
internal virtual Expression ToExpression(ParameterBinder parameterBinder, IList <ArgBuilder> args, IList <Expression> parameters, Expression ret)
{
return(ret);
}
/// <summary>
/// Performs binding against a set of overloaded methods using the specified arguments and the specified
/// instance argument. The arguments are consumed as specified by the CallSignature object.
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="targets">The methods to be called</param>
/// <param name="args">The arguments for the call</param>
/// <param name="instance">The instance which will be provided for dispatching to an instance method.</param>
/// <param name="signature">The call signature which specified how the arguments will be consumed</param>
/// <param name="restrictions">Additional restrictions which should be applied to the resulting MetaObject.</param>
/// <returns>A meta object which results from the call.</returns>
public DynamicMetaObject CallInstanceMethod(ParameterBinder parameterBinder, IList<MethodBase> targets, DynamicMetaObject instance, IList<DynamicMetaObject> args, CallSignature signature, BindingRestrictions restrictions) {
ContractUtils.RequiresNotNull(instance, "instance");
ContractUtils.RequiresNotNull(parameterBinder, "parameterBinder");
return CallWorker(
parameterBinder,
targets,
ArrayUtils.Insert(instance, args),
signature,
CallTypes.ImplicitInstance,
restrictions,
NarrowingLevel.None,
NarrowingLevel.All,
null
);
}
internal override Expression ToReturnExpression(ParameterBinder parameterBinder) {
return _builder.ToReturnExpression(parameterBinder);
}
protected internal override Func<object[], object> ToDelegate(ParameterBinder parameterBinder, IList<DynamicMetaObject> knownTypes, bool[] hasBeenUsed) {
string[] names = _names;
int[] indexes = GetParameters(hasBeenUsed);
return (args) => {
object[] values = new object[indexes.Length];
for (int i = 0; i < indexes.Length; i++) {
values[i] = args[indexes[i] + 1];
}
return BinderOps.MakeSymbolDictionary(names, values);
};
}
internal override Expression UpdateFromReturn(ParameterBinder parameterBinder, IList <Expression> parameters)
{
return(_builder.UpdateFromReturn(parameterBinder, new Expression[] { parameters[GetKeywordIndex(parameters.Count)] }));
}
internal override Expression ToReturnExpression(ParameterBinder parameterBinder)
{
return(_tmp);
}
/// <summary>
/// Provides an Expression which will update the provided value after a call to the method. May
/// return null if no update is required.
/// </summary>
internal virtual Expression UpdateFromReturn(ParameterBinder parameterBinder, IList <Expression> parameters)
{
return(null);
}
protected override Expression ToExpression(ParameterBinder/*!*/ parameterBinder, IList<Expression>/*!*/ parameters, bool[]/*!*/ hasBeenUsed) {
return ((RubyParameterBinder)parameterBinder).ScopeExpression;
}
internal override Expression ToReturnExpression(ParameterBinder parameterBinder)
{
return(_builder.ToReturnExpression(parameterBinder));
}
protected override Expression ToExpression(ParameterBinder/*!*/ parameterBinder, IList<Expression>/*!*/ parameters, bool[]/*!*/ hasBeenUsed) {
Debug.Assert(Index < parameters.Count);
Debug.Assert(Index < hasBeenUsed.Length);
Debug.Assert(parameters[Index] != null);
hasBeenUsed[Index] = true;
return null;
}
internal override Expression ToExpression(ParameterBinder parameterBinder, IList<ArgBuilder> args, IList<Expression> parameters, Expression ret) {
List<Expression> sets = new List<Expression>();
ParameterExpression tmp = parameterBinder.GetTemporary(ret.Type, "val");
sets.Add(
Ast.Assign(tmp, ret)
);
for (int i = 0; i < _indexesUsed.Length; i++) {
Expression value = parameters[parameters.Count - _kwArgCount + _indexesUsed[i]];
switch(_membersSet[i].MemberType) {
case MemberTypes.Field:
FieldInfo fi = (FieldInfo)_membersSet[i];
if (!fi.IsLiteral && !fi.IsInitOnly) {
sets.Add(
Ast.Assign(
Ast.Field(tmp, fi),
ConvertToHelper(parameterBinder, value, fi.FieldType)
)
);
} else {
// call a helper which throws the error but "returns object"
sets.Add(
Ast.Convert(
Ast.Call(
typeof(ScriptingRuntimeHelpers).GetMethod("ReadOnlyAssignError"),
Ast.Constant(true),
Ast.Constant(fi.Name)
),
fi.FieldType
)
);
}
break;
case MemberTypes.Property:
PropertyInfo pi = (PropertyInfo)_membersSet[i];
if (pi.GetSetMethod(_privateBinding) != null) {
sets.Add(
Ast.Assign(
Ast.Property(tmp, pi),
ConvertToHelper(parameterBinder, value, pi.PropertyType)
)
);
} else {
// call a helper which throws the error but "returns object"
sets.Add(
Ast.Convert(
Ast.Call(
typeof(ScriptingRuntimeHelpers).GetMethod("ReadOnlyAssignError"),
Ast.Constant(false),
Ast.Constant(pi.Name)
),
pi.PropertyType
)
);
}
break;
}
}
sets.Add(
tmp
);
Expression newCall = Ast.Block(
sets.ToArray()
);
return _builder.ToExpression(parameterBinder, args, parameters, newCall);
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList <Expression> parameters, bool[] hasBeenUsed)
{
return(((ParameterBinderWithCodeContext)parameterBinder).ContextExpression);
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList <Expression> parameters, bool[] hasBeenUsed)
{
return(Ast.Constant(null));
}
internal protected override Expression ToExpression(ParameterBinder parameterBinder, IList<Expression> parameters, bool[] hasBeenUsed) {
return Ast.Constant(null);
}
