goscript 0.0.26 → 0.0.29

package/compiler/compiler.go

@@ -10,6 +10,7 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
+	"sort"
 	"strings"
 
 	gs "github.com/aperturerobotics/goscript"
@@ -145,6 +146,18 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 
 			// Visit all imports, including standard library packages
 			for _, imp := range pkg.Imports {
+				// Skip protobuf-go-lite packages and their dependencies
+				if isProtobufGoLitePackage(imp.PkgPath) {
+					c.le.Debugf("Skipping protobuf-go-lite package: %s", imp.PkgPath)
+					continue
+				}
+
+				// Skip packages that are only used by .pb.go files
+				if isPackageOnlyUsedByProtobufFiles(pkg, imp.PkgPath) {
+					c.le.Debugf("Skipping package only used by .pb.go files: %s", imp.PkgPath)
+					continue
+				}
+
 				visit(imp)
 			}
 		}
@@ -238,50 +251,6 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			continue
 		}
 
-		// Check if this is the unsafe package, which is not supported in GoScript
-		if pkg.PkgPath == "unsafe" {
-			// Find which packages that would actually be compiled depend on unsafe
-			var dependentPackages []string
-			for _, otherPkg := range pkgs {
-				if otherPkg.PkgPath != "unsafe" {
-					// Check if this package would actually be compiled (same logic as above)
-					wouldBeCompiled := true
-
-					// If the package was not explicitly requested, check if it has a handwritten equivalent
-					if !slices.Contains(patternPkgPaths, otherPkg.PkgPath) {
-						gsSourcePath := "gs/" + otherPkg.PkgPath
-						_, gsErr := gs.GsOverrides.ReadDir(gsSourcePath)
-						if gsErr == nil {
-							// Package has handwritten equivalent, so it wouldn't be compiled
-							wouldBeCompiled = false
-						}
-					}
-
-					// Skip packages that failed to load
-					if len(otherPkg.Errors) > 0 {
-						wouldBeCompiled = false
-					}
-
-					// Only include packages that would actually be compiled and import unsafe
-					if wouldBeCompiled {
-						for importPath := range otherPkg.Imports {
-							if importPath == "unsafe" {
-								dependentPackages = append(dependentPackages, otherPkg.PkgPath)
-								break
-							}
-						}
-					}
-				}
-			}
-
-			dependentList := "unknown package"
-			if len(dependentPackages) > 0 {
-				dependentList = strings.Join(dependentPackages, ", ")
-			}
-
-			return nil, fmt.Errorf("cannot compile package 'unsafe': GoScript does not support the unsafe package due to its low-level memory operations that are incompatible with TypeScript/JavaScript. This package is required by: %s. Consider using alternative approaches that don't require unsafe operations", dependentList)
-		}
-
 		pkgCompiler, err := NewPackageCompiler(c.le, &c.config, pkg)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create package compiler for %s: %w", pkg.PkgPath, err)
@@ -346,6 +315,9 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 		}
 	}
 
+	// Perform package-level analysis for auto-imports
+	packageAnalysis := AnalyzePackage(c.pkg)
+
 	// Track all compiled files for later generating the index.ts
 	compiledFiles := make([]string, 0, len(c.pkg.CompiledGoFiles))
 
@@ -357,13 +329,35 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 			return err
 		}
 
+		// Check if this is a .pb.go file that should be skipped
+		baseFileName := filepath.Base(fileName)
+		if strings.HasSuffix(baseFileName, ".pb.go") {
+			// Check if there's a corresponding .pb.ts file
+			pbTsFileName := strings.TrimSuffix(baseFileName, ".pb.go") + ".pb.ts"
+			packageDir := filepath.Dir(fileName)
+			pbTsPath := filepath.Join(packageDir, pbTsFileName)
+
+			if _, err := os.Stat(pbTsPath); err == nil {
+				// .pb.ts file exists, copy it instead of transpiling .pb.go
+				c.le.WithField("file", relWdFileName).Debug("found .pb.ts file, copying instead of transpiling .pb.go")
+
+				if err := c.copyProtobufTSFile(pbTsPath, pbTsFileName); err != nil {
+					return fmt.Errorf("failed to copy protobuf .pb.ts file: %w", err)
+				}
+
+				// Add the .pb file to our compiled files list for index generation
+				pbFileName := strings.TrimSuffix(baseFileName, ".pb.go") + ".pb"
+				compiledFiles = append(compiledFiles, pbFileName)
+				continue // Skip transpiling this .pb.go file
+			}
+		}
+
 		c.le.WithField("file", relWdFileName).Debug("compiling file")
-		if err := c.CompileFile(ctx, fileName, f); err != nil {
+		if err := c.CompileFile(ctx, fileName, f, packageAnalysis); err != nil {
 			return err
 		}
 
 		// Add the base filename to our list for the index.ts generation
-		baseFileName := filepath.Base(fileName)
 		// Strip .go extension and add .gs
 		gsFileName := strings.TrimSuffix(baseFileName, ".go") + ".gs"
 		compiledFiles = append(compiledFiles, gsFileName)
@@ -378,8 +372,9 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 }
 
 // generateIndexFile creates an index.ts file in the package output directory
-// that re-exports all symbols from the compiled TypeScript files.
-// This ensures the package can be imported correctly by TypeScript modules.
+// that re-exports only Go-exported symbols from the compiled TypeScript files.
+// This ensures the package can be imported correctly by TypeScript modules
+// while maintaining proper Go package boundaries.
 func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 	indexFilePath := filepath.Join(c.outputPath, "index.ts")
 
@@ -390,12 +385,128 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 	}
 	defer indexFile.Close() //nolint:errcheck
 
-	// Write the re-export statements for each compiled file
+	// Collect exported symbols from all files in the package
+	var exportedSymbols []string
+
+	// Iterate through all syntax files to find exported symbols
+	for i, syntax := range c.pkg.Syntax {
+		fileName := c.pkg.CompiledGoFiles[i]
+		baseFileName := filepath.Base(fileName)
+		gsFileName := strings.TrimSuffix(baseFileName, ".go") + ".gs"
+
+		// Only include this file if it was compiled (in our compiledFiles list)
+		fileWasCompiled := false
+		for _, compiledFile := range compiledFiles {
+			if compiledFile == gsFileName {
+				fileWasCompiled = true
+				break
+			}
+		}
+		if !fileWasCompiled {
+			continue
+		}
+
+		// Analyze declarations in this file to find exported symbols
+		for _, decl := range syntax.Decls {
+			switch d := decl.(type) {
+			case *ast.FuncDecl:
+				// Only include top-level functions (not methods)
+				if d.Recv == nil && d.Name.IsExported() {
+					exportedSymbols = append(exportedSymbols, d.Name.Name)
+				}
+			case *ast.GenDecl:
+				for _, spec := range d.Specs {
+					switch s := spec.(type) {
+					case *ast.TypeSpec:
+						if s.Name.IsExported() {
+							exportedSymbols = append(exportedSymbols, s.Name.Name)
+						}
+					case *ast.ValueSpec:
+						for _, name := range s.Names {
+							if name.IsExported() {
+								exportedSymbols = append(exportedSymbols, name.Name)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Remove duplicates and sort
+	symbolMap := make(map[string]bool)
+	for _, symbol := range exportedSymbols {
+		symbolMap[symbol] = true
+	}
+
+	var uniqueSymbols []string
+	for symbol := range symbolMap {
+		uniqueSymbols = append(uniqueSymbols, symbol)
+	}
+
+	// Sort for consistent output
+	sort.Strings(uniqueSymbols)
+
+	// Write selective re-exports for each compiled file
 	for _, fileName := range compiledFiles {
-		// Create the re-export line: export * from "./file.gs.js"
-		exportLine := fmt.Sprintf("export * from \"./%s.js\"\n", fileName)
-		if _, err := indexFile.WriteString(exportLine); err != nil {
-			return err
+		// Check if this is a protobuf file
+		if strings.HasSuffix(fileName, ".pb") {
+			// For protobuf files, add a simple re-export
+			pbTsFileName := fileName + ".ts"
+			if err := c.writeProtobufExports(indexFile, fileName, pbTsFileName); err != nil {
+				return err
+			}
+			continue
+		}
+
+		// Find which symbols this file exports
+		var fileSymbols []string
+
+		// Find the corresponding syntax file
+		for i, syntax := range c.pkg.Syntax {
+			syntaxFileName := c.pkg.CompiledGoFiles[i]
+			syntaxBaseFileName := filepath.Base(syntaxFileName)
+			syntaxGsFileName := strings.TrimSuffix(syntaxBaseFileName, ".go") + ".gs"
+
+			if syntaxGsFileName != fileName {
+				continue
+			}
+
+			// Collect exported symbols from this specific file
+			for _, decl := range syntax.Decls {
+				switch d := decl.(type) {
+				case *ast.FuncDecl:
+					if d.Recv == nil && d.Name.IsExported() {
+						fileSymbols = append(fileSymbols, d.Name.Name)
+					}
+				case *ast.GenDecl:
+					for _, spec := range d.Specs {
+						switch s := spec.(type) {
+						case *ast.TypeSpec:
+							if s.Name.IsExported() {
+								fileSymbols = append(fileSymbols, s.Name.Name)
+							}
+						case *ast.ValueSpec:
+							for _, name := range s.Names {
+								if name.IsExported() {
+									fileSymbols = append(fileSymbols, name.Name)
+								}
+							}
+						}
+					}
+				}
+			}
+			break
+		}
+
+		// Write selective export if this file has exported symbols
+		if len(fileSymbols) > 0 {
+			sort.Strings(fileSymbols)
+			exportLine := fmt.Sprintf("export { %s } from \"./%s.js\"\n",
+				strings.Join(fileSymbols, ", "), fileName)
+			if _, err := indexFile.WriteString(exportLine); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -408,7 +519,7 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 // about varRefing, async functions, defer statements).
 // Then, it creates a `FileCompiler` instance for the file and invokes its
 // `Compile` method to generate the TypeScript code.
-func (p *PackageCompiler) CompileFile(ctx context.Context, name string, syntax *ast.File) error {
+func (p *PackageCompiler) CompileFile(ctx context.Context, name string, syntax *ast.File, packageAnalysis *PackageAnalysis) error {
 	// Create a new analysis instance for per-file data
 	analysis := NewAnalysis()
 
@@ -418,7 +529,7 @@ func (p *PackageCompiler) CompileFile(ctx context.Context, name string, syntax *
 	// Analyze the file before compiling
 	AnalyzeFile(syntax, p.pkg, analysis, cmap)
 
-	fileCompiler, err := NewFileCompiler(p.compilerConf, p.pkg, syntax, name, analysis)
+	fileCompiler, err := NewFileCompiler(p.compilerConf, p.pkg, syntax, name, analysis, packageAnalysis)
 	if err != nil {
 		return err
 	}
@@ -430,12 +541,13 @@ func (p *PackageCompiler) CompileFile(ctx context.Context, name string, syntax *
 // initializes the `TSCodeWriter` for TypeScript code generation, and uses a
 // `GoToTSCompiler` to translate Go declarations and statements.
 type FileCompiler struct {
-	compilerConfig *Config
-	codeWriter     *TSCodeWriter
-	pkg            *packages.Package
-	ast            *ast.File
-	fullPath       string
-	Analysis       *Analysis
+	compilerConfig  *Config
+	codeWriter      *TSCodeWriter
+	pkg             *packages.Package
+	ast             *ast.File
+	fullPath        string
+	Analysis        *Analysis
+	PackageAnalysis *PackageAnalysis
 }
 
 // NewFileCompiler creates a new `FileCompiler` for a specific Go file.
@@ -448,13 +560,15 @@ func NewFileCompiler(
 	astFile *ast.File,
 	fullPath string,
 	analysis *Analysis,
+	packageAnalysis *PackageAnalysis,
 ) (*FileCompiler, error) {
 	return &FileCompiler{
-		compilerConfig: compilerConf,
-		pkg:            pkg,
-		ast:            astFile,
-		fullPath:       fullPath,
-		Analysis:       analysis,
+		compilerConfig:  compilerConf,
+		pkg:             pkg,
+		ast:             astFile,
+		fullPath:        fullPath,
+		Analysis:        analysis,
+		PackageAnalysis: packageAnalysis,
 	}, nil
 }
 
@@ -488,7 +602,26 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 
 	// Add import for the goscript runtime using namespace import and alias
 	c.codeWriter.WriteLinef("import * as $ from %q;", "@goscript/builtin/builtin.js")
-	c.codeWriter.WriteLine("") // Add a newline after the import
+
+	// Check if there are any .pb.go files in this package and add imports for them
+	if err := c.addProtobufImports(); err != nil {
+		return fmt.Errorf("failed to add protobuf imports: %w", err)
+	}
+
+	// Generate auto-imports for functions from other files in the same package
+	currentFileName := strings.TrimSuffix(filepath.Base(c.fullPath), ".go")
+	if imports := c.PackageAnalysis.FunctionCalls[currentFileName]; imports != nil {
+		for sourceFile, functions := range imports {
+			if len(functions) > 0 {
+				// Sort functions for consistent output
+				sort.Strings(functions)
+				c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
+					strings.Join(functions, ", "), sourceFile)
+			}
+		}
+	}
+
+	c.codeWriter.WriteLine("") // Add a newline after imports
 
 	if err := goWriter.WriteDecls(f.Decls); err != nil {
 		return fmt.Errorf("failed to write declarations: %w", err)
@@ -503,7 +636,6 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 // decisions about code generation (e.g., varRefing, async behavior).
 type GoToTSCompiler struct {
 	tsw *TSCodeWriter
-
 	pkg *packages.Package
 
 	analysis *Analysis

package/compiler/compiler_test.go

@@ -141,7 +141,7 @@ func getParentGoModulePath() (string, error) {
 	return strings.TrimSpace(string(output)), nil
 }
 
-func TestUnsafePackageErrorMessage(t *testing.T) {
+func TestUnsafePackageCompilation(t *testing.T) {
 	// Create a temporary directory for the test output
 	tempDir, err := os.MkdirTemp("", "goscript-test-unsafe")
 	if err != nil {
@@ -154,11 +154,11 @@ func TestUnsafePackageErrorMessage(t *testing.T) {
 	log.SetLevel(logrus.DebugLevel)
 	le := logrus.NewEntry(log)
 
-	// Test with AllDependencies=true to ensure we get all packages including unsafe
+	// Test with AllDependencies=true and DisableEmitBuiltin=false to ensure handwritten packages are copied
 	config := &compiler.Config{
 		OutputPath:         tempDir,
 		AllDependencies:    true,
-		DisableEmitBuiltin: true, // This ensures handwritten packages are skipped
+		DisableEmitBuiltin: false, // This ensures handwritten packages are copied to output
 	}
 
 	comp, err := compiler.NewCompiler(config, le, nil)
@@ -168,32 +168,25 @@ func TestUnsafePackageErrorMessage(t *testing.T) {
 
 	// Try to compile a package that has dependencies that import unsafe
 	// We'll use "sync/atomic" which imports unsafe but doesn't have a handwritten equivalent
-	_, err = comp.CompilePackages(context.Background(), "sync/atomic")
-
-	// We expect this to fail with an unsafe package error
-	if err == nil {
-		t.Fatalf("Expected compilation to fail due to unsafe package, but it succeeded")
+	result, err := comp.CompilePackages(context.Background(), "sync/atomic")
+	// This should now succeed since we have a handwritten unsafe package
+	if err != nil {
+		t.Fatalf("Expected compilation to succeed with handwritten unsafe package, but it failed: %v", err)
 	}
 
-	errorMsg := err.Error()
-
-	// Verify the error message contains the expected text
-	if !strings.Contains(errorMsg, "cannot compile package 'unsafe'") {
-		t.Errorf("Error message should mention unsafe package, got: %s", errorMsg)
+	// Verify that the unsafe package was copied (not compiled) since it has a handwritten equivalent
+	if !slices.Contains(result.CopiedPackages, "unsafe") {
+		t.Errorf("Expected unsafe package to be in CopiedPackages, but it wasn't. CopiedPackages: %v", result.CopiedPackages)
 	}
 
-	// Verify that packages with handwritten equivalents are NOT mentioned in the error
-	// These packages have handwritten equivalents in gs/ and should not be in the error message
-	handwrittenPackages := []string{"runtime", "errors", "time", "context", "slices"}
-
-	for _, pkg := range handwrittenPackages {
-		if strings.Contains(errorMsg, pkg) {
-			t.Errorf("Error message should not mention handwritten package '%s', but it does. Error: %s", pkg, errorMsg)
-		}
+	// Verify that sync/atomic was compiled
+	if !slices.Contains(result.CompiledPackages, "sync/atomic") {
+		t.Errorf("Expected sync/atomic package to be in CompiledPackages, but it wasn't. CompiledPackages: %v", result.CompiledPackages)
 	}
 
-	// The error message should mention sync/atomic since it would actually be compiled
-	if !strings.Contains(errorMsg, "sync/atomic") {
-		t.Errorf("Error message should mention 'sync/atomic' as it would be compiled, got: %s", errorMsg)
+	// Check that the unsafe package directory exists in the output
+	unsafePath := filepath.Join(tempDir, "@goscript/unsafe")
+	if _, err := os.Stat(unsafePath); os.IsNotExist(err) {
+		t.Errorf("unsafe package directory was not created at %s", unsafePath)
 	}
 }

package/compiler/composite-lit.go

@@ -199,18 +199,34 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 				if underlyingStruct, ok := namedType.Underlying().(*types.Struct); ok {
 					structType = underlyingStruct
 					isStructLiteral = true
-					// Named struct, use constructor
-					c.tsw.WriteLiterally("new ")
-					c.WriteTypeExpr(exp.Type)
+
+					// Check if this is a protobuf type
+					if handled, err := c.writeProtobufCompositeLit(exp, litType); handled {
+						if err != nil {
+							return err
+						}
+					} else {
+						// Named struct, use constructor
+						c.tsw.WriteLiterally("new ")
+						c.WriteTypeExpr(exp.Type)
+					}
 				}
 			} else if ptrType, ok := litType.(*types.Pointer); ok {
 				if namedElem, ok := ptrType.Elem().(*types.Named); ok {
 					if underlyingStruct, ok := namedElem.Underlying().(*types.Struct); ok {
 						structType = underlyingStruct
 						isStructLiteral = true // Treat pointer-to-struct literal similarly
-						// Named struct pointer, use constructor
-						c.tsw.WriteLiterally("new ")
-						c.WriteTypeExpr(exp.Type)
+
+						// Check if this is a protobuf type
+						if handled, err := c.writeProtobufCompositeLit(exp, litType); handled {
+							if err != nil {
+								return err
+							}
+						} else {
+							// Named struct pointer, use constructor
+							c.tsw.WriteLiterally("new ")
+							c.WriteTypeExpr(exp.Type)
+						}
 					}
 				}
 			} else if underlyingStruct, ok := litType.Underlying().(*types.Struct); ok {
@@ -339,7 +355,11 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					if firstFieldWritten {
 						c.tsw.WriteLiterally(", ")
 					}
-					c.tsw.WriteLiterally(keyName)
+
+					// Convert field name for protobuf types
+					fieldName := c.convertProtobufFieldNameInLiteral(keyName, litType)
+
+					c.tsw.WriteLiterally(fieldName)
 					c.tsw.WriteLiterally(": ")
 					if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
 						return err
@@ -538,7 +558,11 @@ func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, struct
 		if firstFieldWritten {
 			c.tsw.WriteLiterally(", ")
 		}
-		c.tsw.WriteLiterally(keyName)
+
+		// Convert field name for protobuf types
+		fieldName := c.convertProtobufFieldNameInLiteral(keyName, structType.Underlying())
+
+		c.tsw.WriteLiterally(fieldName)
 		c.tsw.WriteLiterally(": ")
 		if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
 			return err

package/compiler/decl.go

@@ -68,11 +68,9 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 		c.WriteDoc(decl.Doc)
 	}
 
-	// Exported functions start with uppercase in Go, or special-case "main" entry point
-	isExported := decl.Name.IsExported() || decl.Name.Name == "main"
-	if isExported {
-		c.tsw.WriteLiterally("export ")
-	}
+	// Export all functions for intra-package visibility
+	// This allows other files in the same package to import functions
+	c.tsw.WriteLiterally("export ")
 
 	// Check if this function is async using the analysis data
 	var isAsync bool
@@ -233,7 +231,9 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 		if recvName != "_" {
 			c.tsw.WriteLine("{")
 			c.tsw.Indent(1)
-			c.tsw.WriteLinef("const %s = this", recvName)
+			// Sanitize the receiver name to avoid conflicts with TypeScript reserved words
+			sanitizedRecvName := c.sanitizeIdentifier(recvName)
+			c.tsw.WriteLinef("const %s = this", sanitizedRecvName)
 
 			// Add using statement if needed
 			if c.analysis.NeedsDefer(decl.Body) {