Add semicolon as a commit character for object creation and symbol completion

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

@@ -1888,6 +1888,63 @@ await VerifyImportItemIsAbsentAsync(
             }
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task TestCommitWithSemicolonForMethod()
+        {
+            var markup = @"
+public class C
+{
+}
+namespace AA
+{
+    public static class Ext
+    {
+        public static int ToInt(this C c)
+            => 1;
+    }
+}
+
+namespace BB
+{
+    public class B
+    {
+        public void M()
+        {
+            var c = new C();
+            c.$$
+        }
+    }
+}";
+
+            var expected = @"
+using AA;
+
+public class C
+{
+}
+namespace AA
+{
+    public static class Ext
+    {
+        public static int ToInt(this C c)
+            => 1;
+    }
+}
+
+namespace BB
+{
+    public class B
+    {
+        public void M()
+        {
+            var c = new C();
+            c.ToInt();
+        }
+    }
+}";
+            await VerifyProviderCommitAsync(markup, "ToInt", expected, commitChar: ';', sourceCodeKind: SourceCodeKind.Regular);
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
         public async Task TestTimeBox()
         {

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

@@ -677,5 +677,113 @@ void M()
 ";
             await VerifyItemExistsAsync(markup, "List<object?>");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CreateObjectAndCommitWithSemicolon()
+        {
+            var markup = @"
+class Program
+{
+    void Bar()
+    {
+        object o = new $$
+    }
+}";
+            var expectedMark = @"
+class Program
+{
+    void Bar()
+    {
+        object o = new object();
+    }
+}";
+            await VerifyProviderCommitAsync(markup, "object", expectedMark, commitChar: ';');
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CreateNullableObjectAndCommitWithSemicolon()
+        {
+            var markup = @"
+class Program
+{
+    void Bar()
+    {
+        object? o = new $$
+    }
+}";
+            var expectedMark = @"
+class Program
+{
+    void Bar()
+    {
+        object? o = new object();
+    }
+}";
+            await VerifyProviderCommitAsync(markup, "object", expectedMark, commitChar: ';');
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CreateStringAsLocalAndCommitWithSemicolon()
+        {
+            var markup = @"
+class Program
+{
+    void Bar()
+    {
+        string o = new $$
+    }
+}";
+            var expectedMark = @"
+class Program
+{
+    void Bar()
+    {
+        string o = new string();
+    }
+}";
+            await VerifyProviderCommitAsync(markup, "string", expectedMark, commitChar: ';');
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CreateGenericListAsLocalAndCommitWithSemicolon()
+        {
+            var markup = @"
+using System.Collections.Generic;
+class Program
+{
+    void Bar()
+    {
+        List<int> o = new $$
+    }
+}";
+            var expectedMark = @"
+using System.Collections.Generic;
+class Program
+{
+    void Bar()
+    {
+        List<int> o = new List<int>();
+    }
+}";
+            await VerifyProviderCommitAsync(markup, "List<int>", expectedMark, commitChar: ';');
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CreateGenericListAsFieldAndCommitWithSemicolon()
+        {
+            var markup = @"
+using System.Collections.Generic;
+class Program
+{
+    private List<int> o = new $$
+}";
+            var expectedMark = @"
+using System.Collections.Generic;
+class Program
+{
+    private List<int> o = new List<int>();
+}";
+            await VerifyProviderCommitAsync(markup, "List<int>", expectedMark, commitChar: ';');
+        }
     }
 }

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

@@ -10759,6 +10759,186 @@ await VerifyItemIsAbsentAsync(
                 matchingFilters: new List<CompletionFilter> { FilterSet.LocalAndParameterFilter });
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CompletionWithSemicolonForMethod()
+        {
+            var markup = @"
+class Program
+{
+    private void Bar()
+    {
+        F$$
+    }
+
+    private void Foo(int i)
+    {
+    }
+
+    private void Foo(int i, int c)
+    {
+    }
+}";
+            var expected = @"
+class Program
+{
+    private void Bar()
+    {
+        Foo();
+    }
+
+    private void Foo(int i)
+    {
+    }
+
+    private void Foo(int i, int c)
+    {
+    }
+}";
+            await VerifyProviderCommitAsync(markup, "Foo", expected, commitChar: ';');
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CompletionWithSemicolonInNestedMethod()
+        {
+            var markup = @"
+class Program
+{
+    private void Bar()
+    {
+        Foo(F$$);
+    }
+
+    private int Foo(int i)
+    {
+        return 1;
+    }
+}";
+            var expected = @"
+class Program
+{
+    private void Bar()
+    {
+        Foo(Foo(););
+    }
+
+    private int Foo(int i)
+    {
+        return 1;
+    }
+}";
+            await VerifyProviderCommitAsync(markup, "Foo", expected, commitChar: ';');
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CompletionWithSemicolonForDelegateInferredType()
+        {
+            var markup = @"
+using System;
+class Program
+{
+    private void Bar()
+    {
+        Bar2(F$$);
+    }
+
+    private void Foo()
+    {
+    }
+
+    void Bar2(Action t) { }
+}";
+            var expected = @"
+using System;
+class Program
+{
+    private void Bar()
+    {
+        Bar2(Foo;);
+    }
+
+    private void Foo()
+    {
+    }
+
+    void Bar2(Action t) { }
+}";
+            await VerifyProviderCommitAsync(markup, "Foo", expected, commitChar: ';');
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CompletionWithSemicolonForConstructor()
+        {
+            var markup = @"
+class Program
+{
+    private static void Bar()
+    {
+        var o = new P$$
+    }
+}";
+            var expected = @"
+class Program
+{
+    private static void Bar()
+    {
+        var o = new Program();
+    }
+}";
+            await VerifyProviderCommitAsync(markup, "Program", expected, commitChar: ';');
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CompletionWithSemicolonForTypeUnderNonObjectCreationContext()
+        {
+            var markup = @"
+class Program
+{
+    private static void Bar()
+    {
+        var o = P$$
+    }
+}";
+            var expected = @"
+class Program
+{
+    private static void Bar()
+    {
+        var o = Program;
+    }
+}";
+            await VerifyProviderCommitAsync(markup, "Program", expected, commitChar: ';');
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task CompletionWithSemicolonForAliasConstructor()
+        {
+            var markup = @"
+using String2 = System.String;
+namespace Bar1
+{
+    class Program
+    {
+        private static void Bar()
+        {
+            var o = new S$$
+        }
+    }
+}";
+            var expected = @"
+using String2 = System.String;
+namespace Bar1
+{
+    class Program
+    {
+        private static void Bar()
+        {
+            var o = new String2();
+        }
+    }
+}";
+            await VerifyProviderCommitAsync(markup, "String2", expected, commitChar: ';');
+        }
+
         [WorkItem(49072, "https://github.com/dotnet/roslyn/issues/49072")]
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
         public async Task EnumMemberAfterPatternMatch()