Collapse together Command and Flag into CommandFlag

and drop the querier

Makefile

@@ -1,3 +1,5 @@
+BENCHTIME ?= 10s
+
 .PHONY: all
 all: test
 
@@ -9,6 +11,10 @@ clean:
 test:
 	go test -v -coverprofile=coverage.out ./...
 
+.PHONY: bench
+bench:
+	go test -v -bench . -benchtime $(BENCHTIME) ./...
+
 .PHONY: show-cover
 show-cover:
 	go tool cover -func=coverage.out

README.md

@@ -20,6 +20,7 @@ library [parser](https://pkg.go.dev/go/parser).
 - support both POSIX-y and Windows-y styles
 - build a printable/JSON-able parse tree
 - support rich error reporting
+- support event-like reactive parsing
 
 <!--
 vim:tw=90

argh.go

@@ -1,6 +1,7 @@
 package argh
 
 import (
+	"errors"
 	"fmt"
 	"log"
 	"os"
@@ -11,6 +12,8 @@ import (
 var (
 	tracingEnabled = os.Getenv("ARGH_TRACING") == "enabled"
 	traceLogger    *log.Logger
+
+	Error = errors.New("argh error")
 )
 
 func init() {

argh_test.go

@@ -3,12 +3,26 @@ package argh_test
 import (
 	"flag"
 	"fmt"
+	"strconv"
 	"testing"
 	"time"
 
 	"git.meatballhat.com/x/argh"
 )
 
+func ptrTo[T any](v T) *T {
+	return &v
+}
+
+func ptrFrom[T any](v *T) T {
+	if v != nil {
+		return *v
+	}
+
+	var zero T
+	return zero
+}
+
 func BenchmarkStdlibFlag(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		func() {
@@ -22,7 +36,16 @@ func BenchmarkStdlibFlag(b *testing.B) {
 			uFlag := fl.Uint("u", 11, "")
 			u64Flag := fl.Uint64("u64", 11111111111111111111, "")
 
-			_ = fl.Parse([]string{})
+			_ = fl.Parse([]string{
+				"-ok",
+				"-dur", "42h42m10s",
+				"-f64", "4242424242.42",
+				"-i", "-42",
+				"-i64", "-4242424242",
+				"-s", "the answer",
+				"-u", "42",
+				"-u64", "4242424242",
+			})
 			_ = fmt.Sprint(
 				"fl", fl,
 				"okFlag", *okFlag,
@@ -41,23 +64,118 @@ func BenchmarkStdlibFlag(b *testing.B) {
 func BenchmarkArgh(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		func() {
+			var (
+				okFlag  *bool
+				durFlag *time.Duration
+				f64Flag *float64
+				iFlag   *int
+				i64Flag *int64
+				sFlag   *string
+				uFlag   *uint
+				u64Flag *uint64
+			)
+
 			pCfg := argh.NewParserConfig()
 			pCfg.Prog = &argh.CommandConfig{
 				Flags: &argh.Flags{
 					Map: map[string]argh.FlagConfig{
-						"ok":  {},
-						"dur": {},
-						"f64": {},
-						"i":   {},
-						"i64": {},
-						"s":   {},
-						"u":   {},
-						"u64": {},
+						"ok": {
+							On: func(fl argh.CommandFlag) {
+								okFlag = ptrTo(true)
+							},
+						},
+						"dur": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if pt, err := time.ParseDuration(v); err != nil {
+										durFlag = ptrTo(pt)
+									}
+								}
+							},
+						},
+						"f64": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if f, err := strconv.ParseFloat(v, 64); err == nil {
+										f64Flag = ptrTo(f)
+									}
+								}
+							},
+						},
+						"i": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if i, err := strconv.ParseInt(v, 10, 64); err == nil {
+										iFlag = ptrTo(int(i))
+									}
+								}
+							},
+						},
+						"i64": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if i, err := strconv.ParseInt(v, 10, 64); err == nil {
+										i64Flag = ptrTo(i)
+									}
+								}
+							},
+						},
+						"s": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									sFlag = ptrTo(v)
+								}
+							},
+						},
+						"u": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if u, err := strconv.ParseUint(v, 10, 64); err == nil {
+										uFlag = ptrTo(uint(u))
+									}
+								}
+							},
+						},
+						"u64": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if u, err := strconv.ParseUint(v, 10, 64); err == nil {
+										u64Flag = ptrTo(u)
+									}
+								}
+							},
+						},
 					},
 				},
 			}
 
-			_, _ = argh.ParseArgs([]string{}, pCfg)
+			_, _ = argh.ParseArgs([]string{
+				"--ok",
+				"--dur", "42h42m10s",
+				"--f64", "4242424242.42",
+				"-i", "-42",
+				"--i64", "-4242424242",
+				"-s", "the answer",
+				"-u", "42",
+				"--u64", "4242424242",
+			}, pCfg)
+			_ = fmt.Sprint(
+				"okFlag", ptrFrom(okFlag),
+				"durFlag", ptrFrom(durFlag),
+				"f64Flag", ptrFrom(f64Flag),
+				"iFlag", ptrFrom(iFlag),
+				"i64Flag", ptrFrom(i64Flag),
+				"sFlag", ptrFrom(sFlag),
+				"uFlag", ptrFrom(uFlag),
+				"u64Flag", ptrFrom(u64Flag),
+			)
 		}()
 	}
 }

ast.go

@@ -0,0 +1,50 @@
+package argh
+
+// ToAST accepts a slice of nodes as expected from ParseArgs and
+// returns an AST with parse-time artifacts dropped and reorganized
+// where applicable.
+func ToAST(parseTree []Node) []Node {
+	ret := []Node{}
+
+	for i, node := range parseTree {
+		tracef("ToAST i=%d node type=%T", i, node)
+
+		if _, ok := node.(*ArgDelimiter); ok {
+			continue
+		}
+
+		if _, ok := node.(*StopFlag); ok {
+			continue
+		}
+
+		if v, ok := node.(*CompoundShortFlag); ok {
+			if v.Nodes != nil {
+				ret = append(ret, ToAST(v.Nodes)...)
+			}
+
+			continue
+		}
+
+		if v, ok := node.(*CommandFlag); ok {
+			astNodes := ToAST(v.Nodes)
+
+			if len(astNodes) == 0 {
+				astNodes = nil
+			}
+
+			ret = append(
+				ret,
+				&CommandFlag{
+					Name:   v.Name,
+					Values: v.Values,
+					Nodes:  astNodes,
+				})
+
+			continue
+		}
+
+		ret = append(ret, node)
+	}
+
+	return ret
+}

cmd/argh-example/main.go

@@ -29,7 +29,7 @@ func main() {
 		log.Fatal(err)
 	}
 
-	ast := argh.NewQuerier(pt.Nodes).AST()
+	ast := argh.ToAST(pt.Nodes)
 
 	if asJSON {
 		b, err := json.MarshalIndent(ast, "", "  ")

node.go

@@ -25,13 +25,9 @@ type BadArg struct {
 	To      Pos
 }
 
-type Command struct {
-	Name   string
-	Values map[string]string
-	Nodes  []Node
-}
-
-type Flag struct {
+// CommandFlag is a Node with a name, a slice of child Nodes, and
+// potentially a map of named values derived from the child Nodes
+type CommandFlag struct {
 	Name   string
 	Values map[string]string
 	Nodes  []Node

parser.go

@@ -26,10 +26,13 @@ type ParseTree struct {
 
 func ParseArgs(args []string, pCfg *ParserConfig) (*ParseTree, error) {
 	p := &parser{}
-	p.init(
+
+	if err := p.init(
 		strings.NewReader(strings.Join(args, string(nul))),
 		pCfg,
-	)
+	); err != nil {
+		return nil, err
+	}
 
 	tracef("ParseArgs(...) parser=%+#v", p)
 
@@ -40,11 +43,11 @@ func (p *parser) addError(msg string) {
 	p.errors.Add(Position{Column: int(p.pos)}, msg)
 }
 
-func (p *parser) init(r io.Reader, pCfg *ParserConfig) {
+func (p *parser) init(r io.Reader, pCfg *ParserConfig) error {
 	p.errors = ParserErrorList{}
 
 	if pCfg == nil {
-		pCfg = POSIXyParserConfig
+		return fmt.Errorf("nil parser config: %w", Error)
 	}
 
 	p.cfg = pCfg
@@ -52,6 +55,8 @@ func (p *parser) init(r io.Reader, pCfg *ParserConfig) {
 	p.s = NewScanner(r, pCfg.ScannerConfig)
 
 	p.next()
+
+	return nil
 }
 
 func (p *parser) parseArgs() (*ParseTree, error) {
@@ -87,7 +92,7 @@ func (p *parser) next() {
 func (p *parser) parseCommand(cCfg *CommandConfig) Node {
 	tracef("parseCommand(%+#v)", cCfg)
 
-	node := &Command{
+	node := &CommandFlag{
 		Name: p.lit,
 	}
 	values := map[string]string{}
@@ -179,6 +184,13 @@ func (p *parser) parseCommand(cCfg *CommandConfig) Node {
 		node.Values = values
 	}
 
+	if cCfg.On != nil {
+		tracef("parseCommand(...) calling command config handler for node=%+#v", node)
+		cCfg.On(*node)
+	} else {
+		tracef("parseCommand(...) no command config handler for node=%+#v", node)
+	}
+
 	tracef("parseCommand(...) returning node=%+#v", node)
 	return node
 }
@@ -205,65 +217,115 @@ func (p *parser) parseFlag(flags *Flags) Node {
 }
 
 func (p *parser) parseShortFlag(flags *Flags) Node {
-	node := &Flag{Name: string(p.lit[1])}
+	node := &CommandFlag{Name: string(p.lit[1])}
 
 	flCfg, ok := flags.Get(node.Name)
 	if !ok {
-		p.addError(fmt.Sprintf("unknown flag %q", node.Name))
+		p.addError(fmt.Sprintf("unknown flag %[1]q", node.Name))
 
 		return node
 	}
 
-	return p.parseConfiguredFlag(node, flCfg)
+	return p.parseConfiguredFlag(node, flCfg, nil)
 }
 
 func (p *parser) parseLongFlag(flags *Flags) Node {
-	node := &Flag{Name: string(p.lit[2:])}
+	node := &CommandFlag{Name: string(p.lit[2:])}
 
 	flCfg, ok := flags.Get(node.Name)
 	if !ok {
-		p.addError(fmt.Sprintf("unknown flag %q", node.Name))
+		p.addError(fmt.Sprintf("unknown flag %[1]q", node.Name))
 
 		return node
 	}
 
-	return p.parseConfiguredFlag(node, flCfg)
+	return p.parseConfiguredFlag(node, flCfg, nil)
 }
 
 func (p *parser) parseCompoundShortFlag(flags *Flags) Node {
-	flagNodes := []Node{}
+	unparsedFlags := []*CommandFlag{}
+	unparsedFlagConfigs := []FlagConfig{}
 
 	withoutFlagPrefix := p.lit[1:]
 
-	for i, r := range withoutFlagPrefix {
-		node := &Flag{Name: string(r)}
+	for _, r := range withoutFlagPrefix {
+		node := &CommandFlag{Name: string(r)}
 
-		if i == len(withoutFlagPrefix)-1 {
-			flCfg, ok := flags.Get(node.Name)
-			if !ok {
-				p.addError(fmt.Sprintf("unknown flag %q", node.Name))
+		flCfg, ok := flags.Get(node.Name)
+		if !ok {
+			p.addError(fmt.Sprintf("unknown flag %[1]q", node.Name))
 
-				continue
+			continue
+		}
+
+		unparsedFlags = append(unparsedFlags, node)
+		unparsedFlagConfigs = append(unparsedFlagConfigs, flCfg)
+	}
+
+	flagNodes := []Node{}
+
+	for i, node := range unparsedFlags {
+		flCfg := unparsedFlagConfigs[i]
+
+		if i != len(unparsedFlags)-1 {
+			// NOTE: if a compound short flag is configured to accept
+			// more than zero values but is not the last flag in the
+			// group, it will be parsed with an override NValue of
+			// ZeroValue so that it does not consume the next token.
+			if flCfg.NValue.Required() {
+				p.addError(
+					fmt.Sprintf(
+						"short flag %[1]q before end of compound group expects value",
+						node.Name,
+					),
+				)
 			}
 
-			flagNodes = append(flagNodes, p.parseConfiguredFlag(node, flCfg))
+			flagNodes = append(
+				flagNodes,
+				p.parseConfiguredFlag(node, flCfg, zeroValuePtr),
+			)
 
 			continue
 		}
 
-		flagNodes = append(flagNodes, node)
+		flagNodes = append(flagNodes, p.parseConfiguredFlag(node, flCfg, nil))
 	}
 
 	return &CompoundShortFlag{Nodes: flagNodes}
 }
 
-func (p *parser) parseConfiguredFlag(node *Flag, flCfg FlagConfig) Node {
+func (p *parser) parseConfiguredFlag(node *CommandFlag, flCfg FlagConfig, nValueOverride *NValue) Node {
 	values := map[string]string{}
 	nodes := []Node{}
 
+	atExit := func() *CommandFlag {
+		if len(nodes) > 0 {
+			node.Nodes = nodes
+		}
+
+		if len(values) > 0 {
+			node.Values = values
+		}
+
+		if flCfg.On != nil {
+			tracef("parseConfiguredFlag(...) calling flag config handler for node=%+#[1]v", node)
+			flCfg.On(*node)
+		} else {
+			tracef("parseConfiguredFlag(...) no flag config handler for node=%+#[1]v", node)
+		}
+
+		return node
+	}
+
 	identIndex := 0
 
 	for i := 0; p.tok != EOL; i++ {
+		if nValueOverride != nil && !(*nValueOverride).Contains(identIndex) {
+			tracef("parseConfiguredFlag(...) identIndex=%d exceeds expected=%v; breaking", identIndex, *nValueOverride)
+			break
+		}
+
 		if !flCfg.NValue.Contains(identIndex) {
 			tracef("parseConfiguredFlag(...) identIndex=%d exceeds expected=%v; breaking", identIndex, flCfg.NValue)
 			break
@@ -308,27 +370,11 @@ func (p *parser) parseConfiguredFlag(node *Flag, flCfg FlagConfig) Node {
 			tracef("parseConfiguredFlag(...) breaking on %s %q %v; setting buffered=true", p.tok, p.lit, p.pos)
 			p.buffered = true
 
-			if len(nodes) > 0 {
-				node.Nodes = nodes
-			}
-
-			if len(values) > 0 {
-				node.Values = values
-			}
-
-			return node
+			return atExit()
 		}
 	}
 
-	if len(nodes) > 0 {
-		node.Nodes = nodes
-	}
-
-	if len(values) > 0 {
-		node.Values = values
-	}
-
-	return node
+	return atExit()
 }
 
 func (p *parser) parsePassthrough() Node {

parser_config.go

@@ -7,11 +7,22 @@ const (
 )
 
 var (
-	POSIXyParserConfig = NewParserConfig()
+	zeroValuePtr = func() *NValue {
+		v := ZeroValue
+		return &v
+	}()
 )
 
 type NValue int
 
+func (nv NValue) Required() bool {
+	if nv == OneOrMoreValue {
+		return true
+	}
+
+	return int(nv) >= 1
+}
+
 func (nv NValue) Contains(i int) bool {
 	tracef("NValue.Contains(%v)", i)
 
@@ -60,6 +71,8 @@ type CommandConfig struct {
 	ValueNames []string
 	Flags      *Flags
 	Commands   *Commands
+
+	On func(CommandFlag)
 }
 
 func (cCfg *CommandConfig) init() {
@@ -100,6 +113,8 @@ type FlagConfig struct {
 	NValue     NValue
 	Persist    bool
 	ValueNames []string
+
+	On func(CommandFlag)
 }
 
 type Flags struct {

parser_test.go

@@ -9,6 +9,10 @@ import (
 )
 
 func TestParser(t *testing.T) {
+	traceOnCommandFlag := func(cmd argh.CommandFlag) {
+		t.Logf("CommandFlag.On: %+#[1]v", cmd)
+	}
+
 	for _, tc := range []struct {
 		name   string
 		args   []string
@@ -27,10 +31,10 @@ func TestParser(t *testing.T) {
 				Prog: &argh.CommandConfig{
 					Flags: &argh.Flags{
 						Map: map[string]argh.FlagConfig{
-							"e":   {},
-							"a":   {},
-							"t":   {},
-							"wat": {},
+							"e":   {On: traceOnCommandFlag},
+							"a":   {On: traceOnCommandFlag},
+							"t":   {On: traceOnCommandFlag},
+							"wat": {On: traceOnCommandFlag},
 						},
 					},
 					Commands: &argh.Commands{
@@ -38,27 +42,29 @@ func TestParser(t *testing.T) {
 							"hello": argh.CommandConfig{
 								NValue:     1,
 								ValueNames: []string{"name"},
+								On:         traceOnCommandFlag,
 							},
 						},
 					},
+					On: traceOnCommandFlag,
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pies",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
 						&argh.CompoundShortFlag{
 							Nodes: []argh.Node{
-								&argh.Flag{Name: "e"},
-								&argh.Flag{Name: "a"},
-								&argh.Flag{Name: "t"},
+								&argh.CommandFlag{Name: "e"},
+								&argh.CommandFlag{Name: "a"},
+								&argh.CommandFlag{Name: "t"},
 							},
 						},
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "wat"},
+						&argh.CommandFlag{Name: "wat"},
 						&argh.ArgDelimiter{},
-						&argh.Command{
+						&argh.CommandFlag{
 							Name: "hello",
 							Values: map[string]string{
 								"name": "mario",
@@ -72,14 +78,14 @@ func TestParser(t *testing.T) {
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pies",
 					Nodes: []argh.Node{
-						&argh.Flag{Name: "e"},
-						&argh.Flag{Name: "a"},
-						&argh.Flag{Name: "t"},
-						&argh.Flag{Name: "wat"},
-						&argh.Command{
+						&argh.CommandFlag{Name: "e"},
+						&argh.CommandFlag{Name: "a"},
+						&argh.CommandFlag{Name: "t"},
+						&argh.CommandFlag{Name: "wat"},
+						&argh.CommandFlag{
 							Name: "hello",
 							Values: map[string]string{
 								"name": "mario",
@@ -102,12 +108,13 @@ func TestParser(t *testing.T) {
 					cmdCfg := &argh.CommandConfig{
 						Flags: &argh.Flags{
 							Map: map[string]argh.FlagConfig{
-								"e":   {Persist: true},
-								"a":   {Persist: true},
-								"t":   {Persist: true},
-								"wat": {},
+								"e":   {Persist: true, On: traceOnCommandFlag},
+								"a":   {Persist: true, On: traceOnCommandFlag},
+								"t":   {Persist: true, On: traceOnCommandFlag},
+								"wat": {On: traceOnCommandFlag},
 							},
 						},
+						On: traceOnCommandFlag,
 					}
 
 					cmdCfg.Commands = &argh.Commands{
@@ -119,6 +126,7 @@ func TestParser(t *testing.T) {
 									Parent: cmdCfg.Flags,
 									Map:    map[string]argh.FlagConfig{},
 								},
+								On: traceOnCommandFlag,
 							},
 						},
 					}
@@ -127,13 +135,13 @@ func TestParser(t *testing.T) {
 				}(),
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pies",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "wat"},
+						&argh.CommandFlag{Name: "wat"},
 						&argh.ArgDelimiter{},
-						&argh.Command{
+						&argh.CommandFlag{
 							Name: "hello",
 							Values: map[string]string{
 								"name": "mario",
@@ -144,9 +152,9 @@ func TestParser(t *testing.T) {
 								&argh.ArgDelimiter{},
 								&argh.CompoundShortFlag{
 									Nodes: []argh.Node{
-										&argh.Flag{Name: "e"},
-										&argh.Flag{Name: "a"},
-										&argh.Flag{Name: "t"},
+										&argh.CommandFlag{Name: "e"},
+										&argh.CommandFlag{Name: "a"},
+										&argh.CommandFlag{Name: "t"},
 									},
 								},
 							},
@@ -155,20 +163,20 @@ func TestParser(t *testing.T) {
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pies",
 					Nodes: []argh.Node{
-						&argh.Flag{Name: "wat"},
-						&argh.Command{
+						&argh.CommandFlag{Name: "wat"},
+						&argh.CommandFlag{
 							Name: "hello",
 							Values: map[string]string{
 								"name": "mario",
 							},
 							Nodes: []argh.Node{
 								&argh.Ident{Literal: "mario"},
-								&argh.Flag{Name: "e"},
-								&argh.Flag{Name: "a"},
-								&argh.Flag{Name: "t"},
+								&argh.CommandFlag{Name: "e"},
+								&argh.CommandFlag{Name: "a"},
+								&argh.CommandFlag{Name: "t"},
 							},
 						},
 					},
@@ -179,12 +187,12 @@ func TestParser(t *testing.T) {
 			name: "bare",
 			args: []string{"pizzas"},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 				},
 			},
@@ -193,10 +201,10 @@ func TestParser(t *testing.T) {
 			name: "one positional arg",
 			args: []string{"pizzas", "excel"},
 			cfg: &argh.ParserConfig{
-				Prog: &argh.CommandConfig{NValue: 1},
+				Prog: &argh.CommandConfig{NValue: 1, On: traceOnCommandFlag},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name:   "pizzas",
 					Values: map[string]string{"0": "excel"},
 					Nodes: []argh.Node{
@@ -206,7 +214,7 @@ func TestParser(t *testing.T) {
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name:   "pizzas",
 					Values: map[string]string{"0": "excel"},
 					Nodes: []argh.Node{
@@ -222,10 +230,11 @@ func TestParser(t *testing.T) {
 				Prog: &argh.CommandConfig{
 					NValue:     argh.OneOrMoreValue,
 					ValueNames: []string{"word"},
+					On:         traceOnCommandFlag,
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Values: map[string]string{
 						"word":   "excel",
@@ -246,7 +255,7 @@ func TestParser(t *testing.T) {
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Values: map[string]string{
 						"word":   "excel",
@@ -270,33 +279,34 @@ func TestParser(t *testing.T) {
 				Prog: &argh.CommandConfig{
 					Flags: &argh.Flags{
 						Map: map[string]argh.FlagConfig{
-							"tasty":               {},
-							"fresh":               {},
-							"super-hot-right-now": {},
+							"tasty":               {On: traceOnCommandFlag},
+							"fresh":               {On: traceOnCommandFlag},
+							"super-hot-right-now": {On: traceOnCommandFlag},
 						},
 					},
+					On: traceOnCommandFlag,
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "tasty"},
+						&argh.CommandFlag{Name: "tasty"},
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "fresh"},
+						&argh.CommandFlag{Name: "fresh"},
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "super-hot-right-now"},
+						&argh.CommandFlag{Name: "super-hot-right-now"},
 					},
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
-						&argh.Flag{Name: "tasty"},
-						&argh.Flag{Name: "fresh"},
-						&argh.Flag{Name: "super-hot-right-now"},
+						&argh.CommandFlag{Name: "tasty"},
+						&argh.CommandFlag{Name: "fresh"},
+						&argh.CommandFlag{Name: "super-hot-right-now"},
 					},
 				},
 			},
@@ -316,23 +326,24 @@ func TestParser(t *testing.T) {
 					Commands: &argh.Commands{Map: map[string]argh.CommandConfig{}},
 					Flags: &argh.Flags{
 						Map: map[string]argh.FlagConfig{
-							"tasty":               {},
-							"fresh":               argh.FlagConfig{NValue: 1},
-							"super-hot-right-now": {},
-							"box":                 argh.FlagConfig{NValue: argh.OneOrMoreValue},
-							"please":              {},
+							"tasty":               {On: traceOnCommandFlag},
+							"fresh":               argh.FlagConfig{NValue: 1, On: traceOnCommandFlag},
+							"super-hot-right-now": {On: traceOnCommandFlag},
+							"box":                 argh.FlagConfig{NValue: argh.OneOrMoreValue, On: traceOnCommandFlag},
+							"please":              {On: traceOnCommandFlag},
 						},
 					},
+					On: traceOnCommandFlag,
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "tasty"},
+						&argh.CommandFlag{Name: "tasty"},
 						&argh.ArgDelimiter{},
-						&argh.Flag{
+						&argh.CommandFlag{
 							Name:   "fresh",
 							Values: map[string]string{"0": "soon"},
 							Nodes: []argh.Node{
@@ -341,9 +352,9 @@ func TestParser(t *testing.T) {
 							},
 						},
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "super-hot-right-now"},
+						&argh.CommandFlag{Name: "super-hot-right-now"},
 						&argh.ArgDelimiter{},
-						&argh.Flag{
+						&argh.CommandFlag{
 							Name:   "box",
 							Values: map[string]string{"0": "square", "1": "shaped", "2": "hot"},
 							Nodes: []argh.Node{
@@ -356,24 +367,24 @@ func TestParser(t *testing.T) {
 								&argh.ArgDelimiter{},
 							},
 						},
-						&argh.Flag{Name: "please"},
+						&argh.CommandFlag{Name: "please"},
 					},
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
-						&argh.Flag{Name: "tasty"},
-						&argh.Flag{
+						&argh.CommandFlag{Name: "tasty"},
+						&argh.CommandFlag{
 							Name:   "fresh",
 							Values: map[string]string{"0": "soon"},
 							Nodes: []argh.Node{
 								&argh.Ident{Literal: "soon"},
 							},
 						},
-						&argh.Flag{Name: "super-hot-right-now"},
-						&argh.Flag{
+						&argh.CommandFlag{Name: "super-hot-right-now"},
+						&argh.CommandFlag{
 							Name:   "box",
 							Values: map[string]string{"0": "square", "1": "shaped", "2": "hot"},
 							Nodes: []argh.Node{
@@ -382,7 +393,7 @@ func TestParser(t *testing.T) {
 								&argh.Ident{Literal: "hot"},
 							},
 						},
-						&argh.Flag{Name: "please"},
+						&argh.CommandFlag{Name: "please"},
 					},
 				},
 			},
@@ -394,33 +405,34 @@ func TestParser(t *testing.T) {
 				Prog: &argh.CommandConfig{
 					Flags: &argh.Flags{
 						Map: map[string]argh.FlagConfig{
-							"t": {},
-							"f": {},
-							"s": {},
+							"t": {On: traceOnCommandFlag},
+							"f": {On: traceOnCommandFlag},
+							"s": {On: traceOnCommandFlag},
 						},
 					},
+					On: traceOnCommandFlag,
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "t"},
+						&argh.CommandFlag{Name: "t"},
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "f"},
+						&argh.CommandFlag{Name: "f"},
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "s"},
+						&argh.CommandFlag{Name: "s"},
 					},
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
-						&argh.Flag{Name: "t"},
-						&argh.Flag{Name: "f"},
-						&argh.Flag{Name: "s"},
+						&argh.CommandFlag{Name: "t"},
+						&argh.CommandFlag{Name: "f"},
+						&argh.CommandFlag{Name: "s"},
 					},
 				},
 			},
@@ -432,50 +444,51 @@ func TestParser(t *testing.T) {
 				Prog: &argh.CommandConfig{
 					Flags: &argh.Flags{
 						Map: map[string]argh.FlagConfig{
-							"a": {},
-							"b": {},
-							"c": {},
-							"l": {},
-							"o": {},
+							"a": {On: traceOnCommandFlag},
+							"b": {On: traceOnCommandFlag},
+							"c": {On: traceOnCommandFlag},
+							"l": {On: traceOnCommandFlag},
+							"o": {On: traceOnCommandFlag},
 						},
 					},
+					On: traceOnCommandFlag,
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
 						&argh.CompoundShortFlag{
 							Nodes: []argh.Node{
-								&argh.Flag{Name: "a"},
-								&argh.Flag{Name: "c"},
-								&argh.Flag{Name: "a"},
+								&argh.CommandFlag{Name: "a"},
+								&argh.CommandFlag{Name: "c"},
+								&argh.CommandFlag{Name: "a"},
 							},
 						},
 						&argh.ArgDelimiter{},
 						&argh.CompoundShortFlag{
 							Nodes: []argh.Node{
-								&argh.Flag{Name: "b"},
-								&argh.Flag{Name: "l"},
-								&argh.Flag{Name: "o"},
-								&argh.Flag{Name: "l"},
+								&argh.CommandFlag{Name: "b"},
+								&argh.CommandFlag{Name: "l"},
+								&argh.CommandFlag{Name: "o"},
+								&argh.CommandFlag{Name: "l"},
 							},
 						},
 					},
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
-						&argh.Flag{Name: "a"},
-						&argh.Flag{Name: "c"},
-						&argh.Flag{Name: "a"},
-						&argh.Flag{Name: "b"},
-						&argh.Flag{Name: "l"},
-						&argh.Flag{Name: "o"},
-						&argh.Flag{Name: "l"},
+						&argh.CommandFlag{Name: "a"},
+						&argh.CommandFlag{Name: "c"},
+						&argh.CommandFlag{Name: "a"},
+						&argh.CommandFlag{Name: "b"},
+						&argh.CommandFlag{Name: "l"},
+						&argh.CommandFlag{Name: "o"},
+						&argh.CommandFlag{Name: "l"},
 					},
 				},
 			},
@@ -488,25 +501,26 @@ func TestParser(t *testing.T) {
 					Commands: &argh.Commands{Map: map[string]argh.CommandConfig{}},
 					Flags: &argh.Flags{
 						Map: map[string]argh.FlagConfig{
-							"a":  {},
-							"b":  argh.FlagConfig{NValue: 1},
-							"ca": {},
-							"l":  {},
-							"o":  {},
+							"a":  {On: traceOnCommandFlag},
+							"b":  argh.FlagConfig{NValue: 1, On: traceOnCommandFlag},
+							"ca": {On: traceOnCommandFlag},
+							"l":  {On: traceOnCommandFlag},
+							"o":  {On: traceOnCommandFlag},
 						},
 					},
+					On: traceOnCommandFlag,
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "a"},
+						&argh.CommandFlag{Name: "a"},
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "ca"},
+						&argh.CommandFlag{Name: "ca"},
 						&argh.ArgDelimiter{},
-						&argh.Flag{
+						&argh.CommandFlag{
 							Name:   "b",
 							Values: map[string]string{"0": "1312"},
 							Nodes: []argh.Node{
@@ -517,30 +531,30 @@ func TestParser(t *testing.T) {
 						&argh.ArgDelimiter{},
 						&argh.CompoundShortFlag{
 							Nodes: []argh.Node{
-								&argh.Flag{Name: "l"},
-								&argh.Flag{Name: "o"},
-								&argh.Flag{Name: "l"},
+								&argh.CommandFlag{Name: "l"},
+								&argh.CommandFlag{Name: "o"},
+								&argh.CommandFlag{Name: "l"},
 							},
 						},
 					},
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
-						&argh.Flag{Name: "a"},
-						&argh.Flag{Name: "ca"},
-						&argh.Flag{
+						&argh.CommandFlag{Name: "a"},
+						&argh.CommandFlag{Name: "ca"},
+						&argh.CommandFlag{
 							Name:   "b",
 							Values: map[string]string{"0": "1312"},
 							Nodes: []argh.Node{
 								&argh.Ident{Literal: "1312"},
 							},
 						},
-						&argh.Flag{Name: "l"},
-						&argh.Flag{Name: "o"},
-						&argh.Flag{Name: "l"},
+						&argh.CommandFlag{Name: "l"},
+						&argh.CommandFlag{Name: "o"},
+						&argh.CommandFlag{Name: "l"},
 					},
 				},
 			},
@@ -558,7 +572,7 @@ func TestParser(t *testing.T) {
 										"fry": argh.CommandConfig{
 											Flags: &argh.Flags{
 												Map: map[string]argh.FlagConfig{
-													"forever": {},
+													"forever": {On: traceOnCommandFlag},
 												},
 											},
 										},
@@ -568,14 +582,15 @@ func TestParser(t *testing.T) {
 						},
 					},
 					Flags: &argh.Flags{Map: map[string]argh.FlagConfig{}},
+					On:    traceOnCommandFlag,
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
-						&argh.Command{
+						&argh.CommandFlag{
 							Name: "fly",
 							Nodes: []argh.Node{
 								&argh.ArgDelimiter{},
@@ -589,13 +604,13 @@ func TestParser(t *testing.T) {
 								&argh.ArgDelimiter{},
 								&argh.Ident{Literal: "times"},
 								&argh.ArgDelimiter{},
-								&argh.Command{
+								&argh.CommandFlag{
 									Name: "fry",
 									Nodes: []argh.Node{
 										&argh.ArgDelimiter{},
 										&argh.Ident{Literal: "deeply"},
 										&argh.ArgDelimiter{},
-										&argh.Flag{Name: "forever"},
+										&argh.CommandFlag{Name: "forever"},
 									},
 								},
 							},
@@ -604,10 +619,10 @@ func TestParser(t *testing.T) {
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
-						&argh.Command{
+						&argh.CommandFlag{
 							Name: "fly",
 							Nodes: []argh.Node{
 								&argh.Ident{Literal: "freely"},
@@ -615,11 +630,11 @@ func TestParser(t *testing.T) {
 								&argh.Ident{Literal: "and"},
 								&argh.Ident{Literal: "other"},
 								&argh.Ident{Literal: "times"},
-								&argh.Command{
+								&argh.CommandFlag{
 									Name: "fry",
 									Nodes: []argh.Node{
 										&argh.Ident{Literal: "deeply"},
-										&argh.Flag{Name: "forever"},
+										&argh.CommandFlag{Name: "forever"},
 									},
 								},
 							},
@@ -635,28 +650,29 @@ func TestParser(t *testing.T) {
 				Prog: &argh.CommandConfig{
 					Flags: &argh.Flags{
 						Map: map[string]argh.FlagConfig{
-							"a": {NValue: argh.ZeroOrMoreValue},
-							"d": {NValue: argh.OneOrMoreValue},
-							"e": {},
-							"l": {},
-							"n": {},
-							"o": {NValue: 1, ValueNames: []string{"level"}},
-							"s": {NValue: argh.ZeroOrMoreValue},
+							"a": {NValue: argh.ZeroOrMoreValue, On: traceOnCommandFlag},
+							"d": {NValue: argh.OneOrMoreValue, On: traceOnCommandFlag},
+							"e": {On: traceOnCommandFlag},
+							"l": {On: traceOnCommandFlag},
+							"n": {On: traceOnCommandFlag},
+							"o": {NValue: 1, ValueNames: []string{"level"}, On: traceOnCommandFlag},
+							"s": {NValue: argh.ZeroOrMoreValue, On: traceOnCommandFlag},
 						},
 					},
+					On: traceOnCommandFlag,
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
 						&argh.CompoundShortFlag{
 							Nodes: []argh.Node{
-								&argh.Flag{Name: "n"},
-								&argh.Flag{Name: "e"},
-								&argh.Flag{Name: "e"},
-								&argh.Flag{
+								&argh.CommandFlag{Name: "n"},
+								&argh.CommandFlag{Name: "e"},
+								&argh.CommandFlag{Name: "e"},
+								&argh.CommandFlag{
 									Name: "d",
 									Values: map[string]string{
 										"0": "sauce",
@@ -677,10 +693,10 @@ func TestParser(t *testing.T) {
 						},
 						&argh.CompoundShortFlag{
 							Nodes: []argh.Node{
-								&argh.Flag{Name: "a"},
-								&argh.Flag{Name: "l"},
-								&argh.Flag{Name: "s"},
-								&argh.Flag{
+								&argh.CommandFlag{Name: "a"},
+								&argh.CommandFlag{Name: "l"},
+								&argh.CommandFlag{Name: "s"},
+								&argh.CommandFlag{
 									Name: "o",
 									Values: map[string]string{
 										"level": "over9000",
@@ -696,13 +712,13 @@ func TestParser(t *testing.T) {
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
-						&argh.Flag{Name: "n"},
-						&argh.Flag{Name: "e"},
-						&argh.Flag{Name: "e"},
-						&argh.Flag{
+						&argh.CommandFlag{Name: "n"},
+						&argh.CommandFlag{Name: "e"},
+						&argh.CommandFlag{Name: "e"},
+						&argh.CommandFlag{
 							Name: "d",
 							Values: map[string]string{
 								"0": "sauce",
@@ -715,10 +731,10 @@ func TestParser(t *testing.T) {
 								&argh.Ident{Literal: "love"},
 							},
 						},
-						&argh.Flag{Name: "a"},
-						&argh.Flag{Name: "l"},
-						&argh.Flag{Name: "s"},
-						&argh.Flag{
+						&argh.CommandFlag{Name: "a"},
+						&argh.CommandFlag{Name: "l"},
+						&argh.CommandFlag{Name: "s"},
+						&argh.CommandFlag{
 							Name: "o",
 							Values: map[string]string{
 								"level": "over9000",
@@ -741,7 +757,7 @@ func TestParser(t *testing.T) {
 							"fly": argh.CommandConfig{
 								Flags: &argh.Flags{
 									Map: map[string]argh.FlagConfig{
-										"freely": {},
+										"freely": {On: traceOnCommandFlag},
 									},
 								},
 								Commands: &argh.Commands{
@@ -749,10 +765,10 @@ func TestParser(t *testing.T) {
 										"fry": argh.CommandConfig{
 											Flags: &argh.Flags{
 												Map: map[string]argh.FlagConfig{
-													"deeply": {},
-													"w":      {},
-													"A":      {},
-													"t":      argh.FlagConfig{NValue: 1},
+													"deeply": {On: traceOnCommandFlag},
+													"w":      {On: traceOnCommandFlag},
+													"A":      {On: traceOnCommandFlag},
+													"t":      argh.FlagConfig{NValue: 1, On: traceOnCommandFlag},
 												},
 											},
 										},
@@ -762,30 +778,31 @@ func TestParser(t *testing.T) {
 						},
 					},
 					Flags: &argh.Flags{Map: map[string]argh.FlagConfig{}},
+					On:    traceOnCommandFlag,
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
-						&argh.Command{
+						&argh.CommandFlag{
 							Name: "fly",
 							Nodes: []argh.Node{
 								&argh.ArgDelimiter{},
-								&argh.Flag{Name: "freely"},
+								&argh.CommandFlag{Name: "freely"},
 								&argh.ArgDelimiter{},
-								&argh.Command{
+								&argh.CommandFlag{
 									Name: "fry",
 									Nodes: []argh.Node{
 										&argh.ArgDelimiter{},
-										&argh.Flag{Name: "deeply"},
+										&argh.CommandFlag{Name: "deeply"},
 										&argh.ArgDelimiter{},
 										&argh.CompoundShortFlag{
 											Nodes: []argh.Node{
-												&argh.Flag{Name: "w"},
-												&argh.Flag{Name: "A"},
-												&argh.Flag{
+												&argh.CommandFlag{Name: "w"},
+												&argh.CommandFlag{Name: "A"},
+												&argh.CommandFlag{
 													Name:   "t",
 													Values: map[string]string{"0": "hugs"},
 													Nodes: []argh.Node{
@@ -803,20 +820,20 @@ func TestParser(t *testing.T) {
 				},
 			},
 			expAST: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
-						&argh.Command{
+						&argh.CommandFlag{
 							Name: "fly",
 							Nodes: []argh.Node{
-								&argh.Flag{Name: "freely"},
-								&argh.Command{
+								&argh.CommandFlag{Name: "freely"},
+								&argh.CommandFlag{
 									Name: "fry",
 									Nodes: []argh.Node{
-										&argh.Flag{Name: "deeply"},
-										&argh.Flag{Name: "w"},
-										&argh.Flag{Name: "A"},
-										&argh.Flag{
+										&argh.CommandFlag{Name: "deeply"},
+										&argh.CommandFlag{Name: "w"},
+										&argh.CommandFlag{Name: "A"},
+										&argh.CommandFlag{
 											Name:   "t",
 											Values: map[string]string{"0": "hugs"},
 											Nodes: []argh.Node{
@@ -842,7 +859,7 @@ func TestParser(t *testing.T) {
 								NValue: 1,
 								Flags: &argh.Flags{
 									Map: map[string]argh.FlagConfig{
-										"FIERCENESS": argh.FlagConfig{NValue: 1},
+										"FIERCENESS": argh.FlagConfig{NValue: 1, On: traceOnCommandFlag},
 									},
 								},
 							},
@@ -850,12 +867,13 @@ func TestParser(t *testing.T) {
 					},
 					Flags: &argh.Flags{
 						Map: map[string]argh.FlagConfig{
-							"w":       argh.FlagConfig{},
-							"A":       argh.FlagConfig{},
-							"T":       argh.FlagConfig{NValue: 1},
-							"hecKing": argh.FlagConfig{},
+							"w":       {On: traceOnCommandFlag},
+							"A":       {On: traceOnCommandFlag},
+							"T":       {NValue: 1, On: traceOnCommandFlag},
+							"hecKing": {On: traceOnCommandFlag},
 						},
 					},
+					On: traceOnCommandFlag,
 				},
 				ScannerConfig: &argh.ScannerConfig{
 					AssignmentOperator: '@',
@@ -864,15 +882,15 @@ func TestParser(t *testing.T) {
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "PIZZAs",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
 						&argh.CompoundShortFlag{
 							Nodes: []argh.Node{
-								&argh.Flag{Name: "w"},
-								&argh.Flag{Name: "A"},
-								&argh.Flag{
+								&argh.CommandFlag{Name: "w"},
+								&argh.CommandFlag{Name: "A"},
+								&argh.CommandFlag{
 									Name:   "T",
 									Values: map[string]string{"0": "golf"},
 									Nodes: []argh.Node{
@@ -883,16 +901,16 @@ func TestParser(t *testing.T) {
 							},
 						},
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "hecKing"},
+						&argh.CommandFlag{Name: "hecKing"},
 						&argh.ArgDelimiter{},
-						&argh.Command{
+						&argh.CommandFlag{
 							Name:   "goose",
 							Values: map[string]string{"0": "bonk"},
 							Nodes: []argh.Node{
 								&argh.ArgDelimiter{},
 								&argh.Ident{Literal: "bonk"},
 								&argh.ArgDelimiter{},
-								&argh.Flag{
+								&argh.CommandFlag{
 									Name:   "FIERCENESS",
 									Values: map[string]string{"0": "-2"},
 									Nodes: []argh.Node{
@@ -913,9 +931,9 @@ func TestParser(t *testing.T) {
 				Prog: &argh.CommandConfig{
 					Flags: &argh.Flags{
 						Map: map[string]argh.FlagConfig{
-							"f": {},
-							"L": {},
-							"o": argh.FlagConfig{NValue: 1},
+							"f": {On: traceOnCommandFlag},
+							"L": {On: traceOnCommandFlag},
+							"o": argh.FlagConfig{NValue: 1, On: traceOnCommandFlag},
 						},
 					},
 					Commands: &argh.Commands{
@@ -923,6 +941,7 @@ func TestParser(t *testing.T) {
 							"hats": {},
 						},
 					},
+					On: traceOnCommandFlag,
 				},
 				ScannerConfig: &argh.ScannerConfig{
 					AssignmentOperator: ':',
@@ -931,15 +950,15 @@ func TestParser(t *testing.T) {
 				},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "hotdog",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "f"},
+						&argh.CommandFlag{Name: "f"},
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "L"},
+						&argh.CommandFlag{Name: "L"},
 						&argh.ArgDelimiter{},
-						&argh.Flag{
+						&argh.CommandFlag{
 							Name:   "o",
 							Values: map[string]string{"0": "ppy"},
 							Nodes: []argh.Node{
@@ -948,7 +967,7 @@ func TestParser(t *testing.T) {
 							},
 						},
 						&argh.ArgDelimiter{},
-						&argh.Command{Name: "hats"},
+						&argh.CommandFlag{Name: "hats"},
 					},
 				},
 			},
@@ -960,21 +979,22 @@ func TestParser(t *testing.T) {
 				Prog: &argh.CommandConfig{
 					Flags: &argh.Flags{
 						Map: map[string]argh.FlagConfig{
-							"wat": {},
+							"wat": {On: traceOnCommandFlag},
 						},
 					},
+					On: traceOnCommandFlag,
 				},
 			},
 			expErr: argh.ParserErrorList{
 				&argh.ParserError{Pos: argh.Position{Column: 8}, Msg: "invalid bare assignment"},
 			},
 			expPT: []argh.Node{
-				&argh.Command{
+				&argh.CommandFlag{
 					Name: "pizzas",
 					Nodes: []argh.Node{
 						&argh.ArgDelimiter{},
 						&argh.ArgDelimiter{},
-						&argh.Flag{Name: "wat"},
+						&argh.CommandFlag{Name: "wat"},
 					},
 				},
 			},
@@ -987,7 +1007,12 @@ func TestParser(t *testing.T) {
 					return
 				}
 
-				pt, err := argh.ParseArgs(tc.args, tc.cfg)
+				pCfg := tc.cfg
+				if pCfg == nil {
+					pCfg = argh.NewParserConfig()
+				}
+
+				pt, err := argh.ParseArgs(tc.args, pCfg)
 				if err != nil || tc.expErr != nil {
 					if !assert.ErrorIs(ct, err, tc.expErr) {
 						spew.Dump(err, tc.expErr)
@@ -1009,7 +1034,12 @@ func TestParser(t *testing.T) {
 					return
 				}
 
-				pt, err := argh.ParseArgs(tc.args, tc.cfg)
+				pCfg := tc.cfg
+				if pCfg == nil {
+					pCfg = argh.NewParserConfig()
+				}
+
+				pt, err := argh.ParseArgs(tc.args, pCfg)
 				if err != nil || tc.expErr != nil {
 					if !assert.ErrorIs(ct, err, tc.expErr) {
 						spew.Dump(pt)
@@ -1017,7 +1047,7 @@ func TestParser(t *testing.T) {
 					return
 				}
 
-				ast := argh.NewQuerier(pt.Nodes).AST()
+				ast := argh.ToAST(pt.Nodes)
 
 				if !assert.Equal(ct, tc.expAST, ast) {
 					spew.Dump(ast)

querier.go

@@ -1,94 +0,0 @@
-package argh
-
-type Querier interface {
-	Program() (*Command, bool)
-	AST() []Node
-}
-
-func NewQuerier(nodes []Node) Querier {
-	return &defaultQuerier{nodes: nodes}
-}
-
-type defaultQuerier struct {
-	nodes []Node
-}
-
-func (dq *defaultQuerier) Program() (*Command, bool) {
-	if len(dq.nodes) == 0 {
-		tracef("Program nodes are empty")
-		return nil, false
-	}
-
-	tracef("Program node[0] is %T", dq.nodes[0])
-
-	v, ok := dq.nodes[0].(*Command)
-	if ok && v.Name == "" {
-		return v, false
-	}
-
-	return v, ok
-}
-
-func (dq *defaultQuerier) AST() []Node {
-	ret := []Node{}
-
-	for i, node := range dq.nodes {
-		tracef("AST i=%d node type=%T", i, node)
-
-		if _, ok := node.(*ArgDelimiter); ok {
-			continue
-		}
-
-		if _, ok := node.(*StopFlag); ok {
-			continue
-		}
-
-		if v, ok := node.(*CompoundShortFlag); ok {
-			if v.Nodes != nil {
-				ret = append(ret, NewQuerier(v.Nodes).AST()...)
-			}
-
-			continue
-		}
-
-		if v, ok := node.(*Command); ok {
-			astNodes := NewQuerier(v.Nodes).AST()
-
-			if len(astNodes) == 0 {
-				astNodes = nil
-			}
-
-			ret = append(
-				ret,
-				&Command{
-					Name:   v.Name,
-					Values: v.Values,
-					Nodes:  astNodes,
-				})
-
-			continue
-		}
-
-		if v, ok := node.(*Flag); ok {
-			astNodes := NewQuerier(v.Nodes).AST()
-
-			if len(astNodes) == 0 {
-				astNodes = nil
-			}
-
-			ret = append(
-				ret,
-				&Flag{
-					Name:   v.Name,
-					Values: v.Values,
-					Nodes:  astNodes,
-				})
-
-			continue
-		}
-
-		ret = append(ret, node)
-	}
-
-	return ret
-}

querier_test.go

@@ -1,60 +0,0 @@
-package argh_test
-
-import (
-	"testing"
-
-	"git.meatballhat.com/x/argh"
-	"github.com/stretchr/testify/require"
-)
-
-func TestQuerier_Program(t *testing.T) {
-	for _, tc := range []struct {
-		name  string
-		args  []string
-		cfg   *argh.ParserConfig
-		exp   string
-		expOK bool
-	}{
-		{
-			name: "typical",
-			args: []string{"pizzas", "ahoy", "--treatsa", "fun"},
-			cfg: &argh.ParserConfig{
-				Prog: &argh.CommandConfig{
-					Commands: &argh.Commands{
-						Map: map[string]argh.CommandConfig{
-							"ahoy": argh.CommandConfig{
-								Flags: &argh.Flags{
-									Map: map[string]argh.FlagConfig{
-										"treatsa": argh.FlagConfig{NValue: 1},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-			exp:   "pizzas",
-			expOK: true,
-		},
-		{
-			name:  "minimal",
-			args:  []string{"pizzas"},
-			exp:   "pizzas",
-			expOK: true,
-		},
-		{
-			name:  "invalid",
-			args:  []string{},
-			expOK: false,
-		},
-	} {
-		t.Run(tc.name, func(ct *testing.T) {
-			pt, err := argh.ParseArgs(tc.args, tc.cfg)
-			require.Nil(ct, err)
-
-			prog, ok := argh.NewQuerier(pt.Nodes).Program()
-			require.Equal(ct, tc.expOK, ok)
-			require.Equal(ct, tc.exp, prog.Name)
-		})
-	}
-}