fix: import handling for struct embedding with promoted methods

When embedding structs like bytes.Buffer, promoted methods reference types from
packages (e.g., io.Reader, io.Writer) that may not be imported in the source Go
file. This caused TypeScript compilation errors.

The fix adds import detection during the analysis phase by scanning embedded
struct types and recursively collecting all packages referenced by promoted
method signatures. These imports are then written during code generation.

Signed-off-by: Christian Stewart <[email protected]>

Author: paralin

compiler/analysis.go

@@ -1207,9 +1207,145 @@ func AnalyzePackageFiles(pkg *packages.Package, allPackages map[string]*packages
 	// Interface implementation async status is now updated on-demand in IsInterfaceMethodAsync
 	visitor.analyzeAllMethodsAsync()
 
+	// Fourth pass: collect imports needed by promoted methods from embedded structs
+	analysis.addImportsForPromotedMethods(pkg)
+
 	return analysis
 }
 
+// addImportsForPromotedMethods scans all struct types in the package for embedded fields
+// and adds imports for any packages referenced by the promoted methods' parameter/return types.
+func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
+	// Collect all package names we need to add
+	packagesToAdd := make(map[string]*types.Package)
+
+	// Iterate through all type definitions in the package
+	scope := pkg.Types.Scope()
+	for _, name := range scope.Names() {
+		obj := scope.Lookup(name)
+		if obj == nil {
+			continue
+		}
+
+		// Check if it's a type definition
+		typeName, ok := obj.(*types.TypeName)
+		if !ok {
+			continue
+		}
+
+		// Get the underlying type
+		namedType, ok := typeName.Type().(*types.Named)
+		if !ok {
+			continue
+		}
+
+		// Check if it's a struct
+		structType, ok := namedType.Underlying().(*types.Struct)
+		if !ok {
+			continue
+		}
+
+		// Look for embedded fields
+		for i := 0; i < structType.NumFields(); i++ {
+			field := structType.Field(i)
+			if !field.Embedded() {
+				continue
+			}
+
+			// Get the type of the embedded field
+			embeddedType := field.Type()
+			
+			// Handle pointer to embedded type
+			if ptr, ok := embeddedType.(*types.Pointer); ok {
+				embeddedType = ptr.Elem()
+			}
+
+			// Get named type to access methods
+			embeddedNamed, ok := embeddedType.(*types.Named)
+			if !ok {
+				continue
+			}
+
+			// Scan all methods of the embedded type
+			for j := 0; j < embeddedNamed.NumMethods(); j++ {
+				method := embeddedNamed.Method(j)
+				sig, ok := method.Type().(*types.Signature)
+				if !ok {
+					continue
+				}
+
+				// Scan parameters
+				if sig.Params() != nil {
+					for k := 0; k < sig.Params().Len(); k++ {
+						param := sig.Params().At(k)
+						a.collectPackageFromType(param.Type(), pkg.Types, packagesToAdd)
+					}
+				}
+
+				// Scan results
+				if sig.Results() != nil {
+					for k := 0; k < sig.Results().Len(); k++ {
+						result := sig.Results().At(k)
+						a.collectPackageFromType(result.Type(), pkg.Types, packagesToAdd)
+					}
+				}
+			}
+		}
+	}
+
+	// Add collected packages to imports
+	for pkgName, pkgObj := range packagesToAdd {
+		if _, exists := a.Imports[pkgName]; !exists {
+			tsImportPath := "@goscript/" + pkgObj.Path()
+			a.Imports[pkgName] = &fileImport{
+				importPath: tsImportPath,
+				importVars: make(map[string]struct{}),
+			}
+		}
+	}
+}
+
+// collectPackageFromType recursively collects packages referenced by a type.
+func (a *Analysis) collectPackageFromType(t types.Type, currentPkg *types.Package, packagesToAdd map[string]*types.Package) {
+	switch typ := t.(type) {
+	case *types.Named:
+		pkg := typ.Obj().Pkg()
+		if pkg != nil && pkg != currentPkg {
+			packagesToAdd[pkg.Name()] = pkg
+		}
+		// Check type arguments for generics
+		if typ.TypeArgs() != nil {
+			for i := 0; i < typ.TypeArgs().Len(); i++ {
+				a.collectPackageFromType(typ.TypeArgs().At(i), currentPkg, packagesToAdd)
+			}
+		}
+	case *types.Pointer:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Slice:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Array:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Map:
+		a.collectPackageFromType(typ.Key(), currentPkg, packagesToAdd)
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Chan:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Signature:
+		// Collect from parameters
+		if typ.Params() != nil {
+			for i := 0; i < typ.Params().Len(); i++ {
+				a.collectPackageFromType(typ.Params().At(i).Type(), currentPkg, packagesToAdd)
+			}
+		}
+		// Collect from results
+		if typ.Results() != nil {
+			for i := 0; i < typ.Results().Len(); i++ {
+				a.collectPackageFromType(typ.Results().At(i).Type(), currentPkg, packagesToAdd)
+			}
+		}
+	}
+}
+
 // AnalyzePackageImports performs package-level analysis to collect function definitions
 // and calls across all files in the package for auto-import generation
 func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {

compiler/compiler.go

@@ -676,6 +676,36 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 		}
 	}
 
+	// Write any imports that were added during analysis (e.g., for promoted methods)
+	// but don't appear in the source AST
+	writtenImports := make(map[string]bool)
+	// Track imports that will be written from the AST
+	for _, imp := range f.Imports {
+		if imp.Path != nil {
+			path := imp.Path.Value[1 : len(imp.Path.Value)-1] // Remove quotes
+			if imp.Name != nil && imp.Name.Name != "" {
+				writtenImports[imp.Name.Name] = true
+			} else {
+				// Use the actual package name
+				if actualName, err := getActualPackageName(path, c.pkg.Imports); err == nil {
+					writtenImports[actualName] = true
+				}
+			}
+		}
+	}
+	// Write imports from analysis that aren't in the AST
+	var additionalImports []string
+	for pkgName := range c.Analysis.Imports {
+		if !writtenImports[pkgName] && pkgName != "$" {
+			additionalImports = append(additionalImports, pkgName)
+		}
+	}
+	sort.Strings(additionalImports)
+	for _, pkgName := range additionalImports {
+		fileImp := c.Analysis.Imports[pkgName]
+		c.codeWriter.WriteImport(pkgName, fileImp.importPath+"/index.js")
+	}
+
 	c.codeWriter.WriteLine("") // Add a newline after imports
 
 	if err := goWriter.WriteDecls(f.Decls); err != nil {

compiler/spec-struct.go

@@ -345,15 +345,21 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			}
 		}
 
-		// Promoted methods
-		embeddedMethodSet := types.NewMethodSet(embeddedFieldType) // Use original field type for method set
-		for k := range embeddedMethodSet.Len() {
-			methodSelection := embeddedMethodSet.At(k)
-			method := methodSelection.Obj().(*types.Func)
-			methodName := method.Name()
-
-			// Skip if it's not a promoted method (indirect) or if it's shadowed by a direct method or an already processed promoted method
-			if len(methodSelection.Index()) == 1 && !directMethods[methodName] && !seenPromotedFields[methodName] {
+	// Promoted methods
+	// 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
+	methodSetType := embeddedFieldType
+	if _, isPtr := embeddedFieldType.(*types.Pointer); !isPtr {
+		methodSetType = types.NewPointer(embeddedFieldType)
+	}
+	embeddedMethodSet := types.NewMethodSet(methodSetType)
+	for k := range embeddedMethodSet.Len() {
+		methodSelection := embeddedMethodSet.At(k)
+		method := methodSelection.Obj().(*types.Func)
+		methodName := method.Name()
+
+		// Skip if it's not a promoted method (indirect) or if it's shadowed by a direct method or an already processed promoted method
+		if len(methodSelection.Index()) == 1 && !directMethods[methodName] && !seenPromotedFields[methodName] {
 				// Check for conflict with outer struct's own fields
 				conflictWithField := false
 				for k_idx := 0; k_idx < underlyingStruct.NumFields(); k_idx++ {
@@ -543,15 +549,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

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
@@ -1129,3 +1138,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
+}

compiler/type.go

@@ -249,7 +249,8 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 	typePkg := t.Obj().Pkg()
 	if typePkg != nil && typePkg != c.pkg.Types {
 		// This type is from an imported package, find the import alias
-		if alias, found := c.resolveImportAlias(typePkg); found {
+		alias, found := c.resolveImportAlias(typePkg)
+		if found && alias != "" {
 			// Write the qualified name: importAlias.TypeName
 			c.tsw.WriteLiterally(alias)
 			c.tsw.WriteLiterally(".")

compliance/WIP.md

@@ -4,6 +4,13 @@ import { foldName } from "./fold.gs.js";
 import { checkValid, stateEndValue } from "./scanner.gs.js";
 import { structFields } from "./encode.gs.js";
 import { scanner } from "./scanner.gs.js";
+import * as bytes from "bytes/index.js"
+import * as cmp from "cmp/index.js"
+import * as errors from "errors/index.js"
+import * as io from "io/index.js"
+import * as math from "math/index.js"
+import * as slices from "slices/index.js"
+import * as sync from "sync/index.js"
 
 import * as encoding from "@goscript/encoding/index.js"