fix: interface to concrete type by T(ifaceVal) is not allowed (#3757)

Closes [3412](#3412)

Author: petar-dambovaliev

Diff for: gnovm/pkg/gnolang/gno_test.go

@@ -128,6 +128,300 @@ func TestBuiltinIdentifiersShadowing(t *testing.T) {
 	}
 }
 
+func TestConvertTo(t *testing.T) {
+	t.Parallel()
+
+	testFunc := func(source, msg string) {
+		defer func() {
+			if len(msg) == 0 {
+				return
+			}
+
+			r := recover()
+
+			if r == nil {
+				t.Fail()
+			}
+
+			err := r.(*PreprocessError)
+			c := strings.Contains(err.Error(), msg)
+			if !c {
+				t.Fatalf(`expected "%s", got "%s"`, msg, r)
+			}
+		}()
+
+		m := NewMachine("test", nil)
+
+		n := MustParseFile("main.go", source)
+		m.RunFiles(n)
+		m.RunMain()
+	}
+
+	type cases struct {
+		source string
+		msg    string
+	}
+
+	tests := []cases{
+		{
+			`package test
+		func main() {
+			var t interface{}
+			t = 2
+			var g = float32(t)
+			println(g)
+		}
+		`, `test/main.go:5:12: cannot convert interface{} to float32: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = 2
+		   var g = int(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to int: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = 2
+		   var g = int8(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to int8: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = 2
+		   var g = int16(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to int16: need type assertion`,
+		},
+		{
+			`package test
+				func main() {
+				   var t interface{}
+				   t = 2
+				   var g = int32(t)
+				   println(g)
+				}
+				`, `test/main.go:5:16: cannot convert interface{} to int32: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = 2
+		   var g = int64(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to int64: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = 2
+		   var g = uint(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to uint: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = 2
+		   var g = uint8(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to uint8: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = 2
+		   var g = uint16(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to uint16: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = 2
+		   var g = uint32(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to uint32: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = 2
+		   var g = uint64(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to uint64: need type assertion`,
+		},
+
+		// Built-in non-numeric types
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = "hello"
+		   var g = string(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to string: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = true
+		   var g = bool(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to bool: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = 'a'
+		   var g = rune(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to int32: need type assertion`,
+		},
+		{
+			`package test
+		func main() {
+		   var t interface{}
+		   t = byte(65)
+		   var g = byte(t)
+		   println(g)
+		}
+		`, `test/main.go:5:14: cannot convert interface{} to uint8: need type assertion`,
+		},
+
+		{
+			`package test
+		type MyInt int
+		func main() {
+		   var t interface{}
+		   t = MyInt(2)
+		   var g = MyInt(t)
+		   println(g)
+		}
+		`, `test/main.go:6:14: cannot convert interface{} to test.MyInt: need type assertion`,
+		},
+		{
+			`package test
+		
+		func main() {
+			const a int = -1
+		   println(uint(a))
+		}`,
+			`test/main.go:5:14: cannot convert constant of type IntKind to UintKind`,
+		},
+		{
+			`package test
+		
+		func main() {
+			const a int = -1
+		   println(uint8(a))
+		}`,
+			`test/main.go:5:14: cannot convert constant of type IntKind to Uint8Kind`,
+		},
+		{
+			`package test
+		
+		func main() {
+			const a int = -1
+		   println(uint16(a))
+		}`,
+			`test/main.go:5:14: cannot convert constant of type IntKind to Uint16Kind`,
+		},
+		{
+			`package test
+		
+		func main() {
+			const a int = -1
+		   println(uint32(a))
+		}`,
+			`test/main.go:5:14: cannot convert constant of type IntKind to Uint32Kind`,
+		},
+		{
+			`package test
+		
+		func main() {
+			const a int = -1
+		   println(uint64(a))
+		}`,
+			`test/main.go:5:14: cannot convert constant of type IntKind to Uint64Kind`,
+		},
+		{
+			`package test
+		
+		func main() {
+			const a float32 = 1.5
+		   println(int32(a))
+		}`,
+			`test/main.go:5:14: cannot convert constant of type Float32Kind to Int32Kind`,
+		},
+		{
+			`package test
+		
+		func main() {
+		   println(int32(1.5))
+		}`,
+			`test/main.go:4:14: cannot convert (const (1.5 <untyped> bigdec)) to integer type`,
+		},
+		{
+			`package test
+		
+		func main() {
+			const a float64 = 1.5
+		   println(int64(a))
+		}`,
+			`test/main.go:5:14: cannot convert constant of type Float64Kind to Int64Kind`,
+		},
+		{
+			`package test
+		
+		func main() {
+		   println(int64(1.5))
+		}`,
+			`test/main.go:4:14: cannot convert (const (1.5 <untyped> bigdec)) to integer type`,
+		},
+		{
+			`package test
+		
+				func main() {
+					const f = float64(1.0)
+				   println(int64(f))
+				}`,
+			``,
+		},
+	}
+
+	for _, tc := range tests {
+		testFunc(tc.source, tc.msg)
+	}
+}
+
 // run empty main().
 func TestRunEmptyMain(t *testing.T) {
 	t.Parallel()

Diff for: gnovm/pkg/gnolang/preprocess.go

@@ -1441,7 +1441,16 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 							checkOrConvertType(store, last, n, &n.Args[0], ct, false)
 						}
 					default:
-						// do nothing
+						ctBase := baseOf(ct)
+						atBase := baseOf(at)
+
+						_, isCTInterface := ctBase.(*InterfaceType)
+						_, isCTNative := ctBase.(*NativeType)
+						_, isATInterface := atBase.(*InterfaceType)
+
+						if (!isCTInterface && !isCTNative) && isATInterface {
+							panic(fmt.Sprintf("cannot convert %v to %v: need type assertion", at.TypeID(), ct.TypeID()))
+						}
 					}
 					// general case, for non-const untyped && no nested untyped shift
 					// after handling const, and special cases recursively, set the target node type

Diff for: gnovm/tests/files/interface39b.gno

@@ -14,7 +14,7 @@ type Stringer interface {
 
 func main() {
 	var f Stringer = &foo{bar: "bar"}
-	println(*((*foo)(f)))
+	println(*f.(*foo))
 }
 
 // Output: