goscript 0.0.23 → 0.0.24

package/compiler/assignment.go

@@ -21,7 +21,7 @@ import (
 //     to `$.mapSet(myMap_ts, key_ts, value_ts)`.
 //   - Other single-variable assignments (`variable = value`):
 //   - The LHS expression is written (caller typically ensures `.value` is appended
-//     if assigning to a boxed variable's content).
+//     if assigning to a VarRefed variable's content).
 //   - The Go assignment token (`tok`, e.g., `=`, `+=`) is translated to its
 //     TypeScript equivalent using `TokenToTs`.
 //   - The RHS expression(s) are written. If `shouldApplyClone` indicates the RHS
@@ -68,10 +68,10 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 			return nil
 		}
 
-		// Special handling for boxed variables in declarations
+		// Special handling for variable referenced variables in declarations
 		if addDeclaration && tok == token.DEFINE {
-			// Determine if LHS is boxed
-			isLHSBoxed := false
+			// Determine if LHS is variable referenced
+			isLHSVarRefed := false
 			var lhsIdent *ast.Ident
 			var lhsObj types.Object
 
@@ -84,30 +84,22 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 					lhsObj = def
 				}
 
-				// Check if this variable needs to be boxed
-				if lhsObj != nil && c.analysis.NeedsBoxed(lhsObj) {
-					isLHSBoxed = true
+				// Check if this variable needs to be variable referenced
+				if lhsObj != nil && c.analysis.NeedsVarRef(lhsObj) {
+					isLHSVarRefed = true
 				}
 			}
 
-			// Special handling for short declaration of boxed variables
-			if isLHSBoxed && lhsIdent != nil {
+			// Special handling for short declaration of variable referenced variables
+			if isLHSVarRefed && lhsIdent != nil {
 				c.tsw.WriteLiterally("let ")
 				// Just write the identifier name without .value
 				c.tsw.WriteLiterally(lhsIdent.Name)
-
-				// Add type annotation for boxed variables in declarations
-				if lhsObj != nil {
-					c.tsw.WriteLiterally(": ")
-					c.tsw.WriteLiterally("$.Box<")
-					c.WriteGoType(lhsObj.Type(), GoTypeContextGeneral)
-					c.tsw.WriteLiterally(">")
-				}
-
+				// No type annotation, allow TypeScript to infer it from varRef.
 				c.tsw.WriteLiterally(" = ")
 
-				// Box the initializer
-				c.tsw.WriteLiterally("$.box(")
+				// Create the variable reference for the initializer
+				c.tsw.WriteLiterally("$.varRef(")
 				if err := c.WriteValueExpr(rhs[0]); err != nil {
 					return err
 				}
@@ -226,12 +218,12 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		}
 
 		if !currentIsMapIndex {
-			// For single assignments, handle boxed variables specially
+			// For single assignments, handle variable referenced variables specially
 			if len(lhs) == 1 && len(rhs) == 1 {
 				lhsExprIdent, lhsExprIsIdent := l.(*ast.Ident)
 				if lhsExprIsIdent {
-					// Determine if LHS is boxed
-					isLHSBoxed := false
+					// Determine if LHS is variable referenced
+					isLHSVarRefed := false
 					var lhsObj types.Object
 
 					// Get the types.Object from the identifier
@@ -241,13 +233,13 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 						lhsObj = def
 					}
 
-					// Check if this variable needs to be boxed
-					if lhsObj != nil && c.analysis.NeedsBoxed(lhsObj) {
-						isLHSBoxed = true
+					// Check if this variable needs to be variable referenced
+					if lhsObj != nil && c.analysis.NeedsVarRef(lhsObj) {
+						isLHSVarRefed = true
 					}
 
-					// prevent writing .value unless lhs is boxed
-					c.WriteIdent(lhsExprIdent, isLHSBoxed)
+					// prevent writing .value unless lhs is variable referenced
+					c.WriteIdent(lhsExprIdent, isLHSVarRefed)
 					continue
 				}
 			}
@@ -279,15 +271,16 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		if i != 0 {
 			c.tsw.WriteLiterally(", ")
 		}
-		// Check if we need to access a boxed source value and apply clone
+
+		// Check if we need to access a variable referenced source value and apply clone
 		// For struct value assignments, we need to handle:
-		// 1. Unboxed source, unboxed target: source.clone()
-		// 2. Boxed source, unboxed target: source.value.clone()
-		// 3. Unboxed source, boxed target: $.box(source)
-		// 4. Boxed source, boxed target: source (straight assignment of the box)
+		// 1. UnVarRefed source, unVarRefed target: source.clone()
+		// 2. Variable referenced source, unVarRefed target: source.value.clone()
+		// 3. UnVarRefed source, variable referenced target: $.varRef(source)
+		// 4. Variable referenced source, variable referenced target: source (straight assignment of the variable reference)
 
-		// Determine if RHS is a boxed variable (could be a struct or other variable)
-		needsBoxedAccessRHS := false
+		// Determine if RHS is a variable referenced variable (could be a struct or other variable)
+		needsVarRefedAccessRHS := false
 		var rhsObj types.Object
 
 		// Check if RHS is an identifier (variable name)
@@ -298,17 +291,17 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 				rhsObj = c.pkg.TypesInfo.Defs[rhsIdent]
 			}
 
-			// Important: For struct copying, we need to check if the variable itself is boxed
-			// Important: For struct copying, we need to check if the variable needs boxed access
-			// This is more comprehensive than just checking if it's boxed
+			// Important: For struct copying, we need to check if the variable itself is variable referenced
+			// Important: For struct copying, we need to check if the variable needs variable referenced access
+			// This is more comprehensive than just checking if it's variable referenced
 			if rhsObj != nil {
-				needsBoxedAccessRHS = c.analysis.NeedsBoxedAccess(rhsObj)
+				needsVarRefedAccessRHS = c.analysis.NeedsVarRefAccess(rhsObj)
 			}
 		}
 
 		// Handle different cases for struct cloning
 		if shouldApplyClone(c.pkg, r) {
-			// For other expressions, we need to handle boxed access differently
+			// For other expressions, we need to handle variable referenced access differently
 			if _, isIdent := r.(*ast.Ident); isIdent {
 				// For identifiers, WriteValueExpr already adds .value if needed
 				if err := c.WriteValueExpr(r); err != nil {
@@ -319,14 +312,15 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 				if err := c.WriteValueExpr(r); err != nil {
 					return err
 				}
-				// Only add .value for non-identifiers that need boxed access
-				if needsBoxedAccessRHS {
-					c.tsw.WriteLiterally(".value") // Access the boxed value
+				// Only add .value for non-identifiers that need variable referenced access
+				if needsVarRefedAccessRHS {
+					c.tsw.WriteLiterally(".value") // Access the variable referenced value
 				}
 			}
 
 			c.tsw.WriteLiterally(".clone()") // Always add clone for struct values
 		} else {
+			// Non-struct case: write RHS normally
 			if err := c.WriteValueExpr(r); err != nil { // RHS is a non-struct value
 				return err
 			}

package/compiler/builtin_test.go

@@ -0,0 +1,102 @@
+package compiler
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/sirupsen/logrus"
+)
+
+func TestEmitBuiltinOption(t *testing.T) {
+	// Create a temporary directory for the test output
+	tempDir, err := os.MkdirTemp("", "goscript-test-emit-builtin")
+	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)
+
+	// Case 1: DisableEmitBuiltin = true (default behavior in compliance tests)
+	t.Run("DisableEmitBuiltin=true", func(t *testing.T) {
+		outputDir := filepath.Join(tempDir, "disabled")
+		config := &Config{
+			OutputPath:         outputDir,
+			AllDependencies:    true,
+			DisableEmitBuiltin: true,
+		}
+
+		compiler, err := NewCompiler(config, le, nil)
+		if err != nil {
+			t.Fatalf("Failed to create compiler: %v", err)
+		}
+
+		// Compile a package that depends on builtin (time)
+		err = compiler.CompilePackages(context.Background(), "time")
+		if err != nil {
+			t.Fatalf("Compilation failed: %v", err)
+		}
+
+		// Check that the unsafe package wasn't emitted (we know it's handwritten)
+		unsafePath := filepath.Join(outputDir, "@goscript/unsafe")
+		if _, err := os.Stat(unsafePath); !os.IsNotExist(err) {
+			t.Errorf("unsafe package was emitted when DisableEmitBuiltin=true")
+		}
+
+		// Also check for runtime package
+		runtimePath := filepath.Join(outputDir, "@goscript/runtime")
+		if _, err := os.Stat(runtimePath); !os.IsNotExist(err) {
+			t.Errorf("runtime package was emitted when DisableEmitBuiltin=true")
+		}
+
+		// But time package should have been emitted
+		timePath := filepath.Join(outputDir, "@goscript/time")
+		if _, err := os.Stat(timePath); os.IsNotExist(err) {
+			t.Errorf("time package was not emitted")
+		}
+	})
+
+	// Case 2: DisableEmitBuiltin = false (new behavior for third-party projects)
+	t.Run("DisableEmitBuiltin=false", func(t *testing.T) {
+		outputDir := filepath.Join(tempDir, "enabled")
+		config := &Config{
+			OutputPath:         outputDir,
+			AllDependencies:    true,
+			DisableEmitBuiltin: false,
+		}
+
+		compiler, err := NewCompiler(config, le, nil)
+		if err != nil {
+			t.Fatalf("Failed to create compiler: %v", err)
+		}
+
+		// Compile a package that depends on builtin (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) {
+			t.Errorf("time package was not emitted")
+		}
+	})
+}

package/compiler/compiler.go

@@ -150,13 +150,39 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) erro
 	for _, pkg := range pkgs {
 		// Check if the package has a handwritten equivalent
 		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
 			}
 			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)
+					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 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)
+					}
+
+					// 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)
+					}
+
+					continue
+				}
 			}
 		}
 
@@ -202,7 +228,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 +313,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 +377,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 +408,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
 
@@ -408,14 +434,12 @@ func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analy
 // variable, function name) into its TypeScript equivalent.
 //   - If the identifier is `nil`, it writes `null`.
 //   - 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
@@ -432,7 +456,7 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessBoxedValue bool) {
 	c.tsw.WriteLiterally(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 +651,44 @@ func (c *GoToTSCompiler) WriteDoc(doc *ast.CommentGroup) {
 		}
 	}
 }
+
+// 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 {
+	// 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
+}