[NRefactory] Merged changes back from nrefactory.

7 files changed, 152 insertions, 75 deletions

diff --git a/main/contrib/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs b/main/contrib/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs
index eef45cff58..ca2291fcb5 100644
--- a/main/contrib/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs
+++ b/main/contrib/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs
@@ -121,6 +121,8 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			case '<':
 				if (IsInsideDocComment ())
 					return GetXmlDocumentationCompletionData ();
+				if (controlSpace)
+					return DefaultControlSpaceItems ();
 				return null;
 			case '>':
 				if (!IsInsideDocComment ())
@@ -161,7 +163,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 					return null;
 				var methodGroup = invocationResult.Item1 as MethodGroupResolveResult;
 				if (methodGroup != null)
-					return CreateParameterCompletion (methodGroup, invocationResult.Item2, invoke.Item2, 0);
+					return CreateParameterCompletion (methodGroup, invocationResult.Item2, invoke.Item2, 0, controlSpace);
 				return null;
 			case ',':
 				int cpos2;
@@ -183,7 +185,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				// check propose name, for context <variable name> <ctrl+space> (but only in control space context)
 				IType isAsType = null;
 				var isAsExpression = GetExpressionAt (offset);
-				if (controlSpace && isAsExpression != null && isAsExpression.Item2 is VariableDeclarationStatement) {
+				if (controlSpace && isAsExpression != null && isAsExpression.Item2 is VariableDeclarationStatement && token != "new") {
 					var parent = isAsExpression.Item2 as VariableDeclarationStatement;
 					int offset1 = document.GetOffset (parent.Type.StartLocation);
 					int offset2 = document.GetOffset (parent.Type.EndLocation);
@@ -217,7 +219,6 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 					AutoCompleteEmptyMatch = false;
 					return proposeNameList.Result;
 				}
-			
 //				int tokenIndex = offset;
 //				string token = GetPreviousToken (ref tokenIndex, false);
 //				if (result.ExpressionContext == ExpressionContext.ObjectInitializer) {
@@ -252,7 +253,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 						return null;
 					methodGroup = invocationResult.Item1 as MethodGroupResolveResult;
 					if (methodGroup != null)
-						return CreateParameterCompletion (methodGroup, invocationResult.Item2, invoke.Item2, currentParameter);
+						return CreateParameterCompletion (methodGroup, invocationResult.Item2, invoke.Item2, currentParameter, controlSpace);
 					return null;
 				case "=":
 				case "==":
@@ -266,7 +267,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 					if (resolveResult == null)
 						return null;
 					
-					if (resolveResult.Item1.Type.IsEnum ()) {
+					if (resolveResult.Item1.Type.Kind == TypeKind.Enum) {
 						var wrapper = new CompletionDataWrapper (this);
 						AddContextCompletion (wrapper, resolveResult.Item2, expressionOrVariableDeclaration.Item2);
 						AddEnumMembers (wrapper, resolveResult.Item1.Type, resolveResult.Item2);
@@ -546,21 +547,21 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 
 		void AddTypesAndNamespaces (CompletionDataWrapper wrapper, CSharpResolver state, Predicate<ITypeDefinition> typePred = null, Predicate<IMember> memberPred = null)
 		{
-			if (state.CurrentTypeDefinition != null) {
-				
-				for (var ct = state.CurrentTypeDefinition; ct != null; ct = ct.DeclaringTypeDefinition) {
+			var currentType = state.CurrentTypeDefinition ?? this.currentType;
+			if (currentType != null) {
+				for (var ct = currentType; ct != null; ct = ct.DeclaringTypeDefinition) {
 					foreach (var nestedType in ct.NestedTypes) {
 						if (typePred == null || typePred (nestedType))
 							wrapper.AddType (nestedType, nestedType.Name);
 					}
 				}
 				
-				foreach (var member in state.CurrentTypeDefinition.Resolve (ctx).GetMembers (ctx)) {
+				foreach (var member in currentType.Resolve (ctx).GetMembers (ctx)) {
 					if (memberPred == null || memberPred (member))
 						wrapper.AddMember (member);
 				}
 				
-				foreach (var p in state.CurrentTypeDefinition.TypeParameters) {
+				foreach (var p in currentType.TypeParameters) {
 					wrapper.AddTypeParameter (p);
 				}
 			}
@@ -603,8 +604,8 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				var wrapper = new CompletionDataWrapper (this);
 				AddTypesAndNamespaces (wrapper, GetState (), t => false);
 				return wrapper.Result;
-//				case "case":
-//					return CreateCaseCompletionData (location, result);
+				case "case":
+					return CreateCaseCompletionData (location);
 //				case ",":
 //				case ":":
 //					if (result.ExpressionContext == ExpressionContext.InheritableType) {
@@ -918,7 +919,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				DefaultCompletionString = GetShortType (hintType, GetState ());
 				wrapper.AddType (hintType, DefaultCompletionString);
 			}
-			AddTypesAndNamespaces (wrapper, state, pred);
+			AddTypesAndNamespaces (wrapper, state, pred, m => false);
 			AddKeywords (wrapper, primitiveTypesKeywords.Where (k => k != "void"));
 			AutoCompleteEmptyMatch = true;
 			return wrapper.Result;
@@ -946,7 +947,6 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 					return null; // don't add override completion for static members
 				}
 			}
-			
 			foreach (var baseType in type.GetAllBaseTypeDefinitions (ctx)) {
 				AddVirtuals (alreadyInserted, wrapper, type, modifiers, baseType, declarationBegin);
 				addedVirtuals = true;
@@ -956,6 +956,14 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			return wrapper.Result;
 		}
 		
+		static string GetNameWithParamCount (IMember member)
+		{
+			var e = member as IMethod;
+			if (e == null || e.TypeParameters.Count == 0)
+				return member.Name;
+			return e.Name + "`" + e.TypeParameters.Count;
+		}
+		
 		void AddVirtuals (Dictionary<string, bool> alreadyInserted, CompletionDataWrapper col, ITypeDefinition type, string modifiers, ITypeDefinition curType, int declarationBegin)
 		{
 			if (curType == null)
@@ -963,16 +971,15 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			foreach (var m in curType.Methods.Where (m => !m.IsConstructor && !m.IsDestructor).Cast<IMember> ().Concat (curType.Properties.Cast<IMember> ())) {
 				if (m.IsSynthetic || curType.Kind != TypeKind.Interface && !(m.IsVirtual || m.IsOverride || m.IsAbstract))
 					continue;
-				
 				// filter out the "Finalize" methods, because finalizers should be done with destructors.
 				if (m is IMethod && m.Name == "Finalize")
 					continue;
 				
 				var data = factory.CreateNewOverrideCompletionData (declarationBegin, type, m);
-				string text = m.ReflectionName; //TODO:correct ?
-				// check if the member is already implemented
-				bool foundMember = type.Members.Any (cm => cm.ReflectionName /*amb.GetString (ctx, cm, OutputFlags.ClassBrowserEntries)*/ == text);
+				string text = GetNameWithParamCount (m);
 				
+				// check if the member is already implemented
+				bool foundMember = type.Members.Any (cm => GetNameWithParamCount (cm) == text);
 				if (!foundMember && !alreadyInserted.ContainsKey (text)) {
 					alreadyInserted [text] = true;
 					data.CompletionCategory = col.GetCompletionCategory (curType);
@@ -1172,7 +1179,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			return result;
 		}
 		
-		IEnumerable<ICompletionData> CreateParameterCompletion (MethodGroupResolveResult resolveResult, CSharpResolver state, AstNode invocation, int parameter)
+		IEnumerable<ICompletionData> CreateParameterCompletion (MethodGroupResolveResult resolveResult, CSharpResolver state, AstNode invocation, int parameter, bool controlSpace)
 		{
 			var result = new CompletionDataWrapper (this);
 			var addedEnums = new HashSet<string> ();
@@ -1197,10 +1204,12 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				
 				}
 			}
-			if (addedEnums.Count + addedDelegates.Count == 0)
-				return Enumerable.Empty<ICompletionData> ();
-			AutoCompleteEmptyMatch = false;
-			AutoSelect = false;
+			if (!controlSpace) {
+				if (addedEnums.Count + addedDelegates.Count == 0)
+					return Enumerable.Empty<ICompletionData> ();
+				AutoCompleteEmptyMatch = false;
+				AutoSelect = false;
+			}
 			AddContextCompletion (result, state, invocation);
 			
 //			resolver.AddAccessibleCodeCompletionData (ExpressionContext.MethodBody, cdc);
@@ -1290,25 +1299,27 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 //			Console.WriteLine ("type:" + type +"/"+type.GetType ());
 //			Console.WriteLine ("IS PROT ALLOWED:" + isProtectedAllowed);
 //			Console.WriteLine (resolveResult);
-//			Console.WriteLine (currentMember.IsStatic);
-			foreach (var member in type.GetMembers (ctx)) {
-				if (!lookup.IsAccessible (member, isProtectedAllowed)) {
-//					Console.WriteLine ("skip access: " + member.FullName);
-					continue;
-				}
-				if (resolvedNode is BaseReferenceExpression && member.IsAbstract)
-					continue;
-				
-				if (!includeStaticMembers && member.IsStatic && !(resolveResult is TypeResolveResult)) {
-//					Console.WriteLine ("skip static member: " + member.FullName);
-					continue;
-				}
-				if (!member.IsStatic && (resolveResult is TypeResolveResult)) {
-//					Console.WriteLine ("skip non static member: " + member.FullName);
-					continue;
+//			Console.WriteLine (currentMember !=  null ? currentMember.IsStatic : "currentMember == null");
+			if (resolvedNode.Annotation<ObjectCreateExpression> () == null) { //tags the created expression as part of an object create expression.
+				foreach (var member in type.GetMembers (ctx)) {
+					if (!lookup.IsAccessible (member, isProtectedAllowed)) {
+	//					Console.WriteLine ("skip access: " + member.FullName);
+						continue;
+					}
+					if (resolvedNode is BaseReferenceExpression && member.IsAbstract)
+						continue;
+					
+					if (!includeStaticMembers && member.IsStatic && !(resolveResult is TypeResolveResult)) {
+	//					Console.WriteLine ("skip static member: " + member.FullName);
+						continue;
+					}
+					if (!member.IsStatic && (resolveResult is TypeResolveResult)) {
+	//					Console.WriteLine ("skip non static member: " + member.FullName);
+						continue;
+					}
+	//				Console.WriteLine ("add : "+ member.FullName + " --- " + member.IsStatic);
+					result.AddMember (member);
 				}
-//				Console.WriteLine ("add : "+ member.FullName + " --- " + member.IsStatic);
-				result.AddMember (member);
 			}
 			
 			if (resolveResult is TypeResolveResult || includeStaticMembers) {
@@ -1366,6 +1377,28 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				}
 			}
 		}
+		IEnumerable<ICompletionData> CreateCaseCompletionData (TextLocation location)
+		{
+			var unit = ParseStub ("a: break;");
+			if (unit == null)
+				return null;
+			var s = unit.GetNodeAt<SwitchStatement> (location);
+			if (s == null)
+				return null;
+			
+			var offset = document.GetOffset (s.Expression.StartLocation);
+			var expr = GetExpressionAt (offset);
+			if (expr == null)
+				return null;
+			
+			var resolveResult = ResolveExpression (expr.Item1, expr.Item2, expr.Item3);
+			if (resolveResult == null || resolveResult.Item1.Type.Kind != TypeKind.Enum) 
+				return null;
+			var wrapper = new CompletionDataWrapper (this);
+			AddEnumMembers (wrapper, resolveResult.Item1.Type, resolveResult.Item2);
+			AutoCompleteEmptyMatch = false;
+			return wrapper.Result;
+		}
 		
 		#region Parsing methods
 
@@ -1394,19 +1427,38 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				return null;
 			}
 			baseUnit = ParseStub ("a()");
-			
+			Print (baseUnit);
 			var memberLocation = currentMember != null ? currentMember.Region.Begin : currentType.Region.Begin;
 			var mref = baseUnit.GetNodeAt<MemberReferenceExpression> (location); 
-			Expression expr;
+			if (mref == null){
+				var invoke = baseUnit.GetNodeAt<InvocationExpression> (location); 
+				if (invoke != null)
+					mref = invoke.Target as MemberReferenceExpression;
+			}
+			Expression expr = null;
 			if (mref != null) {
 				expr = mref.Target.Clone ();
 				mref.Parent.ReplaceWith (expr);
 			} else {
-				var tref = baseUnit.GetNodeAt<TypeReferenceExpression> (location); 
-				var memberType = tref != null ? tref.Type as MemberType : null;
+				Expression tref = baseUnit.GetNodeAt<TypeReferenceExpression> (location); 
+				var memberType = tref != null ? ((TypeReferenceExpression)tref).Type as MemberType : null;
+				if (memberType == null) {
+					memberType =  baseUnit.GetNodeAt<MemberType> (location); 
+					if (memberType != null) {
+						tref = baseUnit.GetNodeAt<Expression> (location); 
+						if (tref == null)
+							return null;
+					}
+					if (tref is ObjectCreateExpression) {
+						expr = new TypeReferenceExpression (memberType.Target.Clone ());
+						expr.AddAnnotation (new ObjectCreateExpression ());
+					}
+				}
+					
 				if (memberType == null)
 					return null;
-				expr = new TypeReferenceExpression (memberType.Target.Clone ());
+				if (expr == null)
+					expr = new TypeReferenceExpression (memberType.Target.Clone ());
 				tref.ReplaceWith (expr);
 			}
 			
diff --git a/main/contrib/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngineBase.cs b/main/contrib/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngineBase.cs
index c57ba02753..62f4938634 100644
--- a/main/contrib/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngineBase.cs
+++ b/main/contrib/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngineBase.cs
@@ -345,7 +345,8 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			var result = visitor.GetResolveResult (resolveNode);
 			return Tuple.Create (result, state);
 		}
-		static void Print (AstNode node)
+		
+		protected static void Print (AstNode node)
 		{
 			var v = new CSharpOutputVisitor (Console.Out, new CSharpFormattingOptions ());
 			node.AcceptVisitor (v, null);
diff --git a/main/contrib/ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs b/main/contrib/ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs
index 5f293c3fa5..98e7d887f8 100644
--- a/main/contrib/ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs
+++ b/main/contrib/ICSharpCode.NRefactory.CSharp/Parser/CSharpParser.cs
@@ -36,6 +36,7 @@ namespace ICSharpCode.NRefactory.CSharp
 {
 	public class CSharpParser
 	{
+		
 		class ConversionVisitor : StructuralVisitor
 		{
 			CompilationUnit unit = new CompilationUnit ();
@@ -3435,6 +3436,11 @@ namespace ICSharpCode.NRefactory.CSharp
 			set;
 		}
 		
+		public CompilationUnit Parse (string program)
+		{
+			return Parse (new StringReader (program));
+		}
+		
 		public CompilationUnit Parse (Stream stream, int line = 0)
 		{
 			lock (CompilerCallableEntryPoint.parseLock) {
diff --git a/main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs b/main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs
index 18ab1986cc..4b8b067770 100644
--- a/main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs
+++ b/main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs
@@ -2008,9 +2008,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 			}
 			
-			bool parameterizeResultType = k > 0;
-			if (parameterizeResultType && typeArguments.All(t => t.Kind == TypeKind.UnboundTypeArgument))
-				parameterizeResultType = false;
+			bool parameterizeResultType = !(typeArguments.Count != 0 && typeArguments.All(t => t.Kind == TypeKind.UnboundTypeArgument));
 			
 			ResolveResult r = null;
 			if (currentTypeDefinition != null) {
@@ -2152,7 +2150,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 							def = context.GetTypeDefinition(ns.NamespaceName, identifier, k, StringComparer.Ordinal);
 							if (def != null) {
 								if (firstResult == null) {
-									if (parameterizeResultType)
+									if (parameterizeResultType && k > 0)
 										firstResult = new ParameterizedType(def, typeArguments);
 									else
 										firstResult = def;
@@ -2238,9 +2236,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			cancellationToken.ThrowIfCancellationRequested();
 			
-			bool parameterizeResultType = typeArguments.Count > 0;
-			if (parameterizeResultType && typeArguments.All(t => t.Kind == TypeKind.UnboundTypeArgument))
-				parameterizeResultType = false;
+			bool parameterizeResultType = !(typeArguments.Count != 0 && typeArguments.All(t => t.Kind == TypeKind.UnboundTypeArgument));
 			
 			NamespaceResolveResult nrr = target as NamespaceResolveResult;
 			if (nrr != null) {
@@ -2260,7 +2256,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 			ITypeDefinition def = context.GetTypeDefinition(nrr.NamespaceName, identifier, typeArguments.Count, StringComparer.Ordinal);
 			if (def != null) {
-				if (parameterizeResultType)
+				if (parameterizeResultType && typeArguments.Count > 0)
 					return new TypeResolveResult(new ParameterizedType(def, typeArguments));
 				else
 					return new TypeResolveResult(def);
diff --git a/main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs b/main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs
index ea246a99aa..932dcc38bb 100644
--- a/main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs
+++ b/main/contrib/ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs
@@ -168,7 +168,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					if (resolverBeforeDict.Count == 0) {
 						// If we're just starting to resolve and haven't any context cached yet,
 						// make sure to cache the root node.
-						StoreState(node, resolver.Clone());
+						StoreCurrentState(node);
 					}
 					break;
 				case ResolveVisitorNavigationMode.Scan:
@@ -184,7 +184,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					
 					bool oldResolverEnabled = resolverEnabled;
 					resolverEnabled = false;
-					StoreState(node, resolver.Clone());
+					StoreCurrentState(node);
 					node.AcceptVisitor(this, null);
 					resolverEnabled = oldResolverEnabled;
 					break;
@@ -206,7 +206,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// This method now is internal, because it is difficult to use correctly.
 		/// Users of the public API should use Scan()+GetResolveResult() instead.
 		/// </summary>
-		public ResolveResult Resolve(AstNode node)
+		internal ResolveResult Resolve(AstNode node)
 		{
 			if (node == null || node.IsNull)
 				return errorResult;
@@ -215,7 +215,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			ResolveResult result;
 			if (!resolveResultCache.TryGetValue(node, out result)) {
 				resolver.cancellationToken.ThrowIfCancellationRequested();
-				StoreState(node, resolver.Clone());
+				StoreCurrentState(node);
 				result = node.AcceptVisitor(this, null) ?? errorResult;
 				Log.WriteLine("Resolved '{0}' to {1}", node, result);
 				StoreResult(node, result);
@@ -229,12 +229,11 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return Resolve(type).Type;
 		}
 		
-		void StoreState(AstNode node, CSharpResolver resolverState)
+		void StoreCurrentState(AstNode node)
 		{
-			Debug.Assert(resolverState != null);
 			// It's possible that we re-visit an expression that we scanned over earlier,
 			// so we might have to overwrite an existing state.
-			resolverBeforeDict[node] = resolverState;
+			resolverBeforeDict[node] = resolver.Clone();
 		}
 		
 		void StoreResult(AstNode node, ResolveResult result)
@@ -242,6 +241,9 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			Debug.Assert(result != null);
 			if (node.IsNull)
 				return;
+			// The state should be stored before the result is.
+			Debug.Assert(resolverBeforeDict.ContainsKey(node));
+			// Don't store results twice.
 			Debug.Assert(!resolveResultCache.ContainsKey(node));
 			resolveResultCache.Add(node, result);
 			if (navigator != null)
@@ -621,7 +623,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 				ArrayType arrayType = result.Type as ArrayType;
 				if (aie != null && arrayType != null) {
-					StoreState(aie, resolver.Clone());
+					StoreCurrentState(aie);
 					List<Expression> initializerElements = new List<Expression>();
 					UnpackArrayInitializer(initializerElements, aie, arrayType.Dimensions, true);
 					ResolveResult[] initializerElementResults = new ResolveResult[initializerElements.Count];
@@ -966,6 +968,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				initializerElements = null;
 				initializerElementResults = null;
 			} else {
+				StoreCurrentState(arrayCreateExpression.Initializer);
+				
 				initializerElements = new List<Expression>();
 				UnpackArrayInitializer(initializerElements, arrayCreateExpression.Initializer, dimensions, true);
 				initializerElementResults = new ResolveResult[initializerElements.Count];
@@ -996,8 +1000,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				foreach (var node in initializer.Elements) {
 					ArrayInitializerExpression aie = node as ArrayInitializerExpression;
 					if (aie != null) {
-						if (resolveNestedInitializesToVoid)
+						if (resolveNestedInitializesToVoid) {
+							StoreCurrentState(aie);
 							StoreResult(aie, voidResult);
+						}
 						UnpackArrayInitializer(elementList, aie, dimensions - 1, resolveNestedInitializesToVoid);
 					} else {
 						elementList.Add(node);
@@ -1239,6 +1245,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		void HandleObjectInitializer(IType type, ArrayInitializerExpression initializer)
 		{
+			StoreCurrentState(initializer);
 			resolver.PushInitializerType(type);
 			foreach (Expression element in initializer.Elements) {
 				ArrayInitializerExpression aie = element as ArrayInitializerExpression;
@@ -1247,7 +1254,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 						// Don't resolve the add call again if we already did so
 						continue;
 					}
-					StoreState(aie, resolver.Clone());
+					StoreCurrentState(aie);
 					// constructor argument list in collection initializer
 					ResolveResult[] addArguments = new ResolveResult[aie.Elements.Count];
 					int i = 0;
@@ -1505,7 +1512,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			    && !resolveResultCache.ContainsKey(identifierExpression))
 			{
 				// Special handling for §7.6.4.1 Identicial simple names and type names
-				StoreState(identifierExpression, resolver.Clone());
+				StoreCurrentState(identifierExpression);
 				ResolveResult target = resolver.ResolveSimpleName(identifierExpression.Identifier, EmptyList<IType>.Instance);
 				TypeResolveResult trr;
 				if (IsVariableReferenceWithSameType(target, identifierExpression.Identifier, out trr)) {
@@ -1563,6 +1570,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			    && !resolveResultCache.ContainsKey(identifierExpression))
 			{
 				// Special handling for §7.6.4.1 Identicial simple names and type names
+				
+				StoreCurrentState(identifierExpression);
+				StoreCurrentState(mre);
+				
 				ResolveResult idRR = resolver.ResolveSimpleName(identifierExpression.Identifier, EmptyList<IType>.Instance);
 				ResolveResult target = ResolveMemberReferenceOnGivenTarget(idRR, mre);
 				Log.WriteLine("Member reference '{0}' on potentially-ambiguous simple-name was resolved to {1}", mre, target);
@@ -2111,12 +2122,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				
 				visitor.MergeUndecidedLambdas();
 				Log.WriteLine("Merging " + ToString());
+				foreach (var pair in visitor.resolverBeforeDict) {
+					parentVisitor.resolverBeforeDict[pair.Key] = pair.Value;
+				}
 				foreach (var pair in visitor.resolveResultCache) {
 					parentVisitor.StoreResult(pair.Key, pair.Value);
 				}
-				foreach (var pair in visitor.resolverBeforeDict) {
-					parentVisitor.StoreState(pair.Key, pair.Value);
-				}
 				parentVisitor.undecidedLambdas.Remove(lambda);
 			}
 			
@@ -2416,6 +2427,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				Scan(foreachStatement.InExpression);
 				type = ResolveType(foreachStatement.VariableType);
 			}
+			StoreCurrentState(foreachStatement.VariableNameToken);
 			IVariable v = resolver.AddVariable(type, MakeRegion(foreachStatement.VariableNameToken), foreachStatement.VariableName);
 			StoreResult(foreachStatement.VariableNameToken, new LocalResolveResult(v, v.Type.Resolve(resolver.Context)));
 			Scan(foreachStatement.EmbeddedStatement);
@@ -2437,6 +2449,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (!string.IsNullOrEmpty(catchClause.VariableName)) {
 				ITypeReference variableType = MakeTypeReference(catchClause.Type);
 				DomRegion region = MakeRegion(catchClause.VariableNameToken);
+				StoreCurrentState(catchClause.VariableNameToken);
 				IVariable v = resolver.AddVariable(variableType, region, catchClause.VariableName);
 				StoreResult(catchClause.VariableNameToken, new LocalResolveResult(v, v.Type.Resolve(resolver.Context)));
 			}
@@ -2457,6 +2470,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					|| navigator.Scan(vi) == ResolveVisitorNavigationMode.Resolve;
 				ITypeReference type;
 				if (needResolve) {
+					StoreCurrentState(variableDeclarationStatement.Type);
 					type = Resolve(vi.Initializer).Type;
 					if (!resolveResultCache.ContainsKey(variableDeclarationStatement.Type)) {
 						StoreResult(variableDeclarationStatement.Type, new TypeResolveResult(type.Resolve(resolver.Context)));
@@ -2466,7 +2480,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					type = MakeVarTypeReference(vi.Initializer, false);
 				}
 				IVariable v = resolver.AddVariable(type, MakeRegion(vi), vi.Name);
-				StoreState(vi, resolver.Clone());
+				StoreCurrentState(vi);
 				if (needResolve) {
 					ResolveResult result;
 					if (!resolveResultCache.TryGetValue(vi, out result)) {
@@ -2834,6 +2848,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			ResolveResult target;
 			if (memberType.IsDoubleColon && memberType.Target is SimpleType) {
 				SimpleType t = (SimpleType)memberType.Target;
+				StoreCurrentState(t);
 				target = resolver.ResolveAlias(t.Identifier);
 				StoreResult(t, target);
 			} else {
@@ -2984,6 +2999,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 			}
 			
+			StoreCurrentState(queryFromClause.IdentifierToken);
 			DomRegion region = MakeRegion(queryFromClause.IdentifierToken);
 			IVariable v = resolver.AddVariable(variableType, region, queryFromClause.Identifier);
 			StoreResult(queryFromClause.IdentifierToken, new LocalResolveResult(v, variableType));
@@ -3014,6 +3030,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			ResolveResult rr = Resolve(queryContinuationClause.PrecedingQuery);
 			IType variableType = GetTypeForQueryVariable(rr.Type);
 			DomRegion region = MakeRegion(queryContinuationClause.IdentifierToken);
+			StoreCurrentState(queryContinuationClause.IdentifierToken);
 			IVariable v = resolver.AddVariable(variableType, region, queryContinuationClause.Identifier);
 			StoreResult(queryContinuationClause.IdentifierToken, new LocalResolveResult(v, variableType));
 			return rr;
@@ -3023,6 +3040,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			ResolveResult expr = Resolve(queryLetClause.Expression);
 			DomRegion region = MakeRegion(queryLetClause.IdentifierToken);
+			StoreCurrentState(queryLetClause.IdentifierToken);
 			IVariable v = resolver.AddVariable(expr.Type, region, queryLetClause.Identifier);
 			StoreResult(queryLetClause.IdentifierToken, new LocalResolveResult(v, expr.Type));
 			if (resolverEnabled && currentQueryResult != null) {
@@ -3066,6 +3084,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			ResetContext(resolverOutsideQuery, delegate {
 			             	equalsResult = Resolve(queryJoinClause.EqualsExpression);
 			             });
+			StoreCurrentState(queryJoinClause.JoinIdentifierToken);
 			StoreResult(queryJoinClause.JoinIdentifierToken, new LocalResolveResult(v, variableType));
 			
 			if (queryJoinClause.IsGroupJoin) {
@@ -3144,10 +3163,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 				
 				implicitlyTypedLambda.EnforceMerge(this);
-				if (implicitlyTypedLambda.winningHypothesis.parameterTypes.Length == 2)
+				if (implicitlyTypedLambda.winningHypothesis.parameterTypes.Length == 2) {
+					StoreCurrentState(queryJoinClause.IntoIdentifierToken);
 					groupVariable = implicitlyTypedLambda.winningHypothesis.lambdaParameters[1];
-				else
+				} else {
 					groupVariable = null;
+				}
 			} else {
 				Debug.Assert(groupJoinLambda is QueryExpressionLambda);
 				
@@ -3172,6 +3193,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				else
 					groupParameterType = SharedTypes.UnknownType;
 				
+				StoreCurrentState(queryJoinClause.IntoIdentifierToken);
 				groupVariable = resolver.AddVariable(groupParameterType, intoIdentifierRegion, queryJoinClause.IntoIdentifier);
 			}
 			
diff --git a/main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/BaseTypeCollector.cs b/main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/BaseTypeCollector.cs
index 38a6c0e5c3..98e9195384 100644
--- a/main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/BaseTypeCollector.cs
+++ b/main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/BaseTypeCollector.cs
@@ -61,7 +61,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			// (e.g. C implements I1 and I2, and both interfaces derive from Object)
 			if (!this.Contains(type)) {
 				foreach (IType baseType in type.GetBaseTypes(context)) {
-					if (SkipImplementedInterfaces && def != null && def.Kind != TypeKind.Interface) {
+					if (SkipImplementedInterfaces && def != null && def.Kind != TypeKind.Interface && def.Kind != TypeKind.TypeParameter) {
 						if (baseType.Kind == TypeKind.Interface) {
 							// skip the interface
 							continue;
diff --git a/main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeDefinition.cs b/main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeDefinition.cs
index f9eccea610..1361ec794d 100644
--- a/main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeDefinition.cs
+++ b/main/contrib/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeDefinition.cs
@@ -615,13 +615,13 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		{
 			// Two ITypeDefinitions are considered to be equal if they have the same compound class.
 			ITypeDefinition typeDef = other as ITypeDefinition;
-			return typeDef != null && this.GetDefinition().ReflectionName == typeDef.GetDefinition().ReflectionName;
+			return typeDef != null && this.ProjectContent == typeDef.ProjectContent && this.GetDefinition().ReflectionName == typeDef.GetDefinition().ReflectionName;
 		}
 		
 		public override bool Equals(object obj)
 		{
 			ITypeDefinition typeDef = obj as ITypeDefinition;
-			return typeDef != null && this.GetDefinition().ReflectionName == typeDef.GetDefinition().ReflectionName;
+			return typeDef != null && this.ProjectContent == typeDef.ProjectContent && this.GetDefinition().ReflectionName == typeDef.GetDefinition().ReflectionName;
 		}
 		
 		public override int GetHashCode()