fix a magic command completion case

Author: jonsequitur

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

@@ -98,10 +98,10 @@ This Kernel can compile and execute C# code and display the results.
 
     public ScriptState ScriptState { get; private set; }
 
-    private Task<bool> IsCompleteSubmissionAsync(string code)
+    private bool IsCompleteSubmissionAsync(string code)
     {
         var syntaxTree = SyntaxFactory.ParseSyntaxTree(code, _csharpParseOptions);
-        return Task.FromResult(SyntaxFactory.IsCompleteSubmission(syntaxTree));
+        return SyntaxFactory.IsCompleteSubmission(syntaxTree);
     }
 
     Task IKernelCommandHandler<RequestValueInfos>.HandleAsync(RequestValueInfos command, KernelInvocationContext context)
@@ -257,7 +257,7 @@ async Task IKernelCommandHandler<SubmitCode>.HandleAsync(SubmitCode submitCode,
         context.Publish(codeSubmissionReceived);
 
         var code = submitCode.Code;
-        var isComplete = await IsCompleteSubmissionAsync(submitCode.Code);
+        var isComplete = IsCompleteSubmissionAsync(submitCode.Code);
 
         if (isComplete)
         {

src/Microsoft.DotNet.Interactive.Parsing.Tests/PolyglotSyntaxParserTests.Completions.cs

@@ -81,7 +81,34 @@ public async Task produce_completions_for_parameter_names(string markupCode)
 
                 var completions = await node.GetCompletionsAtPositionAsync(position.Value);
 
-                completions.Select(c => c.DisplayText).Should().Contain(["--kernel-name"]);
+                completions.Select(c => c.DisplayText).Should().Contain("--kernel-name");
+            }
+
+            [Theory]
+            [InlineData("#!connect jupyter --kernel-name asdf $$")]
+            [InlineData("#!connect jupyter --kernel-name @input $$")]
+            [InlineData("""#!connect jupyter --kernel-name @input:{"saveAs":"xyz"} $$""")]
+            [InlineData("#!connect jupyter $$ --kernel-name")]
+            public async Task produce_completions_for_parameter_names_2(string markupCode)
+            {
+                MarkupTestFile.GetPosition(markupCode, out var code, out var position);
+
+                var tree = Parse(code, PolyglotParserConfigurationTests.GetDefaultConfiguration());
+
+                var node = tree.RootNode.FindNode(position.Value)
+                               .AncestorsAndSelf()
+                               .OfType<DirectiveNode>()
+                               .First();
+
+                var completions = await node.GetCompletionsAtPositionAsync(position.Value);
+
+                completions.Select(c => c.DisplayText).Should().Contain([
+                    "--url", 
+                    "--kernel-spec",
+                    "--init-script",
+                    "--conda-env",
+                    "--bearer"
+                ]);
             }
 
             [Fact]

src/Microsoft.DotNet.Interactive/Parsing/DirectiveNode.cs

@@ -568,20 +568,33 @@ public async Task<IReadOnlyList<CompletionItem>> GetCompletionsAtPositionAsync(i
 
             case DirectiveParameterValueNode directiveParameterValueNode:
             {
-                if (directiveParameterValueNode.Parent is DirectiveParameterNode pn &&
-                    currentToken is not { Kind: TokenKind.Whitespace } &&
-                    pn.TryGetParameter(out var parameter))
+                if (directiveParameterValueNode.Parent is DirectiveParameterNode pn)
                 {
-                    var completions = await parameter.GetValueCompletionsAsync();
-                    return completions;
+                    if (currentToken is not { Kind: TokenKind.Whitespace })
+                    {
+                        if (pn.TryGetParameter(out var parameter))
+                        {
+                            var completions = await parameter.GetValueCompletionsAsync();
+                            return completions;
+                        }
+                    }
+                    else
+                    {
+                    }
                 }
 
                 if (TryGetDirective(out var directive))
                 {
-                    // This could also be a partial subcommand, so...
-                    var completions = await directive.GetChildCompletionsAsync();
-
-                    return FilterOutCompletionsWithMaxOccurrencesReached(completions);
+                    if (TryGetSubcommand(directive, out var subcommand))
+                    {
+                        var completions = await subcommand.GetChildCompletionsAsync();
+                        return FilterOutCompletionsWithMaxOccurrencesReached(completions);
+                    }
+                    else
+                    {
+                        var completions = await directive.GetChildCompletionsAsync();
+                        return FilterOutCompletionsWithMaxOccurrencesReached(completions);
+                    }
                 }
             }