goscript 0.0.25 → 0.0.28

package/compiler/compiler.go

@@ -4,15 +4,15 @@ import (
 	"context"
 	"fmt"
 	"go/ast"
+	"go/constant"
 	"go/token"
 	"go/types"
 	"os"
 	"path/filepath"
 	"slices"
+	"sort"
 	"strings"
 
-	"go/constant"
-
 	gs "github.com/aperturerobotics/goscript"
 	"github.com/sirupsen/logrus"
 	"golang.org/x/tools/go/packages"
@@ -146,6 +146,18 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 
 			// Visit all imports, including standard library packages
 			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
+				}
+
 				visit(imp)
 			}
 		}
@@ -239,29 +251,6 @@ func (c *Compiler) CompilePackages(ctx context.Context, patterns ...string) (*Co
 			continue
 		}
 
-		// Check if this is the unsafe package, which is not supported in GoScript
-		if pkg.PkgPath == "unsafe" {
-			// Find which package depends on unsafe by looking at the import graph
-			var dependentPackages []string
-			for _, otherPkg := range pkgs {
-				if otherPkg.PkgPath != "unsafe" {
-					for importPath := range otherPkg.Imports {
-						if importPath == "unsafe" {
-							dependentPackages = append(dependentPackages, otherPkg.PkgPath)
-							break
-						}
-					}
-				}
-			}
-
-			dependentList := "unknown package"
-			if len(dependentPackages) > 0 {
-				dependentList = strings.Join(dependentPackages, ", ")
-			}
-
-			return nil, fmt.Errorf("cannot compile package 'unsafe': GoScript does not support the unsafe package due to its low-level memory operations that are incompatible with TypeScript/JavaScript. This package is required by: %s. Consider using alternative approaches that don't require unsafe operations", dependentList)
-		}
-
 		pkgCompiler, err := NewPackageCompiler(c.le, &c.config, pkg)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create package compiler for %s: %w", pkg.PkgPath, err)
@@ -326,6 +315,9 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 		}
 	}
 
+	// Perform package-level analysis for auto-imports
+	packageAnalysis := AnalyzePackage(c.pkg)
+
 	// Track all compiled files for later generating the index.ts
 	compiledFiles := make([]string, 0, len(c.pkg.CompiledGoFiles))
 
@@ -337,13 +329,35 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 			return err
 		}
 
+		// Check if this is a .pb.go file that should be skipped
+		baseFileName := filepath.Base(fileName)
+		if strings.HasSuffix(baseFileName, ".pb.go") {
+			// Check if there's a corresponding .pb.ts file
+			pbTsFileName := strings.TrimSuffix(baseFileName, ".pb.go") + ".pb.ts"
+			packageDir := filepath.Dir(fileName)
+			pbTsPath := filepath.Join(packageDir, pbTsFileName)
+
+			if _, err := os.Stat(pbTsPath); err == nil {
+				// .pb.ts file exists, copy it instead of transpiling .pb.go
+				c.le.WithField("file", relWdFileName).Debug("found .pb.ts file, copying instead of transpiling .pb.go")
+
+				if err := c.copyProtobufTSFile(pbTsPath, pbTsFileName); err != nil {
+					return fmt.Errorf("failed to copy protobuf .pb.ts file: %w", err)
+				}
+
+				// Add the .pb file to our compiled files list for index generation
+				pbFileName := strings.TrimSuffix(baseFileName, ".pb.go") + ".pb"
+				compiledFiles = append(compiledFiles, pbFileName)
+				continue // Skip transpiling this .pb.go file
+			}
+		}
+
 		c.le.WithField("file", relWdFileName).Debug("compiling file")
-		if err := c.CompileFile(ctx, fileName, f); err != nil {
+		if err := c.CompileFile(ctx, fileName, f, packageAnalysis); err != nil {
 			return err
 		}
 
 		// Add the base filename to our list for the index.ts generation
-		baseFileName := filepath.Base(fileName)
 		// Strip .go extension and add .gs
 		gsFileName := strings.TrimSuffix(baseFileName, ".go") + ".gs"
 		compiledFiles = append(compiledFiles, gsFileName)
@@ -358,8 +372,9 @@ func (c *PackageCompiler) Compile(ctx context.Context) error {
 }
 
 // generateIndexFile creates an index.ts file in the package output directory
-// that re-exports all symbols from the compiled TypeScript files.
-// This ensures the package can be imported correctly by TypeScript modules.
+// that re-exports only Go-exported symbols from the compiled TypeScript files.
+// This ensures the package can be imported correctly by TypeScript modules
+// while maintaining proper Go package boundaries.
 func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 	indexFilePath := filepath.Join(c.outputPath, "index.ts")
 
@@ -370,12 +385,128 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 	}
 	defer indexFile.Close() //nolint:errcheck
 
-	// Write the re-export statements for each compiled file
+	// Collect exported symbols from all files in the package
+	var exportedSymbols []string
+
+	// Iterate through all syntax files to find exported symbols
+	for i, syntax := range c.pkg.Syntax {
+		fileName := c.pkg.CompiledGoFiles[i]
+		baseFileName := filepath.Base(fileName)
+		gsFileName := strings.TrimSuffix(baseFileName, ".go") + ".gs"
+
+		// Only include this file if it was compiled (in our compiledFiles list)
+		fileWasCompiled := false
+		for _, compiledFile := range compiledFiles {
+			if compiledFile == gsFileName {
+				fileWasCompiled = true
+				break
+			}
+		}
+		if !fileWasCompiled {
+			continue
+		}
+
+		// Analyze declarations in this file to find exported symbols
+		for _, decl := range syntax.Decls {
+			switch d := decl.(type) {
+			case *ast.FuncDecl:
+				// Only include top-level functions (not methods)
+				if d.Recv == nil && d.Name.IsExported() {
+					exportedSymbols = append(exportedSymbols, d.Name.Name)
+				}
+			case *ast.GenDecl:
+				for _, spec := range d.Specs {
+					switch s := spec.(type) {
+					case *ast.TypeSpec:
+						if s.Name.IsExported() {
+							exportedSymbols = append(exportedSymbols, s.Name.Name)
+						}
+					case *ast.ValueSpec:
+						for _, name := range s.Names {
+							if name.IsExported() {
+								exportedSymbols = append(exportedSymbols, name.Name)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Remove duplicates and sort
+	symbolMap := make(map[string]bool)
+	for _, symbol := range exportedSymbols {
+		symbolMap[symbol] = true
+	}
+
+	var uniqueSymbols []string
+	for symbol := range symbolMap {
+		uniqueSymbols = append(uniqueSymbols, symbol)
+	}
+
+	// Sort for consistent output
+	sort.Strings(uniqueSymbols)
+
+	// Write selective re-exports for each compiled file
 	for _, fileName := range compiledFiles {
-		// Create the re-export line: export * from "./file.gs.js"
-		exportLine := fmt.Sprintf("export * from \"./%s.js\"\n", fileName)
-		if _, err := indexFile.WriteString(exportLine); err != nil {
-			return err
+		// Check if this is a protobuf file
+		if strings.HasSuffix(fileName, ".pb") {
+			// For protobuf files, add a simple re-export
+			pbTsFileName := fileName + ".ts"
+			if err := c.writeProtobufExports(indexFile, fileName, pbTsFileName); err != nil {
+				return err
+			}
+			continue
+		}
+
+		// Find which symbols this file exports
+		var fileSymbols []string
+
+		// Find the corresponding syntax file
+		for i, syntax := range c.pkg.Syntax {
+			syntaxFileName := c.pkg.CompiledGoFiles[i]
+			syntaxBaseFileName := filepath.Base(syntaxFileName)
+			syntaxGsFileName := strings.TrimSuffix(syntaxBaseFileName, ".go") + ".gs"
+
+			if syntaxGsFileName != fileName {
+				continue
+			}
+
+			// Collect exported symbols from this specific file
+			for _, decl := range syntax.Decls {
+				switch d := decl.(type) {
+				case *ast.FuncDecl:
+					if d.Recv == nil && d.Name.IsExported() {
+						fileSymbols = append(fileSymbols, d.Name.Name)
+					}
+				case *ast.GenDecl:
+					for _, spec := range d.Specs {
+						switch s := spec.(type) {
+						case *ast.TypeSpec:
+							if s.Name.IsExported() {
+								fileSymbols = append(fileSymbols, s.Name.Name)
+							}
+						case *ast.ValueSpec:
+							for _, name := range s.Names {
+								if name.IsExported() {
+									fileSymbols = append(fileSymbols, name.Name)
+								}
+							}
+						}
+					}
+				}
+			}
+			break
+		}
+
+		// Write selective export if this file has exported symbols
+		if len(fileSymbols) > 0 {
+			sort.Strings(fileSymbols)
+			exportLine := fmt.Sprintf("export { %s } from \"./%s.js\"\n",
+				strings.Join(fileSymbols, ", "), fileName)
+			if _, err := indexFile.WriteString(exportLine); err != nil {
+				return err
+			}
 		}
 	}
 
@@ -388,7 +519,7 @@ func (c *PackageCompiler) generateIndexFile(compiledFiles []string) error {
 // about varRefing, async functions, defer statements).
 // 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) error {
+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()
 
@@ -398,7 +529,7 @@ func (p *PackageCompiler) CompileFile(ctx context.Context, name string, syntax *
 	// Analyze the file before compiling
 	AnalyzeFile(syntax, p.pkg, analysis, cmap)
 
-	fileCompiler, err := NewFileCompiler(p.compilerConf, p.pkg, syntax, name, analysis)
+	fileCompiler, err := NewFileCompiler(p.compilerConf, p.pkg, syntax, name, analysis, packageAnalysis)
 	if err != nil {
 		return err
 	}
@@ -410,12 +541,13 @@ func (p *PackageCompiler) CompileFile(ctx context.Context, name string, syntax *
 // initializes the `TSCodeWriter` for TypeScript code generation, and uses a
 // `GoToTSCompiler` to translate Go declarations and statements.
 type FileCompiler struct {
-	compilerConfig *Config
-	codeWriter     *TSCodeWriter
-	pkg            *packages.Package
-	ast            *ast.File
-	fullPath       string
-	Analysis       *Analysis
+	compilerConfig  *Config
+	codeWriter      *TSCodeWriter
+	pkg             *packages.Package
+	ast             *ast.File
+	fullPath        string
+	Analysis        *Analysis
+	PackageAnalysis *PackageAnalysis
 }
 
 // NewFileCompiler creates a new `FileCompiler` for a specific Go file.
@@ -428,13 +560,15 @@ func NewFileCompiler(
 	astFile *ast.File,
 	fullPath string,
 	analysis *Analysis,
+	packageAnalysis *PackageAnalysis,
 ) (*FileCompiler, error) {
 	return &FileCompiler{
-		compilerConfig: compilerConf,
-		pkg:            pkg,
-		ast:            astFile,
-		fullPath:       fullPath,
-		Analysis:       analysis,
+		compilerConfig:  compilerConf,
+		pkg:             pkg,
+		ast:             astFile,
+		fullPath:        fullPath,
+		Analysis:        analysis,
+		PackageAnalysis: packageAnalysis,
 	}, nil
 }
 
@@ -468,7 +602,26 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 
 	// Add import for the goscript runtime using namespace import and alias
 	c.codeWriter.WriteLinef("import * as $ from %q;", "@goscript/builtin/builtin.js")
-	c.codeWriter.WriteLine("") // Add a newline after the import
+
+	// Check if there are any .pb.go files in this package and add imports for them
+	if err := c.addProtobufImports(); err != nil {
+		return fmt.Errorf("failed to add protobuf imports: %w", err)
+	}
+
+	// Generate auto-imports for functions from other files in the same package
+	currentFileName := strings.TrimSuffix(filepath.Base(c.fullPath), ".go")
+	if imports := c.PackageAnalysis.FunctionCalls[currentFileName]; imports != nil {
+		for sourceFile, functions := range imports {
+			if len(functions) > 0 {
+				// Sort functions for consistent output
+				sort.Strings(functions)
+				c.codeWriter.WriteLinef("import { %s } from \"./%s.gs.js\";",
+					strings.Join(functions, ", "), sourceFile)
+			}
+		}
+	}
+
+	c.codeWriter.WriteLine("") // Add a newline after imports
 
 	if err := goWriter.WriteDecls(f.Decls); err != nil {
 		return fmt.Errorf("failed to write declarations: %w", err)
@@ -483,7 +636,6 @@ func (c *FileCompiler) Compile(ctx context.Context) error {
 // decisions about code generation (e.g., varRefing, async behavior).
 type GoToTSCompiler struct {
 	tsw *TSCodeWriter
-
 	pkg *packages.Package
 
 	analysis *Analysis

package/compiler/compiler_test.go

@@ -1,6 +1,7 @@
 package compiler_test
 
 import (
+	"context"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -11,7 +12,9 @@ import (
 	"sync/atomic"
 	"testing"
 
+	"github.com/aperturerobotics/goscript/compiler"
 	"github.com/aperturerobotics/goscript/compliance"
+	"github.com/sirupsen/logrus"
 )
 
 // NOTE: this is here instead of compliance/compliance_test.go so coverage ends up in this package.
@@ -137,3 +140,53 @@ func getParentGoModulePath() (string, error) {
 	}
 	return strings.TrimSpace(string(output)), nil
 }
+
+func TestUnsafePackageCompilation(t *testing.T) {
+	// Create a temporary directory for the test output
+	tempDir, err := os.MkdirTemp("", "goscript-test-unsafe")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Setup logger
+	log := logrus.New()
+	log.SetLevel(logrus.DebugLevel)
+	le := logrus.NewEntry(log)
+
+	// Test with AllDependencies=true and DisableEmitBuiltin=false to ensure handwritten packages are copied
+	config := &compiler.Config{
+		OutputPath:         tempDir,
+		AllDependencies:    true,
+		DisableEmitBuiltin: false, // This ensures handwritten packages are copied to output
+	}
+
+	comp, err := compiler.NewCompiler(config, le, nil)
+	if err != nil {
+		t.Fatalf("Failed to create compiler: %v", err)
+	}
+
+	// Try to compile a package that has dependencies that import unsafe
+	// We'll use "sync/atomic" which imports unsafe but doesn't have a handwritten equivalent
+	result, err := comp.CompilePackages(context.Background(), "sync/atomic")
+	// This should now succeed since we have a handwritten unsafe package
+	if err != nil {
+		t.Fatalf("Expected compilation to succeed with handwritten unsafe package, but it failed: %v", err)
+	}
+
+	// Verify that the unsafe package was copied (not compiled) since it has a handwritten equivalent
+	if !slices.Contains(result.CopiedPackages, "unsafe") {
+		t.Errorf("Expected unsafe package to be in CopiedPackages, but it wasn't. CopiedPackages: %v", result.CopiedPackages)
+	}
+
+	// Verify that sync/atomic was compiled
+	if !slices.Contains(result.CompiledPackages, "sync/atomic") {
+		t.Errorf("Expected sync/atomic package to be in CompiledPackages, but it wasn't. CompiledPackages: %v", result.CompiledPackages)
+	}
+
+	// Check that the unsafe package directory exists in the output
+	unsafePath := filepath.Join(tempDir, "@goscript/unsafe")
+	if _, err := os.Stat(unsafePath); os.IsNotExist(err) {
+		t.Errorf("unsafe package directory was not created at %s", unsafePath)
+	}
+}

package/compiler/composite-lit.go

@@ -199,18 +199,34 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 				if underlyingStruct, ok := namedType.Underlying().(*types.Struct); ok {
 					structType = underlyingStruct
 					isStructLiteral = true
-					// Named struct, use constructor
-					c.tsw.WriteLiterally("new ")
-					c.WriteTypeExpr(exp.Type)
+
+					// Check if this is a protobuf type
+					if handled, err := c.writeProtobufCompositeLit(exp, litType); handled {
+						if err != nil {
+							return err
+						}
+					} else {
+						// Named struct, use constructor
+						c.tsw.WriteLiterally("new ")
+						c.WriteTypeExpr(exp.Type)
+					}
 				}
 			} else if ptrType, ok := litType.(*types.Pointer); ok {
 				if namedElem, ok := ptrType.Elem().(*types.Named); ok {
 					if underlyingStruct, ok := namedElem.Underlying().(*types.Struct); ok {
 						structType = underlyingStruct
 						isStructLiteral = true // Treat pointer-to-struct literal similarly
-						// Named struct pointer, use constructor
-						c.tsw.WriteLiterally("new ")
-						c.WriteTypeExpr(exp.Type)
+
+						// Check if this is a protobuf type
+						if handled, err := c.writeProtobufCompositeLit(exp, litType); handled {
+							if err != nil {
+								return err
+							}
+						} else {
+							// Named struct pointer, use constructor
+							c.tsw.WriteLiterally("new ")
+							c.WriteTypeExpr(exp.Type)
+						}
 					}
 				}
 			} else if underlyingStruct, ok := litType.Underlying().(*types.Struct); ok {
@@ -339,7 +355,11 @@ func (c *GoToTSCompiler) WriteCompositeLit(exp *ast.CompositeLit) error {
 					if firstFieldWritten {
 						c.tsw.WriteLiterally(", ")
 					}
-					c.tsw.WriteLiterally(keyName)
+
+					// Convert field name for protobuf types
+					fieldName := c.convertProtobufFieldNameInLiteral(keyName, litType)
+
+					c.tsw.WriteLiterally(fieldName)
 					c.tsw.WriteLiterally(": ")
 					if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
 						return err
@@ -538,7 +558,11 @@ func (c *GoToTSCompiler) writeUntypedStructLiteral(exp *ast.CompositeLit, struct
 		if firstFieldWritten {
 			c.tsw.WriteLiterally(", ")
 		}
-		c.tsw.WriteLiterally(keyName)
+
+		// Convert field name for protobuf types
+		fieldName := c.convertProtobufFieldNameInLiteral(keyName, structType.Underlying())
+
+		c.tsw.WriteLiterally(fieldName)
 		c.tsw.WriteLiterally(": ")
 		if err := c.WriteVarRefedValue(directFields[keyName]); err != nil {
 			return err

package/compiler/decl.go

@@ -68,11 +68,9 @@ func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
 		c.WriteDoc(decl.Doc)
 	}
 
-	// Exported functions start with uppercase in Go, or special-case "main" entry point
-	isExported := decl.Name.IsExported() || decl.Name.Name == "main"
-	if isExported {
-		c.tsw.WriteLiterally("export ")
-	}
+	// Export all functions for intra-package visibility
+	// This allows other files in the same package to import functions
+	c.tsw.WriteLiterally("export ")
 
 	// Check if this function is async using the analysis data
 	var isAsync bool
@@ -233,7 +231,9 @@ func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
 		if recvName != "_" {
 			c.tsw.WriteLine("{")
 			c.tsw.Indent(1)
-			c.tsw.WriteLinef("const %s = this", recvName)
+			// Sanitize the receiver name to avoid conflicts with TypeScript reserved words
+			sanitizedRecvName := c.sanitizeIdentifier(recvName)
+			c.tsw.WriteLinef("const %s = this", sanitizedRecvName)
 
 			// Add using statement if needed
 			if c.analysis.NeedsDefer(decl.Body) {

package/compiler/expr-call.go

@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"strings"
 
 	"github.com/pkg/errors"
 )
@@ -38,6 +39,11 @@ import (
 func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 	expFun := exp.Fun
 
+	// Handle protobuf method calls
+	if handled, err := c.writeProtobufMethodCall(exp); handled {
+		return err
+	}
+
 	// Handle any type conversion with nil argument
 	if len(exp.Args) == 1 {
 		if nilIdent, isIdent := exp.Args[0].(*ast.Ident); isIdent && nilIdent.Name == "nil" {
@@ -325,6 +331,53 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 										}
 									}
 								}
+							} else {
+								// Handle named types with slice underlying types: make(NamedSliceType, len, cap)
+								// This handles cases like: type appendSliceWriter []byte; make(appendSliceWriter, 0, len(s))
+								namedType := typeName.Type()
+								if sliceType, isSlice := namedType.Underlying().(*types.Slice); isSlice {
+									goElemType := sliceType.Elem()
+
+									// Check if it's a named type with []byte underlying type
+									if basicElem, isBasic := goElemType.(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
+										c.tsw.WriteLiterally("new Uint8Array(")
+										if len(exp.Args) >= 2 {
+											if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+												return err
+											}
+											// Capacity argument for make([]byte, len, cap) is ignored for new Uint8Array(len)
+										} else {
+											// If no length is provided, default to 0
+											c.tsw.WriteLiterally("0")
+										}
+										c.tsw.WriteLiterally(")")
+										return nil // Handled make for named []byte type
+									}
+
+									// Handle other named slice types
+									c.tsw.WriteLiterally("$.makeSlice<")
+									c.WriteGoType(goElemType, GoTypeContextGeneral) // Write the element type
+									c.tsw.WriteLiterally(">(")
+
+									if len(exp.Args) >= 2 {
+										if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Length
+											return err
+										}
+										if len(exp.Args) == 3 {
+											c.tsw.WriteLiterally(", ")
+											if err := c.WriteValueExpr(exp.Args[2]); err != nil { // Capacity
+												return err
+											}
+										} else if len(exp.Args) > 3 {
+											return errors.New("makeSlice expects 2 or 3 arguments")
+										}
+									} else {
+										// If no length is provided, default to 0
+										c.tsw.WriteLiterally("0")
+									}
+									c.tsw.WriteLiterally(")")
+									return nil // Handled make for named slice type
+								}
 							}
 						}
 					}
@@ -554,6 +607,36 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 			return nil // Handled regular function call
 		}
 	} else {
+		// Check if this is an async method call (e.g., mu.Lock())
+		if selExpr, ok := expFun.(*ast.SelectorExpr); ok {
+			// Check if this is a method call on a variable (e.g., mu.Lock())
+			if ident, ok := selExpr.X.(*ast.Ident); ok {
+				// Get the type of the receiver
+				if obj := c.pkg.TypesInfo.Uses[ident]; obj != nil {
+					if varObj, ok := obj.(*types.Var); ok {
+						// Get the type name and package
+						if namedType, ok := varObj.Type().(*types.Named); ok {
+							typeName := namedType.Obj().Name()
+							methodName := selExpr.Sel.Name
+
+							// Check if the type is from an imported package
+							if typePkg := namedType.Obj().Pkg(); typePkg != nil && typePkg != c.pkg.Types {
+								pkgPath := typePkg.Path()
+								// Extract package name from path (e.g., "sync" from "github.com/.../gs/sync")
+								parts := strings.Split(pkgPath, "/")
+								pkgName := parts[len(parts)-1]
+
+								// Check if this method is async based on metadata
+								if c.analysis.IsMethodAsync(pkgName, typeName, methodName) {
+									c.tsw.WriteLiterally("await ")
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
 		// If expFun is a function literal, it needs to be wrapped in parentheses for IIFE syntax
 		if _, isFuncLit := expFun.(*ast.FuncLit); isFuncLit {
 			c.tsw.WriteLiterally("(")

package/compiler/expr.go

@@ -388,7 +388,7 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		isBitwise = true
 	}
 
-	// Special handling for large bit shift expressions that would overflow in JavaScript
+	// Handle large bit shift expressions that would overflow in JavaScript
 	if exp.Op == token.SHL {
 		// Check if this is 1 << 63 pattern
 		if leftLit, leftIsLit := exp.X.(*ast.BasicLit); leftIsLit && leftLit.Value == "1" {