extract collection literal parsing helpers

Author: mgomes

docs/architecture.md

@@ -66,6 +66,7 @@ Key files:
 - `vibes/parser_expressions.go` (expression-level parsing and yield/case literals)
 - `vibes/parser_call_literals.go` (call argument parsing, keyword labels, and call blocks)
 - `vibes/parser_literals.go` (identifier and scalar literal parsing)
+- `vibes/parser_collection_literals.go` (array/hash literal parsing and symbol-style hash pairs)
 - `vibes/parser_block_literals.go` (block literals, block params, and typed union param parsing)
 - `vibes/parser_statements.go` (statement dispatch + return/raise/block parsing)
 - `vibes/parser_expression_statements.go` (expression/assert/assignment statement parsing)

vibes/parser_collection_literals.go

@@ -0,0 +1,78 @@
+package vibes
+
+import "fmt"
+
+func (p *parser) parseArrayLiteral() Expression {
+	pos := p.curToken.Pos
+	elements := []Expression{}
+
+	if p.peekToken.Type == tokenRBracket {
+		p.nextToken()
+		return &ArrayLiteral{Elements: elements, position: pos}
+	}
+
+	p.nextToken()
+	elements = append(elements, p.parseExpression(lowestPrec))
+
+	for p.peekToken.Type == tokenComma {
+		p.nextToken()
+		p.nextToken()
+		elements = append(elements, p.parseExpression(lowestPrec))
+	}
+
+	if !p.expectPeek(tokenRBracket) {
+		return nil
+	}
+
+	return &ArrayLiteral{Elements: elements, position: pos}
+}
+
+func (p *parser) parseHashLiteral() Expression {
+	pos := p.curToken.Pos
+	pairs := []HashPair{}
+
+	if p.peekToken.Type == tokenRBrace {
+		p.nextToken()
+		return &HashLiteral{Pairs: pairs, position: pos}
+	}
+
+	p.nextToken()
+	if pair := p.parseHashPair(); pair.Key != nil {
+		pairs = append(pairs, pair)
+	}
+
+	for p.peekToken.Type == tokenComma {
+		p.nextToken()
+		p.nextToken()
+		if pair := p.parseHashPair(); pair.Key != nil {
+			pairs = append(pairs, pair)
+		}
+	}
+
+	if !p.expectPeek(tokenRBrace) {
+		return nil
+	}
+
+	return &HashLiteral{Pairs: pairs, position: pos}
+}
+
+func (p *parser) parseHashPair() HashPair {
+	if !isLabelNameToken(p.curToken.Type) || p.peekToken.Type != tokenColon {
+		p.addParseError(p.curToken.Pos, "invalid hash pair: expected symbol-style key like name:")
+		return HashPair{}
+	}
+
+	key := &SymbolLiteral{Name: p.curToken.Literal, position: p.curToken.Pos}
+	p.nextToken()
+	p.nextToken()
+	if p.curToken.Type == tokenComma || p.curToken.Type == tokenRBrace {
+		p.addParseError(p.curToken.Pos, fmt.Sprintf("missing value for hash key %s", key.Name))
+		return HashPair{}
+	}
+
+	value := p.parseExpression(lowestPrec)
+	if value == nil {
+		return HashPair{}
+	}
+	return HashPair{Key: key, Value: value}
+}

vibes/parser_expressions.go

@@ -1,9 +1,5 @@
 package vibes
 
-import (
-	"fmt"
-)
-
 func (p *parser) parseExpression(precedence int) Expression {
 	prefix := p.prefixFns[p.curToken.Type]
 	if prefix == nil {
@@ -124,81 +120,6 @@ func (p *parser) parseGroupedExpression() Expression {
 	return expr
 }
 
-func (p *parser) parseArrayLiteral() Expression {
-	pos := p.curToken.Pos
-	elements := []Expression{}
-
-	if p.peekToken.Type == tokenRBracket {
-		p.nextToken()
-		return &ArrayLiteral{Elements: elements, position: pos}
-	}
-
-	p.nextToken()
-	elements = append(elements, p.parseExpression(lowestPrec))
-
-	for p.peekToken.Type == tokenComma {
-		p.nextToken()
-		p.nextToken()
-		elements = append(elements, p.parseExpression(lowestPrec))
-	}
-
-	if !p.expectPeek(tokenRBracket) {
-		return nil
-	}
-
-	return &ArrayLiteral{Elements: elements, position: pos}
-}
-
-func (p *parser) parseHashLiteral() Expression {
-	pos := p.curToken.Pos
-	pairs := []HashPair{}
-
-	if p.peekToken.Type == tokenRBrace {
-		p.nextToken()
-		return &HashLiteral{Pairs: pairs, position: pos}
-	}
-
-	p.nextToken()
-	if pair := p.parseHashPair(); pair.Key != nil {
-		pairs = append(pairs, pair)
-	}
-
-	for p.peekToken.Type == tokenComma {
-		p.nextToken()
-		p.nextToken()
-		if pair := p.parseHashPair(); pair.Key != nil {
-			pairs = append(pairs, pair)
-		}
-	}
-
-	if !p.expectPeek(tokenRBrace) {
-		return nil
-	}
-
-	return &HashLiteral{Pairs: pairs, position: pos}
-}
-
-func (p *parser) parseHashPair() HashPair {
-	if !isLabelNameToken(p.curToken.Type) || p.peekToken.Type != tokenColon {
-		p.addParseError(p.curToken.Pos, "invalid hash pair: expected symbol-style key like name:")
-		return HashPair{}
-	}
-
-	key := &SymbolLiteral{Name: p.curToken.Literal, position: p.curToken.Pos}
-	p.nextToken()
-	p.nextToken()
-	if p.curToken.Type == tokenComma || p.curToken.Type == tokenRBrace {
-		p.addParseError(p.curToken.Pos, fmt.Sprintf("missing value for hash key %s", key.Name))
-		return HashPair{}
-	}
-
-	value := p.parseExpression(lowestPrec)
-	if value == nil {
-		return HashPair{}
-	}
-	return HashPair{Key: key, Value: value}
-}
-
 func (p *parser) parsePrefixExpression() Expression {
 	pos := p.curToken.Pos
 	operator := p.curToken.Type