Merge pull request #1853 from sharwell/validname-accuracy

Improve IsValidNewMemberName accuracy

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/Helpers/RenameHelper.cs

@@ -3,6 +3,7 @@
 
 namespace StyleCop.Analyzers.Helpers
 {
+    using System.Collections.Immutable;
     using System.Threading;
     using System.Threading.Tasks;
     using Microsoft.CodeAnalysis;
@@ -31,10 +32,19 @@ public static async Task<Solution> RenameSymbolAsync(Document document, SyntaxNo
 
         public static bool IsValidNewMemberName(SemanticModel semanticModel, ISymbol symbol, string name)
         {
-            var members = (symbol as INamedTypeSymbol)?.GetMembers(name);
-            if (members.HasValue && !members.Value.IsDefaultOrEmpty)
+            if (symbol.Kind == SymbolKind.NamedType)
             {
-                return false;
+                TypeKind typeKind = ((INamedTypeSymbol)symbol).TypeKind;
+
+                // If the symbol is a class or struct, the name can't be the same as any of its members.
+                if (typeKind == TypeKind.Class || typeKind == TypeKind.Struct)
+                {
+                    var members = (symbol as INamedTypeSymbol)?.GetMembers(name);
+                    if (members.HasValue && !members.Value.IsDefaultOrEmpty)
+                    {
+                        return false;
+                    }
+                }
             }
 
             var containingSymbol = symbol.ContainingSymbol as INamespaceOrTypeSymbol;
@@ -50,16 +60,21 @@ public static bool IsValidNewMemberName(SemanticModel semanticModel, ISymbol sym
             }
             else if (containingSymbol.Kind == SymbolKind.NamedType)
             {
-                // The name can't be the same as the name of the containing type
-                if (containingSymbol.Name == name)
+                TypeKind typeKind = ((INamedTypeSymbol)containingSymbol).TypeKind;
+
+                // If the containing type is a class or struct, the name can't be the same as the name of the containing
+                // type.
+                if ((typeKind == TypeKind.Class || typeKind == TypeKind.Struct)
+                    && containingSymbol.Name == name)
                 {
                     return false;
                 }
             }
 
-            // The name can't be the same as the name of an other member of the same type
-            members = containingSymbol.GetMembers(name);
-            if (!members.Value.IsDefaultOrEmpty)
+            // The name can't be the same as the name of an other member of the same type. At this point no special
+            // consideration is given to overloaded methods.
+            ImmutableArray<ISymbol> siblings = containingSymbol.GetMembers(name);
+            if (!siblings.IsDefaultOrEmpty)
             {
                 return false;
             }

StyleCop.Analyzers/StyleCop.Analyzers.Test/NamingRules/SA1300UnitTests.cs

@@ -252,6 +252,25 @@ public class Test { }";
             await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestLowerCaseEnumWithMemberMatchingTargetNameAsync()
+        {
+            var testCode = @"public enum test
+{
+    Test
+}";
+            var fixedCode = @"public enum Test
+{
+    Test
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithArguments("test").WithLocation(1, 13);
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestUpperCaseDelegateAsync()
         {
@@ -807,15 +826,17 @@ public event System.EventHandler fooBar
 
     public void foo()
     {
-
     }
+
+    public string iInterface { get; }
 }
 
 public interface IInterface
 {
     void foo();
     int bar { get; }
     event System.EventHandler fooBar;
+    string iInterface { get; }
 }";
             var fixedCode = @"public class TestClass : IInterface
 {
@@ -835,22 +856,25 @@ public event System.EventHandler FooBar
 
     public void Foo()
     {
-
     }
+
+    public string IInterface { get; }
 }
 
 public interface IInterface
 {
     void Foo();
     int Bar { get; }
     event System.EventHandler FooBar;
+    string IInterface { get; }
 }";
 
             var expected = new[]
             {
-                this.CSharpDiagnostic().WithLocation(25, 10).WithArguments("foo"),
-                this.CSharpDiagnostic().WithLocation(26, 9).WithArguments("bar"),
-                this.CSharpDiagnostic().WithLocation(27, 31).WithArguments("fooBar"),
+                this.CSharpDiagnostic().WithLocation(26, 10).WithArguments("foo"),
+                this.CSharpDiagnostic().WithLocation(27, 9).WithArguments("bar"),
+                this.CSharpDiagnostic().WithLocation(28, 31).WithArguments("fooBar"),
+                this.CSharpDiagnostic().WithLocation(29, 12).WithArguments("iInterface"),
             };
 
             await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);

StyleCop.Analyzers/StyleCop.Analyzers.Test/NamingRules/SA1302UnitTests.cs

@@ -209,15 +209,15 @@ public interface IFoo { }";
         }
 
         [Fact]
-        public async Task TestInterfaceDeclarationDoesNotStartWithIWithMemberConflictAsync()
+        public async Task TestInterfaceDeclarationDoesNotStartWithIWithMemberMatchingTargetNameAsync()
         {
             string testCode = @"
 public interface Foo
 {
     int IFoo { get; }
 }";
             string fixedCode = @"
-public interface IFoo1
+public interface IFoo
 {
     int IFoo { get; }
 }";

documentation/SA1300.md

@@ -21,15 +21,30 @@ The name of a C# element does not begin with an upper-case letter.
 
 ## Rule description
 
-A violation of this rule occurs when the names of certain types of elements do not begin with an upper-case letter. The following types of elements should use an upper-case letter as the first letter of the element name: *namespaces, classes, enums, structs, delegates, events, methods,* and *properties*.
-
-In addition, any field which is public, internal, or marked with the const attribute should begin with an upper-case letter. Non-private readonly fields must also be named using an upper-case letter.
-
-If the field or variable name is intended to match the name of an item associated with Win32 or COM, and thus needs to begin with a lower-case letter, place the field or variable within a special *NativeMethods* class. A NativeMethods class is any class which contains a name ending in NativeMethods, and is intended as a placeholder for Win32 or COM wrappers. StyleCop will ignore this violation if the item is placed within a NativeMethods class.
+A violation of this rule occurs when the names of certain types of elements do not begin with an upper-case letter. The
+following types of elements should use an upper-case letter as the first letter of the element name:
+
+* Namespaces
+* Classes
+* Enums
+* Structs
+* Delegates
+* Events
+* Methods
+* Properties
+
+In addition, any field which is public, internal, or marked with the const attribute should begin with an upper-case
+letter. Non-private readonly fields must also be named using an upper-case letter.
+
+If the field or variable name is intended to match the name of an item associated with Win32 or COM, and thus needs to
+begin with a lower-case letter, place the field or variable within a special `NativeMethods` class. A `NativeMethods`
+class is any class which contains a name ending in `NativeMethods`, and is intended as a placeholder for Win32 or COM
+wrappers. StyleCop will ignore this violation if the item is placed within a `NativeMethods` class.
 
 ## How to fix violations
 
-To fix a violation of this rule, change the name of the element so that it begins with an upper-case letter, or place the item within a NativeMethods class if appropriate.
+To fix a violation of this rule, change the name of the element so that it begins with an upper-case letter, or place
+the item within a `NativeMethods` class if appropriate.
 
 ## How to suppress violations