Add ToArray code fix for unmaterialized enumerables #280 (#292)

* Add ToArray code fix for unmaterialized enumerables

* Add PR number to CHANGELOG.md

Author: marinasundstrom

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- PR [#292](https://github.com/marinasundstrom/CheckedExceptions/pull/292) Materialize deferred enumerables with ToArray
 - 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`
 

CheckedExceptions.CodeFixes/CodeFixReleases.Unshipped.md

@@ -2,3 +2,4 @@
 
 ### New Rules
 
+- THROW017: Materialize deferred enumeration with ToArray

CheckedExceptions.CodeFixes/MaterializeEnumerableCodeFixProvider.cs

@@ -0,0 +1,70 @@
+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;
+using Microsoft.CodeAnalysis.Editing;
+
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace Sundstrom.CheckedExceptions;
+
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(MaterializeEnumerableCodeFixProvider)), Shared]
+public class MaterializeEnumerableCodeFixProvider : CodeFixProvider
+{
+    private const string Title = "Materialize enumeration with ToArray";
+
+    public sealed override ImmutableArray<string> FixableDiagnosticIds =>
+        [CheckedExceptionsAnalyzer.DiagnosticIdDeferredMustBeHandled];
+
+    public sealed override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+    public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+        var diagnostic = context.Diagnostics.First();
+        var node = root?.FindNode(diagnostic.Location.SourceSpan) as ExpressionSyntax;
+        if (node is null)
+            return;
+
+        context.RegisterCodeFix(
+            CodeAction.Create(
+                Title,
+                c => AddToArrayAsync(context.Document, node, c),
+                Title),
+            context.Diagnostics);
+    }
+
+    private static async Task<Document> AddToArrayAsync(Document document, ExpressionSyntax expression, CancellationToken cancellationToken)
+    {
+        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false) as CompilationUnitSyntax;
+        if (root is null)
+            return document;
+
+        var exprWithoutTrivia = expression.WithoutTrivia();
+        var target = exprWithoutTrivia is IdentifierNameSyntax or MemberAccessExpressionSyntax or InvocationExpressionSyntax or ElementAccessExpressionSyntax
+            ? exprWithoutTrivia
+            : ParenthesizedExpression(exprWithoutTrivia);
+
+        var newExpression = InvocationExpression(
+            MemberAccessExpression(
+                SyntaxKind.SimpleMemberAccessExpression,
+                target,
+                IdentifierName("ToArray")),
+            ArgumentList())
+            .WithTriviaFrom(expression);
+
+        var newRoot = root.ReplaceNode((SyntaxNode)expression, newExpression);
+
+        if (!newRoot.Usings.Any(u => u.Name is IdentifierNameSyntax id && id.Identifier.Text == "System.Linq" ||
+                                     u.Name is QualifiedNameSyntax q && q.ToString() == "System.Linq"))
+        {
+            newRoot = newRoot.AddUsings(UsingDirective(IdentifierName("System.Linq")));
+        }
+
+        return document.WithSyntaxRoot(newRoot);
+    }
+}

CheckedExceptions.Tests/CodeFixes/MaterializeEnumerableCodeFixProviderTests.cs

@@ -0,0 +1,56 @@
+namespace Sundstrom.CheckedExceptions.Tests.CodeFixes;
+
+using System.Threading.Tasks;
+
+using Microsoft.CodeAnalysis.Testing;
+
+using Xunit;
+
+using Verifier = CSharpCodeFixVerifier<CheckedExceptionsAnalyzer, MaterializeEnumerableCodeFixProvider, Microsoft.CodeAnalysis.Testing.DefaultVerifier>;
+
+public class MaterializeEnumerableCodeFixProviderTests
+{
+    [Fact]
+    public async Task ReturnEnumerable()
+    {
+        var testCode = /* lang=c#-test */ """
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+IEnumerable<string> items = [];
+IEnumerable<string> Get()
+{
+    var query = items.Where(x => int.Parse(x) > 0);
+    return query;
+}
+""";
+
+        var fixedCode = /* lang=c#-test */ """
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+IEnumerable<string> items = [];
+IEnumerable<string> Get()
+{
+    var query = items.Where(x => int.Parse(x) > 0);
+    return query.ToArray();
+}
+""";
+
+        var expected = Verifier.Diagnostic(CheckedExceptionsAnalyzer.DiagnosticIdDeferredMustBeHandled)
+            .WithArguments("IEnumerable<string>", "FormatException")
+            .WithSpan(10, 12, 10, 17);
+        var expected2 = Verifier.Diagnostic(CheckedExceptionsAnalyzer.DiagnosticIdDeferredMustBeHandled)
+            .WithArguments("IEnumerable<string>", "OverflowException")
+            .WithSpan(10, 12, 10, 17);
+
+        await Verifier.VerifyCodeFixAsync(testCode, new[] { expected, expected2 }, fixedCode, executable: true, setup: opt =>
+        {
+            opt.DisabledDiagnostics.Add(CheckedExceptionsAnalyzer.DiagnosticIdImplicitlyDeclaredException);
+        });
+    }
+}

docs/codefix-specification.md

@@ -16,6 +16,7 @@ This document describes the available **code fixes** and which diagnostics they
 | **THROW013**  | Redundant catch-all clause      | 🧹 Remove redundant catch clause    
 | **THROW014**  | Catch clause has no remaining exceptions to handle      | 🧹 Remove redundant catch clause
 | **THROW015**  | Redundant catch clause      | 🧹 Remove redundant catch clause
+| **THROW017**  | Deferred enumeration crossing boundary | 🧺 Materialize enumeration with ToArray
 ---
 
 ## What is a Throwing Site?
@@ -560,4 +561,33 @@ public string Data
     get => throw new IOException();
     set => throw new IOException();
 }
-```
+```
+---
+
+## 🧺 `Materialize enumeration`
+
+**Applies to:**
+
+* `THROW017` – *Deferred enumeration crossing boundary*
+
+Adds `.ToArray()` to deferred sequences that leave the member, forcing materialization so exceptions surface within the current member.
+
+### Example
+
+```csharp
+// Before
+IEnumerable<string> items = [];
+IEnumerable<string> Get()
+{
+    var query = items.Where(x => int.Parse(x) > 0);
+    return query; // THROW017
+}
+
+// After
+IEnumerable<string> items = [];
+IEnumerable<string> Get()
+{
+    var query = items.Where(x => int.Parse(x) > 0);
+    return query.ToArray();
+}
+```