goscript 0.0.21 → 0.0.23

package/compiler/expr-call.go

@@ -0,0 +1,479 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"github.com/pkg/errors"
+)
+
+// WriteCallExpr translates a Go function call expression (`ast.CallExpr`)
+// into its TypeScript equivalent.
+// It handles several Go built-in functions specially:
+// - `println(...)` becomes `console.log(...)`.
+// - `panic(...)` becomes `$.panic(...)`.
+// - `len(arg)` becomes `$.len(arg)`.
+// - `cap(arg)` becomes `$.cap(arg)`.
+// - `delete(m, k)` becomes `$.deleteMapEntry(m, k)`.
+// - `make(chan T, size)` becomes `$.makeChannel<T_ts>(size, zeroValueForT)`.
+// - `make(map[K]V)` becomes `$.makeMap<K_ts, V_ts>()`.
+// - `make([]T, len, cap)` becomes `$.makeSlice<T_ts>(len, cap)`.
+// - `make([]byte, len, cap)` becomes `new Uint8Array(len)`.
+// - `string(runeVal)` becomes `String.fromCharCode(runeVal)`.
+// - `string([]runeVal)` becomes `$.runesToString(sliceVal)`.
+// - `string([]byteVal)` becomes `$.bytesToString(sliceVal)`.
+// - `[]rune(stringVal)` becomes `$.stringToRunes(stringVal)“.
+// - `[]byte(stringVal)` becomes `$.stringToBytes(stringVal)`.
+// - `close(ch)` becomes `ch.close()`.
+// - `append(slice, elems...)` becomes `$.append(slice, elems...)`.
+// - `byte(val)` becomes `$.byte(val)`.
+// For other function calls:
+//   - If the `Analysis` data indicates the function is asynchronous (e.g., due to
+//     channel operations or `go`/`defer` usage within it), the call is prefixed with `await`.
+//   - Otherwise, it's translated as a standard TypeScript function call: `funcName(arg1, arg2)`.
+//
+// Arguments are recursively translated using `WriteValueExpr`.
+func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
+	expFun := exp.Fun
+
+	// Handle any type conversion with nil argument
+	if len(exp.Args) == 1 {
+		if nilIdent, isIdent := exp.Args[0].(*ast.Ident); isIdent && nilIdent.Name == "nil" {
+			// Handle nil pointer to struct type conversions: (*struct{})(nil)
+			if starExpr, isStarExpr := expFun.(*ast.StarExpr); isStarExpr {
+				if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
+					c.tsw.WriteLiterally("null")
+					return nil
+				}
+			}
+
+			c.tsw.WriteLiterally("null")
+			return nil
+		}
+	}
+
+	// Handle array type conversions like []rune(string)
+	if arrayType, isArrayType := expFun.(*ast.ArrayType); isArrayType {
+		// Check if it's a []rune type
+		if ident, isIdent := arrayType.Elt.(*ast.Ident); isIdent && ident.Name == "rune" {
+			// Check if the argument is a string
+			if len(exp.Args) == 1 {
+				arg := exp.Args[0]
+				if tv, ok := c.pkg.TypesInfo.Types[arg]; ok && tv.Type != nil {
+					if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && basic.Kind() == types.String {
+						// Translate []rune(stringValue) to $.stringToRunes(stringValue)
+						c.tsw.WriteLiterally("$.stringToRunes(")
+						if err := c.WriteValueExpr(arg); err != nil {
+							return fmt.Errorf("failed to write argument for []rune(string) conversion: %w", err)
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled []rune(string)
+					}
+				}
+			}
+		}
+		// Check if it's a []byte type and the argument is a string
+		if eltIdent, ok := arrayType.Elt.(*ast.Ident); ok && eltIdent.Name == "byte" && arrayType.Len == nil {
+			if len(exp.Args) == 1 {
+				arg := exp.Args[0]
+				// Ensure TypesInfo is available and the argument type can be determined
+				if tv, typeOk := c.pkg.TypesInfo.Types[arg]; typeOk && tv.Type != nil {
+					if basicArgType, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && (basicArgType.Info()&types.IsString) != 0 {
+						c.tsw.WriteLiterally("$.stringToBytes(")
+						if err := c.WriteValueExpr(arg); err != nil {
+							return fmt.Errorf("failed to write argument for []byte(string) conversion: %w", err)
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled []byte(string)
+					}
+				}
+			}
+		}
+	}
+
+	if funIdent, funIsIdent := expFun.(*ast.Ident); funIsIdent {
+		switch funIdent.String() {
+		case "panic":
+			c.tsw.WriteLiterally("$.panic")
+		case "println":
+			c.tsw.WriteLiterally("console.log")
+		case "len":
+			// Translate len(arg) to $.len(arg)
+			if len(exp.Args) != 1 {
+				return errors.Errorf("unhandled len call with incorrect number of arguments: %d != 1", len(exp.Args))
+			}
+			c.tsw.WriteLiterally("$.len")
+		case "cap":
+			// Translate cap(arg) to $.cap(arg)
+			if len(exp.Args) != 1 {
+				return errors.Errorf("unhandled cap call with incorrect number of arguments: %d != 1", len(exp.Args))
+			}
+			c.tsw.WriteLiterally("$.cap")
+		case "delete":
+			// Translate delete(map, key) to $.deleteMapEntry(map, key)
+			if len(exp.Args) != 2 {
+				return errors.Errorf("unhandled delete call with incorrect number of arguments: %d != 2", len(exp.Args))
+			}
+			c.tsw.WriteLiterally("$.deleteMapEntry")
+		case "make":
+			// First check if we have a channel type
+			if typ := c.pkg.TypesInfo.TypeOf(exp.Args[0]); typ != nil {
+				if chanType, ok := typ.Underlying().(*types.Chan); ok {
+					// Handle channel creation: make(chan T, bufferSize) or make(chan T)
+					c.tsw.WriteLiterally("$.makeChannel<")
+					c.WriteGoType(chanType.Elem(), GoTypeContextGeneral)
+					c.tsw.WriteLiterally(">(")
+
+					// If buffer size is provided, add it
+					if len(exp.Args) >= 2 {
+						if err := c.WriteValueExpr(exp.Args[1]); err != nil {
+							return fmt.Errorf("failed to write buffer size in makeChannel: %w", err)
+						}
+					} else {
+						// Default to 0 (unbuffered channel)
+						c.tsw.WriteLiterally("0")
+					}
+
+					c.tsw.WriteLiterally(", ") // Add comma for zero value argument
+
+					// Write the zero value for the channel's element type
+					if chanType.Elem().String() == "struct{}" {
+						c.tsw.WriteLiterally("{}")
+					} else {
+						c.WriteZeroValueForType(chanType.Elem())
+					}
+
+					// Add direction parameter
+					c.tsw.WriteLiterally(", ")
+
+					// Determine channel direction
+					switch chanType.Dir() {
+					case types.SendRecv:
+						c.tsw.WriteLiterally("'both'")
+					case types.SendOnly:
+						c.tsw.WriteLiterally("'send'")
+					case types.RecvOnly:
+						c.tsw.WriteLiterally("'receive'")
+					default:
+						c.tsw.WriteLiterally("'both'") // Default to bidirectional
+					}
+
+					c.tsw.WriteLiterally(")")
+					return nil // Handled make for channel
+				}
+			}
+			// Handle make for slices: make([]T, len, cap) or make([]T, len)
+			if len(exp.Args) >= 1 {
+				// Handle map creation: make(map[K]V)
+				if mapType, ok := exp.Args[0].(*ast.MapType); ok {
+					c.tsw.WriteLiterally("$.makeMap<")
+					c.WriteTypeExpr(mapType.Key) // Write the key type
+					c.tsw.WriteLiterally(", ")
+					c.WriteTypeExpr(mapType.Value) // Write the value type
+					c.tsw.WriteLiterally(">()")
+					return nil // Handled make for map
+				}
+
+				// Handle slice creation
+				if _, ok := exp.Args[0].(*ast.ArrayType); ok {
+					// Get the slice type information
+					sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
+					if sliceType == nil {
+						return errors.New("could not get type information for slice in make call")
+					}
+					goUnderlyingType, ok := sliceType.Underlying().(*types.Slice)
+					if !ok {
+						return errors.New("expected slice type for make call")
+					}
+					goElemType := goUnderlyingType.Elem()
+
+					// Check if it's make([]byte, ...)
+					if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
+						c.tsw.WriteLiterally("new Uint8Array(")
+						if len(exp.Args) >= 2 {
+							if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+								return err
+							}
+							// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+						} else {
+							// If no length is provided, default to 0
+							c.tsw.WriteLiterally("0")
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled make for []byte
+					}
+
+					c.tsw.WriteLiterally("$.makeSlice<")
+					c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
+					c.tsw.WriteLiterally(">(")
+
+					if len(exp.Args) >= 2 {
+						if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+							return err
+						}
+						if len(exp.Args) == 3 {
+							c.tsw.WriteLiterally(", ")
+							if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+								return err
+							}
+						} else if len(exp.Args) > 3 {
+							return errors.New("makeSlice expects 2 or 3 arguments")
+						}
+					} else {
+						// If no length is provided, default to 0
+						c.tsw.WriteLiterally("0")
+					}
+					c.tsw.WriteLiterally(")")
+					return nil // Handled make for slice
+				}
+			}
+			// Fallthrough for unhandled make calls (e.g., channels)
+			return errors.New("unhandled make call")
+		case "string":
+			// Handle string() conversion
+			if len(exp.Args) == 1 {
+				arg := exp.Args[0]
+
+				// Case 1: Argument is a string literal string("...")
+				if basicLit, isBasicLit := arg.(*ast.BasicLit); isBasicLit && basicLit.Kind == token.STRING {
+					// Translate string("...") to "..." (no-op)
+					c.WriteBasicLit(basicLit)
+					return nil // Handled string literal conversion
+				}
+
+				// Case 2: Argument is a rune (int32) or a call to rune()
+				innerCall, isCallExpr := arg.(*ast.CallExpr)
+
+				if isCallExpr {
+					// Check if it's a call to rune()
+					if innerFunIdent, innerFunIsIdent := innerCall.Fun.(*ast.Ident); innerFunIsIdent && innerFunIdent.String() == "rune" {
+						// Translate string(rune(val)) to String.fromCharCode(val)
+						if len(innerCall.Args) == 1 {
+							c.tsw.WriteLiterally("String.fromCharCode(")
+							if err := c.WriteValueExpr(innerCall.Args[0]); err != nil {
+								return fmt.Errorf("failed to write argument for string(rune) conversion: %w", err)
+							}
+							c.tsw.WriteLiterally(")")
+							return nil // Handled string(rune)
+						}
+					}
+				}
+
+				// Handle direct string(int32) conversion
+				// This assumes 'rune' is int32
+				if tv, ok := c.pkg.TypesInfo.Types[arg]; ok {
+					// Case 3a: Argument is already a string - no-op
+					if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && basic.Kind() == types.String {
+						// Translate string(stringValue) to stringValue (no-op)
+						if err := c.WriteValueExpr(arg); err != nil {
+							return fmt.Errorf("failed to write argument for string(string) no-op conversion: %w", err)
+						}
+						return nil // Handled string(string) no-op
+					}
+
+					if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && (basic.Kind() == types.Int32 || basic.Kind() == types.UntypedRune) {
+						// Translate string(rune_val) to String.fromCharCode(rune_val)
+						c.tsw.WriteLiterally("String.fromCharCode(")
+						if err := c.WriteValueExpr(arg); err != nil {
+							return fmt.Errorf("failed to write argument for string(int32) conversion: %w", err)
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled string(int32)
+					}
+
+					// Case 3: Argument is a slice of runes or bytes string([]rune{...}) or string([]byte{...})
+					if sliceType, isSlice := tv.Type.Underlying().(*types.Slice); isSlice {
+						if basic, isBasic := sliceType.Elem().Underlying().(*types.Basic); isBasic {
+							// Handle string([]byte)
+							if basic.Kind() == types.Uint8 {
+								c.tsw.WriteLiterally("$.bytesToString(")
+								if err := c.WriteValueExpr(arg); err != nil {
+									return fmt.Errorf("failed to write argument for string([]byte) conversion: %w", err)
+								}
+								c.tsw.WriteLiterally(")")
+								return nil // Handled string([]byte)
+							}
+							// Handle both runes (int32)
+							if basic.Kind() == types.Int32 {
+								// Translate string([]rune) to $.runesToString(...)
+								c.tsw.WriteLiterally("$.runesToString(")
+								if err := c.WriteValueExpr(arg); err != nil {
+									return fmt.Errorf("failed to write argument for string([]rune) conversion: %w", err)
+								}
+								c.tsw.WriteLiterally(")")
+								return nil // Handled string([]rune)
+							}
+						}
+					}
+
+					// Case 4: Argument is a generic type parameter (e.g., string | []byte)
+					if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+						// Check if this is a []byte | string union constraint
+						constraint := typeParam.Constraint()
+						if constraint != nil {
+							// For now, assume any type parameter that could be string or []byte needs the helper
+							// This is a heuristic - in the future we could parse the constraint more precisely
+							c.tsw.WriteLiterally("$.genericBytesOrStringToString(")
+							if err := c.WriteValueExpr(arg); err != nil {
+								return fmt.Errorf("failed to write argument for string(generic) conversion: %w", err)
+							}
+							c.tsw.WriteLiterally(")")
+							return nil // Handled string(generic type parameter)
+						}
+					}
+				}
+			}
+			// Return error for other unhandled string conversions
+			return fmt.Errorf("unhandled string conversion: %s", exp.Fun)
+		case "close":
+			// Translate close(ch) to ch.close()
+			if len(exp.Args) == 1 {
+				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+					return fmt.Errorf("failed to write channel in close call: %w", err)
+				}
+				c.tsw.WriteLiterally(".close()")
+				return nil // Handled close
+			}
+			return errors.New("unhandled close call with incorrect number of arguments")
+		case "append":
+			// Translate append(slice, elements...) to $.append(slice, elements...)
+			if len(exp.Args) >= 1 {
+				c.tsw.WriteLiterally("$.append(")
+				// The first argument is the slice
+				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+					return fmt.Errorf("failed to write slice in append call: %w", err)
+				}
+				// The remaining arguments are the elements to append
+				for i, arg := range exp.Args[1:] {
+					if i > 0 || len(exp.Args) > 1 { // Add comma before elements if there are any
+						c.tsw.WriteLiterally(", ")
+					}
+					if err := c.WriteValueExpr(arg); err != nil {
+						return fmt.Errorf("failed to write argument %d in append call: %w", i+1, err)
+					}
+				}
+				c.tsw.WriteLiterally(")")
+				return nil // Handled append
+			}
+			return errors.New("unhandled append call with incorrect number of arguments")
+		case "byte":
+			// Translate byte(val) to $.byte(val)
+			if len(exp.Args) == 1 {
+				c.tsw.WriteLiterally("$.byte(")
+				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+					return err
+				}
+				c.tsw.WriteLiterally(")")
+				return nil // Handled byte
+			}
+			return errors.New("unhandled byte call with incorrect number of arguments")
+		default:
+			// Check if this is a type conversion to a function type
+			if funIdent != nil {
+				if obj := c.pkg.TypesInfo.Uses[funIdent]; obj != nil {
+					// Check if the object is a type name
+					if typeName, isType := obj.(*types.TypeName); isType {
+						// Make sure we have exactly one argument
+						if len(exp.Args) == 1 {
+							// Check if this is a function type
+							if _, isFuncType := typeName.Type().Underlying().(*types.Signature); isFuncType {
+								// For function types, we need to add a __goTypeName property
+								c.tsw.WriteLiterally("Object.assign(")
+
+								// Write the argument first
+								if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+									return fmt.Errorf("failed to write argument for function type cast: %w", err)
+								}
+
+								// Add the __goTypeName property with the function type name
+								c.tsw.WriteLiterallyf(", { __goTypeName: '%s' })", funIdent.String())
+								return nil // Handled function type cast
+							} else {
+								// For non-function types, use the TypeScript "as" operator
+								c.tsw.WriteLiterally("(")
+								if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+									return fmt.Errorf("failed to write argument for type cast: %w", err)
+								}
+
+								// Then use the TypeScript "as" operator with the mapped type name
+								c.tsw.WriteLiterally(" as ")
+								c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
+								c.tsw.WriteLiterally(")")
+								return nil // Handled non-function type cast
+							}
+						}
+					}
+				}
+			}
+
+			// Check if this is an async function call
+			if funIdent != nil {
+				// Get the object for this function identifier
+				if obj := c.pkg.TypesInfo.Uses[funIdent]; obj != nil && c.analysis.IsAsyncFunc(obj) {
+					// This is an async function
+					c.tsw.WriteLiterally("await ")
+				}
+			}
+
+			// Not a special built-in, treat as a regular function call
+			if err := c.WriteValueExpr(expFun); err != nil {
+				return fmt.Errorf("failed to write function expression in call: %w", err)
+			}
+
+			if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
+				if _, ok := funType.Underlying().(*types.Signature); ok {
+					if _, isNamed := funType.(*types.Named); isNamed {
+						c.tsw.WriteLiterally("!")
+					}
+				}
+			}
+
+			c.tsw.WriteLiterally("(")
+			for i, arg := range exp.Args {
+				if i != 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				if err := c.WriteValueExpr(arg); err != nil {
+					return fmt.Errorf("failed to write argument %d in call: %w", i, err)
+				}
+			}
+			c.tsw.WriteLiterally(")")
+			return nil // Handled regular function call
+		}
+	} else {
+		// If expFun is a function literal, it needs to be wrapped in parentheses for IIFE syntax
+		if _, isFuncLit := expFun.(*ast.FuncLit); isFuncLit {
+			c.tsw.WriteLiterally("(")
+			if err := c.WriteValueExpr(expFun); err != nil {
+				return fmt.Errorf("failed to write function literal in call: %w", err)
+			}
+			c.tsw.WriteLiterally(")")
+		} else {
+			// Not an identifier (e.g., method call on a value)
+			if err := c.WriteValueExpr(expFun); err != nil {
+				return fmt.Errorf("failed to write method expression in call: %w", err)
+			}
+
+			if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
+				if _, ok := funType.Underlying().(*types.Signature); ok {
+					if _, isNamed := funType.(*types.Named); isNamed {
+						c.tsw.WriteLiterally("!")
+					}
+				}
+			}
+		}
+	}
+	c.tsw.WriteLiterally("(")
+	for i, arg := range exp.Args {
+		if i != 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		if err := c.WriteValueExpr(arg); err != nil {
+			return fmt.Errorf("failed to write argument %d in call: %w", i, err)
+		}
+	}
+	c.tsw.WriteLiterally(")")
+	return nil
+}

package/compiler/expr-selector.go

@@ -0,0 +1,125 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/types"
+)
+
+// WriteSelectorExpr translates a Go selector expression (`ast.SelectorExpr`)
+// used as a value (e.g., `obj.Field`, `pkg.Variable`, `structVar.Method()`)
+// into its TypeScript equivalent.
+// It distinguishes between package selectors (e.g., `time.Now`) and field/method
+// 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.
+//   - 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).
+//     Then, it writes a dot (`.`) followed by the selected identifier (`exp.Sel`)
+//     using `WriteIdent`, which appends `.value` if the field itself is boxed
+//     (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.
+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 {
+		if obj := c.pkg.TypesInfo.ObjectOf(pkgIdent); obj != nil {
+			if _, isPkg := obj.(*types.PkgName); isPkg {
+				// 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
+				c.WriteIdent(exp.Sel, true)
+				return nil
+			}
+		}
+	}
+
+	// --- Special case for dereferenced pointer to struct with field access: (*p).field ---
+	var baseExpr ast.Expr = exp.X
+	// Look inside parentheses if present
+	if parenExpr, isParen := exp.X.(*ast.ParenExpr); isParen {
+		baseExpr = parenExpr.X
+	}
+
+	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)
+						}
+
+						// 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)
+						}
+
+						// Add ! for non-null assertion
+						c.tsw.WriteLiterally("!")
+
+						// 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")
+						}
+
+						// 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.
+	if err := c.WriteValueExpr(exp.X); err != nil {
+		return fmt.Errorf("failed to write selector base expression: %w", err)
+	}
+
+	// Add null assertion for selector expressions when accessing fields/methods on nullable types
+	// In Go, accessing fields or calling methods on nil pointers/interfaces panics, so we should throw in TypeScript
+	baseType := c.pkg.TypesInfo.TypeOf(exp.X)
+	if baseType != nil {
+		// Check if the base is a pointer type
+		if _, isPtr := baseType.(*types.Pointer); isPtr {
+			c.tsw.WriteLiterally("!.")
+		} else if _, isInterface := baseType.Underlying().(*types.Interface); isInterface {
+			// For interface types, add null assertion since interfaces can be nil
+			c.tsw.WriteLiterally("!.")
+		} else if callExpr, isCall := exp.X.(*ast.CallExpr); isCall {
+			// For function calls that return nullable types, add null assertion
+			_ = callExpr // Use the variable to avoid unused error
+			c.tsw.WriteLiterally("!.")
+		} else {
+			// Add .
+			c.tsw.WriteLiterally(".")
+		}
+	} else {
+		// Add .
+		c.tsw.WriteLiterally(".")
+	}
+
+	// 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)
+	return nil
+}

package/compiler/expr-star.go

@@ -0,0 +1,90 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+)
+
+// 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.
+//
+// The translation depends on whether the pointer variable `p` itself is boxed 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!`.
+//     (`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).
+//
+// `WriteValueExpr(operand)` handles the initial unboxing of `p` if `p` itself is a boxed 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`).
+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)
+		}
+
+		// 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)
+	}
+
+	// Add ! for null assertion - all pointers can be null in TypeScript
+	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")
+	}
+
+	return nil
+}