fix: solve problem that variable (of declaredType) is not assigned with correct type

gnovm/pkg/gnolang/preprocess.go

@@ -1008,10 +1008,16 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 						}
 					} else if fv.PkgPath == uversePkgPath && fv.Name == "copy" {
 						if len(n.Args) == 2 {
+							args0T := evalStaticTypeOf(store, last, n.Args[0])
+							args1T := evalStaticTypeOf(store, last, n.Args[1])
+							if args0T.Elem().TypeID() != args1T.Elem().TypeID() {
+								panic(fmt.Sprintf(
+									"arguments to copy have different element types, want %s, got %s", args0T.Elem().TypeID(), args1T.Elem().TypeID()))
+							}
 							// If the second argument is a string,
 							// convert to byteslice.
 							args1 := n.Args[1]
-							if evalStaticTypeOf(store, last, args1).Kind() == StringKind {
+							if args1T.Kind() == StringKind {
 								bsx := constType(nil, gByteSliceType)
 								args1 = Call(bsx, args1)
 								args1 = Preprocess(nil, last, args1).(Expr)
@@ -1119,12 +1125,12 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 					for i, tv := range argTVs {
 						if hasVarg {
 							if (len(spts) - 1) <= i {
-								checkType(tv.T, spts[len(spts)-1].Type.Elem(), true)
+								checkType(tv.T, spts[len(spts)-1].Type.Elem(), true, nil)
 							} else {
-								checkType(tv.T, spts[i].Type, true)
+								checkType(tv.T, spts[i].Type, true, nil)
 							}
 						} else {
-							checkType(tv.T, spts[i].Type, true)
+							checkType(tv.T, spts[i].Type, true, nil)
 						}
 					}
 				} else {
@@ -2309,9 +2315,12 @@ func checkOrConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative
 		checkOrConvertType(store, last, &bx.Left, t, autoNative)
 	} else if *x != nil { // XXX if x != nil && t != nil {
 		xt := evalStaticTypeOf(store, last, *x)
+		var conversionNeeded bool
 		if t != nil {
-			checkType(xt, t, autoNative)
+			// TODO: shall convert here?
+			checkType(xt, t, autoNative, &conversionNeeded)
 		}
+
 		if isUntyped(xt) {
 			if t == nil {
 				t = defaultTypeOf(xt)
@@ -2337,6 +2346,12 @@ func checkOrConvertType(store Store, last BlockNode, x *Expr, t Type, autoNative
 			cx = Preprocess(store, last, cx).(Expr)
 			*x = cx
 		}
+		// cover all declared type case
+		if conversionNeeded {
+			cx := Expr(Call(constType(nil, t), *x))
+			cx = Preprocess(store, last, cx).(Expr)
+			*x = cx
+		}
 	}
 }
 
@@ -2364,7 +2379,7 @@ func convertConst(store Store, last BlockNode, cx *ConstExpr, t Type) {
 // Assert that xt can be assigned as dt (dest type).
 // If autoNative is true, a broad range of xt can match against
 // a target native dt type, if and only if dt is a native type.
-func checkType(xt Type, dt Type, autoNative bool) {
+func checkType(xt Type, dt Type, autoNative bool, conversionNeeded *bool) {
 	// Special case if dt is interface kind:
 	if dt.Kind() == InterfaceKind {
 		if idt, ok := baseOf(dt).(*InterfaceType); ok {
@@ -2480,9 +2495,12 @@ func checkType(xt Type, dt Type, autoNative bool) {
 				"cannot use %s as %s without explicit conversion",
 				xt.String(),
 				ddt.String()))
-		} else {
+		} else { // implies unnamed composite
 			// carry on with baseOf(ddt)
 			dt = ddt.Base
+			if conversionNeeded != nil {
+				*conversionNeeded = true
+			}
 		}
 	}
 	// General cases.
@@ -2527,23 +2545,23 @@ func checkType(xt Type, dt Type, autoNative bool) {
 		}
 	case *PointerType:
 		if pt, ok := xt.(*PointerType); ok {
-			checkType(pt.Elt, cdt.Elt, false)
+			checkType(pt.Elt, cdt.Elt, false, conversionNeeded)
 			return // ok
 		}
 	case *ArrayType:
 		if at, ok := xt.(*ArrayType); ok {
-			checkType(at.Elt, cdt.Elt, false)
+			checkType(at.Elt, cdt.Elt, false, conversionNeeded)
 			return // ok
 		}
 	case *SliceType:
 		if st, ok := xt.(*SliceType); ok {
-			checkType(st.Elt, cdt.Elt, false)
+			checkType(st.Elt, cdt.Elt, false, conversionNeeded)
 			return // ok
 		}
 	case *MapType:
 		if mt, ok := xt.(*MapType); ok {
-			checkType(mt.Key, cdt.Key, false)
-			checkType(mt.Value, cdt.Value, false)
+			checkType(mt.Key, cdt.Key, false, conversionNeeded)
+			checkType(mt.Value, cdt.Value, false, conversionNeeded)
 			return // ok
 		}
 	case *FuncType:

gnovm/pkg/gnolang/types.go

@@ -2363,7 +2363,7 @@ func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTy
 				generic := ct.Generic[:len(ct.Generic)-len(".Elem()")]
 				match, ok := lookup[generic]
 				if ok {
-					checkType(spec, match.Elem(), false)
+					checkType(spec, match.Elem(), false, nil)
 					return // ok
 				} else {
 					// Panic here, because we don't know whether T
@@ -2377,7 +2377,7 @@ func specifyType(store Store, lookup map[Name]Type, tmpl Type, spec Type, specTy
 			} else {
 				match, ok := lookup[ct.Generic]
 				if ok {
-					checkType(spec, match, false)
+					checkType(spec, match, false, nil)
 					return // ok
 				} else {
 					if isUntyped(spec) {

gnovm/tests/files/declaredType0.gno

@@ -0,0 +1,14 @@
+package main
+
+ type word uint
+ type nat []word
+
+ func (n nat) add() bool {
+ 	return true
+ }
+
+ func main() {
+ 	var abs nat
+ 	abs = []word{0} // unname-Composit to named DeclaredTypes
+ 	println(abs.add())
+ }

gnovm/tests/files/declaredType1.gno

@@ -0,0 +1,25 @@
+package main
+
+ type word uint
+ type nat []word
+
+ // structLit
+ type Int struct {
+ 	neg bool
+ 	abs nat
+ }
+
+ func (n nat) add() bool {
+ 	return true
+ }
+
+ func main() {
+ 	z := &Int{
+ 		neg: true,
+ 		abs: []word{0},
+ 	}
+ 	println(z.abs.add())
+ }
+
+ // Output:
+ // true

gnovm/tests/files/declaredType1b.gno

@@ -0,0 +1,25 @@
+package main
+
+ type word uint
+ type nat []word
+
+ type Int struct {
+ 	neg bool
+ 	abs nat
+ }
+
+ func (n nat) add() bool {
+ 	return true
+ }
+
+ func main() {
+ 	z := &Int{
+ 		neg: true,
+ 	}
+
+ 	z.abs = []word{0}
+ 	println(z.abs.add())
+ }
+
+ // Output:
+ // true

gnovm/tests/files/declaredType2.gno

@@ -0,0 +1,21 @@
+package main
+
+ type word uint
+ type nat []word
+
+ func (n nat) add() bool {
+ 	return true
+ }
+
+ // map 
+ func main() {
+ 	items := map[string]nat{}
+
+ 	n := []word{0}
+
+ 	items["test"] = n
+
+ 	r := items["test"]
+
+ 	println(r.add())
+ }

gnovm/tests/files/declaredType2b.gno

@@ -0,0 +1,24 @@
+package main
+
+ type word uint
+ type nat []word
+
+ func (n nat) add() bool {
+ 	return true
+ }
+
+ // mapLit
+ func main() {
+ 	n := []word{0}
+
+ 	items := map[string]nat{
+ 		"test": n,
+ 	}
+
+ 	r := items["test"]
+
+ 	println(r.add())
+ }
+
+ // Output:
+ // true

gnovm/tests/files/declaredType3.gno

@@ -0,0 +1,20 @@
+package main
+
+ type word uint
+ type nat []word
+
+ func (n nat) add() bool {
+ 	return true
+ }
+
+ // sliceLit
+ func main() {
+ 	items := []nat{[]word{0}, []word{1}}
+
+ 	r := items[0]
+
+ 	println(r.add())
+ }
+
+ // Output:
+ // true

gnovm/tests/files/declaredType3b.gno

@@ -0,0 +1,20 @@
+package main
+
+ type word uint
+ type nat []word
+
+ func (n nat) add() bool {
+ 	return true
+ }
+
+ // sliceLit2
+ func main() {
+ 	items := []nat{1:[]word{0}, 2:[]word{1}}
+
+ 	r := items[1]
+
+ 	println(r.add())
+ }
+
+ // Output:
+ // true 

gnovm/tests/files/declaredType3c.gno

@@ -0,0 +1,24 @@
+package main
+
+ type word uint
+ type nat []word
+
+ func (n nat) add() bool {
+ 	return true
+ }
+
+ // slice append
+ func main() {
+ 	var items []nat
+
+ 	n := []word{0}
+
+ 	items = append(items, n)
+
+ 	r := items[0]
+
+ 	println(r.add())
+ }
+
+ // Output:
+ // true 

gnovm/tests/files/declaredType3d.gno

@@ -0,0 +1,20 @@
+package main
+
+ type word uint
+ type nat []word
+
+ func (n nat) add() bool {
+ 	return true
+ }
+
+ // ArrayLit
+ func main() {
+ 	items := [3]nat{[]word{0}, []word{1}}
+
+ 	r := items[0]
+
+ 	println(r.add())
+ }
+
+ // Output:
+ // true 

gnovm/tests/files/declaredType4.gno

@@ -0,0 +1,22 @@
+package main
+
+
+ type word uint
+ type nat []word
+
+ func (n nat) add(x, y nat) bool {
+ 	return true
+ }
+
+ // parameter
+ func main() {
+ 	var abs nat
+ 	abs = []word{0}
+ 	x := []word{1}
+ 	y := []word{2}
+
+ 	println(abs.add(x, y))
+ }
+
+ // Output:
+ // true

gnovm/tests/files/declaredType5.gno

@@ -0,0 +1,22 @@
+package main
+
+ type BasicFunc func(int, int) int
+ type MyFunc BasicFunc
+
+ func (f MyFunc) Apply(a, b int) int {
+ 	return f(a, b)
+ }
+
+ func main() {
+ 	basicAdd := func(a, b int) int {
+ 		return a + b
+ 	}
+ 	var myAdd MyFunc
+ 	myAdd = basicAdd
+
+ 	result := myAdd.Apply(2, 3)
+ 	println(result)
+ }
+
+ // Output:
+ // 5