eclass = ExprClass.Type;
}
- public NullableType (Type type, Location loc)
+ public NullableType (TypeSpec type, Location loc)
: this (new TypeExpression (type, loc), loc)
{ }
{
if (TypeManager.generic_nullable_type == null) {
TypeManager.generic_nullable_type = TypeManager.CoreLookupType (ec.Compiler,
- "System", "Nullable`1", Kind.Struct, true);
+ "System", "Nullable", 1, MemberKind.Struct, true);
}
TypeArguments args = new TypeArguments (underlying);
GenericTypeExpr ctype = new GenericTypeExpr (TypeManager.generic_nullable_type, args, loc);
return ctype.ResolveAsTypeTerminal (ec, false);
}
-
- public override TypeExpr ResolveAsTypeTerminal (IMemberContext ec, bool silent)
- {
- return ResolveAsBaseTerminal (ec, silent);
- }
}
- public sealed class NullableInfo
+ static class NullableInfo
{
- public readonly Type Type;
- public readonly Type UnderlyingType;
- public MethodSpec HasValue;
- public MethodSpec Value;
- public MethodSpec GetValueOrDefault;
- public MethodSpec Constructor;
-
- public NullableInfo (Type type)
+ public static MethodSpec GetConstructor (TypeSpec nullableType)
{
- Type = type;
- UnderlyingType = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (type) [0]);
-
- var has_value_pi = TypeManager.GetPredefinedProperty (type, "HasValue", Location.Null, Type.EmptyTypes);
- var value_pi = TypeManager.GetPredefinedProperty (type, "Value", Location.Null, Type.EmptyTypes);
- GetValueOrDefault = TypeManager.GetPredefinedMethod (type, "GetValueOrDefault", Location.Null, Type.EmptyTypes);
+ return TypeManager.GetPredefinedConstructor (nullableType, Location.Null, GetUnderlyingType (nullableType));
+ }
- HasValue = Import.CreateMethod (has_value_pi.MetaInfo.GetGetMethod (false));
- Value = Import.CreateMethod (value_pi.MetaInfo.GetGetMethod (false));
+ public static MethodSpec GetHasValue (TypeSpec nullableType)
+ {
+ return (MethodSpec) MemberCache.FindMember (nullableType,
+ MemberFilter.Method ("get_HasValue", 0, ParametersCompiled.EmptyReadOnlyParameters, null), BindingRestriction.None);
+ }
- // When compiling corlib
- if (TypeManager.IsBeingCompiled (type)) {
- TypeContainer tc = TypeManager.LookupGenericTypeContainer (type);
-
- // TODO: check for correct overload
- Constructor c = ((Constructor) tc.InstanceConstructors [0]);
+ public static MethodSpec GetGetValueOrDefault (TypeSpec nullableType)
+ {
+ return (MethodSpec) MemberCache.FindMember (nullableType,
+ MemberFilter.Method ("GetValueOrDefault", 0, ParametersCompiled.EmptyReadOnlyParameters, null), BindingRestriction.None);
+ }
- Constructor = Import.CreateMethod (TypeBuilder.GetConstructor (type, c.ConstructorBuilder));
- return;
- }
+ public static MethodSpec GetValue (TypeSpec nullableType)
+ {
+ return (MethodSpec) MemberCache.FindMember (nullableType,
+ MemberFilter.Method ("get_Value", 0, ParametersCompiled.EmptyReadOnlyParameters, null), BindingRestriction.None);
+ }
-#if MS_COMPATIBLE
-// if (TypeManager.IsBeingCompiled (UnderlyingType)) {
-// ConstructorInfo cinfo = TypeManager.DropGenericTypeArguments (type).GetConstructors ()[0];
-// Constructor = TypeBuilder.GetConstructor (type, cinfo);
-// return;
-// }
-#endif
+ public static TypeSpec GetUnderlyingType (TypeSpec nullableType)
+ {
+ return ((InflatedTypeSpec) nullableType).TypeArguments[0];
+ }
- Constructor = Import.CreateMethod (type.GetConstructor (new Type[] { UnderlyingType }));
+ public static bool IsNullableType (TypeSpec type)
+ {
+ throw new NotImplementedException ("net");
}
}
public class Unwrap : Expression, IMemoryLocation, IAssignMethod
{
Expression expr;
- NullableInfo info;
LocalTemporary temp;
readonly bool useDefaultValue;
this.loc = expr.Location;
this.useDefaultValue = useDefaultValue;
- info = new NullableInfo (expr.Type);
- type = info.UnderlyingType;
+ type = NullableInfo.GetUnderlyingType (expr.Type);
eclass = expr.eclass;
}
public override Expression DoResolveLValue (ResolveContext ec, Expression right_side)
{
- return DoResolve (ec);
+ expr = expr.DoResolveLValue (ec, right_side);
+ return this;
}
public override void Emit (EmitContext ec)
{
Store (ec);
if (useDefaultValue)
- Invocation.EmitCall (ec, false, this, info.GetValueOrDefault, null, loc);
+ Invocation.EmitCall (ec, this, NullableInfo.GetGetValueOrDefault (expr.Type), null, loc);
else
- Invocation.EmitCall (ec, false, this, info.Value, null, loc);
+ Invocation.EmitCall (ec, this, NullableInfo.GetValue (expr.Type), null, loc);
}
public void EmitCheck (EmitContext ec)
{
Store (ec);
- Invocation.EmitCall (ec, false, this, info.HasValue, null, loc);
+ Invocation.EmitCall (ec, this, NullableInfo.GetHasValue (expr.Type), null, loc);
}
public override bool Equals (object obj)
return expr.MakeExpression (ctx);
}
- public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
- {
- type = storey.MutateType (type);
- storey.MutateConstructor (info.Constructor);
- storey.MutateGenericMethod (info.HasValue);
- storey.MutateGenericMethod (info.GetValueOrDefault);
- storey.MutateGenericMethod (info.Value);
- }
-
public void AddressOf (EmitContext ec, AddressOp mode)
{
IMemoryLocation ml = expr as VariableReference;
- if (ml != null)
+ if (ml != null)
ml.AddressOf (ec, mode);
else
LocalVariable.AddressOf (ec, mode);
LocalTemporary LocalVariable {
get {
if (temp == null)
- temp = new LocalTemporary (info.Type);
+ temp = new LocalTemporary (expr.Type);
return temp;
}
}
public void EmitAssign (EmitContext ec, Expression source,
bool leave_copy, bool prepare_for_load)
{
- InternalWrap wrap = new InternalWrap (source, info, loc);
+ InternalWrap wrap = new InternalWrap (source, expr.Type, loc);
((IAssignMethod) expr).EmitAssign (ec, wrap, leave_copy, false);
}
- protected class InternalWrap : Expression
+ class InternalWrap : Expression
{
public Expression expr;
- public NullableInfo info;
- public InternalWrap (Expression expr, NullableInfo info, Location loc)
+ public InternalWrap (Expression expr, TypeSpec type, Location loc)
{
this.expr = expr;
- this.info = info;
this.loc = loc;
+ this.type = type;
- type = info.Type;
eclass = ExprClass.Value;
}
public override void Emit (EmitContext ec)
{
expr.Emit (ec);
- ec.ig.Emit (OpCodes.Newobj, (ConstructorInfo) info.Constructor.MetaInfo);
+ ec.Emit (OpCodes.Newobj, NullableInfo.GetConstructor (type));
}
}
}
- public class Wrap : TypeCast
+ //
+ // Calls get_Value method on nullable expression
+ //
+ public class UnwrapCall : CompositeExpression
{
- readonly NullableInfo info;
+ public UnwrapCall (Expression expr)
+ : base (expr)
+ {
+ }
- protected Wrap (Expression expr, Type type)
- : base (expr, type)
+ protected override Expression DoResolve (ResolveContext rc)
{
- info = new NullableInfo (type);
- eclass = ExprClass.Value;
+ base.DoResolve (rc);
+
+ if (type != null)
+ type = NullableInfo.GetUnderlyingType (type);
+
+ return this;
}
- public Expression Child {
- get { return child; }
+ public override void Emit (EmitContext ec)
+ {
+ Invocation.EmitCall (ec, Child, NullableInfo.GetValue (Child.Type), null, loc);
+ }
+ }
+
+ public class Wrap : TypeCast
+ {
+ private Wrap (Expression expr, TypeSpec type)
+ : base (expr, type)
+ {
+ eclass = ExprClass.Value;
}
public override Expression CreateExpressionTree (ResolveContext ec)
return base.CreateExpressionTree (ec);
}
- public static Expression Create (Expression expr, Type type)
+ public static Expression Create (Expression expr, TypeSpec type)
{
//
// Avoid unwraping and wraping of the same type
//
Unwrap unwrap = expr as Unwrap;
- if (unwrap != null && TypeManager.IsEqual (expr.Type, TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (type) [0])))
+ if (unwrap != null && expr.Type == NullableInfo.GetUnderlyingType (type))
return unwrap.Original;
return new Wrap (expr, type);
public override void Emit (EmitContext ec)
{
child.Emit (ec);
- ec.ig.Emit (OpCodes.Newobj, (ConstructorInfo) info.Constructor.MetaInfo);
+ ec.Emit (OpCodes.Newobj, NullableInfo.GetConstructor (type));
}
}
//
public class LiftedNull : NullConstant, IMemoryLocation
{
- private LiftedNull (Type nullable_type, Location loc)
+ private LiftedNull (TypeSpec nullable_type, Location loc)
: base (nullable_type, loc)
{
eclass = ExprClass.Value;
}
- public static Constant Create (Type nullable, Location loc)
+ public static Constant Create (TypeSpec nullable, Location loc)
{
return new LiftedNull (nullable, loc);
}
- public static Expression CreateFromExpression (ResolveContext ec, Expression e)
+ public static Constant CreateFromExpression (ResolveContext ec, Expression e)
{
ec.Report.Warning (458, 2, e.Location, "The result of the expression is always `null' of type `{0}'",
TypeManager.CSharpName (e.Type));
LocalTemporary value_target = new LocalTemporary (type);
value_target.AddressOf (ec, AddressOp.Store);
- ec.ig.Emit (OpCodes.Initobj, type);
+ ec.Emit (OpCodes.Initobj, type);
value_target.Emit (ec);
}
LocalTemporary value_target = new LocalTemporary (type);
value_target.AddressOf (ec, AddressOp.Store);
- ec.ig.Emit (OpCodes.Initobj, type);
+ ec.Emit (OpCodes.Initobj, type);
((IMemoryLocation) value_target).AddressOf (ec, Mode);
}
}
Expression expr, null_value;
Unwrap unwrap;
- public Lifted (Expression expr, Unwrap unwrap, Type type)
+ public Lifted (Expression expr, Unwrap unwrap, TypeSpec type)
{
this.expr = expr;
this.unwrap = unwrap;
this.type = type;
}
- public Lifted (Expression expr, Expression unwrap, Type type)
+ public Lifted (Expression expr, Expression unwrap, TypeSpec type)
: this (expr, unwrap as Unwrap, type)
{
}
if (expr == null)
return null;
+ null_value = LiftedNull.Create (type, loc);
+ } else if (TypeManager.IsValueType (type)) {
null_value = LiftedNull.Create (type, loc);
} else {
null_value = new NullConstant (type, loc);
public override void Emit (EmitContext ec)
{
- ILGenerator ig = ec.ig;
- Label is_null_label = ig.DefineLabel ();
- Label end_label = ig.DefineLabel ();
+ Label is_null_label = ec.DefineLabel ();
+ Label end_label = ec.DefineLabel ();
unwrap.EmitCheck (ec);
- ig.Emit (OpCodes.Brfalse, is_null_label);
+ ec.Emit (OpCodes.Brfalse, is_null_label);
expr.Emit (ec);
- ig.Emit (OpCodes.Br, end_label);
- ig.MarkLabel (is_null_label);
+ ec.Emit (OpCodes.Br, end_label);
+ ec.MarkLabel (is_null_label);
null_value.Emit (ec);
- ig.MarkLabel (end_label);
+ ec.MarkLabel (end_label);
}
public void AddressOf (EmitContext ec, AddressOp mode)
Unwrap unwrap;
Expression user_operator;
- public LiftedUnaryOperator (Unary.Operator op, Expression expr)
- : base (op, expr)
+ public LiftedUnaryOperator (Unary.Operator op, Expression expr, Location loc)
+ : base (op, expr, loc)
{
}
public override void Emit (EmitContext ec)
{
- ILGenerator ig = ec.ig;
- Label is_null_label = ig.DefineLabel ();
- Label end_label = ig.DefineLabel ();
+ Label is_null_label = ec.DefineLabel ();
+ Label end_label = ec.DefineLabel ();
unwrap.EmitCheck (ec);
- ig.Emit (OpCodes.Brfalse, is_null_label);
-
- NullableInfo ni = new NullableInfo (type);
+ ec.Emit (OpCodes.Brfalse, is_null_label);
if (user_operator != null) {
user_operator.Emit (ec);
} else {
- EmitOperator (ec, ni.UnderlyingType);
+ EmitOperator (ec, NullableInfo.GetUnderlyingType (type));
}
- ig.Emit (OpCodes.Newobj, (ConstructorInfo) ni.Constructor.MetaInfo);
- ig.Emit (OpCodes.Br_S, end_label);
+ ec.Emit (OpCodes.Newobj, NullableInfo.GetConstructor (type));
+ ec.Emit (OpCodes.Br_S, end_label);
- ig.MarkLabel (is_null_label);
+ ec.MarkLabel (is_null_label);
LiftedNull.Create (type, loc).Emit (ec);
- ig.MarkLabel (end_label);
+ ec.MarkLabel (end_label);
}
Expression LiftExpression (ResolveContext ec, Expression expr)
public class LiftedBinaryOperator : Binary
{
Unwrap left_unwrap, right_unwrap;
- bool left_null_lifted, right_null_lifted;
Expression left_orig, right_orig;
Expression user_operator;
MethodSpec wrap_ctor;
- public LiftedBinaryOperator (Binary.Operator op, Expression left, Expression right,
- Location loc)
- : base (op, left, right)
+ public LiftedBinaryOperator (Binary.Operator op, Expression left, Expression right, Location loc)
+ : base (op, left, right, loc)
{
- this.loc = loc;
+ }
+
+ bool IsBitwiseBoolean {
+ get {
+ return (Oper == Operator.BitwiseAnd || Oper == Operator.BitwiseOr) &&
+ ((left_unwrap != null && left_unwrap.Type == TypeManager.bool_type) ||
+ (right_unwrap != null && right_unwrap.Type == TypeManager.bool_type));
+ }
+ }
+
+ bool IsLeftNullLifted {
+ get {
+ return (state & State.LeftNullLifted) != 0;
+ }
+ }
+
+ bool IsRightNullLifted {
+ get {
+ return (state & State.RightNullLifted) != 0;
+ }
}
public override Expression CreateExpressionTree (ResolveContext ec)
// with the null literal *outside* of a generics context and
// inlines that as true or false.
//
- Expression CreateNullConstant (ResolveContext ec, Expression expr)
+ Constant CreateNullConstant (ResolveContext ec, Expression expr)
{
// FIXME: Handle side effect constants
Constant c = new BoolConstant (Oper == Operator.Inequality, loc).Resolve (ec);
// Arguments can be lifted for equal operators when the return type is bool and both
// arguments are of same type
//
- if (left_orig.IsNull) {
+ if (left_orig is NullLiteral) {
left = right;
- left_null_lifted = true;
+ state |= State.LeftNullLifted;
type = TypeManager.bool_type;
}
if (right_orig.IsNull) {
- right = left;
- right_null_lifted = true;
+ if ((Oper & Operator.ShiftMask) != 0)
+ right = new EmptyExpression (TypeManager.int32_type);
+ else
+ right = left;
+
+ state |= State.RightNullLifted;
type = TypeManager.bool_type;
}
void EmitBitwiseBoolean (EmitContext ec)
{
- ILGenerator ig = ec.ig;
+ Label load_left = ec.DefineLabel ();
+ Label load_right = ec.DefineLabel ();
+ Label end_label = ec.DefineLabel ();
- Label load_left = ig.DefineLabel ();
- Label load_right = ig.DefineLabel ();
- Label end_label = ig.DefineLabel ();
+ // null & value, null | value
+ if (left_unwrap == null) {
+ left_unwrap = right_unwrap;
+ right_unwrap = null;
+ right = left;
+ }
left_unwrap.Emit (ec);
- ig.Emit (OpCodes.Brtrue_S, load_right);
+ ec.Emit (OpCodes.Brtrue_S, load_right);
- right_unwrap.Emit (ec);
- ig.Emit (OpCodes.Brtrue_S, load_left);
+ // value & null, value | null
+ if (right_unwrap != null) {
+ right_unwrap.Emit (ec);
+ ec.Emit (OpCodes.Brtrue_S, load_left);
+ }
left_unwrap.EmitCheck (ec);
- ig.Emit (OpCodes.Brfalse_S, load_right);
+ ec.Emit (OpCodes.Brfalse_S, load_right);
// load left
- ig.MarkLabel (load_left);
+ ec.MarkLabel (load_left);
if (Oper == Operator.BitwiseAnd) {
left_unwrap.Load (ec);
} else {
- right_unwrap.Load (ec);
- right_unwrap = left_unwrap;
+ if (right_unwrap == null) {
+ right.Emit (ec);
+ if (right is EmptyConstantCast || right is EmptyCast)
+ ec.Emit (OpCodes.Newobj, NullableInfo.GetConstructor (type));
+ } else {
+ right_unwrap.Load (ec);
+ right_unwrap = left_unwrap;
+ }
}
- ig.Emit (OpCodes.Br_S, end_label);
+ ec.Emit (OpCodes.Br_S, end_label);
// load right
- ig.MarkLabel (load_right);
- right_unwrap.Load (ec);
+ ec.MarkLabel (load_right);
+ if (right_unwrap == null) {
+ if (Oper == Operator.BitwiseAnd) {
+ right.Emit (ec);
+ if (right is EmptyConstantCast || right is EmptyCast)
+ ec.Emit (OpCodes.Newobj, NullableInfo.GetConstructor (type));
+ } else {
+ left_unwrap.Load (ec);
+ }
+ } else {
+ right_unwrap.Load (ec);
+ }
- ig.MarkLabel (end_label);
+ ec.MarkLabel (end_label);
}
//
//
void EmitEquality (EmitContext ec)
{
- ILGenerator ig = ec.ig;
-
//
// Either left or right is null
//
- if (left_unwrap != null && (right_null_lifted || right.IsNull)) {
+ if (left_unwrap != null && (IsRightNullLifted || right.IsNull)) {
left_unwrap.EmitCheck (ec);
if (Oper == Binary.Operator.Equality) {
- ig.Emit (OpCodes.Ldc_I4_0);
- ig.Emit (OpCodes.Ceq);
+ ec.Emit (OpCodes.Ldc_I4_0);
+ ec.Emit (OpCodes.Ceq);
}
return;
}
- if (right_unwrap != null && (left_null_lifted || left.IsNull)) {
+ if (right_unwrap != null && (IsLeftNullLifted || left.IsNull)) {
right_unwrap.EmitCheck (ec);
if (Oper == Binary.Operator.Equality) {
- ig.Emit (OpCodes.Ldc_I4_0);
- ig.Emit (OpCodes.Ceq);
+ ec.Emit (OpCodes.Ldc_I4_0);
+ ec.Emit (OpCodes.Ceq);
}
return;
}
- Label dissimilar_label = ig.DefineLabel ();
- Label end_label = ig.DefineLabel ();
+ Label dissimilar_label = ec.DefineLabel ();
+ Label end_label = ec.DefineLabel ();
if (user_operator != null) {
user_operator.Emit (ec);
- ig.Emit (Oper == Operator.Equality ? OpCodes.Brfalse_S : OpCodes.Brtrue_S, dissimilar_label);
+ ec.Emit (Oper == Operator.Equality ? OpCodes.Brfalse_S : OpCodes.Brtrue_S, dissimilar_label);
} else {
left.Emit (ec);
right.Emit (ec);
- ig.Emit (OpCodes.Bne_Un_S, dissimilar_label);
+ ec.Emit (OpCodes.Bne_Un_S, dissimilar_label);
}
if (left_unwrap != null)
if (left_unwrap != null && right_unwrap != null) {
if (Oper == Operator.Inequality)
- ig.Emit (OpCodes.Xor);
+ ec.Emit (OpCodes.Xor);
else
- ig.Emit (OpCodes.Ceq);
+ ec.Emit (OpCodes.Ceq);
} else {
if (Oper == Operator.Inequality) {
- ig.Emit (OpCodes.Ldc_I4_0);
- ig.Emit (OpCodes.Ceq);
+ ec.Emit (OpCodes.Ldc_I4_0);
+ ec.Emit (OpCodes.Ceq);
}
}
- ig.Emit (OpCodes.Br_S, end_label);
+ ec.Emit (OpCodes.Br_S, end_label);
- ig.MarkLabel (dissimilar_label);
+ ec.MarkLabel (dissimilar_label);
if (Oper == Operator.Inequality)
- ig.Emit (OpCodes.Ldc_I4_1);
+ ec.Emit (OpCodes.Ldc_I4_1);
else
- ig.Emit (OpCodes.Ldc_I4_0);
+ ec.Emit (OpCodes.Ldc_I4_0);
- ig.MarkLabel (end_label);
+ ec.MarkLabel (end_label);
}
public override void EmitBranchable (EmitContext ec, Label target, bool onTrue)
{
Emit (ec);
- ec.ig.Emit (onTrue ? OpCodes.Brtrue : OpCodes.Brfalse, target);
+ ec.Emit (onTrue ? OpCodes.Brtrue : OpCodes.Brfalse, target);
}
public override void Emit (EmitContext ec)
return;
}
- ILGenerator ig = ec.ig;
-
- Label is_null_label = ig.DefineLabel ();
- Label end_label = ig.DefineLabel ();
+ Label is_null_label = ec.DefineLabel ();
+ Label end_label = ec.DefineLabel ();
if (left_unwrap != null) {
left_unwrap.EmitCheck (ec);
- ig.Emit (OpCodes.Brfalse, is_null_label);
+ ec.Emit (OpCodes.Brfalse, is_null_label);
}
//
//
if (right_unwrap != null && !left.Equals (right)) {
right_unwrap.EmitCheck (ec);
- ig.Emit (OpCodes.Brfalse, is_null_label);
+ ec.Emit (OpCodes.Brfalse, is_null_label);
}
EmitOperator (ec, left.Type);
if (wrap_ctor != null)
- ig.Emit (OpCodes.Newobj, (ConstructorInfo) wrap_ctor.MetaInfo);
+ ec.Emit (OpCodes.Newobj, wrap_ctor);
- ig.Emit (OpCodes.Br_S, end_label);
- ig.MarkLabel (is_null_label);
+ ec.Emit (OpCodes.Br_S, end_label);
+ ec.MarkLabel (is_null_label);
if ((Oper & Operator.ComparisonMask) != 0) {
- ig.Emit (OpCodes.Ldc_I4_0);
+ ec.Emit (OpCodes.Ldc_I4_0);
} else {
LiftedNull.Create (type, loc).Emit (ec);
}
- ig.MarkLabel (end_label);
+ ec.MarkLabel (end_label);
}
- protected override void EmitOperator (EmitContext ec, Type l)
+ protected override void EmitOperator (EmitContext ec, TypeSpec l)
{
if (user_operator != null) {
user_operator.Emit (ec);
}
if (TypeManager.IsNullableType (l))
- l = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (l) [0]);
+ l = TypeManager.GetTypeArguments (l) [0];
base.EmitOperator (ec, l);
}
- bool IsBitwiseBoolean {
- get {
- return (Oper & Operator.BitwiseMask) != 0 && left_unwrap != null && right_unwrap != null &&
- left_unwrap.Type == TypeManager.bool_type && right_unwrap.Type == TypeManager.bool_type;
- }
- }
-
Expression LiftResult (ResolveContext ec, Expression res_expr)
{
TypeExpr lifted_type;
//
// Avoid double conversion
//
- if (left_unwrap == null || left_null_lifted || !TypeManager.IsEqual (left_unwrap.Type, left.Type) || (left_unwrap != null && right_null_lifted)) {
+ if (left_unwrap == null || IsLeftNullLifted || left_unwrap.Type != left.Type || (left_unwrap != null && IsRightNullLifted)) {
lifted_type = new NullableType (left.Type, loc);
lifted_type = lifted_type.ResolveAsTypeTerminal (ec, false);
if (lifted_type == null)
left = EmptyCast.Create (left, lifted_type.Type);
}
- if (right_unwrap == null || right_null_lifted || !TypeManager.IsEqual (right_unwrap.Type, right.Type) || (right_unwrap != null && left_null_lifted)) {
+ if (left != right && (right_unwrap == null || IsRightNullLifted || right_unwrap.Type != right.Type || (right_unwrap != null && IsLeftNullLifted))) {
lifted_type = new NullableType (right.Type, loc);
lifted_type = lifted_type.ResolveAsTypeTerminal (ec, false);
if (lifted_type == null)
return null;
- if (right is UserCast || right is TypeCast)
- right.Type = lifted_type.Type;
+ var r = right;
+ if (r is ReducedExpression)
+ r = ((ReducedExpression) r).OriginalExpression;
+
+ if (r is UserCast || r is TypeCast)
+ r.Type = lifted_type.Type;
else
right = EmptyCast.Create (right, lifted_type.Type);
}
if (lifted_type == null)
return null;
- wrap_ctor = new NullableInfo (lifted_type.Type).Constructor;
+ wrap_ctor = NullableInfo.GetConstructor (lifted_type.Type);
type = res_expr.Type = lifted_type.Type;
}
- if (left_null_lifted) {
+ if (IsLeftNullLifted) {
left = LiftedNull.Create (right.Type, left.Location);
+ //
+ // Special case for bool?, the result depends on both null right side and left side value
+ //
+ if ((Oper == Operator.BitwiseAnd || Oper == Operator.BitwiseOr) && NullableInfo.GetUnderlyingType (type) == TypeManager.bool_type) {
+ return res_expr;
+ }
+
if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask | Operator.BitwiseMask)) != 0)
return LiftedNull.CreateFromExpression (ec, res_expr);
return CreateNullConstant (ec, right_orig).Resolve (ec);
}
- if (right_null_lifted) {
+ if (IsRightNullLifted) {
right = LiftedNull.Create (left.Type, right.Location);
+ //
+ // Special case for bool?, the result depends on both null right side and left side value
+ //
+ if ((Oper == Operator.BitwiseAnd || Oper == Operator.BitwiseOr) && NullableInfo.GetUnderlyingType (type) == TypeManager.bool_type) {
+ return res_expr;
+ }
+
if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask | Operator.BitwiseMask)) != 0)
return LiftedNull.CreateFromExpression (ec, res_expr);
return res_expr;
}
- protected override Expression ResolveOperatorPredefined (ResolveContext ec, Binary.PredefinedOperator [] operators, bool primitives_only, Type enum_type)
+ protected override Expression ResolveOperatorPredefined (ResolveContext ec, Binary.PredefinedOperator [] operators, bool primitives_only, TypeSpec enum_type)
{
Expression e = base.ResolveOperatorPredefined (ec, operators, primitives_only, enum_type);
// (in unlifted or lifted form) exists for the operation.
//
if (e == null && (Oper & Operator.EqualityMask) != 0) {
- if ((left_null_lifted && right_unwrap != null) || (right_null_lifted && left_unwrap != null))
+ if ((IsLeftNullLifted && right_unwrap != null) || (IsRightNullLifted && left_unwrap != null))
return LiftResult (ec, this);
}
return e;
}
- protected override Expression ResolveUserOperator (ResolveContext ec, Type l, Type r)
+ protected override Expression ResolveUserOperator (ResolveContext ec, Expression left, Expression right)
{
- Expression expr = base.ResolveUserOperator (ec, l, r);
+ //
+ // Try original types first for exact match without unwrapping
+ //
+ Expression expr = base.ResolveUserOperator (ec, left_orig, right_orig);
+ if (expr != null)
+ return expr;
+
+ State orig_state = state;
+
+ //
+ // One side is a nullable type, try to match underlying types
+ //
+ if (left_unwrap != null || right_unwrap != null || (state & (State.RightNullLifted | State.LeftNullLifted)) != 0) {
+ expr = base.ResolveUserOperator (ec, left, right);
+ }
+
if (expr == null)
return null;
+ //
+ // Lift the result in the case it can be null and predefined or user operator
+ // result type is of a value type
+ //
+ if (!TypeManager.IsValueType (expr.Type))
+ return null;
+
+ if (state != orig_state)
+ return expr;
+
expr = LiftResult (ec, expr);
if (expr is Constant)
return expr;
public override Expression CreateExpressionTree (ResolveContext ec)
{
- if (left.Type == TypeManager.null_type)
+ if (left is NullLiteral)
ec.Report.Error (845, loc, "An expression tree cannot contain a coalescing operator with null left side");
UserCast uc = left as UserCast;
if (left.eclass == ExprClass.MethodGroup)
return null;
- Type ltype = left.Type;
+ TypeSpec ltype = left.Type;
//
// If left is a nullable type and an implicit conversion exists from right to underlying type of left,
if (unwrap == null)
return null;
+ //
+ // Reduce (left ?? null) to left
+ //
+ if (right.IsNull)
+ return ReducedExpression.Create (left, this);
+
if (Convert.ImplicitConversionExists (ec, right, unwrap.Type)) {
left = unwrap;
- type = left.Type;
- right = Convert.ImplicitConversion (ec, right, type, loc);
+ ltype = left.Type;
+
+ //
+ // If right is a dynamic expression, the result type is dynamic
+ //
+ if (right.Type == InternalType.Dynamic) {
+ type = right.Type;
+
+ // Need to box underlying value type
+ left = Convert.ImplicitBoxingConversion (left, ltype, type);
+ return this;
+ }
+
+ right = Convert.ImplicitConversion (ec, right, ltype, loc);
+ type = ltype;
return this;
}
} else if (TypeManager.IsReferenceType (ltype)) {
if (Convert.ImplicitConversionExists (ec, right, ltype)) {
//
- // Reduce (constant ?? expr) to constant
+ // If right is a dynamic expression, the result type is dynamic
+ //
+ if (right.Type == InternalType.Dynamic) {
+ type = right.Type;
+ return this;
+ }
+
+ //
+ // Reduce ("foo" ?? expr) to expression
//
Constant lc = left as Constant;
if (lc != null && !lc.IsDefaultValue)
- return new SideEffectConstant (lc, right, loc).Resolve (ec);
+ return ReducedExpression.Create (lc, this).Resolve (ec);
//
// Reduce (left ?? null) to left OR (null-constant ?? right) to right
return ReducedExpression.Create (lc != null ? right : left, this);
right = Convert.ImplicitConversion (ec, right, ltype, loc);
- type = left.Type;
+ type = ltype;
return this;
}
} else {
return null;
}
- Type rtype = right.Type;
+ TypeSpec rtype = right.Type;
if (!Convert.ImplicitConversionExists (ec, unwrap != null ? unwrap : left, rtype) || right.eclass == ExprClass.MethodGroup)
return null;
public override void Emit (EmitContext ec)
{
- ILGenerator ig = ec.ig;
-
- Label end_label = ig.DefineLabel ();
+ Label end_label = ec.DefineLabel ();
if (unwrap != null) {
- Label is_null_label = ig.DefineLabel ();
+ Label is_null_label = ec.DefineLabel ();
unwrap.EmitCheck (ec);
- ig.Emit (OpCodes.Brfalse, is_null_label);
+ ec.Emit (OpCodes.Brfalse, is_null_label);
left.Emit (ec);
- ig.Emit (OpCodes.Br, end_label);
+ ec.Emit (OpCodes.Br, end_label);
- ig.MarkLabel (is_null_label);
+ ec.MarkLabel (is_null_label);
right.Emit (ec);
- ig.MarkLabel (end_label);
+ ec.MarkLabel (end_label);
return;
}
left.Emit (ec);
+ ec.Emit (OpCodes.Dup);
- ig.Emit (OpCodes.Dup);
- ig.Emit (OpCodes.Brtrue, end_label);
+ // Only to make verifier happy
+ if (left.Type.IsGenericParameter)
+ ec.Emit (OpCodes.Box, left.Type);
- ig.Emit (OpCodes.Pop);
- right.Emit (ec);
+ ec.Emit (OpCodes.Brtrue, end_label);
- ig.MarkLabel (end_label);
- }
+ ec.Emit (OpCodes.Pop);
+ right.Emit (ec);
- public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
- {
- left.MutateHoistedGenericType (storey);
- right.MutateHoistedGenericType (storey);
- type = storey.MutateType (type);
+ ec.MarkLabel (end_label);
}
protected override void CloneTo (CloneContext clonectx, Expression t)
if (unwrap == null)
return null;
- underlying = (UnaryMutator) new UnaryMutator (Mode, unwrap).Resolve (ec);
+ underlying = (UnaryMutator) new UnaryMutator (Mode, unwrap, loc).Resolve (ec);
if (underlying == null)
return null;
void DoEmit (EmitContext ec, bool is_expr)
{
- ILGenerator ig = ec.ig;
- Label is_null_label = ig.DefineLabel ();
- Label end_label = ig.DefineLabel ();
+ Label is_null_label = ec.DefineLabel ();
+ Label end_label = ec.DefineLabel ();
unwrap.EmitCheck (ec);
- ig.Emit (OpCodes.Brfalse, is_null_label);
+ ec.Emit (OpCodes.Brfalse, is_null_label);
if (is_expr) {
underlying.Emit (ec);
- ig.Emit (OpCodes.Br_S, end_label);
+ ec.Emit (OpCodes.Br_S, end_label);
} else {
underlying.EmitStatement (ec);
}
- ig.MarkLabel (is_null_label);
+ ec.MarkLabel (is_null_label);
if (is_expr)
LiftedNull.Create (type, loc).Emit (ec);
- ig.MarkLabel (end_label);
+ ec.MarkLabel (end_label);
}
public override void Emit (EmitContext ec)
projects / mono.git / blobdiff