fix(gnovm): Fix panic when calling len()/cap() on pointer array

gnovm/pkg/gnolang/uverse_test.go

@@ -4,14 +4,14 @@ import (
  "testing"
 )
 
-type printlnTestCases struct {
+type uverseTestCases struct {
  name string
  code string
  expected string
 }
 
 func TestIssue1337PrintNilSliceAsUndefined(t *testing.T) {
- test := []printlnTestCases{
+ test := []uverseTestCases{
  {
  name: "print empty slice",
  code: `package test
@@ -158,3 +158,247 @@ func TestIssue1337PrintNilSliceAsUndefined(t *testing.T) {
  })
  }
 }
+
+func TestIssue2707PointerSliceAsParamInLen(t *testing.T) {
+ tests := []uverseTestCases{
+ {
+ name: "pointer slice as param in len",
+ code: `
+package test
+
+func main() {
+ exp := [...]string{"HELLO"}
+ x := len(&exp)
+ println(x)
+}
+ `,
+ expected: "1\n",
+ },
+ {
+ name: "len of array",
+ code: `
+package test
+
+func main() {
+ exp := [...]string{"HELLO", "WORLD"}
+ println(len(exp))
+}
+ `,
+ expected: "2\n",
+ },
+ {
+ name: "len of pointer to array",
+ code: `
+package test
+
+func main() {
+ exp := [...]int{1, 2, 3, 4, 5}
+ ptr := &exp
+ println(len(ptr))
+}
+ `,
+ expected: "5\n",
+ },
+ {
+ name: "nil array pointer",
+ code: `
+package test
+
+func main() {
+ printLen(nil)
+}
+
+func printLen(arr *[2]int) {
+ println(len(arr))
+}`,
+ expected: "2\n",
+ },
+ {
+ name: "cap of nil pointer to array",
+ code: `
+package test
+
+func main() {
+ var arr *[3]string
+ println(cap(arr))
+}`,
+ expected: "3\n",
+ },
+ {
+ name: "len and cap of nil pointer to array as function parameter",
+ code: `
+package test
+
+func main() {
+ printLenCap(nil)
+}
+
+func printLenCap(arr *[4]float64) {
+ println(len(arr))
+ println(cap(arr))
+}`,
+ expected: "4\n4\n",
+ },
+ }
+
+ for _, tc := range tests {
+ m := NewMachine("test", nil)
+ n := MustParseFile("main.go", tc.code)
+ m.RunFiles(n)
+ m.RunMain()
+ assertOutput(t, tc.code, tc.expected)
+ }
+}
+
+func TestGetCapacityPointerSlice(t *testing.T) {
+ tests := []uverseTestCases{
+ {
+ name: "cap of pointer to array",
+ code: `
+package test
+
+func main() {
+ exp := [...]string{"HELLO"}
+ x := cap(&exp)
+ println(x)
+}`,
+ expected: "1\n",
+ },
+ {
+ name: "cap of array",
+ code: `
+package test
+
+func main() {
+ exp := [...]int{1, 2, 3, 4, 5}
+ println(cap(exp))
+}`,
+ expected: "5\n",
+ },
+ {
+ name: "cap of slice",
+ code: `
+package test
+
+func main() {
+ slice := make([]int, 3, 5)
+ println(cap(slice))
+}`,
+ expected: "5\n",
+ },
+ {
+ name: "cap of nil slice",
+ code: `
+package test
+
+func main() {
+ var slice []int
+ println(cap(slice))
+}`,
+ expected: "0\n",
+ },
+ {
+ name: "cap of nil array pointer",
+ code: `
+package test
+
+func main() {
+ printCap(nil)
+}
+
+func printCap(arr *[2]int) {
+ println(cap(arr))
+}`,
+ expected: "2\n",
+ },
+ }
+
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ m := NewMachine("test", nil)
+ n := MustParseFile("main.go", tc.code)
+ m.RunFiles(n)
+ m.RunMain()
+ assertOutput(t, tc.code, tc.expected)
+ })
+ }
+}
+
+func TestGetCapacityNilValue(t *testing.T) {
+ tests := []uverseTestCases{
+ {
+ name: "cap of nil array",
+ code: `
+package test
+
+func main() {
+ var arr [5]int
+ println(cap(&arr))
+ var nilArr *[5]int
+ println(cap(nilArr))
+}`,
+ expected: "5\n5\n",
+ },
+ {
+ name: "cap of nil slice",
+ code: `
+package test
+
+func main() {
+ var slice []int
+ println(cap(slice))
+}`,
+ expected: "0\n",
+ },
+ {
+ name: "cap of nil array in function",
+ code: `
+package test
+
+func main() {
+ printCap(nil)
+}
+
+func printCap(arr *[3]string) {
+ println(cap(arr))
+}`,
+ expected: "3\n",
+ },
+ {
+ name: "cap of different nil array types",
+ code: `
+package test
+
+func main() {
+ var nilIntArr *[4]int
+ var nilFloatArr *[6]float64
+ var nilStringArr *[2]string
+ println(cap(nilIntArr))
+ println(cap(nilFloatArr))
+ println(cap(nilStringArr))
+}`,
+ expected: "4\n6\n2\n",
+ },
+ {
+ name: "cap of nil multidimensional array",
+ code: `
+package test
+
+func main() {
+ var nilMultiArr *[2][3]int
+ println(cap(nilMultiArr))
+}`,
+ expected: "2\n",
+ },
+ }
+
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ m := NewMachine("test", nil)
+ n := MustParseFile("main.go", tc.code)
+ m.RunFiles(n)
+ m.RunMain()
+ assertOutput(t, tc.code, tc.expected)
+ })
+ }
+}

gnovm/pkg/gnolang/values.go

@@ -2132,6 +2132,11 @@
  return bt.Len
  case *SliceType:
  return 0
+ case *PointerType:
+ if at, ok := bt.Elt.(*ArrayType); ok {
+ return at.Len
+ }
+ panic(fmt.Sprintf("unexpected pointer type for len(): %s", tv.T.String()))
  default:
  panic(fmt.Sprintf(
  "unexpected type for len(): %s",
@@ -2149,6 +2154,11 @@
  return cv.GetLength()
  case *NativeValue:
  return cv.Value.Len()
+ case PointerValue:
+ if av, ok := cv.TV.V.(*ArrayValue); ok {
+ return av.GetLength()
+ }
+ panic(fmt.Sprintf("unexpected pointer value for len(): %s", tv.T.String()))
  default:
  panic(fmt.Sprintf("unexpected type for len(): %s",
  tv.T.String()))
@@ -2157,17 +2167,20 @@
 
 func (tv *TypedValue) GetCapacity() int {
  if tv.V == nil {
- if debug {
- // assert acceptable type.
- switch baseOf(tv.T).(type) {
- // strings have no capacity.
- case *ArrayType:
- case *SliceType:
- default:
- panic("should not happen")
+ // assert acceptable type.
+ switch bt := baseOf(tv.T).(type) {
+ // strings have no capacity.
+ case *ArrayType:
+ case *SliceType:
+ return 0
+ case *PointerType:
+ if at, ok := bt.Elt.(*ArrayType); ok {
+ return at.Len
  }
+ panic(fmt.Sprintf("unexpected pointer type for cap(): %s", tv.T.String()))
+ default:
+ panic(fmt.Sprintf("unexpected nil type for cap(): %s", tv.T.String()))
  }
- return 0
  }
  switch cv := tv.V.(type) {
  case StringValue:
@@ -2178,6 +2191,11 @@
  return cv.GetCapacity()
  case *NativeValue:
  return cv.Value.Cap()
+ case PointerValue:
+ if av, ok := cv.TV.V.(*ArrayValue); ok {
+ return av.GetCapacity()
+ }
+ panic(fmt.Sprintf("unexpected pointer value for cap(): %s", tv.T.String()))
  default:
  panic(fmt.Sprintf("unexpected type for cap(): %s",
  tv.T.String()))

gnovm/tests/files/cap1.gno

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+ exp := [...]int{1, 2, 3, 4, 5}
+ println(cap(exp))
+}
+
+// Output:
+// 5

gnovm/tests/files/len1.gno

@@ -0,0 +1,10 @@
+package main
+
+func main() {
+ exp := [...]string{"HELLO"}
+ x := len(&exp)
+ println(x)
+}
+
+// Output:
+// 1

gnovm/tests/files/len2.gno

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+ printLen(nil)
+}
+
+func printLen(arr *[2]int) {
+ println(len(arr))
+}
+
+// Output:
+// 2