goscript 0.0.21 → 0.0.22

package/compiler/spec.go

@@ -0,0 +1,263 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/types"
+	"strings"
+
+	// types provides type information for Go types.
+	"github.com/pkg/errors"
+)
+
+// WriteSpec is a dispatcher function that translates a Go specification node
+// (`ast.Spec`) into its TypeScript equivalent. It handles different types of
+// specifications found within `GenDecl` (general declarations):
+// - `ast.ImportSpec` (import declarations): Delegates to `WriteImportSpec`.
+// - `ast.ValueSpec` (variable or constant declarations): Delegates to `WriteValueSpec`.
+// - `ast.TypeSpec` (type definitions like structs, interfaces): Delegates to `WriteTypeSpec`.
+// If an unknown specification type is encountered, it returns an error.
+func (c *GoToTSCompiler) WriteSpec(a ast.Spec) error {
+	switch d := a.(type) {
+	case *ast.ImportSpec:
+		c.WriteImportSpec(d)
+	case *ast.ValueSpec:
+		if err := c.WriteValueSpec(d); err != nil {
+			return err
+		}
+	case *ast.TypeSpec:
+		if err := c.WriteTypeSpec(d); err != nil {
+			return err
+		}
+	default:
+		return fmt.Errorf("unknown spec type: %T", a)
+	}
+	return nil
+}
+
+func (c *GoToTSCompiler) getEmbeddedFieldKeyName(fieldType types.Type) string {
+	trueType := fieldType
+	if ptr, isPtr := trueType.(*types.Pointer); isPtr {
+		trueType = ptr.Elem()
+	}
+
+	if named, isNamed := trueType.(*types.Named); isNamed {
+		return named.Obj().Name()
+	} else {
+		// Fallback for unnamed embedded types, though less common for structs
+		fieldKeyName := strings.Title(trueType.String()) // Simple heuristic
+		if dotIndex := strings.LastIndex(fieldKeyName, "."); dotIndex != -1 {
+			fieldKeyName = fieldKeyName[dotIndex+1:]
+		}
+		return fieldKeyName
+	}
+}
+
+func (c *GoToTSCompiler) writeGetterSetter(fieldName string, fieldType types.Type, doc, comment *ast.CommentGroup) {
+	fieldTypeStr := c.getTypeString(fieldType)
+
+	// Generate getter
+	if doc != nil {
+		c.WriteDoc(doc)
+	}
+	if comment != nil {
+		c.WriteDoc(comment)
+	}
+	c.tsw.WriteLinef("public get %s(): %s {", fieldName, fieldTypeStr)
+	c.tsw.Indent(1)
+	c.tsw.WriteLinef("return this._fields.%s.value", fieldName)
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+
+	// Generate setter (no comments)
+	c.tsw.WriteLinef("public set %s(value: %s) {", fieldName, fieldTypeStr)
+	c.tsw.Indent(1)
+	c.tsw.WriteLinef("this._fields.%s.value = value", fieldName)
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
+	c.tsw.WriteLine("")
+}
+
+func (c *GoToTSCompiler) writeBoxedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
+	c.tsw.WriteLiterally(fieldName)
+	c.tsw.WriteLiterally(": $.box(")
+
+	if isEmbedded {
+		if _, isPtr := fieldType.(*types.Pointer); isPtr {
+			c.tsw.WriteLiterallyf("init?.%s ?? null", fieldName)
+		} else {
+			typeForNew := fieldName
+			c.tsw.WriteLiterallyf("new %s(init?.%s)", typeForNew, fieldName)
+		}
+	} else {
+		isStructValueType := false
+		var structTypeNameForClone string
+		if named, ok := fieldType.(*types.Named); ok {
+			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
+				isStructValueType = true
+				structTypeNameForClone = named.Obj().Name()
+			}
+		}
+
+		if isStructValueType {
+			c.tsw.WriteLiterallyf("init?.%s?.clone() ?? new %s()", fieldName, structTypeNameForClone)
+		} else {
+			c.tsw.WriteLiterallyf("init?.%s ?? ", fieldName)
+			c.WriteZeroValueForType(fieldType)
+		}
+	}
+
+	c.tsw.WriteLiterally(")")
+}
+
+func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
+	c.tsw.WriteLiterally(fieldName)
+	c.tsw.WriteLiterally(": $.box(")
+
+	if isEmbedded {
+		isPointerToStruct := false
+		trueType := fieldType
+		if ptr, isPtr := trueType.(*types.Pointer); isPtr {
+			trueType = ptr.Elem()
+			isPointerToStruct = true
+		}
+
+		if named, isNamed := trueType.(*types.Named); isNamed {
+			_, isUnderlyingStruct := named.Underlying().(*types.Struct)
+			if isUnderlyingStruct && !isPointerToStruct { // Is a value struct
+				c.tsw.WriteLiterallyf("this._fields.%s.value.clone()", fieldName)
+			} else { // Is a pointer to a struct, or not a struct
+				c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
+			}
+		} else {
+			c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
+		}
+	} else {
+		isValueTypeStruct := false
+		if named, ok := fieldType.(*types.Named); ok {
+			if _, isStruct := named.Underlying().(*types.Struct); isStruct {
+				isValueTypeStruct = true
+			}
+		}
+
+		if isValueTypeStruct {
+			c.tsw.WriteLiterallyf("this._fields.%s.value?.clone() ?? null", fieldName)
+		} else {
+			c.tsw.WriteLiterallyf("this._fields.%s.value", fieldName)
+		}
+	}
+
+	c.tsw.WriteLiterally(")")
+}
+
+// WriteTypeSpec writes the type specification to the output.
+func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
+	if a.Doc != nil {
+		c.WriteDoc(a.Doc)
+	}
+	if a.Comment != nil {
+		c.WriteDoc(a.Comment)
+	}
+
+	switch t := a.Type.(type) {
+	case *ast.StructType:
+		return c.WriteStructTypeSpec(a, t)
+	case *ast.InterfaceType:
+		return c.WriteInterfaceTypeSpec(a, t)
+	default:
+		// type alias
+		c.tsw.WriteLiterally("type ")
+		if err := c.WriteValueExpr(a.Name); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(" = ")
+		c.WriteTypeExpr(a.Type) // The aliased type
+		c.tsw.WriteLine(";")
+	}
+	return nil
+}
+
+// WriteInterfaceTypeSpec writes the TypeScript type for a Go interface type.
+func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.InterfaceType) error {
+	c.tsw.WriteLiterally("type ")
+	if err := c.WriteValueExpr(a.Name); err != nil {
+		return err
+	}
+	c.tsw.WriteLiterally(" = ")
+	// Get the types.Interface from the ast.InterfaceType.
+	// For an interface definition like `type MyInterface interface { M() }`,
+	// 't' is the *ast.InterfaceType representing `interface { M() }`.
+	// TypesInfo.TypeOf(t) will give the *types.Interface.
+	goType := c.pkg.TypesInfo.TypeOf(t)
+	if goType == nil {
+		return errors.Errorf("could not get type for interface AST node for %s", a.Name.Name)
+	}
+	ifaceType, ok := goType.(*types.Interface)
+	if !ok {
+		return errors.Errorf("expected *types.Interface, got %T for %s when processing interface literal", goType, a.Name.Name)
+	}
+	c.WriteInterfaceType(ifaceType, t) // Pass the *ast.InterfaceType for comment fetching
+	c.tsw.WriteLine("")
+
+	// Add code to register the interface with the runtime system
+	interfaceName := a.Name.Name
+	c.tsw.WriteLine("")
+	c.tsw.WriteLinef("$.registerInterfaceType(")
+	c.tsw.WriteLinef("  '%s',", interfaceName)
+	c.tsw.WriteLinef("  null, // Zero value for interface is null")
+
+	// Collect methods for the interface type
+	var interfaceMethods []*types.Func
+	if ifaceType != nil { // ifaceType is *types.Interface
+		for i := range ifaceType.NumExplicitMethods() {
+			interfaceMethods = append(interfaceMethods, ifaceType.ExplicitMethod(i))
+		}
+		// TODO: Handle embedded interface methods if necessary for full signature collection.
+		// For now, explicit methods are covered.
+	}
+	c.tsw.WriteLiterally("  [")
+	c.writeMethodSignatures(interfaceMethods)
+	c.tsw.WriteLiterally("]")
+	c.tsw.WriteLine("")
+
+	c.tsw.WriteLinef(");")
+
+	return nil
+}
+
+// WriteImportSpec translates a Go import specification (`ast.ImportSpec`)
+// into a TypeScript import statement.
+//
+// It extracts the Go import path (e.g., `"path/to/pkg"`) and determines the
+// import alias/name for TypeScript. If the Go import has an explicit name
+// (e.g., `alias "path/to/pkg"`), that alias is used. Otherwise, the package
+// name is derived from the Go path.
+//
+// The Go path is then translated to a TypeScript module path using
+// `translateGoPathToTypescriptPath`.
+//
+// Finally, it writes a TypeScript import statement like `import * as alias from "typescript/path/to/pkg";`
+// and records the import details in `c.analysis.Imports` for later use (e.g.,
+// resolving qualified identifiers).
+func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
+	if a.Doc != nil {
+		c.WriteDoc(a.Doc)
+	}
+	if a.Comment != nil {
+		c.WriteDoc(a.Comment)
+	}
+
+	goPath := a.Path.Value[1 : len(a.Path.Value)-1]
+	impName := packageNameFromGoPath(goPath)
+	if a.Name != nil && a.Name.Name != "" {
+		impName = a.Name.Name
+	}
+
+	importPath := translateGoPathToTypescriptPath(goPath)
+	c.analysis.Imports[impName] = &fileImport{
+		importPath: importPath,
+		importVars: make(map[string]struct{}),
+	}
+
+	c.tsw.WriteImport(impName, importPath+"/index.js")
+}

package/compiler/stmt-assign.go

@@ -0,0 +1,411 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"github.com/pkg/errors"
+)
+
+// WriteStmtAssign translates a Go assignment statement (`ast.AssignStmt`) into
+// its TypeScript equivalent. It handles various forms of Go assignments:
+//
+// 1.  **Multi-variable assignment from a single function call** (e.g., `a, b := fn()`):
+//   - Uses `writeMultiVarAssignFromCall` to generate `let [a, b] = fn_ts();`.
+//
+// 2.  **Type assertion with comma-ok** (e.g., `val, ok := expr.(Type)`):
+//   - Uses `writeTypeAssertion` to generate `let { value: val, ok: ok } = $.typeAssert<Type_ts>(expr_ts, 'TypeName');`.
+//
+// 3.  **Map lookup with comma-ok** (e.g., `val, ok := myMap[key]`):
+//   - Uses `writeMapLookupWithExists` to generate separate assignments for `val`
+//     (using `myMap_ts.get(key_ts) ?? zeroValue`) and `ok` (using `myMap_ts.has(key_ts)`).
+//
+// 4.  **Channel receive with comma-ok** (e.g., `val, ok := <-ch`):
+//   - Uses `writeChannelReceiveWithOk` to generate `let { value: val, ok: ok } = await ch_ts.receiveWithOk();`.
+//
+// 5.  **Discarded channel receive** (e.g., `<-ch` on RHS, no LHS vars):
+//   - Translates to `await ch_ts.receive();`.
+//
+// 6.  **Single assignment** (e.g., `x = y`, `x := y`, `*p = y`, `x[i] = y`):
+//   - 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);`.
+//   - 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.
+//
+// 7.  **Multi-variable assignment with multiple RHS values** (e.g., `a, b = x, y`):
+//   - Uses `writeAssignmentCore` to generate `[a,b] = [x_ts, y_ts];` (or `let [a,b] = ...` for `:=`).
+//
+// 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
+// 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.
+	writeMultiVarAssignFromCall := func(lhs []ast.Expr, callExpr *ast.CallExpr, tok token.Token) error {
+		// For token.DEFINE (:=), we need to check if any of the variables are already declared
+		// In Go, := can be used for redeclaration if at least one variable is new
+		if tok == token.DEFINE {
+			// For token.DEFINE (:=), we need to handle variable declarations differently
+			// In Go, := can redeclare existing variables if at least one variable is new
+
+			// First, identify which variables are new vs existing
+			newVars := make([]bool, len(lhs))
+			anyNewVars := false
+			allNewVars := true
+
+			// For multi-variable assignments with :=, we need to determine which variables
+			// are already in scope and which are new declarations
+			for i, lhsExpr := range lhs {
+				if ident, ok := lhsExpr.(*ast.Ident); ok && ident.Name != "_" {
+					// In Go, variables declared with := can be redeclared if at least one is new
+					// For TypeScript, we need to separately declare new variables
+
+					// Check if this variable is already in scope
+					// - If the variable is used elsewhere before this point, it's existing
+					// - Otherwise, it's a new variable being declared
+					isNew := true
+
+					// Check if the variable is used elsewhere in the code
+					if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+						// If it's in Uses, it's referenced elsewhere, so it exists
+						isNew = false
+						allNewVars = false
+					}
+
+					newVars[i] = isNew
+					if isNew {
+						anyNewVars = true
+					}
+				}
+			}
+
+			// Get function return types if available
+			var resultTypes []*types.Var
+			if callExpr.Fun != nil {
+				if funcType, ok := c.pkg.TypesInfo.TypeOf(callExpr.Fun).Underlying().(*types.Signature); ok {
+					if funcType.Results() != nil && funcType.Results().Len() > 0 {
+						for i := 0; i < funcType.Results().Len(); i++ {
+							resultTypes = append(resultTypes, funcType.Results().At(i))
+						}
+					}
+				}
+			}
+
+			if allNewVars && anyNewVars {
+				c.tsw.WriteLiterally("let [")
+
+				for i, lhsExpr := range lhs {
+					if i != 0 {
+						c.tsw.WriteLiterally(", ")
+					}
+
+					if ident, ok := lhsExpr.(*ast.Ident); ok {
+						if ident.Name == "_" {
+							// For underscore variables, use empty slots in destructuring pattern
+						} else {
+							c.WriteIdent(ident, false)
+						}
+					} else {
+						c.WriteValueExpr(lhsExpr)
+					}
+				}
+				c.tsw.WriteLiterally("] = ")
+				c.WriteValueExpr(callExpr)
+				c.tsw.WriteLine("")
+				return nil
+			} else if anyNewVars {
+				// If only some variables are new, declare them separately before the assignment
+				// Declare each new variable with appropriate type
+				for i, lhsExpr := range lhs {
+					if ident, ok := lhsExpr.(*ast.Ident); ok && ident.Name != "_" && newVars[i] {
+						c.tsw.WriteLiterally("let ")
+						c.WriteIdent(ident, false)
+
+						// Add type annotation if we have type information
+						if i < len(resultTypes) {
+							c.tsw.WriteLiterally(": ")
+							c.WriteGoType(resultTypes[i].Type())
+						}
+
+						c.tsw.WriteLine("")
+					}
+				}
+			}
+		}
+
+		// First, collect all the selector expressions to identify variables that need to be initialized
+		hasSelectors := false
+		for _, lhsExpr := range lhs {
+			if _, ok := lhsExpr.(*ast.SelectorExpr); ok {
+				hasSelectors = true
+				break
+			}
+		}
+
+		// If we have selector expressions, we need to ensure variables are initialized
+		// before the destructuring assignment
+		if hasSelectors {
+			c.tsw.WriteLiterally("{")
+			c.tsw.WriteLine("")
+
+			// Write a temporary variable to hold the function call result
+			c.tsw.WriteLiterally("  const _tmp = ")
+			if err := c.WriteValueExpr(callExpr); err != nil {
+				return fmt.Errorf("failed to write RHS call expression in assignment: %w", err)
+			}
+			c.tsw.WriteLine("")
+
+			for i, lhsExpr := range lhs {
+				// Skip underscore variables
+				if ident, ok := lhsExpr.(*ast.Ident); ok && ident.Name == "_" {
+					continue
+				}
+
+				// Write the LHS with indentation
+				c.tsw.WriteLiterally("  ")
+				if ident, ok := lhsExpr.(*ast.Ident); ok {
+					c.WriteIdent(ident, false)
+				} else if selectorExpr, ok := lhsExpr.(*ast.SelectorExpr); ok {
+					if err := c.WriteValueExpr(selectorExpr); err != nil {
+						return fmt.Errorf("failed to write selector expression in LHS: %w", err)
+					}
+				} else {
+					return errors.Errorf("unhandled LHS expression in assignment: %T", lhsExpr)
+				}
+
+				// Write the assignment
+				c.tsw.WriteLiterallyf(" = _tmp[%d]", i)
+				// Always add a newline after each assignment
+				c.tsw.WriteLine("")
+			}
+
+			// Close the block scope
+			c.tsw.WriteLiterally("}")
+			c.tsw.WriteLine("")
+
+			return nil
+		}
+
+		// For simple cases without selector expressions, use array destructuring
+		c.tsw.WriteLiterally("[")
+
+		for i, lhsExpr := range lhs {
+			if i != 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+
+			if ident, ok := lhsExpr.(*ast.Ident); ok {
+				// For underscore variables, use empty slots in destructuring pattern
+				if ident.Name != "_" {
+					c.WriteIdent(ident, false)
+				}
+			} else if selectorExpr, ok := lhsExpr.(*ast.SelectorExpr); ok {
+				// Handle selector expressions (e.g., a.b) by using WriteValueExpr
+				if err := c.WriteValueExpr(selectorExpr); err != nil {
+					return fmt.Errorf("failed to write selector expression in LHS: %w", err)
+				}
+			} else {
+				// Should not happen for valid Go code in this context, but handle defensively
+				return errors.Errorf("unhandled LHS expression in destructuring: %T", lhsExpr)
+			}
+		}
+		c.tsw.WriteLiterally("] = ")
+
+		// Write the right-hand side (the function call)
+		if err := c.WriteValueExpr(callExpr); err != nil {
+			return fmt.Errorf("failed to write RHS call expression in assignment: %w", err)
+		}
+
+		c.tsw.WriteLine("")
+		return nil
+	}
+
+	// writeMapLookupWithExists handles the map comma-ok idiom: value, exists := myMap[key]
+	// Note: We don't use WriteIndexExpr here because we need to handle .has() and .get() separately
+	writeMapLookupWithExists := func(lhs []ast.Expr, indexExpr *ast.IndexExpr, tok token.Token) error {
+		// First check that we have exactly two LHS expressions (value and exists)
+		if len(lhs) != 2 {
+			return fmt.Errorf("map comma-ok idiom requires exactly 2 variables on LHS, got %d", len(lhs))
+		}
+
+		// Check for blank identifiers and get variable names
+		valueIsBlank := false
+		existsIsBlank := false
+		var valueName string
+		var existsName string
+
+		if valIdent, ok := lhs[0].(*ast.Ident); ok {
+			if valIdent.Name == "_" {
+				valueIsBlank = true
+			} else {
+				valueName = valIdent.Name
+			}
+		} else {
+			return fmt.Errorf("unhandled LHS expression type for value in map comma-ok: %T", lhs[0])
+		}
+
+		if existsIdent, ok := lhs[1].(*ast.Ident); ok {
+			if existsIdent.Name == "_" {
+				existsIsBlank = true
+			} else {
+				existsName = existsIdent.Name
+			}
+		} else {
+			return fmt.Errorf("unhandled LHS expression type for exists in map comma-ok: %T", lhs[1])
+		}
+
+		// Declare variables if using := and not blank
+		if tok == token.DEFINE {
+			if !valueIsBlank {
+				c.tsw.WriteLiterally("let ")
+				c.tsw.WriteLiterally(valueName)
+				// TODO: Add type annotation based on map value type
+				c.tsw.WriteLine("")
+			}
+			if !existsIsBlank {
+				c.tsw.WriteLiterally("let ")
+				c.tsw.WriteLiterally(existsName)
+				c.tsw.WriteLiterally(": boolean") // exists is always boolean
+				c.tsw.WriteLine("")
+			}
+		}
+
+		// Assign 'exists'
+		if !existsIsBlank {
+			c.tsw.WriteLiterally(existsName)
+			c.tsw.WriteLiterally(" = ")
+			c.tsw.WriteLiterally("$.mapHas(")
+			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
+				return err
+			}
+			c.tsw.WriteLiterally(")")
+			c.tsw.WriteLine("")
+		}
+
+		// Assign 'value'
+		if !valueIsBlank {
+			c.tsw.WriteLiterally(valueName)
+			c.tsw.WriteLiterally(" = ")
+			c.tsw.WriteLiterally("$.mapGet(")
+			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+			// Write the zero value for the map's value type
+			if tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]; ok {
+				if mapType, isMap := tv.Type.Underlying().(*types.Map); isMap {
+					c.WriteZeroValueForType(mapType.Elem())
+				} else {
+					// Fallback zero value if type info is missing or not a map
+					c.tsw.WriteLiterally("null")
+				}
+			} else {
+				c.tsw.WriteLiterally("null")
+			}
+			c.tsw.WriteLiterally(")")
+			c.tsw.WriteLine("")
+		} else if existsIsBlank {
+			// If both are blank, still evaluate for side effects (though .has/.get are usually pure)
+			// We add a ; otherwise TypeScript thinks we are invoking a function.
+			c.tsw.WriteLiterally(";(") // Wrap in parens to make it an expression statement
+			c.tsw.WriteLiterally("$.mapHas(")
+			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
+				return err
+			}
+			c.tsw.WriteLiterally("), ") // Evaluate .has
+			c.tsw.WriteLiterally("$.mapGet(")
+			if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
+				return err
+			}
+			c.tsw.WriteLiterally(", null))") // Evaluate .get with null as default
+			c.tsw.WriteLine("")
+		}
+
+		return nil
+	}
+
+	// Handle multi-variable assignment from a single expression.
+	if len(exp.Lhs) > 1 && len(exp.Rhs) == 1 {
+		rhsExpr := exp.Rhs[0]
+		if typeAssertExpr, ok := rhsExpr.(*ast.TypeAssertExpr); ok {
+			return c.writeTypeAssert(exp.Lhs, typeAssertExpr, exp.Tok)
+		} else if indexExpr, ok := rhsExpr.(*ast.IndexExpr); ok {
+			// Check if this is a map lookup (comma-ok idiom)
+			if len(exp.Lhs) == 2 {
+				// Get the type of the indexed expression
+				if c.pkg != nil && c.pkg.TypesInfo != nil {
+					tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]
+					if ok {
+						// Check if it's a map type
+						if _, isMap := tv.Type.Underlying().(*types.Map); isMap {
+							return writeMapLookupWithExists(exp.Lhs, indexExpr, exp.Tok)
+						}
+					}
+				}
+			}
+		} else if unaryExpr, ok := rhsExpr.(*ast.UnaryExpr); ok && unaryExpr.Op == token.ARROW {
+			// Handle val, ok := <-channel
+			if len(exp.Lhs) == 2 {
+				return c.writeChannelReceiveWithOk(exp.Lhs, unaryExpr, exp.Tok)
+			}
+			// If LHS count is not 2, fall through to error or other handling
+		} else if callExpr, ok := rhsExpr.(*ast.CallExpr); ok {
+			return writeMultiVarAssignFromCall(exp.Lhs, callExpr, exp.Tok)
+		}
+		// If none of the specific multi-assign patterns match, fall through to the error check below
+	}
+
+	// Ensure LHS and RHS have the same length for valid Go code in these cases
+	if len(exp.Lhs) != len(exp.Rhs) {
+		return fmt.Errorf("invalid assignment statement: LHS count (%d) != RHS count (%d)", len(exp.Lhs), len(exp.Rhs))
+	}
+
+	// Handle multi-variable assignment (e.g., swaps) using writeAssignmentCore
+	if len(exp.Lhs) > 1 {
+		// Need to handle := for multi-variable declarations
+		if exp.Tok == token.DEFINE {
+			c.tsw.WriteLiterally("let ") // Use let for multi-variable declarations
+		}
+		// For multi-variable assignments, we've already added the "let" if needed
+		if err := c.writeAssignmentCore(exp.Lhs, exp.Rhs, exp.Tok, false); err != nil {
+			return err
+		}
+		c.tsw.WriteLine("") // Add newline after the statement
+		return nil
+	}
+
+	// Handle single assignment using writeAssignmentCore
+	if len(exp.Lhs) == 1 {
+		addDeclaration := exp.Tok == token.DEFINE
+		if err := c.writeAssignmentCore(exp.Lhs, exp.Rhs, exp.Tok, addDeclaration); err != nil {
+			return err
+		}
+		c.tsw.WriteLine("") // Add newline after the statement
+		return nil
+	}
+
+	// Should not reach here if LHS/RHS counts are valid and handled
+	return fmt.Errorf("unhandled assignment case")
+}