public override DefaultOverloadResolver CreateOverloadResolver(IList <DynamicMetaObject> args, CallSignature signature, CallTypes callType)
{
return(new DefaultOverloadResolver(_binder, args, signature, callType));
}
// instance method call:
public DefaultOverloadResolver(ActionBinder binder, DynamicMetaObject instance, IList <DynamicMetaObject> args, CallSignature signature)
: this(binder, ArrayUtils.Insert(instance, args), signature, CallTypes.ImplicitInstance)
{
}
protected InvokeMemberAction(SymbolId memberName, InvokeMemberActionFlags flags, CallSignature signature)
: base(memberName)
{
_flags = flags;
_signature = signature;
}
public static InvokeMemberAction Make(SymbolId memberName, InvokeMemberActionFlags flags, CallSignature signature)
{
return(new InvokeMemberAction(memberName, flags, signature));
}
/// <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 MetaObject CallInstanceMethod(ParameterBinder parameterBinder, IList <MethodBase> targets, MetaObject instance, IList <MetaObject> args, CallSignature signature, Restrictions 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
));
}
public static new CreateInstanceAction Make(CallSignature signature)
{
return(new CreateInstanceAction(signature));
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")] // TODO: fix
private static MetaObject[] GetArgumentTypes(CallSignature signature, IList <MetaObject> args)
{
List <MetaObject> res = new List <MetaObject>();
List <MetaObject> namedObjects = null;
for (int i = 0; i < args.Count; i++)
{
switch (signature.GetArgumentKind(i))
{
case ArgumentType.Named:
if (namedObjects == null)
{
namedObjects = new List <MetaObject>();
}
namedObjects.Add(args[i]);
break;
case ArgumentType.Simple:
case ArgumentType.Instance:
res.Add(args[i]);
break;
case ArgumentType.List:
IList <object> list = args[i].Value as IList <object>;
if (list == null)
{
return(null);
}
for (int j = 0; j < list.Count; j++)
{
res.Add(
new MetaObject(
Ast.Call(
Ast.Convert(
args[i].Expression,
typeof(IList <object>)
),
typeof(IList <object>).GetMethod("get_Item"),
Ast.Constant(j)
),
args[i].Restrictions,
list[j]
)
);
}
break;
case ArgumentType.Dictionary:
// caller needs to process these...
break;
default:
throw new NotImplementedException();
}
}
if (namedObjects != null)
{
res.AddRange(namedObjects);
}
return(res.ToArray());
}
protected OldCreateInstanceAction(ActionBinder binder, CallSignature callSignature)
: base(binder, callSignature)
{
}
private MetaObject CallWorker(ParameterBinder parameterBinder, IList <MethodBase> targets, IList <MetaObject> args, CallSignature signature, CallTypes callType, Restrictions 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");
MetaObject[] 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 MetaObject(
target.MakeExpression(parameterBinder),
restrictions.Merge(MakeSplatTests(callType, signature, args).Merge(Restrictions.Combine(target.RestrictedArguments)))
));
}
// make an error rule
return(MakeInvalidParametersRule(callType, signature, this, args, restrictions, target));
}
private static Restrictions MakeSplatTests(CallTypes callType, CallSignature signature, IList <MetaObject> args)
{
return(MakeSplatTests(callType, signature, false, args));
}
private MetaObject CallWorker(ParameterBinder parameterBinder, IList <MethodBase> targets, IList <MetaObject> args, CallSignature signature, CallTypes callType, Restrictions restrictions, NarrowingLevel minLevel, NarrowingLevel maxLevel, string name)
{
BindingTarget dummy;
return(CallWorker(parameterBinder, targets, args, signature, callType, restrictions, minLevel, maxLevel, name, out dummy));
}
/// <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 MetaObject CallInstanceMethod(ParameterBinder parameterBinder, IList <MethodBase> targets, MetaObject instance, IList <MetaObject> args, CallSignature signature, Restrictions 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
));
}
/// <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 MetaObject CallMethod(ParameterBinder parameterBinder, IList <MethodBase> targets, IList <MetaObject> args, CallSignature signature, Restrictions restrictions, NarrowingLevel minLevel, NarrowingLevel maxLevel, string name, out BindingTarget target)
{
return(CallWorker(
parameterBinder,
targets,
args,
signature,
CallTypes.None,
restrictions,
minLevel,
maxLevel,
name,
out target
));
}
// method call:
public DefaultOverloadResolver(ActionBinder binder, IList <DynamicMetaObject> args, CallSignature signature)
: this(binder, args, signature, CallTypes.None)
{
}
/// <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>
/// <returns>A meta object which results from the call.</returns>
public MetaObject CallMethod(ParameterBinder parameterBinder, IList <MethodBase> targets, IList <MetaObject> args, CallSignature signature)
{
return(CallMethod(parameterBinder, targets, args, signature, Restrictions.Empty));
}
public DefaultOverloadResolver(ActionBinder binder, IList <DynamicMetaObject> args, CallSignature signature, CallTypes callType)
: base(binder)
{
ContractUtils.RequiresNotNullItems(args, nameof(args));
Debug.Assert((callType == CallTypes.ImplicitInstance ? 1 : 0) + signature.ArgumentCount == args.Count);
_args = args;
_signature = signature;
_callType = callType;
}
protected CreateInstanceAction(CallSignature callSignature)
: base(callSignature)
{
}
public static new OldCreateInstanceAction Make(ActionBinder binder, CallSignature signature)
{
return(new OldCreateInstanceAction(binder, signature));
}
/// <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="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 MetaObject CallMethod(ParameterBinder parameterBinder, IList <MethodBase> targets, IList <MetaObject> args, CallSignature signature, Restrictions restrictions, string name)
{
return(CallWorker(
parameterBinder,
targets,
args,
signature,
CallTypes.None,
restrictions,
NarrowingLevel.None,
NarrowingLevel.All,
name
));
}
