Method parseArray

internal/parser/parser.go:733–813

Assumes that the leading '[' has already been consumed and passed as tok. Should read up to and consume the trailing ']'

(tok *token)

// Assumes that the leading '[' has already been consumed and passed as tok.
// Should read up to and consume the trailing ']'
func (p *parser) parseArray(tok *token) (ast.Node, errors.StaticError) {
	if p.peek().kind == tokenBracketR {
		bracketR := p.pop()
		return &ast.Array{
			NodeBase:    ast.NewNodeBaseLoc(locFromTokens(tok, bracketR), tok.fodder),
			CloseFodder: bracketR.fodder,
		}, nil
	}

	first, err := p.parse(iast.MaxPrecedence)
	if err != nil {
		return nil, err
	}
	var gotComma bool
	var commaFodder ast.Fodder
	if p.peek().kind == tokenComma {
		comma := p.pop()
		gotComma = true
		commaFodder = comma.fodder
	}

	if p.peek().kind == tokenFor {
		// It's a comprehension
		forToken := p.pop()
		spec, last, err := p.parseComprehensionSpecs(forToken, tokenBracketR)
		if err != nil {
			return nil, err
		}
		return &ast.ArrayComp{
			NodeBase:            ast.NewNodeBaseLoc(locFromTokens(tok, last), tok.fodder),
			Body:                first,
			TrailingComma:       gotComma,
			TrailingCommaFodder: commaFodder,
			Spec:                *spec,
			CloseFodder:         last.fodder,
		}, nil
	}

	// Not a comprehension: It can have more elements.
	elements := []ast.CommaSeparatedExpr{{
		Expr:        first,
		CommaFodder: commaFodder,
	}}

	var bracketR *token
	for {
		next := p.peek()

		if next.kind == tokenBracketR {
			bracketR = p.pop()
			break
		}
		if !gotComma {
			return nil, errors.MakeStaticError("Expected a comma before next array element", next.loc)
		}
		nextElem, err := p.parse(iast.MaxPrecedence)
		if err != nil {
			return nil, err