internal/core: allow variable arg functions

This is mostly to allow os-dependent functions
that are convenient, yet still hermetic.

E.g. path.Base(str, path.Unix)

Most of the files in this CL are generated.
Only files not starting with pkg/ and
pkg/internal/builtin.go are relevant.

The basic idea is that to intead of just specifying
the kind of paramter, to also allow a default value.
As this is just a CUE value, this will also allow
for constraints down the line. The old shim
implementation in pkg/internal/builtin.go keeps
it simple, though. Builtins with default values
will have to be hand-coded later on.

Change-Id: I184d672a8704f4ec6c53491d08caddd1f774bda2
Reviewed-on: https://cue-review.googlesource.com/c/cue/+/7842
Reviewed-by: Marcel van Lohuizen <[email protected]>
Reviewed-by: CUE cueckoo <[email protected]>

Author: mpvl

internal/core/adt/expr.go

@@ -937,7 +937,7 @@ func (x *CallExpr) evaluate(c *OpContext) Value {
 // A Builtin is a value representing a native function call.
 type Builtin struct {
 	// TODO:  make these values for better type checking.
-	Params []Kind
+	Params []Param
 	Result Kind
 	Func   func(c *OpContext, args []Value) Expr
 
@@ -947,6 +947,23 @@ type Builtin struct {
 	Const string
 }
 
+type Param struct {
+	Name  Feature // name of the argument; mostly for documentation
+	Value Value   // Could become Value later, using disjunctions for defaults.
+}
+
+func (p Param) Kind() Kind {
+	return p.Value.Kind()
+}
+
+func (p Param) Default() Value {
+	d, ok := p.Value.(*Disjunction)
+	if !ok || d.NumDefaults != 1 {
+		return nil
+	}
+	return d.Values[0]
+}
+
 func (x *Builtin) WriteName(w io.Writer, c *OpContext) {
 	_, _ = fmt.Fprintf(w, "%s.%s", x.Package.StringValue(c), x.Name)
 }
@@ -956,7 +973,7 @@ func (x *Builtin) Kind() Kind {
 	if len(x.Params) == 0 {
 		return BottomKind
 	}
-	return x.Params[0]
+	return x.Params[0].Kind()
 }
 
 func (x *Builtin) validate(c *OpContext, v Value) *Bottom {
@@ -984,32 +1001,36 @@ func (x *Builtin) call(c *OpContext, call *ast.CallExpr, args []Value) Expr {
 		// We have a custom builtin
 		return &BuiltinValidator{call, x, args}
 	}
-	switch {
-	case len(x.Params) < len(args):
+	if len(args) > len(x.Params) {
 		c.addErrf(0, call.Rparen,
 			"too many arguments in call to %s (have %d, want %d)",
 			call.Fun, len(args), len(x.Params))
 		return nil
-	case len(x.Params) > len(args):
-		c.addErrf(0, call.Rparen,
-			"not enough arguments in call to %s (have %d, want %d)",
-			call.Fun, len(args), len(x.Params))
-		return nil
+	}
+	for i := len(args); i < len(x.Params); i++ {
+		v := x.Params[i].Default()
+		if v == nil {
+			c.addErrf(0, call.Rparen,
+				"not enough arguments in call to %s (have %d, want %d)",
+				call.Fun, len(args), len(x.Params))
+			return nil
+		}
+		args = append(args, v)
 	}
 	for i, a := range args {
-		if x.Params[i] != BottomKind {
+		if x.Params[i].Kind() != BottomKind {
 			if b := bottom(a); b != nil {
 				return b
 			}
-			if k := kind(a); x.Params[i]&k == BottomKind {
+			if k := kind(a); x.Params[i].Kind()&k == BottomKind {
 				code := EvalError
 				b, _ := args[i].(*Bottom)
 				if b != nil {
 					code = b.Code
 				}
 				c.addErrf(code, pos(a),
 					"cannot use %s (type %s) as %s in argument %d to %s",
-					a, k, x.Params[i], i+1, call.Fun)
+					a, k, x.Params[i].Kind(), i+1, call.Fun)
 				return nil
 			}
 		}
@@ -1038,7 +1059,7 @@ func (x *BuiltinValidator) Source() ast.Node {
 }
 
 func (x *BuiltinValidator) Kind() Kind {
-	return x.Builtin.Params[0]
+	return x.Builtin.Params[0].Kind()
 }
 
 func (x *BuiltinValidator) validate(c *OpContext, v Value) *Bottom {

internal/core/compile/builtin.go

@@ -26,9 +26,16 @@ import (
 
 const supportedByLen = adt.StructKind | adt.BytesKind | adt.StringKind | adt.ListKind
 
+var (
+	stringParam = adt.Param{Value: &adt.BasicType{K: adt.StringKind}}
+	structParam = adt.Param{Value: &adt.BasicType{K: adt.StructKind}}
+	listParam   = adt.Param{Value: &adt.BasicType{K: adt.ListKind}}
+	intParam    = adt.Param{Value: &adt.BasicType{K: adt.IntKind}}
+)
+
 var lenBuiltin = &adt.Builtin{
 	Name:   "len",
-	Params: []adt.Kind{supportedByLen},
+	Params: []adt.Param{{Value: &adt.BasicType{K: supportedByLen}}},
 	Result: adt.IntKind,
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		v := args[0]
@@ -74,7 +81,7 @@ var lenBuiltin = &adt.Builtin{
 
 var closeBuiltin = &adt.Builtin{
 	Name:   "close",
-	Params: []adt.Kind{adt.StructKind},
+	Params: []adt.Param{structParam},
 	Result: adt.StructKind,
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		s, ok := args[0].(*adt.Vertex)
@@ -92,7 +99,7 @@ var closeBuiltin = &adt.Builtin{
 
 var andBuiltin = &adt.Builtin{
 	Name:   "and",
-	Params: []adt.Kind{adt.ListKind},
+	Params: []adt.Param{listParam},
 	Result: adt.IntKind,
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		list := c.Elems(args[0])
@@ -109,7 +116,7 @@ var andBuiltin = &adt.Builtin{
 
 var orBuiltin = &adt.Builtin{
 	Name:   "or",
-	Params: []adt.Kind{adt.ListKind},
+	Params: []adt.Param{listParam},
 	Result: adt.IntKind,
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		d := []adt.Disjunct{}
@@ -141,7 +148,7 @@ var orBuiltin = &adt.Builtin{
 
 var divBuiltin = &adt.Builtin{
 	Name:   "div",
-	Params: []adt.Kind{adt.IntKind, adt.IntKind},
+	Params: []adt.Param{intParam, intParam},
 	Result: adt.IntKind,
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		const name = "argument to div builtin"
@@ -152,7 +159,7 @@ var divBuiltin = &adt.Builtin{
 
 var modBuiltin = &adt.Builtin{
 	Name:   "mod",
-	Params: []adt.Kind{adt.IntKind, adt.IntKind},
+	Params: []adt.Param{intParam, intParam},
 	Result: adt.IntKind,
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		const name = "argument to mod builtin"
@@ -163,7 +170,7 @@ var modBuiltin = &adt.Builtin{
 
 var quoBuiltin = &adt.Builtin{
 	Name:   "quo",
-	Params: []adt.Kind{adt.IntKind, adt.IntKind},
+	Params: []adt.Param{intParam, intParam},
 	Result: adt.IntKind,
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		const name = "argument to quo builtin"
@@ -174,7 +181,7 @@ var quoBuiltin = &adt.Builtin{
 
 var remBuiltin = &adt.Builtin{
 	Name:   "rem",
-	Params: []adt.Kind{adt.IntKind, adt.IntKind},
+	Params: []adt.Param{intParam, intParam},
 	Result: adt.IntKind,
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		const name = "argument to rem builtin"