goscript 0.0.21 → 0.0.22

package/compiler/stmt-for.go

@@ -0,0 +1,178 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+
+	"github.com/pkg/errors"
+)
+
+// WriteStmtFor translates a Go `for` statement (`ast.ForStmt`) into a
+// TypeScript `for` loop.
+// The structure is `for (init_ts; cond_ts; post_ts) { body_ts }`.
+//   - The initialization part (`exp.Init`) is translated using `WriteStmtForInit`.
+//   - The condition part (`exp.Cond`) is translated using `WriteValueExpr`. If nil,
+//     the condition part in TypeScript is empty (resulting in an infinite loop
+//     unless broken out of).
+//   - The post-iteration part (`exp.Post`) is translated using `WriteStmtForPost`.
+//   - The loop body (`exp.Body`) is translated as a block statement using `WriteStmtBlock`.
+//
+// This function covers standard Go `for` loops (three-part loops, condition-only
+// loops, and infinite loops). `for...range` loops are handled by `WriteStmtRange`.
+func (c *GoToTSCompiler) WriteStmtFor(exp *ast.ForStmt) error {
+	c.tsw.WriteLiterally("for (")
+	if exp.Init != nil {
+		if err := c.WriteStmtForInit(exp.Init); err != nil { // Use WriteStmtForInit
+			return fmt.Errorf("failed to write for loop initialization: %w", err)
+		}
+	}
+	c.tsw.WriteLiterally("; ")
+	if exp.Cond != nil {
+		if err := c.WriteValueExpr(exp.Cond); err != nil { // Condition is a value
+			return fmt.Errorf("failed to write for loop condition: %w", err)
+		}
+	}
+	c.tsw.WriteLiterally("; ")
+	if exp.Post != nil {
+		if err := c.WriteStmtForPost(exp.Post); err != nil { // Use WriteStmtForPost
+			return fmt.Errorf("failed to write for loop post statement: %w", err)
+		}
+	}
+	c.tsw.WriteLiterally(") ")
+	if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+		return fmt.Errorf("failed to write for loop body: %w", err)
+	}
+	return nil
+}
+
+// WriteStmtForInit translates the initialization part of a Go `for` loop header
+// (e.g., `i := 0` or `i = 0` in `for i := 0; ...`) into its TypeScript equivalent.
+// - If `stmt` is an `ast.AssignStmt`:
+//   - For short variable declarations (`:=`) with multiple variables (e.g., `i, j := 0, 10`),
+//     it generates `let i = 0, j = 10`. Each LHS variable is paired with its
+//     corresponding RHS value; if RHS values are insufficient, remaining LHS
+//     variables are initialized with their zero value using `WriteZeroValue`.
+//   - For other assignments (single variable `:=`, or regular `=`), it uses
+//     `writeAssignmentCore`. If it's `:=`, `let` is prepended.
+//   - If `stmt` is an `ast.ExprStmt` (less common in `for` inits), it translates
+//     the expression using `WriteValueExpr`.
+//
+// Unhandled statement types in the init part result in a comment.
+func (c *GoToTSCompiler) WriteStmtForInit(stmt ast.Stmt) error {
+	switch s := stmt.(type) {
+	case *ast.AssignStmt:
+		// Handle assignment in init (e.g., i := 0 or i = 0)
+		// For TypeScript for-loop init, we need to handle multi-variable declarations differently
+		if s.Tok == token.DEFINE && len(s.Lhs) > 1 && len(s.Rhs) > 0 {
+			// For loop initialization with multiple variables (e.g., let i = 0, j = 10)
+			c.tsw.WriteLiterally("let ")
+
+			// Handle each LHS variable with its corresponding RHS value
+			for i, lhs := range s.Lhs {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+
+				// Write the LHS variable name
+				if err := c.WriteValueExpr(lhs); err != nil {
+					return err
+				}
+
+				// Write the corresponding RHS, or a default if not enough RHS values
+				c.tsw.WriteLiterally(" = ")
+				if i < len(s.Rhs) {
+					// If there's a corresponding RHS value
+					if err := c.WriteValueExpr(s.Rhs[i]); err != nil {
+						return err
+					}
+				} else {
+					// No corresponding RHS
+					return errors.Errorf("no corresponding rhs to lhs: %v", s)
+				}
+			}
+		} else {
+			// Regular single variable or assignment (not declaration)
+			if s.Tok == token.DEFINE {
+				c.tsw.WriteLiterally("let ")
+			}
+			// Use existing assignment core logic
+			if err := c.writeAssignmentCore(s.Lhs, s.Rhs, s.Tok, false); err != nil {
+				return err
+			}
+		}
+		return nil
+	case *ast.ExprStmt:
+		// Handle expression statement in init
+		return c.WriteValueExpr(s.X)
+	default:
+		return errors.Errorf("unhandled for loop init statement: %T", stmt)
+	}
+}
+
+// WriteStmtForPost translates the post-iteration part of a Go `for` loop header
+// (e.g., `i++` or `i, j = i+1, j-1` in `for ...; i++`) into its TypeScript
+// equivalent.
+// - If `stmt` is an `ast.IncDecStmt` (e.g., `i++`), it writes `i_ts++`.
+// - If `stmt` is an `ast.AssignStmt`:
+//   - For multiple variable assignments (e.g., `i, j = i+1, j-1`), it generates
+//     TypeScript array destructuring: `[i_ts, j_ts] = [i_ts+1, j_ts-1]`.
+//   - For single variable assignments, it uses `writeAssignmentCore`.
+//   - If `stmt` is an `ast.ExprStmt` (less common), it translates the expression
+//     using `WriteValueExpr`.
+//
+// Unhandled statement types in the post part result in a comment.
+func (c *GoToTSCompiler) WriteStmtForPost(stmt ast.Stmt) error {
+	switch s := stmt.(type) {
+	case *ast.IncDecStmt:
+		// Handle increment/decrement (e.g., 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
+	case *ast.AssignStmt:
+		// For multiple variable assignment in post like i, j = i+1, j-1
+		// we need to use destructuring in TypeScript like [i, j] = [i+1, j-1]
+		if len(s.Lhs) > 1 && len(s.Rhs) > 0 {
+			// Write LHS as array destructuring
+			c.tsw.WriteLiterally("[")
+			for i, lhs := range s.Lhs {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				if err := c.WriteValueExpr(lhs); err != nil {
+					return err
+				}
+			}
+			c.tsw.WriteLiterally("] = [")
+
+			// Write RHS as array
+			for i, rhs := range s.Rhs {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				if err := c.WriteValueExpr(rhs); err != nil {
+					return err
+				}
+			}
+			c.tsw.WriteLiterally("]")
+		} else {
+			// Regular single variable assignment
+			// No declaration handling needed in for loop post statements
+			if err := c.writeAssignmentCore(s.Lhs, s.Rhs, s.Tok, false); err != nil {
+				return err
+			}
+		}
+		return nil
+	case *ast.ExprStmt:
+		// Handle expression statement in post
+		return c.WriteValueExpr(s.X)
+	default:
+		return errors.Errorf("unhandled for loop post statement: %T", stmt)
+	}
+}

package/compiler/stmt-range.go

@@ -0,0 +1,237 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/types"
+
+	"github.com/pkg/errors"
+)
+
+// WriteStmtRange translates a Go `for...range` statement (`ast.RangeStmt`)
+// into an equivalent TypeScript loop. The translation depends on the type of
+// the expression being ranged over (`exp.X`), determined using `go/types` info.
+//
+//   - **Maps (`*types.Map`):**
+//     `for k, v := range myMap` becomes `for (const [k_ts, v_ts] of myMap_ts.entries()) { const k = k_ts; const v = v_ts; ...body... }`.
+//     If only `k` or `v` (or neither) is used, the corresponding TypeScript const declaration is adjusted.
+//
+//   - **Strings (`*types.Basic` with `IsString` info):**
+//     `for i, r := range myString` becomes:
+//     `const _runes = $.stringToRunes(myString_ts);`
+//     `for (let i_ts = 0; i_ts < _runes.length; i_ts++) { const r_ts = _runes[i_ts]; ...body... }`.
+//     The index variable `i_ts` uses the Go key variable name if provided (and not `_`).
+//     The rune variable `r_ts` uses the Go value variable name.
+//
+//   - **Integers (`*types.Basic` with `IsInteger` info, Go 1.22+):**
+//     `for i := range N` becomes `for (let i_ts = 0; i_ts < N_ts; i_ts++) { ...body... }`.
+//     `for i, v := range N` becomes `for (let i_ts = 0; i_ts < N_ts; i_ts++) { const v_ts = i_ts; ...body... }`.
+//
+// - **Arrays (`*types.Array`) and Slices (`*types.Slice`):**
+//   - If both key (index) and value are used (`for i, val := range arr`):
+//     `for (let i_ts = 0; i_ts < arr_ts.length; i_ts++) { const val_ts = arr_ts[i_ts]; ...body... }`.
+//   - If only the key (index) is used (`for i := range arr`):
+//     `for (let i_ts = 0; i_ts < arr_ts.length; i_ts++) { ...body... }`.
+//   - If only the value is used (`for _, val := range arr`):
+//     `for (const v_ts of arr_ts) { const val_ts = v_ts; ...body... }`.
+//   - If neither is used (e.g., `for range arr`), a simple index loop `for (let _i = 0; ...)` is generated.
+//     The index variable `i_ts` uses the Go key variable name if provided.
+//
+// Loop variables (`exp.Key`, `exp.Value`) are declared as `const` inside the loop
+// body if they are not blank identifiers (`_`). The loop body (`exp.Body`) is
+// translated using `WriteStmtBlock` (or `WriteStmt` for array/slice with key and value).
+// If the ranged type is not supported, a comment is written, and an error is returned.
+func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
+	// Get the type of the iterable expression
+	iterType := c.pkg.TypesInfo.TypeOf(exp.X)
+	underlying := iterType.Underlying()
+
+	// Handle map types
+	if _, ok := underlying.(*types.Map); ok {
+		// Use for-of with entries() for proper Map iteration
+		c.tsw.WriteLiterally("for (const [k, v] of ")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write range loop map expression: %w", err)
+		}
+		c.tsw.WriteLiterally(".entries()) {")
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+		// If a key variable is provided and is not blank, declare it as a constant
+		if exp.Key != nil {
+			if ident, ok := exp.Key.(*ast.Ident); ok && ident.Name != "_" {
+				c.tsw.WriteLiterally("const ")
+				c.WriteIdent(ident, false)
+				c.tsw.WriteLiterally(" = k")
+				c.tsw.WriteLine("")
+			}
+		}
+		// If a value variable is provided and is not blank, use the value from entries()
+		if exp.Value != nil {
+			if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+				c.tsw.WriteLiterally("const ")
+				c.WriteIdent(ident, false)
+				c.tsw.WriteLiterally(" = v")
+				c.tsw.WriteLine("")
+			}
+		}
+		// Write the loop body
+		if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+			return fmt.Errorf("failed to write range loop map body: %w", err)
+		}
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("}")
+		return nil
+	}
+
+	// Handle basic types (string, integer)
+	if basic, ok := underlying.(*types.Basic); ok {
+		if basic.Info()&types.IsString != 0 {
+			// Add a scope to avoid collision of _runes variable
+			c.tsw.WriteLine("{")
+			c.tsw.Indent(1)
+
+			// Convert the string to runes using $.stringToRunes
+			c.tsw.WriteLiterally("const _runes = $.stringToRunes(")
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return fmt.Errorf("failed to write range loop string conversion expression: %w", err)
+			}
+			c.tsw.WriteLiterally(")")
+			c.tsw.WriteLine("")
+
+			// 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
+				}
+			}
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < _runes.length; %s++) {", indexVarName, indexVarName, indexVarName)
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+			// Declare value if provided and not blank
+			if exp.Value != nil {
+				if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
+					c.tsw.WriteLiterally("const ")
+					c.WriteIdent(ident, false)
+					c.tsw.WriteLiterally(" = _runes[i]") // TODO: should be indexVarName?
+					c.tsw.WriteLine("")
+				}
+			}
+			if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+				return fmt.Errorf("failed to write range loop string body: %w", err)
+			}
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+
+			// outer }
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+			return nil
+		} else if basic.Info()&types.IsInteger != 0 {
+			// Handle ranging over an integer (Go 1.22+)
+			// 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
+				}
+			}
+
+			c.tsw.WriteLiterallyf("for (let %s = 0; %s < ", indexVarName, indexVarName)
+			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.Indent(1)
+			c.tsw.WriteLine("")
+
+			// The value variable is not allowed ranging over an integer.
+			if exp.Value != nil {
+				return errors.Errorf("ranging over an integer supports key variable only (not value variable): %v", exp)
+			}
+
+			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
+		}
+	}
+
+	// Handle array and slice types
+	_, isSlice := underlying.(*types.Slice)
+	_, isArray := underlying.(*types.Array)
+	if isArray || isSlice {
+		// 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)
+			if err := c.WriteValueExpr(exp.X); err != nil { // Write the expression for the iterable
+				return fmt.Errorf("failed to write range loop array/slice expression (key and value): %w", err)
+			}
+			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(" = ")
+				if err := c.WriteValueExpr(exp.X); err != nil {
+					return fmt.Errorf("failed to write range loop array/slice value expression: %w", err)
+				}
+				c.tsw.WriteLiterallyf("![%s]", indexVarName) // Use indexVarName with not-null assert
+				c.tsw.WriteLine("")
+			}
+			if err := c.WriteStmt(exp.Body); err != nil {
+				return fmt.Errorf("failed to write range loop 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 expression for the iterable
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return fmt.Errorf("failed to write expression for the iterable: %w", err)
+			}
+			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 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)
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return fmt.Errorf("failed to write range loop array/slice length expression (fallback): %w", err)
+			}
+			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 array/slice body (fallback): %w", err)
+			}
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+			return nil
+		}
+	}
+
+	return errors.Errorf("unsupported range loop type: %T for expression %v", underlying, exp)
+}