goscript 0.0.23 → 0.0.25

package/compiler/compiler.go

@@ -11,6 +11,8 @@ import (
 	"slices"
 	"strings"
 
+	"go/constant"
+
 	gs "github.com/aperturerobotics/goscript"
 	"github.com/sirupsen/logrus"
 	"golang.org/x/tools/go/packages"
@@ -72,6 +74,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 +91,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 +100,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 +109,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 +133,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,17 +179,57 @@ 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) {
-			_, gsErr := gs.GsOverrides.ReadDir("gs/" + 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 {
-				c.le.Infof("Skipping compilation for overridden package %s", pkg.PkgPath)
-				continue
+				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
+					c.le.Infof("Copying handwritten package %s to output directory", pkg.PkgPath)
+
+					// Compute output path for this package
+					outputPath := ComputeModulePath(c.config.OutputPath, pkg.PkgPath)
+
+					// Remove existing directory if it exists
+					if err := os.RemoveAll(outputPath); err != nil {
+						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 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 nil, fmt.Errorf("failed to copy embedded package %s: %w", pkg.PkgPath, err)
+					}
+
+					result.CopiedPackages = append(result.CopiedPackages, pkg.PkgPath)
+					continue
+				}
 			}
 		}
 
@@ -166,17 +239,42 @@ 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 package depends on unsafe by looking at the import graph
+			var dependentPackages []string
+			for _, otherPkg := range pkgs {
+				if otherPkg.PkgPath != "unsafe" {
+					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
@@ -202,7 +300,7 @@ func NewPackageCompiler(
 		le:           le,
 		pkg:          pkg,
 		compilerConf: compilerConf,
-		outputPath:   ComputeModulePath(compilerConf.OutputPathRoot, pkg.PkgPath),
+		outputPath:   ComputeModulePath(compilerConf.OutputPath, pkg.PkgPath),
 	}
 
 	return res, nil
@@ -287,7 +385,7 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 // CompileFile handles the compilation of a single Go source file to TypeScript.
 // It first performs a pre-compilation analysis of the file using `AnalyzeFile`
 // to gather information necessary for accurate TypeScript generation (e.g.,
-// about boxing, async functions, defer statements).
+// 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 {
@@ -351,7 +449,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 	pkgPath := c.pkg.PkgPath
 
 	outputFilePath := TranslateGoFilePathToTypescriptFilePath(pkgPath, filepath.Base(c.fullPath))
-	outputFilePathAbs := filepath.Join(c.compilerConfig.OutputPathRoot, outputFilePath)
+	outputFilePathAbs := filepath.Join(c.compilerConfig.OutputPath, outputFilePath)
 
 	if err := os.MkdirAll(filepath.Dir(outputFilePathAbs), 0o755); err != nil {
 		return err
@@ -382,7 +480,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 // GoToTSCompiler is the core component responsible for translating Go AST nodes
 // and type information into TypeScript code. It uses a `TSCodeWriter` to output
 // the generated TypeScript and relies on `Analysis` data to make informed
-// decisions about code generation (e.g., boxing, async behavior).
+// decisions about code generation (e.g., varRefing, async behavior).
 type GoToTSCompiler struct {
 	tsw *TSCodeWriter
 
@@ -407,15 +505,14 @@ 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 `accessBoxedValue` is true and the analysis (`c.analysis.NeedsBoxedAccess`)
-//     indicates that this identifier refers to a variable whose value is stored
-//     in a box (due to its address being taken or other boxing requirements),
-//     it appends `.value` to access the actual value from the box.
+//   - If `accessVarRefedValue` is true and the analysis (`c.analysis.NeedsVarRefAccess`)
+//     indicates the variable is variable referenced, `.value` is appended to access the contained value.
 //
 // This function relies on `go/types` (`TypesInfo.Uses` or `Defs`) to resolve
-// the identifier and the `Analysis` data to determine boxing needs.
-func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessBoxedValue bool) {
+// the identifier and the `Analysis` data to determine varRefing needs.
+func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 	if exp.Name == "nil" {
 		c.tsw.WriteLiterally("null")
 		return
@@ -428,11 +525,25 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessBoxedValue 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 && accessBoxedValue && c.analysis.NeedsBoxedAccess(obj) {
+	if obj != nil && accessVarRefedValue && c.analysis.NeedsVarRefAccess(obj) {
 		c.tsw.WriteLiterally("!.value")
 	}
 }
@@ -627,3 +738,177 @@ 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 {
+		return fmt.Errorf("failed to read embedded directory %s: %w", embeddedPath, err)
+	}
+
+	// Process each entry
+	for _, entry := range entries {
+		entryPath := filepath.Join(embeddedPath, entry.Name())
+		outputEntryPath := filepath.Join(outputPath, entry.Name())
+
+		if entry.IsDir() {
+			// Create the output directory
+			if err := os.MkdirAll(outputEntryPath, 0o755); err != nil {
+				return fmt.Errorf("failed to create output directory %s: %w", outputEntryPath, err)
+			}
+
+			// Recursively copy the directory contents
+			if err := c.copyEmbeddedPackage(entryPath, outputEntryPath); err != nil {
+				return err
+			}
+		} else {
+			// Read the file content from the embedded FS
+			content, err := gs.GsOverrides.ReadFile(entryPath)
+			if err != nil {
+				return fmt.Errorf("failed to read embedded file %s: %w", entryPath, err)
+			}
+
+			// Write the content to the output file
+			if err := os.WriteFile(outputEntryPath, content, 0o644); err != nil {
+				return fmt.Errorf("failed to write file %s: %w", outputEntryPath, err)
+			}
+		}
+	}
+
+	return nil
+}