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); }