internal/core/adt: do list artihmetic with comprehensions

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

Author: mpvl

internal/core/adt/binop.go

@@ -183,20 +183,36 @@ func BinOp(c *OpContext, op Op, left, right Value) Value {
 			return c.newBytes(b)
 
 		case leftKind == ListKind && rightKind == ListKind:
-			a := c.Elems(left)
-			b := c.Elems(right)
+			// TODO: get rid of list addition. Semantically it is somewhat
+			// unclear and, as it turns out, it is also hard to get right.
+			// Simulate addition with comprehensions now.
 			if err := c.Err(); err != nil {
 				return err
 			}
-			n := c.newList(c.src, nil)
-			if err := n.appendListArcs(a); err != nil {
-				return err
+
+			x := MakeIdentLabel(c, "x", "")
+
+			forClause := func(src Expr) *ForClause {
+				return &ForClause{
+					Value: x,
+					Src:   src,
+					Dst: &ValueClause{&StructLit{Decls: []Decl{
+						&FieldReference{UpCount: 1, Label: x},
+					}}},
+				}
 			}
-			if err := n.appendListArcs(b); err != nil {
-				return err
+
+			list := &ListLit{
+				Elems: []Elem{
+					forClause(left),
+					forClause(right),
+				},
 			}
-			// n.isList = true
-			// n.IsClosed = true
+
+			n := &Vertex{}
+			n.AddConjunct(MakeRootConjunct(c.Env(0), list))
+			n.Finalize(c)
+
 			return n
 		}
 
@@ -230,21 +246,30 @@ func BinOp(c *OpContext, op Op, left, right Value) Value {
 			fallthrough
 
 		case leftKind == IntKind && rightKind == ListKind:
-			a := c.Elems(right)
-			n := c.newList(c.src, nil)
-			// n.IsClosed = true
-			index := int64(0)
+			// TODO: get rid of list multiplication.
+
+			list := &ListLit{}
+			x := MakeIdentLabel(c, "x", "")
+
 			for i := c.uint64(left, "list multiplier"); i > 0; i-- {
-				for _, a := range a {
-					f, _ := MakeLabel(a.Source(), index, IntLabel)
-					n.Arcs = append(n.Arcs, &Vertex{
-						Parent:    n,
-						Label:     f,
-						Conjuncts: a.Conjuncts,
-					})
-					index++
-				}
+				list.Elems = append(list.Elems,
+					&ForClause{
+						Value: x,
+						Src:   right,
+						Dst: &ValueClause{&StructLit{Decls: []Decl{
+							&FieldReference{UpCount: 1, Label: x},
+						}}},
+					},
+				)
+			}
+			if err := c.Err(); err != nil {
+				return err
 			}
+
+			n := &Vertex{}
+			n.AddConjunct(MakeRootConjunct(c.Env(0), list))
+			n.Finalize(c)
+
 			return n
 		}
 

internal/core/adt/composite.go

@@ -572,23 +572,6 @@ func appendPath(a []Feature, v *Vertex) []Feature {
 	return a
 }
 
-func (v *Vertex) appendListArcs(arcs []*Vertex) (err *Bottom) {
-	for _, a := range arcs {
-		// TODO(list): BUG this only works if lists do not have definitions
-		// fields.
-		label, err := MakeLabel(a.Source(), int64(len(v.Arcs)), IntLabel)
-		if err != nil {
-			return &Bottom{Src: a.Source(), Err: err}
-		}
-		v.Arcs = append(v.Arcs, &Vertex{
-			Parent:    v,
-			Label:     label,
-			Conjuncts: a.Conjuncts,
-		})
-	}
-	return nil
-}
-
 // An Conjunct is an Environment-Expr pair. The Environment is the starting
 // point for reference lookup for any reference contained in X.
 type Conjunct struct {

internal/core/adt/expr.go

@@ -875,11 +875,7 @@ func (x *BinaryExpr) evaluate(c *OpContext) Value {
 		return err
 	}
 
-	value := BinOp(c, x.Op, left, right)
-	if n, ok := value.(*Vertex); ok && n.IsList() {
-		n.UpdateStatus(Partial)
-	}
-	return value
+	return BinOp(c, x.Op, left, right)
 }
 
 // A CallExpr represents a call to a builtin.

internal/core/eval/eval.go

@@ -1731,6 +1731,9 @@ func (n *nodeContext) insertField(f adt.Feature, x adt.Conjunct) *adt.Vertex {
 	// TODO: disallow adding conjuncts when cache set?
 	arc.AddConjunct(x)
 
+	adt.Assert("invalid adt.ID",
+		x.CloseID == 0 || int(x.CloseID) < len(closedInfo(n.node).Canopy))
+
 	if isNew {
 		closedInfo(n.node).visitAllFieldSets(func(o *fieldSet) {
 			o.MatchAndInsert(ctx, arc)