Method parseObjectRemainderLocal

internal/parser/parser.go:501–570

(binds *ast.IdentifierSet, tok *token, next *token)

}

func (p *parser) parseObjectRemainderLocal(binds *ast.IdentifierSet, tok *token, next *token) (*ast.ObjectField, errors.StaticError) {
	varID, popErr := p.popExpect(tokenIdentifier)
	if popErr != nil {
		return nil, popErr
	}

	id := ast.Identifier(varID.data)

	if binds.Contains(id) {
		return nil, errors.MakeStaticError(fmt.Sprintf("Duplicate local var: %v", id), varID.loc)
	}

	// TODO(sbarzowski) Can we reuse regular local bind parsing here?

	isMethod := false
	funcComma := false
	var parenL *token
	var parenR *token
	var params []ast.Parameter
	if p.peek().kind == tokenParenL {
		parenL = p.pop()
		isMethod = true
		var err errors.StaticError
		parenR, params, funcComma, err = p.parseParameters("function parameter")
		if err != nil {
			return nil, err
		}
	}
	opToken, popErr := p.popExpectOp("=")
	if popErr != nil {
		return nil, popErr
	}

	body, err := p.parse(iast.MaxPrecedence)
	if err != nil {
		return nil, err
	}

	var method *ast.Function
	if isMethod {
		method = &ast.Function{
			ParenLeftFodder:  parenL.fodder,
			Parameters:       params,
			ParenRightFodder: parenR.fodder,
			TrailingComma:    funcComma,
			Body:             body,
		}
	}

	binds.Add(id)

	var commaFodder ast.Fodder
	if p.peek().kind == tokenComma {
		commaFodder = p.peek().fodder
	}

	return &ast.ObjectField{
		Kind:        ast.ObjectLocal,