Rename IParsedFile -> IUnresolvedFile to make clear it belongs to the unresolved type system.

ICSharpCode.NRefactory.CSharp/Ast/SyntaxTree.cs

@@ -146,13 +146,13 @@ namespace ICSharpCode.NRefactory.CSharp
 		/// <summary>
 		/// Converts this syntax tree into a parsed file that can be stored in the type system.
 		/// </summary>
-		public CSharpParsedFile ToTypeSystem ()
+		public CSharpUnresolvedFile ToTypeSystem ()
 		{
 			if (string.IsNullOrEmpty (this.FileName))
 				throw new InvalidOperationException ("Cannot use ToTypeSystem() on a syntax tree without file name.");
 			var v = new TypeSystemConvertVisitor (this.FileName);
 			v.VisitSyntaxTree (this);
-			return v.ParsedFile;
+			return v.UnresolvedFile;
 		}
 		
 		public static SyntaxTree Parse (string program, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default (CancellationToken))

ICSharpCode.NRefactory.CSharp/CSharpProjectContent.cs

@@ -33,13 +33,13 @@ namespace ICSharpCode.NRefactory.CSharp
 		string assemblyName;
 		string projectFileName;
 		string location;
-		Dictionary<string, IParsedFile> parsedFiles;
+		Dictionary<string, IUnresolvedFile> unresolvedFiles;
 		List<IAssemblyReference> assemblyReferences;
 		CompilerSettings compilerSettings;
 		
 		public CSharpProjectContent()
 		{
-			this.parsedFiles = new Dictionary<string, IParsedFile>(Platform.FileNameComparer);
+			this.unresolvedFiles = new Dictionary<string, IUnresolvedFile>(Platform.FileNameComparer);
 			this.assemblyReferences = new List<IAssemblyReference>();
 			this.compilerSettings = new CompilerSettings();
 			compilerSettings.Freeze();
@@ -50,13 +50,13 @@ namespace ICSharpCode.NRefactory.CSharp
 			this.assemblyName = pc.assemblyName;
 			this.projectFileName = pc.projectFileName;
 			this.location = pc.location;
-			this.parsedFiles = new Dictionary<string, IParsedFile>(pc.parsedFiles, Platform.FileNameComparer);
+			this.unresolvedFiles = new Dictionary<string, IUnresolvedFile>(pc.unresolvedFiles, Platform.FileNameComparer);
 			this.assemblyReferences = new List<IAssemblyReference>(pc.assemblyReferences);
 			this.compilerSettings = pc.compilerSettings;
 		}
 		
-		public IEnumerable<IParsedFile> Files {
+		public IEnumerable<IUnresolvedFile> Files {
-			get { return parsedFiles.Values; }
+			get { return unresolvedFiles.Values; }
 		}
 		
 		public IEnumerable<IAssemblyReference> AssemblyReferences {
@@ -101,10 +101,10 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
-		public IParsedFile GetFile(string fileName)
+		public IUnresolvedFile GetFile(string fileName)
 		{
-			IParsedFile file;
+			IUnresolvedFile file;
-			if (parsedFiles.TryGetValue(fileName, out file))
+			if (unresolvedFiles.TryGetValue(fileName, out file))
 				return file;
 			else
 				return null;
@@ -160,6 +160,11 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public IProjectContent AddAssemblyReferences(IEnumerable<IAssemblyReference> references)
+		{
+			return AddAssemblyReferences(references.ToArray());
+		}
+		
+		public IProjectContent AddAssemblyReferences(params IAssemblyReference[] references)
 		{
 			CSharpProjectContent pc = Clone();
 			pc.assemblyReferences.AddRange(references);
@@ -167,13 +172,62 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		public IProjectContent RemoveAssemblyReferences(IEnumerable<IAssemblyReference> references)
+		{
+			return RemoveAssemblyReferences(references.ToArray());
+		}
+		
+		public IProjectContent RemoveAssemblyReferences(params IAssemblyReference[] references)
+		{
+			CSharpProjectContent pc = Clone();
+			foreach (var r in references)
+				pc.assemblyReferences.Remove(r);
+			return pc;
+		}
+		
+		/// <summary>
+		/// Adds the specified files to the project content.
+		/// If a file with the same name already exists, updated the existing file.
+		/// </summary>
+		public IProjectContent AddOrUpdateFiles(IEnumerable<IUnresolvedFile> newFiles)
+		{
+			CSharpProjectContent pc = Clone();
+			foreach (var file in newFiles) {
+				pc.unresolvedFiles[file.FileName] = file;
+			}
+			return pc;
+		}
+		
+		/// <summary>
+		/// Adds the specified files to the project content.
+		/// If a file with the same name already exists, this method updates the existing file.
+		/// </summary>
+		public IProjectContent AddOrUpdateFiles(params IUnresolvedFile[] newFiles)
+		{
+			return AddOrUpdateFiles((IEnumerable<IUnresolvedFile>)newFiles);
+		}
+		
+		/// <summary>
+		/// Removes the files with the specified names.
+		/// </summary>
+		public IProjectContent RemoveFiles(IEnumerable<string> fileNames)
 		{
 			CSharpProjectContent pc = Clone();
-			pc.assemblyReferences.RemoveAll(r => references.Contains(r));
+			foreach (var fileName in fileNames) {
+				pc.unresolvedFiles.Remove(fileName);
+			}
 			return pc;
 		}
 		
-		public IProjectContent UpdateProjectContent(IParsedFile oldFile, IParsedFile newFile)
+		/// <summary>
+		/// Removes the files with the specified names.
+		/// </summary>
+		public IProjectContent RemoveFiles(params string[] fileNames)
+		{
+			return RemoveFiles((IEnumerable<string>)fileNames);
+		}
+		
+		[Obsolete("Use RemoveFiles/AddOrUpdateFiles instead")]
+		public IProjectContent UpdateProjectContent(IUnresolvedFile oldFile, IUnresolvedFile newFile)
 		{
 			if (oldFile == null && newFile == null)
 				return this;
@@ -183,23 +237,24 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 			CSharpProjectContent pc = Clone();
 			if (newFile == null)
-				pc.parsedFiles.Remove(oldFile.FileName);
+				pc.unresolvedFiles.Remove(oldFile.FileName);
 			else
-				pc.parsedFiles[newFile.FileName] = newFile;
+				pc.unresolvedFiles[newFile.FileName] = newFile;
 			return pc;
 		}
 		
-		public IProjectContent UpdateProjectContent(IEnumerable<IParsedFile> oldFiles, IEnumerable<IParsedFile> newFiles)
+		[Obsolete("Use RemoveFiles/AddOrUpdateFiles instead")]
+		public IProjectContent UpdateProjectContent(IEnumerable<IUnresolvedFile> oldFiles, IEnumerable<IUnresolvedFile> newFiles)
 		{
 			CSharpProjectContent pc = Clone();
 			if (oldFiles != null) {
 				foreach (var oldFile in oldFiles) {
-					pc.parsedFiles.Remove(oldFile.FileName);
+					pc.unresolvedFiles.Remove(oldFile.FileName);
 				}
 			}
 			if (newFiles != null) {
 				foreach (var newFile in newFiles) {
-					pc.parsedFiles.Add(newFile.FileName, newFile);
+					pc.unresolvedFiles.Add(newFile.FileName, newFile);
 				}
 			}
 			return pc;

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs

@@ -723,7 +723,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 						//						var astResolver = new CSharpAstResolver(
 						//							GetState(),
 						//							identifierStart.Unit,
-						//							CSharpParsedFile
+						//							CSharpUnresolvedFile
 						//						);
 						//
 						//						foreach (var type in CreateFieldAction.GetValidTypes(astResolver, (Expression)n)) {
@@ -1172,7 +1172,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			if (csResolver == null) {
 				if (node != null) {
 					csResolver = GetState();
-					//var astResolver = new CSharpAstResolver (csResolver, node, xp != null ? xp.Item1 : CSharpParsedFile);
+					//var astResolver = new CSharpAstResolver (csResolver, node, xp != null ? xp.Item1 : CSharpUnresolvedFile);
 					
 					try {
 						//csResolver = astResolver.GetResolverStateBefore (node);

ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngineBase.cs

@@ -494,13 +494,13 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			
 			state.CurrentMember = currentMember;
 			state.CurrentTypeDefinition = currentType;
-			state.CurrentUsingScope = CSharpParsedFile.GetUsingScope (location);
+			state.CurrentUsingScope = CSharpUnresolvedFile.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);
+				var visitor = new ResolveVisitor (state, CSharpUnresolvedFile, navigator);
 				Unit.AcceptVisitor (visitor, null);
 				try {
 					var newState = visitor.GetResolverStateBefore (node);

ICSharpCode.NRefactory.CSharp/Completion/ICompletionContextProvider.cs

@@ -1,4 +1,4 @@
-// 
+// 
 // IMemberProvider.cs
 //  
 // Author:
@@ -45,16 +45,16 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 	public class DefaultCompletionContextProvider : ICompletionContextProvider
 	{
 		readonly IDocument document;
-		readonly CSharpParsedFile parsedFile;
+		readonly CSharpUnresolvedFile unresolvedFile;
 
-		public DefaultCompletionContextProvider (IDocument document, CSharpParsedFile parsedFile)
+		public DefaultCompletionContextProvider (IDocument document, CSharpUnresolvedFile unresolvedFile)
 		{
 			if (document == null)
 				throw new ArgumentNullException("document");
-			if (parsedFile == null)
+			if (unresolvedFile == null)
-				throw new ArgumentNullException("parsedFile");
+				throw new ArgumentNullException("unresolvedFile");
 			this.document = document;
-			this.parsedFile = parsedFile;
+			this.unresolvedFile = unresolvedFile;
 		}
 		
 		public void GetCurrentMembers(int offset, out IUnresolvedTypeDefinition currentType, out IUnresolvedMember currentMember)
@@ -64,7 +64,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 			
 			currentType = null;
 			
-			foreach (var type in parsedFile.TopLevelTypeDefinitions) {
+			foreach (var type in unresolvedFile.TopLevelTypeDefinitions) {
 				if (type.Region.Begin < location)
 					currentType = type;
 			}
@@ -189,7 +189,7 @@ namespace ICSharpCode.NRefactory.CSharp.Completion
 
 		public CSharpAstResolver GetResolver (CSharpResolver resolver, AstNode rootNode)
 		{
-			return new CSharpAstResolver (resolver, rootNode, parsedFile);
+			return new CSharpAstResolver (resolver, rootNode, unresolvedFile);
 		}
 
 

ICSharpCode.NRefactory.CSharp/ICSharpCode.NRefactory.CSharp.csproj

@@ -300,7 +300,7 @@
     <Compile Include="TypeSystem\CSharpAssembly.cs" />
     <Compile Include="TypeSystem\CSharpAttribute.cs" />
     <Compile Include="TypeSystem\CSharpDocumentationComment.cs" />
-    <Compile Include="TypeSystem\CSharpParsedFile.cs" />
+    <Compile Include="TypeSystem\CSharpUnresolvedFile.cs" />
     <Compile Include="TypeSystem\CSharpUnresolvedTypeDefinition.cs" />
     <Compile Include="TypeSystem\CSharpTypeResolveContext.cs" />
     <Compile Include="TypeSystem\ResolvedUsingScope.cs" />

ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs

@@ -64,19 +64,19 @@ namespace ICSharpCode.NRefactory.CSharp
 		/// </summary>
 		/// <param name="syntaxTree">The input syntax tree.</param>
 		/// <param name="compilation">The current compilation.</param>
-		/// <param name="parsedFile">CSharpParsedFile, used for resolving.</param>
+		/// <param name="unresolvedFile">CSharpUnresolvedFile, used for resolving.</param>
 		/// <returns>Converted CodeCompileUnit</returns>
 		/// <remarks>
 		/// This conversion process requires a resolver because it needs to distinguish field/property/event references etc.
 		/// </remarks>
-		public CodeCompileUnit Convert(ICompilation compilation, SyntaxTree syntaxTree, CSharpParsedFile parsedFile)
+		public CodeCompileUnit Convert(ICompilation compilation, SyntaxTree syntaxTree, CSharpUnresolvedFile unresolvedFile)
 		{
 			if (syntaxTree == null)
 				throw new ArgumentNullException("syntaxTree");
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
 			
-			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, parsedFile);
+			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile);
 			return (CodeCompileUnit)Convert(syntaxTree, resolver);
 		}
 		

ICSharpCode.NRefactory.CSharp/Refactoring/BaseRefactoringContext.cs

@@ -72,9 +72,9 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			}
 		}
 
-		public virtual CSharpParsedFile ParsedFile {
+		public virtual CSharpUnresolvedFile UnresolvedFile {
 			get {
-				return resolver.ParsedFile;
+				return resolver.UnresolvedFile;
 			}
 		}
 

ICSharpCode.NRefactory.CSharp/Refactoring/CodeActions/InlineLocalVariableAction.cs

@@ -58,7 +58,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				yield break;
 			}
 			yield return new CodeAction(context.TranslateString("Inline local variable"), script => {
-				refFinder.FindLocalReferences(resolveResult.Variable, context.ParsedFile, unit, context.Compilation, (n, r) => script.Replace(n, initializer.Initializer.Clone()), default(CancellationToken));
+				refFinder.FindLocalReferences(resolveResult.Variable, context.UnresolvedFile, unit, context.Compilation, (n, r) => script.Replace(n, initializer.Initializer.Clone()), default(CancellationToken));
 				script.Remove(node);
 			});
 		}

ICSharpCode.NRefactory.CSharp/Resolver/CSharpAstResolver.cs

@@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	{
 		readonly CSharpResolver initialResolverState;
 		readonly AstNode rootNode;
-		readonly CSharpParsedFile parsedFile;
+		readonly CSharpUnresolvedFile unresolvedFile;
 		readonly ResolveVisitor resolveVisitor;
 		bool resolverInitialized;
 		
@@ -43,19 +43,19 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// </summary>
 		/// <param name="compilation">The current compilation.</param>
 		/// <param name="syntaxTree">The syntax tree corresponding to the specified parsed file.</param>
-		/// <param name="parsedFile">
+		/// <param name="unresolvedFile">
 		/// Optional: Result of the <see cref="TypeSystemConvertVisitor"/> for the file being resolved.
 		/// <para>
 		/// This is used for setting up the context on the resolver. The parsed file must be registered in the compilation.
 		/// </para>
 		/// <para>
-		/// When a parsedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
+		/// When a unresolvedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
 		/// member declarations in the AST with members in the type system.
-		/// When no parsedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
+		/// When no unresolvedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
 		/// member's signature in the AST with the signature in the type system.
 		/// </para>
 		/// </param>
-		public CSharpAstResolver(ICompilation compilation, SyntaxTree syntaxTree, CSharpParsedFile parsedFile = null)
+		public CSharpAstResolver(ICompilation compilation, SyntaxTree syntaxTree, CSharpUnresolvedFile unresolvedFile = null)
 		{
 			if (compilation == null)
 				throw new ArgumentNullException("compilation");
@@ -63,8 +63,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				throw new ArgumentNullException("syntaxTree");
 			this.initialResolverState = new CSharpResolver(compilation);
 			this.rootNode = syntaxTree;
-			this.parsedFile = parsedFile;
+			this.unresolvedFile = unresolvedFile;
-			this.resolveVisitor = new ResolveVisitor(initialResolverState, parsedFile);
+			this.resolveVisitor = new ResolveVisitor(initialResolverState, unresolvedFile);
 		}
 		
 		/// <summary>
@@ -73,19 +73,19 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// </summary>
 		/// <param name="resolver">The resolver state at the root node (to be more precise: just outside the root node).</param>
 		/// <param name="rootNode">The root node of the resolved tree.</param>
-		/// <param name="parsedFile">
+		/// <param name="unresolvedFile">
 		/// Optional: Result of the <see cref="TypeSystemConvertVisitor"/> for the file being resolved.
 		/// <para>
 		/// This is used for setting up the context on the resolver. The parsed file must be registered in the compilation.
 		/// </para>
 		/// <para>
-		/// When a parsedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
+		/// When a unresolvedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
 		/// member declarations in the AST with members in the type system.
-		/// When no parsedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
+		/// When no unresolvedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
 		/// member's signature in the AST with the signature in the type system.
 		/// </para>
 		/// </param>
-		public CSharpAstResolver(CSharpResolver resolver, AstNode rootNode, CSharpParsedFile parsedFile = null)
+		public CSharpAstResolver(CSharpResolver resolver, AstNode rootNode, CSharpUnresolvedFile unresolvedFile = null)
 		{
 			if (resolver == null)
 				throw new ArgumentNullException("resolver");
@@ -93,8 +93,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				throw new ArgumentNullException("rootNode");
 			this.initialResolverState = resolver;
 			this.rootNode = rootNode;
-			this.parsedFile = parsedFile;
+			this.unresolvedFile = unresolvedFile;
-			this.resolveVisitor = new ResolveVisitor(initialResolverState, parsedFile);
+			this.resolveVisitor = new ResolveVisitor(initialResolverState, unresolvedFile);
 		}
 		
 		/// <summary>
@@ -122,8 +122,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// Gets the parsed file used by this CSharpAstResolver.
 		/// Can return null.
 		/// </summary>
-		public CSharpParsedFile ParsedFile {
+		public CSharpUnresolvedFile UnresolvedFile {
-			get { return parsedFile; }
+			get { return unresolvedFile; }
 		}
 		
 		/// <summary>

ICSharpCode.NRefactory.CSharp/Resolver/FindReferences.cs

@@ -290,7 +290,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// <summary>
 		/// Gets the file names that possibly contain references to the element being searched for.
 		/// </summary>
-		public IEnumerable<CSharpParsedFile> GetInterestingFiles(IFindReferenceSearchScope searchScope, ICompilation compilation)
+		public IEnumerable<CSharpUnresolvedFile> GetInterestingFiles(IFindReferenceSearchScope searchScope, ICompilation compilation)
 		{
 			if (searchScope == null)
 				throw new ArgumentNullException("searchScope");
@@ -303,47 +303,47 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				ITypeDefinition topLevelTypeDef = compilation.Import(searchScope.TopLevelTypeDefinition);
 				if (topLevelTypeDef == null) {
 					// This compilation cannot have references to the target entity.
-					return EmptyList<CSharpParsedFile>.Instance;
+					return EmptyList<CSharpUnresolvedFile>.Instance;
 				}
 				switch (searchScope.Accessibility) {
 					case Accessibility.None:
 					case Accessibility.Private:
 						if (topLevelTypeDef.ParentAssembly == compilation.MainAssembly)
-							return topLevelTypeDef.Parts.Select(p => p.ParsedFile).OfType<CSharpParsedFile>().Distinct();
+							return topLevelTypeDef.Parts.Select(p => p.UnresolvedFile).OfType<CSharpUnresolvedFile>().Distinct();
 						else
-							return EmptyList<CSharpParsedFile>.Instance;
+							return EmptyList<CSharpUnresolvedFile>.Instance;
 					case Accessibility.Protected:
 						return GetInterestingFilesProtected(topLevelTypeDef);
 					case Accessibility.Internal:
 						if (topLevelTypeDef.ParentAssembly.InternalsVisibleTo(compilation.MainAssembly))
-							return pc.Files.OfType<CSharpParsedFile>();
+							return pc.Files.OfType<CSharpUnresolvedFile>();
 						else
-							return EmptyList<CSharpParsedFile>.Instance;
+							return EmptyList<CSharpUnresolvedFile>.Instance;
 					case Accessibility.ProtectedAndInternal:
 						if (topLevelTypeDef.ParentAssembly.InternalsVisibleTo(compilation.MainAssembly))
 							return GetInterestingFilesProtected(topLevelTypeDef);
 						else
-							return EmptyList<CSharpParsedFile>.Instance;
+							return EmptyList<CSharpUnresolvedFile>.Instance;
 					case Accessibility.ProtectedOrInternal:
 						if (topLevelTypeDef.ParentAssembly.InternalsVisibleTo(compilation.MainAssembly))
-							return pc.Files.OfType<CSharpParsedFile>();
+							return pc.Files.OfType<CSharpUnresolvedFile>();
 						else
 							return GetInterestingFilesProtected(topLevelTypeDef);
 					default:
-						return pc.Files.OfType<CSharpParsedFile>();
+						return pc.Files.OfType<CSharpUnresolvedFile>();
 				}
 			} else {
-				return pc.Files.OfType<CSharpParsedFile>();
+				return pc.Files.OfType<CSharpUnresolvedFile>();
 			}
 		}
 		
-		IEnumerable<CSharpParsedFile> GetInterestingFilesProtected(ITypeDefinition referencedTypeDefinition)
+		IEnumerable<CSharpUnresolvedFile> GetInterestingFilesProtected(ITypeDefinition referencedTypeDefinition)
 		{
 			return (from typeDef in referencedTypeDefinition.Compilation.MainAssembly.GetAllTypeDefinitions()
 			        where typeDef.IsDerivedFrom(referencedTypeDefinition)
 			        from part in typeDef.Parts
-			        select part.ParsedFile
+			        select part.UnresolvedFile
-			       ).OfType<CSharpParsedFile>().Distinct();
+			       ).OfType<CSharpUnresolvedFile>().Distinct();
 		}
 		#endregion
 		
@@ -352,35 +352,35 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// Finds all references in the given file.
 		/// </summary>
 		/// <param name="searchScope">The search scope for which to look.</param>
-		/// <param name="parsedFile">The type system representation of the file being searched.</param>
+		/// <param name="unresolvedFile">The type system representation of the file being searched.</param>
 		/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
 		/// <param name="compilation">The compilation for the project that contains the file.</param>
 		/// <param name="callback">Callback used to report the references that were found.</param>
 		/// <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
-		public void FindReferencesInFile(IFindReferenceSearchScope searchScope, CSharpParsedFile parsedFile, SyntaxTree syntaxTree,
+		public void FindReferencesInFile(IFindReferenceSearchScope searchScope, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree,
 		                                 ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
 		{
 			if (searchScope == null)
 				throw new ArgumentNullException("searchScope");
-			FindReferencesInFile(new[] { searchScope }, parsedFile, syntaxTree, compilation, callback, cancellationToken);
+			FindReferencesInFile(new[] { searchScope }, unresolvedFile, syntaxTree, compilation, callback, cancellationToken);
 		}
 		
 		/// <summary>
 		/// Finds all references in the given file.
 		/// </summary>
 		/// <param name="searchScopes">The search scopes for which to look.</param>
-		/// <param name="parsedFile">The type system representation of the file being searched.</param>
+		/// <param name="unresolvedFile">The type system representation of the file being searched.</param>
 		/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
 		/// <param name="compilation">The compilation for the project that contains the file.</param>
 		/// <param name="callback">Callback used to report the references that were found.</param>
 		/// <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
-		public void FindReferencesInFile(IList<IFindReferenceSearchScope> searchScopes, CSharpParsedFile parsedFile, SyntaxTree syntaxTree,
+		public void FindReferencesInFile(IList<IFindReferenceSearchScope> searchScopes, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree,
 		                                 ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
 		{
 			if (searchScopes == null)
 				throw new ArgumentNullException("searchScopes");
-			if (parsedFile == null)
+			if (unresolvedFile == null)
-				throw new ArgumentNullException("parsedFile");
+				throw new ArgumentNullException("unresolvedFile");
 			if (syntaxTree == null)
 				throw new ArgumentNullException("syntaxTree");
 			if (compilation == null)
@@ -404,7 +404,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			cancellationToken.ThrowIfCancellationRequested();
 			combinedNavigator = new DetectSkippableNodesNavigator(combinedNavigator, syntaxTree);
 			cancellationToken.ThrowIfCancellationRequested();
-			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, parsedFile);
+			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile);
 			resolver.ApplyNavigator(combinedNavigator, cancellationToken);
 			foreach (var n in navigators) {
 				var frn = n as FindReferenceNavigator;
@@ -1171,19 +1171,19 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// Finds all references of a given variable.
 		/// </summary>
 		/// <param name="variable">The variable for which to look.</param>
-		/// <param name="parsedFile">The type system representation of the file being searched.</param>
+		/// <param name="unresolvedFile">The type system representation of the file being searched.</param>
 		/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
 		/// <param name="compilation">The compilation.</param>
 		/// <param name="callback">Callback used to report the references that were found.</param>
 		/// <param name="cancellationToken">Cancellation token that may be used to cancel the operation.</param>
-		public void FindLocalReferences(IVariable variable, CSharpParsedFile parsedFile, SyntaxTree syntaxTree,
+		public void FindLocalReferences(IVariable variable, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree,
 		                                ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
 		{
 			if (variable == null)
 				throw new ArgumentNullException("variable");
 			var searchScope = new SearchScope(c => new FindLocalReferencesNavigator(variable));
 			searchScope.declarationCompilation = compilation;
-			FindReferencesInFile(searchScope, parsedFile, syntaxTree, compilation, callback, cancellationToken);
+			FindReferencesInFile(searchScope, unresolvedFile, syntaxTree, compilation, callback, cancellationToken);
 		}
 		
 		class FindLocalReferencesNavigator : FindReferenceNavigator
@@ -1225,12 +1225,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// Finds all references of a given type parameter.
 		/// </summary>
 		/// <param name="typeParameter">The type parameter for which to look.</param>
-		/// <param name="parsedFile">The type system representation of the file being searched.</param>
+		/// <param name="unresolvedFile">The type system representation of the file being searched.</param>
 		/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
 		/// <param name="compilation">The compilation.</param>
 		/// <param name="callback">Callback used to report the references that were found.</param>
 		/// <param name="cancellationToken">Cancellation token that may be used to cancel the operation.</param>
-		public void FindTypeParameterReferences(IType typeParameter, CSharpParsedFile parsedFile, SyntaxTree syntaxTree,
+		public void FindTypeParameterReferences(IType typeParameter, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree,
 		                                ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
 		{
 			if (typeParameter == null)
@@ -1240,7 +1240,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			var searchScope = new SearchScope(c => new FindTypeParameterReferencesNavigator((ITypeParameter)typeParameter));
 			searchScope.declarationCompilation = compilation;
 			searchScope.accessibility = Accessibility.Private;
-			FindReferencesInFile(searchScope, parsedFile, syntaxTree, compilation, callback, cancellationToken);
+			FindReferencesInFile(searchScope, unresolvedFile, syntaxTree, compilation, callback, cancellationToken);
 		}
 		
 		class FindTypeParameterReferencesNavigator : FindReferenceNavigator

ICSharpCode.NRefactory.CSharp/Resolver/ResolveAtLocation.cs

@@ -30,24 +30,24 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	/// </summary>
 	public static class ResolveAtLocation
 	{
-		public static ResolveResult Resolve (ICompilation compilation, CSharpParsedFile parsedFile, SyntaxTree syntaxTree, TextLocation location,
+		public static ResolveResult Resolve (ICompilation compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location,
 		                                    CancellationToken cancellationToken = default(CancellationToken))
 		{
-			return Resolve (new Lazy<ICompilation>(() => compilation), parsedFile, syntaxTree, location, cancellationToken);
+			return Resolve (new Lazy<ICompilation>(() => compilation), unresolvedFile, syntaxTree, location, cancellationToken);
 		}
-		public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpParsedFile parsedFile, SyntaxTree syntaxTree, TextLocation location,
+		public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location,
 		                                    CancellationToken cancellationToken = default(CancellationToken))
 		{
 			AstNode node;
-			return Resolve(compilation, parsedFile, syntaxTree, location, out node, cancellationToken);
+			return Resolve(compilation, unresolvedFile, syntaxTree, location, out node, cancellationToken);
 		}
 		
-		public static ResolveResult Resolve (ICompilation compilation, CSharpParsedFile parsedFile, SyntaxTree syntaxTree, TextLocation location, out AstNode node,
+		public static ResolveResult Resolve (ICompilation compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location, out AstNode node,
 		                                    CancellationToken cancellationToken = default(CancellationToken))
 		{
-			return Resolve (new Lazy<ICompilation>(() => compilation), parsedFile, syntaxTree, location, out node, cancellationToken);
+			return Resolve (new Lazy<ICompilation>(() => compilation), unresolvedFile, syntaxTree, location, out node, cancellationToken);
 		}
-		public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpParsedFile parsedFile, SyntaxTree syntaxTree, TextLocation location, out AstNode node,
+		public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location, out AstNode node,
 		                                    CancellationToken cancellationToken = default(CancellationToken))
 		{
 			node = syntaxTree.GetNodeAt(location);
@@ -96,7 +96,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 			
 			// TODO: I think we should provide an overload so that an existing CSharpAstResolver can be reused
-			CSharpAstResolver resolver = new CSharpAstResolver(compilation.Value, syntaxTree, parsedFile);
+			CSharpAstResolver resolver = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile);
 			ResolveResult rr = resolver.Resolve(node, cancellationToken);
 			if (rr is MethodGroupResolveResult && parentInvocation != null)
 				return resolver.Resolve(parentInvocation);

ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

@@ -64,7 +64,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// <remarks>We do not have to put this into the stored state (resolver) because
 		/// query expressions are always resolved in a single operation.</remarks>
 		ResolveResult currentQueryResult;
-		readonly CSharpParsedFile parsedFile;
+		readonly CSharpUnresolvedFile unresolvedFile;
 		readonly Dictionary<AstNode, ResolveResult> resolveResultCache = new Dictionary<AstNode, ResolveResult>();
 		readonly Dictionary<AstNode, CSharpResolver> resolverBeforeDict = new Dictionary<AstNode, CSharpResolver>();
 		readonly Dictionary<AstNode, CSharpResolver> resolverAfterDict = new Dictionary<AstNode, CSharpResolver>();
@@ -93,12 +93,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		/// <summary>
 		/// Creates a new ResolveVisitor instance.
 		/// </summary>
-		public ResolveVisitor(CSharpResolver resolver, CSharpParsedFile parsedFile)
+		public ResolveVisitor(CSharpResolver resolver, CSharpUnresolvedFile unresolvedFile)
 		{
 			if (resolver == null)
 				throw new ArgumentNullException("resolver");
 			this.resolver = resolver;
-			this.parsedFile = parsedFile;
+			this.unresolvedFile = unresolvedFile;
 			this.navigator = skipAllNavigator;
 		}
 		
@@ -534,12 +534,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			CSharpResolver previousResolver = resolver;
 			try {
-				if (parsedFile != null) {
+				if (unresolvedFile != null) {
-					resolver = resolver.WithCurrentUsingScope(parsedFile.RootUsingScope.Resolve(resolver.Compilation));
+					resolver = resolver.WithCurrentUsingScope(unresolvedFile.RootUsingScope.Resolve(resolver.Compilation));
 				} else {
 					var cv = new TypeSystemConvertVisitor(unit.FileName ?? string.Empty);
 					ApplyVisitorToUsings(cv, unit.Children);
-					PushUsingScope(cv.ParsedFile.RootUsingScope);
+					PushUsingScope(cv.UnresolvedFile.RootUsingScope);
 				}
 				ScanChildren(unit);
 				return voidResult;
@@ -567,8 +567,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			CSharpResolver previousResolver = resolver;
 			try {
-				if (parsedFile != null) {
+				if (unresolvedFile != null) {
-					resolver = resolver.WithCurrentUsingScope(parsedFile.GetUsingScope(namespaceDeclaration.StartLocation).Resolve(resolver.Compilation));
+					resolver = resolver.WithCurrentUsingScope(unresolvedFile.GetUsingScope(namespaceDeclaration.StartLocation).Resolve(resolver.Compilation));
 				} else {
 					string fileName = namespaceDeclaration.GetRegion().FileName ?? string.Empty;
 					// Fetch parent using scope
@@ -589,7 +589,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					// Last using scope:
 					usingScope = new UsingScope(resolver.CurrentUsingScope.UnresolvedUsingScope, identifiers.Last().Name);
 					usingScope.Region = region;
-					var cv = new TypeSystemConvertVisitor(new CSharpParsedFile(region.FileName ?? string.Empty), usingScope);
+					var cv = new TypeSystemConvertVisitor(new CSharpUnresolvedFile(region.FileName ?? string.Empty), usingScope);
 					ApplyVisitorToUsings(cv, namespaceDeclaration.Children);
 					PushUsingScope(usingScope);
 				}
@@ -673,7 +673,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			for (AstNode node = fieldOrEventDeclaration.FirstChild; node != null; node = node.NextSibling) {
 				if (node.Role == Roles.Variable) {
 					IMember member;
-					if (parsedFile != null) {
+					if (unresolvedFile != null) {
 						member = GetMemberFromLocation(node);
 					} else {
 						string name = ((VariableInitializer)node).Name;
@@ -699,7 +699,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			TextLocation location = TypeSystemConvertVisitor.GetStartLocationAfterAttributes(node);
 			return typeDef.GetMembers(
 				delegate (IUnresolvedMember m) {
-					if (m.ParsedFile != parsedFile)
+					if (m.UnresolvedFile != unresolvedFile)
 						return false;
 					DomRegion region = m.Region;
 					return !region.IsEmpty && region.Begin <= location && region.End > location;
@@ -792,7 +792,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			CSharpResolver oldResolver = resolver;
 			try {
 				IMember member;
-				if (parsedFile != null) {
+				if (unresolvedFile != null) {
 					member = GetMemberFromLocation(memberDeclaration);
 				} else {
 					// Re-discover the method:
@@ -855,7 +855,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			CSharpResolver oldResolver = resolver;
 			try {
 				IMember member;
-				if (parsedFile != null) {
+				if (unresolvedFile != null) {
 					member = GetMemberFromLocation(propertyOrIndexerDeclaration);
 				} else {
 					// Re-discover the property:
@@ -911,7 +911,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			CSharpResolver oldResolver = resolver;
 			try {
 				IMember member;
-				if (parsedFile != null) {
+				if (unresolvedFile != null) {
 					member = GetMemberFromLocation(eventDeclaration);
 				} else {
 					string name = eventDeclaration.Name;
@@ -1034,7 +1034,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					Scan(attributeSection);
 				
 				IMember member = null;
-				if (parsedFile != null) {
+				if (unresolvedFile != null) {
 					member = GetMemberFromLocation(enumMemberDeclaration);
 				} else if (resolver.CurrentTypeDefinition != null) {
 					string name = enumMemberDeclaration.Name;
@@ -1958,8 +1958,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		DomRegion MakeRegion(AstNode node)
 		{
-			if (parsedFile != null)
+			if (unresolvedFile != null)
-				return new DomRegion(parsedFile.FileName, node.StartLocation, node.EndLocation);
+				return new DomRegion(unresolvedFile.FileName, node.StartLocation, node.EndLocation);
 			else
 				return node.GetRegion();
 		}
@@ -2148,7 +2148,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			readonly QuerySelectClause selectClause;
 			
 			readonly CSharpResolver storedContext;
-			readonly CSharpParsedFile parsedFile;
+			readonly CSharpUnresolvedFile unresolvedFile;
 			readonly List<LambdaTypeHypothesis> hypotheses = new List<LambdaTypeHypothesis>();
 			internal IList<IParameter> parameters = new List<IParameter>();
 			
@@ -2186,7 +2186,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			{
 				this.parentVisitor = parentVisitor;
 				this.storedContext = parentVisitor.resolver;
-				this.parsedFile = parentVisitor.parsedFile;
+				this.unresolvedFile = parentVisitor.unresolvedFile;
 				this.bodyResult = parentVisitor.voidResult;
 			}
 			
@@ -2254,7 +2254,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 					if (ok)
 						return h;
 				}
-				ResolveVisitor visitor = new ResolveVisitor(storedContext, parsedFile);
+				ResolveVisitor visitor = new ResolveVisitor(storedContext, unresolvedFile);
 				var newHypothesis = new LambdaTypeHypothesis(this, parameterTypes, visitor, lambda != null ? lambda.Parameters : null);
 				hypotheses.Add(newHypothesis);
 				return newHypothesis;

ICSharpCode.NRefactory.CSharp/TypeSystem/CSharpAssembly.cs

@@ -73,9 +73,9 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 				return result;
 			} else {
 				result = new List<IAttribute>();
-				foreach (var parsedFile in projectContent.Files.OfType<CSharpParsedFile>()) {
+				foreach (var unresolvedFile in projectContent.Files.OfType<CSharpUnresolvedFile>()) {
-					var attributes = assemblyAttributes ? parsedFile.AssemblyAttributes : parsedFile.ModuleAttributes;
+					var attributes = assemblyAttributes ? unresolvedFile.AssemblyAttributes : unresolvedFile.ModuleAttributes;
-					var context = new CSharpTypeResolveContext(this, parsedFile.RootUsingScope.Resolve(compilation));
+					var context = new CSharpTypeResolveContext(this, unresolvedFile.RootUsingScope.Resolve(compilation));
 					foreach (var unresolvedAttr in attributes) {
 						result.Add(unresolvedAttr.CreateResolvedAttribute(context));
 					}

ICSharpCode.NRefactory.CSharp/TypeSystem/CSharpUnresolvedFile.cs

@@ -30,7 +30,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 	/// Represents a file that was parsed and converted for the type system.
 	/// </summary>
 	[Serializable]
-	public sealed class CSharpParsedFile : AbstractFreezable, IParsedFile, IUnresolvedDocumentationProvider
+	public sealed class CSharpUnresolvedFile : AbstractFreezable, IUnresolvedFile, IUnresolvedDocumentationProvider
 	{
 		readonly string fileName;
 		readonly UsingScope rootUsingScope;
@@ -51,7 +51,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			usingScopes = FreezableHelper.FreezeListAndElements(usingScopes);
 		}
 		
-		public CSharpParsedFile(string fileName)
+		public CSharpUnresolvedFile(string fileName)
 		{
 			if (fileName == null)
 				throw new ArgumentNullException("fileName");
@@ -59,7 +59,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			this.rootUsingScope = new UsingScope();
 		}
 		
-		public CSharpParsedFile(string fileName, UsingScope rootUsingScope)
+		public CSharpUnresolvedFile(string fileName, UsingScope rootUsingScope)
 		{
 			if (fileName == null)
 				throw new ArgumentNullException("fileName");
@@ -178,7 +178,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			return rctx;
 		}
 		
-		ITypeResolveContext IParsedFile.GetTypeResolveContext (ICompilation compilation, TextLocation loc)
+		ITypeResolveContext IUnresolvedFile.GetTypeResolveContext (ICompilation compilation, TextLocation loc)
 		{
 			return GetTypeResolveContext (compilation, loc);
 		}

ICSharpCode.NRefactory.CSharp/TypeSystem/TypeSystemConvertVisitor.cs

@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 	/// </summary>
 	public class TypeSystemConvertVisitor : DepthFirstAstVisitor<IUnresolvedEntity>
 	{
-		readonly CSharpParsedFile parsedFile;
+		readonly CSharpUnresolvedFile unresolvedFile;
 		UsingScope usingScope;
 		CSharpUnresolvedTypeDefinition currentTypeDefinition;
 		DefaultUnresolvedMethod currentMethod;
@@ -64,32 +64,32 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 		{
 			if (fileName == null)
 				throw new ArgumentNullException("fileName");
-			this.parsedFile = new CSharpParsedFile(fileName);
+			this.unresolvedFile = new CSharpUnresolvedFile(fileName);
-			this.usingScope = parsedFile.RootUsingScope;
+			this.usingScope = unresolvedFile.RootUsingScope;
 		}
 		
 		/// <summary>
 		/// Creates a new TypeSystemConvertVisitor and initializes it with a given context.
 		/// </summary>
-		/// <param name="parsedFile">The parsed file to which members should be added.</param>
+		/// <param name="unresolvedFile">The parsed file to which members should be added.</param>
 		/// <param name="currentUsingScope">The current using scope.</param>
 		/// <param name="currentTypeDefinition">The current type definition.</param>
-		public TypeSystemConvertVisitor(CSharpParsedFile parsedFile, UsingScope currentUsingScope = null, CSharpUnresolvedTypeDefinition currentTypeDefinition = null)
+		public TypeSystemConvertVisitor(CSharpUnresolvedFile unresolvedFile, UsingScope currentUsingScope = null, CSharpUnresolvedTypeDefinition currentTypeDefinition = null)
 		{
-			if (parsedFile == null)
+			if (unresolvedFile == null)
-				throw new ArgumentNullException("parsedFile");
+				throw new ArgumentNullException("unresolvedFile");
-			this.parsedFile = parsedFile;
+			this.unresolvedFile = unresolvedFile;
-			this.usingScope = currentUsingScope ?? parsedFile.RootUsingScope;
+			this.usingScope = currentUsingScope ?? unresolvedFile.RootUsingScope;
 			this.currentTypeDefinition = currentTypeDefinition;
 		}
 		
-		public CSharpParsedFile ParsedFile {
+		public CSharpUnresolvedFile UnresolvedFile {
-			get { return parsedFile; }
+			get { return unresolvedFile; }
 		}
 		
 		DomRegion MakeRegion(TextLocation start, TextLocation end)
 		{
-			return new DomRegion(parsedFile.FileName, start.Line, start.Column, end.Line, end.Column);
+			return new DomRegion(unresolvedFile.FileName, start.Line, start.Column, end.Line, end.Column);
 		}
 		
 		DomRegion MakeRegion(AstNode node)
@@ -122,7 +122,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 		#region Compilation Unit
 		public override IUnresolvedEntity VisitSyntaxTree (SyntaxTree unit)
 		{
-			parsedFile.Errors = unit.Errors;
+			unresolvedFile.Errors = unit.Errors;
 			return base.VisitSyntaxTree (unit);
 		}
 		#endregion
@@ -167,7 +167,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 				usingScope.Region = region;
 			}
 			base.VisitNamespaceDeclaration(namespaceDeclaration);
-			parsedFile.UsingScopes.Add(usingScope); // add after visiting children so that nested scopes come first
+			unresolvedFile.UsingScopes.Add(usingScope); // add after visiting children so that nested scopes come first
 			usingScope = previousUsingScope;
 			return null;
 		}
@@ -184,9 +184,9 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 				currentTypeDefinition.NestedTypes.Add(newType);
 			} else {
 				newType = new CSharpUnresolvedTypeDefinition(usingScope, name);
-				parsedFile.TopLevelTypeDefinitions.Add(newType);
+				unresolvedFile.TopLevelTypeDefinitions.Add(newType);
 			}
-			newType.ParsedFile = parsedFile;
+			newType.UnresolvedFile = unresolvedFile;
 			newType.HasExtensionMethods = false; // gets set to true when an extension method is added
 			return newType;
 		}
@@ -868,9 +868,9 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 		{
 			// non-assembly attributes are handled by their parent entity
 			if (attributeSection.AttributeTarget == "assembly") {
-				ConvertAttributes(parsedFile.AssemblyAttributes, attributeSection);
+				ConvertAttributes(unresolvedFile.AssemblyAttributes, attributeSection);
 			} else if (attributeSection.AttributeTarget == "module") {
-				ConvertAttributes(parsedFile.ModuleAttributes, attributeSection);
+				ConvertAttributes(unresolvedFile.ModuleAttributes, attributeSection);
 			}
 			return null;
 		}
@@ -1197,7 +1197,7 @@ namespace ICSharpCode.NRefactory.CSharp.TypeSystem
 			}
 			if (documentation != null) {
 				documentation.Reverse(); // bring documentation in correct order
-				parsedFile.AddDocumentation(entity, string.Join(Environment.NewLine, documentation));
+				unresolvedFile.AddDocumentation(entity, string.Join(Environment.NewLine, documentation));
 			}
 		}
 		

ICSharpCode.NRefactory.ConsistencyCheck/CSharpProject.cs

@@ -91,13 +91,13 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			if (!hasSystemCore && FindAssembly(Program.AssemblySearchPaths, "System.Core") != null)
 				references.Add(Program.LoadAssembly(FindAssembly(Program.AssemblySearchPaths, "System.Core")));
 			foreach (var item in p.GetItems("ProjectReference")) {
-				references.Add(new ProjectReference(solution, item.GetMetadataValue("Name")));
+				references.Add(new ProjectReference(item.EvaluatedInclude));
 			}
 			this.ProjectContent = new CSharpProjectContent()
 				.SetAssemblyName(this.AssemblyName)
 				.SetCompilerSettings(this.CompilerSettings)
 				.AddAssemblyReferences(references)
-				.UpdateProjectContent(null, Files.Select(f => f.ParsedFile));
+				.AddOrUpdateFiles(Files.Select(f => f.UnresolvedFile));
 		}
 		
 		string FindAssembly(IEnumerable<string> assemblySearchPaths, string evaluatedInclude)
@@ -133,24 +133,6 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 		}
 	}
 	
-	public class ProjectReference : IAssemblyReference
-	{
-		readonly Solution solution;
-		readonly string projectTitle;
-		
-		public ProjectReference(Solution solution, string projectTitle)
-		{
-			this.solution = solution;
-			this.projectTitle = projectTitle;
-		}
-		
-		public IAssembly Resolve(ITypeResolveContext context)
-		{
-			var project = solution.Projects.Single(p => string.Equals(p.Title, projectTitle, StringComparison.OrdinalIgnoreCase));
-			return project.ProjectContent.Resolve(context);
-		}
-	}
-	
 	public class CSharpFile
 	{
 		public readonly CSharpProject Project;
@@ -159,7 +141,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 		public readonly ITextSource Content;
 		public readonly int LinesOfCode;
 		public SyntaxTree SyntaxTree;
-		public CSharpParsedFile ParsedFile;
+		public CSharpUnresolvedFile UnresolvedFile;
 		
 		public CSharpFile(CSharpProject project, string fileName)
 		{
@@ -176,7 +158,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 					Console.WriteLine("  " + error.Region + " " + error.Message);
 				}
 			}
-			this.ParsedFile = this.SyntaxTree.ToTypeSystem();
+			this.UnresolvedFile = this.SyntaxTree.ToTypeSystem();
 		}
 	}
 }

ICSharpCode.NRefactory.ConsistencyCheck/FindReferencesConsistencyCheck.cs

@@ -59,7 +59,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 							}
 						}
 					);
-					var resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.ParsedFile);
+					var resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedFile);
 					resolver.ApplyNavigator(navigator);
 				}
 			}
@@ -102,9 +102,9 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 				HashSet<AstNode> foundReferences = new HashSet<AstNode>();
 				var interestingFiles = new HashSet<CSharpFile>();
 				foreach (var searchScope in searchScopes) {
-					foreach (var parsedFile in fr.GetInterestingFiles(searchScope, project.Compilation)) {
+					foreach (var unresolvedFile in fr.GetInterestingFiles(searchScope, project.Compilation)) {
-						var file = project.GetFile(parsedFile.FileName);
+						var file = project.GetFile(unresolvedFile.FileName);
-						Debug.Assert(file.ParsedFile == parsedFile);
+						Debug.Assert(file.UnresolvedFile == unresolvedFile);
 						
 						// Skip file if it doesn't contain the search term
 						if (searchScope.SearchTerm != null && file.Content.IndexOf(searchScope.SearchTerm, 0, file.Content.TextLength, StringComparison.Ordinal) < 0)
@@ -114,7 +114,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 					}
 				}
 				foreach (var file in interestingFiles) {
-					fr.FindReferencesInFile(searchScopes, file.ParsedFile, file.SyntaxTree, project.Compilation,
+					fr.FindReferencesInFile(searchScopes, file.UnresolvedFile, file.SyntaxTree, project.Compilation,
 					                        delegate(AstNode node, ResolveResult result) {
 					                        	foundReferences.Add(node);
 					                        }, CancellationToken.None);

ICSharpCode.NRefactory.ConsistencyCheck/Program.cs

@@ -63,7 +63,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			using (new Timer("Resolve unresolved members... ")) TypeSystemTests.ResolvedUnresolvedMembers(solution);
 			//RunTestOnAllFiles("Roundtripping test", RoundtripTest.RunTest);
 			RunTestOnAllFiles("Resolver test", ResolverTest.RunTest);
-			RunTestOnAllFiles("Resolver test (no parsed file)", ResolverTest.RunTestWithoutParsedFile);
+			RunTestOnAllFiles("Resolver test (no parsed file)", ResolverTest.RunTestWithoutUnresolvedFile);
 			RunTestOnAllFiles("Resolver test (randomized order)", RandomizedOrderResolverTest.RunTest);
 			new FindReferencesConsistencyCheck(solution).Run();
 			

ICSharpCode.NRefactory.ConsistencyCheck/RandomizedOrderResolverTest.cs

@@ -45,9 +45,9 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			Random rnd = new Random(seed);
 			var test = new RandomizedOrderResolverTest();
 			// Resolve all nodes, but in a random order without using a navigator.
-			test.resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.ParsedFile);
+			test.resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedFile);
 			// For comparing whether the results are equivalent, we also use a normal 'resolve all' resolver:
-			test.resolveAllResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.ParsedFile);
+			test.resolveAllResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedFile);
 			test.resolveAllResolver.ApplyNavigator(new ResolveAllNavigator(), CancellationToken.None);
 			// Prepare list of actions that we need to verify:
 			var actions = new List<Func<bool>>();

ICSharpCode.NRefactory.ConsistencyCheck/ResolverTest.cs

@@ -35,7 +35,7 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 	{
 		public static void RunTest(CSharpFile file)
 		{
-			CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.ParsedFile);
+			CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedFile);
 			var navigator = new ValidatingResolveAllNavigator(file.FileName);
 			resolver.ApplyNavigator(navigator, CancellationToken.None);
 			navigator.Validate(resolver, file.SyntaxTree);
@@ -102,19 +102,19 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			}
 		}
 		
-		public static void RunTestWithoutParsedFile(CSharpFile file)
+		public static void RunTestWithoutUnresolvedFile(CSharpFile file)
 		{
 			CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree);
 			var navigator = new ValidatingResolveAllNavigator(file.FileName);
 			resolver.ApplyNavigator(navigator, CancellationToken.None);
 			navigator.Validate(resolver, file.SyntaxTree);
 			
-			CSharpAstResolver originalResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.ParsedFile);
+			CSharpAstResolver originalResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedFile);
 			foreach (var node in file.SyntaxTree.DescendantsAndSelf) {
 				var originalResult = originalResolver.Resolve(node);
 				var result = resolver.Resolve(node);
 				if (!RandomizedOrderResolverTest.IsEqualResolveResult(result, originalResult)) {
-					Console.WriteLine("Got different without IParsedFile at " + file.FileName + ":" + node.StartLocation);
+					Console.WriteLine("Got different without IUnresolvedFile at " + file.FileName + ":" + node.StartLocation);
 				}
 			}
 		}

ICSharpCode.NRefactory.ConsistencyCheck/VisitorBenchmark.cs

@@ -50,11 +50,6 @@ namespace ICSharpCode.NRefactory.ConsistencyCheck
 			        	visitor.EnterIdentifierExpression += list.Add;
 			        	syntaxTree.AcceptVisitor(visitor);
 			        });
-			RunTest("ObservableAstVisitor<object, object>", files, (syntaxTree, list) => {
-			        	var visitor = new ObservableAstVisitor<object, object>();
-			        	visitor.IdentifierExpressionVisited += (id, data) => list.Add(id);
-			        	syntaxTree.AcceptVisitor(visitor, null);
-			        });
 		}
 		
 		static void WalkTreeForEach(AstNode node, List<IdentifierExpression> list)

ICSharpCode.NRefactory.Demo/CSDemo.cs

@@ -204,8 +204,8 @@ namespace ICSharpCode.NRefactory.Demo
 		void ResolveButtonClick(object sender, EventArgs e)
 		{
 			IProjectContent project = new CSharpProjectContent();
-			var parsedFile = syntaxTree.ToTypeSystem();
+			var unresolvedFile = syntaxTree.ToTypeSystem();
-			project = project.UpdateProjectContent(null, parsedFile);
+			project = project.AddOrUpdateFiles(unresolvedFile);
 			project = project.AddAssemblyReferences(builtInLibs.Value);
 			
 			ICompilation compilation = project.CreateCompilation();
@@ -213,12 +213,12 @@ namespace ICSharpCode.NRefactory.Demo
 			ResolveResult result;
 			if (csharpTreeView.SelectedNode != null) {
 				var selectedNode = (AstNode)csharpTreeView.SelectedNode.Tag;
-				CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, parsedFile);
+				CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile);
 				result = resolver.Resolve(selectedNode);
 				// CSharpAstResolver.Resolve() never returns null
 			} else {
 				TextLocation location = GetTextLocation(csharpCodeTextBox, csharpCodeTextBox.SelectionStart);
-				result = ResolveAtLocation.Resolve(compilation, parsedFile, syntaxTree, location);
+				result = ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, location);
 				if (result == null) {
 					MessageBox.Show("Could not find a resolvable node at the caret location.");
 					return;
@@ -248,12 +248,12 @@ namespace ICSharpCode.NRefactory.Demo
 				return;
 			
 			IProjectContent project = new CSharpProjectContent();
-			var parsedFile = syntaxTree.ToTypeSystem();
+			var unresolvedFile = syntaxTree.ToTypeSystem();
-			project = project.UpdateProjectContent(null, parsedFile);
+			project = project.AddOrUpdateFiles(unresolvedFile);
 			project = project.AddAssemblyReferences(builtInLibs.Value);
 			
 			ICompilation compilation = project.CreateCompilation();
-			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, parsedFile);
+			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile);
 			
 			AstNode node = (AstNode)csharpTreeView.SelectedNode.Tag;
 			IEntity entity;
@@ -276,7 +276,7 @@ namespace ICSharpCode.NRefactory.Demo
 			
 			var searchScopes = fr.GetSearchScopes(entity);
 			Debug.WriteLine("Find references to " + entity.ReflectionName);
-			fr.FindReferencesInFile(searchScopes, parsedFile, syntaxTree, compilation, callback, CancellationToken.None);
+			fr.FindReferencesInFile(searchScopes, unresolvedFile, syntaxTree, compilation, callback, CancellationToken.None);
 			
 			MessageBox.Show("Found " + referenceCount + " references to " + entity.FullName);
 		}

ICSharpCode.NRefactory.GtkDemo/MainWindow.cs

@@ -223,14 +223,14 @@ namespace ICSharpCode.NRefactory.GtkDemo
 			var parser = new CSharpParser ();
 			var unit = parser.Parse (textview1.Buffer.Text, "dummy.cs");
 			
-			var parsedFile = unit.ToTypeSystem();
+			var unresolvedFile = unit.ToTypeSystem();
 			
 			IProjectContent project = new CSharpProjectContent ();
-			project = project.UpdateProjectContent (null, parsedFile);
+			project = project.AddOrUpdateFiles (unresolvedFile);
 			project = project.AddAssemblyReferences (builtInLibs.Value);
 			
 			
-			CSharpAstResolver resolver = new CSharpAstResolver(project.CreateCompilation (), unit, parsedFile);
+			CSharpAstResolver resolver = new CSharpAstResolver(project.CreateCompilation (), unit, unresolvedFile);
 			ShowUnit (unit, resolver);
 			
 		}

ICSharpCode.NRefactory.Tests/CSharp/CodeActions/TestRefactoringContext.cs

@@ -158,7 +158,7 @@ namespace ICSharpCode.NRefactory.CSharp.CodeActions
 			{
 				FindReferences refFinder = new FindReferences ();
 				refFinder.FindReferencesInFile (refFinder.GetSearchScopes (entity), 
-				                               context.ParsedFile, 
+				                               context.UnresolvedFile, 
 				                               context.RootNode as SyntaxTree, 
 				                               context.Compilation, (n, r) => Rename (n, name), 
 				                               context.CancellationToken);
@@ -168,7 +168,7 @@ namespace ICSharpCode.NRefactory.CSharp.CodeActions
 			{
 				FindReferences refFinder = new FindReferences ();
 				refFinder.FindLocalReferences (variable, 
-				                               context.ParsedFile, 
+				                               context.UnresolvedFile, 
 				                               context.RootNode as SyntaxTree, 
 				                               context.Compilation, (n, r) => Rename (n, name), 
 				                               context.CancellationToken);
@@ -178,7 +178,7 @@ namespace ICSharpCode.NRefactory.CSharp.CodeActions
 			{
 				FindReferences refFinder = new FindReferences ();
 				refFinder.FindTypeParameterReferences (type, 
-				                               context.ParsedFile, 
+				                               context.UnresolvedFile, 
 				                               context.RootNode as SyntaxTree, 
 				                               context.Compilation, (n, r) => Rename (n, name), 
 				                               context.CancellationToken);
@@ -258,14 +258,14 @@ namespace ICSharpCode.NRefactory.CSharp.CodeActions
 				Console.WriteLine (error.Message);
 			Assert.IsFalse (parser.HasErrors, "File contains parsing errors.");
 			unit.Freeze ();
-			var parsedFile = unit.ToTypeSystem ();
+			var unresolvedFile = unit.ToTypeSystem ();
 			
 			IProjectContent pc = new CSharpProjectContent ();
-			pc = pc.UpdateProjectContent (null, parsedFile);
+			pc = pc.AddOrUpdateFiles (unresolvedFile);
 			pc = pc.AddAssemblyReferences (new[] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore });
 			
 			var compilation = pc.CreateCompilation ();
-			var resolver = new CSharpAstResolver (compilation, unit, parsedFile);
+			var resolver = new CSharpAstResolver (compilation, unit, unresolvedFile);
 			TextLocation location = TextLocation.Empty;
 			if (idx >= 0)
 				location = doc.GetLocation (idx);

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

@@ -225,16 +225,16 @@ namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 			var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs");
 			syntaxTree.Freeze();
 
-			var parsedFile = syntaxTree.ToTypeSystem();
+			var unresolvedFile = syntaxTree.ToTypeSystem();
-			pctx = pctx.UpdateProjectContent(null, parsedFile);
+			pctx = pctx.AddOrUpdateFiles(unresolvedFile);
 
 			var cmp = pctx.CreateCompilation();
 			var loc = cursorPosition > 0 ? doc.GetLocation(cursorPosition) : new TextLocation (1, 1);
 
 			var rctx = new CSharpTypeResolveContext(cmp.MainAssembly);
-			rctx = rctx.WithUsingScope(parsedFile.GetUsingScope(loc).Resolve(cmp));
+			rctx = rctx.WithUsingScope(unresolvedFile.GetUsingScope(loc).Resolve(cmp));
 
-			var curDef = parsedFile.GetInnermostTypeDefinition(loc);
+			var curDef = unresolvedFile.GetInnermostTypeDefinition(loc);
 			if (curDef != null) {
 					var resolvedDef = curDef.Resolve(rctx).GetDefinition();
 					rctx = rctx.WithCurrentTypeDefinition(resolvedDef);
@@ -243,7 +243,7 @@ namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 							rctx = rctx.WithCurrentMember(curMember);
 					}
 			}
-			var mb = new DefaultCompletionContextProvider(doc, parsedFile);
+			var mb = new DefaultCompletionContextProvider(doc, unresolvedFile);
 			var engine = new CSharpCompletionEngine(doc, mb, new TestFactory(), pctx, rctx);
 
 			engine.EolMarker = Environment.NewLine;
@@ -270,12 +270,12 @@ namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 			var doc = new ReadOnlyDocument(text);
 			IProjectContent pctx = new CSharpProjectContent();
 			pctx = pctx.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore });
-			var parsedFile = syntaxTree.ToTypeSystem();
+			var unresolvedFile = syntaxTree.ToTypeSystem();
 			
-			pctx = pctx.UpdateProjectContent(null, parsedFile);
+			pctx = pctx.AddOrUpdateFiles(unresolvedFile);
 			var cmp = pctx.CreateCompilation();
 			
-			var mb = new DefaultCompletionContextProvider(doc, parsedFile);
+			var mb = new DefaultCompletionContextProvider(doc, unresolvedFile);
 			var engine = new CSharpCompletionEngine (doc, mb, new TestFactory (), pctx, new CSharpTypeResolveContext (cmp.MainAssembly));
 			engine.EolMarker = Environment.NewLine;
 			engine.FormattingPolicy = FormattingOptionsFactory.CreateMono ();

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

@@ -275,23 +275,23 @@ namespace ICSharpCode.NRefactory.CSharp.CodeCompletion
 			var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs");
 			syntaxTree.Freeze();
 			
-			var parsedFile = syntaxTree.ToTypeSystem();
+			var unresolvedFile = syntaxTree.ToTypeSystem();
-			pctx = pctx.UpdateProjectContent(null, parsedFile);
+			pctx = pctx.AddOrUpdateFiles(unresolvedFile);
 			var cmp = pctx.CreateCompilation();
 			var loc = doc.GetLocation(cursorPosition);
 			
 			
 			var rctx = new CSharpTypeResolveContext(cmp.MainAssembly);
-			rctx = rctx.WithUsingScope(parsedFile.GetUsingScope(loc).Resolve(cmp));
+			rctx = rctx.WithUsingScope(unresolvedFile.GetUsingScope(loc).Resolve(cmp));
-			var curDef = parsedFile.GetInnermostTypeDefinition(loc);
+			var curDef = unresolvedFile.GetInnermostTypeDefinition(loc);
 			if (curDef != null) {
 				rctx = rctx.WithCurrentTypeDefinition(curDef.Resolve(rctx).GetDefinition());
-				var curMember = parsedFile.GetMember(loc);
+				var curMember = unresolvedFile.GetMember(loc);
 				if (curMember != null) {
 					rctx = rctx.WithCurrentMember(curMember.CreateResolved(rctx));
 				}
 			}
-			var mb = new DefaultCompletionContextProvider(doc, parsedFile);
+			var mb = new DefaultCompletionContextProvider(doc, unresolvedFile);
 			var engine = new CSharpParameterCompletionEngine (doc, mb, new TestFactory (pctx), pctx, rctx);
 			return engine.GetParameterDataProvider (cursorPosition, doc.GetCharAt (cursorPosition - 1));
 		}

ICSharpCode.NRefactory.Tests/CSharp/CodeDomConvertVisitorTests.cs

@@ -34,15 +34,15 @@ namespace ICSharpCode.NRefactory.CSharp
 	public class CodeDomConvertVisitorTests : ResolverTestBase
 	{
 		CodeDomConvertVisitor convertVisitor;
-		CSharpParsedFile parsedFile;
+		CSharpUnresolvedFile unresolvedFile;
 		
 		public override void SetUp()
 		{
 			base.SetUp();
-			parsedFile = new CSharpParsedFile("test.cs");
+			unresolvedFile = new CSharpUnresolvedFile("test.cs");
-			parsedFile.RootUsingScope.Usings.Add(MakeReference("System"));
+			unresolvedFile.RootUsingScope.Usings.Add(MakeReference("System"));
-			parsedFile.RootUsingScope.Usings.Add(MakeReference("System.Collections.Generic"));
+			unresolvedFile.RootUsingScope.Usings.Add(MakeReference("System.Collections.Generic"));
-			parsedFile.RootUsingScope.Usings.Add(MakeReference("System.Linq"));
+			unresolvedFile.RootUsingScope.Usings.Add(MakeReference("System.Linq"));
 			
 			convertVisitor = new CodeDomConvertVisitor();
 			convertVisitor.AllowSnippetNodes = false;
@@ -53,7 +53,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		string ConvertHelper(AstNode node, Action<CSharpCodeProvider, CodeObject, TextWriter, CodeGeneratorOptions> action)
 		{
 			CSharpResolver resolver = new CSharpResolver(compilation);
-			resolver = resolver.WithCurrentUsingScope(parsedFile.RootUsingScope.Resolve(compilation));
+			resolver = resolver.WithCurrentUsingScope(unresolvedFile.RootUsingScope.Resolve(compilation));
 			resolver = resolver.WithCurrentTypeDefinition(compilation.FindType(KnownTypeCode.Object).GetDefinition());
 			var codeObj = convertVisitor.Convert(node, new CSharpAstResolver(resolver, node));
 			

ICSharpCode.NRefactory.Tests/CSharp/Parser/ParseSelfTests.cs

@@ -54,15 +54,15 @@ namespace ICSharpCode.NRefactory.CSharp.Parser
 				using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan)) {
 					syntaxTree = parser.Parse(fs, fileName);
 				}
-				var parsedFile = syntaxTree.ToTypeSystem();
+				var unresolvedFile = syntaxTree.ToTypeSystem();
-				foreach (var td in parsedFile.GetAllTypeDefinitions()) {
+				foreach (var td in unresolvedFile.GetAllTypeDefinitions()) {
-					Assert.AreSame(parsedFile, td.ParsedFile);
+					Assert.AreSame(unresolvedFile, td.UnresolvedFile);
 					foreach (var member in td.Members) {
-						Assert.AreSame(parsedFile, member.ParsedFile);
+						Assert.AreSame(unresolvedFile, member.UnresolvedFile);
 						Assert.AreSame(td, member.DeclaringTypeDefinition);
 					}
 				}
-				pc = pc.UpdateProjectContent(null, parsedFile);
+				pc = pc.AddOrUpdateFiles(unresolvedFile);
 			}
 		}
 		

ICSharpCode.NRefactory.Tests/CSharp/Parser/TypeSystemConvertVisitorTests.cs

@@ -47,9 +47,9 @@ namespace ICSharpCode.NRefactory.CSharp.Parser
 				syntaxTree = parser.Parse(s, fileName);
 			}
 			
-			var parsedFile = syntaxTree.ToTypeSystem();
+			var unresolvedFile = syntaxTree.ToTypeSystem();
 			return new CSharpProjectContent()
-				.UpdateProjectContent(null, parsedFile)
+				.AddOrUpdateFiles(unresolvedFile)
 				.AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib })
 				.SetAssemblyName(typeof(TypeSystemTests).Assembly.GetName().Name);
 		}

ICSharpCode.NRefactory.Tests/CSharp/Refactoring/TypeSystemAstBuilderTests.cs

@@ -56,15 +56,15 @@ namespace OtherNS {
 		IProjectContent pc;
 		ICompilation compilation;
 		ITypeDefinition baseClass, derivedClass, nestedClass, systemClass;
-		CSharpParsedFile parsedFile;
+		CSharpUnresolvedFile unresolvedFile;
 		
 		[SetUp]
 		public void SetUp()
 		{
 			pc = new CSharpProjectContent();
 			pc = pc.SetAssemblyName("MyAssembly");
-			parsedFile = SyntaxTree.Parse(program, "program.cs").ToTypeSystem();
+			unresolvedFile = SyntaxTree.Parse(program, "program.cs").ToTypeSystem();
-			pc = pc.UpdateProjectContent(null, parsedFile);
+			pc = pc.AddOrUpdateFiles(unresolvedFile);
 			pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib });
 			
 			compilation = pc.CreateCompilation();
@@ -77,7 +77,7 @@ namespace OtherNS {
 		
 		TypeSystemAstBuilder CreateBuilder(ITypeDefinition currentTypeDef = null)
 		{
-			UsingScope usingScope = currentTypeDef != null ? parsedFile.GetUsingScope(currentTypeDef.Region.Begin) : parsedFile.RootUsingScope;
+			UsingScope usingScope = currentTypeDef != null ? unresolvedFile.GetUsingScope(currentTypeDef.Region.Begin) : unresolvedFile.RootUsingScope;
 			return new TypeSystemAstBuilder(new CSharpResolver(
 				new CSharpTypeResolveContext(compilation.MainAssembly, usingScope.Resolve(compilation), currentTypeDef)));
 		}

ICSharpCode.NRefactory.Tests/CSharp/Resolver/FindReferencesTest.cs

@@ -31,15 +31,15 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 	public class FindReferencesTest
 	{
 		SyntaxTree syntaxTree;
-		CSharpParsedFile parsedFile;
+		CSharpUnresolvedFile unresolvedFile;
 		ICompilation compilation;
 		FindReferences findReferences;
 		
 		void Init(string code)
 		{
 			syntaxTree = SyntaxTree.Parse(code, "test.cs");
-			parsedFile = syntaxTree.ToTypeSystem();
+			unresolvedFile = syntaxTree.ToTypeSystem();
-			compilation = TypeSystemHelper.CreateCompilation(parsedFile);
+			compilation = TypeSystemHelper.CreateCompilation(unresolvedFile);
 			findReferences = new FindReferences();
 		}
 		
@@ -47,7 +47,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			var result = new List<AstNode>();
 			var searchScopes = findReferences.GetSearchScopes(entity);
-			findReferences.FindReferencesInFile(searchScopes, parsedFile, syntaxTree, compilation,
+			findReferences.FindReferencesInFile(searchScopes, unresolvedFile, syntaxTree, compilation,
 			                                    (node, rr) => result.Add(node), CancellationToken.None);
 			return result.OrderBy(n => n.StartLocation).ToArray();
 		}

ICSharpCode.NRefactory.Tests/CSharp/Resolver/MemberLookupTests.cs

@@ -38,13 +38,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			lookup = new MemberLookup(null, compilation.MainAssembly);
 		}
 		
-		CSharpParsedFile Parse(string program)
+		CSharpUnresolvedFile Parse(string program)
 		{
 			SyntaxTree syntaxTree = SyntaxTree.Parse(program, "test.cs");
-			CSharpParsedFile parsedFile = syntaxTree.ToTypeSystem();
+			CSharpUnresolvedFile unresolvedFile = syntaxTree.ToTypeSystem();
-			project = project.UpdateProjectContent(null, parsedFile);
+			project = project.AddOrUpdateFiles(unresolvedFile);
 			compilation = project.CreateCompilation();
-			return parsedFile;
+			return unresolvedFile;
 		}
 		
 		[Test]
@@ -60,8 +60,8 @@ class Middle : Base {
 class Derived : Middle {
 	public override void Method() {}
 }";
-			var parsedFile = Parse(program);
+			var unresolvedFile = Parse(program);
-			ITypeDefinition derived = compilation.MainAssembly.GetTypeDefinition(parsedFile.TopLevelTypeDefinitions[2]);
+			ITypeDefinition derived = compilation.MainAssembly.GetTypeDefinition(unresolvedFile.TopLevelTypeDefinitions[2]);
 			var rr = lookup.Lookup(new ResolveResult(derived), "Method", EmptyList<IType>.Instance, true) as MethodGroupResolveResult;
 			Assert.AreEqual(2, rr.MethodsGroupedByDeclaringType.Count());
 			
@@ -87,8 +87,8 @@ class Derived : Base<int> {
 	public override void Method(int a) {}
 	public override void Method(string a) {}
 }";
-			var parsedFile = Parse(program);
+			var unresolvedFile = Parse(program);
-			ITypeDefinition derived = compilation.MainAssembly.GetTypeDefinition(parsedFile.TopLevelTypeDefinitions[1]);
+			ITypeDefinition derived = compilation.MainAssembly.GetTypeDefinition(unresolvedFile.TopLevelTypeDefinitions[1]);
 			var rr = lookup.Lookup(new ResolveResult(derived), "Method", EmptyList<IType>.Instance, true) as MethodGroupResolveResult;
 			Assert.AreEqual(2, rr.MethodsGroupedByDeclaringType.Count());
 			
@@ -115,8 +115,8 @@ class Base {
 class Derived : Base {
 	public override void Method<S>(S a) {}
 }";
-			var parsedFile = Parse(program);
+			var unresolvedFile = Parse(program);
-			ITypeDefinition derived = compilation.MainAssembly.GetTypeDefinition(parsedFile.TopLevelTypeDefinitions[1]);
+			ITypeDefinition derived = compilation.MainAssembly.GetTypeDefinition(unresolvedFile.TopLevelTypeDefinitions[1]);
 			var rr = lookup.Lookup(new ResolveResult(derived), "Method", EmptyList<IType>.Instance, true) as MethodGroupResolveResult;
 			Assert.AreEqual(1, rr.MethodsGroupedByDeclaringType.Count());
 			

ICSharpCode.NRefactory.Tests/CSharp/Resolver/ResolverTestBase.cs

@@ -168,11 +168,11 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			
 			SetUp();
 			
-			CSharpParsedFile parsedFile = syntaxTree.ToTypeSystem();
+			CSharpUnresolvedFile unresolvedFile = syntaxTree.ToTypeSystem();
-			project = project.UpdateProjectContent(null, parsedFile);
+			project = project.AddOrUpdateFiles(unresolvedFile);
 			compilation = project.CreateCompilation();
 			
-			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, parsedFile);
+			CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile);
 			return Tuple.Create(resolver, FindNode(syntaxTree, dollars[0], dollars[1]));
 		}
 		
@@ -253,11 +253,11 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			
 			SetUp();
 			
-			CSharpParsedFile parsedFile = syntaxTree.ToTypeSystem();
+			CSharpUnresolvedFile unresolvedFile = syntaxTree.ToTypeSystem();
-			project = project.UpdateProjectContent(null, parsedFile);
+			project = project.AddOrUpdateFiles(unresolvedFile);
 			compilation = project.CreateCompilation();
 			
-			ResolveResult rr = Resolver.ResolveAtLocation.Resolve(compilation, parsedFile, syntaxTree, dollars[0]);
+			ResolveResult rr = Resolver.ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, dollars[0]);
 			return rr;
 		}
 		

ICSharpCode.NRefactory.Tests/Documentation/CSharpCrefLookupTests.cs

@@ -56,7 +56,7 @@ class Impl<T> : IGeneric<List<string>[,], T> {
 			
 			var pc = new CSharpProjectContent().AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib });
 			var syntaxTree = SyntaxTree.Parse(program, "program.cs");
-			var compilation = pc.UpdateProjectContent(null, syntaxTree.ToTypeSystem()).CreateCompilation();
+			var compilation = pc.AddOrUpdateFiles(syntaxTree.ToTypeSystem()).CreateCompilation();
 			var typeDefinition = compilation.MainAssembly.TopLevelTypeDefinitions.First();
 			IEntity entity = typeDefinition.Documentation.ResolveCref(cref);
 			Assert.IsNotNull(entity, "ResolveCref() returned null.");

ICSharpCode.NRefactory.Tests/Documentation/CSharpDocumentationTests.cs

@@ -36,7 +36,7 @@ namespace ICSharpCode.NRefactory.Documentation
 		{
 			var pc = new CSharpProjectContent().AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib });
 			var syntaxTree = SyntaxTree.Parse(program, "program.cs");
-			compilation = pc.UpdateProjectContent(null, syntaxTree.ToTypeSystem()).CreateCompilation();
+			compilation = pc.AddOrUpdateFiles(syntaxTree.ToTypeSystem()).CreateCompilation();
 			typeDefinition = compilation.MainAssembly.TopLevelTypeDefinitions.FirstOrDefault();
 		}
 		

ICSharpCode.NRefactory.Tests/TypeSystem/GetAllBaseTypesTest.cs

@@ -67,8 +67,8 @@ namespace System.Collections.Generic {
 		[SetUp]
 		public void SetUp()
 		{
-			var parsedFile = new CSharpParser().Parse(corlib, "corlib.cs").ToTypeSystem();
+			var unresolvedFile = new CSharpParser().Parse(corlib, "corlib.cs").ToTypeSystem();
-			compilation = new CSharpProjectContent().SetAssemblyName("mscorlib").UpdateProjectContent(null, parsedFile).CreateCompilation();
+			compilation = new CSharpProjectContent().SetAssemblyName("mscorlib").AddOrUpdateFiles(unresolvedFile).CreateCompilation();
 		}
 		
 		IType[] GetAllBaseTypes(Type type)

ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemHelper.cs

@@ -27,20 +27,20 @@ namespace ICSharpCode.NRefactory.TypeSystem
 	{
 		public static ICompilation CreateCompilation()
 		{
-			return CreateCompilation(new IParsedFile[0]);
+			return CreateCompilation(new IUnresolvedFile[0]);
 		}
 		
 		public static ICompilation CreateCompilation(params IUnresolvedTypeDefinition[] unresolvedTypeDefinitions)
 		{
-			var parsedFile = new CSharpParsedFile("dummy.cs");
+			var unresolvedFile = new CSharpUnresolvedFile("dummy.cs");
 			foreach (var typeDef in unresolvedTypeDefinitions)
-				parsedFile.TopLevelTypeDefinitions.Add(typeDef);
+				unresolvedFile.TopLevelTypeDefinitions.Add(typeDef);
-			return CreateCompilation(parsedFile);
+			return CreateCompilation(unresolvedFile);
 		}
 		
-		public static ICompilation CreateCompilation(params IParsedFile[] parsedFiles)
+		public static ICompilation CreateCompilation(params IUnresolvedFile[] unresolvedFiles)
 		{
-			var pc = new CSharpProjectContent().UpdateProjectContent(null, parsedFiles);
+			var pc = new CSharpProjectContent().AddOrUpdateFiles(unresolvedFiles);
 			pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore });
 			return pc.CreateCompilation();
 		}

ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj

@@ -206,7 +206,7 @@
     <Compile Include="TypeSystem\IntersectionType.cs" />
     <Compile Include="TypeSystem\IParameter.cs" />
     <Compile Include="TypeSystem\IParameterizedMember.cs" />
-    <Compile Include="TypeSystem\IParsedFile.cs" />
+    <Compile Include="TypeSystem\IUnresolvedFile.cs" />
     <Compile Include="TypeSystem\IProjectContent.cs" />
     <Compile Include="TypeSystem\IProperty.cs" />
     <Compile Include="TypeSystem\ISolutionSnapshot.cs" />

ICSharpCode.NRefactory/TypeSystem/ExtensionMethods.cs

@@ -268,7 +268,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// Gets all unresolved type definitions from the file.
 		/// For partial classes, each part is returned.
 		/// </summary>
-		public static IEnumerable<IUnresolvedTypeDefinition> GetAllTypeDefinitions (this IParsedFile file)
+		public static IEnumerable<IUnresolvedTypeDefinition> GetAllTypeDefinitions (this IUnresolvedFile file)
 		{
 			return TreeTraversal.PreOrder(file.TopLevelTypeDefinitions, t => t.NestedTypes);
 		}
@@ -300,7 +300,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// Gets the type (potentially a nested type) defined at the specified location.
 		/// Returns null if no type is defined at that location.
 		/// </summary>
-		public static IUnresolvedTypeDefinition GetInnermostTypeDefinition (this IParsedFile file, int line, int column)
+		public static IUnresolvedTypeDefinition GetInnermostTypeDefinition (this IUnresolvedFile file, int line, int column)
 		{
 			return file.GetInnermostTypeDefinition (new TextLocation (line, column));
 		}
@@ -309,7 +309,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// Gets the member defined at the specified location.
 		/// Returns null if no member is defined at that location.
 		/// </summary>
-		public static IUnresolvedMember GetMember (this IParsedFile file, int line, int column)
+		public static IUnresolvedMember GetMember (this IUnresolvedFile file, int line, int column)
 		{
 			return file.GetMember (new TextLocation (line, column));
 		}

ICSharpCode.NRefactory/TypeSystem/IEntity.cs

@@ -54,7 +54,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// Gets the parsed file in which this entity is defined.
 		/// Returns null if this entity wasn't parsed from source code (e.g. loaded from a .dll with CecilLoader).
 		/// </summary>
-		IParsedFile ParsedFile { get; }
+		IUnresolvedFile UnresolvedFile { get; }
 		
 		/// <summary>
 		/// Gets the attributes on this entity.

ICSharpCode.NRefactory/TypeSystem/IProjectContent.cs

@@ -35,12 +35,12 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// <summary>
 		/// Gets a parsed file by its file name.
 		/// </summary>
-		IParsedFile GetFile(string fileName);
+		IUnresolvedFile GetFile(string fileName);
 		
 		/// <summary>
 		/// Gets the list of all parsed files in the project content.
 		/// </summary>
-		IEnumerable<IParsedFile> Files { get; }
+		IEnumerable<IUnresolvedFile> Files { get; }
 		
 		/// <summary>
 		/// Gets the referenced assemblies.
@@ -94,20 +94,54 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// </summary>
 		IProjectContent AddAssemblyReferences(IEnumerable<IAssemblyReference> references);
 		
+		/// <summary>
+		/// Add assembly references to this project content.
+		/// </summary>
+		IProjectContent AddAssemblyReferences(params IAssemblyReference[] references);
+		
 		/// <summary>
 		/// Removes assembly references from this project content.
 		/// </summary>
 		IProjectContent RemoveAssemblyReferences(IEnumerable<IAssemblyReference> references);
 		
+		/// <summary>
+		/// Removes assembly references from this project content.
+		/// </summary>
+		IProjectContent RemoveAssemblyReferences(params IAssemblyReference[] references);
+		
+		/// <summary>
+		/// Adds the specified files to the project content.
+		/// If a file with the same name already exists, updated the existing file.
+		/// </summary>
+		IProjectContent AddOrUpdateFiles(IEnumerable<IUnresolvedFile> newFiles);
+		
+		/// <summary>
+		/// Adds the specified files to the project content.
+		/// If a file with the same name already exists, this method updates the existing file.
+		/// </summary>
+		IProjectContent AddOrUpdateFiles(params IUnresolvedFile[] newFiles);
+		
+		/// <summary>
+		/// Removes the files with the specified names.
+		/// </summary>
+		IProjectContent RemoveFiles(IEnumerable<string> fileNames);
+		
+		/// <summary>
+		/// Removes the files with the specified names.
+		/// </summary>
+		IProjectContent RemoveFiles(params string[] fileNames);
+		
 		/// <summary>
 		/// Removes types and attributes from oldFile from the project, and adds those from newFile.
 		/// </summary>
-		IProjectContent UpdateProjectContent(IParsedFile oldFile, IParsedFile newFile);
+		[Obsolete("Use RemoveFiles()/AddOrUpdateFiles() instead")]
+		IProjectContent UpdateProjectContent(IUnresolvedFile oldFile, IUnresolvedFile newFile);
 		
 		/// <summary>
 		/// Removes types and attributes from oldFiles from the project, and adds those from newFiles.
 		/// </summary>
-		IProjectContent UpdateProjectContent(IEnumerable<IParsedFile> oldFiles, IEnumerable<IParsedFile> newFiles);
+		[Obsolete("Use RemoveFiles()/AddOrUpdateFiles() instead")]
+		IProjectContent UpdateProjectContent(IEnumerable<IUnresolvedFile> oldFiles, IEnumerable<IUnresolvedFile> newFiles);
 		
 		/// <summary>
 		/// Sets the compiler settings object.

ICSharpCode.NRefactory/TypeSystem/IUnresolvedFile.cs

@@ -21,10 +21,13 @@ using System.Collections.Generic;
 
 namespace ICSharpCode.NRefactory.TypeSystem
 {
+	[Obsolete("IParsedFile was renamed to IUnresolvedFile", true)]
+	public interface IParsedFile {}
+	
 	/// <summary>
 	/// Represents a single file that was parsed.
 	/// </summary>
-	public interface IParsedFile
+	public interface IUnresolvedFile
 	{
 		/// <summary>
 		/// Returns the full path of the file.

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs

@@ -92,7 +92,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		
 		public override DocumentationComment Documentation {
 			get {
-				IUnresolvedDocumentationProvider docProvider = unresolved.ParsedFile as IUnresolvedDocumentationProvider;
+				IUnresolvedDocumentationProvider docProvider = unresolved.UnresolvedFile as IUnresolvedDocumentationProvider;
 				if (docProvider != null) {
 					var doc = docProvider.GetDocumentation(unresolved, this);
 					if (doc != null)

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractUnresolvedEntity.cs

@@ -101,7 +101,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		{
 			internal DomRegion region;
 			internal DomRegion bodyRegion;
-			internal IParsedFile parsedFile;
+			internal IUnresolvedFile unresolvedFile;
 			
 			protected internal virtual void FreezeInternal()
 			{
@@ -148,11 +148,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
-		public IParsedFile ParsedFile {
+		public IUnresolvedFile UnresolvedFile {
-			get { return rareFields != null ? rareFields.parsedFile : null; }
+			get { return rareFields != null ? rareFields.unresolvedFile : null; }
 			set {
 				if (value != null || rareFields != null)
-					WriteRareFields().parsedFile = value;
+					WriteRareFields().unresolvedFile = value;
 			}
 		}
 		

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedTypeDefinition.cs

@@ -589,7 +589,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		public virtual DocumentationComment Documentation {
 			get {
 				foreach (var part in parts) {
-					var unresolvedProvider = part.ParsedFile as IUnresolvedDocumentationProvider;
+					var unresolvedProvider = part.UnresolvedFile as IUnresolvedDocumentationProvider;
 					if (unresolvedProvider != null) {
 						var doc = unresolvedProvider.GetDocumentation(part, this);
 						if (doc != null)

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedEvent.cs

@@ -55,7 +55,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			this.DeclaringTypeDefinition = declaringType;
 			this.Name = name;
 			if (declaringType != null)
-				this.ParsedFile = declaringType.ParsedFile;
+				this.UnresolvedFile = declaringType.UnresolvedFile;
 		}
 		
 		public bool CanAdd {

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedField.cs

@@ -51,7 +51,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			this.DeclaringTypeDefinition = declaringType;
 			this.Name = name;
 			if (declaringType != null)
-				this.ParsedFile = declaringType.ParsedFile;
+				this.UnresolvedFile = declaringType.UnresolvedFile;
 		}
 		
 		public bool IsConst {

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedMethod.cs

@@ -63,7 +63,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			this.DeclaringTypeDefinition = declaringType;
 			this.Name = name;
 			if (declaringType != null)
-				this.ParsedFile = declaringType.ParsedFile;
+				this.UnresolvedFile = declaringType.UnresolvedFile;
 		}
 		
 		public IList<IUnresolvedAttribute> ReturnTypeAttributes {

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedProperty.cs

@@ -58,7 +58,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			this.DeclaringTypeDefinition = declaringType;
 			this.Name = name;
 			if (declaringType != null)
-				this.ParsedFile = declaringType.ParsedFile;
+				this.UnresolvedFile = declaringType.UnresolvedFile;
 		}
 		
 		public bool IsIndexer {

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultUnresolvedTypeDefinition.cs

@@ -72,7 +72,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			this.DeclaringTypeDefinition = declaringTypeDefinition;
 			this.namespaceName = declaringTypeDefinition.Namespace;
 			this.Name = name;
-			this.ParsedFile = declaringTypeDefinition.ParsedFile;
+			this.UnresolvedFile = declaringTypeDefinition.UnresolvedFile;
 		}
 		
 		public TypeKind Kind {

doc/XML Documentation.html

@@ -20,7 +20,7 @@
 	property is accessed.<br/>
 	For this purpose, the type system casts the parsed file to <code>IUnresolvedDocumentationProvider</code>
 	and tries to get the documentation.
-	This way, the <code>CSharpParsedFile</code> can provide the documentation from the XML comments.<br/>
+	This way, the <code>CSharpUnresolvedFile</code> can provide the documentation from the XML comments.<br/>
 	If this fails, the type system casts the unresolved assembly/project content to <code>IDocumentationProvider</code>.
 	This is the way the request for documentation gets to the <code>CecilLoader</code>,
 	which in turn forwards it to the user-provided <code>IDocumentationProvider</code>.