marinasundstrom · marinasundstrom · Sep 5, 2025 · Sep 5, 2025 · Sep 5, 2025 · Sep 5, 2025
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,6 +11,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - PR [#301](https://github.com/marinasundstrom/CheckedExceptions/pull/301) Allow treating `Exception` in `[Throws]` as a catch-all via `treatThrowsExceptionAsCatchRest` setting (base-type diagnostic unchanged)
+- PR [#PR_NUMBER](https://github.com/marinasundstrom/CheckedExceptions/pull/PR_NUMBER) Provide comprehensive baseline exception classifications in `default-settings.json`
+
+### Changed
+
+- PR [#PR_NUMBER](https://github.com/marinasundstrom/CheckedExceptions/pull/PR_NUMBER) Replace `ignoredExceptions` and `informationalExceptions` with explicit `exceptions` classification map
+- PR [#PR_NUMBER](https://github.com/marinasundstrom/CheckedExceptions/pull/PR_NUMBER) Document explicit exception taxonomy and strict default for unlisted types in README and docs
+
+### Deprecated
+
+- PR [#PR_NUMBER](https://github.com/marinasundstrom/CheckedExceptions/pull/PR_NUMBER) Support legacy `ignoredExceptions` and `informationalExceptions` settings by translating them to `exceptions`
 
 ## [2.2.3] - 2025-08-24
 

diff --git a/CheckedExceptions.Tests/AnazylerConfigTest.cs b/CheckedExceptions.Tests/AnazylerConfigTest.cs
@@ -70,12 +70,12 @@ public void TestMethod2()
             }
             """;
 
-        var expected1 = Verifier.Informational("IOException")
-            .WithSpan(9, 21, 9, 39);
-
-        var expected2 = Verifier.Diagnostic(CheckedExceptionsAnalyzer.DiagnosticIdRedundantCatchAllClause)
-            .WithSpan(11, 9, 11, 14);
-
-        await Verifier.VerifyAnalyzerAsync2(test, expected1, expected2);
-    }
+        var expected1 = Verifier.Informational("IOException")
+            .WithSpan(9, 21, 9, 39);
+
+        var expected2 = Verifier.Informational("IOException")
+            .WithSpan(13, 13, 13, 19);
+
+        await Verifier.VerifyAnalyzerAsync2(test, expected1, expected2);
+    }
 }
diff --git a/CheckedExceptions.Tests/CSharpAnalyzerVerifier.cs b/CheckedExceptions.Tests/CSharpAnalyzerVerifier.cs
@@ -96,8 +96,8 @@ await VerifyAnalyzerAsync(source, (test) =>
                     "System.NotImplementedException"
                 ],
                 "informationalExceptions": {
-                    "System.IO.IOException": "Always",
-                    "System.TimeoutException": "Always"
+                    "System.IO.IOException": "Propagation",
+                    "System.TimeoutException": "Propagation"
                 }
             }
             """"));

diff --git a/CheckedExceptions.Tests/CheckedExceptions.settings.json b/CheckedExceptions.Tests/CheckedExceptions.settings.json
@@ -1,11 +1,9 @@
 {
-    "ignoredExceptions": [
-        "System.ArgumentNullException"
-    ],
-    "informationalExceptions": {
-        "System.NotImplementedException": "Propagation",
-        "System.IO.IOException": "Propagation",
-        "System.TimeoutException": "Always"
+    "exceptions": {
+        "System.ArgumentNullException": "Ignored",
+        "System.NotImplementedException": "Informational",
+        "System.IO.IOException": "Informational",
+        "System.TimeoutException": "Informational"
     },
     "disableXmlDocInterop": false,
     "disableLinqSupport": false,

diff --git a/CheckedExceptions.Tests/CheckedExceptionsAnalyzerTests.ThrowsExceptionCatchRest.cs b/CheckedExceptions.Tests/CheckedExceptionsAnalyzerTests.ThrowsExceptionCatchRest.cs
@@ -58,8 +58,7 @@ await Verifier.VerifyAnalyzerAsync(test, t =>
         {
             t.TestState.AdditionalFiles.Add(("CheckedExceptions.settings.json", """
             {
-                "ignoredExceptions": [],
-                "informationalExceptions": {},
+                "exceptions": {},
                 "treatThrowsExceptionAsCatchRest": true
             }
             """));

diff --git a/CheckedExceptions/AnalyzerSettings.cs b/CheckedExceptions/AnalyzerSettings.cs
@@ -64,17 +64,52 @@ public partial class AnalyzerSettings
     [JsonIgnore]
     internal bool TreatThrowsExceptionAsCatchRestEnabled => TreatThrowsExceptionAsCatchRest;
 
+    [JsonPropertyName("exceptions")]
+    public IDictionary<string, ExceptionClassification> Exceptions { get; set; } = new Dictionary<string, ExceptionClassification>();
+
     [JsonPropertyName("ignoredExceptions")]
-    public IEnumerable<string> IgnoredExceptions { get; set; } = new List<string>();
+    [Obsolete("Use 'exceptions' instead.")]
+    public IList<string>? IgnoredExceptions
+    {
+        get => null;
+        set
+        {
+            if (value is null)
+            {
+                return;
+            }
+
+            foreach (var exception in value)
+            {
+                Exceptions[exception] = ExceptionClassification.Ignored;
+            }
+        }
+    }
 
     [JsonPropertyName("informationalExceptions")]
-    public IDictionary<string, ExceptionMode> InformationalExceptions { get; set; } = new Dictionary<string, ExceptionMode>();
+    [Obsolete("Use 'exceptions' instead.")]
+    public IDictionary<string, string>? InformationalExceptions
+    {
+        get => null;
+        set
+        {
+            if (value is null)
+            {
+                return;
+            }
+
+            foreach (var exception in value.Keys)
+            {
+                Exceptions[exception] = ExceptionClassification.Informational;
+            }
+        }
+    }
 }
 
 [JsonConverter(typeof(JsonStringEnumConverter))]
-public enum ExceptionMode
+public enum ExceptionClassification
 {
-    Throw = 1,
-    Propagation = 2,
-    Always = Throw | Propagation
+    Ignored,
+    Informational,
+    Strict
 }
diff --git a/CheckedExceptions/CheckedExceptionsAnalyzer.Analysis.cs b/CheckedExceptions/CheckedExceptionsAnalyzer.Analysis.cs
@@ -48,22 +48,17 @@ private static void AnalyzeExceptionsInTryBlock(SyntaxNodeAnalysisContext contex
         // For each thrown exception, check if it is handled
         foreach (var exceptionType in thrownExceptions.Distinct(SymbolEqualityComparer.Default).OfType<INamedTypeSymbol>())
         {
-            var exceptionName = exceptionType.ToDisplayString();
+            var classification = GetExceptionClassification(exceptionType, settings);
 
-            if (FilterIgnored(settings, exceptionName))
+            if (classification is ExceptionClassification.Ignored)
             {
-                // Completely ignore this exception
                 continue;
             }
-            else if (settings.InformationalExceptions.TryGetValue(exceptionName, out var mode))
+            else if (classification is ExceptionClassification.Informational)
             {
-                if (ShouldIgnore(throwStatement, mode))
-                {
-                    // Report as THROW002 (Info level)
-                    var diagnostic = Diagnostic.Create(RuleIgnoredException, GetSignificantLocation(throwStatement), exceptionType.Name);
-                    context.ReportDiagnostic(diagnostic);
-                    continue;
-                }
+                var diagnostic = Diagnostic.Create(RuleIgnoredException, GetSignificantLocation(throwStatement), exceptionType.Name);
+                context.ReportDiagnostic(diagnostic);
+                continue;
             }
 
             // ① handled by any typed catch BEFORE the general catch?
@@ -168,7 +163,7 @@ private static HashSet<INamedTypeSymbol> CollectExceptionsFromStatement(Statemen
                 var exceptionType = semanticModel.GetTypeInfo(throwStatement.Expression).Type as INamedTypeSymbol;
                 if (exceptionType is not null)
                 {
-                    if (ShouldIncludeException(exceptionType, throwStatement, settings))
+                    if (ShouldIncludeException(exceptionType, settings))
                     {
                         exceptions.Add(exceptionType);
                     }
@@ -199,7 +194,7 @@ private static void CollectExceptionsFromExpression(SyntaxNode expression, Compi
                 var exceptionType = semanticModel.GetTypeInfo(throwExpression.Expression).Type as INamedTypeSymbol;
                 if (exceptionType is not null)
                 {
-                    if (ShouldIncludeException(exceptionType, throwExpression, settings))
+                    if (ShouldIncludeException(exceptionType, settings))
                     {
                         exceptions.Add(exceptionType);
                     }
@@ -225,7 +220,7 @@ private static void CollectExceptionsFromExpression(SyntaxNode expression, Compi
 
                     foreach (var exceptionType in exceptionTypes)
                     {
-                        if (ShouldIncludeException(exceptionType, invocation, settings))
+                        if (ShouldIncludeException(exceptionType, settings))
                         {
                             exceptions.Add(exceptionType);
                         }
@@ -250,7 +245,7 @@ private static void CollectExceptionsFromExpression(SyntaxNode expression, Compi
 
                     foreach (var exceptionType in exceptionTypes)
                     {
-                        if (ShouldIncludeException(exceptionType, invocation, settings))
+                        if (ShouldIncludeException(exceptionType, settings))
                         {
                             exceptions.Add(exceptionType);
                         }
@@ -282,7 +277,7 @@ private static void CollectExceptionsFromExpression(SyntaxNode expression, Compi
 
                 foreach (var exceptionType in exceptionTypes)
                 {
-                    if (ShouldIncludeException(exceptionType, objectCreation, settings))
+                    if (ShouldIncludeException(exceptionType, settings))
                     {
                         exceptions.Add(exceptionType);
                     }
@@ -301,7 +296,7 @@ private static void CollectExceptionsFromExpression(SyntaxNode expression, Compi
 
                 foreach (var exceptionType in exceptionTypes)
                 {
-                    if (ShouldIncludeException(exceptionType, memberAccess, settings))
+                    if (ShouldIncludeException(exceptionType, settings))
                     {
                         exceptions.Add(exceptionType);
                     }
@@ -319,7 +314,7 @@ private static void CollectExceptionsFromExpression(SyntaxNode expression, Compi
 
                 foreach (var exceptionType in exceptionTypes)
                 {
-                    if (ShouldIncludeException(exceptionType, elementAccess, settings))
+                    if (ShouldIncludeException(exceptionType, settings))
                     {
                         exceptions.Add(exceptionType);
                     }
@@ -339,7 +334,7 @@ private static void CollectExceptionsFromExpression(SyntaxNode expression, Compi
                 {
                     if (exceptionType is not null)
                     {
-                        if (ShouldIncludeException(exceptionType, identifier, settings))
+                        if (ShouldIncludeException(exceptionType, settings))
                         {
                             exceptions.Add(exceptionType);
                         }
@@ -361,7 +356,7 @@ private static void CollectExceptionsFromExpression(SyntaxNode expression, Compi
 
             if (invalidCastException is not null)
             {
-                if (ShouldIncludeException(invalidCastException, castExpression, settings))
+                if (ShouldIncludeException(invalidCastException, settings))
                 {
                     exceptions.Add(invalidCastException);
                 }

diff --git a/CheckedExceptions/CheckedExceptionsAnalyzer.ExceptionClassification.cs b/CheckedExceptions/CheckedExceptionsAnalyzer.ExceptionClassification.cs
@@ -0,0 +1,26 @@
+using Microsoft.CodeAnalysis;
+
+namespace Sundstrom.CheckedExceptions;
+
+partial class CheckedExceptionsAnalyzer
+{
+    public static ExceptionClassification GetExceptionClassification(
+        INamedTypeSymbol exceptionType,
+        AnalyzerSettings settings)
+    {
+        var exceptionName = exceptionType.ToDisplayString();
+
+        if (settings.Exceptions.TryGetValue(exceptionName, out var classification))
+        {
+            return classification;
+        }
+
+        return ExceptionClassification.Strict;
+    }
+
+    public static bool ShouldIncludeException(
+        INamedTypeSymbol exceptionType,
+        AnalyzerSettings settings)
+        => GetExceptionClassification(exceptionType, settings) != ExceptionClassification.Ignored;
+}
+
diff --git a/CheckedExceptions/CheckedExceptionsAnalyzer.IgnoredExceptions.cs b/CheckedExceptions/CheckedExceptionsAnalyzer.IgnoredExceptions.cs