fix(gnovm): correct comparison between different types

examples/gno.land/p/demo/uassert/uassert.gno

@@ -373,46 +373,85 @@ func NotEqual(t TestingT, expected, actual interface{}, msgs ...string) bool {
 	return true
 }
 
+func isNumberEmpty(n interface{}) (isNumber, isEmpty bool) {
+	switch n := n.(type) {
+	// NOTE: the cases are split individually, so that n becomes of the
+	// asserted type; the type of '0' was correctly inferred and converted
+	// to the corresponding type, int, int8, etc.
+	case int:
+		return true, n == 0
+	case int8:
+		return true, n == 0
+	case int16:
+		return true, n == 0
+	case int32:
+		return true, n == 0
+	case int64:
+		return true, n == 0
+	case uint:
+		return true, n == 0
+	case uint8:
+		return true, n == 0
+	case uint16:
+		return true, n == 0
+	case uint32:
+		return true, n == 0
+	case uint64:
+		return true, n == 0
+	case float32:
+		return true, n == 0
+	case float64:
+		return true, n == 0
+	}
+	return false, false
+}
 func Empty(t TestingT, obj interface{}, msgs ...string) bool {
 	t.Helper()
-	switch val := obj.(type) {
-	case string:
-		if val != "" {
-			return fail(t, msgs, "uassert.Empty: not empty string: %s", val)
-		}
-	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
-		if val != 0 {
-			return fail(t, msgs, "uassert.Empty: not empty number: %d", val)
+
+	isNumber, isEmpty := isNumberEmpty(obj)
+	if isNumber {
+		if !isEmpty {
+			return fail(t, msgs, "uassert.Empty: not empty number: %d", obj)
 		}
-	case std.Address:
-		var zeroAddr std.Address
-		if val != zeroAddr {
-			return fail(t, msgs, "uassert.Empty: not empty std.Address: %s", string(val))
+	} else {
+		switch val := obj.(type) {
+		case string:
+			if val != "" {
+				return fail(t, msgs, "uassert.Empty: not empty string: %s", val)
+			}
+		case std.Address:
+			var zeroAddr std.Address
+			if val != zeroAddr {
+				return fail(t, msgs, "uassert.Empty: not empty std.Address: %s", string(val))
+			}
+		default:
+			return fail(t, msgs, "uassert.Empty: unsupported type")
 		}
-	default:
-		return fail(t, msgs, "uassert.Empty: unsupported type")
 	}
 	return true
 }
 
 func NotEmpty(t TestingT, obj interface{}, msgs ...string) bool {
 	t.Helper()
-	switch val := obj.(type) {
-	case string:
-		if val == "" {
-			return fail(t, msgs, "uassert.NotEmpty: empty string: %s", val)
-		}
-	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
-		if val == 0 {
-			return fail(t, msgs, "uassert.NotEmpty: empty number: %d", val)
-		}
-	case std.Address:
-		var zeroAddr std.Address
-		if val == zeroAddr {
-			return fail(t, msgs, "uassert.NotEmpty: empty std.Address: %s", string(val))
+	isNumber, isEmpty := isNumberEmpty(obj)
+	if isNumber {
+		if isEmpty {
+			return fail(t, msgs, "uassert.NotEmpty: empty number: %d", obj)
+		}
+	} else {
+		switch val := obj.(type) {
+		case string:
+			if val == "" {
+				return fail(t, msgs, "uassert.NotEmpty: empty string: %s", val)
+			}
+		case std.Address:
+			var zeroAddr std.Address
+			if val == zeroAddr {
+				return fail(t, msgs, "uassert.NotEmpty: empty std.Address: %s", string(val))
+			}
+		default:
+			return fail(t, msgs, "uassert.NotEmpty: unsupported type")
 		}
-	default:
-		return fail(t, msgs, "uassert.NotEmpty: unsupported type")
 	}
 	return true
 }

examples/gno.land/p/demo/uassert/uassert_test.gno

@@ -218,6 +218,7 @@ func TestEmpty(t *testing.T) {
 		{"", true},
 		{0, true},
 		{int(0), true},
+		{int32(0), true},
 		{int64(0), true},
 		{uint(0), true},
 		// XXX: continue
@@ -258,6 +259,7 @@ func TestNotEmpty(t *testing.T) {
 		{"", false},
 		{0, false},
 		{int(0), false},
+		{int32(0), false},
 		{int64(0), false},
 		{uint(0), false},
 		{std.Address(""), false},

gnovm/pkg/gnolang/op_binary.go

@@ -79,7 +79,6 @@ func (m *Machine) doOpEql() {
 	if debug {
 		debugAssertEqualityTypes(lv.T, rv.T)
 	}
-
 	// set result in lv.
 	res := isEql(m.Store, lv, rv)
 	lv.T = UntypedBoolType
@@ -344,6 +343,9 @@ func isEql(store Store, lv, rv *TypedValue) bool {
 	} else if rvu {
 		return false
 	}
+	if err := checkSame(lv.T, rv.T, ""); err != nil {
+		return false
+	}
 	if lnt, ok := lv.T.(*NativeType); ok {
 		if rnt, ok := rv.T.(*NativeType); ok {
 			if lnt.Type != rnt.Type {

gnovm/pkg/gnolang/op_expressions.go

@@ -194,8 +194,13 @@ func (m *Machine) doOpRef() {
 			nv.Value = rv2
 		}
 	}
+	// when obtaining a pointer of the databyte type, use the ElemType of databyte
+	elt := xv.TV.T
+	if elt == DataByteType {
+		elt = xv.TV.V.(DataByteValue).ElemType
+	}
 	m.PushValue(TypedValue{
-		T: m.Alloc.NewType(&PointerType{Elt: xv.TV.T}),
+		T: m.Alloc.NewType(&PointerType{Elt: elt}),
 		V: xv,
 	})
 }

gnovm/pkg/gnolang/preprocess.go

@@ -1498,6 +1498,13 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 				checkOrConvertIntegerKind(store, last, n.High)
 				checkOrConvertIntegerKind(store, last, n.Max)
 
+				// if n.X is untyped, convert to corresponding type
+				t := evalStaticTypeOf(store, last, n.X)
+				if isUntyped(t) {
+					dt := defaultTypeOf(t)
+					checkOrConvertType(store, last, &n.X, dt, false)
+				}
+
 			// TRANS_LEAVE -----------------------
 			case *TypeAssertExpr:
 				if n.Type == nil {
@@ -2781,8 +2788,10 @@ func checkOrConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative
 					// push t into bx.Left
 					checkOrConvertType(store, last, &bx.Left, t, autoNative)
 					return
-					// case EQL, LSS, GTR, NEQ, LEQ, GEQ:
-					// default:
+				case EQL, LSS, GTR, NEQ, LEQ, GEQ:
+					// do nothing
+				default:
+					// do nothing
 				}
 			}
 		}

gnovm/tests/files/types/cmp_databyte.gno

@@ -0,0 +1,12 @@
+package main
+
+import "bytes"
+
+func main() {
+	cmp := bytes.Compare([]byte("hello"), []byte("hey"))
+	println(cmp)
+
+}
+
+// Output:
+// -1

gnovm/tests/files/types/cmp_iface_0_stdlibs.gno

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"errors"
+	"strconv"
+)
+
+type Error int64
+
+func (e Error) Error() string {
+	return "error: " + strconv.Itoa(int(e))
+}
+
+var errCmp = errors.New("XXXX")
+
+// special case:
+// one is interface
+func main() {
+	if Error(0) == errCmp {
+		println("what the firetruck?")
+	} else {
+		println("something else")
+	}
+}
+
+// Output:
+// something else

gnovm/tests/files/types/cmp_iface_1.gno

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"errors"
+	"strconv"
+)
+
+type Error int64
+
+func (e Error) Error() string {
+	return "error: " + strconv.Itoa(int(e))
+}
+
+// typed
+var errCmp error = errors.New("XXXX")
+
+// special case:
+// one is interface
+func main() {
+	const e Error = Error(0) // typed const
+	if e == errCmp {
+		println("what the firetruck?")
+	} else {
+		println("something else")
+	}
+}
+
+// Output:
+// something else

gnovm/tests/files/types/cmp_iface_2.gno

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type E interface {
+	Error() string
+}
+type Error int64
+
+func (e Error) Error() string {
+	return "error: " + strconv.Itoa(int(e))
+}
+
+// special case:
+// one is interface
+func main() {
+	var e0 E
+	e0 = Error(0)
+	fmt.Printf("%T \n", e0)
+	if e0 == Error(0) {
+		println("what the firetruck?")
+	} else {
+		println("something else")
+	}
+}
+
+// Output:
+// int64
+// what the firetruck?

gnovm/tests/files/types/cmp_iface_3_stdlibs.gno

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"errors"
+	"strconv"
+)
+
+type Error int64
+
+func (e Error) Error() string {
+	return "error: " + strconv.Itoa(int(e))
+}
+
+var errCmp = errors.New("XXXX")
+
+// special case:
+// one is interface
+func main() {
+	if Error(1) == errCmp {
+		println("what the firetruck?")
+	} else {
+		println("something else")
+	}
+}
+
+// Output:
+// something else

gnovm/tests/files/types/cmp_iface_4.gno

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"strconv"
+)
+
+type Error int64
+
+func (e Error) Error() string {
+	return "error: " + strconv.Itoa(int(e))
+}
+
+// both not const, and both interface
+func main() {
+	var l interface{}
+	if l == Error(0) {
+		println("what the firetruck?")
+	} else {
+		println("something else")
+	}
+}
+
+// Output:
+// something else

gnovm/tests/files/types/cmp_iface_5_stdlibs.gno

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"errors"
+	"strconv"
+)
+
+type Error int64
+
+func (e Error) Error() string {
+	return "error: " + strconv.Itoa(int(e))
+}
+
+var errCmp = errors.New("XXXX")
+
+// special case:
+// one is interface
+func main() {
+	if errCmp == int64(1) {
+		println("what the firetruck?")
+	} else {
+		println("something else")
+	}
+}
+
+// Error:
+// main/files/types/cmp_iface_5_stdlibs.gno:19:5: int64 does not implement .uverse.error (missing method Error)