X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fassign.cs;h=19a5e7e6dac9d5137a87f225cf383d69ef9d4768;hb=9d23552efbb02fb4d6410db9fd1ce0a9ca9d08a8;hp=c50c278145b535605db2587691d906f7d104d9e0;hpb=5cf7ad2307b8d94c0bcb9df3204ef330d038e134;p=mono.git

diff --git a/mcs/mcs/assign.cs b/mcs/mcs/assign.cs
index c50c278145b..19a5e7e6dac 100644
--- a/mcs/mcs/assign.cs
+++ b/mcs/mcs/assign.cs
@@ -253,13 +253,6 @@ namespace Mono.CSharp {
 
 			source.Emit (ec);
 
-			// HACK: variable is already emitted when source is an initializer 
-			if (source is NewInitialize) {
-				if (leave_copy)
-					Emit (ec);
-				return;
-			}
-
 			Store (ec);
 
 			if (leave_copy)
@@ -299,6 +292,11 @@ namespace Mono.CSharp {
 				ig.Emit (OpCodes.Ldloca, builder);
 		}
 
+		public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
+		{
+			type = storey.MutateType (type);
+		}
+
 		public bool PointsToAddress {
 			get {
 				return is_address;
@@ -375,20 +373,7 @@ namespace Mono.CSharp {
 				if (resolved != this)
 					return resolved;
 			}
-			
-			if (target.eclass == ExprClass.Variable) {
-				New n = source as New;
-				if (n == null)
-					return this;
-				
-				if (n.HasInitializer) {
-					n.SetTargetVariable (target);
-				} else if (target_type.IsValueType) {
-					n.SetTargetVariable (target);
-					return n;
-				}
-			}
-			
+
 			return this;
 		}
 
@@ -410,7 +395,8 @@ namespace Mono.CSharp {
 
 		void Emit (EmitContext ec, bool is_statement)
 		{
-			((IAssignMethod) target).EmitAssign (ec, source, !is_statement, this is CompoundAssign);
+			IAssignMethod t = (IAssignMethod) target;
+			t.EmitAssign (ec, source, !is_statement, this is CompoundAssign);
 		}
 
 		public override void Emit (EmitContext ec)
@@ -477,7 +463,7 @@ namespace Mono.CSharp {
 		IResolveContext rc;
 
 		public FieldInitializer (FieldBuilder field, Expression expression, IResolveContext rc)
-			: base (new FieldExpr (field, expression.Location, true), expression, expression.Location)
+			: base (new FieldExpr (field, expression.Location), expression, expression.Location)
 		{
 			this.rc = rc;
 			if (!field.IsStatic)
@@ -601,10 +587,9 @@ namespace Mono.CSharp {
 			this.op = op;
 		}
 
-		// !!! What a stupid name
-		public class Helper : Expression {
+		public sealed class TargetExpression : Expression {
 			Expression child;
-			public Helper (Expression child)
+			public TargetExpression (Expression child)
 			{
 				this.child = child;
 				this.loc = child.Location;
@@ -657,44 +642,39 @@ namespace Mono.CSharp {
 			// into a tree, to guarantee that we do not have side
 			// effects.
 			//
-			source = new Binary (op, new Helper (target), original_source, true);
+			source = new Binary (op, new TargetExpression (target), original_source, true);
 			return base.DoResolve (ec);
 		}
 
 		protected override Expression ResolveConversions (EmitContext ec)
 		{
-			// source might have changed to BinaryDelegate
 			Type target_type = target.Type;
-			Type source_type = source.Type;
-			Binary b = source as Binary;
-			if (b == null)
-				return base.ResolveConversions (ec);
-
-			// FIXME: Restrict only to predefined operators
-
-			//
-			// 1. if the source is explicitly convertible to the
-			//    target_type
-			//
-			source = Convert.ExplicitConversion (ec, source, target_type, loc);
-			if (source == null){
-				original_source.Error_ValueCannotBeConverted (ec, loc, target_type, true);
-				return null;
-			}
 
 			//
-			// 2. and the original right side is implicitly convertible to
-			// the type of target
+			// 1. the return type is implicitly convertible to the type of target
 			//
-			if (Convert.ImplicitConversionExists (ec, original_source, target_type))
+			if (Convert.ImplicitConversionExists (ec, source, target_type)) {
+				source = Convert.ImplicitConversion (ec, source, target_type, loc);
 				return this;
+			}
 
 			//
-			// In the spec 2.4 they added: or if type of the target is int
-			// and the operator is a shift operator...
+			// Otherwise, if the selected operator is a predefined operator
 			//
-			if (source_type == TypeManager.int32_type && (b.Oper & Binary.Operator.ShiftMask) != 0)
-				return this;
+			Binary b = source as Binary;
+			if (b != null) {
+				//
+				// 2a. the operator is a shift operator
+				//
+				// 2b. the return type is explicitly convertible to the type of x, and
+				// y is implicitly convertible to the type of x
+				//
+				if ((b.Oper & Binary.Operator.ShiftMask) != 0 ||
+					Convert.ImplicitConversionExists (ec, original_source, target_type)) {
+					source = Convert.ExplicitConversion (ec, source, target_type, loc);
+					return this;
+				}
+			}
 
 			original_source.Error_ValueCannotBeConverted (ec, loc, target_type, false);
 			return null;