X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fnullable.cs;h=307ebfb5d32515543b1ad707ecb54863d979d330;hb=67dae6e4154448e87f29b3b4b13f8cc364b7ef83;hp=d8a1d4b82f21f97fa16c648d26715fb0d29c9f66;hpb=217ddc29c40bc8b11f8fbd4800e61db7f4f22bbf;p=mono.git diff --git a/mcs/mcs/nullable.cs b/mcs/mcs/nullable.cs index d8a1d4b82f2..307ebfb5d32 100644 --- a/mcs/mcs/nullable.cs +++ b/mcs/mcs/nullable.cs @@ -20,9 +20,9 @@ namespace Mono.CSharp.Nullable { public class NullableType : TypeExpr { - Expression underlying; + TypeExpr underlying; - public NullableType (Expression underlying, Location l) + public NullableType (TypeExpr underlying, Location l) { this.underlying = underlying; loc = l; @@ -34,21 +34,19 @@ namespace Mono.CSharp.Nullable : this (new TypeExpression (type, loc), loc) { } - protected override TypeExpr DoResolveAsTypeStep (IResolveContext ec) + protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec) { - TypeArguments args = new TypeArguments (loc); - args.Add (underlying); - if (TypeManager.generic_nullable_type == null) { - TypeManager.generic_nullable_type = TypeManager.CoreLookupType ( + TypeManager.generic_nullable_type = TypeManager.CoreLookupType (ec.Compiler, "System", "Nullable`1", Kind.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 (IResolveContext ec, bool silent) + public override TypeExpr ResolveAsTypeTerminal (IMemberContext ec, bool silent) { return ResolveAsBaseTerminal (ec, silent); } @@ -66,7 +64,7 @@ namespace Mono.CSharp.Nullable public NullableInfo (Type type) { Type = type; - UnderlyingType = TypeManager.GetTypeArguments (type) [0]; + UnderlyingType = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (type) [0]); PropertyInfo has_value_pi = TypeManager.GetPredefinedProperty (type, "HasValue", Location.Null, Type.EmptyTypes); PropertyInfo value_pi = TypeManager.GetPredefinedProperty (type, "Value", Location.Null, Type.EmptyTypes); @@ -74,14 +72,26 @@ namespace Mono.CSharp.Nullable HasValue = has_value_pi.GetGetMethod (false); Value = value_pi.GetGetMethod (false); + + // When compiling corlib + if (TypeManager.IsBeingCompiled (type)) { + TypeContainer tc = TypeManager.LookupGenericTypeContainer (type); + + // TODO: check for correct overload + Constructor c = ((Constructor) tc.InstanceConstructors [0]); + + Constructor = TypeBuilder.GetConstructor (type, c.ConstructorBuilder); + return; + } + #if MS_COMPATIBLE - if (UnderlyingType.Module == CodeGen.Module.Builder) { - Type o_type = TypeManager.DropGenericTypeArguments (type); - Constructor = TypeBuilder.GetConstructor (type, - TypeManager.GetPredefinedConstructor (o_type, Location.Null, o_type.GetGenericArguments ())); + if (TypeManager.IsBeingCompiled (UnderlyingType)) { + ConstructorInfo cinfo = TypeManager.DropGenericTypeArguments (type).GetConstructors ()[0]; + Constructor = TypeBuilder.GetConstructor (type, cinfo); return; } #endif + Constructor = type.GetConstructor (new Type[] { UnderlyingType }); } } @@ -92,58 +102,64 @@ namespace Mono.CSharp.Nullable NullableInfo info; LocalTemporary temp; + readonly bool useDefaultValue; - protected Unwrap (Expression expr) + Unwrap (Expression expr, bool useDefaultValue) { this.expr = expr; this.loc = expr.Location; + this.useDefaultValue = useDefaultValue; + + info = new NullableInfo (expr.Type); + type = info.UnderlyingType; + eclass = expr.eclass; + } + + public static Expression Create (Expression expr) + { + // + // Avoid unwraping and wraping of same type + // + Wrap wrap = expr as Wrap; + if (wrap != null) + return wrap.Child; + + return Create (expr, false); } - public static Unwrap Create (Expression expr, EmitContext ec) + public static Unwrap Create (Expression expr, bool useDefaultValue) { - return new Unwrap (expr).Resolve (ec) as Unwrap; + return new Unwrap (expr, useDefaultValue); } - public override Expression CreateExpressionTree (EmitContext ec) + public override Expression CreateExpressionTree (ResolveContext ec) { return expr.CreateExpressionTree (ec); - } + } - public override Expression DoResolve (EmitContext ec) + public override Expression DoResolve (ResolveContext ec) { - if (expr == null) - return null; - - info = new NullableInfo (expr.Type); - type = info.UnderlyingType; - eclass = expr.eclass; return this; } - - public override Expression DoResolveLValue (EmitContext ec, Expression right_side) + + public override Expression DoResolveLValue (ResolveContext ec, Expression right_side) { return DoResolve (ec); - } + } public override void Emit (EmitContext ec) { Store (ec); - AddressOf (ec, AddressOp.LoadStore); - ec.ig.EmitCall (OpCodes.Call, info.Value, null); + if (useDefaultValue) + Invocation.EmitCall (ec, false, this, info.GetValueOrDefault, null, loc); + else + Invocation.EmitCall (ec, false, this, info.Value, null, loc); } public void EmitCheck (EmitContext ec) { Store (ec); - AddressOf (ec, AddressOp.LoadStore); - ec.ig.EmitCall (OpCodes.Call, info.HasValue, null); - } - - public void EmitGetValueOrDefault (EmitContext ec) - { - Store (ec); - AddressOf (ec, AddressOp.LoadStore); - ec.ig.EmitCall (OpCodes.Call, info.GetValueOrDefault, null); + Invocation.EmitCall (ec, false, this, info.HasValue, null, loc); } public override bool Equals (object obj) @@ -189,6 +205,13 @@ namespace Mono.CSharp.Nullable LocalVariable.Emit (ec); } +#if NET_4_0 + public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx) + { + return expr.MakeExpression (ctx); + } +#endif + public override void MutateHoistedGenericType (AnonymousMethodStorey storey) { type = storey.MutateType (type); @@ -248,12 +271,12 @@ namespace Mono.CSharp.Nullable eclass = ExprClass.Value; } - public override Expression CreateExpressionTree (EmitContext ec) + public override Expression CreateExpressionTree (ResolveContext ec) { throw new NotSupportedException ("ET"); } - public override Expression DoResolve (EmitContext ec) + public override Expression DoResolve (ResolveContext ec) { return this; } @@ -277,13 +300,28 @@ namespace Mono.CSharp.Nullable eclass = ExprClass.Value; } + public Expression Child { + get { return child; } + } + + public override Expression CreateExpressionTree (ResolveContext ec) + { + TypeCast child_cast = child as TypeCast; + if (child_cast != null) { + child.Type = type; + return child_cast.CreateExpressionTree (ec); + } + + return base.CreateExpressionTree (ec); + } + public static Expression Create (Expression expr, Type type) { // // Avoid unwraping and wraping of the same type // Unwrap unwrap = expr as Unwrap; - if (unwrap != null && TypeManager.IsEqual (expr.Type, TypeManager.GetTypeArguments (type) [0])) + if (unwrap != null && TypeManager.IsEqual (expr.Type, TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (type) [0]))) return unwrap.Original; return new Wrap (expr, type); @@ -299,10 +337,10 @@ namespace Mono.CSharp.Nullable // // Represents null literal lifted to nullable type // - public class LiftedNull : EmptyConstantCast, IMemoryLocation + public class LiftedNull : NullConstant, IMemoryLocation { private LiftedNull (Type nullable_type, Location loc) - : base (new NullLiteral (loc), nullable_type) + : base (nullable_type, loc) { eclass = ExprClass.Value; } @@ -312,23 +350,14 @@ namespace Mono.CSharp.Nullable return new LiftedNull (nullable, loc); } - public static Expression CreateFromExpression (Expression e) + public static Expression CreateFromExpression (ResolveContext ec, Expression e) { - Report.Warning (458, 2, e.Location, "The result of the expression is always `null' of type `{0}'", + ec.Report.Warning (458, 2, e.Location, "The result of the expression is always `null' of type `{0}'", TypeManager.CSharpName (e.Type)); return ReducedExpression.Create (Create (e.Type, e.Location), e); } - public override Expression CreateExpressionTree (EmitContext ec) - { - ArrayList args = new ArrayList (2); - args.Add (new Argument (this)); - args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc))); - - return CreateExpressionFactoryCall ("Constant", args); - } - public override void Emit (EmitContext ec) { // TODO: generate less temporary variables @@ -349,57 +378,61 @@ namespace Mono.CSharp.Nullable } } - public abstract class Lifted : Expression, IMemoryLocation + // + // Generic lifting expression, supports all S/S? -> T/T? cases + // + public class Lifted : Expression, IMemoryLocation { - Expression expr, underlying, wrap, null_value; + Expression expr, null_value; Unwrap unwrap; - protected Lifted (Expression expr, Location loc) + public Lifted (Expression expr, Unwrap unwrap, Type type) { this.expr = expr; - this.loc = loc; + this.unwrap = unwrap; + this.loc = expr.Location; + this.type = type; + } + + public Lifted (Expression expr, Expression unwrap, Type type) + : this (expr, unwrap as Unwrap, type) + { } - public override Expression CreateExpressionTree (EmitContext ec) + public override Expression CreateExpressionTree (ResolveContext ec) { - ArrayList args = new ArrayList (2); - args.Add (new Argument (expr.CreateExpressionTree (ec))); - args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc))); - return CreateExpressionFactoryCall ("Convert", args); + return expr.CreateExpressionTree (ec); } - public override Expression DoResolve (EmitContext ec) + public override Expression DoResolve (ResolveContext ec) { - expr = expr.Resolve (ec); - if (expr == null) - return null; - - unwrap = Unwrap.Create (expr, ec); - if (unwrap == null) - return null; - - underlying = ResolveUnderlying (unwrap, ec); - if (underlying == null) - return null; + // + // It's null when lifting non-nullable type + // + if (unwrap == null) { + // S -> T? is wrap only + if (TypeManager.IsNullableType (type)) + return Wrap.Create (expr, type); - TypeExpr target_type = new NullableType (underlying.Type, loc); - target_type = target_type.ResolveAsTypeTerminal (ec, false); - if (target_type == null) - return null; + // S -> T can be simplified + return expr; + } - wrap = Wrap.Create (underlying, target_type.Type); - if (wrap == null) - return null; + // Wrap target for T? + if (TypeManager.IsNullableType (type)) { + expr = Wrap.Create (expr, type); + if (expr == null) + return null; - null_value = LiftedNull.Create (wrap.Type, loc); + null_value = LiftedNull.Create (type, loc); + } else { + null_value = new NullConstant (type, loc); + } - type = wrap.Type; eclass = ExprClass.Value; return this; } - protected abstract Expression ResolveUnderlying (Expression unwrap, EmitContext ec); - public override void Emit (EmitContext ec) { ILGenerator ig = ec.ig; @@ -409,12 +442,12 @@ namespace Mono.CSharp.Nullable unwrap.EmitCheck (ec); ig.Emit (OpCodes.Brfalse, is_null_label); - wrap.Emit (ec); - ig.Emit (OpCodes.Br, end_label); + expr.Emit (ec); + ig.Emit (OpCodes.Br, end_label); ig.MarkLabel (is_null_label); - null_value.Emit (ec); + null_value.Emit (ec); ig.MarkLabel (end_label); } @@ -424,39 +457,6 @@ namespace Mono.CSharp.Nullable } } - public class LiftedConversion : Lifted - { - public readonly bool IsUser; - public readonly bool IsExplicit; - public readonly Type TargetType; - - public LiftedConversion (Expression expr, Type target_type, bool is_user, - bool is_explicit, Location loc) - : base (expr, loc) - { - this.IsUser = is_user; - this.IsExplicit = is_explicit; - this.TargetType = target_type; - } - - protected override Expression ResolveUnderlying (Expression unwrap, EmitContext ec) - { - Type type = TypeManager.GetTypeArguments (TargetType) [0]; - - if (IsUser) { - if (IsExplicit) - return Convert.ExplicitUserConversion (ec, unwrap, type, loc); - else - return Convert.ImplicitUserConversion (ec, unwrap, type, loc); - } else { - if (IsExplicit) - return Convert.ExplicitConversion (ec, unwrap, type, loc); - else - return Convert.ImplicitConversion (ec, unwrap, type, loc); - } - } - } - public class LiftedUnaryOperator : Unary, IMemoryLocation { Unwrap unwrap; @@ -472,7 +472,7 @@ namespace Mono.CSharp.Nullable unwrap.AddressOf (ec, mode); } - public override Expression CreateExpressionTree (EmitContext ec) + public override Expression CreateExpressionTree (ResolveContext ec) { if (user_operator != null) return user_operator.CreateExpressionTree (ec); @@ -483,12 +483,12 @@ namespace Mono.CSharp.Nullable return base.CreateExpressionTree (ec); } - public override Expression DoResolve (EmitContext ec) + public override Expression DoResolve (ResolveContext ec) { if (eclass != ExprClass.Invalid) return this; - unwrap = Unwrap.Create (Expr, ec); + unwrap = Unwrap.Create (Expr, false); if (unwrap == null) return null; @@ -534,7 +534,7 @@ namespace Mono.CSharp.Nullable ig.MarkLabel (end_label); } - Expression LiftExpression (EmitContext ec, Expression expr) + Expression LiftExpression (ResolveContext ec, Expression expr) { TypeExpr lifted_type = new NullableType (expr.Type, expr.Location); lifted_type = lifted_type.ResolveAsTypeTerminal (ec, false); @@ -545,7 +545,7 @@ namespace Mono.CSharp.Nullable return expr; } - protected override Expression ResolveEnumOperator (EmitContext ec, Expression expr) + protected override Expression ResolveEnumOperator (ResolveContext ec, Expression expr) { expr = base.ResolveEnumOperator (ec, expr); if (expr == null) @@ -555,7 +555,7 @@ namespace Mono.CSharp.Nullable return LiftExpression (ec, expr); } - protected override Expression ResolveUserOperator (EmitContext ec, Expression expr) + protected override Expression ResolveUserOperator (ResolveContext ec, Expression expr) { expr = base.ResolveUserOperator (ec, expr); if (expr == null) @@ -588,7 +588,7 @@ namespace Mono.CSharp.Nullable this.loc = loc; } - public override Expression CreateExpressionTree (EmitContext ec) + public override Expression CreateExpressionTree (ResolveContext ec) { if (user_operator != null) return user_operator.CreateExpressionTree (ec); @@ -601,42 +601,43 @@ namespace Mono.CSharp.Nullable // with the null literal *outside* of a generics context and // inlines that as true or false. // - Expression CreateNullConstant (Expression expr) + Expression CreateNullConstant (ResolveContext ec, Expression expr) { // FIXME: Handle side effect constants Constant c = new BoolConstant (Oper == Operator.Inequality, loc); if ((Oper & Operator.EqualityMask) != 0) { - Report.Warning (472, 2, loc, "The result of comparing value type `{0}' with null is `{1}'", - expr.GetSignatureForError (), c.AsString ()); + ec.Report.Warning (472, 2, loc, "The result of comparing value type `{0}' with null is `{1}'", + TypeManager.CSharpName (expr.Type), c.AsString ()); } else { - Report.Warning (464, 2, loc, "The result of comparing type `{0}' with null is always `{1}'", - expr.GetSignatureForError (), c.AsString ()); + ec.Report.Warning (464, 2, loc, "The result of comparing type `{0}' with null is always `{1}'", + TypeManager.CSharpName (expr.Type), c.AsString ()); } return ReducedExpression.Create (c, this); } - public override Expression DoResolve (EmitContext ec) + public override Expression DoResolve (ResolveContext ec) { if (eclass != ExprClass.Invalid) return this; if ((Oper & Operator.LogicalMask) != 0) { - Error_OperatorCannotBeApplied (left, right); + Error_OperatorCannotBeApplied (ec, left, right); return null; } + bool use_default_call = (Oper & (Operator.BitwiseMask | Operator.EqualityMask)) != 0; left_orig = left; if (TypeManager.IsNullableType (left.Type)) { - left = left_unwrap = Unwrap.Create (left, ec); + left = left_unwrap = Unwrap.Create (left, use_default_call); if (left == null) return null; } right_orig = right; if (TypeManager.IsNullableType (right.Type)) { - right = right_unwrap = Unwrap.Create (right, ec); + right = right_unwrap = Unwrap.Create (right, use_default_call); if (right == null) return null; } @@ -646,13 +647,13 @@ namespace Mono.CSharp.Nullable // Arguments can be lifted for equal operators when the return type is bool and both // arguments are of same type // - if (left is NullLiteral) { + if (left_orig.IsNull) { left = right; left_null_lifted = true; type = TypeManager.bool_type; } - if (right is NullLiteral) { + if (right_orig.IsNull) { right = left; right_null_lifted = true; type = TypeManager.bool_type; @@ -670,10 +671,10 @@ namespace Mono.CSharp.Nullable Label load_right = ig.DefineLabel (); Label end_label = ig.DefineLabel (); - left_unwrap.EmitGetValueOrDefault (ec); + left_unwrap.Emit (ec); ig.Emit (OpCodes.Brtrue_S, load_right); - right_unwrap.EmitGetValueOrDefault (ec); + right_unwrap.Emit (ec); ig.Emit (OpCodes.Brtrue_S, load_left); left_unwrap.EmitCheck (ec); @@ -700,7 +701,7 @@ namespace Mono.CSharp.Nullable // // Emits optimized equality or inequality operator when possible // - bool EmitEquality (EmitContext ec) + void EmitEquality (EmitContext ec) { ILGenerator ig = ec.ig; @@ -713,7 +714,7 @@ namespace Mono.CSharp.Nullable ig.Emit (OpCodes.Ldc_I4_0); ig.Emit (OpCodes.Ceq); } - return true; + return; } if (right_unwrap != null && (left_null_lifted || left.IsNull)) { @@ -722,29 +723,25 @@ namespace Mono.CSharp.Nullable ig.Emit (OpCodes.Ldc_I4_0); ig.Emit (OpCodes.Ceq); } - return true; + return; } - if (user_operator != null) - return false; - Label dissimilar_label = ig.DefineLabel (); Label end_label = ig.DefineLabel (); - if (left_unwrap != null) - left_unwrap.EmitGetValueOrDefault (ec); - else + if (user_operator != null) { + user_operator.Emit (ec); + ig.Emit (Oper == Operator.Equality ? OpCodes.Brfalse_S : OpCodes.Brtrue_S, dissimilar_label); + } else { left.Emit (ec); - - if (right_unwrap != null) - right_unwrap.EmitGetValueOrDefault (ec); - else right.Emit (ec); - ig.Emit (OpCodes.Bne_Un_S, dissimilar_label); + ig.Emit (OpCodes.Bne_Un_S, dissimilar_label); + } if (left_unwrap != null) left_unwrap.EmitCheck (ec); + if (right_unwrap != null) right_unwrap.EmitCheck (ec); @@ -769,7 +766,6 @@ namespace Mono.CSharp.Nullable ig.Emit (OpCodes.Ldc_I4_0); ig.MarkLabel (end_label); - return true; } public override void EmitBranchable (EmitContext ec, Label target, bool onTrue) @@ -792,8 +788,8 @@ namespace Mono.CSharp.Nullable } if ((Oper & Operator.EqualityMask) != 0) { - if (EmitEquality (ec)) - return; + EmitEquality (ec); + return; } ILGenerator ig = ec.ig; @@ -823,15 +819,7 @@ namespace Mono.CSharp.Nullable ig.MarkLabel (is_null_label); if ((Oper & Operator.ComparisonMask) != 0) { - // - // Emit true when equality operator both operands are null - // or inequality operator operands has only one null - // - if ((Oper == Operator.Equality && left_unwrap != null && right_unwrap != null) || - (Oper == Operator.Inequality && left_unwrap != right_unwrap)) - ig.Emit (OpCodes.Ldc_I4_1); - else - ig.Emit (OpCodes.Ldc_I4_0); + ig.Emit (OpCodes.Ldc_I4_0); } else { LiftedNull.Create (type, loc).Emit (ec); } @@ -847,7 +835,7 @@ namespace Mono.CSharp.Nullable } if (TypeManager.IsNullableType (l)) - l = TypeManager.GetTypeArguments (l) [0]; + l = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (l) [0]); base.EmitOperator (ec, l); } @@ -859,7 +847,7 @@ namespace Mono.CSharp.Nullable } } - Expression LiftResult (EmitContext ec, Expression res_expr) + Expression LiftResult (ResolveContext ec, Expression res_expr) { TypeExpr lifted_type; @@ -903,33 +891,33 @@ namespace Mono.CSharp.Nullable if (left_null_lifted) { left = LiftedNull.Create (right.Type, left.Location); - if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask)) != 0) - return LiftedNull.CreateFromExpression (res_expr); + if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask | Operator.BitwiseMask)) != 0) + return LiftedNull.CreateFromExpression (ec, res_expr); // // Value types and null comparison // if (right_unwrap == null || (Oper & Operator.RelationalMask) != 0) - return CreateNullConstant (right_orig).Resolve (ec); + return CreateNullConstant (ec, right_orig).Resolve (ec); } if (right_null_lifted) { right = LiftedNull.Create (left.Type, right.Location); - if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask)) != 0) - return LiftedNull.CreateFromExpression (res_expr); + if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask | Operator.BitwiseMask)) != 0) + return LiftedNull.CreateFromExpression (ec, res_expr); // // Value types and null comparison // if (left_unwrap == null || (Oper & Operator.RelationalMask) != 0) - return CreateNullConstant (left_orig).Resolve (ec); + return CreateNullConstant (ec, left_orig).Resolve (ec); } return res_expr; } - protected override Expression ResolveOperatorPredefined (EmitContext ec, Binary.PredefinedOperator [] operators, bool primitives_only, Type enum_type) + protected override Expression ResolveOperatorPredefined (ResolveContext ec, Binary.PredefinedOperator [] operators, bool primitives_only, Type enum_type) { Expression e = base.ResolveOperatorPredefined (ec, operators, primitives_only, enum_type); @@ -951,7 +939,7 @@ namespace Mono.CSharp.Nullable return e; } - protected override Expression ResolveUserOperator (EmitContext ec, Type l, Type r) + protected override Expression ResolveUserOperator (ResolveContext ec, Type l, Type r) { Expression expr = base.ResolveUserOperator (ec, l, r); if (expr == null) @@ -979,32 +967,32 @@ namespace Mono.CSharp.Nullable this.loc = loc; } - public override Expression CreateExpressionTree (EmitContext ec) + public override Expression CreateExpressionTree (ResolveContext ec) { - if (left is NullLiteral) - Report.Error (845, loc, "An expression tree cannot contain a coalescing operator with null left side"); + if (left.Type == TypeManager.null_type) + ec.Report.Error (845, loc, "An expression tree cannot contain a coalescing operator with null left side"); UserCast uc = left as UserCast; Expression conversion = null; if (uc != null) { left = uc.Source; - ArrayList c_args = new ArrayList (2); + Arguments c_args = new Arguments (2); c_args.Add (new Argument (uc.CreateExpressionTree (ec))); c_args.Add (new Argument (left.CreateExpressionTree (ec))); - conversion = CreateExpressionFactoryCall ("Lambda", c_args); + conversion = CreateExpressionFactoryCall (ec, "Lambda", c_args); } - ArrayList args = new ArrayList (3); + Arguments args = new Arguments (3); args.Add (new Argument (left.CreateExpressionTree (ec))); args.Add (new Argument (right.CreateExpressionTree (ec))); if (conversion != null) args.Add (new Argument (conversion)); - return CreateExpressionFactoryCall ("Coalesce", args); + return CreateExpressionFactoryCall (ec, "Coalesce", args); } - Expression ConvertExpression (EmitContext ec) + Expression ConvertExpression (ResolveContext ec) { // TODO: ImplicitConversionExists should take care of this if (left.eclass == ExprClass.MethodGroup) @@ -1017,7 +1005,7 @@ namespace Mono.CSharp.Nullable // the result is underlying type of left // if (TypeManager.IsNullableType (ltype)) { - unwrap = Unwrap.Create (left, ec); + unwrap = Unwrap.Create (left, false); if (unwrap == null) return null; @@ -1065,7 +1053,7 @@ namespace Mono.CSharp.Nullable return this; } - public override Expression DoResolve (EmitContext ec) + public override Expression DoResolve (ResolveContext ec) { if (eclass != ExprClass.Invalid) return this; @@ -1080,7 +1068,7 @@ namespace Mono.CSharp.Nullable Expression e = ConvertExpression (ec); if (e == null) { - Binary.Error_OperatorCannotBeApplied (left, right, "??", loc); + Binary.Error_OperatorCannotBeApplied (ec, left, right, "??", loc); return null; } @@ -1152,18 +1140,18 @@ namespace Mono.CSharp.Nullable eclass = ExprClass.Value; } - public override Expression CreateExpressionTree (EmitContext ec) + public override Expression CreateExpressionTree (ResolveContext ec) { return new SimpleAssign (this, this).CreateExpressionTree (ec); } - public override Expression DoResolve (EmitContext ec) + public override Expression DoResolve (ResolveContext ec) { expr = expr.Resolve (ec); if (expr == null) return null; - unwrap = Unwrap.Create (expr, ec); + unwrap = Unwrap.Create (expr, false); if (unwrap == null) return null;