Handle global flags appearing in subcommands

Kong allows global flags to appear in the subcommand. From the point of
view of `complete`, *all* flags are global flags.

However, in the custom PositionalPredictor, we were only handling flags
at the current level - causing us to skip over, and get the wrong
predictor in this case. This can be resolved by tracking all parent args
as well.

Signed-off-by: Justin Chadwell <me@jedevc.com>

Author: jedevc

prediction.go

@@ -2,6 +2,7 @@ package kongcompletion
 
 import (
 	"fmt"
+	"slices"
 
 	"github.com/alecthomas/kong"
 	"github.com/posener/complete"
@@ -89,7 +90,7 @@ func Command(parser *kong.Kong, opt ...Option) (complete.Command, error) {
 	if parser == nil || parser.Model == nil {
 		return complete.Command{}, nil
 	}
-	command, err := nodeCommand(parser.Model.Node, opts, nil)
+	command, err := nodeCommand(parser.Model.Node, opts, nil, flags{})
 	if err != nil {
 		return complete.Command{}, err
 	}
@@ -126,7 +127,12 @@ func Register(parser *kong.Kong, opt ...Option) {
 	}
 }
 
-func nodeCommand(node *kong.Node, opts *options, vars kong.Vars) (*complete.Command, error) {
+type flags struct {
+	argFlags  []*kong.Flag
+	boolFlags []*kong.Flag
+}
+
+func nodeCommand(node *kong.Node, opts *options, vars kong.Vars, flags flags) (*complete.Command, error) {
 	if node == nil {
 		return nil, nil
 	}
@@ -137,11 +143,15 @@ func nodeCommand(node *kong.Node, opts *options, vars kong.Vars) (*complete.Comm
 		GlobalFlags: complete.Flags{},
 	}
 
+	boolFlags, argFlags := boolAndNonBoolFlags(node.Flags)
+	flags.boolFlags = append(slices.Clone(flags.boolFlags), boolFlags...)
+	flags.argFlags = append(slices.Clone(flags.argFlags), argFlags...)
+
 	for _, child := range node.Children {
 		if child == nil || child.Hidden {
 			continue
 		}
-		childCmd, err := nodeCommand(child, opts, vars)
+		childCmd, err := nodeCommand(child, opts, vars, flags)
 		if err != nil {
 			return nil, err
 		}
@@ -166,15 +176,14 @@ func nodeCommand(node *kong.Node, opts *options, vars kong.Vars) (*complete.Comm
 		}
 	}
 
-	boolFlags, nonBoolFlags := boolAndNonBoolFlags(node.Flags)
 	pps, err := positionalPredictors(node.Positional, opts.predictors, vars)
 	if err != nil {
 		return nil, err
 	}
 	cmd.Args = &PositionalPredictor{
 		Predictors: pps,
-		ArgFlags:   flagNamesWithHyphens(nonBoolFlags...),
-		BoolFlags:  flagNamesWithHyphens(boolFlags...),
+		ArgFlags:   flagNamesWithHyphens(flags.argFlags...),
+		BoolFlags:  flagNamesWithHyphens(flags.boolFlags...),
 	}
 
 	return &cmd, nil

prediction_test.go

@@ -50,6 +50,8 @@ func TestComplete(t *testing.T) {
 			BooFlag  bool   `kong:"name=boofl,short=b"`
 		} `kong:"cmd,set=a=other"`
 		Baz struct{} `kong:"cmd,hidden"`
+
+		Global string `kong:""`
 	}
 
 	for _, td := range []completeTest{
@@ -75,13 +77,13 @@ func TestComplete(t *testing.T) {
 		},
 		{
 			parser: kong.Must(&cli),
-			want:   []string{"--bar", "--baz", "--tata", "--titi", "--xuxu", "--xoxo", "--xixi", "--quz", "--lion", "--help", "-h"},
+			want:   []string{"--bar", "--baz", "--tata", "--titi", "--xuxu", "--xoxo", "--xixi", "--quz", "--lion", "--help", "-h", "--global"},
 			line:   "myApp foo -",
 		},
 		{
 			parser: kong.Must(&cli),
-			want:   []string{"--bar", "--baz", "--tata", "--titi", "--xuxu", "--xoxo", "--xixi", "--quz", "--lion", "--help", "-h"},
-			line:   "myApp foo -",
+			want:   []string{"--bar", "--baz", "--tata", "--titi", "--xuxu", "--xoxo", "--xixi", "--quz", "--lion", "--help", "--global"},
+			line:   "myApp foo --",
 		},
 		{
 			parser: kong.Must(&cli),
@@ -95,7 +97,7 @@ func TestComplete(t *testing.T) {
 		},
 		{
 			parser: kong.Must(&cli),
-			want:   []string{"--bar", "--baz", "--tata", "--titi", "--xuxu", "--xoxo", "--xixi", "--quz", "--lion", "--help", "-h"},
+			want:   []string{"--bar", "--baz", "--tata", "--titi", "--xuxu", "--xoxo", "--xixi", "--quz", "--lion", "--help", "-h", "--global"},
 			line:   "myApp foo --baz -",
 		},
 		{
@@ -125,7 +127,7 @@ func TestComplete(t *testing.T) {
 		},
 		{
 			parser: kong.Must(&cli),
-			want:   []string{"-n", "--number", "--omg", "--help", "-h", "--boofl", "-b"},
+			want:   []string{"-n", "--number", "--omg", "--help", "-h", "--boofl", "-b", "--global"},
 			line:   "myApp bar -",
 		},
 		{
@@ -135,7 +137,7 @@ func TestComplete(t *testing.T) {
 		},
 		{
 			parser: kong.Must(&cli),
-			want:   []string{"-n", "--number", "--omg", "--help", "-h", "--boofl", "-b"},
+			want:   []string{"-n", "--number", "--omg", "--help", "-h", "--boofl", "-b", "--global"},
 			line:   "myApp bar -b thing1 -",
 		},
 		{
@@ -148,6 +150,21 @@ func TestComplete(t *testing.T) {
 			want:   []string{"otherthing1", "otherthing2"},
 			line:   "myApp bar -b thing1 --omg gizzles ",
 		},
+		{
+			parser: kong.Must(&cli),
+			want:   []string{"foo", "bar"},
+			line:   "myApp --global=test ",
+		},
+		{
+			parser: kong.Must(&cli),
+			want:   []string{"rabbit", "duck", "bird"},
+			line:   "myApp foo --global=test ",
+		},
+		{
+			parser: kong.Must(&cli),
+			want:   []string{"thing1", "thing2"},
+			line:   "myApp bar --global=test ",
+		},
 	} {
 		name := td.name
 		if name == "" {