Add prefer trailing commas code-style option

src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems

@@ -34,6 +34,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)NewLines\ConstructorInitializerPlacement\ConstructorInitializerPlacementDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)NewLines\MultipleBlankLines\CSharpMultipleBlankLinesDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)MatchFolderAndNamespace\CSharpMatchFolderAndNamespaceDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)PreferTrailingComma\PreferTrailingCommaDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveRedundantEquality\CSharpRemoveRedundantEqualityDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryDiscardDesignation\CSharpRemoveUnnecessaryDiscardDesignationDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs" />

src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx

@@ -383,4 +383,7 @@
   <data name="Remove_redundant_nullable_directive" xml:space="preserve">
     <value>Remove redundant nullable directive</value>
   </data>
+  <data name="Missing_trailing_comma" xml:space="preserve">
+    <value>Missing trailing comma</value>
+  </data>
 </root>

src/Analyzers/CSharp/Analyzers/CodeStyle/CSharpAnalyzerOptionsProvider.cs

@@ -50,6 +50,7 @@ public CSharpAnalyzerOptionsProvider(AnalyzerConfigOptions options, AnalyzerOpti
     public CodeStyleOption2<bool> AllowEmbeddedStatementsOnSameLine => GetOption(CSharpCodeStyleOptions.AllowEmbeddedStatementsOnSameLine, FallbackSimplifierOptions.AllowEmbeddedStatementsOnSameLine);
     public CodeStyleOption2<bool> PreferThrowExpression => GetOption(CSharpCodeStyleOptions.PreferThrowExpression, FallbackSimplifierOptions.PreferThrowExpression);
     public CodeStyleOption2<PreferBracesPreference> PreferBraces => GetOption(CSharpCodeStyleOptions.PreferBraces, FallbackSimplifierOptions.PreferBraces);
+    public CodeStyleOption2<bool> PreferTrailingComma => GetOption(CSharpCodeStyleOptions.PreferTrailingComma, FallbackSimplifierOptions.PreferTrailingComma);
 
     internal CSharpSimplifierOptions GetSimplifierOptions()
         => _options.GetCSharpSimplifierOptions(FallbackSimplifierOptions);

src/Analyzers/CSharp/Analyzers/PreferTrailingComma/PreferTrailingCommaDiagnosticAnalyzer.cs

@@ -0,0 +1,95 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.PreferTrailingComma
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    internal sealed class PreferTrailingCommaDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+    {
+        public PreferTrailingCommaDiagnosticAnalyzer() : base(
+            diagnosticId: IDEDiagnosticIds.PreferTrailingCommaDiagnosticId,
+            enforceOnBuild: EnforceOnBuildValues.PreferTrailingComma,
+            option: CSharpCodeStyleOptions.PreferTrailingComma,
+            language: LanguageNames.CSharp,
+            title: new LocalizableResourceString(nameof(CSharpAnalyzersResources.Missing_trailing_comma), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)))
+        {
+        }
+
+        public override DiagnosticAnalyzerCategory GetAnalyzerCategory() => DiagnosticAnalyzerCategory.SyntaxTreeWithoutSemanticsAnalysis;
+
+        protected override void InitializeWorker(AnalysisContext context)
+        {
+            context.RegisterSyntaxNodeAction(AnalyzeSyntaxNode,
+                SyntaxKind.EnumDeclaration, SyntaxKind.PropertyPatternClause, SyntaxKind.SwitchExpression,
+                SyntaxKind.ObjectInitializerExpression, SyntaxKind.CollectionInitializerExpression, SyntaxKind.WithInitializerExpression,
+                SyntaxKind.ArrayInitializerExpression, SyntaxKind.AnonymousObjectCreationExpression, SyntaxKind.ListPattern);
+        }
+
+        private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context)
+        {
+            var option = context.GetCSharpAnalyzerOptions().PreferTrailingComma;
+            if (!option.Value)
+                return;
+
+            var nodesWithSeparators = GetNodesWithSeparators(context.Node);
+            if (nodesWithSeparators.Count < 1)
+            {
+                return;
+            }
+
+            var lastNodeOrSeparator = nodesWithSeparators[^1];
+            if (lastNodeOrSeparator.IsToken)
+            {
+                return;
+            }
+
+            if (lastNodeOrSeparator.IsNode)
+            {
+                var lastNode = lastNodeOrSeparator.AsNode()!;
+                if (CommaWillBeLastTokenOnLine(lastNode, context.CancellationToken))
+                    context.ReportDiagnostic(DiagnosticHelper.Create(Descriptor, lastNode.GetLocation(), option.Notification.Severity, additionalLocations: null, properties: null));
+            }
+        }
+
+        private static bool CommaWillBeLastTokenOnLine(SyntaxNode node, CancellationToken cancellationToken)
+        {
+            var lines = node.SyntaxTree.GetText(cancellationToken).Lines;
+            var lastCurrentToken = node.DescendantTokens().Last();
+            var nextToken = lastCurrentToken.GetNextToken();
+            if (nextToken == default)
+            {
+                return true;
+            }
+
+            var line1 = lines.GetLineFromPosition(lastCurrentToken.Span.End).LineNumber;
+            var line2 = lines.GetLineFromPosition(lastCurrentToken.GetNextToken().SpanStart).LineNumber;
+            return line1 != line2;
+        }
+
+        internal static SyntaxNodeOrTokenList GetNodesWithSeparators(SyntaxNode node)
+        {
+            return node switch
+            {
+                EnumDeclarationSyntax enumDeclaration => enumDeclaration.Members.GetWithSeparators(),
+                PropertyPatternClauseSyntax propertyPattern => propertyPattern.Subpatterns.GetWithSeparators(),
+                SwitchExpressionSyntax switchExpression => switchExpression.Arms.GetWithSeparators(),
+                InitializerExpressionSyntax initializerExpression => initializerExpression.Expressions.GetWithSeparators(),
+                AnonymousObjectCreationExpressionSyntax anonymousObjectCreation => anonymousObjectCreation.Initializers.GetWithSeparators(),
+                ListPatternSyntax listPattern => listPattern.Patterns.GetWithSeparators(),
+                _ => throw ExceptionUtilities.Unreachable,
+            };
+        }
+    }
+}

src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUseCollectionInitializerDiagnosticAnalyzer.cs

@@ -27,5 +27,10 @@ protected override bool AreCollectionInitializersSupported(Compilation compilati
             => compilation.LanguageVersion() >= LanguageVersion.CSharp3;
 
         protected override ISyntaxFacts GetSyntaxFacts() => CSharpSyntaxFacts.Instance;
+
+        protected override bool PreferTrailingComma(SyntaxNodeAnalysisContext context)
+        {
+            return context.GetCSharpAnalyzerOptions().PreferTrailingComma.Value;
+        }
     }
 }

src/Analyzers/CSharp/Analyzers/UseObjectInitializer/CSharpUseObjectInitializerDiagnosticAnalyzer.cs

@@ -61,5 +61,10 @@ protected override bool IsValidContainingStatement(StatementSyntax node)
             return node is not LocalDeclarationStatementSyntax localDecl ||
                 localDecl.UsingKeyword == default;
         }
+
+        protected override bool PreferTrailingComma(SyntaxNodeAnalysisContext context)
+        {
+            return context.GetCSharpAnalyzerOptions().PreferTrailingComma.Value;
+        }
     }
 }

src/Analyzers/CSharp/CodeFixes/CSharpCodeFixes.projitems

@@ -38,6 +38,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)MakeStatementAsynchronous\CSharpMakeStatementAsynchronousCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)MakeTypeAbstract\CSharpMakeTypeAbstractCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Nullable\CSharpDeclareAsNullableCodeFixProvider.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)PreferTrailingComma\PreferTrailingCommaCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RemoveUnnecessaryNullableDirective\CSharpRemoveUnnecessaryNullableDirectiveCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UnsealClass\CSharpUnsealClassCodeFixProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)UseInterpolatedVerbatimString\CSharpUseInterpolatedVerbatimStringCodeFixProvider.cs" />

src/Analyzers/CSharp/CodeFixes/CSharpCodeFixesResources.resx

@@ -187,4 +187,7 @@
   <data name="Declare_as_nullable" xml:space="preserve">
     <value>Declare as nullable</value>
   </data>
+  <data name="Add_trailing_comma" xml:space="preserve">
+    <value>Add trailing comma</value>
+  </data>
 </root>