fix: addressability

gnovm/pkg/gnolang/nodes.go

@@ -328,6 +328,7 @@
 type Expr interface {
 	Node
 	assertExpr()
+	isAddressable() bool
 }
 
 type Exprs []Expr
@@ -374,6 +375,10 @@
 	Name
 }
 
+func (x *NameExpr) isAddressable() bool {
+	return true
+}
+
 type NameExprs []NameExpr
 
 type BasicLitExpr struct {
@@ -385,41 +390,69 @@
 	Value string
 }
 
+func (x *BasicLitExpr) isAddressable() bool {
+	return false
+}
+
 type BinaryExpr struct { // (Left Op Right)
 	Attributes
 	Left  Expr // left operand
 	Op    Word // operator
 	Right Expr // right operand
 }
 
+func (x *BinaryExpr) isAddressable() bool {
+	return false
+}
+
 type CallExpr struct { // Func(Args<Varg?...>)
 	Attributes
-	Func    Expr  // function expression
-	Args    Exprs // function arguments, if any.
-	Varg    bool  // if true, final arg is variadic.
-	NumArgs int   // len(Args) or len(Args[0].Results)
+	Func          Expr  // function expression
+	Args          Exprs // function arguments, if any.
+	Varg          bool  // if true, final arg is variadic.
+	NumArgs       int   // len(Args) or len(Args[0].Results)
+	IsAddressable bool
+}
+
+func (x *CallExpr) isAddressable() bool {
+	return x.IsAddressable
 }
 
 type IndexExpr struct { // X[Index]
 	Attributes
-	X     Expr // expression
-	Index Expr // index expression
-	HasOK bool // if true, is form: `value, ok := <X>[<Key>]
+	X              Expr // expression
+	Index          Expr // index expression
+	HasOK          bool // if true, is form: `value, ok := <X>[<Key>]
+	NotAddressable bool
+}
+
+func (x *IndexExpr) isAddressable() bool {
+	return !x.NotAddressable && x.X.isAddressable()
 }
 
 type SelectorExpr struct { // X.Sel
 	Attributes
-	X    Expr      // expression
-	Path ValuePath // set by preprocessor.
-	Sel  Name      // field selector
+	X             Expr      // expression
+	Path          ValuePath // set by preprocessor.
+	Sel           Name      // field selector
+	IsAddressable bool
+}
+
+func (x *SelectorExpr) isAddressable() bool {
+	return x.IsAddressable || x.X.isAddressable()
 }
 
 type SliceExpr struct { // X[Low:High:Max]
 	Attributes
-	X    Expr // expression
-	Low  Expr // begin of slice range; or nil
-	High Expr // end of slice range; or nil
-	Max  Expr // maximum capacity of slice; or nil; added in Go 1.2
+	X             Expr // expression
+	Low           Expr // begin of slice range; or nil
+	High          Expr // end of slice range; or nil
+	Max           Expr // maximum capacity of slice; or nil; added in Go 1.2
+	IsAddressable bool
+}
+
+func (x *SliceExpr) isAddressable() bool {
+	return x.IsAddressable
 }
 
 // A StarExpr node represents an expression of the form
@@ -430,16 +463,29 @@
 	X Expr // operand
 }
 
+func (x *StarExpr) isAddressable() bool {
+	return x.X.isAddressable()
+}
+
 type RefExpr struct { // &X
 	Attributes
 	X Expr // operand
 }
 
+func (x *RefExpr) isAddressable() bool {
+	return x.X.isAddressable()
+}
+
 type TypeAssertExpr struct { // X.(Type)
 	Attributes
-	X     Expr // expression.
-	Type  Expr // asserted type, never nil.
-	HasOK bool // if true, is form: `_, ok := <X>.(<Type>)`.
+	X             Expr // expression.
+	Type          Expr // asserted type, never nil.
+	HasOK         bool // if true, is form: `_, ok := <X>.(<Type>)`.
+	IsAddressable bool
+}
+
+func (x *TypeAssertExpr) isAddressable() bool {
+	return x.IsAddressable
 }
 
 // A UnaryExpr node represents a unary expression. Unary
@@ -452,12 +498,21 @@
 	Op Word // operator
 }
 
+func (x *UnaryExpr) isAddressable() bool {
+	return x.X.isAddressable()
+}
+
 // MyType{<key>:<value>} struct, array, slice, and map
 // expressions.
 type CompositeLitExpr struct {
 	Attributes
-	Type Expr          // literal type; or nil
-	Elts KeyValueExprs // list of struct fields; if any
+	Type          Expr          // literal type; or nil
+	Elts          KeyValueExprs // list of struct fields; if any
+	IsAddressable bool
+}
+
+func (x *CompositeLitExpr) isAddressable() bool {
+	return x.IsAddressable
 }
 
 // Returns true if any elements are keyed.
@@ -490,6 +545,10 @@
 	Value Expr // never nil
 }
 
+func (x *KeyValueExpr) isAddressable() bool {
+	return false
+}
+
 type KeyValueExprs []KeyValueExpr
 
 // A FuncLitExpr node represents a function literal.  Here one
@@ -502,6 +561,10 @@
 	Body              // function body
 }
 
+func (x *FuncLitExpr) isAddressable() bool {
+	return false
+}
+
 // The preprocessor replaces const expressions
 // with *ConstExpr nodes.
 type ConstExpr struct {
@@ -510,6 +573,10 @@
 	TypedValue
 }
 
+func (x *ConstExpr) isAddressable() bool {
+	return false
+}
+
 // ----------------------------------------
 // Type(Expressions)
 //
@@ -574,6 +641,10 @@
 	Tag Expr
 }
 
+func (x *FieldTypeExpr) isAddressable() bool {
+	return false
+}
+
 type FieldTypeExprs []FieldTypeExpr
 
 func (ftxz FieldTypeExprs) IsNamed() bool {
@@ -598,18 +669,30 @@
 	Elt Expr // element type
 }
 
+func (x *ArrayTypeExpr) isAddressable() bool {
+	return false
+}
+
 type SliceTypeExpr struct {
 	Attributes
 	Elt Expr // element type
 	Vrd bool // variadic arg expression
 }
 
+func (x *SliceTypeExpr) isAddressable() bool {
+	return false
+}
+
 type InterfaceTypeExpr struct {
 	Attributes
 	Methods FieldTypeExprs // list of methods
 	Generic Name           // for uverse generics
 }
 
+func (x *InterfaceTypeExpr) isAddressable() bool {
+	return false
+}
+
 type ChanDir int
 
 const (
@@ -627,36 +710,60 @@
 	Value Expr    // value type
 }
 
+func (x *ChanTypeExpr) isAddressable() bool {
+	return false
+}
+
 type FuncTypeExpr struct {
 	Attributes
 	Params  FieldTypeExprs // (incoming) parameters, if any.
 	Results FieldTypeExprs // (outgoing) results, if any.
 }
 
+func (x *FuncTypeExpr) isAddressable() bool {
+	return false
+}
+
 type MapTypeExpr struct {
 	Attributes
 	Key   Expr // const
 	Value Expr // value type
 }
 
+func (x *MapTypeExpr) isAddressable() bool {
+	return false
+}
+
 type StructTypeExpr struct {
 	Attributes
 	Fields FieldTypeExprs // list of field declarations
 }
 
+func (x *StructTypeExpr) isAddressable() bool {
+	return false
+}
+
 // Like ConstExpr but for types.
 type constTypeExpr struct {
 	Attributes
 	Source Expr
 	Type   Type
 }
 
+func (x *constTypeExpr) isAddressable() bool {
+	return false
+}
+
 // Only used for native func arguments
 type MaybeNativeTypeExpr struct {
 	Attributes
 	Type Expr
 }
 
+func (x *MaybeNativeTypeExpr) isAddressable() bool {
+	return false
+}
+
 // ----------------------------------------
 // Stmt
 //
@@ -1484,6 +1591,7 @@
 	GetParentNode(Store) BlockNode
 	GetPathForName(Store, Name) ValuePath
 	GetIsConst(Store, Name) bool
+	GetIsConstAt(Store, ValuePath) bool
 	GetLocalIndex(Name) (uint16, bool)
 	GetValueRef(Store, Name, bool) *TypedValue
 	GetStaticTypeOf(Store, Name) Type
@@ -1671,6 +1779,17 @@
 	}
 }
 
+func (sb *StaticBlock) GetIsConstAt(store Store, path ValuePath) bool {
+	for {
+		if path.Depth == 1 {
+			return sb.getLocalIsConst(path.Name)
+		} else {
+			sb = sb.GetParentNode(store).GetStaticBlock()
+			path.Depth -= 1
+		}
+	}
+}
+
 // Returns true iff n is a local const defined name.
 func (sb *StaticBlock) getLocalIsConst(n Name) bool {
 	for _, name := range sb.Consts {