From f9e434859affd7e0358cd104aca2892a154722da Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Thu, 22 Jun 2023 11:40:14 -0500
Subject: [PATCH] Update Microsoft.CodeAnalysis.Analyzers to use Roslyn 3.7.0

---
 Directory.Build.props                         |  3 ++
 eng/Versions.props                            |  2 +-
 .../Fixers/CSharpPreferIsKindFix.cs           |  3 ++
 .../FixerWithFixAllAnalyzer.Fixer.cs          |  5 ++-
 .../InternalImplementationOnlyAnalyzer.cs     |  2 +-
 .../CompareSymbolsCorrectlyAnalyzer.cs        |  2 +-
 .../CompilerExtensionStrictApiAnalyzer.cs     |  9 +++-
 .../DiagnosticAnalyzerAPIUsageAnalyzer.cs     |  8 ++--
 .../DiagnosticAnalyzerAttributeAnalyzer.cs    |  2 +-
 ...deWithinAnalyzerTypeCompilationAnalyzer.cs |  2 +-
 .../DiagnosticAnalyzerFieldsAnalyzer.cs       |  2 +-
 .../DiagnosticDescriptorCreationAnalyzer.cs   | 21 +++++++--
 ...onAnalyzer_IdRangeAndCategoryValidation.cs |  2 +-
 ...criptorCreationAnalyzer_ReleaseTracking.cs |  4 +-
 ...rCreationAnalyzer_ResourceStringsFormat.cs |  3 +-
 ...alyzerReleaseTrackingFix.FixAllProvider.cs |  4 +-
 .../Fixers/AnalyzerReleaseTrackingFix.cs      |  4 +-
 .../ApplyDiagnosticAnalyzerAttributeFix.cs    |  2 +-
 .../Fixers/CompareSymbolsCorrectlyFix.cs      |  8 ++--
 .../ConfigureGeneratedCodeAnalysisFix.cs      |  4 +-
 ...umentsCorrectlyFix.CustomFixAllProvider.cs |  2 +-
 ...agnosticDescriptorArgumentsCorrectlyFix.cs |  4 +-
 .../Fixers/EnableConcurrentExecutionFix.cs    |  2 +-
 .../MetaAnalyzers/RegisterActionAnalyzer.cs   |  4 +-
 .../MetaAnalyzers/ReportDiagnosticAnalyzer.cs |  8 ++--
 .../SymbolIsBannedInAnalyzersAnalyzer.cs      |  5 ++-
 src/PublicApiAnalyzers/Directory.Build.props  |  1 +
 .../Compiler/Analyzer.Utilities.projitems     |  3 +-
 .../Extensions/AdditionalTextExtensions.cs    | 18 ++++++++
 ...ataAnalysis.TaintedDataOperationVisitor.cs |  2 +-
 .../DataFlow/AnalysisEntityFactory.cs         |  2 +-
 .../Workspaces/DocumentExtensions.cs          | 43 +++++++++++++++++++
 .../Workspaces/Workspaces.Utilities.projitems |  1 +
 33 files changed, 141 insertions(+), 46 deletions(-)
 create mode 100644 src/Utilities/Compiler/Extensions/AdditionalTextExtensions.cs
 create mode 100644 src/Utilities/Workspaces/DocumentExtensions.cs

diff --git a/Directory.Build.props b/Directory.Build.props
index a8feff3916..84c7774033 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -49,6 +49,9 @@
     <!-- When building in source build mode, treat this set of warnings not as errors.-->
     <!-- Some crefs reference internal APIs not present in the reference package. -->
     <NoWarn>$(NoWarn);CS1574;CS8602</NoWarn>
+    <!-- Source build reference assemblies are not correctly annotated.
+      https://github.com/dotnet/source-build/issues/3531 -->
+    <NoWarn>$(NoWarn);CS8603</NoWarn>
   </PropertyGroup>
 
   <PropertyGroup>
diff --git a/eng/Versions.props b/eng/Versions.props
index 728c5f7cd4..d87602ff15 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -69,7 +69,7 @@
     <MicrosoftCodeAnalysisVersionForResxSourceGenerators>4.0.1</MicrosoftCodeAnalysisVersionForResxSourceGenerators>
     <MicrosoftCodeAnalysisVersionForNetAnalyzers>3.3.1</MicrosoftCodeAnalysisVersionForNetAnalyzers>
     <MicrosoftCodeAnalysisVersionForTextAnalyzers>3.3.1</MicrosoftCodeAnalysisVersionForTextAnalyzers>
-    <MicrosoftCodeAnalysisVersionForCodeAnalysisAnalyzers>3.3.1</MicrosoftCodeAnalysisVersionForCodeAnalysisAnalyzers>
+    <MicrosoftCodeAnalysisVersionForCodeAnalysisAnalyzers>3.7.0</MicrosoftCodeAnalysisVersionForCodeAnalysisAnalyzers>
     <MicrosoftCodeAnalysisVersionForToolsAndUtilities>3.3.1</MicrosoftCodeAnalysisVersionForToolsAndUtilities>
     <!-- Versions for tests and general utility execution. -->
     <!-- This version is for utility and executable assemblies. The version here should not overlap with any of the surface
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/CSharp/MetaAnalyzers/Fixers/CSharpPreferIsKindFix.cs b/src/Microsoft.CodeAnalysis.Analyzers/CSharp/MetaAnalyzers/Fixers/CSharpPreferIsKindFix.cs
index 111955aea2..c9de785bfc 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/CSharp/MetaAnalyzers/Fixers/CSharpPreferIsKindFix.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/CSharp/MetaAnalyzers/Fixers/CSharpPreferIsKindFix.cs
@@ -17,6 +17,9 @@ public sealed class CSharpPreferIsKindFix : PreferIsKindFix
         protected override SyntaxNode? TryGetNodeToFix(SyntaxNode root, TextSpan span)
         {
             var binaryExpression = root.FindNode(span, getInnermostNodeForTie: true).FirstAncestorOrSelf<BinaryExpressionSyntax>();
+            if (binaryExpression is null)
+                return null;
+
             if (binaryExpression.Left.IsKind(SyntaxKind.InvocationExpression) ||
                 binaryExpression.Left.IsKind(SyntaxKind.ConditionalAccessExpression))
             {
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/FixAnalyzers/FixerWithFixAllAnalyzer.Fixer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/FixAnalyzers/FixerWithFixAllAnalyzer.Fixer.cs
index 0c9b53739e..e589751216 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/FixAnalyzers/FixerWithFixAllAnalyzer.Fixer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/FixAnalyzers/FixerWithFixAllAnalyzer.Fixer.cs
@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Analyzer.Utilities;
 using Analyzer.Utilities.Extensions;
 using Microsoft.CodeAnalysis.Analyzers.FixAnalyzers;
 using Microsoft.CodeAnalysis.CodeActions;
@@ -28,7 +29,7 @@ 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.GetRequiredSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
             SyntaxToken token = root.FindToken(context.Span.Start);
             if (!token.Span.IntersectsWith(context.Span))
             {
@@ -52,7 +53,7 @@ private static async Task<Document> AddMethodAsync(Document document, SyntaxNode
             var editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
             var generator = editor.Generator;
 
-            var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var model = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var typeIsSealed = ((INamedTypeSymbol)model.GetDeclaredSymbol(classDecl, cancellationToken)).IsSealed;
 
             INamedTypeSymbol? codeFixProviderSymbol = model.Compilation.GetOrCreateTypeByMetadataName(FixerWithFixAllAnalyzer.CodeFixProviderMetadataName);
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/InternalImplementationOnlyAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/InternalImplementationOnlyAnalyzer.cs
index 661adf7d49..55dea1bae4 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/InternalImplementationOnlyAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/InternalImplementationOnlyAnalyzer.cs
@@ -52,7 +52,7 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context)
                 // We are doing a string comparison of the name here because we don't care where the attribute comes from.
                 // CodeAnalysis.dll itself has this attribute and if the user assembly also had it, symbol equality will fail
                 // but we should still issue the error.
-                if (attributes.Any(a => a.AttributeClass.Name.Equals(InternalImplementationOnlyAttributeName, StringComparison.Ordinal)
+                if (attributes.Any(a => a.AttributeClass is { Name: InternalImplementationOnlyAttributeName }
                                         && a.AttributeClass.ToDisplayString().Equals(InternalImplementationOnlyAttributeFullName, StringComparison.Ordinal)) &&
                     !iface.ContainingAssembly.GivesAccessTo(namedTypeSymbol.ContainingAssembly))
                 {
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/CompareSymbolsCorrectlyAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/CompareSymbolsCorrectlyAnalyzer.cs
index 584d659d45..f0e3be553e 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/CompareSymbolsCorrectlyAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/CompareSymbolsCorrectlyAnalyzer.cs
@@ -271,7 +271,7 @@ private static bool IsSymbolType(IOperation? operation, INamedTypeSymbol? symbol
         private static bool IsSymbolType(ITypeSymbol typeSymbol, INamedTypeSymbol? symbolType)
             => typeSymbol != null
                 && (SymbolEqualityComparer.Default.Equals(typeSymbol, symbolType)
-                    || typeSymbol.AllInterfaces.Contains(symbolType));
+                    || typeSymbol.AllInterfaces.Any(SymbolEqualityComparer.Default.Equals, symbolType));
 
         private static bool IsSymbolClassType(IOperation operation)
         {
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/CompilerExtensionStrictApiAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/CompilerExtensionStrictApiAnalyzer.cs
index 9f407cee83..bd338c7dd8 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/CompilerExtensionStrictApiAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/CompilerExtensionStrictApiAnalyzer.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using Analyzer.Utilities;
 using Analyzer.Utilities.Extensions;
@@ -146,6 +147,12 @@ private static bool IsRegisteredExtension(INamedTypeSymbol extension, [NotNullWh
 
             foreach (var attribute in extension.GetAttributes())
             {
+                // Only examine extension registrations in source
+                Debug.Assert(attribute.ApplicationSyntaxReference is not null,
+                    $"Expected attributes returned by {nameof(ISymbol.GetAttributes)} (as opposed to {nameof(ITypeSymbolExtensions.GetApplicableAttributes)}) to have a non-null application.");
+                if (attribute.ApplicationSyntaxReference is null)
+                    continue;
+
                 if (!attribute.AttributeClass.Inherits(registrationAttributeType))
                     continue;
 
@@ -173,7 +180,7 @@ private static void CheckLanguage(TypedConstant argument, ref bool supportsCShar
         {
             if (argument is { Kind: TypedConstantKind.Primitive, Type.SpecialType: SpecialType.System_String })
             {
-                string supportedLanguage = (string)argument.Value;
+                var supportedLanguage = (string?)argument.Value;
                 if (supportedLanguage == LanguageNames.CSharp)
                 {
                     supportsCSharp = true;
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerAPIUsageAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerAPIUsageAnalyzer.cs
index 776d4ff94f..935985796f 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerAPIUsageAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerAPIUsageAnalyzer.cs
@@ -243,9 +243,9 @@ private ImmutableHashSet<INamedTypeSymbol> GetUsedNamedTypes(INamedTypeSymbol na
             return builder.ToImmutableAndFree();
         }
 
-        private static void AddUsedNamedTypeCore(ITypeSymbol typeOpt, PooledHashSet<INamedTypeSymbol> builder, ref bool hasAccessToTypeFromWorkspaceAssemblies)
+        private static void AddUsedNamedTypeCore(ITypeSymbol? type, PooledHashSet<INamedTypeSymbol> builder, ref bool hasAccessToTypeFromWorkspaceAssemblies)
         {
-            if (typeOpt is INamedTypeSymbol usedType &&
+            if (type is INamedTypeSymbol usedType &&
                 usedType.TypeKind != TypeKind.Error)
             {
                 builder.Add(usedType);
@@ -259,9 +259,9 @@ private static void AddUsedNamedTypeCore(ITypeSymbol typeOpt, PooledHashSet<INam
 
                 if (usedType.IsGenericType)
                 {
-                    foreach (var type in usedType.TypeArguments)
+                    foreach (var typeArgument in usedType.TypeArguments)
                     {
-                        AddUsedNamedTypeCore(type, builder, ref hasAccessToTypeFromWorkspaceAssemblies);
+                        AddUsedNamedTypeCore(typeArgument, builder, ref hasAccessToTypeFromWorkspaceAssemblies);
                     }
                 }
             }
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerAttributeAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerAttributeAnalyzer.cs
index ddf317fc0a..96121f3774 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerAttributeAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerAttributeAnalyzer.cs
@@ -147,7 +147,7 @@ private static void CheckLanguage(TypedConstant argument, ref bool supportsCShar
                 argument.Type != null &&
                 argument.Type.SpecialType == SpecialType.System_String)
             {
-                string supportedLanguage = (string)argument.Value;
+                var supportedLanguage = (string?)argument.Value;
                 if (supportedLanguage == LanguageNames.CSharp)
                 {
                     supportsCSharp = true;
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerCorrectnessAnalyzer.SyntaxNodeWithinAnalyzerTypeCompilationAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerCorrectnessAnalyzer.SyntaxNodeWithinAnalyzerTypeCompilationAnalyzer.cs
index e115c597a7..57daebf68d 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerCorrectnessAnalyzer.SyntaxNodeWithinAnalyzerTypeCompilationAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerCorrectnessAnalyzer.SyntaxNodeWithinAnalyzerTypeCompilationAnalyzer.cs
@@ -25,7 +25,7 @@ internal static IEnumerable<TClassDeclarationSyntax> GetClassDeclarationNodes(IN
                 {
                     if (syntax != null)
                     {
-                        TClassDeclarationSyntax classDecl = syntax.FirstAncestorOrSelf<TClassDeclarationSyntax>(ascendOutOfTrivia: false);
+                        TClassDeclarationSyntax? classDecl = syntax.FirstAncestorOrSelf<TClassDeclarationSyntax>(ascendOutOfTrivia: false);
                         if (classDecl != null)
                         {
                             yield return classDecl;
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerFieldsAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerFieldsAnalyzer.cs
index 0c9b42937c..e144835fab 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerFieldsAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticAnalyzerFieldsAnalyzer.cs
@@ -109,7 +109,7 @@ protected override void AnalyzeNode(SymbolAnalysisContext symbolContext, TFieldD
 
                 foreach (TTypeSyntax typeNode in typeNodes)
                 {
-                    ITypeSymbol type = semanticModel.GetTypeInfo(typeNode, symbolContext.CancellationToken).Type;
+                    ITypeSymbol? type = semanticModel.GetTypeInfo(typeNode, symbolContext.CancellationToken).Type;
                     if (type != null)
                     {
                         foreach (ITypeSymbol innerType in type.GetBaseTypesAndThis())
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer.cs
index 39ad993e6c..fe804449b0 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer.cs
@@ -692,7 +692,8 @@ DiagnosticIds.DefineDiagnosticMessageCorrectlyRuleId or
 
             filePath = null;
             fileSpan = null;
-            if (!diagnostic.Properties.TryGetValue(DefineDescriptorArgumentCorrectlyFixAdditionalDocumentLocationInfo, out var locationInfo))
+            if (!diagnostic.Properties.TryGetValue(DefineDescriptorArgumentCorrectlyFixAdditionalDocumentLocationInfo, out var locationInfo)
+                || locationInfo is null)
             {
                 return false;
             }
@@ -918,7 +919,7 @@ private static bool TryGetNonEmptyConstantStringValue(
                 if (fieldDeclaration.Language == LanguageNames.VisualBasic)
                 {
                     // For VB, the field initializer is on the parent node.
-                    fieldDeclaration = fieldDeclaration.Parent;
+                    fieldDeclaration = fieldDeclaration.Parent!;
                 }
 
                 foreach (var node in fieldDeclaration.DescendantNodes())
@@ -1279,7 +1280,7 @@ ConcurrentDictionary<string, ConcurrentBag<Location>> UpdateNamedTypeFactory(str
             }
         }
 
-        private static bool IsReservedDiagnosticId(string ruleId, string assemblyName)
+        private static bool IsReservedDiagnosticId(string ruleId, string? assemblyName)
         {
             if (ruleId.Length < 3)
             {
@@ -1300,7 +1301,19 @@ private static bool IsReservedDiagnosticId(string ruleId, string assemblyName)
                 return false;
             }
 
-            return !isCARule || !CADiagnosticIdAllowedAssemblies.Contains(assemblyName);
+            if (!isCARule)
+            {
+                // This is a reserved compiler diagnostic ID (CS or BC prefix)
+                return true;
+            }
+
+            if (assemblyName is null)
+            {
+                // This is a reserved code analysis ID (CA prefix) being reported from an unspecified assembly
+                return true;
+            }
+
+            return !CADiagnosticIdAllowedAssemblies.Contains(assemblyName);
         }
     }
 }
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs
index 5a6b37d64a..7eb1f49f51 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs
@@ -235,7 +235,7 @@ private static bool TryParseCategoryAndAllowedIdsInfoFile(
             invalidFileDiagnostics = null;
 
             var builder = ImmutableDictionary.CreateBuilder<string, ImmutableArray<(string? prefix, int start, int end)>>();
-            var lines = additionalText.GetText(cancellationToken).Lines;
+            var lines = additionalText.GetTextOrEmpty(cancellationToken).Lines;
             foreach (var line in lines)
             {
                 var contents = line.ToString();
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_ReleaseTracking.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_ReleaseTracking.cs
index 3f5dc6be53..3197cb311f 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_ReleaseTracking.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_ReleaseTracking.cs
@@ -176,8 +176,8 @@ private static bool TryGetReleaseTrackingData(
 
             var diagnostics = new List<Diagnostic>();
             using var reportedInvalidLines = PooledHashSet<TextLine>.GetInstance();
-            shippedData = ReadReleaseTrackingData(shippedText.Path, shippedText.GetText(cancellationToken), OnDuplicateEntryInRelease, OnInvalidEntry, isShippedFile: true);
-            unshippedData = ReadReleaseTrackingData(unshippedText.Path, unshippedText.GetText(cancellationToken), OnDuplicateEntryInRelease, OnInvalidEntry, isShippedFile: false);
+            shippedData = ReadReleaseTrackingData(shippedText.Path, shippedText.GetTextOrEmpty(cancellationToken), OnDuplicateEntryInRelease, OnInvalidEntry, isShippedFile: true);
+            unshippedData = ReadReleaseTrackingData(unshippedText.Path, unshippedText.GetTextOrEmpty(cancellationToken), OnDuplicateEntryInRelease, OnInvalidEntry, isShippedFile: false);
 
             invalidFileDiagnostics = diagnostics;
             return invalidFileDiagnostics.Count == 0;
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_ResourceStringsFormat.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_ResourceStringsFormat.cs
index f5548c26a5..8d67bae592 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_ResourceStringsFormat.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/DiagnosticDescriptorCreationAnalyzer_ResourceStringsFormat.cs
@@ -7,6 +7,7 @@
 using System.Linq;
 using System.Threading;
 using System.Xml.Linq;
+using Analyzer.Utilities.Extensions;
 using Analyzer.Utilities.PooledObjects;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
@@ -67,7 +68,7 @@ private static bool HasResxAdditionalFiles(AnalyzerOptions options)
                 const string valueTagPrefix = @"<value>";
                 const string valueTagSuffix = @"</value>";
                 var builder = ImmutableDictionary.CreateBuilder<string, (string value, Location location)>();
-                var sourceText = file.GetText(cancellationToken);
+                var sourceText = file.GetTextOrEmpty(cancellationToken);
                 var sourceTextStr = sourceText.ToString();
                 var parsedDocument = XDocument.Parse(sourceTextStr, LoadOptions.PreserveWhitespace);
                 foreach (var dataElement in parsedDocument.Descendants("data"))
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/AnalyzerReleaseTrackingFix.FixAllProvider.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/AnalyzerReleaseTrackingFix.FixAllProvider.cs
index d771d273ee..741b05acc9 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/AnalyzerReleaseTrackingFix.FixAllProvider.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/AnalyzerReleaseTrackingFix.FixAllProvider.cs
@@ -84,7 +84,7 @@ public FixAllAdditionalDocumentChangeAction(FixAllScope fixAllScope, Solution so
                 public override string Title { get; }
                 public override string EquivalenceKey { get; }
 
-                protected override async Task<Solution> GetChangedSolutionAsync(CancellationToken cancellationToken)
+                protected override async Task<Solution?> GetChangedSolutionAsync(CancellationToken cancellationToken)
                 {
                     var updatedUnshippedText = new List<(DocumentId, SourceText)>();
 
@@ -168,7 +168,7 @@ public FixAllAddAdditionalDocumentsAction(ImmutableArray<ProjectId> projectIds,
                 public override string Title => CodeAnalysisDiagnosticsResources.EnableAnalyzerReleaseTrackingRuleTitle;
                 public override string EquivalenceKey => CodeAnalysisDiagnosticsResources.EnableAnalyzerReleaseTrackingRuleTitle;
 
-                protected override async Task<Solution> GetChangedSolutionAsync(CancellationToken cancellationToken)
+                protected override async Task<Solution?> GetChangedSolutionAsync(CancellationToken cancellationToken)
                 {
                     var newSolution = _solution;
                     foreach (var projectId in _projectIds)
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/AnalyzerReleaseTrackingFix.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/AnalyzerReleaseTrackingFix.cs
index 8c16309261..c0bc5bbfc7 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/AnalyzerReleaseTrackingFix.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/AnalyzerReleaseTrackingFix.cs
@@ -120,7 +120,7 @@ private static bool IsAddEntryToUnshippedFileDiagnostic(Diagnostic diagnostic, [
         {
             if (diagnostic.Properties != null &&
                 diagnostic.Properties.TryGetValue(DiagnosticDescriptorCreationAnalyzer.EntryToAddPropertyName, out entryToAdd) &&
-                !string.IsNullOrEmpty(entryToAdd))
+                !RoslynString.IsNullOrEmpty(entryToAdd))
             {
                 return true;
             }
@@ -136,7 +136,7 @@ private static bool IsUpdateEntryToUnshippedFileDiagnostic(
         {
             if (diagnostic.Properties != null &&
                 diagnostic.Properties.TryGetValue(DiagnosticDescriptorCreationAnalyzer.EntryToUpdatePropertyName, out entryToUpdate) &&
-                !string.IsNullOrEmpty(entryToUpdate) &&
+                !RoslynString.IsNullOrEmpty(entryToUpdate) &&
                 TryGetRuleIdForEntry(entryToUpdate, out ruleId))
             {
                 return true;
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/ApplyDiagnosticAnalyzerAttributeFix.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/ApplyDiagnosticAnalyzerAttributeFix.cs
index 724aa9d275..453d8cab56 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/ApplyDiagnosticAnalyzerAttributeFix.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/ApplyDiagnosticAnalyzerAttributeFix.cs
@@ -16,7 +16,7 @@ public abstract class ApplyDiagnosticAnalyzerAttributeFix : CodeFixProvider
 
         public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
-            SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            SyntaxNode root = await context.Document.GetRequiredSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
             SyntaxToken token = root.FindToken(context.Span.Start);
             if (!token.Span.IntersectsWith(context.Span))
             {
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/CompareSymbolsCorrectlyFix.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/CompareSymbolsCorrectlyFix.cs
index c795381cf5..c6e3c27919 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/CompareSymbolsCorrectlyFix.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/CompareSymbolsCorrectlyFix.cs
@@ -57,8 +57,8 @@ public sealed override Task RegisterCodeFixesAsync(CodeFixContext context)
 
         private async Task<Document> ConvertToEqualsAsync(Document document, TextSpan sourceSpan, CancellationToken cancellationToken)
         {
-            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var expression = root.FindNode(sourceSpan, getInnermostNodeForTie: true);
             var rawOperation = semanticModel.GetOperation(expression, cancellationToken);
 
@@ -72,8 +72,8 @@ private async Task<Document> ConvertToEqualsAsync(Document document, TextSpan so
 
         private async Task<Document> CallOverloadWithEqualityComparerAsync(Document document, TextSpan sourceSpan, CancellationToken cancellationToken)
         {
-            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var expression = root.FindNode(sourceSpan, getInnermostNodeForTie: true);
             var rawOperation = semanticModel.GetOperation(expression, cancellationToken);
 
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/ConfigureGeneratedCodeAnalysisFix.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/ConfigureGeneratedCodeAnalysisFix.cs
index 40d002f55e..5f0e355483 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/ConfigureGeneratedCodeAnalysisFix.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/ConfigureGeneratedCodeAnalysisFix.cs
@@ -39,14 +39,14 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
 
         private async Task<Document> ConfigureGeneratedCodeAnalysisAsync(Document document, TextSpan sourceSpan, CancellationToken cancellationToken)
         {
-            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var generatedCodeAnalysisFlags = semanticModel.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.MicrosoftCodeAnalysisDiagnosticsGeneratedCodeAnalysisFlags);
             if (generatedCodeAnalysisFlags is null)
             {
                 return document;
             }
 
-            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var analysisContextParameter = root.FindNode(sourceSpan, getInnermostNodeForTie: true);
 
             var generator = SyntaxGenerator.GetGenerator(document);
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/DefineDiagnosticDescriptorArgumentsCorrectlyFix.CustomFixAllProvider.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/DefineDiagnosticDescriptorArgumentsCorrectlyFix.CustomFixAllProvider.cs
index 496449a499..430a0ec2d5 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/DefineDiagnosticDescriptorArgumentsCorrectlyFix.CustomFixAllProvider.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/DefineDiagnosticDescriptorArgumentsCorrectlyFix.CustomFixAllProvider.cs
@@ -91,7 +91,7 @@ public FixAllAdditionalDocumentChangeAction(FixAllScope fixAllScope, Solution so
                 public override string Title { get; }
                 public override string EquivalenceKey { get; }
 
-                protected override async Task<Solution> GetChangedSolutionAsync(CancellationToken cancellationToken)
+                protected override async Task<Solution?> GetChangedSolutionAsync(CancellationToken cancellationToken)
                 {
                     // Group fixes by additional documents.
                     var fixInfoMap = new Dictionary<TextDocument, List<FixInfo>>();
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/DefineDiagnosticDescriptorArgumentsCorrectlyFix.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/DefineDiagnosticDescriptorArgumentsCorrectlyFix.cs
index 895351f5b4..7f977c6be9 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/DefineDiagnosticDescriptorArgumentsCorrectlyFix.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/DefineDiagnosticDescriptorArgumentsCorrectlyFix.cs
@@ -31,7 +31,7 @@ public sealed partial class DefineDiagnosticDescriptorArgumentsCorrectlyFix : Co
 
         public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
-            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            var root = await context.Document.GetRequiredSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
             var node = root.FindNode(context.Span, getInnermostNodeForTie: true);
             if (node is null)
             {
@@ -39,7 +39,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             }
 
             var additionalDocuments = context.Document.Project.AdditionalDocuments.ToImmutableArray();
-            var semanticModel = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
+            var semanticModel = await context.Document.GetRequiredSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
             foreach (var diagnostic in context.Diagnostics)
             {
                 if (!TryGetFixInfo(diagnostic, root, semanticModel, additionalDocuments,
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/EnableConcurrentExecutionFix.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/EnableConcurrentExecutionFix.cs
index 2f17a53114..4b18d47f2b 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/EnableConcurrentExecutionFix.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/Fixers/EnableConcurrentExecutionFix.cs
@@ -38,7 +38,7 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
 
         private async Task<Document> EnableConcurrentExecutionAsync(Document document, TextSpan sourceSpan, CancellationToken cancellationToken)
         {
-            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var analysisContextParameter = root.FindNode(sourceSpan, getInnermostNodeForTie: true);
 
             var generator = SyntaxGenerator.GetGenerator(document);
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/RegisterActionAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/RegisterActionAnalyzer.cs
index cd8844655a..c996f84f2f 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/RegisterActionAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/RegisterActionAnalyzer.cs
@@ -308,7 +308,7 @@ private void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
                 var invocation = (TInvocationExpressionSyntax)context.Node;
                 SemanticModel semanticModel = context.SemanticModel;
 
-                ISymbol symbol = semanticModel.GetSymbolInfo(invocation, context.CancellationToken).Symbol;
+                ISymbol? symbol = semanticModel.GetSymbolInfo(invocation, context.CancellationToken).Symbol;
                 if (symbol == null || symbol.Kind != SymbolKind.Method || !symbol.Name.StartsWith("Register", StringComparison.Ordinal))
                 {
                     return;
@@ -331,7 +331,7 @@ private void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
                         int argumentCount = arguments.Count();
                         if (argumentCount >= 1)
                         {
-                            ITypeSymbol type = semanticModel.GetTypeInfo(arguments.First(), context.CancellationToken).ConvertedType;
+                            ITypeSymbol? type = semanticModel.GetTypeInfo(arguments.First(), context.CancellationToken).ConvertedType;
                             if (type == null || type.Name.Equals(nameof(Action), StringComparison.Ordinal))
                             {
                                 if (argumentCount == 1)
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/ReportDiagnosticAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/ReportDiagnosticAnalyzer.cs
index 4c5d238417..12d18b6153 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/ReportDiagnosticAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/ReportDiagnosticAnalyzer.cs
@@ -178,7 +178,7 @@ private ImmutableArray<IFieldSymbol> GetReferencedDescriptorFields(SyntaxNode sy
                 ImmutableArray<IFieldSymbol>.Builder builder = ImmutableArray.CreateBuilder<IFieldSymbol>();
                 foreach (TIdentifierNameSyntax identifier in syntax.DescendantNodes().OfType<TIdentifierNameSyntax>())
                 {
-                    ISymbol symbol = semanticModel.GetSymbolInfo(identifier, cancellationToken).Symbol;
+                    ISymbol? symbol = semanticModel.GetSymbolInfo(identifier, cancellationToken).Symbol;
                     if (symbol != null && symbol.Kind == SymbolKind.Field)
                     {
                         var field = (IFieldSymbol)symbol;
@@ -194,7 +194,7 @@ private ImmutableArray<IFieldSymbol> GetReferencedDescriptorFields(SyntaxNode sy
 
             protected override void AnalyzeNode(SymbolAnalysisContext symbolContext, TInvocationExpressionSyntax syntaxNode, SemanticModel semanticModel)
             {
-                ISymbol symbol = semanticModel.GetSymbolInfo(syntaxNode, symbolContext.CancellationToken).Symbol;
+                ISymbol? symbol = semanticModel.GetSymbolInfo(syntaxNode, symbolContext.CancellationToken).Symbol;
                 if (symbol == null ||
                     symbol.Kind != SymbolKind.Method ||
                     !symbol.Name.Equals(DiagnosticWellKnownNames.ReportDiagnosticName, StringComparison.OrdinalIgnoreCase) ||
@@ -207,10 +207,10 @@ protected override void AnalyzeNode(SymbolAnalysisContext symbolContext, TInvoca
                 if (arguments?.HasExactly(1) == true)
                 {
                     SyntaxNode argument = arguments.First();
-                    ITypeSymbol type = semanticModel.GetTypeInfo(argument, symbolContext.CancellationToken).ConvertedType;
+                    ITypeSymbol? type = semanticModel.GetTypeInfo(argument, symbolContext.CancellationToken).ConvertedType;
                     if (type != null && type.Equals(_diagnosticType))
                     {
-                        ISymbol argSymbol = semanticModel.GetSymbolInfo(argument, symbolContext.CancellationToken).Symbol;
+                        ISymbol? argSymbol = semanticModel.GetSymbolInfo(argument, symbolContext.CancellationToken).Symbol;
                         if (argSymbol != null)
                         {
                             SyntaxNode? diagnosticInitializer = null;
diff --git a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/SymbolIsBannedInAnalyzersAnalyzer.cs b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/SymbolIsBannedInAnalyzersAnalyzer.cs
index db29cd9666..086e2f0359 100644
--- a/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/SymbolIsBannedInAnalyzersAnalyzer.cs
+++ b/src/Microsoft.CodeAnalysis.Analyzers/Core/MetaAnalyzers/SymbolIsBannedInAnalyzersAnalyzer.cs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -78,6 +78,9 @@ void analyzePossibleAnalyzerOrGenerator(SymbolAnalysisContext symbolAnalysisCont
 
                     bool shouldReportNotSpecifiedEnforceAnalyzerBannedApisSetting(AttributeData attributeData)
                     {
+                        if (attributeData.AttributeClass is null)
+                            return false;
+
                         return attributeData.AttributeClass.Equals(diagnosticAnalyzerAttributeType, SymbolEqualityComparer.Default)
                             || attributeData.AttributeClass.Equals(generatorAttributeType, SymbolEqualityComparer.Default);
                     }
diff --git a/src/PublicApiAnalyzers/Directory.Build.props b/src/PublicApiAnalyzers/Directory.Build.props
index 49176dc3f9..cc1fc0eb36 100644
--- a/src/PublicApiAnalyzers/Directory.Build.props
+++ b/src/PublicApiAnalyzers/Directory.Build.props
@@ -3,5 +3,6 @@
   <PropertyGroup>
     <ExcludeFromSourceBuild>true</ExcludeFromSourceBuild>
     <NoWarn>$(NoWarn);NU1701</NoWarn>
+    <DefineConstants>$(DefineConstants),MICROSOFT_CODEANALYSIS_PUBLIC_API_ANALYZERS</DefineConstants>
   </PropertyGroup>
 </Project>
diff --git a/src/Utilities/Compiler/Analyzer.Utilities.projitems b/src/Utilities/Compiler/Analyzer.Utilities.projitems
index 4bd5bb8663..209b48217e 100644
--- a/src/Utilities/Compiler/Analyzer.Utilities.projitems
+++ b/src/Utilities/Compiler/Analyzer.Utilities.projitems
@@ -14,7 +14,7 @@
   <PropertyGroup Condition="'$(MicrosoftCodeAnalysisVersion)' == '' OR $([MSBuild]::VersionGreaterThanOrEquals($(MicrosoftCodeAnalysisVersion),'3.7'))">
     <DefineConstants>$(DefineConstants),CODEANALYSIS_V3_7_OR_BETTER</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition="$([MSBuild]::VersionNotEquals($(MicrosoftCodeAnalysisVersion),'1.2.1'))">
+  <PropertyGroup Condition="'$(MicrosoftCodeAnalysisVersion)' == '' OR $([MSBuild]::VersionNotEquals($(MicrosoftCodeAnalysisVersion),'1.2.1'))">
     <DefineConstants>$(DefineConstants);HAS_IOPERATION</DefineConstants>
     <HasIOperation>true</HasIOperation>
     <!-- Explicitly enable nullable for all projects that link Analyzer.Utilities.
@@ -47,6 +47,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Debug.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)DiagnosticDescriptorHelper.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)DoNotCatchGeneralUnlessRethrown.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Extensions\AdditionalTextExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ArrayBuilderExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\CompilationExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\ISetExtensions.cs" />
diff --git a/src/Utilities/Compiler/Extensions/AdditionalTextExtensions.cs b/src/Utilities/Compiler/Extensions/AdditionalTextExtensions.cs
new file mode 100644
index 0000000000..e92da8036c
--- /dev/null
+++ b/src/Utilities/Compiler/Extensions/AdditionalTextExtensions.cs
@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+using System.Text;
+using System.Threading;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Analyzer.Utilities.Extensions
+{
+    internal static class AdditionalTextExtensions
+    {
+        private static readonly Encoding s_utf8bom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);
+        private static readonly SourceText s_emptySourceText = SourceText.From("", s_utf8bom, SourceHashAlgorithm.Sha256);
+
+        public static SourceText GetTextOrEmpty(this AdditionalText text, CancellationToken cancellationToken)
+            => text.GetText(cancellationToken) ?? s_emptySourceText;
+    }
+}
diff --git a/src/Utilities/FlowAnalysis/FlowAnalysis/Analysis/TaintedDataAnalysis/TaintedDataAnalysis.TaintedDataOperationVisitor.cs b/src/Utilities/FlowAnalysis/FlowAnalysis/Analysis/TaintedDataAnalysis/TaintedDataAnalysis.TaintedDataOperationVisitor.cs
index e8958ac91c..beac4184c6 100644
--- a/src/Utilities/FlowAnalysis/FlowAnalysis/Analysis/TaintedDataAnalysis/TaintedDataAnalysis.TaintedDataOperationVisitor.cs
+++ b/src/Utilities/FlowAnalysis/FlowAnalysis/Analysis/TaintedDataAnalysis/TaintedDataAnalysis.TaintedDataOperationVisitor.cs
@@ -459,7 +459,7 @@ protected override TaintedDataAbstractValue ComputeAnalysisValueForEscapedRefOrO
                 // Note this method is only called when interprocedural DFA is *NOT* performed.
                 if (operation.Parent is IInvocationOperation invocationOperation)
                 {
-                    Debug.Assert(!this.TryGetInterproceduralAnalysisResult(invocationOperation, out TaintedDataAnalysisResult _));
+                    Debug.Assert(!this.TryGetInterproceduralAnalysisResult(invocationOperation, out var _));
 
                     // Treat ref or out arguments as the same as the invocation operation.
                     TaintedDataAbstractValue returnValueAbstractValue = this.GetCachedAbstractValue(invocationOperation);
diff --git a/src/Utilities/FlowAnalysis/FlowAnalysis/Framework/DataFlow/AnalysisEntityFactory.cs b/src/Utilities/FlowAnalysis/FlowAnalysis/Framework/DataFlow/AnalysisEntityFactory.cs
index ee77af7b3d..f4886efb89 100644
--- a/src/Utilities/FlowAnalysis/FlowAnalysis/Framework/DataFlow/AnalysisEntityFactory.cs
+++ b/src/Utilities/FlowAnalysis/FlowAnalysis/Framework/DataFlow/AnalysisEntityFactory.cs
@@ -369,7 +369,7 @@ public bool TryCreateForTupleElements(ITupleOperation tupleOperation, [NotNullWh
                 using var builder = ArrayBuilder<AnalysisEntity>.GetInstance(tupleType.TupleElements.Length);
                 foreach (var field in tupleType.TupleElements)
                 {
-                    var tupleFieldName = field.CorrespondingTupleField.Name;
+                    var tupleFieldName = field.CorrespondingTupleField!.Name;
                     var mappedValueTupleField = underlyingValueTupleType.GetMembers(tupleFieldName).OfType<IFieldSymbol>().FirstOrDefault();
                     if (mappedValueTupleField == null)
                     {
diff --git a/src/Utilities/Workspaces/DocumentExtensions.cs b/src/Utilities/Workspaces/DocumentExtensions.cs
new file mode 100644
index 0000000000..b56f38b733
--- /dev/null
+++ b/src/Utilities/Workspaces/DocumentExtensions.cs
@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+#if !MICROSOFT_CODEANALYSIS_PUBLIC_API_ANALYZERS
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+
+namespace Analyzer.Utilities
+{
+    internal static class DocumentExtensions
+    {
+        public static async ValueTask<SemanticModel> GetRequiredSemanticModelAsync(this Document document, CancellationToken cancellationToken)
+        {
+            if (document.TryGetSemanticModel(out var semanticModel))
+                return semanticModel;
+
+            semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            return semanticModel ?? throw new InvalidOperationException("SyntaxTree is required to accomplish the task but is not supported by document");
+        }
+
+        public static async ValueTask<SyntaxTree> GetRequiredSyntaxTreeAsync(this Document document, CancellationToken cancellationToken)
+        {
+            if (document.TryGetSyntaxTree(out var syntaxTree))
+                return syntaxTree;
+
+            syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+            return syntaxTree ?? throw new InvalidOperationException("SyntaxTree is required to accomplish the task but is not supported by document");
+        }
+
+        public static async ValueTask<SyntaxNode> GetRequiredSyntaxRootAsync(this Document document, CancellationToken cancellationToken)
+        {
+            if (document.TryGetSyntaxRoot(out var root))
+                return root;
+
+            root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            return root ?? throw new InvalidOperationException("SyntaxTree is required to accomplish the task but is not supported by document");
+        }
+    }
+}
+
+#endif
diff --git a/src/Utilities/Workspaces/Workspaces.Utilities.projitems b/src/Utilities/Workspaces/Workspaces.Utilities.projitems
index e44de29c5e..13c497f197 100644
--- a/src/Utilities/Workspaces/Workspaces.Utilities.projitems
+++ b/src/Utilities/Workspaces/Workspaces.Utilities.projitems
@@ -12,6 +12,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)DocumentBasedFixAllProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)FixAllContextHelper.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SyntaxGeneratorExtensions.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)DocumentExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SyntaxNodeExtensions.cs" />
   </ItemGroup>
   <ItemGroup>