add completion item snippet mode

src/Microsoft.DotNet.Interactive.ApiCompatibility.Tests/ApiCompatibilityTests.Interactive_api_is_not_changed.approved.txt

@@ -492,11 +492,12 @@ Microsoft.DotNet.Interactive.Events
     public System.String Code { get;}
     public System.String ToString()
   public class CompletionItem
-    .ctor(System.String displayText, System.String kind, System.String filterText = null, System.String sortText = null, System.String insertText = null, System.String documentation = null)
+    .ctor(System.String displayText, System.String kind, System.String filterText = null, System.String sortText = null, System.String insertText = null, System.Nullable<InsertTextFormat> insertTextFormat = null, System.String documentation = null)
     public System.String DisplayText { get;}
     public System.String Documentation { get; set;}
     public System.String FilterText { get;}
     public System.String InsertText { get;}
+    public System.Nullable<InsertTextFormat> InsertTextFormat { get;}
     public System.String Kind { get;}
     public System.String SortText { get;}
     public System.String ToString()
@@ -532,6 +533,9 @@ Microsoft.DotNet.Interactive.Events
     public Microsoft.DotNet.Interactive.LinePositionSpan LinePositionSpan { get;}
   public class IncompleteCodeSubmissionReceived : KernelEvent
     .ctor(Microsoft.DotNet.Interactive.Commands.SubmitCode submitCode)
+  public enum InsertTextFormat : System.Enum, System.IComparable, System.IConvertible, System.IFormattable
+    PlainText=1
+    Snippet=2
   public abstract class KernelEvent
     public Microsoft.DotNet.Interactive.Commands.KernelCommand Command { get;}
     public System.String ToString()

src/Microsoft.DotNet.Interactive.CSharp/CompletionExtensions.cs

@@ -51,13 +51,37 @@ public static string GetKind(this RoslynCompletionItem completionItem)
 
         public static CompletionItem ToModel(this RoslynCompletionItem item, RoslynCompletionDescription description)
         {
+            var isGeneric =
+                item.Properties.TryGetValue("IsGeneric", out var isGenericProperty) &&
+                bool.TryParse(isGenericProperty, out var isGenericResult) &&
+                isGenericResult;
+
+            var isMethod =
+                item.Tags.Contains(WellKnownTags.Method) ||
+                item.Tags.Contains(WellKnownTags.ExtensionMethod);
+
+            var (displayTextSuffix, insertTextSuffix) = (isGeneric, isMethod) switch
+            {
+                (true, true) => ("<>", "<$1>($2)"),
+                (true, false) => ("<>", "<$1>"),
+                (false, true) => ("", "($1)"),
+                (false, false) => ("", ""),
+            };
+
+            var displayText = item.DisplayText + displayTextSuffix;
+            var insertText = item.FilterText + insertTextSuffix;
+
+            InsertTextFormat? insertTextFormat = isGeneric || isMethod
+                ? InsertTextFormat.Snippet
+                : null;
             return new CompletionItem(
-                displayText: item.DisplayText,
+                displayText: displayText,
                 kind: item.GetKind(),
                 filterText: item.FilterText,
                 sortText: item.SortText,
-                insertText: item.FilterText,
+                insertText: insertText,
+                insertTextFormat: insertTextFormat,
                 documentation: description.Text);
         }
     }
-}
+}

src/Microsoft.DotNet.Interactive.CSharpProject/CSharpProjectKernel.cs

@@ -153,7 +153,13 @@ public async Task HandleAsync(RequestCompletions command, KernelInvocationContex
             var updatedWorkspace = await GetWorkspaceWithCode(command.Code, position);
             var request = new Protocol.WorkspaceRequest(updatedWorkspace, _buffer.Id);
             var completionResult = await _workspaceServer.GetCompletionList(request, new Budget());
-            var completionItems = completionResult.Items.Select(item => new CompletionItem(item.DisplayText, item.Kind, item.FilterText, item.SortText, item.InsertText, item.Documentation?.Value)).ToList();
+            var completionItems = completionResult.Items.Select(item => new CompletionItem(
+                displayText: item.DisplayText,
+                kind: item.Kind,
+                filterText: item.FilterText,
+                sortText: item.SortText,
+                insertText: item.InsertText,
+                documentation: item.Documentation?.Value)).ToList();
 
             context.Publish(new CompletionsProduced(completionItems, command));
         }

src/Microsoft.DotNet.Interactive.FSharp/FSharpKernel.fs

@@ -157,7 +157,13 @@ type FSharpKernel () as this =
             let kind = getKindString declarationItem.Glyph
             let filterText = getFilterText declarationItem
             let! documentation = getDocumentation declarationItem
-            return CompletionItem(declarationItem.Name, kind, filterText=filterText, documentation=documentation, insertText=declarationItem.NameInCode)
+            let isMethod =
+                match declarationItem.Kind with
+                | CompletionItemKind.Method _ -> true
+                | _ -> false
+            let insertTextSuffix = if isMethod then "($1)" else ""
+            let insertTextFormat = if isMethod then System.Nullable(InsertTextFormat.Snippet) else System.Nullable<InsertTextFormat>()
+            return CompletionItem(declarationItem.Name, kind, filterText=filterText, documentation=documentation, insertText=declarationItem.NameInCode + insertTextSuffix, insertTextFormat=insertTextFormat)
         }
 
     let getDiagnostic (error: FSharpDiagnostic) =

src/Microsoft.DotNet.Interactive.SqlServer/ToolsServiceClient.cs

@@ -139,12 +139,12 @@ public async Task<IEnumerable<CompletionItem>> ProvideCompletionItemsAsync(Uri f
             return sqlCompletionItems.Select(item =>
             {
                 return new CompletionItem(
-                    item.Label,
-                    item.Kind is not null ? Enum.GetName(typeof(SqlCompletionItemKind), item.Kind) : string.Empty,
-                    item.FilterText,
-                    item.SortText,
-                    item.InsertText,
-                    item.Documentation);
+                    displayText: item.Label,
+                    kind: item.Kind is not null ? Enum.GetName(typeof(SqlCompletionItemKind), item.Kind) : string.Empty,
+                    filterText: item.FilterText,
+                    sortText: item.SortText,
+                    insertText: item.InsertText,
+                    documentation: item.Documentation);
             });
         }
 

src/Microsoft.DotNet.Interactive.Tests/LanguageServices/CompletionTests.cs

@@ -459,5 +459,153 @@ public async Task fsharp_completions_can_read_doc_comments_from_nuget_packages()
                 .Should()
                 .ContainSingle(ci => !string.IsNullOrEmpty(ci.Documentation) && ci.Documentation.Contains("Represents JavaScript's null as a string. This field is read-only."));
         }
+
+        [Theory]
+        [InlineData(Language.CSharp)]
+        [InlineData(Language.FSharp)]
+        public async Task Property_completions_are_returned_as_plain_text(Language language)
+        {
+            var kernel = CreateKernel(language);
+
+            var markupCode = "Console.Ou$$";
+
+            MarkupTestFile.GetLineAndColumn(markupCode, out var code, out var line, out var character);
+
+            await kernel.SendAsync(new RequestCompletions(code, new LinePosition(line, character)));
+
+            KernelEvents
+                .Should()
+                .ContainSingle<CompletionsProduced>()
+                .Which
+                .Completions
+                .Should()
+                .Contain(item =>
+                    item.DisplayText == "Out" &&
+                    item.InsertText == "Out" &&
+                    item.InsertTextFormat == null);
+        }
+
+        [Theory]
+        [InlineData(Language.CSharp)]
+        [InlineData(Language.FSharp)]
+        public async Task Method_completions_are_returned_as_a_snippet(Language language)
+        {
+            var kernel = CreateKernel(language);
+
+            var markupCode = "Console.Wri$$";
+
+            MarkupTestFile.GetLineAndColumn(markupCode, out var code, out var line, out var character);
+
+            await kernel.SendAsync(new RequestCompletions(code, new LinePosition(line, character)));
+
+            KernelEvents
+                .Should()
+                .ContainSingle<CompletionsProduced>()
+                .Which
+                .Completions
+                .Should()
+                .Contain(item =>
+                    item.DisplayText == "WriteLine" &&
+                    item.InsertText == "WriteLine($1)" &&
+                    item.InsertTextFormat == InsertTextFormat.Snippet);
+        }
+
+        [Fact]
+        public async Task FSharp_module_functions_are_returned_as_plain_text()
+        {
+            var kernel = CreateKernel(Language.FSharp);
+
+            var markupCode = "[1;2;3] |> List.ma$$";
+
+            MarkupTestFile.GetLineAndColumn(markupCode, out var code, out var line, out var character);
+
+            await kernel.SendAsync(new RequestCompletions(code, new LinePosition(line, character)));
+
+            KernelEvents
+                .Should()
+                .ContainSingle<CompletionsProduced>()
+                .Which
+                .Completions
+                .Should()
+                .Contain(item =>
+                    item.DisplayText == "map" &&
+                    item.InsertText == "map" &&
+                    item.InsertTextFormat == null);
+        }
+
+        [Fact]
+        public async Task CSharp_generic_method_completions_are_returned_as_a_snippet()
+        {
+            // in general F# prefers to infer generic types, not specify them
+
+            var kernel = CreateKernel(Language.CSharp);
+
+            var markupCode = "System.Array.Emp$$";
+
+            MarkupTestFile.GetLineAndColumn(markupCode, out var code, out var line, out var character);
+
+            await kernel.SendAsync(new RequestCompletions(code, new LinePosition(line, character)));
+
+            KernelEvents
+                .Should()
+                .ContainSingle<CompletionsProduced>()
+                .Which
+                .Completions
+                .Should()
+                .Contain(item =>
+                    item.DisplayText == "Empty<>" &&
+                    item.InsertText == "Empty<$1>($2)" &&
+                    item.InsertTextFormat == InsertTextFormat.Snippet);
+        }
+
+        [Theory]
+        [InlineData(Language.CSharp)]
+        [InlineData(Language.FSharp)]
+        public async Task Non_generic_type_completions_are_returned_as_plain_text(Language language)
+        {
+            var kernel = CreateKernel(language);
+
+            var markupCode = "System.Cons$$";
+
+            MarkupTestFile.GetLineAndColumn(markupCode, out var code, out var line, out var character);
+
+            await kernel.SendAsync(new RequestCompletions(code, new LinePosition(line, character)));
+
+            KernelEvents
+                .Should()
+                .ContainSingle<CompletionsProduced>()
+                .Which
+                .Completions
+                .Should()
+                .Contain(item =>
+                    item.DisplayText == "Console" &&
+                    item.InsertText == "Console" &&
+                    item.InsertTextFormat == null);
+        }
+
+        [Fact]
+        public async Task CSharp_generic_type_completions_are_returned_as_a_snippet()
+        {
+            // in general F# prefers to infer generic types, not specify them
+
+            var kernel = CreateKernel(Language.CSharp);
+
+            var markupCode = "System.Collections.Generic.IEnu$$";
+
+            MarkupTestFile.GetLineAndColumn(markupCode, out var code, out var line, out var character);
+
+            await kernel.SendAsync(new RequestCompletions(code, new LinePosition(line, character)));
+
+            KernelEvents
+                .Should()
+                .ContainSingle<CompletionsProduced>()
+                .Which
+                .Completions
+                .Should()
+                .Contain(item =>
+                    item.DisplayText == "IEnumerable<>" &&
+                    item.InsertText == "IEnumerable<$1>" &&
+                    item.InsertTextFormat == InsertTextFormat.Snippet);
+        }
     }
 }

src/Microsoft.DotNet.Interactive.Tests/Server/SerializationTests.Event_contract_has_not_been_broken.approved.CompletionsProduced.json

@@ -1 +1 @@
-{"event":{"linePositionSpan":null,"completions":[{"displayText":"WriteLine","kind":"Method","filterText":"WriteLine","sortText":"WriteLine","insertText":"WriteLine","documentation":"Writes the line"}]},"eventType":"CompletionsProduced","command":{"token":"the-token","id":"command-id","commandType":"RequestCompletions","command":{"code":"Console.Wri","linePosition":{"line":0,"character":11},"targetKernelName":null},"originUri":"","destinationUri":""}}
+{"event":{"linePositionSpan":null,"completions":[{"displayText":"WriteLine","kind":"Method","filterText":"WriteLine","sortText":"WriteLine","insertText":"WriteLine","insertTextFormat":"snippet","documentation":"Writes the line"}]},"eventType":"CompletionsProduced","command":{"token":"the-token","id":"command-id","commandType":"RequestCompletions","command":{"code":"Console.Wri","linePosition":{"line":0,"character":11},"targetKernelName":null},"originUri":"","destinationUri":""}}

src/Microsoft.DotNet.Interactive.Tests/Server/SerializationTests.cs

@@ -291,12 +291,13 @@ IEnumerable<KernelEvent> events()
                     new[]
                     {
                         new CompletionItem(
-                            "WriteLine",
-                            "Method",
-                            "WriteLine",
-                            "WriteLine",
-                            "WriteLine",
-                            "Writes the line")
+                            displayText: "WriteLine",
+                            kind: "Method",
+                            filterText: "WriteLine",
+                            sortText: "WriteLine",
+                            insertText: "WriteLine",
+                            insertTextFormat: InsertTextFormat.Snippet,
+                            documentation: "Writes the line")
                     },
                     requestCompletion);
 

src/Microsoft.DotNet.Interactive/Events/CompletionItem.cs

@@ -7,13 +7,14 @@ namespace Microsoft.DotNet.Interactive.Events
 {
     public class CompletionItem
     {
-        public CompletionItem(string displayText, string kind, string filterText = null, string sortText = null, string insertText = null, string documentation = null)
+        public CompletionItem(string displayText, string kind, string filterText = null, string sortText = null, string insertText = null, InsertTextFormat? insertTextFormat = null, string documentation = null)
         {
             DisplayText = displayText ?? throw new ArgumentNullException(nameof(displayText));
             Kind = kind ?? throw new ArgumentException(nameof(kind));
             FilterText = filterText;
             SortText = sortText;
             InsertText = insertText;
+            InsertTextFormat = insertTextFormat;
             Documentation = documentation;
         }
 
@@ -27,6 +28,8 @@ public CompletionItem(string displayText, string kind, string filterText = null,
 
         public string InsertText { get; }
 
+        public InsertTextFormat? InsertTextFormat { get; }
+
         public string Documentation { get; set; }
 
         public override string ToString() => DisplayText;

src/Microsoft.DotNet.Interactive/Events/InsertTextFormat.cs

@@ -0,0 +1,8 @@
+namespace Microsoft.DotNet.Interactive.Events
+{
+    public enum InsertTextFormat
+    {
+        PlainText = 1,
+        Snippet = 2,
+    }
+}

src/dotnet-interactive-vscode-common/src/languageProvider.ts

@@ -27,11 +27,12 @@ export class CompletionItemProvider implements vscode.CompletionItemProvider {
             }
             const completionItems: Array<vscode.CompletionItem> = [];
             for (const item of result.completions) {
+                const insertText: string | vscode.SnippetString = item.insertTextFormat === 'snippet' ? new vscode.SnippetString(item.insertText) : item.insertText;
                 const vscodeItem: vscode.CompletionItem = {
                     label: item.displayText,
                     documentation: item.documentation,
                     filterText: item.filterText,
-                    insertText: item.insertText,
+                    insertText: insertText,
                     sortText: item.sortText,
                     range: range,
                     kind: this.mapCompletionItem(item.kind)

src/microsoft-dotnet-interactive/src/contracts.ts

@@ -381,9 +381,15 @@ export interface CompletionItem {
     filterText: string;
     sortText: string;
     insertText: string;
+    insertTextFormat?: InsertTextFormat;
     documentation: string;
 }
 
+export enum InsertTextFormat {
+    PlainText = "plaintext",
+    Snippet = "snippet",
+}
+
 export interface Diagnostic {
     linePositionSpan: LinePositionSpan;
     severity: DiagnosticSeverity;