Async suggestions improvements

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/EnumAndCompletionListTagCompletionProviderTests.cs

@@ -792,6 +792,33 @@ readonly struct Colors
             await VerifyItemIsAbsentAsync(markup + colorsLike, "Colors");
         }
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NotAfterAsync1()
+        {
+            var markup = @"
+class Test
+{
+    public async $$
+}";
+
+            await VerifyNoItemsExistAsync(markup);
+        }
+
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NotAfterAsync2()
+        {
+            var markup = @"
+class Test
+{
+    public async $$
+    public void M() {}
+}";
+
+            await VerifyNoItemsExistAsync(markup);
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
         public async Task NotAfterDot()
         {

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/SymbolCompletionProviderTests.cs

@@ -2296,22 +2296,16 @@ void M(String parameter)
             await VerifyItemIsAbsentAsync(markup, "parameter");
         }
 
-        [WorkItem(53585, "https://github.com/dotnet/roslyn/issues/53585")]
         [Theory, Trait(Traits.Feature, Traits.Features.Completion)]
+        [WorkItem(53585, "https://github.com/dotnet/roslyn/issues/53585")]
         [InlineData("extern")]
         [InlineData("static extern")]
         [InlineData("extern static")]
-        [InlineData("async")]
-        [InlineData("static async")]
-        [InlineData("async static")]
         [InlineData("unsafe")]
         [InlineData("static unsafe")]
         [InlineData("unsafe static")]
-        [InlineData("async unsafe")]
-        [InlineData("unsafe async")]
         [InlineData("unsafe extern")]
         [InlineData("extern unsafe")]
-        [InlineData("extern unsafe async static")]
         public async Task AfterLocalFunction_TypeOnly(string keyword)
         {
             var markup = $@"
@@ -2328,21 +2322,45 @@ void M(String parameter)
             await VerifyItemIsAbsentAsync(markup, "parameter");
         }
 
+        [Theory, Trait(Traits.Feature, Traits.Features.Completion)]
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [InlineData("async")]
+        [InlineData("static async")]
+        [InlineData("async static")]
+        [InlineData("async unsafe")]
+        [InlineData("unsafe async")]
+        [InlineData("extern unsafe async static")]
+        public async Task AfterLocalFunction_TypeOnly_Async(string keyword)
+        {
+            var markup = $@"
+using System;
+class C
+{{
+    void M(String parameter)
+    {{
+        {keyword} $$
+    }}
+}}
+";
+            await VerifyItemIsAbsentAsync(markup, "String");
+            await VerifyItemIsAbsentAsync(markup, "parameter");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
-        [WorkItem(53585, "https://github.com/dotnet/roslyn/issues/53585")]
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         public async Task AfterAsyncLocalFunctionWithTwoAsyncs()
         {
             var markup = @"
 using System;
 class C
 {
-    void M(String parameter)
+    void M(string parameter)
     {
         async async $$
     }
 }
 ";
-            await VerifyItemExistsAsync(markup, "String");
+            await VerifyItemIsAbsentAsync(markup, "String");
             await VerifyItemIsAbsentAsync(markup, "parameter");
         }
 
@@ -7252,6 +7270,55 @@ public async T$$
             await VerifyItemExistsAsync(markup, "Task");
         }
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task AfterAsync3()
+        {
+            var markup = @"
+using System.Threading.Tasks;
+class Program
+{
+    public async $$
+
+    public void M() {}
+}";
+
+            await VerifyItemExistsAsync(markup, "Task");
+        }
+
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task AfterAsync4()
+        {
+            var markup = @"
+using System;
+using System.Threading.Tasks;
+class Program
+{
+    public async $$
+}";
+
+            await VerifyItemExistsAsync(markup, "Task");
+            await VerifyItemIsAbsentAsync(markup, "Console");
+        }
+
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task AfterAsync5()
+        {
+            var markup = @"
+using System.Threading.Tasks;
+class Program
+{
+    public async $$
+}
+
+class Test {}";
+
+            await VerifyItemExistsAsync(markup, "Task");
+            await VerifyItemIsAbsentAsync(markup, "Test");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
         public async Task NotAfterAsyncInMethodBody()
         {

src/EditorFeatures/CSharpTest2/Recommendations/BoolKeywordRecommenderTests.cs

@@ -694,13 +694,15 @@ class C { }
 ");
         }
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsync()
-            => await VerifyKeywordAsync(@"class c { async $$ }");
+        public async Task TestNotAfterAsync()
+            => await VerifyAbsenceAsync(@"class c { async $$ }");
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsyncAsType()
-            => await VerifyKeywordAsync(@"class c { async async $$ }");
+        public async Task TestNotAfterAsyncAsType()
+            => await VerifyAbsenceAsync(@"class c { async async $$ }");
 
         [WorkItem(1468, "https://github.com/dotnet/roslyn/issues/1468")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
@@ -786,10 +788,19 @@ class C
 
         [WorkItem(53585, "https://github.com/dotnet/roslyn/issues/53585")]
         [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunction))]
-        public async Task TestAfterKeywordIndicatingLocalFunction(string keyword)
+        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunctionWithoutAsync))]
+        public async Task TestAfterKeywordIndicatingLocalFunctionWithoutAsync(string keyword)
         {
             await VerifyKeywordAsync(AddInsideMethod($@"
+{keyword} $$"));
+        }
+
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunctionWithAsync))]
+        public async Task TestNotAfterKeywordIndicatingLocalFunctionWithAsync(string keyword)
+        {
+            await VerifyAbsenceAsync(AddInsideMethod($@"
 {keyword} $$"));
         }
     }

src/EditorFeatures/CSharpTest2/Recommendations/ByteKeywordRecommenderTests.cs

@@ -695,13 +695,15 @@ class C { }
 ");
         }
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsync()
-            => await VerifyKeywordAsync(@"class c { async $$ }");
+        public async Task TestNotAfterAsync()
+            => await VerifyAbsenceAsync(@"class c { async $$ }");
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsyncAsType()
-            => await VerifyKeywordAsync(@"class c { async async $$ }");
+        public async Task TestNotAfterAsyncAsType()
+            => await VerifyAbsenceAsync(@"class c { async async $$ }");
 
         [WorkItem(1468, "https://github.com/dotnet/roslyn/issues/1468")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
@@ -787,10 +789,19 @@ class C
 
         [WorkItem(53585, "https://github.com/dotnet/roslyn/issues/53585")]
         [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunction))]
-        public async Task TestAfterKeywordIndicatingLocalFunction(string keyword)
+        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunctionWithoutAsync))]
+        public async Task TestAfterKeywordIndicatingLocalFunctionWithoutAsync(string keyword)
         {
             await VerifyKeywordAsync(AddInsideMethod($@"
+{keyword} $$"));
+        }
+
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunctionWithAsync))]
+        public async Task TestNotAfterKeywordIndicatingLocalFunctionWithAsync(string keyword)
+        {
+            await VerifyAbsenceAsync(AddInsideMethod($@"
 {keyword} $$"));
         }
     }

src/EditorFeatures/CSharpTest2/Recommendations/CharKeywordRecommenderTests.cs

@@ -667,13 +667,15 @@ class C { }
 ");
         }
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsync()
-            => await VerifyKeywordAsync(@"class c { async $$ }");
+        public async Task TestNotAfterAsync()
+            => await VerifyAbsenceAsync(@"class c { async $$ }");
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsyncAsType()
-            => await VerifyKeywordAsync(@"class c { async async $$ }");
+        public async Task TestNotAfterAsyncAsType()
+            => await VerifyAbsenceAsync(@"class c { async async $$ }");
 
         [WorkItem(988025, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/988025")]
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
@@ -816,10 +818,19 @@ class C
 
         [WorkItem(53585, "https://github.com/dotnet/roslyn/issues/53585")]
         [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunction))]
-        public async Task TestAfterKeywordIndicatingLocalFunction(string keyword)
+        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunctionWithoutAsync))]
+        public async Task TestAfterKeywordIndicatingLocalFunctionWithoutAsync(string keyword)
         {
             await VerifyKeywordAsync(AddInsideMethod($@"
+{keyword} $$"));
+        }
+
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunctionWithAsync))]
+        public async Task TestNotAfterKeywordIndicatingLocalFunctionWithAsync(string keyword)
+        {
+            await VerifyAbsenceAsync(AddInsideMethod($@"
 {keyword} $$"));
         }
     }

src/EditorFeatures/CSharpTest2/Recommendations/DecimalKeywordRecommenderTests.cs

@@ -683,13 +683,15 @@ class C { }
 ");
         }
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsync()
-            => await VerifyKeywordAsync(@"class c { async $$ }");
+        public async Task TestNotAfterAsync()
+            => await VerifyAbsenceAsync(@"class c { async $$ }");
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsyncAsType()
-            => await VerifyKeywordAsync(@"class c { async async $$ }");
+        public async Task TestNotAfterAsyncAsType()
+            => await VerifyAbsenceAsync(@"class c { async async $$ }");
 
         [WorkItem(1468, "https://github.com/dotnet/roslyn/issues/1468")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
@@ -780,10 +782,19 @@ class C
 
         [WorkItem(53585, "https://github.com/dotnet/roslyn/issues/53585")]
         [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunction))]
-        public async Task TestAfterKeywordIndicatingLocalFunction(string keyword)
+        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunctionWithoutAsync))]
+        public async Task TestAfterKeywordIndicatingLocalFunctionWithoutAsync(string keyword)
         {
             await VerifyKeywordAsync(AddInsideMethod($@"
+{keyword} $$"));
+        }
+
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunctionWithAsync))]
+        public async Task TestNotAfterKeywordIndicatingLocalFunctionWithAsync(string keyword)
+        {
+            await VerifyAbsenceAsync(AddInsideMethod($@"
 {keyword} $$"));
         }
     }

src/EditorFeatures/CSharpTest2/Recommendations/DoubleKeywordRecommenderTests.cs

@@ -667,13 +667,15 @@ class C { }
 ");
         }
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsync()
-            => await VerifyKeywordAsync(@"class c { async $$ }");
+        public async Task TestNotAfterAsync()
+            => await VerifyAbsenceAsync(@"class c { async $$ }");
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsyncAsType()
-            => await VerifyKeywordAsync(@"class c { async async $$ }");
+        public async Task TestNotAfterAsyncAsType()
+            => await VerifyAbsenceAsync(@"class c { async async $$ }");
 
         [WorkItem(1468, "https://github.com/dotnet/roslyn/issues/1468")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
@@ -764,10 +766,19 @@ class C
 
         [WorkItem(53585, "https://github.com/dotnet/roslyn/issues/53585")]
         [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunction))]
-        public async Task TestAfterKeywordIndicatingLocalFunction(string keyword)
+        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunctionWithoutAsync))]
+        public async Task TestAfterKeywordIndicatingLocalFunctionWithoutAsync(string keyword)
         {
             await VerifyKeywordAsync(AddInsideMethod($@"
+{keyword} $$"));
+        }
+
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
+        [Theory, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
+        [ClassData(typeof(TheoryDataKeywordsIndicatingLocalFunctionWithAsync))]
+        public async Task TestNotAfterKeywordIndicatingLocalFunctionWithAsync(string keyword)
+        {
+            await VerifyAbsenceAsync(AddInsideMethod($@"
 {keyword} $$"));
         }
     }

src/EditorFeatures/CSharpTest2/Recommendations/DynamicKeywordRecommenderTests.cs

@@ -635,13 +635,15 @@ await VerifyAbsenceAsync(
 }");
         }
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsync()
-            => await VerifyKeywordAsync(@"class c { async $$ }");
+        public async Task TestNotAfterAsync()
+            => await VerifyAbsenceAsync(@"class c { async $$ }");
 
+        [WorkItem(60341, "https://github.com/dotnet/roslyn/issues/60341")]
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
-        public async Task TestAfterAsyncAsType()
-            => await VerifyKeywordAsync(@"class c { async async $$ }");
+        public async Task TestNotAfterAsyncAsType()
+            => await VerifyAbsenceAsync(@"class c { async async $$ }");
 
         [Fact, Trait(Traits.Feature, Traits.Features.KeywordRecommending)]
         public async Task TestInFunctionPointerType()