fix(format): preserve square brackets in SIMD operands

Assisted-by: GLM 5.3 Flash

format/format.go

@@ -300,6 +300,26 @@ func wouldMerge(prev, cur token.Token) bool {
 	return len(kinds) != 2 || kinds[0] != prev.Kind || kinds[1] != cur.Kind
 }
 
+// isOperandBracket reports whether t is one of the square-bracket tokens the
+// lexer emits, as Illegal tokens carrying their spelling, for the arm64 and
+// loong64 register lists and element selectors that valid GAsm source
+// contains.
+func isOperandBracket(t token.Token) bool {
+	return t.Kind == token.Illegal && (t.Text == "[" || t.Text == "]")
+}
+
+// isOpenBracket reports whether t is the '[' of a register list or element
+// selector.
+func isOpenBracket(t token.Token) bool {
+	return t.Kind == token.Illegal && t.Text == "["
+}
+
+// isCloseBracket reports whether t is the ']' that closes a register list or
+// element selector.
+func isCloseBracket(t token.Token) bool {
+	return t.Kind == token.Illegal && t.Text == "]"
+}
+
 // spaceBetween decides whether a single space separates prev and cur.
 func spaceBetween(prev, cur token.Token) bool {
 	// '/' beside '/' or '*' would form a comment opener in the output and
@@ -308,6 +328,22 @@ func spaceBetween(prev, cur token.Token) bool {
 		return true
 	}
 	switch cur.Kind {
+	case token.Illegal:
+		// A closing bracket always glues to the text it closes.  An opening
+		// bracket glues to the operand it extends (V31.B[15]) but takes its
+		// own space after a comma, a mnemonic or an operator, exactly like
+		// the parenthesis rule below.  Any other Illegal spelling is stray.
+		if isCloseBracket(cur) {
+			return false
+		}
+		if isOpenBracket(cur) {
+			switch prev.Kind {
+			case token.Ident, token.Number, token.RParen, token.RAngle:
+				return false
+			}
+			return true
+		}
+		return true
 	case token.RParen:
 		return false
 	case token.Comma:
@@ -328,6 +364,10 @@ func spaceBetween(prev, cur token.Token) bool {
 		}
 	}
 	switch prev.Kind {
+	case token.Illegal:
+		// '[' opens a bracket group and glues to what follows; ']' closes
+		// one, and what comes next takes its own space.
+		return !isOpenBracket(prev)
 	case token.LParen, token.Star, token.Plus, token.Minus, token.Slash, token.Pipe:
 		return false
 	case token.Dollar:
@@ -358,8 +398,15 @@ func splitLines(toks []token.Token) [][]token.Token {
 			// Illegal tokens carry no canonical spelling: the parser
 			// reports them as errors where they matter, and the formatter
 			// drops them so that a stray character cannot survive into the
-			// output and make the next pass render a different file.
-			continue
+			// output and make the next pass render a different file.  The
+			// square brackets of the arm64 and loong64 vector syntaxes are
+			// the one exception: the lexer gives them no dedicated kind,
+			// but a register list [V0.B16, V1.B16] and an element selector
+			// V0.B[3] are valid, load-bearing source, so their tokens stay
+			// in the stream and renderOps glues them back where they were.
+			if !isOperandBracket(t) {
+				continue
+			}
 		}
 		if t.Kind == token.Newline {
 			lines = append(lines, cur)