Enable batch fixing for try/catch code fixes #275 (#294)

* Enable batch fixing for redundant catch clause remover

* Add PR number to CHANGELOG.md

Author: marinasundstrom

CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 - PR [#287](https://github.com/marinasundstrom/CheckedExceptions/pull/287) Fix LINQ chain diagnostics
+- PR [#294](https://github.com/marinasundstrom/CheckedExceptions/pull/294) Enable batch fixing for catch-clause, try-catch, and redundant catch clause code fixes
 
 ## [2.1.2] - 2025-08-22
 

CheckedExceptions.CodeFixes/AddCatchClauseToTryCodeFixProvider.cs

@@ -20,7 +20,7 @@ public class AddCatchClauseToTryCodeFixProvider : CodeFixProvider
         [CheckedExceptionsAnalyzer.DiagnosticIdUnhandled];
 
     public sealed override FixAllProvider GetFixAllProvider() =>
-        null!;
+        WellKnownFixAllProviders.BatchFixer;
 
     public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {

CheckedExceptions.CodeFixes/RemoveRedundantCatchClauseCodeFixProvider.cs

@@ -33,83 +33,69 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         var node = root.FindNode(diagnostic.Location.SourceSpan);
 
         var catchClause = node.AncestorsAndSelf().OfType<CatchClauseSyntax>().First();
-
         var tryStatement = catchClause.Parent as TryStatementSyntax;
 
         string title = TitleRemoveRedundantCatchClause;
 
-        if (tryStatement is not null)
+        if (diagnostics.Length is 1 && tryStatement?.Catches.Count is 1)
         {
-            if (tryStatement.Catches.Count is 1)
-            {
-                title = title.Replace(title, "Remove redundant try/catch");
-            }
+            title = "Remove redundant try/catch";
         }
 
         context.RegisterCodeFix(
             CodeAction.Create(
                 title: title,
-                createChangedDocument: c => RemoveRedundantCatchClauseAsync(context.Document, catchClause, diagnostics, c),
+                createChangedDocument: c => RemoveRedundantCatchClausesAsync(context.Document, diagnostics, c),
                 equivalenceKey: TitleRemoveRedundantCatchClause),
             diagnostics);
     }
 
-    private async Task<Document> RemoveRedundantCatchClauseAsync(Document document, CatchClauseSyntax catchClause, IEnumerable<Diagnostic> diagnostics, CancellationToken cancellationToken)
+    private async Task<Document> RemoveRedundantCatchClausesAsync(Document document, IEnumerable<Diagnostic> diagnostics, CancellationToken cancellationToken)
     {
-        var exceptionTypeNames = diagnostics
-            .Select(d => d.Properties.TryGetValue("ExceptionType", out var type) ? type! : string.Empty);
-
         var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-        if (root is null) return document;
+        if (root is null)
+        {
+            return document;
+        }
 
-        var tryStatement = catchClause.Parent as TryStatementSyntax;
+        var orderedDiagnostics = diagnostics
+            .OrderByDescending(d => d.Location.SourceSpan.Start);
+
+        var newRoot = root;
 
-        if (tryStatement is not null)
+        foreach (var diagnostic in orderedDiagnostics)
         {
-            if (tryStatement.Catches.Count is 1)
-            {
-                // Get the current node in the tree
-                var nodeInRoot = root.FindNode(tryStatement.Span);
+            var clause = newRoot.FindNode(diagnostic.Location.SourceSpan).AncestorsAndSelf().OfType<CatchClauseSyntax>().First();
+            var tryStatement = clause.Parent as TryStatementSyntax;
 
-                // What we want to insert instead
+            if (tryStatement is not null && tryStatement.Catches.Count == 1)
+            {
+                var nodeInRoot = newRoot.FindNode(tryStatement.Span);
                 var liftedStatements = tryStatement.Block.Statements;
 
-                SyntaxNode newRoot;
-
                 if (nodeInRoot is GlobalStatementSyntax global)
                 {
-                    // Wrap each lifted statement in its own GlobalStatementSyntax
-                    var newGlobals = liftedStatements.Select(
-                        s => GlobalStatement(s)
-                            .WithLeadingTrivia(global.GetLeadingTrivia())
-                            .WithTrailingTrivia(global.GetTrailingTrivia()));
+                    var newGlobals = liftedStatements.Select(s => GlobalStatement(s)
+                        .WithLeadingTrivia(global.GetLeadingTrivia())
+                        .WithTrailingTrivia(global.GetTrailingTrivia()));
 
-                    newRoot = root.ReplaceNode(global, newGlobals);
+                    newRoot = newRoot.ReplaceNode(global, newGlobals);
                 }
                 else if (nodeInRoot is TryStatementSyntax tryNode)
                 {
-                    // Normal case inside a block
-
                     var annotatedStatements = liftedStatements
                         .Select(s => s.WithAdditionalAnnotations(Formatter.Annotation));
 
-                    newRoot = root.ReplaceNode(tryNode, annotatedStatements);
+                    newRoot = newRoot.ReplaceNode(tryNode, annotatedStatements);
                 }
-                else
-                {
-                    // Fallback (shouldn’t really happen)
-                    return document;
-                }
-
-                return document.WithSyntaxRoot(newRoot);
             }
             else
             {
-                var newRoot = root.RemoveNode(catchClause, SyntaxRemoveOptions.AddElasticMarker);
-                return document.WithSyntaxRoot(newRoot);
+                var currentClause = newRoot.FindNode(clause.Span).AncestorsAndSelf().OfType<CatchClauseSyntax>().First();
+                newRoot = newRoot.RemoveNode(currentClause, SyntaxRemoveOptions.AddElasticMarker);
             }
         }
 
-        return document;
+        return document.WithSyntaxRoot(newRoot);
     }
 }

CheckedExceptions.CodeFixes/SurroundWithTryCatchCodeFixProvider.cs

@@ -23,7 +23,7 @@ public class SurroundWithTryCatchCodeFixProvider : CodeFixProvider
          CheckedExceptionsAnalyzer.DiagnosticIdImplicitlyDeclaredException];
 
     public sealed override FixAllProvider GetFixAllProvider() =>
-        null!;
+        WellKnownFixAllProviders.BatchFixer;
 
     public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {

CheckedExceptions.Tests/CodeFixes/AddCatchClauseToTryCodeFixProviderTests.cs

@@ -2,6 +2,7 @@ namespace Sundstrom.CheckedExceptions.Tests.CodeFixes;
 
 using System.Threading.Tasks;
 
+using Microsoft.CodeAnalysis.Testing;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -105,4 +106,90 @@ public void TestMethod()
 
         await Verifier.VerifyCodeFixAsync(testCode, expectedDiagnostic, fixedCode, expectedIncrementalIterations: 0);
     }
+
+    [Fact]
+    public async Task FixAll_AddsCatchClauses_ForMultipleUnhandledExceptions()
+    {
+        var testCode = /* lang=c#-test */  """
+using System;
+
+namespace TestNamespace
+{
+    public class TestClass
+    {
+        public void TestMethod1()
+        {
+            try
+            {
+                throw new InvalidOperationException();
+            }
+            catch (ArgumentException ex)
+            {
+            }
+        }
+
+        public void TestMethod2()
+        {
+            try
+            {
+                throw new ArgumentException();
+            }
+            catch (InvalidOperationException ex)
+            {
+            }
+        }
+    }
+}
+""";
+
+        var fixedCode = /* lang=c#-test */  """
+using System;
+
+namespace TestNamespace
+{
+    public class TestClass
+    {
+        public void TestMethod1()
+        {
+            try
+            {
+                throw new InvalidOperationException();
+            }
+            catch (ArgumentException ex)
+            {
+            }
+            catch (InvalidOperationException invalidOperationException)
+            {
+            }
+        }
+
+        public void TestMethod2()
+        {
+            try
+            {
+                throw new ArgumentException();
+            }
+            catch (InvalidOperationException ex)
+            {
+            }
+            catch (ArgumentException argumentException)
+            {
+            }
+        }
+    }
+}
+""";
+
+        var expectedDiagnostic1 = Verifier.UnhandledException("InvalidOperationException")
+            .WithSpan(11, 17, 11, 55);
+        var expectedDiagnostic2 = Verifier.UnhandledException("ArgumentException")
+            .WithSpan(22, 17, 22, 47);
+
+        await Verifier.VerifyCodeFixAsync(
+            testCode,
+            [expectedDiagnostic1, expectedDiagnostic2],
+            fixedCode,
+            expectedIncrementalIterations: 2,
+            setup: test => test.CodeFixTestBehaviors &= ~CodeFixTestBehaviors.SkipFixAllCheck);
+    }
 }

CheckedExceptions.Tests/CodeFixes/RemoveRedundantCatchClauseCodeFixProviderTests.cs

@@ -2,6 +2,7 @@ namespace Sundstrom.CheckedExceptions.Tests.CodeFixes;
 
 using System.Threading.Tasks;
 
+using Microsoft.CodeAnalysis.Testing;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -187,4 +188,91 @@ await Verifier.VerifyCodeFixAsync(testCode, [expectedDiagnostic], fixedCode, exe
             option.DisabledDiagnostics.Remove(CheckedExceptionsAnalyzer.DiagnosticIdRedundantTypedCatchClause);
         });
     }
+
+    [Fact]
+    public async Task FixAll_RemovesRedundantCatchClausesAcrossMethods()
+    {
+        var testCode = /* lang=c#-test */  """
+#nullable enable
+using System;
+
+class TestClass
+{
+    void Method1()
+    {
+        try
+        {
+            int.Parse("a");
+        }
+        catch (FormatException ex)
+        {
+        }
+        catch (OverflowException ex)
+        {
+        }
+        catch (ArgumentException ex)
+        {
+        }
+    }
+
+    void Method2()
+    {
+        try
+        {
+            int x = 0;
+            string y = "";
+        }
+        catch (FormatException ex)
+        {
+        }
+    }
+}
+""";
+
+        var fixedCode = /* lang=c#-test */  """
+#nullable enable
+using System;
+
+class TestClass
+{
+    void Method1()
+    {
+        try
+        {
+            int.Parse("a");
+        }
+        catch (FormatException ex)
+        {
+        }
+        catch (OverflowException ex)
+        {
+        }
+    }
+
+    void Method2()
+    {
+        int x = 0;
+        string y = "";
+    }
+}
+""";
+
+        var expectedDiagnostic1 = Verifier.Diagnostic(CheckedExceptionsAnalyzer.DiagnosticIdRedundantTypedCatchClause)
+            .WithArguments("ArgumentException")
+            .WithSpan(18, 16, 18, 33);
+        var expectedDiagnostic2 = Verifier.Diagnostic(CheckedExceptionsAnalyzer.DiagnosticIdRedundantTypedCatchClause)
+            .WithArguments("FormatException")
+            .WithSpan(30, 16, 30, 31);
+
+        await Verifier.VerifyCodeFixAsync(
+            testCode,
+            [expectedDiagnostic1, expectedDiagnostic2],
+            fixedCode,
+            expectedIncrementalIterations: 2,
+            setup: test =>
+            {
+                test.CodeFixTestBehaviors &= ~CodeFixTestBehaviors.SkipFixAllCheck;
+                test.DisabledDiagnostics.Remove(CheckedExceptionsAnalyzer.DiagnosticIdRedundantTypedCatchClause);
+            });
+    }
 }