fix: nested_async_method_-value and named_struct_underlying_methodset

Signed-off-by: Christian Stewart <christian@aperture.us>

Author: paralin

compiler/analysis.go

@@ -2756,23 +2756,25 @@ func (v *analysisVisitor) analyzeAllMethodsAsync() {
 	// Topologically sort methods by their dependencies
 	sorted, cycles := v.topologicalSortMethods(methodCalls)
 
-	// Mark methods in cycles - check if they contain async operations
-	// We can't rely on the call graph for methods in cycles (circular dependency),
-	// but we can still detect if they call async external methods
-	//
-	// We need to iterate multiple times because methods in cycles can call each other,
-	// and we need to propagate async status until no changes occur
+	// Analyze methods in dependency order (dependencies analyzed before dependents)
+	for _, methodKey := range sorted {
+		v.analyzeMethodAsyncTopological(methodKey, methodCalls[methodKey])
+	}
+
+	// Analyze methods in cycles after the acyclic portion of the graph is known.
+	// This lets recursive methods observe async callees outside the cycle while
+	// still converging over recursive edges inside the cycle.
 	maxIterations := 10
 	for range maxIterations {
 		changed := false
 
 		for _, methodKey := range cycles {
-			// For methods in cycles, we need to check their body directly for async operations
 			pkg := v.analysis.AllPackages[methodKey.PackagePath]
 			if pkg == nil && methodKey.PackagePath == v.pkg.Types.Path() {
 				pkg = v.pkg
 			}
 
+			isAsync := false
 			if pkg != nil {
 				var funcDecl *ast.FuncDecl
 				if methodKey.ReceiverType == "" {
@@ -2782,37 +2784,29 @@ func (v *analysisVisitor) analyzeAllMethodsAsync() {
 				}
 
 				if funcDecl != nil && funcDecl.Body != nil {
-					// Check if the method contains async operations (including calls to async external methods)
-					isAsync := v.containsAsyncOperationsComplete(funcDecl.Body, pkg)
-
-					// Check if status changed
-					if oldStatus, exists := v.analysis.MethodAsyncStatus[methodKey]; !exists || oldStatus != isAsync {
-						changed = true
+					isAsync = v.containsAsyncOperationsComplete(funcDecl.Body, pkg)
+					if !isAsync {
+						for _, callee := range methodCalls[methodKey] {
+							if calleeAsync, exists := v.analysis.MethodAsyncStatus[callee]; exists && calleeAsync {
+								isAsync = true
+								break
+							}
+						}
 					}
-
-					v.analysis.MethodAsyncStatus[methodKey] = isAsync
-					continue
 				}
 			}
 
-			// Fallback: mark as sync if we can't analyze the body
-			if _, exists := v.analysis.MethodAsyncStatus[methodKey]; !exists {
-				v.analysis.MethodAsyncStatus[methodKey] = false
+			if oldStatus, exists := v.analysis.MethodAsyncStatus[methodKey]; !exists || oldStatus != isAsync {
 				changed = true
 			}
+			v.analysis.MethodAsyncStatus[methodKey] = isAsync
 		}
 
-		// If no changes in this iteration, we're done
 		if !changed {
 			break
 		}
 	}
 
-	// Analyze methods in dependency order (dependencies analyzed before dependents)
-	for _, methodKey := range sorted {
-		v.analyzeMethodAsyncTopological(methodKey, methodCalls[methodKey])
-	}
-
 	// Track async-returning variables BEFORE analyzing function literals
 	// This detects variables assigned from higher-order functions with async function literal args
 	// e.g., indirect := sync.OnceValue(asyncFunc)
@@ -3259,6 +3253,11 @@ func (v *analysisVisitor) containsAsyncOperationsComplete(node ast.Node, pkg *pa
 		if n == nil {
 			return false
 		}
+		if n != node {
+			if _, ok := n.(*ast.FuncLit); ok {
+				return false
+			}
+		}
 
 		switch s := n.(type) {
 		case *ast.SendStmt:

compiler/decl.go

@@ -1,7 +1,6 @@
 package compiler
 
 import (
-	"bytes"
 	"fmt"
 	"go/ast"
 	"go/token"
@@ -678,14 +677,6 @@ func (c *GoToTSCompiler) writeMethodSignature(decl *ast.FuncDecl) (bool, error)
 		}
 	}
 
-	if !isAsync {
-		bodyNeedsAsync, err := c.funcBodyNeedsAsync(decl, true)
-		if err != nil {
-			return false, err
-		}
-		isAsync = bodyNeedsAsync
-	}
-
 	// Methods are typically public in the TS output
 	c.tsw.WriteLiterally("public ")
 
@@ -753,31 +744,6 @@ func (c *GoToTSCompiler) writeMethodSignature(decl *ast.FuncDecl) (bool, error)
 	return isAsync, nil
 }
 
-// funcBodyNeedsAsync checks whether emitting a function body would generate await.
-func (c *GoToTSCompiler) funcBodyNeedsAsync(decl *ast.FuncDecl, isMethod bool) (bool, error) {
-	if decl.Body == nil {
-		return false, nil
-	}
-
-	var body strings.Builder
-	writer := NewTSCodeWriter(&body)
-	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis, c.currentFilePath)
-
-	if isMethod {
-		if err := tempCompiler.writeMethodBodyWithReceiverBinding(decl, "this"); err != nil {
-			return false, err
-		}
-	} else {
-		for _, stmt := range decl.Body.List {
-			if err := tempCompiler.WriteStmt(stmt); err != nil {
-				return false, err
-			}
-		}
-	}
-
-	return bytes.Contains([]byte(body.String()), []byte("await")), nil
-}
-
 // writeMethodBodyWithReceiverBinding writes the method body with optional receiver binding
 // receiverTarget should be "this" for struct methods or "this._value" for named type methods
 func (c *GoToTSCompiler) writeMethodBodyWithReceiverBinding(decl *ast.FuncDecl, receiverTarget string) error {