internal/core/adt: support comparsion of structs

This is now trivial given the recent changes.

Issue #2583

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

Author: mpvl

cue/testdata/basicrewrite/016_comparison.txtar

@@ -17,18 +17,35 @@ package adt
 import (
 	"bytes"
 	"strings"
+
+	"cuelang.org/go/cue/token"
 )
 
 var checkConcrete = &ValidateConfig{
 	Concrete: true,
 	Final:    true,
 }
 
+// errOnDiffType is a special value that is used as a source to BinOp to
+// indicate that the operation is not supported for the operands of different
+// kinds.
+var errOnDiffType = &UnaryExpr{}
+
 // BinOp handles all operations except AndOp and OrOp. This includes processing
 // unary comparators such as '<4' and '=~"foo"'.
 //
+// The node argument is the adt node corresponding to the binary expression. It
+// is used to determine the source position of the operation, which in turn is
+// used to determine the experiment context.
+//
 // BinOp returns nil if not both left and right are concrete.
-func BinOp(c *OpContext, op Op, left, right Value) Value {
+func BinOp(c *OpContext, node Node, op Op, left, right Value) Value {
+	var p token.Pos
+	if node != nil {
+		if src := node.Source(); src != nil {
+			p = src.Pos()
+		}
+	}
 	leftKind := left.Kind()
 	rightKind := right.Kind()
 
@@ -75,6 +92,10 @@ func BinOp(c *OpContext, op Op, left, right Value) Value {
 
 		case leftKind == ListKind && rightKind == ListKind:
 			return c.newBool(Equal(c, left, right, RegularOnly|IgnoreOptional))
+
+		case !p.Experiment().StructCmp:
+		case leftKind == StructKind && rightKind == StructKind:
+			return c.newBool(Equal(c, left, right, RegularOnly|IgnoreOptional))
 		}
 
 	case NotEqualOp:
@@ -101,6 +122,10 @@ func BinOp(c *OpContext, op Op, left, right Value) Value {
 
 		case leftKind == ListKind && rightKind == ListKind:
 			return c.newBool(!Equal(c, left, right, RegularOnly|IgnoreOptional))
+
+		case !p.Experiment().StructCmp:
+		case leftKind == StructKind && rightKind == StructKind:
+			return c.newBool(!Equal(c, left, right, RegularOnly|IgnoreOptional))
 		}
 
 	case LessThanOp, LessEqualOp, GreaterEqualOp, GreaterThanOp:

internal/core/adt/binop.go

@@ -653,7 +653,7 @@ func (n *nodeContext) insertValueConjunct(env *Environment, v Value, id CloseInf
 		n.updateCyclicStatusV3(id)
 
 		if y := n.scalar; y != nil {
-			if b, ok := BinOp(ctx, EqualOp, x, y).(*Bool); !ok || !b.B {
+			if b, ok := BinOp(ctx, errOnDiffType, EqualOp, x, y).(*Bool); !ok || !b.B {
 				n.reportConflict(x, y, x.Kind(), y.Kind(), n.scalarID, id)
 			}
 			break

internal/core/adt/conjunct.go

@@ -191,7 +191,7 @@ func equalTerminal(ctx *OpContext, v, w Value, flags Flag) bool {
 		return ok
 
 	case *Num, *String, *Bool, *Bytes, *Null:
-		if b, ok := BinOp(ctx, EqualOp, v, w).(*Bool); ok {
+		if b, ok := BinOp(ctx, errOnDiffType, EqualOp, v, w).(*Bool); ok {
 			return b.B
 		}
 		return false

internal/core/adt/equality.go

@@ -2134,7 +2134,7 @@ func (n *nodeContext) addValueConjunct(env *Environment, v Value, id CloseInfo)
 
 	case Value: // *NullLit, *BoolLit, *NumLit, *StringLit, *BytesLit, *Builtin
 		if y := n.scalar; y != nil {
-			if b, ok := BinOp(ctx, EqualOp, x, y).(*Bool); !ok || !b.B {
+			if b, ok := BinOp(ctx, errOnDiffType, EqualOp, x, y).(*Bool); !ok || !b.B {
 				n.reportConflict(x, y, x.Kind(), y.Kind(), n.scalarID, id)
 			}
 			// TODO: do we need to explicitly add again?

internal/core/adt/eval.go

@@ -657,7 +657,7 @@ func (x *BoundValue) validate(c *OpContext, y Value) *Bottom {
 		return c.Err()
 	}
 
-	switch v := BinOp(c, x.Op, a, b).(type) {
+	switch v := BinOp(c, x, x.Op, a, b).(type) {
 	case *Bottom:
 		return v
 
@@ -1379,7 +1379,7 @@ func (x *BinaryExpr) evaluate(c *OpContext, state combinedFlags) Value {
 		return err
 	}
 
-	return BinOp(c, x.Op, left, right)
+	return BinOp(c, x, x.Op, left, right)
 }
 
 func (c *OpContext) validate(env *Environment, src ast.Node, x Expr, op Op, flags combinedFlags) (r Value) {

internal/core/adt/expr.go

@@ -279,7 +279,7 @@ func opInfo(op Op) (cmp Op, norm int) {
 }
 
 func test(ctx *OpContext, op Op, a, b Value) bool {
-	if b, ok := BinOp(ctx, op, a, b).(*Bool); ok {
+	if b, ok := BinOp(ctx, nil, op, a, b).(*Bool); ok {
 		return b.B
 	}
 	return false

internal/core/adt/simplify.go

@@ -312,7 +312,7 @@ func (s *subsumer) bound(x *adt.BoundValue, v adt.Value) bool {
 }
 
 func test(ctx *adt.OpContext, src adt.Node, op adt.Op, gt, lt adt.Value) bool {
-	x := adt.BinOp(ctx, op, gt, lt)
+	x := adt.BinOp(ctx, src, op, gt, lt)
 	b, ok := x.(*adt.Bool)
 	return ok && b.B
 }

internal/core/subsume/value.go

@@ -44,6 +44,13 @@ type File struct {
 	// TODO: we could later use it for enabling testing features, such as
 	// testing-specific builtins.
 	Testing bool `experiment:"since:v0.13.0"`
+
+	// StructCmp enables comparison of structs. This also defines the ==
+	// operator to be defined on all values. For instance, comparing `1` and
+	// "foo" will return false, whereas previously it would return an error.
+	//
+	// Proposal was defined in https://cuelang.org/issue/2358.
+	StructCmp bool `experiment:"since:v0.14.0"`
 }
 
 // NewFile parses the given comma-separated list of experiments for