Add CS8602 suppressor

eng/Versions.props

@@ -30,5 +30,6 @@
   </PropertyGroup>
   <PropertyGroup Label="Other dependencies">
     <MicrosoftCodeAnalysisVersion>3.7.0</MicrosoftCodeAnalysisVersion>
+    <MicrosoftCodeAnalysisTestingVersion>1.0.1-beta1.20623.3</MicrosoftCodeAnalysisTestingVersion>
   </PropertyGroup>
 </Project>

src/EFCore.Analyzers/NullableDiagnosticSuppressor.cs

@@ -0,0 +1,64 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using Microsoft.EntityFrameworkCore.Utilities;
+
+namespace Microsoft.EntityFrameworkCore
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public sealed class NullableDiagnosticSuppressor : DiagnosticSuppressor
+    {
+        private static readonly ImmutableArray<OperationKind> _invocationKind = ImmutableArray.Create(OperationKind.Invocation);
+
+        private static readonly SuppressionDescriptor _descriptor = new(
+            id: "EFS0001",
+            suppressedDiagnosticId: "CS8602",
+            justification: "The dereference is safe inside this expression tree.");
+
+        public override ImmutableArray<SuppressionDescriptor> SupportedSuppressions => ImmutableArray.Create(_descriptor);
+
+        public override void ReportSuppressions(SuppressionAnalysisContext context)
+        {
+            var linqExpressionType = context.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+            if (linqExpressionType is null)
+            {
+                return;
+            }
+
+            var efQueryableExtensionsType = context.Compilation.GetTypeByMetadataName("Microsoft.EntityFrameworkCore.EntityFrameworkQueryableExtensions");
+            if (efQueryableExtensionsType is null)
+            {
+                return;
+            }
+
+            foreach (var diagnostic in context.ReportedDiagnostics)
+            {
+                if (diagnostic.Location.SourceTree is not SyntaxTree tree)
+                {
+                    continue;
+                }
+
+                var root = tree.GetRoot(context.CancellationToken);
+                var node = root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
+                var model = context.GetSemanticModel(tree);
+                var operation = model.GetOperation(node, context.CancellationToken);
+                if (operation is null)
+                {
+                    continue;
+                }
+
+                if (operation.IsWithinExpressionTree(linqExpressionType, out var anonymousOrLocalFunctionOperation) &&
+                    anonymousOrLocalFunctionOperation.GetAncestor(_invocationKind) is IInvocationOperation invocation &&
+                    SymbolEqualityComparer.Default.Equals(invocation.TargetMethod.ContainingType, efQueryableExtensionsType))
+                {
+                    context.ReportSuppression(Suppression.Create(_descriptor, diagnostic));
+                }
+
+            }
+        }
+    }
+}

src/EFCore.Analyzers/Utilities/IOperationExtensions.cs

@@ -0,0 +1,65 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.CodeAnalysis;
+
+namespace Microsoft.EntityFrameworkCore.Utilities
+{
+    internal static class IOperationExtensions
+    {
+        private static readonly ImmutableArray<OperationKind> lambdaAndLocalFunctionKinds =
+            ImmutableArray.Create(OperationKind.AnonymousFunction, OperationKind.LocalFunction);
+
+        public static bool IsWithinExpressionTree(this IOperation operation, INamedTypeSymbol linqExpressionTreeType, [NotNullWhen(true)] out IOperation? anonymousOrLocalFunctionOperation)
+        {
+            if (operation.GetAncestor(lambdaAndLocalFunctionKinds) is IOperation op &&
+                op.Parent?.Type?.OriginalDefinition is { } lambdaType &&
+                linqExpressionTreeType.Equals(lambdaType, SymbolEqualityComparer.Default))
+            {
+                anonymousOrLocalFunctionOperation = op;
+                return true;
+            }
+
+            anonymousOrLocalFunctionOperation = default;
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the first ancestor of this operation with:
+        ///  1. Any OperationKind from the specified <paramref name="ancestorKinds"/>.
+        ///  2. If <paramref name="predicate"/> is non-null, it succeeds for the ancestor.
+        /// Returns null if there is no such ancestor.
+        /// </summary>
+        public static IOperation? GetAncestor(this IOperation root, ImmutableArray<OperationKind> ancestorKinds, Func<IOperation, bool>? predicate = null)
+        {
+            if (root == null)
+            {
+                throw new ArgumentNullException(nameof(root));
+            }
+
+            var ancestor = root;
+            do
+            {
+                ancestor = ancestor.Parent;
+            } while (ancestor != null && !ancestorKinds.Contains(ancestor.Kind));
+
+            if (ancestor != null)
+            {
+                if (predicate != null && !predicate(ancestor))
+                {
+                    return GetAncestor(ancestor, ancestorKinds, predicate);
+                }
+                return ancestor;
+            }
+            else
+            {
+                return default;
+            }
+        }
+
+
+    }
+}

src/EFCore.Analyzers/Utilities/NotNullWhenAttribute.cs

@@ -0,0 +1,20 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.</summary>
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+    internal sealed class NotNullWhenAttribute : Attribute
+    {
+        /// <summary>Initializes the attribute with the specified return value condition.</summary>
+        /// <param name="returnValue">
+        /// The return value condition. If the method returns this value, the associated parameter will not be null.
+        /// </param>
+        public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;
+
+        /// <summary>Gets the return value condition.</summary>
+        public bool ReturnValue { get; }
+    }
+
+}

test/EFCore.Analyzers.Tests/EFCore.Analyzers.Tests.csproj

@@ -5,6 +5,7 @@
     <AssemblyName>Microsoft.EntityFrameworkCore.Analyzers.Tests</AssemblyName>
     <RootNamespace>Microsoft.EntityFrameworkCore</RootNamespace>
     <PreserveCompilationContext>true</PreserveCompilationContext>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
  <ItemGroup>
@@ -13,7 +14,8 @@
     <ProjectReference Include="..\EFCore.Tests\EFCore.Tests.csproj" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="$(MicrosoftCodeAnalysisVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic" Version="$(MicrosoftCodeAnalysisVersion)" />
-    <PackageReference Include="Microsoft.Extensions.DependencyModel" Version="$(MicrosoftExtensionsDependencyModelVersion)" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.XUnit" Version="$(MicrosoftCodeAnalysisTestingVersion)" />
+   <PackageReference Include="Microsoft.Extensions.DependencyModel" Version="$(MicrosoftExtensionsDependencyModelVersion)" />
   </ItemGroup>
 
   <ItemGroup>

test/EFCore.Analyzers.Tests/NullableDiagnosticSuppressorTest.cs

@@ -0,0 +1,85 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Testing;
+using Xunit;
+
+using VerifyWithSuppressor = Microsoft.EntityFrameworkCore.TestUtilities.Verifiers.CSharpCodeFixVerifier<
+    Microsoft.EntityFrameworkCore.NullableDiagnosticSuppressor,
+    Microsoft.CodeAnalysis.Testing.EmptyCodeFixProvider>;
+
+using VerifyWithoutSuppressor = Microsoft.EntityFrameworkCore.TestUtilities.Verifiers.CSharpCodeFixVerifier<
+    Microsoft.CodeAnalysis.Testing.EmptyDiagnosticAnalyzer,
+    Microsoft.CodeAnalysis.Testing.EmptyCodeFixProvider>;
+
+namespace Microsoft.EntityFrameworkCore
+{
+    public class NullableDiagnosticSuppressorTest
+    {
+        /// <summary>
+        /// Assert that given code have warnings specified by markup that are suppressed by <see cref="NullableDiagnosticSuppressor"/>
+        /// </summary>
+        private static async Task AssertWarningIsSuppressedAsync(string code)
+        {
+            await VerifyWithoutSuppressor.VerifyAnalyzerAsync(code);
+
+            await new VerifyWithSuppressor.Test()
+            {
+                TestState = { Sources = { code }, MarkupHandling = MarkupMode.Ignore }
+            }.RunAsync();
+        }
+
+        /// <summary>
+        /// Assert that given code have warnings specified by markup that are not suppressed by <see cref="NullableDiagnosticSuppressor"/>
+        /// </summary>
+        private static async Task AssertWarningIsNotSuppressedAsync(string code)
+        {
+            await VerifyWithSuppressor.VerifyAnalyzerAsync(code);
+            await VerifyWithoutSuppressor.VerifyAnalyzerAsync(code);
+        }
+
+        [Fact]
+        public async Task TestCompilerWarningAsync()
+        {
+            var code = @"
+#nullable enable
+
+class C
+{
+    public void M(C? c)
+    {
+        _ = {|CS8602:c|}.ToString();
+    }
+}";
+            await AssertWarningIsNotSuppressedAsync(code);
+        }
+
+        [Fact]
+        public async Task TestEFCoreIncludeIsSuppressed()
+        {
+            var code = @"
+#nullable enable
+
+using System.Linq;
+using Microsoft.EntityFrameworkCore;
+
+class SomeModel
+{
+    public NavigationModel? Navigation { get; set; }
+}
+
+class NavigationModel
+{
+    public string DeeperNavigation { get; set; } = null!;
+}
+
+static class C
+{
+    public static void M(IQueryable<SomeModel> q)
+    {
+        _ = q.Include(m => m.Navigation).ThenInclude(n => {|CS8602:n|}.DeeperNavigation);
+    }
+}
+";
+            await AssertWarningIsSuppressedAsync(code);
+        }
+    }
+}

test/EFCore.Analyzers.Tests/TestUtilities/DiagnosticAnalyzerTestBase.cs

@@ -52,7 +52,7 @@ protected async Task AssertNoDiagnostics(string source, params string[] extraUsi
         protected async Task<Diagnostic[]> GetDiagnosticsFullSourceAsync(string source)
         {
             var compilation = await CreateProject(source).GetCompilationAsync();
-            var errors = compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error);
+            var errors = compilation!.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error);
 
             Assert.Empty(errors);
 
@@ -92,7 +92,7 @@ var metadataReferences
                 .AddMetadataReferences(projectId, metadataReferences)
                 .AddDocument(documentId, fileName, SourceText.From(source));
 
-            return solution.GetProject(projectId)
+            return solution.GetProject(projectId)!
                 .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
         }
     }

test/EFCore.Analyzers.Tests/TestUtilities/Verifiers/AdditionalMetadataReferences.cs

@@ -0,0 +1,24 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace Microsoft.EntityFrameworkCore.TestUtilities.Verifiers
+{
+    public static class AdditionalMetadataReferences
+    {
+        public static ReferenceAssemblies Default { get; } = CreateDefaultReferenceAssemblies();
+
+        private static ReferenceAssemblies CreateDefaultReferenceAssemblies()
+        {
+            var referenceAssemblies = ReferenceAssemblies.Default;
+
+            referenceAssemblies = referenceAssemblies.AddPackages(ImmutableArray.Create(
+                new PackageIdentity("Microsoft.EntityFrameworkCore", "5.0.3")
+                ));
+
+            return referenceAssemblies;
+        }
+    }
+
+}

test/EFCore.Analyzers.Tests/TestUtilities/Verifiers/CSharpCodeFixVerifier`2+Test.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Immutable;
+using System.Net;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.EntityFrameworkCore.TestUtilities.Verifiers
+{
+    public static partial class CSharpCodeFixVerifier<TAnalyzer, TCodeFix>
+        where TAnalyzer : DiagnosticAnalyzer, new()
+        where TCodeFix : CodeFixProvider, new()
+    {
+        public class Test : CSharpCodeFixTest<TAnalyzer, TCodeFix, XUnitVerifier>
+        {
+            static Test()
+            {
+                // If we have outdated defaults from the host unit test application targeting an older .NET Framework, use more
+                // reasonable TLS protocol version for outgoing connections.
+#pragma warning disable CA5364 // Do Not Use Deprecated Security Protocols
+#pragma warning disable CS0618 // Type or member is obsolete
+                if (ServicePointManager.SecurityProtocol == (SecurityProtocolType.Ssl3 | SecurityProtocolType.Tls))
+#pragma warning restore CS0618 // Type or member is obsolete
+#pragma warning restore CA5364 // Do Not Use Deprecated Security Protocols
+                {
+                    ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
+                }
+            }
+
+            public Test()
+            {
+                ReferenceAssemblies = AdditionalMetadataReferences.Default;
+
+                SolutionTransforms.Add((solution, projectId) =>
+                {
+                    var project = solution.GetProject(projectId)!;
+                    var parseOptions = (CSharpParseOptions)project.ParseOptions!;
+                    solution = solution.WithProjectParseOptions(projectId, parseOptions.WithLanguageVersion(LanguageVersion));
+
+                    var compilationOptions = project.CompilationOptions!;
+
+                    solution = solution.WithProjectCompilationOptions(projectId, compilationOptions);
+
+                    if (AnalyzerConfigDocument is not null)
+                    {
+                        solution = solution.AddAnalyzerConfigDocument(
+                            DocumentId.CreateNewId(projectId, debugName: ".editorconfig"),
+                            ".editorconfig",
+                            SourceText.From($"is_global = true" + Environment.NewLine + AnalyzerConfigDocument),
+                            filePath: @"z:\.editorconfig");
+                    }
+
+                    return solution;
+                });
+            }
+
+            protected override bool IsCompilerDiagnosticIncluded(Diagnostic diagnostic, CompilerDiagnostics compilerDiagnostics)
+            {
+                return !diagnostic.IsSuppressed;
+            }
+
+            public LanguageVersion LanguageVersion { get; set; } = LanguageVersion.CSharp9;
+
+            public string? AnalyzerConfigDocument { get; set; }
+        }
+    }
+
+}