internal/core/eval: reduce per-node allocations

Removed resultNode from nodeShared and reuse
allocations of nodeShared and nodeContext.

Reduces running time of all tests by about 15%.

This also simplifies disjunction handling and prepares
for optimizing disjunction handling further.

Note that with this change, it would be possible to
merge nodeShared and nodeContext into a single
type. This is left for later work.

This also delays the creation of the arcMap to
when it is really needed, avoiding another allocation
for the majority of nodes.

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

Author: mpvl

cue/testdata/cycle/051_resolved_self-reference_cycles_with_disjunction.txtar

@@ -172,7 +172,8 @@ Result:
   xa4: (int){ 10 }
   xb1: (int){ |((int){ 8 }, (int){ 9 }) }
   xb2: (_|_){
-    // [incomplete]
+    // [incomplete] xb2: unresolved disjunction 6 | 9 (type int):
+    //     ./in.cue:18:6
   }
   xb3: (int){ |((int){ 6 }, (int){ 9 }) }
   xb4: (_|_){
@@ -213,7 +214,8 @@ Result:
   }
   xf1: (int){ |((int){ 8 }, (int){ 9 }) }
   xf2: (_|_){
-    // [incomplete]
+    // [incomplete] xf2: unresolved disjunction 6 | 9 (type int):
+    //     ./in.cue:52:6
   }
   xf3: (int){ |((int){ 6 }, (int){ 9 }) }
   xf4: (_|_){

cue/testdata/cycle/052_resolved_self-reference_cycles_with_disjunction_with_defaults.txtar

@@ -140,10 +140,8 @@ Result:
   xa2: (int){ 8 }
   xa3: (int){ 6 }
   xa4: (int){ 10 }
-  xb1: (int){ |(*(int){ 8 }, (int){ 9 }) }
-  xb2: (_|_){
-    // [incomplete]
-  }
+  xb1: (int){ 8 }
+  xb2: (int){ 8 }
   xb3: (int){ 6 }
   xb4: (_|_){
     // [cycle] cycle error

internal/core/eval/disjunct.go

@@ -133,11 +133,8 @@ func (n *nodeContext) updateResult() (isFinal bool) {
 		return n.isFinal
 	}
 
-	d := n.nodeShared.disjunct
-	if d == nil {
-		d = &adt.Disjunction{}
-		n.nodeShared.disjunct = d
-	}
+	n.touched = true
+	d := &n.nodeShared.disjunct
 
 	result := *n.node
 	if result.Value == nil {
@@ -152,6 +149,11 @@ func (n *nodeContext) updateResult() (isFinal bool) {
 
 	p := &result
 	d.Values = append(d.Values, p)
+
+	if n.done() && (!n.isDefault() || n.isDefault()) {
+		n.nodeShared.isDone = true
+	}
+
 	if n.defaultMode == isDefault {
 		// Keep defaults sorted first.
 		i := d.NumDefaults
@@ -172,22 +174,9 @@ func (n *nodeContext) updateResult() (isFinal bool) {
 	case !n.nodeShared.isDefault() && n.defaultMode == isDefault:
 
 	default:
-		if x := n.result(); x == nil && Equal(n.ctx, n.node, x) {
-			return n.isFinal
-		}
-
-		// TODO: Compute fancy error message.
-		n.nodeShared.resultNode = n
-		// n.nodeShared.result.AddErr(n.ctx, &adt.Bottom{
-		// 	Code: adt.IncompleteError,
-		// 	Err:  errors.Newf(n.ctx.Pos(), "ambiguous disjunction"),
-		// })
-		n.nodeShared.result_.Arcs = nil
-		n.nodeShared.result_.Structs = nil
 		return n.isFinal // n.defaultMode == isDefault
 	}
 
-	n.nodeShared.resultNode = n
 	n.nodeShared.setResult(n.node)
 
 	return n.isFinal
@@ -225,11 +214,11 @@ func (n *nodeContext) insertDisjuncts() (inserted bool) {
 	p := 0
 	inserted = true
 
-	disjunctions := []envDisjunct{}
+	n.subDisjunctions = n.subDisjunctions[:0]
 
 	// fmt.Println("----", debug.NodeString(n.ctx, n.node, nil))
 	for _, d := range n.disjunctions {
-		disjunctions = append(disjunctions, d)
+		n.subDisjunctions = append(n.subDisjunctions, d)
 
 		sub := len(n.disjunctions)
 		defMode, ok := n.insertSingleDisjunct(p, d, false)
@@ -260,7 +249,7 @@ func (n *nodeContext) insertDisjuncts() (inserted bool) {
 			// 0 to a referenced number (forces the default to be discarded).
 			wasScalar := n.scalar != nil // Hack line 1
 
-			disjunctions = append(disjunctions, d)
+			n.subDisjunctions = append(n.subDisjunctions, d)
 			mode, ok := n.insertSingleDisjunct(p, d, true)
 			p++
 			if !ok {
@@ -278,7 +267,7 @@ func (n *nodeContext) insertDisjuncts() (inserted bool) {
 	}
 
 	// Find last disjunction at which there is no overflow.
-	for ; p > 0 && n.stack[p-1]+1 >= len(disjunctions[p-1].values); p-- {
+	for ; p > 0 && n.stack[p-1]+1 >= len(n.subDisjunctions[p-1].values); p-- {
 	}
 	if p > 0 {
 		// Increment a valid position and set all subsequent entries to 0.