Optional args parser/lexer/ast support (google#33)

* Optional args parser/lexer/ast support

Just "frontend" part. They are ignored during actual execution.

Author: sbarzowski

ast/ast.go

@@ -95,10 +95,19 @@ type CompSpecs []CompSpec
 type Apply struct {
 	NodeBase
 	Target        Node
-	Arguments     Nodes
+	Arguments     Arguments
 	TrailingComma bool
 	TailStrict    bool
-	// TODO(sbarzowski) support named arguments
+}
+
+type NamedArgument struct {
+	Name Identifier
+	Arg  Node
+}
+
+type Arguments struct {
+	Positional Nodes
+	Named      []NamedArgument
 }
 
 // ---------------------------------------------------------------------------
@@ -277,11 +286,21 @@ type Error struct {
 // Function represents a function definition
 type Function struct {
 	NodeBase
-	Parameters    Identifiers // TODO(sbarzowski) support default arguments
+	Parameters    Parameters
 	TrailingComma bool
 	Body          Node
 }
 
+type NamedParameter struct {
+	Name       Identifier
+	DefaultArg Node
+}
+
+type Parameters struct {
+	Positional Identifiers
+	Named      []NamedParameter
+}
+
 // ---------------------------------------------------------------------------
 
 // Import represents import "file".
@@ -328,7 +347,7 @@ type LocalBind struct {
 	Variable      Identifier
 	Body          Node
 	FunctionSugar bool
-	Params        Identifiers // if functionSugar is true
+	Params        *Parameters // if functionSugar is true
 	TrailingComma bool
 }
 type LocalBinds []LocalBind
@@ -413,19 +432,19 @@ type ObjectField struct {
 	MethodSugar   bool            // f(x, y, z): ...  (ignore if kind  == astObjectAssert)
 	Expr1         Node            // Not in scope of the object
 	Id            *Identifier
-	Ids           Identifiers // If methodSugar == true then holds the params.
+	Params        *Parameters // If methodSugar == true then holds the params.
 	TrailingComma bool        // If methodSugar == true then remembers the trailing comma
 	Expr2, Expr3  Node        // In scope of the object (can see self).
 }
 
 // TODO(jbeda): Add the remaining constructor helpers here
 
-func ObjectFieldLocal(methodSugar bool, id *Identifier, ids Identifiers, trailingComma bool, body Node) ObjectField {
-	return ObjectField{ObjectLocal, ObjectFieldVisible, false, methodSugar, nil, id, ids, trailingComma, body, nil}
+func ObjectFieldLocal(methodSugar bool, id *Identifier, params *Parameters, trailingComma bool, body Node) ObjectField {
+	return ObjectField{ObjectLocal, ObjectFieldVisible, false, methodSugar, nil, id, params, trailingComma, body, nil}
 }
 
 func ObjectFieldLocalNoMethod(id *Identifier, body Node) ObjectField {
-	return ObjectField{ObjectLocal, ObjectFieldVisible, false, false, nil, id, Identifiers{}, false, body, nil}
+	return ObjectField{ObjectLocal, ObjectFieldVisible, false, false, nil, id, nil, false, body, nil}
 }
 
 type ObjectFields []ObjectField

desugarer.go

@@ -143,11 +143,11 @@ func desugarFields(location ast.LocationRange, fields *ast.ObjectFields, objLeve
 		function := &ast.Function{
 			// TODO(sbarzowski) better location
 			NodeBase:   ast.NewNodeBaseLoc(*origBody.Loc()),
-			Parameters: field.Ids,
+			Parameters: *field.Params,
 			Body:       origBody,
 		}
 		field.MethodSugar = false
-		field.Ids = nil
+		field.Params = nil
 		field.Expr2 = function
 	}
 
@@ -247,7 +247,7 @@ func buildStdCall(builtinName ast.Identifier, args ...ast.Node) ast.Node {
 	builtin := buildSimpleIndex(std, builtinName)
 	return &ast.Apply{
 		Target:    builtin,
-		Arguments: args,
+		Arguments: ast.Arguments{Positional: args},
 	}
 }
 
@@ -269,8 +269,8 @@ func desugar(astPtr *ast.Node, objLevel int) (err error) {
 	switch node := node.(type) {
 	case *ast.Apply:
 		desugar(&node.Target, objLevel)
-		for i := range node.Arguments {
-			err = desugar(&node.Arguments[i], objLevel)
+		for i := range node.Arguments.Positional {
+			err = desugar(&node.Arguments.Positional[i], objLevel)
 			if err != nil {
 				return
 			}
@@ -421,7 +421,7 @@ func desugar(astPtr *ast.Node, objLevel int) (err error) {
 				function := &ast.Function{
 					// TODO(sbarzowski) better location
 					NodeBase:   ast.NewNodeBaseLoc(*origBody.Loc()),
-					Parameters: node.Binds[i].Params,
+					Parameters: *node.Binds[i].Params,
 					Body:       origBody,
 				}
 				node.Binds[i] = ast.LocalBind{

interpreter.go

@@ -439,9 +439,9 @@ func (i *interpreter) evaluate(a ast.Node, context *TraceContext) (value, error)
 		argEnv := i.getCurrentEnv(a)
 
 		arguments := callArguments{
-			positional: make([]potentialValue, len(ast.Arguments)),
+			positional: make([]potentialValue, len(ast.Arguments.Positional)),
 		}
-		for i, arg := range ast.Arguments {
+		for i, arg := range ast.Arguments.Positional {
 			// TODO(sbarzowski) better thunk name
 			arguments.positional[i] = makeThunk("arg", argEnv, arg)
 		}

main_test.go

@@ -105,7 +105,6 @@ func TestMain(t *testing.T) {
 			if bytes.Compare(golden, []byte(output)) != 0 {
 				// TODO(sbarzowski) better reporting of differences in whitespace
 				// missing newline issues can be very subtle now
-				t.Errorf("%#v %#v\n", golden, []byte(output))
 				t.Fail()
 				t.Errorf("Mismatch when running %s.input. Golden: %s\n", test.name, test.golden)
 				data := diff(output, string(golden))

parser/parser.go

@@ -115,54 +115,99 @@ func (p *parser) peek() *token {
 	return &p.t[p.currT]
 }
 
-func (p *parser) parseIdentifierList(elementKind string) (ast.Identifiers, bool, error) {
-	_, exprs, gotComma, err := p.parseCommaList(tokenParenR, elementKind)
-	if err != nil {
-		return ast.Identifiers{}, false, err
+func (p *parser) doublePeek() *token {
+	return &p.t[p.currT+1]
+}
+
+// in some cases it's convenient to parse something as an expression, and later
+// decide that it should be just an identifer
+func astVarToIdentifier(node ast.Node) (*ast.Identifier, bool) {
+	v, ok := node.(*ast.Var)
+	if ok {
+		return &v.Id, true
 	}
-	var ids ast.Identifiers
-	for _, n := range exprs {
-		v, ok := n.(*ast.Var)
-		if !ok {
-			return ast.Identifiers{}, false, MakeStaticError(fmt.Sprintf("Expected simple identifier but got a complex expression."), *n.Loc())
-		}
-		ids = append(ids, v.Id)
+	return nil, false
+}
+
+func (p *parser) parseArgument() (*ast.Identifier, ast.Node, error) {
+	var id *ast.Identifier
+	if p.peek().kind == tokenIdentifier && p.doublePeek().kind == tokenOperator && p.doublePeek().data == "=" {
+		ident := p.pop()
+		var tmpID = ast.Identifier(ident.data)
+		id = &tmpID
+		p.pop() // "=" token
+	}
+	expr, err := p.parse(maxPrecedence)
+	if err != nil {
+		return nil, nil, err
 	}
-	return ids, gotComma, nil
+	return id, expr, nil
 }
 
-func (p *parser) parseCommaList(end tokenKind, elementKind string) (*token, ast.Nodes, bool, error) {
-	var exprs ast.Nodes
+// TODO(sbarzowski) - this returned bool is weird
+// TODO(sbarzowski) - name - it's also used for parameters
+func (p *parser) parseArguments(elementKind string) (*token, *ast.Arguments, bool, error) {
+	args := &ast.Arguments{}
 	gotComma := false
+	namedArgumentAdded := false
 	first := true
 	for {
 		next := p.peek()
-		if !first && !gotComma {
-			if next.kind == tokenComma {
-				p.pop()
-				next = p.peek()
-				gotComma = true
-			}
-		}
-		if next.kind == end {
+
+		if next.kind == tokenParenR {
 			// gotComma can be true or false here.
-			return p.pop(), exprs, gotComma, nil
+			return p.pop(), args, gotComma, nil
 		}
 
 		if !first && !gotComma {
-			return nil, nil, false, MakeStaticError(fmt.Sprintf("Expected a comma before next %s.", elementKind), next.loc)
+			return nil, nil, false, MakeStaticError(fmt.Sprintf("Expected a comma before next %s, got %s.", elementKind, next), next.loc)
 		}
 
-		expr, err := p.parse(maxPrecedence)
+		id, expr, err := p.parseArgument()
 		if err != nil {
 			return nil, nil, false, err
 		}
-		exprs = append(exprs, expr)
-		gotComma = false
+		if id == nil {
+			if namedArgumentAdded {
+				return nil, nil, false, MakeStaticError("Positional argument after a named argument is not allowed", next.loc)
+			}
+			args.Positional = append(args.Positional, expr)
+		} else {
+			namedArgumentAdded = true
+			args.Named = append(args.Named, ast.NamedArgument{Name: *id, Arg: expr})
+		}
+
+		if p.peek().kind == tokenComma {
+			p.pop()
+			gotComma = true
+		} else {
+			gotComma = false
+		}
+
 		first = false
 	}
 }
 
+// TODO(sbarzowski) - this returned bool is weird
+func (p *parser) parseParameters(elementKind string) (*ast.Parameters, bool, error) {
+	_, args, trailingComma, err := p.parseArguments(elementKind)
+	if err != nil {
+		return nil, false, err
+	}
+	var params ast.Parameters
+	for _, arg := range args.Positional {
+		id, ok := astVarToIdentifier(arg)
+		if !ok {
+			return nil, false, MakeStaticError(fmt.Sprintf("Expected simple identifier but got a complex expression."), *arg.Loc())
+		}
+		params.Positional = append(params.Positional, *id)
+	}
+	for _, arg := range args.Named {
+		params.Named = append(params.Named, ast.NamedParameter{Name: arg.Name, DefaultArg: arg.Arg})
+	}
+	return &params, trailingComma, nil
+}
+
 func (p *parser) parseBind(binds *ast.LocalBinds) error {
 	varID, err := p.popExpect(tokenIdentifier)
 	if err != nil {
@@ -176,7 +221,7 @@ func (p *parser) parseBind(binds *ast.LocalBinds) error {
 
 	if p.peek().kind == tokenParenL {
 		p.pop()
-		params, gotComma, err := p.parseIdentifierList("function parameter")
+		params, gotComma, err := p.parseParameters("function parameter")
 		if err != nil {
 			return err
 		}
@@ -373,11 +418,11 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 
 			isMethod := false
 			methComma := false
-			var params ast.Identifiers
+			var params *ast.Parameters
 			if p.peek().kind == tokenParenL {
 				p.pop()
 				var err error
-				params, methComma, err = p.parseIdentifierList("method parameter")
+				params, methComma, err = p.parseParameters("method parameter")
 				if err != nil {
 					return nil, nil, err
 				}
@@ -413,7 +458,7 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 				MethodSugar:   isMethod,
 				Expr1:         expr1,
 				Id:            id,
-				Ids:           params,
+				Params:        params,
 				TrailingComma: methComma,
 				Expr2:         body,
 			})
@@ -432,11 +477,11 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 
 			isMethod := false
 			funcComma := false
-			var params ast.Identifiers
+			var params *ast.Parameters
 			if p.peek().kind == tokenParenL {
 				p.pop()
 				isMethod = true
-				params, funcComma, err = p.parseIdentifierList("function parameter")
+				params, funcComma, err = p.parseParameters("function parameter")
 				if err != nil {
 					return nil, nil, err
 				}
@@ -459,7 +504,7 @@ func (p *parser) parseObjectRemainder(tok *token) (ast.Node, *token, error) {
 				SuperSugar:    false,
 				MethodSugar:   isMethod,
 				Id:            &id,
-				Ids:           params,
+				Params:        params,
 				TrailingComma: funcComma,
 				Expr2:         body,
 			})
@@ -830,7 +875,7 @@ func (p *parser) parse(prec precedence) (ast.Node, error) {
 		p.pop()
 		next := p.pop()
 		if next.kind == tokenParenL {
-			params, gotComma, err := p.parseIdentifierList("function parameter")
+			params, gotComma, err := p.parseParameters("function parameter")
 			if err != nil {
 				return nil, err
 			}
@@ -840,7 +885,7 @@ func (p *parser) parse(prec precedence) (ast.Node, error) {
 			}
 			return &ast.Function{
 				NodeBase:      ast.NewNodeBaseLoc(locFromTokenAST(begin, body)),
-				Parameters:    params,
+				Parameters:    *params,
 				TrailingComma: gotComma,
 				Body:          body,
 			}, nil
@@ -1048,7 +1093,7 @@ func (p *parser) parse(prec precedence) (ast.Node, error) {
 					Id:       &id,
 				}
 			case tokenParenL:
-				end, args, gotComma, err := p.parseCommaList(tokenParenR, "function argument")
+				end, args, gotComma, err := p.parseArguments("function argument")
 				if err != nil {
 					return nil, err
 				}
@@ -1060,7 +1105,7 @@ func (p *parser) parse(prec precedence) (ast.Node, error) {
 				lhs = &ast.Apply{
 					NodeBase:      ast.NewNodeBaseLoc(locFromTokens(begin, end)),
 					Target:        lhs,
-					Arguments:     args,
+					Arguments:     *args,
 					TrailingComma: gotComma,
 					TailStrict:    tailStrict,
 				}