Legacy redundancy checks #228 (#229)

* Legacy redundancy checks #228

Add option for basic redundancy checks when control flow analysis disabled

* Restore sample project

* Update CHANGELOG.md

* Update analyzer-specification.md

Author: marinasundstrom

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - PR [#226](https://github.com/marinasundstrom/CheckedExceptions/issues/226) Enable codefix "Remove redundant catch clause" for catch all
+- PR [#229](https://github.com/marinasundstrom/CheckedExceptions/issues/229) Legacy redundancy checks
 
 ## [1.9.6] - 2025-08-05
 

CheckedExceptions.Package/docs/README.md

@@ -148,7 +148,10 @@ Add `CheckedExceptions.settings.json`:
   "disableXmlDocInterop": false,
 
   // If true, control flow analysis, with redundancy checks, is disabled (default: false).
-  "disableControlFlowAnalysis": true
+  "disableControlFlowAnalysis": false,
+
+    // If true, basic redundancy checks are available when control flow analysis is disabled (default: false).
+  "enableLegacyRedundancyChecks": false
 }
 ```
 

CheckedExceptions/AnalyzerSettings.cs

@@ -13,9 +13,14 @@ public partial class AnalyzerSettings
     [JsonPropertyName("disableControlFlowAnalysis")]
     public bool DisableControlFlowAnalysis { get; set; } = false;
 
+    [JsonPropertyName("enableLegacyRedundancyChecks")]
+    public bool EnableLegacyRedundancyChecks { get; set; } = false;
+
     [JsonIgnore]
     internal bool IsControlFlowAnalysisEnabled => !DisableControlFlowAnalysis;
 
+    internal bool IsLegacyRedundancyChecksEnabled => EnableLegacyRedundancyChecks;
+
     [JsonPropertyName("ignoredExceptions")]
     public IEnumerable<string> IgnoredExceptions { get; set; } = new List<string>();
 

CheckedExceptions/CheckedExceptionsAnalyzer.cs

@@ -358,6 +358,7 @@ private static void CheckNoThrowsOnFullPropertyDecl(SyntaxNodeAnalysisContext co
         }
     }
 
+    // Legacy redundancy check
     private void AnalyzeTryStatement(SyntaxNodeAnalysisContext context)
     {
         var tryStatement = context.Node as TryStatementSyntax;
@@ -367,47 +368,57 @@ private void AnalyzeTryStatement(SyntaxNodeAnalysisContext context)
 
         var settings = GetAnalyzerSettings(context.Options);
 
-        var semanticModel = context.SemanticModel;
-
-        // Check for redundant typed catch clauses
-        foreach (var catchClause in tryStatement.Catches)
+        if (!settings.IsControlFlowAnalysisEnabled && settings.IsLegacyRedundancyChecksEnabled)
         {
-            if (catchClause.Declaration?.Type is null)
-            {
-                var thrownExceptions = CollectUnhandledExceptions(context, tryStatement.Block, settings);
+            var semanticModel = context.SemanticModel;
 
-                if (thrownExceptions.Count > 0)
-                    continue;
+            var thrownExceptions = CollectUnhandledExceptions(context, tryStatement.Block, settings);
 
-                // Report redundant catch clause
-                /*var diagnostic = Diagnostic.Create(
-                RuleRedundantCatchAllClause,
-                catchClause.CatchKeyword.GetLocation());
+            HashSet<INamespaceOrTypeSymbol> unhandledExceptions = new HashSet<INamespaceOrTypeSymbol>(thrownExceptions, SymbolEqualityComparer.Default);
 
-                context.ReportDiagnostic(diagnostic);*/
-            }
-            else
+            // Check for redundant typed catch clauses
+            foreach (var catchClause in tryStatement.Catches)
             {
-                var catchType = semanticModel.GetTypeInfo(catchClause.Declaration.Type).Type as INamedTypeSymbol;
-                if (catchType is null)
-                    continue;
+                if (catchClause.Declaration?.Type is null)
+                {
+                    if (unhandledExceptions.Count > 0)
+                        continue;
 
-                var thrownExceptions = CollectUnhandledExceptions(context, tryStatement.Block, settings);
+                    unhandledExceptions.Clear();
 
-                // Check if any thrown exception matches or derives from this catch type
-                bool isRelevant = thrownExceptions.OfType<INamedTypeSymbol>().Any(thrown =>
-                    thrown.Equals(catchType, SymbolEqualityComparer.Default) ||
-                    thrown.InheritsFrom(catchType));
+                    // Report redundant catch clause
+                    var diagnostic = Diagnostic.Create(
+                            RuleRedundantCatchAllClause,
+                            catchClause.CatchKeyword.GetLocation());
 
-                if (!isRelevant)
+                    context.ReportDiagnostic(diagnostic);
+                }
+                else
                 {
-                    // Report redundant catch clause
-                    /*var diagnostic = Diagnostic.Create(
-                        RuleRedundantTypedCatchClause,
-                        catchClause.Declaration.Type.GetLocation(),
-                        catchType.Name);
+                    var catchType = semanticModel.GetTypeInfo(catchClause.Declaration.Type).Type as INamedTypeSymbol;
+                    if (catchType is null)
+                        continue;
 
-                    context.ReportDiagnostic(diagnostic);*/
+                    // Update unhandled set
+                    unhandledExceptions.RemoveWhere(thrown =>
+                        SymbolEqualityComparer.Default.Equals(thrown, catchType) ||
+                        (thrown is INamedTypeSymbol named && named.InheritsFrom(catchType)));
+
+                    // Check if any thrown exception matches or derives from this catch type
+                    bool isRelevant = thrownExceptions.OfType<INamedTypeSymbol>().Any(thrown =>
+                        thrown.Equals(catchType, SymbolEqualityComparer.Default) ||
+                        thrown.InheritsFrom(catchType));
+
+                    if (!isRelevant)
+                    {
+                        // Report redundant catch clause
+                        var diagnostic = Diagnostic.Create(
+                            RuleRedundantTypedCatchClause,
+                            catchClause.Declaration.Type.GetLocation(),
+                            catchType.Name);
+
+                        context.ReportDiagnostic(diagnostic);
+                    }
                 }
             }
         }

README.md

@@ -148,7 +148,10 @@ Add `CheckedExceptions.settings.json`:
   "disableXmlDocInterop": false,
 
   // If true, control flow analysis, with redundancy checks, is disabled (default: false).
-  "disableControlFlowAnalysis": true
+  "disableControlFlowAnalysis": false,
+
+    // If true, basic redundancy checks are available when control flow analysis is disabled (default: false).
+  "enableLegacyRedundancyChecks": false
 }
 ```
 

SampleProject/Program.cs

@@ -1,49 +1,36 @@
 try
 {
-    NewMethod();
+    int result = ReadAndParse();
+    Console.WriteLine(result);
 }
-catch (InvalidUserInputException invalidUserInputException)
+catch (InvalidUserInputException ex)
 {
+    Console.WriteLine($"Input error: {ex.Message}");
 }
 
-public class Foo
+[Throws(typeof(InvalidUserInputException))] // ✔️ Only the domain-specific exception is exposed
+static int ReadAndParse()
 {
+    string input = "abc";  // Simulated input — could be user input in real scenarios
 
-    [Throws(typeof(InvalidUserInputException))] // ✔️ Only the domain-specific exception is exposed
-    static int ReadAndParse()
+    try
     {
-        string input = "abc";  // Simulated input — could be user input in real scenarios
-
-        try
-        {
-            return int.Parse(input);
-        }
-        catch (FormatException formatException)
-        {
-            // Handle and rethrow as domain-specific exception
-            throw new InvalidUserInputException("Input was not a valid number.", formatException);
-        }
-        catch (OverflowException overflowException)
-        {
-            // Handle and rethrow as domain-specific exception
-            throw new InvalidUserInputException("Input number was too large.", overflowException);
-        }
+        return int.Parse(input);
     }
-
-    /// <summary>
-    /// Test
-    /// </summary>
-    /// <exception cref="InvalidUserInputException" />
-    [Throws(typeof(InvalidUserInputException))]
-    static void NewMethod()
+    catch (FormatException formatException)
     {
-        int result = ReadAndParse();
-        Console.WriteLine(result);
+        // Handle and rethrow as domain-specific exception
+        throw new InvalidUserInputException("Input was not a valid number.", formatException);
+    }
+    catch (OverflowException overflowException)
+    {
+        // Handle and rethrow as domain-specific exception
+        throw new InvalidUserInputException("Input number was too large.", overflowException);
     }
 }
 
 class InvalidUserInputException : Exception
 {
     public InvalidUserInputException(string message, Exception inner)
         : base(message, inner) { }
-}
+}

Test/CheckedExceptions.settings.json

@@ -6,5 +6,6 @@
         "System.TimeoutException": "Always"
     },
     "disableXmlDocInterop": false,
-    "disableControlFlowAnalysis": false
+    "disableControlFlowAnalysis": false,
+    "enableLegacyRedundancyChecks": false
 }

docs/analyzer-specification.md

@@ -417,3 +417,20 @@ When set, the analyzer will still report **unhandled exceptions** and enforce `[
 * Detect redundant catch clauses (`THROW009`, `THROW013`)
 * Report redundant exception declarations (`THROW012`, `THROW008`)
 * Highlight unreachable code (IDE gray‑out support)
+
+### Enable legacy redundancy checks
+
+> This option enables a simplified _light mode_.
+
+```json
+{
+  "disableControlFlowAnalysis": true, // prerequisite
+  "enableLegacyRedundancyChecks": true
+}
+```
+
+When enabled, the analyzer performs **basic redundancy checks** without relying on full control flow analysis.
+
+It provides:
+
+* Detection of redundant catch clauses (`THROW009`, `THROW013`)

schemas/settings-schema.json

@@ -12,6 +12,11 @@
       "default": false,
       "description": "Indicates whether control flow analysis is disabled."
     },
+    "enableLegacyRedundancyChecks": {
+      "type": "boolean",
+      "default": false,
+      "description": "Indicates whether redundancy checks are available when control flow analysis is disabled."
+    },
     "ignoredExceptions": {
       "type": "array",
       "items": {