fix(gnovm): correct comparison between different types

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

@@ -218,8 +218,8 @@ func TestEmpty(t *testing.T) {
 		{"", true},
 		{0, true},
 		{int(0), true},
-		{int64(0), true},
-		{uint(0), true},
+		{int64(0), false},
+		{uint(0), false},
 		// XXX: continue
 
 		// not expected to be empty
@@ -258,8 +258,8 @@ func TestNotEmpty(t *testing.T) {
 		{"", false},
 		{0, false},
 		{int(0), false},
-		{int64(0), false},
-		{uint(0), false},
+		{int64(0), true},
+		{uint(0), true},
 		{std.Address(""), false},
 
 		// not expected to be empty

gnovm/pkg/gnolang/op_binary.go

@@ -79,7 +79,6 @@
 	if debug {
 		debugAssertEqualityTypes(lv.T, rv.T)
 	}
-
 	// set result in lv.
 	res := isEql(m.Store, lv, rv)
 	lv.T = UntypedBoolType
@@ -344,6 +343,9 @@
 	} 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
 		}
 	}
+	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: xv.TV.T}),
+		T: m.Alloc.NewType(&PointerType{Elt: elt}),
 		V: xv,
 	})
 }

gnovm/pkg/gnolang/preprocess.go

@@ -1257,6 +1257,7 @@
 								return n, TRANS_CONTINUE
 							}
 						}
+						// TODO: consider this, need check?
 						// (const) untyped decimal -> float64.
 						// (const) untyped bigint -> int.
 						if !constConverted {
@@ -1498,6 +1499,13 @@
 				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 +2789,10 @@
 					// 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:
+					// nothing to do, quick forward
+				default:
+					// do nothing
 				}
 			}
 		}

gnovm/pkg/gnolang/values_conversions.go

@@ -868,6 +868,8 @@ GNO_CASE:
 				"cannot convert %s to %s",
 				tv.T.String(), k.String()))
 		}
+	// case BigintKind:
+	//	ConvertUntypedBigintTo(tv, tv.V.(BigintValue), t)
 	default:
 		panic(fmt.Sprintf(
 			"cannot convert %s to %s",

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")
+
+// specil 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")
+
+// specil 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)

gnovm/tests/files/types/cmp_iface_6.gno

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"strconv"
+)
+
+type E interface {
+	Error() string
+}
+
+type Error1 int64
+
+func (e Error1) Error() string {
+	return "error: " + strconv.Itoa(int(e))
+}
+
+type Error2 int64
+
+func (e Error2) Error() string {
+	return "error: " + strconv.Itoa(int(e))
+}
+
+// both not const, and both interface
+func main() {
+	var e1 E = Error1(0)
+	var e2 E = Error2(0)
+	println(e1 == e2)
+}
+
+// Output:
+// false

gnovm/tests/files/types/cmp_primitive_0.gno

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"strconv"
+)
+
+type Error int8
+
+func (e Error) Error() string {
+	return "error: " + strconv.Itoa(int(e))
+}
+
+// left is untyped const, right is typed const
+// left is assignable to right
+func main() {
+	if 1 == Error(1) {
+		println("what the firetruck?")
+	} else {
+		println("something else")
+	}
+}
+
+// Output:
+// what the firetruck?

gnovm/tests/files/types/cmp_primitive_1.gno

@@ -0,0 +1,22 @@
+package main
+
+type Error string
+
+func (e Error) Error() string {
+	return "error: " + string(e)
+}
+
+// left is untyped const, right is typed const
+// left is not assignable to right
+// a) it's (untyped) bigint
+// b) base type of right is string
+func main() {
+	if 1 == Error(1) {
+		println("what the firetruck?")
+	} else {
+		println("something else")
+	}
+}
+
+// Error:
+// main/files/types/cmp_primitive_1.gno:14:5: cannot use untyped Bigint as StringKind

gnovm/tests/files/types/cmp_primitive_2.gno

@@ -0,0 +1,15 @@
+package main
+
+var a int8
+
+func main() {
+	a = 1
+	if 1 == a {
+		println("what the firetruck?")
+	} else {
+		println("something else")
+	}
+}
+
+// Output:
+// what the firetruck?

gnovm/tests/files/types/cmp_primitive_3.gno

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"strconv"
+)
+
+type Error int8
+
+func (e Error) Error() string {
+	return "error: " + strconv.Itoa(int(e))
+}
+
+// left is typed const, right is untyped const
+func main() {
+	if Error(1) == 1 {
+		println("what the firetruck?")
+	} else {
+		println("something else")
+	}
+}
+
+// Output:
+// what the firetruck?