public KeywordArgBuilder(ArgBuilder builder, int kwArgCount, int kwArgIndex) : base(builder.ParameterInfo) { Debug.Assert(BuilderExpectsSingleParameter(builder)); _builder = builder; Debug.Assert(kwArgIndex < kwArgCount); _kwArgCount = kwArgCount; _kwArgIndex = kwArgIndex; }
/// <summary> /// The underlying builder should expect a single parameter as KeywordArgBuilder is responsible /// for calculating the correct parameter to use /// </summary> /// <param name="builder"></param> internal static bool BuilderExpectsSingleParameter(ArgBuilder builder) { return (((SimpleArgBuilder)builder).Index == 0); }
private MethodCandidate MakeParamsExtended(string[] names, int[] nameIndices, List <ParameterWrapper> parameters) { Debug.Assert(Overload.IsVariadic); List <ArgBuilder> newArgBuilders = new List <ArgBuilder>(ArgBuilders.Count); // current argument that we consume, initially skip this if we have it. int curArg = Overload.IsStatic ? 0 : 1; int kwIndex = -1; ArgBuilder paramsDictBuilder = null; foreach (ArgBuilder ab in ArgBuilders) { // TODO: define a virtual method on ArgBuilder implementing this functionality: if (ab is SimpleArgBuilder sab) { // we consume one or more incoming argument(s) if (sab.IsParamsArray) { // consume all the extra arguments int paramsUsed = parameters.Count - GetConsumedArguments() - names.Length + (Overload.IsStatic ? 1 : 0); newArgBuilders.Add(new ParamsArgBuilder( sab.ParameterInfo, sab.Type.GetElementType(), curArg, paramsUsed )); curArg += paramsUsed; } else if (sab.IsParamsDict) { // consume all the kw arguments kwIndex = newArgBuilders.Count; paramsDictBuilder = sab; } else { // consume the argument, adjust its position: newArgBuilders.Add(sab.MakeCopy(curArg++)); } } else if (ab is KeywordArgBuilder) { newArgBuilders.Add(ab); curArg++; } else { // CodeContext, null, default, etc... we don't consume an // actual incoming argument. newArgBuilders.Add(ab); } } if (kwIndex != -1) { newArgBuilders.Insert(kwIndex, new ParamsDictArgBuilder(paramsDictBuilder.ParameterInfo, curArg, names, nameIndices)); } return(new MethodCandidate(Resolver, Overload, parameters, null, ReturnBuilder, _instanceBuilder, newArgBuilders, null)); }
/// <summary> /// The underlying builder should expect a single parameter as KeywordArgBuilder is responsible /// for calculating the correct parameter to use /// </summary> /// <param name="builder"></param> internal static bool BuilderExpectsSingleParameter(ArgBuilder builder) { return(((SimpleArgBuilder)builder).Index == 0); }
internal MethodTarget(MethodBinder binder, MethodBase method, int parameterCount, ArgBuilder instanceBuilder, IList <ArgBuilder> argBuilders, ReturnBuilder returnBuilder) { this._binder = binder; this._method = method; this._parameterCount = parameterCount; this._instanceBuilder = instanceBuilder; this._argBuilders = argBuilders; this._returnBuilder = returnBuilder; //argBuilders.TrimExcess(); }
internal MethodTarget MakeParamsExtended(int argCount, SymbolId[] names, int[] nameIndexes) { Debug.Assert(BinderHelpers.IsParamsMethod(Method)); List <ArgBuilder> newArgBuilders = new List <ArgBuilder>(_argBuilders.Count); // current argument that we consume, initially skip this if we have it. int curArg = CompilerHelpers.IsStatic(_method) ? 0 : 1; int kwIndex = -1; ArgBuilder paramsDictBuilder = null; foreach (ArgBuilder ab in _argBuilders) { SimpleArgBuilder sab = ab as SimpleArgBuilder; if (sab != null) { // we consume one or more incoming argument(s) if (sab.IsParamsArray) { // consume all the extra arguments int paramsUsed = argCount - GetConsumedArguments() - names.Length + (CompilerHelpers.IsStatic(_method) ? 1 : 0); newArgBuilders.Add(new ParamsArgBuilder( sab.ParameterInfo, sab.Type.GetElementType(), curArg, paramsUsed )); curArg += paramsUsed; } else if (sab.IsParamsDict) { // consume all the kw arguments kwIndex = newArgBuilders.Count; paramsDictBuilder = sab; } else { // consume the argument, adjust its position: newArgBuilders.Add(sab.MakeCopy(curArg++)); } } else { // CodeContext, null, default, etc... we don't consume an // actual incoming argument. newArgBuilders.Add(ab); } } if (kwIndex != -1) { newArgBuilders.Insert(kwIndex, new ParamsDictArgBuilder(paramsDictBuilder.ParameterInfo, curArg, names, nameIndexes)); } return(new MethodTarget(_binder, Method, argCount, _instanceBuilder, newArgBuilders, _returnBuilder)); }