goscript 0.0.23 → 0.0.25

package/compiler/spec-value.go

@@ -12,13 +12,12 @@ import (
 // declarations.
 //
 // For single variable declarations (`var x T = val` or `var x = val` or `var x T`):
-//   - It determines if the variable `x` needs to be boxed (e.g., if its address is taken)
-//     using `c.analysis.NeedsBoxed(obj)`.
-//   - If boxed: `let x: $.Box<T_ts> = $.box(initializer_ts_or_zero_ts);`
-//     The type annotation is `$.Box<T_ts>`, and the initializer is wrapped in `$.box()`.
-//   - If not boxed: `let x: T_ts = initializer_ts_or_zero_ts;`
-//     The type annotation is `T_ts`. If the initializer is `&unboxedVar`, it becomes `$.box(unboxedVar_ts)`.
-//     If the RHS is a struct value, `.clone()` is applied to maintain Go's value semantics.
+//   - It determines if the variable `x` needs to be varrefed (e.g., if its address is taken)
+//     using `c.analysis.NeedsVarRef(obj)`.
+//   - If variable referenced: `let x: $.VarRef<T_ts> = $.varRef(initializer_ts_or_zero_ts);`
+//     The type annotation is `$.VarRef<T_ts>`, and the initializer is wrapped in `$.varRef()`.
+//   - If not variable referenced: `let x: T_ts = initializer_ts_or_zero_ts;`
+//     The type annotation is `T_ts`. If the initializer is `&unvarrefedVar`, it becomes `$.varRef(unvarrefedVar_ts)`.
 //   - If no initializer is provided, the TypeScript zero value (from `WriteZeroValueForType`)
 //     is used.
 //   - Type `T` (or `T_ts`) is obtained from `obj.Type()` and translated via `WriteGoType`.
@@ -48,7 +47,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 		}
 
 		goType := obj.Type()
-		needsBox := c.analysis.NeedsBoxed(obj) // Check if address is taken
+		needsVarRef := c.analysis.NeedsVarRef(obj) // Check if address is taken
 
 		hasInitializer := len(a.Values) > 0
 		var initializerExpr ast.Expr
@@ -86,17 +85,64 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 		c.tsw.WriteLiterally("let ")
 		c.tsw.WriteLiterally(name.Name)
 
-		if !isSliceConversion {
+		// Write type annotation if:
+		// 1. Not a slice conversion (normal case), OR
+		// 2. Is a slice conversion but needs varRefing (we need explicit type for $.varRef())
+		if !isSliceConversion || needsVarRef {
 			c.tsw.WriteLiterally(": ")
 			// Write type annotation
-			if needsBox {
-				// If boxed, the variable holds Box<OriginalGoType>
-				c.tsw.WriteLiterally("$.Box<")
-				c.WriteGoType(goType, GoTypeContextGeneral) // Write the original Go type T
+			if needsVarRef {
+				// If varrefed, the variable holds VarRef<OriginalGoType>
+				c.tsw.WriteLiterally("$.VarRef<")
+
+				// Special case: if this is a slice conversion from an array type,
+				// we should use the slice type instead of the array type
+				if isSliceConversion {
+					if arrayType, isArray := goType.Underlying().(*types.Array); isArray {
+						// Convert [N]T to $.Slice<T>
+						c.tsw.WriteLiterally("$.Slice<")
+						c.WriteGoType(arrayType.Elem(), GoTypeContextGeneral)
+						c.tsw.WriteLiterally(">")
+					} else {
+						// For slice types, write as-is (already $.Slice<T>)
+						c.WriteGoType(goType, GoTypeContextGeneral)
+					}
+				} else {
+						c.WriteGoType(goType, GoTypeContextGeneral) // Write the original Go type T
+				}
 				c.tsw.WriteLiterally(">")
 			} else {
-				// If not boxed, the variable holds the translated Go type directly
-				c.WriteGoType(goType, GoTypeContextGeneral)
+				// If not varrefed, the variable holds the translated Go type directly
+				// Custom logic for non-var-ref'd pointers to structs/interfaces.
+				if ptrType, isPtr := goType.(*types.Pointer); isPtr {
+					elemType := ptrType.Elem()
+					actualElemType := elemType.Underlying() // Get the true underlying type (e.g., struct, interface, basic)
+
+					isStruct := false
+					if _, ok := actualElemType.(*types.Struct); ok {
+						isStruct = true
+					}
+
+					isInterface := false
+					if _, ok := actualElemType.(*types.Interface); ok {
+						isInterface = true
+					}
+
+					if isStruct || isInterface {
+						// For non-var-ref'd pointers to structs or interfaces,
+						// the type is T | null, not $.VarRef<T> | null.
+						c.WriteGoType(elemType, GoTypeContextGeneral) // Write the element type itself (e.g., MyStruct)
+						c.tsw.WriteLiterally(" | null")
+					} else {
+						// For other pointer types (e.g., *int, *string, *[]int, **MyStruct),
+						// or pointers to types that are not structs/interfaces,
+						// use the standard pointer type translation.
+						c.WriteGoType(goType, GoTypeContextGeneral)
+					}
+				} else {
+					// Not a pointer type, write as is.
+					c.WriteGoType(goType, GoTypeContextGeneral)
+				}
 			}
 		}
 
@@ -121,41 +167,41 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 			}
 		}
 
-		if needsBox {
-			// Boxed variable: let v: Box<T> = $.box(init_or_zero);
-			c.tsw.WriteLiterally("$.box(")
+		if needsVarRef {
+			// VarRef variable: let v: VarRef<T> = $.varRef(init_or_zero);
+			c.tsw.WriteLiterally("$.varRef(")
 			if hasInitializer {
 				// Write the compiled initializer expression normally
 				if err := c.WriteValueExpr(initializerExpr); err != nil {
 					return err
 				}
 			} else {
-				// No initializer, box the zero value
+				// No initializer, varRef the zero value
 				c.WriteZeroValueForType(goType)
 			}
 			c.tsw.WriteLiterally(")")
 		} else {
-			// Unboxed variable: let v: T = init_or_zero;
+			// Unvarrefed variable: let v: T = init_or_zero;
 			if hasInitializer {
-				// Handle &v initializer specifically for unboxed variables
+				// Handle &v initializer specifically for unvarrefed variables
 				if unaryExpr, isUnary := initializerExpr.(*ast.UnaryExpr); isUnary && unaryExpr.Op == token.AND {
 					// Initializer is &v
-					// Check if v is boxed
-					needsBoxOperand := false
+					// Check if v is varrefed
+					needsVarRefOperand := false
 					unaryExprXIdent, ok := unaryExpr.X.(*ast.Ident)
 					if ok {
 						innerObj := c.pkg.TypesInfo.Uses[unaryExprXIdent]
-						needsBoxOperand = innerObj != nil && c.analysis.NeedsBoxed(innerObj)
+						needsVarRefOperand = innerObj != nil && c.analysis.NeedsVarRef(innerObj)
 					}
 
-					// If v is boxed, assign the box itself (v)
-					// If v is not boxed, assign $.box(v)
-					if needsBoxOperand {
+					// If v is varrefed, assign the varRef itself (v)
+					// If v is not varrefed, assign $.varRef(v)
+					if needsVarRefOperand {
 						// special handling: do not write .value here.
 						c.WriteIdent(unaryExprXIdent, false)
 					} else {
-						// &unboxedVar -> $.box(unboxedVar)
-						c.tsw.WriteLiterally("$.box(")
+						// &unvarrefedVar -> $.varRef(unvarrefedVar)
+						c.tsw.WriteLiterally("$.varRef(")
 						if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Write 'v'
 							return err
 						}

package/compiler/spec.go

@@ -78,9 +78,9 @@ func (c *GoToTSCompiler) writeGetterSetter(fieldName string, fieldType types.Typ
 	c.tsw.WriteLine("")
 }
 
-func (c *GoToTSCompiler) writeBoxedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
+func (c *GoToTSCompiler) writeVarRefedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
 	c.tsw.WriteLiterally(fieldName)
-	c.tsw.WriteLiterally(": $.box(")
+	c.tsw.WriteLiterally(": $.varRef(")
 
 	if isEmbedded {
 		if _, isPtr := fieldType.(*types.Pointer); isPtr {
@@ -112,7 +112,7 @@ func (c *GoToTSCompiler) writeBoxedFieldInitializer(fieldName string, fieldType
 
 func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
 	c.tsw.WriteLiterally(fieldName)
-	c.tsw.WriteLiterally(": $.box(")
+	c.tsw.WriteLiterally(": $.varRef(")
 
 	if isEmbedded {
 		isPointerToStruct := false
@@ -183,6 +183,12 @@ func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.Interfac
 	if err := c.WriteValueExpr(a.Name); err != nil {
 		return err
 	}
+
+	// Write type parameters if present (for generics)
+	if a.TypeParams != nil {
+		c.WriteTypeParameters(a.TypeParams)
+	}
+
 	c.tsw.WriteLiterally(" = ")
 	// Get the types.Interface from the ast.InterfaceType.
 	// For an interface definition like `type MyInterface interface { M() }`,

package/compiler/stmt-assign.go

@@ -33,7 +33,7 @@ import (
 //   - Uses `writeAssignmentCore` which handles:
 //   - Blank identifier `_` on LHS (evaluates RHS for side effects).
 //   - Assignment to dereferenced pointer `*p = val` -> `p_ts!.value = val_ts`.
-//   - Short declaration `x := y`: `let x = y_ts;`. If `x` is boxed, `let x: $.Box<T> = $.box(y_ts);`.
+//   - Short declaration `x := y`: `let x = y_ts;`. If `x` is variable referenced, `let x: $.VarRef<T> = $.varRef(y_ts);`.
 //   - Regular assignment `x = y`, including compound assignments like `x += y`.
 //   - Assignment to map index `m[k] = v` using `$.mapSet`.
 //   - Struct value assignment `s1 = s2` becomes `s1 = s2.clone()` if `s2` is a struct.
@@ -44,7 +44,7 @@ import (
 // The function ensures that the number of LHS and RHS expressions matches for
 // most cases, erroring if they don't, except for specifically handled patterns
 // like multi-assign from single call or discarded channel receive.
-// It correctly applies `let` for `:=` (define) tokens and handles boxing and
+// It correctly applies `let` for `:=` (define) tokens and handles varRefing and
 // cloning semantics based on type information and analysis.
 func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 	// writeMultiVarAssignFromCall handles multi-variable assignment from a single function call.
@@ -147,6 +147,10 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 				hasSelectors = true
 				break
 			}
+			if _, ok := lhsExpr.(*ast.StarExpr); ok {
+				hasSelectors = true
+				break
+			}
 		}
 
 		// If we have selector expressions, we need to ensure variables are initialized
@@ -176,6 +180,21 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 					if err := c.WriteValueExpr(selectorExpr); err != nil {
 						return fmt.Errorf("failed to write selector expression in LHS: %w", err)
 					}
+				} else if starExpr, ok := lhsExpr.(*ast.StarExpr); ok {
+					// Handle pointer dereference assignment: *p = value becomes p!.value = value
+					// Write the pointer variable directly without using WriteValueExpr
+					// because we don't want automatic .value access here
+					switch operand := starExpr.X.(type) {
+					case *ast.Ident:
+						// Write identifier without .value access
+						c.WriteIdent(operand, false)
+					default:
+						// For other expressions, use WriteValueExpr
+						if err := c.WriteValueExpr(starExpr.X); err != nil {
+							return fmt.Errorf("failed to write star expression X in LHS: %w", err)
+						}
+					}
+					c.tsw.WriteLiterally("!.value")
 				} else {
 					return errors.Errorf("unhandled LHS expression in assignment: %T", lhsExpr)
 				}
@@ -211,6 +230,21 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 				if err := c.WriteValueExpr(selectorExpr); err != nil {
 					return fmt.Errorf("failed to write selector expression in LHS: %w", err)
 				}
+			} else if starExpr, ok := lhsExpr.(*ast.StarExpr); ok {
+				// Handle pointer dereference in destructuring: *p becomes p!.value
+				// Write the pointer variable directly without using WriteValueExpr
+				// because we don't want automatic .value access here
+				switch operand := starExpr.X.(type) {
+				case *ast.Ident:
+					// Write identifier without .value access
+					c.WriteIdent(operand, false)
+				default:
+					// For other expressions, use WriteValueExpr
+					if err := c.WriteValueExpr(starExpr.X); err != nil {
+						return fmt.Errorf("failed to write star expression X in destructuring: %w", err)
+					}
+				}
+				c.tsw.WriteLiterally("!.value")
 			} else {
 				// Should not happen for valid Go code in this context, but handle defensively
 				return errors.Errorf("unhandled LHS expression in destructuring: %T", lhsExpr)

package/compiler/stmt-for.go

@@ -105,6 +105,17 @@ func (c *GoToTSCompiler) WriteStmtForInit(stmt ast.Stmt) error {
 	case *ast.ExprStmt:
 		// Handle expression statement in init
 		return c.WriteValueExpr(s.X)
+	case *ast.IncDecStmt:
+		// Handle increment/decrement in init (e.g., for i++; ...)
+		if err := c.WriteValueExpr(s.X); err != nil { // The expression (e.g., i)
+			return err
+		}
+		tokStr, ok := TokenToTs(s.Tok)
+		if !ok {
+			return errors.Errorf("unknown incdec token: %v", s.Tok)
+		}
+		c.tsw.WriteLiterally(tokStr) // The token (e.g., ++)
+		return nil
 	default:
 		return errors.Errorf("unhandled for loop init statement: %T", stmt)
 	}

package/compiler/stmt-range.go

@@ -146,13 +146,15 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 			if err := c.WriteValueExpr(exp.X); err != nil { // This is N
 				return fmt.Errorf("failed to write range loop integer expression: %w", err)
 			}
-			c.tsw.WriteLiterallyf("; %s++) ", indexVarName)
+			c.tsw.WriteLiterallyf("; %s++) {", indexVarName)
 
 			// write body
 			if err := c.WriteStmtBlock(exp.Body, false); err != nil {
 				return fmt.Errorf("failed to write range loop integer body: %w", err)
 			}
 
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
 			return nil
 		}
 	}
@@ -231,5 +233,316 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 		}
 	}
 
+	// Handle pointer to array/slice types
+	if ptrType, ok := underlying.(*types.Pointer); ok {
+		elem := ptrType.Elem().Underlying()
+		_, isSlice := elem.(*types.Slice)
+		_, isArray := elem.(*types.Array)
+		if isArray || isSlice {
+			// For pointer to array/slice, we need to dereference the pointer
+			// Check if the pointer variable itself is varrefed
+
+			// Determine the index variable name for the generated loop
+			indexVarName := "_i" // Default name
+			if exp.Key != nil {
+				if keyIdent, ok := exp.Key.(*ast.Ident); ok && keyIdent.Name != "_" {
+					indexVarName = keyIdent.Name
+				}
+			}
+			// If both key and value are provided, use an index loop and assign both
+			if exp.Key != nil && exp.Value != nil {
+				c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
+
+				// Write the pointer expression - use WriteIdent to avoid automatic .value access
+				// since we'll add !.value for pointer dereference
+				if ident, ok := exp.X.(*ast.Ident); ok {
+					c.WriteIdent(ident, false) // Don't add .value here
+				} else {
+					if err := c.WriteValueExpr(exp.X); err != nil {
+						return fmt.Errorf("failed to write range loop pointer array/slice expression (key and value): %w", err)
+					}
+				}
+				// Add dereference for the pointer: since we're ranging over a pointer to array/slice,
+				// we need to dereference to get to the array/slice
+				c.tsw.WriteLiterally("!.value")
+				c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
+				c.tsw.Indent(1)
+				c.tsw.WriteLine("")
+				// Declare value if not blank
+				if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+					c.tsw.WriteLiterally("const ")
+					c.WriteIdent(ident, false)
+					c.tsw.WriteLiterally(" = ")
+					// Write the pointer expression again for value access
+					if identX, ok := exp.X.(*ast.Ident); ok {
+						c.WriteIdent(identX, false) // Don't add .value here
+					} else {
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return fmt.Errorf("failed to write range loop pointer array/slice value expression: %w", err)
+						}
+					}
+					c.tsw.WriteLiterally("!.value![")
+					c.tsw.WriteLiterally(indexVarName)
+					c.tsw.WriteLiterally("]")
+					c.tsw.WriteLine("")
+				}
+				if err := c.WriteStmt(exp.Body); err != nil {
+					return fmt.Errorf("failed to write range loop pointer array/slice body (key and value): %w", err)
+				}
+				c.tsw.Indent(-1)
+				c.tsw.WriteLine("}")
+				return nil
+			} else if exp.Key != nil && exp.Value == nil { // Only key provided
+				c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
+				// Write the pointer expression - use WriteIdent to avoid automatic .value access
+				// since we'll add !.value for pointer dereference
+				if ident, ok := exp.X.(*ast.Ident); ok {
+					c.WriteIdent(ident, false) // Don't add .value here
+				} else {
+					if err := c.WriteValueExpr(exp.X); err != nil {
+						return fmt.Errorf("failed to write expression for the pointer iterable: %w", err)
+					}
+				}
+				c.tsw.WriteLiterally("!.value")
+				c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
+				c.tsw.Indent(1)
+				c.tsw.WriteLine("")
+				if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+					return fmt.Errorf("failed to write range loop pointer array/slice body (only key): %w", err)
+				}
+				c.tsw.Indent(-1)
+				c.tsw.WriteLine("}")
+				return nil
+			} else if exp.Key == nil && exp.Value != nil { // Only value provided
+				// I think this is impossible. See for_range_value_only test.
+				return errors.Errorf("unexpected value without key in for range expression: %v", exp)
+			} else {
+				// Fallback: simple index loop without declaring range variables, use _i
+				indexVarName := "_i"
+				c.tsw.WriteLiterallyf("for (let %s = 0; %s < $.len(", indexVarName, indexVarName)
+				// Write the pointer expression - use WriteIdent to avoid automatic .value access
+				// since we'll add !.value for pointer dereference
+				if ident, ok := exp.X.(*ast.Ident); ok {
+					c.WriteIdent(ident, false) // Don't add .value here
+				} else {
+					if err := c.WriteValueExpr(exp.X); err != nil {
+						return fmt.Errorf("failed to write range loop pointer array/slice length expression (fallback): %w", err)
+					}
+				}
+				c.tsw.WriteLiterally("!.value")
+				c.tsw.WriteLiterallyf("); %s++) {", indexVarName)
+				c.tsw.Indent(1)
+				c.tsw.WriteLine("")
+				if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+					return fmt.Errorf("failed to write range loop pointer array/slice body (fallback): %w", err)
+				}
+				c.tsw.Indent(-1)
+				c.tsw.WriteLine("}")
+				return nil
+			}
+		}
+	}
+
+	// Handle iterator function signatures
+	if sig, ok := underlying.(*types.Signature); ok {
+		// Check if this is an iterator function signature
+		// Iterator functions have the form: func(yield func(...) bool)
+		params := sig.Params()
+		if params.Len() == 1 {
+			yieldParam := params.At(0).Type()
+			if yieldSig, ok := yieldParam.Underlying().(*types.Signature); ok {
+				yieldParams := yieldSig.Params()
+				yieldResults := yieldSig.Results()
+
+				// Verify the yield function returns bool
+				if yieldResults.Len() == 1 {
+					if basic, ok := yieldResults.At(0).Type().Underlying().(*types.Basic); ok && basic.Kind() == types.Bool {
+						// This is an iterator function
+						// Generate TypeScript code that calls the iterator with a yield function
+
+						if yieldParams.Len() == 0 {
+							// func(func() bool) - iterator with no values
+							c.tsw.WriteLiterally(";(() => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							c.tsw.WriteLiterally("let shouldContinue = true")
+							c.tsw.WriteLine("")
+							if err := c.WriteValueExpr(exp.X); err != nil {
+								return fmt.Errorf("failed to write iterator expression: %w", err)
+							}
+							c.tsw.WriteLiterally("(() => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+								return fmt.Errorf("failed to write iterator body: %w", err)
+							}
+							c.tsw.WriteLiterally("return shouldContinue")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLiterally("})")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLine("})()")
+							return nil
+						} else if yieldParams.Len() == 1 {
+							// func(func(V) bool) - iterator with one value
+							c.tsw.WriteLiterally(";(() => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							c.tsw.WriteLiterally("let shouldContinue = true")
+							c.tsw.WriteLine("")
+							if err := c.WriteValueExpr(exp.X); err != nil {
+								return fmt.Errorf("failed to write iterator expression: %w", err)
+							}
+							c.tsw.WriteLiterally("((")
+							if exp.Value != nil {
+								if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+									c.WriteIdent(ident, false)
+								} else {
+									c.tsw.WriteLiterally("v")
+								}
+							} else {
+								c.tsw.WriteLiterally("v")
+							}
+							c.tsw.WriteLiterally(") => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+								return fmt.Errorf("failed to write iterator body: %w", err)
+							}
+							c.tsw.WriteLiterally("return shouldContinue")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLiterally("})")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLine("})()")
+							return nil
+						} else if yieldParams.Len() == 2 {
+							// func(func(K, V) bool) - iterator with key-value pairs
+							c.tsw.WriteLiterally(";(() => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							c.tsw.WriteLiterally("let shouldContinue = true")
+							c.tsw.WriteLine("")
+							if err := c.WriteValueExpr(exp.X); err != nil {
+								return fmt.Errorf("failed to write iterator expression: %w", err)
+							}
+							c.tsw.WriteLiterally("((")
+							if exp.Key != nil {
+								if ident, ok := exp.Key.(*ast.Ident); ok && ident.Name != "_" {
+									c.WriteIdent(ident, false)
+								} else {
+									c.tsw.WriteLiterally("k")
+								}
+							} else {
+								c.tsw.WriteLiterally("k")
+							}
+							c.tsw.WriteLiterally(", ")
+							if exp.Value != nil {
+								if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+									c.WriteIdent(ident, false)
+								} else {
+									c.tsw.WriteLiterally("v")
+								}
+							} else {
+								c.tsw.WriteLiterally("v")
+							}
+							c.tsw.WriteLiterally(") => {")
+							c.tsw.Indent(1)
+							c.tsw.WriteLine("")
+							if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+								return fmt.Errorf("failed to write iterator body: %w", err)
+							}
+							c.tsw.WriteLiterally("return shouldContinue")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLiterally("})")
+							c.tsw.WriteLine("")
+							c.tsw.Indent(-1)
+							c.tsw.WriteLine("})()")
+							return nil
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Handle interface types that may represent iterators
+	if _, ok := underlying.(*types.Interface); ok {
+		// For interface types, we need to treat them as potential iterators
+		// In Go 1.23+, interfaces can represent iterator functions
+		// We'll attempt to call them as iterator functions with a yield callback
+
+		// Try to determine the iterator pattern based on context or assume key-value pairs
+		// Since we can't easily determine the exact signature from just the interface,
+		// we'll generate a generic iterator call pattern
+
+		c.tsw.WriteLiterally(";(() => {")
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+		c.tsw.WriteLiterally("let shouldContinue = true")
+		c.tsw.WriteLine("")
+
+		// Call the interface as an iterator function
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write interface iterator expression: %w", err)
+		}
+
+		// Generate the appropriate yield function based on the range variables
+		if exp.Key != nil && exp.Value != nil {
+			// Key-value iterator
+			c.tsw.WriteLiterally("((")
+			if ident, ok := exp.Key.(*ast.Ident); ok && ident.Name != "_" {
+				c.WriteIdent(ident, false)
+			} else {
+				c.tsw.WriteLiterally("k")
+			}
+			c.tsw.WriteLiterally(", ")
+			if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+				c.WriteIdent(ident, false)
+			} else {
+				c.tsw.WriteLiterally("v")
+			}
+			c.tsw.WriteLiterally(") => {")
+		} else if exp.Value != nil {
+			// Value-only iterator
+			c.tsw.WriteLiterally("((")
+			if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+				c.WriteIdent(ident, false)
+			} else {
+				c.tsw.WriteLiterally("v")
+			}
+			c.tsw.WriteLiterally(") => {")
+		} else if exp.Key != nil {
+			// Key-only iterator (treating it as value for single-param iterator)
+			c.tsw.WriteLiterally("((")
+			if ident, ok := exp.Key.(*ast.Ident); ok && ident.Name != "_" {
+				c.WriteIdent(ident, false)
+			} else {
+				c.tsw.WriteLiterally("k")
+			}
+			c.tsw.WriteLiterally(") => {")
+		} else {
+			// No variables iterator
+			c.tsw.WriteLiterally("(() => {")
+		}
+
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+		if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+			return fmt.Errorf("failed to write interface iterator body: %w", err)
+		}
+		c.tsw.WriteLiterally("return shouldContinue")
+		c.tsw.WriteLine("")
+		c.tsw.Indent(-1)
+		c.tsw.WriteLiterally("})")
+		c.tsw.WriteLine("")
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("})()")
+		return nil
+	}
+
 	return errors.Errorf("unsupported range loop type: %T for expression %v", underlying, exp)
 }