Consistently use 'null' DeclaringType for top-level entities.

dgrunwald · dgrunwald · commit 7df13597c75e · 2015-06-05T18:41:47.000+02:00
diff --git a/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/ConvertExplicitToImplicitImplementationAction.cs b/ICSharpCode.NRefactory.CSharp.Refactoring/CodeActions/ConvertExplicitToImplicitImplementationAction.cs
@@ -44,7 +44,7 @@ protected override CodeAction GetAction (RefactoringContext context, MethodDecla
 				return null;
 
 			var method = (IMethod)((MemberResolveResult)context.Resolve (node)).Member;
-			var type = method.DeclaringType;
+			var type = method.DeclaringType ?? SpecialType.UnknownType;
 
 			// find existing method with the same signature
 			if (type.GetMethods (m => m.Name == node.Name && m.TypeParameters.Count == method.TypeParameters.Count
diff --git a/ICSharpCode.NRefactory.CSharp/Analysis/SemanticHighlightingVisitor.cs b/ICSharpCode.NRefactory.CSharp/Analysis/SemanticHighlightingVisitor.cs
@@ -535,7 +535,8 @@ bool TryGetMemberColor(IMember member, out TColor color)
 					return true;
 				case SymbolKind.Constructor:
 				case SymbolKind.Destructor:
-					return TryGetTypeHighlighting (member.DeclaringType.Kind, out color);
+					var declaringType = member.DeclaringType;
+					return TryGetTypeHighlighting (declaringType != null ? declaringType.Kind : TypeKind.Unknown, out color);
 				default:
 					color = default (TColor);
 					return false;
diff --git a/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs b/ICSharpCode.NRefactory.CSharp/Completion/CSharpCompletionEngine.cs
@@ -613,7 +613,7 @@ IEnumerable<ICompletionData> HandleToStringFormatItems()
 			if (invokeResult == null)
 				return Enumerable.Empty<ICompletionData>();
 			if (invokeResult.Member.Name == "ToString")
-				return GetFormatCompletionData(invokeResult.Member.DeclaringType) ?? Enumerable.Empty<ICompletionData>();
+				return GetFormatCompletionData(invokeResult.Member.DeclaringType ?? SpecialType.UnknownType) ?? Enumerable.Empty<ICompletionData>();
 			return Enumerable.Empty<ICompletionData>();
 		}
 
diff --git a/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs b/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs
@@ -203,7 +203,7 @@ void WriteMemberDeclarationName(IMember member, TokenWriter writer, CSharpFormat
 		{
 			TypeSystemAstBuilder astBuilder = CreateAstBuilder();
 			EntityDeclaration node = astBuilder.ConvertEntity(member);
-			if ((ConversionFlags & ConversionFlags.ShowDeclaringType) == ConversionFlags.ShowDeclaringType) {
+			if ((ConversionFlags & ConversionFlags.ShowDeclaringType) == ConversionFlags.ShowDeclaringType && member.DeclaringType != null) {
 				ConvertType(member.DeclaringType, writer, formattingPolicy);
 				writer.WriteToken(Roles.Dot, ".");
 			}
diff --git a/ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs b/ICSharpCode.NRefactory.CSharp/OutputVisitor/CodeDomConvertVisitor.cs
@@ -448,7 +448,7 @@ CodeObject IAstVisitor<CodeObject>.VisitInvocationExpression(InvocationExpressio
 			if (id != null) {
 				CodeExpression target;
 				if (rr != null && rr.Member.IsStatic)
-					target = new CodeTypeReferenceExpression(Convert(rr.Member.DeclaringType));
+					target = new CodeTypeReferenceExpression(Convert(rr.Member.DeclaringType ?? SpecialType.UnknownType));
 				else
 					target = new CodeThisReferenceExpression();
 				
@@ -493,7 +493,7 @@ CodeExpression HandleMemberReference(CodeExpression target, string identifier, A
 		{
 			if (target == null) {
 				if (mrr.Member.IsStatic)
-					target = new CodeTypeReferenceExpression(Convert(mrr.Member.DeclaringType));
+					target = new CodeTypeReferenceExpression(Convert(mrr.Member.DeclaringType ?? SpecialType.UnknownType));
 				else
 					target = new CodeThisReferenceExpression();
 			}
diff --git a/ICSharpCode.NRefactory.CSharp/Refactoring/CodeGenerationService.cs b/ICSharpCode.NRefactory.CSharp/Refactoring/CodeGenerationService.cs
@@ -48,8 +48,8 @@ public override EntityDeclaration GenerateMemberImplementation(RefactoringContex
 			var decl = builder.ConvertEntity(member);
 			if (explicitImplementation) {
 				decl.Modifiers = Modifiers.None;
-				decl.AddChild(builder.ConvertType(member.DeclaringType), EntityDeclaration.PrivateImplementationTypeRole);
-			} else if (member.DeclaringType.Kind == TypeKind.Interface) {
+				decl.AddChild(builder.ConvertType(member.DeclaringType ?? SpecialType.UnknownType), EntityDeclaration.PrivateImplementationTypeRole);
+			} else if (member.DeclaringType != null && member.DeclaringType.Kind == TypeKind.Interface) {
 				decl.Modifiers |= Modifiers.Public;
 			} else {
 				// Remove 'internal' modifier from 'protected internal' members if the override is in a different assembly than the member
diff --git a/ICSharpCode.NRefactory.CSharp/Refactoring/FormatStringHelper.cs b/ICSharpCode.NRefactory.CSharp/Refactoring/FormatStringHelper.cs
@@ -46,7 +46,7 @@ public static bool TryGetFormattingParameters(CSharpInvocationResolveResult invo
 			arguments = new List<Expression>();
 
 			// Serach for method of type: void Name(string format, params object[] args);
-			if (invocationResolveResult.Member.SymbolKind == SymbolKind.Method) {
+			if (invocationResolveResult.Member.SymbolKind == SymbolKind.Method && invocationResolveResult.Member.DeclaringType != null) {
 				var methods = invocationResolveResult.Member.DeclaringType.GetMethods(m => m.Name == invocationResolveResult.Member.Name).ToList();
 				if (!methods.Any(m => m.Parameters.Count == 2 && 
 					m.Parameters[0].Type.IsKnownType(KnownTypeCode.String) && parameterNames.Contains(m.Parameters[0].Name) && 
diff --git a/ICSharpCode.NRefactory.CSharp/Refactoring/TypeSystemAstBuilder.cs b/ICSharpCode.NRefactory.CSharp/Refactoring/TypeSystemAstBuilder.cs
@@ -829,7 +829,7 @@ PropertyDeclaration ConvertProperty(IProperty property)
 			decl.Name = property.Name;
 			decl.Getter = ConvertAccessor(property.Getter, property.Accessibility, false);
 			decl.Setter = ConvertAccessor(property.Setter, property.Accessibility, true);
-			decl.PrivateImplementationType = GetExcplicitInterfaceType (property);
+			decl.PrivateImplementationType = GetExplicitInterfaceType (property);
 			return decl;
 		}
 		
@@ -846,7 +846,7 @@ IndexerDeclaration ConvertIndexer(IProperty indexer)
 			}
 			decl.Getter = ConvertAccessor(indexer.Getter, indexer.Accessibility, false);
 			decl.Setter = ConvertAccessor(indexer.Setter, indexer.Accessibility, true);
-			decl.PrivateImplementationType = GetExcplicitInterfaceType (indexer);
+			decl.PrivateImplementationType = GetExplicitInterfaceType (indexer);
 			return decl;
 		}
 		
@@ -910,7 +910,7 @@ MethodDeclaration ConvertMethod(IMethod method)
 				}
 			}
 			decl.Body = GenerateBodyBlock();
-			decl.PrivateImplementationType = GetExcplicitInterfaceType (method);
+			decl.PrivateImplementationType = GetExplicitInterfaceType (method);
 			return decl;
 		}
 		
@@ -978,7 +978,8 @@ public static Modifiers ModifierFromAccessibility(Accessibility accessibility)
 		
 		bool NeedsAccessibility(IMember member)
 		{
-			if (member.DeclaringType.Kind == TypeKind.Interface || member.IsExplicitInterfaceImplementation)
+			var declaringType = member.DeclaringType;
+			if ((declaringType != null && declaringType.Kind == TypeKind.Interface) || member.IsExplicitInterfaceImplementation)
 				return false;
 			switch (member.SymbolKind) {
 				case SymbolKind.Constructor:
@@ -1000,7 +1001,8 @@ Modifiers GetMemberModifiers(IMember member)
 				if (member.IsStatic) {
 					m |= Modifiers.Static;
 				} else {
-					if (member.IsAbstract && member.DeclaringType.Kind != TypeKind.Interface)
+					var declaringType = member.DeclaringType;
+					if (member.IsAbstract && declaringType != null && declaringType.Kind != TypeKind.Interface)
 						m |= Modifiers.Abstract;
 					if (member.IsOverride)
 						m |= Modifiers.Override;
@@ -1075,7 +1077,7 @@ NamespaceDeclaration ConvertNamespaceDeclaration(INamespace ns)
 			return new NamespaceDeclaration(ns.FullName);
 		}
 
-		AstType GetExcplicitInterfaceType (IMember member)
+		AstType GetExplicitInterfaceType (IMember member)
 		{
 			if (member.IsExplicitInterfaceImplementation) {
 				var baseMember = member.ImplementedInterfaceMembers.FirstOrDefault ();
diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs b/ICSharpCode.NRefactory.CSharp/Resolver/CSharpOperators.cs
@@ -120,7 +120,7 @@ ITypeDefinition IEntity.DeclaringTypeDefinition {
 			}
 			
 			IType IEntity.DeclaringType {
-				get { return SpecialType.UnknownType; }
+				get { return null; }
 			}
 			
 			IMember IMember.MemberDefinition {
diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs b/ICSharpCode.NRefactory.CSharp/Resolver/CSharpResolver.cs
@@ -2252,7 +2252,7 @@ public ResolveResult ResolveObjectCreation(IType type, ResolveResult[] arguments
 				if (invoke != null) {
 					input = new MethodGroupResolveResult(
 						input, invoke.Name,
-						methods: new[] { new MethodListWithDeclaringType(invoke.DeclaringType) { invoke } },
+						methods: new[] { new MethodListWithDeclaringType(input.Type) { invoke } },
 						typeArguments: EmptyList<IType>.Instance
 					);
 				}
diff --git a/ICSharpCode.NRefactory.CSharp/Resolver/OverloadResolution.cs b/ICSharpCode.NRefactory.CSharp/Resolver/OverloadResolution.cs
@@ -944,7 +944,7 @@ public CSharpInvocationResolveResult CreateResolveResult(ResolveResult targetRes
 				throw new InvalidOperationException();
 
 			return new CSharpInvocationResolveResult(
-				this.IsExtensionMethodInvocation ? new TypeResolveResult(member.DeclaringType) : targetResolveResult,
+				this.IsExtensionMethodInvocation ? new TypeResolveResult(member.DeclaringType ?? SpecialType.UnknownType) : targetResolveResult,
 				member,
 				GetArgumentsWithConversions(targetResolveResult, member),
 				this.BestCandidateErrors,
diff --git a/ICSharpCode.NRefactory/Analysis/SymbolCollector.cs b/ICSharpCode.NRefactory/Analysis/SymbolCollector.cs
@@ -130,7 +130,7 @@ public IEnumerable<ISymbol> GetRelatedSymbols(Lazy<TypeGraph> g, ISymbol m)
 					symbols.AddRange(member.ImplementedInterfaceMembers);
 				}
 
-				if (member.DeclaringType.Kind == TypeKind.Interface) {
+				if (member.DeclaringTypeDefinition != null && member.DeclaringTypeDefinition.Kind == TypeKind.Interface) {
 					var declaringTypeNode = g.Value.GetNode(member.DeclaringTypeDefinition);
 					if (declaringTypeNode != null) {
 						foreach (var derivedType in declaringTypeNode.DerivedTypes) {
diff --git a/ICSharpCode.NRefactory/Documentation/IdStringProvider.cs b/ICSharpCode.NRefactory/Documentation/IdStringProvider.cs
@@ -58,8 +58,10 @@ public static string GetIdString(this IEntity entity)
 					break;
 			}
 			IMember member = (IMember)entity;
-			AppendTypeName(b, member.DeclaringType, false);
-			b.Append('.');
+			if (member.DeclaringType != null) {
+				AppendTypeName(b, member.DeclaringType, false);
+				b.Append('.');
+			}
 			if (member.IsExplicitInterfaceImplementation && member.Name.IndexOf('.') < 0 && member.ImplementedInterfaceMembers.Count == 1) {
 				AppendTypeName(b, member.ImplementedInterfaceMembers[0].DeclaringType, true);
 				b.Append('#');
diff --git a/ICSharpCode.NRefactory/Semantics/MemberResolveResult.cs b/ICSharpCode.NRefactory/Semantics/MemberResolveResult.cs
@@ -72,7 +72,7 @@ static IType ComputeType(IMember member)
 		{
 			switch (member.SymbolKind) {
 				case SymbolKind.Constructor:
-					return member.DeclaringType;
+					return member.DeclaringType ?? SpecialType.UnknownType;
 				case SymbolKind.Field:
 					if (((IField)member).IsFixed)
 						return new PointerType(member.ReturnType);
diff --git a/ICSharpCode.NRefactory/TypeSystem/IEntity.cs b/ICSharpCode.NRefactory/TypeSystem/IEntity.cs
@@ -125,7 +125,7 @@ public interface IEntity : ISymbol, ICompilationProvider, INamedElement, IHasAcc
 		
 		/// <summary>
 		/// Gets/Sets the declaring type (incl. type arguments, if any).
-		/// This property never returns null -- for top-level entities, it returns SharedTypes.UnknownType.
+		/// This property will return null for top-level entities.
 		/// If this is not a specialized member, the value returned is equal to <see cref="DeclaringTypeDefinition"/>.
 		/// </summary>
 		IType DeclaringType { get; }
diff --git a/ICSharpCode.NRefactory/TypeSystem/ITypeDefinition.cs b/ICSharpCode.NRefactory/TypeSystem/ITypeDefinition.cs
@@ -132,7 +132,7 @@ public interface ITypeDefinition : IType, IEntity
 		
 		/// <summary>
 		/// Gets/Sets the declaring type (incl. type arguments, if any).
-		/// This property never returns null -- for top-level entities, it returns SharedTypes.UnknownType.
+		/// This property will return null for top-level types.
 		/// </summary>
 		new IType DeclaringType { get; } // solves ambiguity between IType.DeclaringType and IEntity.DeclaringType
 		
diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedEntity.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedEntity.cs
@@ -63,7 +63,7 @@ public ITypeDefinition DeclaringTypeDefinition {
 		}
 		
 		public virtual IType DeclaringType {
-			get { return parentContext.CurrentTypeDefinition ?? (IType)SpecialType.UnknownType; }
+			get { return parentContext.CurrentTypeDefinition; }
 		}
 		
 		public IAssembly ParentAssembly {
diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/AbstractResolvedMember.cs
@@ -134,7 +134,8 @@ IMemberReference IMember.ToReference()
 		
 		public override ISymbolReference ToReference()
 		{
-			var declTypeRef = this.DeclaringType.ToTypeReference();
+			var declType = this.DeclaringType;
+			var declTypeRef = declType != null ? declType.ToTypeReference() : SpecialType.UnknownType;
 			if (IsExplicitInterfaceImplementation && ImplementedInterfaceMembers.Count == 1) {
 				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToReference());
 			} else {
diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultAttribute.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultAttribute.cs
@@ -53,7 +53,7 @@ public DefaultAttribute(IMethod constructor, IList<ResolveResult> positionalArgu
 			if (constructor == null)
 				throw new ArgumentNullException("constructor");
 			this.constructor = constructor;
-			this.attributeType = constructor.DeclaringType;
+			this.attributeType = constructor.DeclaringType ?? SpecialType.UnknownType;
 			this.positionalArguments = positionalArguments ?? EmptyList<ResolveResult>.Instance;
 			this.namedArguments = namedArguments ?? EmptyList<KeyValuePair<IMember, ResolveResult>>.Instance;
 			this.region = region;
diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedMethod.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedMethod.cs
@@ -236,7 +236,8 @@ public virtual IMember AccessorOwner {
 		
 		public override ISymbolReference ToReference()
 		{
-			var declTypeRef = this.DeclaringType.ToTypeReference();
+			var declType = this.DeclaringType;
+			var declTypeRef = declType != null ? declType.ToTypeReference() : SpecialType.UnknownType;
 			if (IsExplicitInterfaceImplementation && ImplementedInterfaceMembers.Count == 1) {
 				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToReference());
 			} else {
@@ -270,7 +271,7 @@ public override string ToString()
 			StringBuilder b = new StringBuilder("[");
 			b.Append(this.SymbolKind);
 			b.Append(' ');
-			if (this.DeclaringType.Kind != TypeKind.Unknown) {
+			if (this.DeclaringType != null) {
 				b.Append(this.DeclaringType.ReflectionName);
 				b.Append('.');
 			}
diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedProperty.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultResolvedProperty.cs
@@ -87,7 +87,8 @@ public bool IsIndexer {
 		
 		public override ISymbolReference ToReference()
 		{
-			var declTypeRef = this.DeclaringType.ToTypeReference();
+			var declType = this.DeclaringType;
+			var declTypeRef = declType != null ? declType.ToTypeReference() : SpecialType.UnknownType;
 			if (IsExplicitInterfaceImplementation && ImplementedInterfaceMembers.Count == 1) {
 				return new ExplicitInterfaceImplementationMemberReference(declTypeRef, ImplementedInterfaceMembers[0].ToReference());
 			} else {
diff --git a/ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs b/ICSharpCode.NRefactory/TypeSystem/Implementation/SpecializedMember.cs
@@ -129,7 +129,7 @@ public IType DeclaringType {
 					} else {
 						result = new ParameterizedType(definitionDeclaringTypeDef, definitionDeclaringTypeDef.TypeParameters).AcceptVisitor(substitution);
 					}
-				} else {
+				} else if (definitionDeclaringType != null) {
 					result = definitionDeclaringType.AcceptVisitor(substitution);
 				}
 				return LazyInit.GetOrSet(ref this.declaringType, result);
@@ -138,7 +138,6 @@ internal set {
 				// This setter is used as an optimization when the code constructing
 				// the SpecializedMember already knows the declaring type.
 				Debug.Assert(this.declaringType == null);
-				Debug.Assert(value != null);
 				// As this setter is used only during construction before the member is published
 				// to other threads, we don't need a volatile write.
 				this.declaringType = value;

Original file line number	Diff line number	Diff line change
`@@ -613,7 +613,7 @@ IEnumerable<ICompletionData> HandleToStringFormatItems()`
`613`	`613`	`if (invokeResult == null)`
`614`	`614`	`return Enumerable.Empty<ICompletionData>();`
`615`	`615`	`if (invokeResult.Member.Name == "ToString")`
`616`		`- return GetFormatCompletionData(invokeResult.Member.DeclaringType) ?? Enumerable.Empty<ICompletionData>();`
	`616`	`+ return GetFormatCompletionData(invokeResult.Member.DeclaringType ?? SpecialType.UnknownType) ?? Enumerable.Empty<ICompletionData>();`
`617`	`617`	`return Enumerable.Empty<ICompletionData>();`
`618`	`618`	`}`
`619`	`619`
Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ void WriteMemberDeclarationName(IMember member, TokenWriter writer, CSharpFormat`
`203`	`203`	`{`
`204`	`204`	`TypeSystemAstBuilder astBuilder = CreateAstBuilder();`
`205`	`205`	`EntityDeclaration node = astBuilder.ConvertEntity(member);`
`206`		`- if ((ConversionFlags & ConversionFlags.ShowDeclaringType) == ConversionFlags.ShowDeclaringType) {`
	`206`	`+ if ((ConversionFlags & ConversionFlags.ShowDeclaringType) == ConversionFlags.ShowDeclaringType && member.DeclaringType != null) {`
`207`	`207`	`ConvertType(member.DeclaringType, writer, formattingPolicy);`
`208`	`208`	`writer.WriteToken(Roles.Dot, ".");`
`209`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -829,7 +829,7 @@ PropertyDeclaration ConvertProperty(IProperty property)`
`829`	`829`	`decl.Name = property.Name;`
`830`	`830`	`decl.Getter = ConvertAccessor(property.Getter, property.Accessibility, false);`
`831`	`831`	`decl.Setter = ConvertAccessor(property.Setter, property.Accessibility, true);`
`832`		`- decl.PrivateImplementationType = GetExcplicitInterfaceType (property);`
	`832`	`+ decl.PrivateImplementationType = GetExplicitInterfaceType (property);`
`833`	`833`	`return decl;`
`834`	`834`	`}`
`835`	`835`
`@@ -846,7 +846,7 @@ IndexerDeclaration ConvertIndexer(IProperty indexer)`
`846`	`846`	`}`
`847`	`847`	`decl.Getter = ConvertAccessor(indexer.Getter, indexer.Accessibility, false);`
`848`	`848`	`decl.Setter = ConvertAccessor(indexer.Setter, indexer.Accessibility, true);`
`849`		`- decl.PrivateImplementationType = GetExcplicitInterfaceType (indexer);`
	`849`	`+ decl.PrivateImplementationType = GetExplicitInterfaceType (indexer);`
`850`	`850`	`return decl;`
`851`	`851`	`}`
`852`	`852`
`@@ -910,7 +910,7 @@ MethodDeclaration ConvertMethod(IMethod method)`
`910`	`910`	`}`
`911`	`911`	`}`
`912`	`912`	`decl.Body = GenerateBodyBlock();`
`913`		`- decl.PrivateImplementationType = GetExcplicitInterfaceType (method);`
	`913`	`+ decl.PrivateImplementationType = GetExplicitInterfaceType (method);`
`914`	`914`	`return decl;`
`915`	`915`	`}`
`916`	`916`
`@@ -978,7 +978,8 @@ public static Modifiers ModifierFromAccessibility(Accessibility accessibility)`
`978`	`978`
`979`	`979`	`bool NeedsAccessibility(IMember member)`
`980`	`980`	`{`
`981`		`- if (member.DeclaringType.Kind == TypeKind.Interface \|\| member.IsExplicitInterfaceImplementation)`
	`981`	`+ var declaringType = member.DeclaringType;`
	`982`	`+ if ((declaringType != null && declaringType.Kind == TypeKind.Interface) \|\| member.IsExplicitInterfaceImplementation)`
`982`	`983`	`return false;`
`983`	`984`	`switch (member.SymbolKind) {`
`984`	`985`	`case SymbolKind.Constructor:`
`@@ -1000,7 +1001,8 @@ Modifiers GetMemberModifiers(IMember member)`
`1000`	`1001`	`if (member.IsStatic) {`
`1001`	`1002`	`m \|= Modifiers.Static;`
`1002`	`1003`	`} else {`
`1003`		`- if (member.IsAbstract && member.DeclaringType.Kind != TypeKind.Interface)`
	`1004`	`+ var declaringType = member.DeclaringType;`
	`1005`	`+ if (member.IsAbstract && declaringType != null && declaringType.Kind != TypeKind.Interface)`
`1004`	`1006`	`m \|= Modifiers.Abstract;`
`1005`	`1007`	`if (member.IsOverride)`
`1006`	`1008`	`m \|= Modifiers.Override;`
`@@ -1075,7 +1077,7 @@ NamespaceDeclaration ConvertNamespaceDeclaration(INamespace ns)`
`1075`	`1077`	`return new NamespaceDeclaration(ns.FullName);`
`1076`	`1078`	`}`
`1077`	`1079`
`1078`		`- AstType GetExcplicitInterfaceType (IMember member)`
	`1080`	`+ AstType GetExplicitInterfaceType (IMember member)`
`1079`	`1081`	`{`
`1080`	`1082`	`if (member.IsExplicitInterfaceImplementation) {`
`1081`	`1083`	`var baseMember = member.ImplementedInterfaceMembers.FirstOrDefault ();`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ ITypeDefinition IEntity.DeclaringTypeDefinition {`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`IType IEntity.DeclaringType {`
`123`		`- get { return SpecialType.UnknownType; }`
	`123`	`+ get { return null; }`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`IMember IMember.MemberDefinition {`
Original file line number	Diff line number	Diff line change
`@@ -2252,7 +2252,7 @@ public ResolveResult ResolveObjectCreation(IType type, ResolveResult[] arguments`
`2252`	`2252`	`if (invoke != null) {`
`2253`	`2253`	`input = new MethodGroupResolveResult(`
`2254`	`2254`	`input, invoke.Name,`
`2255`		`- methods: new[] { new MethodListWithDeclaringType(invoke.DeclaringType) { invoke } },`
	`2255`	`+ methods: new[] { new MethodListWithDeclaringType(input.Type) { invoke } },`
`2256`	`2256`	`typeArguments: EmptyList<IType>.Instance`
`2257`	`2257`	`);`
`2258`	`2258`	`}`