goscript 0.0.34 → 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 {

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(" = ")
 
@@ -282,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
@@ -353,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/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,104 +899,9 @@ func (c *GoToTSCompiler) WriteDoc(doc *ast.CommentGroup) {
 	}
 }
 
-// sanitizeIdentifier checks if an identifier is a JavaScript/TypeScript reserved word
-// or conflicts with built-in types, and transforms it if needed. This prevents
-// compilation errors when Go identifiers conflict with JS/TS keywords or built-ins.
+// 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
-	}
-
-	// Handle TypeScript built-in types that conflict with Go type parameter names
-	builtinTypes := map[string]string{
-		"Map": "MapType",
-		// Add other built-in types as needed
-	}
-
-	if replacement, exists := builtinTypes[name]; exists {
-		return replacement
-	}
-
-	// 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.
@@ -1006,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/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))