Updated mcs.

ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs

@@ -2766,8 +2766,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				var initLoc = LocationsBag.GetLocations(minit);
 				var commaLoc = LocationsBag.GetLocations(minit.Initializers);
 				int curComma = 0;
-				if (initLoc != null)
-					init.AddChild(new CSharpTokenNode(Convert(initLoc [0]), Roles.LBrace), Roles.LBrace);
+				init.AddChild(new CSharpTokenNode(Convert(minit.Location), Roles.LBrace), Roles.LBrace);
 				foreach (var expr in minit.Initializers) {
 					var collectionInit = expr as CollectionElementInitializer;
 					if (collectionInit != null) {
@@ -2829,8 +2828,8 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 
 				if (initLoc != null) {
-					if (initLoc.Count == 3) // optional comma
-						init.AddChild(new CSharpTokenNode(Convert(initLoc [1]), Roles.Comma), Roles.Comma);
+					if (initLoc.Count == 2) // optional comma
+						init.AddChild(new CSharpTokenNode(Convert(initLoc [0]), Roles.Comma), Roles.Comma);
 					init.AddChild(new CSharpTokenNode(Convert(initLoc [initLoc.Count - 1]), Roles.RBrace), Roles.RBrace);
 				}
 			}

ICSharpCode.NRefactory.CSharp/Parser/mcs/assembly.cs

@@ -36,7 +36,6 @@ namespace Mono.CSharp
 	public interface IAssemblyDefinition
 	{
 		string FullName { get; }
-		bool HasExtensionMethod { get; }
 		bool IsCLSCompliant { get; }
 		bool IsMissing { get; }
 		string Name { get; }
@@ -132,12 +131,6 @@ namespace Mono.CSharp
 			}
 		}
 
-		public bool HasExtensionMethod {
-			get {
-				return module.HasExtensionMethod;
-			}
-		}
-
 		public bool HasCLSCompliantAttribute {
 			get {
 				return cls_attribute != null;

ICSharpCode.NRefactory.CSharp/Parser/mcs/attribute.cs

@@ -172,7 +172,7 @@ namespace Mono.CSharp {
 			if (NamedArguments == null)
 				named_args = new Arguments (1);
 
-			var value = Constant.CreateConstant (rc.Module.PredefinedTypes.CharSet.TypeSpec, rc.Module.DefaultCharSet, Location);
+			var value = Constant.CreateConstantFromValue (rc.Module.PredefinedTypes.CharSet.TypeSpec, rc.Module.DefaultCharSet, Location);
 			NamedArguments.Add (new NamedArgument (dll_import_char_set, loc, value));
 		}
 
@@ -1060,15 +1060,17 @@ namespace Mono.CSharp {
 				cdata = encoder.ToArray ();
 			}
 
-			try {
-				foreach (Attributable target in targets)
-					target.ApplyAttributeBuilder (this, ctor, cdata, predefined);
-			} catch (Exception e) {
-				if (e is BadImageFormat && Report.Errors > 0)
-					return;
+			if (!ctor.DeclaringType.IsConditionallyExcluded (context, Location)) {
+				try {
+					foreach (Attributable target in targets)
+						target.ApplyAttributeBuilder (this, ctor, cdata, predefined);
+				} catch (Exception e) {
+					if (e is BadImageFormat && Report.Errors > 0)
+						return;
 
-				Error_AttributeEmitError (e.Message);
-				return;
+					Error_AttributeEmitError (e.Message);
+					return;
+				}
 			}
 
 			if (!usage_attr.AllowMultiple && allEmitted != null) {
@@ -1659,7 +1661,6 @@ namespace Mono.CSharp {
 
 		// New in .NET 4.5
 		public readonly PredefinedStateMachineAttribute AsyncStateMachine;
-		public readonly PredefinedStateMachineAttribute IteratorStateMachine;
 
 		//
 		// Optional types which are used as types and for member lookup
@@ -1723,9 +1724,6 @@ namespace Mono.CSharp {
 			FieldOffset = new PredefinedAttribute (module, "System.Runtime.InteropServices", "FieldOffsetAttribute");
 
 			AsyncStateMachine = new PredefinedStateMachineAttribute (module, "System.Runtime.CompilerServices", "AsyncStateMachineAttribute");
-			IteratorStateMachine = new PredefinedStateMachineAttribute (module, "System.Runtime.CompilerServices", "IteratorStateMachineAttribute") {
-				IsIterator = true
-			};
 
 			CallerMemberNameAttribute = new PredefinedAttribute (module, "System.Runtime.CompilerServices", "CallerMemberNameAttribute");
 			CallerLineNumberAttribute = new PredefinedAttribute (module, "System.Runtime.CompilerServices", "CallerLineNumberAttribute");
@@ -1921,13 +1919,9 @@ namespace Mono.CSharp {
 		{
 		}
 
-		public bool IsIterator { get; set; }
-
 		public void EmitAttribute (MethodBuilder builder, StateMachine type)
 		{
-			var predefined_ctor = IsIterator ?
-				module.PredefinedMembers.IteratorStateMachineAttributeCtor :
-				module.PredefinedMembers.AsyncStateMachineAttributeCtor;
+			var predefined_ctor = module.PredefinedMembers.AsyncStateMachineAttributeCtor;
 
 			var ctor = predefined_ctor.Get ();
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/class.cs

@@ -298,6 +298,15 @@ namespace Mono.CSharp
 			return true;
 		}
 
+		public virtual void ExpandBaseInterfaces ()
+		{
+			if (containers != null) {
+				foreach (TypeContainer tc in containers) {
+					tc.ExpandBaseInterfaces ();
+				}
+			}
+		}
+
 		protected virtual void DefineNamespace ()
 		{
 			if (containers != null) {
@@ -676,6 +685,12 @@ namespace Mono.CSharp
 			}
 		}
 
+		bool ITypeDefinition.IsTypeForwarder {
+			get {
+				return false;
+			}
+		}
+
 		//
 		// Returns true for secondary partial containers
 		//
@@ -1483,12 +1498,14 @@ namespace Mono.CSharp
 					    GetSignatureForError (), cycle.GetSignatureForError ());
 
 					iface_exprs = null;
+					PartialContainer.iface_exprs = null;
 				} else {
 					Report.Error (146, Location,
 						"Circular base class dependency involving `{0}' and `{1}'",
 						GetSignatureForError (), cycle.GetSignatureForError ());
 
 					base_type = null;
+					PartialContainer.base_type = null;
 				}
 			}
 
@@ -1502,26 +1519,6 @@ namespace Mono.CSharp
 						continue;
 
 					TypeBuilder.AddInterfaceImplementation (iface_type.GetMetaInfo ());
-
-					// Ensure the base is always setup
-					var compiled_iface = iface_type.MemberDefinition as Interface;
-					if (compiled_iface != null) {
-						// TODO: Need DefineBaseType only
-						compiled_iface.DefineContainer ();
-					}
-
-					if (iface_type.Interfaces != null) {
-						var base_ifaces = new List<TypeSpec> (iface_type.Interfaces);
-						for (int i = 0; i < base_ifaces.Count; ++i) {
-							var ii_iface_type = base_ifaces[i];
-							if (spec.AddInterfaceDefined (ii_iface_type)) {
-								TypeBuilder.AddInterfaceImplementation (ii_iface_type.GetMetaInfo ());
-
-								if (ii_iface_type.Interfaces != null)
-									base_ifaces.AddRange (ii_iface_type.Interfaces);
-							}
-						}
-					}
 				}
 			}
 
@@ -1544,6 +1541,70 @@ namespace Mono.CSharp
 			return true;
 		}
 
+		public override void ExpandBaseInterfaces ()
+		{
+			if (!IsPartialPart)
+				DoExpandBaseInterfaces ();
+
+			base.ExpandBaseInterfaces ();
+		}
+
+		public void DoExpandBaseInterfaces ()
+		{
+			if ((caching_flags & Flags.InterfacesExpanded) != 0)
+				return;
+
+			caching_flags |= Flags.InterfacesExpanded;
+
+			//
+			// Expand base interfaces. It cannot be done earlier because all partial
+			// interface parts need to be defined before the type they are used from
+			//
+			if (iface_exprs != null) {
+				foreach (var iface in iface_exprs) {
+					if (iface == null)
+						continue;
+
+					var td = iface.MemberDefinition as TypeDefinition;
+					if (td != null)
+						td.DoExpandBaseInterfaces ();
+
+					if (iface.Interfaces == null)
+						continue;
+
+					foreach (var biface in iface.Interfaces) {
+						if (spec.AddInterfaceDefined (biface)) {
+							TypeBuilder.AddInterfaceImplementation (biface.GetMetaInfo ());
+						}
+					}
+				}
+			}
+
+			//
+			// Include all base type interfaces too, see ImportTypeBase for details
+			//
+			if (base_type != null) {
+				var td = base_type.MemberDefinition as TypeDefinition;
+				if (td != null)
+					td.DoExpandBaseInterfaces ();
+
+				//
+				// Simply use base interfaces only, they are all expanded which makes
+				// it easy to handle generic type argument propagation with single
+				// inflator only.
+				//
+				// interface IA<T> : IB<T>
+				// interface IB<U> : IC<U>
+				// interface IC<V>
+				//
+				if (base_type.Interfaces != null) {
+					foreach (var iface in base_type.Interfaces) {
+						spec.AddInterfaceDefined (iface);
+					}
+				}
+			}
+		}
+
 		public override void PrepareEmit ()
 		{
 			if ((caching_flags & Flags.CloseTypeCreated) != 0)
@@ -1727,9 +1788,6 @@ namespace Mono.CSharp
 					if (compiled_iface != null)
 						compiled_iface.Define ();
 
-					if (Kind == MemberKind.Interface)
-						MemberCache.AddInterface (iface_type);
-
 					ObsoleteAttribute oa = iface_type.GetAttributeObsolete ();
 					if (oa != null && !IsObsolete)
 						AttributeTester.Report_ObsoleteMessage (oa, iface_type.GetSignatureForError (), Location, Report);
@@ -1747,21 +1805,25 @@ namespace Mono.CSharp
 					}
 
 					if (iface_type.IsGenericOrParentIsGeneric) {
-						if (spec.Interfaces != null) {
-							foreach (var prev_iface in iface_exprs) {
-								if (prev_iface == iface_type)
-									break;
-
-								if (!TypeSpecComparer.Unify.IsEqual (iface_type, prev_iface))
-									continue;
-
-								Report.Error (695, Location,
-									"`{0}' cannot implement both `{1}' and `{2}' because they may unify for some type parameter substitutions",
-									GetSignatureForError (), prev_iface.GetSignatureForError (), iface_type.GetSignatureForError ());
-							}
+						foreach (var prev_iface in iface_exprs) {
+							if (prev_iface == iface_type || prev_iface == null)
+								break;
+
+							if (!TypeSpecComparer.Unify.IsEqual (iface_type, prev_iface))
+								continue;
+
+							Report.Error (695, Location,
+								"`{0}' cannot implement both `{1}' and `{2}' because they may unify for some type parameter substitutions",
+								GetSignatureForError (), prev_iface.GetSignatureForError (), iface_type.GetSignatureForError ());
 						}
 					}
 				}
+
+				if (Kind == MemberKind.Interface) {
+					foreach (var iface in spec.Interfaces) {
+						MemberCache.AddInterface (iface);
+					}
+				}
 			}
 
 			if (base_type != null) {
@@ -1780,11 +1842,6 @@ namespace Mono.CSharp
 					}
 				}
 
-				if (base_type.Interfaces != null) {
-					foreach (var iface in base_type.Interfaces)
-						spec.AddInterface (iface);
-				}
-
 				var baseContainer = base_type.MemberDefinition as ClassOrStruct;
 				if (baseContainer != null) {
 					baseContainer.Define ();

ICSharpCode.NRefactory.CSharp/Parser/mcs/constant.cs

@@ -103,17 +103,12 @@ namespace Mono.CSharp {
 				  TypeManager.CSharpName (Type), TypeManager.CSharpName (type));
 			}
 
-			return CreateConstant (type, constant_value, loc);
+			return CreateConstantFromValue (type, constant_value, loc);
 		}
 
 		//
 		//  Returns a constant instance based on Type
 		//
-		public static Constant CreateConstant (TypeSpec t, object v, Location loc)
-		{
-			return CreateConstantFromValue (t, v, loc);
-		}
-
 		public static Constant CreateConstantFromValue (TypeSpec t, object v, Location loc)
 		{
 			switch (t.BuiltinType) {

ICSharpCode.NRefactory.CSharp/Parser/mcs/cs-parser.jay

@@ -529,7 +529,7 @@ namespace_declaration
 		if (doc_support)
 			Lexer.doc_state = XmlCommentState.Allowed;
 	  }
-	  opt_extern_alias_directives opt_using_directives opt_namespace_or_type_declarations CLOSE_BRACE opt_semicolon
+	  opt_extern_alias_directives opt_using_directives opt_namespace_or_type_declarations CLOSE_BRACE opt_semicolon_error
 	  {
 		if ($11 != null)
 			lbag.AddLocation (current_container, GetLocation ($2), GetLocation ($5), GetLocation ($10), GetLocation ($11));
@@ -549,6 +549,16 @@ namespace_declaration
 	  }
 	;
 
+opt_semicolon_error
+	: /* empty */
+	| SEMICOLON
+	| error
+	  {
+		Error_SyntaxError (yyToken);
+	  	$$ = null;
+	  }
+	;
+
 namespace_name
 	: IDENTIFIER
 	  {
@@ -3285,17 +3295,16 @@ object_or_collection_initializer
 	: OPEN_BRACE opt_member_initializer_list close_brace_or_complete_completion
 	  {
 	  	if ($2 == null) {
-	  		$$ = new CollectionOrObjectInitializers (new List<Expression> (), GetLocation ($1));
-	  		lbag.AddLocation ($$, GetLocation ($1), GetLocation ($3));
+	  		$$ = new CollectionOrObjectInitializers (GetLocation ($1));
 	  	} else {
 	  		$$ = new CollectionOrObjectInitializers ((List<Expression>) $2, GetLocation ($1));
-	  		lbag.AddLocation ($$, GetLocation ($1), GetLocation ($3));
 	  	}
+ 		lbag.AddLocation ($$, GetLocation ($3));
 	  }
 	| OPEN_BRACE member_initializer_list COMMA CLOSE_BRACE
 	  {
 	  	$$ = new CollectionOrObjectInitializers ((List<Expression>) $2, GetLocation ($1));
-	  	lbag.AddLocation ($$, GetLocation ($1), GetLocation ($3), GetLocation ($4));
+	  	lbag.AddLocation ($$, GetLocation ($3), GetLocation ($4));
 	  }
 	;
 
@@ -4554,6 +4563,8 @@ lambda_expression_body
 	  {
 	  	// Handles only cases like foo = x.FirstOrDefault (l => );
 	  	// where we must restore current_variable
+		Block b = end_block (Location.Null);
+		b.IsCompilerGenerated = true;
 
 		Error_SyntaxError (yyToken);
 		$$ = null;
@@ -5492,8 +5503,9 @@ statement_expression
 	  {
 		ExpressionStatement s = $1 as ExpressionStatement;
 		if (s == null) {
-			Expression.Error_InvalidExpressionStatement (report, GetLocation ($1));
-			$$ = new StatementErrorExpression ($1 as Expression);
+			var expr = $1 as Expression;
+			expr.Error_InvalidExpressionStatement (report);
+			$$ = new StatementErrorExpression (expr);
 		} else {
 			$$ = new StatementExpression (s);
 		}
@@ -7005,7 +7017,7 @@ void Error_ExpectingTypeName (Expression expr)
 	if (expr is Invocation){
 		report.Error (1002, expr.Location, "Expecting `;'");
 	} else {
-		Expression.Error_InvalidExpressionStatement (report, expr.Location);
+		expr.Error_InvalidExpressionStatement (report);
 	}
 }
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/cs-tokenizer.cs

@@ -1273,6 +1273,7 @@ namespace Mono.CSharp
 			case Token.OPEN_BRACKET:
 			case Token.OP_GENERICS_GT:
 			case Token.INTERR:
+			case Token.OP_COALESCING:
 				next_token = Token.INTERR_NULLABLE;
 				break;
 				
@@ -1567,13 +1568,13 @@ namespace Mono.CSharp
 		//
 		// Invoked if we know we have .digits or digits
 		//
-		int is_number (int c)
+		int is_number (int c, bool dotLead)
 		{
 			ILiteralConstant res;
 
 #if FULL_AST
 			int read_start = reader.Position - 1;
-			if (c == '.') {
+			if (dotLead) {
 				//
 				// Caller did peek_char
 				//
@@ -1584,7 +1585,7 @@ namespace Mono.CSharp
 			var loc = Location;
 			bool hasLeadingDot = c == '.';
 
-			if (c >= '0' && c <= '9'){
+			if (!dotLead){
 				if (c == '0'){
 					int peek = peek_char ();
 
@@ -1598,7 +1599,7 @@ namespace Mono.CSharp
 					}
 				}
 				decimal_digits (c);
-				c = get_char ();
+				c = peek_char ();
 			}
 
 			//
@@ -1607,9 +1608,12 @@ namespace Mono.CSharp
 			//
 			bool is_real = false;
 			if (c == '.'){
+				if (!dotLead)
+					get_char ();
+
 				if (decimal_digits ('.')){
 					is_real = true;
-					c = get_char ();
+					c = peek_char ();
 				} else {
 					putback ('.');
 					number_pos--;
@@ -1623,6 +1627,7 @@ namespace Mono.CSharp
 			
 			if (c == 'e' || c == 'E'){
 				is_real = true;
+				get_char ();
 				if (number_pos == MaxNumberLength)
 					Error_NumericConstantTooLong ();
 				number_builder [number_pos++] = (char) c;
@@ -1645,18 +1650,17 @@ namespace Mono.CSharp
 				}
 					
 				decimal_digits (c);
-				c = get_char ();
+				c = peek_char ();
 			}
 
 			var type = real_type_suffix (c);
 			if (type == TypeCode.Empty && !is_real) {
-				putback (c);
 				res = adjust_int (c, loc);
 			} else {
 				is_real = true;
 
-				if (type == TypeCode.Empty) {
-					putback (c);
+				if (type != TypeCode.Empty) {
+					get_char ();
 				}
 
 				res = adjust_real (type, loc);
@@ -3520,7 +3524,7 @@ namespace Mono.CSharp
 				case '0': case '1': case '2': case '3': case '4':
 				case '5': case '6': case '7': case '8': case '9':
 					tokens_seen = true;
-					return is_number (c);
+					return is_number (c, false);
 
 				case '\n': // white space
 					any_token_seen |= tokens_seen;
@@ -3532,7 +3536,7 @@ namespace Mono.CSharp
 					tokens_seen = true;
 					d = peek_char ();
 					if (d >= '0' && d <= '9')
-						return is_number (c);
+						return is_number (c, true);
 
 					ltb.CreateOptional (current_source, ref_line, col, ref val);
 					return Token.DOT;

ICSharpCode.NRefactory.CSharp/Parser/mcs/decl.cs

@@ -300,7 +300,8 @@ namespace Mono.CSharp {
 			HasStructLayout	= 1 << 15,			// Has StructLayoutAttribute
 			HasInstanceConstructor = 1 << 16,
 			HasUserOperators = 1 << 17,
-			CanBeReused = 1 << 18
+			CanBeReused = 1 << 18,
+			InterfacesExpanded = 1 << 19
 		}
 
 		/// <summary>
@@ -972,7 +973,10 @@ namespace Mono.CSharp {
 			this.definition = definition;
 			this.modifiers = modifiers;
 
-			state = StateFlags.Obsolete_Undetected | StateFlags.CLSCompliant_Undetected | StateFlags.MissingDependency_Undetected;
+			if (kind == MemberKind.MissingType)
+				state = StateFlags.MissingDependency;
+			else
+				state = StateFlags.Obsolete_Undetected | StateFlags.CLSCompliant_Undetected | StateFlags.MissingDependency_Undetected;
 		}
 
 		#region Properties

ICSharpCode.NRefactory.CSharp/Parser/mcs/delegate.cs

@@ -441,7 +441,7 @@ namespace Mono.CSharp {
 			return false;
 		}
 
-		public static Arguments CreateDelegateMethodArguments (AParametersCollection pd, TypeSpec[] types, Location loc)
+		public static Arguments CreateDelegateMethodArguments (ResolveContext rc, AParametersCollection pd, TypeSpec[] types, Location loc)
 		{
 			Arguments delegate_arguments = new Arguments (pd.Count);
 			for (int i = 0; i < pd.Count; ++i) {
@@ -458,7 +458,11 @@ namespace Mono.CSharp {
 					break;
 				}
 
-				delegate_arguments.Add (new Argument (new TypeExpression (types [i], loc), atype_modifier));
+				var ptype = types[i];
+				if (ptype.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
+					ptype = rc.BuiltinTypes.Object;
+
+				delegate_arguments.Add (new Argument (new TypeExpression (ptype, loc), atype_modifier));
 			}
 
 			return delegate_arguments;
@@ -494,7 +498,7 @@ namespace Mono.CSharp {
 
 			var invoke_method = Delegate.GetInvokeMethod (type);
 
-			Arguments arguments = CreateDelegateMethodArguments (invoke_method.Parameters, invoke_method.Parameters.Types, loc);
+			Arguments arguments = CreateDelegateMethodArguments (ec, invoke_method.Parameters, invoke_method.Parameters.Types, loc);
 			method_group = method_group.OverloadResolve (ec, ref arguments, this, OverloadResolver.Restrictions.CovariantDelegate);
 			if (method_group == null)
 				return null;
@@ -602,7 +606,7 @@ namespace Mono.CSharp {
 
 			var invoke = Delegate.GetInvokeMethod (target_type);
 
-			Arguments arguments = CreateDelegateMethodArguments (invoke.Parameters, invoke.Parameters.Types, mg.Location);
+			Arguments arguments = CreateDelegateMethodArguments (ec, invoke.Parameters, invoke.Parameters.Types, mg.Location);
 			return mg.OverloadResolve (ec, ref arguments, null, OverloadResolver.Restrictions.CovariantDelegate | OverloadResolver.Restrictions.ProbingOnly) != null;
 		}
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/ecore.cs

@@ -225,14 +225,19 @@ namespace Mono.CSharp {
 				name, TypeManager.CSharpName (type));
 		}
 
-		public static void Error_InvalidExpressionStatement (Report Report, Location loc)
+		protected virtual void Error_InvalidExpressionStatement (Report report, Location loc)
 		{
-			Report.Error (201, loc, "Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement");
+			report.Error (201, loc, "Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement");
 		}
 		
-		public void Error_InvalidExpressionStatement (BlockContext ec)
+		public void Error_InvalidExpressionStatement (BlockContext bc)
 		{
-			Error_InvalidExpressionStatement (ec.Report, loc);
+			Error_InvalidExpressionStatement (bc.Report, loc);
+		}
+
+		public void Error_InvalidExpressionStatement (Report report)
+		{
+			Error_InvalidExpressionStatement (report, loc);
 		}
 
 		public static void Error_VoidInvalidInTheContext (Location loc, Report Report)
@@ -360,6 +365,27 @@ namespace Mono.CSharp {
 			}
 		}
 
+		//
+		// Implements identical simple name and type-name resolution
+		//
+		public Expression ProbeIdenticalTypeName (ResolveContext rc, Expression left, SimpleName name)
+		{
+			var t = left.Type;
+			if (t.Kind == MemberKind.InternalCompilerType || t is ElementTypeSpec || t.Arity > 0)
+				return left;
+
+			// In a member access of the form E.I, if E is a single identifier, and if the meaning of E as a simple-name is
+			// a constant, field, property, local variable, or parameter with the same type as the meaning of E as a type-name
+
+			if (left is MemberExpr || left is VariableReference) {
+				var identical_type = rc.LookupNamespaceOrType (name.Name, 0, LookupMode.Probing, loc) as TypeExpr;
+				if (identical_type != null && identical_type.Type == left.Type)
+					return identical_type;
+			}
+
+			return left;
+		}
+
 		public virtual string GetSignatureForError ()
 		{
 			return type.GetDefinition ().GetSignatureForError ();
@@ -675,7 +701,7 @@ namespace Mono.CSharp {
 					if ((member.Modifiers & Modifiers.OVERRIDE) != 0 && member.Kind != MemberKind.Event)
 						continue;
 
-					if ((member.Modifiers & Modifiers.BACKING_FIELD) != 0)
+					if ((member.Modifiers & Modifiers.BACKING_FIELD) != 0 || member.Kind == MemberKind.Operator)
 						continue;
 
 					if ((arity > 0 || (restrictions & MemberLookupRestrictions.ExactArity) != 0) && member.Arity != arity)
@@ -714,6 +740,23 @@ namespace Mono.CSharp {
 					if (non_method == null || member is MethodSpec || non_method.IsNotCSharpCompatible) {
 						non_method = member;
 					} else if (!errorMode && !member.IsNotCSharpCompatible) {
+						//
+						// Interface members that are hidden by class members are removed from the set when T is a type parameter and
+						// T has both an effective base class other than object and a non-empty effective interface set.
+						//
+						// The spec has more complex rules but we simply remove all members declared in an interface declaration.
+						//
+						var tps = queried_type as TypeParameterSpec;
+						if (tps != null && tps.HasTypeConstraint) {
+							if (non_method.DeclaringType.IsClass && member.DeclaringType.IsInterface)
+								continue;
+
+							if (non_method.DeclaringType.IsInterface && member.DeclaringType.IsInterface) {
+								non_method = member;
+								continue;
+							}
+						}
+
 						ambig_non_method = member;
 					}
 				}
@@ -2302,10 +2345,16 @@ namespace Mono.CSharp {
 
 			var ns_candidates = ctx.Module.GlobalRootNamespace.FindTypeNamespaces (ctx, Name, Arity);
 			if (ns_candidates != null) {
-				string usings = string.Join ("' or `", ns_candidates.ToArray ());
-				report.Error (246, loc,
-					"The type or namespace name `{0}' could not be found. Are you missing `{1}' using directive?",
-					Name, usings);
+				if (ctx is UsingAliasNamespace.AliasContext) {
+					report.Error (246, loc,
+						"The type or namespace name `{1}' could not be found. Consider using fully qualified name `{0}.{1}'",
+						ns_candidates[0], Name);
+				} else {
+					string usings = string.Join ("' or `", ns_candidates.ToArray ());
+					report.Error (246, loc,
+						"The type or namespace name `{0}' could not be found. Are you missing `{1}' using directive?",
+						Name, usings);
+				}
 			} else {
 				report.Error (246, loc,
 					"The type or namespace name `{0}' could not be found. Are you missing an assembly reference?",
@@ -2788,7 +2837,7 @@ namespace Mono.CSharp {
 				//
 				TypeSpec[] targs = null;
 				if (method.DeclaringType != InstanceExpression.Type) {
-					var base_override = MemberCache.FindMember (InstanceExpression.Type, new MemberFilter (method), BindingRestriction.InstanceOnly) as MethodSpec;
+					var base_override = MemberCache.FindMember (InstanceExpression.Type, new MemberFilter (method), BindingRestriction.InstanceOnly | BindingRestriction.OverrideOnly) as MethodSpec;
 					if (base_override != null && base_override.DeclaringType != method.DeclaringType) {
 						if (base_override.IsGeneric)
 							targs = method.TypeArguments;
@@ -2933,27 +2982,6 @@ namespace Mono.CSharp {
 				member.GetSignatureForError (), qualifier.GetSignatureForError (), rc.CurrentType.GetSignatureForError ());
 		}
 
-		//
-		// Implements identicial simple name and type-name
-		//
-		public Expression ProbeIdenticalTypeName (ResolveContext rc, Expression left, SimpleName name)
-		{
-			var t = left.Type;
-			if (t.Kind == MemberKind.InternalCompilerType || t is ElementTypeSpec || t.Arity > 0)
-				return left;
-
-			// In a member access of the form E.I, if E is a single identifier, and if the meaning of E as a simple-name is
-			// a constant, field, property, local variable, or parameter with the same type as the meaning of E as a type-name
-
-			if (left is MemberExpr || left is VariableReference) {
-				var identical_type = rc.LookupNamespaceOrType (name.Name, 0, LookupMode.Probing, loc) as TypeExpr;
-				if (identical_type != null && identical_type.Type == left.Type)
-					return identical_type;
-			}
-
-			return left;
-		}
-
 		public bool ResolveInstanceExpression (ResolveContext rc, Expression rhs)
 		{
 			if (!ResolveInstanceExpressionCore (rc, rhs))
@@ -3827,11 +3855,7 @@ namespace Mono.CSharp {
 				// better conversion is performed between underlying types Y1 and Y2
 				//
 				if (p.IsGenericTask || q.IsGenericTask) {
-					if (am.Block.IsAsync) {
-						if (p.IsGenericTask != q.IsGenericTask) {
-							return 0;
-						}
-
+					if (am.Block.IsAsync && p.IsGenericTask && q.IsGenericTask) {
 						q = q.TypeArguments[0];
 						p = p.TypeArguments[0];
 					}
@@ -4205,6 +4229,9 @@ namespace Mono.CSharp {
 					} else if (arg_count > param_count) {
 						int args_gap = System.Math.Abs (arg_count - param_count);
 						return int.MaxValue - 10000 + args_gap;
+					} else if (arg_count < param_count - optional_count) {
+						int args_gap = System.Math.Abs (param_count - optional_count - arg_count);
+						return int.MaxValue - 10000 + args_gap;
 					}
 				} else if (arg_count != param_count) {
 					int args_gap = System.Math.Abs (arg_count - param_count);
@@ -4379,7 +4406,8 @@ namespace Mono.CSharp {
 				}
 
 				candidate = ms;
-				ptypes = ms.Parameters.Types;
+				pd = ms.Parameters;
+				ptypes = pd.Types;
 			} else {
 				if (type_arguments != null)
 					return int.MaxValue - 15000;
@@ -4407,34 +4435,15 @@ namespace Mono.CSharp {
 					// if the type matches
 					//
 					Expression e = fp.DefaultValue;
-					if (!(e is Constant) || e.Type != ptypes [i]) {
-						//
-						// LAMESPEC: No idea what the exact rules are for System.Reflection.Missing.Value instead of null
-						//
-						var ptype = ptypes [i];
-						if (e == EmptyExpression.MissingValue && ptype.BuiltinType == BuiltinTypeSpec.Type.Object || ptype.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
-							e = new MemberAccess (new MemberAccess (new MemberAccess (
-								new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Reflection", loc), "Missing", loc), "Value", loc);
-						} else if (e is Constant) {
-							//
-							// Handles int to int? conversions
-							//
-							e = Convert.ImplicitConversionStandard (ec, e, ptype, loc);
-							
-							//
-							// When constant type paramter contains type argument
-							//
-							// Foo (T[] arg = null)
-							//
-							if (e == null) {
-								e = new DefaultValueExpression (new TypeExpression (ptype, loc), loc);
-							}
-						} else {
-							e = new DefaultValueExpression (new TypeExpression (ptype, loc), loc);
+					if (e != null) {
+						e = ResolveDefaultValueArgument (ec, ptypes[i], e, loc);
+						if (e == null) {
+							// Restore for possible error reporting
+							for (int ii = i; ii < arg_count; ++ii)
+								arguments.RemoveAt (i);
+
+							return (arg_count - i) * 2 + 1;
 						}
-					
-
-						e = e.Resolve (ec);
 					}
 
 					if ((fp.ModFlags & Parameter.Modifier.CallerMask) != 0) {
@@ -4527,6 +4536,31 @@ namespace Mono.CSharp {
 			return 0;
 		}
 
+		public static Expression ResolveDefaultValueArgument (ResolveContext ec, TypeSpec ptype, Expression e, Location loc)
+		{
+			if (e is Constant && e.Type == ptype)
+				return e;
+
+			//
+			// LAMESPEC: No idea what the exact rules are for System.Reflection.Missing.Value instead of null
+			//
+			if (e == EmptyExpression.MissingValue && ptype.BuiltinType == BuiltinTypeSpec.Type.Object || ptype.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
+				e = new MemberAccess (new MemberAccess (new MemberAccess (
+					new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Reflection", loc), "Missing", loc), "Value", loc);
+			} else if (e is Constant) {
+				//
+				// Handles int to int? conversions, DefaultParameterValue check
+				//
+				e = Convert.ImplicitConversionStandard (ec, e, ptype, loc);
+				if (e == null)
+					return null;
+			} else {
+				e = new DefaultValueExpression (new TypeExpression (ptype, loc), loc);
+			}
+
+			return e.Resolve (ec);
+		}
+
 		//
 		// Tests argument compatibility with the parameter
 		// The possible return values are
@@ -5262,7 +5296,7 @@ namespace Mono.CSharp {
 			var c = constant.GetConstant (rc);
 
 			// Creates reference expression to the constant value
-			return Constant.CreateConstant (constant.MemberType, c.GetValue (), loc);
+			return Constant.CreateConstantFromValue (constant.MemberType, c.GetValue (), loc);
 		}
 
 		public override void Emit (EmitContext ec)
@@ -5817,6 +5851,8 @@ namespace Mono.CSharp {
 	//
 	sealed class PropertyExpr : PropertyOrIndexerExpr<PropertySpec>
 	{
+		Arguments arguments;
+
 		public PropertyExpr (PropertySpec spec, Location l)
 			: base (l)
 		{
@@ -5828,9 +5864,10 @@ namespace Mono.CSharp {
 
 		protected override Arguments Arguments {
 			get {
-				return null;
+				return arguments;
 			}
 			set {
+				arguments = value;
 			}
 		}
 
@@ -5987,7 +6024,7 @@ namespace Mono.CSharp {
 					}
 				}
 			} else {
-				args = new Arguments (1);
+				args = arguments == null ? new Arguments (1) : arguments;
 
 				if (leave_copy) {
 					source.Emit (ec);
@@ -6037,6 +6074,22 @@ namespace Mono.CSharp {
 			}
 
 			DoBestMemberChecks (rc, best_candidate);
+
+			// Handling of com-imported properties with any number of default property parameters
+			if (best_candidate.HasGet && !best_candidate.Get.Parameters.IsEmpty) {
+				var p = best_candidate.Get.Parameters;
+				arguments = new Arguments (p.Count);
+				for (int i = 0; i < p.Count; ++i) {
+					arguments.Add (new Argument (OverloadResolver.ResolveDefaultValueArgument (rc, p.Types [i], p.FixedParameters [i].DefaultValue, loc)));
+				}
+			} else if (best_candidate.HasSet && best_candidate.Set.Parameters.Count > 1) {
+				var p = best_candidate.Set.Parameters;
+				arguments = new Arguments (p.Count - 1);
+				for (int i = 0; i < p.Count - 1; ++i) {
+					arguments.Add (new Argument (OverloadResolver.ResolveDefaultValueArgument (rc, p.Types [i], p.FixedParameters [i].DefaultValue, loc)));
+				}
+			}
+
 			return this;
 		}
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/expression.cs

@@ -4643,7 +4643,7 @@ namespace Mono.CSharp
 						// ambiguous because 1 literal can be converted to short.
 						//
 						if (conv_false_expr != null) {
-							if (conv_false_expr is IntConstant && conv is Constant) {
+							if (conv_false_expr.Type.BuiltinType == BuiltinTypeSpec.Type.Int && conv is Constant) {
 								type = true_type;
 								conv_false_expr = null;
 							} else if (type.BuiltinType == BuiltinTypeSpec.Type.Int && conv_false_expr is Constant) {
@@ -8081,7 +8081,7 @@ namespace Mono.CSharp
 						return null;
 					}
 
-					if (member_lookup is MethodGroupExpr) {
+					if (member_lookup is MethodGroupExpr || member_lookup is PropertyExpr) {
 						// Leave it to overload resolution to report correct error
 					} else if (!(member_lookup is TypeExpr)) {
 						// TODO: rc.SymbolRelatedToPreviousError
@@ -8100,13 +8100,9 @@ namespace Mono.CSharp
 
 			TypeExpr texpr = member_lookup as TypeExpr;
 			if (texpr != null) {
-				if (!(expr is TypeExpr)) {
-					me = expr as MemberExpr;
-					if (me == null || me.ProbeIdenticalTypeName (rc, expr, sn) == expr) {
-						rc.Report.Error (572, loc, "`{0}': cannot reference a type through an expression; try `{1}' instead",
-							Name, member_lookup.GetSignatureForError ());
-						return null;
-					}
+				if (!(expr is TypeExpr) && (sn == null || expr.ProbeIdenticalTypeName (rc, expr, sn) == expr)) {
+					rc.Report.Error (572, loc, "`{0}': cannot reference a type through an expression. Consider using `{1}' instead",
+						Name, texpr.GetSignatureForError ());
 				}
 
 				if (!texpr.Type.IsAccessible (rc)) {
@@ -8261,6 +8257,11 @@ namespace Mono.CSharp
 				Name, expr_type.GetSignatureForError ());
 		}
 
+		protected override void Error_InvalidExpressionStatement (Report report, Location loc)
+		{
+			base.Error_InvalidExpressionStatement (report, LeftExpression.Location);
+		}
+
 		protected override void Error_TypeDoesNotContainDefinition (ResolveContext ec, TypeSpec type, string name)
 		{
 			if (ec.Module.Compiler.Settings.Version > LanguageVersion.ISO_2 && !ec.IsRuntimeBinder && MethodGroupExpr.IsExtensionMethodArgument (expr)) {
@@ -9945,9 +9946,11 @@ namespace Mono.CSharp
 	{
 		IList<Expression> initializers;
 		bool is_collection_initialization;
-		
-		public static readonly CollectionOrObjectInitializers Empty = 
-			new CollectionOrObjectInitializers (Array.AsReadOnly (new Expression [0]), Location.Null);
+
+		public CollectionOrObjectInitializers (Location loc)
+			: this (new Expression[0], loc)
+		{
+		}
 
 		public CollectionOrObjectInitializers (IList<Expression> initializers, Location loc)
 		{
@@ -10157,6 +10160,7 @@ namespace Mono.CSharp
 
 		CollectionOrObjectInitializers initializers;
 		IMemoryLocation instance;
+		DynamicExpressionStatement dynamic;
 
 		public NewInitialize (FullNamedExpression requested_type, Arguments arguments, CollectionOrObjectInitializers initializers, Location l)
 			: base (requested_type, arguments, l)
@@ -10201,16 +10205,32 @@ namespace Mono.CSharp
 			if (type == null)
 				return null;
 
+			if (type.IsDelegate) {
+				ec.Report.Error (1958, Initializers.Location,
+					"Object and collection initializers cannot be used to instantiate a delegate");
+			}
+
 			Expression previous = ec.CurrentInitializerVariable;
 			ec.CurrentInitializerVariable = new InitializerTargetExpression (this);
 			initializers.Resolve (ec);
 			ec.CurrentInitializerVariable = previous;
+
+			dynamic = e as DynamicExpressionStatement;
+			if (dynamic != null)
+				return this;
+
 			return e;
 		}
 
 		public override bool Emit (EmitContext ec, IMemoryLocation target)
 		{
-			bool left_on_stack = base.Emit (ec, target);
+			bool left_on_stack;
+			if (dynamic != null) {
+				dynamic.Emit (ec);
+				left_on_stack = true;
+			} else {
+				left_on_stack = base.Emit (ec, target);
+			}
 
 			if (initializers.IsEmpty)
 				return left_on_stack;

ICSharpCode.NRefactory.CSharp/Parser/mcs/generic.cs

@@ -422,6 +422,12 @@ namespace Mono.CSharp {
 			}
 		}
 
+		bool ITypeDefinition.IsComImport {
+			get {
+				return false;
+			}
+		}
+
 		bool ITypeDefinition.IsPartial {
 			get {
 				return false;
@@ -434,6 +440,12 @@ namespace Mono.CSharp {
 			}
 		}
 
+		bool ITypeDefinition.IsTypeForwarder {
+			get {
+				return false;
+			}
+		}
+
 		public string Name {
 			get {
 				return MemberName.Name;
@@ -754,21 +766,39 @@ namespace Mono.CSharp {
 			get {
 				if ((state & StateFlags.InterfacesExpanded) == 0) {
 					if (ifaces != null) {
-						for (int i = 0; i < ifaces.Count; ++i ) {
-							var iface_type = ifaces[i];
-							if (iface_type.Interfaces != null) {
-								if (ifaces_defined == null)
-									ifaces_defined = ifaces.ToArray ();
+						if (ifaces_defined == null)
+							ifaces_defined = ifaces.ToArray ();
+
+						for (int i = 0; i < ifaces_defined.Length; ++i ) {
+							var iface_type = ifaces_defined[i];
+							var td = iface_type.MemberDefinition as TypeDefinition;
+							if (td != null)
+								td.DoExpandBaseInterfaces ();
 
+							if (iface_type.Interfaces != null) {
 								for (int ii = 0; ii < iface_type.Interfaces.Count; ++ii) {
 									var ii_iface_type = iface_type.Interfaces [ii];
-
 									AddInterface (ii_iface_type);
 								}
 							}
 						}
 					}
 
+					//
+					// Include all base type interfaces too, see ImportTypeBase for details
+					//
+					if (BaseType != null) {
+						var td = BaseType.MemberDefinition as TypeDefinition;
+						if (td != null)
+							td.DoExpandBaseInterfaces ();
+
+						if (BaseType.Interfaces != null) {
+							foreach (var iface in BaseType.Interfaces) {
+								AddInterface (iface);
+							}
+						}
+					}
+
 					if (ifaces_defined == null)
 						ifaces_defined = ifaces == null ? TypeSpec.EmptyTypes : ifaces.ToArray ();
 
@@ -796,7 +826,7 @@ namespace Mono.CSharp {
 			set {
 				ifaces_defined = value;
 				if (value != null && value.Length != 0)
-					ifaces = value;
+					ifaces = new List<TypeSpec> (value);
 			}
 		}
 
@@ -1156,6 +1186,15 @@ namespace Mono.CSharp {
 		public void InflateConstraints (TypeParameterInflator inflator, TypeParameterSpec tps)
 		{
 			tps.BaseType = inflator.Inflate (BaseType);
+
+			var defined = InterfacesDefined;
+			if (defined != null) {
+				tps.ifaces_defined = new TypeSpec[defined.Length];
+				for (int i = 0; i < defined.Length; ++i)
+					tps.ifaces_defined [i] = inflator.Inflate (defined[i]);
+			}
+
+			var ifaces = Interfaces;
 			if (ifaces != null) {
 				tps.ifaces = new List<TypeSpec> (ifaces.Count);
 				for (int i = 0; i < ifaces.Count; ++i)
@@ -1192,8 +1231,8 @@ namespace Mono.CSharp {
 			if (BaseType.BuiltinType != BuiltinTypeSpec.Type.Object && BaseType.BuiltinType != BuiltinTypeSpec.Type.ValueType)
 				cache.AddBaseType (BaseType);
 
-			if (ifaces != null) {
-				foreach (var iface_type in Interfaces) {
+			if (InterfacesDefined != null) {
+				foreach (var iface_type in InterfacesDefined) {
 					cache.AddInterface (iface_type);
 				}
 			}
@@ -1204,8 +1243,11 @@ namespace Mono.CSharp {
 					if (b_type.BuiltinType != BuiltinTypeSpec.Type.Object && b_type.BuiltinType != BuiltinTypeSpec.Type.ValueType)
 						cache.AddBaseType (b_type);
 
-					if (ta.Interfaces != null) {
-						foreach (var iface_type in ta.Interfaces) {
+					var tps = ta as TypeParameterSpec;
+					var ifaces = tps != null ? tps.InterfacesDefined : ta.Interfaces;
+
+					if (ifaces != null) {
+						foreach (var iface_type in ifaces) {
 							cache.AddInterface (iface_type);
 						}
 					}
@@ -1256,6 +1298,22 @@ namespace Mono.CSharp {
 			return false;
 		}
 
+		public bool HasDependencyOn (TypeSpec type)
+		{
+			if (TypeArguments != null) {
+				foreach (var targ in TypeArguments) {
+					if (TypeSpecComparer.Override.IsEqual (targ, type))
+						return true;
+
+					var tps = targ as TypeParameterSpec;
+					if (tps != null && tps.HasDependencyOn (type))
+						return true;
+				}
+			}
+
+			return false;
+		}
+
 		public override TypeSpec Mutate (TypeParameterMutator mutator)
 		{
 			return mutator.Mutate (this);
@@ -1619,6 +1677,16 @@ namespace Mono.CSharp {
 
 		#endregion
 
+		public override bool AddInterface (TypeSpec iface)
+		{
+			var inflator = CreateLocalInflator (context);
+			iface = inflator.Inflate (iface);
+			if (iface == null)
+				return false;
+
+			return base.AddInterface (iface);
+		}
+
 		public static bool ContainsTypeParameter (TypeSpec type)
 		{
 			if (type.Kind == MemberKind.TypeParameter)
@@ -1828,7 +1896,7 @@ namespace Mono.CSharp {
 						if (iface_inflated == null)
 							continue;
 
-						AddInterface (iface_inflated);
+						base.AddInterface (iface_inflated);
 					}
 				}
 
@@ -2374,6 +2442,7 @@ namespace Mono.CSharp {
 							return false;
 
 						ok = false;
+						break;
 					}
 				}
 			}
@@ -2388,6 +2457,7 @@ namespace Mono.CSharp {
 							return false;
 
 						ok = false;
+						break;
 					}
 				}
 			}
@@ -2432,12 +2502,8 @@ namespace Mono.CSharp {
 
 			if (atype.IsGenericParameter) {
 				var tps = (TypeParameterSpec) atype;
-				if (tps.TypeArguments != null) {
-					foreach (var targ in tps.TypeArguments) {
-						if (TypeSpecComparer.Override.IsEqual (targ, ttype))
-							return true;
-					}
-				}
+				if (tps.HasDependencyOn (ttype))
+					return true;
 
 				if (Convert.ImplicitTypeParameterConversion (null, tps, ttype) != null)
 					return true;
@@ -3253,12 +3319,12 @@ namespace Mono.CSharp {
 					//
 					if (t.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
 						u_candidates.Add (t);
+				}
 
-					if (t.Interfaces != null) {
-						foreach (var iface in t.Interfaces) {
-							if (open_v == iface.MemberDefinition)
-								u_candidates.Add (iface);
-						}
+				if (u.Interfaces != null) {
+					foreach (var iface in u.Interfaces) {
+						if (open_v == iface.MemberDefinition)
+							u_candidates.Add (iface);
 					}
 				}
 
@@ -3394,7 +3460,7 @@ namespace Mono.CSharp {
 				}
 
 				MethodGroupExpr mg = (MethodGroupExpr) e;
-				Arguments args = DelegateCreation.CreateDelegateMethodArguments (invoke.Parameters, param_types, e.Location);
+				Arguments args = DelegateCreation.CreateDelegateMethodArguments (ec, invoke.Parameters, param_types, e.Location);
 				mg = mg.OverloadResolve (ec, ref args, null, OverloadResolver.Restrictions.CovariantDelegate | OverloadResolver.Restrictions.ProbingOnly);
 				if (mg == null)
 					return 0;

ICSharpCode.NRefactory.CSharp/Parser/mcs/import.cs

@@ -6,7 +6,7 @@
 // Dual licensed under the terms of the MIT X11 or GNU GPL
 //
 // Copyright 2009-2011 Novell, Inc
-// Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
+// Copyright 2011-2012 Xamarin, Inc (http://www.xamarin.com)
 //
 
 using System;
@@ -32,7 +32,7 @@ namespace Mono.CSharp
 		// Dynamic types reader with additional logic to reconstruct a dynamic
 		// type using DynamicAttribute values
 		//
-		struct DynamicTypeReader
+		protected struct DynamicTypeReader
 		{
 			static readonly bool[] single_attribute = { true };
 
@@ -120,7 +120,7 @@ namespace Mono.CSharp
 		protected readonly Dictionary<MetaType, TypeSpec> import_cache;
 		protected readonly Dictionary<MetaType, TypeSpec> compiled_types;
 		protected readonly Dictionary<Assembly, IAssemblyDefinition> assembly_2_definition;
-		readonly ModuleContainer module;
+		protected readonly ModuleContainer module;
 
 		public static readonly string CompilerServicesNamespace = "System.Runtime.CompilerServices";
 
@@ -191,7 +191,9 @@ namespace Mono.CSharp
 			var definition = new ImportedMemberDefinition (fi, field_type, this);
 
 			if ((fa & FieldAttributes.Literal) != 0) {
-				var c = Constant.CreateConstantFromValue (field_type, fi.GetRawConstantValue (), Location.Null);
+				Constant c = field_type.Kind == MemberKind.MissingType ?
+					new NullConstant (InternalType.ErrorType, Location.Null) :
+					Constant.CreateConstantFromValue (field_type, fi.GetRawConstantValue (), Location.Null);
 				return new ConstSpec (declaringType, definition, field_type, fi, mod, c);
 			}
 
@@ -489,7 +491,7 @@ namespace Mono.CSharp
 					//
 					var el = p.ParameterType.GetElementType ();
 					types[i] = ImportType (el, new DynamicTypeReader (p));	// TODO: 1-based positio to be csc compatible
-				} else if (i == 0 && method.IsStatic && parent.IsStatic && parent.MemberDefinition.DeclaringAssembly.HasExtensionMethod &&
+				} else if (i == 0 && method.IsStatic && (parent.Modifiers & Modifiers.METHOD_EXTENSION) != 0 &&
 					HasAttribute (CustomAttributeData.GetCustomAttributes (method), "ExtensionAttribute", CompilerServicesNamespace)) {
 					mod = Parameter.Modifier.This;
 					types[i] = ImportType (p.ParameterType);
@@ -508,7 +510,7 @@ namespace Mono.CSharp
 						var ptype = types[i];
 						if ((p.Attributes & ParameterAttributes.HasDefault) != 0 && ptype.Kind != MemberKind.TypeParameter && (value != null || TypeSpec.IsReferenceType (ptype))) {
 							if (value == null) {
-								default_value = Constant.CreateConstant (ptype, null, Location.Null);
+								default_value = Constant.CreateConstantFromValue (ptype, null, Location.Null);
 							} else {
 								default_value = ImportParameterConstant (value);
 
@@ -516,6 +518,21 @@ namespace Mono.CSharp
 									default_value = new EnumConstant ((Constant) default_value, ptype);
 								}
 							}
+
+							var attrs = CustomAttributeData.GetCustomAttributes (p);
+							for (int ii = 0; ii < attrs.Count; ++ii) {
+								var attr = attrs[ii];
+								var dt = attr.Constructor.DeclaringType;
+								if (dt.Namespace != CompilerServicesNamespace)
+									continue;
+
+								if (dt.Name == "CallerLineNumberAttribute" && (ptype.BuiltinType == BuiltinTypeSpec.Type.Int || Convert.ImplicitNumericConversionExists (module.Compiler.BuiltinTypes.Int, ptype)))
+									mod |= Parameter.Modifier.CallerLineNumber;
+								else if (dt.Name == "CallerFilePathAttribute" && Convert.ImplicitReferenceConversionExists (module.Compiler.BuiltinTypes.String, ptype))
+									mod |= Parameter.Modifier.CallerFilePath;
+								else if (dt.Name == "CallerMemberNameAttribute" && Convert.ImplicitReferenceConversionExists (module.Compiler.BuiltinTypes.String, ptype))
+									mod |= Parameter.Modifier.CallerMemberName;
+							}
 						} else if (value == Missing.Value) {
 							default_value = EmptyExpression.MissingValue;
 						} else if (value == null) {
@@ -618,26 +635,41 @@ namespace Mono.CSharp
 
 			PropertySpec spec = null;
 			if (!param.IsEmpty) {
-				var index_name = declaringType.MemberDefinition.GetAttributeDefaultMember ();
-				if (index_name == null) {
-					is_valid_property = false;
-				} else {
-					if (get != null) {
-						if (get.IsStatic)
-							is_valid_property = false;
-						if (get.Name.IndexOf (index_name, StringComparison.Ordinal) != 4)
-							is_valid_property = false;
+				if (is_valid_property) {
+					var index_name = declaringType.MemberDefinition.GetAttributeDefaultMember ();
+					if (index_name == null) {
+						is_valid_property = false;
+					} else {
+						if (get != null) {
+							if (get.IsStatic)
+								is_valid_property = false;
+							if (get.Name.IndexOf (index_name, StringComparison.Ordinal) != 4)
+								is_valid_property = false;
+						}
+						if (set != null) {
+							if (set.IsStatic)
+								is_valid_property = false;
+							if (set.Name.IndexOf (index_name, StringComparison.Ordinal) != 4)
+								is_valid_property = false;
+						}
 					}
-					if (set != null) {
-						if (set.IsStatic)
-							is_valid_property = false;
-						if (set.Name.IndexOf (index_name, StringComparison.Ordinal) != 4)
-							is_valid_property = false;
+
+					if (is_valid_property) {
+						spec = new IndexerSpec (declaringType, new ImportedParameterMemberDefinition (pi, type, param, this), type, param, pi, mod);
+					} else if (declaringType.MemberDefinition.IsComImport && param.FixedParameters[0].HasDefaultValue) {
+						//
+						// Enables support for properties with parameters (must have default value) of COM-imported types
+						//
+						is_valid_property = true;
+
+						for (int i = 0; i < param.FixedParameters.Length; ++i) {
+							if (!param.FixedParameters[i].HasDefaultValue) {
+								is_valid_property = false;
+								break;
+							}
+						}
 					}
 				}
-
-				if (is_valid_property)
-					spec = new IndexerSpec (declaringType, new ImportedParameterMemberDefinition (pi, type, param, this), type, param, pi, mod);
 			}
 
 			if (spec == null)
@@ -677,7 +709,7 @@ namespace Mono.CSharp
 			return CreateType (type, declaring_type, dtype, canImportBaseType);
 		}
 
-		TypeSpec CreateType (MetaType type, TypeSpec declaringType, DynamicTypeReader dtype, bool canImportBaseType)
+		protected TypeSpec CreateType (MetaType type, TypeSpec declaringType, DynamicTypeReader dtype, bool canImportBaseType)
 		{
 			TypeSpec spec;
 			if (import_cache.TryGetValue (type, out spec)) {
@@ -995,6 +1027,11 @@ namespace Mono.CSharp
 				}
 			}
 
+			//
+			// It's impossible to get declared interfaces only using System.Reflection
+			// hence we need to mimic the behavior with ikvm-reflection too to keep
+			// our type look-up logic same
+			//
 			if (spec.BaseType != null) {
 				var bifaces = spec.BaseType.Interfaces;
 				if (bifaces != null) {
@@ -1028,7 +1065,7 @@ namespace Mono.CSharp
 			}
 		}
 
-		protected void ImportTypes (MetaType[] types, Namespace targetNamespace, bool hasExtensionTypes)
+		protected void ImportTypes (MetaType[] types, Namespace targetNamespace, bool importExtensionTypes)
 		{
 			Namespace ns = targetNamespace;
 			string prev_namespace = null;
@@ -1052,12 +1089,14 @@ namespace Mono.CSharp
 					prev_namespace = t.Namespace;
 				}
 
-				ns.AddType (module, it);
-
-				if (it.IsStatic && hasExtensionTypes &&
+				// Cannot rely on assembly level Extension attribute or static modifier because they
+				// are not followed by other compilers (e.g. F#).
+				if (it.IsClass && it.Arity == 0 && importExtensionTypes &&
 					HasAttribute (CustomAttributeData.GetCustomAttributes (t), "ExtensionAttribute", CompilerServicesNamespace)) {
 					it.SetExtensionMethodContainer ();
 				}
+
+				ns.AddType (module, it);
 			}
 		}
 
@@ -1074,12 +1113,13 @@ namespace Mono.CSharp
 					continue;
 				}
 
-				if (!IsMissingType (ct) && ct.IsClass) {
-					spec.BaseType = CreateType (ct);
+				var constraint_type = CreateType (ct);
+				if (constraint_type.IsClass) {
+					spec.BaseType = constraint_type;
 					continue;
 				}
 
-				spec.AddInterface (CreateType (ct));
+				spec.AddInterface (constraint_type);
 			}
 
 			if (spec.BaseType == null)
@@ -1520,7 +1560,6 @@ namespace Mono.CSharp
 		readonly Assembly assembly;
 		readonly AssemblyName aname;
 		bool cls_compliant;
-		bool contains_extension_methods;
 
 		List<AssemblyName> internals_visible_to;
 		Dictionary<IAssemblyDefinition, AssemblyName> internals_visible_to_cache;
@@ -1545,12 +1584,6 @@ namespace Mono.CSharp
 			}
 		}
 
-		public bool HasExtensionMethod {
-			get {
-				return contains_extension_methods;
-			}
-		}
-
 		public bool HasStrongName {
 			get {
 				return aname.GetPublicKey ().Length != 0;
@@ -1668,13 +1701,6 @@ namespace Mono.CSharp
 					internals_visible_to.Add (an);
 					continue;
 				}
-
-				if (name == "ExtensionAttribute") {
-					if (dt.Namespace == MetadataImporter.CompilerServicesNamespace)
-						contains_extension_methods = true;
-
-					continue;
-				}
 			}
 		}
 
@@ -1777,12 +1803,29 @@ namespace Mono.CSharp
 			}
 		}
 
+		bool ITypeDefinition.IsComImport {
+			get {
+				return ((MetaType) provider).IsImport;
+			}
+		}
+
+
 		bool ITypeDefinition.IsPartial {
 			get {
 				return false;
 			}
 		}
 
+		bool ITypeDefinition.IsTypeForwarder {
+			get {
+#if STATIC
+				return ((MetaType) provider).__IsTypeForwarder;
+#else
+				return false;
+#endif
+			}
+		}
+
 		public override string Name {
 			get {
 				if (name == null) {
@@ -1845,9 +1888,15 @@ namespace Mono.CSharp
 						"Reference to type `{0}' claims it is defined in this assembly, but it is not defined in source or any added modules",
 						name);
 				} else if (t.MemberDefinition.DeclaringAssembly.IsMissing) {
-					ctx.Module.Compiler.Report.Error (12, loc,
-						"The type `{0}' is defined in an assembly that is not referenced. Consider adding a reference to assembly `{1}'",
-						name, t.MemberDefinition.DeclaringAssembly.FullName);
+					if (t.MemberDefinition.IsTypeForwarder) {
+						ctx.Module.Compiler.Report.Error (1070, loc,
+							"The type `{0}' has been forwarded to an assembly that is not referenced. Consider adding a reference to assembly `{1}'",
+							name, t.MemberDefinition.DeclaringAssembly.FullName);
+					} else {
+						ctx.Module.Compiler.Report.Error (12, loc,
+							"The type `{0}' is defined in an assembly that is not referenced. Consider adding a reference to assembly `{1}'",
+							name, t.MemberDefinition.DeclaringAssembly.FullName);
+					}
 				} else {
 					ctx.Module.Compiler.Report.Error (1684, loc,
 						"Reference to type `{0}' claims it is defined assembly `{1}', but it could not be found",
@@ -2122,12 +2171,24 @@ namespace Mono.CSharp
 			}
 		}
 
+		bool ITypeDefinition.IsComImport {
+			get {
+				return false;
+			}
+		}
+
 		bool ITypeDefinition.IsPartial {
 			get {
 				return false;
 			}
 		}
 
+		bool ITypeDefinition.IsTypeForwarder {
+			get {
+				return false;
+			}
+		}
+
 		public string Namespace {
 			get {
 				return null;

ICSharpCode.NRefactory.CSharp/Parser/mcs/membercache.cs

@@ -240,6 +240,8 @@ namespace Mono.CSharp {
 		// contain all base interface members, so the Lookup code
 		// can use simple inheritance rules.
 		//
+		// Does not work recursively because of generic interfaces
+		//
 		public void AddInterface (TypeSpec iface)
 		{
 			var cache = iface.MemberCache;
@@ -258,6 +260,13 @@ namespace Mono.CSharp {
 				}
 
 				foreach (var ce in entry.Value) {
+					//
+					// When two or more different base interfaces implemenent common
+					// interface
+					//
+					// I : IA, IFoo
+					// IA : IFoo
+					//
 					if (list.Contains (ce))
 						continue;
 
@@ -265,12 +274,6 @@ namespace Mono.CSharp {
 						member_hash[entry.Key] = list;
 				}
 			}
-
-			// Add also all base interfaces
-			if (iface.Interfaces != null) {
-				foreach (var base_iface in iface.Interfaces)
-					AddInterface (base_iface);
-			}
 		}
 
 		public void AddMember (InterfaceMemberBase imb, string exlicitName, MemberSpec ms)
@@ -302,7 +305,7 @@ namespace Mono.CSharp {
 				// rules (e.g. binary operators) by not setting the flag we hide them for
 				// user conversions
 				//
-				if (!BuiltinTypeSpec.IsPrimitiveType (dt)) {
+				if (!BuiltinTypeSpec.IsPrimitiveType (dt) || dt.BuiltinType == BuiltinTypeSpec.Type.Char) {
 					switch (dt.BuiltinType) {
 					case BuiltinTypeSpec.Type.String:
 					case BuiltinTypeSpec.Type.Delegate:

ICSharpCode.NRefactory.CSharp/Parser/mcs/method.cs

@@ -1016,21 +1016,32 @@ namespace Mono.CSharp {
 			TypeParameterSpec[] base_decl_tparams = TypeParameterSpec.EmptyTypes;
 			TypeSpec[] base_targs = TypeSpec.EmptyTypes;
 			if (((ModFlags & Modifiers.OVERRIDE) != 0 || IsExplicitImpl)) {
-				if (base_method != null) {
-					base_tparams = base_method.GenericDefinition.TypeParameters;
-				
-					if (base_method.DeclaringType.IsGeneric) {
-						base_decl_tparams = base_method.DeclaringType.MemberDefinition.TypeParameters;
+				MethodSpec base_override = base_method ?? MethodData.implementing;
 
-						var base_type_parent = CurrentType;
-						while (base_type_parent.BaseType != base_method.DeclaringType) {
-							base_type_parent = base_type_parent.BaseType;
-						}
+				if (base_override != null) {
+					base_tparams = base_override.GenericDefinition.TypeParameters;
 
-						base_targs = base_type_parent.BaseType.TypeArguments;
+					if (base_override.DeclaringType.IsGeneric) {
+						base_decl_tparams = base_override.DeclaringType.MemberDefinition.TypeParameters;
+
+						if (base_method != null) {
+							var base_type_parent = CurrentType;
+							while (base_type_parent.BaseType != base_override.DeclaringType) {
+								base_type_parent = base_type_parent.BaseType;
+							}
+
+							base_targs = base_type_parent.BaseType.TypeArguments;
+						} else {
+							foreach (var iface in Parent.CurrentType.Interfaces) {
+								if (iface == base_override.DeclaringType) {
+									base_targs = iface.TypeArguments;
+									break;
+								}
+							}
+						}
 					}
 
-					if (base_method.IsGeneric) {
+					if (base_override.IsGeneric) {
 						ObsoleteAttribute oa;
 						foreach (var base_tp in base_tparams) {
 							oa = base_tp.BaseType.GetAttributeObsolete ();
@@ -1056,17 +1067,6 @@ namespace Mono.CSharp {
 							base_targs = tparams.Types;
 						}
 					}
-				} else if (MethodData.implementing != null) {
-					base_tparams = MethodData.implementing.GenericDefinition.TypeParameters;
-					if (MethodData.implementing.DeclaringType.IsGeneric) {
-						base_decl_tparams = MethodData.implementing.DeclaringType.MemberDefinition.TypeParameters;
-						foreach (var iface in Parent.CurrentType.Interfaces) {
-							if (iface == MethodData.implementing.DeclaringType) {
-								base_targs = iface.TypeArguments;
-								break;
-							}
-						}
-					}
 				}
 			}
 
@@ -1127,8 +1127,6 @@ namespace Mono.CSharp {
 							Constraints.CheckConflictingInheritedConstraint (local_tparam, ta, this, Location);
 						}
 					}
-
-					continue;
 				}
 			}
 
@@ -1304,10 +1302,8 @@ namespace Mono.CSharp {
 					}
 				}
 
-				if (block != null && block.StateMachine != null) {
-					var psm = block.StateMachine is IteratorStorey ?
-						Module.PredefinedAttributes.IteratorStateMachine :
-						Module.PredefinedAttributes.AsyncStateMachine;
+				if (block != null && block.StateMachine is AsyncTaskStorey) {
+					var psm = Module.PredefinedAttributes.AsyncStateMachine;
 					
 					psm.EmitAttribute (MethodBuilder, block.StateMachine);
 				}
@@ -1779,7 +1775,7 @@ namespace Mono.CSharp {
 			var token = ConstructorBuilder.GetToken ();
 			int t = token.Token;
 #if STATIC
-			if (token.IsPseudoToken)
+			if (ModuleBuilder.IsPseudoToken (t))
 				t = Module.Builder.ResolvePseudoToken (t);
 #endif
 
@@ -2120,7 +2116,7 @@ namespace Mono.CSharp {
 			var token = builder.GetToken ();
 			int t = token.Token;
 #if STATIC
-			if (token.IsPseudoToken)
+			if (ModuleBuilder.IsPseudoToken (t))
 				t = member.Module.Builder.ResolvePseudoToken (t);
 #endif
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/module.cs

@@ -398,6 +398,8 @@ namespace Mono.CSharp
 		{
 			DefineContainer ();
 
+			ExpandBaseInterfaces ();
+
 			base.Define ();
 
 			HasTypesFullyDefined = true;

ICSharpCode.NRefactory.CSharp/Parser/mcs/namespace.cs

@@ -498,12 +498,14 @@ namespace Mono.CSharp {
 				types = new Dictionary<string, IList<TypeSpec>> (64);
 			}
 
-			if ((ts.IsStatic || ts.MemberDefinition.IsPartial) && ts.Arity == 0 &&
-				(ts.MemberDefinition.DeclaringAssembly == null || ts.MemberDefinition.DeclaringAssembly.HasExtensionMethod)) {
-				if (extension_method_types == null)
-					extension_method_types = new List<TypeSpec> ();
+			if (ts.IsClass && ts.Arity == 0) {
+				var extension_method_allowed = ts.MemberDefinition.IsImported ? (ts.Modifiers & Modifiers.METHOD_EXTENSION) != 0 : (ts.IsStatic || ts.MemberDefinition.IsPartial);
+				if (extension_method_allowed) {
+					if (extension_method_types == null)
+						extension_method_types = new List<TypeSpec> ();
 
-				extension_method_types.Add (ts);
+					extension_method_types.Add (ts);
+				}
 			}
 
 			var name = ts.Name;
@@ -648,6 +650,11 @@ namespace Mono.CSharp {
 					"Identifier `{0}' differing only in case is not CLS-compliant", compiled.GetSignatureForError ());
 			}
 		}
+
+		public override string ToString ()
+		{
+			return Name;
+		}
 	}
 
 	public class CompilationSourceFile : NamespaceContainer
@@ -1405,6 +1412,11 @@ namespace Mono.CSharp {
 		{
 			visitor.Visit (this);
 		}
+
+		public override string ToString()
+		{
+			return resolved.ToString();
+		}
 	}
 
 	public class UsingExternAlias : UsingAliasNamespace

ICSharpCode.NRefactory.CSharp/Parser/mcs/nullable.cs

@@ -68,6 +68,9 @@ namespace Mono.CSharp.Nullable
 				MemberFilter.Method ("GetValueOrDefault", 0, ParametersCompiled.EmptyReadOnlyParameters, null), BindingRestriction.None);
 		}
 
+		//
+		// Don't use unless really required for correctness, see Unwrap::Emit
+		//
 		public static MethodSpec GetValue (TypeSpec nullableType)
 		{
 			return (MethodSpec) MemberCache.FindMember (nullableType,
@@ -142,6 +145,11 @@ namespace Mono.CSharp.Nullable
 			var call = new CallEmitter ();
 			call.InstanceExpression = this;
 
+			//
+			// Using GetGetValueOrDefault is prefered because JIT can possibly
+			// inline it whereas Value property contains a throw which is very
+			// unlikely to be inlined
+			//
 			if (useDefaultValue)
 				call.EmitPredefined (ec, NullableInfo.GetGetValueOrDefault (expr.Type), null);
 			else
@@ -1256,7 +1264,7 @@ namespace Mono.CSharp.Nullable
 
 			call = new CallEmitter ();
 			call.InstanceExpression = lt;
-			call.EmitPredefined (ec, NullableInfo.GetValue (expr.Type), null);
+			call.EmitPredefined (ec, NullableInfo.GetGetValueOrDefault (expr.Type), null);
 
 			lt.Release (ec);
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/parameter.cs

@@ -932,9 +932,14 @@ namespace Mono.CSharp {
 					if (inflated_param == types[i])
 						continue;
 
-					default_value |= FixedParameters[i] is DefaultValueExpression;
+					default_value |= FixedParameters[i].HasDefaultValue;
 					inflated_types = new TypeSpec[types.Length];
-					Array.Copy (types, inflated_types, types.Length);	
+					Array.Copy (types, inflated_types, types.Length);
+				} else {
+					if (inflated_param == types[i])
+						continue;
+
+					default_value |= FixedParameters[i].HasDefaultValue;
 				}
 
 				inflated_types[i] = inflated_param;
@@ -945,13 +950,34 @@ namespace Mono.CSharp {
 
 			var clone = (AParametersCollection) MemberwiseClone ();
 			clone.types = inflated_types;
+
+			//
+			// Default expression is original expression from the parameter
+			// declaration context which can be of nested enum in generic class type.
+			// In such case we end up with expression type of G<T>.E and e.g. parameter
+			// type of G<int>.E and conversion would fail without inflate in this
+			// context.
+			//
 			if (default_value) {
+				clone.parameters = new IParameterData[Count];
 				for (int i = 0; i < Count; ++i) {
-					var dve = clone.FixedParameters[i] as DefaultValueExpression;
-					if (dve != null) {
-						throw new NotImplementedException ("net");
-						//	clone.FixedParameters [i].DefaultValue = new DefaultValueExpression ();
-					}
+					var fp = FixedParameters[i];
+					clone.FixedParameters[i] = fp;
+
+					if (!fp.HasDefaultValue)
+						continue;
+
+					var expr = fp.DefaultValue;
+
+					if (inflated_types[i] == expr.Type)
+						continue;
+
+					if (expr is DefaultValueExpression)
+						expr = new DefaultValueExpression (new TypeExpression (inflated_types[i], expr.Location), expr.Location);
+					else if (expr is Constant)
+						expr = Constant.CreateConstantFromValue (inflated_types[i], ((Constant) expr).GetValue (), expr.Location);
+
+					clone.FixedParameters[i] = new ParameterData (fp.Name, fp.ModFlags, expr);
 				}
 			}
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/pending.cs

@@ -192,17 +192,17 @@ namespace Mono.CSharp {
 		static MissingInterfacesInfo [] GetMissingInterfaces (TypeDefinition container)
 		{
 			//
-			// Notice that Interfaces will only return the interfaces that the Type
-			// is supposed to implement, not all the interfaces that the type implements.
+			// Interfaces will return all interfaces that the container
+			// implements including any inherited interfaces
 			//
 			var impl = container.Definition.Interfaces;
 
 			if (impl == null || impl.Count == 0)
 				return EmptyMissingInterfacesInfo;
 
-			MissingInterfacesInfo[] ret = new MissingInterfacesInfo[impl.Count];
+			var ret = new MissingInterfacesInfo[impl.Count];
 
-			for (int i = 0; i < impl.Count; i++)
+			for (int i = 0; i < ret.Length; i++)
 				ret [i] = new MissingInterfacesInfo (impl [i]);
 
 			// we really should not get here because Object doesnt implement any
@@ -548,7 +548,7 @@ namespace Mono.CSharp {
 						continue;
 
 					var candidate_param = ((MethodSpec) candidate).Parameters;
-					if (!TypeSpecComparer.Override.IsSame (parameters.Types, candidate_param.Types))
+					if (!TypeSpecComparer.Override.IsEqual (parameters.Types, candidate_param.Types))
 						continue;
 
 					bool modifiers_match = true;
@@ -587,7 +587,7 @@ namespace Mono.CSharp {
 						continue;
 
 					//
-					// From this point on the candidate is used for detailed error reporting
+					// From this point the candidate is used for detailed error reporting
 					// because it's very close match to what we are looking for
 					//
 					base_method = (MethodSpec) candidate;

ICSharpCode.NRefactory.CSharp/Parser/mcs/reflection.cs

@@ -83,7 +83,7 @@ namespace Mono.CSharp
 		{
 			// It can be used more than once when importing same assembly
 			// into 2 or more global aliases
-			var definition = GetAssemblyDefinition (assembly);
+		GetAssemblyDefinition (assembly);
 
 			//
 			// This part tries to simulate loading of top-level
@@ -98,7 +98,7 @@ namespace Mono.CSharp
 				all_types = e.Types;
 			}
 
-			ImportTypes (all_types, targetNamespace, definition.HasExtensionMethod);
+			ImportTypes (all_types, targetNamespace, true);
 		}
 
 		public ImportedModuleDefinition ImportModule (Module module, RootNamespace targetNamespace)
@@ -547,4 +547,4 @@ namespace Mono.CSharp
 			}
 		}
 	}
-}
+}

ICSharpCode.NRefactory.CSharp/Parser/mcs/settings.cs

@@ -600,24 +600,7 @@ namespace Mono.CSharp {
 
 		static bool IsExternAliasValid (string identifier)
 		{
-			if (identifier.Length == 0)
-				return false;
-			if (identifier[0] != '_' && !char.IsLetter (identifier[0]))
-				return false;
-
-			for (int i = 1; i < identifier.Length; i++) {
-				char c = identifier[i];
-				if (char.IsLetter (c) || char.IsDigit (c))
-					continue;
-
-				UnicodeCategory category = char.GetUnicodeCategory (c);
-				if (category != UnicodeCategory.Format || category != UnicodeCategory.NonSpacingMark ||
-						category != UnicodeCategory.SpacingCombiningMark ||
-						category != UnicodeCategory.ConnectorPunctuation)
-					return false;
-			}
-
-			return true;
+			return Tokenizer.IsValidIdentifier (identifier);
 		}
 
 		static string[] LoadArgs (string file)

ICSharpCode.NRefactory.CSharp/Parser/mcs/statement.cs

@@ -6147,39 +6147,31 @@ namespace Mono.CSharp {
 				if (!gen_ienumerable.Define ())
 					gen_ienumerable = null;
 
-				do {
-					var ifaces = t.Interfaces;
-					if (ifaces != null) {
-						foreach (var iface in ifaces) {
-							if (gen_ienumerable != null && iface.MemberDefinition == gen_ienumerable.TypeSpec.MemberDefinition) {
-								if (iface_candidate != null && iface_candidate != rc.Module.PredefinedMembers.IEnumerableGetEnumerator) {
-									rc.Report.SymbolRelatedToPreviousError (expr.Type);
-									rc.Report.Error (1640, loc,
-										"foreach statement cannot operate on variables of type `{0}' because it contains multiple implementation of `{1}'. Try casting to a specific implementation",
-										expr.Type.GetSignatureForError (), gen_ienumerable.TypeSpec.GetSignatureForError ());
-
-									return null;
-								}
-
-								// TODO: Cache this somehow
-								iface_candidate = new PredefinedMember<MethodSpec> (rc.Module, iface,
-									MemberFilter.Method ("GetEnumerator", 0, ParametersCompiled.EmptyReadOnlyParameters, null));
-
-								continue;
+				var ifaces = t.Interfaces;
+				if (ifaces != null) {
+					foreach (var iface in ifaces) {
+						if (gen_ienumerable != null && iface.MemberDefinition == gen_ienumerable.TypeSpec.MemberDefinition) {
+							if (iface_candidate != null && iface_candidate != rc.Module.PredefinedMembers.IEnumerableGetEnumerator) {
+								rc.Report.SymbolRelatedToPreviousError (expr.Type);
+								rc.Report.Error (1640, loc,
+									"foreach statement cannot operate on variables of type `{0}' because it contains multiple implementation of `{1}'. Try casting to a specific implementation",
+									expr.Type.GetSignatureForError (), gen_ienumerable.TypeSpec.GetSignatureForError ());
+
+								return null;
 							}
 
-							if (iface.BuiltinType == BuiltinTypeSpec.Type.IEnumerable && iface_candidate == null) {
-								iface_candidate = rc.Module.PredefinedMembers.IEnumerableGetEnumerator;
-							}
-						}
-					}
+							// TODO: Cache this somehow
+							iface_candidate = new PredefinedMember<MethodSpec> (rc.Module, iface,
+								MemberFilter.Method ("GetEnumerator", 0, ParametersCompiled.EmptyReadOnlyParameters, null));
 
-					if (t.IsGenericParameter)
-						t = t.BaseType;
-					else
-						t = null;
+							continue;
+						}
 
-				} while (t != null);
+						if (iface.BuiltinType == BuiltinTypeSpec.Type.IEnumerable && iface_candidate == null) {
+							iface_candidate = rc.Module.PredefinedMembers.IEnumerableGetEnumerator;
+						}
+					}
+				}
 
 				if (iface_candidate == null) {
 					if (expr.Type != InternalType.ErrorType) {

ICSharpCode.NRefactory.CSharp/Parser/mcs/typemanager.cs

@@ -358,7 +358,6 @@ namespace Mono.CSharp
 		public readonly PredefinedMember<MethodSpec> IEnumerableGetEnumerator;
 		public readonly PredefinedMember<MethodSpec> InterlockedCompareExchange;
 		public readonly PredefinedMember<MethodSpec> InterlockedCompareExchange_T;
-		public readonly PredefinedMember<MethodSpec> IteratorStateMachineAttributeCtor;
 		public readonly PredefinedMember<MethodSpec> FixedBufferAttributeCtor;
 		public readonly PredefinedMember<MethodSpec> MethodInfoGetMethodFromHandle;
 		public readonly PredefinedMember<MethodSpec> MethodInfoGetMethodFromHandle2;
@@ -631,10 +630,6 @@ namespace Mono.CSharp
 							}, false),
 					null));
 
-			IteratorStateMachineAttributeCtor = new PredefinedMember<MethodSpec> (module, atypes.IteratorStateMachine,
-				MemberFilter.Constructor (ParametersCompiled.CreateFullyResolved (
-					btypes.Type)));
-
 			MethodInfoGetMethodFromHandle = new PredefinedMember<MethodSpec> (module, types.MethodBase,
 				"GetMethodFromHandle", MemberKind.Method, types.RuntimeMethodHandle);
 

ICSharpCode.NRefactory.CSharp/Parser/mcs/typespec.cs

@@ -91,6 +91,10 @@ namespace Mono.CSharp
 			}
 		}
 
+		//
+		// Returns a list of all interfaces including
+		// interfaces from base type or base interfaces
+		//
 		public virtual IList<TypeSpec> Interfaces {
 			get {
 				return ifaces;
@@ -350,7 +354,7 @@ namespace Mono.CSharp
 
 		#endregion
 
-		public bool AddInterface (TypeSpec iface)
+		public virtual bool AddInterface (TypeSpec iface)
 		{
 			if ((state & StateFlags.InterfacesExpanded) != 0)
 				throw new InternalErrorException ("Modifying expanded interface list");
@@ -549,22 +553,16 @@ namespace Mono.CSharp
 
 		public bool ImplementsInterface (TypeSpec iface, bool variantly)
 		{
-			var t = this;
-			do {
-				var ifaces = t.Interfaces;
-				if (ifaces != null) {
-					for (int i = 0; i < ifaces.Count; ++i) {
-						if (TypeSpecComparer.IsEqual (ifaces[i], iface))
-							return true;
-
-						if (variantly && TypeSpecComparer.Variant.IsEqual (ifaces[i], iface))
-							return true;
-					}
-				}
+			var ifaces = Interfaces;
+			if (ifaces != null) {
+				for (int i = 0; i < ifaces.Count; ++i) {
+					if (TypeSpecComparer.IsEqual (ifaces[i], iface))
+						return true;
 
-				// TODO: Why is it needed when we do it during import
-				t = t.BaseType;
-			} while (t != null);
+					if (variantly && TypeSpecComparer.Variant.IsEqual (ifaces[i], iface))
+						return true;
+				}
+			}
 
 			return false;
 		}
@@ -1056,6 +1054,23 @@ namespace Mono.CSharp
 				return true;
 			}
 
+			public static bool IsEqual (TypeSpec[] a, TypeSpec[] b)
+			{
+				if (a == b)
+					return true;
+
+				if (a.Length != b.Length)
+					return false;
+
+				for (int i = 0; i < a.Length; ++i) {
+					if (!IsEqual (a[i], b[i]))
+						return false;
+				}
+
+				return true;
+			}
+
+
 			//
 			// Compares unordered arrays
 			//
@@ -1337,6 +1352,8 @@ namespace Mono.CSharp
 		IAssemblyDefinition DeclaringAssembly { get; }
 		string Namespace { get; }
 		bool IsPartial { get; }
+		bool IsComImport { get; }
+		bool IsTypeForwarder { get; }
 		int TypeParametersCount { get; }
 		TypeParameterSpec[] TypeParameters { get; }
 
@@ -1384,6 +1401,12 @@ namespace Mono.CSharp
 			}
 		}
 
+		bool ITypeDefinition.IsComImport {
+			get {
+				return false;
+			}
+		}
+
 		bool IMemberDefinition.IsImported {
 			get {
 				return false;
@@ -1396,6 +1419,12 @@ namespace Mono.CSharp
 			}
 		}
 
+		bool ITypeDefinition.IsTypeForwarder {
+			get {
+				return false;
+			}
+		}
+
 		public override string Name {
 			get {
 				return name;
@@ -1508,12 +1537,24 @@ namespace Mono.CSharp
 
 		public TypeSpec Element { get; private set; }
 
+		bool ITypeDefinition.IsComImport {
+			get {
+				return false;
+			}
+		}
+
 		bool ITypeDefinition.IsPartial {
 			get {
 				return false;
 			}
 		}
 
+		bool ITypeDefinition.IsTypeForwarder {
+			get {
+				return false;
+			}
+		}
+
 		public override string Name {
 			get {
 				throw new NotSupportedException ();
@@ -1802,9 +1843,9 @@ namespace Mono.CSharp
 			ArrayContainer ac;
 			var key = new TypeRankPair (element, rank);
 			if (!module.ArrayTypesCache.TryGetValue (key, out ac)) {
-				ac = new ArrayContainer (module, element, rank) {
-					BaseType = module.Compiler.BuiltinTypes.Array
-				};
+				ac = new ArrayContainer (module, element, rank);
+				ac.BaseType = module.Compiler.BuiltinTypes.Array;
+				ac.Interfaces = ac.BaseType.Interfaces;
 
 				module.ArrayTypesCache.Add (key, ac);
 			}

ICSharpCode.NRefactory.Tests/CSharp/CodeCompletion/CodeCompletionBugTests.cs

@@ -827,6 +827,7 @@ class Test
 		/// <summary>
 		/// Bug 405000 - Namespace alias qualifier operator (::) does not trigger code completion
 		/// </summary>
+		[Ignore("GOT BROKEN! FIXME")]
 		[Test]
 		public void TestBug405000 ()
 		{