Merge pull request #593 from goplus/xgopilot/claude/fix-forrange-scope-1771217831

fix: emit pre-range statements to outer scope in ForRange

Author: xushiwei

stmt.go

@@ -493,11 +493,12 @@ func (p *forStmt) End(cb *CodeBuilder, src ast.Node) {
 //
 // end
 type forRangeStmt struct {
-	names []string
-	stmt  *ast.RangeStmt
-	x     *internal.Elem
-	old   codeBlockCtx
-	kvt   []types.Type
+	names    []string
+	stmt     *ast.RangeStmt
+	x        *internal.Elem
+	old      codeBlockCtx
+	kvt      []types.Type
+	preStmts []ast.Stmt // statements emitted during range expression compilation
 
 	enumName string // XGo_Enum or Gop_Enum
 
@@ -506,6 +507,10 @@ type forRangeStmt struct {
 }
 
 func (p *forRangeStmt) RangeAssignThen(cb *CodeBuilder, pos token.Pos) {
+	// Extract statements emitted during range expression compilation (e.g., auto-generated
+	// type assertions like `_autoGo_1, _ := doc.(map[string]any)`). These were emitted to
+	// the for-range block scope but belong in the outer scope before the for statement.
+	p.preStmts = cb.clearBlockStmt()
 	if names := p.names; names != nil { // for k, v := range XXX {
 		var val ast.Expr
 		switch len(names) {
@@ -785,6 +790,11 @@ func (p *forRangeStmt) End(cb *CodeBuilder, src ast.Node) {
 	}
 	stmts, flows := cb.endBlockStmt(&p.old)
 	cb.current.flows |= (flows &^ (flowFlagBreak | flowFlagContinue))
+	// Emit pre-range statements (e.g., type assertions) to the outer scope
+	// before the for-range statement.
+	for _, s := range p.preStmts {
+		cb.emitStmt(s)
+	}
 	if n := p.udt; n == 0 {
 		if p.enumName != "" {
 			p.stmt.X = &ast.CallExpr{

xgo_test.go

@@ -1083,6 +1083,49 @@ func bar(v *foo.Foo6) {
 `)
 }
 
+// Test that pre-range statements are emitted to outer scope
+// Regression test for: goplus/xgo#2629
+func TestForRangePreStmts(t *testing.T) {
+	pkg := newMainPackage()
+	// Create a function that takes an interface{} parameter
+	v := pkg.NewParam(token.NoPos, "data", types.NewInterfaceType(nil, nil).Complete())
+
+	pkg.NewFunc(nil, "bar", types.NewTuple(v), nil, false).BodyStart(pkg).
+		// Start for-range and push the block scope
+		ForRange("k", "v").
+		// This simulates the scenario where type assertion statements are emitted
+		// during range expression compilation. We'll manually emit a statement
+		// to the current block (which is the for-range block scope) before
+		// calling RangeAssignThen.
+		DefineVarStart(token.NoPos, "_autoGo_1", "_").
+		Val(ctxRef(pkg, "data")).TypeAssert(types.NewMap(
+		types.Typ[types.String],
+		types.NewInterfaceType(nil, nil).Complete(),
+	), 2).
+		EndInit(1).
+		// Now call RangeAssignThen which should extract the DefineVar statement
+		// and save it as a pre-statement
+		VarVal("_autoGo_1").
+		RangeAssignThen(token.NoPos).
+		Val(pkg.Import("fmt").Ref("Println")).Val(ctxRef(pkg, "k")).Val(ctxRef(pkg, "v")).Call(2).EndStmt().
+		End().
+		End()
+
+	// The expected output should have the type assertion BEFORE the for-range loop,
+	// not inside it
+	domTest(t, pkg, `package main
+
+import "fmt"
+
+func bar(data interface{}) {
+	_autoGo_1, _ := data.(map[string]interface{})
+	for k, v := range _autoGo_1 {
+		fmt.Println(k, v)
+	}
+}
+`)
+}
+
 // ----------------------------------------------------------------------------
 
 func TestStaticMethod(t *testing.T) {