ExpressionType node_type;
Type type;
- const BindingFlags PublicInstance = BindingFlags.Public | BindingFlags.Instance;
- const BindingFlags PublicStatic = BindingFlags.Public | BindingFlags.Static;
- const BindingFlags AllInstance = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
- const BindingFlags AllStatic = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
- const BindingFlags All = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
+ internal const BindingFlags PublicInstance = BindingFlags.Public | BindingFlags.Instance;
+ internal const BindingFlags NonPublicInstance = BindingFlags.NonPublic | BindingFlags.Instance;
+ internal const BindingFlags PublicStatic = BindingFlags.Public | BindingFlags.Static;
+ internal const BindingFlags AllInstance = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
+ internal const BindingFlags AllStatic = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
+ internal const BindingFlags All = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
public ExpressionType NodeType {
get { return node_type; }
#region Binary Expressions
- static MethodInfo GetUnaryOperator (string oper_name, Type on_type, Expression expression)
+ static MethodInfo GetUnaryOperator (string oper_name, Type declaring, Type param)
{
- var methods = on_type.GetMethods (PublicStatic);
+ return GetUnaryOperator (oper_name, declaring, param, null);
+ }
+
+ static MethodInfo GetUnaryOperator (string oper_name, Type declaring, Type param, Type ret)
+ {
+ var methods = GetNotNullableOf (declaring).GetMethods (PublicStatic);
foreach (var method in methods) {
if (method.Name != oper_name)
if (parameters.Length != 1)
continue;
- if (!parameters [0].ParameterType.IsAssignableFrom (expression.Type))
+ if (!IsAssignableToParameterType (GetNotNullableOf (param), parameters [0]))
+ continue;
+
+ if (ret != null && method.ReturnType != GetNotNullableOf (ret))
continue;
return method;
return null;
}
- static MethodInfo UnaryCoreCheck (string oper_name, Expression expression, MethodInfo method)
+ static bool IsAssignableToParameterType (Type type, ParameterInfo param)
{
- if (expression == null)
- throw new ArgumentNullException ("expression");
+ var ptype = param.ParameterType;
+ if (ptype.IsByRef)
+ ptype = ptype.GetElementType ();
- if (method != null) {
- if (method.ReturnType == typeof (void))
- throw new ArgumentException ("Specified method must return a value", "method");
+ return GetNotNullableOf (type).IsAssignableTo (ptype);
+ }
- if (!method.IsStatic)
- throw new ArgumentException ("Method must be static", "method");
+ static MethodInfo CheckUnaryMethod (MethodInfo method, Type param)
+ {
+ if (method.ReturnType == typeof (void))
+ throw new ArgumentException ("Specified method must return a value", "method");
- var parameters = method.GetParameters ();
+ if (!method.IsStatic)
+ throw new ArgumentException ("Method must be static", "method");
- if (parameters.Length != 1)
- throw new ArgumentException ("Must have only one parameters", "method");
+ var parameters = method.GetParameters ();
- if (!parameters [0].ParameterType.IsAssignableFrom (expression.Type))
- throw new InvalidOperationException ("left-side argument type does not match left expression type");
+ if (parameters.Length != 1)
+ throw new ArgumentException ("Must have only one parameters", "method");
- return method;
- } else {
- if (IsNumber (expression.Type))
+ if (!IsAssignableToParameterType (GetNotNullableOf (param), parameters [0]))
+ throw new InvalidOperationException ("left-side argument type does not match expression type");
+
+ return method;
+ }
+
+ static MethodInfo UnaryCoreCheck (string oper_name, Expression expression, MethodInfo method, Func<Type, bool> validator)
+ {
+ if (expression == null)
+ throw new ArgumentNullException ("expression");
+
+ if (method != null)
+ return CheckUnaryMethod (method, expression.Type);
+
+ var type = GetNotNullableOf (expression.Type);
+
+ if (validator (type))
return null;
if (oper_name != null) {
- method = GetUnaryOperator (oper_name, expression.Type, expression);
+ method = GetUnaryOperator (oper_name, type, expression.Type);
if (method != null)
return method;
}
throw new InvalidOperationException (
- String.Format ("Operation {0} not defined for {1}", oper_name != null ? oper_name.Substring (3) : "is", expression.Type));
- }
+ string.Format ("Operation {0} not defined for {1}", oper_name != null ? oper_name.Substring (3) : "is", expression.Type));
}
static MethodInfo GetBinaryOperator (string oper_name, Type on_type, Expression left, Expression right)
{
MethodInfo [] methods = on_type.GetMethods (PublicStatic);
- foreach (MethodInfo m in methods) {
- if (m.Name != oper_name)
+ foreach (var method in methods) {
+ if (method.Name != oper_name)
continue;
- ParameterInfo [] pi = m.GetParameters ();
- if (pi.Length != 2)
+ var parameters = method.GetParameters ();
+ if (parameters.Length != 2)
continue;
- if (!pi [0].ParameterType.IsAssignableFrom (left.Type))
+ if (!IsAssignableToParameterType (left.Type, parameters [0]))
continue;
- if (!pi [1].ParameterType.IsAssignableFrom (right.Type))
+ if (!IsAssignableToParameterType (right.Type, parameters [1]))
continue;
// Method has papers in order.
- return m;
+ return method;
}
return null;
if (!method.IsStatic)
throw new ArgumentException ("Method must be static", "method");
- ParameterInfo [] pi = method.GetParameters ();
- if (pi.Length != 2)
+ var parameters = method.GetParameters ();
+
+ if (parameters.Length != 2)
throw new ArgumentException ("Must have only two parameters", "method");
- if (!pi [0].ParameterType.IsAssignableFrom (GetNotNullableOf (left.Type)))
+ if (!IsAssignableToParameterType (left.Type, parameters [0]))
throw new InvalidOperationException ("left-side argument type does not match left expression type");
- if (!pi [1].ParameterType.IsAssignableFrom (GetNotNullableOf (right.Type)))
+ if (!IsAssignableToParameterType (right.Type, parameters [1]))
throw new InvalidOperationException ("right-side argument type does not match right expression type");
return method;
return null;
if (oper_name != null){
- method = GetBinaryOperator (oper_name, rtype, left, right);
+ method = GetBinaryOperator (oper_name, urtype, left, right);
if (method != null)
return method;
}
}
if (oper_name != null){
- method = GetBinaryOperator (oper_name, ltype, left, right);
+ method = GetBinaryOperator (oper_name, ultype, left, right);
if (method != null)
return method;
}
- //
- // == and != allow reference types without operators defined.
- //
- if (!ltype.IsValueType && !rtype.IsValueType &&
- (oper_name == "op_Equality" || oper_name == "op_Inequality"))
- return null;
+ if (oper_name == "op_Equality" || oper_name == "op_Inequality") {
+ //
+ // == and != allow reference types without operators defined.
+ //
+ if (!ltype.IsValueType && !rtype.IsValueType)
+ return null;
+
+ if (ltype == rtype && ultype == typeof (bool))
+ return null;
+ }
+
+ if (oper_name == "op_LeftShift" || oper_name == "op_RightShift") {
+ if (IsInt (ultype) && urtype == typeof (int))
+ return null;
+ }
throw new InvalidOperationException (
String.Format ("Operation {0} not defined for {1} and {2}", oper_name != null ? oper_name.Substring (3) : "is", ltype, rtype));
static BinaryExpression MakeSimpleBinary (ExpressionType et, Expression left, Expression right, MethodInfo method)
{
bool is_lifted;
+ Type type;
if (method == null) {
- if (IsNullable (left.Type)) {
- if (!IsNullable (right.Type))
- throw new InvalidOperationException ("Assertion, internal error: left is nullable, requires right to be as well");
+ is_lifted = left.Type.IsNullable ();
+ type = left.Type;
+ } else {
+ var parameters = method.GetParameters ();
+
+ var lp = parameters [0];
+ var rp = parameters [1];
+
+ if (IsAssignableToOperatorParameter (left, lp) && IsAssignableToOperatorParameter (right, rp)) {
+ is_lifted = false;
+ type = method.ReturnType;
+ } else if (left.Type.IsNullable ()
+ && right.Type.IsNullable ()
+ && GetNotNullableOf (left.Type) == lp.ParameterType
+ && GetNotNullableOf (right.Type) == rp.ParameterType
+ && !method.ReturnType.IsNullable ()) {
is_lifted = true;
+ type = method.ReturnType.MakeNullableType ();
} else
- is_lifted = false;
- } else {
- //
- // FIXME: implement
- //
- is_lifted = false;
+ throw new InvalidOperationException ();
}
- return new BinaryExpression (et, GetResultType (left, method), left, right, is_lifted, is_lifted, method, null);
+ return new BinaryExpression (et, type, left, right, is_lifted, is_lifted, method, null);
+ }
+
+ static bool IsAssignableToOperatorParameter (Expression expression, ParameterInfo parameter)
+ {
+ if (expression.Type == parameter.ParameterType)
+ return true;
+
+ if ((!expression.Type.IsNullable () && !parameter.ParameterType.IsNullable ())
+ && IsAssignableToParameterType (expression.Type, parameter))
+ return true;
+
+ return false;
}
static UnaryExpression MakeSimpleUnary (ExpressionType et, Expression expression, MethodInfo method)
{
- return new UnaryExpression (et, expression, GetResultType (expression, method), method);
+ bool is_lifted;
+ Type type;
+
+ if (method == null) {
+ type = expression.Type;
+ is_lifted = type.IsNullable ();
+ } else {
+ var parameter = method.GetParameters () [0];
+
+ if (IsAssignableToOperatorParameter (expression, parameter)) {
+ is_lifted = false;
+ type = method.ReturnType;
+ } else if (expression.Type.IsNullable ()
+ && GetNotNullableOf (expression.Type) == parameter.ParameterType
+ && !method.ReturnType.IsNullable ()) {
+
+ is_lifted = true;
+ type = method.ReturnType.MakeNullableType ();
+ } else
+ throw new InvalidOperationException ();
+ }
+
+ return new UnaryExpression (et, expression, type, method, is_lifted);
}
static BinaryExpression MakeBoolBinary (ExpressionType et, Expression left, Expression right, bool liftToNull, MethodInfo method)
{
- Type result;
- Type ltype = left.Type;
- Type rtype = right.Type;
- bool lnullable = IsNullable (ltype);
- bool rnullable = IsNullable (rtype);
bool is_lifted;
+ Type type;
- // Implement the rules as described in "Expression.Equal" method.
if (method == null) {
- if (!lnullable && !rnullable) {
+ if (!left.Type.IsNullable () && !right.Type.IsNullable ()) {
is_lifted = false;
liftToNull = false;
- result = typeof (bool);
- } else if (lnullable && rnullable) {
+ type = typeof (bool);
+ } else if (left.Type.IsNullable () && right.Type.IsNullable ()) {
is_lifted = true;
- result = liftToNull ? typeof(bool?) : typeof (bool);
+ type = liftToNull ? typeof (bool?) : typeof (bool);
} else
- throw new InvalidOperationException ("Internal error: this should have been caught in BinaryCoreCheck");
+ throw new InvalidOperationException ();
} else {
- ParameterInfo [] pi = method.GetParameters ();
- Type mltype = pi [0].ParameterType;
- Type mrtype = pi [1].ParameterType;
+ var parameters = method.GetParameters ();
- if (ltype == mltype && rtype == mrtype) {
+ var lp = parameters [0];
+ var rp = parameters [1];
+
+ if (IsAssignableToOperatorParameter (left, lp) && IsAssignableToOperatorParameter (right, rp)) {
is_lifted = false;
liftToNull = false;
- result = method.ReturnType;
- } else if (ltype.IsValueType && rtype.IsValueType &&
- ((lnullable && GetNullableOf (ltype) == mltype) ||
- (rnullable && GetNullableOf (rtype) == mrtype))){
+ type = method.ReturnType;
+ } else if (left.Type.IsNullable ()
+ && right.Type.IsNullable ()
+ && GetNotNullableOf (left.Type) == lp.ParameterType
+ && GetNotNullableOf (right.Type) == rp.ParameterType) {
+
is_lifted = true;
- if (method.ReturnType == typeof(bool)){
- result = liftToNull ? typeof(bool?) : typeof(bool);
- } else {
+
+ if (method.ReturnType == typeof (bool))
+ type = liftToNull ? typeof (bool?) : typeof (bool);
+ else if (!method.ReturnType.IsNullable ()) {
//
// This behavior is not documented: what
// happens if the result is not typeof(bool), but
//
// See:
// https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=323139
- result = typeof (Nullable<>).MakeGenericType (method.ReturnType);
- }
- } else {
- is_lifted = false;
- liftToNull = false;
- result = method.ReturnType;
- }
+
+ type = method.ReturnType.MakeNullableType ();
+ } else
+ throw new InvalidOperationException ();
+ } else
+ throw new InvalidOperationException ();
}
- return new BinaryExpression (et, result, left, right, liftToNull, is_lifted, method, null);
+ return new BinaryExpression (et, type, left, right, liftToNull, is_lifted, method, null);
}
//
{
method = BinaryCoreCheck (null, left, right, method);
- if (left.Type != typeof (double))
+ if (GetNotNullableOf (left.Type) != typeof (double))
throw new InvalidOperationException ("Power only supports double arguments");
return MakeSimpleBinary (ExpressionType.Power, left, right, method);
// The method should have identical parameter and return types.
if (left.Type != right.Type || method.ReturnType != left.Type)
throw new ArgumentException ("left, right and return type must match");
+
+ var optrue = left.Type.GetMethod ("op_True", AllStatic);
+ var opfalse = left.Type.GetMethod ("op_False", AllStatic);
+
+ if (optrue == null || opfalse == null)
+ throw new ArgumentException ("Operators true and false are required but not defined");
}
return method;
//
// First arg must ne nullable (either Nullable<T> or a reference type
//
- if (left.Type.IsValueType && !IsNullable (left.Type))
+ if (left.Type.IsValueType && !left.Type.IsNullable ())
throw new InvalidOperationException ("Left expression can never be null");
Type result = null;
- if (IsNullable (left.Type)){
- Type lbase = GetNullableOf (left.Type);
+ if (left.Type.IsNullable ()) {
+ Type lbase = GetNullableArgumentType (left.Type);
- if (!IsNullable (right.Type) && lbase.IsAssignableFrom (right.Type))
+ if (!right.Type.IsNullable () && right.Type.IsAssignableTo (lbase))
result = lbase;
}
- if (result == null && left.Type.IsAssignableFrom (right.Type))
+ if (result == null && right.Type.IsAssignableTo (left.Type))
result = left.Type;
- if (result == null){
- if (IsNullable (left.Type) && right.Type.IsAssignableFrom (GetNullableOf (left.Type))){
+ if (result == null) {
+ if (left.Type.IsNullable () && GetNullableArgumentType (left.Type).IsAssignableTo (right.Type))
result = right.Type;
- }
}
if (result == null)
if (type == null)
throw new ArgumentException ("member");
- if (!type.IsAssignableFrom (expression.Type))
+ if (!expression.Type.IsAssignableTo (type))
throw new ArgumentException ("member");
return new MemberAssignment (member, expression);
if (setter == null)
throw new ArgumentException ("setter");
- if (!prop.PropertyType.IsAssignableFrom (expression.Type))
+ if (!expression.Type.IsAssignableTo (prop.PropertyType))
throw new ArgumentException ("member");
return new MemberAssignment (prop, expression);
throw new ArgumentNullException ("method");
if (instance == null && !method.IsStatic)
throw new ArgumentNullException ("instance");
- if (instance != null && !method.DeclaringType.IsAssignableFrom (instance.Type))
+ if (!method.IsStatic && !instance.Type.IsAssignableTo (method.DeclaringType))
throw new ArgumentException ("Type is not assignable to the declaring type of the method");
var args = arguments.ToReadOnlyCollection ();
if (methodName == null)
throw new ArgumentNullException ("methodName");
- var method = instance.Type.GetMethod (methodName, AllInstance, null, CollectTypes (arguments), null);
- method = TryMakeGeneric (method, typeArguments);
- if (method == null)
- throw new InvalidOperationException ("No such method");
+ var method = TryGetMethod (instance.Type, methodName, AllInstance,
+ CollectTypes (arguments), typeArguments);
var args = arguments.ToReadOnlyCollection ();
+
CheckMethodArguments (method, args);
return new MethodCallExpression (instance, method, args);
}
+ static bool MethodMatch (MethodInfo method, string name, Type [] parameterTypes)
+ {
+ if (method.Name != name)
+ return false;
+
+ var parameters = method.GetParameters ();
+
+ if (parameters.Length != parameterTypes.Length)
+ return false;
+
+ if (method.IsGenericMethod) // if it's a generic method, when can't compare its parameters
+ return true;
+
+ for (int i = 0; i < parameters.Length; i++)
+ if (!IsAssignableToParameterType (parameterTypes [i], parameters [i]))
+ return false;
+
+ return true;
+ }
+
+ static MethodInfo TryGetMethod (Type type, string methodName, BindingFlags flags, Type [] parameterTypes, Type [] argumentTypes)
+ {
+ var methods = from meth in type.GetMethods (flags)
+ where MethodMatch (meth, methodName, parameterTypes)
+ select meth;
+
+ if (methods.Count () > 1)
+ throw new InvalidOperationException ("Too much method candidates");
+
+ var method = TryMakeGeneric (methods.FirstOrDefault (), argumentTypes);
+ if (method != null)
+ return method;
+
+ throw new InvalidOperationException ("No such method");
+ }
+
public static MethodCallExpression Call (Type type, string methodName, Type [] typeArguments, params Expression [] arguments)
{
if (type == null)
if (methodName == null)
throw new ArgumentNullException ("methodName");
- var method = type.GetMethod (methodName, AllStatic, null, CollectTypes (arguments), null);
- method = TryMakeGeneric (method, typeArguments);
- if (method == null)
- throw new InvalidOperationException ("No such method");
+ var method = TryGetMethod (type, methodName, AllStatic,
+ CollectTypes (arguments), typeArguments);
var args = arguments.ToReadOnlyCollection ();
+
CheckMethodArguments (method, args);
return new MethodCallExpression (method, args);
// are allowed
//
if (value == null){
- if (type.IsValueType && !IsNullable (type))
+ if (type.IsValueType && !type.IsNullable ())
throw new ArgumentException ();
} else {
- if (!(type.IsValueType && IsNullable (type)) && value.GetType () != type)
+ if (!(type.IsValueType && type.IsNullable ()) && !value.GetType ().IsAssignableTo (type))
throw new ArgumentException ();
}
return new ConstantExpression (value, type);
}
- [MonoTODO]
+ static bool IsConvertiblePrimitive (Type type)
+ {
+ var t = GetNotNullableOf (type);
+
+ if (t == typeof (bool))
+ return false;
+
+ if (t.IsEnum)
+ return true;
+
+ return t.IsPrimitive;
+ }
+
+ internal static bool IsPrimitiveConversion (Type type, Type target)
+ {
+ if (type == target)
+ return true;
+
+ if (IsConvertiblePrimitive (type) && IsConvertiblePrimitive (target))
+ return true;
+
+ return false;
+ }
+
+ internal static bool IsReferenceConversion (Type type, Type target)
+ {
+ if (type == target)
+ return true;
+
+ if (type.IsAssignableTo (target) || target.IsAssignableTo (type))
+ return true;
+
+ if (type == typeof (object) || target == typeof (object))
+ return true;
+
+ if (type.IsInterface || target.IsInterface)
+ return true;
+
+ return false;
+ }
+
public static UnaryExpression Convert (Expression expression, Type type)
{
- throw new NotImplementedException ();
+ return Convert (expression, type, null);
+ }
+
+ static MethodInfo GetUserConversionMethod (Type type, Type target)
+ {
+ var method = GetUnaryOperator ("op_Explicit", type, type, target);
+ if (method == null)
+ method = GetUnaryOperator ("op_Implicit", type, type, target);
+ if (method == null)
+ method = GetUnaryOperator ("op_Explicit", target, type, target);
+ if (method == null)
+ method = GetUnaryOperator ("op_Implicit", target, type, target);
+ if (method == null)
+ throw new InvalidOperationException ();
+
+ return method;
}
- [MonoTODO]
public static UnaryExpression Convert (Expression expression, Type type, MethodInfo method)
{
- throw new NotImplementedException ();
+ if (expression == null)
+ throw new ArgumentNullException ("expression");
+ if (type == null)
+ throw new ArgumentNullException ("type");
+
+ var et = expression.Type;
+
+ if (method != null)
+ CheckUnaryMethod (method, et);
+ else if (!IsPrimitiveConversion (et, type) && !IsReferenceConversion (et, type))
+ method = GetUserConversionMethod (et, type);
+
+ return new UnaryExpression (ExpressionType.Convert,
+ expression, type, method,
+ IsConvertNodeLifted (method, expression, type));
+ }
+
+ static bool IsConvertNodeLifted (MethodInfo method, Expression operand, Type target)
+ {
+ if (method == null)
+ return operand.Type.IsNullable () || target.IsNullable ();
+
+ if (operand.Type.IsNullable () && !ParameterMatch (method, operand.Type))
+ return true;
+
+ if (target.IsNullable () && !ReturnTypeMatch (method, target))
+ return true;
+
+ return false;
+ }
+
+ static bool ParameterMatch (MethodInfo method, Type type)
+ {
+ return method.GetParameters () [0].ParameterType == type;
+ }
+
+ static bool ReturnTypeMatch (MethodInfo method, Type type)
+ {
+ return method.ReturnType == type;
}
- [MonoTODO]
public static UnaryExpression ConvertChecked (Expression expression, Type type)
{
- throw new NotImplementedException ();
+ return ConvertChecked (expression, type, null);
}
- [MonoTODO]
public static UnaryExpression ConvertChecked (Expression expression, Type type, MethodInfo method)
{
- throw new NotImplementedException ();
+ if (expression == null)
+ throw new ArgumentNullException ("expression");
+ if (type == null)
+ throw new ArgumentNullException ("type");
+
+ var et = expression.Type;
+
+ if (method != null)
+ CheckUnaryMethod (method, et);
+ else if (IsReferenceConversion (et, type))
+ return Convert (expression, type, method);
+ else if (!IsPrimitiveConversion (et, type))
+ method = GetUserConversionMethod (et, type);
+
+ return new UnaryExpression (ExpressionType.ConvertChecked,
+ expression, type, method,
+ IsConvertNodeLifted (method, expression, type));
}
public static ElementInit ElementInit (MethodInfo addMethod, params Expression [] arguments)
if (!field.IsStatic) {
if (expression == null)
throw new ArgumentNullException ("expression");
- if (!field.DeclaringType.IsAssignableFrom (expression.Type))
+ if (!expression.Type.IsAssignableTo (field.DeclaringType))
throw new ArgumentException ("field");
}
static Type GetInvokableType (Type t)
{
- if (typeof (Delegate).IsAssignableFrom (t))
+ if (t.IsAssignableTo (typeof (Delegate)))
return t;
return GetGenericType (t, typeof (Expression<>));
return new InvocationExpression (expression, invoke.ReturnType, args);
}
+ static bool CanAssign (Type target, Type source)
+ {
+ // This catches object and value type mixage, type compatibility is handled later
+ if (target.IsValueType ^ source.IsValueType)
+ return false;
+
+ return source.IsAssignableTo (target);
+ }
+
+ static void CheckLambda (Type delegateType, Expression body, ReadOnlyCollection<ParameterExpression> parameters)
+ {
+ if (!delegateType.IsSubclassOf (typeof (System.Delegate)))
+ throw new ArgumentException ("delegateType");
+
+ var invoke = delegateType.GetMethod ("Invoke", BindingFlags.Instance | BindingFlags.Public);
+ if (invoke == null)
+ throw new ArgumentException ("delegate must contain an Invoke method", "delegateType");
+
+ var invoke_parameters = invoke.GetParameters ();
+ if (invoke_parameters.Length != parameters.Count)
+ throw new ArgumentException (string.Format ("Different number of arguments in delegate {0}", delegateType), "delegateType");
+
+ for (int i = 0; i < invoke_parameters.Length; i++) {
+ if (!CanAssign (parameters [i].Type, invoke_parameters [i].ParameterType))
+ throw new ArgumentException (String.Format ("Can not assign a {0} to a {1}", invoke_parameters [i].ParameterType, parameters [i].Type));
+ }
+
+ if (invoke.ReturnType != typeof (void) && !CanAssign (invoke.ReturnType, body.Type))
+ throw new ArgumentException (String.Format ("body type {0} can not be assigned to {1}", body.Type, invoke.ReturnType));
+ }
+
public static Expression<TDelegate> Lambda<TDelegate> (Expression body, params ParameterExpression [] parameters)
{
return Lambda<TDelegate> (body, parameters as IEnumerable<ParameterExpression>);
if (body == null)
throw new ArgumentNullException ("body");
- return new Expression<TDelegate> (body, parameters.ToReadOnlyCollection ());
+ var ps = parameters.ToReadOnlyCollection ();
+
+ CheckLambda (typeof (TDelegate), body, ps);
+
+ return new Expression<TDelegate> (body, ps);
}
public static LambdaExpression Lambda (Expression body, params ParameterExpression [] parameters)
return Lambda (delegateType, body, parameters as IEnumerable<ParameterExpression>);
}
+ static LambdaExpression CreateExpressionOf (Type type, Expression body, ReadOnlyCollection<ParameterExpression> parameters)
+ {
+ return (LambdaExpression) Activator.CreateInstance (
+ typeof (Expression<>).MakeGenericType (type),
+ NonPublicInstance, null, new object [] { body, parameters }, null);
+ }
+
public static LambdaExpression Lambda (Type delegateType, Expression body, IEnumerable<ParameterExpression> parameters)
{
if (delegateType == null)
if (body == null)
throw new ArgumentNullException ("body");
- return new LambdaExpression (delegateType, body, parameters.ToReadOnlyCollection ());
+ var ps = parameters.ToReadOnlyCollection ();
+
+ CheckLambda (delegateType, body, ps);
+
+ return CreateExpressionOf (delegateType, body, ps);
}
public static MemberListBinding ListBind (MemberInfo member, params ElementInit [] initializers)
static void CheckIsAssignableToIEnumerable (Type t)
{
- if (!typeof (IEnumerable).IsAssignableFrom (t))
+ if (!t.IsAssignableTo (typeof (IEnumerable)))
throw new ArgumentException (string.Format ("Type {0} doesn't implemen IEnumerable", t));
}
var inits = initializers.ToReadOnlyCollection ();
CheckForNull (inits, "initializers");
- switch (member.MemberType) {
- case MemberTypes.Field:
- CheckIsAssignableToIEnumerable ((member as FieldInfo).FieldType);
- break;
- case MemberTypes.Property:
- CheckIsAssignableToIEnumerable ((member as PropertyInfo).PropertyType);
- break;
- default:
- throw new ArgumentException ("member");
- }
+ member.OnFieldOrProperty (
+ field => CheckIsAssignableToIEnumerable (field.FieldType),
+ prop => CheckIsAssignableToIEnumerable (prop.PropertyType));
return new MemberListBinding (member, inits);
}
throw new ArgumentNullException ("newExpression");
if (initializers == null)
throw new ArgumentNullException ("initializers");
- if (!typeof (IEnumerable).IsAssignableFrom (newExpression.Type))
+ if (!newExpression.Type.IsAssignableTo (typeof (IEnumerable)))
throw new InvalidOperationException ("The type of the new expression does not implement IEnumerable");
var inits = initializers.ToReadOnlyCollection ();
if (parameters.Length != 1)
throw new ArgumentException ("addMethod");
- var type = parameters [0].ParameterType;
-
- foreach (var exp in inits)
- if (!type.IsAssignableFrom (exp.Type))
+ foreach (var expression in inits)
+ if (!IsAssignableToParameterType (expression.Type, parameters [0]))
throw new InvalidOperationException ("Initializer not assignable to the add method parameter type");
}
if (member == null)
throw new ArgumentNullException ("member");
- Type type = null;
- switch (member.MemberType) {
- case MemberTypes.Field:
- type = (member as FieldInfo).FieldType;
- break;
- case MemberTypes.Property:
- type = (member as PropertyInfo).PropertyType;
- break;
- default:
- throw new ArgumentException ("Member is neither a field or a property");
- }
+ var type = member.OnFieldOrProperty (
+ field => field.FieldType,
+ prop => prop.PropertyType);
return new MemberMemberBinding (member, CheckMemberBindings (type, bindings));
}
CheckForNull (bds, "bindings");
foreach (var binding in bds)
- if (!binding.Member.DeclaringType.IsAssignableFrom (type))
+ if (!type.IsAssignableTo (binding.Member.DeclaringType))
throw new ArgumentException ("Type not assignable to member type");
return bds;
public static UnaryExpression Negate (Expression expression, MethodInfo method)
{
- method = UnaryCoreCheck ("op_UnaryNegation", expression, method);
+ method = UnaryCoreCheck ("op_UnaryNegation", expression, method, type => IsSignedNumber (type));
return MakeSimpleUnary (ExpressionType.Negate, expression, method);
}
public static UnaryExpression NegateChecked (Expression expression, MethodInfo method)
{
- method = UnaryCoreCheck ("op_UnaryNegation", expression, method);
+ method = UnaryCoreCheck ("op_UnaryNegation", expression, method, type => IsSignedNumber (type));
- return MakeSimpleUnary (ExpressionType.Negate, expression, method);
+ return MakeSimpleUnary (ExpressionType.NegateChecked, expression, method);
}
public static NewExpression New (ConstructorInfo constructor)
if (type == null)
throw new ArgumentNullException ("type");
+ CheckNotVoid (type);
+
var args = (null as IEnumerable<Expression>).ToReadOnlyCollection ();
if (type.IsValueType)
if (arguments [i] == null)
throw new ArgumentNullException ("arguments");
- if (!parameters [i].ParameterType.IsAssignableFrom (arguments [i].Type))
+ if (!IsAssignableToParameterType (arguments [i].Type, parameters [i]))
throw new ArgumentException ("arguments");
}
}
throw new ArgumentException ("Member type not allowed");
}
- if (!type.IsAssignableFrom (args [i].Type))
+ if (!args [i].Type.IsAssignableTo (type))
throw new ArgumentException ("Argument type not assignable to member type");
}
if (bounds == null)
throw new ArgumentNullException ("bounds");
+ CheckNotVoid (type);
+
var array_bounds = bounds.ToReadOnlyCollection ();
foreach (var expression in array_bounds)
if (!IsInt (expression.Type))
if (initializers == null)
throw new ArgumentNullException ("initializers");
- var array_initializers = initializers.ToReadOnlyCollection ();
+ CheckNotVoid (type);
+
+ var inits = initializers.ToReadOnlyCollection ();
- foreach (var expression in initializers) {
+ foreach (var expression in inits) {
if (expression == null)
throw new ArgumentNullException ("initializers");
- if (!type.IsAssignableFrom (expression.Type))
+ if (!expression.Type.IsAssignableTo (type))
throw new InvalidOperationException ();
// TODO: Quote elements if type == typeof (Expression)
}
- return new NewArrayExpression (ExpressionType.NewArrayInit, type.MakeArrayType (), array_initializers);
+ return new NewArrayExpression (ExpressionType.NewArrayInit, type.MakeArrayType (), inits);
}
public static UnaryExpression Not (Expression expression)
public static UnaryExpression Not (Expression expression, MethodInfo method)
{
- method = UnaryCoreCheck ("op_LogicalNot", expression, method);
+ Func<Type, bool> validator = type => IsIntOrBool (type);
+
+ method = UnaryCoreCheck ("op_LogicalNot", expression, method, validator);
+
+ if (method == null)
+ method = UnaryCoreCheck ("op_OnesComplement", expression, method, validator);
return MakeSimpleUnary (ExpressionType.Not, expression, method);
}
+ static void CheckNotVoid (Type type)
+ {
+ if (type == typeof (void))
+ throw new ArgumentException ("Type can't be void");
+ }
+
public static ParameterExpression Parameter (Type type, string name)
{
if (type == null)
throw new ArgumentNullException ("type");
+ CheckNotVoid (type);
+
return new ParameterExpression (type, name);
}
if (!propertyAccessor.IsStatic) {
if (expression == null)
throw new ArgumentNullException ("expression");
- if (!propertyAccessor.DeclaringType.IsAssignableFrom (expression.Type))
+ if (!expression.Type.IsAssignableTo (propertyAccessor.DeclaringType))
throw new ArgumentException ("expression");
}
if (!getter.IsStatic) {
if (expression == null)
throw new ArgumentNullException ("expression");
- if (!property.DeclaringType.IsAssignableFrom (expression.Type))
+ if (!expression.Type.IsAssignableTo (property.DeclaringType))
throw new ArgumentException ("expression");
}
throw new ArgumentNullException ("expression");
if (type == null)
throw new ArgumentNullException ("type");
- if (type.IsValueType && !IsNullable (type))
+ if (type.IsValueType && !type.IsNullable ())
throw new ArgumentException ("TypeAs expect a reference or a nullable type");
return new UnaryExpression (ExpressionType.TypeAs, expression, type);
if (type == null)
throw new ArgumentNullException ("type");
+ CheckNotVoid (type);
+
return new TypeBinaryExpression (ExpressionType.TypeIs, expression, type, typeof (bool));
}
public static UnaryExpression UnaryPlus (Expression expression, MethodInfo method)
{
- method = UnaryCoreCheck ("op_UnaryPlus", expression, method);
+ method = UnaryCoreCheck ("op_UnaryPlus", expression, method, type => IsNumber (type));
return MakeSimpleUnary (ExpressionType.UnaryPlus, expression, method);
}
return t == typeof (float) || t == typeof (double) || t == typeof (decimal);
}
- internal static bool IsNullable (Type type)
+ static bool IsSignedNumber (Type t)
{
- return type.IsGenericType && type.GetGenericTypeDefinition () == typeof (Nullable<>);
+ return IsNumber (t) && !IsUnsigned (t);
}
internal static bool IsUnsigned (Type t)
{
+#if !TARGET_JVM
if (t.IsPointer)
return IsUnsigned (t.GetElementType ());
+#endif
return t == typeof (ushort) ||
t == typeof (uint) ||
t == typeof (ulong) ||
//
// returns the T in a a Nullable<T> type.
//
- internal static Type GetNullableOf (Type type)
+ internal static Type GetNullableArgumentType (Type type)
{
- return type.GetGenericArguments () [0];
+ return type.GetFirstGenericArgument ();
}
internal static Type GetNotNullableOf (Type type)
{
- return IsNullable (type) ? GetNullableOf (type) : type;
+ return type.IsNullable () ? GetNullableArgumentType (type) : type;
}
//
// This method must be overwritten by derived classes to
// compile the expression
//
- internal abstract void Emit (EmitContext ec);
-
- internal static LocalBuilder EmitStored (EmitContext ec, Expression expression)
- {
- var local = ec.ig.DeclareLocal (expression.Type);
- expression.Emit (ec);
- ec.ig.Emit (OpCodes.Stloc, local);
-
- return local;
- }
-
- internal static void EmitLoad (EmitContext ec, Expression expression)
- {
- if (expression.Type.IsValueType) {
- var local = EmitStored (ec, expression);
- ec.ig.Emit (OpCodes.Ldloca, local);
- } else
- expression.Emit (ec);
- }
-
- internal static void EmitLoad (EmitContext ec, LocalBuilder local)
- {
- ec.ig.Emit (OpCodes.Ldloc, local);
- }
-
- internal static void EmitCall (EmitContext ec, LocalBuilder local, IEnumerable<Expression> arguments, MethodInfo method)
- {
- EmitLoad (ec, local);
- EmitCollection (ec, arguments);
- EmitCall (ec, method);
- }
-
- internal static void EmitCall (EmitContext ec, Expression expression, IEnumerable<Expression> arguments, MethodInfo method)
- {
- if (expression != null)
- EmitLoad (ec, expression);
-
- EmitCollection (ec, arguments);
- EmitCall (ec, method);
- }
-
- internal static void EmitCall (EmitContext ec, MethodInfo method)
+ internal virtual void Emit (EmitContext ec)
{
- ec.ig.Emit (
- method.IsVirtual ? OpCodes.Callvirt : OpCodes.Call,
- method);
- }
-
- internal static void EmitCollection<T> (EmitContext ec, IEnumerable<T> collection) where T : Expression
- {
- foreach (var expression in collection)
- expression.Emit (ec);
- }
-
- internal static void EmitCollection (EmitContext ec, IEnumerable<ElementInit> initializers, LocalBuilder local)
- {
- foreach (var initializer in initializers)
- initializer.Emit (ec, local);
- }
-
- internal static void EmitCollection (EmitContext ec, IEnumerable<MemberBinding> bindings, LocalBuilder local)
- {
- foreach (var binding in bindings)
- binding.Emit (ec, local);
- }
-
- internal static void EmitIsInst (EmitContext ec, Expression expression, Type candidate)
- {
- expression.Emit (ec);
-
- if (expression.Type.IsValueType)
- ec.ig.Emit (OpCodes.Box, expression.Type);
-
- ec.ig.Emit (OpCodes.Isinst, candidate);
+ throw new NotImplementedException ();
}
}
}
projects / mono.git / blobdiff