goscript 0.0.22 → 0.0.23

package/compiler/spec-value.go

@@ -1,10 +1,10 @@
 package compiler
 
 import (
+	"fmt"
 	"go/ast"
 	"go/token"
-
-	"github.com/pkg/errors"
+	"go/types"
 )
 
 // WriteValueSpec translates a Go value specification (`ast.ValueSpec`),
@@ -44,36 +44,67 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 		name := a.Names[0]
 		obj := c.pkg.TypesInfo.Defs[name]
 		if obj == nil {
-			return errors.Errorf("could not resolve type: %v", name)
+			return fmt.Errorf("could not resolve type: %v", name)
 		}
 
 		goType := obj.Type()
 		needsBox := c.analysis.NeedsBoxed(obj) // Check if address is taken
 
+		hasInitializer := len(a.Values) > 0
+		var initializerExpr ast.Expr
+		if hasInitializer {
+			initializerExpr = a.Values[0]
+		}
+
+		// Check if the initializer will result in an $.arrayToSlice call in TypeScript
+		isSliceConversion := false
+		if hasInitializer {
+			// Case 1: Direct call to $.arrayToSlice in Go source (less common for typical array literals)
+			if callExpr, isCallExpr := initializerExpr.(*ast.CallExpr); isCallExpr {
+				if selExpr, isSelExpr := callExpr.Fun.(*ast.SelectorExpr); isSelExpr {
+					if pkgIdent, isPkgIdent := selExpr.X.(*ast.Ident); isPkgIdent && pkgIdent.Name == "$" {
+						if selExpr.Sel.Name == "arrayToSlice" {
+							isSliceConversion = true
+						}
+					}
+				}
+			}
+
+			// Case 2: Go array or slice literal, which will be compiled to $.arrayToSlice
+			// We also check if the original Go type is actually a slice or array.
+			if !isSliceConversion { // Only check if not already determined by Case 1
+				if _, isCompositeLit := initializerExpr.(*ast.CompositeLit); isCompositeLit {
+					switch goType.Underlying().(type) {
+					case *types.Slice, *types.Array:
+						isSliceConversion = true
+					}
+				}
+			}
+		}
+
 		// Start declaration
 		c.tsw.WriteLiterally("let ")
 		c.tsw.WriteLiterally(name.Name)
-		c.tsw.WriteLiterally(": ")
 
-		// Write type annotation
-		if needsBox {
-			// If boxed, the variable holds Box<OriginalGoType>
-			c.tsw.WriteLiterally("$.Box<")
-			c.WriteGoType(goType) // Write the original Go type T
-			c.tsw.WriteLiterally(">")
-		} else {
-			// If not boxed, the variable holds the translated Go type directly
-			c.WriteGoType(goType)
+		if !isSliceConversion {
+			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
+				c.tsw.WriteLiterally(">")
+			} else {
+				// If not boxed, the variable holds the translated Go type directly
+				c.WriteGoType(goType, GoTypeContextGeneral)
+			}
 		}
 
 		// Write initializer
 		c.tsw.WriteLiterally(" = ")
-		hasInitializer := len(a.Values) > 0
-		var initializerExpr ast.Expr
-		if hasInitializer {
-			initializerExpr = a.Values[0]
 
-			// Special case for nil pointer to struct type: (*struct{})(nil)
+		// Special case for nil pointer to struct type: (*struct{})(nil)
+		if hasInitializer {
 			if callExpr, isCallExpr := initializerExpr.(*ast.CallExpr); isCallExpr {
 				if starExpr, isStarExpr := callExpr.Fun.(*ast.StarExpr); isStarExpr {
 					if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
@@ -81,6 +112,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 						if len(callExpr.Args) == 1 {
 							if nilIdent, isIdent := callExpr.Args[0].(*ast.Ident); isIdent && nilIdent.Name == "nil" {
 								c.tsw.WriteLiterally("null")
+								c.tsw.WriteLine("") // Ensure newline after null
 								return nil
 							}
 						}

package/compiler/spec.go

@@ -253,11 +253,20 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 		impName = a.Name.Name
 	}
 
-	importPath := translateGoPathToTypescriptPath(goPath)
+	// All Go package imports are mapped to the @goscript/ scope.
+	// The TypeScript compiler will resolve these using tsconfig paths to either
+	// handwritten versions (in .goscript-assets) or transpiled versions (in goscript).
+	var tsImportPath string
+	if goPath == "github.com/aperturerobotics/goscript/builtin" {
+		tsImportPath = "@goscript/builtin/builtin.js"
+	} else {
+		tsImportPath = "@goscript/" + goPath
+	}
+
 	c.analysis.Imports[impName] = &fileImport{
-		importPath: importPath,
+		importPath: tsImportPath,
 		importVars: make(map[string]struct{}),
 	}
 
-	c.tsw.WriteImport(impName, importPath+"/index.js")
+	c.tsw.WriteImport(impName, tsImportPath+"/index.js")
 }

package/compiler/stmt-assign.go

@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"strings"
 
 	"github.com/pkg/errors"
 )
@@ -130,7 +131,7 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 						// Add type annotation if we have type information
 						if i < len(resultTypes) {
 							c.tsw.WriteLiterally(": ")
-							c.WriteGoType(resultTypes[i].Type())
+							c.WriteGoType(resultTypes[i].Type(), GoTypeContextGeneral)
 						}
 
 						c.tsw.WriteLine("")
@@ -392,6 +393,8 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		if err := c.writeAssignmentCore(exp.Lhs, exp.Rhs, exp.Tok, false); err != nil {
 			return err
 		}
+		// Handle potential inline comment for multi-variable assignment
+		c.writeInlineComment(exp)
 		c.tsw.WriteLine("") // Add newline after the statement
 		return nil
 	}
@@ -402,6 +405,8 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 		if err := c.writeAssignmentCore(exp.Lhs, exp.Rhs, exp.Tok, addDeclaration); err != nil {
 			return err
 		}
+		// Handle potential inline comment for single assignment
+		c.writeInlineComment(exp)
 		c.tsw.WriteLine("") // Add newline after the statement
 		return nil
 	}
@@ -409,3 +414,26 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 	// Should not reach here if LHS/RHS counts are valid and handled
 	return fmt.Errorf("unhandled assignment case")
 }
+
+// writeInlineComment checks for and writes any inline comments associated with the given AST node.
+// It is intended to be called immediately after writing the main statement/expression.
+func (c *GoToTSCompiler) writeInlineComment(node ast.Node) {
+	if c.pkg == nil || c.pkg.Fset == nil || !node.End().IsValid() {
+		return
+	}
+
+	file := c.pkg.Fset.File(node.End())
+	if file == nil {
+		return
+	}
+
+	endLine := file.Line(node.End())
+	// Check comments associated *directly* with the node
+	for _, cg := range c.analysis.Cmap[node] {
+		if cg.Pos().IsValid() && file.Line(cg.Pos()) == endLine && cg.Pos() > node.End() {
+			commentText := strings.TrimSpace(strings.TrimPrefix(cg.Text(), "//"))
+			c.tsw.WriteLiterally(" // " + commentText)
+			return // Only write the first inline comment found
+		}
+	}
+}

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

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
+}