goscript 0.0.23 → 0.0.24

package/compiler/composite-lit.go

@@ -13,27 +13,28 @@ import (
 //
 // It handles several types of composite literals:
 //   - Map literals (e.g., `map[K]V{k1: v1}`): Translated to `new Map([[k1_ts, v1_ts]])`.
-//     Values are processed by `writeBoxedValue`.
+//     Values are processed by `WriteVarRefedValue`.
 //   - Array/Slice literals (e.g., `[]T{e1, e2}`, `[N]T{idx: val}`):
 //   - For `[]byte{...}`, translated to `new Uint8Array([...])`.
 //   - For other `[]T` or `[N]T`, translated using the `$.arrayToSlice<T_ts>([...])` runtime helper.
 //     It handles both keyed and unkeyed elements, infers length if necessary,
 //     and uses zero values for uninitialized array elements.
 //     Multi-dimensional arrays/slices pass a depth parameter to `$.arrayToSlice`.
-//     Element values are processed by `writeBoxedValue`.
+//     Element values are processed by `WriteVarRefedValue`.
 //   - Struct literals:
 //   - Named structs (e.g., `MyStruct{F: v}` or `&MyStruct{F: v}`): Translated to
 //     `new MyStruct_ts({ F: v_ts, ... })`. The constructor typically uses an `_init` method.
 //   - Anonymous structs (e.g., `struct{F int}{F: v}`): Translated to TypeScript
 //     object literals `{ F: v_ts, ... }`.
 //     It processes keyed elements (`FieldName: Value`) and unkeyed elements (for anonymous
-//     structs or arrays). Field values are processed by `writeBoxedValue`.
+//     structs or arrays). Field values are processed by `WriteVarRefedValue`.
 //     Embedded struct fields are initialized, and explicit initializers for embedded
 //     structs (e.g. `Outer{InnerField: InnerType{...}}`) are handled.
-//     The function uses `c.analysis` to determine correct value access (e.g., `.value` for boxed fields).
+//     The function uses `c.analysis` to determine correct value access (e.g., `.value` for var-refed fields).
 func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 	// Get the type of the composite literal
 	litType := c.pkg.TypesInfo.TypeOf(exp)
+
 	if exp.Type != nil {
 		// Handle map literals: map[K]V{k1: v1, k2: v2}
 		if _, isMapType := exp.Type.(*ast.MapType); isMapType {
@@ -47,11 +48,11 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 
 				if kv, ok := elm.(*ast.KeyValueExpr); ok {
 					c.tsw.WriteLiterally("[")
-					if err := c.WriteBoxedValue(kv.Key); err != nil {
+					if err := c.WriteVarRefedValue(kv.Key); err != nil {
 						return fmt.Errorf("failed to write map literal key: %w", err)
 					}
 					c.tsw.WriteLiterally(", ")
-					if err := c.WriteBoxedValue(kv.Value); err != nil {
+					if err := c.WriteVarRefedValue(kv.Value); err != nil {
 						return fmt.Errorf("failed to write map literal value: %w", err)
 					}
 					c.tsw.WriteLiterally("]")
@@ -139,7 +140,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 						hasKeyedElements = true
 					} else {
 						c.tsw.WriteCommentInline("unhandled keyed array literal key type")
-						if err := c.WriteBoxedValue(elm); err != nil {
+						if err := c.WriteVarRefedValue(elm); err != nil {
 							return fmt.Errorf("failed to write keyed array literal element with unhandled key type: %w", err)
 						}
 					}
@@ -167,7 +168,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					c.tsw.WriteLiterally(", ")
 				}
 				if elm, ok := elements[i]; ok && elm != nil {
-					if err := c.WriteBoxedValue(elm); err != nil {
+					if err := c.WriteVarRefedValue(elm); err != nil {
 						return fmt.Errorf("failed to write array literal element: %w", err)
 					}
 				} else {
@@ -340,7 +341,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					}
 					c.tsw.WriteLiterally(keyName)
 					c.tsw.WriteLiterally(": ")
-					if err := c.WriteBoxedValue(directFields[keyName]); err != nil {
+					if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
 						return err
 					}
 					firstFieldWritten = true
@@ -368,14 +369,14 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 							if i > 0 {
 								c.tsw.WriteLiterally(", ")
 							}
-							if err := c.WriteBoxedValue(elem); err != nil {
+							if err := c.WriteVarRefedValue(elem); err != nil {
 								return err
 							}
 						}
 						c.tsw.WriteLiterally("}")
 					} else {
 						// Not a composite literal, write it normally
-						if err := c.WriteBoxedValue(explicitEmbedded[embeddedName]); err != nil {
+						if err := c.WriteVarRefedValue(explicitEmbedded[embeddedName]); err != nil {
 							return err
 						}
 					}
@@ -414,7 +415,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 						}
 						c.tsw.WriteLiterally(keyName) // Field name within the embedded struct
 						c.tsw.WriteLiterally(": ")
-						if err := c.WriteBoxedValue(fieldsMap[keyName]); err != nil {
+						if err := c.WriteVarRefedValue(fieldsMap[keyName]); err != nil {
 							return err
 						}
 					}
@@ -436,7 +437,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					if i != 0 {
 						c.tsw.WriteLiterally(", ")
 					}
-					if err := c.WriteBoxedValue(elm); err != nil {
+					if err := c.WriteVarRefedValue(elm); err != nil {
 						return fmt.Errorf("failed to write literal field: %w", err)
 					}
 				}
@@ -448,60 +449,124 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 
 	// Untyped composite literal. Let's use type information to determine what it is.
 	// First try to get the type information for the expression
-	isObject := false
 	if tv, ok := c.pkg.TypesInfo.Types[exp]; ok && tv.Type != nil {
 		underlying := tv.Type.Underlying()
 		switch underlying.(type) {
 		case *types.Map, *types.Struct:
-			isObject = true
+			// Handle struct directly with the struct literal logic
+			if structType, ok := underlying.(*types.Struct); ok {
+				return c.writeUntypedStructLiteral(exp, structType) // true = anonymous
+			}
+			// Map case would be handled here
+			return fmt.Errorf("untyped map composite literals not yet supported")
 		case *types.Array, *types.Slice:
-			isObject = false
+			// Handle array/slice
+			return c.writeUntypedArrayLiteral(exp)
+		case *types.Pointer:
+			// Handle pointer to composite literal
+			ptrType := underlying.(*types.Pointer)
+			elemType := ptrType.Elem().Underlying()
+			switch elemType.(type) {
+			case *types.Struct:
+				// This is an anonymous struct literal with inferred pointer type
+				// Just create the struct object directly - no var-refing needed
+				// Anonymous literals are not variables, so they don't get var-refed
+				structType := elemType.(*types.Struct)
+				return c.writeUntypedStructLiteral(exp, structType) // true = anonymous
+			default:
+				return fmt.Errorf("unhandled pointer composite literal element type: %T", elemType)
+			}
 		default:
 			return fmt.Errorf("unhandled composite literal type: %T", underlying)
 		}
 	} else {
 		return fmt.Errorf("could not determine composite literal type from type information")
 	}
+}
 
-	if isObject {
-		c.tsw.WriteLiterally("{ ")
-	} else {
-		c.tsw.WriteLiterally("[ ")
-	}
-
+// writeUntypedArrayLiteral handles untyped composite literals that are arrays/slices
+func (c *GoToTSCompiler) writeUntypedArrayLiteral(exp *ast.CompositeLit) error {
+	c.tsw.WriteLiterally("[ ")
 	for i, elm := range exp.Elts {
 		if i != 0 {
 			c.tsw.WriteLiterally(", ")
 		}
-		if err := c.WriteBoxedValue(elm); err != nil {
-			return fmt.Errorf("failed to write untyped composite literal element: %w", err)
+		if err := c.WriteVarRefedValue(elm); err != nil {
+			return fmt.Errorf("failed to write untyped array literal element: %w", err)
 		}
 	}
-	if isObject {
-		c.tsw.WriteLiterally(" }")
-	} else {
-		c.tsw.WriteLiterally(" ]")
+	c.tsw.WriteLiterally(" ]")
+	return nil
+}
+
+// writeUntypedStructLiteral handles untyped composite literals that are structs or pointers to structs
+func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, structType *types.Struct) error {
+	// Create field mapping like the typed struct case
+	directFields := make(map[string]ast.Expr)
+
+	// Handle elements that are key-value pairs
+	for _, elt := range exp.Elts {
+		if kv, ok := elt.(*ast.KeyValueExpr); ok {
+			if keyIdent, ok := kv.Key.(*ast.Ident); ok {
+				directFields[keyIdent.Name] = kv.Value
+			}
+		}
 	}
+
+	// Handle elements that are positional (no key specified)
+	if len(directFields) == 0 {
+		// If no key-value pairs, try to match positional values to struct fields
+		for i, elt := range exp.Elts {
+			if _, isKV := elt.(*ast.KeyValueExpr); !isKV && i < structType.NumFields() {
+				field := structType.Field(i)
+				directFields[field.Name()] = elt
+			}
+		}
+	}
+
+	// Write the object literal (always anonymous for untyped)
+	c.tsw.WriteLiterally("{")
+
+	firstFieldWritten := false
+	// Write fields in order
+	directKeys := make([]string, 0, len(directFields))
+	for k := range directFields {
+		directKeys = append(directKeys, k)
+	}
+	slices.Sort(directKeys)
+	for _, keyName := range directKeys {
+		if firstFieldWritten {
+			c.tsw.WriteLiterally(", ")
+		}
+		c.tsw.WriteLiterally(keyName)
+		c.tsw.WriteLiterally(": ")
+		if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
+			return err
+		}
+		firstFieldWritten = true
+	}
+
+	c.tsw.WriteLiterally("}")
 	return nil
 }
 
-// WriteBoxedValue translates a Go expression (`ast.Expr`) into its TypeScript equivalent,
+// WriteVarRefedValue translates a Go expression (`ast.Expr`) into its TypeScript equivalent,
 // specifically for use as a value within a composite literal (e.g., struct fields,
 // map keys/values, or array/slice elements). Its primary goal is to ensure that the
-// actual, unboxed value of the expression is used.
+// actual un-refed value of the expression is used.
 //
 // How it works:
 //   - Identifiers (`*ast.Ident`): Delegates to `c.WriteIdent(ident, true)`, forcing
 //     the `accessValue` flag to `true`. This ensures that if `ident` refers to a
-//     GoScript boxed variable, the generated TypeScript accesses its underlying `.value`
+//     GoScript var-refed variable, the generated TypeScript accesses its underlying `.value`
 //     (e.g., `myVar.value`).
 //   - Selector Expressions (`*ast.SelectorExpr`, e.g., `obj.Field`): Delegates to
 //     `c.WriteSelectorExpr(e)`. This function handles the necessary logic for
-//     accessing fields or methods, including any required unboxing if the field
-//     itself or the object it's accessed on is boxed (e.g., `obj.value.field` or
+//     accessing fields or methods, including any required un-var-refing if the field
+//     itself or the object it's accessed on is var-refed (e.g., `obj.value.field` or
 //     `obj.field.value`).
 //   - Star Expressions (`*ast.StarExpr`, e.g., `*ptr`): Delegates to `c.WriteStarExpr(e)`.
-//     This function handles pointer dereferencing, which in GoScript's boxing model
+//     This function handles pointer dereferencing, which in GoScript's var-refing model
 //     often translates to accessing the `.value` field of the pointer (e.g., `ptr.value`).
 //   - Basic Literals (`*ast.BasicLit`, e.g., `123`, `"hello"`): Delegates to
 //     `c.WriteBasicLit(e)` for direct translation.
@@ -511,25 +576,25 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 //
 // Necessity and Distinction from `WriteValueExpr`:
 // While `WriteValueExpr` is a general-purpose function for translating Go expressions
-// and also unboxes identifiers (by calling `WriteIdent` with `accessValue: true`),
-// `WriteBoxedValue` serves a specific and crucial role when called from `WriteCompositeLit`:
+// and also un-var-refes identifiers (by calling `WriteIdent` with `accessValue: true`),
+// `WriteVarRefedValue` serves a specific and crucial role when called from `WriteCompositeLit`:
 //  1. Clarity of Intent: It explicitly signals that for the constituents of a composite
-//     literal, the *unboxed value* is mandatory.
+//     literal, the *un-var-refed value* is mandatory.
 //  2. Contract for `WriteCompositeLit`: It ensures that `WriteCompositeLit` receives
 //     the correct values for initialization, insulating it from potential changes in
-//     the default behavior of `WriteValueExpr` regarding unboxing.
+//     the default behavior of `WriteValueExpr` regarding un-var-refing.
 //  3. Prevents Recursion: `WriteValueExpr` handles `*ast.CompositeLit` nodes by
 //     calling `WriteCompositeLit`. If `WriteCompositeLit` were to directly call
 //     `WriteValueExpr` for its elements, it could lead to unintended recursion or
-//     behavior if an element itself was another composite literal. `WriteBoxedValue`
+//     behavior if an element itself was another composite literal. `WriteVarRefedValue`
 //     acts as a specific intermediary for the *elements*.
 //
-// In summary, `WriteBoxedValue` is a specialized dispatcher used by `WriteCompositeLit`
+// In summary, `WriteVarRefedValue` is a specialized dispatcher used by `WriteCompositeLit`
 // to guarantee that all parts of a Go composite literal are initialized with their
-// proper, unboxed TypeScript values.
-func (c *GoToTSCompiler) WriteBoxedValue(expr ast.Expr) error {
+// proper, unrefed TypeScript values.
+func (c *GoToTSCompiler) WriteVarRefedValue(expr ast.Expr) error {
 	if expr == nil {
-		return fmt.Errorf("nil expression passed to writeBoxedValue")
+		return fmt.Errorf("nil expression passed to write var refed value")
 	}
 
 	// Handle different expression types

package/compiler/config.go

@@ -13,13 +13,17 @@ type Config struct {
 
 	// Dir is the working directory for the compiler. If empty, uses the current working directory.
 	Dir string
-	// OutputPathRoot is the output path root.
-	OutputPathRoot string
+	// OutputPath is the output path root.
+	OutputPath string
 	// BuildFlags are the Go build flags (tags) to use during analysis.
 	BuildFlags []string
 	// AllDependencies controls whether to compile all dependencies of the requested packages.
 	// If true, all dependencies will be compiled; if false, only the requested packages are compiled.
 	AllDependencies bool
+	// DisableEmitBuiltin controls whether to emit builtin packages when they are referenced.
+	// If true, builtin packages will not be emitted; if false, they will be emitted if referenced.
+	// Default is false (emit builtin packages).
+	DisableEmitBuiltin bool
 }
 
 // Validate checks the config.
@@ -30,7 +34,7 @@ func (c *Config) Validate() error {
 	if c.fset == nil {
 		c.fset = token.NewFileSet()
 	}
-	if c.OutputPathRoot == "" {
+	if c.OutputPath == "" {
 		return errors.New("output path root must be specified")
 	}
 	return nil

package/compiler/config_test.go

@@ -1,7 +1,6 @@
 package compiler
 
 import (
-	"reflect"
 	"testing"
 )
 
@@ -15,9 +14,9 @@ func TestConfigValidate(t *testing.T) {
 		{
 			name: "valid config",
 			config: &Config{
-				Dir:            "/some/dir",
-				OutputPathRoot: "/output/path",
-				BuildFlags:     []string{"-tags", "sometag"},
+				Dir:        "/some/dir",
+				OutputPath: "/output/path",
+				BuildFlags: []string{"-tags", "sometag"},
 			},
 			wantErr: false,
 		},
@@ -33,9 +32,9 @@ func TestConfigValidate(t *testing.T) {
 		{
 			name: "nil fset gets initialized",
 			config: &Config{
-				fset:           nil,
-				Dir:            "/some/dir",
-				OutputPathRoot: "/output/path",
+				fset:       nil,
+				Dir:        "/some/dir",
+				OutputPath: "/output/path",
 			},
 			wantErr: false,
 		},
@@ -61,29 +60,3 @@ func TestConfigValidate(t *testing.T) {
 		})
 	}
 }
-
-func TestConfigFields(t *testing.T) {
-	// Verify that Config has the expected fields
-	config := Config{}
-	configType := reflect.TypeOf(config)
-
-	expectedFields := map[string]string{
-		"fset":           "*token.FileSet",
-		"Dir":            "string",
-		"OutputPathRoot": "string",
-		"BuildFlags":     "[]string",
-	}
-
-	for fieldName, expectedType := range expectedFields {
-		field, exists := configType.FieldByName(fieldName)
-		if !exists {
-			t.Errorf("Expected Config to have field %s", fieldName)
-			continue
-		}
-
-		actualType := field.Type.String()
-		if actualType != expectedType {
-			t.Errorf("Field %s has type %s, expected %s", fieldName, actualType, expectedType)
-		}
-	}
-}

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
 }