internal/core/adt: allow non-concrete values in builtins

By default, arguments to builtins are checked for
concreteness. It will be too much work, not to mention
brittle, to change this at this moment, as it would
require functions to check the result of the arguments
for errors whereas before they did not.

Instead, if a function now wants arguments to be able
to be non-concrete, it should do so by explicitly
setting the NonConcrete flag. It is then subsequently
responsible for checking all return arguments.

A bit of the non-concrete support is added here, but it
will be used and tested in a followup CL. Otherwise,
these changes should not result in any test changes.

Issue #2741

Signed-off-by: Marcel van Lohuizen <[email protected]>
Change-Id: I7a61fb93a6976b0b9b9118507ae41acb7fdd2b05
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1199684
Reviewed-by: Daniel Martí <[email protected]>
TryBot-Result: CUEcueckoo <[email protected]>
Unity-Result: CUE porcuepine <[email protected]>

Author: mpvl

internal/core/adt/context.go

@@ -1131,6 +1131,11 @@ func (c *OpContext) RawElems(v Value) []*Vertex {
 }
 
 func (c *OpContext) list(v Value) *Vertex {
+	if v != nil {
+		if a, ok := c.getDefault(v); ok {
+			v = a
+		}
+	}
 	x, ok := v.(*Vertex)
 	if !ok || !x.IsList() {
 		c.typeError(v, ListKind)

internal/core/adt/expr.go

@@ -1520,7 +1520,12 @@ func (x *CallExpr) evaluate(c *OpContext, state combinedFlags) Value {
 		cond := state.conditions() | allAncestorsProcessed | concreteKnown
 		state = combineMode(cond, runMode).withVertexStatus(state.vertexStatus())
 
-		expr := c.value(a, state)
+		var expr Value
+		if b.NonConcrete {
+			expr = c.evalState(a, state)
+		} else {
+			expr = c.value(a, state)
+		}
 
 		switch v := expr.(type) {
 		case nil:
@@ -1558,7 +1563,12 @@ type Builtin struct {
 	// TODO:  make these values for better type checking.
 	Params []Param
 	Result Kind
-	Func   func(c *OpContext, args []Value) Expr
+
+	// NonConcrete should be set to true if a builtin supports non-concrete
+	// arguments. By default, all arguments are checked to be concrete.
+	NonConcrete bool
+
+	Func func(c *OpContext, args []Value) Expr
 
 	Package Feature
 	Name    string

internal/core/compile/builtin.go

@@ -81,6 +81,7 @@ var closeBuiltin = &adt.Builtin{
 	Name:   "close",
 	Params: []adt.Param{structParam},
 	Result: adt.StructKind,
+	// Noncrete: true, // TODO: should probably be noncrete
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		s, ok := args[0].(*adt.Vertex)
 		if !ok {
@@ -98,9 +99,10 @@ var closeBuiltin = &adt.Builtin{
 }
 
 var andBuiltin = &adt.Builtin{
-	Name:   "and",
-	Params: []adt.Param{listParam},
-	Result: adt.IntKind,
+	Name:        "and",
+	Params:      []adt.Param{listParam},
+	Result:      adt.IntKind,
+	NonConcrete: true,
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		list := c.RawElems(args[0])
 		if len(list) == 0 {
@@ -115,9 +117,10 @@ var andBuiltin = &adt.Builtin{
 }
 
 var orBuiltin = &adt.Builtin{
-	Name:   "or",
-	Params: []adt.Param{listParam},
-	Result: adt.IntKind,
+	Name:        "or",
+	Params:      []adt.Param{listParam},
+	Result:      adt.IntKind,
+	NonConcrete: true,
 	Func: func(c *adt.OpContext, args []adt.Value) adt.Expr {
 		d := []adt.Disjunct{}
 		for _, c := range c.RawElems(args[0]) {

internal/pkg/builtin.go

@@ -44,12 +44,13 @@ import (
 //	[]T
 //	map[string]T
 type Builtin struct {
-	Name   string
-	Pkg    adt.Feature
-	Params []Param
-	Result adt.Kind
-	Func   func(c *CallCtxt)
-	Const  string
+	Name        string
+	Pkg         adt.Feature
+	Params      []Param
+	Result      adt.Kind
+	NonConcrete bool
+	Func        func(c *CallCtxt)
+	Const       string
 }
 
 type Param struct {
@@ -119,10 +120,11 @@ func ToBuiltin(b *Builtin) *adt.Builtin {
 	}
 
 	x := &adt.Builtin{
-		Params:  params,
-		Result:  b.Result,
-		Package: b.Pkg,
-		Name:    b.Name,
+		Params:      params,
+		Result:      b.Result,
+		NonConcrete: b.NonConcrete,
+		Package:     b.Pkg,
+		Name:        b.Name,
 	}
 	x.Func = func(ctx *adt.OpContext, args []adt.Value) (ret adt.Expr) {
 		// call, _ := ctx.Source().(*ast.CallExpr)

internal/pkg/context.go

@@ -49,10 +49,22 @@ func (c *CallCtxt) Do() bool {
 	return c.Err == nil
 }
 
+// Schema returns the ith argument as is, without converting it to a cue.Value.
+func (c *CallCtxt) Schema(i int) Schema {
+	return Schema(value.Make(c.ctx, c.args[i]))
+}
+
+// Value returns a finalized cue.Value for the ith argument.
 func (c *CallCtxt) Value(i int) cue.Value {
 	v := value.Make(c.ctx, c.args[i])
-	// TODO: remove default
-	// v, _ = v.Default()
+	if c.builtin.NonConcrete {
+		// In case NonConcrete is false, the concreteness is already checked
+		// at call time. We may want to use finalize semantics in both cases,
+		// though.
+		_, f := value.ToInternal(v)
+		f = f.ToDataAll(c.ctx)
+		v = value.Make(c.ctx, f)
+	}
 	if !v.IsConcrete() {
 		c.errcf(adt.IncompleteError, "non-concrete argument %d", i)
 	}
@@ -61,6 +73,9 @@ func (c *CallCtxt) Value(i int) cue.Value {
 
 func (c *CallCtxt) Struct(i int) Struct {
 	x := c.args[i]
+	if c.builtin.NonConcrete {
+		x = adt.Default(x)
+	}
 	switch v, ok := x.(*adt.Vertex); {
 	case ok && !v.IsList():
 		v.CompleteArcs(c.ctx)
@@ -254,6 +269,9 @@ func (c *CallCtxt) Iter(i int) (a cue.Iterator) {
 
 func (c *CallCtxt) getList(i int) *adt.Vertex {
 	x := c.args[i]
+	if c.builtin.NonConcrete {
+		x = adt.Default(x)
+	}
 	switch v, ok := x.(*adt.Vertex); {
 	case ok && v.IsList():
 		v.Finalize(c.ctx)
@@ -262,6 +280,7 @@ func (c *CallCtxt) getList(i int) *adt.Vertex {
 	case v != nil:
 		x = v.Value()
 	}
+
 	if x.Kind()&adt.ListKind == 0 {
 		var err error
 		if b, ok := x.(*adt.Bottom); ok {

internal/pkg/types.go

@@ -15,9 +15,18 @@
 package pkg
 
 import (
+	"cuelang.org/go/cue"
 	"cuelang.org/go/internal/core/adt"
 )
 
+// A Schema represents an arbitrary cue.Value that can hold non-concrete values.
+// By default function arguments are checked to be concrete.
+type Schema cue.Value
+
+func (s Schema) Value() cue.Value {
+	return cue.Value(s)
+}
+
 // List represents a CUE list, which can be open or closed.
 type List struct {
 	runtime adt.Runtime

pkg/gen.go

@@ -123,10 +123,11 @@ func main() {
 }
 
 type generator struct {
-	dir        string
-	w          *bytes.Buffer
-	cuePkgPath string
-	first      bool
+	dir         string
+	w           *bytes.Buffer
+	cuePkgPath  string
+	first       bool
+	nonConcrete bool
 }
 
 func generate(pkg *packages.Package) error {
@@ -298,6 +299,7 @@ func (g *generator) processGo(pkg *packages.Package) error {
 var errorType = types.Universe.Lookup("error").Type()
 
 func (g *generator) genFunc(fn *types.Func) {
+	g.nonConcrete = false
 	sign := fn.Type().(*types.Signature)
 	if sign.Recv() != nil {
 		return
@@ -334,6 +336,9 @@ func (g *generator) genFunc(fn *types.Func) {
 	fmt.Fprintf(g.w, "\n},\n")
 
 	fmt.Fprintf(g.w, "Result: %s,\n", g.goToCUE(results.At(0).Type()))
+	if g.nonConcrete {
+		fmt.Fprintf(g.w, "NonConcrete: true,\n")
+	}
 
 	argList := strings.Join(args, ", ")
 	valList := strings.Join(vals, ", ")
@@ -378,6 +383,9 @@ func (g *generator) goKind(typ types.Type) string {
 		return "cueList"
 	case "cuelang.org/go/internal/pkg.Struct":
 		return "struct"
+	case "cuelang.org/go/internal/pkg.Schema":
+		g.nonConcrete = true
+		return "schema"
 	case "[]*github.com/cockroachdb/apd/v3.Decimal":
 		return "decimalList"
 	case "cuelang.org/go/cue.Value":