Add GetInterestingFileNames to FindReferences.

Fixed a few resolver issues related to find references.

ICSharpCode.NRefactory/CSharp/Parser/TypeSystemConvertVisitor.cs

@@ -175,7 +175,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				newType.TypeParameters.AddRange(currentTypeDefinition.TypeParameters);
 				currentTypeDefinition.NestedTypes.Add(newType);
 			} else {
-				newType = new DefaultTypeDefinition(usingScope.ProjectContent, usingScope.NamespaceName, name);
+				newType = new DefaultTypeDefinition(parsedFile, usingScope.NamespaceName, name);
 				parsedFile.TopLevelTypeDefinitions.Add(newType);
 			}
 			return newType;

ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs

@@ -553,6 +553,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				get { throw new NotSupportedException(); }
 			}
 			
+			IParsedFile IEntity.ParsedFile {
+				get { return null; }
+			}
+			
 			string INamedElement.FullName {
 				get { return "operator"; }
 			}

ICSharpCode.NRefactory/CSharp/Resolver/FindReferencedEntities.cs

@@ -42,9 +42,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		public void Resolved(AstNode node, ResolveResult result)
 		{
+			if (ResolveVisitor.ActsAsParenthesizedExpression(node))
+				return;
+			
 			MemberResolveResult mrr = result as MemberResolveResult;
 			if (mrr != null) {
-				referenceFound(node, mrr.Member);
+				referenceFound(node, mrr.Member.MemberDefinition);
 			}
 			TypeResolveResult trr = result as TypeResolveResult;
 			if (trr != null) {
@@ -57,7 +60,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public void ProcessConversion(Expression expression, ResolveResult result, Conversion conversion, IType targetType)
 		{
 			if (conversion.IsUserDefined || conversion.IsMethodGroupConversion) {
-				referenceFound(expression, conversion.Method);
+				referenceFound(expression, conversion.Method.MemberDefinition);
 			}
 		}
 	}

ICSharpCode.NRefactory/CSharp/Resolver/FindReferences.cs

@@ -20,7 +20,9 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
+using ICSharpCode.Editor;
 using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.NRefactory.Utils;
 
 namespace ICSharpCode.NRefactory.CSharp.Resolver
 {
@@ -43,6 +45,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		}
 		#endregion
 		
+		#region Properties
+		/// <summary>
+		/// Gets/Sets whether to find type references even if an alias is being used.
+		/// </summary>
+		public bool FindTypeReferencesEvenIfAliased { get; set; }
+		#endregion
+		
 		#region GetEffectiveAccessibility
 		/// <summary>
 		/// Gets the effective accessibility of the specified entity -
@@ -94,7 +103,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			protected string searchTerm;
 			internal Accessibility accessibility;
-			internal IEntity topLevelEntity;
+			internal ITypeDefinition topLevelTypeDefinition;
 			internal FindReferences findReferences;
 			
 			/// <summary>
@@ -111,7 +120,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			/// <summary>
 			/// Gets the top-level entity that defines the search scope.
 			/// </summary>
-			public IEntity TopLevelEntity { get { return topLevelEntity; } }
+			public ITypeDefinition TopLevelTypeDefinition { get { return topLevelTypeDefinition; } }
 			
 			internal abstract bool CanMatch(AstNode node);
 			internal abstract bool IsMatch(ResolveResult rr);
@@ -155,16 +164,19 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			if (entity == null)
 				throw new ArgumentNullException("entity");
 			Accessibility effectiveAccessibility = GetEffectiveAccessibility(entity);
-			IEntity topLevelEntity = entity;
-			while (topLevelEntity.DeclaringTypeDefinition != null)
-				topLevelEntity = topLevelEntity.DeclaringTypeDefinition;
+			ITypeDefinition topLevelTypeDefinition = entity.DeclaringTypeDefinition;
+			while (topLevelTypeDefinition != null && topLevelTypeDefinition.DeclaringTypeDefinition != null)
+				topLevelTypeDefinition = topLevelTypeDefinition.DeclaringTypeDefinition;
 			SearchScope scope;
 			SearchScope additionalScope = null;
 			switch (entity.EntityType) {
 				case EntityType.TypeDefinition:
-					scope = new FindTypeDefinitionReferences((ITypeDefinition)entity);
+					scope = new FindTypeDefinitionReferences((ITypeDefinition)entity, this.FindTypeReferencesEvenIfAliased);
 					break;
 				case EntityType.Field:
+					if (entity.DeclaringTypeDefinition != null && entity.DeclaringTypeDefinition.Kind == TypeKind.Enum)
+						scope = new FindEnumMemberReferences((IField)entity);
+					else
 						scope = new FindFieldReferences((IField)entity);
 					break;
 				case EntityType.Property:
@@ -194,12 +206,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 			if (scope.accessibility == Accessibility.None)
 				scope.accessibility = effectiveAccessibility;
-			scope.topLevelEntity = topLevelEntity;
+			scope.topLevelTypeDefinition = topLevelTypeDefinition;
 			scope.findReferences = this;
 			if (additionalScope != null) {
 				if (additionalScope.accessibility == Accessibility.None)
 					additionalScope.accessibility = effectiveAccessibility;
-				additionalScope.topLevelEntity = topLevelEntity;
+				additionalScope.topLevelTypeDefinition = topLevelTypeDefinition;
 				additionalScope.findReferences = this;
 				return new[] { scope, additionalScope };
 			} else {
@@ -208,11 +220,77 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		}
 		#endregion
 		
+		#region FindReferencesInSolution
+		/// <summary>
+		/// Gets the file names that possibly contain references to the element being searched for.
+		/// </summary>
+		public IEnumerable<string> GetInterestingFileNames(SearchScope searchScope, ITypeResolveContext context)
+		{
+			IEnumerable<ITypeDefinition> interestingTypes;
+			if (searchScope.TopLevelTypeDefinition != null) {
+				switch (searchScope.Accessibility) {
+					case Accessibility.None:
+					case Accessibility.Private:
+						interestingTypes = new [] { searchScope.TopLevelTypeDefinition.GetDefinition() };
+						break;
+					case Accessibility.Protected:
+						interestingTypes = GetInterestingTypesProtected(context, searchScope.TopLevelTypeDefinition);
+						break;
+					case Accessibility.Internal:
+						interestingTypes = GetInterestingTypesInternal(context, searchScope.TopLevelTypeDefinition.ProjectContent);
+						break;
+					case Accessibility.ProtectedAndInternal:
+						interestingTypes = GetInterestingTypesProtected(context, searchScope.TopLevelTypeDefinition)
+							.Intersect(GetInterestingTypesInternal(context, searchScope.TopLevelTypeDefinition.ProjectContent));
+						break;
+					case Accessibility.ProtectedOrInternal:
+						interestingTypes = GetInterestingTypesProtected(context, searchScope.TopLevelTypeDefinition)
+							.Union(GetInterestingTypesInternal(context, searchScope.TopLevelTypeDefinition.ProjectContent));
+						break;
+					default:
+						interestingTypes = context.GetTypes();
+						break;
+				}
+			} else {
+				interestingTypes = context.GetTypes();
+			}
+			return (from typeDef in interestingTypes
+			        from part in typeDef.GetParts()
+			        where part.ParsedFile != null
+			        select part.ParsedFile.FileName
+			       ).Distinct(Platform.FileNameComparer);
+		}
+		
+		IEnumerable<ITypeDefinition> GetInterestingTypesProtected(ITypeResolveContext context, ITypeDefinition referencedTypeDefinition)
+		{
+			return referencedTypeDefinition.GetSubTypeDefinitions(context);
+		}
+		
+		IEnumerable<ITypeDefinition> GetInterestingTypesInternal(ITypeResolveContext context, IProjectContent referencedProjectContent)
+		{
+			return context.GetTypes().Where(t => referencedProjectContent.InternalsVisibleTo(t.ProjectContent, context));
+		}
+		#endregion
+		
 		#region FindReferencesInFile
 		/// <summary>
 		/// Finds all references in the given file.
 		/// </summary>
-		/// <param name="searchScope">The search scopes for which to look.</param>
+		/// <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="compilationUnit">The compilation unit of the file being searched.</param>
+		/// <param name="context">The type resolve context to use for resolving the file.</param>
+		public void FindReferencesInFile(SearchScope searchScope, ParsedFile parsedFile, CompilationUnit compilationUnit, ITypeResolveContext context)
+		{
+			if (searchScope == null)
+				throw new ArgumentNullException("searchScope");
+			FindReferencesInFile(new[] { searchScope }, parsedFile, compilationUnit, context);
+		}
+		
+		/// <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="compilationUnit">The compilation unit of the file being searched.</param>
 		/// <param name="context">The type resolve context to use for resolving the file.</param>
@@ -252,10 +330,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		{
 			ITypeDefinition typeDefinition;
 			
-			public FindTypeDefinitionReferences(ITypeDefinition typeDefinition)
+			public FindTypeDefinitionReferences(ITypeDefinition typeDefinition, bool findTypeReferencesEvenIfAliased)
 			{
 				this.typeDefinition = typeDefinition;
-				if (ReflectionHelper.GetTypeCode(typeDefinition) == TypeCode.Empty) {
+				if (!findTypeReferencesEvenIfAliased && ReflectionHelper.GetTypeCode(typeDefinition) == TypeCode.Empty) {
 					// not a built-in type
 					this.searchTerm = typeDefinition.Name;
 				}
@@ -282,7 +360,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				if (searchTerm == null && node is PrimitiveType)
 					return true;
 				
-				return false;
+				return node is TypeDeclaration;
 			}
 			
 			internal override bool IsMatch(ResolveResult rr)
@@ -340,7 +418,19 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			
 			internal override bool CanMatch(AstNode node)
 			{
-				return node is FieldDeclaration || base.CanMatch(node);
+				return node is FieldDeclaration || node is VariableInitializer || base.CanMatch(node);
+			}
+		}
+		
+		sealed class FindEnumMemberReferences : FindMemberReferences
+		{
+			public FindEnumMemberReferences(IField field) : base(field)
+			{
+			}
+			
+			internal override bool CanMatch(AstNode node)
+			{
+				return node is EnumMemberDeclaration || base.CanMatch(node);
 			}
 		}
 		
@@ -607,7 +697,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			
 			internal override bool IsMatch(ResolveResult rr)
 			{
-				return false;
+				MemberResolveResult mrr = rr as MemberResolveResult;
+				return mrr != null && op == mrr.Member.MemberDefinition;
 			}
 			
 			internal override void ProcessConversion(Expression expression, ResolveResult result, Conversion conversion, IType targetType)

ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs

@@ -174,6 +174,12 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 						// lambdas must be resolved so that they get stored in the 'undecided' list only once
 						goto case ResolveVisitorNavigationMode.Resolve;
 					}
+					
+					// We shouldn't scan nodes that were already resolved.
+					Debug.Assert(!resolveResultCache.ContainsKey(node));
+					// Doing so should be harmless since we allow scanning twice, but it indicates
+					// a bug in the logic that causes the scan.
+					
 					bool oldResolverEnabled = resolverEnabled;
 					resolverEnabled = false;
 					StoreState(node, resolver.Clone());
@@ -231,6 +237,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			Debug.Assert(result != null);
 			if (node.IsNull)
 				return;
+			Debug.Assert(!resolveResultCache.ContainsKey(node));
 			resolveResultCache.Add(node, result);
 			if (navigator != null)
 				navigator.Resolved(node, result);
@@ -1631,7 +1638,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			
 			var lambda = new ExplicitlyTypedLambda(parameters, isAnonymousMethod, resolver.Clone(), this, body);
 			
-			Scan(body);
+			// Don't scan the lambda body here - we'll do that later when analyzing the ExplicitlyTypedLambda.
 			
 			resolver.PopBlock();
 			return lambda;
@@ -2263,12 +2270,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		ResolveResult IAstVisitor<object, ResolveResult>.VisitFixedStatement(FixedStatement fixedStatement, object data)
 		{
 			resolver.PushBlock();
-			
-			VariableInitializer firstInitializer = fixedStatement.Variables.FirstOrDefault();
-			ITypeReference type = MakeTypeReference(fixedStatement.Type,
-			                                        firstInitializer != null ? firstInitializer.Initializer : null,
-			                                        false);
-			
+			ITypeReference type = MakeTypeReference(fixedStatement.Type);
 			for (AstNode node = fixedStatement.FirstChild; node != null; node = node.NextSibling) {
 				if (node.Role == FixedStatement.Roles.Variable) {
 					VariableInitializer vi = (VariableInitializer)node;
@@ -2283,10 +2285,23 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		ResolveResult IAstVisitor<object, ResolveResult>.VisitForeachStatement(ForeachStatement foreachStatement, object data)
 		{
 			resolver.PushBlock();
-			ITypeReference type = MakeTypeReference(foreachStatement.VariableType, foreachStatement.InExpression, true);
+			ITypeReference type;
+			if (IsVar(foreachStatement.VariableType)) {
+				if (navigator.Scan(foreachStatement.VariableType) == ResolveVisitorNavigationMode.Resolve) {
+					IType collectionType = Resolve(foreachStatement.InExpression).Type;
+					IType elementType = GetElementType(collectionType, resolver.Context, false);
+					StoreResult(foreachStatement.VariableType, new TypeResolveResult(elementType));
+					type = elementType;
+				} else {
+					Scan(foreachStatement.InExpression);
+					type = MakeVarTypeReference(foreachStatement.InExpression, true);
+				}
+			} else {
+				type = ResolveType(foreachStatement.VariableType);
+			}
 			IVariable v = resolver.AddVariable(type, MakeRegion(foreachStatement.VariableNameToken), foreachStatement.VariableName);
 			StoreResult(foreachStatement.VariableNameToken, new LocalResolveResult(v, v.Type.Resolve(resolver.Context)));
-			ScanChildren(foreachStatement);
+			Scan(foreachStatement.EmbeddedStatement);
 			resolver.PopBlock();
 			return voidResult;
 		}
@@ -2302,8 +2317,8 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		ResolveResult IAstVisitor<object, ResolveResult>.VisitCatchClause(CatchClause catchClause, object data)
 		{
 			resolver.PushBlock();
-			if (catchClause.VariableName != null) {
-				ITypeReference variableType = MakeTypeReference(catchClause.Type, null, false);
+			if (!string.IsNullOrEmpty(catchClause.VariableName)) {
+				ITypeReference variableType = MakeTypeReference(catchClause.Type);
 				DomRegion region = MakeRegion(catchClause.VariableNameToken);
 				IVariable v = resolver.AddVariable(variableType, region, catchClause.VariableName);
 				StoreResult(catchClause.VariableNameToken, new LocalResolveResult(v, v.Type.Resolve(resolver.Context)));
@@ -2318,10 +2333,32 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		ResolveResult IAstVisitor<object, ResolveResult>.VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement, object data)
 		{
 			bool isConst = (variableDeclarationStatement.Modifiers & Modifiers.Const) != 0;
-			VariableInitializer firstInitializer = variableDeclarationStatement.Variables.FirstOrDefault();
-			ITypeReference type = MakeTypeReference(variableDeclarationStatement.Type,
-			                                        firstInitializer != null ? firstInitializer.Initializer : null,
-			                                        false);
+			if (!isConst && IsVar(variableDeclarationStatement.Type) && variableDeclarationStatement.Variables.Count == 1) {
+				VariableInitializer vi = variableDeclarationStatement.Variables.Single();
+				bool needResolve = resolverEnabled
+					|| navigator.Scan(variableDeclarationStatement.Type) == ResolveVisitorNavigationMode.Resolve
+					|| navigator.Scan(vi) == ResolveVisitorNavigationMode.Resolve;
+				ITypeReference type;
+				if (needResolve) {
+					type = Resolve(vi.Initializer).Type;
+				} else {
+					Scan(vi.Initializer);
+					type = MakeVarTypeReference(vi.Initializer, false);
+				}
+				IVariable v = resolver.AddVariable(type, MakeRegion(vi), vi.Name);
+				StoreState(vi, resolver.Clone());
+				if (needResolve) {
+					ResolveResult result;
+					if (!resolveResultCache.TryGetValue(vi, out result)) {
+						result = new LocalResolveResult(v, type.Resolve(resolver.Context));
+						StoreResult(vi, result);
+					}
+					return result;
+				} else {
+					return null;
+				}
+			} else {
+				ITypeReference type = MakeTypeReference(variableDeclarationStatement.Type);
 
 				int initializerCount = variableDeclarationStatement.Variables.Count;
 				ResolveResult result = null;
@@ -2346,6 +2383,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				}
 				return result;
 			}
+		}
 		#endregion
 		
 		#region Condition Statements
@@ -2488,39 +2526,6 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		#endregion
 		
 		#region Local Variable Type Inference
-		/// <summary>
-		/// Creates a type reference for the specified type node.
-		/// If the type node is 'var', performs type inference on the initializer expression.
-		/// </summary>
-		ITypeReference MakeTypeReference(AstType type, AstNode initializerExpression, bool isForEach)
-		{
-			bool typeNeedsResolving = (navigator.Scan(type) == ResolveVisitorNavigationMode.Resolve);
-			if (initializerExpression != null && IsVar(type)) {
-				var typeRef = new VarTypeReference(this, resolver.Clone(), initializerExpression, isForEach);
-				if (typeNeedsResolving) {
-					// Hack: I don't see a clean way to make the 'var' SimpleType resolve to the inferred type,
-					// so we just do it here and store the result in the resolver cache.
-					IType actualType = typeRef.Resolve(resolver.Context);
-					if (actualType.Kind != TypeKind.Unknown) {
-						StoreResult(type, new TypeResolveResult(actualType));
-					} else {
-						StoreResult(type, errorResult);
-					}
-					return actualType;
-				} else {
-					return typeRef;
-				}
-			} else {
-				// Perf: avoid duplicate resolving of the type (once as ITypeReference, once directly in ResolveVisitor)
-				// if possible. By using ResolveType when we know we need to resolve the node anyways, the resolve cache
-				// can take care of the duplicate call.
-				if (typeNeedsResolving)
-					return ResolveType(type);
-				else
-					return MakeTypeReference(type);
-			}
-		}
-		
 		static bool IsVar(AstType returnType)
 		{
 			SimpleType st = returnType as SimpleType;
@@ -2532,6 +2537,11 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return TypeSystemConvertVisitor.ConvertType(type, resolver.CurrentTypeDefinition, resolver.CurrentMember as IMethod, resolver.CurrentUsingScope, currentTypeLookupMode);
 		}
 		
+		ITypeReference MakeVarTypeReference(Expression initializer, bool isForEach)
+		{
+			return new VarTypeReference(this, resolver.Clone(), initializer, isForEach);
+		}
+		
 		sealed class VarTypeReference : ITypeReference
 		{
 			ResolveVisitor visitor;

ICSharpCode.NRefactory/TypeSystem/IEntity.cs

@@ -137,6 +137,12 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// </summary>
 		IProjectContent ProjectContent { get; }
 		
+		/// <summary>
+		/// Gets the parsed file in which this entity is defined.
+		/// Returns null if this entity wasn't parsed (loaded with CecilLoader).
+		/// </summary>
+		IParsedFile ParsedFile { get; }
+		
 		//bool IsAccessible(IClass callingClass, bool isAccessThoughReferenceOfCurrentClass);
 	}
 	

ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractMember.cs

@@ -271,6 +271,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return declaringTypeDefinition.ProjectContent; }
 		}
 		
+		public IParsedFile ParsedFile {
+			get { return declaringTypeDefinition.ParsedFile; }
+		}
+		
 		public string Name {
 			get { return name; }
 			set {

ICSharpCode.NRefactory/TypeSystem/Implementation/CompoundTypeDefinition.cs

@@ -35,6 +35,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 		{
 		}
 		
+		private CompoundTypeDefinition(IParsedFile parsedFile, string ns, string name)
+			: base(parsedFile, ns, name)
+		{
+		}
+		
 		private CompoundTypeDefinition(IProjectContent projectContent, string ns, string name)
 			: base(projectContent, ns, name)
 		{
@@ -74,6 +79,9 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			if (mainPart.DeclaringTypeDefinition != null) {
 				throw new NotImplementedException("nested compound types not implemented");
 			} else {
+				if (mainPart.ParsedFile != null)
+					compound = new CompoundTypeDefinition(mainPart.ParsedFile, mainPart.Namespace, mainPart.Name);
+				else
 					compound = new CompoundTypeDefinition(mainPart.ProjectContent, mainPart.Namespace, mainPart.Name);
 			}
 			compound.parts = parts;

ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeDefinition.cs

@@ -29,6 +29,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 	public class DefaultTypeDefinition : AbstractFreezable, ITypeDefinition
 	{
 		readonly IProjectContent projectContent;
+		readonly IParsedFile parsedFile;
 		readonly ITypeDefinition declaringTypeDefinition;
 		
 		volatile ITypeDefinition compoundTypeDefinition;
@@ -79,13 +80,29 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			if (string.IsNullOrEmpty(name))
 				throw new ArgumentException("name");
 			this.projectContent = declaringTypeDefinition.ProjectContent;
+			this.parsedFile = declaringTypeDefinition.ParsedFile;
 			this.declaringTypeDefinition = declaringTypeDefinition;
+			
 			this.name = name;
 			this.ns = declaringTypeDefinition.Namespace;
 			
 			this.compoundTypeDefinition = this;
 		}
 		
+		public DefaultTypeDefinition(IParsedFile parsedFile, string ns, string name)
+		{
+			if (parsedFile == null)
+				throw new ArgumentNullException("parsedFile");
+			if (string.IsNullOrEmpty(name))
+				throw new ArgumentException("name");
+			this.parsedFile = parsedFile;
+			this.projectContent = parsedFile.ProjectContent;
+			this.ns = ns ?? string.Empty;
+			this.name = name;
+			
+			this.compoundTypeDefinition = this;
+		}
+		
 		public DefaultTypeDefinition(IProjectContent projectContent, string ns, string name)
 		{
 			if (projectContent == null)
@@ -377,6 +394,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return projectContent; }
 		}
 		
+		public IParsedFile ParsedFile {
+			get { return parsedFile; }
+		}
+		
 		public IEnumerable<IType> GetBaseTypes(ITypeResolveContext context)
 		{
 			ITypeDefinition compound = this.compoundTypeDefinition;

ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs

@@ -171,6 +171,10 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			get { return memberDefinition.ProjectContent; }
 		}
 		
+		public IParsedFile ParsedFile {
+			get { return memberDefinition.ParsedFile; }
+		}
+		
 		public string FullName {
 			get { return memberDefinition.FullName; }
 		}