fix: correctly import types from separate files

Signed-off-by: Christian Stewart <christian@aperture.us>

Author: paralin

compiler/analysis.go

@@ -125,6 +125,14 @@ type PackageAnalysis struct {
 	// FunctionCalls maps file names to the functions they call from other files
 	// Key: filename (without .go extension), Value: map[sourceFile][]functionNames
 	FunctionCalls map[string]map[string][]string
+
+	// TypeDefs maps file names to the types defined in that file
+	// Key: filename (without .go extension), Value: list of type names
+	TypeDefs map[string][]string
+
+	// TypeCalls maps file names to the types they reference from other files
+	// Key: filename (without .go extension), Value: map[sourceFile][]typeNames
+	TypeCalls map[string]map[string][]string
 }
 
 // NewAnalysis creates a new Analysis instance.
@@ -146,6 +154,8 @@ func NewPackageAnalysis() *PackageAnalysis {
 	return &PackageAnalysis{
 		FunctionDefs:  make(map[string][]string),
 		FunctionCalls: make(map[string]map[string][]string),
+		TypeDefs:      make(map[string][]string),
+		TypeCalls:     make(map[string]map[string][]string),
 	}
 }
 
@@ -1036,18 +1046,30 @@ func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
 		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
 
 		var functions []string
+		var types []string
 		for _, decl := range syntax.Decls {
 			if funcDecl, ok := decl.(*ast.FuncDecl); ok {
 				// Only collect top-level functions (not methods)
 				if funcDecl.Recv == nil {
 					functions = append(functions, funcDecl.Name.Name)
 				}
 			}
+			if genDecl, ok := decl.(*ast.GenDecl); ok {
+				// Collect type declarations
+				for _, spec := range genDecl.Specs {
+					if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+						types = append(types, typeSpec.Name.Name)
+					}
+				}
+			}
 		}
 
 		if len(functions) > 0 {
 			analysis.FunctionDefs[baseFileName] = functions
 		}
+		if len(types) > 0 {
+			analysis.TypeDefs[baseFileName] = types
+		}
 	}
 
 	// Second pass: analyze function calls and determine which need imports
@@ -1111,6 +1133,71 @@ func AnalyzePackage(pkg *packages.Package) *PackageAnalysis {
 		}
 	}
 
+	// Third pass: analyze type references and determine which need imports
+	for i, syntax := range pkg.Syntax {
+		fileName := pkg.CompiledGoFiles[i]
+		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
+
+		// Find all type references in this file
+		typeRefsFromOtherFiles := make(map[string][]string)
+
+		ast.Inspect(syntax, func(n ast.Node) bool {
+			// Look for type references in struct fields, function parameters, etc.
+			if ident, ok := n.(*ast.Ident); ok {
+				// Check if this identifier refers to a type
+				if obj := pkg.TypesInfo.Uses[ident]; obj != nil {
+					if _, ok := obj.(*types.TypeName); ok {
+						typeName := ident.Name
+
+						// Check if this type is defined in the current file
+						currentFileTypes := analysis.TypeDefs[baseFileName]
+						isDefinedInCurrentFile := false
+						for _, t := range currentFileTypes {
+							if t == typeName {
+								isDefinedInCurrentFile = true
+								break
+							}
+						}
+
+						// If not defined in current file, find which file defines it
+						if !isDefinedInCurrentFile {
+							for sourceFile, types := range analysis.TypeDefs {
+								if sourceFile == baseFileName {
+									continue // Skip current file
+								}
+								for _, t := range types {
+									if t == typeName {
+										// Found the type in another file
+										if typeRefsFromOtherFiles[sourceFile] == nil {
+											typeRefsFromOtherFiles[sourceFile] = []string{}
+										}
+										// Check if already added to avoid duplicates
+										found := false
+										for _, existing := range typeRefsFromOtherFiles[sourceFile] {
+											if existing == typeName {
+												found = true
+												break
+											}
+										}
+										if !found {
+											typeRefsFromOtherFiles[sourceFile] = append(typeRefsFromOtherFiles[sourceFile], typeName)
+										}
+										break
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			return true
+		})
+
+		if len(typeRefsFromOtherFiles) > 0 {
+			analysis.TypeCalls[baseFileName] = typeRefsFromOtherFiles
+		}
+	}
+
 	return analysis
 }
 

compiler/compiler.go

@@ -621,6 +621,61 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 		}
 	}
 
+	// Generate auto-imports for types from other files in the same package
+	if typeImports := c.PackageAnalysis.TypeCalls[currentFileName]; typeImports != nil {
+		// Sort source files for consistent import order
+		var sourceFiles []string
+		for sourceFile := range typeImports {
+			sourceFiles = append(sourceFiles, sourceFile)
+		}
+		sort.Strings(sourceFiles)
+
+		for _, sourceFile := range sourceFiles {
+			typeImports := typeImports[sourceFile]
+			if len(typeImports) > 0 {
+				// Filter out protobuf types - they should be imported from .pb.js files, not .gs.js files
+				var nonProtobufTypes []string
+				for _, typeName := range typeImports {
+					// Check if this type is a protobuf type by looking for it in the package
+					isProtobuf := false
+					if typeObj := c.pkg.Types.Scope().Lookup(typeName); typeObj != nil {
+						objType := typeObj.Type()
+						if namedType, ok := objType.(*types.Named); ok {
+							obj := namedType.Obj()
+							if obj != nil && obj.Pkg() != nil {
+								// Check if the type is defined in the current package and has a corresponding .pb.go file
+								if obj.Pkg() == c.pkg.Types {
+									// Check if there's a .pb.go file in the package that exports this type
+									// For now, we'll use a simple heuristic: if the type name ends with "Msg"
+									// and there's a .pb.go file in the package, assume it's a protobuf type
+									if strings.HasSuffix(typeName, "Msg") {
+										// Check if there are any .pb.go files in this package
+										for _, fileName := range c.pkg.CompiledGoFiles {
+											if strings.HasSuffix(fileName, ".pb.go") {
+												isProtobuf = true
+												break
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+					if !isProtobuf {
+						nonProtobufTypes = append(nonProtobufTypes, typeName)
+					}
+				}
+
+				if len(nonProtobufTypes) > 0 {
+					// Sort types for consistent output
+					sort.Strings(nonProtobufTypes)
+					c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
+						strings.Join(nonProtobufTypes, ", "), sourceFile)
+				}
+			}
+		}
+	}
+
 	c.codeWriter.WriteLine("") // Add a newline after imports
 
 	if err := goWriter.WriteDecls(f.Decls); err != nil {

compiler/spec-struct.go

@@ -20,10 +20,9 @@ import (
 //   - Wrapper methods for promoted fields and methods from embedded structs,
 //     ensuring correct access and behavior.
 func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType) error {
-	// Add export for Go-exported structs
-	if a.Name.IsExported() {
-		c.tsw.WriteLiterally("export ")
-	}
+	// Always export types for cross-file imports within the same package
+	// This allows unexported Go types to be imported by other files in the same package
+	c.tsw.WriteLiterally("export ")
 	c.tsw.WriteLiterally("class ")
 	if err := c.WriteValueExpr(a.Name); err != nil {
 		return err

compiler/spec.go

@@ -196,7 +196,7 @@ func (c *GoToTSCompiler) WriteNamedTypeWithMethods(a *ast.TypeSpec) error {
 		isInsideFunction = nodeInfo.IsInsideFunction
 	}
 
-	if a.Name.IsExported() && !isInsideFunction {
+	if !isInsideFunction {
 		c.tsw.WriteLiterally("export ")
 	}
 
@@ -404,13 +404,13 @@ func (c *GoToTSCompiler) WriteTypeSpec(a *ast.TypeSpec) error {
 			return c.WriteNamedTypeWithMethods(a)
 		}
 
-		// type alias - add export for Go-exported types (but not if inside a function)
+		// Always export types for cross-file imports within the same package (but not if inside a function)
 		isInsideFunction := false
 		if nodeInfo := c.analysis.NodeData[a]; nodeInfo != nil {
 			isInsideFunction = nodeInfo.IsInsideFunction
 		}
 
-		if a.Name.IsExported() && !isInsideFunction {
+		if !isInsideFunction {
 			c.tsw.WriteLiterally("export ")
 		}
 		c.tsw.WriteLiterally("type ")
@@ -438,7 +438,7 @@ func (c *GoToTSCompiler) WriteInterfaceTypeSpec(a *ast.TypeSpec, t *ast.Interfac
 		isInsideFunction = nodeInfo.IsInsideFunction
 	}
 
-	if a.Name.IsExported() && !isInsideFunction {
+	if !isInsideFunction {
 		c.tsw.WriteLiterally("export ")
 	}
 	c.tsw.WriteLiterally("type ")

compiler/stmt-range.go

@@ -157,7 +157,7 @@ func (c *GoToTSCompiler) writeMapRange(exp *ast.RangeStmt) error {
 	if err := c.WriteValueExpr(exp.X); err != nil {
 		return fmt.Errorf("failed to write range loop map expression: %w", err)
 	}
-	c.tsw.WriteLiterally(".entries()) {")
+	c.tsw.WriteLiterally("?.entries() ?? []) {")
 	c.tsw.Indent(1)
 	c.tsw.WriteLine("")
 

compiler/type.go

@@ -373,14 +373,15 @@ func (c *GoToTSCompiler) WriteArrayType(t *types.Array) {
 }
 
 // WriteMapType translates a Go map type (map[K]V) to its TypeScript equivalent.
-// It generates Map<K_ts, V_ts>, where K_ts and V_ts are the translated key
+// It generates Map<K_ts, V_ts> | null, where K_ts and V_ts are the translated key
 // and element types respectively.
+// Maps are nilable in Go, so they are represented as nullable types in TypeScript.
 func (c *GoToTSCompiler) WriteMapType(t *types.Map) {
 	c.tsw.WriteLiterally("Map<")
 	c.WriteGoType(t.Key(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally(", ")
 	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
-	c.tsw.WriteLiterally(">")
+	c.tsw.WriteLiterally("> | null")
 }
 
 // WriteChannelType translates a Go channel type (chan T) to its TypeScript equivalent.

compliance/WIP.md

@@ -0,0 +1,42 @@
+# Type Missing Imports Issue
+
+## Problem Description
+When Go types are referenced across different files in the same package, the generated TypeScript code does not properly import these types, causing TypeScript compilation errors.
+
+## Test Case: `type_separate_files`
+- `memory.go` defines: `type file struct { name string; data []byte }`  
+- `storage.go` references: `type storage struct { files map[string]*file; children map[string]map[string]*file }`
+- `type_separate_files.go` uses both types
+
+## Issue Observed
+1. `memory.gs.ts` generates the `file` class but doesn't export it (because it's unexported in Go)
+2. `storage.gs.ts` references `file` type but doesn't import it from `memory.gs.ts`  
+3. TypeScript compilation fails: `Cannot find name 'file'`
+
+## Expected TypeScript Output
+- `memory.gs.ts` should export the `file` class (even though unexported in Go)
+- `storage.gs.ts` should import `{ file }` from `"./memory.gs.ts"`
+
+## Analysis Completed
+
+### Current Function Import System
+The compiler already has a system for cross-file function imports:
+- `PackageAnalysis.FunctionDefs` tracks which functions are defined in each file
+- `PackageAnalysis.FunctionCalls` tracks which functions each file calls from other files
+- `compiler.go` lines 602-622 generate import statements for functions
+
+### Root Cause
+1. **Export Issue**: In `spec-struct.go` line 23, structs are only exported if `a.Name.IsExported()` is true. For unexported types like `file`, this is false.
+2. **Import Issue**: There's no equivalent to `FunctionCalls` for tracking type dependencies across files.
+
+### Solution Approach
+1. **Always export types within same package**: Modify struct generation to export all types (even unexported ones) when generating TypeScript for same-package consumption
+2. **Add type dependency tracking**: Add `TypeDefs` and `TypeCalls` to `PackageAnalysis` similar to function tracking
+3. **Generate type imports**: Add import generation for types similar to function imports
+
+## Implementation Plan
+1. Add `TypeDefs` and `TypeCalls` fields to `PackageAnalysis` struct
+2. Implement type dependency analysis in `AnalyzePackage` function
+3. Modify struct generation to always export types within same package
+4. Add type import generation in compiler.go
+5. Test with `type_separate_files` test case 

compliance/compliance.go

@@ -490,13 +490,31 @@ func WriteTypeScriptRunner(t *testing.T, parentModulePath, testDir, tempDir stri
 		}
 	}
 
+	var mainFile string
 	if len(goFiles) > 1 {
-		t.Logf("warning: found multiple Go files in %s, using the first one for runner: %s", testDir, goFiles[0])
+		// Search for a file containing "func main("
+		for _, file := range goFiles {
+			content, err := os.ReadFile(file)
+			if err != nil {
+				t.Logf("warning: failed to read file %s: %v", file, err)
+				continue
+			}
+			if strings.Contains(string(content), "func main(") {
+				mainFile = file
+				break
+			}
+		}
+		if mainFile == "" {
+			t.Logf("warning: could not find any Go file containing 'func main(' in %s, using first file: %s", testDir, goFiles[0])
+			mainFile = goFiles[0]
+		}
+	} else {
+		mainFile = goFiles[0]
 	}
 
 	// Determine tsFileName relative to the test's package root
-	// e.g. if goFiles[0] is testDir/sub/main.go, relGoPath is sub/main.go
-	relGoPath, _ := filepath.Rel(testDir, goFiles[0])
+	// e.g. if mainFile is testDir/sub/main.go, relGoPath is sub/main.go
+	relGoPath, _ := filepath.Rel(testDir, mainFile)
 	tsFileRelPath := strings.TrimSuffix(relGoPath, ".go") + ".gs.ts"
 
 	testName := filepath.Base(testDir)

compliance/tests/buffer_value_field_error/buffer_value_field_error.gs.ts

@@ -3,7 +3,7 @@
 
 import * as $ from "@goscript/builtin/index.js";
 
-class buffer {
+export class buffer {
 	public get data(): $.Bytes {
 		return this._fields.data.value
 	}

compliance/tests/index_expr_type_assertion/index_expr_type_assertion.gs.ts

@@ -18,9 +18,9 @@ export async function main(): Promise<void> {
 	}
 
 	// Test type assertion assignment with map indexed LHS using regular assignment
-	let m: Map<string, null | any> = $.makeMap<string, null | any>()
+	let m: Map<string, null | any> | null = $.makeMap<string, null | any>()
 	$.mapSet(m, "key2", 123)
-	let mapResults: Map<string, null | any> = $.makeMap<string, null | any>()
+	let mapResults: Map<string, null | any> | null = $.makeMap<string, null | any>()
 	let ok2: boolean = false
 	let _gs_ta_val_545_: number
 	let _gs_ta_ok_545_: boolean