goscript 0.0.48 → 0.0.50

package/compiler/analysis_test.go

@@ -5,6 +5,7 @@ import (
 	"go/parser"
 	"go/token"
 	"go/types"
+	"os"
 	"testing"
 
 	"golang.org/x/tools/go/packages"
@@ -159,6 +160,7 @@ func parseAndAnalyze(t *testing.T, code string) (*Analysis, map[string]types.Obj
 			Defs:  make(map[*ast.Ident]types.Object),
 			Uses:  make(map[*ast.Ident]types.Object),
 		},
+		Fset: fset,
 	}
 
 	// Type check the package
@@ -169,10 +171,8 @@ func parseAndAnalyze(t *testing.T, code string) (*Analysis, map[string]types.Obj
 	}
 	pkg.Types = typePkg
 
-	// Run analysis
-	analysis := NewAnalysis()
-	cmap := ast.NewCommentMap(fset, file, file.Comments)
-	AnalyzeFile(file, pkg, analysis, cmap)
+	// Run package-level analysis
+	analysis := AnalyzePackageFiles(pkg, nil)
 
 	// Collect variable objects
 	objects := make(map[string]types.Object)
@@ -232,3 +232,112 @@ func main() {
 		t.Log("")
 	}
 }
+
+// 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"
+
+	// Load the package using the packages config like the main compiler does
+	cfg := &packages.Config{
+		Mode: packages.NeedName |
+			packages.NeedFiles |
+			packages.NeedCompiledGoFiles |
+			packages.NeedImports |
+			packages.NeedDeps |
+			packages.NeedExportFile |
+			packages.NeedTypes |
+			packages.NeedSyntax |
+			packages.NeedTypesInfo |
+			packages.NeedTypesSizes,
+		Tests: false,
+		Env:   append(os.Environ(), "GOOS=js", "GOARCH=wasm"),
+	}
+
+	pkgs, err := packages.Load(cfg, testPath)
+	if err != nil {
+		t.Fatalf("Failed to load test package: %v", err)
+	}
+
+	if len(pkgs) != 1 {
+		t.Fatalf("Expected 1 package, got %d", len(pkgs))
+	}
+
+	pkg := pkgs[0]
+	if len(pkg.Errors) > 0 {
+		t.Fatalf("Package has errors: %v", pkg.Errors[0])
+	}
+
+	// Run package-level analysis
+	if len(pkg.Syntax) == 0 {
+		t.Fatal("No syntax files found")
+	}
+
+	analysis := AnalyzePackageFiles(pkg, nil)
+
+	// Verify the NamedBasicTypes map was initialized
+	if analysis.NamedBasicTypes == nil {
+		t.Error("NamedBasicTypes map was not initialized")
+	}
+
+	// Test some type lookups to verify wrapper type detection works
+	// We'll check if MyMode (which has methods) is detected as a wrapper type
+	scope := pkg.Types.Scope()
+
+	// Check if MyMode is detected as a wrapper type
+	if obj := scope.Lookup("MyMode"); obj != nil {
+		if typeName, ok := obj.(*types.TypeName); ok {
+			isWrapper := analysis.IsNamedBasicType(typeName.Type())
+			if !isWrapper {
+				t.Errorf("MyMode should be detected as wrapper type, got %v", isWrapper)
+			}
+			t.Logf("MyMode wrapper detection: %v (correct)", isWrapper)
+		}
+	}
+
+	// Test that regular struct types are not detected as wrapper types
+	if obj := scope.Lookup("MyDir"); obj != nil {
+		if typeName, ok := obj.(*types.TypeName); ok {
+			isWrapper := analysis.IsNamedBasicType(typeName.Type())
+			if isWrapper {
+				t.Errorf("MyDir should not be detected as wrapper type, got %v", isWrapper)
+			}
+			t.Logf("MyDir wrapper detection: %v (correct)", isWrapper)
+		}
+	}
+
+	t.Logf("Analysis completed successfully with %d named basic types tracked", len(analysis.NamedBasicTypes))
+}
+
+// TestDiscoverGsPackages verifies that the discoverEmbeddedGsPackages function
+// can find packages in the embedded gs/ directory
+func TestDiscoverGsPackages(t *testing.T) {
+	analysis := NewAnalysis(nil)
+
+	// Test package discovery using the embedded filesystem
+	packages := analysis.discoverEmbeddedGsPackages()
+	t.Logf("Discovered %d packages:", len(packages))
+	for _, pkg := range packages {
+		t.Logf("  - %s", pkg)
+	}
+
+	// We should find at least some packages
+	if len(packages) == 0 {
+		t.Errorf("Expected to find at least one package in gs/ directory")
+	}
+
+	// Check for some known packages that should exist
+	expectedPackages := []string{"sync", "bytes", "strings"}
+	for _, expected := range expectedPackages {
+		found := false
+		for _, pkg := range packages {
+			if pkg == expected {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Logf("Expected package '%s' not found in discovered packages: %v", expected, packages)
+		}
+	}
+}

package/compiler/compiler.go

@@ -2,10 +2,10 @@ package compiler
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"go/ast"
 	"go/constant"
-	"go/parser"
 	"go/token"
 	"go/types"
 	"os"
@@ -72,7 +72,11 @@ func NewCompiler(conf *Config, le *logrus.Entry, opts *packages.Config) (*Compil
 		packages.NeedTypesInfo |
 		packages.NeedTypesSizes
 
-	return &Compiler{config: *conf, le: le, opts: *opts}, nil
+	return &Compiler{
+		config: *conf,
+		le:     le,
+		opts:   *opts,
+	}, nil
 }
 
 // CompilationResult contains information about what was compiled
@@ -141,7 +145,6 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			// Check if this package has a handwritten equivalent
 			if hasHandwrittenEquivalent(pkg.PkgPath) {
 				// Add this package but don't visit its dependencies
-				// c.le.Debugf("Skipping dependencies of handwritten package: %s", pkg.PkgPath)
 				return
 			}
 
@@ -149,13 +152,11 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			for _, imp := range pkg.Imports {
 				// Skip protobuf-go-lite packages and their dependencies
 				if isProtobufGoLitePackage(imp.PkgPath) {
-					// c.le.Debugf("Skipping protobuf-go-lite package: %s", imp.PkgPath)
 					continue
 				}
 
 				// Skip packages that are only used by .pb.go files
 				if isPackageOnlyUsedByProtobufFiles(pkg, imp.PkgPath) {
-					// c.le.Debugf("Skipping package only used by .pb.go files: %s", imp.PkgPath)
 					continue
 				}
 
@@ -168,28 +169,39 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			visit(pkg)
 		}
 
-		// Replace pkgs with all packages
-		pkgs = allPkgs
+		// Now we have collected all dependencies, but they only have minimal information.
+		// We need to reload them with complete type information for compilation.
+		// Collect all package paths from the dependency graph
+		var pkgPaths []string
+		pkgPathSet := make(map[string]bool) // Use set to avoid duplicates
 
-		/*
-			// Now load all packages with full mode to get complete type information
-			var pkgPaths []string
-			for _, pkg := range pkgs {
-				if pkg.PkgPath != "" {
-					pkgPaths = append(pkgPaths, pkg.PkgPath)
-				}
+		for _, pkg := range allPkgs {
+			if pkg.PkgPath != "" && !pkgPathSet[pkg.PkgPath] {
+				pkgPaths = append(pkgPaths, pkg.PkgPath)
+				pkgPathSet[pkg.PkgPath] = true
 			}
+		}
+
+		// Reload all collected packages with complete type information
+		if len(pkgPaths) > 0 {
+			c.le.Debugf("Reloading %d packages with complete type information", len(pkgPaths))
 
-			// Reload all packages with full mode
-			// TODO: Can we get rid of this? This would be very slow!
 			fullOpts := c.opts
 			fullOpts.Context = ctx
+			// Use LoadAllSyntax to get complete type information, syntax trees, and type checking
 			fullOpts.Mode = packages.LoadAllSyntax
-			pkgs, err = packages.Load(&fullOpts, pkgPaths...)
+
+			reloadedPkgs, err := packages.Load(&fullOpts, pkgPaths...)
 			if err != nil {
-				return fmt.Errorf("failed to reload packages with full mode: %w", err)
+				return nil, fmt.Errorf("failed to reload packages with complete type information: %w", err)
 			}
-		*/
+
+			// Replace the minimal packages with the fully loaded ones
+			pkgs = reloadedPkgs
+		} else {
+			// No packages to reload, use the original set
+			pkgs = allPkgs
+		}
 	}
 
 	// If DisableEmitBuiltin is false, we need to copy the builtin package to the output directory
@@ -206,6 +218,12 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 	// Track which gs packages have been processed to avoid duplicates
 	processedGsPackages := make(map[string]bool)
 
+	// Create a map of all loaded packages for dependency analysis
+	allPackages := make(map[string]*packages.Package)
+	for _, pkg := range pkgs {
+		allPackages[pkg.PkgPath] = pkg
+	}
+
 	// Compile all packages
 	for _, pkg := range pkgs {
 		// Check if the package has a handwritten equivalent
@@ -237,7 +255,7 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			continue
 		}
 
-		pkgCompiler, err := NewPackageCompiler(c.le, &c.config, pkg)
+		pkgCompiler, err := NewPackageCompiler(c.le, &c.config, pkg, allPackages)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create package compiler for %s: %w", pkg.PkgPath, err)
 		}
@@ -262,6 +280,7 @@ type PackageCompiler struct {
 	compilerConf *Config
 	outputPath   string
 	pkg          *packages.Package
+	allPackages  map[string]*packages.Package
 }
 
 // NewPackageCompiler creates a new `PackageCompiler` for a given Go package.
@@ -272,12 +291,14 @@ func NewPackageCompiler(
 	le *logrus.Entry,
 	compilerConf *Config,
 	pkg *packages.Package,
+	allPackages map[string]*packages.Package,
 ) (*PackageCompiler, error) {
 	res := &PackageCompiler{
 		le:           le,
 		pkg:          pkg,
 		compilerConf: compilerConf,
 		outputPath:   ComputeModulePath(compilerConf.OutputPath, pkg.PkgPath),
+		allPackages:  allPackages,
 	}
 
 	return res, nil
@@ -304,7 +325,10 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 	}
 
 	// Perform package-level analysis for auto-imports
-	packageAnalysis := AnalyzePackage(c.pkg)
+	packageAnalysis := AnalyzePackageImports(c.pkg)
+
+	// Perform comprehensive package-level analysis for code generation
+	analysis := AnalyzePackageFiles(c.pkg, c.allPackages)
 
 	// Track all compiled files for later generating the index.ts
 	compiledFiles := make([]string, 0, len(c.pkg.CompiledGoFiles))
@@ -342,7 +366,7 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 
 		// log just the filename
 		c.le.Debugf("GS: %s", filepath.Base(fileName))
-		if err := c.CompileFile(ctx, fileName, f, packageAnalysis); err != nil {
+		if err := c.CompileFile(ctx, fileName, f, analysis, packageAnalysis); err != nil {
 			return err
 		}
 
@@ -392,6 +416,7 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 		// Find which symbols this file exports
 		var valueSymbols []string
 		var typeSymbols []string
+		var structSymbols []string // New: Track structs separately
 
 		// Find the corresponding syntax file
 		for i, syntax := range c.pkg.Syntax {
@@ -415,9 +440,15 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 						switch s := spec.(type) {
 						case *ast.TypeSpec:
 							if s.Name.IsExported() {
-								// All type declarations (interfaces, structs, type definitions, type aliases)
-								// become TypeScript types and must be exported with "export type"
-								typeSymbols = append(typeSymbols, s.Name.Name)
+								// Check if this is a struct type
+								if _, isStruct := s.Type.(*ast.StructType); isStruct {
+									// Structs become TypeScript classes and need both type and value exports
+									structSymbols = append(structSymbols, s.Name.Name)
+								} else {
+									// Other type declarations (interfaces, type definitions, type aliases)
+									// become TypeScript types and must be exported with "export type"
+									typeSymbols = append(typeSymbols, s.Name.Name)
+								}
 							}
 						case *ast.ValueSpec:
 							for _, name := range s.Names {
@@ -442,6 +473,17 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 			}
 		}
 
+		// Write struct exports (both as types and values)
+		if len(structSymbols) > 0 {
+			sort.Strings(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)
+			if _, err := indexFile.WriteString(exportLine); err != nil {
+				return err
+			}
+		}
+
 		if len(typeSymbols) > 0 {
 			sort.Strings(typeSymbols)
 			exportLine := fmt.Sprintf("export type { %s } from \"./%s.js\"\n",
@@ -456,21 +498,11 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 }
 
 // CompileFile handles the compilation of a single Go source file to TypeScript.
-// It first performs a pre-compilation analysis of the file using `AnalyzeFile`
-// to gather information necessary for accurate TypeScript generation (e.g.,
-// about varRefing, async functions, defer statements).
+// It uses the pre-computed package-level analysis for accurate TypeScript generation
+// (e.g., about varRefing, async functions, defer statements, receiver usage across files).
 // Then, it creates a `FileCompiler` instance for the file and invokes its
 // `Compile` method to generate the TypeScript code.
-func (p *PackageCompiler) CompileFile(ctx context.Context, name string, syntax *ast.File, packageAnalysis *PackageAnalysis) error {
-	// Create a new analysis instance for per-file data
-	analysis := NewAnalysis()
-
-	// Create comment map for the file
-	cmap := ast.NewCommentMap(p.pkg.Fset, syntax, syntax.Comments)
-
-	// Analyze the file before compiling
-	AnalyzeFile(syntax, p.pkg, analysis, cmap)
-
+func (p *PackageCompiler) CompileFile(ctx context.Context, name string, syntax *ast.File, analysis *Analysis, packageAnalysis *PackageAnalysis) error {
 	fileCompiler, err := NewFileCompiler(p.compilerConf, p.pkg, syntax, name, analysis, packageAnalysis)
 	if err != nil {
 		return err
@@ -644,9 +676,6 @@ type GoToTSCompiler struct {
 	pkg *packages.Package
 
 	analysis *Analysis
-
-	// shadowingContext tracks temporary variable mappings when we're in a shadowing context
-	shadowingContext map[string]string
 }
 
 // It initializes the compiler with a `TSCodeWriter` for output,
@@ -654,10 +683,9 @@ 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,
-		shadowingContext: make(map[string]string),
+		tsw:      tsw,
+		pkg:      pkg,
+		analysis: analysis,
 	}
 }
 
@@ -679,9 +707,9 @@ func (c *GoToTSCompiler) WriteIdent(exp *ast.Ident, accessVarRefedValue bool) {
 		return
 	}
 
-	// Check if we're in a shadowing context and should use a temporary variable
-	if tempVarName, exists := c.shadowingContext[exp.Name]; exists {
-		c.tsw.WriteLiterally(c.sanitizeIdentifier(tempVarName))
+	// Check if this identifier has a pre-computed mapping (e.g., wrapper function receiver)
+	if mappedName := c.analysis.GetIdentifierMapping(exp); mappedName != "" {
+		c.tsw.WriteLiterally(c.sanitizeIdentifier(mappedName))
 		return
 	}
 
@@ -1036,97 +1064,33 @@ func (c *Compiler) copyEmbeddedPackage(embeddedPath string, outputPath string) e
 // GsPackageMetadata holds metadata about a gs/ package
 type GsPackageMetadata struct {
 	// Dependencies lists the import paths that this gs/ package requires
-	Dependencies []string
+	Dependencies []string        `json:"dependencies,omitempty"`
+	AsyncMethods map[string]bool `json:"asyncMethods,omitempty"`
 }
 
-// ReadGsPackageMetadata reads dependency metadata from .go files in a gs/ package
-// It looks for a var variable named "GsDependencies" which should be a slice of strings
-// containing the import paths that this package depends on.
+// ReadGsPackageMetadata reads dependency metadata from meta.json file in a gs/ package
 func (c *Compiler) ReadGsPackageMetadata(gsSourcePath string) (*GsPackageMetadata, error) {
 	metadata := &GsPackageMetadata{
 		Dependencies: []string{},
+		AsyncMethods: make(map[string]bool),
 	}
 
-	// Check if there are any .go files in the gs package directory
-	entries, err := gs.GsOverrides.ReadDir(gsSourcePath)
+	// Try to read meta.json file
+	metaFilePath := filepath.Join(gsSourcePath, "meta.json")
+	content, err := gs.GsOverrides.ReadFile(metaFilePath)
 	if err != nil {
-		return metadata, nil // No metadata files, return empty metadata
+		// No meta.json file found, return empty metadata
+		return metadata, nil
 	}
 
-	// Look for .go files containing metadata
-	for _, entry := range entries {
-		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".go") {
-			metadataFilePath := filepath.Join(gsSourcePath, entry.Name())
-
-			// Read the .go file content
-			content, err := gs.GsOverrides.ReadFile(metadataFilePath)
-			if err != nil {
-				continue // Skip files we can't read
-			}
-
-			// Parse the file to extract metadata
-			if deps, err := c.extractDependenciesFromGoFile(content); err == nil {
-				metadata.Dependencies = append(metadata.Dependencies, deps...)
-			}
-		}
+	// Parse the JSON content
+	if err := json.Unmarshal(content, metadata); err != nil {
+		return metadata, fmt.Errorf("failed to parse meta.json in %s: %w", gsSourcePath, err)
 	}
 
 	return metadata, nil
 }
 
-// extractDependenciesFromGoFile parses a .go file and extracts the GsDependencies var
-func (c *Compiler) extractDependenciesFromGoFile(content []byte) ([]string, error) {
-	// Parse the Go file
-	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "metadata.go", content, 0)
-	if err != nil {
-		return nil, err
-	}
-
-	var dependencies []string
-
-	// Look for var declarations
-	for _, decl := range file.Decls {
-		if genDecl, ok := decl.(*ast.GenDecl); ok && genDecl.Tok == token.VAR {
-			for _, spec := range genDecl.Specs {
-				if valueSpec, ok := spec.(*ast.ValueSpec); ok {
-					for i, name := range valueSpec.Names {
-						if name.Name == "GsDependencies" {
-							// Found the GsDependencies var, extract its value
-							if i < len(valueSpec.Values) {
-								if deps := c.extractStringSliceFromExpr(valueSpec.Values[i]); deps != nil {
-									dependencies = append(dependencies, deps...)
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
-	return dependencies, nil
-}
-
-// extractStringSliceFromExpr extracts string values from a composite literal expression
-func (c *Compiler) extractStringSliceFromExpr(expr ast.Expr) []string {
-	var result []string
-
-	if compLit, ok := expr.(*ast.CompositeLit); ok {
-		for _, elt := range compLit.Elts {
-			if basicLit, ok := elt.(*ast.BasicLit); ok && basicLit.Kind == token.STRING {
-				// Remove quotes from string literal
-				value := basicLit.Value
-				if len(value) >= 2 && value[0] == '"' && value[len(value)-1] == '"' {
-					result = append(result, value[1:len(value)-1])
-				}
-			}
-		}
-	}
-
-	return result
-}
-
 // copyGsPackageWithDependencies copies a gs/ package and all its dependencies recursively
 // It tracks already processed packages to avoid infinite loops and duplicate work
 func (c *Compiler) copyGsPackageWithDependencies(packagePath string, processedPackages map[string]bool, result *CompilationResult) error {

package/compiler/decl.go

@@ -3,6 +3,7 @@ package compiler
 import (
 	"fmt"
 	"go/ast"
+	"go/types"
 )
 
 // WriteDecls iterates through a slice of Go top-level declarations (`ast.Decl`)
@@ -193,6 +194,27 @@ func (c *GoToTSCompiler) writeMethodSignature(decl *ast.FuncDecl) (bool, error)
 	var isAsync bool
 	if obj := c.pkg.TypesInfo.Defs[decl.Name]; obj != nil {
 		isAsync = c.analysis.IsAsyncFunc(obj)
+
+		// Check if this method must be async due to interface constraints
+		if !isAsync && decl.Recv != nil && len(decl.Recv.List) > 0 {
+			// Get the receiver type
+			receiverType := decl.Recv.List[0].Type
+			if starExpr, ok := receiverType.(*ast.StarExpr); ok {
+				receiverType = starExpr.X
+			}
+
+			if ident, ok := receiverType.(*ast.Ident); ok {
+				// Get the named type for this receiver
+				if receiverObj := c.pkg.TypesInfo.Uses[ident]; receiverObj != nil {
+					if namedType, ok := receiverObj.Type().(*types.Named); ok {
+						// Check if this method must be async due to interface constraints
+						if c.analysis.MustBeAsyncDueToInterface(namedType, decl.Name.Name) {
+							isAsync = true
+						}
+					}
+				}
+			}
+		}
 	}
 
 	// Methods are typically public in the TS output

package/compiler/expr-call-async.go

@@ -6,70 +6,64 @@ import (
 	"strings"
 )
 
-// writeAsyncCall writes the await prefix for async function calls
-func (c *GoToTSCompiler) writeAsyncCall(exp *ast.CallExpr, funIdent *ast.Ident) bool {
-	if funIdent == nil {
+// writeAsyncCallIfNeeded writes the await prefix for async function or method calls
+// Returns true if await was written, false otherwise
+func (c *GoToTSCompiler) writeAsyncCallIfNeeded(exp *ast.CallExpr) bool {
+	switch fun := exp.Fun.(type) {
+	case *ast.Ident:
+		// Function call (e.g., func())
+		if obj := c.pkg.TypesInfo.Uses[fun]; obj != nil && c.analysis.IsAsyncFunc(obj) {
+			c.tsw.WriteLiterally("await ")
+			return true
+		}
 		return false
-	}
-
-	// Check if this is an async function call
-	if obj := c.pkg.TypesInfo.Uses[funIdent]; obj != nil && c.analysis.IsAsyncFunc(obj) {
-		c.tsw.WriteLiterally("await ")
-		return true
-	}
 
-	return false
-}
+	case *ast.SelectorExpr:
+		// Method call (e.g., obj.method())
+		ident, ok := fun.X.(*ast.Ident)
+		if !ok {
+			return false
+		}
 
-// writeAsyncMethodCall writes the await prefix for async method calls
-func (c *GoToTSCompiler) writeAsyncMethodCall(exp *ast.CallExpr) bool {
-	selExpr, ok := exp.Fun.(*ast.SelectorExpr)
-	if !ok {
-		return false
-	}
+		// Get the type of the receiver
+		obj := c.pkg.TypesInfo.Uses[ident]
+		if obj == nil {
+			return false
+		}
 
-	// Check if this is a method call on a variable (e.g., mu.Lock())
-	ident, ok := selExpr.X.(*ast.Ident)
-	if !ok {
-		return false
-	}
+		varObj, ok := obj.(*types.Var)
+		if !ok {
+			return false
+		}
 
-	// Get the type of the receiver
-	obj := c.pkg.TypesInfo.Uses[ident]
-	if obj == nil {
-		return false
-	}
+		// Get the type name and package
+		namedType, ok := varObj.Type().(*types.Named)
+		if !ok {
+			return false
+		}
 
-	varObj, ok := obj.(*types.Var)
-	if !ok {
-		return false
-	}
+		typeName := namedType.Obj().Name()
+		methodName := fun.Sel.Name
 
-	// Get the type name and package
-	namedType, ok := varObj.Type().(*types.Named)
-	if !ok {
-		return false
-	}
+		// Check if the type is from an imported package
+		typePkg := namedType.Obj().Pkg()
+		if typePkg == nil || typePkg == c.pkg.Types {
+			return false
+		}
 
-	typeName := namedType.Obj().Name()
-	methodName := selExpr.Sel.Name
+		// Use the full package path from the type information (not just the package name)
+		pkgPath := typePkg.Path()
 
-	// Check if the type is from an imported package
-	typePkg := namedType.Obj().Pkg()
-	if typePkg == nil || typePkg == c.pkg.Types {
+		// Check if this method is async based on metadata
+		if c.analysis.IsMethodAsync(pkgPath, typeName, methodName) {
+			c.tsw.WriteLiterally("await ")
+			return true
+		}
 		return false
-	}
 
-	// Use the actual package name from the type information
-	pkgName := typePkg.Name()
-
-	// Check if this method is async based on metadata
-	if c.analysis.IsMethodAsync(pkgName, typeName, methodName) {
-		c.tsw.WriteLiterally("await ")
-		return true
+	default:
+		return false
 	}
-
-	return false
 }
 
 // addNonNullAssertion adds ! for function calls that might return null