goscript 0.0.61 → 0.0.62

package/compiler/assignment.go

@@ -219,6 +219,15 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		if shouldApplyClone(c.pkg, r) {
 			// When cloning for value assignment, mark the result as struct value
 			c.tsw.WriteLiterally("$.markAsStructValue(")
+
+			// Check if RHS is an async call - if so, wrap in parentheses so .clone() binds correctly
+			// Example: (await asyncFunc()).clone() instead of await asyncFunc().clone()
+			needsParensForAsync := false
+			if callExpr, isCall := r.(*ast.CallExpr); isCall && c.isCallExprAsync(callExpr) {
+				needsParensForAsync = true
+				c.tsw.WriteLiterally("(")
+			}
+
 			// 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
@@ -236,6 +245,9 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 				}
 			}
 
+			if needsParensForAsync {
+				c.tsw.WriteLiterally(")")
+			}
 			c.tsw.WriteLiterally(".clone())") // Always add clone for struct values
 		} else {
 			// Check if this is a pointer variable assignment to an interface type
@@ -270,6 +282,11 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 			}
 
 			// Non-struct case: write RHS normally
+			// Check if this is a primitive error type being assigned to an error interface
+			if c.writePrimitiveErrorWrapperForAssign(lhs, r, i) {
+				continue
+			}
+
 			if err := c.WriteValueExpr(r); err != nil { // RHS is a non-struct value
 				return err
 			}
@@ -288,6 +305,61 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 	return nil
 }
 
+// writePrimitiveErrorWrapperForAssign checks if an RHS value is a primitive type
+// that implements the error interface being assigned to an error-typed LHS,
+// and if so, wraps it with $.wrapPrimitiveError.
+// Returns true if the wrapper was written, false otherwise.
+func (c *GoToTSCompiler) writePrimitiveErrorWrapperForAssign(lhs []ast.Expr, rhs ast.Expr, rhsIndex int) bool {
+	// Only handle single assignments for now
+	if len(lhs) != 1 || rhsIndex != 0 {
+		return false
+	}
+
+	// Get the LHS type
+	lhsType := c.pkg.TypesInfo.TypeOf(lhs[0])
+	if lhsType == nil {
+		return false
+	}
+
+	// Check if the LHS type is the error interface
+	if iface, ok := lhsType.Underlying().(*types.Interface); !ok || iface.String() != "interface{Error() string}" {
+		return false
+	}
+
+	// Get the actual type of the RHS expression
+	rhsType := c.pkg.TypesInfo.TypeOf(rhs)
+	if rhsType == nil {
+		return false
+	}
+
+	// Check if the RHS type is a wrapper type (named type with basic underlying type)
+	if !c.isWrapperType(rhsType) {
+		return false
+	}
+
+	// Check if the RHS type has an Error() method
+	if !c.typeHasMethods(rhsType, "Error") {
+		return false
+	}
+
+	// Get the qualified type name for the Error function
+	typeName := c.getQualifiedTypeName(rhsType)
+	if typeName == "" {
+		return false
+	}
+
+	// Write: $.wrapPrimitiveError(value, TypeName_Error)
+	c.tsw.WriteLiterally("$.wrapPrimitiveError(")
+	if err := c.WriteValueExpr(rhs); err != nil {
+		return false
+	}
+	c.tsw.WriteLiterally(", ")
+	c.tsw.WriteLiterally(typeName)
+	c.tsw.WriteLiterally("_Error)")
+
+	return true
+}
+
 // writeBlankIdentifierAssign handles assignment to blank identifier (_)
 func (c *GoToTSCompiler) writeBlankIdentifierAssign(rhs ast.Expr) error {
 	c.tsw.WriteLiterally("/* _ = */ ")

package/compiler/compiler.go

@@ -13,7 +13,6 @@ import (
 	"os"
 	"path/filepath"
 	"slices"
-	"sort"
 	"strings"
 
 	gs "github.com/aperturerobotics/goscript"
@@ -487,7 +486,7 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 
 		// Write exports if this file has exported symbols
 		if len(valueSymbols) > 0 {
-			sort.Strings(valueSymbols)
+			slices.Sort(valueSymbols)
 			exportLine := fmt.Sprintf("export { %s } from \"./%s.js\"\n",
 				strings.Join(valueSymbols, ", "), fileName)
 			if _, err := indexFile.WriteString(exportLine); err != nil {
@@ -497,7 +496,7 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 
 		// Write struct exports (both as types and values)
 		if len(structSymbols) > 0 {
-			sort.Strings(structSymbols)
+			slices.Sort(structSymbols)
 			// Export classes as values (which makes them available as both types and values in TypeScript)
 			exportLine := fmt.Sprintf("export { %s } from \"./%s.js\"\n",
 				strings.Join(structSymbols, ", "), fileName)
@@ -507,7 +506,7 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 		}
 
 		if len(typeSymbols) > 0 {
-			sort.Strings(typeSymbols)
+			slices.Sort(typeSymbols)
 			exportLine := fmt.Sprintf("export type { %s } from \"./%s.js\"\n",
 				strings.Join(typeSymbols, ", "), fileName)
 			if _, err := indexFile.WriteString(exportLine); err != nil {
@@ -612,7 +611,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 		for sourceFile := range imports {
 			sourceFiles = append(sourceFiles, sourceFile)
 		}
-		sort.Strings(sourceFiles)
+		slices.Sort(sourceFiles)
 
 		for _, sourceFile := range sourceFiles {
 			functions := imports[sourceFile]
@@ -623,7 +622,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 					sanitizedFunctions = append(sanitizedFunctions, sanitizeIdentifier(fn))
 				}
 				// Sort functions for consistent output
-				sort.Strings(sanitizedFunctions)
+				slices.Sort(sanitizedFunctions)
 				c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
 					strings.Join(sanitizedFunctions, ", "), sourceFile)
 			}
@@ -637,7 +636,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 		for sourceFile := range typeImports {
 			sourceFiles = append(sourceFiles, sourceFile)
 		}
-		sort.Strings(sourceFiles)
+		slices.Sort(sourceFiles)
 
 		for _, sourceFile := range sourceFiles {
 			typeImports := typeImports[sourceFile]
@@ -668,7 +667,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 						sanitizedTypes = append(sanitizedTypes, sanitizeIdentifier(typeName))
 					}
 					// Sort types for consistent output
-					sort.Strings(sanitizedTypes)
+					slices.Sort(sanitizedTypes)
 					c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
 						strings.Join(sanitizedTypes, ", "), sourceFile)
 				}
@@ -676,6 +675,43 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 		}
 	}
 
+	// Generate auto-imports for variables from other files in the same package
+	if varImports := c.PackageAnalysis.VariableCalls[currentFileName]; varImports != nil {
+		// Sort source files for consistent import order
+		var sourceFiles []string
+		for sourceFile := range varImports {
+			sourceFiles = append(sourceFiles, sourceFile)
+		}
+		slices.Sort(sourceFiles)
+
+		for _, sourceFile := range sourceFiles {
+			variables := varImports[sourceFile]
+			if len(variables) > 0 {
+				// Apply sanitization to variable names
+				var sanitizedVariables []string
+				for _, varName := range variables {
+					sanitizedVariables = append(sanitizedVariables, sanitizeIdentifier(varName))
+				}
+				// Sort variables for consistent output
+				slices.Sort(sanitizedVariables)
+				c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
+					strings.Join(sanitizedVariables, ", "), sourceFile)
+			}
+		}
+	}
+
+	// Write synthetic imports (for promoted methods from embedded structs)
+	// Sort by package name for consistent output
+	var syntheticPkgNames []string
+	for pkgName := range c.Analysis.SyntheticImports {
+		syntheticPkgNames = append(syntheticPkgNames, pkgName)
+	}
+	slices.Sort(syntheticPkgNames)
+	for _, pkgName := range syntheticPkgNames {
+		imp := c.Analysis.SyntheticImports[pkgName]
+		c.codeWriter.WriteImport(pkgName, imp.importPath+"/index.js")
+	}
+
 	c.codeWriter.WriteLine("") // Add a newline after imports
 
 	if err := goWriter.WriteDecls(f.Decls); err != nil {
@@ -697,6 +733,10 @@ type GoToTSCompiler struct {
 
 	// Context flags
 	insideAddressOf bool // true when processing operand of & operator
+
+	// renamedVars tracks variables that have been renamed to avoid type shadowing
+	// Key: types.Object of the original variable, Value: new name to use
+	renamedVars map[types.Object]string
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,
@@ -704,9 +744,10 @@ type GoToTSCompiler struct {
 // analysis results (`Analysis`) to guide the translation process.
 func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analysis) *GoToTSCompiler {
 	return &GoToTSCompiler{
-		tsw:      tsw,
-		pkg:      pkg,
-		analysis: analysis,
+		tsw:         tsw,
+		pkg:         pkg,
+		analysis:    analysis,
+		renamedVars: make(map[types.Object]string),
 	}
 }
 
@@ -785,6 +826,18 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 	// Use TypesInfo to find the object associated with the identifier
 	obj := c.objectOfIdent(exp)
 
+	// Check if this variable has been renamed to avoid type shadowing
+	if obj != nil {
+		if renamedName, ok := c.renamedVars[obj]; ok {
+			c.tsw.WriteLiterally(c.sanitizeIdentifier(renamedName))
+			// Determine if we need to access .value based on analysis data
+			if accessVarRefedValue && c.analysis.NeedsVarRefAccess(obj) {
+				c.tsw.WriteLiterally("!.value")
+			}
+			return
+		}
+	}
+
 	// Check if this identifier refers to a constant
 	if obj != nil {
 		if constObj, isConst := obj.(*types.Const); isConst {

package/compiler/composite-lit.go

@@ -341,7 +341,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 		case *types.Map, *types.Struct:
 			// Handle struct directly with the struct literal logic
 			if structType, ok := underlying.(*types.Struct); ok {
-				return c.writeUntypedStructLiteral(exp, structType) // true = anonymous
+				return c.writeUntypedStructLiteral(exp, tv.Type, structType)
 			}
 			// Map case would be handled here
 			return fmt.Errorf("untyped map composite literals not yet supported")
@@ -356,7 +356,7 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 				// This is an anonymous struct literal with inferred pointer type
 				// Just create the struct object directly - no var-refing needed
 				// Anonymous literals are not variables, so they don't get var-refed
-				return c.writeUntypedStructLiteral(exp, elemType) // true = anonymous
+				return c.writeUntypedStructLiteral(exp, ptrType.Elem(), elemType)
 			default:
 				return fmt.Errorf("unhandled pointer composite literal element type: %T", elemType)
 			}
@@ -384,7 +384,7 @@ func (c *GoToTSCompiler) writeUntypedArrayLiteral(exp *ast.CompositeLit) error {
 }
 
 // writeUntypedStructLiteral handles untyped composite literals that are structs or pointers to structs
-func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, structType *types.Struct) error {
+func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, actualType types.Type, structType *types.Struct) error {
 	// Create field mapping like the typed struct case
 	directFields := make(map[string]ast.Expr)
 
@@ -408,8 +408,23 @@ func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, struct
 		}
 	}
 
-	// Write the object literal (always anonymous for untyped)
-	c.tsw.WriteLiterally("{")
+	// Check if this is a named type
+	isNamed := false
+	if _, ok := actualType.(*types.Named); ok {
+		isNamed = true
+	}
+
+	// Write the object literal
+	if isNamed {
+		// For named structs, use constructor
+		c.tsw.WriteLiterally("$.markAsStructValue(new ")
+		// Write the type name
+		c.WriteGoType(actualType, GoTypeContextGeneral)
+		c.tsw.WriteLiterally("({")
+	} else {
+		// For truly anonymous structs, just write a simple object literal
+		c.tsw.WriteLiterally("{")
+	}
 
 	firstFieldWritten := false
 	// Write fields in order
@@ -434,7 +449,12 @@ func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, struct
 		firstFieldWritten = true
 	}
 
-	c.tsw.WriteLiterally("}")
+	// Close the object literal
+	if isNamed {
+		c.tsw.WriteLiterally("}))")
+	} else {
+		c.tsw.WriteLiterally("}")
+	}
 	return nil
 }
 
@@ -606,9 +626,10 @@ func (c *GoToTSCompiler) categorizeStructFields(
 		}
 	}
 
-	// Handle the case where an anonymous struct has values without keys
+	// Handle the case where a struct has values without keys (positional initialization)
 	// This block processes non-key-value elements and associates them with struct fields.
-	if isAnonymousStruct && len(exp.Elts) > 0 && len(directFields) == 0 {
+	// This applies to both named and anonymous structs.
+	if len(exp.Elts) > 0 && len(directFields) == 0 {
 		// Check if any elements in the composite literal are not key-value pairs.
 		hasNonKeyValueElts := false
 		for _, elt := range exp.Elts {

package/compiler/decl.go

@@ -5,7 +5,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
-	"sort"
+	"slices"
 )
 
 // WriteDecls iterates through a slice of Go top-level declarations (`ast.Decl`)
@@ -210,7 +210,7 @@ func (c *GoToTSCompiler) extractTypeDependencies(typeExpr ast.Expr, typeSpecMap
 	}
 
 	// Sort dependencies for deterministic output
-	sort.Strings(deps)
+	slices.Sort(deps)
 	return deps
 }
 
@@ -347,7 +347,7 @@ func (c *GoToTSCompiler) topologicalSort(dependencies map[string][]string) ([]st
 		// Sort dependencies for consistent output
 		sortedDeps := make([]string, len(deps))
 		copy(sortedDeps, deps)
-		sort.Strings(sortedDeps)
+		slices.Sort(sortedDeps)
 
 		for _, dep := range sortedDeps {
 			if _, exists := inDegree[dep]; exists {
@@ -359,7 +359,7 @@ func (c *GoToTSCompiler) topologicalSort(dependencies map[string][]string) ([]st
 
 	// Sort neighbors in graph for consistency
 	for node := range graph {
-		sort.Strings(graph[node])
+		slices.Sort(graph[node])
 	}
 
 	// Find nodes with no incoming edges and sort them
@@ -369,7 +369,7 @@ func (c *GoToTSCompiler) topologicalSort(dependencies map[string][]string) ([]st
 			queue = append(queue, node)
 		}
 	}
-	sort.Strings(queue) // Sort initial queue for deterministic output
+	slices.Sort(queue) // Sort initial queue for deterministic output
 
 	var result []string
 
@@ -389,7 +389,7 @@ func (c *GoToTSCompiler) topologicalSort(dependencies map[string][]string) ([]st
 		}
 
 		// Sort new zero-degree nodes and add to queue
-		sort.Strings(newZeroNodes)
+		slices.Sort(newZeroNodes)
 		queue = append(queue, newZeroNodes...)
 	}
 
@@ -407,7 +407,7 @@ func (c *GoToTSCompiler) topologicalSort(dependencies map[string][]string) ([]st
 				remaining = append(remaining, name)
 			}
 		}
-		sort.Strings(remaining)
+		slices.Sort(remaining)
 
 		return nil, fmt.Errorf("circular dependency detected in type declarations. Remaining types: %v", remaining)
 	}
@@ -622,11 +622,20 @@ func (c *GoToTSCompiler) writeMethodSignature(decl *ast.FuncDecl) (bool, error)
 		} else {
 			// Multiple return values -> tuple type
 			c.tsw.WriteLiterally("[")
-			for i, field := range funcType.Results.List {
-				if i > 0 {
-					c.tsw.WriteLiterally(", ")
+			first := true
+			for _, field := range funcType.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
+					c.WriteTypeExpr(field.Type)
 				}
-				c.WriteTypeExpr(field.Type)
 			}
 			c.tsw.WriteLiterally("]")
 		}

package/compiler/expr-call-async.go

@@ -12,7 +12,15 @@ func (c *GoToTSCompiler) isCallExprAsync(exp *ast.CallExpr) bool {
 	case *ast.Ident:
 		// Function call (e.g., func())
 		if obj := c.objectOfIdent(fun); obj != nil {
-			return c.analysis.IsAsyncFunc(obj)
+			// Check if this is a known async function
+			if c.analysis.IsAsyncFunc(obj) {
+				return true
+			}
+			// Check if this is a variable that returns async values
+			// (e.g., indirect := sync.OnceValue(asyncFunc))
+			if c.analysis.IsAsyncReturningVar(obj) {
+				return true
+			}
 		}
 		return false
 
@@ -42,6 +50,13 @@ func (c *GoToTSCompiler) isCallExprAsync(exp *ast.CallExpr) bool {
 				objOk = true
 			}
 
+		case *ast.CallExpr:
+			// Method call on function result: funcCall().method()
+			// Get the type of the function call result
+			if callType := c.pkg.TypesInfo.TypeOf(x); callType != nil {
+				objOk = true
+			}
+
 		default:
 			objOk = false
 		}
@@ -144,6 +159,16 @@ func (c *GoToTSCompiler) addNonNullAssertion(expFun ast.Expr) {
 						c.tsw.WriteLiterally("!")
 					}
 				}
+			} else if selectorExpr, isSelectorExpr := expFun.(*ast.SelectorExpr); isSelectorExpr {
+				// Check if this is a field access that returns a function type
+				// e.g., s.step where step is a function-typed field
+				if selection := c.pkg.TypesInfo.Selections[selectorExpr]; selection != nil {
+					// This is a field or method selection
+					if selection.Kind() == types.FieldVal {
+						// It's a field - function-typed fields may be nil
+						c.tsw.WriteLiterally("!")
+					}
+				}
 			} else if _, isNamed := funType.(*types.Named); isNamed {
 				c.tsw.WriteLiterally("!")
 			}

package/compiler/expr-call-builtins.go

@@ -25,6 +25,9 @@ var builtinFunctions = map[string]bool{
 	"recover": true,
 	"print":   true,
 	"println": true,
+	"min":     true,
+	"max":     true,
+	"clear":   true,
 }
 
 // writeBuiltinFunction handles built-in Go functions
@@ -34,7 +37,7 @@ func (c *GoToTSCompiler) writeBuiltinFunction(exp *ast.CallExpr, funName string)
 		c.tsw.WriteLiterally("$.panic")
 		return true, nil
 	case "println":
-		c.tsw.WriteLiterally("console.log")
+		c.tsw.WriteLiterally("$.println")
 		return true, nil
 	case "len":
 		if len(exp.Args) != 1 {
@@ -89,6 +92,46 @@ func (c *GoToTSCompiler) writeBuiltinFunction(exp *ast.CallExpr, funName string)
 		return true, nil
 	case "append":
 		return true, c.writeAppendCall(exp)
+	case "min":
+		if len(exp.Args) < 1 {
+			return true, errors.New("unhandled min call with no arguments")
+		}
+		c.tsw.WriteLiterally("Math.min(")
+		for i, arg := range exp.Args {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return true, fmt.Errorf("failed to write argument %d in min call: %w", i, err)
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		return true, nil
+	case "max":
+		if len(exp.Args) < 1 {
+			return true, errors.New("unhandled max call with no arguments")
+		}
+		c.tsw.WriteLiterally("Math.max(")
+		for i, arg := range exp.Args {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return true, fmt.Errorf("failed to write argument %d in max call: %w", i, err)
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		return true, nil
+	case "clear":
+		if len(exp.Args) != 1 {
+			return true, errors.Errorf("unhandled clear call with incorrect number of arguments: %d != 1", len(exp.Args))
+		}
+		c.tsw.WriteLiterally("$.clear(")
+		if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+			return true, fmt.Errorf("failed to write argument in clear call: %w", err)
+		}
+		c.tsw.WriteLiterally(")")
+		return true, nil
 	case "byte":
 		if len(exp.Args) != 1 {
 			return true, errors.Errorf("unhandled byte call with incorrect number of arguments: %d != 1", len(exp.Args))
@@ -119,13 +162,16 @@ func (c *GoToTSCompiler) writeAppendCall(exp *ast.CallExpr) error {
 	}
 
 	// The remaining arguments are the elements to append
-	for i, arg := range exp.Args[1:] {
+	elemsToAppend := exp.Args[1:]
+	for i, arg := range elemsToAppend {
 		if i > 0 || len(exp.Args) > 1 {
 			c.tsw.WriteLiterally(", ")
 		}
 
-		// Special case: append([]byte, string...) should convert string to bytes
-		if exp.Ellipsis != token.NoPos && i == 0 { // This is the first element after slice and has ellipsis
+		// Handle ellipsis (spread) for the last argument: append(slice, elems...)
+		// The ellipsis can only appear on the last argument, so check if this is the last element
+		isLastElement := i == len(elemsToAppend)-1
+		if exp.Ellipsis != token.NoPos && isLastElement {
 			// Check if the slice is []byte and the argument is a string
 			sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
 			argType := c.pkg.TypesInfo.TypeOf(arg)
@@ -141,6 +187,16 @@ func (c *GoToTSCompiler) writeAppendCall(exp *ast.CallExpr) error {
 					continue
 				}
 			}
+
+			// For other slice types with ellipsis, use spread operator
+			// append(slice, anotherSlice...) -> $.append(slice, ...(anotherSlice || []))
+			// The || [] handles the case where anotherSlice is null (nil in Go)
+			c.tsw.WriteLiterally("...(")
+			if err := c.WriteValueExpr(arg); err != nil {
+				return fmt.Errorf("failed to write spread argument in append call: %w", err)
+			}
+			c.tsw.WriteLiterally(" || [])")
+			continue
 		}
 
 		if err := c.WriteValueExpr(arg); err != nil {

package/compiler/expr-call-type-conversion.go

@@ -18,14 +18,33 @@ func (c *GoToTSCompiler) writeNilConversion(exp *ast.CallExpr) (handled bool, er
 		return false, nil
 	}
 
-	// Handle nil pointer to struct type conversions: (*struct{})(nil)
-	if starExpr, isStarExpr := exp.Fun.(*ast.StarExpr); isStarExpr {
-		if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
-			c.tsw.WriteLiterally("null")
+	// Check if this is actually a type conversion, not a method/function call
+	// For type conversions, exp.Fun is a type expression (IsType() is true)
+	// For method calls like s.ptr.Swap(nil), exp.Fun is a selector expression (IsType() is false)
+	if tv, ok := c.pkg.TypesInfo.Types[exp.Fun]; !ok || !tv.IsType() {
+		// This is not a type conversion, let the normal call handling proceed
+		return false, nil
+	}
+
+	// Get the type being converted to
+	if typ := c.pkg.TypesInfo.TypeOf(exp.Fun); typ != nil {
+		// For pointer types, create a typed nil that preserves type information
+		if ptrType, ok := typ.(*types.Pointer); ok {
+			// Use a qualifier that returns the package name for local types
+			// This matches Go's reflect output format (e.g., "main.Stringer")
+			qualifier := func(pkg *types.Package) string {
+				if pkg == nil {
+					return ""
+				}
+				return pkg.Name()
+			}
+			typeName := types.TypeString(ptrType, qualifier)
+			c.tsw.WriteLiterallyf("$.typedNil(%q)", typeName)
 			return true, nil
 		}
 	}
 
+	// For non-pointer types (or if type info is unavailable), use plain null
 	c.tsw.WriteLiterally("null")
 	return true, nil
 }
@@ -141,8 +160,21 @@ func (c *GoToTSCompiler) writeStringConversion(exp *ast.CallExpr) error {
 
 	// Handle direct string(int32) conversion
 	if tv, ok := c.pkg.TypesInfo.Types[arg]; ok {
-		// Case 3a: Argument is already a string - no-op
+		// Case 3a: Argument is already a string - no-op (unless it's a named type with toString)
 		if c.isStringType(tv.Type) {
+			// Check if this is a named type from the reflect package (like StructTag)
+			// which is implemented as a class in TypeScript with a toString() method
+			if namedType, isNamed := tv.Type.(*types.Named); isNamed {
+				obj := namedType.Obj()
+				if obj != nil && obj.Pkg() != nil && obj.Pkg().Path() == "reflect" && obj.Name() == "StructTag" {
+					// Call toString() for reflect.StructTag
+					if err := c.WriteValueExpr(arg); err != nil {
+						return fmt.Errorf("failed to write argument for string(reflect.StructTag) conversion: %w", err)
+					}
+					c.tsw.WriteLiterally(".toString()")
+					return nil
+				}
+			}
 			// Translate string(stringValue) to stringValue (no-op)
 			if err := c.WriteValueExpr(arg); err != nil {
 				return fmt.Errorf("failed to write argument for string(string) no-op conversion: %w", err)

package/compiler/expr-call.go

@@ -61,7 +61,8 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			// For built-ins that don't return early, write the arguments
 			if funIdent.String() != "new" && funIdent.String() != "close" && funIdent.String() != "make" &&
 				funIdent.String() != "string" && funIdent.String() != "append" && funIdent.String() != "byte" &&
-				funIdent.String() != "int" {
+				funIdent.String() != "int" && funIdent.String() != "min" && funIdent.String() != "max" &&
+				funIdent.String() != "clear" {
 				return c.writeCallArguments(exp)
 			}
 			return nil
@@ -117,14 +118,26 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 		}
 		c.tsw.WriteLiterally(")")
 	} else {
+		// Check if this is a function call that returns a function (e.g., simpleIterator(m)())
+		// and if the inner call is async, wrap it in parentheses
+		innerCallExpr, isCallExpr := expFun.(*ast.CallExpr)
+		needsParens := isCallExpr && c.isCallExprAsync(innerCallExpr)
+
+		if needsParens {
+			c.tsw.WriteLiterally("(")
+		}
+
 		// Not an identifier (e.g., method call on a value, function call result)
 		if err := c.WriteValueExpr(expFun); err != nil {
 			return fmt.Errorf("failed to write method expression in call: %w", err)
 		}
 
-		// Check if this is a function call that returns a function (e.g., simpleIterator(m)())
+		if needsParens {
+			c.tsw.WriteLiterally(")")
+		}
+
 		// Add non-null assertion since the returned function could be null
-		if _, isCallExpr := expFun.(*ast.CallExpr); isCallExpr {
+		if isCallExpr {
 			c.tsw.WriteLiterally("!")
 		} else {
 			c.addNonNullAssertion(expFun)