Fix #3710 (#3714)

* diagnostics for missing subcommand parameters

* fix #3710

* rename local

Author: jonsequitur

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

@@ -19,8 +19,10 @@ public ConnectJupyterKernel(string connectedKernelName) : base(connectedKernelNa
 
     public string InitScript { get; set; }
 
+    [JsonPropertyName("url")]
     public string TargetUrl { get; set; }
-    
+
+    [JsonPropertyName("bearer")]
     public bool UseBearerAuth { get; set; }
 
     public string Token { get; set; }

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

@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using Microsoft.DotNet.Interactive.Connection;
@@ -31,7 +31,10 @@ public ConnectJupyterKernelDirective() : base("jupyter", "Connects a Jupyter ker
         };
 
     public KernelDirectiveParameter InitScriptParameter { get; } =
-        new("--init-script", "Script to run on kernel initialization");
+        new("--init-script", "Script to run on kernel initialization")
+        {
+            TypeHint = "file"
+        };
 
     public ConnectJupyterKernelDirective AddConnectionOptions(IJupyterKernelConnectionOptions connectionOptions)
     {

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

@@ -299,6 +299,38 @@ public void When_the_value_for_a_required_parameter_is_missing_then_an_error_is_
                 .Be("Missing value for required parameter '--required'");
         }
 
+        [Fact]
+        public void When_a_required_parameter_on_a_subcommand_is_missing_then_an_error_is_produced()
+        {
+            var tree = Parse("#!connect jupyter --kernel-spec .net-csharp");
+
+            tree.RootNode
+                .GetDiagnostics()
+                .Should()
+                .ContainSingle()
+                .Which
+                .GetMessage()
+                .Should()
+                .Be("Missing required parameter '--kernel-name'");
+        }
+
+        [Theory]
+        [InlineData("#!connect jupyter --kernel-spec .net-csharp --kernel-name")]
+        [InlineData("#!connect jupyter --kernel-name --kernel-spec .net-csharp")]
+        public void When_the_value_for_a_required_parameter_on_a_subcommand_is_missing_then_an_error_is_produced(string code)
+        {
+            var tree = Parse(code);
+
+            tree.RootNode
+                .GetDiagnostics()
+                .Should()
+                .ContainSingle()
+                .Which
+                .GetMessage()
+                .Should()
+                .Be("Missing value for required parameter '--kernel-name'");
+        }
+
         [Theory]
         [InlineData("""
                     "just a JSON string"

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

@@ -3,7 +3,6 @@
 
 using System;
 using System.Linq;
-using System.Threading.Tasks;
 using FluentAssertions;
 using Microsoft.CodeAnalysis;
 using Microsoft.DotNet.Interactive.Directives;

src/Microsoft.DotNet.Interactive/Directives/KernelActionDirective.cs

@@ -11,7 +11,6 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Tags;
 using Microsoft.DotNet.Interactive.Events;
-using Microsoft.DotNet.Interactive.Parsing;
 
 namespace Microsoft.DotNet.Interactive.Directives;
 

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

@@ -47,39 +47,9 @@ internal DirectiveNode(
 
         if (TryGetDirective(out var directive))
         {
-            foreach (var namedParameter in directive.Parameters)
+            foreach (var diagnostic in GetDiagnosticsForMissingParameters(directive, this))
             {
-                if (namedParameter.Required)
-                {
-                    var matchingNodes = ChildNodes.OfType<DirectiveParameterNode>()
-                                                  .Where(p => p.NameNode is null
-                                                                  ? namedParameter.AllowImplicitName
-                                                                  : p.NameNode?.Text == namedParameter.Name)
-                                                  .ToArray();
-
-                    if (!matchingNodes.Any())
-                    {
-                        yield return CreateDiagnostic(
-                            new(PolyglotSyntaxParser.ErrorCodes.MissingRequiredParameter,
-                                "Missing required parameter '{0}'",
-                                DiagnosticSeverity.Error,
-                                namedParameter.Name));
-                    }
-                    else
-                    {
-                        foreach (var parameterNode in matchingNodes)
-                        {
-                            if (parameterNode.ValueNode is null)
-                            {
-                                yield return CreateDiagnostic(
-                                    new(PolyglotSyntaxParser.ErrorCodes.MissingRequiredParameter,
-                                        "Missing value for required parameter '{0}'",
-                                        DiagnosticSeverity.Error,
-                                        namedParameter.Name));
-                            }
-                        }
-                    }
-                }
+                yield return diagnostic;
             }
         }
 
@@ -103,6 +73,46 @@ internal DirectiveNode(
         }
     }
 
+    internal static IEnumerable<CodeAnalysis.Diagnostic> GetDiagnosticsForMissingParameters(
+        KernelDirective directive,
+        SyntaxNode node)
+    {
+        foreach (var namedParameter in directive.Parameters)
+        {
+            if (namedParameter.Required)
+            {
+                var matchingNodes = node.ChildNodes.OfType<DirectiveParameterNode>()
+                                        .Where(p => p.NameNode is null
+                                                        ? namedParameter.AllowImplicitName
+                                                        : p.NameNode?.Text == namedParameter.Name)
+                                        .ToArray();
+
+                if (!matchingNodes.Any())
+                {
+                    yield return node.CreateDiagnostic(
+                        new(PolyglotSyntaxParser.ErrorCodes.MissingRequiredParameter,
+                            "Missing required parameter '{0}'",
+                            DiagnosticSeverity.Error,
+                            namedParameter.Name));
+                }
+                else
+                {
+                    foreach (var parameterNode in matchingNodes)
+                    {
+                        if (parameterNode.ValueNode is null)
+                        {
+                            yield return node.CreateDiagnostic(
+                                new(PolyglotSyntaxParser.ErrorCodes.MissingRequiredParameter,
+                                    "Missing value for required parameter '{0}'",
+                                    DiagnosticSeverity.Error,
+                                    namedParameter.Name));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     public bool TryGetActionDirective(out KernelActionDirective directive)
     {
         if (GetKernelInfo() is { } kernelInfo)

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

@@ -2,7 +2,9 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 #nullable enable
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.DotNet.Interactive.Directives;
 
@@ -36,6 +38,22 @@ public void Add(DirectiveParameterValueNode node)
         HasParameters = true;
     }
 
+    public override IEnumerable<CodeAnalysis.Diagnostic> GetDiagnostics()
+    {
+        foreach (var diagnostic in base.GetDiagnostics())
+        {
+            yield return diagnostic;
+        }
+
+        if (TryGetSubcommand(out var directive))
+        {
+            foreach (var diagnostic in DirectiveNode.GetDiagnosticsForMissingParameters(directive, this))
+            {
+                yield return diagnostic;
+            }
+        }
+    }
+
     public bool TryGetSubcommand([NotNullWhen(true)] out KernelActionDirective? subcommandDirective)
     {
         if (Parent is DirectiveNode parentDirectiveNode)