[WIP] feat: capture transient values in loop block for closures

examples/gno.land/p/demo/avl/z_0_filetest.gno

@@ -280,6 +280,7 @@ func main() {
 //                         "PkgPath": "gno.land/r/test"
 //                     }
 //                 },
+//                 "TransientLoopData": null,
 //                 "Type": {
 //                     "@type": "/gno.FuncType",
 //                     "Params": [],
@@ -316,6 +317,7 @@ func main() {
 //                         "PkgPath": "gno.land/r/test"
 //                     }
 //                 },
+//                 "TransientLoopData": null,
 //                 "Type": {
 //                     "@type": "/gno.FuncType",
 //                     "Params": [],

examples/gno.land/p/demo/avl/z_1_filetest.gno

@@ -304,6 +304,7 @@ func main() {
 //                         "PkgPath": "gno.land/r/test"
 //                     }
 //                 },
+//                 "TransientLoopData": null,
 //                 "Type": {
 //                     "@type": "/gno.FuncType",
 //                     "Params": [],
@@ -340,6 +341,7 @@ func main() {
 //                         "PkgPath": "gno.land/r/test"
 //                     }
 //                 },
+//                 "TransientLoopData": null,
 //                 "Type": {
 //                     "@type": "/gno.FuncType",
 //                     "Params": [],

gnovm/Makefile

@@ -60,6 +60,7 @@ _test.gnolang.native:;       go test tests/*.go -test.short -run "TestFilesNativ
 _test.gnolang.stdlibs:;      go test tests/*.go -test.short -run 'TestFiles$$/' $(GOTEST_FLAGS)
 _test.gnolang.native.sync:;  go test tests/*.go -test.short -run "TestFilesNative/" --update-golden-tests $(GOTEST_FLAGS)
 _test.gnolang.stdlibs.sync:; go test tests/*.go -test.short -run 'TestFiles$$/' --update-golden-tests $(GOTEST_FLAGS)
+_test.gnolang.debug:;      go test tests/*.go -test.short -run 'TestDebug$$/' --update-golden-tests $(GOTEST_FLAGS)
 
 ########################################
 # Code gen

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

@@ -68,6 +68,7 @@ func main() {
 //                         "PkgPath": "gno.land/r/x"
 //                     }
 //                 },
+//                 "TransientLoopData": null,
 //                 "Type": {
 //                     "@type": "/gno.FuncType",
 //                     "Params": [],

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

@@ -7,7 +7,7 @@ stderr '=== RUN   file/x_filetest.gno'
 stderr 'panic: fail on x_filetest.gno: diff:'
 stderr '--- Expected'
 stderr '\+\+\+ Actual'
-stderr '@@ -1 \+1,66 @@'
+stderr '@@ -1 \+1,67 @@'
 stderr '-xxx'
 stderr '\+switchrealm\["gno.land/r/x"\]'
 

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

@@ -83,6 +83,7 @@ func main() {
 //                         "PkgPath": "gno.land/r/x"
 //                     }
 //                 },
+//                 "TransientLoopData": null,
 //                 "Type": {
 //                     "@type": "/gno.FuncType",
 //                     "Params": [],

gnovm/pkg/gnolang/machine.go

@@ -1628,7 +1628,7 @@
 
 func (m *Machine) PushBlock(b *Block) {
 	if debug {
-		m.Println("+B")
+		m.Printf("+B: %v \n", b)
 	}
 	m.Blocks = append(m.Blocks, b)
 }

gnovm/pkg/gnolang/nodes.go

@@ -873,15 +873,17 @@ type SwitchClauseStmt struct {
 // NOTE: embedded in Block.
 type bodyStmt struct {
 	Attributes
-	Body                       // for non-loop stmts
-	BodyLen       int          // for for-continue
-	NextBodyIndex int          // init:-2, cond/elem:-1, body:0..., post:n
-	NumOps        int          // number of Ops, for goto
-	NumValues     int          // number of Values, for goto
-	NumExprs      int          // number of Exprs, for goto
-	NumStmts      int          // number of Stmts, for goto
-	Cond          Expr         // for ForStmt
-	Post          Stmt         // for ForStmt
+	Body                         // for non-loop stmts
+	BodyLen       int            // for for-continue
+	NextBodyIndex int            // init:-2, cond/elem:-1, body:0..., post:n
+	NumOps        int            // number of Ops, for goto
+	NumValues     int            // number of Values, for goto
+	NumExprs      int            // number of Exprs, for goto
+	NumStmts      int            // number of Stmts, for goto
+	Cond          Expr           // for ForStmt
+	Post          Stmt           // for ForStmt
+	LoopValuesBox *LoopValuesBox // a series of transient values of captured var generated as the iteration goes on
+	isLoop        bool
 	Active        Stmt         // for PopStmt()
 	Key           Expr         // for RangeStmt
 	Value         Expr         // for RangeStmt

gnovm/pkg/gnolang/op_assign.go

@@ -5,6 +5,7 @@ func (m *Machine) doOpDefine() {
 	// Define each value evaluated for Lhs.
 	// NOTE: PopValues() returns a slice in
 	// forward order, not the usual reverse.
+	// m.PopValue()
 	rvs := m.PopValues(len(s.Lhs))
 	lb := m.LastBlock()
 	for i := 0; i < len(s.Lhs); i++ {
@@ -30,6 +31,7 @@ func (m *Machine) doOpAssign() {
 	// NOTE: PopValues() returns a slice in
 	// forward order, not the usual reverse.
 	rvs := m.PopValues(len(s.Lhs))
+
 	for i := len(s.Lhs) - 1; 0 <= i; i-- {
 		// Pop lhs value and desired type.
 		lv := m.PopAsPointer(s.Lhs[i])

gnovm/pkg/gnolang/op_call.go

@@ -54,8 +54,44 @@
 	pts := ft.Params
 	numParams := len(pts)
 	isMethod := 0 // 1 if true
-	// Create new block scope.
-	clo := fr.Func.GetClosure(m.Store)
+
+	clo := fr.Func.GetClosure(m.Store) // this is "static"
+	// update block vars using captured vars
+	var loopBlock *Block             // target loop block with values to be updated
+	if fv.TransientLoopData != nil { // it captured a bundle of values
+		for i, loopData := range fv.TransientLoopData { // each LoopValuesBox is for a certain level of block
+			box := loopData.loopValuesBox
+			if box.isSealed {
+				for _, t := range box.transient { // unpack vars belong to a specific block
+					if debug {
+						for k, v := range t.values {
+							fmt.Printf("values[%d] is %v \n", k, v)
+						}
+					}
+					loopBlock = clo.GetBlockWithDepth(m.Store, t.nx.Path) // find target block using depth
+					// check if exists, should always be?
+					names := loopBlock.GetSource(m.Store).GetBlockNames()
+					var index int
+					var match bool
+					for l, n := range names {
+						if n == t.nx.Name {
+							index = l
+							match = true
+							break
+						}
+					}
+					if match {
+						// update values in context with previously captured.
+						loopBlock.UpdateValue(index, t.values[loopData.index])
+					}
+				}
+			} else { // not sealed will be tainted, indicates not sealed with values when loopBlock ends, it's not a closure.
+				fv.TransientLoopData[i].loopValuesBox.isTainted = true
+			}
+		}
+		fv.TransientLoopData = nil
+	}
+
 	b := m.Alloc.NewBlock(fr.Func.GetSource(m.Store), clo)
 	m.PushBlock(b)
 	if fv.nativeBody == nil && fv.NativePkg != "" {
@@ -67,6 +103,7 @@
 	}
 	if fv.nativeBody == nil {
 		fbody := fv.GetBodyFromSource(m.Store)
+		debug.Printf("fbody: %v \n", fbody)
 		if len(ft.Results) == 0 {
 			// Push final empty *ReturnStmt;
 			// TODO: transform in preprocessor instead to return only

gnovm/pkg/gnolang/op_eval.go

@@ -18,6 +18,7 @@ func (m *Machine) doOpEval() {
 		debug.Printf("EVAL: (%T) %v\n", x, x)
 		// fmt.Println(m.String())
 	}
+
 	// This case moved out of switch for performance.
 	// TODO: understand this better.
 	if nx, ok := x.(*NameExpr); ok {
@@ -307,7 +308,6 @@ func (m *Machine) doOpEval() {
 		m.PushOp(OpEval)
 	case *FuncLitExpr:
 		m.PushOp(OpFuncLit)
-		// evaluate func type
 		m.PushExpr(&x.Type)
 		m.PushOp(OpEval)
 	case *ConstExpr:

gnovm/pkg/gnolang/op_exec.go

@@ -43,6 +43,32 @@
 
 */
 
+func updateCapturedValue(m *Machine, lb *Block) {
+	if lb.GetBodyStmt().isLoop { // do we need this?
+		bs := lb.GetBodyStmt()
+		if bs.LoopValuesBox != nil && bs.LoopValuesBox.isFilled && !bs.LoopValuesBox.isTainted {
+			var isSealed bool
+			for i, tt := range bs.LoopValuesBox.transient {
+				nvp := lb.Source.GetPathForName(m.Store, tt.nx.Name)
+				ptr := m.LastBlock().GetPointerTo(m.Store, nvp)
+				tv := ptr.Deref()
+				// update context use previously recorded value
+				// inner loops iterates twice while outer loop iterates once.
+				// it's an alignment for the values of out loop block.
+				// TODO: hard to understand, more doc or e.g.
+				expandRatio := bs.LoopValuesBox.transient[i].cursor + 1 - len(bs.LoopValuesBox.transient[i].values) // 2 - 0
+				for j := 0; j < expandRatio; j++ {
+					bs.LoopValuesBox.transient[i].values = append(bs.LoopValuesBox.transient[i].values, tv)
+				}
+				isSealed = true
+			}
+			if isSealed {
+				bs.LoopValuesBox.isSealed = true // seal for this LoopValuesBox for closure execution.
+			}
+		}
+	}
+}
+
 //----------------------------------------
 // doOpExec
 //
@@ -85,6 +111,7 @@
 			return
 		}
 	case OpForLoop:
+		lb := m.LastBlock()
 		bs := m.LastBlock().GetBodyStmt()
 		// evaluate .Cond.
 		if bs.NextBodyIndex == -2 { // init
@@ -114,6 +141,7 @@
 			s = next
 			goto EXEC_SWITCH
 		} else if bs.NextBodyIndex == bs.BodyLen {
+			updateCapturedValue(m, lb)
 			// (queue to) go back.
 			if bs.Cond != nil {
 				m.PushExpr(bs.Cond)
@@ -206,6 +234,8 @@
 				s = next // switch on bs.Active
 				goto EXEC_SWITCH
 			} else if bs.NextBodyIndex == bs.BodyLen {
+				// update captured values
+				updateCapturedValue(m, m.LastBlock())
 				if bs.ListIndex < bs.ListLen-1 {
 					// set up next assign if needed.
 					switch bs.Op {
@@ -300,6 +330,7 @@
 				s = next // switch on bs.Active
 				goto EXEC_SWITCH
 			} else if bs.NextBodyIndex == bs.BodyLen {
+				updateCapturedValue(m, m.LastBlock())
 				if bs.StrIndex < bs.StrLen {
 					// set up next assign if needed.
 					switch bs.Op {
@@ -393,6 +424,7 @@
 				s = next // switch on bs.Active
 				goto EXEC_SWITCH
 			} else if bs.NextBodyIndex == bs.BodyLen {
+				updateCapturedValue(m, m.LastBlock())
 				nnext := bs.NextItem.Next
 				if nnext == nil {
 					// done with range.
@@ -501,6 +533,7 @@
 			NextBodyIndex: -2,
 			Cond:          cs.Cond,
 			Post:          cs.Post,
+			isLoop:        true,
 		}
 		m.PushBlock(b)
 		m.PushOp(OpForLoop)
@@ -587,6 +620,7 @@
 			Key:           cs.Key,
 			Value:         cs.Value,
 			Op:            cs.Op,
+			isLoop:        true,
 		}
 		m.PushBlock(b)
 		// TODO: replace with "cs.Op".