Fix rest of nullable warnings in CheckedExceptions proj

sibber5 · sibber5 · commit 448327e715d3 · 2025-07-11T03:50:17.000+03:00
diff --git a/CheckedExceptions/AttributeHelper.cs b/CheckedExceptions/AttributeHelper.cs
@@ -1,13 +1,13 @@
-namespace Sundstrom.CheckedExceptions;
-
-using System.Diagnostics;
-
+namespace Sundstrom.CheckedExceptions;
+
+using System.Diagnostics;
+
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 public static class AttributeHelper
 {
-    public static AttributeData? GetSpecificAttributeData(AttributeSyntax attributeSyntax, SemanticModel semanticModel)
+    public static AttributeData? GetSpecificAttributeData(AttributeSyntax? attributeSyntax, SemanticModel? semanticModel)
     {
         if (attributeSyntax is null || semanticModel is null)
             return null;
diff --git a/CheckedExceptions/CheckedExceptionsAnalyzer.Inheritance.cs b/CheckedExceptions/CheckedExceptionsAnalyzer.Inheritance.cs
@@ -20,7 +20,7 @@ MethodKind.EventAdd or
             MethodKind.EventRemove))
             return;
 
-        ImmutableHashSet<ISymbol> declaredExceptions = GetDistictExceptionTypes(throwsAttributes).Where(x => x is not null).ToImmutableHashSet(SymbolEqualityComparer.Default)!;
+        ImmutableHashSet<ISymbol> declaredExceptions = GetDistinctExceptionTypes(throwsAttributes).Where(x => x is not null).ToImmutableHashSet(SymbolEqualityComparer.Default)!;
         Debug.Assert(!declaredExceptions.Any(x => x is null));
 
         if (declaredExceptions.Count == 0)
diff --git a/CheckedExceptions/CheckedExceptionsAnalyzer.Shared.cs b/CheckedExceptions/CheckedExceptionsAnalyzer.Shared.cs
@@ -9,7 +9,7 @@ partial class CheckedExceptionsAnalyzer
     /// <summary>
     /// Retrieves the name of the exception type from a ThrowsAttribute's AttributeData.
     /// </summary>
-    private string GetExceptionTypeName(AttributeData attributeData)
+    private string GetExceptionTypeName(AttributeData? attributeData)
     {
         if (attributeData is null)
             return string.Empty;
diff --git a/CheckedExceptions/CheckedExceptionsAnalyzer.cs b/CheckedExceptions/CheckedExceptionsAnalyzer.cs
@@ -3,7 +3,6 @@
 using System.Collections.Concurrent;
 using System.Collections.Immutable;
 using System.Linq;
-using System.Reflection;
 using System.Text.Json;
 
 using Microsoft.CodeAnalysis;
@@ -25,7 +24,7 @@ public partial class CheckedExceptionsAnalyzer : DiagnosticAnalyzer
     public const string DiagnosticIdMissingThrowsOnBaseMember = "THROW006";
     public const string DiagnosticIdMissingThrowsFromBaseMember = "THROW007";
 
-    public static IEnumerable<string> AllDiagnosticsIds = [DiagnosticIdUnhandled, DiagnosticIdGeneralThrows, DiagnosticIdGeneralThrow, DiagnosticIdDuplicateDeclarations];
+    public static readonly IEnumerable<string> AllDiagnosticsIds = [DiagnosticIdUnhandled, DiagnosticIdGeneralThrows, DiagnosticIdGeneralThrow, DiagnosticIdDuplicateDeclarations];
 
     private static readonly DiagnosticDescriptor RuleUnhandledException = new(
         DiagnosticIdUnhandled,
@@ -130,7 +129,7 @@ public override void Initialize(AnalysisContext context)
 
     private AnalyzerSettings LoadAnalyzerSettings(AnalyzerOptions analyzerOptions)
     {
-        return configs.GetOrAdd(analyzerOptions, key =>
+        return configs.GetOrAdd(analyzerOptions, _ =>
         {
             var configFileText = analyzerOptions.AdditionalFiles
                 .FirstOrDefault(f => SettingsFileName.Equals(Path.GetFileName(f.Path), StringComparison.OrdinalIgnoreCase))
@@ -143,7 +142,7 @@ private AnalyzerSettings LoadAnalyzerSettings(AnalyzerOptions analyzerOptions)
                 val = JsonSerializer.Deserialize<AnalyzerSettings>(configFileText, _settingsFileJsonOptions);
             }
 
-            return val ?? AnalyzerSettings.CreateWithDefaults(); // Return default options if config file is not found
+            return val ?? AnalyzerSettings.CreateWithDefaults(); // Return default options if the config file is not found
         });
     }
 
@@ -186,9 +185,6 @@ private void AnalyzeMethodSymbol(SymbolAnalysisContext context)
     {
         var methodSymbol = (IMethodSymbol)context.Symbol;
 
-        if (methodSymbol is null)
-            return;
-
         var throwsAttributes = GetThrowsAttributes(methodSymbol).ToImmutableArray();
 
         CheckForCompatibilityWithBaseOrInterface(context, throwsAttributes);
@@ -211,7 +207,7 @@ public static bool IsThrowsAttributeForException(AttributeData attribute, string
         if (!attribute.ConstructorArguments.Any())
             return false;
 
-        var exceptionTypes = GetDistictExceptionTypes(attribute);
+        var exceptionTypes = GetDistinctExceptionTypes(attribute);
         return exceptionTypes.Any(exceptionType => exceptionType?.Name == exceptionTypeName);
     }
 
@@ -239,11 +235,12 @@ public static IEnumerable<INamedTypeSymbol> GetExceptionTypes(params IEnumerable
         }
     }
 
-    public static IEnumerable<INamedTypeSymbol> GetDistictExceptionTypes(params IEnumerable<AttributeData> exceptionAttributes)
+    public static IEnumerable<INamedTypeSymbol> GetDistinctExceptionTypes(params IEnumerable<AttributeData> exceptionAttributes)
     {
         var exceptionTypes = GetExceptionTypes(exceptionAttributes);
 
-        return exceptionTypes.Distinct(SymbolEqualityComparer.Default)
+        return exceptionTypes
+            .Distinct(SymbolEqualityComparer.Default)
             .OfType<INamedTypeSymbol>();
     }
 
@@ -259,26 +256,23 @@ private void AnalyzeThrowStatement(SyntaxNodeAnalysisContext context)
         // Handle rethrows (throw;)
         if (throwStatement.Expression is null)
         {
-            if (IsWithinCatchBlock(throwStatement, out var catchClause))
+            if (IsWithinCatchBlock(throwStatement, out var catchClause) && catchClause is not null)
             {
-                if (catchClause is not null)
+                if (catchClause.Declaration is null)
                 {
-                    if (catchClause.Declaration is null)
-                    {
-                        // General catch block with 'throw;'
-                        // Analyze exceptions thrown in the try block
-                        var tryStatement = catchClause.Ancestors().OfType<TryStatementSyntax>().FirstOrDefault();
-                        if (tryStatement is not null)
-                        {
-                            AnalyzeExceptionsInTryBlock(context, tryStatement, catchClause, throwStatement, settings);
-                        }
-                    }
-                    else
+                    // General catch block with 'throw;'
+                    // Analyze exceptions thrown in the try block
+                    var tryStatement = catchClause.Ancestors().OfType<TryStatementSyntax>().FirstOrDefault();
+                    if (tryStatement is not null)
                     {
-                        var exceptionType = context.SemanticModel.GetTypeInfo(catchClause.Declaration.Type).Type as INamedTypeSymbol;
-                        AnalyzeExceptionThrowingNode(context, throwStatement, exceptionType, settings);
+                        AnalyzeExceptionsInTryBlock(context, tryStatement, catchClause, throwStatement, settings);
                     }
                 }
+                else
+                {
+                    var exceptionType = context.SemanticModel.GetTypeInfo(catchClause.Declaration.Type).Type as INamedTypeSymbol;
+                    AnalyzeExceptionThrowingNode(context, throwStatement, exceptionType, settings);
+                }
             }
 
             return; // No further analysis for rethrows
@@ -492,7 +486,7 @@ void CollectExpressionsForPropertySymbols(ExpressionSyntax expression)
 
     public bool ShouldIncludeException(INamedTypeSymbol exceptionType, SyntaxNode node, AnalyzerSettings settings)
     {
-        var exceptions = new HashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default);
+        // var exceptions = new HashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default);
 
         var exceptionName = exceptionType.ToDisplayString();
 
@@ -595,7 +589,7 @@ private void AnalyzeAwait(SyntaxNodeAnalysisContext context)
     /// <summary>
     /// Determines if a node is within a catch block.
     /// </summary>
-    private bool IsWithinCatchBlock(SyntaxNode node, out CatchClauseSyntax catchClause)
+    private bool IsWithinCatchBlock(SyntaxNode node, out CatchClauseSyntax? catchClause)
     {
         catchClause = node.Ancestors().OfType<CatchClauseSyntax>().FirstOrDefault();
         return catchClause is not null;
@@ -784,14 +778,9 @@ private void AnalyzeIdentifier(SyntaxNodeAnalysisContext context)
 
     private void AnalyzeIdentifierAndMemberAccess(SyntaxNodeAnalysisContext context, ExpressionSyntax expression, AnalyzerSettings settings)
     {
-        var s = context.SemanticModel.GetSymbolInfo(expression).Symbol;
-        var symbol = s as IPropertySymbol;
-        if (symbol is null)
-            return;
-
-        if (symbol is IPropertySymbol propertySymbol)
+        if (context.SemanticModel.GetSymbolInfo(expression).Symbol is IPropertySymbol propertySymbol)
         {
-            AnalyzePropertyExceptions(context, expression, symbol, settings);
+            AnalyzePropertyExceptions(context, expression, propertySymbol, settings);
         }
     }
 
@@ -804,13 +793,9 @@ private void AnalyzeElementAccess(SyntaxNodeAnalysisContext context)
 
         var elementAccess = (ElementAccessExpressionSyntax)context.Node;
 
-        var symbol = context.SemanticModel.GetSymbolInfo(elementAccess).Symbol as IPropertySymbol;
-        if (symbol is null)
-            return;
-
-        if (symbol is IPropertySymbol propertySymbol)
+        if (context.SemanticModel.GetSymbolInfo(elementAccess).Symbol is IPropertySymbol propertySymbol)
         {
-            AnalyzePropertyExceptions(context, elementAccess, symbol, settings);
+            AnalyzePropertyExceptions(context, elementAccess, propertySymbol, settings);
         }
     }
 
@@ -873,28 +858,17 @@ private HashSet<INamedTypeSymbol> GetPropertyExceptionTypes(SyntaxNodeAnalysisCo
         var xmlDocumentedExceptions = GetExceptionTypesFromDocumentationCommentXml(context.Compilation, propertySymbol);
 
         // Filter exceptions documented specifically for the getter and setter
-        var getterExceptions = xmlDocumentedExceptions.Where(x =>
-            x.Description.Contains(" get ") ||
-            x.Description.Contains(" gets ") ||
-            x.Description.Contains(" getting ") ||
-            x.Description.Contains(" retrieved "));
-
-        var setterExceptions = xmlDocumentedExceptions.Where(x =>
-            x.Description.Contains(" set ") ||
-            x.Description.Contains(" sets ") ||
-            x.Description.Contains(" setting "));
+        var getterExceptions = xmlDocumentedExceptions.Where(IsGetterException);
+        var setterExceptions = xmlDocumentedExceptions.Where(IsSetterException);
 
         if (isSetter && propertySymbol.SetMethod is not null)
         {
-            // Will filter away 
+            // Will filter away
             setterExceptions = ProcessNullable(context, expression, propertySymbol.SetMethod, setterExceptions);
         }
 
         // Handle exceptions that don't explicitly belong to getters or setters
-        var allOtherExceptions = xmlDocumentedExceptions
-            .Except(getterExceptions);
-        allOtherExceptions = allOtherExceptions
-            .Except(setterExceptions);
+        var allOtherExceptions = xmlDocumentedExceptions.Where(x => !IsGetterException(x) && !IsSetterException(x));
 
         if (isSetter && propertySymbol.SetMethod is not null)
         {
@@ -925,12 +899,23 @@ private HashSet<INamedTypeSymbol> GetPropertyExceptionTypes(SyntaxNodeAnalysisCo
         // Add other exceptions not specific to getters or setters
         exceptionTypes.AddRange(allOtherExceptions.Select(x => x.ExceptionType));
         return exceptionTypes;
+
+        static bool IsGetterException(ExceptionInfo ei) =>
+            ei.Description.Contains(" get ") ||
+            ei.Description.Contains(" gets ") ||
+            ei.Description.Contains(" getting ") ||
+            ei.Description.Contains(" retrieved ");
+
+        static bool IsSetterException(ExceptionInfo ei) =>
+            ei.Description.Contains(" set ") ||
+            ei.Description.Contains(" sets ") ||
+            ei.Description.Contains(" setting ");
     }
 
     /// <summary>
     /// Analyzes exceptions thrown by a method, constructor, or other member.
     /// </summary>
-    private void AnalyzeMemberExceptions(SyntaxNodeAnalysisContext context, SyntaxNode node, IMethodSymbol methodSymbol,
+    private void AnalyzeMemberExceptions(SyntaxNodeAnalysisContext context, SyntaxNode node, IMethodSymbol? methodSymbol,
         AnalyzerSettings settings)
     {
         if (methodSymbol is null)
@@ -1027,7 +1012,7 @@ private static IEnumerable<INamedTypeSymbol> GetExceptionTypes(IMethodSymbol met
         // Get exceptions from Throws attributes
         var exceptionAttributes = GetThrowsAttributes(methodSymbol);
 
-        return GetDistictExceptionTypes(exceptionAttributes);
+        return GetDistinctExceptionTypes(exceptionAttributes);
     }
 
     private static IEnumerable<AttributeData> GetThrowsAttributes(ISymbol symbol)
@@ -1062,7 +1047,7 @@ private bool CatchClauseHandlesException(CatchClauseSyntax catchClause, Semantic
     /// </summary>
     private bool IsExceptionHandled(SyntaxNode node, INamedTypeSymbol exceptionType, SemanticModel semanticModel)
     {
-        SyntaxNode? prevNode = null;
+        // SyntaxNode? prevNode = null;
 
         var current = node.Parent;
         while (current is not null)
@@ -1078,7 +1063,7 @@ private bool IsExceptionHandled(SyntaxNode node, INamedTypeSymbol exceptionType,
             if (current is TryStatementSyntax tryStatement)
             {
                 // Prevents analysis within the first try-catch,
-                // when coming from either a catch clause or a finally clause. 
+                // when coming from either a catch clause or a finally clause.
 
                 // Skip if the node is within a catch or finally block of the current try statement
                 bool isInCatchOrFinally = tryStatement.Catches.Any(c => c.Contains(node)) ||
@@ -1097,7 +1082,7 @@ private bool IsExceptionHandled(SyntaxNode node, INamedTypeSymbol exceptionType,
                 }
             }
 
-            prevNode = current;
+            // prevNode = current;
             current = current.Parent;
         }
 
@@ -1182,48 +1167,34 @@ private bool IsExceptionDeclaredInMethod(SyntaxNodeAnalysisContext context, Synt
     {
         foreach (var ancestor in node.Ancestors())
         {
-            IMethodSymbol? methodSymbol = null;
-
-            switch (ancestor)
+            IMethodSymbol? methodSymbol = ancestor switch
             {
-                case MethodDeclarationSyntax methodDeclaration:
-                    methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclaration);
-                    break;
-                case ConstructorDeclarationSyntax constructorDeclaration:
-                    methodSymbol = context.SemanticModel.GetDeclaredSymbol(constructorDeclaration);
-                    break;
-                case AccessorDeclarationSyntax accessorDeclaration:
-                    methodSymbol = context.SemanticModel.GetDeclaredSymbol(accessorDeclaration);
-                    break;
-                case LocalFunctionStatementSyntax localFunction:
-                    methodSymbol = context.SemanticModel.GetDeclaredSymbol(localFunction);
-                    break;
-                case AnonymousFunctionExpressionSyntax anonymousFunction:
-                    methodSymbol = context.SemanticModel.GetSymbolInfo(anonymousFunction).Symbol as IMethodSymbol;
-                    break;
-                default:
-                    // Continue up to next node
-                    continue;
-            }
+                MethodDeclarationSyntax methodDeclaration => context.SemanticModel.GetDeclaredSymbol(methodDeclaration),
+                ConstructorDeclarationSyntax constructorDeclaration => context.SemanticModel.GetDeclaredSymbol(constructorDeclaration),
+                AccessorDeclarationSyntax accessorDeclaration => context.SemanticModel.GetDeclaredSymbol(accessorDeclaration),
+                LocalFunctionStatementSyntax localFunction => context.SemanticModel.GetDeclaredSymbol(localFunction),
+                AnonymousFunctionExpressionSyntax anonymousFunction => context.SemanticModel.GetSymbolInfo(anonymousFunction).Symbol as IMethodSymbol,
+                _ => null,
+            };
 
-            if (methodSymbol is not null)
-            {
-                if (IsExceptionDeclaredInSymbol(methodSymbol, exceptionType))
-                    return true;
+            if (methodSymbol is null)
+                continue; // Continue up to next node
 
-                if (ancestor is AnonymousFunctionExpressionSyntax or LocalFunctionStatementSyntax)
-                {
-                    // Break because you are analyzing a local function or anonymous function (lambda)
-                    // If you don't then it will got to the method, and it will affect analysis of this inline function.
-                    break;
-                }
+            if (IsExceptionDeclaredInSymbol(methodSymbol, exceptionType))
+                return true;
+
+            if (ancestor is AnonymousFunctionExpressionSyntax or LocalFunctionStatementSyntax)
+            {
+                // Break because you are analyzing a local function or anonymous function (lambda)
+                // If you don't then it will got to the method, and it will affect analysis of this inline function.
+                break;
             }
         }
 
         return false;
     }
 
-    private bool IsExceptionDeclaredInSymbol(IMethodSymbol methodSymbol, INamedTypeSymbol exceptionType)
+    private bool IsExceptionDeclaredInSymbol(IMethodSymbol? methodSymbol, INamedTypeSymbol exceptionType)
     {
         if (methodSymbol is null)
             return false;
diff --git a/CheckedExceptions/TypeSymbolExtensions.cs b/CheckedExceptions/TypeSymbolExtensions.cs
@@ -10,7 +10,7 @@ public static class TypeSymbolExtensions
     /// <summary>
     /// Determines if a type inherits from a base type.
     /// </summary>
-    public static bool InheritsFrom(this INamedTypeSymbol type, INamedTypeSymbol baseType)
+    public static bool InheritsFrom(this INamedTypeSymbol? type, INamedTypeSymbol? baseType)
     {
         if (type is null || baseType is null)
             return false;
diff --git a/CheckedExceptions/XmlDocumentationHelper.cs b/CheckedExceptions/XmlDocumentationHelper.cs
@@ -1,8 +1,5 @@
-using System.Text;
 using System.Xml.Linq;
 
-using Microsoft.CodeAnalysis;
-
 namespace Sundstrom.CheckedExceptions;
 
 public static class XmlDocumentationHelper
@@ -16,7 +13,7 @@ public static Dictionary<string, XElement> CreateMemberLookup(XDocument xmlDoc)
         var lookup = members
             .Where(m => m.Attribute("name") is not null) // Ensure the member has a 'name' attribute
             .ToDictionary(
-                m => m.Attribute("name").Value,        // Key: the member's name attribute
+                m => m.Attribute("name")!.Value,        // Key: the member's name attribute
                 m => m                   // Value: the inner XML or text content
             );
 

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ partial class CheckedExceptionsAnalyzer`
`9`	`9`	`/// <summary>`
`10`	`10`	`/// Retrieves the name of the exception type from a ThrowsAttribute's AttributeData.`
`11`	`11`	`/// </summary>`
`12`		`- private string GetExceptionTypeName(AttributeData attributeData)`
	`12`	`+ private string GetExceptionTypeName(AttributeData? attributeData)`
`13`	`13`	`{`
`14`	`14`	`if (attributeData is null)`
`15`	`15`	`return string.Empty;`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ public static class TypeSymbolExtensions`
`10`	`10`	`/// <summary>`
`11`	`11`	`/// Determines if a type inherits from a base type.`
`12`	`12`	`/// </summary>`
`13`		`- public static bool InheritsFrom(this INamedTypeSymbol type, INamedTypeSymbol baseType)`
	`13`	`+ public static bool InheritsFrom(this INamedTypeSymbol? type, INamedTypeSymbol? baseType)`
`14`	`14`	`{`
`15`	`15`	`if (type is null \|\| baseType is null)`
`16`	`16`	`return false;`