Method parse

internal/parser/parser.go:983–1379

(prec iast.Precedence)

}

func (p *parser) parse(prec iast.Precedence) (ast.Node, errors.StaticError) {
	begin := p.peek()

	switch begin.kind {
	// These cases have effectively iast.MaxPrecedence as the first
	// call to parse will parse them.
	case tokenAssert:
		p.pop()
		cond, err := p.parse(iast.MaxPrecedence)
		if err != nil {
			return nil, err
		}
		var msg ast.Node
		var colonFodder ast.Fodder
		if p.peek().kind == tokenOperator && p.peek().data == ":" {
			colon := p.pop()
			colonFodder = colon.fodder
			msg, err = p.parse(iast.MaxPrecedence)
			if err != nil {
				return nil, err
			}
		}
		semicolon, err := p.popExpect(tokenSemicolon)
		if err != nil {
			return nil, err
		}
		rest, err := p.parse(iast.MaxPrecedence)
		if err != nil {
			return nil, err
		}
		return &ast.Assert{
			NodeBase:        ast.NewNodeBaseLoc(locFromTokenAST(begin, rest), begin.fodder),
			Cond:            cond,
			ColonFodder:     colonFodder,
			Message:         msg,
			SemicolonFodder: semicolon.fodder,
			Rest:            rest,
		}, nil

	case tokenError:
		p.pop()
		expr, err := p.parse(iast.MaxPrecedence)
		if err != nil {
			return nil, err
		}
		return &ast.Error{
			NodeBase: ast.NewNodeBaseLoc(locFromTokenAST(begin, expr), begin.fodder),
			Expr:     expr,
		}, nil

	case tokenIf:
		p.pop()
		cond, err := p.parse(iast.MaxPrecedence)
		if err != nil {
			return nil, err
		}
		thenToken, err := p.popExpect(tokenThen)
		if err != nil {