Add MA0007.IgnoreCatchAllArm configuration option

Introduce a new configuration option `MA0007.IgnoreCatchAllArm` to control diagnostics for missing trailing commas in catch-all arms (`_`) of switch expressions.

Author: meziantou

docs/Rules/MA0007.md

@@ -17,3 +17,38 @@ new Sample
     B = 1,
 };
 ````
+
+## Configuration
+
+### `MA0007.IgnoreCatchAllArm`
+
+By default, the analyzer reports a diagnostic when a catch-all arm (`_`) in a switch expression is missing a trailing comma. You can disable this behavior by setting `MA0007.IgnoreCatchAllArm` to `true`.
+
+````csharp
+// Default behavior (non-compliant)
+_ = value switch
+{
+    1 => "one",
+    _ => "other"  // Diagnostic reported
+};
+
+// With MA0007.IgnoreCatchAllArm = true
+_ = value switch
+{
+    1 => "one",
+    _ => "other"  // No diagnostic
+};
+
+// Compliant code
+_ = value switch
+{
+    1 => "one",
+    _ => "other",
+};
+````
+
+**.editorconfig**
+
+```ini
+# Ignore missing trailing comma on catch-all arms in switch expressions
+MA0007.IgnoreCatchAllArm = true

src/Meziantou.Analyzer/Configurations/AnalyzerOptionsExtensions.cs

@@ -14,6 +14,11 @@ public static string GetConfigurationValue(this AnalyzerOptions options, SyntaxT
         return defaultValue;
     }
 
+    public static string GetConfigurationValue(this AnalyzerOptions options, SyntaxNode syntaxNode, string key, string defaultValue)
+    {
+        return GetConfigurationValue(options, syntaxNode.SyntaxTree, key, defaultValue);
+    }
+
     public static string GetConfigurationValue(this AnalyzerOptions options, IOperation operation, string key, string defaultValue)
     {
         return GetConfigurationValue(options, operation.Syntax.SyntaxTree, key, defaultValue);
@@ -28,6 +33,12 @@ public static bool GetConfigurationValue(this AnalyzerOptions options, SyntaxTre
         return defaultValue;
     }
 
+    [return: NotNullIfNotNull(nameof(defaultValue))]
+    public static bool? GetConfigurationValue(this AnalyzerOptions options, SyntaxNode syntaxNode, string key, bool? defaultValue)
+    {
+        return GetConfigurationValue(options, syntaxNode.SyntaxTree, key, defaultValue);
+    }
+
     [return: NotNullIfNotNull(nameof(defaultValue))]
     public static bool? GetConfigurationValue(this AnalyzerOptions options, SyntaxTree syntaxTree, string key, bool? defaultValue)
     {

src/Meziantou.Analyzer/Rules/CommaAnalyzer.cs

@@ -1,4 +1,5 @@
-using System.Collections.Immutable;
+using System.Collections.Immutable;
+using Meziantou.Analyzer.Configurations;
 using Meziantou.Analyzer.Internals;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
@@ -63,6 +64,14 @@ private void HandleCollectionExpression(SyntaxNodeAnalysisContext context)
     private void HandleSwitchExpression(SyntaxNodeAnalysisContext context)
     {
         var node = (SwitchExpressionSyntax)context.Node;
+        var options = context.Options.GetConfigurationValue(node, Rule.Id + ".IgnoreCatchAllArm", defaultValue: false);
+        if (options is true)
+        {
+            var last = node.Arms.LastOrDefault();
+            if (last is not null && last.Pattern is DiscardPatternSyntax)
+                return;
+        }
+
         HandleSeparatedList(context, node, node.Arms);
     }
 

tests/Meziantou.Analyzer.Test/Rules/CommaAnalyzerTests.cs

@@ -259,6 +259,58 @@ await CreateProjectBuilder()
     }
 #endif
 
+    [Fact]
+    public Task SwitchExpressionWithoutLeadingComma_CatchAll()
+        => CreateProjectBuilder()
+            .WithLanguageVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp8)
+            .WithSourceCode("""
+                class TypeName
+                {
+                    public void Test()
+                    {
+                        _ = 0 switch
+                        {
+                            1 => 1,
+                            [||]_ => 2
+                        };
+                    }
+                }
+                """)
+            .ShouldFixCodeWith("""
+                class TypeName
+                {
+                    public void Test()
+                    {
+                        _ = 0 switch
+                        {
+                            1 => 1,
+                            _ => 2,
+                        };
+                    }
+                }
+                """)
+            .ValidateAsync();
+
+    [Fact]
+    public Task SwitchExpressionWithoutLeadingComma_IgnoreCatchAll()
+        => CreateProjectBuilder()
+            .WithLanguageVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp8)
+            .AddAnalyzerConfiguration("MA0007.IgnoreCatchAllArm", "true")
+            .WithSourceCode("""
+                class TypeName
+                {
+                    public void Test()
+                    {
+                        _ = 0 switch
+                        {
+                            1 => 1,
+                            _ => 2
+                        };
+                    }
+                }
+                """)
+            .ValidateAsync();
+
     [Fact]
     public Task SwitchExpressionWithoutLeadingComma()
         => CreateProjectBuilder()