goscript 0.0.23 → 0.0.25

package/compiler/expr-selector.go

@@ -13,16 +13,16 @@ import (
 // access on an object or struct.
 //   - For package selectors, it writes `PackageName.IdentifierName`. The `IdentifierName`
 //     is written using `WriteIdent` which handles potential `.value` access if the
-//     package-level variable is boxed.
+//     package-level variable is varrefed.
 //   - For field or method access on an object (`exp.X`), it first writes the base
-//     expression (`exp.X`) using `WriteValueExpr` (which handles its own boxing).
+//     expression (`exp.X`) using `WriteValueExpr` (which handles its own varRefing).
 //     Then, it writes a dot (`.`) followed by the selected identifier (`exp.Sel`)
-//     using `WriteIdent`, which appends `.value` if the field itself is boxed
+//     using `WriteIdent`, which appends `.value` if the field itself is varrefed
 //     (e.g., accessing a field of primitive type through a pointer to a struct
 //     where the field's address might have been taken).
 //
 // This function aims to correctly navigate Go's automatic dereferencing and
-// TypeScript's explicit boxing model.
+// TypeScript's explicit varRefing model.
 func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 	// Check if this is a package selector (e.g., time.Now)
 	if pkgIdent, isPkgIdent := exp.X.(*ast.Ident); isPkgIdent {
@@ -31,62 +31,89 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 				// Package selectors should never use .value on the package name
 				c.tsw.WriteLiterally(pkgIdent.Name)
 				c.tsw.WriteLiterally(".")
-				// Write the selected identifier, allowing .value if it's a boxed package variable
+				// Write the selected identifier, allowing .value if it's a varrefed package variable
 				c.WriteIdent(exp.Sel, true)
 				return nil
 			}
 		}
 	}
 
-	// --- Special case for dereferenced pointer to struct with field access: (*p).field ---
+	// --- Special case for dereferenced pointer to struct with field access: (*p).field or (**p).field etc ---
 	var baseExpr ast.Expr = exp.X
 	// Look inside parentheses if present
 	if parenExpr, isParen := exp.X.(*ast.ParenExpr); isParen {
 		baseExpr = parenExpr.X
 	}
 
+	// Check if we have one or more star expressions (dereferences)
 	if starExpr, isStarExpr := baseExpr.(*ast.StarExpr); isStarExpr {
-		// Get the type of the pointer being dereferenced (e.g., type of 'p' in *p)
-		ptrType := c.pkg.TypesInfo.TypeOf(starExpr.X)
-		if ptrType != nil {
-			if ptrTypeUnwrapped, ok := ptrType.(*types.Pointer); ok {
-				elemType := ptrTypeUnwrapped.Elem()
-				if elemType != nil {
-					// If it's a pointer to a struct, handle field access specially
-					if _, isStruct := elemType.Underlying().(*types.Struct); isStruct {
-						// Get the object for the pointer variable itself (e.g., 'p')
-						var ptrObj types.Object
-						if ptrIdent, isIdent := starExpr.X.(*ast.Ident); isIdent {
-							ptrObj = c.pkg.TypesInfo.ObjectOf(ptrIdent)
-						}
+		// Count the levels of dereference and find the innermost expression
+		dereferenceCount := 0
+		currentExpr := baseExpr
+		for {
+			if star, ok := currentExpr.(*ast.StarExpr); ok {
+				dereferenceCount++
+				currentExpr = star.X
+			} else {
+				break
+			}
+		}
 
-						// Write the pointer expression (e.g., p or p.value if p is boxed)
-						if err := c.WriteValueExpr(starExpr.X); err != nil {
-							return fmt.Errorf("failed to write pointer expression for (*p).field: %w", err)
-						}
+		// Get the type of the innermost expression (the pointer variable)
+		innerType := c.pkg.TypesInfo.TypeOf(currentExpr)
+		if innerType != nil {
+			// Check if after all dereferences we end up with a struct
+			finalType := innerType
+			for i := 0; i < dereferenceCount; i++ {
+				if ptrType, ok := finalType.(*types.Pointer); ok {
+					finalType = ptrType.Elem()
+				} else {
+					break
+				}
+			}
 
-						// Add ! for non-null assertion
-						c.tsw.WriteLiterally("!")
+			// If the final type is a struct, handle field access specially
+			if _, isStruct := finalType.Underlying().(*types.Struct); isStruct {
+				// Write the fully dereferenced expression
+				if err := c.WriteValueExpr(starExpr); err != nil {
+					return fmt.Errorf("failed to write dereferenced expression for field access: %w", err)
+				}
 
-						// Add .value ONLY if the pointer variable itself needs boxed access
-						// This handles the case where 'p' points to a boxed struct (e.g., p = s where s is Box<MyStruct>)
-						if ptrObj != nil && c.analysis.NeedsBoxedAccess(ptrObj) {
-							c.tsw.WriteLiterally(".value")
+				// Check if we need an extra .value for varrefed struct access
+				// This happens when the struct being pointed to is varrefed
+				needsExtraValue := false
+				if ident, ok := currentExpr.(*ast.Ident); ok {
+					if obj := c.pkg.TypesInfo.ObjectOf(ident); obj != nil {
+						// Check if after dereferencing, we get a varrefed struct
+						ptrType := obj.Type()
+						for i := 0; i < dereferenceCount; i++ {
+							if ptr, ok := ptrType.(*types.Pointer); ok {
+								ptrType = ptr.Elem()
+							}
+						}
+						// If the final pointed-to type suggests the struct is varrefed
+						// (i.e., the dereference operation results in VarRef<Struct>)
+						if c.analysis.NeedsVarRefAccess(obj) {
+							needsExtraValue = true
 						}
-
-						// Add .field
-						c.tsw.WriteLiterally(".")
-						c.WriteIdent(exp.Sel, false) // Don't add .value to the field itself
-						return nil
 					}
 				}
+
+				if needsExtraValue {
+					c.tsw.WriteLiterally("!.value")
+				}
+
+				// Add .field
+				c.tsw.WriteLiterally(".")
+				c.WriteIdent(exp.Sel, false) // Don't add .value to the field itself
+				return nil
 			}
 		}
 	}
 	// --- End Special Case ---
 
 	// Fallback / Normal Case (e.g., obj.Field, pkg.Var, method calls)
-	// WriteValueExpr handles adding .value for the base variable itself if it's boxed.
+	// WriteValueExpr handles adding .value for the base variable itself if it's varrefed.
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write selector base expression: %w", err)
 	}
@@ -115,11 +142,9 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 	}
 
 	// Write the field/method name.
-	// Pass 'true' to WriteIdent to potentially add '.value' if the field itself
-	// needs boxed access (e.g., accessing a primitive field via pointer where
-	// the field's address might have been taken elsewhere - less common but possible).
-	// For simple struct field access like p.Val or (*p).Val, WriteIdent(..., true)
-	// relies on NeedsBoxedAccess for the field 'Val', which should typically be false.
-	c.WriteIdent(exp.Sel, true)
+	// Pass 'false' to WriteIdent to NOT add '.value' for struct fields.
+	// Struct fields use getters/setters, so we don't want to add .value here.
+	// The setter will handle the internal .value access.
+	c.WriteIdent(exp.Sel, false)
 	return nil
 }

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

@@ -71,8 +71,44 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 		}
 
 		// Check if it's a type parameter with a union constraint (e.g., string | []byte)
-		if _, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
-			// For type parameters with string | []byte constraint, use specialized function
+		if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+			// Check if the type parameter is constrained to slice types
+			constraint := typeParam.Constraint()
+			if constraint != nil {
+				underlying := constraint.Underlying()
+				if iface, isInterface := underlying.(*types.Interface); isInterface {
+					// Check if this is a mixed string/byte constraint (like string | []byte)
+					if hasMixedStringByteConstraint(iface) {
+						// For mixed constraints, use specialized function that returns number (byte value)
+						c.tsw.WriteLiterally("$.indexStringOrBytes(")
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(", ")
+						if err := c.WriteValueExpr(exp.Index); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally(")")
+						return nil
+					}
+
+					// Check if the constraint includes only slice types (pure slice constraint)
+					if hasSliceConstraint(iface) {
+						// This is a pure slice type parameter, use regular slice indexing
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally("![") // non-null assertion
+						if err := c.WriteValueExpr(exp.Index); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally("]")
+						return nil
+					}
+				}
+			}
+
+			// For other type parameters, use specialized function as fallback
 			// that returns number (byte value) for better TypeScript typing
 			c.tsw.WriteLiterally("$.indexStringOrBytes(")
 			if err := c.WriteValueExpr(exp.X); err != nil {
@@ -157,7 +193,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 +231,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 +279,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 +311,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 +337,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 {
@@ -316,6 +413,7 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	if !ok {
 		return errors.Errorf("unhandled binary op: %s", exp.Op.String())
 	}
+
 	c.tsw.WriteLiterally(tokStr)
 	c.tsw.WriteLiterally(" ")
 	if err := c.WriteValueExpr(exp.Y); err != nil {
@@ -334,11 +432,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 +457,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)
 		}
@@ -391,6 +489,13 @@ func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 	if !ok {
 		return errors.Errorf("unhandled unary op: %s", exp.Op.String())
 	}
+
+	// Special case: In Go, ^ is bitwise NOT when used as unary operator
+	// In TypeScript, bitwise NOT is ~, not ^
+	if exp.Op == token.XOR {
+		tokStr = "~"
+	}
+
 	c.tsw.WriteLiterally(tokStr)
 
 	// Add space if operator is not postfix (e.g., !)

package/compiler/field.go

@@ -47,7 +47,7 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 				if j > 0 {
 					c.tsw.WriteLiterally(", ")
 				}
-				c.tsw.WriteLiterally(name.Name)
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 				c.tsw.WriteLiterally(": ")
 				typ := c.pkg.TypesInfo.TypeOf(field.Type)
 				c.WriteGoType(typ, GoTypeContextGeneral)
@@ -65,7 +65,7 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 				c.tsw.WriteLiterally(", ")
 			}
 			c.tsw.WriteLiterally("...")
-			c.tsw.WriteLiterally(name.Name)
+			c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 		}
 
 		c.tsw.WriteLiterally(": ")
@@ -86,7 +86,7 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 					if j > 0 {
 						c.tsw.WriteLiterally(", ")
 					}
-					c.tsw.WriteLiterally(name.Name)
+					c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 					c.tsw.WriteLiterally(": ")
 					typ := c.pkg.TypesInfo.TypeOf(field.Type)
 					c.WriteGoType(typ, GoTypeContextGeneral) // Use WriteGoType for parameter type
@@ -143,7 +143,7 @@ func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
 
 		// argument names: keep original casing, no access modifier
 		if isArguments {
-			c.tsw.WriteLiterally(name.Name)
+			c.tsw.WriteLiterally(c.sanitizeIdentifier(name.Name))
 			// Argument type is handled in WriteFieldList, so continue
 			continue
 		} else {

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(",")