private static Expression PromoteExpression(Expression expr, Type type, bool exact)
{
if (expr.Type == type)
{
return(expr);
}
var constantExpression = expr as ConstantExpression;
if (constantExpression != null && constantExpression == ExpressionConstants.NullLiteral &&
(!type.GetTypeInfo().IsValueType || TypeExtensions.IsNullableType(type)))
{
return(Expression.Constant(null, type));
}
if (!TypeExtensions.IsCompatibleWith(expr.Type, type))
{
return(null);
}
if (type.GetTypeInfo().IsValueType || exact)
{
return(Expression.Convert(expr, type));
}
return(expr);
}
/// <exception cref="T:System.ArgumentException"><c>ArgumentException</c>.</exception>
public override Expression CreateBodyExpression()
{
Expression memberExpression = CreateMemberExpression();
Type type = memberExpression.Type;
Expression valueExpression = CreateValueExpression(type, descriptor.Value, CultureInfo.InvariantCulture);
bool flag = true;
if (TypesAreDifferent(descriptor, memberExpression, valueExpression))
{
if (!TryConvertExpressionTypes(ref memberExpression, ref valueExpression))
{
flag = false;
}
}
else if (TypeExtensions.IsEnumType(memberExpression.Type) || TypeExtensions.IsEnumType(valueExpression.Type))
{
if (!TryPromoteNullableEnums(ref memberExpression, ref valueExpression))
{
flag = false;
}
}
else if (TypeExtensions.IsNullableType(type) && memberExpression.Type != valueExpression.Type &&
!TryConvertNullableValue(memberExpression, ref valueExpression))
{
flag = false;
}
if (flag)
{
return(descriptor.Operator.CreateExpression(memberExpression, valueExpression,
Options.LiftMemberAccessToNull));
}
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture,
"Operator '{0}' is incompatible with operand types '{1}' and '{2}'", (object)descriptor.Operator,
(object)TypeExtensions.GetTypeName(memberExpression.Type),
(object)TypeExtensions.GetTypeName(valueExpression.Type)));
}
private static Expression CreateValueExpression(Type targetType, object value, CultureInfo culture)
{
if (targetType != typeof(string) && (!targetType.GetTypeInfo().IsValueType || TypeExtensions.IsNullableType(targetType)) &&
string.Compare(value as string, "null", StringComparison.OrdinalIgnoreCase) == 0)
{
value = null;
}
if (value != null)
{
Type nonNullableType = TypeExtensions.GetNonNullableType(targetType);
if (value.GetType() != nonNullableType)
{
if (nonNullableType.GetTypeInfo().IsEnum)
{
value = Enum.Parse(nonNullableType, value.ToString(), true);
}
else if (nonNullableType == typeof(Guid))
{
value = new Guid(value.ToString());
}
else if (value is IConvertible)
{
value = Convert.ChangeType(value, nonNullableType, culture);
}
}
}
return(CreateConstantExpression(value));
}
