|
static private IncorrectNumberOfMethodCallArguments ( object p0, string paramName ) : |
||
| p0 | object | |
| paramName | string | |
| return | ||
private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection <Expression> arguments)
{
if (indexes.Length > 0)
{
if (indexes.Length != arguments.Count)
{
throw Error.IncorrectNumberOfMethodCallArguments(method);
}
Expression[] newArgs = null;
var n = indexes.Length;
for (var i = 0; i < n; i++)
{
var arg = arguments[i];
var pi = indexes[i];
RequiresCanRead(arg, "arguments");
var pType = pi.ParameterType;
if (pType.IsByRef)
{
throw Error.AccessorsCannotHaveByRefArgs();
}
TypeHelper.ValidateType(pType);
if (!TypeHelper.AreReferenceAssignable(pType, arg.Type))
{
if (!TryQuote(pType, ref arg))
{
throw Error.ExpressionTypeDoesNotMatchMethodParameter(arg.Type, pType, method);
}
}
if (newArgs == null && arg != arguments[i])
{
newArgs = new Expression[arguments.Count];
for (var j = 0; j < i; j++)
{
newArgs[j] = arguments[j];
}
}
if (newArgs != null)
{
newArgs[i] = arg;
}
}
if (newArgs != null)
{
arguments = new TrueReadOnlyCollection <Expression>(newArgs);
}
}
else if (arguments.Count > 0)
{
throw Error.IncorrectNumberOfMethodCallArguments(method);
}
}
private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref Expression[] arguments, string paramName)
{
if (indexes.Length > 0)
{
if (indexes.Length != arguments.Length)
{
throw Error.IncorrectNumberOfMethodCallArguments(method, paramName);
}
Expression[] newArgs = null;
for (int i = 0, n = indexes.Length; i < n; i++)
{
var arg = arguments[i];
var pi = indexes[i];
ExpressionUtils.RequiresCanRead(arg, nameof(arguments), i);
var pType = pi.ParameterType;
if (pType.IsByRef)
{
throw Error.AccessorsCannotHaveByRefArgs(nameof(indexes), i);
}
TypeUtils.ValidateType(pType, nameof(indexes), i);
if (!pType.IsReferenceAssignableFromInternal(arg.Type))
{
if (!TryQuote(pType, ref arg))
{
throw Error.ExpressionTypeDoesNotMatchMethodParameter(arg.Type, pType, method, nameof(arguments), i);
}
}
if (newArgs == null && arg != arguments[i])
{
newArgs = new Expression[arguments.Length];
for (var j = 0; j < i; j++)
{
newArgs[j] = arguments[j];
}
}
if (newArgs != null)
{
newArgs[i] = arg;
}
}
if (newArgs != null)
{
arguments = newArgs;
}
}
else if (arguments.Length > 0)
{
throw Error.IncorrectNumberOfMethodCallArguments(method, paramName);
}
}
private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection <Expression> arguments)
{
if (indexes.Length > 0)
{
if (indexes.Length != arguments.Count)
{
throw Error.IncorrectNumberOfMethodCallArguments(method);
}
Expression[] newArgs = null;
for (int i = 0, n = indexes.Length; i < n; i++)
{
Expression arg = arguments[i];
ParameterInfo pi = indexes[i];
RequiresCanRead(arg, "arguments");
Type pType = pi.ParameterType;
ContractUtils.Requires(!pType.IsByRef, "indexes", Strings.AccessorsCannotHaveByRefArgs);
TypeUtils.ValidateType(pType);
if (!TypeUtils.AreReferenceAssignable(pType, arg.Type))
{
if (TypeUtils.IsSameOrSubclass(typeof(Expression), pType) && pType.IsAssignableFrom(arg.GetType()))
{
arg = Expression.Quote(arg);
}
else
{
throw Error.ExpressionTypeDoesNotMatchMethodParameter(arg.Type, pType, method);
}
}
if (newArgs == null && arg != arguments[i])
{
newArgs = new Expression[arguments.Count];
for (int j = 0; j < i; j++)
{
newArgs[j] = arguments[j];
}
}
if (newArgs != null)
{
newArgs[i] = arg;
}
}
if (newArgs != null)
{
arguments = new ReadOnlyCollection <Expression>(newArgs);
}
}
else if (arguments.Count > 0)
{
throw Error.IncorrectNumberOfMethodCallArguments(method);
}
}
private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection <Expression> arguments, string?paramName)
{
if (indexes.Length > 0)
{
if (indexes.Length != arguments.Count)
{
throw Error.IncorrectNumberOfMethodCallArguments(method, paramName);
}
Expression[]? newArgs = null;
for (int i = 0, n = indexes.Length; i < n; i++)
{
Expression arg = arguments[i];
ParameterInfo pi = indexes[i];
ExpressionUtils.RequiresCanRead(arg, nameof(arguments), i);
Type pType = pi.ParameterType;
if (pType.IsByRef)
{
throw Error.AccessorsCannotHaveByRefArgs(nameof(indexes), i);
}
TypeUtils.ValidateType(pType, nameof(indexes), i);
if (!TypeUtils.AreReferenceAssignable(pType, arg.Type))
{
if (!TryQuote(pType, ref arg))
{
throw Error.ExpressionTypeDoesNotMatchMethodParameter(arg.Type, pType, method, nameof(arguments), i);
}
}
if (newArgs == null && arg != arguments[i])
{
newArgs = new Expression[arguments.Count];
for (int j = 0; j < i; j++)
{
newArgs[j] = arguments[j];
}
}
if (newArgs != null)
{
newArgs[i] = arg;
}
}
if (newArgs != null)
{
arguments = new TrueReadOnlyCollection <Expression>(newArgs);
}
}
else if (arguments.Count > 0)
{
throw Error.IncorrectNumberOfMethodCallArguments(method, paramName);
}
}
public static MemberExpression Property(Expression expression, PropertyInfo property)
{
ContractUtils.RequiresNotNull(property, nameof(property));
var mi = property.GetGetMethod(nonPublic: true);
if (mi == null)
{
mi = property.GetSetMethod(nonPublic: true);
if (mi == null)
{
throw Error.PropertyDoesNotHaveAccessor(property, nameof(property));
}
if (mi.GetParameters().Length != 1)
{
throw Error.IncorrectNumberOfMethodCallArguments(mi, nameof(property));
}
}
else if (mi.GetParameters().Length != 0)
{
throw Error.IncorrectNumberOfMethodCallArguments(mi, nameof(property));
}
if (mi.IsStatic)
{
if (expression != null)
{
throw Error.OnlyStaticPropertiesHaveNullInstance(nameof(expression));
}
}
else
{
if (expression == null)
{
throw Error.OnlyStaticPropertiesHaveNullInstance(nameof(property));
}
ExpressionUtils.RequiresCanRead(expression, nameof(expression));
if (!TypeUtils.IsValidInstanceType(property, expression.Type))
{
throw Error.PropertyNotDefinedForType(property, expression.Type, nameof(property));
}
}
ValidateMethodInfo(mi, nameof(property));
return(MemberExpression.Make(expression, property));
}
public static MemberExpression Property(Expression expression, PropertyInfo property)
{
ContractUtils.RequiresNotNull(property, "property");
MethodInfo mi = property.GetGetMethod(true);
if (mi == null)
{
mi = property.GetSetMethod(true);
if (mi == null)
{
throw Error.PropertyDoesNotHaveAccessor(property);
}
else if (mi.GetParametersCached().Length != 1)
{
throw Error.IncorrectNumberOfMethodCallArguments(mi);
}
}
else if (mi.GetParametersCached().Length != 0)
{
throw Error.IncorrectNumberOfMethodCallArguments(mi);
}
if (mi.IsStatic)
{
if (expression != null)
{
throw new ArgumentException(Strings.OnlyStaticPropertiesHaveNullInstance, "expression");
}
}
else
{
if (expression == null)
{
throw new ArgumentException(Strings.OnlyStaticPropertiesHaveNullInstance, "property");
}
RequiresCanRead(expression, "expression");
if (!TypeUtils.IsValidInstanceType(property, expression.Type))
{
throw Error.PropertyNotDefinedForType(property, expression.Type);
}
}
return(MemberExpression.Make(expression, property));
}
private static Type ValidateConversion(CSharpExpressionType nodeType, Type inputType, LambdaExpression conversion)
{
var invoke = conversion.Type.GetMethod("Invoke");
var invokeParameters = invoke.GetParametersCached();
if (invokeParameters.Length != 1)
{
throw LinqError.IncorrectNumberOfMethodCallArguments(conversion);
}
if (!TypeUtils.AreEquivalent(invokeParameters[0].ParameterType, inputType))
{
throw LinqError.OperandTypesDoNotMatchParameters(nodeType, conversion.ToString());
}
return(invoke.ReturnType);
}
//CONFORMING
private static UnaryExpression GetMethodBasedCoercionOperator(ExpressionType unaryType, Expression operand, Type convertToType, MethodInfo method)
{
System.Diagnostics.Debug.Assert(method != null);
ValidateOperator(method);
ParameterInfo[] pms = method.GetParametersCached();
if (pms.Length != 1)
{
throw Error.IncorrectNumberOfMethodCallArguments(method);
}
if (ParameterIsAssignable(pms[0], operand.Type) && method.ReturnType == convertToType)
{
return(new UnaryExpression(unaryType, operand, method.ReturnType, method));
}
// check for lifted call
if ((TypeUtils.IsNullableType(operand.Type) || TypeUtils.IsNullableType(convertToType)) &&
ParameterIsAssignable(pms[0], TypeUtils.GetNonNullableType(operand.Type)) &&
method.ReturnType == TypeUtils.GetNonNullableType(convertToType))
{
return(new UnaryExpression(unaryType, operand, convertToType, method));
}
throw Error.OperandTypesDoNotMatchParameters(unaryType, method.Name);
}
private static void ValidateArgumentCount(MethodBase method, ExpressionType nodeKind, int count, ParameterInfo[] pis)
{
if (pis.Length != count)
{
// TODO: this is for LinqV1 compat, can we just have one exception?
switch (nodeKind)
{
case ExpressionType.New:
throw Error.IncorrectNumberOfConstructorArguments();
case ExpressionType.Invoke:
throw Error.IncorrectNumberOfLambdaArguments();
case ExpressionType.Dynamic:
case ExpressionType.Call:
throw Error.IncorrectNumberOfMethodCallArguments(method);
default:
throw Assert.Unreachable;
}
}
}
/// <summary>
/// Creates a <see cref="SwitchExpression"/>.
/// </summary>
/// <param name="type">The result type of the switch.</param>
/// <param name="switchValue">The value to be tested against each case.</param>
/// <param name="defaultBody">The result of the switch if no cases are matched.</param>
/// <param name="comparison">The equality comparison method to use.</param>
/// <param name="cases">The valid cases for this switch.</param>
/// <returns>The created <see cref="SwitchExpression"/>.</returns>
public static SwitchExpression Switch(Type type, Expression switchValue, Expression defaultBody, MethodInfo comparison, IEnumerable <SwitchCase> cases)
{
RequiresCanRead(switchValue, nameof(switchValue));
if (switchValue.Type == typeof(void))
{
throw Error.ArgumentCannotBeOfTypeVoid();
}
var caseList = cases.ToReadOnly();
ContractUtils.RequiresNotNullItems(caseList, nameof(cases));
// Type of the result. Either provided, or it is type of the branches.
Type resultType;
if (type != null)
{
resultType = type;
}
else if (caseList.Count != 0)
{
resultType = caseList[0].Body.Type;
}
else if (defaultBody != null)
{
resultType = defaultBody.Type;
}
else
{
resultType = typeof(void);
}
bool customType = type != null;
if (comparison != null)
{
var pms = comparison.GetParametersCached();
if (pms.Length != 2)
{
throw Error.IncorrectNumberOfMethodCallArguments(comparison);
}
// Validate that the switch value's type matches the comparison method's
// left hand side parameter type.
var leftParam = pms[0];
bool liftedCall = false;
if (!ParameterIsAssignable(leftParam, switchValue.Type))
{
liftedCall = ParameterIsAssignable(leftParam, switchValue.Type.GetNonNullableType());
if (!liftedCall)
{
throw Error.SwitchValueTypeDoesNotMatchComparisonMethodParameter(switchValue.Type, leftParam.ParameterType);
}
}
var rightParam = pms[1];
foreach (var c in caseList)
{
ContractUtils.RequiresNotNull(c, nameof(cases));
ValidateSwitchCaseType(c.Body, customType, resultType, nameof(cases));
for (int i = 0; i < c.TestValues.Count; i++)
{
// When a comparison method is provided, test values can have different type but have to
// be reference assignable to the right hand side parameter of the method.
Type rightOperandType = c.TestValues[i].Type;
if (liftedCall)
{
if (!rightOperandType.IsNullableType())
{
throw Error.TestValueTypeDoesNotMatchComparisonMethodParameter(rightOperandType, rightParam.ParameterType);
}
rightOperandType = rightOperandType.GetNonNullableType();
}
if (!ParameterIsAssignable(rightParam, rightOperandType))
{
throw Error.TestValueTypeDoesNotMatchComparisonMethodParameter(rightOperandType, rightParam.ParameterType);
}
}
}
}
else if (caseList.Count != 0)
{
// When comparison method is not present, all the test values must have
// the same type. Use the first test value's type as the baseline.
var firstTestValue = caseList[0].TestValues[0];
foreach (var c in caseList)
{
ContractUtils.RequiresNotNull(c, nameof(cases));
ValidateSwitchCaseType(c.Body, customType, resultType, nameof(cases));
// When no comparison method is provided, require all test values to have the same type.
for (int i = 0; i < c.TestValues.Count; i++)
{
if (!TypeUtils.AreEquivalent(firstTestValue.Type, c.TestValues[i].Type))
{
throw new ArgumentException(Strings.AllTestValuesMustHaveSameType, nameof(cases));
}
}
}
// Now we need to validate that switchValue.Type and testValueType
// make sense in an Equal node. Fortunately, Equal throws a
// reasonable error, so just call it.
var equal = Equal(switchValue, firstTestValue, false, comparison);
// Get the comparison function from equals node.
comparison = equal.Method;
}
if (defaultBody == null)
{
if (resultType != typeof(void))
{
throw Error.DefaultBodyMustBeSupplied();
}
}
else
{
ValidateSwitchCaseType(defaultBody, customType, resultType, nameof(defaultBody));
}
// if we have a non-boolean user-defined equals, we don't want it.
if (comparison != null && comparison.ReturnType != typeof(bool))
{
throw Error.EqualityMustReturnBoolean(comparison);
}
return(new SwitchExpression(resultType, switchValue, defaultBody, comparison, caseList));
}
/// <summary>
/// Creates an expression representing an indexer access operation.
/// </summary>
/// <param name="object">The object to access.</param>
/// <param name="argument">The argument that will be used to index or slice the object.</param>
/// <param name="lengthOrCount">The property used to retrieve the element count of the object getting accessed.</param>
/// <param name="indexOrSlice">The member used to index or slice the object.</param>
/// <returns>A new <see cref="IndexerAccessCSharpExpression"/> instance representing the array access operation.</returns>
public static IndexerAccessCSharpExpression IndexerAccess(Expression @object, Expression argument, PropertyInfo lengthOrCount, MemberInfo indexOrSlice)
{
RequiresCanRead(@object, nameof(@object));
//
// The argument can be of type Index or Range. We'll check indexOrSlice accordingly below.
//
RequiresCanRead(argument, nameof(argument));
if (argument.Type != typeof(Index) && argument.Type != typeof(Range))
{
throw Error.InvalidIndexerAccessArgumentType(argument.Type);
}
//
// A type is Countable if it has a property named Length or Count with an accessible getter and a return type of int.
//
lengthOrCount ??= FindCountProperty("Length") ?? FindCountProperty("Count");
PropertyInfo FindCountProperty(string name) => @object.Type.GetProperty(name, BindingFlags.Public | BindingFlags.Instance, binder: null, typeof(int), Type.EmptyTypes, modifiers: null);
ContractUtils.RequiresNotNull(lengthOrCount, nameof(lengthOrCount));
var lengthOrCountGetMethod = lengthOrCount.GetGetMethod(nonPublic: true); // NB: System.Linq.Expressions allows non-public properties.
if (lengthOrCountGetMethod == null)
{
throw LinqError.PropertyDoesNotHaveAccessor(lengthOrCount);
}
if (lengthOrCountGetMethod.IsStatic)
{
throw Error.AccessorCannotBeStatic(lengthOrCountGetMethod);
}
if (lengthOrCountGetMethod.GetParametersCached().Length != 0)
{
throw LinqError.IncorrectNumberOfMethodCallArguments(lengthOrCountGetMethod);
}
if (!TypeUtils.IsValidInstanceType(lengthOrCount, @object.Type))
{
throw LinqError.PropertyNotDefinedForType(lengthOrCount, @object.Type);
}
if (lengthOrCount.PropertyType != typeof(int))
{
throw Error.InvalidLengthOrCountPropertyType(lengthOrCount);
}
ValidateMethodInfo(lengthOrCountGetMethod);
if (argument.Type == typeof(Index))
{
//
// The type has an accessible instance indexer which takes a single int as the argument.
//
indexOrSlice ??= FindIndexer();
PropertyInfo FindIndexer()
{
var indexers = (from p in @object.Type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
let i = p.GetIndexParameters()
where i.Length == 1 && i[0].ParameterType == typeof(int)
select p)
.ToArray();
return(indexers.Length == 1 ? indexers[0] : null);
}
ContractUtils.RequiresNotNull(indexOrSlice, nameof(indexOrSlice));
var index = indexOrSlice as PropertyInfo ?? GetProperty(indexOrSlice as MethodInfo ?? throw Error.InvalidIndexMember(indexOrSlice));
indexOrSlice = index; // NB: Store the property rather than a method.
var indexAccessor = index.GetGetMethod(nonPublic: true); // NB: System.Linq.Expressions allows non-public properties.
if (indexAccessor == null)
{
indexAccessor = index.GetSetMethod(nonPublic: true) ?? throw LinqError.PropertyDoesNotHaveAccessor(indexOrSlice);
if (indexAccessor.GetParametersCached().Length != 2)
{
throw LinqError.IncorrectNumberOfMethodCallArguments(indexAccessor);
}
}
else if (indexAccessor.GetParametersCached().Length != 1)
{
throw LinqError.IncorrectNumberOfMethodCallArguments(indexAccessor);
}
if (indexAccessor.IsStatic)
{
throw Error.AccessorCannotBeStatic(indexAccessor);
}
if (!TypeUtils.IsValidInstanceType(indexAccessor, @object.Type))
{
throw LinqError.PropertyNotDefinedForType(indexAccessor, @object.Type);
}
if (indexAccessor.GetParametersCached()[0].ParameterType != typeof(int))
{
throw Error.InvalidIndexerParameterType(indexOrSlice);
}
ValidateMethodInfo(indexAccessor);
}
else
{
//
// The type has an accessible member named Slice which has two parameters of type int.
//
Debug.Assert(argument.Type == typeof(Range));
indexOrSlice ??= FindSliceMethod();
MethodInfo FindSliceMethod() => @object.Type.GetMethod(@object.Type == typeof(string) ? "Substring" : "Slice", BindingFlags.Public | BindingFlags.Instance, binder: null, new[] { typeof(int), typeof(int) }, modifiers: null);
ContractUtils.RequiresNotNull(indexOrSlice, nameof(indexOrSlice));
var slice = indexOrSlice as MethodInfo ?? throw Error.InvalidSliceMember(indexOrSlice);
ValidateMethodInfo(slice);
if (slice.IsStatic)
{
throw Error.SliceMethodMustNotBeStatic(slice);
}
ValidateCallInstanceType(@object.Type, slice);
var sliceParams = slice.GetParametersCached();
if (sliceParams.Length != 2 || sliceParams[0].ParameterType != typeof(int) || sliceParams[1].ParameterType != typeof(int))
{
throw Error.InvalidSliceParameters(slice);
}
}
return(new IndexerAccessCSharpExpression(@object, argument, lengthOrCount, indexOrSlice));
}
