Simplify CompletionContext — remove unused substitution metadata

Remove SubstitutionDepth, SubstitutionKind, SubstitutionScope,
SubstitutionScopes, and related helpers. The inner-first approach
means the standard fields (Words, CurrentWord, etc.) already
describe the inner command when inside a substitution — callers
don't need depth/kind metadata. Replace with a single
innermostUnclosedCommandScope helper that finds the innermost
unclosed $( opener and extracts inner tokens.

Assisted-by: Crush:glm-5.2

Author: rsteube-bot

completion.go

@@ -5,8 +5,8 @@ package shlex
 // tokens.CurrentPipeline().FilterRedirects().Words().CurrentToken() chains.
 type CompletionContext struct {
 	// Words are the dequoted word values in the current pipeline
-	// (redirects filtered). Equivalent to:
-	//   tokens.CurrentPipeline().FilterRedirects().Words().Strings()
+	// (redirects filtered). When the cursor is inside a substitution
+	// scope (e.g. $(...), these are the inner command's words.
 	Words []string
 
 	// CurrentWord is the word at the cursor position (dequoted Value).
@@ -17,13 +17,11 @@ type CompletionContext struct {
 	RawCurrentWord string
 
 	// Prefix is the wordbreak prefix up to the cursor.
-	// Equivalent to tokens.CurrentPipeline().WordbreakPrefix().
 	Prefix string
 
 	// QuotingState is the lexer state of the current word.
 	// IN_WORD_STATE, QUOTING_STATE, QUOTING_ESCAPING_STATE, QUOTING_TRIPLE_STATE,
 	// QUOTING_TRIPLE_ESCAPING_STATE, or ESCAPING_STATE.
-	// Replaces the regex-based quoting detection in carapace's zsh action.
 	QuotingState LexerState
 
 	// IsRedirect is true when the cursor is completing a redirect target
@@ -39,57 +37,31 @@ type CompletionContext struct {
 	// redirect filtering and word merging). Use this as an escape hatch
 	// for edge cases not covered by the fields above.
 	Pipeline TokenSlice
-
-	// SubstitutionDepth is the number of unclosed substitution scopes at
-	// the cursor position. 0 = cursor at top level. When > 0, all other
-	// fields (Words, CurrentWord, etc.) describe the innermost
-	// substitution's command, not the outer command.
-	SubstitutionDepth int
-
-	// SubstitutionKind indicates what type of substitution the cursor is
-	// inside (command, arithmetic, backtick). Only meaningful when
-	// SubstitutionDepth > 0.
-	SubstitutionKind SubstitutionKind
 }
 
 // SplitForCompletion parses s and returns a CompletionContext describing
 // the completion state at the end of the string, using the given format.
 //
 // When the cursor is inside an unclosed substitution scope (e.g. inside
-// $(...), the returned context describes the innermost substitution's
-// command, not the outer command. SubstitutionDepth indicates how many
-// nesting levels deep the cursor is.
+// $(...), the context describes the innermost substitution's command,
+// not the outer command.
 func SplitForCompletion(s string, format Format) *CompletionContext {
 	tokens, err := SplitWith(s, format)
 	if err != nil || len(tokens) == 0 {
 		return &CompletionContext{QuotingState: START_STATE}
 	}
 
-	// Check for unclosed substitution scopes at cursor
-	scopes := tokens.SubstitutionScopes()
-	innermost := innermostUnclosedScope(scopes)
-
-	if innermost != nil && innermost.Kind != SUBSTITUTION_ARITHMETIC && innermost.OpenIndex >= 0 {
-		// Cursor inside a command substitution — build context from inner tokens
-		innerTokens := tokens[innermost.OpenIndex+1:]
-		ctx := buildCompletionContext(innerTokens)
-		ctx.SubstitutionDepth = countUnclosedScopes(scopes)
-		ctx.SubstitutionKind = innermost.Kind
-		return ctx
+	// If cursor is inside an unclosed command substitution, build the
+	// context from the inner tokens.
+	if scope := innermostUnclosedCommandScope(tokens); scope >= 0 {
+		return buildCompletionContext(tokens[scope+1:])
 	}
 
-	// Cursor at top level (or inside arithmetic/backtick — no inner command)
-	ctx := buildCompletionContext(tokens)
-	if innermost != nil {
-		ctx.SubstitutionDepth = countUnclosedScopes(scopes)
-		ctx.SubstitutionKind = innermost.Kind
-	}
-	return ctx
+	return buildCompletionContext(tokens)
 }
 
 // buildCompletionContext derives the completion context fields from a
-// token slice. It is called by SplitForCompletion with either the full
-// token slice (top-level) or the inner tokens of an unclosed substitution.
+// token slice.
 func buildCompletionContext(tokens TokenSlice) *CompletionContext {
 	pipeline := tokens.CurrentPipeline()
 	filtered := pipeline.FilterRedirects()
@@ -101,8 +73,6 @@ func buildCompletionContext(tokens TokenSlice) *CompletionContext {
 		Pipeline: pipeline,
 	}
 
-	// Detect redirect: if the second-to-last token in the pipeline is a redirect
-	// wordbreak, the current word is a redirect target.
 	if len(pipeline) >= 2 {
 		prev := pipeline[len(pipeline)-2]
 		if prev.WordbreakType.IsRedirect() {
@@ -111,8 +81,6 @@ func buildCompletionContext(tokens TokenSlice) *CompletionContext {
 	}
 
 	if ctx.IsRedirect {
-		// For redirects, the current word is the redirect target which was
-		// filtered out of the words list. Get it from the raw pipeline.
 		current := pipeline[len(pipeline)-1]
 		ctx.CurrentWord = current.Value
 		ctx.RawCurrentWord = current.RawValue
@@ -126,8 +94,6 @@ func buildCompletionContext(tokens TokenSlice) *CompletionContext {
 
 	ctx.Prefix = pipeline.WordbreakPrefix()
 
-	// Detect lambda parameter context: an odd number of WORDBREAK_LAMBDA_PIPE
-	// tokens in the current pipeline means we're inside an unclosed {|...| parameter list.
 	lambdaPipeCount := 0
 	for _, t := range pipeline {
 		if t.Type == WORDBREAK_TOKEN && t.WordbreakType == WORDBREAK_LAMBDA_PIPE {

format_elvish_test.go

@@ -409,9 +409,6 @@ func TestElvishFormat_OutputCaptureCompletion(t *testing.T) {
 	// Cursor inside output capture: echo (ls
 	// The ( opens a substitution scope, so the inner context is "ls"
 	ctx := SplitForCompletion("echo (ls", ElvishFormat())
-	if ctx.SubstitutionDepth != 1 {
-		t.Errorf("elvish output capture completion: SubstitutionDepth = %v, want 1", ctx.SubstitutionDepth)
-	}
 	if len(ctx.Words) != 1 || ctx.Words[0] != "ls" {
 		t.Errorf("elvish output capture completion: Words = %v, want [ls]", ctx.Words)
 	}

substitution.go

@@ -1,151 +1,42 @@
 package shlex
 
-import "encoding/json"
-
-// SubstitutionKind classifies the type of substitution scope.
-type SubstitutionKind int
-
-const (
-	// SUBSTITUTION_COMMAND is $(...), (...), or similar command/output capture.
-	SUBSTITUTION_COMMAND SubstitutionKind = iota
-	// SUBSTITUTION_ARITHMETIC is $((...)).
-	SUBSTITUTION_ARITHMETIC
-	// SUBSTITUTION_BACKTICK is `...` (POSIX backtick command substitution).
-	SUBSTITUTION_BACKTICK
-)
-
-var substitutionKinds = map[SubstitutionKind]string{
-	SUBSTITUTION_COMMAND:    "SUBSTITUTION_COMMAND",
-	SUBSTITUTION_ARITHMETIC: "SUBSTITUTION_ARITHMETIC",
-	SUBSTITUTION_BACKTICK:   "SUBSTITUTION_BACKTICK",
-}
-
-func (k SubstitutionKind) MarshalJSON() ([]byte, error) {
-	return json.Marshal(substitutionKinds[k])
-}
-
-// SubstitutionScope describes a single substitution nesting level in the
-// token stream.
-type SubstitutionScope struct {
-	OpenIndex  int // TokenSlice index of the opener token
-	CloseIndex int // TokenSlice index of the closer token, or -1 if unclosed
-	Kind       SubstitutionKind
-	Depth      int // nesting depth at this scope (1 = outermost)
-}
-
-// SubstitutionScopes returns all substitution scopes in the token slice,
-// ordered by open position. Unclosed scopes (cursor inside) have
-// CloseIndex == -1. Backtick scopes are detected by scanning WORD_TOKEN
-// RawValue for unescaped backticks and have OpenIndex == -1 (since there
-// is no single opener token in the stream).
-func (t TokenSlice) SubstitutionScopes() []SubstitutionScope {
-	var scopes []SubstitutionScope
-	var stack []SubstitutionScope
-
-	for i, token := range t {
-		switch {
-		case token.WordbreakType == WORDBREAK_SUBSTITUTION_OPEN:
-			kind := SUBSTITUTION_COMMAND
-			// Detect arithmetic $(( : the opener RawValue contains two '('
-			if len(token.RawValue) >= 2 && token.RawValue[len(token.RawValue)-2] == '(' {
-				kind = SUBSTITUTION_ARITHMETIC
+// innermostUnclosedCommandScope returns the TokenSlice index of the opener
+// of the innermost unclosed command substitution scope, or -1 if the cursor
+// is at top level. Arithmetic ($((...))) and backtick scopes are not
+// command scopes — they don't produce an inner completion context.
+func innermostUnclosedCommandScope(tokens TokenSlice) int {
+	depth := 0
+	lastOpen := -1
+
+	for i, t := range tokens {
+		switch t.WordbreakType {
+		case WORDBREAK_SUBSTITUTION_OPEN:
+			if isArithmeticOpener(t) {
+				continue
 			}
-			scope := SubstitutionScope{
-				OpenIndex:  i,
-				CloseIndex: -1,
-				Kind:       kind,
-				Depth:      len(stack) + 1,
+			depth++
+			lastOpen = i
+		case WORDBREAK_SUBSTITUTION_CLOSE:
+			if isArithmeticCloser(t) {
+				continue
 			}
-			stack = append(stack, scope)
-
-		case token.WordbreakType == WORDBREAK_SUBSTITUTION_CLOSE:
-			if len(stack) > 0 {
-				scope := &stack[len(stack)-1]
-				scope.CloseIndex = i
-				scopes = append(scopes, *scope)
-				stack = stack[:len(stack)-1]
+			depth--
+			if depth == 0 {
+				lastOpen = -1
 			}
 		}
 	}
 
-	// Any unclosed scopes remain on the stack
-	for j := range stack {
-		s := stack[j]
-		scopes = append(scopes, s)
-	}
-
-	// Scan for backtick substitution in WORD_TOKEN RawValues.
-	// This is detect-only: backtick content is already merged into
-	// word tokens by the tokenizer, so we can't extract inner tokens.
-	scopes = append(scopes, t.detectBacktickScopes()...)
-
-	return scopes
-}
-
-// detectBacktickScopes scans WORD_TOKENs for unescaped backticks.
-// An odd count of backticks in a single word's RawValue indicates an
-// unclosed backtick substitution starting at that word. The scope has
-// OpenIndex == -1 (no single opener token) and Kind == SUBSTITUTION_BACKTICK.
-func (t TokenSlice) detectBacktickScopes() []SubstitutionScope {
-	var scopes []SubstitutionScope
-	for i, token := range t {
-		if token.Type != WORD_TOKEN {
-			continue
-		}
-		count := countUnescapedBackticks(token.RawValue)
-		if count%2 == 1 {
-			scopes = append(scopes, SubstitutionScope{
-				OpenIndex:  -1,
-				CloseIndex: -1,
-				Kind:       SUBSTITUTION_BACKTICK,
-				Depth:      1,
-			})
-			_ = i // index kept for potential future use
-		}
-	}
-	return scopes
-}
-
-// countUnescapedBackticks counts backtick characters in s that are not
-// preceded by an escape character (backslash).
-func countUnescapedBackticks(s string) int {
-	count := 0
-	runes := []rune(s)
-	for i, r := range runes {
-		if r == '`' {
-			if i > 0 && runes[i-1] == '\\' {
-				continue // escaped backtick
-			}
-			count++
-		}
+	if depth > 0 {
+		return lastOpen
 	}
-	return count
+	return -1
 }
 
-// innermostUnclosedScope returns the unclosed substitution scope with the
-// greatest depth, or nil if all scopes are closed. When the cursor is
-// inside a substitution, this is the scope whose content forms the inner
-// completion context.
-func innermostUnclosedScope(scopes []SubstitutionScope) *SubstitutionScope {
-	var result *SubstitutionScope
-	for i := range scopes {
-		s := &scopes[i]
-		if s.CloseIndex == -1 {
-			if result == nil || s.Depth > result.Depth {
-				result = s
-			}
-		}
-	}
-	return result
+func isArithmeticOpener(t Token) bool {
+	return len(t.RawValue) >= 2 && t.RawValue[len(t.RawValue)-2] == '('
 }
 
-// countUnclosedScopes returns the number of scopes with CloseIndex == -1.
-func countUnclosedScopes(scopes []SubstitutionScope) int {
-	count := 0
-	for _, s := range scopes {
-		if s.CloseIndex == -1 {
-			count++
-		}
-	}
-	return count
+func isArithmeticCloser(t Token) bool {
+	return len(t.RawValue) >= 2 && t.RawValue[0] == ')' && t.RawValue[1] == ')'
 }