Merge branch 'master' of github.com:icsharpcode/NRefactory

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@@ -2246,31 +2246,6 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			return parentheses != 1 || bracket > 0 ? -1 : index;
 		}
 		
-		CSharpResolver GetState ()
-		{
-			return new CSharpResolver (ctx);
-			/*var state = new CSharpResolver (ctx);
-			
-			state.CurrentMember = currentMember;
-			state.CurrentTypeDefinition = currentType;
-			state.CurrentUsingScope = CSharpParsedFile.GetUsingScope (location);
-			if (state.CurrentMember != null) {
-				var node = Unit.GetNodeAt (location);
-				if (node == null)
-					return state;
-				var navigator = new NodeListResolveVisitorNavigator (new[] { node });
-				var visitor = new ResolveVisitor (state, CSharpParsedFile, navigator);
-				Unit.AcceptVisitor (visitor, null);
-				try {
-					var newState = visitor.GetResolverStateBefore (node);
-					if (newState != null)
-						state = newState;
-				} catch (Exception) {
-				}
-			}
-			
-			return state;*/
-		}
 		#endregion
 		
 		#region Preprocessor

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngineBase.cs

@@ -192,7 +192,33 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			var expr = Unit.GetNodeAt<PrimitiveExpression> (loc.Line, loc.Column);
 			return expr != null && expr.Value is string;
 		}
-		#endregion
+		
+		protected CSharpResolver GetState ()
+		{
+			return new CSharpResolver (ctx);
+			/*var state = new CSharpResolver (ctx);
+			
+			state.CurrentMember = currentMember;
+			state.CurrentTypeDefinition = currentType;
+			state.CurrentUsingScope = CSharpParsedFile.GetUsingScope (location);
+			if (state.CurrentMember != null) {
+				var node = Unit.GetNodeAt (location);
+				if (node == null)
+					return state;
+				var navigator = new NodeListResolveVisitorNavigator (new[] { node });
+				var visitor = new ResolveVisitor (state, CSharpParsedFile, navigator);
+				Unit.AcceptVisitor (visitor, null);
+				try {
+					var newState = visitor.GetResolverStateBefore (node);
+					if (newState != null)
+						state = newState;
+				} catch (Exception) {
+				}
+			}
+			
+			return state;*/
+		}
+				#endregion
 		
 		#region Basic parsing/resolving functions
 		Stack<Tuple<char, int>> GetBracketStack (string memberText)
@@ -343,7 +369,6 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			} else {
 				memberLocation = new TextLocation (1, 1);
 			}
-			
 			using (var stream = new System.IO.StringReader (wrapper.ToString ())) {
 				try {
 					var parser = new CSharpParser ();

ICSharpCode.NRefactory.CSharp/Completion/CSharpParameterCompletionEngine.cs

@@ -57,7 +57,6 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			
 			var memberLocation = currentMember != null ? currentMember.Region.Begin : currentType.Region.Begin;
 			var mref = baseUnit.GetNodeAt (location, n => n is IndexerExpression); 
-			Print (baseUnit);
 			AstNode expr;
 			if (mref is IndexerExpression) {
 				expr = ((IndexerExpression)mref).Target;
@@ -74,6 +73,25 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			return Tuple.Create (tsvisitor.ParsedFile, (AstNode)expr, Unit);
 		}
 		
+		public Tuple<CSharpParsedFile, AstNode, CompilationUnit> GetTypeBeforeCursor ()
+		{
+			CompilationUnit baseUnit;
+			if (currentMember == null && currentType == null) 
+				return null;
+			baseUnit = ParseStub ("x> a");
+			
+			var memberLocation = currentMember != null ? currentMember.Region.Begin : currentType.Region.Begin;
+			var expr = baseUnit.GetNodeAt<AstType> (location.Line, location.Column + 1); // '>' position
+			
+			var member = Unit.GetNodeAt<AttributedNode> (memberLocation);
+			var member2 = baseUnit.GetNodeAt<AttributedNode> (memberLocation);
+			member2.Remove ();
+			member.ReplaceWith (member2);
+			var tsvisitor = new TypeSystemConvertVisitor (CSharpParsedFile.FileName);
+			Unit.AcceptVisitor (tsvisitor, null);
+			return Tuple.Create (tsvisitor.ParsedFile, (AstNode)expr, Unit);
+		}
+		
 		public IParameterDataProvider GetParameterDataProvider (int offset, char completionChar)
 		{
 			if (offset <= 0)
@@ -85,13 +103,13 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			if (IsInsideCommentOrString ())
 				return null;
 			
-			var invoke = GetInvocationBeforeCursor (true) ?? GetIndexerBeforeCursor ();
-			if (invoke == null)
-				return null;
 			
 			ResolveResult resolveResult;
 			switch (completionChar) {
 			case '(':
+				var invoke = GetInvocationBeforeCursor (true) ?? GetIndexerBeforeCursor ();
+				if (invoke == null)
+					return null;
 				if (invoke.Item2 is ObjectCreateExpression) {
 					var createType = ResolveExpression (invoke.Item1, ((ObjectCreateExpression)invoke.Item2).Type, invoke.Item3);
 					return factory.CreateConstructorProvider (createType.Item1.Type);
@@ -131,6 +149,18 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 //				}
 				break;
 			case ',':
+				invoke = GetInvocationBeforeCursor (true) ?? GetIndexerBeforeCursor ();
+				if (invoke == null) {
+					invoke = GetTypeBeforeCursor ();
+					if (invoke !=null) {
+						var typeExpression = ResolveExpression (invoke.Item1, invoke.Item2, invoke.Item3);
+						if (typeExpression == null || typeExpression.Item1 == null || typeExpression.Item1.IsError)
+							return null;
+						
+						return factory.CreateTypeParameterDataProvider (CollectAllTypes (typeExpression.Item1.Type));
+					}
+					return null;
+				}
 				if (invoke.Item2 is ObjectCreateExpression) {
 					var createType = ResolveExpression (invoke.Item1, ((ObjectCreateExpression)invoke.Item2).Type, invoke.Item3);
 					return factory.CreateConstructorProvider (createType.Item1.Type);
@@ -161,12 +191,19 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 				if (resolveResult != null)
 					return factory.CreateIndexerParameterDataProvider (resolveResult.Type, invoke.Item2);
 				break;
-//			case '<':
+			case '<':
-//				if (string.IsNullOrEmpty (result.Expression))
+				invoke = GetTypeBeforeCursor ();
-//					return null;
+				if (invoke == null)
-//				return new NRefactoryTemplateParameterDataProvider (textEditorData, resolver, GetUsedNamespaces (), result, new TextLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset));
+					return null;
+				var typeExpression = ResolveExpression (invoke.Item1, invoke.Item2, invoke.Item3);
+				if (typeExpression == null || typeExpression.Item1 == null || typeExpression.Item1.IsError)
+					return null;
 				
+				return factory.CreateTypeParameterDataProvider (CollectAllTypes (typeExpression.Item1.Type));
 			case '[':
+				invoke = GetIndexerBeforeCursor ();
+				if (invoke == null)
+					return null;
 				var indexerExpression = ResolveExpression (invoke.Item1, invoke.Item2, invoke.Item3);
 				if (indexerExpression == null || indexerExpression.Item1 == null || indexerExpression.Item1.IsError)
 					return null;
@@ -175,6 +212,24 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			return null;
 		}
 		
+		IEnumerable<IType> CollectAllTypes (IType baseType)
+		{
+			var state = GetState ();
+			for (var n = state.CurrentUsingScope; n != null; n = n.Parent) {
+				foreach (var u in n.Usings) {
+					foreach (var type in u.Types) {
+						if (type.TypeParameterCount > 0 && type.Name == baseType.Name)
+							yield return type;
+					}
+				}
+				
+				foreach (var type in n.Namespace.Types) {
+					if (type.TypeParameterCount > 0 && type.Name == baseType.Name)
+						yield return type;
+				}
+			}
+		}
+		
 		List<string> GetUsedNamespaces ()
 		{
 			var scope = CSharpParsedFile.GetUsingScope (location);

ICSharpCode.NRefactory.CSharp/Completion/IParameterCompletionDataFactory.cs

@@ -27,6 +27,7 @@ using System;
 using ICSharpCode.NRefactory.TypeSystem;
 using ICSharpCode.NRefactory.Completion;
 using ICSharpCode.NRefactory.CSharp.Resolver;
+using System.Collections.Generic;
 
 namespace ICSharpCode.NRefactory.CSharp.Completion
 {
@@ -41,6 +42,8 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 		IParameterDataProvider CreateDelegateDataProvider (IType type);
 		
 		IParameterDataProvider CreateIndexerParameterDataProvider (IType type, AstNode resolvedNode);
+		
+		IParameterDataProvider CreateTypeParameterDataProvider (IEnumerable<IType> types);
 	}
 	
 }

ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpOutputVisitor.cs

@@ -118,6 +118,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				WriteSpecialsUpToNode (node);
 			containerStack.Push (node);
 			positionStack.Push (node.FirstChild);
+			formatter.WriteToken (""); // force indentation, if required
 			OnOutputStarted (new AstNodeEventArgs (node));
 			formatter.StartNode (node);
 		}

ICSharpCode.NRefactory.CSharp/Refactoring/NodeOutputAction.cs

@@ -62,24 +62,29 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 		{
 			public int Offset {
 				get;
-				set;
+				internal set;
 			}
 
 			public int Length {
-				get {
+				get;
-					return EndOffset - Offset;
+				internal set;
-				}
 			}
 
 			public int EndOffset {
-				get;
+				get {
-				set;
+					return Offset + Length;
+				}
 			}
 			
 			public Segment (int offset)
 			{
 				this.Offset = offset;
 			}
+			
+			public override string ToString ()
+			{
+				return string.Format ("[NodeOutput.Segment: Offset={0}, Length={1}, EndOffset={2}]", Offset, Length, EndOffset);
+			}
 		}
 	}
 	

ICSharpCode.NRefactory.CSharp/Refactoring/RefactoringContext.cs

@@ -48,22 +48,36 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			get;
 		}
 		
+		public ICompilation Compilation {
+			get;
+			protected set;
+		}
+		
 		public abstract CSharpFormattingOptions FormattingOptions {
 			get;
 		}
 
 		public abstract AstType CreateShortType (IType fullType);
 		
-		public AstType CreateShortType (string ns, string typeName)
+		public AstType CreateShortType (string ns, string name, int typeParameterCount = 0)
 		{
-			throw new NotImplementedException();
+			var def = Compilation.MainAssembly.GetTypeDefinition (ns, name, typeParameterCount);
-			//return CreateShortType (TypeResolveContext.GetTypeDefinition (ns, typeName, 0, StringComparer.Ordinal));
+			if (def == null) {
+				foreach (var asm in Compilation.ReferencedAssemblies) {
+					def = asm.GetTypeDefinition (ns, name, typeParameterCount);
+					if (def != null)
+						break;
+				}
+				
+			}
+			if (def == null)
+				return new MemberType (new SimpleType (ns), name);
+			return CreateShortType (def);
 		}
 		
 		public virtual AstType CreateShortType (AstType fullType)
 		{
-			throw new NotImplementedException();
+			return CreateShortType (Resolve (fullType).Type);
-			//return CreateShortType (Resolve (fullType).Type.Resolve (TypeResolveContext));
 		}
 		
 //		public abstract IType GetDefinition (AstType resolvedType);

ICSharpCode.NRefactory.CSharp/Refactoring/Script.cs

@@ -162,7 +162,8 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				result.NodeSegments [e.AstNode] = new NodeOutput.Segment (stringWriter.GetStringBuilder ().Length);
 			};
 			visitor.OutputFinished += (sender, e) => {
-				result.NodeSegments [e.AstNode].EndOffset = stringWriter.GetStringBuilder ().Length;
+				var nodeSegment = result.NodeSegments [e.AstNode];
+				nodeSegment.Length = stringWriter.GetStringBuilder ().Length - nodeSegment.Offset;
 			};
 			node.AcceptVisitor (visitor, null);
 			result.Text = stringWriter.ToString ().TrimEnd ();

ICSharpCode.NRefactory.CSharp/Resolver/FindReferences.cs

@@ -189,7 +189,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			SearchScope additionalScope = null;
 			switch (entity.EntityType) {
 				case EntityType.TypeDefinition:
-					scope = FindTypeDefinitionReferences((ITypeDefinition)entity, this.FindTypeReferencesEvenIfAliased);
+					scope = FindTypeDefinitionReferences((ITypeDefinition)entity, this.FindTypeReferencesEvenIfAliased, out additionalScope);
 					break;
 				case EntityType.Field:
 					if (entity.DeclaringTypeDefinition != null && entity.DeclaringTypeDefinition.Kind == TypeKind.Enum)
@@ -353,14 +353,28 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		#endregion
 		
 		#region Find TypeDefinition References
-		SearchScope FindTypeDefinitionReferences(ITypeDefinition typeDefinition, bool findTypeReferencesEvenIfAliased)
+		SearchScope FindTypeDefinitionReferences(ITypeDefinition typeDefinition, bool findTypeReferencesEvenIfAliased, out SearchScope additionalScope)
 		{
 			string searchTerm = null;
-			if (!findTypeReferencesEvenIfAliased && ReflectionHelper.GetTypeCode(typeDefinition) == TypeCode.Empty) {
+			additionalScope = null;
-				// not a built-in type
+			if (!findTypeReferencesEvenIfAliased && KnownTypeReference.GetCSharpNameByTypeCode(typeDefinition.KnownTypeCode) == null) {
+				// We can optimize the search by looking only for the type references with the right identifier,
+				// but only if it's not a primitive type and we're not looking for indirect references (through an alias)
 				searchTerm = typeDefinition.Name;
+				if (searchTerm.Length > 9 && searchTerm.EndsWith("Attribute", StringComparison.Ordinal)) {
+					// The type might be an attribute, so we also need to look for the short form:
+					string shortForm = searchTerm.Substring(0, searchTerm.Length - 9);
+					additionalScope = new SearchScope(
+						shortForm,
+						delegate (ICompilation compilation) {
+							ITypeDefinition imported = compilation.Import(typeDefinition);
+							if (imported != null)
+								return new FindTypeDefinitionReferencesNavigator(imported, shortForm);
+							else
+								return null;
+						});
+				}
 			}
-			
 			return new SearchScope(
 				searchTerm,
 				delegate (ICompilation compilation) {
@@ -404,7 +418,15 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				if (searchTerm == null && node is PrimitiveType)
 					return true;
 				
-				return node is TypeDeclaration || node is DelegateDeclaration;
+				TypeDeclaration typeDecl = node as TypeDeclaration;
+				if (typeDecl != null)
+					return searchTerm == null || typeDecl.Name == searchTerm;
+				
+				DelegateDeclaration delegateDecl = node as DelegateDeclaration;
+				if (delegateDecl != null)
+					return searchTerm == null || delegateDecl.Name == searchTerm;
+				
+				return false;
 			}
 			
 			internal override bool IsMatch(ResolveResult rr)
@@ -872,9 +894,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			ctor = (IMethod)ctor.MemberDefinition;
 			string searchTerm = null;
-			if (ReflectionHelper.GetTypeCode(ctor.DeclaringTypeDefinition) == TypeCode.Empty) {
+			if (KnownTypeReference.GetCSharpNameByTypeCode(ctor.DeclaringTypeDefinition.KnownTypeCode) == null) {
 				// not a built-in type
 				searchTerm = ctor.DeclaringTypeDefinition.Name;
+				if (searchTerm.Length > 9 && searchTerm.EndsWith("Attribute", StringComparison.Ordinal)) {
+					// we also need to look for the short form
+					searchTerm = null;
+				}
 			}
 			return new SearchScope(
 				searchTerm,
@@ -898,7 +924,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			
 			internal override bool CanMatch(AstNode node)
 			{
-				return node is ObjectCreateExpression || node is ConstructorDeclaration;
+				return node is ObjectCreateExpression || node is ConstructorDeclaration || node is Attribute;
 			}
 			
 			internal override bool IsMatch(ResolveResult rr)

ICSharpCode.NRefactory.Demo/CSDemo.cs

@@ -312,10 +312,12 @@ namespace ICSharpCode.NRefactory.Demo
 			FindReferences fr = new FindReferences();
 			int referenceCount = 0;
 			FoundReferenceCallback callback = delegate(AstNode matchNode, ResolveResult result) {
+				Debug.WriteLine(matchNode.StartLocation + " - " + matchNode + " - " + result);
 				referenceCount++;
 			};
 			
 			var searchScopes = fr.GetSearchScopes(entity);
+			Debug.WriteLine("Find references to " + entity.ReflectionName);
 			fr.FindReferencesInFile(searchScopes, parsedFile, compilationUnit, compilation, callback, CancellationToken.None);
 			
 			MessageBox.Show("Found " + referenceCount + " references to " + entity.FullName);

ICSharpCode.NRefactory.GtkDemo/MainWindow.cs

@@ -86,7 +86,12 @@ namespace ICSharpCode.NRefactory.GtkDemo
 			buttonGenerate.Clicked += CSharpGenerateCodeButtonClick;
 			HandleClicked (this, EventArgs.Empty);
 		}
-
+		protected override void OnDestroyed ()
+		{
+			base.OnDestroyed ();
+			Application.Quit ();
+		}
+		
 		void HandlePositionChanged (object sender, DocumentLocationEventArgs e)
 		{
 			var node = unit.GetNodeAt (editor.Caret.Line, editor.Caret.Column);

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

@@ -26,6 +26,8 @@
 
 using System;
 using NUnit.Framework;
+using ICSharpCode.NRefactory.CSharp.Parser;
+using System.Linq;
 
 namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 {

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

@@ -135,6 +135,34 @@ namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 				#endregion
 			}
 			
+			class TypeParameterDataProvider : IParameterDataProvider
+			{
+				public IEnumerable<IType> Data { get; set; }
+				#region IParameterDataProvider implementation
+				public string GetMethodMarkup (int overload, string[] parameterMarkup, int currentParameter)
+				{
+					return "";
+				}
+
+				public string GetParameterMarkup (int overload, int paramIndex)
+				{
+					return "";
+				}
+
+				public int GetParameterCount (int overload)
+				{
+					var method = Data.ElementAt (overload);
+					return method.TypeParameterCount;
+				}
+
+				public int OverloadCount {
+					get {
+						return Data.Count ();
+					}
+				}
+				#endregion
+			}
+			
 			#region IParameterCompletionDataFactory implementation
 			public IParameterDataProvider CreateConstructorProvider (ICSharpCode.NRefactory.TypeSystem.IType type)
 			{
@@ -173,6 +201,12 @@ namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 					Data = type.GetProperties (p => p.IsIndexer)
 				};
 			}
+			public IParameterDataProvider CreateTypeParameterDataProvider (IEnumerable<IType> types)
+			{
+				return new TypeParameterDataProvider () {
+					Data = types
+				};
+			}
 			#endregion
 		}
 		
@@ -536,7 +570,129 @@ namespace Test
 			Assert.IsNotNull (provider, "provider was not created.");
 			Assert.AreEqual (2, provider.OverloadCount);
 		}
+		
+		[Test()]
+		public void TestTypeParameter ()
+		{
+			IParameterDataProvider provider = CreateProvider (
+@"using System;
+
+namespace Test 
+{
+	class A
+	{
+		void Method ()
+		{
+			$Action<$
+		}
+	}
+}");
+			Assert.IsNotNull (provider, "provider was not created.");
+			Assert.AreEqual (16, provider.OverloadCount);
+		}
+		
+		[Test()]
+		public void TestSecondTypeParameter ()
+		{
+			IParameterDataProvider provider = CreateProvider (
+@"using System;
 
+namespace Test 
+{
+	class A
+	{
+		void Method ()
+		{
+			$Action<string,$
+		}
+	}
+}");
+			Assert.IsNotNull (provider, "provider was not created.");
+			Assert.AreEqual (16, provider.OverloadCount);
+		}
+		
+		[Ignore("TODO")]
+		[Test()]
+		public void TestMethodTypeParameter ()
+		{
+			IParameterDataProvider provider = CreateProvider (
+@"using System;
+
+namespace Test 
+{
+	class A
+	{
+		void TestMethod<T, S>()
+		{
+		}
+
+		void Method ()
+		{
+			$TestMethod<$
+		}
+	}
+}");
+			Assert.IsNotNull (provider, "provider was not created.");
+			Assert.AreEqual (1, provider.OverloadCount);
+		}
+		
+		[Ignore("TODO")]
+		[Test()]
+		public void TestSecondMethodTypeParameter ()
+		{
+			IParameterDataProvider provider = CreateProvider (
+@"using System;
+
+namespace Test 
+{
+	class A
+	{
+		void TestMethod<T, S>()
+		{
+		}
+
+		void Method ()
+		{
+			$TestMethod<string,$
+		}
+	}
+}");
+			Assert.IsNotNull (provider, "provider was not created.");
+			Assert.AreEqual (1, provider.OverloadCount);
+		}		
 	
+		[Test()]
+		public void TestArrayParameter ()
+		{
+			var provider = CreateProvider (
+@"
+class TestClass
+{
+	public void Method()
+	{
+		int[,,,] arr;
+		$arr[$
+	}
+}");
+			Assert.IsNotNull (provider, "provider was not created.");
+			Assert.AreEqual (1, provider.OverloadCount);
+		}
+		
+		[Test()]
+		public void TestSecondArrayParameter ()
+		{
+			var provider = CreateProvider (
+@"
+class TestClass
+{
+	public void Method()
+	{
+		int[,,,] arr;
+		$arr[5,$
+	}
+}");
+			Assert.IsNotNull (provider, "provider was not created.");
+			Assert.AreEqual (1, provider.OverloadCount);
+		}
 	}
 }

ICSharpCode.NRefactory/TypeSystem/ExtensionMethods.cs

@@ -252,16 +252,33 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		#endregion
 		
 		#region GetType/Member
+		/// <summary>
+		/// Gets all unresolved type definitions from the file.
+		/// For partial classes, each part is returned.
+		/// </summary>
 		public static IEnumerable<IUnresolvedTypeDefinition> GetAllTypeDefinitions (this IParsedFile file)
 		{
 			return TreeTraversal.PreOrder(file.TopLevelTypeDefinitions, t => t.NestedTypes);
 		}
 		
+		/// <summary>
+		/// Gets all unresolved type definitions from the assembly.
+		/// For partial classes, each part is returned.
+		/// </summary>
+		public static IEnumerable<IUnresolvedTypeDefinition> GetAllTypeDefinitions (this IUnresolvedAssembly assembly)
+		{
+			return TreeTraversal.PreOrder(assembly.TopLevelTypeDefinitions, t => t.NestedTypes);
+		}
+		
 		public static IEnumerable<ITypeDefinition> GetAllTypeDefinitions (this IAssembly assembly)
 		{
 			return TreeTraversal.PreOrder(assembly.TopLevelTypeDefinitions, t => t.NestedTypes);
 		}
 		
+		/// <summary>
+		/// Gets all type definitions in the compilation.
+		/// This may include types from referenced assemblies that are not accessible in the main assembly.
+		/// </summary>
 		public static IEnumerable<ITypeDefinition> GetAllTypeDefinitions (this ICompilation compilation)
 		{
 			return compilation.MainAssembly.GetAllTypeDefinitions()

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultSolutionSnapshot.cs

@@ -24,7 +24,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 	/// <summary>
 	/// Default implementation of ISolutionSnapshot.
 	/// </summary>
-	public sealed class DefaultSolutionSnapshot : ISolutionSnapshot
+	public class DefaultSolutionSnapshot : ISolutionSnapshot
 	{
 		ConcurrentDictionary<IProjectContent, ICompilation> dictionary = new ConcurrentDictionary<IProjectContent, ICompilation>();