goscript 0.0.23 → 0.0.24

package/README.md

@@ -81,7 +81,7 @@ func main() {
 
     // Configure the compiler
     conf := &compiler.Config{
-        OutputPathRoot: "./ts_output",          // Directory for generated TypeScript files
+        OutputPath: "./ts_output",          // Directory for generated TypeScript files
     }
     if err := conf.Validate(); err != nil {
         log.Fatalf("invalid compiler config: %v", err)

package/cmd/goscript/cmd_compile.go

@@ -44,7 +44,7 @@ var CompileCommands = []*cli.Command{{
 		&cli.StringFlag{
 			Name:        "output",
 			Usage:       "the output typescript path to use",
-			Destination: &cliCompilerConfig.OutputPathRoot,
+			Destination: &cliCompilerConfig.OutputPath,
 			Value:       "./output",
 			EnvVars:     []string{"GOSCRIPT_OUTPUT"},
 		},

package/compiler/analysis.go

@@ -145,13 +145,14 @@ func (a *Analysis) IsFuncLitAsync(funcLit *ast.FuncLit) bool {
 	return nodeInfo.InAsyncContext
 }
 
-// NeedsBoxed returns whether the given object needs to be boxed.
-// According to the new logic, a variable needs boxing if its address is taken
-// and assigned to another variable (i.e., it appears as a destination with AddressOfAssignment).
-func (a *Analysis) NeedsBoxed(obj types.Object) bool {
+// NeedsVarRef returns whether the given object needs to be variable referenced.
+// This is true when the object's address is taken (e.g., &myVar) in the analyzed code.
+// Variables that have their address taken must be wrapped in VarRef to maintain identity.
+func (a *Analysis) NeedsVarRef(obj types.Object) bool {
 	if obj == nil {
 		return false
 	}
+
 	usageInfo, exists := a.VariableUsage[obj]
 	if !exists {
 		return false
@@ -165,156 +166,97 @@ func (a *Analysis) NeedsBoxed(obj types.Object) bool {
 	return false
 }
 
-// NeedsBoxedAccess returns whether accessing the given object requires '.value' access in TypeScript.
-// This function is critical for correctly handling pointer dereferencing by determining when
-// a variable is boxed and needs .value to access its content.
-//
-// Two distinct cases determine when a variable needs .value access:
-//
-//  1. The variable itself is boxed (its address is taken)
-//     Example: let x = $.box(10) => x.value
+// NeedsVarRefAccess returns whether accessing the given object requires '.value' access in TypeScript.
+// This is more nuanced than NeedsVarRef and considers both direct variable references and
+// pointers that may point to variable-referenced values.
 //
-//  2. For pointer variables: it points to a boxed struct variable rather than a direct struct literal
-//     Example: let ptrToVal = val (where val is boxed) => ptrToVal.value
-//     vs.     let ptr = new MyStruct() => ptr (no .value needed)
-//
-// This distinction is crucial for avoiding over-dereferencing or under-dereferencing,
-// which was the root cause of several bugs in our pointer handling.
-func (a *Analysis) NeedsBoxedAccess(obj types.Object) bool {
+// Examples:
+//   - Direct variable reference (NeedsVarRef = true):
+//     Example: let x = $.varRef(10) => x.value
+//   - Pointer pointing to a variable-referenced value:
+//     Example: let p: VarRef<number> | null = x => p!.value
+//   - Regular pointer (NeedsVarRef = false, but points to variable reference):
+//     Example: let q = x => q!.value (where x is VarRef)
+func (a *Analysis) NeedsVarRefAccess(obj types.Object) bool {
 	if obj == nil {
 		return false
 	}
 
-	// First, check if the variable itself is boxed - this always requires .value
-	// A variable is boxed if its address is taken elsewhere in the code
-	if a.NeedsBoxed(obj) {
+	// If the variable itself is variable referenced, it needs .value access
+	if a.NeedsVarRef(obj) {
 		return true
 	}
 
-	// Check if this is a pointer variable pointing to a boxed struct value
-	objType := obj.Type()
-	if ptrType, isPointer := objType.Underlying().(*types.Pointer); isPointer {
-		// Check if it's a pointer to a struct
-		if elemType := ptrType.Elem(); elemType != nil {
-			if _, isStructType := elemType.Underlying().(*types.Struct); isStructType {
-				// For struct pointers, check if it points to a boxed struct variable
-				if usageInfo, exists := a.VariableUsage[obj]; exists {
-					for _, src := range usageInfo.Sources {
-						// Check if this pointer was assigned the address of another variable
-						// (e.g., ptr = &someVar) rather than a direct literal (ptr = &Struct{})
-						if src.Type == AddressOfAssignment && src.Object != nil {
-							// Bug fix: If the source variable is boxed, the pointer needs .value to access it
-							// This distinguishes between:
-							// - ptrToVal := &val (val is boxed, so we need ptrToVal.value)
-							// - ptr := &MyStruct{} (direct literal, no boxing needed)
-							return a.NeedsBoxed(src.Object)
-						}
+	// For pointer variables, check if they point to a variable-referenced value
+	if ptrType, ok := obj.Type().(*types.Pointer); ok {
+		// Check all assignments to this pointer variable
+		for varObj, info := range a.VariableUsage {
+			if varObj == obj {
+				for _, src := range info.Sources {
+					if src.Type == AddressOfAssignment && src.Object != nil {
+						// This pointer was assigned &someVar, check if someVar is variable referenced
+						return a.NeedsVarRef(src.Object)
 					}
 				}
 			}
 		}
+
+		// Handle direct pointer initialization like: var p *int = &x
+		// Check if the pointer type's element type requires variable referencing
+		_ = ptrType.Elem()
+		// For now, conservatively return false for untracked cases
 	}
 
 	return false
 }
 
-// NeedsBoxedDeref determines whether a pointer dereference operation (*ptr) needs
-// the .value suffix in TypeScript when used in a direct dereference expression.
+// NeedsVarRefDeref determines whether a pointer dereference operation (*ptr) needs
+// additional .value access beyond the standard !.value pattern.
 //
-// Critical distinction (source of bugs):
+// Standard pattern: ptr!.value  (for *int, *string, etc.)
+// Enhanced pattern: ptr.value!.value  (when ptr itself is variable referenced)
 //
-//  1. For primitive types and pointers-to-primitive: Need .value
-//     *p => p!.value
-//     **p => p!.value!.value
+// This function returns true when the pointer variable itself is variable referenced,
+// meaning we need an extra .value to access the actual pointer before dereferencing.
 //
-//  2. For pointers to structs: No .value needed because structs are references
-//     *p => p!
-//     Where p is a pointer to a struct
+// Examples:
+//   - ptr := &x (ptr not variable referenced): *ptr => ptr!.value
+//   - ptrPtr := &ptr (ptr is variable referenced): *ptr => ptr.value!.value
 //
-// This distinction is essential because in TypeScript:
-// - Primitives are stored inside $.Box with a .value property
-// - Structs are reference types, so dereferencing just removes the null possibility
-func (a *Analysis) NeedsBoxedDeref(ptrType types.Type) bool {
-	// If we don't have a valid pointer type, default to true (safer)
-	if ptrType == nil {
-		return true
-	}
-
-	// Unwrap the pointer to get the element type
-	ptrTypeUnwrapped, ok := ptrType.(*types.Pointer)
-	if !ok {
-		return true // Not a pointer type, default to true
-	}
-
-	// Get the underlying element type
-	elemType := ptrTypeUnwrapped.Elem()
-	if elemType == nil {
-		return true
-	}
-
-	// Check if the element is another pointer - if so, we always need .value
-	// This fixes the bug with multi-level pointer dereferencing like **p
-	if _, isPointer := elemType.(*types.Pointer); isPointer {
-		return true
-	}
-
-	// Check if the element is a struct (directly or via a named type)
-	// Bug fix: Struct pointers in TS don't need .value when dereferenced
-	// because structs are already references in JavaScript/TypeScript
-	if _, isStruct := elemType.Underlying().(*types.Struct); isStruct {
-		return false // Pointers to structs don't need .value suffix in direct dereference (*p)
-	}
-
-	// For all other cases (primitives, pointers-to-pointers, etc.) need .value
-	// This ensures primitives and nested pointers are correctly dereferenced
-	return true
+// Args:
+//
+//	ptrType: The type of the pointer being dereferenced
+//
+// Returns:
+//
+//	true if additional .value access is needed due to the pointer being variable referenced
+func (a *Analysis) NeedsVarRefDeref(ptrType types.Type) bool {
+	// For now, return false - this would need more sophisticated analysis
+	// to track when pointer variables themselves are variable referenced
+	return false
 }
 
-// NeedsBoxedFieldAccess determines whether a pointer variable needs the .value
-// suffix when accessing fields (e.g., ptr.field).
+// NeedsVarRefFieldAccess determines whether a pointer variable needs the .value
+// access when performing field access through the pointer.
 //
-// Bug fix: This function was a major source of issues with struct field access.
-// The critical discovery was that field access through a pointer depends not on the
-// field itself, but on whether the pointer variable is boxed:
+// In Go, field access through pointers is automatically dereferenced:
 //
-//  1. For normal struct pointers (unboxed): No .value needed
-//     Example: let ptr = new MyStruct() => ptr.field
-//     (Common case from &MyStruct{} literals)
+//	ptr.Field  // equivalent to (*ptr).Field
 //
-//  2. For boxed struct pointers: Need .value to access the pointed-to struct
-//     Example: let ptrToVal = val (where val is boxed) => ptrToVal.value.field
+// In TypeScript, we need to determine if the pointer is:
+//  1. A simple pointer: ptr.Field  (no .value needed)
+//  2. A variable-referenced pointer: ptr.value.Field  (needs .value)
 //
-// We ultimately delegated this decision to WriteSelectorExpr which examines
-// the actual variable to determine if it's boxed, rather than just the type.
-func (a *Analysis) NeedsBoxedFieldAccess(ptrType types.Type) bool {
-	// If we don't have a valid pointer type, default to false
-	if ptrType == nil {
-		return false
-	}
-
-	// Unwrap the pointer to get the element type
-	ptrTypeUnwrapped, ok := ptrType.(*types.Pointer)
-	if !ok {
-		return false // Not a pointer type, no dereference needed for field access
-	}
-
-	// Check if the element is a struct (directly or via a named type)
-	elemType := ptrTypeUnwrapped.Elem()
-	if elemType == nil {
-		return false // Not pointing to anything
-	}
-
-	// For pointers to structs, check if it's a struct type first
-	_, isStruct := elemType.Underlying().(*types.Struct)
-	if !isStruct {
-		return false // Not a pointer to a struct
-	}
-
-	// The critical decision: We'll determine if .value is needed in the WriteSelectorExpr function
-	// by checking if the pointer variable itself is boxed.
-	// This allows us to handle both:
-	// - ptr := &MyStruct{} (unboxed, direct access)
-	// - ptrToVal := &val (boxed, needs .value)
+// Args:
+//
+//	ptrType: The pointer type being used for field access
+//
+// Returns:
+//
+//	true if .value access is needed before field access
+func (a *Analysis) NeedsVarRefFieldAccess(ptrType types.Type) bool {
+	// This would require analysis of the specific pointer variable
+	// For now, return false as a conservative default
 	return false
 }
 
@@ -479,7 +421,7 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 						if vr, ok := def.(*types.Var); ok {
 							v.currentReceiver = vr
 							// Add the receiver variable to the VariableUsage map
-							// to ensure it is properly analyzed for boxing
+							// to ensure it is properly analyzed for varRefing
 							v.getOrCreateUsageInfo(v.currentReceiver)
 						}
 					}
@@ -609,7 +551,7 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 	case *ast.UnaryExpr:
 		// We handle address-of (&) within AssignStmt where it's actually used.
 		// Standalone &x doesn't directly assign, but its usage in assignments
-		// or function calls determines boxing. Assignments are handled below.
+		// 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.
 		return v
@@ -724,7 +666,7 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 
 			// 2. If RHS involved a source variable (rhsSourceObj is not nil),
 			//    record that this source variable was used (its destinations).
-			//    This is CRITICAL for boxing analysis (e.g., if &rhsSourceObj was assigned).
+			//    This is CRITICAL for varRefing analysis (e.g., if &rhsSourceObj was assigned).
 			if rhsSourceObj != nil {
 				sourceUsageInfo := v.getOrCreateUsageInfo(rhsSourceObj)
 				// The 'Object' in DestinationInfo is what/where rhsSourceObj (or its address) was assigned TO.
@@ -842,7 +784,7 @@ func (v *analysisVisitor) containsDefer(block *ast.BlockStmt) bool {
 }
 
 // AnalyzeFile analyzes a Go source file AST and populates the Analysis struct with information
-// that will be used during code generation to properly handle pointers, variables that need boxing, etc.
+// that will be used during code generation to properly handle pointers, variables that need varRefing, etc.
 func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap ast.CommentMap) {
 	// Store the comment map in the analysis object
 	analysis.Cmap = cmap

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("")
+	}
+}