goscript 0.0.60 → 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 {
@@ -844,7 +897,7 @@ func (c *GoToTSCompiler) WriteCaseClause(exp *ast.CaseClause) error {
 	if exp.List == nil {
 		// Default case
 		c.tsw.WriteLiterally("default:")
-		c.tsw.WriteLine("")
+		c.tsw.WriteLine(" {")
 	} else {
 		// Case with expressions
 		// For Go's `case expr1, expr2:`, we translate to:
@@ -852,18 +905,23 @@ func (c *GoToTSCompiler) WriteCaseClause(exp *ast.CaseClause) error {
 		// case expr2:
 		// ... body ...
 		// break
-		for _, caseExpr := range exp.List {
+		for i, caseExpr := range exp.List {
 			c.tsw.WriteLiterally("case ")
 			if err := c.WriteValueExpr(caseExpr); err != nil {
 				return fmt.Errorf("failed to write case clause expression: %w", err)
 			}
 			c.tsw.WriteLiterally(":")
-			c.tsw.WriteLine("")
+			// Only add opening brace after the last case label
+			if i == len(exp.List)-1 {
+				c.tsw.WriteLine(" {")
+			} else {
+				c.tsw.WriteLine("")
+			}
 		}
 	}
 
 	// The body is written once, after all case labels for this clause.
-	// Indentation for the body starts here.
+	// Wrap in block to provide Go-like case scope semantics.
 	c.tsw.Indent(1)
 	for _, stmt := range exp.Body {
 		if err := c.WriteStmt(stmt); err != nil {
@@ -873,6 +931,7 @@ func (c *GoToTSCompiler) WriteCaseClause(exp *ast.CaseClause) error {
 	// Add break statement (Go's switch has implicit breaks, TS needs explicit break)
 	c.tsw.WriteLine("break")
 	c.tsw.Indent(-1)
+	c.tsw.WriteLine("}")
 	return nil
 }
 

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
 }
 
@@ -252,122 +252,82 @@ func (c *GoToTSCompiler) extractStructFieldDependencies(fieldType ast.Expr, type
 	return deps
 }
 
-// sortVarSpecsByTypeDependencies sorts variable declarations based on their type dependencies
+// sortVarSpecsByTypeDependencies sorts variable declarations based on their value dependencies
+// to ensure that variables are initialized in the correct order (respecting JavaScript's TDZ).
+// For example: var StdEncoding = NewEncoding(...) must come before var RawStdEncoding = StdEncoding.WithPadding(...)
 func (c *GoToTSCompiler) sortVarSpecsByTypeDependencies(varSpecs []*ast.ValueSpec, typeSpecs []*ast.TypeSpec) ([]*ast.ValueSpec, error) {
 	if len(varSpecs) <= 1 {
 		return varSpecs, nil
 	}
 
-	// Build type name map
-	typeSpecMap := make(map[string]*ast.TypeSpec)
-	for _, typeSpec := range typeSpecs {
-		typeSpecMap[typeSpec.Name.Name] = typeSpec
-	}
-
-	// Group variables by dependency status with names for sorting
-	type namedVarSpec struct {
-		spec *ast.ValueSpec
-		name string
-	}
-
-	var independentVars []namedVarSpec
-	var dependentVars []namedVarSpec
-
+	// Build a map of variable names to their specs
+	varSpecMap := make(map[string]*ast.ValueSpec)
+	varNames := []string{}
 	for _, varSpec := range varSpecs {
-		// Get variable name for sorting
-		varName := ""
 		if len(varSpec.Names) > 0 {
-			varName = varSpec.Names[0].Name
+			name := varSpec.Names[0].Name
+			varSpecMap[name] = varSpec
+			varNames = append(varNames, name)
 		}
+	}
 
-		hasDependency := false
-
-		// Check type annotation
-		if varSpec.Type != nil {
-			deps := c.extractTypeDependencies(varSpec.Type, typeSpecMap)
-			if len(deps) > 0 {
-				hasDependency = true
-			}
-		}
+	// Build dependency graph: varName -> list of variables it depends on
+	dependencies := make(map[string][]string)
+	for _, name := range varNames {
+		dependencies[name] = []string{}
+	}
 
-		// Check initializer expressions for type usage
-		if !hasDependency {
-			for _, value := range varSpec.Values {
-				if c.hasTypeReferences(value, typeSpecMap) {
-					hasDependency = true
-					break
-				}
-			}
+	// Extract value dependencies from initializer expressions
+	for _, varSpec := range varSpecs {
+		if len(varSpec.Names) == 0 {
+			continue
 		}
+		varName := varSpec.Names[0].Name
 
-		namedVar := namedVarSpec{spec: varSpec, name: varName}
-		if hasDependency {
-			dependentVars = append(dependentVars, namedVar)
-		} else {
-			independentVars = append(independentVars, namedVar)
+		// Check initializer expressions for variable references
+		for _, value := range varSpec.Values {
+			deps := c.extractVarDependencies(value, varSpecMap)
+			dependencies[varName] = append(dependencies[varName], deps...)
 		}
 	}
 
-	// Sort both groups by name for deterministic output
-	sort.Slice(independentVars, func(i, j int) bool {
-		return independentVars[i].name < independentVars[j].name
-	})
-	sort.Slice(dependentVars, func(i, j int) bool {
-		return dependentVars[i].name < dependentVars[j].name
-	})
+	// Perform topological sort
+	sorted, err := c.topologicalSort(dependencies)
+	if err != nil {
+		return nil, err
+	}
 
-	// Return independent variables first, then dependent ones
+	// Build result in sorted order
 	result := make([]*ast.ValueSpec, 0, len(varSpecs))
-	for _, namedVar := range independentVars {
-		result = append(result, namedVar.spec)
-	}
-	for _, namedVar := range dependentVars {
-		result = append(result, namedVar.spec)
+	for _, varName := range sorted {
+		if spec, exists := varSpecMap[varName]; exists {
+			result = append(result, spec)
+		}
 	}
 
 	return result, nil
 }
 
-// hasTypeReferences checks if an expression contains references to local types
-func (c *GoToTSCompiler) hasTypeReferences(expr ast.Expr, typeSpecMap map[string]*ast.TypeSpec) bool {
-	hasRef := false
+// extractVarDependencies extracts variable dependencies from an initializer expression.
+// It returns a list of variable names that the expression depends on.
+func (c *GoToTSCompiler) extractVarDependencies(expr ast.Expr, varSpecMap map[string]*ast.ValueSpec) []string {
+	var deps []string
+	seen := make(map[string]bool)
 
 	ast.Inspect(expr, func(n ast.Node) bool {
-		switch t := n.(type) {
-		case *ast.CallExpr:
-			// Check function calls like new Message(), makeChannel<Message>()
-			if ident, ok := t.Fun.(*ast.Ident); ok {
-				if _, isLocalType := typeSpecMap[ident.Name]; isLocalType {
-					hasRef = true
-					return false
+		if ident, ok := n.(*ast.Ident); ok {
+			// Check if this identifier refers to a package-level variable
+			if _, isVar := varSpecMap[ident.Name]; isVar {
+				if !seen[ident.Name] {
+					deps = append(deps, ident.Name)
+					seen[ident.Name] = true
 				}
 			}
-			// Check type arguments in generic calls
-			if funcType, ok := t.Fun.(*ast.IndexExpr); ok {
-				if c.hasTypeReferences(funcType.Index, typeSpecMap) {
-					hasRef = true
-					return false
-				}
-			}
-		case *ast.CompositeLit:
-			// Check composite literals like Message{...}
-			if ident, ok := t.Type.(*ast.Ident); ok {
-				if _, isLocalType := typeSpecMap[ident.Name]; isLocalType {
-					hasRef = true
-					return false
-				}
-			}
-		case *ast.Ident:
-			// Check direct type references
-			if _, isLocalType := typeSpecMap[t.Name]; isLocalType {
-				hasRef = true
-				return false
-			}
 		}
-		return !hasRef // Stop walking if we found a reference
+		return true
 	})
 
-	return hasRef
+	return deps
 }
 
 // topologicalSort performs a topological sort of the dependency graph
@@ -387,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 {
@@ -399,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
@@ -409,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
 
@@ -429,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...)
 	}
 
@@ -447,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)
 	}
@@ -662,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("!")
 			}