goscript 0.0.61 → 0.0.62

package/README.md

@@ -58,6 +58,15 @@ GoScript is working on compiling a subset of Go:
 
 > **Warning:** This is experimental software. Features may be incomplete or broken. Please report any issues!
 
+### Prerequisites
+
+GoScript requires [Bun](https://bun.sh) to be installed for running compliance tests:
+
+```bash
+# Install Bun
+curl -fsSL https://bun.sh/install | bash
+```
+
 ### Installation
 
 **Option 1: Go Install**

package/compiler/analysis.go

@@ -52,6 +52,10 @@ type ShadowingInfo struct {
 	ShadowedVariables map[string]types.Object
 	// TempVariables maps shadowed variable names to temporary variable names
 	TempVariables map[string]string
+	// TypeShadowedVars maps variable names that shadow type names to their renamed identifier
+	// This happens when a variable name matches a type name used in its initialization
+	// e.g., field := field{...} where the variable 'field' shadows the type 'field'
+	TypeShadowedVars map[string]string
 }
 
 // FunctionTypeInfo represents Go function type information for reflection
@@ -122,6 +126,10 @@ type Analysis struct {
 	// Imports stores the imports for the file
 	Imports map[string]*fileImport
 
+	// SyntheticImports stores imports that need to be written but were not in the source file.
+	// These are typically needed for promoted methods from embedded structs.
+	SyntheticImports map[string]*fileImport
+
 	// Cmap stores the comment map for the file
 	Cmap ast.CommentMap
 
@@ -141,6 +149,11 @@ type Analysis struct {
 	// FunctionAssignments tracks which function literals are assigned to which variables
 	FunctionAssignments map[types.Object]ast.Node
 
+	// AsyncReturningVars tracks variables whose function type returns async values
+	// This happens when a variable is assigned from a higher-order function (like sync.OnceValue)
+	// that receives an async function literal as an argument
+	AsyncReturningVars map[types.Object]bool
+
 	// NamedBasicTypes tracks types that should be implemented as type aliases with standalone functions
 	// This includes named types with basic underlying types (like uint32, string) that have methods
 	NamedBasicTypes map[types.Type]bool
@@ -175,6 +188,14 @@ type PackageAnalysis struct {
 	// TypeCalls maps file names to the types they reference from other files
 	// Key: filename (without .go extension), Value: map[sourceFile][]typeNames
 	TypeCalls map[string]map[string][]string
+
+	// VariableDefs maps file names to the package-level variables defined in that file
+	// Key: filename (without .go extension), Value: list of variable names
+	VariableDefs map[string][]string
+
+	// VariableCalls maps file names to the package-level variables they reference from other files
+	// Key: filename (without .go extension), Value: map[sourceFile][]variableNames
+	VariableCalls map[string]map[string][]string
 }
 
 // NewAnalysis creates a new Analysis instance.
@@ -184,16 +205,17 @@ func NewAnalysis(allPackages map[string]*packages.Package) *Analysis {
 	}
 
 	return &Analysis{
-		VariableUsage:       make(map[types.Object]*VariableUsageInfo),
-		Imports:             make(map[string]*fileImport),
-		FunctionData:        make(map[types.Object]*FunctionInfo),
-		NodeData:            make(map[ast.Node]*NodeInfo),
-		FuncLitData:         make(map[*ast.FuncLit]*FunctionInfo),
-		ReflectedFunctions:  make(map[ast.Node]*ReflectedFunctionInfo),
-		FunctionAssignments: make(map[types.Object]ast.Node),
-		// PackageMetadata removed - using MethodAsyncStatus only
-		NamedBasicTypes:          make(map[types.Type]bool),
-		AllPackages:              allPackages,
+		VariableUsage:        make(map[types.Object]*VariableUsageInfo),
+		Imports:              make(map[string]*fileImport),
+		SyntheticImports:     make(map[string]*fileImport),
+		FunctionData:         make(map[types.Object]*FunctionInfo),
+		NodeData:             make(map[ast.Node]*NodeInfo),
+		FuncLitData:          make(map[*ast.FuncLit]*FunctionInfo),
+		ReflectedFunctions:   make(map[ast.Node]*ReflectedFunctionInfo),
+		FunctionAssignments:  make(map[types.Object]ast.Node),
+		AsyncReturningVars:   make(map[types.Object]bool),
+		NamedBasicTypes:      make(map[types.Type]bool),
+		AllPackages:          allPackages,
 		InterfaceImplementations: make(map[InterfaceMethodKey][]ImplementationInfo),
 		MethodAsyncStatus:        make(map[MethodKey]bool),
 	}
@@ -206,6 +228,8 @@ func NewPackageAnalysis() *PackageAnalysis {
 		FunctionCalls: make(map[string]map[string][]string),
 		TypeDefs:      make(map[string][]string),
 		TypeCalls:     make(map[string]map[string][]string),
+		VariableDefs:  make(map[string][]string),
+		VariableCalls: make(map[string]map[string][]string),
 	}
 }
 
@@ -313,6 +337,15 @@ func (a *Analysis) IsAsyncFunc(obj types.Object) bool {
 	return false
 }
 
+// IsAsyncReturningVar returns whether the given variable holds a function that returns async values.
+// This is true when the variable is assigned from a higher-order function that receives an async function literal.
+func (a *Analysis) IsAsyncReturningVar(obj types.Object) bool {
+	if obj == nil {
+		return false
+	}
+	return a.AsyncReturningVars[obj]
+}
+
 func (a *Analysis) IsReceiverUsed(obj types.Object) bool {
 	if obj == nil {
 		return false
@@ -909,9 +942,63 @@ func (v *analysisVisitor) visitAssignStmt(n *ast.AssignStmt) ast.Visitor {
 		}
 	}
 
+	// NOTE: Async-returning variable tracking (trackAsyncReturningVar) is done in a separate pass
+	// after function literals are analyzed for async status. See trackAsyncReturningVarsAllFiles.
+
 	return v
 }
 
+// trackAsyncReturningVar tracks variables that are assigned from higher-order function calls
+// where one of the arguments is an async function literal.
+// Pattern: x := higherOrderFunc(asyncFuncLit)
+// This is needed because when sync.OnceValue(asyncFunc) is called, the result is a function
+// that returns a Promise, and callers of x() need to await the result.
+func (v *analysisVisitor) trackAsyncReturningVar(lhs ast.Expr, rhs ast.Expr) {
+	// LHS must be an identifier
+	lhsIdent, ok := lhs.(*ast.Ident)
+	if !ok {
+		return
+	}
+
+	// RHS must be a call expression
+	callExpr, ok := rhs.(*ast.CallExpr)
+	if !ok {
+		return
+	}
+
+	// The result type of the call must be a function type
+	rhsType := v.pkg.TypesInfo.TypeOf(rhs)
+	if rhsType == nil {
+		return
+	}
+	_, isFunc := rhsType.Underlying().(*types.Signature)
+	if !isFunc {
+		return
+	}
+
+	// Check if any argument is an async function literal
+	// Use containsAsyncOperationsComplete to check the function body directly
+	// rather than relying on the InAsyncContext flag which may not be set yet
+	hasAsyncArg := false
+	for _, arg := range callExpr.Args {
+		if funcLit, ok := arg.(*ast.FuncLit); ok {
+			if funcLit.Body != nil && v.containsAsyncOperationsComplete(funcLit.Body, v.pkg) {
+				hasAsyncArg = true
+				break
+			}
+		}
+	}
+
+	if !hasAsyncArg {
+		return
+	}
+
+	// Mark the LHS variable as returning async values
+	if obj := v.pkg.TypesInfo.ObjectOf(lhsIdent); obj != nil {
+		v.analysis.AsyncReturningVars[obj] = true
+	}
+}
+
 // visitReturnStmt handles return statement analysis
 func (v *analysisVisitor) visitReturnStmt(n *ast.ReturnStmt) ast.Visitor {
 	nodeInfo := v.analysis.ensureNodeData(n)
@@ -1207,9 +1294,165 @@ func AnalyzePackageFiles(pkg *packages.Package, allPackages map[string]*packages
 	// Interface implementation async status is now updated on-demand in IsInterfaceMethodAsync
 	visitor.analyzeAllMethodsAsync()
 
+	// Fourth pass: collect imports needed by promoted methods from embedded structs
+	analysis.addImportsForPromotedMethods(pkg)
+
 	return analysis
 }
 
+// addImportsForPromotedMethods scans all struct types in the package for embedded fields
+// and adds imports for any packages referenced by the promoted methods' parameter/return types.
+func (a *Analysis) addImportsForPromotedMethods(pkg *packages.Package) {
+	// Collect all package names we need to add
+	packagesToAdd := make(map[string]*types.Package)
+
+	// Iterate through all type definitions in the package
+	scope := pkg.Types.Scope()
+	for _, name := range scope.Names() {
+		obj := scope.Lookup(name)
+		if obj == nil {
+			continue
+		}
+
+		// Check if it's a type definition
+		typeName, ok := obj.(*types.TypeName)
+		if !ok {
+			continue
+		}
+
+		// Get the underlying type
+		namedType, ok := typeName.Type().(*types.Named)
+		if !ok {
+			continue
+		}
+
+		// Check if it's a struct
+		structType, ok := namedType.Underlying().(*types.Struct)
+		if !ok {
+			continue
+		}
+
+		// Look for embedded fields
+		for i := 0; i < structType.NumFields(); i++ {
+			field := structType.Field(i)
+			if !field.Embedded() {
+				continue
+			}
+
+			// Get the type of the embedded field
+			embeddedType := field.Type()
+
+			// Handle pointer to embedded type
+			if ptr, ok := embeddedType.(*types.Pointer); ok {
+				embeddedType = ptr.Elem()
+			}
+
+			// Use method set to get all promoted methods including pointer receiver methods
+			// This matches Go's behavior where embedding T promotes both T and *T methods
+			methodSetType := embeddedType
+			if _, isPtr := embeddedType.(*types.Pointer); !isPtr {
+				if _, isInterface := embeddedType.Underlying().(*types.Interface); !isInterface {
+					methodSetType = types.NewPointer(embeddedType)
+				}
+			}
+			embeddedMethodSet := types.NewMethodSet(methodSetType)
+
+			// Scan all methods in the method set
+			for j := 0; j < embeddedMethodSet.Len(); j++ {
+				selection := embeddedMethodSet.At(j)
+				method := selection.Obj()
+				sig, ok := method.Type().(*types.Signature)
+				if !ok {
+					continue
+				}
+
+				// Scan parameters
+				if sig.Params() != nil {
+					for k := 0; k < sig.Params().Len(); k++ {
+						param := sig.Params().At(k)
+						a.collectPackageFromType(param.Type(), pkg.Types, packagesToAdd)
+					}
+				}
+
+				// Scan results
+				if sig.Results() != nil {
+					for k := 0; k < sig.Results().Len(); k++ {
+						result := sig.Results().At(k)
+						a.collectPackageFromType(result.Type(), pkg.Types, packagesToAdd)
+					}
+				}
+			}
+		}
+	}
+
+	// Add collected packages to imports (both regular and synthetic)
+	// Always add to SyntheticImports - the file compiler will check if
+	// the import was already written from the AST to avoid duplicates
+	for pkgName, pkgObj := range packagesToAdd {
+		tsImportPath := "@goscript/" + pkgObj.Path()
+		fileImp := &fileImport{
+			importPath: tsImportPath,
+			importVars: make(map[string]struct{}),
+		}
+		// Add to SyntheticImports unconditionally
+		a.SyntheticImports[pkgName] = fileImp
+		// Also add to Imports if not already present
+		if _, exists := a.Imports[pkgName]; !exists {
+			a.Imports[pkgName] = fileImp
+		}
+	}
+}
+
+// collectPackageFromType recursively collects packages referenced by a type.
+func (a *Analysis) collectPackageFromType(t types.Type, currentPkg *types.Package, packagesToAdd map[string]*types.Package) {
+	switch typ := t.(type) {
+	case *types.Named:
+		pkg := typ.Obj().Pkg()
+		if pkg != nil && pkg != currentPkg {
+			packagesToAdd[pkg.Name()] = pkg
+		}
+		// Check type arguments for generics
+		if typ.TypeArgs() != nil {
+			for i := 0; i < typ.TypeArgs().Len(); i++ {
+				a.collectPackageFromType(typ.TypeArgs().At(i), currentPkg, packagesToAdd)
+			}
+		}
+	case *types.Interface:
+		// For interfaces, we need to check embedded interfaces and method signatures
+		for i := 0; i < typ.NumEmbeddeds(); i++ {
+			a.collectPackageFromType(typ.EmbeddedType(i), currentPkg, packagesToAdd)
+		}
+		for i := 0; i < typ.NumExplicitMethods(); i++ {
+			method := typ.ExplicitMethod(i)
+			a.collectPackageFromType(method.Type(), currentPkg, packagesToAdd)
+		}
+	case *types.Pointer:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Slice:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Array:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Map:
+		a.collectPackageFromType(typ.Key(), currentPkg, packagesToAdd)
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Chan:
+		a.collectPackageFromType(typ.Elem(), currentPkg, packagesToAdd)
+	case *types.Signature:
+		// Collect from parameters
+		if typ.Params() != nil {
+			for i := 0; i < typ.Params().Len(); i++ {
+				a.collectPackageFromType(typ.Params().At(i).Type(), currentPkg, packagesToAdd)
+			}
+		}
+		// Collect from results
+		if typ.Results() != nil {
+			for i := 0; i < typ.Results().Len(); i++ {
+				a.collectPackageFromType(typ.Results().At(i).Type(), currentPkg, packagesToAdd)
+			}
+		}
+	}
+}
+
 // AnalyzePackageImports performs package-level analysis to collect function definitions
 // and calls across all files in the package for auto-import generation
 func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
@@ -1221,19 +1464,50 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
 
 		var functions []string
-		var types []string
+		var typeNames []string
+		var variables []string
 		for _, decl := range syntax.Decls {
 			if funcDecl, ok := decl.(*ast.FuncDecl); ok {
-				// Only collect top-level functions (not methods)
+				// Collect top-level functions (not methods)
 				if funcDecl.Recv == nil {
 					functions = append(functions, funcDecl.Name.Name)
+				} else {
+					// Check if this is a method on a wrapper type (named basic type)
+					// If so, it will be compiled as TypeName_MethodName function
+					if len(funcDecl.Recv.List) > 0 {
+						recvType := funcDecl.Recv.List[0].Type
+						// Handle pointer receiver (*Type)
+						if starExpr, ok := recvType.(*ast.StarExpr); ok {
+							recvType = starExpr.X
+						}
+						if recvIdent, ok := recvType.(*ast.Ident); ok {
+							// Check if this receiver type is a wrapper type
+							if obj := pkg.TypesInfo.Uses[recvIdent]; obj != nil {
+								if typeName, ok := obj.(*types.TypeName); ok {
+									if namedType, ok := typeName.Type().(*types.Named); ok {
+										if _, ok := namedType.Underlying().(*types.Basic); ok {
+											// This is a method on a wrapper type
+											funcName := recvIdent.Name + "_" + funcDecl.Name.Name
+											functions = append(functions, funcName)
+										}
+									}
+								}
+							}
+						}
+					}
 				}
 			}
 			if genDecl, ok := decl.(*ast.GenDecl); ok {
 				// Collect type declarations
 				for _, spec := range genDecl.Specs {
 					if typeSpec, ok := spec.(*ast.TypeSpec); ok {
-						types = append(types, typeSpec.Name.Name)
+						typeNames = append(typeNames, typeSpec.Name.Name)
+					}
+					// Collect variable/constant declarations
+					if valueSpec, ok := spec.(*ast.ValueSpec); ok {
+						for _, name := range valueSpec.Names {
+							variables = append(variables, name.Name)
+						}
 					}
 				}
 			}
@@ -1242,8 +1516,11 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 		if len(functions) > 0 {
 			analysis.FunctionDefs[baseFileName] = functions
 		}
-		if len(types) > 0 {
-			analysis.TypeDefs[baseFileName] = types
+		if len(typeNames) > 0 {
+			analysis.TypeDefs[baseFileName] = typeNames
+		}
+		if len(variables) > 0 {
+			analysis.VariableDefs[baseFileName] = variables
 		}
 	}
 
@@ -1343,6 +1620,172 @@ func AnalyzePackageImports(pkg *packages.Package) *PackageAnalysis {
 		}
 	}
 
+	// Fourth pass: analyze variable references and determine which need imports
+	for i, syntax := range pkg.Syntax {
+		fileName := pkg.CompiledGoFiles[i]
+		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
+
+		// Find all variable references in this file
+		varRefsFromOtherFiles := make(map[string][]string)
+
+		ast.Inspect(syntax, func(n ast.Node) bool {
+			// Look for identifier references
+			if ident, ok := n.(*ast.Ident); ok {
+				// Check if this identifier refers to a package-level variable
+				if obj := pkg.TypesInfo.Uses[ident]; obj != nil {
+					if varObj, ok := obj.(*types.Var); ok {
+						// Only track package-level variables (not function parameters or local vars)
+						if varObj.Parent() == pkg.Types.Scope() {
+							varName := ident.Name
+
+							// Check if this variable is defined in the current file
+							currentFileVars := analysis.VariableDefs[baseFileName]
+							isDefinedInCurrentFile := slices.Contains(currentFileVars, varName)
+
+							// If not defined in current file, find which file defines it
+							if !isDefinedInCurrentFile {
+								for sourceFile, vars := range analysis.VariableDefs {
+									if sourceFile == baseFileName {
+										continue // Skip current file
+									}
+									if slices.Contains(vars, varName) {
+										// Found the variable in another file
+										if varRefsFromOtherFiles[sourceFile] == nil {
+											varRefsFromOtherFiles[sourceFile] = []string{}
+										}
+										// Check if already added to avoid duplicates
+										found := slices.Contains(varRefsFromOtherFiles[sourceFile], varName)
+										if !found {
+											varRefsFromOtherFiles[sourceFile] = append(varRefsFromOtherFiles[sourceFile], varName)
+										}
+									}
+								}
+							}
+						}
+					}
+					// Also check for constants
+					if constObj, ok := obj.(*types.Const); ok {
+						// Only track package-level constants
+						if constObj.Parent() == pkg.Types.Scope() {
+							constName := ident.Name
+
+							// Check if this constant is defined in the current file
+							currentFileVars := analysis.VariableDefs[baseFileName]
+							isDefinedInCurrentFile := slices.Contains(currentFileVars, constName)
+
+							// If not defined in current file, find which file defines it
+							if !isDefinedInCurrentFile {
+								for sourceFile, vars := range analysis.VariableDefs {
+									if sourceFile == baseFileName {
+										continue // Skip current file
+									}
+									if slices.Contains(vars, constName) {
+										// Found the constant in another file
+										if varRefsFromOtherFiles[sourceFile] == nil {
+											varRefsFromOtherFiles[sourceFile] = []string{}
+										}
+										// Check if already added to avoid duplicates
+										found := slices.Contains(varRefsFromOtherFiles[sourceFile], constName)
+										if !found {
+											varRefsFromOtherFiles[sourceFile] = append(varRefsFromOtherFiles[sourceFile], constName)
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			return true
+		})
+
+		if len(varRefsFromOtherFiles) > 0 {
+			analysis.VariableCalls[baseFileName] = varRefsFromOtherFiles
+		}
+	}
+
+	// Fifth pass: analyze method calls on wrapper types (named basic types with methods)
+	// These generate TypeName_MethodName function calls that need to be imported
+	for i, syntax := range pkg.Syntax {
+		fileName := pkg.CompiledGoFiles[i]
+		baseFileName := strings.TrimSuffix(filepath.Base(fileName), ".go")
+
+		// Find all method calls on wrapper types in this file
+		ast.Inspect(syntax, func(n ast.Node) bool {
+			callExpr, ok := n.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+
+			// Check if this is a method call (selector expression)
+			selectorExpr, ok := callExpr.Fun.(*ast.SelectorExpr)
+			if !ok {
+				return true
+			}
+
+			// Get the type of the receiver
+			receiverType := pkg.TypesInfo.TypeOf(selectorExpr.X)
+			if receiverType == nil {
+				return true
+			}
+
+			// Check if this is a wrapper type (named type with basic underlying type and methods)
+			namedType, ok := receiverType.(*types.Named)
+			if !ok {
+				return true
+			}
+
+			// Check if it has a basic underlying type
+			if _, ok := namedType.Underlying().(*types.Basic); !ok {
+				return true
+			}
+
+			// Check if this type is defined in the same package
+			obj := namedType.Obj()
+			if obj == nil || obj.Pkg() == nil || obj.Pkg() != pkg.Types {
+				return true // Not from this package
+			}
+
+			// Check if this type has the method being called
+			methodName := selectorExpr.Sel.Name
+			found := false
+			for j := 0; j < namedType.NumMethods(); j++ {
+				if namedType.Method(j).Name() == methodName {
+					found = true
+					break
+				}
+			}
+			if !found {
+				return true
+			}
+
+			// Generate the function name: TypeName_MethodName
+			funcName := obj.Name() + "_" + methodName
+
+			// Find which file defines this function
+			for sourceFile, funcs := range analysis.FunctionDefs {
+				if sourceFile == baseFileName {
+					continue // Skip current file
+				}
+				if slices.Contains(funcs, funcName) {
+					// Found the function in another file
+					if analysis.FunctionCalls[baseFileName] == nil {
+						analysis.FunctionCalls[baseFileName] = make(map[string][]string)
+					}
+					if analysis.FunctionCalls[baseFileName][sourceFile] == nil {
+						analysis.FunctionCalls[baseFileName][sourceFile] = []string{}
+					}
+					// Check if already added to avoid duplicates
+					if !slices.Contains(analysis.FunctionCalls[baseFileName][sourceFile], funcName) {
+						analysis.FunctionCalls[baseFileName][sourceFile] = append(analysis.FunctionCalls[baseFileName][sourceFile], funcName)
+					}
+				}
+			}
+
+			return true
+		})
+	}
+
 	return analysis
 }
 
@@ -1546,6 +1989,7 @@ func (v *analysisVisitor) detectVariableShadowing(assignStmt *ast.AssignStmt) *S
 	shadowingInfo := &ShadowingInfo{
 		ShadowedVariables: make(map[string]types.Object),
 		TempVariables:     make(map[string]string),
+		TypeShadowedVars:  make(map[string]string),
 	}
 
 	hasShadowing := false
@@ -1563,12 +2007,60 @@ func (v *analysisVisitor) detectVariableShadowing(assignStmt *ast.AssignStmt) *S
 		v.findVariableUsageInExpr(rhsExpr, lhsVarNames, shadowingInfo, &hasShadowing)
 	}
 
+	// Check for type shadowing: variable name matches a type name used in its initialization
+	// e.g., field := field{...} where the variable 'field' shadows the type 'field'
+	if assignStmt.Tok == token.DEFINE {
+		for i, lhsExpr := range assignStmt.Lhs {
+			if i < len(assignStmt.Rhs) {
+				if lhsIdent, ok := lhsExpr.(*ast.Ident); ok && lhsIdent.Name != "_" {
+					if typeName := v.findTypeShadowing(lhsIdent.Name, assignStmt.Rhs[i]); typeName != "" {
+						shadowingInfo.TypeShadowedVars[lhsIdent.Name] = lhsIdent.Name + "_"
+						hasShadowing = true
+					}
+				}
+			}
+		}
+	}
+
 	if hasShadowing {
 		return shadowingInfo
 	}
 	return nil
 }
 
+// findTypeShadowing checks if the given variable name matches a type name used in the RHS expression.
+// Returns the type name if shadowing is detected, empty string otherwise.
+func (v *analysisVisitor) findTypeShadowing(varName string, rhsExpr ast.Expr) string {
+	// Handle address-of expressions: field := &field{...}
+	if unary, ok := rhsExpr.(*ast.UnaryExpr); ok && unary.Op == token.AND {
+		rhsExpr = unary.X
+	}
+
+	// Check if RHS is a composite literal with a type name matching varName
+	compLit, ok := rhsExpr.(*ast.CompositeLit)
+	if !ok {
+		return ""
+	}
+
+	// Get the type name from the composite literal
+	var typeName string
+	switch t := compLit.Type.(type) {
+	case *ast.Ident:
+		typeName = t.Name
+	case *ast.SelectorExpr:
+		// pkg.Type - just use the type name part
+		typeName = t.Sel.Name
+	default:
+		return ""
+	}
+
+	// Check if variable name matches type name
+	if typeName == varName {
+		return typeName
+	}
+	return ""
+}
+
 // findVariableUsageInExpr recursively searches for variable usage in an expression
 func (v *analysisVisitor) findVariableUsageInExpr(expr ast.Expr, lhsVarNames map[string]*ast.Ident, shadowingInfo *ShadowingInfo, hasShadowing *bool) {
 	if expr == nil {
@@ -2173,8 +2665,17 @@ func (v *analysisVisitor) analyzeAllMethodsAsync() {
 		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)
+	// This must happen first so that function literals containing calls to these variables
+	// will be correctly identified as async.
+	v.trackAsyncReturningVarsAllFiles()
+
 	// Finally, analyze function literals in the current package only
 	// (external packages' function literals are not accessible)
+	// This must run AFTER trackAsyncReturningVarsAllFiles so that function literals
+	// containing calls to async-returning variables are correctly marked as async.
 	v.analyzeFunctionLiteralsAsync(v.pkg)
 }
 
@@ -2190,6 +2691,21 @@ func (v *analysisVisitor) analyzeFunctionLiteralsAsync(pkg *packages.Package) {
 	}
 }
 
+// trackAsyncReturningVarsAllFiles scans all files for assignment statements
+// and marks variables that are assigned from higher-order functions with async function literal args
+func (v *analysisVisitor) trackAsyncReturningVarsAllFiles() {
+	for _, file := range v.pkg.Syntax {
+		ast.Inspect(file, func(n ast.Node) bool {
+			if assignStmt, ok := n.(*ast.AssignStmt); ok {
+				if len(assignStmt.Lhs) == 1 && len(assignStmt.Rhs) == 1 {
+					v.trackAsyncReturningVar(assignStmt.Lhs[0], assignStmt.Rhs[0])
+				}
+			}
+			return true
+		})
+	}
+}
+
 // analyzeFunctionLiteralAsync determines if a function literal is async and stores the result
 func (v *analysisVisitor) analyzeFunctionLiteralAsync(funcLit *ast.FuncLit, pkg *packages.Package) {
 	// Check if already analyzed
@@ -2641,6 +3157,11 @@ func (v *analysisVisitor) isCallAsync(callExpr *ast.CallExpr, pkg *packages.Pack
 				result := v.isFunctionAsync(funcObj, pkg)
 				return result
 			}
+			// Check if this is a variable that returns async values
+			// (e.g., indirect := sync.OnceValue(asyncFunc))
+			if v.analysis.IsAsyncReturningVar(obj) {
+				return true
+			}
 		}
 
 	case *ast.SelectorExpr: