public static ParameterAssignment Bind(MethodBase method, string parameter, Expression expression)
{
// NB: This overload is needed for the compiler to emit factory calls;
// we can't emit a `ldtoken` instruction to obtain a ParameterInfo.
ContractUtils.RequiresNotNull(method, nameof(method));
ContractUtils.RequiresNotNull(parameter, nameof(parameter));
var parameterInfo = default(ParameterInfo);
foreach (var candidate in method.GetParametersCached())
{
if (candidate.Name == parameter)
{
parameterInfo = candidate;
break;
}
}
if (parameterInfo == null)
{
throw Error.ParameterNotDefinedForMethod(parameter, method.Name);
}
return Bind(parameterInfo, expression);
}
private static bool IsCompatible(MethodBase m, Expression[] args)
{
ParameterInfo[] parms = m.GetParametersCached();
if (parms.Length != args.Length)
return false;
for (int i = 0; i < args.Length; i++)
{
Expression arg = args[i];
ContractUtils.RequiresNotNull(arg, "argument");
Type argType = arg.Type;
Type pType = parms[i].ParameterType;
if (pType.IsByRef)
{
pType = pType.GetElementType();
}
if (!TypeUtils.AreReferenceAssignable(pType, argType) &&
!(TypeUtils.IsSameOrSubclass(typeof(LambdaExpression), pType) && pType.IsAssignableFrom(arg.GetType())))
{
return false;
}
}
return true;
}
/// <summary>
/// Emits arguments to a call, and returns an array of write-backs that
/// should happen after the call. For emitting dynamic expressions, we
/// need to skip the first parameter of the method (the call site).
/// </summary>
private List<WriteBack> EmitArguments(MethodBase method, IArgumentProvider args, int skipParameters)
{
ParameterInfo[] pis = method.GetParametersCached();
Debug.Assert(args.ArgumentCount + skipParameters == pis.Length);
var writeBacks = new List<WriteBack>();
for (int i = skipParameters, n = pis.Length; i < n; i++)
{
ParameterInfo parameter = pis[i];
Expression argument = args.GetArgument(i - skipParameters);
Type type = parameter.ParameterType;
if (type.IsByRef)
{
type = type.GetElementType();
WriteBack wb = EmitAddressWriteBack(argument, type);
if (wb != null)
{
writeBacks.Add(wb);
}
}
else
{
EmitExpression(argument);
}
}
return writeBacks;
}
private static ParameterInfo[] GetParametersForValidation(MethodBase method, ExpressionType nodeKind) {
ParameterInfo[] pis = method.GetParametersCached();
if (nodeKind == ExpressionType.Dynamic) {
pis = pis.RemoveFirst(); // ignore CallSite argument
}
return pis;
}
/// <summary>
/// Marks child expressions representing arguments bound to parameters of
/// the specified <paramref name="method"/> as ByRef values if needed.
/// </summary>
/// <param name="method">
/// The method containing the parameters bound to the arguments held by
/// child expressions tracked by this rewriter.
/// </param>
/// <param name="startIndex">
/// The index of the child expression representing the first argument. This
/// value is typically 0 for static methods and 1 for instance methods.
/// </param>
internal void MarkRefArgs(MethodBase method, int startIndex)
{
var parameters = method.GetParametersCached();
for (int i = 0, n = parameters.Length; i < n; i++)
{
if (parameters[i].ParameterType.IsByRef)
{
MarkRef(startIndex + i);
}
}
}
public static ReadOnlyCollection<ParameterAssignment> GetParameterBindings(MethodBase method, IEnumerable<Expression> expressions)
{
return GetParameterBindings(method.GetParametersCached(), expressions);
}
public static void ValidateParameterBindings(MethodBase method, ReadOnlyCollection<ParameterAssignment> argList, bool extensionMethod = false)
{
ValidateParameterBindings(method, method.GetParametersCached(), argList, extensionMethod);
}
