Add EF1004 analyzer for ToAsyncEnumerable on IQueryable (#38218)

Fixes #37670

Author: m-x-shokhzod

src/EFCore.Analyzers/AnalyzerReleases.Unshipped.md

@@ -0,0 +1,4 @@
+### New Rules
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+EF1004  | Usage    | Warning  | ToAsyncEnumerableOnQueryableDiagnosticAnalyzer

src/EFCore.Analyzers/Properties/AnalyzerStrings.Designer.cs

@@ -42,4 +42,13 @@
   <data name="StringConcatenationUsageInRawQueriesMessageFormat" xml:space="preserve">
     <value>Method '{0}' inserts concatenated strings directly into the SQL, without any protection against SQL injection. Consider using '{1}' instead, which protects against SQL injection, or make sure that the value is sanitized and suppress the warning.</value>
   </data>
+  <data name="ToAsyncEnumerableOnQueryableTitle" xml:space="preserve">
+    <value>Avoid using 'ToAsyncEnumerable' on an 'IQueryable'.</value>
+  </data>
+  <data name="ToAsyncEnumerableOnQueryableMessageFormat" xml:space="preserve">
+    <value>Calling 'ToAsyncEnumerable' on an 'IQueryable' iterates the source synchronously. Use 'AsAsyncEnumerable' instead to iterate the database query asynchronously, or suppress this warning if the 'IQueryable' is not an EF Core query.</value>
+  </data>
+  <data name="ToAsyncEnumerableOnQueryableCodeActionTitle" xml:space="preserve">
+    <value>Use 'AsAsyncEnumerable' to iterate the query asynchronously</value>
+  </data>
 </root>

src/EFCore.Analyzers/Properties/AnalyzerStrings.resx

@@ -0,0 +1,69 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Microsoft.EntityFrameworkCore;
+
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(ToAsyncEnumerableOnQueryableCodeFixProvider)), Shared]
+public sealed class ToAsyncEnumerableOnQueryableCodeFixProvider : CodeFixProvider
+{
+    public override ImmutableArray<string> FixableDiagnosticIds
+        => [EFDiagnostics.ToAsyncEnumerableOnQueryable];
+
+    public override FixAllProvider GetFixAllProvider()
+        => WellKnownFixAllProviders.BatchFixer;
+
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        var document = context.Document;
+        var cancellationToken = context.CancellationToken;
+
+        // The analyzer reports a single diagnostic per location.
+        var diagnostic = context.Diagnostics.First();
+
+        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        if (root is null)
+        {
+            return;
+        }
+
+        if (root.FindNode(diagnostic.Location.SourceSpan) is not SimpleNameSyntax simpleName)
+        {
+            Debug.Fail("Analyzer reported diagnostic not on a SimpleNameSyntax. This should never happen");
+            return;
+        }
+
+        // Skip the static-call form `AsyncEnumerable.ToAsyncEnumerable<T>(q)`. Fixing it would require a
+        // structural rewrite to a different containing type (EntityFrameworkQueryableExtensions) or to
+        // the instance form, which is beyond a pure name swap. The analyzer still warns; the user can
+        // refactor manually.
+        if (simpleName.Parent is MemberAccessExpressionSyntax
+            {
+                Expression: IdentifierNameSyntax { Identifier.ValueText: "AsyncEnumerable" }
+            })
+        {
+            return;
+        }
+
+        context.RegisterCodeFix(
+            CodeAction.Create(
+                AnalyzerStrings.ToAsyncEnumerableOnQueryableCodeActionTitle,
+                _ => Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(simpleName, GetReplacementName(simpleName)))),
+                nameof(ToAsyncEnumerableOnQueryableCodeFixProvider)),
+            diagnostic);
+    }
+
+    private static SimpleNameSyntax GetReplacementName(SimpleNameSyntax oldName)
+    {
+        // Preserve trivia (comments/whitespace) and any generic type arguments — only the identifier changes.
+        var newToken = SyntaxFactory.Identifier("AsAsyncEnumerable").WithTriviaFrom(oldName.Identifier);
+        return oldName.WithIdentifier(newToken);
+    }
+}

src/EFCore.Analyzers/ToAsyncEnumerableOnQueryableCodeFixProvider.cs

@@ -0,0 +1,132 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace Microsoft.EntityFrameworkCore;
+
+/// <summary>
+///     Reports calls to <c>System.Linq.AsyncEnumerable.ToAsyncEnumerable&lt;TSource&gt;(IEnumerable&lt;TSource&gt;)</c>
+///     whose source is an <c>IQueryable&lt;T&gt;</c>. The conversion forces the queryable to be enumerated synchronously,
+///     defeating the purpose of using <c>await foreach</c>. EF Core's <c>AsAsyncEnumerable&lt;T&gt;()</c> is the
+///     intended async-friendly alternative.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class ToAsyncEnumerableOnQueryableDiagnosticAnalyzer : DiagnosticAnalyzer
+{
+    private static readonly DiagnosticDescriptor Descriptor
+        = new(
+            EFDiagnostics.ToAsyncEnumerableOnQueryable,
+            title: AnalyzerStrings.ToAsyncEnumerableOnQueryableTitle,
+            messageFormat: AnalyzerStrings.ToAsyncEnumerableOnQueryableMessageFormat,
+            category: "Usage",
+            defaultSeverity: DiagnosticSeverity.Warning,
+            isEnabledByDefault: true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+        => [Descriptor];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+
+        context.RegisterOperationAction(AnalyzeInvocation, OperationKind.Invocation);
+    }
+
+    private static void AnalyzeInvocation(OperationAnalysisContext context)
+    {
+        var invocation = (IInvocationOperation)context.Operation;
+        var targetMethod = invocation.TargetMethod;
+
+        if (targetMethod.Name != "ToAsyncEnumerable")
+        {
+            return;
+        }
+
+        // Only flag the System.Linq.AsyncEnumerable.ToAsyncEnumerable<TSource>(IEnumerable<TSource>) overload.
+        // Other libraries may define methods with the same name (e.g. on Channel<T>, IObservable<T>) — we don't
+        // want to false-positive on those.
+        var containingType = targetMethod.ContainingType;
+        if (containingType is null
+            || containingType.Name != "AsyncEnumerable"
+            || containingType.ContainingNamespace?.ToDisplayString() != "System.Linq")
+        {
+            return;
+        }
+
+        // The source is exposed as Arguments[0].Value for an extension method invocation. Peel any
+        // chained implicit conversions to recover the user-written expression's type — a single C#
+        // expression can produce stacked IConversionOperation nodes in the Roslyn tree. An explicit
+        // cast to IEnumerable<T> (e.g. ((IEnumerable<T>)q).ToAsyncEnumerable()) shows up as
+        // IsImplicit: false, so the loop stops there and the underlying IQueryable type is hidden —
+        // a deliberate opt-out. Mirrors the WalkDownConversion(predicate) helper used across
+        // dotnet/roslyn-analyzers.
+        if (invocation.Arguments.Length == 0)
+        {
+            return;
+        }
+
+        var sourceOperation = invocation.Arguments[0].Value;
+        while (sourceOperation is IConversionOperation { IsImplicit: true } conversion)
+        {
+            sourceOperation = conversion.Operand;
+        }
+
+        if (sourceOperation.Type is not { } sourceType || !ImplementsGenericIQueryable(sourceType))
+        {
+            return;
+        }
+
+        context.ReportDiagnostic(Diagnostic.Create(Descriptor, GetInvocationLocation(invocation)));
+    }
+
+    private static bool ImplementsGenericIQueryable(ITypeSymbol type)
+    {
+        if (IsGenericIQueryable(type))
+        {
+            return true;
+        }
+
+        foreach (var iface in type.AllInterfaces)
+        {
+            if (IsGenericIQueryable(iface))
+            {
+                return true;
+            }
+        }
+
+        return false;
+
+        static bool IsGenericIQueryable(ITypeSymbol candidate)
+            => candidate is INamedTypeSymbol { Name: "IQueryable", TypeArguments.Length: 1 } named
+                && named.ContainingNamespace?.ToDisplayString() == "System.Linq";
+    }
+
+    private static Location GetInvocationLocation(IInvocationOperation invocation)
+    {
+        if (invocation.Syntax is not InvocationExpressionSyntax invocationExpression)
+        {
+            return invocation.Syntax.GetLocation();
+        }
+
+        var targetNode = invocationExpression.Expression;
+
+        while (targetNode is MemberAccessExpressionSyntax memberAccess)
+        {
+            targetNode = memberAccess.Name;
+        }
+
+        // Generic name case (e.g. `AsyncEnumerable.ToAsyncEnumerable<T>(q)`): point at just the identifier.
+        if (targetNode is GenericNameSyntax genericName)
+        {
+            return genericName.Identifier.GetLocation();
+        }
+
+        return targetNode.GetLocation();
+    }
+}

src/EFCore.Analyzers/ToAsyncEnumerableOnQueryableDiagnosticAnalyzer.cs

@@ -11,6 +11,7 @@ internal static class EFDiagnostics
     internal const string InternalUsage = "EF1001";
     internal const string InterpolatedStringUsageInRawQueries = "EF1002";
     internal const string StringConcatenationUsageInRawQueries = "EF1003";
+    internal const string ToAsyncEnumerableOnQueryable = "EF1004";
     internal const string SuppressUninitializedDbSetRule = "EFSPR1001";
 
     // Diagnostics for [Obsolete]