internal/core/adt: rewrite Environments for disjuncts

The Evaluator uses an Environment that is used
to resolve references within CUE expressions.
Each Environment points to a Vertex in which to
look up a reference at that level.

When a disjunction for a node is evaluated, the
node is "cloned" for each disjunct.
Environments that point to the "cloned" node
must be updated to point to the respective
disjunct. This is especially true for the
various disjuncts that are inserted.
This change adds this rewriting code.

Note that for conjuncts that were already
added, either the value will not change,
or the expression will be re-evalauted when
it is later unified with something else.
We nonetheless add some code for this as
this invariant may not hold if we apply
more aggressive structure sharing.
This code is marked with a TODO.

Issue #3829

Signed-off-by: Marcel van Lohuizen <[email protected]>
Change-Id: If5804ad37bae17f8015022404b6af254b0fc1026
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1212022
TryBot-Result: CUEcueckoo <[email protected]>
Unity-Result: CUE porcuepine <[email protected]>
Reviewed-by: Matthew Sackman <[email protected]>

Author: mpvl

cue/testdata/disjunctions/resolve.txtar

@@ -51,71 +51,6 @@ Retain: 0
 Unifications: 32
 Conjuncts:    67
 Disjuncts:    44
--- out/evalalpha --
-(struct){
-  resolveAcrossDisjunct: (struct){
-    t1: (struct){ |((struct){
-        #B: (int){ int }
-        d: (int){ int }
-      }, (struct){
-        #B: (int){ int }
-      }, (struct){
-        #B: (int){ 1 }
-        d: (int){ int }
-      }, (struct){
-        #B: (int){ 1 }
-      }) }
-    nested: (struct){ |((struct){
-        a: (struct){
-          b: (struct){
-            #B: (int){ int }
-          }
-        }
-        d: (int){ int }
-      }, (struct){
-        a: (struct){
-          b: (struct){
-            #B: (int){ int }
-          }
-        }
-      }, (struct){
-        a: (struct){
-          b: (struct){
-            #B: (int){ 1 }
-          }
-        }
-        d: (int){ int }
-      }, (struct){
-        a: (struct){
-          b: (struct){
-            #B: (int){ 1 }
-          }
-        }
-      }) }
-  }
-}
--- diff/-out/evalalpha<==>+out/eval --
-diff old new
---- old
-+++ new
-@@ -7,7 +7,7 @@
-         #B: (int){ int }
-       }, (struct){
-         #B: (int){ 1 }
--        d: (int){ 1 }
-+        d: (int){ int }
-       }, (struct){
-         #B: (int){ 1 }
-       }) }
-@@ -30,7 +30,7 @@
-             #B: (int){ 1 }
-           }
-         }
--        d: (int){ 1 }
-+        d: (int){ int }
-       }, (struct){
-         a: (struct){
-           b: (struct){
 -- out/eval --
 (struct){
   resolveAcrossDisjunct: (struct){

internal/core/adt/disjunct2.go

@@ -389,7 +389,7 @@ func (n *nodeContext) crossProduct(dst, cross []*nodeContext, dn *envDisjunct, m
 			ID.node.nextDisjunct(j, len(dn.disjuncts), d.expr)
 
 			c := MakeConjunct(dn.env, d.expr, dn.cloneID)
-			r, err := p.doDisjunct(c, d.mode, mode)
+			r, err := p.doDisjunct(c, d.mode, mode, n.node)
 
 			if err != nil {
 				// TODO: store more error context
@@ -436,7 +436,10 @@ func (n *nodeContext) collectErrors(dn *envDisjunct) (errs *Bottom) {
 	return b
 }
 
-func (n *nodeContext) doDisjunct(c Conjunct, m defaultMode, mode runMode) (*nodeContext, *Bottom) {
+// doDisjunct computes a single disjunct. n is the current disjunct that is
+// augmented, whereas orig is the original node where disjunction processing
+// started. orig is used to clean up Environments.
+func (n *nodeContext) doDisjunct(c Conjunct, m defaultMode, mode runMode, orig *Vertex) (*nodeContext, *Bottom) {
 	n.ctx.inDisjunct++
 	defer func() { n.ctx.inDisjunct-- }()
 
@@ -458,6 +461,7 @@ func (n *nodeContext) doDisjunct(c Conjunct, m defaultMode, mode runMode) (*node
 
 	d := oc.cloneRoot(n)
 	d.runMode = mode
+	c.Env = derefDisjunctsEnv(c.Env, orig, d.node)
 
 	d.defaultMode = combineDefault(m, n.defaultMode)
 

internal/core/adt/overlay.go

@@ -57,7 +57,7 @@ type overlayContext struct {
 // inserting selected disjuncts into a new Vertex.
 func (ctx *overlayContext) cloneRoot(root *nodeContext) *nodeContext {
 	// Clone all vertices that need to be cloned to support the overlay.
-	v := ctx.cloneVertex(root.node)
+	v := ctx.cloneVertex(root.node, nil, nil)
 	v.IsDisjunct = true
 
 	for _, v := range ctx.vertices {
@@ -101,29 +101,46 @@ func (ctx *overlayContext) unlinkOverlay() {
 // benefit this gives. More importantly, we should first implement the filter
 // to eliminate disjunctions pre-copy based on discriminator fields and what
 // have you. This is not unlikely to eliminate
-func (ctx *overlayContext) cloneVertex(x *Vertex) *Vertex {
+func (ctx *overlayContext) cloneVertex(x, from, to *Vertex) *Vertex {
 	if x.overlay != nil {
 		return x.overlay
 	}
 
 	v := &Vertex{}
 	*v = *x
 
+	// from == nil signals that cloneVertex is directly called from cloneRoot.
+	// All nested calls to cloneVertex will be called with the value of x and v
+	// of this vertex. Ideally, cloneRoot would call cloneVertex with the
+	// correct values already, but x is not known yet at that point.
+	if from == nil {
+		from, to = x, v
+	}
+
 	x.overlay = v
 
 	ctx.vertices = append(ctx.vertices, x)
 
+	v.Conjuncts = slices.Clone(v.Conjuncts)
+
 	// The group of the root closeContext should point to the Conjuncts field
 	// of the Vertex. As we already allocated the group, we use that allocation,
 	// but "move" it to v.Conjuncts.
-	v.Conjuncts = slices.Clone(v.Conjuncts)
+	// TODO: Is this ever necessary? It is certainly necessary to rewrite
+	// environments from inserted disjunction values, but expressions that
+	// were already added will typically need to be recomputed and recreated
+	// anyway. We add this in to be a bit defensive and reinvestigate once we
+	// have more aggressive structure sharing implemented
+	for i, c := range v.Conjuncts {
+		v.Conjuncts[i].Env = derefDisjunctsEnv(c.Env, x, v)
+	}
 
 	if a := x.Arcs; len(a) > 0 {
 		// TODO(perf): reuse buffer.
 		v.Arcs = make([]*Vertex, len(a))
 		for i, arc := range a {
 			// TODO(perf): reuse when finalized.
-			arc := ctx.cloneVertex(arc)
+			arc := ctx.cloneVertex(arc, from, to)
 			v.Arcs[i] = arc
 			arc.Parent = v
 		}
@@ -139,7 +156,7 @@ func (ctx *overlayContext) cloneVertex(x *Vertex) *Vertex {
 		for i, p := range pc.Pairs {
 			npc.Pairs[i] = PatternConstraint{
 				Pattern:    p.Pattern,
-				Constraint: ctx.cloneVertex(p.Constraint),
+				Constraint: ctx.cloneVertex(p.Constraint, from, to),
 			}
 		}
 	}
@@ -154,6 +171,23 @@ func (ctx *overlayContext) cloneVertex(x *Vertex) *Vertex {
 	return v
 }
 
+// derefDisjunctsEnv creates a new env for each Environment in the Up chain
+// with each Environment where Vertex is "from" to one where Vertex is "to".
+func derefDisjunctsEnv(env *Environment, from, to *Vertex) *Environment {
+	if env == nil {
+		return nil
+	}
+	up := derefDisjunctsEnv(env.Up, from, to)
+	if up != env.Up || env.Vertex == from {
+		env = &Environment{
+			Up:           up,
+			Vertex:       to,
+			DynamicLabel: env.DynamicLabel,
+		}
+	}
+	return env
+}
+
 func (ctx *overlayContext) cloneNodeContext(n *nodeContext) *nodeContext {
 	n.node.getState(ctx.ctx) // ensure state is initialized.