goscript 0.0.61 → 0.0.62

package/compiler/expr-selector.go

@@ -130,10 +130,23 @@ func (c *GoToTSCompiler) WriteSelectorExpr(exp *ast.SelectorExpr) error {
 
 	// Fallback / Normal Case (e.g., obj.Field, pkg.Var, method calls)
 	// WriteValueExpr handles adding .value for the base variable itself if it's varrefed.
+
+	// Check if the base expression is an async call - if so, we need to wrap it in parentheses
+	// so that await binds correctly: (await asyncFn()).method instead of await asyncFn().method
+	needsParensForAsync := false
+	if callExpr, isCall := exp.X.(*ast.CallExpr); isCall && c.isCallExprAsync(callExpr) {
+		needsParensForAsync = true
+		c.tsw.WriteLiterally("(")
+	}
+
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write selector base expression: %w", err)
 	}
 
+	if needsParensForAsync {
+		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)
@@ -212,8 +225,24 @@ func (c *GoToTSCompiler) writeMethodValue(exp *ast.SelectorExpr, selection *type
 			return fmt.Errorf("failed to get qualified type name for primitive receiver")
 		}
 
-		// Generate: () => TypeName_MethodName(receiverValue)
-		c.tsw.WriteLiterally("(() => ")
+		// Get the method parameters to forward them
+		params := sig.Params()
+		paramNames := make([]string, params.Len())
+		for i := 0; i < params.Len(); i++ {
+			paramNames[i] = fmt.Sprintf("_p%d", i)
+		}
+
+		// Generate: ((_p0: type0, _p1: type1, ...) => TypeName_MethodName(receiverValue, _p0, _p1, ...))
+		c.tsw.WriteLiterally("((")
+		for i, name := range paramNames {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.tsw.WriteLiterally(name)
+			c.tsw.WriteLiterally(": ")
+			c.WriteGoType(params.At(i).Type(), GoTypeContextGeneral)
+		}
+		c.tsw.WriteLiterally(") => ")
 		c.tsw.WriteLiterally(typeName)
 		c.tsw.WriteLiterally("_")
 		c.tsw.WriteLiterally(exp.Sel.Name)
@@ -221,6 +250,10 @@ func (c *GoToTSCompiler) writeMethodValue(exp *ast.SelectorExpr, selection *type
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write method value receiver: %w", err)
 		}
+		for _, name := range paramNames {
+			c.tsw.WriteLiterally(", ")
+			c.tsw.WriteLiterally(name)
+		}
 		c.tsw.WriteLiterally("))")
 
 		return nil

package/compiler/expr-type.go

@@ -26,13 +26,23 @@ func (c *GoToTSCompiler) WriteTypeExpr(a ast.Expr) {
 			// Check if this is a package selector (e.g., os.FileInfo)
 			if obj := c.pkg.TypesInfo.Uses[pkgIdent]; obj != nil {
 				if _, isPkg := obj.(*types.PkgName); isPkg {
-					// This is a package.Type reference - write the qualified name
+					// This is a package.Type reference
+					typ := c.pkg.TypesInfo.TypeOf(a)
+
+					// Check if this is an interface type and add null | prefix
+					if typ != nil {
+						if _, isInterface := typ.Underlying().(*types.Interface); isInterface {
+							c.tsw.WriteLiterally("null | ")
+						}
+					}
+
+					// Write the qualified name
 					c.tsw.WriteLiterally(pkgIdent.Name)
 					c.tsw.WriteLiterally(".")
 					c.tsw.WriteLiterally(selectorExpr.Sel.Name)
 
 					// Check if this is a function type and add | null
-					if typ := c.pkg.TypesInfo.TypeOf(a); typ != nil {
+					if typ != nil {
 						if namedType, isNamed := typ.(*types.Named); isNamed {
 							if _, isSignature := namedType.Underlying().(*types.Signature); isSignature {
 								c.tsw.WriteLiterally(" | null")

package/compiler/expr.go

@@ -441,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)
@@ -479,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("")
@@ -543,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
@@ -573,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)
@@ -406,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("]")
 					}
@@ -625,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
@@ -574,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
 			}
@@ -586,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.
@@ -1129,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
+}

package/compiler/type-utils.go

@@ -25,11 +25,50 @@ func (c *GoToTSCompiler) isRuneSliceType(t types.Type) bool {
 	return false
 }
 
-// isStringType checks if a type is string
+// isStringType checks if a type is string or could be string (e.g., type parameter)
 func (c *GoToTSCompiler) isStringType(t types.Type) bool {
 	if basic, isBasic := t.Underlying().(*types.Basic); isBasic {
 		return basic.Kind() == types.String || basic.Kind() == types.UntypedString
 	}
+	// Handle type parameters (e.g., Bytes ~[]byte | ~string)
+	if typeParam, isTypeParam := t.(*types.TypeParam); isTypeParam {
+		constraint := typeParam.Constraint()
+		if constraintIface, ok := constraint.(*types.Interface); ok {
+			return c.constraintIncludesString(constraintIface)
+		}
+	}
+	return false
+}
+
+// constraintIncludesString checks if a type constraint includes string
+func (c *GoToTSCompiler) constraintIncludesString(constraint *types.Interface) bool {
+	// Check if the constraint has type terms that include string
+	if constraint.IsMethodSet() {
+		return false // Pure method interface, no type terms
+	}
+	// For union constraints like []byte | string, check each term
+	for i := 0; i < constraint.NumEmbeddeds(); i++ {
+		embedded := constraint.EmbeddedType(i)
+		// Check if embedded is a union
+		if union, isUnion := embedded.(*types.Union); isUnion {
+			for j := 0; j < union.Len(); j++ {
+				term := union.Term(j)
+				termType := term.Type()
+				// Check if term is string or ~string
+				if basic, isBasic := termType.Underlying().(*types.Basic); isBasic {
+					if basic.Kind() == types.String {
+						return true
+					}
+				}
+			}
+		}
+		// Check direct embedded type
+		if basic, isBasic := embedded.Underlying().(*types.Basic); isBasic {
+			if basic.Kind() == types.String {
+				return true
+			}
+		}
+	}
 	return false
 }