internal/core: move equality checks from eval to adt

So that it can be used by adt itself without cycles.

Also seems to be the more appropriate place.

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

Author: mpvl

cue/types.go

@@ -1785,7 +1785,7 @@ func (v Value) Equals(other Value) bool {
 	if v.v == nil || other.v == nil {
 		return false
 	}
-	return eval.Equal(v.ctx().opCtx, v.v, other.v)
+	return adt.Equal(v.ctx().opCtx, v.v, other.v)
 }
 
 // Format prints a debug version of a value.

internal/core/eval/equality.go renamed to internal/core/adt/equality.go

@@ -12,22 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package eval
+package adt
 
-import "cuelang.org/go/internal/core/adt"
-
-func Equal(ctx *adt.OpContext, v, w adt.Value) bool {
-	if x, ok := v.(*adt.Vertex); ok {
+func Equal(ctx *OpContext, v, w Value) bool {
+	if x, ok := v.(*Vertex); ok {
 		return equalVertex(ctx, x, w)
 	}
-	if y, ok := w.(*adt.Vertex); ok {
+	if y, ok := w.(*Vertex); ok {
 		return equalVertex(ctx, y, v)
 	}
 	return equalTerminal(ctx, v, w)
 }
 
-func equalVertex(ctx *adt.OpContext, x *adt.Vertex, v adt.Value) bool {
-	y, ok := v.(*adt.Vertex)
+func equalVertex(ctx *OpContext, x *Vertex, v Value) bool {
+	y, ok := v.(*Vertex)
 	if !ok {
 		return false
 	}
@@ -69,42 +67,42 @@ loop1:
 	// 		return false
 	// 	}
 
-	v, ok1 := x.BaseValue.(adt.Value)
-	w, ok2 := y.BaseValue.(adt.Value)
+	v, ok1 := x.BaseValue.(Value)
+	w, ok2 := y.BaseValue.(Value)
 	if !ok1 && !ok2 {
 		return true // both are struct or list.
 	}
 
 	return equalTerminal(ctx, v, w)
 }
 
-func equalTerminal(ctx *adt.OpContext, v, w adt.Value) bool {
+func equalTerminal(ctx *OpContext, v, w Value) bool {
 	if v == w {
 		return true
 	}
 
 	switch x := v.(type) {
-	case *adt.Num, *adt.String, *adt.Bool, *adt.Bytes:
-		if b, ok := adt.BinOp(ctx, adt.EqualOp, v, w).(*adt.Bool); ok {
+	case *Num, *String, *Bool, *Bytes:
+		if b, ok := BinOp(ctx, EqualOp, v, w).(*Bool); ok {
 			return b.B
 		}
 		return false
 
 	// TODO: for the remainder we are dealing with non-concrete values, so we
 	// could also just not bother.
 
-	case *adt.BoundValue:
-		if y, ok := w.(*adt.BoundValue); ok {
+	case *BoundValue:
+		if y, ok := w.(*BoundValue); ok {
 			return x.Op == y.Op && Equal(ctx, x.Value, y.Value)
 		}
 
-	case *adt.BasicType:
-		if y, ok := w.(*adt.BasicType); ok {
+	case *BasicType:
+		if y, ok := w.(*BasicType); ok {
 			return x.K == y.K
 		}
 
-	case *adt.Conjunction:
-		y, ok := w.(*adt.Conjunction)
+	case *Conjunction:
+		y, ok := w.(*Conjunction)
 		if !ok || len(x.Values) != len(y.Values) {
 			return false
 		}
@@ -116,10 +114,10 @@ func equalTerminal(ctx *adt.OpContext, v, w adt.Value) bool {
 		}
 		return true
 
-	case *adt.Disjunction:
+	case *Disjunction:
 		// The best way to compute this is with subsumption, but even that won't
 		// be too accurate. Assume structural equivalence for now.
-		y, ok := w.(*adt.Disjunction)
+		y, ok := w.(*Disjunction)
 		if !ok || len(x.Values) != len(y.Values) {
 			return false
 		}
@@ -130,7 +128,7 @@ func equalTerminal(ctx *adt.OpContext, v, w adt.Value) bool {
 		}
 		return true
 
-	case *adt.BuiltinValidator:
+	case *BuiltinValidator:
 	}
 
 	return false

internal/core/adt/simplify.go

@@ -230,7 +230,7 @@ func SimplifyValidator(ctx *OpContext, v, w Validator) Validator {
 				return nil
 			}
 			for i, a := range x.Args {
-				if !test(ctx, EqualOp, a, y.Args[i]) {
+				if !Equal(ctx, a, y.Args[i]) {
 					return nil
 				}
 			}

internal/core/eval/disjunct.go

@@ -158,7 +158,7 @@ func (n *nodeContext) updateResult(state adt.VertexStatus) (isFinal bool) {
 	}
 
 	for _, v := range d.Values {
-		if Equal(n.ctx, v, &result) {
+		if adt.Equal(n.ctx, v, &result) {
 			return isFinal
 		}
 	}