goscript 0.0.23 → 0.0.24

package/compiler/expr-star.go

@@ -1,89 +1,81 @@
 package compiler
 
 import (
-	"fmt"
 	"go/ast"
+	"go/types"
 )
 
 // WriteStarExpr translates a Go pointer dereference expression (`ast.StarExpr`, e.g., `*p`)
 // into its TypeScript equivalent. This involves careful handling of Go's pointers
-// and TypeScript's boxing mechanism for emulating pointer semantics.
+// and TypeScript's varRefing mechanism for emulating pointer semantics.
 //
-// The translation depends on whether the pointer variable `p` itself is boxed and
+// The translation depends on whether the pointer variable `p` itself is varrefed and
 // what type of value it points to:
-//  1. If `p` is not boxed and points to a primitive or another pointer: `*p` -> `p!.value`.
-//     (`p` holds a box, so dereference accesses its `value` field).
-//  2. If `p` is not boxed and points to a struct: `*p` -> `p!`.
+//  1. If `p` is not varrefed and points to a primitive or another pointer: `*p` -> `p!.value`.
+//     (`p` holds a varRef, so dereference accesses its `value` field).
+//  2. If `p` is not varrefed and points to a struct: `*p` -> `p!`.
 //     (`p` holds the struct instance directly; structs are reference types in TS).
-//  3. If `p` is boxed (i.e., `p` is `$.Box<PointerType>`) and points to a primitive/pointer:
-//     `*p` -> `p.value!.value`.
-//     (First `.value` unboxes `p`, then `!.value` dereferences the inner pointer).
-//  4. If `p` is boxed and points to a struct: `*p` -> `p.value!`.
-//     (First `.value` unboxes `p` to get the struct instance).
+//  3. If `p` is variable referenced (i.e., `p` is `$.VarRef<PointerType>`) and points to a primitive/pointer:
+//     `p.value!.value` (access the variable reference, then dereference the pointer)
+//  4. If `p` is varrefed and points to a struct: `p.value!`.
+//     (First `.value` unvarRefes `p` to get the struct instance).
 //
-// `WriteValueExpr(operand)` handles the initial unboxing of `p` if `p` itself is a boxed variable.
+// `WriteValueExpr(operand)` handles the initial unvarRefing of `p` if `p` itself is a varrefed variable.
 // A non-null assertion `!` is always added as pointers can be nil.
-// `c.analysis.NeedsBoxedDeref(ptrType)` determines if an additional `.value` is needed
-// based on whether the dereferenced type is a primitive/pointer (requires `.value`) or
-// a struct (does not require `.value`).
+// The function determines if `.value` access is needed by checking what the Go pointer operand points to.
+//
+// For multi-level dereferences like `***p`, this function is called recursively, with each level
+// adding the appropriate `!.value` suffix.
+//
+// Examples:
+//   - Simple pointer to primitive: `p!.value` (where p is *int)
+//   - Variable referenced pointer to primitive: `p.value!.value` (where p is VarRef<*int>)
+//     Example: let p = $.varRef(x) (where x is another variable reference) => p.value!.value
+//   - Pointer to struct: `p!` (where p is *MyStruct)
+//     Example: let p = $.varRef(new MyStruct()) => p.value!
+//   - Variable referenced pointer to struct: `p.value!` (where p is VarRef<*MyStruct>)
+//   - Triple pointer: `p3!.value!.value!.value` (where p3 is VarRef<VarRef<VarRef<number> | null> | null> | null)
 func (c *GoToTSCompiler) WriteStarExpr(exp *ast.StarExpr) error {
-	// Generate code for a pointer dereference expression (*p).
-	//
-	// IMPORTANT: Pointer dereferencing in TypeScript requires careful handling of the box/unbox state:
-	//
-	// 1. p!.value - when p is not boxed and points to a primitive/pointer
-	//    Example: let p = x (where x is a box) => p!.value
-	//
-	// 2. p!       - when p is not boxed and points to a struct
-	//    Example: let p = new MyStruct() => p! (structs are reference types)
-	//
-	// 3. p.value!.value - when p is boxed and points to a primitive/pointer
-	//    Example: let p = $.box(x) (where x is another box) => p.value!.value
-	//
-	// 4. p.value! - when p is boxed and points to a struct
-	//    Example: let p = $.box(new MyStruct()) => p.value!
-	//
-	// Critical bug fix: We must handle each case correctly to avoid over-dereferencing
-	// (adding too many .value) or under-dereferencing (missing .value where needed)
-	//
-	// NOTE: This logic aligns with design/BOXES_POINTERS.md.
-
-	// Get the operand expression and its type information
-	operand := exp.X
-
-	// Get the type of the operand (the pointer being dereferenced)
-	ptrType := c.pkg.TypesInfo.TypeOf(operand)
-
-	// Special case for handling multi-level dereferencing:
-	// Check if the operand is itself a StarExpr (e.g., **p or ***p)
-	// We need to handle these specially to correctly generate nested .value accesses
-	if starExpr, isStarExpr := operand.(*ast.StarExpr); isStarExpr {
-		// First, write the inner star expression
-		if err := c.WriteStarExpr(starExpr); err != nil {
-			return fmt.Errorf("failed to write inner star expression: %w", err)
+	// Check if the operand is an identifier that is varrefed
+	isVarrefedIdent := false
+	if ident, ok := exp.X.(*ast.Ident); ok {
+		if obj := c.pkg.TypesInfo.ObjectOf(ident); obj != nil {
+			isVarrefedIdent = c.analysis.NeedsVarRef(obj)
 		}
-
-		// Always add .value for multi-level dereferences
-		// For expressions like **p, each * adds a .value
-		c.tsw.WriteLiterally("!.value")
-		return nil
 	}
 
-	// Standard case: single-level dereference
-	// Write the pointer expression, which will access .value if the variable is boxed
-	// WriteValueExpr will add .value if the variable itself is boxed (p.value)
-	if err := c.WriteValueExpr(operand); err != nil {
-		return fmt.Errorf("failed to write star expression operand: %w", err)
+	// Write the operand
+	if isVarrefedIdent {
+		// For varrefed identifiers, we need to access the value first
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+	} else {
+		// For non-varrefed identifiers and other expressions
+		switch operand := exp.X.(type) {
+		case *ast.Ident:
+			// Write identifier without .value access
+			c.WriteIdent(operand, false)
+		default:
+			// For other expressions (like nested star expressions), use WriteValueExpr
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return err
+			}
+		}
 	}
 
-	// Add ! for null assertion - all pointers can be null in TypeScript
+	// Add non-null assertion for pointer safety
 	c.tsw.WriteLiterally("!")
 
-	// Add .value only if we need boxed dereferencing for this type of pointer
-	// This depends on whether we're dereferencing to a primitive (needs .value)
-	// or to a struct (no .value needed)
-	if c.analysis.NeedsBoxedDeref(ptrType) {
-		c.tsw.WriteLiterally(".value")
+	// Check what the operand points to (not what the result is)
+	operandType := c.pkg.TypesInfo.TypeOf(exp.X)
+	if ptrType, isPtr := operandType.(*types.Pointer); isPtr {
+		elemType := ptrType.Elem()
+		// Only add .value if NOT pointing to a struct
+		if _, isStruct := elemType.Underlying().(*types.Struct); !isStruct {
+			c.tsw.WriteLiterally(".value")
+		}
+		// If pointing to a struct, don't add .value (structs are reference types in TS)
 	}
 
 	return nil

package/compiler/expr-type.go

@@ -11,7 +11,7 @@ import (
 // It handles various Go type expressions:
 // - Basic types (e.g., int, string, bool) -> TypeScript primitives (number, string, boolean)
 // - Named types -> TypeScript class/interface names
-// - Pointer types (`*T`) -> `$.Box<T_ts> | null`
+// - Pointer types (`*T`) -> `$.VarRef<T_ts> | null`
 // - Slice types (`[]T`) -> `$.Slice<T_ts>`
 // - Array types (`[N]T`) -> `T_ts[]`
 // - Map types (`map[K]V`) -> `Map<K_ts, V_ts>`

package/compiler/expr-value.go

@@ -7,7 +7,7 @@ import (
 // WriteValueExpr translates a Go abstract syntax tree (AST) expression (`ast.Expr`)
 // that represents a value into its TypeScript value equivalent.
 // This is a central dispatch function for various expression types:
-// - Identifiers (`ast.Ident`): Delegates to `WriteIdent`, potentially adding `.value` for boxed variables.
+// - Identifiers (`ast.Ident`): Delegates to `WriteIdent`, potentially adding `.value` for varrefed variables.
 // - Selector expressions (`ast.SelectorExpr`, e.g., `obj.Field` or `pkg.Var`): Delegates to `WriteSelectorExpr`.
 // - Pointer dereferences (`ast.StarExpr`, e.g., `*ptr`): Delegates to `WriteStarExpr`.
 // - Function calls (`ast.CallExpr`): Delegates to `WriteCallExpr`.

package/compiler/expr.go

@@ -157,7 +157,7 @@ func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
 // of the left (X) and right (Y) operands of the binary expression.
 // Returns `true` if both operands are determined to be pointer types,
 // `false` otherwise. This is used to apply specific comparison semantics
-// for pointers (e.g., comparing the box objects directly).
+// for pointers (e.g., comparing the varRef objects directly).
 func (c *GoToTSCompiler) isPointerComparison(exp *ast.BinaryExpr) bool {
 	leftType := c.pkg.TypesInfo.TypeOf(exp.X)
 	rightType := c.pkg.TypesInfo.TypeOf(exp.Y)
@@ -195,10 +195,10 @@ func (c *GoToTSCompiler) getTypeNameString(typeExpr ast.Expr) string {
 // It handles several cases:
 //   - Channel send (`ch <- val`): Becomes `await ch.send(val)`.
 //   - Nil comparison for pointers (`ptr == nil` or `ptr != nil`): Compares the
-//     pointer (which may be a box object or `null`) directly to `null` using
+//     pointer (which may be a varRef object or `null`) directly to `null` using
 //     the translated operator (`==` or `!=`).
 //   - Pointer comparison (non-nil, `ptr1 == ptr2` or `ptr1 != ptr2`): Compares
-//     the box objects directly using strict equality (`===` or `!==`).
+//     the varRef objects directly using strict equality (`===` or `!==`).
 //   - Bitwise operations (`&`, `|`, `^`, `<<`, `>>`, `&^`): The expression is wrapped
 //     in parentheses `()` to ensure correct precedence in TypeScript, and operators
 //     are mapped (e.g., `&^` might need special handling or is mapped to a runtime helper).
@@ -243,9 +243,26 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	}
 
 	if isNilComparison {
-		// Compare the box object directly to null
-		if err := c.WriteValueExpr(ptrExpr); err != nil {
-			return fmt.Errorf("failed to write pointer expression in nil comparison: %w", err)
+		// For nil comparisons, we need to decide whether to write .value or not
+		// If the pointer variable is varrefed, we need to access .value
+		if ident, ok := ptrExpr.(*ast.Ident); ok {
+			if obj := c.pkg.TypesInfo.ObjectOf(ident); obj != nil {
+				if c.analysis.NeedsVarRef(obj) {
+					// Variable is varrefed, so we need to access .value
+					c.WriteIdent(ident, true) // This will add .value
+				} else {
+					// Variable is not varrefed, write directly
+					c.WriteIdent(ident, false)
+				}
+			} else {
+				// No object info, write directly
+				c.WriteIdent(ident, false)
+			}
+		} else {
+			// For other expressions, use WriteValueExpr (but this might need review)
+			if err := c.WriteValueExpr(ptrExpr); err != nil {
+				return fmt.Errorf("failed to write pointer expression in nil comparison: %w", err)
+			}
 		}
 		c.tsw.WriteLiterally(" ")
 		tokStr, ok := TokenToTs(exp.Op)
@@ -258,7 +275,7 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	}
 
 	// Check if this is a pointer comparison (non-nil)
-	// Compare the box objects directly using === or !==
+	// Compare the varRef objects directly using === or !==
 	if c.isPointerComparison(exp) {
 		c.tsw.WriteLiterally("(") // Wrap comparison
 		if err := c.WriteValueExpr(exp.X); err != nil {
@@ -284,6 +301,50 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		return nil
 	}
 
+	// Check for Duration arithmetic operations (multiplication)
+	if exp.Op == token.MUL && c.pkg != nil && c.pkg.TypesInfo != nil {
+		leftType := c.pkg.TypesInfo.TypeOf(exp.X)
+		rightType := c.pkg.TypesInfo.TypeOf(exp.Y)
+
+		// Check if left operand is a Duration type (from time package)
+		if leftType != nil {
+			if namedType, ok := leftType.(*types.Named); ok {
+				if namedType.Obj().Pkg() != nil && namedType.Obj().Pkg().Path() == "time" && namedType.Obj().Name() == "Duration" {
+					// Duration * number -> Duration.multiply(duration, number)
+					c.tsw.WriteLiterally("$.multiplyDuration(")
+					if err := c.WriteValueExpr(exp.X); err != nil {
+						return fmt.Errorf("failed to write Duration in multiplication: %w", err)
+					}
+					c.tsw.WriteLiterally(", ")
+					if err := c.WriteValueExpr(exp.Y); err != nil {
+						return fmt.Errorf("failed to write multiplier in Duration multiplication: %w", err)
+					}
+					c.tsw.WriteLiterally(")")
+					return nil
+				}
+			}
+		}
+
+		// Check if right operand is a Duration type (number * Duration)
+		if rightType != nil {
+			if namedType, ok := rightType.(*types.Named); ok {
+				if namedType.Obj().Pkg() != nil && namedType.Obj().Pkg().Path() == "time" && namedType.Obj().Name() == "Duration" {
+					// number * Duration -> Duration.multiply(duration, number)
+					c.tsw.WriteLiterally("$.multiplyDuration(")
+					if err := c.WriteValueExpr(exp.Y); err != nil {
+						return fmt.Errorf("failed to write Duration in multiplication: %w", err)
+					}
+					c.tsw.WriteLiterally(", ")
+					if err := c.WriteValueExpr(exp.X); err != nil {
+						return fmt.Errorf("failed to write multiplier in Duration multiplication: %w", err)
+					}
+					c.tsw.WriteLiterally(")")
+					return nil
+				}
+			}
+		}
+	}
+
 	// Check if the operator is a bitwise operator
 	isBitwise := false
 	switch exp.Op {
@@ -334,11 +395,11 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 // It handles several unary operations:
 // - Channel receive (`<-ch`): Becomes `await ch.receive()`.
 // - Address-of (`&var`):
-//   - If `var` is a boxed variable (its address was taken), `&var` evaluates
-//     to the box itself (i.e., `varName` in TypeScript, which holds the box).
-//   - Otherwise (e.g., `&unboxedVar`, `&MyStruct{}`, `&FuncCall()`), it evaluates
+//   - If `var` is a varrefed variable (its address was taken), `&var` evaluates
+//     to the varRef itself (i.e., `varName` in TypeScript, which holds the varRef).
+//   - Otherwise (e.g., `&unvarrefedVar`, `&MyStruct{}`, `&FuncCall()`), it evaluates
 //     the operand `var`. The resulting TypeScript value (e.g., a new object instance)
-//     acts as the "pointer". Boxing decisions for such pointers are handled at
+//     acts as the "pointer". VarRefing decisions for such pointers are handled at
 //     the assignment site.
 //   - Other unary operators (`+`, `-`, `!`, `^`): Mapped to their TypeScript
 //     equivalents (e.g., `+`, `-`, `!`, `~` for bitwise NOT). Parentheses are added
@@ -359,26 +420,26 @@ func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 	}
 
 	if exp.Op == token.AND { // Address-of operator (&)
-		// If the operand is an identifier for a variable that is boxed,
-		// the result of & is the box itself.
+		// If the operand is an identifier for a variable that is varrefed,
+		// the result of & is the varRef itself.
 		if ident, ok := exp.X.(*ast.Ident); ok {
 			var obj types.Object
 			obj = c.pkg.TypesInfo.Uses[ident]
 			if obj == nil {
 				obj = c.pkg.TypesInfo.Defs[ident]
 			}
-			if obj != nil && c.analysis.NeedsBoxed(obj) {
-				// &boxedVar -> boxedVar (the box itself)
-				c.tsw.WriteLiterally(ident.Name) // Write the identifier name (which holds the box)
+			if obj != nil && c.analysis.NeedsVarRef(obj) {
+				// &varRefVar -> varRefVar (the variable reference itself)
+				c.tsw.WriteLiterally(ident.Name) // Write the identifier name (which holds the variable reference)
 				return nil
 			}
 		}
 
-		// Otherwise (&unboxedVar, &CompositeLit{}, &FuncCall(), etc.),
+		// Otherwise (&unvarrefedVar, &CompositeLit{}, &FuncCall(), etc.),
 		// the address-of operator in Go, when used to create a pointer,
 		// translates to simply evaluating the operand in TypeScript.
 		// The resulting value (e.g., a new object instance) acts as the "pointer".
-		// Boxing decisions are handled at the assignment site based on the LHS variable.
+		// VarRefing decisions are handled at the assignment site based on the LHS variable.
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write &-operand: %w", err)
 		}

package/compiler/primitive.go

@@ -82,16 +82,17 @@ func GoBuiltinToTypescript(typeName string) (string, bool) {
 // 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:     "+",
+	token.SUB:     "-",
+	token.MUL:     "*",
+	token.QUO:     "/",
+	token.REM:     "%",
+	token.AND:     "&",
+	token.OR:      "|",
+	token.XOR:     "^",
+	token.SHL:     "<<",
+	token.SHR:     ">>",
+	token.AND_NOT: "& ~", // &^ operator: bitwise AND NOT
 
 	token.ADD_ASSIGN: "+=",
 	token.SUB_ASSIGN: "-=",

package/compiler/spec-struct.go

@@ -12,7 +12,7 @@ import (
 // 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
+//   - The internal `_fields` property, which stores field values in `$.VarRef` 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.
@@ -83,7 +83,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			fieldKeyName = field.Name()
 		}
 		fieldTsType := c.getTypeString(field.Type())
-		c.tsw.WriteLinef("%s: $.Box<%s>;", fieldKeyName, fieldTsType)
+		c.tsw.WriteLinef("%s: $.VarRef<%s>;", fieldKeyName, fieldTsType)
 	}
 	c.tsw.Indent(-1)
 	c.tsw.WriteLine("}")
@@ -111,7 +111,7 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 				fieldKeyName = field.Name()
 			}
 
-			c.writeBoxedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
+			c.writeVarRefedFieldInitializer(fieldKeyName, fieldType, field.Anonymous())
 
 			if i < numFields-1 {
 				c.tsw.WriteLine(",")

package/compiler/spec-value.go

@@ -12,13 +12,12 @@ import (
 // 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.
+//   - It determines if the variable `x` needs to be varrefed (e.g., if its address is taken)
+//     using `c.analysis.NeedsVarRef(obj)`.
+//   - If variable referenced: `let x: $.VarRef<T_ts> = $.varRef(initializer_ts_or_zero_ts);`
+//     The type annotation is `$.VarRef<T_ts>`, and the initializer is wrapped in `$.varRef()`.
+//   - If not variable referenced: `let x: T_ts = initializer_ts_or_zero_ts;`
+//     The type annotation is `T_ts`. If the initializer is `&unvarrefedVar`, it becomes `$.varRef(unvarrefedVar_ts)`.
 //   - 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`.
@@ -48,7 +47,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 		}
 
 		goType := obj.Type()
-		needsBox := c.analysis.NeedsBoxed(obj) // Check if address is taken
+		needsVarRef := c.analysis.NeedsVarRef(obj) // Check if address is taken
 
 		hasInitializer := len(a.Values) > 0
 		var initializerExpr ast.Expr
@@ -86,17 +85,64 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 		c.tsw.WriteLiterally("let ")
 		c.tsw.WriteLiterally(name.Name)
 
-		if !isSliceConversion {
+		// Write type annotation if:
+		// 1. Not a slice conversion (normal case), OR
+		// 2. Is a slice conversion but needs varRefing (we need explicit type for $.varRef())
+		if !isSliceConversion || needsVarRef {
 			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
+			if needsVarRef {
+				// If varrefed, the variable holds VarRef<OriginalGoType>
+				c.tsw.WriteLiterally("$.VarRef<")
+
+				// Special case: if this is a slice conversion from an array type,
+				// we should use the slice type instead of the array type
+				if isSliceConversion {
+					if arrayType, isArray := goType.Underlying().(*types.Array); isArray {
+						// Convert [N]T to $.Slice<T>
+						c.tsw.WriteLiterally("$.Slice<")
+						c.WriteGoType(arrayType.Elem(), GoTypeContextGeneral)
+						c.tsw.WriteLiterally(">")
+					} else {
+						// For slice types, write as-is (already $.Slice<T>)
+						c.WriteGoType(goType, GoTypeContextGeneral)
+					}
+				} else {
+						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)
+				// If not varrefed, the variable holds the translated Go type directly
+				// Custom logic for non-var-ref'd pointers to structs/interfaces.
+				if ptrType, isPtr := goType.(*types.Pointer); isPtr {
+					elemType := ptrType.Elem()
+					actualElemType := elemType.Underlying() // Get the true underlying type (e.g., struct, interface, basic)
+
+					isStruct := false
+					if _, ok := actualElemType.(*types.Struct); ok {
+						isStruct = true
+					}
+
+					isInterface := false
+					if _, ok := actualElemType.(*types.Interface); ok {
+						isInterface = true
+					}
+
+					if isStruct || isInterface {
+						// For non-var-ref'd pointers to structs or interfaces,
+						// the type is T | null, not $.VarRef<T> | null.
+						c.WriteGoType(elemType, GoTypeContextGeneral) // Write the element type itself (e.g., MyStruct)
+						c.tsw.WriteLiterally(" | null")
+					} else {
+						// For other pointer types (e.g., *int, *string, *[]int, **MyStruct),
+						// or pointers to types that are not structs/interfaces,
+						// use the standard pointer type translation.
+						c.WriteGoType(goType, GoTypeContextGeneral)
+					}
+				} else {
+					// Not a pointer type, write as is.
+					c.WriteGoType(goType, GoTypeContextGeneral)
+				}
 			}
 		}
 
@@ -121,41 +167,41 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 			}
 		}
 
-		if needsBox {
-			// Boxed variable: let v: Box<T> = $.box(init_or_zero);
-			c.tsw.WriteLiterally("$.box(")
+		if needsVarRef {
+			// VarRef variable: let v: VarRef<T> = $.varRef(init_or_zero);
+			c.tsw.WriteLiterally("$.varRef(")
 			if hasInitializer {
 				// Write the compiled initializer expression normally
 				if err := c.WriteValueExpr(initializerExpr); err != nil {
 					return err
 				}
 			} else {
-				// No initializer, box the zero value
+				// No initializer, varRef the zero value
 				c.WriteZeroValueForType(goType)
 			}
 			c.tsw.WriteLiterally(")")
 		} else {
-			// Unboxed variable: let v: T = init_or_zero;
+			// Unvarrefed variable: let v: T = init_or_zero;
 			if hasInitializer {
-				// Handle &v initializer specifically for unboxed variables
+				// Handle &v initializer specifically for unvarrefed variables
 				if unaryExpr, isUnary := initializerExpr.(*ast.UnaryExpr); isUnary && unaryExpr.Op == token.AND {
 					// Initializer is &v
-					// Check if v is boxed
-					needsBoxOperand := false
+					// Check if v is varrefed
+					needsVarRefOperand := false
 					unaryExprXIdent, ok := unaryExpr.X.(*ast.Ident)
 					if ok {
 						innerObj := c.pkg.TypesInfo.Uses[unaryExprXIdent]
-						needsBoxOperand = innerObj != nil && c.analysis.NeedsBoxed(innerObj)
+						needsVarRefOperand = innerObj != nil && c.analysis.NeedsVarRef(innerObj)
 					}
 
-					// If v is boxed, assign the box itself (v)
-					// If v is not boxed, assign $.box(v)
-					if needsBoxOperand {
+					// If v is varrefed, assign the varRef itself (v)
+					// If v is not varrefed, assign $.varRef(v)
+					if needsVarRefOperand {
 						// special handling: do not write .value here.
 						c.WriteIdent(unaryExprXIdent, false)
 					} else {
-						// &unboxedVar -> $.box(unboxedVar)
-						c.tsw.WriteLiterally("$.box(")
+						// &unvarrefedVar -> $.varRef(unvarrefedVar)
+						c.tsw.WriteLiterally("$.varRef(")
 						if err := c.WriteValueExpr(unaryExpr.X); err != nil { // Write 'v'
 							return err
 						}

package/compiler/spec.go

@@ -78,9 +78,9 @@ func (c *GoToTSCompiler) writeGetterSetter(fieldName string, fieldType types.Typ
 	c.tsw.WriteLine("")
 }
 
-func (c *GoToTSCompiler) writeBoxedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
+func (c *GoToTSCompiler) writeVarRefedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
 	c.tsw.WriteLiterally(fieldName)
-	c.tsw.WriteLiterally(": $.box(")
+	c.tsw.WriteLiterally(": $.varRef(")
 
 	if isEmbedded {
 		if _, isPtr := fieldType.(*types.Pointer); isPtr {
@@ -112,7 +112,7 @@ func (c *GoToTSCompiler) writeBoxedFieldInitializer(fieldName string, fieldType
 
 func (c *GoToTSCompiler) writeClonedFieldInitializer(fieldName string, fieldType types.Type, isEmbedded bool) {
 	c.tsw.WriteLiterally(fieldName)
-	c.tsw.WriteLiterally(": $.box(")
+	c.tsw.WriteLiterally(": $.varRef(")
 
 	if isEmbedded {
 		isPointerToStruct := false
@@ -183,6 +183,12 @@ func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.Interfac
 	if err := c.WriteValueExpr(a.Name); err != nil {
 		return err
 	}
+
+	// Write type parameters if present (for generics)
+	if a.TypeParams != nil {
+		c.WriteTypeParameters(a.TypeParams)
+	}
+
 	c.tsw.WriteLiterally(" = ")
 	// Get the types.Interface from the ast.InterfaceType.
 	// For an interface definition like `type MyInterface interface { M() }`,

package/compiler/stmt-assign.go

@@ -33,7 +33,7 @@ import (
 //   - 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);`.
+//   - Short declaration `x := y`: `let x = y_ts;`. If `x` is variable referenced, `let x: $.VarRef<T> = $.varRef(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.
@@ -44,7 +44,7 @@ import (
 // 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
+// It correctly applies `let` for `:=` (define) tokens and handles varRefing 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.
@@ -147,6 +147,10 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 				hasSelectors = true
 				break
 			}
+			if _, ok := lhsExpr.(*ast.StarExpr); ok {
+				hasSelectors = true
+				break
+			}
 		}
 
 		// If we have selector expressions, we need to ensure variables are initialized
@@ -176,6 +180,21 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 					if err := c.WriteValueExpr(selectorExpr); err != nil {
 						return fmt.Errorf("failed to write selector expression in LHS: %w", err)
 					}
+				} else if starExpr, ok := lhsExpr.(*ast.StarExpr); ok {
+					// Handle pointer dereference assignment: *p = value becomes p!.value = value
+					// Write the pointer variable directly without using WriteValueExpr
+					// because we don't want automatic .value access here
+					switch operand := starExpr.X.(type) {
+					case *ast.Ident:
+						// Write identifier without .value access
+						c.WriteIdent(operand, false)
+					default:
+						// For other expressions, use WriteValueExpr
+						if err := c.WriteValueExpr(starExpr.X); err != nil {
+							return fmt.Errorf("failed to write star expression X in LHS: %w", err)
+						}
+					}
+					c.tsw.WriteLiterally("!.value")
 				} else {
 					return errors.Errorf("unhandled LHS expression in assignment: %T", lhsExpr)
 				}
@@ -211,6 +230,21 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 				if err := c.WriteValueExpr(selectorExpr); err != nil {
 					return fmt.Errorf("failed to write selector expression in LHS: %w", err)
 				}
+			} else if starExpr, ok := lhsExpr.(*ast.StarExpr); ok {
+				// Handle pointer dereference in destructuring: *p becomes p!.value
+				// Write the pointer variable directly without using WriteValueExpr
+				// because we don't want automatic .value access here
+				switch operand := starExpr.X.(type) {
+				case *ast.Ident:
+					// Write identifier without .value access
+					c.WriteIdent(operand, false)
+				default:
+					// For other expressions, use WriteValueExpr
+					if err := c.WriteValueExpr(starExpr.X); err != nil {
+						return fmt.Errorf("failed to write star expression X in destructuring: %w", err)
+					}
+				}
+				c.tsw.WriteLiterally("!.value")
 			} else {
 				// Should not happen for valid Go code in this context, but handle defensively
 				return errors.Errorf("unhandled LHS expression in destructuring: %T", lhsExpr)