fix: addressability

gnovm/pkg/gnolang/preprocess.go

@@ -1323,6 +1323,8 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 				if cx, ok := n.Func.(*ConstExpr); ok {
 					fv := cx.GetFunc()
 					if fv.PkgPath == uversePkgPath && fv.Name == "append" {
+						// append returns a slice and slices are always addressable.
+						n.Addressability = addressabilityStatusSatisfied
 						if n.Varg && len(n.Args) == 2 {
 							// If the second argument is a string,
 							// convert to byteslice.
@@ -1369,9 +1371,17 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 								n.Args[1] = args1
 							}
 						}
+					} else if fv.PkgPath == uversePkgPath && fv.Name == "new" {
+						// The pointer value returned is not addressable, but maybe some selector
+						// will make it addressable. For now mark it as not addressable.
+						n.Addressability = addressabilityStatusUnsatisfied
 					}
 				}
 
+				if n.Addressability != addressabilityStatusSatisfied && len(ft.Results) == 1 {
+					n.Addressability = addressabilityStatusUnsatisfied
+				}
+
 				// Continue with general case.
 				hasVarg := ft.HasVarg()
 				isVarg := n.Varg
@@ -1517,9 +1527,23 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 					// Replace const index with int *ConstExpr,
 					// or if not const, assert integer type..
 					checkOrConvertIntegerKind(store, last, n.Index)
+
+					// Addressability of this index expression can only be known for slice and
+					// strings, explanations below in the respective blocks. If this is an index
+					// on an array, do nothing. This will defer to the array's addresability when
+					// the `addressability` method is called on this index expression.
+					if dt.Kind() == SliceKind {
+						// A value at a slice index is always addressable because the underlying
+						// array is addressable.
+						n.Addressability = addressabilityStatusSatisfied
+					} else if dt.Kind() == StringKind {
+						// Special case; string indexes are never addressable.
+						n.Addressability = addressabilityStatusUnsatisfied
+					}
 				case MapKind:
 					mt := baseOf(gnoTypeOf(store, dt)).(*MapType)
 					checkOrConvertType(store, last, &n.Index, mt.Key, false)
+					n.Addressability = addressabilityStatusUnsatisfied
 				default:
 					panic(fmt.Sprintf(
 						"unexpected index base kind for type %s",
@@ -1534,8 +1558,14 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 				checkOrConvertIntegerKind(store, last, n.High)
 				checkOrConvertIntegerKind(store, last, n.Max)
 
-				// if n.X is untyped, convert to corresponding type
 				t := evalStaticTypeOf(store, last, n.X)
+				if t.Kind() == ArrayKind {
+					if n.X.addressability() == addressabilityStatusUnsatisfied {
+						panic(fmt.Sprintf("cannot take address of %s", n.X.String()))
+					}
+				}
+
+				// if n.X is untyped, convert to corresponding type
 				if isUntyped(t) {
 					dt := defaultTypeOf(t)
 					checkOrConvertType(store, last, &n.X, dt, false)
@@ -1573,8 +1603,6 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 					)
 				}
 
-				evalStaticType(store, last, n.Type)
-
 			// TRANS_LEAVE -----------------------
 			case *UnaryExpr:
 				xt := evalStaticTypeOf(store, last, n.X)
@@ -1634,6 +1662,10 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 						convertType(store, last, &n.Elts[i].Key, IntType)
 						checkOrConvertType(store, last, &n.Elts[i].Value, cclt.Elt, false)
 					}
+
+					// Slices are always addressable because the underlying array
+					// is added to the heap during initialization.
+					n.IsAddressable = true
 				case *MapType:
 					for i := 0; i < len(n.Elts); i++ {
 						checkOrConvertType(store, last, &n.Elts[i].Key, cclt.Key, false)
@@ -1673,6 +1705,16 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 					}
 				}
 
+				// If ftype is TRANS_REF_X, then this composite literal being created looks
+				// something like this in the code: `&MyStruct{}`. It is marked as addressable here
+				// because on TRANS_LEAVE for a RefExpr, it defers to the addressability of the
+				// expression it is referencing. When a composite literal is created with a preceding
+				// '&', it means the value is assigned to an address and that address is returned,
+				// so the value is addressable.
+				if ftype == TRANS_REF_X {
+					n.IsAddressable = true
+				}
+
 			// TRANS_LEAVE -----------------------
 			case *KeyValueExpr:
 				// NOTE: For simplicity we just
@@ -1681,6 +1723,9 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 			// TRANS_LEAVE -----------------------
 			case *SelectorExpr:
 				xt := evalStaticTypeOf(store, last, n.X)
+				if xt.Kind() == PointerKind {
+					n.IsAddressable = true
+				}
 
 				// Set selector path based on xt's type.
 				switch cxt := xt.(type) {
@@ -1693,6 +1738,7 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 						panic(fmt.Sprintf("missing field %s in %s",
 							n.Sel, cxt.String()))
 					}
+
 					if len(tr) > 1 {
 						// (the last vp, tr[len(tr)-1], is for n.Sel)
 						if debug {
@@ -1795,10 +1841,13 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 					// packages may contain constant vars,
 					// so check and evaluate if so.
 					tt := pn.GetStaticTypeOfAt(store, n.Path)
-					if isUntyped(tt) {
+
+					// Produce a constant expression for both typed and untyped constants.
+					if isUntyped(tt) || pn.GetIsConstAt(store, n.Path) {
 						cx := evalConst(store, last, n)
 						return cx, TRANS_CONTINUE
 					}
+
 				case *TypeType:
 					// unbound method
 					xt := evalStaticType(store, last, n.X)
@@ -2388,9 +2437,18 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
 				// We need to replace all references of the new
 				// Type with old Type, including in attributes.
 				n.Type.SetAttribute(ATTR_TYPE_VALUE, dst)
-				// Replace the type with *constTypeExpr{},
+				// Replace the type with *{},
 				// otherwise methods would be un at runtime.
 				n.Type = constType(n.Type, dst)
+
+			case *RefExpr:
+				// If n.X is a RefExpr, then this expression is something like:
+				// &(&value). The resulting pointer value of the first reference is not
+				// addressable. Otherwise fall back to the target expression's addressability.
+				_, xIsRef := n.X.(*RefExpr)
+				if xIsRef || n.X.addressability() == addressabilityStatusUnsatisfied {
+					panic(fmt.Sprintf("cannot take address of %s", n.X.String()))
+				}
 			}
 			// end type switch statement
 			// END TRANS_LEAVE -----------------------

gnovm/stdlibs/crypto/sha256/sha256_test.gno

@@ -7,7 +7,8 @@ import (
 )
 
 func TestSha256Sum(t *testing.T) {
-	got := sha256.Sum256([]byte("sha256 this string"))[:]
+	result := sha256.Sum256([]byte("sha256 this string"))
+	got := result[:]
 	expected := "1af1dfa857bf1d8814fe1af8983c18080019922e557f15a8a0d3db739d77aacb"
 
 	if hex.EncodeToString(got) != expected {

gnovm/tests/files/addressable_1.gno

@@ -0,0 +1,38 @@
+package main
+
+func main() {
+	// Array pointers are addressable.
+	println(&getArrPtr1()[0])
+	println(&getArrPtr2()[0])
+	println(&getArrPtr3()[0])
+	println(&new([1]int)[0])
+
+	// Array pointers are slicable.
+	println(getArrPtr1()[:])
+	println(getArrPtr2()[:])
+	println(getArrPtr3()[:])
+	println(new([1]int)[:])
+}
+
+func getArrPtr1() *[1]int {
+	return &[1]int{1}
+}
+
+func getArrPtr2() *[1]int {
+	a := [1]int{2}
+	return &a
+}
+
+func getArrPtr3() *[1]int {
+	return new([1]int)
+}
+
+// Output:
+// &(1 int)
+// &(2 int)
+// &(0 int)
+// &(0 int)
+// slice[(1 int)]
+// slice[(2 int)]
+// slice[(0 int)]
+// slice[(0 int)]

gnovm/tests/files/addressable_10.gno

@@ -0,0 +1,12 @@
+package main
+
+type S struct {
+	i int
+}
+
+func main() {
+	println(&new(S).i)
+}
+
+// Output:
+// &(0 int)

gnovm/tests/files/addressable_10a_err.gno

@@ -0,0 +1,14 @@
+package main
+
+func main() {
+	println(&getPtr())
+}
+
+type S struct{}
+
+func getPtr() *S {
+	return &S{}
+}
+
+// Error:
+// main/files/addressable_10a_err.gno:4:10: cannot take address of getPtr<VPBlock(3,2)>()

gnovm/tests/files/addressable_10b_err.gno

@@ -0,0 +1,12 @@
+package main
+
+type S struct {
+	i int
+}
+
+func main() {
+	println(&new(S))
+}
+
+// Error:
+// main/files/addressable_10b_err.gno:8:10: cannot take address of (const (new func(t type{})( *main.S)))(S<VPBlock(3,0)>)

gnovm/tests/files/addressable_11.gno

@@ -0,0 +1,39 @@
+package main
+
+func main() {
+	var ii **int
+	i := new(int)
+	ii = &i
+	println(&(*ii))
+	println(&ii)
+	println(i)
+	println(ii)
+	println(&i)
+
+	j := new(int)
+	println(&(*j))
+
+	println(&(*getPtr()))
+
+	derefTypeAssert()
+}
+
+func getPtr() *int {
+	return new(int)
+}
+
+func derefTypeAssert() {
+	var i interface{}
+	i = new(int)
+	println(&(*(i.(*int))))
+}
+
+// Output:
+// &(&(0 int) *int)
+// &(&(&(0 int) *int) **int)
+// &(0 int)
+// &(&(0 int) *int)
+// &(&(0 int) *int)
+// &(0 int)
+// &(0 int)
+// &(0 int)

gnovm/tests/files/addressable_1a_err.gno

@@ -0,0 +1,8 @@
+package main
+
+func main() {
+	_ = &[1]int{1}[0]
+}
+
+// Error:
+// main/files/addressable_1a_err.gno:4:6: cannot take address of [(const (1 int))](const-type int){(const (1 int))}[(const (0 int))]

gnovm/tests/files/addressable_1b_err.gno

@@ -0,0 +1,8 @@
+package main
+
+func main() {
+	_ = [1]int{1}[:]
+}
+
+// Error:
+// main/files/addressable_1b_err.gno:4:6: cannot take address of [(const (1 int))](const-type int){(const (1 int))}

gnovm/tests/files/addressable_1c_err.gno

@@ -0,0 +1,13 @@
+package main
+
+func main() {
+	_ = &getArr()[0]
+}
+
+func getArr() [1]int {
+	arr := [1]int{1}
+	return arr
+}
+
+// Error:
+// main/files/addressable_1c_err.gno:4:6: cannot take address of getArr<VPBlock(3,1)>()[(const (0 int))]

gnovm/tests/files/addressable_1d_err.gno

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	_ = getArr()[:]
+}
+
+func getArr() [1]int {
+	return [1]int{1}
+}
+
+// Error:
+// main/files/addressable_1d_err.gno:4:6: cannot take address of getArr<VPBlock(3,1)>()

gnovm/tests/files/addressable_2.gno

@@ -0,0 +1,40 @@
+package main
+
+func main() {
+	// Slices are addressable because the underlying array is addressable
+	// after slice initialization.
+	println(&[]int{1}[0])
+	println(&getSlice1()[0])
+	println(&getSlice2()[0])
+	println(&[]int{1})
+
+	a := []int{1}
+	println(&append(a, 1, 2, 3, 4, 5)[5])
+
+	println([]int{1}[:])
+	println(getSlice1()[:])
+	println(getSlice2()[:])
+
+	b := []int{1}
+	println(append(b, 1, 2, 3, 4, 5)[:])
+}
+
+func getSlice1() []int {
+	return []int{2}
+}
+
+func getSlice2() []int {
+	s := []int{3}
+	return s
+}
+
+// Output:
+// &(1 int)
+// &(2 int)
+// &(3 int)
+// &(slice[(1 int)] []int)
+// &(5 int)
+// slice[(1 int)]
+// slice[(2 int)]
+// slice[(3 int)]
+// slice[(1 int),(1 int),(2 int),(3 int),(4 int),(5 int)]

gnovm/tests/files/addressable_2a_err.gno

@@ -0,0 +1,8 @@
+package main
+
+func main() {
+	_ = &[]int{1}[:]
+}
+
+// Error:
+// main/files/addressable_2a_err.gno:4:6: cannot take address of [](const-type int){(const (1 int))}[:]

gnovm/tests/files/addressable_2b_err.gno

@@ -0,0 +1,12 @@
+package main
+
+func main() {
+	_ = &getSlice()
+}
+
+func getSlice() []int {
+	return []int{1}
+}
+
+// Error:
+// main/files/addressable_2b_err.gno:4:6: cannot take address of getSlice<VPBlock(3,1)>()