goscript 0.0.20 → 0.0.22

package/compiler/primitive.go

@@ -0,0 +1,142 @@
+package compiler
+
+import "go/token"
+
+// goToTypescriptPrimitives maps Go built-in primitive type names (as strings)
+// to their corresponding TypeScript type names. This map is used by
+// `GoBuiltinToTypescript` for direct type name translation.
+//
+// Key mappings include:
+// - `bool` -> `boolean`
+// - `string` -> `string`
+// - `int`, `int8`, `int16`, `int32`, `rune` (alias for int32) -> `number`
+// - `uint`, `uint8` (`byte`), `uint16`, `uint32` -> `number`
+// - `int64`, `uint64` -> `bigint` (requires ES2020+ TypeScript target)
+// - `float32`, `float64` -> `number`
+//
+// This mapping assumes a target environment similar to GOOS=js, GOARCH=wasm,
+// where Go's `int` and `uint` are 32-bit and fit within TypeScript's `number`.
+var goToTypescriptPrimitives = map[string]string{
+	// Boolean
+	"bool": "boolean",
+
+	// Strings
+	"string": "string",
+
+	// Signed Integers
+	"int":   "number",
+	"int8":  "number",
+	"int16": "number",
+	"int32": "number",
+	"rune":  "number", // alias for int32
+	"int64": "bigint", // Requires TypeScript target >= ES2020
+
+	// Unsigned Integers
+	"uint":   "number",
+	"uint8":  "number", // byte is an alias for uint8
+	"byte":   "number",
+	"uint16": "number",
+	"uint32": "number",
+	"uint64": "bigint", // Requires TypeScript target >= ES2020
+
+	// Floating Point Numbers
+	"float32": "number",
+	"float64": "number",
+}
+
+func isPrimitiveType(name string) bool {
+	_, ok := goToTypescriptPrimitives[name]
+	return ok
+}
+
+// GoBuiltinToTypescript translates a Go built-in primitive type name (string)
+// to its TypeScript equivalent. It uses the `goToTypescriptPrimitives` map
+// for the conversion.
+// It returns the TypeScript type name and `true` if the Go type name is found
+// in the map. Otherwise, it returns an empty string and `false`.
+// This function only handles primitive types listed in the map; composite types
+// or custom types are not processed here.
+func GoBuiltinToTypescript(typeName string) (string, bool) {
+	val, ok := goToTypescriptPrimitives[typeName]
+	return val, ok
+}
+
+// tokenMap provides a mapping from Go `token.Token` types (representing operators
+// and punctuation) to their corresponding string representations in TypeScript.
+// This map is used by `TokenToTs` to translate Go operators during expression
+// and statement compilation.
+//
+// Examples:
+// - `token.ADD` (Go `+`) -> `"+"` (TypeScript `+`)
+// - `token.LAND` (Go `&&`) -> `"&&"` (TypeScript `&&`)
+// - `token.ASSIGN` (Go `=`) -> `"="` (TypeScript `=`)
+// - `token.DEFINE` (Go `:=`) -> `"="` (TypeScript `=`, as `let` is handled separately)
+//
+// Some tokens like `token.ARROW` (channel send/receive) are handled specially
+// in their respective expression/statement writers and might not be directly mapped here.
+// Bitwise AND NOT (`&^=`) is also mapped but may require specific runtime support if not directly translatable.
+var tokenMap = map[token.Token]string{
+	token.ADD: "+",
+	token.SUB: "-",
+	token.MUL: "*",
+	token.QUO: "/",
+	token.REM: "%",
+	token.AND: "&",
+	token.OR:  "|",
+	token.XOR: "^",
+	token.SHL: "<<",
+	token.SHR: ">>",
+
+	token.ADD_ASSIGN: "+=",
+	token.SUB_ASSIGN: "-=",
+	token.MUL_ASSIGN: "*=",
+	token.QUO_ASSIGN: "/=",
+	token.REM_ASSIGN: "%=",
+
+	token.AND_ASSIGN:     "&=",
+	token.OR_ASSIGN:      "|=",
+	token.XOR_ASSIGN:     "^=", // TODO: check if this works
+	token.SHL_ASSIGN:     "<<=",
+	token.SHR_ASSIGN:     ">>=",
+	token.AND_NOT_ASSIGN: "&^=",
+
+	token.LAND: "&&",
+	token.LOR:  "||",
+	// token.ARROW: ""
+	token.INC:    "++",
+	token.DEC:    "--",
+	token.EQL:    "==",
+	token.LSS:    "<",
+	token.GTR:    ">",
+	token.ASSIGN: "=",
+	token.NOT:    "!",
+
+	token.NEQ:      "!=",
+	token.LEQ:      "<=",
+	token.GEQ:      ">=",
+	token.DEFINE:   "=",   // :=
+	token.ELLIPSIS: "...", // TODO
+
+	token.LPAREN: "(",
+	token.LBRACK: "[",
+	token.LBRACE: "{",
+	token.COMMA:  ",",
+	token.PERIOD: ".",
+
+	token.RPAREN:    ")",
+	token.RBRACK:    "]",
+	token.RBRACE:    "}",
+	token.SEMICOLON: ";",
+	token.COLON:     ":",
+}
+
+// TokenToTs converts a Go `token.Token` (representing an operator or punctuation)
+// into its corresponding TypeScript string representation using the `tokenMap`.
+// It returns the TypeScript string and `true` if the token is found in the map.
+// Otherwise, it returns an empty string and `false`. This function is essential
+// for translating expressions involving operators (e.g., arithmetic, logical,
+// assignment operators).
+func TokenToTs(tok token.Token) (string, bool) {
+	t, ok := tokenMap[tok]
+	return t, ok
+}

package/compiler/{write-type-spec.go → spec-struct.go}

@@ -5,153 +5,19 @@ import (
 	"go/ast"
 	"go/types"
 	"strings"
-
-	// types provides type information for Go types.
-	"github.com/pkg/errors"
 )
 
-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
-}
-
+// WriteStructTypeSpec generates the TypeScript class definition for a Go struct type.
+// It handles the generation of:
+//   - The class declaration.
+//   - Getters and setters for all fields (both direct and embedded).
+//   - The internal `_fields` property, which stores field values in `$.Box` containers
+//     to maintain Go's value semantics.
+//   - A constructor that initializes the `_fields` and allows partial initialization.
+//   - A `clone` method for creating a deep copy of the struct instance.
+//   - Methods defined directly on the struct.
+//   - Wrapper methods for promoted fields and methods from embedded structs,
+//     ensuring correct access and behavior.
 func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType) error {
 	c.tsw.WriteLiterally("class ")
 	if err := c.WriteValueExpr(a.Name); err != nil {
@@ -188,7 +54,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	}
 
 	// Generate getters and setters for EMBEDDED struct fields themselves
-	for i := 0; i < underlyingStruct.NumFields(); i++ {
+	for i := range underlyingStruct.NumFields() {
 		field := underlyingStruct.Field(i)
 		if field.Anonymous() {
 			fieldKeyName := c.getEmbeddedFieldKeyName(field.Type())
@@ -221,31 +87,35 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLine("")
 	c.tsw.WriteLinef("constructor(init?: Partial<%s>) {", flattenedInitType)
 	c.tsw.Indent(1)
-	c.tsw.WriteLine("this._fields = {")
-	c.tsw.Indent(1)
+	c.tsw.WriteLiterally("this._fields = {")
 
 	numFields := underlyingStruct.NumFields()
-	for i := 0; i < numFields; i++ {
-		field := underlyingStruct.Field(i)
-		fieldType := field.Type()
-		var fieldKeyName string
-		if field.Anonymous() {
-			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
-		} else {
-			fieldKeyName = field.Name()
-		}
+	if numFields != 0 {
+		c.tsw.WriteLine("")
+		c.tsw.Indent(1)
+
+		for i := range numFields {
+			field := underlyingStruct.Field(i)
+			fieldType := field.Type()
+			var fieldKeyName string
+			if field.Anonymous() {
+				fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
+			} else {
+				fieldKeyName = field.Name()
+			}
 
-		c.writeBoxedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
+			c.writeBoxedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
 
-		if i < numFields-1 {
-			c.tsw.WriteLine(",")
-		} else {
-			c.tsw.WriteLine("")
+			if i < numFields-1 {
+				c.tsw.WriteLine(",")
+			} else {
+				c.tsw.WriteLine("")
+			}
 		}
+		c.tsw.Indent(-1)
 	}
-
-	c.tsw.Indent(-1)
 	c.tsw.WriteLine("}")
+
 	c.tsw.Indent(-1)
 	c.tsw.WriteLine("}")
 	c.tsw.WriteLine("")
@@ -257,7 +127,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLine("cloned._fields = {")
 	c.tsw.Indent(1)
 
-	for i := 0; i < numFields; i++ {
+	for i := range numFields {
 		field := underlyingStruct.Field(i)
 		fieldType := field.Type()
 		var fieldKeyName string
@@ -307,7 +177,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	seenPromotedFields := make(map[string]bool)
 	directMethods := make(map[string]bool)
 	// Populate directMethods (methods defined directly on this struct type)
-	for i := 0; i < goStructType.NumMethods(); i++ {
+	for i := range goStructType.NumMethods() {
 		method := goStructType.Method(i)
 		sig := method.Type().(*types.Signature)
 		if sig.Recv() != nil {
@@ -322,7 +192,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		}
 	}
 
-	for i := 0; i < underlyingStruct.NumFields(); i++ {
+	for i := range underlyingStruct.NumFields() {
 		field := underlyingStruct.Field(i)
 		if !field.Anonymous() {
 			continue
@@ -383,7 +253,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 
 		// Promoted methods
 		embeddedMethodSet := types.NewMethodSet(embeddedFieldType) // Use original field type for method set
-		for k := 0; k < embeddedMethodSet.Len(); k++ {
+		for k := range embeddedMethodSet.Len() {
 			methodSelection := embeddedMethodSet.At(k)
 			method := methodSelection.Obj().(*types.Func)
 			methodName := method.Name()
@@ -456,51 +326,57 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		}
 	}
 
-	// Add code to register the type with the runtime system
+	// Add code to register the type with the runtime type system
 	c.tsw.WriteLine("")
 	c.tsw.WriteLinef("// Register this type with the runtime type system")
 	c.tsw.WriteLinef("static __typeInfo = $.registerStructType(")
 	c.tsw.WriteLinef("  '%s',", className)
 	c.tsw.WriteLinef("  new %s(),", className)
-	c.tsw.WriteLinef("  new Set([%s]),", c.collectMethodNames(className)) // collectMethodNames should ideally consider promoted methods too
-	c.tsw.WriteLinef("  %s", className)
-	c.tsw.WriteLinef(");")
-
-	c.tsw.Indent(-1)
-	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.tsw.WriteLiterally("  [")
+	// Collect methods for the struct type
+	var structMethods []*types.Func
+	for i := range goStructType.NumMethods() {
+		method := goStructType.Method(i)
+		// Ensure it's a method directly on this type (not promoted here, promotion handled separately)
+		// Check if receiver is *T or T where T is goStructType
+		sig := method.Type().(*types.Signature)
+		recv := sig.Recv().Type()
+		if ptr, ok := recv.(*types.Pointer); ok {
+			recv = ptr.Elem()
+		}
+		if namedRecv, ok := recv.(*types.Named); ok && namedRecv.Obj() == goStructType.Obj() {
+			structMethods = append(structMethods, method)
+		}
 	}
-	c.WriteInterfaceType(ifaceType, t) // Pass the *ast.InterfaceType for comment fetching
+	c.writeMethodSignatures(structMethods)
+	c.tsw.WriteLiterally("],")
 	c.tsw.WriteLine("")
 
-	// Add code to register the interface with the runtime system
-	interfaceName := a.Name.Name
+	c.tsw.WriteLinef("  %s,", className)
+	// Add field type information for type assertions
+	c.tsw.WriteLiterally("  {")
+	firstField := true
+	for i := 0; i < underlyingStruct.NumFields(); i++ {
+		field := underlyingStruct.Field(i)
+		var fieldKeyName string
+		if field.Anonymous() {
+			fieldKeyName = c.getEmbeddedFieldKeyName(field.Type())
+		} else {
+			fieldKeyName = field.Name()
+		}
+		// fieldTsType := c.getTypeString(field.Type())
+		if !firstField {
+			c.tsw.WriteLiterally(", ")
+		}
+		firstField = false
+		c.tsw.WriteLiterallyf("%q: ", fieldKeyName)
+		c.writeTypeInfoObject(field.Type()) // Use writeTypeInfoObject for field types
+	}
+	c.tsw.WriteLiterally("}")
 	c.tsw.WriteLine("")
-	c.tsw.WriteLinef("$.registerInterfaceType(")
-	c.tsw.WriteLinef("  '%s',", interfaceName)
-	c.tsw.WriteLinef("  null, // Zero value for interface is null")
-	c.tsw.WriteLinef("  new Set([%s]),", c.collectInterfaceMethods(t))
 	c.tsw.WriteLinef(");")
 
+	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
 	return nil
 }

package/compiler/spec-value.go

@@ -0,0 +1,194 @@
+package compiler
+
+import (
+	"go/ast"
+	"go/token"
+
+	"github.com/pkg/errors"
+)
+
+// WriteValueSpec translates a Go value specification (`ast.ValueSpec`),
+// which represents `var` or `const` declarations, into TypeScript `let`
+// declarations.
+//
+// For single variable declarations (`var x T = val` or `var x = val` or `var x T`):
+//   - It determines if the variable `x` needs to be boxed (e.g., if its address is taken)
+//     using `c.analysis.NeedsBoxed(obj)`.
+//   - If boxed: `let x: $.Box<T_ts> = $.box(initializer_ts_or_zero_ts);`
+//     The type annotation is `$.Box<T_ts>`, and the initializer is wrapped in `$.box()`.
+//   - If not boxed: `let x: T_ts = initializer_ts_or_zero_ts;`
+//     The type annotation is `T_ts`. If the initializer is `&unboxedVar`, it becomes `$.box(unboxedVar_ts)`.
+//     If the RHS is a struct value, `.clone()` is applied to maintain Go's value semantics.
+//   - If no initializer is provided, the TypeScript zero value (from `WriteZeroValueForType`)
+//     is used.
+//   - Type `T` (or `T_ts`) is obtained from `obj.Type()` and translated via `WriteGoType`.
+//
+// For multiple variable declarations (`var a, b = val1, val2` or `a, b := val1, val2`):
+//   - It uses TypeScript array destructuring: `let [a, b] = [val1_ts, val2_ts];`.
+//   - If initialized from a single multi-return function call (`a, b := func()`),
+//     it becomes `let [a, b] = func_ts();`.
+//   - If no initializers are provided, it defaults to `let [a,b] = []` (with a TODO
+//     to assign correct individual zero values).
+//
+// Documentation comments associated with the `ValueSpec` are preserved.
+func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
+	if a.Doc != nil {
+		c.WriteDoc(a.Doc)
+	}
+	if a.Comment != nil {
+		c.WriteDoc(a.Comment)
+	}
+
+	// Handle single variable declaration
+	if len(a.Names) == 1 {
+		name := a.Names[0]
+		obj := c.pkg.TypesInfo.Defs[name]
+		if obj == nil {
+			return errors.Errorf("could not resolve type: %v", name)
+		}
+
+		goType := obj.Type()
+		needsBox := c.analysis.NeedsBoxed(obj) // Check if address is taken
+
+		// 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)
+		}
+
+		// 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)
+			if callExpr, isCallExpr := initializerExpr.(*ast.CallExpr); isCallExpr {
+				if starExpr, isStarExpr := callExpr.Fun.(*ast.StarExpr); isStarExpr {
+					if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
+						// Check if the argument is nil
+						if len(callExpr.Args) == 1 {
+							if nilIdent, isIdent := callExpr.Args[0].(*ast.Ident); isIdent && nilIdent.Name == "nil" {
+								c.tsw.WriteLiterally("null")
+								return nil
+							}
+						}
+					}
+				}
+			}
+		}
+
+		if needsBox {
+			// Boxed variable: let v: Box<T> = $.box(init_or_zero);
+			c.tsw.WriteLiterally("$.box(")
+			if hasInitializer {
+				// Write the compiled initializer expression normally
+				if err := c.WriteValueExpr(initializerExpr); err != nil {
+					return err
+				}
+			} else {
+				// No initializer, box the zero value
+				c.WriteZeroValueForType(goType)
+			}
+			c.tsw.WriteLiterally(")")
+		} else {
+			// Unboxed variable: let v: T = init_or_zero;
+			if hasInitializer {
+				// Handle &v initializer specifically for unboxed variables
+				if unaryExpr, isUnary := initializerExpr.(*ast.UnaryExpr); isUnary && unaryExpr.Op == token.AND {
+					// Initializer is &v
+					// Check if v is boxed
+					needsBoxOperand := false
+					unaryExprXIdent, ok := unaryExpr.X.(*ast.Ident)
+					if ok {
+						innerObj := c.pkg.TypesInfo.Uses[unaryExprXIdent]
+						needsBoxOperand = innerObj != nil && c.analysis.NeedsBoxed(innerObj)
+					}
+
+					// If v is boxed, assign the box itself (v)
+					// If v is not boxed, assign $.box(v)
+					if needsBoxOperand {
+						// special handling: do not write .value here.
+						c.WriteIdent(unaryExprXIdent, false)
+					} else {
+						// &unboxedVar -> $.box(unboxedVar)
+						c.tsw.WriteLiterally("$.box(")
+						if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Write 'v'
+							return err
+						}
+						c.tsw.WriteLiterally(")")
+					}
+				} else {
+					// Regular initializer, clone if needed
+					if shouldApplyClone(c.pkg, initializerExpr) {
+						if err := c.WriteValueExpr(initializerExpr); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(".clone()")
+					} else {
+						if err := c.WriteValueExpr(initializerExpr); err != nil {
+							return err
+						}
+					}
+				}
+			} else {
+				// No initializer, use the zero value directly
+				c.WriteZeroValueForType(goType)
+			}
+		}
+		c.tsw.WriteLine("") // Finish the declaration line
+		return nil
+	}
+
+	// --- Multi-variable declaration (existing logic seems okay, but less common for pointers) ---
+	c.tsw.WriteLiterally("let ")
+	c.tsw.WriteLiterally("[") // Use array destructuring for multi-assign
+	for i, name := range a.Names {
+		if i != 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		c.tsw.WriteLiterally(name.Name)
+		// TODO: Add type annotations for multi-var declarations if possible/needed
+	}
+	c.tsw.WriteLiterally("]")
+	if len(a.Values) > 0 {
+		// TODO: handle other kinds of assignment += -= etc.
+		c.tsw.WriteLiterally(" = ")
+		if len(a.Values) == 1 && len(a.Names) > 1 {
+			// Assign from a single multi-return value
+			if err := c.WriteValueExpr(a.Values[0]); err != nil {
+				return err
+			}
+		} else {
+			// Assign from multiple values
+			c.tsw.WriteLiterally("[")
+			for i, val := range a.Values {
+				if i != 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				if err := c.WriteValueExpr(val); err != nil { // Initializers are values
+					return err
+				}
+			}
+			c.tsw.WriteLiterally("]")
+		}
+	} else {
+		// No initializer, assign default values (complex for multi-assign)
+		// For simplicity, assign default array based on context (needs improvement)
+		c.tsw.WriteLiterally(" = []") // Placeholder
+		// TODO: Assign correct zero values based on types
+	}
+	c.tsw.WriteLine("") // Use WriteLine instead of WriteLine(";")
+	return nil
+}