goscript 0.0.24 → 0.0.26

package/README.md

@@ -95,7 +95,7 @@ func main() {
 
     // Compile the desired Go package(s)
     // Replace "." with the specific Go import path of the package you want to compile
-    if err := comp.CompilePackages(context.Background(), "your/go/package/path"); err != nil {
+    if _, err := comp.CompilePackages(context.Background(), "your/go/package/path"); err != nil {
         log.Fatalf("compilation failed: %v", err)
     }
 

package/cmd/goscript/cmd_compile.go

@@ -62,6 +62,21 @@ var CompileCommands = []*cli.Command{{
 			Destination: &cliCompilerBuildFlags,
 			EnvVars:     []string{"GOSCRIPT_BUILD_FLAGS"},
 		},
+		&cli.BoolFlag{
+			Name:        "disable-emit-builtin",
+			Usage:       "disable emitting built-in packages that have handwritten equivalents",
+			Destination: &cliCompilerConfig.DisableEmitBuiltin,
+			Value:       false,
+			EnvVars:     []string{"GOSCRIPT_DISABLE_EMIT_BUILTIN"},
+		},
+		&cli.BoolFlag{
+			Name:        "all-dependencies",
+			Usage:       "compile all dependencies of the requested packages",
+			Aliases:     []string{"all-deps", "deps"},
+			Destination: &cliCompilerConfig.AllDependencies,
+			Value:       false,
+			EnvVars:     []string{"GOSCRIPT_ALL_DEPENDENCIES"},
+		},
 	},
 }}
 
@@ -75,5 +90,6 @@ func compilePackage(c *cli.Context) error {
 	// build flags
 	cliCompilerConfig.BuildFlags = slices.Clone(cliCompilerBuildFlags.Value())
 
-	return cliCompiler.CompilePackages(context.Background(), pkgs...)
+	_, err := cliCompiler.CompilePackages(context.Background(), pkgs...)
+	return err
 }

package/compiler/analysis.go

@@ -553,7 +553,7 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 		// Standalone &x doesn't directly assign, but its usage in assignments
 		// or function calls determines varRefing. Assignments are handled below.
 		// Function calls like foo(&x) would require different tracking if needed.
-		// For now, we focus on assignments as per the request.
+		// TODO: for now, we focus on assignments
 		return v
 
 	case *ast.CallExpr:

package/compiler/builtin_test.go

@@ -37,7 +37,7 @@ func TestEmitBuiltinOption(t *testing.T) {
 		}
 
 		// Compile a package that depends on builtin (time)
-		err = compiler.CompilePackages(context.Background(), "time")
+		_, err = compiler.CompilePackages(context.Background(), "time")
 		if err != nil {
 			t.Fatalf("Compilation failed: %v", err)
 		}
@@ -76,23 +76,11 @@ func TestEmitBuiltinOption(t *testing.T) {
 		}
 
 		// Compile a package that depends on builtin (time)
-		err = compiler.CompilePackages(context.Background(), "time")
+		_, err = compiler.CompilePackages(context.Background(), "time")
 		if err != nil {
 			t.Fatalf("Compilation failed: %v", err)
 		}
 
-		// Check that the unsafe package was copied to the output
-		unsafePath := filepath.Join(outputDir, "@goscript/unsafe")
-		if _, err := os.Stat(unsafePath); os.IsNotExist(err) {
-			t.Errorf("unsafe package was not emitted when DisableEmitBuiltin=false")
-		}
-
-		// Also check for runtime package
-		runtimePath := filepath.Join(outputDir, "@goscript/runtime")
-		if _, err := os.Stat(runtimePath); os.IsNotExist(err) {
-			t.Errorf("runtime package was not emitted when DisableEmitBuiltin=false")
-		}
-
 		// Time package should also have been emitted
 		timePath := filepath.Join(outputDir, "@goscript/time")
 		if _, err := os.Stat(timePath); os.IsNotExist(err) {

package/compiler/compiler.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"go/ast"
+	"go/constant"
 	"go/token"
 	"go/types"
 	"os"
@@ -72,6 +73,16 @@ func NewCompiler(conf *Config, le *logrus.Entry, opts *packages.Config) (*Compil
 	return &Compiler{config: *conf, le: le, opts: *opts}, nil
 }
 
+// CompilationResult contains information about what was compiled
+type CompilationResult struct {
+	// CompiledPackages contains the package paths of all packages that were actually compiled to TypeScript
+	CompiledPackages []string
+	// CopiedPackages contains the package paths of all packages that were copied from handwritten sources
+	CopiedPackages []string
+	// OriginalPackages contains the package paths that were explicitly requested for compilation
+	OriginalPackages []string
+}
+
 // CompilePackages loads Go packages based on the provided patterns and
 // then compiles each loaded package into TypeScript. It uses the context for
 // cancellation and applies the compiler's configured options during package loading.
@@ -79,7 +90,8 @@ func NewCompiler(conf *Config, le *logrus.Entry, opts *packages.Config) (*Compil
 // invokes its `Compile` method.
 // If c.config.AllDependencies is true, it will also compile all dependencies
 // of the requested packages, including standard library dependencies.
-func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) error {
+// Returns a CompilationResult with information about what was compiled.
+func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*CompilationResult, error) {
 	opts := c.opts
 	opts.Context = ctx
 
@@ -87,7 +99,7 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 	opts.Mode |= packages.NeedImports
 	pkgs, err := packages.Load(&opts, patterns...)
 	if err != nil {
-		return fmt.Errorf("failed to load packages: %w", err)
+		return nil, fmt.Errorf("failed to load packages: %w", err)
 	}
 
 	// build a list of packages that patterns matched
@@ -96,12 +108,23 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 		patternPkgPaths = append(patternPkgPaths, pkg.PkgPath)
 	}
 
+	result := &CompilationResult{
+		OriginalPackages: patternPkgPaths,
+	}
+
 	// If AllDependencies is true, we need to collect all dependencies
 	if c.config.AllDependencies {
 		// Create a set to track processed packages by their ID
 		processed := make(map[string]bool)
 		var allPkgs []*packages.Package
 
+		// Helper function to check if a package has a handwritten equivalent
+		hasHandwrittenEquivalent := func(pkgPath string) bool {
+			gsSourcePath := "gs/" + pkgPath
+			_, gsErr := gs.GsOverrides.ReadDir(gsSourcePath)
+			return gsErr == nil
+		}
+
 		// Visit all packages and their dependencies
 		var visit func(pkg *packages.Package)
 		visit = func(pkg *packages.Package) {
@@ -109,8 +132,17 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 				return
 			}
 			processed[pkg.ID] = true
+
+			// Add this package to the list of all packages
 			allPkgs = append(allPkgs, pkg)
 
+			// Check if this package has a handwritten equivalent
+			if hasHandwrittenEquivalent(pkg.PkgPath) {
+				// Add this package but don't visit its dependencies
+				c.le.Debugf("Skipping dependencies of handwritten package: %s", pkg.PkgPath)
+				return
+			}
+
 			// Visit all imports, including standard library packages
 			for _, imp := range pkg.Imports {
 				visit(imp)
@@ -146,18 +178,31 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 		*/
 	}
 
+	// If DisableEmitBuiltin is false, we need to copy the builtin package to the output directory
+	if !c.config.DisableEmitBuiltin {
+		c.le.Infof("Copying builtin package to output directory")
+		builtinPath := "gs/builtin"
+		outputPath := ComputeModulePath(c.config.OutputPath, "builtin")
+		if err := c.copyEmbeddedPackage(builtinPath, outputPath); err != nil {
+			return nil, fmt.Errorf("failed to copy builtin package to output directory: %w", err)
+		}
+		result.CopiedPackages = append(result.CopiedPackages, "builtin")
+	}
+
 	// Compile all packages
 	for _, pkg := range pkgs {
 		// Check if the package has a handwritten equivalent
+		// If the package was explicitly requested, skip this logic
 		if !slices.Contains(patternPkgPaths, pkg.PkgPath) {
 			gsSourcePath := "gs/" + pkg.PkgPath
 			_, gsErr := gs.GsOverrides.ReadDir(gsSourcePath)
 			if gsErr != nil && !os.IsNotExist(gsErr) {
-				return gsErr
+				return nil, gsErr
 			}
 			if gsErr == nil {
 				if c.config.DisableEmitBuiltin {
 					c.le.Infof("Skipping compilation for overridden package %s", pkg.PkgPath)
+					result.CopiedPackages = append(result.CopiedPackages, pkg.PkgPath)
 					continue
 				} else {
 					// If DisableEmitBuiltin is false, we need to copy the handwritten package to the output directory
@@ -168,19 +213,20 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 
 					// Remove existing directory if it exists
 					if err := os.RemoveAll(outputPath); err != nil {
-						return fmt.Errorf("failed to remove existing output directory for %s: %w", pkg.PkgPath, err)
+						return nil, fmt.Errorf("failed to remove existing output directory for %s: %w", pkg.PkgPath, err)
 					}
 
 					// Create the output directory
 					if err := os.MkdirAll(outputPath, 0o755); err != nil {
-						return fmt.Errorf("failed to create output directory for %s: %w", pkg.PkgPath, err)
+						return nil, fmt.Errorf("failed to create output directory for %s: %w", pkg.PkgPath, err)
 					}
 
 					// Copy files from embedded FS to output directory
 					if err := c.copyEmbeddedPackage(gsSourcePath, outputPath); err != nil {
-						return fmt.Errorf("failed to copy embedded package %s: %w", pkg.PkgPath, err)
+						return nil, fmt.Errorf("failed to copy embedded package %s: %w", pkg.PkgPath, err)
 					}
 
+					result.CopiedPackages = append(result.CopiedPackages, pkg.PkgPath)
 					continue
 				}
 			}
@@ -192,17 +238,63 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 			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 fmt.Errorf("failed to create package compiler for %s: %w", pkg.PkgPath, err)
+			return nil, fmt.Errorf("failed to create package compiler for %s: %w", pkg.PkgPath, err)
 		}
 
 		if err := pkgCompiler.Compile(ctx); err != nil {
-			return fmt.Errorf("failed to compile package %s: %w", pkg.PkgPath, err)
+			return nil, fmt.Errorf("failed to compile package %s: %w", pkg.PkgPath, err)
 		}
+
+		result.CompiledPackages = append(result.CompiledPackages, pkg.PkgPath)
 	}
 
-	return nil
+	return result, nil
 }
 
 // PackageCompiler is responsible for compiling an entire Go package into
@@ -433,6 +525,7 @@ func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analy
 // WriteIdent translates a Go identifier (`ast.Ident`) used as a value (e.g.,
 // variable, function name) into its TypeScript equivalent.
 //   - If the identifier is `nil`, it writes `null`.
+//   - If the identifier refers to a constant, it writes the constant's evaluated value.
 //   - Otherwise, it writes the identifier's name.
 //   - If `accessVarRefedValue` is true and the analysis (`c.analysis.NeedsVarRefAccess`)
 //     indicates the variable is variable referenced, `.value` is appended to access the contained value.
@@ -452,8 +545,22 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 		obj = c.pkg.TypesInfo.Defs[exp]
 	}
 
-	// Write the identifier name first
-	c.tsw.WriteLiterally(exp.Name)
+	// Check if this identifier refers to a constant
+	if obj != nil {
+		if constObj, isConst := obj.(*types.Const); isConst {
+			// Only evaluate constants from the current package being compiled
+			// Don't evaluate constants from imported packages (they should use their exported names)
+			// Special case: predeclared constants like iota have a nil package, so we should evaluate them
+			if constObj.Pkg() == c.pkg.Types || constObj.Pkg() == nil {
+				// Write the constant's evaluated value instead of the identifier name
+				c.writeConstantValue(constObj)
+				return
+			}
+		}
+	}
+
+	// Write the identifier name first, sanitizing if it's a reserved word
+	c.tsw.WriteLiterally(c.sanitizeIdentifier(exp.Name))
 
 	// Determine if we need to access .value based on analysis data
 	if obj != nil && accessVarRefedValue && c.analysis.NeedsVarRefAccess(obj) {
@@ -652,9 +759,142 @@ func (c *GoToTSCompiler) WriteDoc(doc *ast.CommentGroup) {
 	}
 }
 
+// sanitizeIdentifier checks if an identifier is a JavaScript/TypeScript reserved word
+// and prefixes it with an underscore if it is. This prevents compilation errors
+// when Go identifiers conflict with JS/TS keywords.
+func (c *GoToTSCompiler) sanitizeIdentifier(name string) string {
+	// Don't sanitize boolean literals - they are valid in both Go and JS/TS
+	if name == "true" || name == "false" {
+		return name
+	}
+
+	// List of JavaScript/TypeScript reserved words that could conflict
+	reservedWords := map[string]bool{
+		"abstract":    true,
+		"any":         true,
+		"as":          true,
+		"asserts":     true,
+		"async":       true,
+		"await":       true,
+		"boolean":     true,
+		"break":       true,
+		"case":        true,
+		"catch":       true,
+		"class":       true,
+		"const":       true,
+		"constructor": true,
+		"continue":    true,
+		"debugger":    true,
+		"declare":     true,
+		"default":     true,
+		"delete":      true,
+		"do":          true,
+		"else":        true,
+		"enum":        true,
+		"export":      true,
+		"extends":     true,
+		"finally":     true,
+		"for":         true,
+		"from":        true,
+		"function":    true,
+		"get":         true,
+		"if":          true,
+		"implements":  true,
+		"import":      true,
+		"in":          true,
+		"instanceof":  true,
+		"interface":   true,
+		"is":          true,
+		"keyof":       true,
+		"let":         true,
+		"module":      true,
+		"namespace":   true,
+		"never":       true,
+		"new":         true,
+		"null":        true,
+		"number":      true,
+		"object":      true,
+		"of":          true,
+		"package":     true,
+		"private":     true,
+		"protected":   true,
+		"public":      true,
+		"readonly":    true,
+		"require":     true,
+		"return":      true,
+		"set":         true,
+		"static":      true,
+		"string":      true,
+		"super":       true,
+		"switch":      true,
+		"symbol":      true,
+		"this":        true,
+		"throw":       true,
+		"try":         true,
+		"type":        true,
+		"typeof":      true,
+		"undefined":   true,
+		"unique":      true,
+		"unknown":     true,
+		"var":         true,
+		"void":        true,
+		"while":       true,
+		"with":        true,
+		"yield":       true,
+	}
+
+	if reservedWords[name] {
+		return "_" + name
+	}
+	return name
+}
+
+// writeConstantValue writes the evaluated value of a Go constant to TypeScript.
+// It handles different constant types (integer, float, string, boolean, complex)
+// and writes the appropriate TypeScript literal.
+func (c *GoToTSCompiler) writeConstantValue(constObj *types.Const) {
+	val := constObj.Val()
+
+	switch val.Kind() {
+	case constant.Int:
+		// For integer constants, write the string representation
+		c.tsw.WriteLiterally(val.String())
+	case constant.Float:
+		// For float constants, write the string representation
+		c.tsw.WriteLiterally(val.String())
+	case constant.String:
+		// For string constants, write as a quoted string literal
+		c.tsw.WriteLiterally(val.String()) // val.String() already includes quotes
+	case constant.Bool:
+		// For boolean constants, write true/false
+		if constant.BoolVal(val) {
+			c.tsw.WriteLiterally("true")
+		} else {
+			c.tsw.WriteLiterally("false")
+		}
+	case constant.Complex:
+		// For complex constants, we need to handle them specially
+		// For now, write as a comment indicating unsupported
+		c.tsw.WriteLiterally("/* complex constant: " + val.String() + " */")
+	default:
+		// For unknown constant types, write as a comment
+		c.tsw.WriteLiterally("/* unknown constant: " + val.String() + " */")
+	}
+}
+
 // copyEmbeddedPackage recursively copies files from an embedded FS path to a filesystem directory.
 // It handles both regular files and directories.
 func (c *Compiler) copyEmbeddedPackage(embeddedPath string, outputPath string) error {
+	// Remove the output path if it exists
+	if err := os.RemoveAll(outputPath); err != nil {
+		return fmt.Errorf("failed to remove output directory %s: %w", outputPath, err)
+	}
+
+	// Create the output path
+	if err := os.MkdirAll(outputPath, 0o755); err != nil {
+		return fmt.Errorf("failed to create output directory %s: %w", outputPath, err)
+	}
+
 	// List the entries in the embedded path
 	entries, err := gs.GsOverrides.ReadDir(embeddedPath)
 	if err != nil {

package/compiler/compiler_test.go

@@ -1,6 +1,7 @@
 package compiler_test
 
 import (
+	"context"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -11,7 +12,9 @@ import (
 	"sync/atomic"
 	"testing"
 
+	"github.com/aperturerobotics/goscript/compiler"
 	"github.com/aperturerobotics/goscript/compliance"
+	"github.com/sirupsen/logrus"
 )
 
 // NOTE: this is here instead of compliance/compliance_test.go so coverage ends up in this package.
@@ -137,3 +140,60 @@ func getParentGoModulePath() (string, error) {
 	}
 	return strings.TrimSpace(string(output)), nil
 }
+
+func TestUnsafePackageErrorMessage(t *testing.T) {
+	// Create a temporary directory for the test output
+	tempDir, err := os.MkdirTemp("", "goscript-test-unsafe")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Setup logger
+	log := logrus.New()
+	log.SetLevel(logrus.DebugLevel)
+	le := logrus.NewEntry(log)
+
+	// Test with AllDependencies=true to ensure we get all packages including unsafe
+	config := &compiler.Config{
+		OutputPath:         tempDir,
+		AllDependencies:    true,
+		DisableEmitBuiltin: true, // This ensures handwritten packages are skipped
+	}
+
+	comp, err := compiler.NewCompiler(config, le, nil)
+	if err != nil {
+		t.Fatalf("Failed to create compiler: %v", err)
+	}
+
+	// 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")
+	}
+
+	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 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)
+		}
+	}
+
+	// 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)
+	}
+}

package/compiler/decl.go

@@ -37,7 +37,7 @@ func (c *GoToTSCompiler) WriteDecls(decls []ast.Decl) error {
 				c.tsw.WriteLine("") // Add space after spec
 			}
 		default:
-			fmt.Printf("unknown decl: %#v\n", decl)
+			return fmt.Errorf("unknown decl: %#v", decl)
 		}
 	}
 	return nil
@@ -79,6 +79,12 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 	if obj := c.pkg.TypesInfo.Defs[decl.Name]; obj != nil {
 		isAsync = c.analysis.IsAsyncFunc(obj)
 	}
+
+	// Always make main function async (only in main package)
+	if decl.Name.Name == "main" && c.pkg.Name == "main" {
+		isAsync = true
+	}
+
 	if isAsync {
 		c.tsw.WriteLiterally("async ")
 	}