Fix #22: Await ForEach statements

semihokur · May 11, 2022 · 8bba5a6 · 8bba5a6
1 parent 5000c6d
commit 8bba5a6
Show file tree

Hide file tree

Showing 4 changed files with 144 additions and 7 deletions.
diff --git a/AsyncFixer.Samples/UnnecessaryAsync.cs b/AsyncFixer.Samples/UnnecessaryAsync.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
 
@@ -110,5 +111,25 @@ public static async Task foo4(int i)
                 await Task.Delay(2000);
             }
         }
+
+        public async Task MyFunction()
+        {
+            await Task.Run(async () =>
+            {
+                await foreach (var i in RangeAsync(10, 3))
+                {
+                    Console.WriteLine(i);
+                }
+            });
+        }
+
+        static async IAsyncEnumerable<int> RangeAsync(int start, int count)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                await Task.Delay(i);
+                yield return start + i;
+            }
+        }
     }
 }
diff --git a/AsyncFixer.Test/Helpers/CSharpCodeFixVerifier.cs b/AsyncFixer.Test/Helpers/CSharpCodeFixVerifier.cs
@@ -36,7 +36,6 @@ public static async Task VerifyAnalyzerAsync(string source, params DiagnosticRes
             var test = new Test
             {
                 TestCode = source,
-                LanguageVersion = LanguageVersion.Latest
             };
 
             test.ExpectedDiagnostics.AddRange(expected);

diff --git a/AsyncFixer.Test/UnnecessaryAsyncTests.cs b/AsyncFixer.Test/UnnecessaryAsyncTests.cs
@@ -462,7 +462,7 @@ async Task foo()
         }
 
         [Fact]
-        public async Task OutOfScopeSiblingUsingBlock()
+        public Task OutOfScopeSiblingUsingBlock()
         {
             var test = @"
 using System;
@@ -506,7 +506,7 @@ Task foo(bool cond)
     }
 }";
 
-            await new Verify.Test
+            return new Verify.Test
             {
                 TestState =
                 {
@@ -942,6 +942,115 @@ async Task<int> boo(bool c) {
             VerifyCSharpDiagnostic(test);
         }
 
+        [Fact]
+        public Task NoWarn_AwaitForEach()
+        {
+            //No diagnostics expected to show up
+
+            var test = @"
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+internal class Program
+{
+    public async Task MyFunction()
+    {
+        await foreach (var i in RangeAsync(10, 3))
+        {
+            Console.WriteLine(i);
+        }
+
+        await Task.Delay(1);
+    }
+
+    static async IAsyncEnumerable<int> RangeAsync(int start, int count)
+    {
+        for (int i = 0; i < count; i++)
+        {
+            await Task.Delay(i);
+            yield return start + i;
+        }
+    }
+}";
+            return Verify.VerifyAsync(test);
+        }
+
+        [Fact]
+        public Task AwaitForEachUnderLambda()
+        {
+            var test = @"
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+internal class Program
+{
+    public async Task MyFunction()
+    {
+        await Task.Run(async () =>
+        {
+            await foreach (var i in RangeAsync(10, 3))
+            {
+                Console.WriteLine(i);
+            }
+        });
+    }
+
+    static async IAsyncEnumerable<int> RangeAsync(int start, int count)
+    {
+        for (int i = 0; i < count; i++)
+        {
+            await Task.Delay(i);
+            yield return start + i;
+        }
+    }
+}";
+
+            var fixtest = @"
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+internal class Program
+{
+    public Task MyFunction()
+    {
+        return Task.Run(async () =>
+         {
+             await foreach (var i in RangeAsync(10, 3))
+             {
+                 Console.WriteLine(i);
+             }
+         });
+    }
+
+    static async IAsyncEnumerable<int> RangeAsync(int start, int count)
+    {
+        for (int i = 0; i < count; i++)
+        {
+            await Task.Delay(i);
+            yield return start + i;
+        }
+    }
+}";
+            return new Verify.Test
+            {
+                TestState =
+                {
+                    Sources = { test },
+                    ExpectedDiagnostics =
+                    {
+                        Verify.Diagnostic().WithSpan(8, 5, 17, 6).WithArguments("MyFunction"),
+                    },
+                },
+                FixedState =
+                {
+                    Sources = { fixtest },
+                },
+            }.RunAsync();
+        }
+
         protected override CodeFixProvider GetCSharpCodeFixProvider()
         {
             return new UnnecessaryAsyncFixer();

diff --git a/AsyncFixer/UnnecessaryAsync/UnnecessaryAsyncAnalyzer.cs b/AsyncFixer/UnnecessaryAsync/UnnecessaryAsyncAnalyzer.cs
@@ -91,6 +91,14 @@ private void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
                 return;
             }
 
+            var awaitForEachStatements = node.DescendantNodes().OfType<ForEachStatementSyntax>()
+                .Where(a => a.AwaitKeyword != null  && a.FirstAncestorOrSelfUnderGivenNode<LambdaExpressionSyntax>(node) == null).ToList();
+
+            if (awaitForEachStatements.Any())
+            {
+                return; 
+            }            
+
             // Retrieve all await expressions excluding the ones under lambda functions.
             var awaitExpressions = node.DescendantNodes().OfType<AwaitExpressionSyntax>().Where(a => a.FirstAncestorOrSelfUnderGivenNode<LambdaExpressionSyntax>(node) == null).ToList();
 
@@ -130,7 +138,7 @@ private void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
 
             var controlFlow = context.SemanticModel.AnalyzeControlFlow(node.Body);
             var returnStatements = controlFlow?.ReturnStatements ?? ImmutableArray<SyntaxNode>.Empty;
-            var numAwait = 0;
+            var numAwaitsToRemove = 0;
 
             if (returnStatements.Any())
             {
@@ -158,7 +166,7 @@ private void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
                         return;
                     }
 
-                    numAwait++;
+                    numAwaitsToRemove++;
                 }
             }
             else
@@ -190,10 +198,10 @@ private void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
                     return;
                 }
 
-                numAwait++;
+                numAwaitsToRemove++;
             }
 
-            if (numAwait < awaitExpressions.Count())
+            if (numAwaitsToRemove < awaitExpressions.Count())
             {
                 return;
             }