Jupyter/fix completion kind

src/Microsoft.DotNet.Interactive.Jupyter.Tests/JupyterKernelTests.cs

@@ -1,4 +1,5 @@
 using FluentAssertions;
+using Microsoft.CodeAnalysis.Text;
 using Microsoft.DotNet.Interactive.Commands;
 using Microsoft.DotNet.Interactive.Events;
 using Microsoft.DotNet.Interactive.Formatting;
@@ -573,4 +574,45 @@ public async Task can_fail_on_completions_status_error()
             .Should()
             .BeEmpty();
     }
+
+    [Fact]
+    public async Task can_translate_completion_item_metadata_for_completions_produce()
+    {
+        var code = "test";
+        var metadata = new Dictionary<string, IReadOnlyList<CompletionResultMetadata>>
+        {
+            {
+                CompletionResultMetadata.Experimental, new[]
+                {
+                    new CompletionResultMetadata(0, 1, "test1-test", "function", "TEST1TEST"),
+                    new CompletionResultMetadata(0, 1, "test2-test", "class", null)
+                }
+            }
+        };
+        var options = new TestJupyterConnectionOptions(GenerateReplies(new[] {
+                Message.CreateReply(new CompleteReply(0, 1, new[] {"test1", "test2"}, metadata, StatusValues.Ok),
+                Message.Create(new CompleteRequest(code, 1))),
+        }));
+
+        var kernel = await CreateJupyterKernelAsync(options);
+
+        var command = new RequestCompletions(code, SourceUtilities.GetPositionFromCursorOffset(code, 1));
+        var result = await kernel.SendAsync(command);
+        var events = result.Events;
+
+        events
+            .Should()
+            .NotContainErrors();
+
+        events
+            .Should()
+            .ContainSingle<CompletionsProduced>()
+            .Which
+            .Completions
+                .Should()
+                .BeEquivalentToRespectingRuntimeTypes(new[] {
+                        new CompletionItem("TEST1TEST", "Method", "test1-test", "test1-test", "test1-test"),
+                        new CompletionItem("test2-test", "Class", "test2-test", "test2-test", "test2-test")
+                    });
+    }
 }

src/Microsoft.DotNet.Interactive.Jupyter/JupyterKernelCommandHandlers.cs

@@ -94,29 +94,56 @@ public async Task HandleAsync(RequestCompletions command, KernelInvocationContex
             return;
         }
 
-        bool metadataAvailable = results.MetaData.TryGetValue(CompletionResultMetadata.Entry, out IReadOnlyList<CompletionResultMetadata> resultsMetadata);
-        if (!metadataAvailable)
+        bool metadataAvailable = results.MetaData.TryGetValue(CompletionResultMetadata.Experimental, out IReadOnlyList<CompletionResultMetadata> resultsMetadata);
+
+        string GetCompletionKind(string type)
         {
-            resultsMetadata = new List<CompletionResultMetadata>();
-        }
+            var kind = type switch
+            {
+                "keyword" => "Keyword",
+                "function" => "Method",
+                "class" => "Class",
+                "instance" => "Field",
+                "module" => "Module",
+                "type" => "Class",
+                "property" => "Property",
+                "field" => "Field",
+                "builtin" => "Method",
+                "builtinfunction" => "Method",
+                "builtinmodule" => "Module",
+                "builtintype" => "Class",
+                "value" => "Variable",
+                "constant" => "Constant",
+                "variable" => "Variable",
+                _ => string.Empty
+            };
+            return kind;
+        };
+
+        var completionItems = metadataAvailable ?
+               resultsMetadata.Select(m =>
+                             new CompletionItem(
+                                 displayText: m.DisplayText ?? m.Text,
+                                 kind: GetCompletionKind(m.Type ?? string.Empty),
+                                 insertText: m.Text,
+                                 filterText: m.Text,
+                                 sortText: m.Text))
+                 : results.Matches.Select(match =>
+                             new CompletionItem(
+                                    displayText: match,
+                                    kind: string.Empty,
+                                    insertText: match,
+                                    filterText: match,
+                                    sortText: match));
 
-        var completionItems = from match in results.Matches
-                              join metadata in resultsMetadata on match equals metadata.Text into ci
-                              from itemMetadata in ci.DefaultIfEmpty()
-                              select new CompletionItem(
-                                  displayText: itemMetadata?.DisplayText ?? match,
-                                  kind: itemMetadata?.Type ?? string.Empty,
-                                  insertText: match,
-                                  filterText: match,
-                                  sortText: match);
 
         var completion = new CompletionsProduced(
             completionItems, command,
             SourceUtilities.GetLinePositionSpanFromStartAndEndIndices(command.Code, results.CursorStart, results.CursorEnd));
 
         context.Publish(completion);
     }
-
+    
     public async Task HandleAsync(SubmitCode command, KernelInvocationContext context)
     {
         CancelCommandOnKernelIfRequested(context);
@@ -126,7 +153,7 @@ public async Task HandleAsync(SubmitCode command, KernelInvocationContext contex
 
         var executeRequest = Messaging.Message.Create(
                                     new ExecuteRequest(
-                                        command.Code.NormalizeLineEndings(), 
+                                        command.Code.NormalizeLineEndings(),
                                         allowStdin: false, // TODO: ZMQ stdin channel is hanging. Disable until a consistent experience can be turned on. 
                                         stopOnError: true));
         var processMessages = Receiver.Messages
@@ -148,7 +175,7 @@ public async Task HandleAsync(SubmitCode command, KernelInvocationContext contex
                                     }
                                 })
                                 .TakeUntil(m => m.MessageType == JupyterMessageContentTypes.Error || (messagesProcessed && results is not null));
-                                // run until kernel idle or until execution is done
+        // run until kernel idle or until execution is done
 
         await Sender.SendAsync(executeRequest);
         await processMessages.ToTask(context.CancellationToken);

src/Microsoft.DotNet.Interactive.Jupyter/Protocol/CompleteReply.cs

@@ -9,7 +9,7 @@ namespace Microsoft.DotNet.Interactive.Jupyter.Protocol;
 public class CompletionResultMetadata
 {
     [JsonIgnore]
-    public static string Entry = "_jupyter_types_experimental";
+    public static string Experimental = "_jupyter_types_experimental";
 
     [JsonPropertyName("end")]
     public int End { get; }