goscript 0.0.61 → 0.0.63

package/compiler/analysis_test.go

@@ -12,7 +12,7 @@ import (
 )
 
 // TestAnalysisVarRefLogic verifies that the analysis correctly identifies
-// which variables need variable references based on actual compliance test cases
+// which variables need variable references based on actual tests test cases
 func TestAnalysisVarRefLogic(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -235,8 +235,8 @@ func main() {
 
 // TestWrapperTypeDetection verifies that the analysis correctly identifies wrapper types
 func TestWrapperTypeDetection(t *testing.T) {
-	// Use the actual compliance test case
-	testPath := "../compliance/tests/wrapper_type_args"
+	// Use the actual tests test case
+	testPath := "../tests/tests/wrapper_type_args"
 
 	// Load the package using the packages config like the main compiler does
 	cfg := &packages.Config{

package/compiler/assignment.go

@@ -148,9 +148,32 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		}
 	}
 
+	// Check for integer division compound assignment (i /= n)
+	// Go's integer division truncates, but JavaScript's /= doesn't
+	// We need to convert `i /= n` to `i = Math.trunc(i / n)`
+	isIntegerDivisionAssign := false
+	if tok == token.QUO_ASSIGN && len(lhs) == 1 && len(rhs) == 1 {
+		if lhsType := c.pkg.TypesInfo.TypeOf(lhs[0]); lhsType != nil {
+			if basic, ok := lhsType.Underlying().(*types.Basic); ok {
+				if basic.Info()&types.IsInteger != 0 {
+					isIntegerDivisionAssign = true
+				}
+			}
+		}
+	}
+
 	// Only write the assignment operator for regular variables, not for map assignments handled by mapSet
 	if isMapIndexLHS && len(lhs) == 1 { // Only skip operator if it's a single map assignment
 		// Continue, we've already written part of the mapSet() function call
+	} else if isIntegerDivisionAssign {
+		// For integer division compound assignment, convert `i /= n` to `i = Math.trunc(i / n)`
+		c.tsw.WriteLiterally(" = Math.trunc(")
+		// Write LHS again as first operand of division
+		if err := c.WriteValueExpr(lhs[0]); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(" / ")
+		// RHS will be written below, then we close the parenthesis
 	} else {
 		c.tsw.WriteLiterally(" ")
 		if err := c.writeAssignmentOperator(tok); err != nil {
@@ -219,6 +242,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 +268,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 +305,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
 			}
@@ -281,6 +321,11 @@ func (c *GoToTSCompiler) writeAssignmentCore(lhs, rhs []ast.Expr, tok token.Toke
 		c.tsw.WriteLiterally(")")
 	}
 
+	// Close the parenthesis for integer division compound assignment
+	if isIntegerDivisionAssign {
+		c.tsw.WriteLiterally(")")
+	}
+
 	// If the LHS was a single map index, close the mapSet call
 	if isMapIndexLHS && len(lhs) == 1 {
 		c.tsw.WriteLiterally(")")
@@ -288,6 +333,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/builtin_test.go

@@ -24,7 +24,7 @@ func TestEmitBuiltinOption(t *testing.T) {
 	log.SetLevel(logrus.DebugLevel)
 	le := logrus.NewEntry(log)
 
-	// Case 1: DisableEmitBuiltin = true (default behavior in compliance tests)
+	// Case 1: DisableEmitBuiltin = true (default behavior in tests tests)
 	t.Run("DisableEmitBuiltin=true", func(t *testing.T) {
 		outputDir := filepath.Join(tempDir, "disabled")
 		config := &Config{

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 {
@@ -594,7 +593,7 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 	c.codeWriter = NewTSCodeWriter(of)
 
 	// Pass analysis to compiler
-	goWriter := NewGoToTSCompiler(c.codeWriter, c.pkg, c.Analysis)
+	goWriter := NewGoToTSCompiler(c.codeWriter, c.pkg, c.Analysis, c.fullPath)
 
 	// Add import for the goscript runtime using namespace import and alias
 	c.codeWriter.WriteLinef("import * as $ from %q", "@goscript/builtin/index.js")
@@ -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,46 @@ 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)
+	// Use per-file synthetic imports to avoid adding unused imports
+	if syntheticImports := c.Analysis.SyntheticImportsPerFile[c.fullPath]; syntheticImports != nil {
+		// Sort by package name for consistent output
+		var syntheticPkgNames []string
+		for pkgName := range syntheticImports {
+			syntheticPkgNames = append(syntheticPkgNames, pkgName)
+		}
+		slices.Sort(syntheticPkgNames)
+		for _, pkgName := range syntheticPkgNames {
+			imp := 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 {
@@ -695,18 +734,27 @@ type GoToTSCompiler struct {
 
 	analysis *Analysis
 
+	// currentFilePath is the path of the file being compiled
+	// Used for looking up per-file synthetic imports
+	currentFilePath string
+
 	// 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,
-// Go package information (`packages.Package`), and pre-computed
-// analysis results (`Analysis`) to guide the translation process.
-func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analysis) *GoToTSCompiler {
+// NewGoToTSCompiler creates a new GoToTSCompiler with a TSCodeWriter for output,
+// Go package information, pre-computed analysis results, and the current file path.
+func NewGoToTSCompiler(tsw *TSCodeWriter, pkg *packages.Package, analysis *Analysis, filePath string) *GoToTSCompiler {
 	return &GoToTSCompiler{
-		tsw:      tsw,
-		pkg:      pkg,
-		analysis: analysis,
+		tsw:             tsw,
+		pkg:             pkg,
+		analysis:        analysis,
+		currentFilePath: filePath,
+		renamedVars:     make(map[types.Object]string),
 	}
 }
 
@@ -785,6 +833,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/compiler_test.go

@@ -12,10 +12,10 @@ import (
 	"sync/atomic"
 	"testing"
 
-	"github.com/aperturerobotics/goscript/compliance"
+	"github.com/aperturerobotics/goscript/tests"
 )
 
-// NOTE: this is here instead of compliance/compliance_test.go so coverage ends up in this package.
+// NOTE: this is here instead of tests/tests_test.go so coverage ends up in this package.
 
 func TestCompliance(t *testing.T) {
 	// Get workspace directory (project root)
@@ -26,7 +26,7 @@ func TestCompliance(t *testing.T) {
 	workspaceDir = filepath.Join(workspaceDir, "..")
 
 	// First collect all test paths
-	testsDir := filepath.Join(workspaceDir, "compliance/tests")
+	testsDir := filepath.Join(workspaceDir, "tests/tests")
 	dirs, err := os.ReadDir(testsDir)
 	if err != nil {
 		t.Fatalf("failed to read tests dir: %v", err)
@@ -50,7 +50,7 @@ func TestCompliance(t *testing.T) {
 	slices.Sort(testPaths)
 
 	// limit concurrency
-	simulLimit := make(chan struct{}, runtime.GOMAXPROCS(-1)*2)
+	simulLimit := make(chan struct{}, runtime.GOMAXPROCS(-1))
 	for range cap(simulLimit) {
 		simulLimit <- struct{}{}
 	}
@@ -71,7 +71,7 @@ func TestCompliance(t *testing.T) {
 				defer func() {
 					simulLimit <- struct{}{}
 				}()
-				compliance.RunGoScriptTestDir(t, workspaceDir, path) // Pass workspaceDir
+				tests.RunGoScriptTestDir(t, workspaceDir, path) // Pass workspaceDir
 
 				// Remove dir if everything passed
 				if !t.Failed() {
@@ -89,13 +89,13 @@ func TestCompliance(t *testing.T) {
 	t.Run("typecheck", func(t *testing.T) {
 		t.Helper()
 		if failed {
-			t.Log("at least one compliance test failed: skipping typecheck")
+			t.Log("at least one tests test failed: skipping typecheck")
 			t.SkipNow()
 		}
 
 		// NOTE: typecheck does not yet pass, so we skip for now.
 		if ranTests.Load() != 0 {
-			t.Log("at least one compliance test ran: skipping typecheck")
+			t.Log("at least one tests test ran: skipping typecheck")
 			t.SkipNow()
 		}
 
@@ -106,7 +106,7 @@ func TestCompliance(t *testing.T) {
 		}
 
 		// Create global typecheck tsconfig
-		tsconfigPath := compliance.WriteGlobalTypeCheckConfig(t, parentModPath, workspaceDir)
+		tsconfigPath := tests.WriteGlobalTypeCheckConfig(t, parentModPath, workspaceDir)
 
 		// Run TypeScript type checking
 		typecheckDir := filepath.Dir(tsconfigPath)
@@ -129,7 +129,7 @@ func TestCompliance(t *testing.T) {
 }
 
 // getParentGoModulePath is a helper function to get the parent Go module path
-// This is similar to the one in compliance.go but simplified for use in tests
+// This is similar to the one in tests.go but simplified for use in tests
 func getParentGoModulePath() (string, error) {
 	cmd := exec.Command("go", "list", "-m")
 	output, err := cmd.Output()

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("!")
 			}