goscript 0.0.60 → 0.0.62

package/compiler/expr.go

@@ -251,34 +251,6 @@ func (c *GoToTSCompiler) getTypeNameString(typeExpr ast.Expr) string {
 	return "unknown"
 }
 
-// getFinalUnderlyingType traverses the chain of named types to find the ultimate underlying type.
-// This handles cases like: type A B; type B C; type C string.
-// Returns the final underlying type and whether the original type was a named type.
-func (c *GoToTSCompiler) getFinalUnderlyingType(t types.Type) (types.Type, bool) {
-	if t == nil {
-		return nil, false
-	}
-
-	// Check if this is a named type
-	namedType, isNamed := t.(*types.Named)
-	if !isNamed {
-		return t, false
-	}
-
-	// Follow the chain of named types to find the ultimate underlying type
-	ultimate := namedType
-	for {
-		underlying := ultimate.Underlying()
-		if underlyingNamed, isNamedUnderlying := underlying.(*types.Named); isNamedUnderlying {
-			// Continue following the chain
-			ultimate = underlyingNamed
-		} else {
-			// We've reached the final underlying type
-			return underlying, true
-		}
-	}
-}
-
 // WriteBinaryExpr translates a Go binary expression (`ast.BinaryExpr`) into its
 // TypeScript equivalent.
 // It handles several cases:
@@ -469,9 +441,46 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		c.tsw.WriteLiterally("(") // Add opening parenthesis for bitwise operations
 	}
 
+	// Check if this is a comparison that might trigger TypeScript's control flow narrowing.
+	// When a numeric field is compared to a literal, TypeScript may narrow the field type
+	// to that literal, causing subsequent comparisons to appear unintentional.
+	// We cast to number to widen the type and avoid these false positives.
+	needsNumberCast := false
+	if (exp.Op == token.EQL || exp.Op == token.NEQ) && c.pkg != nil && c.pkg.TypesInfo != nil {
+		// Check if left side is a selector expression (field access) and right is a literal or constant
+		_, leftIsSelector := exp.X.(*ast.SelectorExpr)
+		_, rightIsLiteral := exp.Y.(*ast.BasicLit)
+		// Also check if right side is an identifier referring to a constant
+		rightIsConstant := false
+		if rightIdent, ok := exp.Y.(*ast.Ident); ok {
+			if obj := c.pkg.TypesInfo.Uses[rightIdent]; obj != nil {
+				if _, isConst := obj.(*types.Const); isConst {
+					rightIsConstant = true
+				}
+			}
+		}
+		if leftIsSelector && (rightIsLiteral || rightIsConstant) {
+			leftType := c.pkg.TypesInfo.TypeOf(exp.X)
+			if leftType != nil {
+				if basic, ok := leftType.Underlying().(*types.Basic); ok {
+					// Check if it's a numeric type
+					if basic.Info()&types.IsNumeric != 0 {
+						needsNumberCast = true
+					}
+				}
+			}
+		}
+	}
+
+	if needsNumberCast {
+		c.tsw.WriteLiterally("Number(")
+	}
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write binary expression left operand: %w", err)
 	}
+	if needsNumberCast {
+		c.tsw.WriteLiterally(")")
+	}
 
 	c.tsw.WriteLiterally(" ")
 	tokStr, ok := TokenToTs(exp.Op)

package/compiler/index.test.ts

@@ -24,6 +24,8 @@ describe("GoScript Compiler API", () => {
     };
 
     await expect(compile(config)).resolves.toBeUndefined();
-    await expect(fs.access(expectedOutputFile)).resolves.toBeUndefined();
+    // fs.access resolves to undefined/null on success - verify file exists
+    const fileExists = await fs.access(expectedOutputFile).then(() => true).catch(() => false);
+    expect(fileExists).toBe(true);
   }, 30000); // 30 second timeout for compilation
 });

package/compiler/lit.go

@@ -143,11 +143,20 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 			c.WriteTypeExpr(exp.Type.Results.List[0].Type)
 		} else {
 			c.tsw.WriteLiterally("[")
-			for i, field := range exp.Type.Results.List {
-				if i > 0 {
-					c.tsw.WriteLiterally(", ")
+			first := true
+			for _, field := range exp.Type.Results.List {
+				// Each field may represent multiple return values (e.g., "a, b int")
+				count := len(field.Names)
+				if count == 0 {
+					count = 1 // Unnamed return value
+				}
+				for j := 0; j < count; j++ {
+					if !first {
+						c.tsw.WriteLiterally(", ")
+					}
+					first = false
+					c.WriteTypeExpr(field.Type)
 				}
-				c.WriteTypeExpr(field.Type)
 			}
 			c.tsw.WriteLiterally("]")
 		}

package/compiler/spec-struct.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/types"
-	"sort"
+	"slices"
 	"strings"
 )
 
@@ -109,8 +109,10 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		}
 
 		// Use AST-based type string when available, fall back to types-based
+		// Note: getASTTypeString already includes "null |" for interface types
 		astType := fieldASTTypes[fieldKeyName]
 		fieldTsType := c.getASTTypeString(astType, field.Type())
+
 		c.tsw.WriteLinef("%s: $.VarRef<%s>;", fieldKeyName, fieldTsType)
 	}
 	c.tsw.Indent(-1)
@@ -346,7 +348,16 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		}
 
 		// Promoted methods
-		embeddedMethodSet := types.NewMethodSet(embeddedFieldType) // Use original field type for method set
+		// Use pointer to embedded type to get both value and pointer receiver methods
+		// This matches Go's behavior where embedding T promotes both T and *T methods
+		// Exception: For interfaces, use the interface directly as pointer-to-interface has no methods
+		methodSetType := embeddedFieldType
+		if _, isPtr := embeddedFieldType.(*types.Pointer); !isPtr {
+			if _, isInterface := embeddedFieldType.Underlying().(*types.Interface); !isInterface {
+				methodSetType = types.NewPointer(embeddedFieldType)
+			}
+		}
+		embeddedMethodSet := types.NewMethodSet(methodSetType)
 		for k := range embeddedMethodSet.Len() {
 			methodSelection := embeddedMethodSet.At(k)
 			method := methodSelection.Obj().(*types.Func)
@@ -429,8 +440,19 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	// Add code to register the type with the runtime type system
 	c.tsw.WriteLine("")
 	c.tsw.WriteLinef("// Register this type with the runtime type system")
+
+	// Build full package path name for registration
+	structName := className
+	pkgPath := c.pkg.Types.Path()
+	pkgName := c.pkg.Types.Name()
+	if pkgPath != "" && pkgName != "main" {
+		structName = pkgPath + "." + className
+	} else if pkgName == "main" {
+		structName = "main." + className
+	}
+
 	c.tsw.WriteLinef("static __typeInfo = $.registerStructType(")
-	c.tsw.WriteLinef("  '%s',", className)
+	c.tsw.WriteLinef("  '%s',", structName)
 	c.tsw.WriteLinef("  new %s(),", className)
 	c.tsw.WriteLiterally("  [")
 	// Collect methods for the struct type
@@ -468,13 +490,23 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 		if fieldKeyName == "_" {
 			continue
 		}
-		// fieldTsType := c.getTypeString(field.Type())
 		if !firstField {
 			c.tsw.WriteLiterally(", ")
 		}
 		firstField = false
 		c.tsw.WriteLiterallyf("%q: ", fieldKeyName)
-		c.writeTypeInfoObject(field.Type()) // Use writeTypeInfoObject for field types
+
+		// Get the struct tag for this field
+		tag := underlyingStruct.Tag(i)
+		if tag != "" {
+			// Write field info with tag as StructFieldInfo object
+			c.tsw.WriteLiterally("{ type: ")
+			c.writeTypeInfoObject(field.Type())
+			c.tsw.WriteLiterallyf(", tag: %q }", tag)
+		} else {
+			// No tag, write type info directly for backwards compatibility
+			c.writeTypeInfoObject(field.Type())
+		}
 	}
 	c.tsw.WriteLiterally("}")
 	c.tsw.WriteLine("")
@@ -532,15 +564,16 @@ func (c *GoToTSCompiler) generateFlattenedInitTypeString(structType *types.Named
 				fieldType = ptr.Elem()
 			}
 
-			if named, ok := fieldType.(*types.Named); ok {
-				embeddedName := named.Obj().Name()
+			if _, ok := fieldType.(*types.Named); ok {
 				// Check if the embedded type is an interface
 				if _, isInterface := fieldType.Underlying().(*types.Interface); isInterface {
 					// For embedded interfaces, use the full qualified interface type
 					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = c.getTypeString(field.Type())
 				} else {
 					// For embedded structs, use ConstructorParameters for field-based initialization
-					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = fmt.Sprintf("Partial<ConstructorParameters<typeof %s>[0]>", embeddedName)
+					// Use getTypeString to get the qualified type name (e.g., bytes.Buffer not just Buffer)
+					qualifiedTypeName := c.getTypeString(fieldType)
+					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = fmt.Sprintf("Partial<ConstructorParameters<typeof %s>[0]>", qualifiedTypeName)
 				}
 			}
 			continue
@@ -562,7 +595,7 @@ func (c *GoToTSCompiler) generateFlattenedInitTypeString(structType *types.Named
 	for name := range fieldMap {
 		fieldNames = append(fieldNames, name)
 	}
-	sort.Strings(fieldNames)
+	slices.Sort(fieldNames)
 
 	var fieldDefs []string
 	for _, fieldName := range fieldNames {

package/compiler/spec-value.go

@@ -164,7 +164,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 			isInsideFunction = nodeInfo.IsInsideFunction
 		}
 
-		if name.IsExported() && !isInsideFunction {
+		if !isInsideFunction {
 			c.tsw.WriteLiterally("export ")
 		}
 		c.tsw.WriteLiterally("let ")
@@ -493,7 +493,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 				isInsideFunction = nodeInfo.IsInsideFunction
 			}
 
-			if name.IsExported() && !isInsideFunction {
+			if !isInsideFunction {
 				c.tsw.WriteLiterally("export ")
 			}
 

package/compiler/spec.go

@@ -57,6 +57,7 @@ func (c *GoToTSCompiler) getEmbeddedFieldKeyName(fieldType types.Type) string {
 
 func (c *GoToTSCompiler) writeGetterSetter(fieldName string, fieldType types.Type, doc, comment *ast.CommentGroup, astType ast.Expr) {
 	// Use AST type information if available to preserve qualified names
+	// Note: getASTTypeString/getTypeString already includes "null |" for interface types
 	var fieldTypeStr string
 	if astType != nil {
 		fieldTypeStr = c.getASTTypeString(astType, fieldType)
@@ -121,7 +122,7 @@ func (c *GoToTSCompiler) writeEmbeddedFieldInitializer(fieldName string, fieldTy
 	}
 
 	// For structs, instantiate with provided fields
-	typeForNew := fieldName
+	typeForNew := c.getTypeString(fieldType)
 	c.tsw.WriteLiterallyf("new %s(init?.%s)", typeForNew, fieldName)
 }
 
@@ -224,6 +225,12 @@ func (c *GoToTSCompiler) writeNamedTypeZeroValue(named *types.Named) {
 		return
 	}
 
+	// Check if underlying type is a function
+	if _, isFunc := named.Underlying().(*types.Signature); isFunc {
+		c.tsw.WriteLiterally("null")
+		return
+	}
+
 	// For non-struct, non-interface named types, use constructor
 	c.tsw.WriteLiterally("new ")
 	c.WriteNamedType(named)
@@ -254,6 +261,12 @@ func (c *GoToTSCompiler) writeTypeAliasZeroValue(alias *types.Alias, astType ast
 		return
 	}
 
+	// Check if underlying type is a function
+	if _, isFunc := alias.Underlying().(*types.Signature); isFunc {
+		c.tsw.WriteLiterally("null")
+		return
+	}
+
 	// For non-struct, non-interface type aliases, use constructor
 	c.tsw.WriteLiterally("new ")
 	// Use AST type information if available to preserve qualified names
@@ -394,11 +407,20 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 						c.WriteTypeExpr(funcDecl.Type.Results.List[0].Type)
 					} else {
 						c.tsw.WriteLiterally("[")
-						for i, field := range funcDecl.Type.Results.List {
-							if i > 0 {
-								c.tsw.WriteLiterally(", ")
+						first := true
+						for _, field := range funcDecl.Type.Results.List {
+							// Each field may represent multiple return values (e.g., "a, b int")
+							count := len(field.Names)
+							if count == 0 {
+								count = 1 // Unnamed return value
+							}
+							for j := 0; j < count; j++ {
+								if !first {
+									c.tsw.WriteLiterally(", ")
+								}
+								first = false
+								c.WriteTypeExpr(field.Type)
 							}
-							c.WriteTypeExpr(field.Type)
 						}
 						c.tsw.WriteLiterally("]")
 					}
@@ -521,7 +543,15 @@ func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.Interfac
 	c.tsw.WriteLine("")
 
 	// Add code to register the interface with the runtime system
+	// Build full package path name for registration
 	interfaceName := a.Name.Name
+	pkgPath := c.pkg.Types.Path()
+	pkgName := c.pkg.Types.Name()
+	if pkgPath != "" && pkgName != "main" {
+		interfaceName = pkgPath + "." + interfaceName
+	} else if pkgName == "main" {
+		interfaceName = "main." + interfaceName
+	}
 	c.tsw.WriteLine("")
 	c.tsw.WriteLinef("$.registerInterfaceType(")
 	c.tsw.WriteLinef("  '%s',", interfaceName)
@@ -605,6 +635,13 @@ func (c *GoToTSCompiler) WriteImportSpec(a *ast.ImportSpec) {
 		importVars: make(map[string]struct{}),
 	}
 
+	// Skip writing the import if it was already written as a synthetic import
+	// This prevents duplicate imports when a file needs an import both from
+	// its AST and for promoted methods from embedded structs
+	if _, isSynthetic := c.analysis.SyntheticImports[impName]; isSynthetic {
+		return
+	}
+
 	c.tsw.WriteImport(impName, tsImportPath+"/index.js")
 }
 

package/compiler/stmt-assign.go

@@ -168,6 +168,21 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 
 	// Handle single assignment using writeAssignmentCore
 	if len(exp.Lhs) == 1 {
+		// Check for type shadowing (e.g., field := field{...})
+		// In this case, we need to rename the variable to avoid TypeScript shadowing
+		if nodeInfo := c.analysis.NodeData[exp]; nodeInfo != nil && nodeInfo.ShadowingInfo != nil {
+			if lhsIdent, ok := exp.Lhs[0].(*ast.Ident); ok && lhsIdent.Name != "_" {
+				if renamedVar, hasTypeShadow := nodeInfo.ShadowingInfo.TypeShadowedVars[lhsIdent.Name]; hasTypeShadow {
+					if err := c.writeTypeShadowedAssignment(exp, lhsIdent.Name, renamedVar); err != nil {
+						return err
+					}
+					c.writeInlineComment(exp)
+					c.tsw.WriteLine("")
+					return nil
+				}
+			}
+		}
+
 		addDeclaration := exp.Tok == token.DEFINE
 		if err := c.writeAssignmentCore(exp.Lhs, exp.Rhs, exp.Tok, addDeclaration); err != nil {
 			return err
@@ -536,3 +551,59 @@ func (c *GoToTSCompiler) writeMapLookupWithExists(lhs []ast.Expr, indexExpr *ast
 
 	return nil
 }
+
+// writeTypeShadowedAssignment handles the case where a variable name shadows a type name
+// used in its initialization (e.g., field := field{...}).
+// In TypeScript, `let field = new field({...})` fails because the variable shadows the class
+// before initialization due to the Temporal Dead Zone (TDZ). The TDZ extends from the
+// start of the block scope to the point of initialization, so even capturing the type
+// reference before the `let` declaration doesn't work - they're in the same block.
+//
+// We solve this by renaming the variable to avoid the conflict entirely:
+//
+//	let field_ = $.markAsStructValue(new field({...}));
+//
+// Then we need to track that all subsequent references to `field` should use `field_`.
+// This is stored in the analysis NodeInfo.IdentifierMapping.
+func (c *GoToTSCompiler) writeTypeShadowedAssignment(exp *ast.AssignStmt, origName, renamedVar string) error {
+	if len(exp.Lhs) != 1 || len(exp.Rhs) != 1 {
+		return fmt.Errorf("type shadowing assignment must have exactly 1 LHS and 1 RHS")
+	}
+
+	lhsIdent, ok := exp.Lhs[0].(*ast.Ident)
+	if !ok {
+		return fmt.Errorf("type shadowing assignment LHS must be an identifier")
+	}
+
+	// Check if this variable needs VarRef
+	obj := c.objectOfIdent(lhsIdent)
+	needsVarRef := obj != nil && c.analysis.NeedsVarRef(obj)
+
+	// Store the mapping so that subsequent references to this variable use the renamed version
+	if obj != nil {
+		c.renamedVars[obj] = renamedVar
+	}
+
+	if needsVarRef {
+		// For VarRef'd variables:
+		// let field_ = $.varRef($.markAsStructValue(new field({...})))
+		c.tsw.WriteLiterally("let ")
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(renamedVar))
+		c.tsw.WriteLiterally(" = $.varRef(")
+		if err := c.WriteValueExpr(exp.Rhs[0]); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
+	} else {
+		// For non-VarRef variables:
+		// let field_ = $.markAsStructValue(new field({...}))
+		c.tsw.WriteLiterally("let ")
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(renamedVar))
+		c.tsw.WriteLiterally(" = ")
+		if err := c.WriteValueExpr(exp.Rhs[0]); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

package/compiler/stmt-range.go

@@ -171,7 +171,7 @@ func (c *GoToTSCompiler) writeStringRange(exp *ast.RangeStmt) error {
 
 	if exp.Value != nil {
 		if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
-			c.tsw.WriteLiterally("const ")
+			c.tsw.WriteLiterally("let ")
 			c.WriteIdent(ident, false)
 			c.tsw.WriteLiterally(" = _runes[")
 			c.tsw.WriteLiterally(indexVarName)
@@ -236,7 +236,7 @@ func (c *GoToTSCompiler) writeArraySliceWithKeyValue(exp *ast.RangeStmt, indexVa
 	c.tsw.WriteLine("")
 
 	if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
-		c.tsw.WriteLiterally("const ")
+		c.tsw.WriteLiterally("let ")
 		c.WriteIdent(ident, false)
 		c.tsw.WriteLiterally(" = ")
 		if err := c.writeArraySliceExpression(exp.X, isPointer); err != nil {

package/compiler/stmt.go

@@ -368,6 +368,15 @@ func (c *GoToTSCompiler) WriteStmtExpr(exp *ast.ExprStmt) error {
 		return nil
 	}
 
+	// Defensive semicolon: if the expression will start with '(' in TypeScript,
+	// prepend a semicolon to prevent JavaScript from treating the previous line
+	// as a function call. This happens when:
+	// 1. CallExpr where Fun itself will be parenthesized (e.g., (await fn())())
+	// 2. Array/slice literals starting with '['
+	if c.needsDefensiveSemicolon(exp.X) {
+		c.tsw.WriteLiterally(";")
+	}
+
 	// Handle other expression statements
 	if err := c.WriteValueExpr(exp.X); err != nil { // Expression statement evaluates a value
 		return err
@@ -528,16 +537,8 @@ func (c *GoToTSCompiler) WriteStmtReturn(exp *ast.ReturnStmt) error {
 	nodeInfo := c.analysis.NodeData[exp]
 	if nodeInfo != nil && nodeInfo.IsBareReturn {
 		var namedReturns []string
-		if nodeInfo.EnclosingFuncDecl != nil {
-			if obj := c.pkg.TypesInfo.ObjectOf(nodeInfo.EnclosingFuncDecl.Name); obj != nil {
-				if funcInfo := c.analysis.FunctionData[obj]; funcInfo != nil {
-					namedReturns = funcInfo.NamedReturns
-				}
-			}
-		} else if nodeInfo.EnclosingFuncLit != nil {
-			if funcInfo := c.analysis.FuncLitData[nodeInfo.EnclosingFuncLit]; funcInfo != nil {
-				namedReturns = funcInfo.NamedReturns
-			}
+		if funcInfo := c.analysis.GetFunctionInfoFromContext(nodeInfo, c.pkg); funcInfo != nil {
+			namedReturns = funcInfo.NamedReturns
 		}
 
 		if len(namedReturns) == 1 {
@@ -582,6 +583,12 @@ func (c *GoToTSCompiler) WriteStmtReturn(exp *ast.ReturnStmt) error {
 					}
 				}
 			}
+
+			// Special handling for primitive types that implement error interface
+			if c.writePrimitiveErrorWrapperIfNeeded(exp, res, i) {
+				continue
+			}
+
 			if err := c.WriteValueExpr(res); err != nil { // Return results are values
 				return err
 			}
@@ -594,6 +601,84 @@ func (c *GoToTSCompiler) WriteStmtReturn(exp *ast.ReturnStmt) error {
 	return nil
 }
 
+// writePrimitiveErrorWrapperIfNeeded checks if a return value is a primitive type
+// that implements the error interface, and if so, wraps it with $.wrapPrimitiveError.
+// Returns true if the wrapper was written, false otherwise.
+func (c *GoToTSCompiler) writePrimitiveErrorWrapperIfNeeded(retStmt *ast.ReturnStmt, res ast.Expr, resultIndex int) bool {
+	// Get the expected return type for this position
+	nodeInfo := c.analysis.NodeData[retStmt]
+	if nodeInfo == nil || nodeInfo.EnclosingFuncDecl == nil {
+		return false
+	}
+
+	funcDecl := nodeInfo.EnclosingFuncDecl
+	if funcDecl.Type.Results == nil {
+		return false
+	}
+
+	// Find the expected return type for this result index
+	var expectedType types.Type
+	resultIdx := 0
+	for _, field := range funcDecl.Type.Results.List {
+		count := len(field.Names)
+		if count == 0 {
+			count = 1
+		}
+		for j := 0; j < count; j++ {
+			if resultIdx == resultIndex {
+				expectedType = c.pkg.TypesInfo.TypeOf(field.Type)
+				break
+			}
+			resultIdx++
+		}
+		if expectedType != nil {
+			break
+		}
+	}
+
+	if expectedType == nil {
+		return false
+	}
+
+	// Check if the expected type is the error interface
+	if iface, ok := expectedType.Underlying().(*types.Interface); !ok || iface.String() != "interface{Error() string}" {
+		return false
+	}
+
+	// Get the actual type of the return expression
+	actualType := c.pkg.TypesInfo.TypeOf(res)
+	if actualType == nil {
+		return false
+	}
+
+	// Check if the actual type is a wrapper type (named type with basic underlying type)
+	if !c.isWrapperType(actualType) {
+		return false
+	}
+
+	// Check if the actual type has an Error() method
+	if !c.typeHasMethods(actualType, "Error") {
+		return false
+	}
+
+	// Get the qualified type name for the Error function
+	typeName := c.getQualifiedTypeName(actualType)
+	if typeName == "" {
+		return false
+	}
+
+	// Write: $.wrapPrimitiveError(value, TypeName_Error)
+	c.tsw.WriteLiterally("$.wrapPrimitiveError(")
+	if err := c.WriteValueExpr(res); err != nil {
+		return false
+	}
+	c.tsw.WriteLiterally(", ")
+	c.tsw.WriteLiterally(typeName)
+	c.tsw.WriteLiterally("_Error)")
+
+	return true
+}
+
 // WriteStmtBlock translates a Go block statement (`ast.BlockStmt`), typically
 // `{ ...stmts... }`, into its TypeScript equivalent, carefully preserving
 // comments and blank lines to maintain code readability and structure.
@@ -1137,3 +1222,38 @@ func (c *GoToTSCompiler) substituteExprForShadowing(expr ast.Expr, shadowingInfo
 func (c *GoToTSCompiler) isBuiltinFunction(name string) bool {
 	return builtinFunctions[name]
 }
+
+// needsDefensiveSemicolon determines if an expression will generate TypeScript
+// code starting with '(' or '[', which would require a defensive semicolon to
+// prevent JavaScript from treating the previous line as a function call.
+func (c *GoToTSCompiler) needsDefensiveSemicolon(expr ast.Expr) bool {
+	switch e := expr.(type) {
+	case *ast.CallExpr:
+		// Check if the function being called will be parenthesized
+		// This happens when Fun is itself a CallExpr, TypeAssertExpr, or other complex expression
+		switch e.Fun.(type) {
+		case *ast.CallExpr:
+			// (fn())() - needs defensive semicolon
+			return true
+		case *ast.TypeAssertExpr:
+			// (x.(T))() - needs defensive semicolon
+			return true
+		case *ast.IndexExpr:
+			// Could generate (arr[i])() if indexed result is called
+			// But typically doesn't need defensive semicolon as arr[i]() is fine
+			return false
+		case *ast.ParenExpr:
+			// Already parenthesized - needs defensive semicolon
+			return true
+		}
+	case *ast.CompositeLit:
+		// Array/slice literals start with '['
+		if _, isArray := e.Type.(*ast.ArrayType); isArray {
+			return true
+		}
+	case *ast.ParenExpr:
+		// Parenthesized expressions start with '('
+		return true
+	}
+	return false
+}