Fix #120: RedundantNamespaceUsageIssue bad handling of using aliases

ICSharpCode.NRefactory.CSharp/Ast/AstType.cs

@@ -127,6 +127,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		/// <summary>
 		/// Create an ITypeReference for this AstType.
+		/// Uses the context (ancestors of this node) to determine the correct <see cref="NameLookupMode"/>.
 		/// </summary>
 		/// <remarks>
 		/// The resulting type reference will read the context information from the
@@ -135,7 +136,42 @@ namespace ICSharpCode.NRefactory.CSharp
 		/// For resolving simple names, the current namespace and usings from the CurrentUsingScope
 		/// (on CSharpTypeResolveContext only) is used.
 		/// </remarks>
-		public abstract ITypeReference ToTypeReference(NameLookupMode lookupMode = NameLookupMode.Type, InterningProvider interningProvider = null);
+		public ITypeReference ToTypeReference(InterningProvider interningProvider = null)
+		{
+			return ToTypeReference(GetNameLookupMode(), interningProvider);
+		}
+		
+		/// <summary>
+		/// Create an ITypeReference for this AstType.
+		/// </summary>
+		/// <remarks>
+		/// The resulting type reference will read the context information from the
+		/// <see cref="ITypeResolveContext"/>:
+		/// For resolving type parameters, the CurrentTypeDefinition/CurrentMember is used.
+		/// For resolving simple names, the current namespace and usings from the CurrentUsingScope
+		/// (on CSharpTypeResolveContext only) is used.
+		/// </remarks>
+		public abstract ITypeReference ToTypeReference(NameLookupMode lookupMode, InterningProvider interningProvider = null);
+		
+		/// <summary>
+		/// Gets the name lookup mode from the context (looking at the ancestors of this <see cref="AstType"/>).
+		/// </summary>
+		public NameLookupMode GetNameLookupMode()
+		{
+			AstType outermostType = this;
+			while (outermostType.Parent is AstType)
+				outermostType = (AstType)outermostType.Parent;
+			
+			if (outermostType.Parent is UsingDeclaration || outermostType.Parent is UsingAliasDeclaration) {
+				return NameLookupMode.TypeInUsingDeclaration;
+			} else if (outermostType.Role == Roles.BaseType) {
+				// Use BaseTypeReference for a type's base type, and for a constraint on a type.
+				// Do not use it for a constraint on a method.
+				if (outermostType.Parent is TypeDeclaration || (outermostType.Parent is Constraint && outermostType.Parent.Parent is TypeDeclaration))
+					return NameLookupMode.BaseTypeReference;
+			}
+			return NameLookupMode.Type;
+		}
 		
 		/// <summary>
 		/// Creates a pointer type from this type by nesting it in a <see cref="ComposedType"/>.

ICSharpCode.NRefactory.CSharp/Ast/ComposedType.cs

@@ -126,7 +126,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			return this;
 		}
 		
-		public override ITypeReference ToTypeReference(NameLookupMode lookupMode = NameLookupMode.Type, InterningProvider interningProvider = null)
+		public override ITypeReference ToTypeReference(NameLookupMode lookupMode, InterningProvider interningProvider = null)
 		{
 			if (interningProvider == null)
 				interningProvider = InterningProvider.Dummy;

ICSharpCode.NRefactory.CSharp/Ast/MemberType.cs

@@ -135,7 +135,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			return b.ToString();
 		}
 		
-		public override ITypeReference ToTypeReference(NameLookupMode lookupMode = NameLookupMode.Type, InterningProvider interningProvider = null)
+		public override ITypeReference ToTypeReference(NameLookupMode lookupMode, InterningProvider interningProvider = null)
 		{
 			if (interningProvider == null)
 				interningProvider = InterningProvider.Dummy;

ICSharpCode.NRefactory.CSharp/Ast/PrimitiveType.cs

@@ -103,7 +103,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			return Keyword;
 		}
 		
-		public override ITypeReference ToTypeReference(NameLookupMode lookupMode = NameLookupMode.Type, InterningProvider interningProvider = null)
+		public override ITypeReference ToTypeReference(NameLookupMode lookupMode, InterningProvider interningProvider = null)
 		{
 			KnownTypeCode typeCode = GetTypeCodeForPrimitiveType(this.Keyword);
 			if (typeCode == KnownTypeCode.None)

ICSharpCode.NRefactory.CSharp/Ast/SimpleType.cs

@@ -158,7 +158,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			return b.ToString();
 		}
 		
-		public override ITypeReference ToTypeReference(NameLookupMode lookupMode = NameLookupMode.Type, InterningProvider interningProvider = null)
+		public override ITypeReference ToTypeReference(NameLookupMode lookupMode, InterningProvider interningProvider = null)
 		{
 			if (interningProvider == null)
 				interningProvider = InterningProvider.Dummy;

ICSharpCode.NRefactory.CSharp/Refactoring/CodeIssues/RedundantNamespaceUsageIssue.cs

@@ -71,7 +71,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			{
 				base.VisitMemberType(memberType);
 				HandleMemberReference(
-					memberType, memberType.Target, memberType.MemberNameToken, memberType.TypeArguments, NameLookupMode.Type,
+					memberType, memberType.Target, memberType.MemberNameToken, memberType.TypeArguments, memberType.GetNameLookupMode(),
 					script => {
 						script.Replace(memberType, RefactoringAstHelper.RemoveTarget(memberType));
 					});

ICSharpCode.NRefactory.CSharp/Resolver/ResolveVisitor.cs

@@ -3268,7 +3268,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 			
 			// Figure out the correct lookup mode:
-			NameLookupMode lookupMode = GetNameLookupMode(simpleType);
+			NameLookupMode lookupMode = simpleType.GetNameLookupMode();
 			
 			var typeArguments = ResolveTypeArguments(simpleType.TypeArguments);
 			Identifier identifier = simpleType.IdentifierToken;
@@ -3283,23 +3283,6 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			return rr;
 		}
 		
-		NameLookupMode GetNameLookupMode(AstType type)
-		{
-			AstType outermostType = type;
-			while (outermostType.Parent is AstType)
-				outermostType = (AstType)outermostType.Parent;
-			
-			if (outermostType.Parent is UsingDeclaration || outermostType.Parent is UsingAliasDeclaration) {
-				return NameLookupMode.TypeInUsingDeclaration;
-			} else if (outermostType.Role == Roles.BaseType) {
-				// Use BaseTypeReference for a type's base type, and for a constraint on a type.
-				// Do not use it for a constraint on a method.
-				if (outermostType.Parent is TypeDeclaration || (outermostType.Parent is Constraint && outermostType.Parent.Parent is TypeDeclaration))
-					return NameLookupMode.BaseTypeReference;
-			}
-			return NameLookupMode.Type;
-		}
-		
 		ResolveResult IAstVisitor<ResolveResult>.VisitMemberType(MemberType memberType)
 		{
 			ResolveResult target;
@@ -3316,7 +3299,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 				target = Resolve(memberType.Target);
 			}
 			
-			NameLookupMode lookupMode = GetNameLookupMode(memberType);
+			NameLookupMode lookupMode = memberType.GetNameLookupMode();
 			var typeArguments = ResolveTypeArguments(memberType.TypeArguments);
 			Identifier identifier = memberType.MemberNameToken;
 			ResolveResult rr = resolver.ResolveMemberAccess(target, identifier.Name, typeArguments, lookupMode);

ICSharpCode.NRefactory.Tests/CSharp/CodeIssues/RedundantNamespaceUsageInspectorTests.cs

@@ -81,5 +81,15 @@ class Foo
 	}
 }");
 		}
+		
+		[Test]
+		public void UsingAlias()
+		{
+			var input = @"using IEnumerable = System.Collections.IEnumerable;";
+
+			TestRefactoringContext context;
+			var issues = GetIssues (new RedundantNamespaceUsageIssue (), input, out context);
+			Assert.AreEqual (0, issues.Count);
+		}
 	}
 }