fix: addressability

gnovm/pkg/gnolang/addressability.go

@@ -0,0 +1,9 @@
+package gnolang
+
+type Addressability int
+
+const (
+	AddressabilityNotApplicable Addressability = iota
+	AddressabilitySatisfied
+	AddressabilityUnsatisfied
+)

gnovm/pkg/gnolang/nodes.go

@@ -328,6 +328,7 @@
 type Expr interface {
 	Node
 	assertExpr()
+	addressability() Addressability
 }
 
 type Exprs []Expr
@@ -374,6 +375,10 @@
 	Name
 }
 
+func (x *NameExpr) addressability() Addressability {
+	return AddressabilitySatisfied
+}
+
 type NameExprs []NameExpr
 
 type BasicLitExpr struct {
@@ -385,33 +390,65 @@
 	Value string
 }
 
+func (x *BasicLitExpr) addressability() Addressability {
+	return AddressabilityUnsatisfied
+}
+
 type BinaryExpr struct { // (Left Op Right)
 	Attributes
 	Left  Expr // left operand
 	Op    Word // operator
 	Right Expr // right operand
 }
 
+func (x *BinaryExpr) addressability() Addressability {
+	return AddressabilityUnsatisfied
+}
+
 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)
+	Addressability Addressability
+}
+
+func (x *CallExpr) addressability() Addressability {
+	return x.Addressability
 }
 
 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>]
+	Addressability Addressability
+}
+
+func (x *IndexExpr) addressability() Addressability {
+	// In this case NotApplicable means that it wasn't set, the default value.
+	if x.Addressability == AddressabilityNotApplicable {
+		return x.X.addressability()
+	}
+
+	return x.Addressability
 }
 
 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      // true if X is a pointer
+}
+
+func (x *SelectorExpr) addressability() Addressability {
+	if x.IsAddressable || x.X.addressability() == AddressabilitySatisfied {
+		return AddressabilitySatisfied
+	}
+
+	return AddressabilityUnsatisfied
 }
 
 type SliceExpr struct { // X[Low:High:Max]
@@ -422,6 +459,10 @@
 	Max  Expr // maximum capacity of slice; or nil; added in Go 1.2
 }
 
+func (x *SliceExpr) addressability() Addressability {
+	return AddressabilityUnsatisfied
+}
+
 // A StarExpr node represents an expression of the form
 // "*" Expression.  Semantically it could be a unary "*"
 // expression, or a pointer type.
@@ -430,16 +471,33 @@
 	X Expr // operand
 }
 
+func (x *StarExpr) addressability() Addressability {
+	return x.X.addressability()
+}
+
 type RefExpr struct { // &X
 	Attributes
 	X Expr // operand
 }
 
+func (x *RefExpr) addressability() Addressability {
+	return x.X.addressability()
+}
+
 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) addressability() Addressability {
+	if x.IsAddressable {
+		return AddressabilitySatisfied
+	}
+
+	return AddressabilityUnsatisfied
 }
 
 // A UnaryExpr node represents a unary expression. Unary
@@ -452,12 +510,25 @@
 	Op Word // operator
 }
 
+func (x *UnaryExpr) addressability() Addressability {
+	return x.X.addressability()
+}
+
 // 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) addressability() Addressability {
+	if x.IsAddressable {
+		return AddressabilitySatisfied
+	}
+
+	return AddressabilityUnsatisfied
 }
 
 // Returns true if any elements are keyed.
@@ -490,6 +561,10 @@
 	Value Expr // never nil
 }
 
+func (x *KeyValueExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 type KeyValueExprs []KeyValueExpr
 
 // A FuncLitExpr node represents a function literal.  Here one
@@ -502,6 +577,10 @@
 	Body              // function body
 }
 
+func (x *FuncLitExpr) addressability() Addressability {
+	return AddressabilityUnsatisfied
+}
+
 // The preprocessor replaces const expressions
 // with *ConstExpr nodes.
 type ConstExpr struct {
@@ -510,6 +589,10 @@
 	TypedValue
 }
 
+func (x *ConstExpr) addressability() Addressability {
+	return AddressabilityUnsatisfied
+}
+
 // ----------------------------------------
 // Type(Expressions)
 //
@@ -574,6 +657,10 @@
 	Tag Expr
 }
 
+func (x *FieldTypeExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 type FieldTypeExprs []FieldTypeExpr
 
 func (ftxz FieldTypeExprs) IsNamed() bool {
@@ -598,18 +685,30 @@
 	Elt Expr // element type
 }
 
+func (x *ArrayTypeExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 type SliceTypeExpr struct {
 	Attributes
 	Elt Expr // element type
 	Vrd bool // variadic arg expression
 }
 
+func (x *SliceTypeExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 type InterfaceTypeExpr struct {
 	Attributes
 	Methods FieldTypeExprs // list of methods
 	Generic Name           // for uverse generics
 }
 
+func (x *InterfaceTypeExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 type ChanDir int
 
 const (
@@ -627,36 +726,60 @@
 	Value Expr    // value type
 }
 
+func (x *ChanTypeExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 type FuncTypeExpr struct {
 	Attributes
 	Params  FieldTypeExprs // (incoming) parameters, if any.
 	Results FieldTypeExprs // (outgoing) results, if any.
 }
 
+func (x *FuncTypeExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 type MapTypeExpr struct {
 	Attributes
 	Key   Expr // const
 	Value Expr // value type
 }
 
+func (x *MapTypeExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 type StructTypeExpr struct {
 	Attributes
 	Fields FieldTypeExprs // list of field declarations
 }
 
+func (x *StructTypeExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 // Like ConstExpr but for types.
 type constTypeExpr struct {
 	Attributes
 	Source Expr
 	Type   Type
 }
 
+func (x *constTypeExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 // Only used for native func arguments
 type MaybeNativeTypeExpr struct {
 	Attributes
 	Type Expr
 }
 
+func (x *MaybeNativeTypeExpr) addressability() Addressability {
+	return AddressabilityNotApplicable
+}
+
 // ----------------------------------------
 // Stmt
 //
@@ -1484,6 +1607,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 +1795,30 @@
 	}
 }
 
+func (sb *StaticBlock) getAt(store Store, path ValuePath) *StaticBlock {
+	if debug {
+		if path.Type != VPBlock {
+			panic("should not happen")
+		}
+		if path.Depth == 0 {
+			panic("should not happen")
+		}
+	}
+
+	for {
+		if path.Depth == 1 {
+			return sb
+		} else {
+			sb = sb.GetParentNode(store).GetStaticBlock()
+			path.Depth -= 1
+		}
+	}
+}
+
+func (sb *StaticBlock) GetIsConstAt(store Store, path ValuePath) bool {
+	return sb.getAt(store, path).getLocalIsConst(path.Name)
+}
+
 // Returns true iff n is a local const defined name.
 func (sb *StaticBlock) getLocalIsConst(n Name) bool {
 	for _, name := range sb.Consts {
@@ -1706,22 +1854,7 @@
 
 // Implements BlockNode.
 func (sb *StaticBlock) GetStaticTypeOfAt(store Store, path ValuePath) Type {
-	if debug {
-		if path.Type != VPBlock {
-			panic("should not happen")
-		}
-		if path.Depth == 0 {
-			panic("should not happen")
-		}
-	}
-	for {
-		if path.Depth == 1 {
-			return sb.Types[path.Index]
-		} else {
-			sb = sb.GetParentNode(store).GetStaticBlock()
-			path.Depth -= 1
-		}
-	}
+	return sb.getAt(store, path).Types[path.Index]
 }
 
 // Implements BlockNode.