X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fnullable.cs;h=8e2dc682bbc0fbbfc2403f8ed3842c0c87c11dd4;hb=2d23bfcbce7a3f7e54dcd5911adb88b244baca35;hp=d8a1d4b82f21f97fa16c648d26715fb0d29c9f66;hpb=217ddc29c40bc8b11f8fbd4800e61db7f4f22bbf;p=mono.git

diff --git a/mcs/mcs/nullable.cs b/mcs/mcs/nullable.cs
index d8a1d4b82f2..8e2dc682bbc 100644
--- a/mcs/mcs/nullable.cs
+++ b/mcs/mcs/nullable.cs
@@ -14,15 +14,14 @@
 using System;
 using System.Reflection;
 using System.Reflection.Emit;
-using System.Collections;
 	
 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;
@@ -30,120 +29,121 @@ namespace Mono.CSharp.Nullable
 			eclass = ExprClass.Type;
 		}
 
-		public NullableType (Type type, Location loc)
+		public NullableType (TypeSpec type, Location loc)
 			: 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 (
-					"System", "Nullable`1", Kind.Struct, true);
+				TypeManager.generic_nullable_type = TypeManager.CoreLookupType (ec.Compiler,
+					"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 (IResolveContext ec, bool silent)
-		{
-			return ResolveAsBaseTerminal (ec, silent);
-		}		
 	}
 
-	public sealed class NullableInfo
+	static class NullableInfo
 	{
-		public readonly Type Type;
-		public readonly Type UnderlyingType;
-		public MethodInfo HasValue;
-		public MethodInfo Value;
-		public MethodInfo GetValueOrDefault;
-		public ConstructorInfo Constructor;
-
-		public NullableInfo (Type type)
-		{
-			Type = type;
-			UnderlyingType = 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);
-			GetValueOrDefault = TypeManager.GetPredefinedMethod (type, "GetValueOrDefault", Location.Null, Type.EmptyTypes);
-
-			HasValue = has_value_pi.GetGetMethod (false);
-			Value = value_pi.GetGetMethod (false);
-#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 ()));
-				return;
-			}
-#endif
-			Constructor = type.GetConstructor (new Type[] { UnderlyingType });
+		public static MethodSpec GetConstructor (TypeSpec nullableType)
+		{
+			return TypeManager.GetPredefinedConstructor (nullableType, Location.Null, GetUnderlyingType (nullableType));
+		}
+
+		public static MethodSpec GetHasValue (TypeSpec nullableType)
+		{
+			return (MethodSpec) MemberCache.FindMember (nullableType,
+				MemberFilter.Method ("get_HasValue", 0, ParametersCompiled.EmptyReadOnlyParameters, null), BindingRestriction.None);
+		}
+
+		public static MethodSpec GetGetValueOrDefault (TypeSpec nullableType)
+		{
+			return (MethodSpec) MemberCache.FindMember (nullableType,
+				MemberFilter.Method ("GetValueOrDefault", 0, ParametersCompiled.EmptyReadOnlyParameters, null), BindingRestriction.None);
+		}
+
+		public static MethodSpec GetValue (TypeSpec nullableType)
+		{
+			return (MethodSpec) MemberCache.FindMember (nullableType,
+				MemberFilter.Method ("get_Value", 0, ParametersCompiled.EmptyReadOnlyParameters, null), BindingRestriction.None);
+		}
+
+		public static TypeSpec GetUnderlyingType (TypeSpec nullableType)
+		{
+			return ((InflatedTypeSpec) nullableType).TypeArguments[0];
+		}
+
+		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;
 
-		protected Unwrap (Expression expr)
+		Unwrap (Expression expr, bool useDefaultValue)
 		{
 			this.expr = expr;
 			this.loc = expr.Location;
+			this.useDefaultValue = useDefaultValue;
+
+			type = NullableInfo.GetUnderlyingType (expr.Type);
+			eclass = expr.eclass;
 		}
 
-		public static Unwrap Create (Expression expr, EmitContext ec)
+		public static Expression Create (Expression expr)
 		{
-			return new Unwrap (expr).Resolve (ec) as Unwrap;
+			//
+			// 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, bool useDefaultValue)
+		{
+			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)
+		protected 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, NullableInfo.GetGetValueOrDefault (expr.Type), null, loc);
+			else
+				Invocation.EmitCall (ec, false, this, NullableInfo.GetValue (expr.Type), 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, NullableInfo.GetHasValue (expr.Type), null, loc);
 		}
 
 		public override bool Equals (object obj)
@@ -189,13 +189,9 @@ namespace Mono.CSharp.Nullable
 				LocalVariable.Emit (ec);
 		}
 
-		public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
+		public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
 		{
-			type = storey.MutateType (type);
-			info.Constructor = storey.MutateConstructor (info.Constructor);
-			info.HasValue = storey.MutateGenericMethod (info.HasValue);
-			info.GetValueOrDefault = storey.MutateGenericMethod (info.GetValueOrDefault);
-			info.Value = storey.MutateGenericMethod (info.Value);
+			return expr.MakeExpression (ctx);
 		}
 
 		public void AddressOf (EmitContext ec, AddressOp mode)
@@ -213,7 +209,7 @@ namespace Mono.CSharp.Nullable
 		LocalTemporary LocalVariable {
 			get {
 				if (temp == null)
-					temp = new LocalTemporary (info.Type);
+					temp = new LocalTemporary (expr.Type);
 				return temp;
 			}
 		}
@@ -229,31 +225,29 @@ namespace Mono.CSharp.Nullable
 		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 Expression CreateExpressionTree (EmitContext ec)
+			public override Expression CreateExpressionTree (ResolveContext ec)
 			{
 				throw new NotSupportedException ("ET");
 			}
 
-			public override Expression DoResolve (EmitContext ec)
+			protected override Expression DoResolve (ResolveContext ec)
 			{
 				return this;
 			}
@@ -261,29 +255,37 @@ namespace Mono.CSharp.Nullable
 			public override void Emit (EmitContext ec)
 			{
 				expr.Emit (ec);
-				ec.ig.Emit (OpCodes.Newobj, info.Constructor);
+				ec.Emit (OpCodes.Newobj, NullableInfo.GetConstructor (type));
 			}
 		}
 	}
 
 	public class Wrap : TypeCast
 	{
-		readonly NullableInfo info;
-
-		protected Wrap (Expression expr, Type type)
+		private Wrap (Expression expr, TypeSpec type)
 			: base (expr, type)
 		{
-			info = new NullableInfo (type);
 			eclass = ExprClass.Value;
 		}
 
-		public static Expression Create (Expression expr, Type type)
+		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, TypeSpec 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, NullableInfo.GetUnderlyingType (type)))
 				return unwrap.Original;
 		
 			return new Wrap (expr, type);
@@ -292,50 +294,41 @@ namespace Mono.CSharp.Nullable
 		public override void Emit (EmitContext ec)
 		{
 			child.Emit (ec);
-			ec.ig.Emit (OpCodes.Newobj, info.Constructor);
+			ec.Emit (OpCodes.Newobj, NullableInfo.GetConstructor (type));
 		}
 	}
 
 	//
 	// 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)
+		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 (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
 			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);
 		}
 
@@ -344,78 +337,81 @@ namespace Mono.CSharp.Nullable
 			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);
 		}
 	}
 
-	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, TypeSpec type)
 		{
 			this.expr = expr;
-			this.loc = loc;
+			this.unwrap = unwrap;
+			this.loc = expr.Location;
+			this.type = type;
+		}
+
+		public Lifted (Expression expr, Expression unwrap, TypeSpec 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)
+		protected 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;
-			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);
 
-			wrap.Emit (ec);
-			ig.Emit (OpCodes.Br, end_label);
+			ec.Emit (OpCodes.Br, end_label);
+			ec.MarkLabel (is_null_label);
 
-			ig.MarkLabel (is_null_label);
 			null_value.Emit (ec);
-
-			ig.MarkLabel (end_label);
+			ec.MarkLabel (end_label);
 		}
 
 		public void AddressOf (EmitContext ec, AddressOp mode)
@@ -424,46 +420,13 @@ 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;
 		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)
 		{
 		}
 
@@ -472,7 +435,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 +446,9 @@ namespace Mono.CSharp.Nullable
 			return base.CreateExpressionTree (ec);
 		}
 
-		public override Expression DoResolve (EmitContext ec)
+		protected 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;
 
@@ -510,31 +470,28 @@ namespace Mono.CSharp.Nullable
 
 		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, ni.Constructor);
-			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 (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 +502,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 +512,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)
@@ -579,16 +536,14 @@ namespace Mono.CSharp.Nullable
 		bool left_null_lifted, right_null_lifted;
 		Expression left_orig, right_orig;
 		Expression user_operator;
-		ConstructorInfo wrap_ctor;
+		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;
 		}
 
-		public override Expression CreateExpressionTree (EmitContext ec)
+		public override Expression CreateExpressionTree (ResolveContext ec)
 		{
 			if (user_operator != null)
 				return user_operator.CreateExpressionTree (ec);
@@ -601,42 +556,40 @@ 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);
+			Constant c = new BoolConstant (Oper == Operator.Inequality, loc).Resolve (ec);
 
 			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)
+		protected 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 +599,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;
@@ -664,23 +617,21 @@ namespace Mono.CSharp.Nullable
 
 		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 ();
+			left_unwrap.Emit (ec);
+			ec.Emit (OpCodes.Brtrue_S, load_right);
 
-			left_unwrap.EmitGetValueOrDefault (ec);
-			ig.Emit (OpCodes.Brtrue_S, load_right);
-
-			right_unwrap.EmitGetValueOrDefault (ec);
-			ig.Emit (OpCodes.Brtrue_S, load_left);
+			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);
@@ -688,94 +639,87 @@ namespace Mono.CSharp.Nullable
 				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);
+			ec.MarkLabel (load_right);
 			right_unwrap.Load (ec);
 
-			ig.MarkLabel (end_label);
+			ec.MarkLabel (end_label);
 		}
 
 		//
 		// Emits optimized equality or inequality operator when possible
 		//
-		bool EmitEquality (EmitContext ec)
+		void EmitEquality (EmitContext ec)
 		{
-			ILGenerator ig = ec.ig;
-
 			//
 			// Either left or right is null
 			//
 			if (left_unwrap != null && (right_null_lifted || 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 true;
+				return;
 			}
 
 			if (right_unwrap != null && (left_null_lifted || 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 true;
+				return;
 			}
 
-			if (user_operator != null)
-				return false;
-
-			Label dissimilar_label = ig.DefineLabel ();
-			Label end_label = ig.DefineLabel ();
+			Label dissimilar_label = ec.DefineLabel ();
+			Label end_label = ec.DefineLabel ();
 
-			if (left_unwrap != null)
-				left_unwrap.EmitGetValueOrDefault (ec);
-			else
+			if (user_operator != null) {
+				user_operator.Emit (ec);
+				ec.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);
+				ec.Emit (OpCodes.Bne_Un_S, dissimilar_label);
+			}
 
 			if (left_unwrap != null)
 				left_unwrap.EmitCheck (ec);
+
 			if (right_unwrap != null)
 				right_unwrap.EmitCheck (ec);
 
 			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);
-			return true;
+			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)
@@ -792,18 +736,16 @@ namespace Mono.CSharp.Nullable
 			}
 
 			if ((Oper & Operator.EqualityMask) != 0) {
-				if (EmitEquality (ec))
-					return;
+				EmitEquality (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);
 			}
 
 			//
@@ -811,35 +753,27 @@ namespace Mono.CSharp.Nullable
 			//
 			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, wrap_ctor);
+				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) {
-				//
-				// 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);
+				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);
@@ -859,7 +793,7 @@ namespace Mono.CSharp.Nullable
 			}
 		}
 
-		Expression LiftResult (EmitContext ec, Expression res_expr)
+		Expression LiftResult (ResolveContext ec, Expression res_expr)
 		{
 			TypeExpr lifted_type;
 
@@ -896,40 +830,40 @@ namespace Mono.CSharp.Nullable
 				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) {
 				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);
 			}
 
 			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, TypeSpec enum_type)
 		{
 			Expression e = base.ResolveOperatorPredefined (ec, operators, primitives_only, enum_type);
 
@@ -951,7 +885,7 @@ namespace Mono.CSharp.Nullable
 			return e;
 		}
 
-		protected override Expression ResolveUserOperator (EmitContext ec, Type l, Type r)
+		protected override Expression ResolveUserOperator (ResolveContext ec, TypeSpec l, TypeSpec r)
 		{
 			Expression expr = base.ResolveUserOperator (ec, l, r);
 			if (expr == null)
@@ -979,45 +913,45 @@ 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)
 				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,
 			// 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;
 
@@ -1040,7 +974,7 @@ namespace Mono.CSharp.Nullable
 					// Reduce (left ?? null) to left OR (null-constant ?? right) to right
 					//
 					if (right.IsNull || lc != null)
-						return ReducedExpression.Create (lc != null ? right : left, this).Resolve (ec);
+						return ReducedExpression.Create (lc != null ? right : left, this);
 
 					right = Convert.ImplicitConversion (ec, right, ltype, loc);
 					type = left.Type;
@@ -1050,7 +984,7 @@ namespace Mono.CSharp.Nullable
 				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;
 
@@ -1058,18 +992,15 @@ namespace Mono.CSharp.Nullable
 			// Reduce (null ?? right) to right
 			//
 			if (left.IsNull)
-				return ReducedExpression.Create (right, this).Resolve (ec);
+				return ReducedExpression.Create (right, this);
 
 			left = Convert.ImplicitConversion (ec, unwrap != null ? unwrap : left, rtype, loc);
 			type = rtype;
 			return this;
 		}
 
-		public override Expression DoResolve (EmitContext ec)
+		protected override Expression DoResolve (ResolveContext ec)
 		{
-			if (eclass != ExprClass.Invalid)
-				return this;
-
 			left = left.Resolve (ec);
 			right = right.Resolve (ec);
 
@@ -1080,7 +1011,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;
 			}
 
@@ -1089,42 +1020,33 @@ namespace Mono.CSharp.Nullable
 
 		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);
 
-			ig.Emit (OpCodes.Dup);
-			ig.Emit (OpCodes.Brtrue, end_label);
+			ec.Emit (OpCodes.Dup);
+			ec.Emit (OpCodes.Brtrue, end_label);
 
-			ig.Emit (OpCodes.Pop);
+			ec.Emit (OpCodes.Pop);
 			right.Emit (ec);
 
-			ig.MarkLabel (end_label);
-		}
-
-		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)
@@ -1148,54 +1070,53 @@ namespace Mono.CSharp.Nullable
 			this.expr = expr;
 			this.Mode = mode;
 			this.loc = loc;
-
-			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)
+		protected 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;
 
-			underlying = (UnaryMutator) new UnaryMutator (Mode, unwrap).Resolve (ec);
+			underlying = (UnaryMutator) new UnaryMutator (Mode, unwrap, loc).Resolve (ec);
 			if (underlying == null)
 				return null;
 
+
+			eclass = ExprClass.Value;
 			type = expr.Type;
 			return this;
 		}
 
 		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)