Update to tengo v2 (#976)

1 files changed, 0 insertions, 1216 deletions

diff --git a/vendor/github.com/d5/tengo/compiler/parser/parser.go b/vendor/github.com/d5/tengo/compiler/parser/parser.go
deleted file mode 100644
index 27dd48f0..00000000
--- a/vendor/github.com/d5/tengo/compiler/parser/parser.go
+++ /dev/null
@@ -1,1216 +0,0 @@
-/*
-	Parser parses the Tengo source files.
-
-	Parser is a modified version of Go's parser implementation.
-
-	Copyright 2009 The Go Authors. All rights reserved.
-	Use of this source code is governed by a BSD-style
-	license that can be found in the LICENSE file.
-*/
-
-package parser
-
-import (
-	"fmt"
-	"io"
-	"strconv"
-
-	"github.com/d5/tengo/compiler/ast"
-	"github.com/d5/tengo/compiler/scanner"
-	"github.com/d5/tengo/compiler/source"
-	"github.com/d5/tengo/compiler/token"
-)
-
-type bailout struct{}
-
-// Parser parses the Tengo source files.
-type Parser struct {
-	file      *source.File
-	errors    ErrorList
-	scanner   *scanner.Scanner
-	pos       source.Pos
-	token     token.Token
-	tokenLit  string
-	exprLevel int        // < 0: in control clause, >= 0: in expression
-	syncPos   source.Pos // last sync position
-	syncCount int        // number of advance calls without progress
-	trace     bool
-	indent    int
-	traceOut  io.Writer
-}
-
-// NewParser creates a Parser.
-func NewParser(file *source.File, src []byte, trace io.Writer) *Parser {
-	p := &Parser{
-		file:     file,
-		trace:    trace != nil,
-		traceOut: trace,
-	}
-
-	p.scanner = scanner.NewScanner(p.file, src, func(pos source.FilePos, msg string) {
-		p.errors.Add(pos, msg)
-	}, 0)
-
-	p.next()
-
-	return p
-}
-
-// ParseFile parses the source and returns an AST file unit.
-func (p *Parser) ParseFile() (file *ast.File, err error) {
-	defer func() {
-		if e := recover(); e != nil {
-			if _, ok := e.(bailout); !ok {
-				panic(e)
-			}
-		}
-
-		p.errors.Sort()
-		err = p.errors.Err()
-	}()
-
-	if p.trace {
-		defer un(trace(p, "File"))
-	}
-
-	if p.errors.Len() > 0 {
-		return nil, p.errors.Err()
-	}
-
-	stmts := p.parseStmtList()
-	if p.errors.Len() > 0 {
-		return nil, p.errors.Err()
-	}
-
-	file = &ast.File{
-		InputFile: p.file,
-		Stmts:     stmts,
-	}
-
-	return
-}
-
-func (p *Parser) parseExpr() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Expression"))
-	}
-
-	expr := p.parseBinaryExpr(token.LowestPrec + 1)
-
-	// ternary conditional expression
-	if p.token == token.Question {
-		return p.parseCondExpr(expr)
-	}
-
-	return expr
-}
-
-func (p *Parser) parseBinaryExpr(prec1 int) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "BinaryExpression"))
-	}
-
-	x := p.parseUnaryExpr()
-
-	for {
-		op, prec := p.token, p.token.Precedence()
-		if prec < prec1 {
-			return x
-		}
-
-		pos := p.expect(op)
-
-		y := p.parseBinaryExpr(prec + 1)
-
-		x = &ast.BinaryExpr{
-			LHS:      x,
-			RHS:      y,
-			Token:    op,
-			TokenPos: pos,
-		}
-	}
-}
-
-func (p *Parser) parseCondExpr(cond ast.Expr) ast.Expr {
-	questionPos := p.expect(token.Question)
-
-	trueExpr := p.parseExpr()
-
-	colonPos := p.expect(token.Colon)
-
-	falseExpr := p.parseExpr()
-
-	return &ast.CondExpr{
-		Cond:        cond,
-		True:        trueExpr,
-		False:       falseExpr,
-		QuestionPos: questionPos,
-		ColonPos:    colonPos,
-	}
-}
-
-func (p *Parser) parseUnaryExpr() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "UnaryExpression"))
-	}
-
-	switch p.token {
-	case token.Add, token.Sub, token.Not, token.Xor:
-		pos, op := p.pos, p.token
-		p.next()
-		x := p.parseUnaryExpr()
-		return &ast.UnaryExpr{
-			Token:    op,
-			TokenPos: pos,
-			Expr:     x,
-		}
-	}
-
-	return p.parsePrimaryExpr()
-}
-
-func (p *Parser) parsePrimaryExpr() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "PrimaryExpression"))
-	}
-
-	x := p.parseOperand()
-
-L:
-	for {
-		switch p.token {
-		case token.Period:
-			p.next()
-
-			switch p.token {
-			case token.Ident:
-				x = p.parseSelector(x)
-			default:
-				pos := p.pos
-				p.errorExpected(pos, "selector")
-				p.advance(stmtStart)
-				return &ast.BadExpr{From: pos, To: p.pos}
-			}
-		case token.LBrack:
-			x = p.parseIndexOrSlice(x)
-		case token.LParen:
-			x = p.parseCall(x)
-		default:
-			break L
-		}
-	}
-
-	return x
-}
-
-func (p *Parser) parseCall(x ast.Expr) *ast.CallExpr {
-	if p.trace {
-		defer un(trace(p, "Call"))
-	}
-
-	lparen := p.expect(token.LParen)
-	p.exprLevel++
-
-	var list []ast.Expr
-	for p.token != token.RParen && p.token != token.EOF {
-		list = append(list, p.parseExpr())
-
-		if !p.expectComma(token.RParen, "call argument") {
-			break
-		}
-	}
-
-	p.exprLevel--
-	rparen := p.expect(token.RParen)
-
-	return &ast.CallExpr{
-		Func:   x,
-		LParen: lparen,
-		RParen: rparen,
-		Args:   list,
-	}
-}
-
-func (p *Parser) expectComma(closing token.Token, want string) bool {
-	if p.token == token.Comma {
-		p.next()
-
-		if p.token == closing {
-			p.errorExpected(p.pos, want)
-			return false
-		}
-
-		return true
-	}
-
-	if p.token == token.Semicolon && p.tokenLit == "\n" {
-		p.next()
-	}
-
-	return false
-}
-
-func (p *Parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "IndexOrSlice"))
-	}
-
-	lbrack := p.expect(token.LBrack)
-	p.exprLevel++
-
-	var index [2]ast.Expr
-	if p.token != token.Colon {
-		index[0] = p.parseExpr()
-	}
-	numColons := 0
-	if p.token == token.Colon {
-		numColons++
-		p.next()
-
-		if p.token != token.RBrack && p.token != token.EOF {
-			index[1] = p.parseExpr()
-		}
-	}
-
-	p.exprLevel--
-	rbrack := p.expect(token.RBrack)
-
-	if numColons > 0 {
-		// slice expression
-		return &ast.SliceExpr{
-			Expr:   x,
-			LBrack: lbrack,
-			RBrack: rbrack,
-			Low:    index[0],
-			High:   index[1],
-		}
-	}
-
-	return &ast.IndexExpr{
-		Expr:   x,
-		LBrack: lbrack,
-		RBrack: rbrack,
-		Index:  index[0],
-	}
-}
-
-func (p *Parser) parseSelector(x ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Selector"))
-	}
-
-	sel := p.parseIdent()
-
-	return &ast.SelectorExpr{Expr: x, Sel: &ast.StringLit{
-		Value:    sel.Name,
-		ValuePos: sel.NamePos,
-		Literal:  sel.Name,
-	}}
-}
-
-func (p *Parser) parseOperand() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Operand"))
-	}
-
-	switch p.token {
-	case token.Ident:
-		return p.parseIdent()
-
-	case token.Int:
-		v, _ := strconv.ParseInt(p.tokenLit, 10, 64)
-		x := &ast.IntLit{
-			Value:    v,
-			ValuePos: p.pos,
-			Literal:  p.tokenLit,
-		}
-		p.next()
-		return x
-
-	case token.Float:
-		v, _ := strconv.ParseFloat(p.tokenLit, 64)
-		x := &ast.FloatLit{
-			Value:    v,
-			ValuePos: p.pos,
-			Literal:  p.tokenLit,
-		}
-		p.next()
-		return x
-
-	case token.Char:
-		return p.parseCharLit()
-
-	case token.String:
-		v, _ := strconv.Unquote(p.tokenLit)
-		x := &ast.StringLit{
-			Value:    v,
-			ValuePos: p.pos,
-			Literal:  p.tokenLit,
-		}
-		p.next()
-		return x
-
-	case token.True:
-		x := &ast.BoolLit{
-			Value:    true,
-			ValuePos: p.pos,
-			Literal:  p.tokenLit,
-		}
-		p.next()
-		return x
-
-	case token.False:
-		x := &ast.BoolLit{
-			Value:    false,
-			ValuePos: p.pos,
-			Literal:  p.tokenLit,
-		}
-		p.next()
-		return x
-
-	case token.Undefined:
-		x := &ast.UndefinedLit{TokenPos: p.pos}
-		p.next()
-		return x
-
-	case token.Import:
-		return p.parseImportExpr()
-
-	case token.LParen:
-		lparen := p.pos
-		p.next()
-		p.exprLevel++
-		x := p.parseExpr()
-		p.exprLevel--
-		rparen := p.expect(token.RParen)
-		return &ast.ParenExpr{
-			LParen: lparen,
-			Expr:   x,
-			RParen: rparen,
-		}
-
-	case token.LBrack: // array literal
-		return p.parseArrayLit()
-
-	case token.LBrace: // map literal
-		return p.parseMapLit()
-
-	case token.Func: // function literal
-		return p.parseFuncLit()
-
-	case token.Error: // error expression
-		return p.parseErrorExpr()
-
-	case token.Immutable: // immutable expression
-		return p.parseImmutableExpr()
-	}
-
-	pos := p.pos
-	p.errorExpected(pos, "operand")
-	p.advance(stmtStart)
-	return &ast.BadExpr{From: pos, To: p.pos}
-}
-
-func (p *Parser) parseImportExpr() ast.Expr {
-	pos := p.pos
-
-	p.next()
-
-	p.expect(token.LParen)
-
-	if p.token != token.String {
-		p.errorExpected(p.pos, "module name")
-		p.advance(stmtStart)
-		return &ast.BadExpr{From: pos, To: p.pos}
-	}
-
-	// module name
-	moduleName, _ := strconv.Unquote(p.tokenLit)
-
-	expr := &ast.ImportExpr{
-		ModuleName: moduleName,
-		Token:      token.Import,
-		TokenPos:   pos,
-	}
-
-	p.next()
-
-	p.expect(token.RParen)
-
-	return expr
-}
-
-func (p *Parser) parseCharLit() ast.Expr {
-	if n := len(p.tokenLit); n >= 3 {
-		if code, _, _, err := strconv.UnquoteChar(p.tokenLit[1:n-1], '\''); err == nil {
-			x := &ast.CharLit{
-				Value:    rune(code),
-				ValuePos: p.pos,
-				Literal:  p.tokenLit,
-			}
-			p.next()
-			return x
-		}
-	}
-
-	pos := p.pos
-	p.error(pos, "illegal char literal")
-	p.next()
-	return &ast.BadExpr{
-		From: pos,
-		To:   p.pos,
-	}
-}
-
-func (p *Parser) parseFuncLit() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "FuncLit"))
-	}
-
-	typ := p.parseFuncType()
-
-	p.exprLevel++
-	body := p.parseBody()
-	p.exprLevel--
-
-	return &ast.FuncLit{
-		Type: typ,
-		Body: body,
-	}
-}
-
-func (p *Parser) parseArrayLit() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "ArrayLit"))
-	}
-
-	lbrack := p.expect(token.LBrack)
-	p.exprLevel++
-
-	var elements []ast.Expr
-	for p.token != token.RBrack && p.token != token.EOF {
-		elements = append(elements, p.parseExpr())
-
-		if !p.expectComma(token.RBrack, "array element") {
-			break
-		}
-	}
-
-	p.exprLevel--
-	rbrack := p.expect(token.RBrack)
-
-	return &ast.ArrayLit{
-		Elements: elements,
-		LBrack:   lbrack,
-		RBrack:   rbrack,
-	}
-}
-
-func (p *Parser) parseErrorExpr() ast.Expr {
-	pos := p.pos
-
-	p.next()
-
-	lparen := p.expect(token.LParen)
-	value := p.parseExpr()
-	rparen := p.expect(token.RParen)
-
-	expr := &ast.ErrorExpr{
-		ErrorPos: pos,
-		Expr:     value,
-		LParen:   lparen,
-		RParen:   rparen,
-	}
-
-	return expr
-}
-
-func (p *Parser) parseImmutableExpr() ast.Expr {
-	pos := p.pos
-
-	p.next()
-
-	lparen := p.expect(token.LParen)
-	value := p.parseExpr()
-	rparen := p.expect(token.RParen)
-
-	expr := &ast.ImmutableExpr{
-		ErrorPos: pos,
-		Expr:     value,
-		LParen:   lparen,
-		RParen:   rparen,
-	}
-
-	return expr
-}
-
-func (p *Parser) parseFuncType() *ast.FuncType {
-	if p.trace {
-		defer un(trace(p, "FuncType"))
-	}
-
-	pos := p.expect(token.Func)
-	params := p.parseIdentList()
-
-	return &ast.FuncType{
-		FuncPos: pos,
-		Params:  params,
-	}
-}
-
-func (p *Parser) parseBody() *ast.BlockStmt {
-	if p.trace {
-		defer un(trace(p, "Body"))
-	}
-
-	lbrace := p.expect(token.LBrace)
-	list := p.parseStmtList()
-	rbrace := p.expect(token.RBrace)
-
-	return &ast.BlockStmt{
-		LBrace: lbrace,
-		RBrace: rbrace,
-		Stmts:  list,
-	}
-}
-
-func (p *Parser) parseStmtList() (list []ast.Stmt) {
-	if p.trace {
-		defer un(trace(p, "StatementList"))
-	}
-
-	for p.token != token.RBrace && p.token != token.EOF {
-		list = append(list, p.parseStmt())
-	}
-
-	return
-}
-
-func (p *Parser) parseIdent() *ast.Ident {
-	pos := p.pos
-	name := "_"
-
-	if p.token == token.Ident {
-		name = p.tokenLit
-		p.next()
-	} else {
-		p.expect(token.Ident)
-	}
-
-	return &ast.Ident{
-		NamePos: pos,
-		Name:    name,
-	}
-}
-
-func (p *Parser) parseIdentList() *ast.IdentList {
-	if p.trace {
-		defer un(trace(p, "IdentList"))
-	}
-
-	var params []*ast.Ident
-	lparen := p.expect(token.LParen)
-	isVarArgs := false
-	if p.token != token.RParen {
-		if p.token == token.Ellipsis {
-			isVarArgs = true
-			p.next()
-		}
-
-		params = append(params, p.parseIdent())
-		for !isVarArgs && p.token == token.Comma {
-			p.next()
-			if p.token == token.Ellipsis {
-				isVarArgs = true
-				p.next()
-			}
-			params = append(params, p.parseIdent())
-		}
-	}
-
-	rparen := p.expect(token.RParen)
-
-	return &ast.IdentList{
-		LParen:  lparen,
-		RParen:  rparen,
-		VarArgs: isVarArgs,
-		List:    params,
-	}
-}
-
-func (p *Parser) parseStmt() (stmt ast.Stmt) {
-	if p.trace {
-		defer un(trace(p, "Statement"))
-	}
-
-	switch p.token {
-	case // simple statements
-		token.Func, token.Error, token.Immutable, token.Ident, token.Int, token.Float, token.Char, token.String, token.True, token.False,
-		token.Undefined, token.Import, token.LParen, token.LBrace, token.LBrack,
-		token.Add, token.Sub, token.Mul, token.And, token.Xor, token.Not:
-		s := p.parseSimpleStmt(false)
-		p.expectSemi()
-		return s
-	case token.Return:
-		return p.parseReturnStmt()
-	case token.Export:
-		return p.parseExportStmt()
-	case token.If:
-		return p.parseIfStmt()
-	case token.For:
-		return p.parseForStmt()
-	case token.Break, token.Continue:
-		return p.parseBranchStmt(p.token)
-	case token.Semicolon:
-		s := &ast.EmptyStmt{Semicolon: p.pos, Implicit: p.tokenLit == "\n"}
-		p.next()
-		return s
-	case token.RBrace:
-		// semicolon may be omitted before a closing "}"
-		return &ast.EmptyStmt{Semicolon: p.pos, Implicit: true}
-	default:
-		pos := p.pos
-		p.errorExpected(pos, "statement")
-		p.advance(stmtStart)
-		return &ast.BadStmt{From: pos, To: p.pos}
-	}
-}
-
-func (p *Parser) parseForStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "ForStmt"))
-	}
-
-	pos := p.expect(token.For)
-
-	// for {}
-	if p.token == token.LBrace {
-		body := p.parseBlockStmt()
-		p.expectSemi()
-
-		return &ast.ForStmt{
-			ForPos: pos,
-			Body:   body,
-		}
-	}
-
-	prevLevel := p.exprLevel
-	p.exprLevel = -1
-
-	var s1 ast.Stmt
-	if p.token != token.Semicolon { // skipping init
-		s1 = p.parseSimpleStmt(true)
-	}
-
-	// for _ in seq {}            or
-	// for value in seq {}        or
-	// for key, value in seq {}
-	if forInStmt, isForIn := s1.(*ast.ForInStmt); isForIn {
-		forInStmt.ForPos = pos
-		p.exprLevel = prevLevel
-		forInStmt.Body = p.parseBlockStmt()
-		p.expectSemi()
-		return forInStmt
-	}
-
-	// for init; cond; post {}
-	var s2, s3 ast.Stmt
-	if p.token == token.Semicolon {
-		p.next()
-		if p.token != token.Semicolon {
-			s2 = p.parseSimpleStmt(false) // cond
-		}
-		p.expect(token.Semicolon)
-		if p.token != token.LBrace {
-			s3 = p.parseSimpleStmt(false) // post
-		}
-	} else {
-		// for cond {}
-		s2 = s1
-		s1 = nil
-	}
-
-	// body
-	p.exprLevel = prevLevel
-	body := p.parseBlockStmt()
-	p.expectSemi()
-
-	cond := p.makeExpr(s2, "condition expression")
-
-	return &ast.ForStmt{
-		ForPos: pos,
-		Init:   s1,
-		Cond:   cond,
-		Post:   s3,
-		Body:   body,
-	}
-
-}
-
-func (p *Parser) parseBranchStmt(tok token.Token) ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "BranchStmt"))
-	}
-
-	pos := p.expect(tok)
-
-	var label *ast.Ident
-	if p.token == token.Ident {
-		label = p.parseIdent()
-	}
-	p.expectSemi()
-
-	return &ast.BranchStmt{
-		Token:    tok,
-		TokenPos: pos,
-		Label:    label,
-	}
-}
-
-func (p *Parser) parseIfStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "IfStmt"))
-	}
-
-	pos := p.expect(token.If)
-
-	init, cond := p.parseIfHeader()
-	body := p.parseBlockStmt()
-
-	var elseStmt ast.Stmt
-	if p.token == token.Else {
-		p.next()
-
-		switch p.token {
-		case token.If:
-			elseStmt = p.parseIfStmt()
-		case token.LBrace:
-			elseStmt = p.parseBlockStmt()
-			p.expectSemi()
-		default:
-			p.errorExpected(p.pos, "if or {")
-			elseStmt = &ast.BadStmt{From: p.pos, To: p.pos}
-		}
-	} else {
-		p.expectSemi()
-	}
-
-	return &ast.IfStmt{
-		IfPos: pos,
-		Init:  init,
-		Cond:  cond,
-		Body:  body,
-		Else:  elseStmt,
-	}
-}
-
-func (p *Parser) parseBlockStmt() *ast.BlockStmt {
-	if p.trace {
-		defer un(trace(p, "BlockStmt"))
-	}
-
-	lbrace := p.expect(token.LBrace)
-	list := p.parseStmtList()
-	rbrace := p.expect(token.RBrace)
-
-	return &ast.BlockStmt{
-		LBrace: lbrace,
-		RBrace: rbrace,
-		Stmts:  list,
-	}
-}
-
-func (p *Parser) parseIfHeader() (init ast.Stmt, cond ast.Expr) {
-	if p.token == token.LBrace {
-		p.error(p.pos, "missing condition in if statement")
-		cond = &ast.BadExpr{From: p.pos, To: p.pos}
-		return
-	}
-
-	outer := p.exprLevel
-	p.exprLevel = -1
-
-	if p.token == token.Semicolon {
-		p.error(p.pos, "missing init in if statement")
-		return
-	}
-
-	init = p.parseSimpleStmt(false)
-
-	var condStmt ast.Stmt
-	if p.token == token.LBrace {
-		condStmt = init
-		init = nil
-	} else if p.token == token.Semicolon {
-		p.next()
-
-		condStmt = p.parseSimpleStmt(false)
-	} else {
-		p.error(p.pos, "missing condition in if statement")
-	}
-
-	if condStmt != nil {
-		cond = p.makeExpr(condStmt, "boolean expression")
-	}
-
-	if cond == nil {
-		cond = &ast.BadExpr{From: p.pos, To: p.pos}
-	}
-
-	p.exprLevel = outer
-
-	return
-}
-
-func (p *Parser) makeExpr(s ast.Stmt, want string) ast.Expr {
-	if s == nil {
-		return nil
-	}
-
-	if es, isExpr := s.(*ast.ExprStmt); isExpr {
-		return es.Expr
-	}
-
-	found := "simple statement"
-	if _, isAss := s.(*ast.AssignStmt); isAss {
-		found = "assignment"
-	}
-
-	p.error(s.Pos(), fmt.Sprintf("expected %s, found %s", want, found))
-
-	return &ast.BadExpr{From: s.Pos(), To: p.safePos(s.End())}
-}
-
-func (p *Parser) parseReturnStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "ReturnStmt"))
-	}
-
-	pos := p.pos
-	p.expect(token.Return)
-
-	var x ast.Expr
-	if p.token != token.Semicolon && p.token != token.RBrace {
-		x = p.parseExpr()
-	}
-	p.expectSemi()
-
-	return &ast.ReturnStmt{
-		ReturnPos: pos,
-		Result:    x,
-	}
-}
-
-func (p *Parser) parseExportStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "ExportStmt"))
-	}
-
-	pos := p.pos
-	p.expect(token.Export)
-
-	x := p.parseExpr()
-	p.expectSemi()
-
-	return &ast.ExportStmt{
-		ExportPos: pos,
-		Result:    x,
-	}
-}
-
-func (p *Parser) parseSimpleStmt(forIn bool) ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "SimpleStmt"))
-	}
-
-	x := p.parseExprList()
-
-	switch p.token {
-	case token.Assign, token.Define: // assignment statement
-		pos, tok := p.pos, p.token
-		p.next()
-
-		y := p.parseExprList()
-
-		return &ast.AssignStmt{
-			LHS:      x,
-			RHS:      y,
-			Token:    tok,
-			TokenPos: pos,
-		}
-	case token.In:
-		if forIn {
-			p.next()
-
-			y := p.parseExpr()
-
-			var key, value *ast.Ident
-			var ok bool
-
-			switch len(x) {
-			case 1:
-				key = &ast.Ident{Name: "_", NamePos: x[0].Pos()}
-
-				value, ok = x[0].(*ast.Ident)
-				if !ok {
-					p.errorExpected(x[0].Pos(), "identifier")
-					value = &ast.Ident{Name: "_", NamePos: x[0].Pos()}
-				}
-			case 2:
-				key, ok = x[0].(*ast.Ident)
-				if !ok {
-					p.errorExpected(x[0].Pos(), "identifier")
-					key = &ast.Ident{Name: "_", NamePos: x[0].Pos()}
-				}
-				value, ok = x[1].(*ast.Ident)
-				if !ok {
-					p.errorExpected(x[1].Pos(), "identifier")
-					value = &ast.Ident{Name: "_", NamePos: x[1].Pos()}
-				}
-			}
-
-			return &ast.ForInStmt{
-				Key:      key,
-				Value:    value,
-				Iterable: y,
-			}
-		}
-	}
-
-	if len(x) > 1 {
-		p.errorExpected(x[0].Pos(), "1 expression")
-		// continue with first expression
-	}
-
-	switch p.token {
-	case token.Define,
-		token.AddAssign, token.SubAssign, token.MulAssign, token.QuoAssign, token.RemAssign,
-		token.AndAssign, token.OrAssign, token.XorAssign, token.ShlAssign, token.ShrAssign, token.AndNotAssign:
-		pos, tok := p.pos, p.token
-		p.next()
-
-		y := p.parseExpr()
-
-		return &ast.AssignStmt{
-			LHS:      []ast.Expr{x[0]},
-			RHS:      []ast.Expr{y},
-			Token:    tok,
-			TokenPos: pos,
-		}
-	case token.Inc, token.Dec:
-		// increment or decrement statement
-		s := &ast.IncDecStmt{Expr: x[0], Token: p.token, TokenPos: p.pos}
-		p.next()
-		return s
-	}
-
-	// expression statement
-	return &ast.ExprStmt{Expr: x[0]}
-}
-
-func (p *Parser) parseExprList() (list []ast.Expr) {
-	if p.trace {
-		defer un(trace(p, "ExpressionList"))
-	}
-
-	list = append(list, p.parseExpr())
-	for p.token == token.Comma {
-		p.next()
-		list = append(list, p.parseExpr())
-	}
-
-	return
-}
-
-func (p *Parser) parseMapElementLit() *ast.MapElementLit {
-	if p.trace {
-		defer un(trace(p, "MapElementLit"))
-	}
-
-	pos := p.pos
-	name := "_"
-
-	if p.token == token.Ident {
-		name = p.tokenLit
-	} else if p.token == token.String {
-		v, _ := strconv.Unquote(p.tokenLit)
-		name = v
-	} else {
-		p.errorExpected(pos, "map key")
-	}
-
-	p.next()
-
-	colonPos := p.expect(token.Colon)
-	valueExpr := p.parseExpr()
-
-	return &ast.MapElementLit{
-		Key:      name,
-		KeyPos:   pos,
-		ColonPos: colonPos,
-		Value:    valueExpr,
-	}
-}
-
-func (p *Parser) parseMapLit() *ast.MapLit {
-	if p.trace {
-		defer un(trace(p, "MapLit"))
-	}
-
-	lbrace := p.expect(token.LBrace)
-	p.exprLevel++
-
-	var elements []*ast.MapElementLit
-	for p.token != token.RBrace && p.token != token.EOF {
-		elements = append(elements, p.parseMapElementLit())
-
-		if !p.expectComma(token.RBrace, "map element") {
-			break
-		}
-	}
-
-	p.exprLevel--
-	rbrace := p.expect(token.RBrace)
-
-	return &ast.MapLit{
-		LBrace:   lbrace,
-		RBrace:   rbrace,
-		Elements: elements,
-	}
-}
-
-func (p *Parser) expect(token token.Token) source.Pos {
-	pos := p.pos
-
-	if p.token != token {
-		p.errorExpected(pos, "'"+token.String()+"'")
-	}
-	p.next()
-
-	return pos
-}
-
-func (p *Parser) expectSemi() {
-	switch p.token {
-	case token.RParen, token.RBrace:
-		// semicolon is optional before a closing ')' or '}'
-	case token.Comma:
-		// permit a ',' instead of a ';' but complain
-		p.errorExpected(p.pos, "';'")
-		fallthrough
-	case token.Semicolon:
-		p.next()
-	default:
-		p.errorExpected(p.pos, "';'")
-		p.advance(stmtStart)
-	}
-
-}
-
-func (p *Parser) advance(to map[token.Token]bool) {
-	for ; p.token != token.EOF; p.next() {
-		if to[p.token] {
-			if p.pos == p.syncPos && p.syncCount < 10 {
-				p.syncCount++
-				return
-			}
-
-			if p.pos > p.syncPos {
-				p.syncPos = p.pos
-				p.syncCount = 0
-				return
-			}
-		}
-	}
-}
-
-func (p *Parser) error(pos source.Pos, msg string) {
-	filePos := p.file.Position(pos)
-
-	n := len(p.errors)
-	if n > 0 && p.errors[n-1].Pos.Line == filePos.Line {
-		// discard errors reported on the same line
-		return
-	}
-
-	if n > 10 {
-		// too many errors; terminate early
-		panic(bailout{})
-	}
-
-	p.errors.Add(filePos, msg)
-}
-
-func (p *Parser) errorExpected(pos source.Pos, msg string) {
-	msg = "expected " + msg
-	if pos == p.pos {
-		// error happened at the current position: provide more specific
-		switch {
-		case p.token == token.Semicolon && p.tokenLit == "\n":
-			msg += ", found newline"
-		case p.token.IsLiteral():
-			msg += ", found " + p.tokenLit
-		default:
-			msg += ", found '" + p.token.String() + "'"
-		}
-	}
-
-	p.error(pos, msg)
-}
-
-func (p *Parser) next() {
-	if p.trace && p.pos.IsValid() {
-		s := p.token.String()
-		switch {
-		case p.token.IsLiteral():
-			p.printTrace(s, p.tokenLit)
-		case p.token.IsOperator(), p.token.IsKeyword():
-			p.printTrace(`"` + s + `"`)
-		default:
-			p.printTrace(s)
-		}
-	}
-
-	p.token, p.tokenLit, p.pos = p.scanner.Scan()
-}
-
-func (p *Parser) printTrace(a ...interface{}) {
-	const (
-		dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
-		n    = len(dots)
-	)
-
-	filePos := p.file.Position(p.pos)
-	_, _ = fmt.Fprintf(p.traceOut, "%5d: %5d:%3d: ", p.pos, filePos.Line, filePos.Column)
-
-	i := 2 * p.indent
-	for i > n {
-		_, _ = fmt.Fprint(p.traceOut, dots)
-		i -= n
-	}
-	_, _ = fmt.Fprint(p.traceOut, dots[0:i])
-	_, _ = fmt.Fprintln(p.traceOut, a...)
-}
-
-func (p *Parser) safePos(pos source.Pos) source.Pos {
-	fileBase := p.file.Base
-	fileSize := p.file.Size
-
-	if int(pos) < fileBase || int(pos) > fileBase+fileSize {
-		return source.Pos(fileBase + fileSize)
-	}
-
-	return pos
-}
-
-func trace(p *Parser, msg string) *Parser {
-	p.printTrace(msg, "(")
-	p.indent++
-
-	return p
-}
-
-func un(p *Parser) {
-	p.indent--
-	p.printTrace(")")
-}