goscript 0.0.22 → 0.0.24

package/compiler/stmt-range.go

@@ -128,6 +128,11 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 			c.tsw.WriteLine("}")
 			return nil
 		} else if basic.Info()&types.IsInteger != 0 {
+			// 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)
+			}
+
 			// Handle ranging over an integer (Go 1.22+)
 			// Determine the index variable name for the generated loop
 			indexVarName := "_i" // Default name
@@ -141,20 +146,13 @@ 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.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)
-			}
+			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
 		}
 	}
@@ -164,7 +162,7 @@ func (c *GoToTSCompiler) WriteStmtRange(exp *ast.RangeStmt) error {
 	_, isArray := underlying.(*types.Array)
 	if isArray || isSlice {
 		// Determine the index variable name for the generated loop
-		indexVarName := "i" // Default name
+		indexVarName := "_i" // Default name
 		if exp.Key != nil {
 			if keyIdent, ok := exp.Key.(*ast.Ident); ok && keyIdent.Name != "_" {
 				indexVarName = keyIdent.Name
@@ -233,5 +231,115 @@ 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
+			}
+		}
+	}
+
 	return errors.Errorf("unsupported range loop type: %T for expression %v", underlying, exp)
 }

package/compiler/stmt-select.go

@@ -0,0 +1,211 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+
+	"github.com/pkg/errors"
+)
+
+// WriteStmtSelect translates a Go `select` statement into an asynchronous
+// TypeScript operation using the `$.selectStatement` runtime helper.
+// Go's `select` provides non-deterministic choice over channel operations.
+// This is emulated by constructing an array of `SelectCase` objects, one for
+// each `case` in the Go `select`, and passing it to `$.selectStatement`.
+//
+// Each `SelectCase` object includes:
+//   - `id`: A unique identifier for the case.
+//   - `isSend`: `true` for send operations (`case ch <- val:`), `false` for receives.
+//   - `channel`: The TypeScript channel object.
+//   - `value` (for sends): The value being sent.
+//   - `onSelected: async (result) => { ... }`: A callback executed when this case
+//     is chosen. `result` contains `{ value, ok }` for receives.
+//   - Inside `onSelected`, assignments for receive operations (e.g., `v := <-ch`,
+//     `v, ok := <-ch`) are handled by declaring/assigning variables from `result.value`
+//     and `result.ok`.
+//   - The original Go case body is then translated within this callback.
+//
+// A `default` case in Go `select` is translated to a `SelectCase` with `id: -1`
+// and its body in the `onSelected` handler. The `$.selectStatement` helper
+// is informed if a default case exists.
+// The entire `$.selectStatement(...)` call is `await`ed because channel
+// operations are asynchronous in the TypeScript model.
+func (c *GoToTSCompiler) WriteStmtSelect(exp *ast.SelectStmt) error {
+	// This is our implementation of the select statement, which will use Promise.race
+	// to achieve the same semantics as Go's select statement.
+
+	// Variable to track whether we have a default case
+	hasDefault := false
+
+	// Start the selectStatement call and the array literal
+	c.tsw.WriteLiterally("await $.selectStatement(")
+	c.tsw.WriteLine("[") // Put bracket on new line
+	c.tsw.Indent(1)
+
+	// For each case clause, generate a SelectCase object directly into the array literal
+	for i, stmt := range exp.Body.List {
+		if commClause, ok := stmt.(*ast.CommClause); ok {
+			if commClause.Comm == nil {
+				// This is a default case
+				hasDefault = true
+				// Add a SelectCase object for the default case with a special ID
+				c.tsw.WriteLiterally("{") // Start object literal
+				c.tsw.Indent(1)
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("id: -1,") // Special ID for default case
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("isSend: false,") // Default case is neither send nor receive, but needs a value
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("channel: null,") // No channel for default case
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("onSelected: async (result) => {") // Mark as async because case body might contain await
+				c.tsw.Indent(1)
+				c.tsw.WriteLine("")
+				// Write the case body
+				for _, bodyStmt := range commClause.Body {
+					if err := c.WriteStmt(bodyStmt); err != nil {
+						return fmt.Errorf("failed to write statement in select default case body (onSelected): %w", err)
+					}
+				}
+				c.tsw.Indent(-1)
+				c.tsw.WriteLine("}") // Close onSelected handler
+				c.tsw.Indent(-1)
+				c.tsw.WriteLiterally("},") // Close SelectCase object and add comma
+				c.tsw.WriteLine("")
+
+				continue
+			}
+
+			// Generate a unique ID for this case
+			caseID := i
+
+			// Start writing the SelectCase object
+			c.tsw.WriteLiterally("{") // Start object literal
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+			c.tsw.WriteLiterallyf("id: %d,", caseID)
+			c.tsw.WriteLine("")
+
+			// Handle different types of comm statements
+			switch comm := commClause.Comm.(type) {
+			case *ast.AssignStmt:
+				// This is a receive operation with assignment: case v := <-ch: or case v, ok := <-ch:
+				if len(comm.Rhs) == 1 {
+					if unaryExpr, ok := comm.Rhs[0].(*ast.UnaryExpr); ok && unaryExpr.Op == token.ARROW {
+						// It's a receive operation
+						c.tsw.WriteLiterally("isSend: false,")
+						c.tsw.WriteLine("")
+						c.tsw.WriteLiterally("channel: ")
+						if err := c.WriteValueExpr(unaryExpr.X); err != nil { // The channel expression
+							return fmt.Errorf("failed to write channel expression in select receive case: %w", err)
+						}
+						c.tsw.WriteLiterally(",")
+						c.tsw.WriteLine("")
+					} else {
+						c.tsw.WriteCommentLinef("unhandled RHS in select assignment case: %T", comm.Rhs[0])
+					}
+				} else {
+					c.tsw.WriteCommentLinef("unhandled RHS count in select assignment case: %d", len(comm.Rhs))
+				}
+			case *ast.ExprStmt:
+				// This is a simple receive: case <-ch:
+				if unaryExpr, ok := comm.X.(*ast.UnaryExpr); ok && unaryExpr.Op == token.ARROW {
+					c.tsw.WriteLiterally("isSend: false,")
+					c.tsw.WriteLine("")
+					c.tsw.WriteLiterally("channel: ")
+					if err := c.WriteValueExpr(unaryExpr.X); err != nil { // The channel expression
+						return fmt.Errorf("failed to write channel expression in select receive case: %w", err)
+					}
+					c.tsw.WriteLiterally(",")
+					c.tsw.WriteLine("")
+				} else {
+					c.tsw.WriteCommentLinef("unhandled expression in select case: %T", comm.X)
+				}
+			case *ast.SendStmt:
+				// This is a send operation: case ch <- v:
+				c.tsw.WriteLiterally("isSend: true,")
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("channel: ")
+				if err := c.WriteValueExpr(comm.Chan); err != nil { // The channel expression
+					return fmt.Errorf("failed to write channel expression in select send case: %w", err)
+				}
+				c.tsw.WriteLiterally(",")
+				c.tsw.WriteLine("")
+				c.tsw.WriteLiterally("value: ")
+				if err := c.WriteValueExpr(comm.Value); err != nil { // The value expression
+					return fmt.Errorf("failed to write value expression in select send case: %w", err)
+				}
+				c.tsw.WriteLiterally(",")
+				c.tsw.WriteLine("")
+			default:
+				c.tsw.WriteCommentLinef("unhandled comm statement in select case: %T", comm)
+			}
+
+			// Add the onSelected handler to execute the case body after the select resolves
+			c.tsw.WriteLiterally("onSelected: async (result) => {") // Mark as async because case body might contain await
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+
+			// Handle assignment for channel receives if needed (inside the onSelected handler)
+			if assignStmt, ok := commClause.Comm.(*ast.AssignStmt); ok {
+				// This is a receive operation with assignment
+				if len(assignStmt.Lhs) == 1 {
+					// Simple receive: case v := <-ch:
+					valIdent, ok := assignStmt.Lhs[0].(*ast.Ident)
+					if ok && valIdent.Name != "_" { // Check for blank identifier
+						c.tsw.WriteLiterally("const ")
+						c.WriteIdent(valIdent, false)
+						c.tsw.WriteLiterally(" = result.value")
+						c.tsw.WriteLine("")
+					}
+				} else if len(assignStmt.Lhs) == 2 {
+					// Receive with ok: case v, ok := <-ch:
+					valIdent, valOk := assignStmt.Lhs[0].(*ast.Ident)
+					okIdent, okOk := assignStmt.Lhs[1].(*ast.Ident)
+
+					if valOk && valIdent.Name != "_" {
+						c.tsw.WriteLiterally("const ")
+						c.WriteIdent(valIdent, false)
+						c.tsw.WriteLiterally(" = result.value")
+						c.tsw.WriteLine("")
+					}
+
+					if okOk && okIdent.Name != "_" {
+						c.tsw.WriteLiterally("const ")
+						c.WriteIdent(okIdent, false)
+						c.tsw.WriteLiterally(" = result.ok")
+						c.tsw.WriteLine("")
+					}
+				}
+			}
+			// Note: Simple receive (case <-ch:) and send (case ch <- v:) don't require assignment here,
+			// as the operation was already performed by selectReceive/selectSend and the result is in 'result'.
+
+			// Write the case body
+			for _, bodyStmt := range commClause.Body {
+				if err := c.WriteStmt(bodyStmt); err != nil {
+					return fmt.Errorf("failed to write statement in select case body (onSelected): %w", err)
+				}
+			}
+
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}") // Close onSelected handler
+			c.tsw.Indent(-1)
+			c.tsw.WriteLiterally("},") // Close SelectCase object and add comma
+			c.tsw.WriteLine("")
+
+		} else {
+			return errors.Errorf("unknown statement in select body: %T", stmt)
+		}
+	}
+
+	// Close the array literal and the selectStatement call
+	c.tsw.Indent(-1)
+	c.tsw.WriteLiterally("], ")
+	c.tsw.WriteLiterallyf("%t", hasDefault)
+	c.tsw.WriteLiterally(")")
+	c.tsw.WriteLine("")
+
+	return nil
+}

package/compiler/stmt-type-switch.go

@@ -0,0 +1,147 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+
+	"github.com/pkg/errors"
+)
+
+// WriteStmtTypeSwitch translates a Go `type switch` statement (`ast.TypeSwitchStmt`)
+// into its TypeScript equivalent using the `$.typeSwitch` helper.
+func (c *GoToTSCompiler) WriteStmtTypeSwitch(stmt *ast.TypeSwitchStmt) error {
+	// Outer block for scoping Init variable
+	if stmt.Init != nil {
+		c.tsw.WriteLine("{")
+		c.tsw.Indent(1)
+		if err := c.WriteStmt(stmt.Init); err != nil {
+			return fmt.Errorf("failed to write type switch init statement: %w", err)
+		}
+	}
+
+	// Extract the subject expression and case variable identifier
+	var subjectExpr ast.Expr
+	var caseVarIdent *ast.Ident // The variable in 'v := x.(type)'
+
+	switch assignNode := stmt.Assign.(type) {
+	case *ast.AssignStmt: // v := x.(type)
+		if len(assignNode.Lhs) != 1 || len(assignNode.Rhs) != 1 {
+			return errors.Errorf("TypeSwitchStmt AssignStmt: expected 1 LHS and 1 RHS, got %d and %d", len(assignNode.Lhs), len(assignNode.Rhs))
+		}
+		ident, ok := assignNode.Lhs[0].(*ast.Ident)
+		if !ok {
+			return errors.Errorf("TypeSwitchStmt AssignStmt LHS is not *ast.Ident: %T", assignNode.Lhs[0])
+		}
+		caseVarIdent = ident
+		typeAssert, ok := assignNode.Rhs[0].(*ast.TypeAssertExpr)
+		if !ok {
+			return errors.Errorf("TypeSwitchStmt AssignStmt RHS is not *ast.TypeAssertExpr: %T", assignNode.Rhs[0])
+		}
+		if typeAssert.Type != nil {
+			return errors.Errorf("TypeSwitchStmt AssignStmt TypeAssertExpr.Type is not nil")
+		}
+		subjectExpr = typeAssert.X
+	case *ast.ExprStmt: // x.(type)
+		typeAssert, ok := assignNode.X.(*ast.TypeAssertExpr)
+		if !ok {
+			return errors.Errorf("TypeSwitchStmt ExprStmt.X is not *ast.TypeAssertExpr: %T", assignNode.X)
+		}
+		if typeAssert.Type != nil {
+			return errors.Errorf("TypeSwitchStmt ExprStmt TypeAssertExpr.Type is not nil")
+		}
+		subjectExpr = typeAssert.X
+	default:
+		return errors.Errorf("unknown Assign type in TypeSwitchStmt: %T", stmt.Assign)
+	}
+
+	// Build the array of case configurations for $.typeSwitch
+	c.tsw.WriteLiterally("$.typeSwitch(")
+	if err := c.WriteValueExpr(subjectExpr); err != nil {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("} // End TypeSwitchStmt due to error in subject")
+		return fmt.Errorf("failed to write subject expression in type switch: %w", err)
+	}
+
+	// case list
+	c.tsw.WriteLiterally(", [")
+
+	stmtBodyList := stmt.Body.List
+	var defaultCaseBody []ast.Stmt
+
+	for i, caseClauseStmt := range stmtBodyList {
+		caseClause, ok := caseClauseStmt.(*ast.CaseClause)
+		if !ok {
+			return errors.Errorf("unexpected statement in TypeSwitchStmt Body: not *ast.CaseClause but %T", caseClauseStmt)
+		}
+
+		if len(caseClause.List) == 0 { // Default case
+			defaultCaseBody = caseClause.Body
+			continue // Process default case after type cases
+		}
+
+		// Type case(s)
+		if i != 0 {
+			c.tsw.WriteLiterally(",")
+			c.tsw.WriteLine("")
+		}
+
+		c.tsw.WriteLiterally("{ types: [")
+		for j, typeExpr := range caseClause.List {
+			if j > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.writeTypeDescription(typeExpr) // Descriptor for $.is or $.typeAssert
+		}
+		c.tsw.WriteLiterally("], body: (")
+
+		// Add case variable if it exists and is not '_'
+		if caseVarIdent != nil && caseVarIdent.Name != "_" {
+			c.WriteIdent(caseVarIdent, false) // isDeclaration = false for the parameter
+			// Note: TypeScript type inference should handle the parameter type based on the case type(s)
+		}
+
+		c.tsw.WriteLiterally(") => {")
+
+		caseClauseBody := caseClause.Body
+		if len(caseClauseBody) != 0 {
+			c.tsw.Indent(1)
+			c.tsw.WriteLine("")
+		}
+
+		for _, bodyStmt := range caseClauseBody {
+			if err := c.WriteStmt(bodyStmt); err != nil {
+				return fmt.Errorf("failed to write statement in type switch case body: %w", err)
+			}
+		}
+
+		if len(caseClauseBody) != 0 {
+			c.tsw.Indent(-1)
+		}
+		c.tsw.WriteLiterally("}") // Close case body function
+		c.tsw.WriteLiterally("}") // Close case object
+	}
+
+	c.tsw.WriteLiterally("]") // Close cases array
+
+	// Add default case function if it exists
+	if len(defaultCaseBody) != 0 {
+		c.tsw.WriteLiterally(", () => {")
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+		for _, bodyStmt := range defaultCaseBody {
+			if err := c.WriteStmt(bodyStmt); err != nil {
+				return fmt.Errorf("failed to write statement in type switch default case body: %w", err)
+			}
+		}
+		c.tsw.Indent(-1)
+		c.tsw.WriteLiterally("}") // Close default case function
+	}
+
+	c.tsw.WriteLine(")") // Close $.typeSwitch call
+	if stmt.Init != nil {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("}") // Close outer block
+	}
+
+	return nil
+}