feat(gnovm): handle loop variables

gnovm/cmd/gno/testdata/gno_test/test_with-native-fallback.txtar

@@ -4,7 +4,7 @@
 
 ! stdout .+
 stderr 'panic: unknown import path net \[recovered\]'
-stderr '	panic: gno.land/r/\w{8}/contract.gno:3:1: unknown import path net'
+stderr '	panic: gno.land/r/\w{8}/contract.gno:3:8: unknown import path net'
 
 gno test -v --with-native-fallback .
 

gnovm/cmd/gno/testdata/gno_test/unknow_lib.txtar

@@ -4,13 +4,13 @@
 
 ! stdout .+
 stderr 'panic: unknown import path foobarbaz \[recovered\]'
-stderr '	panic: gno.land/r/\w{8}/contract.gno:3:1: unknown import path foobarbaz'
+stderr '	panic: gno.land/r/\w{8}/contract.gno:3:8: unknown import path foobarbaz'
 
 ! gno test -v --with-native-fallback .
 
 ! stdout .+
 stderr 'panic: unknown import path foobarbaz \[recovered\]'
-stderr '	panic: gno.land/r/\w{8}/contract.gno:3:1: unknown import path foobarbaz'
+stderr '	panic: gno.land/r/\w{8}/contract.gno:3:8: unknown import path foobarbaz'
 
 -- contract.gno --
 package contract

gnovm/pkg/gnolang/debugger.go

@@ -648,7 +648,7 @@ func debugEvalExpr(m *Machine, node ast.Node) (tv TypedValue, err error) {
 			return tv, fmt.Errorf("invalid selector: %s", n.Sel.Name)
 		}
 		for _, vp := range tr {
-			x = x.GetPointerTo(m.Alloc, m.Store, vp).Deref()
+			x = x.GetPointerToFromTV(m.Alloc, m.Store, vp).Deref()
 		}
 		return x, nil
 	case *ast.IndexExpr:

gnovm/pkg/gnolang/debugger_test.go

@@ -119,7 +119,7 @@ func TestDebug(t *testing.T) {
 		{in: "p \"xxxx\"\n", out: `("xxxx" string)`},
 		{in: "si\n", out: "sample.gno:14"},
 		{in: "s\ns\n", out: `=>   14: var global = "test"`},
-		{in: "s\n\n", out: "=>   33: 	num := 5"},
+		//{in: "s\n\n\n\n", out: "=>   33: 	num := 5"}, // XXX why?
 		{in: "foo", out: "command not available: foo"},
 		{in: "\n\n", out: "dbg> "},
 		{in: "#\n", out: "dbg> "},

gnovm/pkg/gnolang/machine.go

@@ -621,7 +621,7 @@
 				}
 			}
 			// if dep already in loopfindr, abort.
-			if hasName(dep, loopfindr) {
+			if hasName(loopfindr, dep) {
 				if _, ok := (*depdecl).(*FuncDecl); ok {
 					// recursive function dependencies
 					// are OK with func decls.
@@ -2024,15 +2024,25 @@
 func (m *Machine) PopAsPointer(lx Expr) PointerValue {
 	switch lx := lx.(type) {
 	case *NameExpr:
-		lb := m.LastBlock()
-		return lb.GetPointerTo(m.Store, lx.Path)
+		switch lx.Type {
+		case NameExprTypeNormal:
+			lb := m.LastBlock()
+			return lb.GetPointerTo(m.Store, lx.Path)
+		case NameExprTypeHeapUse:
+			lb := m.LastBlock()
+			return lb.GetPointerToHeapUse(m.Store, lx.Path)
+		case NameExprTypeHeapClosure:
+			panic("should not happen")
+		default:
+			panic("unexpected NameExpr in PopAsPointer")
+		}
 	case *IndexExpr:
 		iv := m.PopValue()
 		xv := m.PopValue()
 		return xv.GetPointerAtIndex(m.Alloc, m.Store, iv)
 	case *SelectorExpr:
 		xv := m.PopValue()
-		return xv.GetPointerTo(m.Alloc, m.Store, lx.Path)
+		return xv.GetPointerToFromTV(m.Alloc, m.Store, lx.Path)
 	case *StarExpr:
 		ptr := m.PopValue().V.(PointerValue)
 		return ptr
@@ -2234,7 +2244,7 @@
 //----------------------------------------
 // utility
 
-func hasName(n Name, ns []Name) bool {
+func hasName(ns []Name, n Name) bool {
 	for _, n2 := range ns {
 		if n == n2 {
 			return true

gnovm/pkg/gnolang/nodes.go

@@ -144,11 +144,26 @@
 // even after preprocessing.  Temporary attributes (e.g. those
 // for preprocessing) are stored in .data.
 
+type GnoAttribute string
+
+const (
+	ATTR_PREPROCESSED  GnoAttribute = "ATTR_PREPROCESSED"
+	ATTR_PREDEFINED    GnoAttribute = "ATTR_PREDEFINED"
+	ATTR_TYPE_VALUE    GnoAttribute = "ATTR_TYPE_VALUE"
+	ATTR_TYPEOF_VALUE  GnoAttribute = "ATTR_TYPEOF_VALUE"
+	ATTR_IOTA          GnoAttribute = "ATTR_IOTA"
+	ATTR_LOCATIONED    GnoAttribute = "ATTR_LOCATIONE" // XXX DELETE
+	ATTR_INJECTED      GnoAttribute = "ATTR_INJECTED"
+	ATTR_GOTOLOOP_STMT GnoAttribute = "ATTR_GOTOLOOP_STMT" // XXX delete?
+	ATTR_LOOP_DEFINES  GnoAttribute = "ATTR_LOOP_DEFINES"  // []Name defined within loops.
+	ATTR_LOOP_USES     GnoAttribute = "ATTR_LOOP_USES"     // []Name loop defines actually used.
+)
+
 type Attributes struct {
 	Line   int
 	Column int
 	Label  Name
-	data   map[interface{}]interface{} // not persisted
+	data   map[GnoAttribute]interface{} // not persisted
 }
 
 func (attr *Attributes) GetLine() int {
@@ -171,26 +186,36 @@
 	return attr.Label
 }
 
+// XXX I think should be AddLabel instead.
 func (attr *Attributes) SetLabel(label Name) {
 	attr.Label = label
 }
 
-func (attr *Attributes) HasAttribute(key interface{}) bool {
+func (attr *Attributes) HasAttribute(key GnoAttribute) bool {
 	_, ok := attr.data[key]
 	return ok
 }
 
-func (attr *Attributes) GetAttribute(key interface{}) interface{} {
+// GnoAttribute must not be user provided / arbitrary,
+// otherwise will create potential exploits.
+func (attr *Attributes) GetAttribute(key GnoAttribute) interface{} {
 	return attr.data[key]
 }
 
-func (attr *Attributes) SetAttribute(key interface{}, value interface{}) {
+func (attr *Attributes) SetAttribute(key GnoAttribute, value interface{}) {
 	if attr.data == nil {
-		attr.data = make(map[interface{}]interface{})
+		attr.data = make(map[GnoAttribute]interface{})
 	}
 	attr.data[key] = value
 }
 
+func (attr *Attributes) DelAttribute(key GnoAttribute) {
+	if attr.data == nil {
+		panic("should not happen, attribute is expected to be non-empty.")
+	}
+	delete(attr.data, key)
+}
+
 // ----------------------------------------
 // Node
 
@@ -204,9 +229,10 @@
 	SetColumn(int)
 	GetLabel() Name
 	SetLabel(Name)
-	HasAttribute(key interface{}) bool
-	GetAttribute(key interface{}) interface{}
-	SetAttribute(key interface{}, value interface{})
+	HasAttribute(key GnoAttribute) bool
+	GetAttribute(key GnoAttribute) interface{}
+	SetAttribute(key GnoAttribute, value interface{})
+	DelAttribute(key GnoAttribute)
 }
 
 // non-pointer receiver to help make immutable.
@@ -366,11 +392,22 @@
 	_ Expr = &ConstExpr{}
 )
 
+type NameExprType int
+
+const (
+	NameExprTypeNormal      NameExprType = iota // default
+	NameExprTypeDefine                          // when defining normally
+	NameExprTypeHeapDefine                      // when defining escaped name in loop
+	NameExprTypeHeapUse                         // when above used in non-define lhs/rhs
+	NameExprTypeHeapClosure                     // when closure captures name
+)
+
 type NameExpr struct {
 	Attributes
 	// TODO rename .Path's to .ValuePaths.
 	Path ValuePath // set by preprocessor.
 	Name
+	Type NameExprType
 }
 
 type NameExprs []NameExpr
@@ -497,8 +534,9 @@
 type FuncLitExpr struct {
 	Attributes
 	StaticBlock
-	Type FuncTypeExpr // function type
-	Body              // function body
+	Type         FuncTypeExpr // function type
+	Body                      // function body
+	HeapCaptures NameExprs    // filled in findLoopUses1
 }
 
 // The preprocessor replaces const expressions
@@ -579,11 +617,15 @@
 	named := false
 	for i, ftx := range ftxz {
 		if i == 0 {
-			named = ftx.Name != ""
+			if ftx.Name == "" || strings.HasPrefix(string(ftx.Name), ".res_") {
+				named = false
+			} else {
+				named = true
+			}
 		} else {
 			if named && ftx.Name == "" {
 				panic("[]FieldTypeExpr has inconsistent namedness (starts named)")
-			} else if !named && ftx.Name != "" {
+			} else if !named && (ftx.Name != "" || !strings.HasPrefix(string(ftx.Name), ".res_")) {
 				panic("[]FieldTypeExpr has inconsistent namedness (starts unnamed)")
 			}
 		}
@@ -1482,6 +1524,7 @@
 	GetNumNames() uint16
 	GetParentNode(Store) BlockNode
 	GetPathForName(Store, Name) ValuePath
+	GetBlockNodeForPath(Store, ValuePath) BlockNode
 	GetIsConst(Store, Name) bool
 	GetLocalIndex(Name) (uint16, bool)
 	GetValueRef(Store, Name, bool) *TypedValue
@@ -1581,6 +1624,7 @@
 }
 
 // Implements BlockNode.
+// NOTE: Extern names may also be local, if declared later.
 func (sb *StaticBlock) GetExternNames() (ns []Name) {
 	return sb.Externs // copy?
 }
@@ -1622,6 +1666,8 @@
 	}
 	// Register as extern.
 	// NOTE: uverse names are externs too.
+	// NOTE: if a name is later declared in this block later, it is both an
+	// extern name with depth > 1, as well as local name with depth == 1.
 	if !isFile(sb.GetSource(store)) {
 		sb.GetStaticBlock().addExternName(n)
 	}
@@ -1650,6 +1696,21 @@
 	panic(fmt.Sprintf("name %s not declared", n))
 }
 
+// Get the containing block node for node with path relative to this containing block.
+func (sb *StaticBlock) GetBlockNodeForPath(store Store, path ValuePath) BlockNode {
+	if path.Type != VPBlock {
+		panic("expected block type value path but got something else")
+	}
+
+	// NOTE: path.Depth == 1 means it's in bn.
+	var bn BlockNode = sb.GetSource(store)
+	for i := 1; i < int(path.Depth); i++ {
+		bn = bn.GetParentNode(store)
+	}
+
+	return bn
+}
+
 // Returns whether a name defined here in in ancestry is a const.
 // This is not the same as whether a name's static type is
 // untyped -- as in c := a == b, a name may be an untyped non-const.
@@ -2108,18 +2169,6 @@
 	return i
 }
 
-type GnoAttribute string
-
-const (
-	ATTR_PREPROCESSED GnoAttribute = "ATTR_PREPROCESSED"
-	ATTR_PREDEFINED   GnoAttribute = "ATTR_PREDEFINED"
-	ATTR_TYPE_VALUE   GnoAttribute = "ATTR_TYPE_VALUE"
-	ATTR_TYPEOF_VALUE GnoAttribute = "ATTR_TYPEOF_VALUE"
-	ATTR_IOTA         GnoAttribute = "ATTR_IOTA"
-	ATTR_LOCATIONED   GnoAttribute = "ATTR_LOCATIONED"
-	ATTR_INJECTED     GnoAttribute = "ATTR_INJECTED"
-)
-
 var rePkgName = regexp.MustCompile(`^[a-z][a-z0-9_]+$`)
 
 // TODO: consider length restrictions.

gnovm/pkg/gnolang/nodes_string.go

@@ -96,7 +96,20 @@
 }
 
 func (x NameExpr) String() string {
-	return fmt.Sprintf("%s<%s>", x.Name, x.Path.String())
+	switch x.Type {
+	case NameExprTypeNormal:
+		return fmt.Sprintf("%s<%s>", x.Name, x.Path.String())
+	case NameExprTypeDefine:
+		return fmt.Sprintf("%s<!%s>", x.Name, x.Path.String())
+	case NameExprTypeHeapDefine:
+		return fmt.Sprintf("%s<!~%s>", x.Name, x.Path.String())
+	case NameExprTypeHeapUse:
+		return fmt.Sprintf("%s<~%s>", x.Name, x.Path.String())
+	case NameExprTypeHeapClosure:
+		return fmt.Sprintf("%s<()~%s>", x.Name, x.Path.String())
+	default:
+		panic("unexpected NameExpr type")
+	}
 }
 
 func (x BasicLitExpr) String() string {
@@ -172,7 +185,11 @@
 }
 
 func (x FuncLitExpr) String() string {
-	return fmt.Sprintf("func %s{ %s }", x.Type, x.Body.String())
+	heapCaptures := ""
+	if len(x.HeapCaptures) > 0 {
+		heapCaptures = "<" + x.HeapCaptures.String() + ">"
+	}
+	return fmt.Sprintf("func %s{ %s }%s", x.Type, x.Body.String(), heapCaptures)
 }
 
 func (x KeyValueExpr) String() string {

gnovm/pkg/gnolang/op_assign.go

@@ -11,7 +11,7 @@ func (m *Machine) doOpDefine() {
 		// Get name and value of i'th term.
 		nx := s.Lhs[i].(*NameExpr)
 		// Finally, define (or assign if loop block).
-		ptr := lb.GetPointerTo(m.Store, nx.Path)
+		ptr := lb.GetPointerToMaybeHeapDefine(m.Store, nx)
 		// XXX HACK (until value persistence impl'd)
 		if m.ReadOnly {
 			if oo, ok := ptr.Base.(Object); ok {

gnovm/pkg/gnolang/op_call.go

@@ -57,6 +57,18 @@
 	// Create new block scope.
 	clo := fr.Func.GetClosure(m.Store)
 	b := m.Alloc.NewBlock(fr.Func.GetSource(m.Store), clo)
+
+	// Copy *FuncValue.Captures into block
+	// NOTE: addHeapCapture in preprocess ensures order.
+	if len(fv.Captures) != 0 {
+		if len(fv.Captures) > len(b.Values) {
+			panic("should not happen, length of captured variables must not exceed the number of values")
+		}
+		for i := 0; i < len(fv.Captures); i++ {
+			b.Values[len(b.Values)-len(fv.Captures)+i] = fv.Captures[i].Copy(m.Alloc)
+		}
+	}
+
 	m.PushBlock(b)
 	if fv.nativeBody == nil && fv.NativePkg != "" {
 		// native function, unmarshaled so doesn't have nativeBody yet
@@ -78,6 +90,7 @@
 			// Initialize return variables with default value.
 			numParams := len(ft.Params)
 			for i, rt := range ft.Results {
+				// results/parameters never are heap use/closure.
 				ptr := b.GetPointerToInt(nil, numParams+i)
 				dtv := defaultTypedValue(m.Alloc, rt.Type)
 				ptr.Assign2(m.Alloc, nil, nil, dtv, false)
@@ -287,6 +300,15 @@
 		// Create new block scope for defer.
 		clo := dfr.Func.GetClosure(m.Store)
 		b := m.Alloc.NewBlock(fv.GetSource(m.Store), clo)
+		// copy values from captures
+		if len(fv.Captures) != 0 {
+			if len(fv.Captures) > len(b.Values) {
+				panic("should not happen, length of captured variables must not exceed the number of values")
+			}
+			for i := 0; i < len(fv.Captures); i++ {
+				b.Values[len(b.Values)-len(fv.Captures)+i] = fv.Captures[i].Copy(m.Alloc)
+			}
+		}
 		m.PushBlock(b)
 		if fv.nativeBody == nil {
 			fbody := fv.GetBodyFromSource(m.Store)