goscript 0.0.61 → 0.0.63

package/compiler/stmt-assign.go

@@ -168,6 +168,21 @@ func (c *GoToTSCompiler) WriteStmtAssign(exp *ast.AssignStmt) error {
 
 	// Handle single assignment using writeAssignmentCore
 	if len(exp.Lhs) == 1 {
+		// Check for type shadowing (e.g., field := field{...})
+		// In this case, we need to rename the variable to avoid TypeScript shadowing
+		if nodeInfo := c.analysis.NodeData[exp]; nodeInfo != nil && nodeInfo.ShadowingInfo != nil {
+			if lhsIdent, ok := exp.Lhs[0].(*ast.Ident); ok && lhsIdent.Name != "_" {
+				if renamedVar, hasTypeShadow := nodeInfo.ShadowingInfo.TypeShadowedVars[lhsIdent.Name]; hasTypeShadow {
+					if err := c.writeTypeShadowedAssignment(exp, lhsIdent.Name, renamedVar); err != nil {
+						return err
+					}
+					c.writeInlineComment(exp)
+					c.tsw.WriteLine("")
+					return nil
+				}
+			}
+		}
+
 		addDeclaration := exp.Tok == token.DEFINE
 		if err := c.writeAssignmentCore(exp.Lhs, exp.Rhs, exp.Tok, addDeclaration); err != nil {
 			return err
@@ -305,6 +320,59 @@ func (c *GoToTSCompiler) writeMultiVarAssignFromCall(lhs []ast.Expr, callExpr *a
 		}
 
 		if allNewVars && anyNewVars {
+			// Check if any variable needs VarRef - if so, we need a different approach
+			anyNeedsVarRef := false
+			needsVarRefVars := make([]bool, len(lhs))
+			for i, lhsExpr := range lhs {
+				if ident, ok := lhsExpr.(*ast.Ident); ok && ident.Name != "_" {
+					if obj := c.pkg.TypesInfo.Defs[ident]; obj != nil {
+						if c.analysis.NeedsVarRef(obj) {
+							needsVarRefVars[i] = true
+							anyNeedsVarRef = true
+						}
+					}
+				}
+			}
+
+			if anyNeedsVarRef {
+				// Use temp variables for destructuring, then wrap in VarRef as needed
+				c.tsw.WriteLiterally("let [")
+				for i, lhsExpr := range lhs {
+					if i != 0 {
+						c.tsw.WriteLiterally(", ")
+					}
+					if ident, ok := lhsExpr.(*ast.Ident); ok {
+						if ident.Name == "_" {
+							// Empty slot for blank identifier
+						} else if needsVarRefVars[i] {
+							c.tsw.WriteLiterally("_varref_tmp_")
+							c.tsw.WriteLiterally(ident.Name)
+						} else {
+							c.WriteIdent(ident, false)
+						}
+					} else {
+						c.WriteValueExpr(lhsExpr)
+					}
+				}
+				c.tsw.WriteLiterally("] = ")
+				c.WriteValueExpr(callExpr)
+				c.tsw.WriteLine("")
+
+				// Now declare the VarRef-wrapped variables
+				for i, lhsExpr := range lhs {
+					if ident, ok := lhsExpr.(*ast.Ident); ok && ident.Name != "_" && needsVarRefVars[i] {
+						c.tsw.WriteLiterally("let ")
+						c.WriteIdent(ident, false)
+						c.tsw.WriteLiterally(" = $.varRef(_varref_tmp_")
+						c.tsw.WriteLiterally(ident.Name)
+						// Add non-null assertion to handle cases where the tuple type includes null
+						c.tsw.WriteLiterally("!)")
+						c.tsw.WriteLine("")
+					}
+				}
+				return nil
+			}
+
 			c.tsw.WriteLiterally("let [")
 
 			for i, lhsExpr := range lhs {
@@ -536,3 +604,59 @@ func (c *GoToTSCompiler) writeMapLookupWithExists(lhs []ast.Expr, indexExpr *ast
 
 	return nil
 }
+
+// writeTypeShadowedAssignment handles the case where a variable name shadows a type name
+// used in its initialization (e.g., field := field{...}).
+// In TypeScript, `let field = new field({...})` fails because the variable shadows the class
+// before initialization due to the Temporal Dead Zone (TDZ). The TDZ extends from the
+// start of the block scope to the point of initialization, so even capturing the type
+// reference before the `let` declaration doesn't work - they're in the same block.
+//
+// We solve this by renaming the variable to avoid the conflict entirely:
+//
+//	let field_ = $.markAsStructValue(new field({...}));
+//
+// Then we need to track that all subsequent references to `field` should use `field_`.
+// This is stored in the analysis NodeInfo.IdentifierMapping.
+func (c *GoToTSCompiler) writeTypeShadowedAssignment(exp *ast.AssignStmt, origName, renamedVar string) error {
+	if len(exp.Lhs) != 1 || len(exp.Rhs) != 1 {
+		return fmt.Errorf("type shadowing assignment must have exactly 1 LHS and 1 RHS")
+	}
+
+	lhsIdent, ok := exp.Lhs[0].(*ast.Ident)
+	if !ok {
+		return fmt.Errorf("type shadowing assignment LHS must be an identifier")
+	}
+
+	// Check if this variable needs VarRef
+	obj := c.objectOfIdent(lhsIdent)
+	needsVarRef := obj != nil && c.analysis.NeedsVarRef(obj)
+
+	// Store the mapping so that subsequent references to this variable use the renamed version
+	if obj != nil {
+		c.renamedVars[obj] = renamedVar
+	}
+
+	if needsVarRef {
+		// For VarRef'd variables:
+		// let field_ = $.varRef($.markAsStructValue(new field({...})))
+		c.tsw.WriteLiterally("let ")
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(renamedVar))
+		c.tsw.WriteLiterally(" = $.varRef(")
+		if err := c.WriteValueExpr(exp.Rhs[0]); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(")")
+	} else {
+		// For non-VarRef variables:
+		// let field_ = $.markAsStructValue(new field({...}))
+		c.tsw.WriteLiterally("let ")
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(renamedVar))
+		c.tsw.WriteLiterally(" = ")
+		if err := c.WriteValueExpr(exp.Rhs[0]); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

package/compiler/stmt-range.go

@@ -171,7 +171,7 @@ func (c *GoToTSCompiler) writeStringRange(exp *ast.RangeStmt) error {
 
 	if exp.Value != nil {
 		if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
-			c.tsw.WriteLiterally("const ")
+			c.tsw.WriteLiterally("let ")
 			c.WriteIdent(ident, false)
 			c.tsw.WriteLiterally(" = _runes[")
 			c.tsw.WriteLiterally(indexVarName)
@@ -236,7 +236,7 @@ func (c *GoToTSCompiler) writeArraySliceWithKeyValue(exp *ast.RangeStmt, indexVa
 	c.tsw.WriteLine("")
 
 	if ident, ok := exp.Value.(*ast.Ident); ok && ident.Name != "_" {
-		c.tsw.WriteLiterally("const ")
+		c.tsw.WriteLiterally("let ")
 		c.WriteIdent(ident, false)
 		c.tsw.WriteLiterally(" = ")
 		if err := c.writeArraySliceExpression(exp.X, isPointer); err != nil {

package/compiler/stmt.go

@@ -167,9 +167,17 @@ func (c *GoToTSCompiler) WriteStmtIncDec(stmt *ast.IncDecStmt) error {
 func (c *GoToTSCompiler) WriteStmtBranch(stmt *ast.BranchStmt) error {
 	switch stmt.Tok {
 	case token.BREAK:
-		c.tsw.WriteLine("break") // No semicolon needed
+		if stmt.Label != nil {
+			c.tsw.WriteLinef("break %s", stmt.Label.Name)
+		} else {
+			c.tsw.WriteLine("break")
+		}
 	case token.CONTINUE:
-		c.tsw.WriteLine("continue") // No semicolon needed
+		if stmt.Label != nil {
+			c.tsw.WriteLinef("continue %s", stmt.Label.Name)
+		} else {
+			c.tsw.WriteLine("continue")
+		}
 	case token.GOTO:
 		// TypeScript doesn't support goto, but we can handle it by skipping it
 		// since the labeled statement restructuring should handle the control flow
@@ -368,6 +376,15 @@ func (c *GoToTSCompiler) WriteStmtExpr(exp *ast.ExprStmt) error {
 		return nil
 	}
 
+	// Defensive semicolon: if the expression will start with '(' in TypeScript,
+	// prepend a semicolon to prevent JavaScript from treating the previous line
+	// as a function call. This happens when:
+	// 1. CallExpr where Fun itself will be parenthesized (e.g., (await fn())())
+	// 2. Array/slice literals starting with '['
+	if c.needsDefensiveSemicolon(exp.X) {
+		c.tsw.WriteLiterally(";")
+	}
+
 	// Handle other expression statements
 	if err := c.WriteValueExpr(exp.X); err != nil { // Expression statement evaluates a value
 		return err
@@ -475,17 +492,10 @@ func (c *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 		}
 		c.tsw.WriteLiterally(") ")
 
-		if err := c.WriteStmt(exp.Body); err != nil {
+		if err := c.writeIfBody(exp); err != nil {
 			return err
 		}
 
-		if exp.Else != nil {
-			c.tsw.WriteLiterally(" else ")
-			if err := c.WriteStmt(exp.Else); err != nil {
-				return err
-			}
-		}
-
 		c.tsw.Indent(-1)
 		c.tsw.WriteLine("}")
 		return nil
@@ -498,14 +508,31 @@ func (c *GoToTSCompiler) WriteStmtIf(exp *ast.IfStmt) error {
 	}
 	c.tsw.WriteLiterally(") ")
 
-	if err := c.WriteStmt(exp.Body); err != nil {
+	return c.writeIfBody(exp)
+}
+
+// writeIfBody writes the if body and optional else clause, handling newline suppression.
+func (c *GoToTSCompiler) writeIfBody(exp *ast.IfStmt) error {
+	hasElse := exp.Else != nil
+	if err := c.WriteStmtBlock(exp.Body, hasElse); err != nil {
 		return err
 	}
 
-	if exp.Else != nil {
+	if hasElse {
 		c.tsw.WriteLiterally(" else ")
-		if err := c.WriteStmt(exp.Else); err != nil {
-			return err
+		switch elseStmt := exp.Else.(type) {
+		case *ast.BlockStmt:
+			if err := c.WriteStmtBlock(elseStmt, false); err != nil {
+				return err
+			}
+		case *ast.IfStmt:
+			if err := c.WriteStmtIf(elseStmt); err != nil {
+				return err
+			}
+		default:
+			if err := c.WriteStmt(exp.Else); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -574,6 +601,12 @@ func (c *GoToTSCompiler) WriteStmtReturn(exp *ast.ReturnStmt) error {
 					}
 				}
 			}
+
+			// Special handling for primitive types that implement error interface
+			if c.writePrimitiveErrorWrapperIfNeeded(exp, res, i) {
+				continue
+			}
+
 			if err := c.WriteValueExpr(res); err != nil { // Return results are values
 				return err
 			}
@@ -586,6 +619,84 @@ func (c *GoToTSCompiler) WriteStmtReturn(exp *ast.ReturnStmt) error {
 	return nil
 }
 
+// writePrimitiveErrorWrapperIfNeeded checks if a return value is a primitive type
+// that implements the error interface, and if so, wraps it with $.wrapPrimitiveError.
+// Returns true if the wrapper was written, false otherwise.
+func (c *GoToTSCompiler) writePrimitiveErrorWrapperIfNeeded(retStmt *ast.ReturnStmt, res ast.Expr, resultIndex int) bool {
+	// Get the expected return type for this position
+	nodeInfo := c.analysis.NodeData[retStmt]
+	if nodeInfo == nil || nodeInfo.EnclosingFuncDecl == nil {
+		return false
+	}
+
+	funcDecl := nodeInfo.EnclosingFuncDecl
+	if funcDecl.Type.Results == nil {
+		return false
+	}
+
+	// Find the expected return type for this result index
+	var expectedType types.Type
+	resultIdx := 0
+	for _, field := range funcDecl.Type.Results.List {
+		count := len(field.Names)
+		if count == 0 {
+			count = 1
+		}
+		for j := 0; j < count; j++ {
+			if resultIdx == resultIndex {
+				expectedType = c.pkg.TypesInfo.TypeOf(field.Type)
+				break
+			}
+			resultIdx++
+		}
+		if expectedType != nil {
+			break
+		}
+	}
+
+	if expectedType == nil {
+		return false
+	}
+
+	// Check if the expected type is the error interface
+	if iface, ok := expectedType.Underlying().(*types.Interface); !ok || iface.String() != "interface{Error() string}" {
+		return false
+	}
+
+	// Get the actual type of the return expression
+	actualType := c.pkg.TypesInfo.TypeOf(res)
+	if actualType == nil {
+		return false
+	}
+
+	// Check if the actual type is a wrapper type (named type with basic underlying type)
+	if !c.isWrapperType(actualType) {
+		return false
+	}
+
+	// Check if the actual type has an Error() method
+	if !c.typeHasMethods(actualType, "Error") {
+		return false
+	}
+
+	// Get the qualified type name for the Error function
+	typeName := c.getQualifiedTypeName(actualType)
+	if typeName == "" {
+		return false
+	}
+
+	// Write: $.wrapPrimitiveError(value, TypeName_Error)
+	c.tsw.WriteLiterally("$.wrapPrimitiveError(")
+	if err := c.WriteValueExpr(res); err != nil {
+		return false
+	}
+	c.tsw.WriteLiterally(", ")
+	c.tsw.WriteLiterally(typeName)
+	c.tsw.WriteLiterally("_Error)")
+
+	return true
+}
+
 // WriteStmtBlock translates a Go block statement (`ast.BlockStmt`), typically
 // `{ ...stmts... }`, into its TypeScript equivalent, carefully preserving
 // comments and blank lines to maintain code readability and structure.
@@ -1129,3 +1240,38 @@ func (c *GoToTSCompiler) substituteExprForShadowing(expr ast.Expr, shadowingInfo
 func (c *GoToTSCompiler) isBuiltinFunction(name string) bool {
 	return builtinFunctions[name]
 }
+
+// needsDefensiveSemicolon determines if an expression will generate TypeScript
+// code starting with '(' or '[', which would require a defensive semicolon to
+// prevent JavaScript from treating the previous line as a function call.
+func (c *GoToTSCompiler) needsDefensiveSemicolon(expr ast.Expr) bool {
+	switch e := expr.(type) {
+	case *ast.CallExpr:
+		// Check if the function being called will be parenthesized
+		// This happens when Fun is itself a CallExpr, TypeAssertExpr, or other complex expression
+		switch e.Fun.(type) {
+		case *ast.CallExpr:
+			// (fn())() - needs defensive semicolon
+			return true
+		case *ast.TypeAssertExpr:
+			// (x.(T))() - needs defensive semicolon
+			return true
+		case *ast.IndexExpr:
+			// Could generate (arr[i])() if indexed result is called
+			// But typically doesn't need defensive semicolon as arr[i]() is fine
+			return false
+		case *ast.ParenExpr:
+			// Already parenthesized - needs defensive semicolon
+			return true
+		}
+	case *ast.CompositeLit:
+		// Array/slice literals start with '['
+		if _, isArray := e.Type.(*ast.ArrayType); isArray {
+			return true
+		}
+	case *ast.ParenExpr:
+		// Parenthesized expressions start with '('
+		return true
+	}
+	return false
+}

package/compiler/type-info.go

@@ -26,11 +26,9 @@ func (c *GoToTSCompiler) writeTypeInfoObject(typ types.Type) {
 	underlying := typ.Underlying()
 	switch t := underlying.(type) {
 	case *types.Basic:
-		tsTypeName, _ := GoBuiltinToTypescript(t.Name())
-		if tsTypeName == "" {
-			tsTypeName = t.Name() // Fallback
-		}
-		c.tsw.WriteLiterallyf("{ kind: $.TypeKind.Basic, name: %q }", tsTypeName)
+		// Use Go type name (e.g., "int") not TypeScript type name (e.g., "number")
+		// The reflect system needs Go type names to correctly determine Kind()
+		c.tsw.WriteLiterallyf("{ kind: $.TypeKind.Basic, name: %q }", t.Name())
 	// Note: The original 'case *types.Named:' here for 'underlying' is intentionally omitted.
 	// If typ.Underlying() is *types.Named (e.g. type T1 MyInt; type T2 T1;),
 	// then writeTypeInfoObject(typ.Underlying()) would be called in some contexts,

package/compiler/type-utils.go

@@ -25,11 +25,50 @@ func (c *GoToTSCompiler) isRuneSliceType(t types.Type) bool {
 	return false
 }
 
-// isStringType checks if a type is string
+// isStringType checks if a type is string or could be string (e.g., type parameter)
 func (c *GoToTSCompiler) isStringType(t types.Type) bool {
 	if basic, isBasic := t.Underlying().(*types.Basic); isBasic {
 		return basic.Kind() == types.String || basic.Kind() == types.UntypedString
 	}
+	// Handle type parameters (e.g., Bytes ~[]byte | ~string)
+	if typeParam, isTypeParam := t.(*types.TypeParam); isTypeParam {
+		constraint := typeParam.Constraint()
+		if constraintIface, ok := constraint.(*types.Interface); ok {
+			return c.constraintIncludesString(constraintIface)
+		}
+	}
+	return false
+}
+
+// constraintIncludesString checks if a type constraint includes string
+func (c *GoToTSCompiler) constraintIncludesString(constraint *types.Interface) bool {
+	// Check if the constraint has type terms that include string
+	if constraint.IsMethodSet() {
+		return false // Pure method interface, no type terms
+	}
+	// For union constraints like []byte | string, check each term
+	for i := 0; i < constraint.NumEmbeddeds(); i++ {
+		embedded := constraint.EmbeddedType(i)
+		// Check if embedded is a union
+		if union, isUnion := embedded.(*types.Union); isUnion {
+			for j := 0; j < union.Len(); j++ {
+				term := union.Term(j)
+				termType := term.Type()
+				// Check if term is string or ~string
+				if basic, isBasic := termType.Underlying().(*types.Basic); isBasic {
+					if basic.Kind() == types.String {
+						return true
+					}
+				}
+			}
+		}
+		// Check direct embedded type
+		if basic, isBasic := embedded.Underlying().(*types.Basic); isBasic {
+			if basic.Kind() == types.String {
+				return true
+			}
+		}
+	}
 	return false
 }
 

package/compiler/type.go

@@ -21,6 +21,9 @@ const (
 	// GoTypeContextVariadicParam is used when translating types for variadic parameter elements.
 	// This affects how interface{} types are handled (no null prefix).
 	GoTypeContextVariadicParam
+	// GoTypeContextGenericTypeArg is used when translating type arguments for generic types.
+	// This affects how function types are handled (no | null suffix for func() types).
+	GoTypeContextGenericTypeArg
 )
 
 // WriteGoType is the main dispatcher for translating Go types to their TypeScript
@@ -68,7 +71,7 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type, context GoTypeContext) {
 			c.WriteInterfaceType(t, nil) // No ast.InterfaceType available here
 		}
 	case *types.Signature:
-		c.WriteSignatureType(t)
+		c.WriteSignatureType(t, context)
 	case *types.Struct:
 		c.WriteStructType(t)
 	case *types.Alias:
@@ -249,7 +252,8 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 	typePkg := t.Obj().Pkg()
 	if typePkg != nil && typePkg != c.pkg.Types {
 		// This type is from an imported package, find the import alias
-		if alias, found := c.resolveImportAlias(typePkg); found {
+		alias, found := c.resolveImportAlias(typePkg)
+		if found && alias != "" {
 			// Write the qualified name: importAlias.TypeName
 			c.tsw.WriteLiterally(alias)
 			c.tsw.WriteLiterally(".")
@@ -262,7 +266,8 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 					if i > 0 {
 						c.tsw.WriteLiterally(", ")
 					}
-					c.WriteGoType(t.TypeArgs().At(i), GoTypeContextGeneral)
+					// Use GenericTypeArg context to avoid adding | null to function types
+					c.WriteGoType(t.TypeArgs().At(i), GoTypeContextGenericTypeArg)
 				}
 				c.tsw.WriteLiterally(">")
 			}
@@ -285,7 +290,8 @@ func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 			if i > 0 {
 				c.tsw.WriteLiterally(", ")
 			}
-			c.WriteGoType(t.TypeArgs().At(i), GoTypeContextGeneral)
+			// Use GenericTypeArg context to avoid adding | null to function types
+			c.WriteGoType(t.TypeArgs().At(i), GoTypeContextGenericTypeArg)
 		}
 		c.tsw.WriteLiterally(">")
 	}
@@ -392,19 +398,39 @@ func (c *GoToTSCompiler) WriteFuncType(exp *ast.FuncType, isAsync bool) {
 		if isAsync {
 			c.tsw.WriteLiterally("Promise<")
 		}
-		if len(exp.Results.List) == 1 {
+
+		// Count total number of return values (each field may have multiple names like "a, b int")
+		totalResults := 0
+		for _, field := range exp.Results.List {
+			count := len(field.Names)
+			if count == 0 {
+				count = 1 // Unnamed return value
+			}
+			totalResults += count
+		}
+
+		if totalResults == 1 {
 			// Single return type (named or unnamed)
 			// Use WriteTypeExpr to preserve qualified names like os.FileInfo
 			c.WriteTypeExpr(exp.Results.List[0].Type)
 		} else {
 			// Multiple return types -> tuple
 			c.tsw.WriteLiterally("[")
-			for i, field := range exp.Results.List {
-				if i > 0 {
-					c.tsw.WriteLiterally(", ")
+			first := true
+			for _, field := range exp.Results.List {
+				// Each field may represent multiple return values (e.g., "a, b int")
+				count := len(field.Names)
+				if count == 0 {
+					count = 1 // Unnamed return value
+				}
+				for j := 0; j < count; j++ {
+					if !first {
+						c.tsw.WriteLiterally(", ")
+					}
+					first = false
+					// Use WriteTypeExpr to preserve qualified names like os.FileInfo
+					c.WriteTypeExpr(field.Type)
 				}
-				// Use WriteTypeExpr to preserve qualified names like os.FileInfo
-				c.WriteTypeExpr(field.Type)
 			}
 			c.tsw.WriteLiterally("]")
 		}
@@ -440,7 +466,11 @@ func (c *GoToTSCompiler) WriteInterfaceType(t *types.Interface, astNode *ast.Int
 
 // WriteSignatureType translates a Go function signature to its TypeScript equivalent.
 // It generates (param1: type1, param2: type2, ...): returnType for function types.
-func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
+// The context parameter determines whether to add | null suffix:
+// - GoTypeContextGeneral: Add | null (function values can be nil in Go)
+// - GoTypeContextFunctionReturn: Add | null (function return values can be nil)
+// - Other contexts (like type arguments): Don't add | null
+func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature, context GoTypeContext) {
 	c.tsw.WriteLiterally("(")
 	c.tsw.WriteLiterally("(")
 	params := t.Params()
@@ -492,7 +522,15 @@ func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
 		}
 		c.tsw.WriteLiterally("]")
 	}
-	c.tsw.WriteLiterally(") | null")
+	c.tsw.WriteLiterally(")")
+
+	// In Go, function values (not pointers to functions) can be nil.
+	// Add | null for general contexts and function return contexts.
+	// Don't add | null for other contexts like type arguments to avoid
+	// issues with generic types like atomic.Pointer[func()].
+	if context == GoTypeContextGeneral || context == GoTypeContextFunctionReturn {
+		c.tsw.WriteLiterally(" | null")
+	}
 }
 
 // writeInterfaceStructure translates a Go `types.Interface` into its TypeScript structural representation.
@@ -680,7 +718,7 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 func (c *GoToTSCompiler) getTypeString(goType types.Type) string {
 	var typeStr strings.Builder
 	writer := NewTSCodeWriter(&typeStr)
-	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis)
+	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis, c.currentFilePath)
 	tempCompiler.WriteGoType(goType, GoTypeContextGeneral)
 	return typeStr.String()
 }
@@ -692,7 +730,7 @@ func (c *GoToTSCompiler) getTypeString(goType types.Type) string {
 func (c *GoToTSCompiler) getASTTypeString(astType ast.Expr, goType types.Type) string {
 	var typeStr strings.Builder
 	writer := NewTSCodeWriter(&typeStr)
-	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis)
+	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis, c.currentFilePath)
 
 	if astType != nil {
 		// Use AST-based type writing to preserve qualified names

package/dist/gs/builtin/builtin.d.ts

@@ -8,7 +8,14 @@ export declare function println(...args: any[]): void;
  * Implementation of Go's built-in panic function
  * @param args Arguments passed to panic
  */
-export declare function panic(...args: any[]): void;
+export declare function panic(...args: any[]): never;
+/**
+ * Implementation of Go's built-in clear function.
+ * For slices, it sets all elements to their zero value.
+ * For maps, it deletes all entries.
+ * @param v The slice or map to clear
+ */
+export declare function clear<T>(v: T[] | Map<unknown, unknown> | null): void;
 export type Bytes = Uint8Array | Slice<number>;
 export declare function int(value: number): number;
 /**

package/dist/gs/builtin/builtin.js

@@ -4,7 +4,13 @@ import { isSliceProxy } from './slice.js';
  * @param args Arguments to print
  */
 export function println(...args) {
-    console.log(...args);
+    if (args.length === 0) {
+        // Bun's console.log() with no args doesn't print a newline, so we explicitly print an empty string
+        console.log('');
+    }
+    else {
+        console.log(...args);
+    }
 }
 /**
  * Implementation of Go's built-in panic function
@@ -13,6 +19,25 @@ export function println(...args) {
 export function panic(...args) {
     throw new Error(`panic: ${args.map((arg) => String(arg)).join(' ')}`);
 }
+/**
+ * Implementation of Go's built-in clear function.
+ * For slices, it sets all elements to their zero value.
+ * For maps, it deletes all entries.
+ * @param v The slice or map to clear
+ */
+export function clear(v) {
+    if (v === null || v === undefined) {
+        return;
+    }
+    if (v instanceof Map) {
+        v.clear();
+        return;
+    }
+    if (Array.isArray(v)) {
+        v.fill(null);
+        return;
+    }
+}
 // int converts a value to a Go int type, handling proper signed integer conversion
 // This ensures that values like 2147483648 (2^31) are properly handled according to Go semantics
 export function int(value) {