fix: addressability problem

gnovm/pkg/gnolang/alloc.go

@@ -196,14 +196,16 @@ func (alloc *Allocator) NewString(s string) StringValue {
 func (alloc *Allocator) NewListArray(n int) *ArrayValue {
 	alloc.AllocateListArray(int64(n))
 	return &ArrayValue{
-		List: make([]TypedValue, n),
+		List:           make([]TypedValue, n),
+		NotAddressible: true,
 	}
 }
 
 func (alloc *Allocator) NewDataArray(n int) *ArrayValue {
 	alloc.AllocateDataArray(int64(n))
 	return &ArrayValue{
-		Data: make([]byte, n),
+		Data:           make([]byte, n),
+		NotAddressible: true,
 	}
 }
 

gnovm/pkg/gnolang/gonative.go

@@ -715,6 +715,7 @@ func go2GnoValue2(alloc *Allocator, store Store, rv reflect.Value, recursive boo
 				}
 			}
 			tv.V = av
+			tv.NotAddressable = av.NotAddressible
 		}
 	case reflect.Slice:
 		rvl := rv.Len()

gnovm/pkg/gnolang/machine.go

@@ -2087,6 +2087,11 @@ func (m *Machine) PopAsPointer(lx Expr) PointerValue {
 	case *IndexExpr:
 		iv := m.PopValue()
 		xv := m.PopValue()
+
+		if xv.NotAddressable {
+			panic(fmt.Sprintf("PopAsPointer: expr not addressable: %+v\n", xv))
+		}
+
 		return xv.GetPointerAtIndex(m.Alloc, m.Store, iv)
 	case *SelectorExpr:
 		xv := m.PopValue()

gnovm/pkg/gnolang/op_expressions.go

@@ -16,6 +16,11 @@ func (m *Machine) doOpIndex1() {
 	}
 	iv := m.PopValue()   // index
 	xv := m.PeekValue(1) // x
+
+	if xv.NotAddressable {
+		panic(fmt.Sprintf("doOpIndex1: expr not addressable: %+v\n", xv))
+	}
+
 	switch ct := baseOf(xv.T).(type) {
 	case *MapType:
 		mv := xv.V.(*MapValue)
@@ -44,6 +49,11 @@ func (m *Machine) doOpIndex2() {
 	}
 	iv := m.PeekValue(1) // index
 	xv := m.PeekValue(2) // x
+
+	if xv.NotAddressable {
+		panic(fmt.Sprintf("doOpIndex2: expr not addressable: %+v\n", xv))
+	}
+
 	switch ct := baseOf(xv.T).(type) {
 	case *MapType:
 		vt := ct.Value
@@ -105,6 +115,11 @@ func (m *Machine) doOpSlice() {
 	}
 	// slice base x
 	xv := m.PopValue()
+
+	if xv.NotAddressable {
+		panic(fmt.Sprintf("doOpSlice: expr not addressable: %+v\n", xv))
+	}
+
 	// if a is a pointer to an array, a[low : high : max] is
 	// shorthand for (*a)[low : high : max]
 	if xv.T.Kind() == PointerKind &&
@@ -550,8 +565,9 @@ func (m *Machine) doOpArrayLit() {
 	}
 	// push value
 	m.PushValue(TypedValue{
-		T: at,
-		V: av,
+		T:              at,
+		V:              av,
+		NotAddressable: av.NotAddressible,
 	})
 }
 

gnovm/pkg/gnolang/values.go

@@ -15,6 +15,10 @@ import (
 	"github.com/gnolang/gno/tm2/pkg/crypto"
 )
 
+type Addressable interface {
+	Addressable()
+}
+
 // ----------------------------------------
 // (runtime) Value
 
@@ -186,6 +190,17 @@ type PointerValue struct {
 	Key   *TypedValue `json:",omitempty"` // for maps.
 }
 
+func (pv *PointerValue) Addressable() {
+	if pv.TV == nil {
+		return
+	}
+
+	pv.TV.NotAddressable = false
+	if iface, ok := pv.TV.V.(Addressable); ok {
+		iface.Addressable()
+	}
+}
+
 const (
 	PointerIndexBlockBlank = -1 // for the "_" identifier in blocks
 	PointerIndexMap        = -2 // Base is Map, use Key.
@@ -211,6 +226,8 @@ func (pv *PointerValue) GetBase(store Store) Object {
 // TODO: document as something that enables into-native assignment.
 // TODO: maybe consider this as entrypoint for DataByteValue too?
 func (pv PointerValue) Assign2(alloc *Allocator, store Store, rlm *Realm, tv2 TypedValue, cu bool) {
+	tv2.Addressable()
+
 	// Special cases.
 	if pv.Index == PointerIndexNative {
 		// Special case if extended object && native.
@@ -315,8 +332,17 @@ func (pv PointerValue) Deref() (tv TypedValue) {
 
 type ArrayValue struct {
 	ObjectInfo
-	List []TypedValue
-	Data []byte
+	List           []TypedValue
+	Data           []byte
+	NotAddressible bool
+}
+
+func (av *ArrayValue) Addressable() {
+	av.NotAddressible = false
+
+	for i := range av.List {
+		av.List[i].Addressable()
+	}
 }
 
 // NOTE: Result should not be written to,
@@ -392,6 +418,7 @@ func (av *ArrayValue) Copy(alloc *Allocator) *ArrayValue {
 	if av.Data == nil {
 		av2 := alloc.NewListArray(len(av.List))
 		copy(av2.List, av.List)
+		av2.NotAddressible = av.NotAddressible
 		return av2
 	}
 	av2 := alloc.NewDataArray(len(av.Data))
@@ -409,6 +436,12 @@ type SliceValue struct {
 	Maxcap int
 }
 
+func (sv *SliceValue) Addressable() {
+	if iface, ok := sv.Base.(Addressable); ok {
+		iface.Addressable()
+	}
+}
+
 func (sv *SliceValue) GetBase(store Store) *ArrayValue {
 	switch cv := sv.Base.(type) {
 	case nil:
@@ -454,6 +487,12 @@ type StructValue struct {
 	Fields []TypedValue
 }
 
+func (sv *StructValue) Addressable() {
+	for i := range sv.Fields {
+		sv.Fields[i].Addressable()
+	}
+}
+
 // TODO handle unexported fields in debug, and also ensure in the preprocessor.
 func (sv *StructValue) GetPointerTo(store Store, path ValuePath) PointerValue {
 	if debug {
@@ -955,9 +994,19 @@ func (nv *NativeValue) Copy(alloc *Allocator) *NativeValue {
 // TypedValue (is not a value, but a tuple)
 
 type TypedValue struct {
-	T Type    `json:",omitempty"` // never nil
-	V Value   `json:",omitempty"` // an untyped value
-	N [8]byte `json:",omitempty"` // numeric bytes
+	T              Type    `json:",omitempty"` // never nil
+	V              Value   `json:",omitempty"` // an untyped value
+	N              [8]byte `json:",omitempty"` // numeric bytes
+	NotAddressable bool    `json:"-"`
+}
+
+func (tv *TypedValue) Addressable() {
+	tv.NotAddressable = false
+	if p, ok := tv.V.(PointerValue); ok {
+		p.Addressable()
+	} else if iface, ok := tv.V.(Addressable); ok {
+		iface.Addressable()
+	}
 }
 
 func (tv *TypedValue) IsDefined() bool {
@@ -2589,9 +2638,20 @@ func defaultTypedValue(alloc *Allocator, t Type) TypedValue {
 	if t.Kind() == InterfaceKind {
 		return TypedValue{}
 	}
+
+	dv := defaultValue(alloc, t)
+
+	var naddr bool
+
+	switch v := dv.(type) {
+	case *ArrayValue:
+		naddr = v.NotAddressible
+	}
+
 	return TypedValue{
-		T: t,
-		V: defaultValue(alloc, t),
+		T:              t,
+		V:              dv,
+		NotAddressable: naddr,
 	}
 }
 

gnovm/tests/files/assign_unnamed_type/more/realm_compositelit_filetest.gno

@@ -40,6 +40,7 @@ func main() {
 //             }
 //         }
 //     ],
+//     "NotAddressible": false,
 //     "ObjectInfo": {
 //         "ID": "a8ada09dee16d791fd406d629fe29bb0ed084a30:6",
 //         "ModTime": "0",

gnovm/tests/files/notaddressable1.gno

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	foo()[:]
+}
+
+func foo() [2]byte {
+	return [2]byte{1, 2}
+}
+
+// Error:
+// doOpSlice: expr not addressable: (array[0x0102] [2]uint8)

gnovm/tests/files/notaddressable2.gno

@@ -0,0 +1,13 @@
+package main
+
+func main() {
+	arr := &getArray()[0]
+	println(arr)
+}
+
+func getArray() [3]int {
+	return [3]int{1, 2, 3}
+}
+
+// Error:
+// PopAsPointer: expr not addressable: (array[(1 int),(2 int),(3 int)] [3]int)

gnovm/tests/files/zrealm_tests0_stdlibs.gno

@@ -123,6 +123,7 @@ func main() {
 //             }
 //         }
 //     ],
+//     "NotAddressible": false,
 //     "ObjectInfo": {
 //         "ID": "0ffe7732b4d549b4cf9ec18bd68641cd2c75ad0a:16",
 //         "ModTime": "0",