Fix nushell escape sequences and stream redirect operators

Nushell double-quoted strings use a richer C-style escape set than bash
(e.g. \n produces a newline character, not literal "n"). Add the
EscapingQuoteUnescaper interface so formats can provide full escape
translation instead of just backslash-dropping.

Nushell stream redirect operators (out>, err>, o+e>, e>|, etc.) are
multi-rune sequences that the single-rune tokenizer splits into separate
word and wordbreak tokens. Add a PostProcess step that merges these into
single WORDBREAK_TOKENs with correct classification, enabling proper
redirect filtering and pipeline splitting. Only bare words are merged —
quoted strings like 'out' are not treated as stream operators.

Assisted-by: Crush:glm-5.2

Author: rsteube

format.go

@@ -58,10 +58,21 @@ type Format interface {
 	QuoteWord(s string) string
 }
 
+// EscapingQuoteUnescaper is an optional interface for formats that need to
+// transform escape sequences inside double quotes beyond simple
+// backslash-dropping. When implemented, the ESCAPING_QUOTED_STATE handler
+// calls EscapingQuoteUnescape for the rune following a backslash. If the
+// rune is a recognized escape, the replacement string is used; otherwise
+// both the backslash and the rune are kept literally. Formats implementing
+// this interface take priority over EscapingQuoteEscapeChars.
+type EscapingQuoteUnescaper interface {
+	EscapingQuoteUnescape(r rune) (replacement string, handled bool)
+}
+
 // PostProcessor is an optional interface for formats that need to reclassify
 // tokens after the main tokenization pass. Used by formats that require
 // context not available in the flat state machine (e.g. elvish brace/lambda
-// context for | disambiguation).
+// context for | disambiguation, nushell stream-redirect operator merging).
 type PostProcessor interface {
 	PostProcess(tokens TokenSlice) TokenSlice
 }

format_nushell.go

@@ -1,12 +1,17 @@
 package shlex
 
+import "strings"
+
 // nushellFormat implements Format for nushell lexing.
 // Key differences from bash:
 // - Backtick (`) is a quote character (not an escape like PowerShell)
 // - $'...' and $"..." are interpolated strings ($ prefix + standard quote)
-// - r#'...'# raw strings need multi-rune opener support (deferred)
+// - C-style escapes in double quotes with a richer set than bash:
+//   \" \' \\ \/ \b \f \r \n \t \0 \a \e \( \) \{ \} \$ \^ \# \| \~ \xHH \u{X}
 // - No POSIX list operators (no &&, ||, &)
-// - C-style escapes in double quotes (same as bash)
+// - Stream redirect operators: out>, err>, out+err>, o>, e>, o+e>
+//   and pipe variants: e>|, err>|, o+e>|, out+err>|
+// - r#'...'# raw strings need multi-rune opener support (deferred)
 type nushellFormat struct{}
 
 // NushellFormat returns the nushell lexical format.
@@ -59,3 +64,115 @@ func (nushellFormat) NonEscapingQuoteBackslashEscapes() bool { return false }
 func (nushellFormat) EscapeNotBareword() bool                { return true }
 func (nushellFormat) EscapingQuoteEscapeChars() map[rune]bool { return nil }
 func (nushellFormat) QuoteWord(s string) string              { return nushellQuoteWord(s) }
+
+// EscapingQuoteUnescape implements the EscapingQuoteUnescaper interface.
+// Nushell double-quoted strings support C-style escapes with a richer set
+// than bash. Recognized escapes produce the corresponding character(s);
+// unrecognized escapes keep both the backslash and the rune literally
+// (nushell itself errors on unrecognized escapes, but for completion being
+// lenient is better than failing).
+func (nushellFormat) EscapingQuoteUnescape(r rune) (string, bool) {
+	switch r {
+	case '"':
+		return "\"", true
+	case '\'':
+		return "'", true
+	case '\\':
+		return "\\", true
+	case '/':
+		return "/", true
+	case 'b':
+		return "\b", true
+	case 'f':
+		return "\f", true
+	case 'r':
+		return "\r", true
+	case 'n':
+		return "\n", true
+	case 't':
+		return "\t", true
+	case '0':
+		return "\x00", true
+	case 'a':
+		return "\a", true
+	case 'e':
+		return "\x1b", true
+	case '(':
+		return "(", true
+	case ')':
+		return ")", true
+	case '{':
+		return "{", true
+	case '}':
+		return "}", true
+	case '$':
+		return "$", true
+	case '^':
+		return "^", true
+	case '#':
+		return "#", true
+	case '|':
+		return "|", true
+	case '~':
+		return "~", true
+	default:
+		return "", false
+	}
+}
+
+// nushellStreamRedirects maps the word portion of stream-redirect operators
+// (the part before >) to their WordbreakType. The PostProcess step merges
+// these with a following > or >| wordbreak token.
+var nushellStreamRedirects = map[string]WordbreakType{
+	"out":     WORDBREAK_REDIRECT_OUTPUT,
+	"err":     WORDBREAK_REDIRECT_OUTPUT,
+	"o":       WORDBREAK_REDIRECT_OUTPUT,
+	"e":       WORDBREAK_REDIRECT_OUTPUT,
+	"out+err": WORDBREAK_REDIRECT_OUTPUT_BOTH,
+	"o+e":     WORDBREAK_REDIRECT_OUTPUT_BOTH,
+}
+
+// PostProcess merges nushell stream-redirect operators. The tokenizer
+// produces e.g. `out` as a WORD_TOKEN and `>` (or `>|`, `>>`) as a
+// WORDBREAK_TOKEN because the rune-classifier only handles single-rune
+// word breaks. This step detects adjacent word+wordbreak sequences like
+// `out>`, `err>`, `o+e>`, `e>|`, `o+e>|` and reclassifies them as single
+// WORDBREAK_TOKENs with the appropriate WordbreakType.
+func (nushellFormat) PostProcess(tokens TokenSlice) TokenSlice {
+	result := make(TokenSlice, 0, len(tokens))
+	for i := 0; i < len(tokens); i++ {
+		t := tokens[i]
+
+		// Look for bare WORD_TOKEN immediately followed by WORDBREAK_TOKEN starting with '>'
+		// Only merge bare words (Value == RawValue) — quoted words like 'out' or "out"
+		// are string literals, not stream redirect operators.
+		if t.Type == WORD_TOKEN && t.Value == t.RawValue && i+1 < len(tokens) {
+			next := tokens[i+1]
+			if next.Type == WORDBREAK_TOKEN && next.adjoins(t) && len(next.RawValue) > 0 && next.RawValue[0] == '>' {
+				if wbType, ok := nushellStreamRedirects[t.Value]; ok {
+					// Check if the wordbreak token includes a pipe suffix (e.g. >|)
+					// which makes it a pipe-with-stderr variant
+					if strings.Contains(next.RawValue, "|") {
+						wbType = WORDBREAK_PIPE_WITH_STDERR
+					}
+
+					merged := Token{
+						Type:          WORDBREAK_TOKEN,
+						Value:         t.Value + next.Value,
+						RawValue:      t.RawValue + next.RawValue,
+						Span:          Span{Start: t.Span.Start, End: next.Span.End},
+						State:         next.State,
+						WordbreakType: wbType,
+					}
+
+					result = append(result, merged)
+					i += 1
+					continue
+				}
+			}
+		}
+
+		result = append(result, t)
+	}
+	return result
+}