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

gnovm/pkg/gnolang/values.go

@@ -2125,13 +2125,18 @@
  switch bt := baseOf(tv.T).(type) {
  case PrimitiveType:
  if bt != StringType {
- panic("should not happen")
+ panic(fmt.Sprintf("unexpected type for len(): %s", tv.T.String()))
  }
  return 0
  case *ArrayType:
  return bt.Len
  case *SliceType:
  return 0
+ case *PointerType:
+ if at, ok := bt.Elt.(*ArrayType); ok {
+ return at.Len
+ }
+ panic(fmt.Sprintf("unexpected 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 type for len(): %s", tv.T.String()))
  default:
  panic(fmt.Sprintf("unexpected type for len(): %s",
  tv.T.String()))
@@ -2157,27 +2167,34 @@
 
 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:
+ return bt.Len
+ case *SliceType:
+ return 0
+ case *PointerType:
+ if at, ok := bt.Elt.(*ArrayType); ok {
+ return at.Len
  }
+ panic(fmt.Sprintf("unexpected type for cap(): %s", tv.T.String()))
+ default:
+ panic(fmt.Sprintf("unexpected type for cap(): %s", tv.T.String()))
  }
- return 0
  }
  switch cv := tv.V.(type) {
- case StringValue:
- return len(string(cv))
  case *ArrayValue:
  return cv.GetCapacity()
  case *SliceValue:
  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 type for cap(): %s", tv.T.String()))
  default:
  panic(fmt.Sprintf("unexpected type for cap(): %s",
  tv.T.String()))
@@ -2200,13 +2217,13 @@
  "invalid slice index %d > %d",
  low, high))
  }
- if tv.GetCapacity() < high {
- panic(fmt.Sprintf(
- "slice bounds out of range [%d:%d] with capacity %d",
- low, high, tv.GetCapacity()))
- }
  switch t := baseOf(tv.T).(type) {
  case PrimitiveType:
+ if tv.GetLength() < high {
+ panic(fmt.Sprintf(
+ "slice bounds out of range [%d:%d] with string length %d",
+ low, high, tv.GetLength()))
+ }
  if t == StringType || t == UntypedStringType {
  return TypedValue{
  T: tv.T,
@@ -2215,6 +2232,11 @@
  }
  panic("non-string primitive type cannot be sliced")
  case *ArrayType:
+ if tv.GetLength() < high {
+ panic(fmt.Sprintf(
+ "slice bounds out of range [%d:%d] with array length %d",
+ low, high, tv.GetLength()))
+ }
  av := tv.V.(*ArrayValue)
  st := alloc.NewType(&SliceType{
  Elt: t.Elt,
@@ -2230,6 +2252,11 @@
  ),
  }
  case *SliceType:
+ if tv.GetCapacity() < high {
+ panic(fmt.Sprintf(
+ "slice bounds out of range [%d:%d] with capacity %d",
+ low, high, tv.GetCapacity()))
+ }
  if tv.V == nil {
  if low != 0 || high != 0 {
  panic("nil slice index out of range")

gnovm/pkg/gnolang/values_test.go

@@ -0,0 +1,70 @@
+package gnolang
+
+import (
+ "fmt"
+ "testing"
+)
+
+type mockTypedValueStruct struct {
+ field int
+}
+
+func (m *mockTypedValueStruct) assertValue() {}
+
+func (m *mockTypedValueStruct) String() string {
+ return fmt.Sprintf("MockTypedValueStruct(%d)", m.field)
+}
+
+func TestGetLengthPanic(t *testing.T) {
+ tests := []struct {
+ name string
+ tv TypedValue
+ expected string
+ }{
+ {
+ name: "NonArrayPointer",
+ tv: TypedValue{
+ T: &PointerType{Elt: &StructType{}},
+ V: PointerValue{
+ TV: &TypedValue{
+ T: &StructType{},
+ V: &mockTypedValueStruct{field: 42},
+ },
+ },
+ },
+ expected: "unexpected type for len(): *struct{}",
+ },
+ {
+ name: "UnexpectedType",
+ tv: TypedValue{
+ T: &StructType{},
+ V: &mockTypedValueStruct{field: 42},
+ },
+ expected: "unexpected type for len(): struct{}",
+ },
+ {
+ name: "UnexpectedPointerType",
+ tv: TypedValue{
+ T: &PointerType{Elt: &StructType{}},
+ V: nil,
+ },
+ expected: "unexpected type for len(): *struct{}",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ defer func() {
+ if r := recover(); r == nil {
+ t.Errorf("the code did not panic")
+ } else {
+ if r != tt.expected {
+ t.Errorf("expected panic message to be %q, got %q", tt.expected, r)
+ }
+ }
+ }()
+
+ tt.tv.GetLength()
+ })
+ }
+}

gnovm/tests/files/cap1.gno

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

gnovm/tests/files/cap10.gno

@@ -0,0 +1,8 @@
+package main
+
+func main() {
+ println("cap", cap(struct{ A int }{}))
+}
+
+// Error:
+// unexpected type for cap(): struct{A int}

gnovm/tests/files/cap2.gno

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

gnovm/tests/files/cap3.gno

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

gnovm/tests/files/cap4.gno

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+ var slice []int
+ println(cap(slice))
+}
+
+// Output:
+// 0

gnovm/tests/files/cap5.gno

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

gnovm/tests/files/cap6.gno

@@ -0,0 +1,31 @@
+package main
+
+func main() {
+ var arr [5]int
+ var nilArr *[5]int
+ var nilSlice []int
+ var nilArr2 *[8]struct{ A, B int }
+ var nilMatrix *[2][3]int
+
+ println("cap(arr): ", cap(arr))
+ println("cap(&arr): ", cap(&arr))
+ println("cap(nilArr): ", cap(nilArr))
+ println("cap(nilSlice): ", cap(nilSlice))
+ println("cap(nilArr2): ", cap(nilArr2))
+ println("cap(nilMatrix):", cap(nilMatrix))
+
+ printCap(nil)
+}
+
+func printCap(arr *[3]string) {
+ println("printCap: ", cap(arr))
+}
+
+// Output:
+// cap(arr): 5
+// cap(&arr): 5
+// cap(nilArr): 5
+// cap(nilSlice): 0
+// cap(nilArr2): 8
+// cap(nilMatrix): 2
+// printCap: 3

gnovm/tests/files/cap7.gno

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+ var s string
+ println("cap", cap(s))
+}
+
+// Error:
+// unexpected type for cap(): string

gnovm/tests/files/cap8.gno

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+ var i *int
+ println("cap", cap(i))
+}
+
+// Error:
+// unexpected type for cap(): *int

gnovm/tests/files/cap9.gno

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+ i := new(int)
+ println("cap", cap(i))
+}
+
+// Error:
+// unexpected type for cap(): *int

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,9 @@
+package main
+
+func main() {
+ exp := [...]string{"HELLO", "WORLD"}
+ println(len(exp))
+}
+
+// Output:
+// 2

gnovm/tests/files/len3.gno

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

gnovm/tests/files/len4.gno

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

gnovm/tests/files/len5.gno

@@ -0,0 +1,9 @@
+package main
+
+func main() {
+ var arr *[3]string
+ println(cap(arr))
+}
+
+// Output:
+// 3