Fix bugs in RedundantNamespaceUsageIssue and CreatePropertyAction.

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

@@ -1,4 +1,4 @@
-// 
+// 
 // CreateProperty.cs
 //  
 // Author:
@@ -64,15 +64,14 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 				createInOtherType = !state.CurrentTypeDefinition.Equals(targetResolveResult.Type.GetDefinition());
 			}
 
-			bool isStatic;
+			bool isStatic = targetResolveResult is TypeResolveResult;
 			if (createInOtherType) {
-				isStatic = targetResolveResult is TypeResolveResult;
 				if (isStatic && targetResolveResult.Type.Kind == TypeKind.Interface)
 					yield break;
 			} else {
 				if (state.CurrentMember == null || state.CurrentTypeDefinition == null)
 					yield break;
-				isStatic = state.CurrentMember.IsStatic || state.CurrentTypeDefinition.IsStatic;
+				isStatic |= state.CurrentMember.IsStatic || state.CurrentTypeDefinition.IsStatic;
 			}
 
 //			var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));

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

@@ -1,4 +1,4 @@
-// 
+// 
 // RedundantInternalInspector.cs
 //  
 // Author:
@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 	/// <summary>
 	/// Finds redundant internal modifiers.
 	/// </summary>
-	[IssueDescription("Remove redunant 'internal' modifier",
+	[IssueDescription("Remove redundant 'internal' modifier",
 	       Description="Removes 'internal' modifiers that are not required.", 
 	       Category = IssueCategories.Redundancies,
 	       Severity = Severity.Hint,

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

@@ -1,6 +1,6 @@
-// 
+// 
 // RedundantNamespaceUsageInspector.cs
-//  
+//
 // Author:
 //       Mike Krüger <mkrueger@xamarin.com>
 // 
@@ -37,10 +37,10 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 	/// Finds redundant namespace usages.
 	/// </summary>
 	[IssueDescription("Remove redundant namespace usages",
-	       Description = "Removes namespace usages that are obsolete.",
+	                  Description = "Removes namespace usages that are obsolete.",
-	       Category = IssueCategories.Redundancies,
+	                  Category = IssueCategories.Redundancies,
-	       Severity = Severity.Hint,
+	                  Severity = Severity.Hint,
-	       IssueMarker = IssueMarker.GrayOut)]
+	                  IssueMarker = IssueMarker.GrayOut)]
 	public class RedundantNamespaceUsageIssue : ICodeIssueProvider
 	{
 		public IEnumerable<CodeIssue> GetIssues (BaseRefactoringContext context)
@@ -62,24 +62,40 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
 			public override void VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression)
 			{
 				base.VisitMemberReferenceExpression(memberReferenceExpression);
-				
+				HandleMemberReference(
-				var result = ctx.Resolve(memberReferenceExpression.Target);
+					memberReferenceExpression, memberReferenceExpression.Target, memberReferenceExpression.MemberNameToken, memberReferenceExpression.TypeArguments, SimpleNameLookupMode.Expression,
+					script => {
+						script.Replace(memberReferenceExpression, RefactoringAstHelper.RemoveTarget(memberReferenceExpression));
+					});
+			}
+			
+			public override void VisitMemberType(MemberType memberType)
+			{
+				base.VisitMemberType(memberType);
+				HandleMemberReference(
+					memberType, memberType.Target, memberType.MemberNameToken, memberType.TypeArguments, SimpleNameLookupMode.Type,
+					script => {
+						script.Replace(memberType, RefactoringAstHelper.RemoveTarget(memberType));
+					});
+			}
+			
+			void HandleMemberReference(AstNode wholeNode, AstNode targetNode, Identifier memberName, IEnumerable<AstType> typeArguments, SimpleNameLookupMode mode, Action<Script> action)
+			{
+				var result = ctx.Resolve(targetNode);
 				if (!(result is NamespaceResolveResult)) {
 					return;
 				}
-				var wholeResult = ctx.Resolve(memberReferenceExpression);
+				var wholeResult = ctx.Resolve(wholeNode);
 				if (!(wholeResult is TypeResolveResult)) {
 					return;
 				}
 
-				var state = ctx.GetResolverStateBefore(memberReferenceExpression);
+				var state = ctx.GetResolverStateBefore(wholeNode);
-				var lookupName = state.LookupSimpleNameOrTypeName(memberReferenceExpression.MemberName, new List<IType> (), SimpleNameLookupMode.Expression);
+				var resolvedTypeArguments = typeArguments.Select(ctx.ResolveType).ToList();
+				var lookupName = state.LookupSimpleNameOrTypeName(memberName.Name, resolvedTypeArguments, mode);
 				
 				if (lookupName is TypeResolveResult && !lookupName.IsError && wholeResult.Type.Equals(lookupName.Type)) {
-					AddIssue(memberReferenceExpression.StartLocation, memberReferenceExpression.MemberNameToken.StartLocation, ctx.TranslateString("Remove redundant namespace usage"), script => {
+					AddIssue(wholeNode.StartLocation, memberName.StartLocation, ctx.TranslateString("Remove redundant namespace usage"), action);
-						script.Replace(memberReferenceExpression, RefactoringAstHelper.RemoveTarget(memberReferenceExpression));
-					}
-					);
 				}
 			}
 		}

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

@@ -1,4 +1,4 @@
-// 
+// 
 // CreatePropertyTests.cs
 //  
 // Author:
@@ -242,5 +242,26 @@ class TestClass
 }");
 		}
 
+		[Test()]
+		public void CreateStaticPropertyInCurrentType()
+		{
+			Test<CreatePropertyAction> (@"class TestClass
+{
+	public TestClass ()
+	{
+		TestClass.$Foo = 5;
+	}
+}", @"class TestClass
+{
+	static int Foo {
+		get;
+		set;
+	}
+	public TestClass ()
+	{
+		TestClass.Foo = 5;
+	}
+}");
+		}
 	}
 }

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

@@ -1,6 +1,6 @@
-// 
+// 
 // RedundantNamespaceUsageInspectorTests.cs
-//  
+//
 // Author:
 //       Mike Krüger <mkrueger@xamarin.com>
 // 
@@ -56,6 +56,29 @@ class Foo
 	{
 		Console.WriteLine ();
 	}
+}");
+		}
+		
+		[Test]
+		public void TestInspectorCase2 ()
+		{
+			var input = @"using System.Text;
+class Foo
+{
+	void Bar (System.Text.StringBuilder b)
+	{
+	}
+}";
+
+			TestRefactoringContext context;
+			var issues = GetIssues (new RedundantNamespaceUsageIssue (), input, out context);
+			Assert.AreEqual (1, issues.Count);
+			CheckFix (context, issues, @"using System.Text;
+class Foo
+{
+	void Bar (StringBuilder b)
+	{
+	}
 }");
 		}
 	}