Merge pull request #1860 from sharwell/check-enum-members

Add enum members to the list of elements checked by SA1300

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/NamingRules/RenameToUpperCaseCodeFixProvider.cs

@@ -90,7 +90,9 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                     }
 
                     bool usedSuffix = false;
-                    if (declaredSymbol.Kind == SymbolKind.Field && !await RenameHelper.IsValidNewMemberNameAsync(semanticModel, declaredSymbol, newName, context.CancellationToken).ConfigureAwait(false))
+                    if (declaredSymbol.Kind == SymbolKind.Field
+                        && declaredSymbol.ContainingType?.TypeKind != TypeKind.Enum
+                        && !await RenameHelper.IsValidNewMemberNameAsync(semanticModel, declaredSymbol, newName, context.CancellationToken).ConfigureAwait(false))
                     {
                         usedSuffix = true;
                         newName = newName + Suffix;

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

@@ -271,6 +271,101 @@ public async Task TestLowerCaseEnumWithMemberMatchingTargetNameAsync()
             await this.VerifyCSharpFixAsync(testCode, fixedCode).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestUpperCaseEnumMemberAsync()
+        {
+            var testCode = @"public enum Test
+{
+    Member
+}";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestLowerCaseEnumMemberAsync()
+        {
+            var testCode = @"public enum Test
+{
+    member
+}";
+            var fixedCode = @"public enum Test
+{
+    Member
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithArguments("member").WithLocation(3, 5);
+
+            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 TestLowerCaseEnumMemberWithConflictAsync()
+        {
+            var testCode = @"public enum Test
+{
+    member,
+    Member
+}";
+            var fixedCode = @"public enum Test
+{
+    Member1,
+    Member
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithArguments("member").WithLocation(3, 5);
+
+            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 TestLowerCaseEnumMemberWithTwoConflictsAsync()
+        {
+            var testCode = @"public enum Test
+{
+    member,
+    Member,
+    Member1,
+}";
+            var fixedCode = @"public enum Test
+{
+    Member2,
+    Member,
+    Member1,
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithArguments("member").WithLocation(3, 5);
+
+            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 TestLowerCaseEnumMemberWithNumberAndConflictAsync()
+        {
+            var testCode = @"public enum Test
+{
+    member1,
+    Member1
+}";
+            var fixedCode = @"public enum Test
+{
+    Member11,
+    Member1
+}";
+
+            DiagnosticResult expected = this.CSharpDiagnostic().WithArguments("member1").WithLocation(3, 5);
+
+            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()
         {

StyleCop.Analyzers/StyleCop.Analyzers/NamingRules/SA1300ElementMustBeginWithUpperCaseLetter.cs

@@ -48,6 +48,7 @@ internal class SA1300ElementMustBeginWithUpperCaseLetter : DiagnosticAnalyzer
         private static readonly Action<SyntaxNodeAnalysisContext> NamespaceDeclarationAction = HandleNamespaceDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> ClassDeclarationAction = HandleClassDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> EnumDeclarationAction = HandleEnumDeclaration;
+        private static readonly Action<SyntaxNodeAnalysisContext> EnumMemberDeclarationAction = HandleEnumMemberDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> StructDeclarationAction = HandleStructDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> DelegateDeclarationAction = HandleDelegateDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> EventDeclarationAction = HandleEventDeclaration;
@@ -72,6 +73,7 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
             context.RegisterSyntaxNodeActionHonorExclusions(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(ClassDeclarationAction, SyntaxKind.ClassDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(EnumDeclarationAction, SyntaxKind.EnumDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(EnumMemberDeclarationAction, SyntaxKind.EnumMemberDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(StructDeclarationAction, SyntaxKind.StructDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(DelegateDeclarationAction, SyntaxKind.DelegateDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(EventDeclarationAction, SyntaxKind.EventDeclaration);
@@ -121,6 +123,11 @@ private static void HandleEnumDeclaration(SyntaxNodeAnalysisContext context)
             CheckElementNameToken(context, ((EnumDeclarationSyntax)context.Node).Identifier);
         }
 
+        private static void HandleEnumMemberDeclaration(SyntaxNodeAnalysisContext context)
+        {
+            CheckElementNameToken(context, ((EnumMemberDeclarationSyntax)context.Node).Identifier);
+        }
+
         private static void HandleStructDeclaration(SyntaxNodeAnalysisContext context)
         {
             CheckElementNameToken(context, ((StructDeclarationSyntax)context.Node).Identifier);

documentation/KnownChanges.md

@@ -161,6 +161,12 @@ involving members of a type.
 
 ## Naming Rules
 
+### SA1300
+
+StyleCop Analyzers adds enum members to the list of elements which must start with an upper-case letter, and reports
+SA1300 for violations. StyleCop Classic did not report any messages for enum members that did not start with an
+upper-case letter.
+
 ### SA1305
 
 This rule is disabled by default in StyleCop Analyzers, but can be enabled by users via a rule set file.

documentation/SA1300.md

@@ -27,6 +27,7 @@ following types of elements should use an upper-case letter as the first letter
 * Namespaces
 * Classes
 * Enums
+* Enum members
 * Structs
 * Delegates
 * Events