internal/core/adt: make some errors semi-permanent

An incomplete error indicates the error may be resolved by
making a configuration more specific. However, sometimes,
during partial evaluation, an incomplete error may arise
because a value is not fully evaluated yet to the point the
incomplete error may still resolve upon further evaluation.

In this change we make some distinctions between these
cases to prevent non-applicable error messages from
bubbling up and rather propagate applicable error messages
more strictly.

This may also have a positive impact on performance, as
less incomplete evaluations need to be "retried".

Fixes #1837
Issue #804

Signed-off-by: Marcel van Lohuizen <[email protected]>
Change-Id: I2d1a7876d626da5b4a32db8e1cd6cd9b87eb63e9
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/543574
Reviewed-by: Aram Hăvărneanu <[email protected]>
Unity-Result: CUEcueckoo <[email protected]>
TryBot-Result: CUEcueckoo <[email protected]>

Author: mpvl

cue/testdata/eval/incomplete.txtar

@@ -17,6 +17,32 @@ E: {
 
 a:    int
 okay: (>10 & <a) + 3
+
+issue1837: {
+	// x is properly recognized as erroneous and the "message" field is added
+	// with the value "a", instead of as a cycle error.
+	p1: {
+		context: {}
+		x: context.b // incomplete error
+		if x == _|_ {
+			message: "a"
+		}
+	}
+	p2: {
+		if x == _|_ {
+			message: "a"
+		}
+		x: context.b // incomplete error
+		context: {}
+	}
+	p3: {
+		if x == _|_ {
+			message: "a"
+		}
+		context: {}
+		x: context.b // incomplete error
+	}
+}
 -- out/eval --
 (struct){
   s: (string){ string }
@@ -58,6 +84,35 @@ okay: (>10 & <a) + 3
     //     ./in.cue:18:7
     //     ./in.cue:18:8
   }
+  issue1837: (struct){
+    p1: (struct){
+      message: (string){ "a" }
+      context: (struct){
+      }
+      x: (_|_){
+        // [incomplete] issue1837.p1.x: undefined field: b:
+        //     ./in.cue:25:14
+      }
+    }
+    p2: (struct){
+      message: (string){ "a" }
+      x: (_|_){
+        // [incomplete] issue1837.p2.x: undefined field: b:
+        //     ./in.cue:34:14
+      }
+      context: (struct){
+      }
+    }
+    p3: (struct){
+      message: (string){ "a" }
+      context: (struct){
+      }
+      x: (_|_){
+        // [incomplete] issue1837.p3.x: undefined field: b:
+        //     ./in.cue:42:14
+      }
+    }
+  }
 }
 -- out/compile --
 --- in.cue
@@ -76,4 +131,27 @@ okay: (>10 & <a) + 3
   }
   a: int
   okay: ((>10 & <〈0;a〉) + 3)
+  issue1837: {
+    p1: {
+      context: {}
+      x: 〈0;context〉.b
+      if (〈0;x〉 == _|_(explicit error (_|_ literal) in source)) {
+        message: "a"
+      }
+    }
+    p2: {
+      if (〈0;x〉 == _|_(explicit error (_|_ literal) in source)) {
+        message: "a"
+      }
+      x: 〈0;context〉.b
+      context: {}
+    }
+    p3: {
+      if (〈0;x〉 == _|_(explicit error (_|_ literal) in source)) {
+        message: "a"
+      }
+      context: {}
+      x: 〈0;context〉.b
+    }
+  }
 }

internal/core/adt/context.go

@@ -890,17 +890,23 @@ func (c *OpContext) lookup(x *Vertex, pos token.Pos, l Feature, state VertexStat
 
 		// TODO(errors): add path reference and make message
 		//       "undefined field %s in %s"
+		var err *ValueError
 		if l.IsInt() {
-			c.addErrf(code, pos, "index out of range [%d] with length %d",
+			err = c.NewPosf(pos, "index out of range [%d] with length %d",
 				l.Index(), len(x.Elems()))
 		} else {
 			if code != 0 && x.IsOptional(l) {
-				c.addErrf(code, pos,
+				err = c.NewPosf(pos,
 					"cannot reference optional field: %s", label)
 			} else {
-				c.addErrf(code, pos, "undefined field: %s", label)
+				err = c.NewPosf(pos, "undefined field: %s", label)
 			}
 		}
+		c.AddBottom(&Bottom{
+			Code:      code,
+			Permanent: x.status >= AllArcs,
+			Err:       err,
+		})
 	}
 	return a
 }

internal/core/adt/errors.go

@@ -89,7 +89,11 @@ type Bottom struct {
 	Src ast.Node
 	Err errors.Error
 
-	Code         ErrorCode
+	Code ErrorCode
+	// Permanent indicates whether an incomplete error can be
+	// resolved later without making the configuration more specific.
+	// This may happen when an arc isn't fully resolved yet.
+	Permanent    bool
 	HasRecursive bool
 	ChildError   bool // Err is the error of the child
 	NotExists    bool // This error originated from a failed lookup.

internal/core/adt/eval.go

@@ -1390,7 +1390,7 @@ func (n *nodeContext) evalExpr(v Conjunct) {
 	switch x := v.Expr().(type) {
 	case Resolver:
 		arc, err := ctx.Resolve(v, x)
-		if err != nil && !err.IsIncomplete() {
+		if err != nil && (!err.IsIncomplete() || err.Permanent) {
 			n.addBottom(err)
 			break
 		}