Suggested variable names inside using, for & foreach (#26026)

* Adding support for for each variable

* Adding support for for statement variables

* Adding named arguments

* Adding support for using statement

* Addressing feedback

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

@@ -829,6 +829,143 @@ public static void Main()
             await VerifyItemExistsAsync(markup, "token");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void InUsingStatement1()
+        {
+            var markup = @"
+using System.IO;
+
+class C
+{
+    void M()
+    {
+        using (StreamReader s$$
+    }
+}
+";
+            await VerifyItemExistsAsync(markup, "streamReader");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void InUsingStatement2()
+        {
+            var markup = @"
+using System.IO;
+
+class C
+{
+    void M()
+    {
+        using (StreamReader s1, $$
+    }
+}
+";
+            await VerifyItemExistsAsync(markup, "streamReader");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void InUsingStatement_Var()
+        {
+            var markup = @"
+using System.IO;
+
+class C
+{
+    void M()
+    {
+        using (var m$$ = new MemoryStream())
+    }
+}
+";
+            await VerifyItemExistsAsync(markup, "memoryStream");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void InForStatement1()
+        {
+            var markup = @"
+using System.IO;
+
+class C
+{
+    void M()
+    {
+        for (StreamReader s$$
+    }
+}
+";
+            await VerifyItemExistsAsync(markup, "streamReader");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void InForStatement2()
+        {
+            var markup = @"
+using System.IO;
+
+class C
+{
+    void M()
+    {
+        for (StreamReader s1, $$
+    }
+}
+";
+            await VerifyItemExistsAsync(markup, "streamReader");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void InForStatement_Var()
+        {
+            var markup = @"
+using System.IO;
+
+class C
+{
+    void M()
+    {
+        for (var m$$ = new MemoryStream();
+    }
+}
+";
+            await VerifyItemExistsAsync(markup, "memoryStream");
+        }
+
+        [WorkItem(26021, "https://github.com/dotnet/roslyn/issues/26021")]
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void InForEachStatement()
+        {
+            var markup = @"
+using System.IO;
+
+class C
+{
+    void M()
+    {
+        foreach (StreamReader $$
+    }
+}
+";
+            await VerifyItemExistsAsync(markup, "streamReader");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void InForEachStatement_Var()
+        {
+            var markup = @"
+using System.IO;
+
+class C
+{
+    void M()
+    {
+        foreach (var m$$ in new[] { new MemoryStream() })
+    }
+}
+";
+            await VerifyItemExistsAsync(markup, "memoryStream");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
         public async void DisabledByOption()
         {

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

@@ -162,6 +162,96 @@ void goo()
             await VerifyAccessibility(markup, Accessibility.NotApplicable);
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void UsingVariableDeclaration1()
+        {
+            var markup = @"
+class C
+{
+    void M()
+    {
+        using (int i$$
+    }
+}
+";
+            await VerifySymbolKinds(markup, SymbolKind.Local);
+            await VerifyModifiers(markup, new DeclarationModifiers());
+            await VerifyTypeName(markup, "int");
+            await VerifyAccessibility(markup, Accessibility.NotApplicable);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void UsingVariableDeclaration2()
+        {
+            var markup = @"
+class C
+{
+    void M()
+    {
+        using (int i1, $$
+    }
+}
+";
+            await VerifySymbolKinds(markup, SymbolKind.Local);
+            await VerifyModifiers(markup, new DeclarationModifiers());
+            await VerifyTypeName(markup, "int");
+            await VerifyAccessibility(markup, Accessibility.NotApplicable);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void ForVariableDeclaration1()
+        {
+            var markup = @"
+class C
+{
+    void M()
+    {
+        for (int i$$
+    }
+}
+";
+            await VerifySymbolKinds(markup, SymbolKind.Local);
+            await VerifyModifiers(markup, new DeclarationModifiers());
+            await VerifyTypeName(markup, "int");
+            await VerifyAccessibility(markup, Accessibility.NotApplicable);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void ForVariableDeclaration2()
+        {
+            var markup = @"
+class C
+{
+    void M()
+    {
+        for (int i1, $$
+    }
+}
+";
+            await VerifySymbolKinds(markup, SymbolKind.Local);
+            await VerifyModifiers(markup, new DeclarationModifiers());
+            await VerifyTypeName(markup, "int");
+            await VerifyAccessibility(markup, Accessibility.NotApplicable);
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async void ForEachVariableDeclaration()
+        {
+            var markup = @"
+class C
+{
+    void M()
+    {
+        foreach (int $$
+    }
+}
+";
+            await VerifySymbolKinds(markup, SymbolKind.Local);
+            await VerifyModifiers(markup, new DeclarationModifiers());
+            await VerifyTypeName(markup, "int");
+            await VerifyAccessibility(markup, Accessibility.NotApplicable);
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
         public async void Parameter1()
         {

src/Features/CSharp/Portable/Completion/CompletionProviders/DeclarationNameCompletionProvider.DeclarationInfo.cs

@@ -48,6 +48,7 @@ internal static async Task<NameDeclarationInfo> GetDeclarationInfo(Document docu
                 if (IsParameterDeclaration(token, semanticModel, position, cancellationToken, out var result)
                     || IsTypeParameterDeclaration(token, semanticModel, position, cancellationToken, out result)
                     || IsVariableDeclaration(token, semanticModel, position, cancellationToken, out result)
+                    || IsForEachVariableDeclaration(token, semanticModel, position, cancellationToken, out result)
                     || IsIncompleteMemberDeclaration(token, semanticModel, position, cancellationToken, out result)
                     || IsFieldDeclaration(token, semanticModel, position, cancellationToken, out result)
                     || IsMethodDeclaration(token, semanticModel, position, cancellationToken, out result)
@@ -251,13 +252,33 @@ internal static async Task<NameDeclarationInfo> GetDeclarationInfo(Document docu
                 int position, CancellationToken cancellationToken, out NameDeclarationInfo result)
             {
                 result = IsFollowingTypeOrComma<VariableDeclarationSyntax>(token, semanticModel,
-                     v => v.Type,
-                     v => v.Parent is LocalDeclarationStatementSyntax l ? l.Modifiers : default(SyntaxTokenList?),
-                     d => ImmutableArray.Create(SymbolKind.Local),
+                     typeSyntaxGetter: v => v.Type,
+                     modifierGetter: v =>
+                        v.Parent is LocalDeclarationStatementSyntax localDeclaration ? localDeclaration.Modifiers :
+                        v.Parent is UsingStatementSyntax ? default(SyntaxTokenList) :
+                        v.Parent is ForStatementSyntax ? default(SyntaxTokenList) :
+                        default(SyntaxTokenList?), // Return null to bail out.
+                     possibleDeclarationComputer: d => ImmutableArray.Create(SymbolKind.Local),
                      cancellationToken);
                 return result.Type != null;
             }
 
+            private static bool IsForEachVariableDeclaration(SyntaxToken token, SemanticModel semanticModel,
+                int position, CancellationToken cancellationToken, out NameDeclarationInfo result)
+            {
+                // This is parsed as ForEachVariableStatementSyntax:
+                // foreach (int $$
+                result = IsLastTokenOfType<CommonForEachStatementSyntax>(token, semanticModel,
+                    typeSyntaxGetter: f =>
+                        f is ForEachStatementSyntax forEachStatement ? forEachStatement.Type :
+                        f is ForEachVariableStatementSyntax forEachVariableStatement ? forEachVariableStatement.Variable :
+                        null, // Return null to bail out.
+                    modifierGetter: f => default,
+                    possibleDeclarationComputer: d => ImmutableArray.Create(SymbolKind.Local),
+                    cancellationToken);
+                return result.Type != null;
+            }
+
             private static bool IsTypeParameterDeclaration(SyntaxToken token, SemanticModel semanticModel,
                 int position, CancellationToken cancellationToken, out NameDeclarationInfo result)
             {