goscript 0.0.22 → 0.0.24

package/compiler/stmt.go

@@ -28,12 +28,13 @@ import (
 //   - Go statements (`ast.GoStmt`): `WriteStmtGo`.
 //   - Select statements (`ast.SelectStmt`): `WriteStmtSelect`.
 //   - Branch statements (`ast.BranchStmt`): `WriteStmtBranch`.
+//   - Type switch statements (`ast.TypeSwitchStmt`): `WriteStmtTypeSwitch`.
+//   - Labeled statements (`ast.LabeledStmt`): `WriteStmtLabeled`.
 //
 // If an unknown statement type is encountered, it returns an error.
 func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
 	switch exp := a.(type) {
 	case *ast.BlockStmt:
-		// WriteStmtBlock does not currently return an error, assuming it's safe for now.
 		if err := c.WriteStmtBlock(exp, false); err != nil {
 			return fmt.Errorf("failed to write block statement: %w", err)
 		}
@@ -73,7 +74,6 @@ func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
 			return fmt.Errorf("failed to write declaration statement: %w", err)
 		}
 	case *ast.ForStmt:
-		// WriteStmtFor does not currently return an error, assuming it's safe for now.
 		if err := c.WriteStmtFor(exp); err != nil {
 			return fmt.Errorf("failed to write for statement: %w", err)
 		}
@@ -83,7 +83,6 @@ func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
 			return fmt.Errorf("failed to write range statement: %w", err)
 		}
 	case *ast.SwitchStmt:
-		// WriteStmtSwitch does not currently return an error, assuming it's safe for now.
 		if err := c.WriteStmtSwitch(exp); err != nil {
 			return fmt.Errorf("failed to write switch statement: %w", err)
 		}
@@ -108,8 +107,16 @@ func (c *GoToTSCompiler) WriteStmt(a ast.Stmt) error {
 		if err := c.WriteStmtBranch(exp); err != nil {
 			return fmt.Errorf("failed to write branch statement: %w", err)
 		}
+	case *ast.TypeSwitchStmt:
+		if err := c.WriteStmtTypeSwitch(exp); err != nil {
+			return fmt.Errorf("failed to write type switch statement: %w", err)
+		}
+	case *ast.LabeledStmt:
+		if err := c.WriteStmtLabeled(exp); err != nil {
+			return fmt.Errorf("failed to write labeled statement: %w", err)
+		}
 	default:
-		return errors.Errorf("unknown statement: %s\n", a)
+		return errors.Errorf("unknown statement: %#v\n", a)
 	}
 	return nil
 }
@@ -172,17 +179,17 @@ func (c *GoToTSCompiler) WriteStmtBranch(stmt *ast.BranchStmt) error {
 }
 
 // WriteStmtGo translates a Go statement (`ast.GoStmt`) into its TypeScript equivalent.
-// It handles `go func(){...}()` and `go namedFunc(args)`.
+// It handles `go func(){...}()`, `go namedFunc(args)`, and `go x.Method(args)`.
 func (c *GoToTSCompiler) WriteStmtGo(exp *ast.GoStmt) error {
 	// Handle goroutine statement
 	// Translate 'go func() { ... }()' to 'queueMicrotask(() => { ... compiled body ... })'
-
-	// The call expression's function is the function literal
 	callExpr := exp.Call
-	if funcLit, ok := callExpr.Fun.(*ast.FuncLit); ok {
+
+	switch fun := callExpr.Fun.(type) {
+	case *ast.FuncLit:
 		// For function literals, we need to check if the function literal itself is async
 		// This happens during analysis in analysisVisitor.Visit for FuncLit nodes
-		isAsync := c.analysis.IsFuncLitAsync(funcLit)
+		isAsync := c.analysis.IsFuncLitAsync(fun)
 		if isAsync {
 			c.tsw.WriteLiterally("queueMicrotask(async () => ")
 		} else {
@@ -190,18 +197,18 @@ func (c *GoToTSCompiler) WriteStmtGo(exp *ast.GoStmt) error {
 		}
 
 		// Compile the function literal's body directly
-		if err := c.WriteStmtBlock(funcLit.Body, true); err != nil {
+		if err := c.WriteStmtBlock(fun.Body, true); err != nil {
 			return fmt.Errorf("failed to write goroutine function literal body: %w", err)
 		}
 
 		c.tsw.WriteLine(")") // Close the queueMicrotask statement
 
-	} else if ident, ok := callExpr.Fun.(*ast.Ident); ok {
+	case *ast.Ident:
 		// Handle named functions: go namedFunc(args)
 		// Get the object for this function
-		obj := c.pkg.TypesInfo.Uses[ident]
+		obj := c.pkg.TypesInfo.Uses[fun]
 		if obj == nil {
-			return errors.Errorf("could not find object for function: %s", ident.Name)
+			return errors.Errorf("could not find object for function: %s", fun.Name)
 		}
 
 		// Check if the function is async
@@ -221,7 +228,7 @@ func (c *GoToTSCompiler) WriteStmtGo(exp *ast.GoStmt) error {
 		}
 
 		// Write the function name
-		c.tsw.WriteLiterally(ident.Name)
+		c.tsw.WriteLiterally(fun.Name)
 
 		// Write the function arguments
 		c.tsw.WriteLiterally("(")
@@ -238,7 +245,93 @@ func (c *GoToTSCompiler) WriteStmtGo(exp *ast.GoStmt) error {
 
 		c.tsw.Indent(-1)
 		c.tsw.WriteLine("})") // Close the queueMicrotask callback and the statement
-	} else {
+	case *ast.SelectorExpr:
+		// Handle selector expressions: go x.Method(args)
+		// Get the object for the selected method
+		obj := c.pkg.TypesInfo.Uses[fun.Sel]
+		if obj == nil {
+			return errors.Errorf("could not find object for selected method: %s", fun.Sel.Name)
+		}
+
+		// Check if the function is async
+		isAsync := c.analysis.IsAsyncFunc(obj)
+		if isAsync {
+			c.tsw.WriteLiterally("queueMicrotask(async () => {")
+		} else {
+			c.tsw.WriteLiterally("queueMicrotask(() => {")
+		}
+
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+
+		// Write the function call, using await if the function is async
+		if isAsync {
+			c.tsw.WriteLiterally("await ")
+		}
+
+		// Write the selector expression (e.g., f.Bar)
+		// Note: callExpr.Fun is the *ast.SelectorExpr itself
+		// For method calls, we need to add null assertion since Go would panic on nil receiver
+		if selectorExpr, ok := callExpr.Fun.(*ast.SelectorExpr); ok {
+			if err := c.WriteValueExpr(selectorExpr.X); err != nil {
+				return fmt.Errorf("failed to write selector base expression in goroutine: %w", err)
+			}
+			// Add null assertion for method calls - Go would panic if receiver is nil
+			c.tsw.WriteLiterally("!.")
+			c.WriteIdent(selectorExpr.Sel, true)
+		} else {
+			if err := c.WriteValueExpr(callExpr.Fun); err != nil {
+				return fmt.Errorf("failed to write selector expression in goroutine: %w", err)
+			}
+		}
+
+		// Write the function arguments
+		c.tsw.WriteLiterally("(")
+		for i, arg := range callExpr.Args {
+			if i != 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return fmt.Errorf("failed to write argument %d in goroutine selector function call: %w", i, err)
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		c.tsw.WriteLine("")
+
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("})") // Close the queueMicrotask callback and the statement
+	case *ast.TypeAssertExpr:
+		// Handle type assertion expressions: go x.(func())()
+		// We assume this is always synchronous (no async function returned by type assertion)
+		c.tsw.WriteLiterally("queueMicrotask(() => {")
+
+		c.tsw.Indent(1)
+		c.tsw.WriteLine("")
+
+		// Write the type assertion call
+		if err := c.WriteTypeAssertExpr(fun); err != nil {
+			return fmt.Errorf("failed to write type assertion expression in goroutine: %w", err)
+		}
+
+		// Add non-null assertion since mustTypeAssert throws on failure rather than returning null
+		c.tsw.WriteLiterally("!")
+
+		// Write the function arguments
+		c.tsw.WriteLiterally("(")
+		for i, arg := range callExpr.Args {
+			if i != 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return fmt.Errorf("failed to write argument %d in goroutine type assertion function call: %w", i, err)
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		c.tsw.WriteLine("")
+
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("})") // Close the queueMicrotask callback and the statement
+	default:
 		return errors.Errorf("unhandled goroutine function type: %T", callExpr.Fun)
 	}
 	return nil
@@ -258,12 +351,12 @@ func (c *GoToTSCompiler) WriteStmtGo(exp *ast.GoStmt) error {
 func (c *GoToTSCompiler) WriteStmtExpr(exp *ast.ExprStmt) error {
 	// Handle simple channel receive used as a statement (<-ch)
 	if unaryExpr, ok := exp.X.(*ast.UnaryExpr); ok && unaryExpr.Op == token.ARROW {
-		// Translate <-ch to await ch.receive()
-		c.tsw.WriteLiterally("await ")
+		// Translate <-ch to await $.chanRecv(ch)
+		c.tsw.WriteLiterally("await $.chanRecv(")
 		if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Channel expression
 			return fmt.Errorf("failed to write channel expression in receive statement: %w", err)
 		}
-		c.tsw.WriteLiterally(".receive()") // Use receive() as the value is discarded
+		c.tsw.WriteLiterally(")") // Use chanRecv() as the value is discarded
 		c.tsw.WriteLine("")
 		return nil
 	}
@@ -315,12 +408,12 @@ func (c *GoToTSCompiler) WriteStmtExpr(exp *ast.ExprStmt) error {
 // channel send operations are asynchronous in the TypeScript model.
 // The statement is terminated with a newline.
 func (c *GoToTSCompiler) WriteStmtSend(exp *ast.SendStmt) error {
-	// Translate ch <- value to await ch.send(value)
-	c.tsw.WriteLiterally("await ")
+	// Translate ch <- value to await $.chanSend(ch, value)
+	c.tsw.WriteLiterally("await $.chanSend(")
 	if err := c.WriteValueExpr(exp.Chan); err != nil { // The channel expression
 		return fmt.Errorf("failed to write channel expression in send statement: %w", err)
 	}
-	c.tsw.WriteLiterally(".send(")
+	c.tsw.WriteLiterally(", ")
 	if err := c.WriteValueExpr(exp.Value); err != nil { // The value expression
 		return fmt.Errorf("failed to write value expression in send statement: %w", err)
 	}
@@ -346,16 +439,19 @@ func (c *GoToTSCompiler) WriteStmtSend(exp *ast.SendStmt) error {
 // The function aims to produce idiomatic TypeScript `if/else if/else` structures.
 func (s *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 	if exp.Init != nil {
-		s.tsw.WriteLiterally("{")
-		s.tsw.Indent(1)
+		s.tsw.WriteLiterally("{") // Write opening brace
+		s.tsw.WriteLine("")       // Add newline immediately after opening brace
+		s.tsw.Indent(1)           // Indent for the initializer
 
-		if err := s.WriteStmt(exp.Init); err != nil {
+		if err := s.WriteStmt(exp.Init); err != nil { // Write the initializer
 			return err
 		}
 
+		// This defer handles closing the synthetic block for the initializer
 		defer func() {
 			s.tsw.Indent(-1)
-			s.tsw.WriteLiterally("}")
+			s.tsw.WriteLiterally("}") // Write the closing brace at the now-correct indent level
+			s.tsw.WriteLine("")       // Ensure a newline *after* this '}', critical for preventing '}}'
 		}()
 	}
 
@@ -406,21 +502,51 @@ func (s *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 // The statement is terminated with a newline.
 func (c *GoToTSCompiler) WriteStmtReturn(exp *ast.ReturnStmt) error {
 	c.tsw.WriteLiterally("return ")
-	if len(exp.Results) > 1 {
-		c.tsw.WriteLiterally("[")
-	}
-	for i, res := range exp.Results {
-		if i != 0 {
-			c.tsw.WriteLiterally(", ")
+
+	// Check if it's a bare named return
+	nodeInfo := c.analysis.NodeData[exp]
+	if nodeInfo != nil && nodeInfo.IsBareReturn {
+		var namedReturns []string
+		if nodeInfo.EnclosingFuncDecl != nil {
+			if obj := c.pkg.TypesInfo.ObjectOf(nodeInfo.EnclosingFuncDecl.Name); obj != nil {
+				if funcInfo := c.analysis.FunctionData[obj]; funcInfo != nil {
+					namedReturns = funcInfo.NamedReturns
+				}
+			}
+		} else if nodeInfo.EnclosingFuncLit != nil {
+			if funcInfo := c.analysis.FuncLitData[nodeInfo.EnclosingFuncLit]; funcInfo != nil {
+				namedReturns = funcInfo.NamedReturns
+			}
 		}
-		if err := c.WriteValueExpr(res); err != nil { // Return results are values
-			return err
+
+		if len(namedReturns) > 0 {
+			c.tsw.WriteLiterally("[")
+			for i, name := range namedReturns {
+				if i != 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.tsw.WriteLiterally(name)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+	} else {
+		// Handle explicit return values
+		if len(exp.Results) > 1 {
+			c.tsw.WriteLiterally("[")
+		}
+		for i, res := range exp.Results {
+			if i != 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(res); err != nil { // Return results are values
+				return err
+			}
+		}
+		if len(exp.Results) > 1 {
+			c.tsw.WriteLiterally("]")
 		}
 	}
-	if len(exp.Results) > 1 {
-		c.tsw.WriteLiterally("]")
-	}
-	c.tsw.WriteLine("") // Remove semicolon
+	c.tsw.WriteLine("")
 	return nil
 }
 
@@ -464,7 +590,7 @@ func (c *GoToTSCompiler) WriteStmtBlock(exp *ast.BlockStmt, suppressNewline bool
 	for _, stmt := range exp.List {
 		if deferStmt, ok := stmt.(*ast.DeferStmt); ok {
 			if funcLit, ok := deferStmt.Call.Fun.(*ast.FuncLit); ok {
-				if c.analysis.IsInAsyncFunctionMap[funcLit] {
+				if c.analysis.IsFuncLitAsync(funcLit) {
 					hasAsyncDefer = true
 					break
 				}
@@ -530,7 +656,6 @@ func (c *GoToTSCompiler) WriteStmtBlock(exp *ast.BlockStmt, suppressNewline bool
 					start = file.Line(cg.Pos())
 				}
 				writeBlank(lastLine, start)
-				// WriteDoc does not currently return an error, assuming it's safe for now.
 				c.WriteDoc(cg) // WriteDoc will handle the actual comment text
 				if file != nil && cg.End().IsValid() {
 					lastLine = file.Line(cg.End())
@@ -567,7 +692,6 @@ func (c *GoToTSCompiler) WriteStmtBlock(exp *ast.BlockStmt, suppressNewline bool
 		// only emit if it follows the last content
 		if start > lastLine {
 			writeBlank(lastLine, start)
-			// WriteDoc does not currently return an error, assuming it's safe for now.
 			c.WriteDoc(cg)
 			if file != nil && cg.End().IsValid() {
 				lastLine = file.Line(cg.End())
@@ -634,7 +758,6 @@ func (c *GoToTSCompiler) WriteStmtSwitch(exp *ast.SwitchStmt) error {
 	// Handle case clauses
 	for _, stmt := range exp.Body.List {
 		if caseClause, ok := stmt.(*ast.CaseClause); ok {
-			// WriteCaseClause does not currently return an error, assuming it's safe for now.
 			if err := c.WriteCaseClause(caseClause); err != nil {
 				return fmt.Errorf("failed to write case clause in switch statement: %w", err)
 			}
@@ -667,7 +790,7 @@ func (c *GoToTSCompiler) WriteStmtDefer(exp *ast.DeferStmt) error {
 	// Determine if the deferred call is to an async function literal using analysis
 	isAsyncDeferred := false
 	if funcLit, ok := exp.Call.Fun.(*ast.FuncLit); ok {
-		isAsyncDeferred = c.analysis.IsInAsyncFunctionMap[funcLit]
+		isAsyncDeferred = c.analysis.IsFuncLitAsync(funcLit)
 	}
 
 	// Set async prefix based on pre-computed async status
@@ -696,6 +819,7 @@ func (c *GoToTSCompiler) WriteStmtDefer(exp *ast.DeferStmt) error {
 		if err := c.WriteValueExpr(exp.Call); err != nil {
 			return fmt.Errorf("failed to write deferred call: %w", err)
 		}
+		c.tsw.WriteLine("")
 	}
 
 	c.tsw.Indent(-1)
@@ -704,204 +828,17 @@ func (c *GoToTSCompiler) WriteStmtDefer(exp *ast.DeferStmt) error {
 	return nil
 }
 
-// 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
+// WriteStmtLabeled handles labeled statements (ast.LabeledStmt), such as "label: statement".
+// In TypeScript, this translates to "label: statement" directly.
+func (c *GoToTSCompiler) WriteStmtLabeled(stmt *ast.LabeledStmt) error {
+	// Write the label name followed by a colon
+	c.tsw.WriteLiterally(stmt.Label.Name)
+	c.tsw.WriteLiterally(": ")
 
-			// 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 {
-			c.tsw.WriteCommentLinef("unknown statement in select body: %T", stmt)
-		}
+	// Write the labeled statement
+	if err := c.WriteStmt(stmt.Stmt); err != nil {
+		return fmt.Errorf("failed to write labeled statement: %w", err)
 	}
 
-	// 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
 }