SA1413 now also checks enum members.

Author: Dirk Lemstra

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/MaintainabilityRules/SA1413CodeFixProvider.cs

@@ -16,6 +16,7 @@ namespace StyleCop.Analyzers.MaintainabilityRules
     using Microsoft.CodeAnalysis.CodeFixes;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
+    using Microsoft.CodeAnalysis.Text;
 
     /// <summary>
     /// Implements a code fix for <see cref="SA1413UseTrailingCommasInMultiLineInitializers"/>.
@@ -68,6 +69,11 @@ private static async Task<Document> GetTransformedDocumentAsync(Document documen
                 newParent = RewriteAnonymousObjectInitializer((AnonymousObjectCreationExpressionSyntax)parent);
                 break;
 
+            case SyntaxKind.EnumDeclaration:
+                var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+                TextChange textChange = GetEnumMemberTextChange(diagnostic, syntaxRoot);
+                return document.WithText(text.WithChanges(textChange));
+
             default:
                 throw new InvalidOperationException("Unknown initializer type: " + parent.Kind());
             }
@@ -115,5 +121,11 @@ private static SyntaxNode RewriteAnonymousObjectInitializer(AnonymousObjectCreat
             var fixedInitializer = initializer.WithInitializers(newInitializerExpressions);
             return fixedInitializer;
         }
+
+        private static TextChange GetEnumMemberTextChange(Diagnostic diagnostic, SyntaxNode syntaxRoot)
+        {
+            var member = (EnumMemberDeclarationSyntax)syntaxRoot.FindNode(diagnostic.Location.SourceSpan);
+            return new TextChange(diagnostic.Location.SourceSpan, member.ToString() + ",");
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers.Test/MaintainabilityRules/SA1413UnitTests.cs

@@ -425,6 +425,98 @@ void Foo()
             await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Verifies that the last value of an empty enum does not produce a diagnostic.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task VerifyEmptyEnumAsync()
+        {
+            var testCode = @"enum EmptyEnum
+{
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that the last value of an enum with a trailing comma does not produce a diagnostic.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task VerifyEnumWithTrailingCommaAsync()
+        {
+            var testCode = @"enum TestEnum
+{
+    One,
+    Two,
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that the last value of an enum without a trailing comma produces a diagnostic.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task VerifyEnumWithoutTrailingCommaAsync()
+        {
+            var testCode = @"enum TestEnum
+{
+    One,
+    Two
+}
+";
+
+            var fixedTestCode = @"enum TestEnum
+{
+    One,
+    Two,
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                this.CSharpDiagnostic().WithLocation(4, 5),
+            };
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Verifies that the last value of an enum without a trailing comma produces a diagnostic.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task VerifyEnumWithValueWithoutTrailingCommaAsync()
+        {
+            var testCode = @"enum TestEnum
+{
+    One = 2
+}
+";
+
+            var fixedTestCode = @"enum TestEnum
+{
+    One = 2,
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                this.CSharpDiagnostic().WithLocation(3, 5),
+            };
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
+        }
+
         /// <inheritdoc/>
         protected override CodeFixProvider GetCSharpCodeFixProvider()
         {

StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1413UseTrailingCommasInMultiLineInitializers.cs

@@ -5,6 +5,7 @@ namespace StyleCop.Analyzers.MaintainabilityRules
 {
     using System;
     using System.Collections.Immutable;
+    using System.Linq;
     using Helpers;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
@@ -73,6 +74,23 @@ public override void Initialize(AnalysisContext context)
 
             context.RegisterSyntaxNodeAction(HandleObjectInitializerAction, ObjectInitializerKinds);
             context.RegisterSyntaxNodeAction(HandleAnonymousObjectInitializerAction, SyntaxKind.AnonymousObjectCreationExpression);
+            context.RegisterSyntaxNodeAction(HandleEnumMemberDeclarationAction, SyntaxKind.EnumDeclaration);
+        }
+
+        private static void HandleEnumMemberDeclarationAction(SyntaxNodeAnalysisContext context)
+        {
+            var initializer = (EnumDeclarationSyntax)context.Node;
+            var lastMember = initializer.Members.LastOrDefault();
+            if (lastMember == null)
+            {
+                return;
+            }
+
+            var commas = initializer.ChildNodesAndTokens().OfType<SyntaxNodeOrToken>().Where(token => token.IsKind(SyntaxKind.CommaToken));
+            if (initializer.Members.Count() != commas.Count())
+            {
+                context.ReportDiagnostic(Diagnostic.Create(Descriptor, lastMember.GetLocation()));
+            }
         }
 
         private static void HandleObjectInitializer(SyntaxNodeAnalysisContext context)