X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fgmcs%2Fexpression.cs;h=3985cd5818cf8a0f8661dba3622bf71368784743;hb=38f320d19a29a3e7d6a92cdb0b3ebec149d7c1a7;hp=fc32bfb5e02a3dbb8b9d92443ffc24e8fc846db1;hpb=1380cd3dc0fa08bb417bf1689255cd21ada3c192;p=mono.git

diff --git a/mcs/gmcs/expression.cs b/mcs/gmcs/expression.cs
index fc32bfb5e02..3985cd5818c 100644
--- a/mcs/gmcs/expression.cs
+++ b/mcs/gmcs/expression.cs
@@ -359,7 +359,7 @@ namespace Mono.CSharp {
 			
 			op_name = oper_names [(int) Oper];
 
-			mg = MemberLookup (ec.ContainerType, expr_type, op_name, MemberTypes.Method, AllBindingFlags, loc);
+			mg = MemberLookup (ec, expr_type, op_name, MemberTypes.Method, AllBindingFlags, loc);
 			
 			if (mg != null) {
 				Expression e = StaticCallExpr.MakeSimpleCall (
@@ -458,9 +458,8 @@ namespace Mono.CSharp {
 
 				// According to the specs, a variable is considered definitely assigned if you take
 				// its address.
-				if ((variable != null) && (variable.VariableInfo != null)){
+				if ((variable != null) && (variable.VariableInfo != null))
 					variable.VariableInfo.SetAssigned (ec);
-				}
 
 				type = TypeManager.GetPointerType (Expr.Type);
 				return this;
@@ -616,15 +615,15 @@ namespace Mono.CSharp {
 				throw new Exception ("This should be caught by Resolve");
 				
 			case Operator.UnaryNegation:
-				if (ec.CheckState && type != TypeManager.float_type && type != TypeManager.double_type) {
+				if (ec.CheckState) {
 					ig.Emit (OpCodes.Ldc_I4_0);
 					if (type == TypeManager.int64_type)
 						ig.Emit (OpCodes.Conv_U8);
 					Expr.Emit (ec);
 					ig.Emit (OpCodes.Sub_Ovf);
 				} else {
-					Expr.Emit (ec);
-					ig.Emit (OpCodes.Neg);
+				Expr.Emit (ec);
+				ig.Emit (OpCodes.Neg);
 				}
 				
 				break;
@@ -687,7 +686,7 @@ namespace Mono.CSharp {
 		{
 			if (!prepared)
 				expr.Emit (ec);
-			
+
 			LoadFromPtr (ec.ig, Type);
 		}
 
@@ -700,29 +699,29 @@ namespace Mono.CSharp {
 				temporary.Store (ec);
 			}
 		}
-		
+
 		public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
 		{
 			prepared = prepare_for_load;
-			
+
 			expr.Emit (ec);
 
 			if (prepare_for_load)
 				ec.ig.Emit (OpCodes.Dup);
-			
+
 			source.Emit (ec);
 			if (leave_copy) {
 				ec.ig.Emit (OpCodes.Dup);
 				temporary = new LocalTemporary (ec, expr.Type);
 				temporary.Store (ec);
 			}
-			
+
 			StoreFromPtr (ec.ig, type);
-			
+
 			if (temporary != null)
 				temporary.Emit (ec);
 		}
-		
+
 		public void AddressOf (EmitContext ec, AddressOp Mode)
 		{
 			expr.Emit (ec);
@@ -853,7 +852,7 @@ namespace Mono.CSharp {
 			else 
 				op_name = "op_Decrement";
 
-			mg = MemberLookup (ec.ContainerType, expr_type, op_name, MemberTypes.Method, AllBindingFlags, loc);
+			mg = MemberLookup (ec, expr_type, op_name, MemberTypes.Method, AllBindingFlags, loc);
 
 			if (mg != null) {
 				method = StaticCallExpr.MakeSimpleCall (
@@ -883,7 +882,7 @@ namespace Mono.CSharp {
 				if (expr == null)
 					return null;
 			} else {
-				expr.Error_UnexpectedKind (ec.DeclContainer, "variable, indexer or property access", loc);
+				expr.Error_UnexpectedKind (ec, "variable, indexer or property access", loc);
 				return null;
 			}
 
@@ -1052,7 +1051,7 @@ namespace Mono.CSharp {
 
 		public override Expression DoResolve (EmitContext ec)
 		{
-			probe_type_expr = ProbeType.ResolveAsTypeTerminal (ec, false);
+			probe_type_expr = ProbeType.ResolveAsTypeTerminal (ec);
 			if (probe_type_expr == null)
 				return null;
 			if (probe_type_expr.ResolveType (ec) == null)
@@ -1350,7 +1349,7 @@ namespace Mono.CSharp {
 
 		Expression ResolveRest (EmitContext ec)
 		{
-			TypeExpr target = target_type.ResolveAsTypeTerminal (ec, false);
+			TypeExpr target = target_type.ResolveAsTypeTerminal (ec);
 			if (target == null)
 				return null;
 			
@@ -1891,10 +1890,10 @@ namespace Mono.CSharp {
 				string op = oper_names [(int) oper];
 				
 				MethodGroupExpr union;
-				left_operators = MemberLookup (ec.ContainerType, l, op, MemberTypes.Method, AllBindingFlags, loc);
+				left_operators = MemberLookup (ec, l, op, MemberTypes.Method, AllBindingFlags, loc);
 				if (r != l){
 					right_operators = MemberLookup (
-						ec.ContainerType, r, op, MemberTypes.Method, AllBindingFlags, loc);
+						ec, r, op, MemberTypes.Method, AllBindingFlags, loc);
 					union = Invocation.MakeUnionSet (left_operators, right_operators, loc);
 				} else
 					union = (MethodGroupExpr) left_operators;
@@ -1926,7 +1925,7 @@ namespace Mono.CSharp {
 				// Simple constant folding
 				if (left is StringConstant && right is StringConstant)
 					return new StringConstant (((StringConstant) left).Value + ((StringConstant) right).Value, left.Location);
-				
+
 				if (l == TypeManager.string_type || r == TypeManager.string_type) {
 
 					if (r == TypeManager.void_type || l == TypeManager.void_type) {
@@ -1949,7 +1948,7 @@ namespace Mono.CSharp {
 							return left;
 						}
 					}
-					
+
 					// Otherwise, start a new concat expression
 					return new StringConcat (ec, loc, left, right).Resolve (ec);
 				}
@@ -2171,13 +2170,13 @@ namespace Mono.CSharp {
 				// U operator - (E e, E f)
 				if (lie && rie){
 					if (oper == Operator.Subtraction){
-						if (l == r){
-							type = TypeManager.EnumToUnderlying (l);
-							return this;
-						}
-						Error_OperatorCannotBeApplied ();
-						return null;
-					}
+					if (l == r){
+						type = TypeManager.EnumToUnderlying (l);
+						return this;
+					} 
+					Error_OperatorCannotBeApplied ();
+					return null;
+				}
 				}
 					
 				//
@@ -2384,9 +2383,6 @@ namespace Mono.CSharp {
 
 		public override Expression DoResolve (EmitContext ec)
 		{
-			if (left == null)
-				return null;
-
 			if ((oper == Operator.Subtraction) && (left is ParenthesizedExpression)) {
 				left = ((ParenthesizedExpression) left).Expr;
 				left = left.Resolve (ec, ResolveFlags.VariableOrValue | ResolveFlags.Type);
@@ -2601,7 +2597,7 @@ namespace Mono.CSharp {
 					right = left;
 					left = swap;
 				}
-				
+					
 				if (((Constant) right).IsZeroInteger) {
 					left.Emit (ec);
 					if (my_on_true)
@@ -2610,7 +2606,7 @@ namespace Mono.CSharp {
 						ig.Emit (OpCodes.Brfalse, target);
 					
 					return;
-				} else if (right is BoolConstant) {
+				} else if (right is BoolConstant){
 					left.Emit (ec);
 					if (my_on_true != ((BoolConstant) right).Value)
 						ig.Emit (OpCodes.Brtrue, target);
@@ -2623,45 +2619,45 @@ namespace Mono.CSharp {
 			} else if (oper == Operator.LogicalAnd) {
 
 				if (onTrue) {
-					Label tests_end = ig.DefineLabel ();
-					
+						Label tests_end = ig.DefineLabel ();
+						
 					left.EmitBranchable (ec, tests_end, false);
 					right.EmitBranchable (ec, target, true);
-					ig.MarkLabel (tests_end);					
-				} else {
+							ig.MarkLabel (tests_end);
+					} else {
 					left.EmitBranchable (ec, target, false);
 					right.EmitBranchable (ec, target, false);
-				}
-				
+					}
+
 				return;
-				
+								
 			} else if (oper == Operator.LogicalOr){
 				if (onTrue) {
 					left.EmitBranchable (ec, target, true);
 					right.EmitBranchable (ec, target, true);
-					
-				} else {
-					Label tests_end = ig.DefineLabel ();
+						
+					} else {
+						Label tests_end = ig.DefineLabel ();
 					left.EmitBranchable (ec, tests_end, true);
 					right.EmitBranchable (ec, target, false);
 					ig.MarkLabel (tests_end);
 				}
-				
+						
 				return;
-				
+
 			} else if (!(oper == Operator.LessThan        || oper == Operator.GreaterThan ||
 			             oper == Operator.LessThanOrEqual || oper == Operator.GreaterThanOrEqual ||
 			             oper == Operator.Equality        || oper == Operator.Inequality)) {
 				base.EmitBranchable (ec, target, onTrue);
 				return;
-			}
-			
+				}
+				
 			left.Emit (ec);
 			right.Emit (ec);
 
 			Type t = left.Type;
 			bool isUnsigned = is_unsigned (t) || t == TypeManager.double_type || t == TypeManager.float_type;
-			
+
 			switch (oper){
 			case Operator.Equality:
 				if (onTrue)
@@ -2748,11 +2744,11 @@ namespace Mono.CSharp {
 			if (oper == Operator.LogicalAnd) {
 				Label load_zero = ig.DefineLabel ();
 				Label end = ig.DefineLabel ();
-								
+
 				left.EmitBranchable (ec, load_zero, false);
-				right.Emit (ec);
-				ig.Emit (OpCodes.Br, end);
-				
+						right.Emit (ec);
+						ig.Emit (OpCodes.Br, end);
+
 				ig.MarkLabel (load_zero);
 				ig.Emit (OpCodes.Ldc_I4_0);
 				ig.MarkLabel (end);
@@ -2760,11 +2756,11 @@ namespace Mono.CSharp {
 			} else if (oper == Operator.LogicalOr) {
 				Label load_one = ig.DefineLabel ();
 				Label end = ig.DefineLabel ();
-
-				left.EmitBranchable (ec, load_one, true);
-				right.Emit (ec);
-				ig.Emit (OpCodes.Br, end);
 				
+				left.EmitBranchable (ec, load_one, true);
+						right.Emit (ec);
+						ig.Emit (OpCodes.Br, end);
+
 				ig.MarkLabel (load_one);
 				ig.Emit (OpCodes.Ldc_I4_1);
 				ig.MarkLabel (end);
@@ -2944,7 +2940,7 @@ namespace Mono.CSharp {
 				ig.Emit (OpCodes.Call, (ConstructorInfo) method);
 		}
 	}
-	
+
 	//
 	// Represents the operation a + b [+ c [+ d [+ ...]]], where a is a string
 	// b, c, d... may be strings or objects.
@@ -3017,23 +3013,23 @@ namespace Mono.CSharp {
 			// This can get called multiple times, so we have to deal with that.
 			if (!emit_conv_done) {
 				emit_conv_done = true;
-				for (int i = 0; i < operands.Count; i ++) {
-					Expression e = (Expression) operands [i];
-					is_strings_only &= e.Type == TypeManager.string_type;
-				}
+			for (int i = 0; i < operands.Count; i ++) {
+				Expression e = (Expression) operands [i];
+				is_strings_only &= e.Type == TypeManager.string_type;
+			}
+			
+			for (int i = 0; i < operands.Count; i ++) {
+				Expression e = (Expression) operands [i];
 				
-				for (int i = 0; i < operands.Count; i ++) {
-					Expression e = (Expression) operands [i];
+				if (! is_strings_only && e.Type == TypeManager.string_type) {
+					// need to make sure this is an object, because the EmitParams
+					// method might look at the type of this expression, see it is a
+					// string and emit a string [] when we want an object [];
 					
-					if (! is_strings_only && e.Type == TypeManager.string_type) {
-						// need to make sure this is an object, because the EmitParams
-						// method might look at the type of this expression, see it is a
-						// string and emit a string [] when we want an object [];
-						
 						e = new EmptyCast (e, TypeManager.object_type);
-					}
-					operands [i] = new Argument (e, Argument.AType.Expression);
 				}
+				operands [i] = new Argument (e, Argument.AType.Expression);
+			}
 			}
 			
 			//
@@ -3490,7 +3486,7 @@ namespace Mono.CSharp {
 				local_info = Block.GetLocalInfo (Name);
 
 				// is out param
-				if (lvalue_right_side == EmptyExpression.OutAccess)
+				if (lvalue_right_side == EmptyExpression.Null)
 					local_info.Used = true;
 
 				is_readonly = local_info.ReadOnly;
@@ -3501,18 +3497,15 @@ namespace Mono.CSharp {
 			VariableInfo variable_info = local_info.VariableInfo;
 			if (lvalue_right_side != null){
 				if (is_readonly){
-					if (lvalue_right_side is LocalVariableReference || lvalue_right_side == EmptyExpression.OutAccess)
+					if (lvalue_right_side is LocalVariableReference || lvalue_right_side == EmptyExpression.Null)
 						Report.Error (1657, loc, "Cannot pass `{0}' as a ref or out argument because it is a `{1}'",
 							Name, local_info.GetReadOnlyContext ());
-					else if (lvalue_right_side == EmptyExpression.LValueMemberAccess)
-						Report.Error (1654, loc, "Cannot assign to members of `{0}' because it is a `{1}'",
-							Name, local_info.GetReadOnlyContext ());
 					else
 						Report.Error (1656, loc, "Cannot assign to `{0}' because it is a `{1}'",
 							Name, local_info.GetReadOnlyContext ());
 					return null;
 				}
-				
+
 				if (variable_info != null)
 					variable_info.SetAssigned (ec);
 			}
@@ -3545,10 +3538,10 @@ namespace Mono.CSharp {
 					ec.CaptureVariable (local_info);
 				}
 			}
-
+			
 			return this;
 		}
-		
+
 		public override Expression DoResolve (EmitContext ec)
 		{
 			return DoResolveBase (ec, null);
@@ -3650,12 +3643,12 @@ namespace Mono.CSharp {
 		public void AddressOf (EmitContext ec, AddressOp mode)
 		{
 			ILGenerator ig = ec.ig;
-
+			
 			if (local_info.FieldBuilder == null){
 				//
 				// A local variable on the local CLR stack
 				//
-				ig.Emit (OpCodes.Ldloca, local_info.LocalBuilder);
+			ig.Emit (OpCodes.Ldloca, local_info.LocalBuilder);
 			} else {
 				//
 				// A local variable captured by anonymous methods or iterators
@@ -3676,11 +3669,12 @@ namespace Mono.CSharp {
 	///   representation.
 	/// </summary>
 	public class ParameterReference : Expression, IAssignMethod, IMemoryLocation, IVariable {
-		Parameter par;
-		string name;
+		Parameters pars;
+		String name;
 		int idx;
 		Block block;
 		VariableInfo vi;
+		public Parameter.Modifier mod;
 		public bool is_ref, is_out, prepared;
 
 		public bool IsOut {
@@ -3697,16 +3691,20 @@ namespace Mono.CSharp {
 
 		LocalTemporary temp;
 		
-		public ParameterReference (Parameter par, Block block, int idx, Location loc)
+		public ParameterReference (Parameters pars, Block block, int idx, string name, Location loc)
 		{
-			this.par = par;
-			this.name = par.Name;
+			this.pars = pars;
 			this.block = block;
 			this.idx  = idx;
+			this.name = name;
 			this.loc = loc;
 			eclass = ExprClass.Variable;
 		}
 
+		public ParameterReference (InternalParameters pars, Block block, int idx, Location loc)
+			: this (pars.Parameters, block, idx, pars.ParameterName (idx), loc)
+		{ }
+
 		public VariableInfo VariableInfo {
 			get { return vi; }
 		}
@@ -3714,7 +3712,7 @@ namespace Mono.CSharp {
 		public bool VerifyFixed ()
 		{
 			// A parameter is fixed if it's a value parameter (i.e., no modifier like out, ref, param).
-			return par.ModFlags == Parameter.Modifier.NONE;
+			return mod == Parameter.Modifier.NONE;
 		}
 
 		public bool IsAssigned (EmitContext ec, Location loc)
@@ -3723,7 +3721,7 @@ namespace Mono.CSharp {
 				return true;
 
 			Report.Error (269, loc,
-				      "Use of unassigned out parameter `{0}'", par.Name);
+				      "Use of unassigned out parameter `{0}'", name);
 			return false;
 		}
 
@@ -3749,26 +3747,21 @@ namespace Mono.CSharp {
 				ec.CurrentBranching.SetFieldAssigned (vi, field_name);
 		}
 
-		protected bool DoResolveBase (EmitContext ec)
+		protected void DoResolveBase (EmitContext ec)
 		{
-			if (!par.Resolve (ec)) {
-				//TODO:
-			}
-
-			type = par.ParameterType;
-			Parameter.Modifier mod = par.ModFlags;
+			type = pars.GetParameterInfo (ec, idx, out mod);
 			is_ref = (mod & Parameter.Modifier.ISBYREF) != 0;
-			is_out = (mod & Parameter.Modifier.OUT) == Parameter.Modifier.OUT;
+			is_out = (mod & Parameter.Modifier.OUT) != 0;
 			eclass = ExprClass.Variable;
 
 			if (is_out)
 				vi = block.ParameterMap [idx];
 
 			if (ec.CurrentAnonymousMethod != null){
-				if (is_ref && !block.Toplevel.IsLocalParameter (name)){
+				if (is_ref){
 					Report.Error (1628, Location, "Cannot use ref or out parameter `{0}' inside an anonymous method block",
-						par.Name);
-					return false;
+						name);
+					return;
 				}
 
 				//
@@ -3780,8 +3773,6 @@ namespace Mono.CSharp {
 					ec.CaptureParameter (name, type, idx);
 				}
 			}
-
-			return true;
 		}
 
 		public override int GetHashCode()
@@ -3812,8 +3803,7 @@ namespace Mono.CSharp {
 		//
 		public override Expression DoResolve (EmitContext ec)
 		{
-			if (!DoResolveBase (ec))
-				return null;
+			DoResolveBase (ec);
 
 			if (is_out && ec.DoFlowAnalysis && (!ec.OmitStructFlowAnalysis || !vi.TypeInfo.IsStruct) && !IsAssigned (ec, loc))
 				return null;
@@ -3823,8 +3813,7 @@ namespace Mono.CSharp {
 
 		override public Expression DoResolveLValue (EmitContext ec, Expression right_side)
 		{
-			if (!DoResolveBase (ec))
-				return null;
+			DoResolveBase (ec);
 
 			SetAssigned (ec);
 
@@ -3876,8 +3865,11 @@ namespace Mono.CSharp {
 			ILGenerator ig = ec.ig;
 			int arg_idx = idx;
 
-			if (ec.HaveCaptureInfo && ec.IsParameterCaptured (name)){				
-				ec.EmitParameter (name, leave_copy, prepared, ref temp);
+			if (ec.HaveCaptureInfo && ec.IsParameterCaptured (name)){
+				if (leave_copy)
+					throw new InternalErrorException ();
+				
+				ec.EmitParameter (name);
 				return;
 			}
 
@@ -3909,16 +3901,15 @@ namespace Mono.CSharp {
 		
 		public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
 		{
-			prepared = prepare_for_load;
 			if (ec.HaveCaptureInfo && ec.IsParameterCaptured (name)){
-				ec.EmitAssignParameter (name, source, leave_copy, prepare_for_load, ref temp);
+				ec.EmitAssignParameter (name, source, leave_copy, prepare_for_load);
 				return;
 			}
 
 			ILGenerator ig = ec.ig;
 			int arg_idx = idx;
 			
-			
+			prepared = prepare_for_load;
 			
 			if (!ec.MethodIsStatic)
 				arg_idx++;
@@ -4020,10 +4011,10 @@ namespace Mono.CSharp {
 			get {
 				switch (ArgType) {
 					case AType.Out:
-						return Parameter.Modifier.OUT;
+						return Parameter.Modifier.OUT | Parameter.Modifier.ISBYREF;
 
 					case AType.Ref:
-						return Parameter.Modifier.REF;
+						return Parameter.Modifier.REF | Parameter.Modifier.ISBYREF;
 
 					default:
 						return Parameter.Modifier.NONE;
@@ -4075,17 +4066,15 @@ namespace Mono.CSharp {
 					return false;
 				}
 
-				int errors = Report.Errors;
 				Expr = Expr.DoResolveLValue (ec, Expr);
-				if (Expr == null && errors == Report.Errors)
+				if (Expr == null)
 					Error_LValueRequired (loc);
 			} else if (ArgType == AType.Out) {
-				int errors = Report.Errors;
 				ec.InRefOutArgumentResolving = true;
-				Expr = Expr.DoResolveLValue (ec, EmptyExpression.OutAccess);
+				Expr = Expr.DoResolveLValue (ec, EmptyExpression.Null);
 				ec.InRefOutArgumentResolving = false;
 
-				if (Expr == null && errors == Report.Errors)
+				if (Expr == null)
 					Error_LValueRequired (loc);
 			}
 			else
@@ -4118,6 +4107,20 @@ namespace Mono.CSharp {
 					}
 				}
 			}
+
+			if (Expr.eclass != ExprClass.Variable){
+				//
+				// We just probe to match the CSC output
+				//
+				if (Expr.eclass == ExprClass.PropertyAccess ||
+				    Expr.eclass == ExprClass.IndexerAccess){
+					Report.Error (206, loc, "A property or indexer `{0}' may not be passed as an out or ref parameter",
+						Expr.GetSignatureForError ());
+				} else {
+					Error_LValueRequired (loc);
+				}
+				return false;
+			}
 				
 			return true;
 		}
@@ -4213,10 +4216,10 @@ namespace Mono.CSharp {
 				return null;
 
 			if (argument_expr is NullLiteral) {
-				//
+			//
 				// If the argument is null and one of the types to compare is 'object' and
 				// the other is a reference type, we prefer the other.
-				//
+			//
 				// This follows from the usual rules:
 				//   * There is an implicit conversion from 'null' to type 'object'
 				//   * There is an implicit conversion from 'null' to any reference type
@@ -4233,7 +4236,7 @@ namespace Mono.CSharp {
 				if (!q.IsValueType && p == TypeManager.object_type)
 					return q;
 			}
-                                
+			
 			if (argument_type == p)
 				return p;
 
@@ -4242,7 +4245,7 @@ namespace Mono.CSharp {
 
 			Expression p_tmp = new EmptyExpression (p);
 			Expression q_tmp = new EmptyExpression (q);
-
+			
 			bool p_to_q = Convert.ImplicitConversionExists (ec, p_tmp, q);
 			bool q_to_p = Convert.ImplicitConversionExists (ec, q_tmp, p);
 
@@ -4265,6 +4268,7 @@ namespace Mono.CSharp {
 				if (q == TypeManager.ushort_type || q == TypeManager.uint32_type ||
 				    q == TypeManager.uint64_type)
 					return p;
+
 			if (q == TypeManager.short_type)
 				if (p == TypeManager.ushort_type || p == TypeManager.uint32_type ||
 				    p == TypeManager.uint64_type)
@@ -4273,6 +4277,7 @@ namespace Mono.CSharp {
 			if (p == TypeManager.int32_type)
 				if (q == TypeManager.uint32_type || q == TypeManager.uint64_type)
 					return p;
+
 			if (q == TypeManager.int32_type)
 				if (p == TypeManager.uint32_type || p == TypeManager.uint64_type)
 					return q;
@@ -4286,45 +4291,6 @@ namespace Mono.CSharp {
 
 			return null;
 		}
-
-		static Type MoreSpecific (Type p, Type q)
-		{
-			if (p.IsGenericParameter && !q.IsGenericParameter)
-				return q;
-			if (!p.IsGenericParameter && q.IsGenericParameter)
-				return p;
-
-			if (p.IsGenericType) {
-				Type[] pargs = TypeManager.GetTypeArguments (p);
-				Type[] qargs = TypeManager.GetTypeArguments (q);
-
-				bool p_specific_at_least_once = false;
-				bool q_specific_at_least_once = false;
-
-				for (int i = 0; i < pargs.Length; i++) {
-					Type specific = MoreSpecific (pargs [i], qargs [i]);
-					if (specific == pargs [i])
-						p_specific_at_least_once = true;
-					if (specific == qargs [i])
-						q_specific_at_least_once = true;
-				}
-
-				if (p_specific_at_least_once && !q_specific_at_least_once)
-					return p;
-				if (!p_specific_at_least_once && q_specific_at_least_once)
-					return q;
-			} else if (TypeManager.HasElementType (p)) {
-				Type pe = TypeManager.GetElementType (p);
-				Type qe = TypeManager.GetElementType (q);
-				Type specific = MoreSpecific (pe, qe);
-				if (specific == pe)
-					return p;
-				if (specific == qe)
-					return q;
-			}
-
-			return null;
-		}
 		
 		/// <summary>
 		///   Determines "Better function" between candidate
@@ -4336,8 +4302,8 @@ namespace Mono.CSharp {
 		///     true  if candidate is better than the current best match
 		/// </remarks>
 		static bool BetterFunction (EmitContext ec, ArrayList args, int argument_count,
-					    MethodBase candidate, bool candidate_params,
-					    MethodBase best, bool best_params, Location loc)
+					   MethodBase candidate, bool candidate_params,
+					   MethodBase best, bool best_params, Location loc)
 		{
 			ParameterData candidate_pd = TypeManager.GetParameterData (candidate);
 			ParameterData best_pd = TypeManager.GetParameterData (best);
@@ -4363,12 +4329,11 @@ namespace Mono.CSharp {
 
 				same = false;
 				Type better = BetterConversion (ec, a, ct, bt, loc);
-
 				// for each argument, the conversion to 'ct' should be no worse than 
 				// the conversion to 'bt'.
 				if (better == bt)
 					return false;
-
+				
 				// for at least one argument, the conversion to 'ct' should be better than 
 				// the conversion to 'bt'.
 				if (better == ct)
@@ -4378,77 +4343,36 @@ namespace Mono.CSharp {
 			if (better_at_least_one)
 				return true;
 
-			//
-			// This handles the case
-			//
-			//   Add (float f1, float f2, float f3);
-			//   Add (params decimal [] foo);
-			//
-			// The call Add (3, 4, 5) should be ambiguous.  Without this check, the
-			// first candidate would've chosen as better.
-			//
 			if (!same)
 				return false;
 
 			//
-			// The two methods have equal parameter types.  Now apply tie-breaking rules
+			// If two methods have equal parameter types, but
+			// only one of them is generic, the non-generic one wins.
 			//
 			if (TypeManager.IsGenericMethod (best) && !TypeManager.IsGenericMethod (candidate))
 				return true;
-			if (!TypeManager.IsGenericMethod (best) && TypeManager.IsGenericMethod (candidate))
+			else if (!TypeManager.IsGenericMethod (best) && TypeManager.IsGenericMethod (candidate))
 				return false;
 
+			//
+			// Note that this is not just an optimization.  This handles the case
+			// This handles the case
+			//
+			//   Add (float f1, float f2, float f3);
+			//   Add (params decimal [] foo);
+			//
+			// The call Add (3, 4, 5) should be ambiguous.  Without this check, the
+			// first candidate would've chosen as better.
+			//
 			//
 			// This handles the following cases:
 			//
 			//   Trim () is better than Trim (params char[] chars)
 			//   Concat (string s1, string s2, string s3) is better than
 			//     Concat (string s1, params string [] srest)
-			//   Foo (int, params int [] rest) is better than Foo (params int [] rest)
 			//
-			if (!candidate_params && best_params)
-				return true;
-			if (candidate_params && !best_params)
-				return false;
-
-			int candidate_param_count = candidate_pd.Count;
-			int best_param_count = best_pd.Count;
-
-			if (candidate_param_count != best_param_count)
-				// can only happen if (candidate_params && best_params)
-				return candidate_param_count > best_param_count;
-
-			//
-			// now, both methods have the same number of parameters, and the parameters have the same types
-			// Pick the "more specific" signature
-			//
-
-			MethodBase orig_candidate = TypeManager.DropGenericMethodArguments (candidate);
-			MethodBase orig_best = TypeManager.DropGenericMethodArguments (best);
-
-			ParameterData orig_candidate_pd = TypeManager.GetParameterData (orig_candidate);
-			ParameterData orig_best_pd = TypeManager.GetParameterData (orig_best);
-
-			bool specific_at_least_once = false;
-			for (int j = 0; j < candidate_param_count; ++j) {
-				Type ct = TypeManager.TypeToCoreType (orig_candidate_pd.ParameterType (j));
-				Type bt = TypeManager.TypeToCoreType (orig_best_pd.ParameterType (j));
-				if (ct.Equals (bt))
-					continue;
-				Type specific = MoreSpecific (ct, bt);
-				if (specific == bt)
-					return false;
-				if (specific == ct)
-					specific_at_least_once = true;
-			}
-
-			if (specific_at_least_once)
-				return true;
-
-			// FIXME: handle lifted operators
-			// ...
-
-			return false;
+                        return !candidate_params && best_params;
 		}
 
 		internal static bool IsOverride (MethodBase cand_method, MethodBase base_method)
@@ -4570,11 +4494,12 @@ namespace Mono.CSharp {
 						      bool do_varargs)
 		{
 			ParameterData pd = TypeManager.GetParameterData (candidate);
-
+			
 			int pd_count = pd.Count;
+
 			if (pd_count == 0)
 				return false;
-
+			
 			int count = pd_count - 1;
 			if (do_varargs) {
 				if (pd.ParameterModifier (count) != Parameter.Modifier.ARGLIST)
@@ -4582,8 +4507,8 @@ namespace Mono.CSharp {
 				if (pd_count != arg_count)
 					return false;
 			} else {
-				if (!pd.HasParams)
-					return false;
+				if (pd.ParameterModifier (count) != Parameter.Modifier.PARAMS)
+				return false;
 			}
 			
 			if (count > arg_count)
@@ -4602,9 +4527,9 @@ namespace Mono.CSharp {
 				Argument a = (Argument) arguments [i];
 
 				Parameter.Modifier a_mod = a.Modifier & 
-					(unchecked (~(Parameter.Modifier.OUTMASK | Parameter.Modifier.REFMASK)));
+					(unchecked (~(Parameter.Modifier.OUT | Parameter.Modifier.REF)));
 				Parameter.Modifier p_mod = pd.ParameterModifier (i) &
-					(unchecked (~(Parameter.Modifier.OUTMASK | Parameter.Modifier.REFMASK)));
+					(unchecked (~(Parameter.Modifier.OUT | Parameter.Modifier.REF)));
 
 				if (a_mod == p_mod) {
 
@@ -4612,8 +4537,8 @@ namespace Mono.CSharp {
 						if (!Convert.ImplicitConversionExists (ec,
                                                                                        a.Expr,
                                                                                        pd.ParameterType (i)))
-				return false;
-
+							return false;
+										
 					if ((a_mod & Parameter.Modifier.ISBYREF) != 0) {
 						Type pt = pd.ParameterType (i);
 
@@ -4663,8 +4588,8 @@ namespace Mono.CSharp {
 		///   Determines if the candidate method is applicable (section 14.4.2.1)
 		///   to the given set of arguments
 		/// </summary>
-		public static bool IsApplicable (EmitContext ec, ArrayList arguments, int arg_count,
-			MethodBase candidate)
+		static bool IsApplicable (EmitContext ec, ArrayList arguments, int arg_count,
+					  MethodBase candidate)
 		{
 			ParameterData pd = TypeManager.GetParameterData (candidate);
 
@@ -4677,34 +4602,39 @@ namespace Mono.CSharp {
 				Argument a = (Argument) arguments [i];
 
 				Parameter.Modifier a_mod = a.Modifier &
-					~(Parameter.Modifier.OUTMASK | Parameter.Modifier.REFMASK);
-
+					unchecked (~(Parameter.Modifier.OUT | Parameter.Modifier.REF));
 				Parameter.Modifier p_mod = pd.ParameterModifier (i) &
-					~(Parameter.Modifier.OUTMASK | Parameter.Modifier.REFMASK | Parameter.Modifier.PARAMS);
-
-				if (a_mod == p_mod) {
-					Type pt = pd.ParameterType (i);
+					unchecked (~(Parameter.Modifier.OUT | Parameter.Modifier.REF));
 
+				if (a_mod == p_mod ||
+				    (a_mod == Parameter.Modifier.NONE && p_mod == Parameter.Modifier.PARAMS)) {
 					if (a_mod == Parameter.Modifier.NONE) {
-                                                if (!TypeManager.IsEqual (a.Type, pt) &&
-						    !Convert.ImplicitConversionExists (ec, a.Expr, pt))
+                                                if (!TypeManager.IsEqual (a.Type, pd.ParameterType (i)) && !Convert.ImplicitConversionExists (ec,
+                                                                                       a.Expr,
+                                                                                       pd.ParameterType (i)))
 							return false;
-						continue;
-					}
+                                        }
 					
-					if (pt != a.Type)
-						return false;
+					if ((a_mod & Parameter.Modifier.ISBYREF) != 0) {
+						Type pt = pd.ParameterType (i);
+
+						if (!pt.IsByRef)
+							pt = TypeManager.GetReferenceType (pt);
+                                                
+						if (pt != a.Type)
+							return false;
+					}
 				} else
 					return false;
 			}
 
 			return true;
 		}
-
-		static internal bool IsAncestralType (Type first_type, Type second_type)
+		
+		static private bool IsAncestralType (Type first_type, Type second_type)
 		{
 			return first_type != second_type &&
-				(TypeManager.IsSubclassOf (second_type, first_type) ||
+				(second_type.IsSubclassOf (first_type) ||
 				 TypeManager.ImplementsInterface (second_type, first_type));
 		}
 		
@@ -4746,7 +4676,7 @@ namespace Mono.CSharp {
 
 			if (Arguments != null)
 				arg_count = Arguments.Count;
-
+  
 			if ((me.Name == "Invoke") &&
 				TypeManager.IsDelegateType (me.DeclaringType)) {
 				Error_InvokeOnDelegate (loc);
@@ -4755,57 +4685,45 @@ namespace Mono.CSharp {
 
 			MethodBase[] methods = me.Methods;
 
-			int nmethods = methods.Length;
-
-			if (!me.IsBase) {
-				//
-				// Methods marked 'override' don't take part in 'applicable_type'
-				// computation, nor in the actual overload resolution.
-				// However, they still need to be emitted instead of a base virtual method.
-				// So, we salt them away into the 'candidate_overrides' array.
-				//
-				// In case of reflected methods, we replace each overriding method with
-				// its corresponding base virtual method.  This is to improve compatibility
-				// with non-C# libraries which change the visibility of overrides (#75636)
-				//
-				int j = 0;
-				for (int i = 0; i < methods.Length; ++i) {
-					MethodBase m = methods [i];
-					if (TypeManager.IsOverride (m)) {
-						if (candidate_overrides == null)
-							candidate_overrides = new ArrayList ();
-						candidate_overrides.Add (m);
-						m = TypeManager.TryGetBaseDefinition (m);
-					}
-					if (m != null)
-						methods [j++] = m;
-				}
-				nmethods = j;
-			}
-
-			int applicable_errors = Report.Errors;
-			
 			//
 			// First we construct the set of applicable methods
 			//
  			bool is_sorted = true;
-			for (int i = 0; i < nmethods; i++){
+			for (int i = 0; i < methods.Length; i++){
 				Type decl_type = methods [i].DeclaringType;
 
 				//
 				// If we have already found an applicable method
 				// we eliminate all base types (Section 14.5.5.1)
 				//
-				if (applicable_type != null && IsAncestralType (decl_type, applicable_type))
+				if ((applicable_type != null) &&
+					IsAncestralType (decl_type, applicable_type))
+					continue;
+
+				//
+				// Methods marked 'override' don't take part in 'applicable_type'
+				// computation, nor in the actual overload resolution.
+				// However, they still need to be emitted instead of a base virtual method.
+				// We avoid doing the 'applicable' test here, since it'll anyway be applied
+				// to the base virtual function, and IsOverride is much faster than IsApplicable.
+				//
+				if (!me.IsBase && TypeManager.IsOverride (methods [i])) {
+					if (candidate_overrides == null)
+						candidate_overrides = new ArrayList ();
+					candidate_overrides.Add (methods [i]);
 					continue;
+				}
 
 				//
 				// Check if candidate is applicable (section 14.4.2.1)
 				//   Is candidate applicable in normal form?
 				//
-				bool is_applicable = IsApplicable (ec, me, Arguments, arg_count, ref methods [i]);
+				bool is_applicable = IsApplicable (
+					ec, me, Arguments, arg_count, ref methods [i]);
 
-				if (!is_applicable && IsParamsMethodApplicable (ec, me, Arguments, arg_count, ref methods [i])) {
+				if (!is_applicable &&
+					(IsParamsMethodApplicable (
+					ec, me, Arguments, arg_count, ref methods [i]))) {
 					MethodBase candidate = methods [i];
 					if (candidate_to_form == null)
 						candidate_to_form = new PtrHashtable ();
@@ -4815,7 +4733,7 @@ namespace Mono.CSharp {
 				}
 
 				if (!is_applicable)
-					continue;
+                                        continue;
 
 				candidates.Add (methods [i]);
 
@@ -4828,9 +4746,6 @@ namespace Mono.CSharp {
 				}
 			}
 
-			if (applicable_errors != Report.Errors)
-				return null;
-			
 			int candidate_top = candidates.Count;
 
 			if (applicable_type == null) {
@@ -4839,7 +4754,7 @@ namespace Mono.CSharp {
 				// return by providing info about the closest match
 				//
 				int errors = Report.Errors;
-				for (int i = 0; i < nmethods; ++i) {
+				for (int i = 0; i < methods.Length; ++i) {
 					MethodBase c = (MethodBase) methods [i];
 					ParameterData pd = TypeManager.GetParameterData (c);
 
@@ -4974,8 +4889,8 @@ namespace Mono.CSharp {
 
                                 bool cand_params = candidate_to_form != null && candidate_to_form.Contains (candidate);
 				if (!BetterFunction (ec, Arguments, arg_count,
-						     method, method_params,
-						     candidate, cand_params,
+						    method, method_params,
+						    candidate, cand_params,
 						     loc)) {
 					Report.SymbolRelatedToPreviousError (candidate);
 					ambiguous = candidate;
@@ -5014,18 +4929,14 @@ namespace Mono.CSharp {
                                                     method_params, null, may_fail, loc))
 				return null;
 
-			if (method == null)
-				return null;
-
-			MethodBase the_method = TypeManager.DropGenericMethodArguments (method);
-			if (the_method.IsGenericMethodDefinition &&
-			    !ConstraintChecker.CheckConstraints (ec, the_method, method, loc))
-				return null;
-
-			IMethodData data = TypeManager.GetMethod (the_method);
-			if (data != null)
-				data.SetMemberIsUsed ();
-
+			if (method != null) {
+				MethodBase the_method = method;
+				if (the_method.Mono_IsInflatedMethod)
+					the_method = the_method.GetGenericMethodDefinition ();
+				IMethodData data = TypeManager.GetMethod (the_method);
+				if (data != null)
+					data.SetMemberIsUsed ();
+			}
 			return method;
 		}
 
@@ -5155,13 +5066,8 @@ namespace Mono.CSharp {
 			return true;
 		}
 
-		private bool resolved = false;
 		public override Expression DoResolve (EmitContext ec)
 		{
-			if (resolved)
-				return this.method == null ? null : this;
-
-			resolved = true;
 			//
 			// First, resolve the expression that is used to
 			// trigger the invocation
@@ -5201,7 +5107,7 @@ namespace Mono.CSharp {
 			}
 
 			MethodGroupExpr mg = (MethodGroupExpr) expr;
-			MethodBase method = OverloadResolve (ec, mg, Arguments, false, loc);
+			method = OverloadResolve (ec, mg, Arguments, false, loc);
 
 			if (method == null)
 				return null;
@@ -5258,7 +5164,6 @@ namespace Mono.CSharp {
 				mg.InstanceExpression.CheckMarshallByRefAccess (ec.ContainerType);
 
 			eclass = ExprClass.Value;
-			this.method = method;
 			return this;
 		}
 
@@ -5403,14 +5308,14 @@ namespace Mono.CSharp {
 		/// <summary>
 		/// This checks the ConditionalAttribute on the method 
 		/// </summary>
-		static bool IsMethodExcluded (MethodBase method)
+		static bool IsMethodExcluded (MethodBase method, EmitContext ec)
 		{
 			if (method.IsConstructor)
 				return false;
 
 			IMethodData md = TypeManager.GetMethod (method);
 			if (md != null)
-				return md.IsExcluded ();
+				return md.IsExcluded (ec);
 
 			// For some methods (generated by delegate class) GetMethod returns null
 			// because they are not included in builder_to_method table
@@ -5493,7 +5398,7 @@ namespace Mono.CSharp {
 				}
 			}
 
-			if (IsMethodExcluded (method))
+			if (IsMethodExcluded (method, ec))
 				return;
 			
 			if (!is_static){
@@ -5632,7 +5537,7 @@ namespace Mono.CSharp {
 			//
 			// First try to resolve it as a cast.
 			//
-			TypeExpr te = expr.ResolveAsTypeTerminal (ec, true);
+			TypeExpr te = expr.ResolveAsTypeStep (ec) as TypeExpr;
 			if ((te != null) && (te.eclass == ExprClass.Type)) {
 				Cast cast = new Cast (te, argument, loc);
 				return cast.Resolve (ec);
@@ -5679,7 +5584,7 @@ namespace Mono.CSharp {
 			//
 			// First try to resolve it as a cast.
 			//
-			TypeExpr te = expr.ResolveAsTypeTerminal (ec, true);
+			TypeExpr te = expr.ResolveAsTypeStep (ec) as TypeExpr;
 			if ((te != null) && (te.eclass == ExprClass.Type)) {
 				error201 ();
 				return null;
@@ -5874,7 +5779,7 @@ namespace Mono.CSharp {
 				return this;
 			}
 
-			TypeExpr texpr = RequestedType.ResolveAsTypeTerminal (ec, false);
+			TypeExpr texpr = RequestedType.ResolveAsTypeTerminal (ec);
 			if (texpr == null)
 				return null;
 
@@ -5945,7 +5850,6 @@ namespace Mono.CSharp {
 			if (is_struct && Arguments == null)
 				return this;
 
-			// For member-lookup, treat 'new Foo (bar)' as call to 'foo.ctor (bar)', where 'foo' is of type 'Foo'.
 			Expression ml = MemberLookupFinal (ec, type, type, ".ctor",
 				MemberTypes.Constructor, AllBindingFlags | BindingFlags.DeclaredOnly, loc);
 
@@ -5955,7 +5859,7 @@ namespace Mono.CSharp {
 			MethodGroupExpr mg = ml as MethodGroupExpr;
 
 			if (mg == null) {
-				ml.Error_UnexpectedKind (ec.DeclContainer, "method group", loc);
+				ml.Error_UnexpectedKind (ec, "method group", loc);
 				return null;
 			}
 
@@ -5969,7 +5873,7 @@ namespace Mono.CSharp {
 			method = Invocation.OverloadResolve (ec, mg, Arguments, false, loc);
 			if (method == null) {
 				if (almostMatchedMembers.Count != 0)
-					MemberLookupFailed (ec.ContainerType, type, type, ".ctor", null, true, loc);
+					MemberLookupFailed (ec, type, type, ".ctor", null, true, loc);
 				return null;
 			}
 
@@ -6370,11 +6274,16 @@ namespace Mono.CSharp {
 			//
 			TypeExpr array_type_expr;
 			array_type_expr = new ComposedCast (requested_base_type, array_qualifier.ToString (), loc);
-			array_type_expr = array_type_expr.ResolveAsTypeTerminal (ec, false);
+			array_type_expr = array_type_expr.ResolveAsTypeTerminal (ec);
 			if (array_type_expr == null)
 				return false;
 
-			type = array_type_expr.ResolveType (ec);		
+			type = array_type_expr.ResolveType (ec);
+
+			if (!type.IsArray) {
+				Error (622, "Can only use array initializer expressions to assign to array types. Try using a new expression instead.");
+				return false;
+			}
 			underlying_type = TypeManager.GetElementType (type);
 			dimensions = type.GetArrayRank ();
 
@@ -6429,11 +6338,11 @@ namespace Mono.CSharp {
 			if (is_builtin_type) {
 				Expression ml;
 				
-				ml = MemberLookup (ec.ContainerType, type, ".ctor", MemberTypes.Constructor,
+				ml = MemberLookup (ec, type, ".ctor", MemberTypes.Constructor,
 						   AllBindingFlags, loc);
 				
 				if (!(ml is MethodGroupExpr)) {
-					ml.Error_UnexpectedKind (ec.DeclContainer, "method group", loc);
+					ml.Error_UnexpectedKind (ec, "method group", loc);
 					return null;
 				}
 				
@@ -6796,14 +6705,14 @@ namespace Mono.CSharp {
 				// This will never be true for array types that cannot be statically
 				// initialized. num_automatic_initializers will always be zero.  See
 				// CheckIndices.
-				if (num_automatic_initializers > max_automatic_initializers)
-					EmitStaticInitializers (ec);
+					if (num_automatic_initializers > max_automatic_initializers)
+						EmitStaticInitializers (ec);
 				
 				if (dynamic_initializers)
 					EmitDynamicInitializers (ec);
 			}
 		}
-
+		
 		public object EncodeAsAttribute ()
 		{
 			if (!is_one_dimensional){
@@ -6931,20 +6840,11 @@ namespace Mono.CSharp {
 			ILGenerator ig = ec.ig;
 			
 			if (ec.TypeContainer is Struct){
-				ec.EmitThis (false);
+				ec.EmitThis ();
 				source.Emit (ec);
-				
-				LocalTemporary t = null;
-				if (leave_copy) {
-					t = new LocalTemporary (ec, type);
+				if (leave_copy)
 					ec.ig.Emit (OpCodes.Dup);
-					t.Store (ec);
-				}
-
 				ig.Emit (OpCodes.Stobj, type);
-				
-				if (leave_copy)
-					t.Emit (ec);
 			} else {
 				throw new Exception ("how did you get here");
 			}
@@ -6954,7 +6854,7 @@ namespace Mono.CSharp {
 		{
 			ILGenerator ig = ec.ig;
 
-			ec.EmitThis (false);
+			ec.EmitThis ();
 			if (ec.TypeContainer is Struct)
 				ig.Emit (OpCodes.Ldobj, type);
 		}
@@ -6975,7 +6875,7 @@ namespace Mono.CSharp {
 
 		public void AddressOf (EmitContext ec, AddressOp mode)
 		{
-			ec.EmitThis (true);
+			ec.EmitThis ();
 
 			// FIMXE
 			// FIGURE OUT WHY LDARG_S does not work
@@ -7105,7 +7005,7 @@ namespace Mono.CSharp {
 
 		public override Expression DoResolve (EmitContext ec)
 		{
-			TypeExpr texpr = QueriedType.ResolveAsTypeTerminal (ec, false);
+			TypeExpr texpr = QueriedType.ResolveAsTypeTerminal (ec);
 			if (texpr == null)
 				return null;
 
@@ -7173,7 +7073,7 @@ namespace Mono.CSharp {
 
 		public override Expression DoResolve (EmitContext ec)
 		{
-			TypeExpr texpr = QueriedType.ResolveAsTypeTerminal (ec, false);
+			TypeExpr texpr = QueriedType.ResolveAsTypeTerminal (ec);
 			if (texpr == null)
 				return null;
 
@@ -7235,7 +7135,7 @@ namespace Mono.CSharp {
 				return new MemberAccess (RootNamespace.Global, identifier, loc).ResolveAsTypeStep (ec, silent);
 
 			int errors = Report.Errors;
-			FullNamedExpression fne = ec.DeclContainer.NamespaceEntry.LookupAlias (alias);
+			FullNamedExpression fne = ec.DeclSpace.NamespaceEntry.LookupAlias (alias);
 			if (fne == null) {
 				if (errors == Report.Errors)
 					Report.Error (432, loc, "Alias `{0}' not found", alias);
@@ -7256,7 +7156,7 @@ namespace Mono.CSharp {
 				fne = RootNamespace.Global;
 			} else {
 				int errors = Report.Errors;
-				fne = ec.DeclContainer.NamespaceEntry.LookupAlias (alias);
+				fne = ec.DeclSpace.NamespaceEntry.LookupAlias (alias);
 				if (fne == null) {
 					if (errors == Report.Errors)
 						Report.Error (432, loc, "Alias `{0}' not found", alias);
@@ -7350,9 +7250,9 @@ namespace Mono.CSharp {
 			if (new_expr is Namespace) {
 				Namespace ns = (Namespace) new_expr;
 				string lookup_id = MemberName.MakeName (Identifier, args);
-				FullNamedExpression retval = ns.Lookup (ec.DeclContainer, lookup_id, loc);
+				FullNamedExpression retval = ns.Lookup (ec.DeclSpace, lookup_id, loc);
 				if ((retval != null) && (args != null))
-					retval = new ConstructedType (retval, args, loc).ResolveAsTypeStep (ec, false);
+					retval = new ConstructedType (retval, args, loc).ResolveAsTypeStep (ec);
 				if (retval == null)
 					Report.Error (234, loc, "The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
 						Identifier, ns.FullName);
@@ -7364,25 +7264,19 @@ namespace Mono.CSharp {
 				Error (23, "The `.' operator can not be applied to pointer operands (" +
 				       TypeManager.CSharpName (expr_type) + ")");
 				return null;
-			} else if (expr_type == TypeManager.void_type) {
-				Error (23, "The `.' operator can not be applied to operands of type 'void'");
-				return null;
-			} else if (expr_type == TypeManager.anonymous_method_type){
-				Error (23, "The `.' operator can not be applied to anonymous methods");
 			}
-			
 
 			Expression member_lookup;
 			member_lookup = MemberLookup (
-				ec.ContainerType, expr_type, expr_type, Identifier, loc);
+				ec, expr_type, expr_type, Identifier, loc);
 			if ((member_lookup == null) && (args != null)) {
 				string lookup_id = MemberName.MakeName (Identifier, args);
 				member_lookup = MemberLookup (
-					ec.ContainerType, expr_type, expr_type, lookup_id, loc);
+					ec, expr_type, expr_type, lookup_id, loc);
 			}
 			if (member_lookup == null) {
 				MemberLookupFailed (
-					ec.ContainerType, expr_type, expr_type, Identifier, null, true, loc);
+					ec, expr_type, expr_type, Identifier, null, true, loc);
 				return null;
 			}
 
@@ -7406,7 +7300,7 @@ namespace Mono.CSharp {
 					ct = new ConstructedType (
 						member_lookup.Type, ct.TypeArguments, loc);
 
-					return ct.ResolveAsTypeStep (ec, false);
+					return ct.ResolveAsTypeStep (ec);
 				}
 
 				return member_lookup;
@@ -7469,16 +7363,16 @@ namespace Mono.CSharp {
 
 			if (new_expr is Namespace) {
 				Namespace ns = (Namespace) new_expr;
-				FullNamedExpression retval = ns.Lookup (ec.DeclContainer, lookup_id, loc);
+				FullNamedExpression retval = ns.Lookup (ec.DeclSpace, lookup_id, loc);
 				if ((retval != null) && (args != null))
-					retval = new ConstructedType (retval, args, loc).ResolveAsTypeStep (ec, false);
+					retval = new ConstructedType (retval, args, loc).ResolveAsTypeStep (ec);
 				if (!silent && retval == null)
 					Report.Error (234, loc, "The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
 						Identifier, ns.FullName);
 				return retval;
 			}
 
-			TypeExpr tnew_expr = new_expr.ResolveAsTypeTerminal (ec, false);
+			TypeExpr tnew_expr = new_expr.ResolveAsTypeTerminal (ec);
 			if (tnew_expr == null)
 				return null;
 
@@ -7491,11 +7385,11 @@ namespace Mono.CSharp {
 			}
 
 			Expression member_lookup = MemberLookup (
-				ec.ContainerType, expr_type, expr_type, lookup_id,
+				ec, ec.ContainerType, expr_type, expr_type, lookup_id,
 				MemberTypes.NestedType, BindingFlags.Public | BindingFlags.NonPublic, loc);
 			if (member_lookup == null) {
 				int errors = Report.Errors;
-				MemberLookupFailed (ec.ContainerType, expr_type, expr_type, lookup_id, null, false, loc);
+				MemberLookupFailed (ec, expr_type, expr_type, lookup_id, null, false, loc);
 
 				if (!silent && errors == Report.Errors) {
 					Report.Error (426, loc, "The nested type `{0}' does not exist in the type `{1}'",
@@ -7505,11 +7399,11 @@ namespace Mono.CSharp {
 			}
 
 			if (!(member_lookup is TypeExpr)) {
-				new_expr.Error_UnexpectedKind (ec.DeclContainer, "type", loc);
+				new_expr.Error_UnexpectedKind (ec, "type", loc);
 				return null;
 			}
 
-			TypeExpr texpr = member_lookup.ResolveAsTypeTerminal (ec, false);
+			TypeExpr texpr = member_lookup.ResolveAsTypeTerminal (ec);
 			if (texpr == null)
 				return null;
 
@@ -7529,7 +7423,7 @@ namespace Mono.CSharp {
 
 			if (the_args != null) {
 				ConstructedType ctype = new ConstructedType (texpr.Type, the_args, loc);
-				return ctype.ResolveAsTypeStep (ec, false);
+				return ctype.ResolveAsTypeStep (ec);
 			}
 
 			return texpr;
@@ -7894,11 +7788,7 @@ namespace Mono.CSharp {
 				ig.Emit (OpCodes.Ldelema, type);
 				ig.Emit (OpCodes.Ldobj, type);
 			} else if (type.IsGenericParameter)
-#if MS_COMPATIBLE
-				ig.Emit (OpCodes.Ldelem, type);
-#else
 				ig.Emit (OpCodes.Ldelem_Any, type);
-#endif
 			else if (type.IsPointer)
 				ig.Emit (OpCodes.Ldelem_I);
 			else
@@ -7940,12 +7830,7 @@ namespace Mono.CSharp {
 				return OpCodes.Stobj;
 			} else if (t.IsGenericParameter) {
 				has_type_arg = true;
-#if MS_COMPATIBLE
-				return OpCodes.Stelem;
-#else
 				return OpCodes.Stelem_Any;
-#endif
-
 			} else if (t.IsPointer)
 				return OpCodes.Stelem_I;
 			else
@@ -8372,19 +8257,6 @@ namespace Mono.CSharp {
 
 		public override Expression DoResolveLValue (EmitContext ec, Expression right_side)
 		{
-			if (right_side == EmptyExpression.OutAccess) {
-				Report.Error (206, loc, "A property or indexer `{0}' may not be passed as an out or ref parameter",
-					      GetSignatureForError ());
-				return null;
-			}
-
-			// if the indexer returns a value type, and we try to set a field in it
-			if (right_side == EmptyExpression.LValueMemberAccess) {
-				Report.Error (1612, loc, "Cannot modify the return value of `{0}' because it is not a variable",
-					      GetSignatureForError ());
-				return null;
-			}
-
 			ArrayList AllSetters = new ArrayList();
 			if (!CommonResolve (ec))
 				return null;
@@ -8498,25 +8370,17 @@ namespace Mono.CSharp {
 		{
 			Emit (ec, false);
 		}
-
-		public override string GetSignatureForError ()
-		{
-			// FIXME: print the argument list of the indexer
-			return instance_expr.GetSignatureForError () + ".this[...]";
-		}
 	}
 
 	/// <summary>
 	///   The base operator for method names
 	/// </summary>
 	public class BaseAccess : Expression {
-		public readonly string Identifier;
-		TypeArguments args;
+		string member;
 		
-		public BaseAccess (string member, TypeArguments args, Location l)
+		public BaseAccess (string member, Location l)
 		{
-			this.Identifier = member;
-			this.args = args;
+			this.member = member;
 			loc = l;
 		}
 
@@ -8567,10 +8431,11 @@ namespace Mono.CSharp {
 				return null;
 			}
 			
-			member_lookup = MemberLookup (ec.ContainerType, null, base_type, Identifier,
-						      AllMemberTypes, AllBindingFlags, loc);
+			member_lookup = MemberLookup (ec, ec.ContainerType, null, base_type,
+						      member, AllMemberTypes, AllBindingFlags,
+						      loc);
 			if (member_lookup == null) {
-				MemberLookupFailed (ec.ContainerType, base_type, base_type, Identifier, null, true, loc);
+				MemberLookupFailed (ec, base_type, base_type, member, null, true, loc);
 				return null;
 			}
 
@@ -8591,18 +8456,8 @@ namespace Mono.CSharp {
 				pe.IsBase = true;
 			}
 
-			MethodGroupExpr mg = e as MethodGroupExpr;
-			if (mg != null)
-				mg.IsBase = true;
-
-			if (args != null) {
-				if (mg != null)
-					return mg.ResolveGeneric (ec, args);
-
-				Report.Error (307, loc, "`{0}' cannot be used with type arguments",
-					      Identifier);
-				return null;
-			}
+			if (e is MethodGroupExpr)
+				((MethodGroupExpr) e).IsBase = true;
 
 			return e;
 		}
@@ -8654,9 +8509,6 @@ namespace Mono.CSharp {
 	public class EmptyExpression : Expression {
 		public static readonly EmptyExpression Null = new EmptyExpression ();
 
-		public static readonly EmptyExpression OutAccess = new EmptyExpression ();
-		public static readonly EmptyExpression LValueMemberAccess = new EmptyExpression ();
-
 		static EmptyExpression temp = new EmptyExpression ();
 		public static EmptyExpression Grab ()
 		{
@@ -8786,12 +8638,12 @@ namespace Mono.CSharp {
 
 		protected override TypeExpr DoResolveAsTypeStep (EmitContext ec)
 		{
-			TypeExpr lexpr = left.ResolveAsTypeTerminal (ec, false);
+			TypeExpr lexpr = left.ResolveAsTypeTerminal (ec);
 			if (lexpr == null)
 				return null;
 
 			bool old = ec.TestObsoleteMethodUsage;
-			ec.TestObsoleteMethodUsage = false;
+			ec.TestObsoleteMethodUsage = true;
 			Type ltype = lexpr.ResolveType (ec);
 			ec.TestObsoleteMethodUsage = old;
 
@@ -8805,7 +8657,7 @@ namespace Mono.CSharp {
 				TypeExpr nullable = new NullableType (left, loc);
 				if (dim.Length > 1)
 					nullable = new ComposedCast (nullable, dim.Substring (1), loc);
-				return nullable.ResolveAsTypeTerminal (ec, false);
+				return nullable.ResolveAsTypeTerminal (ec);
 			}
 
 			if (dim == "*" && !TypeManager.VerifyUnManaged (ltype, loc)) {
@@ -8837,16 +8689,15 @@ namespace Mono.CSharp {
 		}
 
 		public override string Name {
-			get { return left + dim; }
+			get {
+				return left + dim;
+			}
 		}
 
 		public override string FullName {
-			get { return type.FullName; }
-		}
-
-		public override string GetSignatureForError ()
-		{
-			return left.GetSignatureForError () + dim;
+			get {
+				return type.FullName;
+			}
 		}
 	}
 
@@ -8972,7 +8823,7 @@ namespace Mono.CSharp {
 				return null;
 			}
 
-			TypeExpr texpr = t.ResolveAsTypeTerminal (ec, false);
+			TypeExpr texpr = t.ResolveAsTypeTerminal (ec);
 			if (texpr == null)
 				return null;