goscript 0.0.22 → 0.0.24

package/compiler/analysis_test.go

@@ -0,0 +1,220 @@
+package compiler
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"testing"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// TestAnalysisVarRefLogic verifies that the analysis correctly identifies
+// which variables need variable references based on actual compliance test cases
+func TestAnalysisVarRefLogic(t *testing.T) {
+	tests := []struct {
+		name     string
+		code     string
+		expected map[string]AnalysisExpectation
+	}{
+		{
+			name: "pointer_range_loop",
+			code: `package main
+func main() {
+	arr := [3]int{1, 2, 3}
+	arrPtr := &arr
+	for i, v := range arrPtr {
+		println("index:", i, "value:", v)
+	}
+}`,
+			expected: map[string]AnalysisExpectation{
+				"arr":    {NeedsVarRef: true, NeedsVarRefAccess: true},   // varrefed because &arr is taken
+				"arrPtr": {NeedsVarRef: false, NeedsVarRefAccess: true},  // NOT varrefed, but points to varrefed value
+				"i":      {NeedsVarRef: false, NeedsVarRefAccess: false}, // regular loop variable
+				"v":      {NeedsVarRef: false, NeedsVarRefAccess: false}, // regular loop variable
+			},
+		},
+		{
+			name: "simple_pointers",
+			code: `package main
+type MyStruct struct {
+	Val int
+}
+func main() {
+	s1 := MyStruct{Val: 1}
+	p1 := &s1
+	pp1 := &p1
+	p4 := &s1
+	_ = p4
+	_ = pp1
+}`,
+			expected: map[string]AnalysisExpectation{
+				"s1":  {NeedsVarRef: true, NeedsVarRefAccess: true},  // varrefed because &s1 is taken
+				"p1":  {NeedsVarRef: true, NeedsVarRefAccess: true},  // varrefed because &p1 is taken
+				"pp1": {NeedsVarRef: false, NeedsVarRefAccess: true}, // NOT varrefed, points to varrefed value
+				"p4":  {NeedsVarRef: false, NeedsVarRefAccess: true}, // NOT varrefed, points to varrefed value
+			},
+		},
+		{
+			name: "varref_deref_struct",
+			code: `package main
+type MyStruct struct {
+	MyInt int
+}
+func main() {
+	myStruct := &MyStruct{}
+	(*myStruct).MyInt = 5
+	println((*myStruct).MyInt)
+}`,
+			expected: map[string]AnalysisExpectation{
+				"myStruct": {NeedsVarRef: false, NeedsVarRefAccess: false}, // NOT varrefed, direct pointer to struct
+			},
+		},
+		{
+			name: "pointer_composite_literal_untyped",
+			code: `package main
+func main() {
+	var ptr *struct{ x int }
+	ptr = &struct{ x int }{42}
+	println("Pointer value x:", ptr.x)
+
+	data := []*struct{ x int }{{42}, {43}}
+	println("First element x:", data[0].x)
+	println("Second element x:", data[1].x)
+}`,
+			expected: map[string]AnalysisExpectation{
+				"ptr":  {NeedsVarRef: false, NeedsVarRefAccess: false}, // Should NOT be varrefed
+				"data": {NeedsVarRef: false, NeedsVarRefAccess: false}, // Should NOT be varrefed
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			analysis, objects := parseAndAnalyze(t, tt.code)
+
+			for varName, expected := range tt.expected {
+				obj, exists := objects[varName]
+				if !exists {
+					t.Errorf("Variable %q not found in parsed objects", varName)
+					continue
+				}
+
+				actualNeedsVarRef := analysis.NeedsVarRef(obj)
+				actualNeedsVarRefAccess := analysis.NeedsVarRefAccess(obj)
+
+				if actualNeedsVarRef != expected.NeedsVarRef {
+					t.Errorf("Variable %q: NeedsVarRef = %v, want %v",
+						varName, actualNeedsVarRef, expected.NeedsVarRef)
+				}
+
+				if actualNeedsVarRefAccess != expected.NeedsVarRefAccess {
+					t.Errorf("Variable %q: NeedsVarRefAccess = %v, want %v",
+						varName, actualNeedsVarRefAccess, expected.NeedsVarRefAccess)
+				}
+
+				// Print debug info
+				t.Logf("Variable %q: NeedsVarRef=%v, NeedsVarRefAccess=%v",
+					varName, actualNeedsVarRef, actualNeedsVarRefAccess)
+			}
+		})
+	}
+}
+
+// AnalysisExpectation defines what we expect from the analysis for a variable
+type AnalysisExpectation struct {
+	NeedsVarRef       bool
+	NeedsVarRefAccess bool
+}
+
+// parseAndAnalyze parses Go code and runs the analysis, returning the analysis and variable objects
+func parseAndAnalyze(t *testing.T, code string) (*Analysis, map[string]types.Object) {
+	// Parse the code
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "test.go", code, parser.ParseComments)
+	if err != nil {
+		t.Fatalf("Failed to parse code: %v", err)
+	}
+
+	// Create a minimal package for type checking
+	pkg := &packages.Package{
+		Syntax: []*ast.File{file},
+		TypesInfo: &types.Info{
+			Types: make(map[ast.Expr]types.TypeAndValue),
+			Defs:  make(map[*ast.Ident]types.Object),
+			Uses:  make(map[*ast.Ident]types.Object),
+		},
+	}
+
+	// Type check the package
+	typeConfig := &types.Config{}
+	typePkg, err := typeConfig.Check("main", fset, pkg.Syntax, pkg.TypesInfo)
+	if err != nil {
+		t.Fatalf("Failed to type check: %v", err)
+	}
+	pkg.Types = typePkg
+
+	// Run analysis
+	analysis := NewAnalysis()
+	cmap := ast.NewCommentMap(fset, file, file.Comments)
+	AnalyzeFile(file, pkg, analysis, cmap)
+
+	// Collect variable objects
+	objects := make(map[string]types.Object)
+	for ident, obj := range pkg.TypesInfo.Defs {
+		if obj != nil && ident.Name != "_" {
+			if _, isVar := obj.(*types.Var); isVar {
+				objects[ident.Name] = obj
+			}
+		}
+	}
+
+	return analysis, objects
+}
+
+// TestAnalysisDebugInfo prints debug information about variable usage for manual inspection
+func TestAnalysisDebugInfo(t *testing.T) {
+	code := `package main
+func main() {
+	arr := [3]int{1, 2, 3}
+	arrPtr := &arr
+	for i, v := range arrPtr {
+		println("index:", i, "value:", v)
+	}
+}`
+
+	analysis, objects := parseAndAnalyze(t, code)
+
+	t.Log("=== Analysis Debug Information ===")
+	for varName, obj := range objects {
+		needsVarRef := analysis.NeedsVarRef(obj)
+		needsVarRefAccess := analysis.NeedsVarRefAccess(obj)
+
+		t.Logf("Variable: %s", varName)
+		t.Logf("  Type: %s", obj.Type())
+		t.Logf("  NeedsVarRef: %v", needsVarRef)
+		t.Logf("  NeedsVarRefAccess: %v", needsVarRefAccess)
+
+		// Print usage info if available
+		if usage, exists := analysis.VariableUsage[obj]; exists {
+			t.Logf("  Sources: %d", len(usage.Sources))
+			for i, src := range usage.Sources {
+				srcName := "nil"
+				if src.Object != nil {
+					srcName = src.Object.Name()
+				}
+				t.Logf("    [%d] %s (type: %v)", i, srcName, src.Type)
+			}
+			t.Logf("  Destinations: %d", len(usage.Destinations))
+			for i, dst := range usage.Destinations {
+				dstName := "nil"
+				if dst.Object != nil {
+					dstName = dst.Object.Name()
+				}
+				t.Logf("    [%d] %s (type: %v)", i, dstName, dst.Type)
+			}
+		}
+		t.Log("")
+	}
+}

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())
-					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
 				}
@@ -177,6 +169,11 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 					return err
 				}
 				c.tsw.WriteLiterally("]")
+			} else if callExpr, isCallExpr := r.(*ast.CallExpr); isCallExpr {
+				// If the RHS is a function call, write it as a call
+				if err := c.WriteCallExpr(callExpr); err != nil {
+					return err
+				}
 			} else {
 				// Normal case - write the entire expression
 				if err := c.WriteValueExpr(r); err != nil {
@@ -221,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
@@ -236,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
 				}
 			}
@@ -274,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)
@@ -293,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 {
@@ -314,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")
+		}
+	})
+}