Semantic Snippets: Console snippet first look

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/Snippets/CSharpConsoleSnippetCompletionProviderTests.cs

@@ -0,0 +1,351 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Completion.CompletionProviders.Snippets;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Completion.CompletionProviders.Snippets
+{
+    public class CSharpConsoleSnippetCompletionProviderTests : AbstractCSharpCompletionProviderTests
+    {
+        internal override Type GetCompletionProviderType()
+            => typeof(CSharpSnippetCompletionProvider);
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertConsoleSnippetInMethodTest()
+        {
+            var markupBeforeCommit =
+@"class Program
+{
+    public void Method()
+    {
+        Wr$$
+    }
+}";
+
+            var expectedCodeAfterCommit =
+@"class Program
+{
+    public void Method()
+    {
+        Console.WriteLine($$);
+    }
+}";
+            await VerifyCustomCommitProviderAsync(markupBeforeCommit, "Write to the Console", expectedCodeAfterCommit);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertAsyncConsoleSnippetTest()
+        {
+            var markupBeforeCommit =
+@"class Program
+{
+    public async Task MethodAsync()
+    {
+        Wr$$
+    }
+}";
+
+            var expectedCodeAfterCommit =
+@"class Program
+{
+    public async Task MethodAsync()
+    {
+        await Console.Out.WriteLineAsync($$);
+    }
+}";
+            await VerifyCustomCommitProviderAsync(markupBeforeCommit, "Write to the Console", expectedCodeAfterCommit);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertConsoleSnippetGlobalTest()
+        {
+            var markupBeforeCommit =
+@"
+$$
+class Program
+{
+    public async Task MethodAsync()
+    {
+    }
+}";
+
+            var expectedCodeAfterCommit =
+@"
+Console.WriteLine($$);
+class Program
+{
+    public async Task MethodAsync()
+    {
+    }
+}";
+            await VerifyCustomCommitProviderAsync(markupBeforeCommit, "Write to the Console", expectedCodeAfterCommit);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NoConsoleSnippetInBlockNamespaceTest()
+        {
+            var markupBeforeCommit =
+@"
+namespace Namespace
+{
+    $$
+    class Program
+    {
+        public async Task MethodAsync()
+        {
+        }
+    }
+}";
+            await VerifyItemIsAbsentAsync(markupBeforeCommit, "Write to the Console");
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NoConsoleSnippetInFileScopedNamespaceTest()
+        {
+            var markupBeforeCommit =
+@"
+namespace Namespace;
+$$
+class Program
+{
+    public async Task MethodAsync()
+    {
+    }
+}
+";
+            await VerifyItemIsAbsentAsync(markupBeforeCommit, "Write to the Console");
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertConsoleSnippetInConstructorTest()
+        {
+            var markupBeforeCommit =
+@"class Program
+{
+    public Program()
+    {
+        var x = 5;
+        $$
+    }
+}";
+
+            var expectedCodeAfterCommit =
+@"class Program
+{
+    public Program()
+    {
+        var x = 5;
+        Console.WriteLine($$);
+    }
+}";
+            await VerifyCustomCommitProviderAsync(markupBeforeCommit, "Write to the Console", expectedCodeAfterCommit);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertConsoleSnippetInLocalFunctionTest()
+        {
+            var markupBeforeCommit =
+@"class Program
+{
+    public void Method()
+    {
+        var x = 5;
+        void LocalMethod()
+        {
+            $$
+        }
+    }
+}";
+
+            var expectedCodeAfterCommit =
+@"class Program
+{
+    public void Method()
+    {
+        var x = 5;
+        void LocalMethod()
+        {
+            Console.WriteLine($$);
+        }
+    }
+}";
+            await VerifyCustomCommitProviderAsync(markupBeforeCommit, "Write to the Console", expectedCodeAfterCommit);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertConsoleSnippetInAnonymousFunctionTest()
+        {
+            var markupBeforeCommit =
+@"
+public delegate void Print(int value);
+
+static void Main(string[] args)
+{
+    Print print = delegate(int val) {
+        $$
+    };
+
+}";
+
+            var expectedCodeAfterCommit =
+@"
+public delegate void Print(int value);
+
+static void Main(string[] args)
+{
+    Print print = delegate(int val) {
+        Console.WriteLine($$);
+    };
+
+}";
+            await VerifyCustomCommitProviderAsync(markupBeforeCommit, "Write to the Console", expectedCodeAfterCommit);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertConsoleSnippetInParenthesizedLambdaExpressionTest()
+        {
+            var markupBeforeCommit =
+@"
+Func<int, int, bool> testForEquality = (x, y) =>
+{
+    $$
+    return x == y;
+};";
+
+            var expectedCodeAfterCommit =
+@"
+Func<int, int, bool> testForEquality = (x, y) =>
+{
+    Console.WriteLine($$);
+    return x == y;
+};";
+            await VerifyCustomCommitProviderAsync(markupBeforeCommit, "Write to the Console", expectedCodeAfterCommit);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NoConsoleSnippetInSwitchExpression()
+        {
+            var markupBeforeCommit =
+@"class Program
+{
+    public void Method()
+    {
+       var operation = 2;  
+
+        var result = operation switch  
+        {
+            $$
+            1 => ""Case 1"",  
+            2 => ""Case 2"",  
+            3 => ""Case 3"",  
+            4 => ""Case 4"",  
+        };
+    }
+}";
+            await VerifyItemIsAbsentAsync(markupBeforeCommit, "Write to the Console");
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NoConsoleSnippetInSingleLambdaExpression()
+        {
+            var markupBeforeCommit =
+@"class Program
+{
+    public void Method()
+    {
+       Func<int, int> f = x => $$;
+    }
+}";
+            await VerifyItemIsAbsentAsync(markupBeforeCommit, "Write to the Console");
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NoConsoleSnippetInStringTest()
+        {
+            var markupBeforeCommit =
+@"class Program
+{
+    public void Method()
+    {
+        var str = ""$$"";
+    }
+}";
+
+            await VerifyItemIsAbsentAsync(markupBeforeCommit, "Write to the Console");
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NoConsoleSnippetInObjectInitializerTest()
+        {
+            var markupBeforeCommit =
+@"class Program
+{
+    public void Method()
+    {
+        var str = new Test($$);
+    }
+}
+
+class Test
+{
+    private string val;
+
+    public Test(string val)
+    {
+        this.val = val;
+    }
+}";
+
+            await VerifyItemIsAbsentAsync(markupBeforeCommit, "Write to the Console");
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NoConsoleSnippetInParameterListTest()
+        {
+            var markupBeforeCommit =
+@"class Program
+{
+    public void Method(int x, $$)
+    {
+    }
+}";
+
+            await VerifyItemIsAbsentAsync(markupBeforeCommit, "Write to the Console");
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NoConsoleSnippetInRecordDeclarationTest()
+        {
+            var markupBeforeCommit =
+@"public record Person
+{
+    $$
+    public string FirstName { get; init; } = default!;
+    public string LastName { get; init; } = default!;
+};";
+
+            await VerifyItemIsAbsentAsync(markupBeforeCommit, "Write to the Console");
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task NoConsoleSnippetInVariableDeclarationTest()
+        {
+            var markupBeforeCommit =
+@"class Program
+{
+    public void Method()
+    {
+        var x = $$
+    }
+}";
+
+            await VerifyItemIsAbsentAsync(markupBeforeCommit, "Write to the Console");
+        }
+    }
+}

src/Features/CSharp/Portable/Completion/CompletionProviders/Snippets/CSharpSnippetCompletionProvider.cs

@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Composition;
+using Microsoft.CodeAnalysis.Completion;
+using Microsoft.CodeAnalysis.Completion.Providers.Snippets;
+using Microsoft.CodeAnalysis.CSharp.Completion.Providers;
+using Microsoft.CodeAnalysis.Host.Mef;
+
+namespace Microsoft.CodeAnalysis.CSharp.Completion.CompletionProviders.Snippets
+{
+    [ExportCompletionProvider(nameof(CSharpSnippetCompletionProvider), LanguageNames.CSharp)]
+    [ExtensionOrder(After = nameof(FirstBuiltInCompletionProvider))]
+    [Shared]
+    internal class CSharpSnippetCompletionProvider : AbstractSnippetCompletionProvider
+    {
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public CSharpSnippetCompletionProvider()
+        {
+
+        }
+
+        internal override string Language => LanguageNames.CSharp;
+    }
+}