Enables Nullable Reference Types

BenjaminMichaelis · BenjaminMichaelis · commit ff59bca56868 · 2026-02-24T01:09:59.000-08:00
Enables Nullable Reference Types throughout the project.

Adds null checks and throws exceptions where syntax root or semantic model retrieval fails, improving code safety and preventing potential null reference exceptions.
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -2,5 +2,6 @@
   <PropertyGroup>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <LangVersion>14.0</LangVersion>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 </Project>
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer.CodeFixes/AsyncVoid.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer.CodeFixes/AsyncVoid.cs
@@ -26,13 +26,21 @@ public sealed override FixAllProvider GetFixAllProvider()
 
         public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
-            SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            SyntaxNode? root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            if (root is null)
+            {
+                return;
+            }
 
             Diagnostic diagnostic = context.Diagnostics.First();
             Microsoft.CodeAnalysis.Text.TextSpan diagnosticSpan = diagnostic.Location.SourceSpan;
 
             // Find the type declaration identified by the diagnostic.
             var declaration = root.FindToken(diagnosticSpan.Start).Parent as MethodDeclarationSyntax;
+            if (declaration is null)
+            {
+                return;
+            }
 
             // Register a code action that will invoke the fix.
             context.RegisterCodeFix(
@@ -45,7 +53,8 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
 
         private static async Task<Document> MakeReturnTask(Document document, MethodDeclarationSyntax declaration, CancellationToken cancellationToken)
         {
-            SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false)
+                ?? throw new System.InvalidOperationException("Could not get syntax root");
             SyntaxNode newRoot = root.ReplaceNode(declaration.ReturnType, SyntaxFactory.ParseTypeName(typeof(Task).Name).WithTrailingTrivia(SyntaxFactory.Space));
             return document.WithSyntaxRoot(newRoot);
         }
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer.CodeFixes/AttributesOnSeparateLines.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer.CodeFixes/AttributesOnSeparateLines.cs
@@ -29,7 +29,11 @@ public sealed override FixAllProvider GetFixAllProvider()
 
         public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
-            SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            SyntaxNode? root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            if (root is null)
+            {
+                return;
+            }
 
             Diagnostic diagnostic = context.Diagnostics.First();
             Microsoft.CodeAnalysis.Text.TextSpan diagnosticSpan = diagnostic.Location.SourceSpan;
@@ -38,14 +42,14 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
             SyntaxToken declaration = root.FindToken(diagnosticSpan.Start);
 
             // Find the enclosing AttributeList
-            SyntaxNode attributeList = declaration.Parent;
+            SyntaxNode attributeList = declaration.Parent!;
             while (!attributeList.IsKind(SyntaxKind.AttributeList))
             {
-                attributeList = attributeList.Parent;
+                attributeList = attributeList.Parent!;
             }
 
             // Get the class, method or property adjacent to the AttributeList
-            SyntaxNode parentDeclaration = attributeList.Parent;
+            SyntaxNode parentDeclaration = attributeList.Parent!;
 
             // Register a code action that will invoke the fix.
             context.RegisterCodeFix(
@@ -78,7 +82,8 @@ private static async Task<Document> PutOnSeparateLine(Document document, SyntaxN
                 .WithAdditionalAnnotations(Formatter.Annotation);
 
             // Replace the old local declaration with the new local declaration.
-            SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false)
+                ?? throw new InvalidOperationException("Could not get syntax root");
             SyntaxNode newRoot = oldRoot.ReplaceNode(parentDeclaration, newNode);
 
             return document.WithSyntaxRoot(newRoot);
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer.CodeFixes/NamingFieldPascalUnderscore.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer.CodeFixes/NamingFieldPascalUnderscore.cs
@@ -27,7 +27,11 @@ public sealed override FixAllProvider GetFixAllProvider()
 
         public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
-            SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            SyntaxNode? root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            if (root is null)
+            {
+                return;
+            }
 
             Diagnostic diagnostic = context.Diagnostics.First();
             TextSpan diagnosticSpan = diagnostic.Location.SourceSpan;
@@ -50,8 +54,16 @@ private static async Task<Solution> MakePascalWithUnderscore(Document document,
             string nameWithoutUnderscore = nameOfField.TrimStart('_');
             string newName = "_" + char.ToUpper(nameWithoutUnderscore.First()) + nameWithoutUnderscore.Substring(1);
 
-            SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            ISymbol symbol = semanticModel.GetDeclaredSymbol(declaration.Parent, cancellationToken);
+            SemanticModel? semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            if (semanticModel is null || declaration.Parent is null)
+            {
+                return document.Project.Solution;
+            }
+            ISymbol? symbol = semanticModel.GetDeclaredSymbol(declaration.Parent, cancellationToken);
+            if (symbol is null)
+            {
+                return document.Project.Solution;
+            }
             Solution solution = document.Project.Solution;
             SymbolRenameOptions options = new()
             {
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer.CodeFixes/NamingIdentifierPascal.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer.CodeFixes/NamingIdentifierPascal.cs
@@ -27,7 +27,11 @@ public sealed override FixAllProvider GetFixAllProvider()
 
         public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
-            SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            SyntaxNode? root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            if (root is null)
+            {
+                return;
+            }
 
             Diagnostic diagnostic = context.Diagnostics.First();
             TextSpan diagnosticSpan = diagnostic.Location.SourceSpan;
@@ -49,8 +53,16 @@ private static async Task<Solution> MakePascal(Document document, SyntaxToken de
             string nameOfField = declaration.ValueText;
             string newName = char.ToUpper(nameOfField.First()) + nameOfField.Substring(1);
 
-            SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            ISymbol symbol = semanticModel.GetDeclaredSymbol(declaration.Parent, cancellationToken);
+            SemanticModel? semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            if (semanticModel is null || declaration.Parent is null)
+            {
+                return document.Project.Solution;
+            }
+            ISymbol? symbol = semanticModel.GetDeclaredSymbol(declaration.Parent, cancellationToken);
+            if (symbol is null)
+            {
+                return document.Project.Solution;
+            }
             Solution solution = document.Project.Solution;
             SymbolRenameOptions options = new()
             {
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer.Integration.Tests/AnalyzerTests.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer.Integration.Tests/AnalyzerTests.cs
@@ -34,7 +34,9 @@ public static async Task ProcessProject(FileInfo projectFile)
             using var workspace = MSBuildWorkspace.Create();
             Project project = await workspace.OpenProjectAsync(projectFile.FullName).ConfigureAwait(false);
 
-            CompilationWithAnalyzers compilationWithAnalyzers = (await project.GetCompilationAsync().ConfigureAwait(false))
+            Compilation compilation = await project.GetCompilationAsync().ConfigureAwait(false)
+                ?? throw new InvalidOperationException("Could not get compilation");
+            CompilationWithAnalyzers compilationWithAnalyzers = compilation
                 .WithAnalyzers(ImmutableArray.Create(GetAnalyzers().ToArray()));
 
             ImmutableArray<Diagnostic> diags = await compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync().ConfigureAwait(false);
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer.Test/Helpers/CodeFixVerifier.Helper.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer.Test/Helpers/CodeFixVerifier.Helper.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -26,7 +27,8 @@ private static async Task<Document> ApplyFix(Document document, CodeAction codeA
         {
             System.Collections.Immutable.ImmutableArray<CodeActionOperation> operations = await codeAction.GetOperationsAsync(CancellationToken.None);
             Solution solution = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution;
-            return solution.GetDocument(document.Id);
+            return solution.GetDocument(document.Id)
+                ?? throw new InvalidOperationException("Could not get document from solution");
         }
 
         /// <summary>
@@ -66,7 +68,8 @@ private static IEnumerable<Diagnostic> GetNewDiagnostics(IEnumerable<Diagnostic>
         /// <returns>The compiler diagnostics that were found in the code</returns>
         private static IEnumerable<Diagnostic> GetCompilerDiagnostics(Document document)
         {
-            return document.GetSemanticModelAsync().Result.GetDiagnostics();
+            return (document.GetSemanticModelAsync().Result
+                ?? throw new InvalidOperationException("Could not get semantic model")).GetDiagnostics();
         }
 
         /// <summary>
@@ -77,7 +80,8 @@ private static IEnumerable<Diagnostic> GetCompilerDiagnostics(Document document)
         private static string GetStringFromDocument(Document document)
         {
             Document simplifiedDoc = Simplifier.ReduceAsync(document, Simplifier.Annotation).Result;
-            SyntaxNode root = simplifiedDoc.GetSyntaxRootAsync().Result;
+            SyntaxNode root = simplifiedDoc.GetSyntaxRootAsync().Result
+                ?? throw new InvalidOperationException("Could not get syntax root");
             root = Formatter.Format(root, Formatter.Annotation, simplifiedDoc.Project.Solution.Workspace);
             return root.GetText().ToString();
         }
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer.Test/Helpers/DiagnosticVerifier.Helper.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer.Test/Helpers/DiagnosticVerifier.Helper.cs
@@ -61,7 +61,9 @@ protected static Diagnostic[] GetSortedDiagnosticsFromDocuments(DiagnosticAnalyz
             var diagnostics = new List<Diagnostic>();
             foreach (Project project in projects)
             {
-                CompilationWithAnalyzers compilationWithAnalyzers = project.GetCompilationAsync().Result.WithAnalyzers(ImmutableArray.Create(analyzer));
+                CompilationWithAnalyzers compilationWithAnalyzers = (project.GetCompilationAsync().Result
+                    ?? throw new InvalidOperationException("Could not get compilation"))
+                    .WithAnalyzers(ImmutableArray.Create(analyzer));
                 ImmutableArray<Diagnostic> diags = compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync().Result;
                 foreach (Diagnostic diag in diags)
                 {
@@ -74,7 +76,7 @@ protected static Diagnostic[] GetSortedDiagnosticsFromDocuments(DiagnosticAnalyz
                         for (int i = 0; i < documents.Length; i++)
                         {
                             Document document = documents[i];
-                            SyntaxTree tree = document.GetSyntaxTreeAsync().Result;
+                            SyntaxTree? tree = document.GetSyntaxTreeAsync().Result;
                             if (tree == diag.Location.SourceTree)
                             {
                                 diagnostics.Add(diag);
@@ -173,7 +175,8 @@ private static Project CreateProject(string[] sources, string language = Languag
                 count++;
             }
 
-            return solution.GetProject(projectId);
+            return solution.GetProject(projectId)
+                ?? throw new InvalidOperationException("Could not get project from solution");
         }
         #endregion
     }
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer.Test/Verifiers/CodeFixVerifier.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer.Test/Verifiers/CodeFixVerifier.cs
@@ -22,7 +22,7 @@ public abstract partial class CodeFixVerifier : DiagnosticVerifier
         /// Returns the codefix being tested (C#) - to be implemented in non-abstract class
         /// </summary>
         /// <returns>The CodeFixProvider to be used for CSharp code</returns>
-        protected virtual CodeFixProvider GetCSharpCodeFixProvider()
+        protected virtual CodeFixProvider? GetCSharpCodeFixProvider()
         {
             return null;
         }
@@ -31,7 +31,7 @@ protected virtual CodeFixProvider GetCSharpCodeFixProvider()
         /// Returns the codefix being tested (VB) - to be implemented in non-abstract class
         /// </summary>
         /// <returns>The CodeFixProvider to be used for VisualBasic code</returns>
-        protected virtual CodeFixProvider GetBasicCodeFixProvider()
+        protected virtual CodeFixProvider? GetBasicCodeFixProvider()
         {
             return null;
         }
@@ -73,8 +73,10 @@ protected async Task VerifyBasicFix(string oldSource, string newSource, int? cod
         /// <param name="newSource">A class in the form of a string after the CodeFix was applied to it</param>
         /// <param name="codeFixIndex">Index determining which codefix to apply if there are multiple</param>
         /// <param name="allowNewCompilerDiagnostics">A bool controlling whether or not the test will fail if the CodeFix introduces other warnings after being applied</param>
-        private static async Task VerifyFix(string language, DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider, string oldSource, string newSource, int? codeFixIndex, bool allowNewCompilerDiagnostics)
+        private static async Task VerifyFix(string language, DiagnosticAnalyzer? analyzer, CodeFixProvider? codeFixProvider, string oldSource, string newSource, int? codeFixIndex, bool allowNewCompilerDiagnostics)
         {
+            ArgumentNullException.ThrowIfNull(analyzer);
+            ArgumentNullException.ThrowIfNull(codeFixProvider);
             Document document = CreateDocument(oldSource, language);
             Diagnostic[] analyzerDiagnostics = GetSortedDiagnosticsFromDocuments(analyzer, [document]);
             IEnumerable<Diagnostic> compilerDiagnostics = GetCompilerDiagnostics(document);
@@ -106,11 +108,11 @@ private static async Task VerifyFix(string language, DiagnosticAnalyzer analyzer
                 if (!allowNewCompilerDiagnostics && newCompilerDiagnostics.Any())
                 {
                     // Format and get the compiler diagnostics again so that the locations make sense in the output
-                    document = document.WithSyntaxRoot(Formatter.Format(document.GetSyntaxRootAsync().Result, Formatter.Annotation, document.Project.Solution.Workspace));
+                    document = document.WithSyntaxRoot(Formatter.Format(document.GetSyntaxRootAsync().Result!, Formatter.Annotation, document.Project.Solution.Workspace));
                     newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, GetCompilerDiagnostics(document));
 
                     Assert.Fail($"Fix introduced new compiler diagnostics:{string.Join(Environment.NewLine, newCompilerDiagnostics.Select(d => d.ToString()))}" +
-                        $"{Environment.NewLine}{Environment.NewLine}New document:{Environment.NewLine}{document.GetSyntaxRootAsync().Result.ToFullString()}{Environment.NewLine}");
+                        $"{Environment.NewLine}{Environment.NewLine}New document:{Environment.NewLine}{document.GetSyntaxRootAsync().Result!.ToFullString()}{Environment.NewLine}");
                 }
 
                 //check if there are analyzer diagnostics left after the code fix
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer.Test/Verifiers/DiagnosticVerifier.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer.Test/Verifiers/DiagnosticVerifier.cs
@@ -17,15 +17,15 @@ public abstract partial class DiagnosticVerifier
         /// <summary>
         /// Get the CSharp analyzer being tested - to be implemented in non-abstract class
         /// </summary>
-        protected virtual DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer()
+        protected virtual DiagnosticAnalyzer? GetCSharpDiagnosticAnalyzer()
         {
             return null;
         }
 
         /// <summary>
         /// Get the Visual Basic analyzer being tested (C#) - to be implemented in non-abstract class
         /// </summary>
-        protected virtual DiagnosticAnalyzer GetBasicDiagnosticAnalyzer()
+        protected virtual DiagnosticAnalyzer? GetBasicDiagnosticAnalyzer()
         {
             return null;
         }
@@ -85,8 +85,9 @@ protected void VerifyBasicDiagnostic(string[] sources, params DiagnosticResult[]
         /// <param name="language">The language of the classes represented by the source strings</param>
         /// <param name="analyzer">The analyzer to be run on the source code</param>
         /// <param name="expected">DiagnosticResults that should appear after the analyzer is run on the sources</param>
-        private static void VerifyDiagnostics(string[] sources, string language, DiagnosticAnalyzer analyzer, params DiagnosticResult[] expected)
+        private static void VerifyDiagnostics(string[] sources, string language, DiagnosticAnalyzer? analyzer, params DiagnosticResult[] expected)
         {
+            ArgumentNullException.ThrowIfNull(analyzer);
             Diagnostic[] diagnostics = GetSortedDiagnostics(sources, language, analyzer);
             VerifyDiagnosticResults(diagnostics, analyzer, expected);
         }
@@ -213,7 +214,7 @@ private static string FormatDiagnostics(DiagnosticAnalyzer analyzer, params Diag
                             Assert.IsTrue(location.IsInSource,
                                 $"Test base does not currently handle diagnostics in metadata locations. Diagnostic in metadata: {diagnostics[i]}{Environment.NewLine}");
 
-                            string resultMethodName = diagnostics[i].Location.SourceTree.FilePath.EndsWith(".cs", StringComparison.Ordinal) ? "GetCSharpResultAt" : "GetBasicResultAt";
+                            string resultMethodName = diagnostics[i].Location.SourceTree!.FilePath.EndsWith(".cs", StringComparison.Ordinal) ? "GetCSharpResultAt" : "GetBasicResultAt";
                             Microsoft.CodeAnalysis.Text.LinePosition linePosition = diagnostics[i].Location.GetLineSpan().StartLinePosition;
 
                             builder.AppendFormat("{0}({1}, {2}, {3}.{4})",
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer/AnalyzerBlockMixins.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer/AnalyzerBlockMixins.cs
@@ -5,17 +5,17 @@ namespace IntelliTect.Analyzer
 {
     public static class AnalyzerBlockMixins
     {
-        private static string GetEnumAttributeValue<TAttribute>(Enum value, Func<TAttribute, string> valueAccessor)
+        private static string? GetEnumAttributeValue<TAttribute>(Enum value, Func<TAttribute, string> valueAccessor)
             where TAttribute : Attribute
         {
-            FieldInfo fi = value.GetType().GetRuntimeField(value.ToString());
+            FieldInfo? fi = value.GetType().GetRuntimeField(value.ToString());
 
-            var attributes = (TAttribute[])fi?.GetCustomAttributes(typeof(TAttribute), false);
+            TAttribute[]? attributes = (TAttribute[]?)fi?.GetCustomAttributes(typeof(TAttribute), false);
 
             return attributes?.Length > 0 ? valueAccessor(attributes[0]) : null;
         }
 
-        public static string GetDescription(this AnalyzerBlock value)
+        public static string? GetDescription(this AnalyzerBlock value)
         {
             if (value == AnalyzerBlock.None)
             {
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer/Analyzers/AsyncVoid.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer/Analyzers/AsyncVoid.cs
@@ -35,7 +35,10 @@ public override void Initialize(AnalysisContext context)
 
         private static void AnalyzeSymbol(SymbolAnalysisContext context)
         {
-            var methodSymbol = context.Symbol as IMethodSymbol;
+            if (context.Symbol is not IMethodSymbol methodSymbol)
+            {
+                return;
+            }
 
             if (methodSymbol.IsAsync && methodSymbol.ReturnsVoid)
             {
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer/Analyzers/AttributesOnSeparateLines.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer/Analyzers/AttributesOnSeparateLines.cs
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer/Analyzers/BanImplicitDateTimeToDateTimeOffsetConversion.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer/Analyzers/BanImplicitDateTimeToDateTimeOffsetConversion.cs
diff --git a/IntelliTect.Analyzer/IntelliTect.Analyzer/Analyzers/UnusedLocalVariable.cs b/IntelliTect.Analyzer/IntelliTect.Analyzer/Analyzers/UnusedLocalVariable.cs

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+using System;`
`1`	`2`	`using System.Collections.Generic;`
`2`	`3`	`using System.Linq;`
`3`	`4`	`using System.Threading;`
`@@ -26,7 +27,8 @@ private static async Task<Document> ApplyFix(Document document, CodeAction codeA`
`26`	`27`	`{`
`27`	`28`	`System.Collections.Immutable.ImmutableArray<CodeActionOperation> operations = await codeAction.GetOperationsAsync(CancellationToken.None);`
`28`	`29`	`Solution solution = operations.OfType<ApplyChangesOperation>().Single().ChangedSolution;`
`29`		`- return solution.GetDocument(document.Id);`
	`30`	`+ return solution.GetDocument(document.Id)`
	`31`	`+ ?? throw new InvalidOperationException("Could not get document from solution");`
`30`	`32`	`}`
`31`	`33`
`32`	`34`	`/// <summary>`
`@@ -66,7 +68,8 @@ private static IEnumerable<Diagnostic> GetNewDiagnostics(IEnumerable<Diagnostic>`
`66`	`68`	`/// <returns>The compiler diagnostics that were found in the code</returns>`
`67`	`69`	`private static IEnumerable<Diagnostic> GetCompilerDiagnostics(Document document)`
`68`	`70`	`{`
`69`		`- return document.GetSemanticModelAsync().Result.GetDiagnostics();`
	`71`	`+ return (document.GetSemanticModelAsync().Result`
	`72`	`+ ?? throw new InvalidOperationException("Could not get semantic model")).GetDiagnostics();`
`70`	`73`	`}`
`71`	`74`
`72`	`75`	`/// <summary>`
`@@ -77,7 +80,8 @@ private static IEnumerable<Diagnostic> GetCompilerDiagnostics(Document document)`
`77`	`80`	`private static string GetStringFromDocument(Document document)`
`78`	`81`	`{`
`79`	`82`	`Document simplifiedDoc = Simplifier.ReduceAsync(document, Simplifier.Annotation).Result;`
`80`		`- SyntaxNode root = simplifiedDoc.GetSyntaxRootAsync().Result;`
	`83`	`+ SyntaxNode root = simplifiedDoc.GetSyntaxRootAsync().Result`
	`84`	`+ ?? throw new InvalidOperationException("Could not get syntax root");`
`81`	`85`	`root = Formatter.Format(root, Formatter.Annotation, simplifiedDoc.Project.Solution.Workspace);`
`82`	`86`	`return root.GetText().ToString();`
`83`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,9 @@ protected static Diagnostic[] GetSortedDiagnosticsFromDocuments(DiagnosticAnalyz`
`61`	`61`	`var diagnostics = new List<Diagnostic>();`
`62`	`62`	`foreach (Project project in projects)`
`63`	`63`	`{`
`64`		`- CompilationWithAnalyzers compilationWithAnalyzers = project.GetCompilationAsync().Result.WithAnalyzers(ImmutableArray.Create(analyzer));`
	`64`	`+ CompilationWithAnalyzers compilationWithAnalyzers = (project.GetCompilationAsync().Result`
	`65`	`+ ?? throw new InvalidOperationException("Could not get compilation"))`
	`66`	`+ .WithAnalyzers(ImmutableArray.Create(analyzer));`
`65`	`67`	`ImmutableArray<Diagnostic> diags = compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync().Result;`
`66`	`68`	`foreach (Diagnostic diag in diags)`
`67`	`69`	`{`
`@@ -74,7 +76,7 @@ protected static Diagnostic[] GetSortedDiagnosticsFromDocuments(DiagnosticAnalyz`
`74`	`76`	`for (int i = 0; i < documents.Length; i++)`
`75`	`77`	`{`
`76`	`78`	`Document document = documents[i];`
`77`		`- SyntaxTree tree = document.GetSyntaxTreeAsync().Result;`
	`79`	`+ SyntaxTree? tree = document.GetSyntaxTreeAsync().Result;`
`78`	`80`	`if (tree == diag.Location.SourceTree)`
`79`	`81`	`{`
`80`	`82`	`diagnostics.Add(diag);`
`@@ -173,7 +175,8 @@ private static Project CreateProject(string[] sources, string language = Languag`
`173`	`175`	`count++;`
`174`	`176`	`}`
`175`	`177`
`176`		`- return solution.GetProject(projectId);`
	`178`	`+ return solution.GetProject(projectId)`
	`179`	`+ ?? throw new InvalidOperationException("Could not get project from solution");`
`177`	`180`	`}`
`178`	`181`	`#endregion`
`179`	`182`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public abstract partial class CodeFixVerifier : DiagnosticVerifier`
`22`	`22`	`/// Returns the codefix being tested (C#) - to be implemented in non-abstract class`
`23`	`23`	`/// </summary>`
`24`	`24`	`/// <returns>The CodeFixProvider to be used for CSharp code</returns>`
`25`		`- protected virtual CodeFixProvider GetCSharpCodeFixProvider()`
	`25`	`+ protected virtual CodeFixProvider? GetCSharpCodeFixProvider()`
`26`	`26`	`{`
`27`	`27`	`return null;`
`28`	`28`	`}`
`@@ -31,7 +31,7 @@ protected virtual CodeFixProvider GetCSharpCodeFixProvider()`
`31`	`31`	`/// Returns the codefix being tested (VB) - to be implemented in non-abstract class`
`32`	`32`	`/// </summary>`
`33`	`33`	`/// <returns>The CodeFixProvider to be used for VisualBasic code</returns>`
`34`		`- protected virtual CodeFixProvider GetBasicCodeFixProvider()`
	`34`	`+ protected virtual CodeFixProvider? GetBasicCodeFixProvider()`
`35`	`35`	`{`
`36`	`36`	`return null;`
`37`	`37`	`}`
`@@ -73,8 +73,10 @@ protected async Task VerifyBasicFix(string oldSource, string newSource, int? cod`
`73`	`73`	`/// <param name="newSource">A class in the form of a string after the CodeFix was applied to it</param>`
`74`	`74`	`/// <param name="codeFixIndex">Index determining which codefix to apply if there are multiple</param>`
`75`	`75`	`/// <param name="allowNewCompilerDiagnostics">A bool controlling whether or not the test will fail if the CodeFix introduces other warnings after being applied</param>`
`76`		`- private static async Task VerifyFix(string language, DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider, string oldSource, string newSource, int? codeFixIndex, bool allowNewCompilerDiagnostics)`
	`76`	`+ private static async Task VerifyFix(string language, DiagnosticAnalyzer? analyzer, CodeFixProvider? codeFixProvider, string oldSource, string newSource, int? codeFixIndex, bool allowNewCompilerDiagnostics)`
`77`	`77`	`{`
	`78`	`+ ArgumentNullException.ThrowIfNull(analyzer);`
	`79`	`+ ArgumentNullException.ThrowIfNull(codeFixProvider);`
`78`	`80`	`Document document = CreateDocument(oldSource, language);`
`79`	`81`	`Diagnostic[] analyzerDiagnostics = GetSortedDiagnosticsFromDocuments(analyzer, [document]);`
`80`	`82`	`IEnumerable<Diagnostic> compilerDiagnostics = GetCompilerDiagnostics(document);`
`@@ -106,11 +108,11 @@ private static async Task VerifyFix(string language, DiagnosticAnalyzer analyzer`
`106`	`108`	`if (!allowNewCompilerDiagnostics && newCompilerDiagnostics.Any())`
`107`	`109`	`{`
`108`	`110`	`// Format and get the compiler diagnostics again so that the locations make sense in the output`
`109`		`- document = document.WithSyntaxRoot(Formatter.Format(document.GetSyntaxRootAsync().Result, Formatter.Annotation, document.Project.Solution.Workspace));`
	`111`	`+ document = document.WithSyntaxRoot(Formatter.Format(document.GetSyntaxRootAsync().Result!, Formatter.Annotation, document.Project.Solution.Workspace));`
`110`	`112`	`newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, GetCompilerDiagnostics(document));`
`111`	`113`
`112`	`114`	`Assert.Fail($"Fix introduced new compiler diagnostics:{string.Join(Environment.NewLine, newCompilerDiagnostics.Select(d => d.ToString()))}" +`
`113`		`- $"{Environment.NewLine}{Environment.NewLine}New document:{Environment.NewLine}{document.GetSyntaxRootAsync().Result.ToFullString()}{Environment.NewLine}");`
	`115`	`+ $"{Environment.NewLine}{Environment.NewLine}New document:{Environment.NewLine}{document.GetSyntaxRootAsync().Result!.ToFullString()}{Environment.NewLine}");`
`114`	`116`	`}`
`115`	`117`
`116`	`118`	`//check if there are analyzer diagnostics left after the code fix`
Original file line number	Diff line number	Diff line change
`@@ -17,15 +17,15 @@ public abstract partial class DiagnosticVerifier`
`17`	`17`	`/// <summary>`
`18`	`18`	`/// Get the CSharp analyzer being tested - to be implemented in non-abstract class`
`19`	`19`	`/// </summary>`
`20`		`- protected virtual DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer()`
	`20`	`+ protected virtual DiagnosticAnalyzer? GetCSharpDiagnosticAnalyzer()`
`21`	`21`	`{`
`22`	`22`	`return null;`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`/// <summary>`
`26`	`26`	`/// Get the Visual Basic analyzer being tested (C#) - to be implemented in non-abstract class`
`27`	`27`	`/// </summary>`
`28`		`- protected virtual DiagnosticAnalyzer GetBasicDiagnosticAnalyzer()`
	`28`	`+ protected virtual DiagnosticAnalyzer? GetBasicDiagnosticAnalyzer()`
`29`	`29`	`{`
`30`	`30`	`return null;`
`31`	`31`	`}`
`@@ -85,8 +85,9 @@ protected void VerifyBasicDiagnostic(string[] sources, params DiagnosticResult[]`
`85`	`85`	`/// <param name="language">The language of the classes represented by the source strings</param>`
`86`	`86`	`/// <param name="analyzer">The analyzer to be run on the source code</param>`
`87`	`87`	`/// <param name="expected">DiagnosticResults that should appear after the analyzer is run on the sources</param>`
`88`		`- private static void VerifyDiagnostics(string[] sources, string language, DiagnosticAnalyzer analyzer, params DiagnosticResult[] expected)`
	`88`	`+ private static void VerifyDiagnostics(string[] sources, string language, DiagnosticAnalyzer? analyzer, params DiagnosticResult[] expected)`
`89`	`89`	`{`
	`90`	`+ ArgumentNullException.ThrowIfNull(analyzer);`
`90`	`91`	`Diagnostic[] diagnostics = GetSortedDiagnostics(sources, language, analyzer);`
`91`	`92`	`VerifyDiagnosticResults(diagnostics, analyzer, expected);`
`92`	`93`	`}`
`@@ -213,7 +214,7 @@ private static string FormatDiagnostics(DiagnosticAnalyzer analyzer, params Diag`
`213`	`214`	`Assert.IsTrue(location.IsInSource,`
`214`	`215`	`$"Test base does not currently handle diagnostics in metadata locations. Diagnostic in metadata: {diagnostics[i]}{Environment.NewLine}");`
`215`	`216`
`216`		`- string resultMethodName = diagnostics[i].Location.SourceTree.FilePath.EndsWith(".cs", StringComparison.Ordinal) ? "GetCSharpResultAt" : "GetBasicResultAt";`
	`217`	`+ string resultMethodName = diagnostics[i].Location.SourceTree!.FilePath.EndsWith(".cs", StringComparison.Ordinal) ? "GetCSharpResultAt" : "GetBasicResultAt";`
`217`	`218`	`Microsoft.CodeAnalysis.Text.LinePosition linePosition = diagnostics[i].Location.GetLineSpan().StartLinePosition;`
`218`	`219`
`219`	`220`	`builder.AppendFormat("{0}({1}, {2}, {3}.{4})",`