goscript 0.0.49 → 0.0.50

package/compiler/analysis_test.go

@@ -160,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
@@ -170,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)
@@ -269,18 +268,16 @@ func TestWrapperTypeDetection(t *testing.T) {
 		t.Fatalf("Package has errors: %v", pkg.Errors[0])
 	}
 
-	// Run analysis on the first file
+	// Run package-level analysis
 	if len(pkg.Syntax) == 0 {
 		t.Fatal("No syntax files found")
 	}
 
-	analysis := NewAnalysis()
-	cmap := ast.NewCommentMap(pkg.Fset, pkg.Syntax[0], pkg.Syntax[0].Comments)
-	AnalyzeFile(pkg.Syntax[0], pkg, analysis, cmap)
+	analysis := AnalyzePackageFiles(pkg, nil)
 
-	// Verify the WrapperTypes map was initialized
-	if analysis.WrapperTypes == nil {
-		t.Error("WrapperTypes map was not initialized")
+	// 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
@@ -290,7 +287,7 @@ func TestWrapperTypeDetection(t *testing.T) {
 	// 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.IsWrapperType(typeName.Type())
+			isWrapper := analysis.IsNamedBasicType(typeName.Type())
 			if !isWrapper {
 				t.Errorf("MyMode should be detected as wrapper type, got %v", isWrapper)
 			}
@@ -301,7 +298,7 @@ func TestWrapperTypeDetection(t *testing.T) {
 	// 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.IsWrapperType(typeName.Type())
+			isWrapper := analysis.IsNamedBasicType(typeName.Type())
 			if isWrapper {
 				t.Errorf("MyDir should not be detected as wrapper type, got %v", isWrapper)
 			}
@@ -309,13 +306,13 @@ func TestWrapperTypeDetection(t *testing.T) {
 		}
 	}
 
-	t.Logf("Analysis completed successfully with %d wrapper types tracked", len(analysis.WrapperTypes))
+	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()
+	analysis := NewAnalysis(nil)
 
 	// Test package discovery using the embedded filesystem
 	packages := analysis.discoverEmbeddedGsPackages()

package/compiler/compiler.go

@@ -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

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

package/compiler/expr-call-type-conversion.go

@@ -81,7 +81,7 @@ func (c *GoToTSCompiler) writeArrayTypeConversion(exp *ast.CallExpr) (handled bo
 			// Check if the argument is a named type with a slice underlying type
 			if namedArgType, isNamed := argType.(*types.Named); isNamed {
 				// Check if the named type has receiver methods (is a wrapper type)
-				if c.analysis.IsWrapperType(namedArgType) {
+				if c.analysis.IsNamedBasicType(namedArgType) {
 					// Check if the underlying type matches the target slice type
 					if sliceUnderlying, isSlice := namedArgType.Underlying().(*types.Slice); isSlice {
 						// Get the target slice type
@@ -216,7 +216,7 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 				if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
 					if namedArgType, isNamed := argType.(*types.Named); isNamed {
 						// Check if the argument type is a wrapper type
-						if c.analysis.IsWrapperType(namedArgType) {
+						if c.analysis.IsNamedBasicType(namedArgType) {
 							// Check if we're converting to the underlying type
 							targetType := typeName.Type()
 							underlyingType := namedArgType.Underlying()
@@ -247,7 +247,7 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 					return true, nil
 				} else {
 					// Check if this is a wrapper type
-					isWrapperType := c.analysis.IsWrapperType(typeName.Type())
+					isWrapperType := c.analysis.IsNamedBasicType(typeName.Type())
 					if isWrapperType {
 						// For wrapper types, use type casting instead of constructor calls
 						c.tsw.WriteLiterally("(")
@@ -288,8 +288,6 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 						c.tsw.WriteLiterally(funIdent.String())
 						c.tsw.WriteLiterally("(")
 
-						fmt.Printf("DEBUG: Type conversion constructor for %s\n", funIdent.String())
-
 						// Use auto-wrapping for the constructor argument
 						// The constructor parameter type is the underlying type of the named type
 						// For MyMode (which is type MyMode os.FileMode), the constructor expects os.FileMode
@@ -299,8 +297,6 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 							constructorParamType = namedType.Underlying()
 						}
 
-						fmt.Printf("DEBUG: Constructor param type: %v\n", constructorParamType)
-
 						if err := c.writeAutoWrappedArgument(exp.Args[0], constructorParamType); err != nil {
 							return true, fmt.Errorf("failed to write argument for type constructor: %w", err)
 						}
@@ -376,7 +372,7 @@ func (c *GoToTSCompiler) writeIntConversion(exp *ast.CallExpr) error {
 	if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
 		if namedArgType, isNamed := argType.(*types.Named); isNamed {
 			// Check if the argument type is a wrapper type
-			if c.analysis.IsWrapperType(namedArgType) {
+			if c.analysis.IsNamedBasicType(namedArgType) {
 				// Check if we're converting to int (the underlying type)
 				if types.Identical(types.Typ[types.Int], namedArgType.Underlying()) {
 					// This is a conversion from a wrapper type to int
@@ -413,7 +409,7 @@ func (c *GoToTSCompiler) writeQualifiedTypeConversion(exp *ast.CallExpr, selecto
 				if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
 					if namedArgType, isNamed := argType.(*types.Named); isNamed {
 						// Check if the argument type is a wrapper type
-						if c.analysis.IsWrapperType(namedArgType) {
+						if c.analysis.IsNamedBasicType(namedArgType) {
 							// Check if we're converting to the underlying type
 							targetType := typeName.Type()
 							underlyingType := namedArgType.Underlying()
@@ -444,7 +440,7 @@ func (c *GoToTSCompiler) writeQualifiedTypeConversion(exp *ast.CallExpr, selecto
 					return true, nil
 				} else {
 					// Check if this is a wrapper type
-					isWrapperType := c.analysis.IsWrapperType(typeName.Type())
+					isWrapperType := c.analysis.IsNamedBasicType(typeName.Type())
 					if isWrapperType {
 						// For wrapper types, use type casting instead of constructor calls
 						c.tsw.WriteLiterally("(")

package/compiler/expr-call.go

@@ -74,7 +74,7 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 		}
 
 		// Check if this is an async function call
-		_ = c.writeAsyncCall(exp, funIdent)
+		c.writeAsyncCallIfNeeded(exp)
 
 		// Not a special built-in, treat as a regular function call
 		if err := c.WriteValueExpr(expFun); err != nil {
@@ -99,7 +99,7 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 
 	// Handle non-identifier function expressions (method calls, function literals, etc.)
 	// Check if this is an async method call (e.g., mu.Lock())
-	_ = c.writeAsyncMethodCall(exp)
+	c.writeAsyncCallIfNeeded(exp)
 
 	// If expFun is a function literal, it needs to be wrapped in parentheses for IIFE syntax
 	if _, isFuncLit := expFun.(*ast.FuncLit); isFuncLit {
@@ -169,7 +169,7 @@ func (c *GoToTSCompiler) writeCallArguments(exp *ast.CallExpr) error {
 func (c *GoToTSCompiler) writeArgumentWithTypeHandling(arg ast.Expr, funcSig *types.Signature, argIndex int) error {
 	if funcSig != nil && argIndex < funcSig.Params().Len() {
 		paramType := funcSig.Params().At(argIndex).Type()
-		isWrapper := c.analysis.IsWrapperType(paramType)
+		isWrapper := c.analysis.IsNamedBasicType(paramType)
 
 		if isWrapper {
 			// For wrapper types (now type aliases), no auto-wrapping is needed
@@ -234,7 +234,7 @@ func (c *GoToTSCompiler) getImportAlias(pkgPath string) string {
 func (c *GoToTSCompiler) writeAutoWrappedArgument(arg ast.Expr, expectedType types.Type) error {
 	// For wrapper types (now type aliases), no auto-wrapping is needed
 	// Just use type casting if the types don't match exactly
-	if c.analysis.IsWrapperType(expectedType) {
+	if c.analysis.IsNamedBasicType(expectedType) {
 		argType := c.pkg.TypesInfo.TypeOf(arg)
 
 		// Only add type casting if needed
@@ -271,39 +271,70 @@ func (c *GoToTSCompiler) writeWrapperTypeMethodCall(exp *ast.CallExpr, selectorE
 		return false, nil
 	}
 
-	// Check if this is a wrapper type
-	if !c.analysis.IsWrapperType(baseType) {
+	// Check if this is a wrapper type using the analysis
+	isWrapperType := c.analysis.IsNamedBasicType(baseType)
+
+	// Special handling for type aliases to basic types that might have wrapper functions
+	// Even if IsNamedBasicType returns false, we should check for known wrapper type patterns
+	var typeName string
+	if !isWrapperType {
+		// Check if this is a type alias to a basic type that might have wrapper methods
+		if aliasType, ok := baseType.(*types.Alias); ok {
+			if aliasType.Obj() != nil && aliasType.Obj().Pkg() != nil {
+				// Check if the underlying type is a basic type
+				underlying := aliasType.Underlying()
+				if _, isBasic := underlying.(*types.Basic); isBasic {
+					// This is a type alias to a basic type - treat it as a potential wrapper type
+					isWrapperType = true
+					if aliasType.Obj().Pkg() != c.pkg.Types {
+						// Imported type alias like os.FileMode
+						if importAlias := c.getImportAlias(aliasType.Obj().Pkg().Path()); importAlias != "" {
+							typeName = importAlias + "." + aliasType.Obj().Name()
+						} else {
+							typeName = aliasType.Obj().Name()
+						}
+					} else {
+						// Local type alias
+						typeName = aliasType.Obj().Name()
+					}
+				}
+			}
+		}
+	}
+
+	if !isWrapperType {
 		return false, nil
 	}
 
-	// Get the type name for the function call
-	var typeName string
-	if namedType, ok := baseType.(*types.Named); ok {
-		if obj := namedType.Obj(); obj != nil {
-			if obj.Pkg() != nil && obj.Pkg() != c.pkg.Types {
-				// Imported type like os.FileMode
-				if importAlias := c.getImportAlias(obj.Pkg().Path()); importAlias != "" {
-					typeName = importAlias + "." + obj.Name()
+	// Get the type name for the function call if not already set
+	if typeName == "" {
+		if namedType, ok := baseType.(*types.Named); ok {
+			if obj := namedType.Obj(); obj != nil {
+				if obj.Pkg() != nil && obj.Pkg() != c.pkg.Types {
+					// Imported type like os.FileMode
+					if importAlias := c.getImportAlias(obj.Pkg().Path()); importAlias != "" {
+						typeName = importAlias + "." + obj.Name()
+					} else {
+						typeName = obj.Name()
+					}
 				} else {
+					// Local type
 					typeName = obj.Name()
 				}
-			} else {
-				// Local type
-				typeName = obj.Name()
 			}
-		}
-	} else if aliasType, ok := baseType.(*types.Alias); ok {
-		if obj := aliasType.Obj(); obj != nil {
-			if obj.Pkg() != nil && obj.Pkg() != c.pkg.Types {
-				// Imported type alias
-				if importAlias := c.getImportAlias(obj.Pkg().Path()); importAlias != "" {
-					typeName = importAlias + "." + obj.Name()
+		} else if aliasType, ok := baseType.(*types.Alias); ok {
+			if obj := aliasType.Obj(); obj != nil {
+				if obj.Pkg() != nil && obj.Pkg() != c.pkg.Types {
+					// Imported type alias
+					if importAlias := c.getImportAlias(obj.Pkg().Path()); importAlias != "" {
+						typeName = importAlias + "." + obj.Name()
+					} else {
+						typeName = obj.Name()
+					}
 				} else {
+					// Local type alias
 					typeName = obj.Name()
 				}
-			} else {
-				// Local type alias
-				typeName = obj.Name()
 			}
 		}
 	}

package/compiler/spec-value.go

@@ -237,7 +237,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 					// Check if this is a named type with methods and the initializer is a basic value
 					if namedType, isNamed := goType.(*types.Named); isNamed {
 						// Check if this is a wrapper type first
-						isWrapperType := c.analysis.IsWrapperType(namedType)
+						isWrapperType := c.analysis.IsNamedBasicType(namedType)
 						if isWrapperType {
 							// For wrapper types, no constructor wrapping needed
 							if shouldApplyClone(c.pkg, initializerExpr) {
@@ -334,7 +334,7 @@ func (c *GoToTSCompiler) WriteValueSpec(a *ast.ValueSpec) error {
 				// No initializer, use the zero value directly
 				// Check if this is a wrapper type first
 				if namedType, isNamed := goType.(*types.Named); isNamed {
-					isWrapperType := c.analysis.IsWrapperType(namedType)
+					isWrapperType := c.analysis.IsNamedBasicType(namedType)
 					if isWrapperType {
 						// For wrapper types, just use zero value directly
 						c.WriteZeroValueForType(goType)