goscript 0.0.22 → 0.0.24

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/decl.go

@@ -88,14 +88,50 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 		return fmt.Errorf("failed to write function name: %w", err)
 	}
 
+	// Write type parameters if present
+	if decl.Type.TypeParams != nil {
+		c.WriteTypeParameters(decl.Type.TypeParams)
+	}
+
 	// WriteFuncType needs to be aware if the function is async
 	c.WriteFuncType(decl.Type, isAsync) // Write signature (params, return type)
 	c.tsw.WriteLiterally(" ")
 
+	hasNamedReturns := false
+	if decl.Type.Results != nil {
+		for _, field := range decl.Type.Results.List {
+			if len(field.Names) > 0 {
+				hasNamedReturns = true
+				break
+			}
+		}
+	}
+
+	if hasNamedReturns {
+		c.tsw.WriteLine("{")
+		c.tsw.Indent(1)
+
+		// Declare named return variables and initialize them to their zero values
+		for _, field := range decl.Type.Results.List {
+			for _, name := range field.Names {
+				c.tsw.WriteLiterallyf("let %s: ", name.Name)
+				c.WriteTypeExpr(field.Type)
+				c.tsw.WriteLiterally(" = ")
+				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
+				c.tsw.WriteLine("")
+			}
+		}
+	}
+
 	if err := c.WriteStmt(decl.Body); err != nil {
 		return fmt.Errorf("failed to write function body: %w", err)
 	}
 
+	if hasNamedReturns {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("}")
+	}
+
 	return nil
 }
 

package/compiler/expr-call.go

@@ -13,15 +13,19 @@ import (
 // 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)` or `string([]byteVal)` becomes `$.runesToString(sliceVal)`.
-// - `[]rune(stringVal)` becomes `$.stringToRunes(stringVal)`.
+// - `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)`.
@@ -70,66 +74,56 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				}
 			}
 		}
+		// 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(")
-			for i, arg := range exp.Args {
-				if i != 0 {
-					c.tsw.WriteLiterally(", ")
-				}
-				if err := c.WriteValueExpr(arg); err != nil {
-					return err
-				}
-			}
-			c.tsw.WriteLiterally(")")
-			return nil
+			c.tsw.WriteLiterally("console.log")
 		case "len":
 			// Translate len(arg) to $.len(arg)
-			if len(exp.Args) == 1 {
-				c.tsw.WriteLiterally("$.len(")
-				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally(")")
-				return nil // Handled len
+			if len(exp.Args) != 1 {
+				return errors.Errorf("unhandled len call with incorrect number of arguments: %d != 1", len(exp.Args))
 			}
-			return errors.New("unhandled len call with incorrect number of arguments")
+			c.tsw.WriteLiterally("$.len")
 		case "cap":
 			// Translate cap(arg) to $.cap(arg)
-			if len(exp.Args) == 1 {
-				c.tsw.WriteLiterally("$.cap(")
-				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-					return err
-				}
-				c.tsw.WriteLiterally(")")
-				return nil // Handled cap
+			if len(exp.Args) != 1 {
+				return errors.Errorf("unhandled cap call with incorrect number of arguments: %d != 1", len(exp.Args))
 			}
-			return errors.New("unhandled cap call with incorrect number of arguments")
+			c.tsw.WriteLiterally("$.cap")
 		case "delete":
 			// Translate delete(map, key) to $.deleteMapEntry(map, key)
-			if len(exp.Args) == 2 {
-				c.tsw.WriteLiterally("$.deleteMapEntry(")
-				if err := c.WriteValueExpr(exp.Args[0]); err != nil { // Map
-					return err
-				}
-				c.tsw.WriteLiterally(", ")
-				if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Key
-					return err
-				}
-				c.tsw.WriteLiterally(")")
-				return nil // Handled delete
+			if len(exp.Args) != 2 {
+				return errors.Errorf("unhandled delete call with incorrect number of arguments: %d != 2", len(exp.Args))
 			}
-			return errors.New("unhandled delete call with incorrect number of arguments")
+			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())
+					c.WriteGoType(chanType.Elem(), GoTypeContextGeneral)
 					c.tsw.WriteLiterally(">(")
 
 					// If buffer size is provided, add it
@@ -189,13 +183,30 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					if sliceType == nil {
 						return errors.New("could not get type information for slice in make call")
 					}
-					goElemType, ok := sliceType.Underlying().(*types.Slice)
+					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.Elem()) // Write the element type
+					c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
 					c.tsw.WriteLiterally(">(")
 
 					if len(exp.Args) >= 2 {
@@ -253,7 +264,16 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 				// Handle direct string(int32) conversion
 				// This assumes 'rune' is int32
 				if tv, ok := c.pkg.TypesInfo.Types[arg]; ok {
-					if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && basic.Kind() == types.Int32 {
+					// 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 {
@@ -266,18 +286,43 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 					// 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 both runes (int32) and bytes (uint8)
-							if basic.Kind() == types.Int32 || basic.Kind() == types.Uint8 {
-								// Translate string([]rune) or string([]byte) to $.runesToString(...)
+							// 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/[]byte) conversion: %w", err)
+									return fmt.Errorf("failed to write argument for string([]rune) conversion: %w", err)
 								}
 								c.tsw.WriteLiterally(")")
-								return nil // Handled string([]rune) or string([]byte)
+								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
@@ -352,8 +397,10 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 									return fmt.Errorf("failed to write argument for type cast: %w", err)
 								}
 
-								// Then use the TypeScript "as" operator with the type name
-								c.tsw.WriteLiterallyf(" as %s)", funIdent.String())
+								// 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
 							}
 						}
@@ -396,15 +443,24 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			return nil // Handled regular function call
 		}
 	} 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 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("!")
+			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("!")
+					}
 				}
 			}
 		}

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,75 +31,120 @@ 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)
 	}
 
-	// Add .
-	c.tsw.WriteLiterally(".")
+	// 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)
+	// 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
 }