goscript 0.0.33 → 0.0.35

package/compiler/analysis.go

@@ -317,9 +317,6 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 						if lhsObj == nil {
 							continue
 						}
-						// Ensure usage info exists for LHS
-						lhsUsageInfo := v.getOrCreateUsageInfo(lhsObj)
-
 						// Check if there's a corresponding initial value (RHS)
 						if valueSpec.Values != nil && i < len(valueSpec.Values) {
 							rhsExpr := valueSpec.Values[i]
@@ -327,12 +324,18 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 							// --- Analyze RHS and Update Usage Info (similar to AssignStmt) ---
 							assignmentType := DirectAssignment
 							var sourceObj types.Object
+							shouldTrackUsage := true
 
 							if unaryExpr, ok := rhsExpr.(*ast.UnaryExpr); ok && unaryExpr.Op == token.AND {
-								// Case: var lhs = &rhs_ident
+								// Case: var lhs = &rhs_expr
 								assignmentType = AddressOfAssignment
 								if rhsIdent, ok := unaryExpr.X.(*ast.Ident); ok {
+									// Case: var lhs = &rhs_ident (taking address of a variable)
 									sourceObj = v.pkg.TypesInfo.ObjectOf(rhsIdent)
+								} else {
+									// Case: var lhs = &CompositeLit{} (taking address of composite literal)
+									// No variable tracking needed - this doesn't create VarRef requirements
+									shouldTrackUsage = false
 								}
 							} else if rhsIdent, ok := rhsExpr.(*ast.Ident); ok {
 								// Case: var lhs = rhs_ident
@@ -341,21 +344,26 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 							}
 
 							// --- Record Usage ---
-							if sourceObj != nil {
-								// Record source for LHS
-								lhsUsageInfo.Sources = append(lhsUsageInfo.Sources, AssignmentInfo{
-									Object: sourceObj,
-									Type:   assignmentType,
-								})
-
-								// Record destination for RHS source
-								sourceUsageInfo := v.getOrCreateUsageInfo(sourceObj)
-								sourceUsageInfo.Destinations = append(sourceUsageInfo.Destinations, AssignmentInfo{
-									Object: lhsObj,
-									Type:   assignmentType,
-								})
+							// Only create usage tracking if we're dealing with variable references
+							if shouldTrackUsage {
+								// Ensure usage info exists for LHS only when needed
+								lhsUsageInfo := v.getOrCreateUsageInfo(lhsObj)
+
+								if sourceObj != nil {
+									// Record source for LHS
+									lhsUsageInfo.Sources = append(lhsUsageInfo.Sources, AssignmentInfo{
+										Object: sourceObj,
+										Type:   assignmentType,
+									})
+
+									// Record destination for RHS source
+									sourceUsageInfo := v.getOrCreateUsageInfo(sourceObj)
+									sourceUsageInfo.Destinations = append(sourceUsageInfo.Destinations, AssignmentInfo{
+										Object: lhsObj,
+										Type:   assignmentType,
+									})
+								}
 							}
-							// Note: We might need to handle var lhs = &T{} cases later if necessary.
 						}
 					}
 				}
@@ -418,12 +426,12 @@ func (v *analysisVisitor) Visit(node ast.Node) ast.Visitor {
 			}
 		}
 
-		// Store named return variables
+		// Store named return variables (sanitized for TypeScript)
 		if n.Type != nil && n.Type.Results != nil {
 			var namedReturns []string
 			for _, field := range n.Type.Results.List {
 				for _, name := range field.Names {
-					namedReturns = append(namedReturns, name.Name)
+					namedReturns = append(namedReturns, sanitizeIdentifier(name.Name))
 				}
 			}
 			if len(namedReturns) > 0 {
@@ -864,8 +872,8 @@ func AnalyzeFile(file *ast.File, pkg *packages.Package, analysis *Analysis, cmap
 				importVars: make(map[string]struct{}),
 			}
 
-			// Use the import name or path as the key
-			key := path
+			// Use the import name or package name as the key
+			key := packageNameFromGoPath(path)
 			if name != "" {
 				key = name
 			}

package/compiler/analysis_test.go

@@ -88,6 +88,20 @@ func main() {
 				"data": {NeedsVarRef: false, NeedsVarRefAccess: false}, // Should NOT be varrefed
 			},
 		},
+		{
+			name: "var_declaration_composite_literal",
+			code: `package main
+type MockInode struct {
+	Value int
+}
+func main() {
+	var childInode *MockInode = &MockInode{Value: 42}
+	println("childInode.Value:", childInode.Value)
+}`,
+			expected: map[string]AnalysisExpectation{
+				"childInode": {NeedsVarRef: false, NeedsVarRefAccess: false}, // Should NOT be varrefed
+			},
+		},
 	}
 
 	for _, tt := range tests {

package/compiler/assignment.go

@@ -94,7 +94,7 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 			if isLHSVarRefed && lhsIdent != nil {
 				c.tsw.WriteLiterally("let ")
 				// Just write the identifier name without .value
-				c.tsw.WriteLiterally(lhsIdent.Name)
+				c.tsw.WriteLiterally(c.sanitizeIdentifier(lhsIdent.Name))
 				// No type annotation, allow TypeScript to infer it from varRef.
 				c.tsw.WriteLiterally(" = ")
 
@@ -197,6 +197,7 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		currentIsMapIndex := false
 		if indexExpr, ok := l.(*ast.IndexExpr); ok {
 			if tv, ok := c.pkg.TypesInfo.Types[indexExpr.X]; ok {
+				// Check if it's a concrete map type
 				if _, isMap := tv.Type.Underlying().(*types.Map); isMap {
 					currentIsMapIndex = true
 					if i == 0 {
@@ -213,6 +214,31 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 					}
 					c.tsw.WriteLiterally(", ")
 					// Value will be added after operator and RHS
+				} else if typeParam, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+					// Check if the type parameter is constrained to be a map type
+					constraint := typeParam.Constraint()
+					if constraint != nil {
+						underlying := constraint.Underlying()
+						if iface, isInterface := underlying.(*types.Interface); isInterface {
+							if hasMapConstraint(iface) {
+								currentIsMapIndex = true
+								if i == 0 {
+									isMapIndexLHS = true
+								}
+								// Use mapSet helper for type parameter constrained to map
+								c.tsw.WriteLiterally("$.mapSet(")
+								if err := c.WriteValueExpr(indexExpr.X); err != nil { // Map
+									return err
+								}
+								c.tsw.WriteLiterally(", ")
+								if err := c.WriteValueExpr(indexExpr.Index); err != nil { // Key
+									return err
+								}
+								c.tsw.WriteLiterally(", ")
+								// Value will be added after operator and RHS
+							}
+						}
+					}
 				}
 			}
 		}
@@ -256,14 +282,21 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		// Continue, we've already written part of the mapSet() function call
 	} else {
 		c.tsw.WriteLiterally(" ")
-		tokStr, ok := TokenToTs(tok) // Use explicit gstypes alias
-		if !ok {
-			c.tsw.WriteLiterally("?= ")
-			c.tsw.WriteCommentLine("Unknown token " + tok.String())
+
+		// Special handling for &^= (bitwise AND NOT assignment)
+		if tok == token.AND_NOT_ASSIGN {
+			// Transform x &^= y to x &= ~(y)
+			c.tsw.WriteLiterally("&= ~(")
 		} else {
-			c.tsw.WriteLiterally(tokStr)
+			tokStr, ok := TokenToTs(tok) // Use explicit gstypes alias
+			if !ok {
+				c.tsw.WriteLiterally("?= ")
+				c.tsw.WriteCommentLine("Unknown token " + tok.String())
+			} else {
+				c.tsw.WriteLiterally(tokStr)
+			}
+			c.tsw.WriteLiterally(" ")
 		}
-		c.tsw.WriteLiterally(" ")
 	}
 
 	// Write RHS
@@ -327,6 +360,11 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		}
 	}
 
+	// Close the parenthesis for &^= transformation
+	if tok == token.AND_NOT_ASSIGN && !(isMapIndexLHS && len(lhs) == 1) {
+		c.tsw.WriteLiterally(")")
+	}
+
 	// If the LHS was a single map index, close the mapSet call
 	if isMapIndexLHS && len(lhs) == 1 {
 		c.tsw.WriteLiterally(")")

package/compiler/builtin_test.go

@@ -1,3 +1,5 @@
+//go:build test_emit_builtin
+
 package compiler
 
 import (

package/compiler/compiler.go

@@ -611,7 +611,15 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 	// Generate auto-imports for functions from other files in the same package
 	currentFileName := strings.TrimSuffix(filepath.Base(c.fullPath), ".go")
 	if imports := c.PackageAnalysis.FunctionCalls[currentFileName]; imports != nil {
-		for sourceFile, functions := range imports {
+		// Sort source files for consistent import order
+		var sourceFiles []string
+		for sourceFile := range imports {
+			sourceFiles = append(sourceFiles, sourceFile)
+		}
+		sort.Strings(sourceFiles)
+
+		for _, sourceFile := range sourceFiles {
+			functions := imports[sourceFile]
 			if len(functions) > 0 {
 				// Sort functions for consistent output
 				sort.Strings(functions)
@@ -891,94 +899,9 @@ 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.
+// sanitizeIdentifier is a method wrapper around the package-level sanitizeIdentifier function
 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
+	return sanitizeIdentifier(name)
 }
 
 // writeConstantValue writes the evaluated value of a Go constant to TypeScript.
@@ -996,7 +919,10 @@ func (c *GoToTSCompiler) writeConstantValue(constObj *types.Const) {
 		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
+		// Use constant.StringVal to get the full string value without truncation,
+		// then manually add quotes since StringVal returns the unquoted string
+		stringValue := constant.StringVal(val)
+		c.tsw.WriteLiterallyf("%q", stringValue) // %q adds proper quotes and escaping
 	case constant.Bool:
 		// For boolean constants, write true/false
 		if constant.BoolVal(val) {

package/compiler/compiler_test.go

@@ -1,7 +1,6 @@
 package compiler_test
 
 import (
-	"context"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -12,9 +11,7 @@ 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.
@@ -140,53 +137,3 @@ func getParentGoModulePath() (string, error) {
 	}
 	return strings.TrimSpace(string(output)), nil
 }
-
-func TestUnsafePackageCompilation(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 and DisableEmitBuiltin=false to ensure handwritten packages are copied
-	config := &compiler.Config{
-		OutputPath:         tempDir,
-		AllDependencies:    true,
-		DisableEmitBuiltin: false, // This ensures handwritten packages are copied to output
-	}
-
-	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
-	result, err := comp.CompilePackages(context.Background(), "sync/atomic")
-	// This should now succeed since we have a handwritten unsafe package
-	if err != nil {
-		t.Fatalf("Expected compilation to succeed with handwritten unsafe package, but it failed: %v", err)
-	}
-
-	// Verify that the unsafe package was copied (not compiled) since it has a handwritten equivalent
-	if !slices.Contains(result.CopiedPackages, "unsafe") {
-		t.Errorf("Expected unsafe package to be in CopiedPackages, but it wasn't. CopiedPackages: %v", result.CopiedPackages)
-	}
-
-	// Verify that sync/atomic was compiled
-	if !slices.Contains(result.CompiledPackages, "sync/atomic") {
-		t.Errorf("Expected sync/atomic package to be in CompiledPackages, but it wasn't. CompiledPackages: %v", result.CompiledPackages)
-	}
-
-	// Check that the unsafe package directory exists in the output
-	unsafePath := filepath.Join(tempDir, "@goscript/unsafe")
-	if _, err := os.Stat(unsafePath); os.IsNotExist(err) {
-		t.Errorf("unsafe package directory was not created at %s", unsafePath)
-	}
-}

package/compiler/composite-lit.go

@@ -3,6 +3,7 @@ package compiler
 import (
 	"fmt"
 	"go/ast"
+	"go/constant"
 	"go/token"
 	"go/types"
 	"slices"
@@ -108,6 +109,9 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 				if at, ok := typ.Underlying().(*types.Array); ok {
 					arrayLen = int(at.Len())
 					goElemType = at.Elem()
+				} else if st, ok := typ.Underlying().(*types.Slice); ok {
+					// For slices, get the element type
+					goElemType = st.Elem()
 				}
 			}
 			if arrType.Len != nil {
@@ -116,6 +120,13 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					if _, err := fmt.Sscan(bl.Value, &arrayLen); err != nil {
 						return fmt.Errorf("failed to parse array length from basic literal: %w", err)
 					}
+				} else {
+					// Try to evaluate as a constant expression (e.g., const N = 5; [N]int{})
+					if lenValue := c.evaluateConstantExpr(arrType.Len); lenValue != nil {
+						if length, ok := lenValue.(int); ok {
+							arrayLen = length
+						}
+					}
 				}
 			}
 			elemType = arrType.Elt
@@ -128,28 +139,35 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 
 			for _, elm := range exp.Elts {
 				if kv, ok := elm.(*ast.KeyValueExpr); ok {
-					if lit, ok := kv.Key.(*ast.BasicLit); ok && lit.Kind == token.INT {
-						var index int
-						if _, err := fmt.Sscan(lit.Value, &index); err != nil {
-							return fmt.Errorf("failed to parse array index from basic literal: %w", err)
-						}
-						elements[index] = kv.Value
-						if index > maxIndex {
-							maxIndex = index
+					// Try to evaluate the key expression as a constant (handles both literals and expressions)
+					if keyValue := c.evaluateConstantExpr(kv.Key); keyValue != nil {
+						if index, ok := keyValue.(int); ok {
+							elements[index] = kv.Value
+							if index > maxIndex {
+								maxIndex = index
+							}
+							hasKeyedElements = true
+						} else {
+							return fmt.Errorf("keyed array literal key must evaluate to an integer, got %T", keyValue)
 						}
-						hasKeyedElements = true
 					} else {
-						c.tsw.WriteCommentInline("unhandled keyed array literal key type")
-						if err := c.WriteVarRefedValue(elm); err != nil {
-							return fmt.Errorf("failed to write keyed array literal element with unhandled key type: %w", err)
-						}
+						return fmt.Errorf("keyed array literal key must be a constant expression")
 					}
 				} else {
-					elements[orderedCount] = elm
-					if orderedCount > maxIndex {
-						maxIndex = orderedCount
+					// For unkeyed elements, place them at the next available index
+					// If we have keyed elements, start after the highest keyed index
+					currentIndex := orderedCount
+					if hasKeyedElements && orderedCount <= maxIndex {
+						currentIndex = maxIndex + 1
+						for elements[currentIndex] != nil {
+							currentIndex++
+						}
 					}
-					orderedCount++
+					elements[currentIndex] = elm
+					if currentIndex > maxIndex {
+						maxIndex = currentIndex
+					}
+					orderedCount = currentIndex + 1
 				}
 			}
 
@@ -639,3 +657,28 @@ func (c *GoToTSCompiler) WriteVarRefedValue(expr ast.Expr) error {
 		return c.WriteValueExpr(expr)
 	}
 }
+
+// evaluateConstantExpr attempts to evaluate a Go expression as a compile-time constant.
+// It returns the constant value if successful, or nil if the expression is not a constant.
+// This is used for evaluating array literal keys that are constant expressions.
+func (c *GoToTSCompiler) evaluateConstantExpr(expr ast.Expr) interface{} {
+	// Use the type checker's constant evaluation
+	if tv, ok := c.pkg.TypesInfo.Types[expr]; ok && tv.Value != nil {
+		// The expression has a constant value
+		switch tv.Value.Kind() {
+		case constant.Int:
+			if val, exact := constant.Int64Val(tv.Value); exact {
+				return int(val)
+			}
+		case constant.Float:
+			if val, exact := constant.Float64Val(tv.Value); exact {
+				return val
+			}
+		case constant.String:
+			return constant.StringVal(tv.Value)
+		case constant.Bool:
+			return constant.BoolVal(tv.Value)
+		}
+	}
+	return nil
+}

package/compiler/decl.go

@@ -118,7 +118,7 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 		// Declare named return variables and initialize them to their zero values
 		for _, field := range decl.Type.Results.List {
 			for _, name := range field.Names {
-				c.tsw.WriteLiterallyf("let %s: ", name.Name)
+				c.tsw.WriteLiterallyf("let %s: ", c.sanitizeIdentifier(name.Name))
 				c.WriteTypeExpr(field.Type)
 				c.tsw.WriteLiterally(" = ")
 				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))