feat(gnovm): align Gno constant handling with Go specifications

examples/gno.land/r/demo/keystore/keystore_test.gno

@@ -11,7 +11,7 @@ import (
 )
 
 func TestRender(t *testing.T) {
-	const (
+	var (
 		author1 std.Address = testutils.TestAddress("author1")
 		author2 std.Address = testutils.TestAddress("author2")
 	)

examples/gno.land/r/demo/microblog/microblog_test.gno

@@ -10,7 +10,7 @@ import (
 )
 
 func TestMicroblog(t *testing.T) {
-	const (
+	var (
 		author1 std.Address = testutils.TestAddress("author1")
 		author2 std.Address = testutils.TestAddress("author2")
 	)

gnovm/pkg/gnolang/preprocess.go

@@ -2294,6 +2294,7 @@ func preprocess1(store Store, ctx BlockNode, n Node) Node {
 					// NOTE: may or may not be a *ConstExpr,
 					// but if not, make one now.
 					for i, vx := range n.Values {
+						assertValidConstExpr(store, last, n, vx)
 						n.Values[i] = evalConst(store, last, vx)
 					}
 				} else {

gnovm/pkg/gnolang/type_check.go

@@ -215,6 +215,180 @@
 	}
 }
 
+func assertValidConstExpr(store Store, last BlockNode, n *ValueDecl, expr Expr) {
+	if n.Type != nil {
+		nt := evalStaticType(store, last, n.Type)
+		if xnt, ok := nt.(*NativeType); ok {
+			nt = go2GnoBaseType(xnt.Type)
+		}
+
+		if _, ok := baseOf(nt).(PrimitiveType); !ok {
+			panic(fmt.Sprintf("invalid constant type %s", nt.String()))
+		}
+	}
+
+	nt := evalStaticTypeOf(store, last, expr)
+	if xnt, ok := nt.(*NativeType); ok {
+		nt = go2GnoBaseType(xnt.Type)
+	}
+
+	if nt == nil {
+		panic(fmt.Sprintf("%s (variable of type nil) is not constant", expr))
+	}
+
+	if _, ok := baseOf(nt).(PrimitiveType); !ok {
+		panic(fmt.Sprintf("%s (variable of type %s) is not constant", expr, nt))
+	}
+
+	assertValidConstValue(store, last, expr, nil)
+}
+
+func assertValidConstValue(store Store, last BlockNode, currExpr, parentExpr Expr) {
+Main:
+	switch currExpr := currExpr.(type) {
+	case *NameExpr:
+		t := evalStaticTypeOf(store, last, currExpr)
+		if _, ok := t.(*TypeType); ok {
+			t = evalStaticType(store, last, currExpr)
+		}
+		// special case for len, cap
+		if isParentCallExprWithArrayArg(t, parentExpr) {
+			break Main
+		}
+		panic(fmt.Sprintf("%s (variable of type %s) is not constant", currExpr.Name, t))
+	case *TypeAssertExpr:
+		ty := evalStaticTypeOf(store, last, currExpr)
+		if _, ok := ty.(*TypeType); ok {
+			ty = evalStaticType(store, last, currExpr)
+		}
+		// special case for len, cap
+		if isParentCallExprWithArrayArg(ty, parentExpr) {
+			break Main
+		}
+		panic(fmt.Sprintf("%s (comma, ok expression of type %s) is not constant", currExpr.String(), currExpr.Type))
+	case *IndexExpr:
+		ty := evalStaticTypeOf(store, last, currExpr)
+		if _, ok := ty.(*TypeType); ok {
+			ty = evalStaticType(store, last, currExpr)
+		}
+		// TODO: should add a test after the fix of https://github.com/gnolang/gno/issues/3409
+		// special case for len, cap
+		if isParentCallExprWithArrayArg(ty, parentExpr) {
+			break Main
+		}
+
+		panic(fmt.Sprintf("%s (variable of type %s) is not constant", currExpr.String(), currExpr.X))
+	case *CallExpr:
+		ift := evalStaticTypeOf(store, last, currExpr.Func)
+		switch baseOf(ift).(type) {
+		case *FuncType:
+			tup := evalStaticTypeOfRaw(store, last, currExpr).(*tupleType)
+
+			// check for built-in functions
+			if cx, ok := currExpr.Func.(*ConstExpr); ok {
+				if fv, ok := cx.V.(*FuncValue); ok {
+					if fv.PkgPath == uversePkgPath {
+						// TODO: should support min, max, real, imag
+						switch {
+						case fv.Name == "len":
+							assertValidConstValue(store, last, currExpr.Args[0], currExpr)
+							break Main
+						case fv.Name == "cap":
+							assertValidConstValue(store, last, currExpr.Args[0], currExpr)
+							break Main
+						}
+					}
+				}
+			}
+
+			switch {
+			case len(tup.Elts) == 0:
+				panic(fmt.Sprintf("%s (no value) used as value", currExpr.String()))
+			case len(tup.Elts) == 1:
+				panic(fmt.Sprintf("%s (value of type %s) is not constant", currExpr.String(), tup.Elts[0]))
+			default:
+				panic(fmt.Sprintf("multiple-value %s (value of type %s) in single-value context", currExpr.String(), tup.Elts))
+			}
+		case *TypeType:
+			for _, arg := range currExpr.Args {
+				assertValidConstValue(store, last, arg, currExpr)
+			}
+		case *NativeType:
+			// Todo: should add a test after the fix of https://github.com/gnolang/gno/issues/3006
+			ty := evalStaticType(store, last, currExpr.Func)
+			panic(fmt.Sprintf("%s (variable of type %s) is not constant", currExpr.String(), ty))
+		default:
+			panic(fmt.Sprintf(
+				"unexpected func type %v (%v)",
+				ift, reflect.TypeOf(ift)))
+		}
+	case *BinaryExpr:
+		assertValidConstValue(store, last, currExpr.Left, parentExpr)
+		assertValidConstValue(store, last, currExpr.Right, parentExpr)
+	case *SelectorExpr:
+		xt := evalStaticTypeOf(store, last, currExpr.X)
+		switch xt := xt.(type) {
+		case *PackageType:
+			var pv *PackageValue
+			if cx, ok := currExpr.X.(*ConstExpr); ok {
+				// NOTE: *Machine.TestMemPackage() needs this
+				// to pass in an imported package as *ConstEzpr.
+				pv = cx.V.(*PackageValue)
+			} else {
+				// otherwise, packages can only be referred to by
+				// *NameExprs, and cannot be copied.
+				pvc := evalConst(store, last, currExpr.X)
+				pv_, ok := pvc.V.(*PackageValue)
+				if !ok {
+					panic(fmt.Sprintf(
+						"missing package in selector expr %s",
+						currExpr.String()))
+				}
+				pv = pv_
+			}
+			if pv.GetBlock(store).Source.GetIsConst(store, currExpr.Sel) {
+				break Main
+			}
+
+			tt := pv.GetBlock(store).Source.GetStaticTypeOf(store, currExpr.Sel)
+			panic(fmt.Sprintf("%s (variable of type %s) is not constant", currExpr.String(), tt))
+		case *PointerType, *DeclaredType, *StructType, *InterfaceType, *TypeType, *NativeType:
+			ty := evalStaticTypeOf(store, last, currExpr)
+			if _, ok := ty.(*TypeType); ok {
+				ty = evalStaticType(store, last, currExpr)
+			}
+
+			// special case for len, cap
+			if isParentCallExprWithArrayArg(ty, parentExpr) {
+				break Main
+			}
+			panic(fmt.Sprintf("%s (variable of type %s) is not constant", currExpr.String(), ty))
+		default:
+			panic(fmt.Sprintf(
+				"unexpected selector expression type %v",
+				reflect.TypeOf(xt)))
+		}
+
+	case *ConstExpr:
+	case *BasicLitExpr:
+	case *CompositeLitExpr:
+		assertValidConstValue(store, last, currExpr.Type, parentExpr)
+	default:
+		ift := evalStaticTypeOf(store, last, currExpr)
+		if _, ok := ift.(*TypeType); ok {
+			ift = evalStaticType(store, last, currExpr)
+		}
+		panic(fmt.Sprintf("%s (variable of type %s) is not constant", currExpr.String(), ift))
+	}
+}
+
+func isParentCallExprWithArrayArg(currType Type, parentExpr Expr) bool {
+	_, okArray := baseOf(currType).(*ArrayType)
+	_, okCallExpr := parentExpr.(*CallExpr)
+
+	return okArray && okCallExpr
+}
+
 // checkValDefineMismatch checks for mismatch between the number of variables and values in a ValueDecl or AssignStmt.
 func checkValDefineMismatch(n Node) {
 	var (

gnovm/tests/files/const23.gno

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	const t []string = []string{}
+	fmt.Println(t)
+}
+
+// Error:
+// main/files/const23.gno:6:8: invalid constant type []string

gnovm/tests/files/const24.gno

@@ -0,0 +1,79 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	const a int = 1_000_000
+	const b byte = byte(1)
+	const c float64 = 1_000_000.000
+	const d string = "Hello, World!"
+	const e rune = 'a'
+	const g bool = true
+	const h uint = 1_000
+	const i int8 = 1
+	const j int16 = 1
+	const k int32 = 1
+	const l int64 = 1
+	const m uint8 = 1
+	const n uint16 = 1
+	const o uint32 = 1
+	const p uint64 = 1
+	const r float32 = 1_000_000.000
+	const s = r
+	const t = len("s")
+	const u = 1 + len("s") + 3
+	ars := [10]string{}
+	const v = len(ars)
+	const w = cap(ars)
+	const x = time.Second
+
+	fmt.Println(a)
+	fmt.Println(b)
+	fmt.Println(c)
+	fmt.Println(d)
+	fmt.Println(e)
+	fmt.Println(g)
+	fmt.Println(h)
+	fmt.Println(i)
+	fmt.Println(j)
+	fmt.Println(k)
+	fmt.Println(l)
+	fmt.Println(m)
+	fmt.Println(n)
+	fmt.Println(o)
+	fmt.Println(p)
+	fmt.Println(r)
+	fmt.Println(s)
+	fmt.Println(t)
+	fmt.Println(u)
+	fmt.Println(v)
+	fmt.Println(w)
+	println(x)
+}
+
+// Output:
+// 1000000
+// 1
+// 1e+06
+// Hello, World!
+// 97
+// true
+// 1000
+// 1
+// 1
+// 1
+// 1
+// 1
+// 1
+// 1
+// 1
+// 1e+06
+// 1e+06
+// 1
+// 5
+// 10
+// 10
+// 1s

gnovm/tests/files/const25.gno

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	const t = []string{"1"}
+	fmt.Println(t)
+}
+
+// Error:
+// main/files/const25.gno:6:8: [](const-type string){(const ("1" string))} (variable of type []string) is not constant

gnovm/tests/files/const26.gno

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func v() string {
+	return ""
+}
+
+func main() {
+	const t = v()
+	fmt.Println(t)
+}
+
+// Error:
+// main/files/const26.gno:10:8: v<VPBlock(3,0)>() (value of type string) is not constant

gnovm/tests/files/const27.gno

@@ -0,0 +1,16 @@
+package main
+
+import "fmt"
+
+func v() string {
+	return ""
+}
+
+func main() {
+	var i interface{} = 1
+	const t, ok = i.(int)
+	fmt.Println(t, ok)
+}
+
+// Error:
+// main/files/const27.gno:11:8: i<VPBlock(1,0)>.((const-type int)) (comma, ok expression of type (const-type int)) is not constant

gnovm/tests/files/const28.gno

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	var s []string = []string{"1"}
+	const t, ok = s[0]
+	fmt.Println(t, ok)
+}
+
+// Error:
+// main/files/const28.gno:7:8: s<VPBlock(1,0)>[(const (0 int))] (variable of type s<VPBlock(1,0)>) is not constant

gnovm/tests/files/const29.gno

@@ -0,0 +1,12 @@
+package main
+
+import "fmt"
+
+func main() {
+	s := "1"
+	const t = s
+	fmt.Println(t)
+}
+
+// Error:
+// main/files/const29.gno:7:8: s (variable of type string) is not constant

gnovm/tests/files/const30.gno

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func v() {
+	return
+}
+
+func main() {
+	const t = v()
+	fmt.Println(t)
+}
+
+// Error:
+// main/files/const30.gno:10:8: v<VPBlock(3,0)> (no value) used as value