fix(gnovm): prevent cyclic references in type declarations

gnovm/pkg/gnolang/preprocess.go

@@ -2906,6 +2906,92 @@
  }
 }
 
+func assertTypeDeclNoCycle(store Store, last BlockNode, td *TypeDecl, stack *[]Name) {
+ assertTypeDeclNoCycle2(store, last, td.Type, stack, false, td.IsAlias)
+}
+
+func assertTypeDeclNoCycle2(store Store, last BlockNode, x Expr, stack *[]Name, indirect bool, isAlias bool) {
+ if x == nil {
+ panic("unexpected nil expression when checking for type declaration cycles")
+ }
+
+ var lastX Expr
+ defer func() {
+ if _, ok := lastX.(*NameExpr); ok {
+ // pop stack
+ *stack = (*stack)[:len(*stack)-1]
+ }
+ }()
+
+ switch cx := x.(type) {
+ case *NameExpr:
+ var msg string
+
+ // Function to build the error message
+ buildMessage := func() string {
+ for j := 0; j < len(*stack); j++ {
+ msg += fmt.Sprintf("%s -> ", (*stack)[j])
+ }
+ return msg + string(cx.Name) // Append the current name last
+ }
+
+ // Check for existence of cx.Name in stack
+ findCycle := func() {
+ for _, n := range *stack {
+ if n == cx.Name {
+ msg = buildMessage()
+ panic(fmt.Sprintf("invalid recursive type: %s", msg))
+ }
+ }
+ }
+
+ if indirect && !isAlias {
+ *stack = (*stack)[:0]
+ } else {
+ findCycle()
+ *stack = append(*stack, cx.Name)
+ lastX = cx
+ }
+
+ return
+ case *SelectorExpr:
+ assertTypeDeclNoCycle2(store, last, cx.X, stack, indirect, isAlias)
+ case *StarExpr:
+ assertTypeDeclNoCycle2(store, last, cx.X, stack, true, isAlias)
+ case *FieldTypeExpr:
+ assertTypeDeclNoCycle2(store, last, cx.Type, stack, indirect, isAlias)
+ case *ArrayTypeExpr:
+ if cx.Len != nil {
+ assertTypeDeclNoCycle2(store, last, cx.Len, stack, indirect, isAlias)
+ }
+ assertTypeDeclNoCycle2(store, last, cx.Elt, stack, indirect, isAlias)
+ case *SliceTypeExpr:
+ assertTypeDeclNoCycle2(store, last, cx.Elt, stack, true, isAlias)
+ case *InterfaceTypeExpr:
+ for i := range cx.Methods {
+ assertTypeDeclNoCycle2(store, last, &cx.Methods[i], stack, indirect, isAlias)
+ }
+ case *ChanTypeExpr:
+ assertTypeDeclNoCycle2(store, last, cx.Value, stack, true, isAlias)
+ case *FuncTypeExpr:
+ for i := range cx.Params {
+ assertTypeDeclNoCycle2(store, last, &cx.Params[i], stack, true, isAlias)
+ }
+ for i := range cx.Results {
+ assertTypeDeclNoCycle2(store, last, &cx.Results[i], stack, true, isAlias)
+ }
+ case *MapTypeExpr:
+ assertTypeDeclNoCycle2(store, last, cx.Key, stack, true, isAlias)
+ assertTypeDeclNoCycle2(store, last, cx.Value, stack, true, isAlias)
+ case *StructTypeExpr:
+ for i := range cx.Fields {
+ assertTypeDeclNoCycle2(store, last, &cx.Fields[i], stack, indirect, isAlias)
+ }
+ default:
+ }
+ return
+}
+
 // Returns any names not yet defined nor predefined in expr. These happen
 // upon transcribe:enter from the top, so value paths cannot be used. If no
 // names are un and x is TypeExpr, evalStaticType(store,last, x) must not
@@ -3197,27 +3283,36 @@
  }
  }
  }()
- m := make(map[Name]struct{})
- return predefineNow2(store, last, d, m)
+ stack := &[]Name{}
+ return predefineNow2(store, last, d, stack)
 }
 
-func predefineNow2(store Store, last BlockNode, d Decl, m map[Name]struct{}) (Decl, bool) {
+func predefineNow2(store Store, last BlockNode, d Decl, stack *[]Name) (Decl, bool) {
  pkg := packageOf(last)
  // pre-register d.GetName() to detect circular definition.
  for _, dn := range d.GetDeclNames() {
  if isUverseName(dn) {
  panic(fmt.Sprintf(
  "builtin identifiers cannot be shadowed: %s", dn))
  }
- m[dn] = struct{}{}
+ *stack = append(*stack, dn)
+ }
+
+ // check type decl cycle
+ if td, ok := d.(*TypeDecl); ok {
+ // recursively check
+ assertTypeDeclNoCycle(store, last, td, stack)
  }
+
  // recursively predefine dependencies.
  for {
  un := tryPredefine(store, last, d)
  if un != "" {
  // check circularity.
- if _, ok := m[un]; ok {
- panic(fmt.Sprintf("constant definition loop with %s", un))
+ for _, n := range *stack {
+ if n == un {
+ panic(fmt.Sprintf("constant definition loop with %s", un))
+ }
  }
  // look up dependency declaration from fileset.
  file, decl := pkg.FileSet.GetDeclFor(un)
@@ -3226,7 +3321,7 @@
  panic("all types from files in file-set should have already been predefined")
  }
  // predefine dependency (recursive).
- *decl, _ = predefineNow2(store, file, *decl, m)
+ *decl, _ = predefineNow2(store, file, *decl, stack)
  } else {
  break
  }

gnovm/tests/files/circular_constant.gno

@@ -0,0 +1,10 @@
+package main
+
+const A = B
+const B = A + 1
+
+func main() {
+}
+
+// Error:
+// main/files/circular_constant.gno:3:7: constant definition loop with A

gnovm/tests/files/recursive1.gno

@@ -0,0 +1,13 @@
+package main
+
+type S struct {
+ T S
+}
+
+func main() {
+ var a, b S
+ println(a == b)
+}
+
+// Error:
+// main/files/recursive1.gno:1:1: invalid recursive type: S -> S

gnovm/tests/files/recursive1a.gno

@@ -0,0 +1,15 @@
+package main
+
+type S1 *S
+
+type S struct {
+ T S1
+}
+
+func main() {
+ var a, b S
+ println(a == b)
+}
+
+// Output:
+// true

gnovm/tests/files/recursive1b.gno

@@ -0,0 +1,16 @@
+package main
+
+type S struct {
+ T *S
+ B Integer
+}
+
+type Integer int
+
+func main() {
+ var a, b S
+ println(a == b)
+}
+
+// Output:
+// true

gnovm/tests/files/recursive1c.gno

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+type S struct {
+ A [2][2]S
+}
+
+func main() {
+ var a, b S
+
+ fmt.Println(a)
+ fmt.Println(b)
+}
+
+// Error:
+// main/files/recursive1c.gno:1:1: invalid recursive type: S -> S

gnovm/tests/files/recursive1d.gno

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+type S struct {
+ A [2]S
+}
+
+func main() {
+ var a, b S
+
+ fmt.Println(a)
+ fmt.Println(b)
+}
+
+// Error:
+// main/files/recursive1d.gno:1:1: invalid recursive type: S -> S

gnovm/tests/files/recursive1e.gno

@@ -0,0 +1,13 @@
+package main
+
+type S struct {
+ A [2][]S
+}
+
+func main() {
+ var a, b S
+ println(a)
+}
+
+// Output:
+// (struct{(array[(nil []main.S),(nil []main.S)] [2][]main.S)} main.S)

gnovm/tests/files/recursive1f.gno

@@ -0,0 +1,13 @@
+package main
+
+func main() {
+ type S struct {
+ T S
+ }
+
+ var a, b S
+ println(a == b)
+}
+
+// Error:
+// main/files/recursive1f.gno:3:1: invalid recursive type: S -> S

gnovm/tests/files/recursive2.gno

@@ -0,0 +1,21 @@
+package main
+
+type A struct {
+ X B
+}
+
+type B struct {
+ X C
+}
+
+type C struct {
+ X A
+}
+
+func main() {
+ var p, q A
+ println(p == q)
+}
+
+// Error:
+// main/files/recursive2.gno:1:1: invalid recursive type: A -> B -> C -> A

gnovm/tests/files/recursive2a.gno

@@ -0,0 +1,21 @@
+package main
+
+type A struct {
+ X B
+}
+
+type B struct {
+ X int
+}
+
+type C struct {
+ X A
+}
+
+func main() {
+ var p, q A
+ println(p == q)
+}
+
+// Output:
+// true

gnovm/tests/files/recursive2b.gno

@@ -0,0 +1,21 @@
+package main
+
+type A struct {
+ X B
+}
+
+type B struct {
+ X C
+}
+
+type C struct {
+ X *A
+}
+
+func main() {
+ var p, q A
+ println(p == q)
+}
+
+// Output:
+// true

gnovm/tests/files/recursive2c.gno

@@ -0,0 +1,21 @@
+package main
+
+func main() {
+ type A struct {
+ X B
+ }
+
+ type B struct {
+ X C
+ }
+
+ type C struct {
+ X A
+ }
+
+ var p, q A
+ println(p == q)
+}
+
+// Error:
+// main/files/recursive2c.gno:3:1: name B not defined in fileset with files [files/recursive2c.gno]

gnovm/tests/files/recursive2d.gno

@@ -0,0 +1,21 @@
+package main
+
+type A struct {
+ X *B
+}
+
+type B struct {
+ X int
+}
+
+type C struct {
+ X A
+}
+
+func main() {
+ var p, q A
+ println(p == q)
+}
+
+// Output:
+// true

gnovm/tests/files/recursive3.gno

@@ -0,0 +1,13 @@
+package main
+
+type S struct {
+ T *S
+}
+
+func main() {
+ var a, b S
+ println(a == b)
+}
+
+// Output:
+// true