feat: enable IQueryable LINQ support by default (#291)

* feat: enable queryable support by default

* Update CHANGELOG.md

Author: marinasundstrom

CHANGELOG.md

@@ -10,11 +10,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- PR [#PR_NUMBER](https://github.com/marinasundstrom/CheckedExceptions/pull/PR_NUMBER) Handle LINQ methods on `AsyncEnumerable`
+- PR [#290](https://github.com/marinasundstrom/CheckedExceptions/pull/290) Handle LINQ methods on `AsyncEnumerable`
+- PR [#291](https://github.com/marinasundstrom/CheckedExceptions/pull/291) LINQ support for `IQueryable` enabled by default with option to disable via `disableLinqQueryableSupport`
 
 ### Changed
 
-- PR [#PR_NUMBER](https://github.com/marinasundstrom/CheckedExceptions/pull/PR_NUMBER) Trim NuGet package README and document maintenance guidelines
+- PR [#290](https://github.com/marinasundstrom/CheckedExceptions/pull/290) Trim NuGet package README and document maintenance guidelines
 
 ### Fixed
 

CheckedExceptions.Tests/CheckedExceptionsAnalyzerTests.Linq.cs

@@ -395,8 +395,8 @@ await Verifier.VerifyAnalyzerAsync(test, setup: o =>
     }
 
     [Fact]
-    public async Task ReturnEnumerable()
-    {
+    public async Task ReturnEnumerable()
+    {
         var test = /* lang=c#-test */ """
             #nullable enable
             using System;
@@ -425,9 +425,56 @@ IEnumerable<string> Get()
         var expected4 = Verifier.UnhandledExceptionEnumerableBoundary("IEnumerable<string>", "OverflowException")
             .WithSpan(10, 12, 10, 17);
 
-        await Verifier.VerifyAnalyzerAsync(test, setup: o =>
-        {
-            o.ExpectedDiagnostics.AddRange(expected, expected2, expected3, expected4);
-        }, executable: true);
-    }
+        await Verifier.VerifyAnalyzerAsync(test, setup: o =>
+        {
+            o.ExpectedDiagnostics.AddRange(expected, expected2, expected3, expected4);
+        }, executable: true);
+    }
+
+    [Fact]
+    public async Task QueryableOperator_EnabledByDefault()
+    {
+        var test = /* lang=c#-test */ """
+            #nullable enable
+            using System;
+            using System.Collections.Generic;
+            using System.Linq;
+
+            IQueryable<int> items = new List<int>().AsQueryable();
+            var query = items.Where(x => true);
+            var r = Queryable.First<int>(query);
+            """;
+
+        var expected = Verifier.UnhandledException("InvalidOperationException")
+            .WithSpan(8, 19, 8, 36);
+
+        await Verifier.VerifyAnalyzerAsync(test, setup: o =>
+        {
+            o.ExpectedDiagnostics.Add(expected);
+        }, executable: true);
+    }
+
+    [Fact]
+    public async Task QueryableOperator_Disabled()
+    {
+        var test = /* lang=c#-test */ """
+            #nullable enable
+            using System;
+            using System.Collections.Generic;
+            using System.Linq;
+
+            IQueryable<int> items = new List<int>().AsQueryable();
+            var query = items.Where(x => true);
+            var r = Queryable.First<int>(query);
+            """;
+
+        await Verifier.VerifyAnalyzerAsync(test, setup: o =>
+        {
+            o.TestState.AdditionalFiles.Add(("CheckedExceptions.settings.json", """
+{
+  "disableLinqQueryableSupport": true
+}
+"""));
+        }, executable: true);
+    }
 }

CheckedExceptions/AnalyzerSettings.cs

@@ -28,6 +28,12 @@ public partial class AnalyzerSettings
     [JsonIgnore]
     internal bool IsLinqEnumerableBoundaryWarningsEnabled => !DisableLinqEnumerableBoundaryWarnings;
 
+    [JsonPropertyName("disableLinqQueryableSupport")]
+    public bool DisableLinqQueryableSupport { get; set; } = false;
+
+    [JsonIgnore]
+    internal bool IsLinqQueryableSupportEnabled => !DisableLinqQueryableSupport;
+
     [JsonPropertyName("disableControlFlowAnalysis")]
     public bool DisableControlFlowAnalysis { get; set; } = false;
 

CheckedExceptions/CheckedExceptionsAnalyzer.Analysis.cs

@@ -535,7 +535,9 @@ private static void AnalyzeFunctionAttributes(SyntaxNode node, IEnumerable<Attri
 
     private static void AnalyzeLinqOperation(SyntaxNodeAnalysisContext context, IMethodSymbol methodSymbol, HashSet<INamedTypeSymbol> exceptionTypes, InvocationExpressionSyntax invocation)
     {
-        if (IsLinqExtension(methodSymbol))
+        var settings = GetAnalyzerSettings(context.Options);
+
+        if (IsLinqExtension(methodSymbol, settings))
         {
             var name = methodSymbol.Name;
 
@@ -548,8 +550,6 @@ private static void AnalyzeLinqOperation(SyntaxNodeAnalysisContext context, IMet
             }
         }
 
-        var settings = GetAnalyzerSettings(context.Options);
-
         CollectLinqExceptions(invocation, exceptionTypes, context.Compilation, context.SemanticModel, settings, context.CancellationToken);
     }
 }

CheckedExceptions/CheckedExceptionsAnalyzer.Linq.cs

@@ -21,7 +21,7 @@ private static void CollectLinqExceptions(
     {
         if (semanticModel.GetOperation(invocationSyntax, ct) is not IInvocationOperation termOp)
             return;
-        if (!IsLinqExtension(termOp.TargetMethod))
+        if (!IsLinqExtension(termOp.TargetMethod, settings))
             return;
 
         var name = GetLinqName(termOp.TargetMethod);
@@ -33,7 +33,7 @@ private static void CollectLinqExceptions(
             // defer handling until the outermost call is analyzed.
             if (invocationSyntax.Parent is MemberAccessExpressionSyntax { Parent: InvocationExpressionSyntax outer } &&
                 semanticModel.GetOperation(outer, ct) is IInvocationOperation outerOp &&
-                IsLinqExtension(outerOp.TargetMethod))
+                IsLinqExtension(outerOp.TargetMethod, settings))
             {
                 return;
             }
@@ -108,7 +108,7 @@ private static string GetLinqName(IMethodSymbol method)
         return name;
     }
 
-    private static bool IsLinqExtension(IMethodSymbol method)
+    private static bool IsLinqExtension(IMethodSymbol method, AnalyzerSettings settings)
     {
         if (method is null || !method.IsExtensionMethod) return false;
 
@@ -119,8 +119,26 @@ private static bool IsLinqExtension(IMethodSymbol method)
         if (ns != "System.Linq") return false;
 
         var name = containingType.Name;
-        return name.EndsWith("Enumerable", StringComparison.Ordinal)
-            || name.EndsWith("Queryable", StringComparison.Ordinal);
+        if (name.EndsWith("Enumerable", StringComparison.Ordinal))
+            return true;
+
+        if (name.EndsWith("Queryable", StringComparison.Ordinal))
+            return settings.IsLinqQueryableSupportEnabled;
+
+        return false;
+    }
+
+    private static bool IsQueryableExtension(IMethodSymbol method)
+    {
+        if (method is null || !method.IsExtensionMethod) return false;
+
+        var containingType = method.ContainingType;
+        if (containingType is null) return false;
+
+        var ns = containingType.ContainingNamespace?.ToDisplayString();
+        if (ns != "System.Linq") return false;
+
+        return containingType.Name.EndsWith("Queryable", StringComparison.Ordinal);
     }
 
     private static IOperation? GetLinqSourceOperation(IInvocationOperation op)
@@ -144,7 +162,7 @@ private static void CollectDeferredChainExceptions(
         {
             switch (current)
             {
-                case IInvocationOperation inv when IsLinqExtension(inv.TargetMethod):
+                case IInvocationOperation inv when IsLinqExtension(inv.TargetMethod, settings):
                     var name = GetLinqName(inv.TargetMethod);
 
                     if (LinqKnowledge.DeferredOps.Contains(name))
@@ -316,7 +334,7 @@ private void CollectEnumerationExceptions(
         }
 
         if (inner is IInvocationOperation inv &&
-            IsLinqExtension(inv.TargetMethod) &&
+            IsLinqExtension(inv.TargetMethod, settings) &&
             LinqKnowledge.TerminalOps.Contains(GetLinqName(inv.TargetMethod)))
         {
             return;
@@ -340,7 +358,7 @@ private static void CollectDeferredChainExceptions_ForEnumeration(
         {
             switch (current)
             {
-                case IInvocationOperation inv when IsLinqExtension(inv.TargetMethod):
+                case IInvocationOperation inv when IsLinqExtension(inv.TargetMethod, settings):
                     {
                         var name = GetLinqName(inv.TargetMethod);
 

CheckedExceptions/CheckedExceptionsAnalyzer.Members.cs

@@ -15,6 +15,9 @@ private static void AnalyzeMemberExceptions(SyntaxNodeAnalysisContext context, S
         if (methodSymbol is null)
             return;
 
+        if (!settings.IsLinqQueryableSupportEnabled && IsQueryableExtension(methodSymbol))
+            return;
+
         var exceptionTypes = new HashSet<INamedTypeSymbol>(
             GetExceptionTypes(methodSymbol), SymbolEqualityComparer.Default);
 

CheckedExceptions/CheckedExceptionsAnalyzer.Throw.cs

@@ -76,7 +76,7 @@ private static void AnalyzeExceptionThrowingNode(
         if (!isHandled && !isDeclared)
         {
             if (settings.IsLinqImplicitlyDeclaredExceptionsEnabled
-                && IsInsideLinqLambda(node, semanticModel, out _))
+                && IsInsideLinqLambda(node, semanticModel, settings, out _))
             {
                 // Implicitly declared exceptions in LINQ expressions
 
@@ -116,6 +116,7 @@ private static void AnalyzeExceptionThrowingNode(
     private static bool IsInsideLinqLambda(
         SyntaxNode node,
         SemanticModel semanticModel,
+        AnalyzerSettings settings,
         out IInvocationOperation? linqInvocation,
         CancellationToken ct = default)
     {
@@ -153,7 +154,7 @@ private static bool IsInsideLinqLambda(
         if (inv is null) return false;
 
         // finally: is it a LINQ query operator?
-        if (!IsLinqExtension(inv.TargetMethod)) return false;
+        if (!IsLinqExtension(inv.TargetMethod, settings)) return false;
 
         linqInvocation = inv;
         return true;

CheckedExceptions/CheckedExceptionsAnalyzer.cs

@@ -290,7 +290,7 @@ private void AnalyzeArgument(SyntaxNodeAnalysisContext context)
         // the invocation analysis will handle diagnostics. Skip boundary reporting.
         if (argumentSyntax.Expression is InvocationExpressionSyntax invSyntax &&
             semanticModel.GetOperation(invSyntax) is IInvocationOperation invOp &&
-            IsLinqExtension(invOp.TargetMethod) &&
+            IsLinqExtension(invOp.TargetMethod, settings) &&
             LinqKnowledge.TerminalOps.Contains(invOp.TargetMethod.Name))
         {
             return;

README.md

@@ -307,7 +307,7 @@ This is due to a **technical limitation**: the XML documentation files for .NET
 
 **Answer:**
 
-There is support for LINQ query operators on `IEnumerable<T>` and asynchronous operators like `FirstAsync` on `IAsyncEnumerable<T>` (via [System.Linq.Async](https://www.nuget.org/packages/System.Linq.Async)).
+There is support for LINQ query operators on `IEnumerable<T>` and asynchronous operators like `FirstAsync` on `IAsyncEnumerable<T>` (via [System.Linq.Async](https://www.nuget.org/packages/System.Linq.Async)). Support for `IQueryable<T>` is enabled by default and can be disabled via the `disableLinqQueryableSupport` setting.
 
 ```csharp
 List<string> values = [ "10", "20", "abc", "30" ];

docs/analyzer-specification.md

@@ -400,7 +400,7 @@ This is treated as valid when there is only a `get` accessor.
 
 ### LINQ queries
 
-The analyzer recognizes LINQ query operators whose extensions live in the `System.Linq` namespace and whose containing type name ends with `Enumerable` or `Queryable`, including `AsyncEnumerable` from the [`System.Linq.Async`](https://www.nuget.org/packages/System.Linq.Async) package.
+The analyzer recognizes LINQ query operators whose extensions live in the `System.Linq` namespace and whose containing type name ends with `Enumerable`. Operators ending in `Queryable` are also supported. You can disable this by setting `disableLinqQueryableSupport` to `true`. `AsyncEnumerable` from the [`System.Linq.Async`](https://www.nuget.org/packages/System.Linq.Async) package is also recognized.
 
 Async operator names suffixed with `Async`, `Await`, or `AwaitWithCancellation` are normalized to their synchronous counterparts so built-in exception knowledge applies.
 
@@ -491,6 +491,16 @@ var query = items.Where([Throws(typeof(FormatException), typeof(OverflowExceptio
 var r = query.First();
 ```
 
+### Disable LINQ IQueryable support
+
+This option disables analysis of LINQ operators defined on `Queryable`. Expression tree translation depends on the provider, so disable this when your provider behaves differently.
+
+```json
+{
+    "disableLinqQueryableSupport": true
+}
+```
+
 #### Disable implicitly declared exceptions in lambdas
 
 This option control whether to disable implicitly declared exceptions in lambdas passed into LINQ operator methods.