introduce concept of addressability not applicable

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,7 +328,7 @@ var (
 type Expr interface {
  Node
  assertExpr()
- isAddressable() bool
+ addressability() Addressability
 }
 
 type Exprs []Expr
@@ -375,8 +375,8 @@ type NameExpr struct {
  Name
 }
 
-func (x *NameExpr) isAddressable() bool {
- return true
+func (x *NameExpr) addressability() Addressability {
+ return AddressabilitySatisfied
 }
 
 type NameExprs []NameExpr
@@ -390,8 +390,8 @@ type BasicLitExpr struct {
  Value string
 }
 
-func (x *BasicLitExpr) isAddressable() bool {
- return false
+func (x *BasicLitExpr) addressability() Addressability {
+ return AddressabilityUnsatisfied
 }
 
 type BinaryExpr struct { // (Left Op Right)
@@ -401,21 +401,21 @@ type BinaryExpr struct { // (Left Op Right)
  Right Expr // right operand
 }
 
-func (x *BinaryExpr) isAddressable() bool {
- return false
+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)
- IsAddressable bool
+ 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) isAddressable() bool {
- return x.IsAddressable
+func (x *CallExpr) addressability() Addressability {
+ return x.Addressability
 }
 
 type IndexExpr struct { // X[Index]
@@ -427,12 +427,16 @@ type IndexExpr struct { // X[Index]
  XIsString bool // true if X is a string (never addressable)
 }
 
-func (x *IndexExpr) isAddressable() bool {
+func (x *IndexExpr) addressability() Addressability {
  if x.XIsString {
- return false
+ return AddressabilityUnsatisfied
  }
 
- return x.IsAddressable || x.X.isAddressable()
+ if x.IsAddressable || x.X.addressability() == AddressabilitySatisfied {
+ return AddressabilitySatisfied
+ }
+
+ return AddressabilityUnsatisfied
 }
 
 type SelectorExpr struct { // X.Sel
@@ -443,8 +447,12 @@ type SelectorExpr struct { // X.Sel
  IsAddressable bool // true if X is a pointer
 }
 
-func (x *SelectorExpr) isAddressable() bool {
- return x.IsAddressable || x.X.isAddressable()
+func (x *SelectorExpr) addressability() Addressability {
+ if x.IsAddressable || x.X.addressability() == AddressabilitySatisfied {
+ return AddressabilitySatisfied
+ }
+
+ return AddressabilityUnsatisfied
 }
 
 type SliceExpr struct { // X[Low:High:Max]
@@ -456,8 +464,12 @@ type SliceExpr struct { // X[Low:High:Max]
  IsAddressable bool
 }
 
-func (x *SliceExpr) isAddressable() bool {
- return x.IsAddressable
+func (x *SliceExpr) addressability() Addressability {
+ if x.IsAddressable {
+ return AddressabilitySatisfied
+ }
+
+ return AddressabilityUnsatisfied
 }
 
 // A StarExpr node represents an expression of the form
@@ -468,17 +480,17 @@ type StarExpr struct { // *X
  X Expr // operand
 }
 
-func (x *StarExpr) isAddressable() bool {
- return x.X.isAddressable()
+func (x *StarExpr) addressability() Addressability {
+ return x.X.addressability()
 }
 
 type RefExpr struct { // &X
  Attributes
  X Expr // operand
 }
 
-func (x *RefExpr) isAddressable() bool {
- return x.X.isAddressable()
+func (x *RefExpr) addressability() Addressability {
+ return x.X.addressability()
 }
 
 type TypeAssertExpr struct { // X.(Type)
@@ -489,8 +501,12 @@ type TypeAssertExpr struct { // X.(Type)
  IsAddressable bool
 }
 
-func (x *TypeAssertExpr) isAddressable() bool {
- return x.IsAddressable
+func (x *TypeAssertExpr) addressability() Addressability {
+ if x.IsAddressable {
+ return AddressabilitySatisfied
+ }
+
+ return AddressabilityUnsatisfied
 }
 
 // A UnaryExpr node represents a unary expression. Unary
@@ -503,8 +519,8 @@ type UnaryExpr struct { // (Op X)
  Op Word // operator
 }
 
-func (x *UnaryExpr) isAddressable() bool {
- return x.X.isAddressable()
+func (x *UnaryExpr) addressability() Addressability {
+ return x.X.addressability()
 }
 
 // MyType{<key>:<value>} struct, array, slice, and map
@@ -516,8 +532,12 @@ type CompositeLitExpr struct {
  IsAddressable bool
 }
 
-func (x *CompositeLitExpr) isAddressable() bool {
- return x.IsAddressable
+func (x *CompositeLitExpr) addressability() Addressability {
+ if x.IsAddressable {
+ return AddressabilitySatisfied
+ }
+
+ return AddressabilityUnsatisfied
 }
 
 // Returns true if any elements are keyed.
@@ -550,8 +570,8 @@ type KeyValueExpr struct {
  Value Expr // never nil
 }
 
-func (x *KeyValueExpr) isAddressable() bool {
- return false
+func (x *KeyValueExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 type KeyValueExprs []KeyValueExpr
@@ -566,8 +586,8 @@ type FuncLitExpr struct {
  Body // function body
 }
 
-func (x *FuncLitExpr) isAddressable() bool {
- return false
+func (x *FuncLitExpr) addressability() Addressability {
+ return AddressabilityUnsatisfied
 }
 
 // The preprocessor replaces const expressions
@@ -578,8 +598,8 @@ type ConstExpr struct {
  TypedValue
 }
 
-func (x *ConstExpr) isAddressable() bool {
- return false
+func (x *ConstExpr) addressability() Addressability {
+ return AddressabilityUnsatisfied
 }
 
 // ----------------------------------------
@@ -646,8 +666,8 @@ type FieldTypeExpr struct {
  Tag Expr
 }
 
-func (x *FieldTypeExpr) isAddressable() bool {
- return false
+func (x *FieldTypeExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 type FieldTypeExprs []FieldTypeExpr
@@ -674,8 +694,8 @@ type ArrayTypeExpr struct {
  Elt Expr // element type
 }
 
-func (x *ArrayTypeExpr) isAddressable() bool {
- return false
+func (x *ArrayTypeExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 type SliceTypeExpr struct {
@@ -684,8 +704,8 @@ type SliceTypeExpr struct {
  Vrd bool // variadic arg expression
 }
 
-func (x *SliceTypeExpr) isAddressable() bool {
- return false
+func (x *SliceTypeExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 type InterfaceTypeExpr struct {
@@ -694,8 +714,8 @@ type InterfaceTypeExpr struct {
  Generic Name // for uverse generics
 }
 
-func (x *InterfaceTypeExpr) isAddressable() bool {
- return false
+func (x *InterfaceTypeExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 type ChanDir int
@@ -715,8 +735,8 @@ type ChanTypeExpr struct {
  Value Expr // value type
 }
 
-func (x *ChanTypeExpr) isAddressable() bool {
- return false
+func (x *ChanTypeExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 type FuncTypeExpr struct {
@@ -725,8 +745,8 @@ type FuncTypeExpr struct {
  Results FieldTypeExprs // (outgoing) results, if any.
 }
 
-func (x *FuncTypeExpr) isAddressable() bool {
- return false
+func (x *FuncTypeExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 type MapTypeExpr struct {
@@ -735,17 +755,17 @@ type MapTypeExpr struct {
  Value Expr // value type
 }
 
-func (x *MapTypeExpr) isAddressable() bool {
- return false
+func (x *MapTypeExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 type StructTypeExpr struct {
  Attributes
  Fields FieldTypeExprs // list of field declarations
 }
 
-func (x *StructTypeExpr) isAddressable() bool {
- return false
+func (x *StructTypeExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 // Like ConstExpr but for types.
@@ -755,8 +775,8 @@ type constTypeExpr struct {
  Type Type
 }
 
-func (x *constTypeExpr) isAddressable() bool {
- return false
+func (x *constTypeExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 // Only used for native func arguments
@@ -765,8 +785,8 @@ type MaybeNativeTypeExpr struct {
  Type Expr
 }
 
-func (x *MaybeNativeTypeExpr) isAddressable() bool {
- return false
+func (x *MaybeNativeTypeExpr) addressability() Addressability {
+ return AddressabilityNotApplicable
 }
 
 // ----------------------------------------

gnovm/pkg/gnolang/preprocess.go

@@ -1293,7 +1293,7 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
  fv := cx.GetFunc()
  if fv.PkgPath == uversePkgPath && fv.Name == "append" {
  // append returns a slice and slices are always addressable.
- n.IsAddressable = true
+ n.Addressability = AddressabilitySatisfied
  if n.Varg && len(n.Args) == 2 {
  // If the second argument is a string,
  // convert to byteslice.
@@ -1342,15 +1342,17 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
  }
  } else if fv.PkgPath == uversePkgPath && fv.Name == "new" {
  // new returns a pointer and pointers are always addressable.
- n.IsAddressable = true
+ n.Addressability = AddressabilitySatisfied
  }
  }
 
- if !n.IsAddressable && len(ft.Results) == 1 {
+ if n.Addressability != AddressabilitySatisfied && len(ft.Results) == 1 {
  baseType := baseOf(ft.Results[0].Type)
  switch baseType.(type) {
  case *PointerType, *SliceType:
- n.IsAddressable = true
+ n.Addressability = AddressabilitySatisfied
+ default:
+ n.Addressability = AddressabilityUnsatisfied
  }
  }
 
@@ -1531,7 +1533,7 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
  // Slices and pointers are addressable.
  switch baseOf(t).(type) {
  case *ArrayType:
- if !n.X.isAddressable() {
+ if n.X.addressability() == AddressabilityUnsatisfied {
  panic(fmt.Sprintf("cannot take address of %s", n.X.String()))
  }
 
@@ -2421,7 +2423,7 @@ func Preprocess(store Store, ctx BlockNode, n Node) Node {
  n.Type = constType(n.Type, dst)
 
  case *RefExpr:
- if !n.X.isAddressable() {
+ if n.X.addressability() == AddressabilityUnsatisfied {
  panic(fmt.Sprintf("cannot take address of %s", n.X.String()))
  }
  }

gnovm/tests/files/addressable_7a_err.gno

@@ -0,0 +1,12 @@
+package main
+
+func foo() ([]int, []string) {
+ return []int{1, 2, 3}, []string{"a", "b", "c"}
+}
+
+func main() {
+ _ = &foo()
+}
+
+// Error:
+// main/files/addressable_7a_err.gno:8:2: getTypeOf() only supports *CallExpr with 1 result, got ([]int,[]string)

gnovm/tests/files/addressable_7b_err.gno

@@ -0,0 +1,9 @@
+package main
+
+type MyInt int
+
+func main() {
+ _ = &MyInt
+}
+
+// Error: