feat(gnovm): solution for correctly capturing loop externs

gnovm/pkg/gnolang/helpers.go

@@ -612,6 +612,12 @@ func Return(results ...Expr) *ReturnStmt {
 	}
 }
 
+func BlockS(body Body) *BlockStmt {
+	return &BlockStmt{
+		Body: body,
+	}
+}
+
 func Continue(label interface{}) *BranchStmt {
 	return &BranchStmt{
 		Op:    CONTINUE,
@@ -795,6 +801,17 @@ func SIf(cond bool, then_, else_ Stmt) Stmt {
 	}
 }
 
+func InjectStmts(lvs *CapturedLoopVariables) []Stmt {
+	stmts := []Stmt{}
+	for _, lv := range lvs.loopVars {
+		lhs := Nx(lv)
+		rhs := Nx(lv)
+		as := A(lhs, ":=", rhs)
+		stmts = append(stmts, as)
+	}
+	return stmts
+}
+
 // ----------------------------------------
 // chop functions
 

gnovm/pkg/gnolang/machine.go

@@ -228,7 +228,7 @@ func (m *Machine) PreprocessAllFilesAndSaveBlockNodes() {
 		PredefineFileSet(m.Store, pn, fset)
 		for _, fn := range fset.Files {
 			// Save Types to m.Store (while preprocessing).
-			fn = Preprocess(m.Store, pn, fn).(*FileNode)
+			fn = Preprocess(m.Store, pn, fn, PHASE_VARLOOP).(*FileNode)
 			// Save BlockNodes to m.Store.
 			SaveBlockNodes(m.Store, fn)
 		}
@@ -539,7 +539,7 @@ func (m *Machine) runFiles(fns ...*FileNode) {
 		// runtime package value via PrepareNewValues.  Then,
 		// non-constant var declarations and file-level imports
 		// are re-set in runDeclaration(,true).
-		fn = Preprocess(m.Store, pn, fn).(*FileNode)
+		fn = Preprocess(m.Store, pn, fn, PHASE_VARLOOP).(*FileNode)
 		if debug {
 			debug.Printf("PREPROCESSED FILE: %v\n", fn)
 		}
@@ -726,7 +726,7 @@ func (m *Machine) Eval(x Expr) []TypedValue {
 		// x already creates its own scope.
 	}
 	// Preprocess x.
-	x = Preprocess(m.Store, last, x).(Expr)
+	x = Preprocess(m.Store, last, x, PHASE_CORE).(Expr)
 	// Evaluate x.
 	start := m.NumValues
 	m.PushOp(OpHalt)
@@ -798,7 +798,7 @@ func (m *Machine) EvalStaticTypeOf(last BlockNode, x Expr) Type {
 
 func (m *Machine) RunStatement(s Stmt) {
 	sn := m.LastBlock().GetSource(m.Store)
-	s = Preprocess(m.Store, sn, s).(Stmt)
+	s = Preprocess(m.Store, sn, s, PHASE_CORE).(Stmt)
 	m.PushOp(OpHalt)
 	m.PushStmt(s)
 	m.PushOp(OpExec)
@@ -815,7 +815,7 @@ func (m *Machine) RunDeclaration(d Decl) {
 	// Preprocess input using package block.  There should only
 	// be one block right now, and it's a *PackageNode.
 	pn := m.LastBlock().GetSource(m.Store).(*PackageNode)
-	d = Preprocess(m.Store, pn, d).(Decl)
+	d = Preprocess(m.Store, pn, d, PHASE_CORE).(Decl)
 	// do not SaveBlockNodes(m.Store, d).
 	pn.PrepareNewValues(m.Package)
 	m.runDeclaration(d)

gnovm/pkg/gnolang/nodes.go

@@ -776,6 +776,7 @@ type ForStmt struct {
 	Cond Expr // condition; or nil
 	Post Stmt // post iteration (simple) statement; or nil
 	Body
+	LoopVars *CapturedLoopVariables
 }
 
 type GoStmt struct {
@@ -817,6 +818,7 @@ type RangeStmt struct {
 	IsMap      bool // if X is map type
 	IsString   bool // if X is string type
 	IsArrayPtr bool // if X is array-pointer type
+	LoopVars   *CapturedLoopVariables
 }
 
 type ReturnStmt struct {
@@ -870,6 +872,12 @@ type SwitchClauseStmt struct {
 // ----------------------------------------
 // bodyStmt (persistent)
 
+// loopVar of for/range-loop can be captured or not,
+// recored the captured ones.
+type CapturedLoopVariables struct {
+	loopVars []Name
+}
+
 // NOTE: embedded in Block.
 type bodyStmt struct {
 	Attributes
@@ -1403,7 +1411,7 @@ func (x *PackageNode) DefineNative(n Name, ps, rs FieldTypeExprs, native func(*M
 	}
 
 	fd := FuncD(n, ps, rs, nil)
-	fd = Preprocess(nil, x, fd).(*FuncDecl)
+	fd = Preprocess(nil, x, fd, PHASE_CORE).(*FuncDecl)
 	ft := evalStaticType(nil, x, &fd.Type).(*FuncType)
 	if debug {
 		if ft == nil {
@@ -1459,6 +1467,7 @@ type BlockNode interface {
 	GetNumNames() uint16
 	GetParentNode(Store) BlockNode
 	GetPathForName(Store, Name) ValuePath
+	GetLoopNodeForName(Store, Name) BlockNode
 	GetIsConst(Store, Name) bool
 	GetLocalIndex(Name) (uint16, bool)
 	GetValueRef(Store, Name) *TypedValue
@@ -1500,6 +1509,19 @@ func (sb *StaticBlock) revertToOld() {
 	sb.oldValues = nil
 }
 
+func (sb *StaticBlock) reset() {
+	sb.Block = Block{
+		Source: nil,
+		Values: nil,
+		Parent: nil,
+	}
+	sb.NumNames = 0
+	sb.Names = nil
+	sb.Consts = nil
+	sb.Externs = nil
+	return
+}
+
 // Implements BlockNode
 func (sb *StaticBlock) InitStaticBlock(source BlockNode, parent BlockNode) {
 	if sb.Names != nil || sb.Block.Source != nil {
@@ -1557,6 +1579,7 @@ func (sb *StaticBlock) GetBlockNames() (ns []Name) {
 }
 
 // Implements BlockNode.
+// NOTE: Extern names may also be local, if declared later.
 func (sb *StaticBlock) GetExternNames() (ns []Name) {
 	return sb.Externs // copy?
 }
@@ -1598,6 +1621,8 @@ func (sb *StaticBlock) GetPathForName(store Store, n Name) ValuePath {
 	}
 	// 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)
 	}
@@ -1626,6 +1651,43 @@ func (sb *StaticBlock) GetPathForName(store Store, n Name) ValuePath {
 	panic(fmt.Sprintf("name %s not declared", n))
 }
 
+// Get loop blockNode where a name is declared, return nil if not exist.
+func (sb *StaticBlock) GetLoopNodeForName(store Store, n Name) BlockNode {
+	if n == "_" {
+		return nil
+	}
+	parent := sb.GetParentNode(store)
+	path := parent.GetPathForName(store, n)
+	if path.Type != VPBlock {
+		return nil
+	}
+
+	// NOTE: path.Depth == 1 means it's in bn.
+	bn := sb.GetSource(store)
+	for i := 1; i <= int(path.Depth); i++ {
+		bn = bn.GetParentNode(store)
+	}
+
+	if !isLoopNode(store, bn) {
+		return nil
+	}
+
+	return bn
+}
+
+func isLoopNode(store Store, bn BlockNode) bool {
+	if bn != nil {
+		switch bn.(type) {
+		case *ForStmt:
+			return true
+		case *RangeStmt:
+			return true
+		default:
+		}
+	}
+	return false
+}
+
 // 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.