goscript 0.0.48 → 0.0.50

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

@@ -80,9 +80,8 @@ func (c *GoToTSCompiler) writeArrayTypeConversion(exp *ast.CallExpr) (handled bo
 		if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
 			// 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 class)
-				typeName := namedArgType.Obj().Name()
-				if c.hasReceiverMethods(typeName) {
+				// Check if the named type has receiver methods (is a wrapper type)
+				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
@@ -90,12 +89,11 @@ func (c *GoToTSCompiler) writeArrayTypeConversion(exp *ast.CallExpr) (handled bo
 						if targetSliceType, isTargetSlice := targetType.Underlying().(*types.Slice); isTargetSlice {
 							// Check if element types are compatible
 							if types.Identical(sliceUnderlying.Elem(), targetSliceType.Elem()) {
-								// This is a conversion from NamedType to []T where NamedType has underlying []T
-								// Use valueOf() to get the underlying slice
+								// This is a conversion from wrapper slice type to []T
+								// Since wrapper types are now type aliases, just write the value directly
 								if err := c.WriteValueExpr(arg); err != nil {
 									return true, fmt.Errorf("failed to write argument for slice type conversion: %w", err)
 								}
-								c.tsw.WriteLiterally(".valueOf()")
 								return true, nil
 							}
 						}
@@ -217,19 +215,17 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 				// Check if we're converting FROM a type with receiver methods TO its underlying type
 				if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
 					if namedArgType, isNamed := argType.(*types.Named); isNamed {
-						argTypeName := namedArgType.Obj().Name()
-						// Check if the argument type has receiver methods
-						if c.hasReceiverMethods(argTypeName) {
+						// Check if the argument type is a wrapper type
+						if c.analysis.IsNamedBasicType(namedArgType) {
 							// Check if we're converting to the underlying type
 							targetType := typeName.Type()
 							underlyingType := namedArgType.Underlying()
 							if types.Identical(targetType, underlyingType) {
-								// This is a conversion from a type with methods to its underlying type
-								// Use valueOf() instead of TypeScript cast
+								// This is a conversion from a wrapper type to its underlying type
+								// Since wrapper types are now type aliases, just write the value directly
 								if err := c.WriteValueExpr(arg); err != nil {
-									return true, fmt.Errorf("failed to write argument for valueOf conversion: %w", err)
+									return true, fmt.Errorf("failed to write argument for type conversion: %w", err)
 								}
-								c.tsw.WriteLiterally(".valueOf()")
 								return true, nil
 							}
 						}
@@ -250,29 +246,111 @@ func (c *GoToTSCompiler) writeTypeConversion(exp *ast.CallExpr, funIdent *ast.Id
 					c.tsw.WriteLiterallyf(", { __goTypeName: '%s' })", funIdent.String())
 					return true, nil
 				} else {
+					// Check if this is a wrapper type
+					isWrapperType := c.analysis.IsNamedBasicType(typeName.Type())
+					if isWrapperType {
+						// For wrapper types, use type casting instead of constructor calls
+						c.tsw.WriteLiterally("(")
+						if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+							return true, fmt.Errorf("failed to write argument for wrapper type cast: %w", err)
+						}
+						c.tsw.WriteLiterally(" as ")
+						c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
+						c.tsw.WriteLiterally(")")
+						return true, nil
+					}
+
+					// Check if this is a simple named type (no methods, not struct, not interface)
+					if namedType, ok := typeName.Type().(*types.Named); ok {
+						// Don't use constructors for simple named types without methods
+						if namedType.NumMethods() == 0 {
+							// Exclude struct and interface types - they should still use constructors
+							if _, isStruct := namedType.Underlying().(*types.Struct); !isStruct {
+								if _, isInterface := namedType.Underlying().(*types.Interface); !isInterface {
+									// Simple named type without methods - use type casting
+									c.tsw.WriteLiterally("(")
+									if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+										return true, fmt.Errorf("failed to write argument for simple named type cast: %w", err)
+									}
+									c.tsw.WriteLiterally(" as ")
+									c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
+									c.tsw.WriteLiterally(")")
+									return true, nil
+								}
+							}
+						}
+					}
+
 					// Check if this type has receiver methods
 					if c.hasReceiverMethods(funIdent.String()) {
-						// For types with methods, use class constructor
+						// For types with methods that are NOT wrapper types, still use class constructor
 						c.tsw.WriteLiterally("new ")
 						c.tsw.WriteLiterally(funIdent.String())
 						c.tsw.WriteLiterally("(")
-						if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+
+						// 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
+						constructorParamType := typeName.Type()
+						if namedType, ok := typeName.Type().(*types.Named); ok {
+							// For named types, the constructor expects the underlying type
+							constructorParamType = namedType.Underlying()
+						}
+
+						if err := c.writeAutoWrappedArgument(exp.Args[0], constructorParamType); err != nil {
 							return true, fmt.Errorf("failed to write argument for type constructor: %w", err)
 						}
 						c.tsw.WriteLiterally(")")
 						return true, nil
 					} else {
-						// For non-function types without methods, use the TypeScript "as" operator
-						c.tsw.WriteLiterally("(")
-						if err := c.WriteValueExpr(exp.Args[0]); err != nil {
-							return true, fmt.Errorf("failed to write argument for type cast: %w", err)
+						// Determine if this type should use constructor syntax
+						shouldUseConstructor := false
+
+						// Check if it's a type alias (like os.FileMode)
+						if alias, isAlias := typeName.Type().(*types.Alias); isAlias {
+							// For type aliases, check the underlying type
+							if _, isInterface := alias.Underlying().(*types.Interface); !isInterface {
+								if _, isStruct := alias.Underlying().(*types.Struct); !isStruct {
+									// For non-struct, non-interface type aliases, use constructor
+									shouldUseConstructor = true
+								}
+							}
+						} else if namedType, isNamed := typeName.Type().(*types.Named); isNamed {
+							// For named types, check if they have receiver methods in the current package
+							// or if they follow the pattern of non-struct, non-interface named types
+							if c.hasReceiverMethods(funIdent.String()) {
+								shouldUseConstructor = true
+							} else if _, isInterface := namedType.Underlying().(*types.Interface); !isInterface {
+								if _, isStruct := namedType.Underlying().(*types.Struct); !isStruct {
+									// For non-struct, non-interface named types, use constructor
+									shouldUseConstructor = true
+								}
+							}
 						}
 
-						// Then use the TypeScript "as" operator with the mapped type name
-						c.tsw.WriteLiterally(" as ")
-						c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
-						c.tsw.WriteLiterally(")")
-						return true, nil
+						if shouldUseConstructor {
+							// For types that should use constructors, use class constructor
+							c.tsw.WriteLiterally("new ")
+							c.tsw.WriteLiterally(funIdent.String())
+							c.tsw.WriteLiterally("(")
+							if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+								return true, fmt.Errorf("failed to write argument for type constructor: %w", err)
+							}
+							c.tsw.WriteLiterally(")")
+							return true, nil
+						} else {
+							// For types that don't need constructors, use the TypeScript "as" operator
+							c.tsw.WriteLiterally("(")
+							if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+								return true, fmt.Errorf("failed to write argument for type cast: %w", err)
+							}
+
+							// Then use the TypeScript "as" operator with the mapped type name
+							c.tsw.WriteLiterally(" as ")
+							c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
+							c.tsw.WriteLiterally(")")
+							return true, nil
+						}
 					}
 				}
 			}
@@ -293,17 +371,15 @@ func (c *GoToTSCompiler) writeIntConversion(exp *ast.CallExpr) error {
 	// Check if we're converting FROM a type with receiver methods TO int
 	if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
 		if namedArgType, isNamed := argType.(*types.Named); isNamed {
-			argTypeName := namedArgType.Obj().Name()
-			// Check if the argument type has receiver methods
-			if c.hasReceiverMethods(argTypeName) {
+			// Check if the argument type is a wrapper type
+			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 type with methods to int
-					// Use valueOf() instead of $.int()
+					// This is a conversion from a wrapper type to int
+					// Since wrapper types are now type aliases, just write the value directly
 					if err := c.WriteValueExpr(arg); err != nil {
-						return fmt.Errorf("failed to write argument for valueOf conversion: %w", err)
+						return fmt.Errorf("failed to write argument for int conversion: %w", err)
 					}
-					c.tsw.WriteLiterally(".valueOf()")
 					return nil
 				}
 			}
@@ -332,19 +408,17 @@ func (c *GoToTSCompiler) writeQualifiedTypeConversion(exp *ast.CallExpr, selecto
 				// Check if we're converting FROM a type with receiver methods TO its underlying type
 				if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
 					if namedArgType, isNamed := argType.(*types.Named); isNamed {
-						argTypeName := namedArgType.Obj().Name()
-						// Check if the argument type has receiver methods
-						if c.hasReceiverMethods(argTypeName) {
+						// Check if the argument type is a wrapper type
+						if c.analysis.IsNamedBasicType(namedArgType) {
 							// Check if we're converting to the underlying type
 							targetType := typeName.Type()
 							underlyingType := namedArgType.Underlying()
 							if types.Identical(targetType, underlyingType) {
-								// This is a conversion from a type with methods to its underlying type
-								// Use valueOf() instead of TypeScript cast
+								// This is a conversion from a wrapper type to its underlying type
+								// Since wrapper types are now type aliases, just write the value directly
 								if err := c.WriteValueExpr(arg); err != nil {
-									return true, fmt.Errorf("failed to write argument for valueOf conversion: %w", err)
+									return true, fmt.Errorf("failed to write argument for type conversion: %w", err)
 								}
-								c.tsw.WriteLiterally(".valueOf()")
 								return true, nil
 							}
 						}
@@ -365,33 +439,44 @@ func (c *GoToTSCompiler) writeQualifiedTypeConversion(exp *ast.CallExpr, selecto
 					c.tsw.WriteLiterallyf(", { __goTypeName: '%s' })", selectorExpr.Sel.Name)
 					return true, nil
 				} else {
-					// Determine if this type should use constructor syntax
-					shouldUseConstructor := false
-
-					// Check if it's a type alias (like os.FileMode)
-					if alias, isAlias := typeName.Type().(*types.Alias); isAlias {
-						// For type aliases, check the underlying type
-						if _, isInterface := alias.Underlying().(*types.Interface); !isInterface {
-							if _, isStruct := alias.Underlying().(*types.Struct); !isStruct {
-								// For non-struct, non-interface type aliases, use constructor
-								shouldUseConstructor = true
-							}
+					// Check if this is a wrapper type
+					isWrapperType := c.analysis.IsNamedBasicType(typeName.Type())
+					if isWrapperType {
+						// For wrapper types, use type casting instead of constructor calls
+						c.tsw.WriteLiterally("(")
+						if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+							return true, fmt.Errorf("failed to write argument for wrapper type cast: %w", err)
 						}
-					} else if namedType, isNamed := typeName.Type().(*types.Named); isNamed {
-						// For named types, check if they have receiver methods in the current package
-						// or if they follow the pattern of non-struct, non-interface named types
-						if c.hasReceiverMethods(selectorExpr.Sel.Name) {
-							shouldUseConstructor = true
-						} else if _, isInterface := namedType.Underlying().(*types.Interface); !isInterface {
+						c.tsw.WriteLiterally(" as ")
+						c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
+						c.tsw.WriteLiterally(")")
+						return true, nil
+					}
+
+					// Check if this is a simple named type (no methods, not struct, not interface)
+					if namedType, ok := typeName.Type().(*types.Named); ok {
+						// Don't use constructors for simple named types without methods
+						if namedType.NumMethods() == 0 {
+							// Exclude struct and interface types - they should still use constructors
 							if _, isStruct := namedType.Underlying().(*types.Struct); !isStruct {
-								// For non-struct, non-interface named types, use constructor
-								shouldUseConstructor = true
+								if _, isInterface := namedType.Underlying().(*types.Interface); !isInterface {
+									// Simple named type without methods - use type casting
+									c.tsw.WriteLiterally("(")
+									if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+										return true, fmt.Errorf("failed to write argument for simple named type cast: %w", err)
+									}
+									c.tsw.WriteLiterally(" as ")
+									c.WriteGoType(typeName.Type(), GoTypeContextGeneral)
+									c.tsw.WriteLiterally(")")
+									return true, nil
+								}
 							}
 						}
 					}
 
-					if shouldUseConstructor {
-						// For types that should use constructors, use class constructor
+					// Check if this type has receiver methods
+					if c.hasReceiverMethods(selectorExpr.Sel.Name) {
+						// For types with methods that are NOT wrapper types, still use class constructor
 						c.tsw.WriteLiterally("new ")
 						if err := c.WriteSelectorExpr(selectorExpr); err != nil {
 							return true, fmt.Errorf("failed to write qualified type name: %w", err)

package/compiler/expr-call.go

@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"strings"
 )
 
 // WriteCallExpr translates a Go function call expression (`ast.CallExpr`)
@@ -73,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 {
@@ -89,11 +90,16 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 		if handled, err := c.writeQualifiedTypeConversion(exp, selectorExpr); handled {
 			return err
 		}
+
+		// Handle wrapper type method calls: obj.Method() -> TypeName_Method(obj, ...)
+		if handled, err := c.writeWrapperTypeMethodCall(exp, selectorExpr); handled {
+			return err
+		}
 	}
 
 	// 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 {
@@ -123,27 +129,244 @@ func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
 // writeCallArguments writes the argument list for a function call
 func (c *GoToTSCompiler) writeCallArguments(exp *ast.CallExpr) error {
 	c.tsw.WriteLiterally("(")
+
+	// Get function signature for parameter type checking
+	var funcSig *types.Signature
+	if c.pkg != nil && c.pkg.TypesInfo != nil {
+		if funcType := c.pkg.TypesInfo.TypeOf(exp.Fun); funcType != nil {
+			if sig, ok := funcType.(*types.Signature); ok {
+				funcSig = sig
+			}
+		}
+	}
+
 	for i, arg := range exp.Args {
 		if i != 0 {
 			c.tsw.WriteLiterally(", ")
 		}
 		// Check if this is the last argument and we have ellipsis (variadic call)
 		if exp.Ellipsis != token.NoPos && i == len(exp.Args)-1 {
-			c.tsw.WriteLiterally("...")
+			c.tsw.WriteLiterally("...(")
+			// Write the argument
+			if err := c.writeArgumentWithTypeHandling(arg, funcSig, i); err != nil {
+				return err
+			}
+			// Add null coalescing for slice spread to prevent TypeScript errors
+			c.tsw.WriteLiterally(" ?? [])")
+			continue
 		}
-		if err := c.WriteValueExpr(arg); err != nil {
-			return fmt.Errorf("failed to write argument %d in call: %w", i, err)
+
+		if err := c.writeArgumentWithTypeHandling(arg, funcSig, i); err != nil {
+			return err
 		}
-		// Add non-null assertion for spread arguments that might be null
-		if exp.Ellipsis != token.NoPos && i == len(exp.Args)-1 {
-			// Check if the argument type is potentially nullable (slice)
-			if argType := c.pkg.TypesInfo.TypeOf(arg); argType != nil {
-				if _, isSlice := argType.Underlying().(*types.Slice); isSlice {
-					c.tsw.WriteLiterally("!")
+	}
+
+	c.tsw.WriteLiterally(")")
+	return nil
+}
+
+// writeArgumentWithTypeHandling writes a single argument with proper type handling
+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.IsNamedBasicType(paramType)
+
+		if isWrapper {
+			// For wrapper types (now type aliases), no auto-wrapping is needed
+			// Just use type casting if the types don't match exactly
+			argType := c.pkg.TypesInfo.TypeOf(arg)
+
+			// Only add type casting if needed
+			if argType != nil && !types.Identical(argType, paramType) {
+				c.tsw.WriteLiterally("(")
+				if err := c.WriteValueExpr(arg); err != nil {
+					return fmt.Errorf("failed to write argument for type cast: %w", err)
+				}
+				c.tsw.WriteLiterally(" as ")
+				c.WriteGoType(paramType, GoTypeContextGeneral)
+				c.tsw.WriteLiterally(")")
+			} else {
+				// Types match, just write the argument directly
+				if err := c.WriteValueExpr(arg); err != nil {
+					return fmt.Errorf("failed to write argument: %w", err)
 				}
 			}
+			return nil
 		}
 	}
-	c.tsw.WriteLiterally(")")
+
+	// For non-wrapper types, normal argument writing
+	if err := c.WriteValueExpr(arg); err != nil {
+		return fmt.Errorf("failed to write argument: %w", err)
+	}
+	return nil
+}
+
+// getImportAlias returns the import alias for a given package path
+func (c *GoToTSCompiler) getImportAlias(pkgPath string) string {
+	if c.analysis == nil {
+		return ""
+	}
+
+	// First try to find by exact package path
+	for importAlias := range c.analysis.Imports {
+		if importInfo := c.analysis.Imports[importAlias]; importInfo != nil {
+			if importInfo.importPath == pkgPath {
+				return importAlias
+			}
+		}
+	}
+
+	// Fallback: try to match by package name extracted from path
+	parts := strings.Split(pkgPath, "/")
+	defaultPkgName := parts[len(parts)-1]
+
+	for importAlias := range c.analysis.Imports {
+		if importAlias == defaultPkgName {
+			return importAlias
+		}
+	}
+
+	return ""
+}
+
+// writeAutoWrappedArgument writes an argument, auto-wrapping it if needed based on the expected parameter type
+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.IsNamedBasicType(expectedType) {
+		argType := c.pkg.TypesInfo.TypeOf(arg)
+
+		// Only add type casting if needed
+		if argType != nil && !types.Identical(argType, expectedType) {
+			c.tsw.WriteLiterally("(")
+			if err := c.WriteValueExpr(arg); err != nil {
+				return fmt.Errorf("failed to write argument for wrapper type cast: %w", err)
+			}
+			c.tsw.WriteLiterally(" as ")
+			c.WriteGoType(expectedType, GoTypeContextGeneral)
+			c.tsw.WriteLiterally(")")
+		} else {
+			// Types match, just write the argument directly
+			if err := c.WriteValueExpr(arg); err != nil {
+				return fmt.Errorf("failed to write argument: %w", err)
+			}
+		}
+		return nil
+	}
+
+	// For non-wrapper types, normal argument writing
+	if err := c.WriteValueExpr(arg); err != nil {
+		return fmt.Errorf("failed to write argument: %w", err)
+	}
 	return nil
 }
+
+// writeWrapperTypeMethodCall handles method calls on wrapper types by converting them to function calls
+// obj.Method(args) -> TypeName_Method(obj, args)
+func (c *GoToTSCompiler) writeWrapperTypeMethodCall(exp *ast.CallExpr, selectorExpr *ast.SelectorExpr) (handled bool, err error) {
+	// Get the type of the base expression (the receiver)
+	baseType := c.pkg.TypesInfo.TypeOf(selectorExpr.X)
+	if baseType == nil {
+		return false, nil
+	}
+
+	// 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 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 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()
+				}
+			}
+		}
+	}
+
+	if typeName == "" {
+		return false, nil
+	}
+
+	// Write the function call: TypeName_MethodName(receiver, args...)
+	c.tsw.WriteLiterally(typeName)
+	c.tsw.WriteLiterally("_")
+	c.tsw.WriteLiterally(selectorExpr.Sel.Name)
+	c.tsw.WriteLiterally("(")
+
+	// First argument is the receiver
+	if err := c.WriteValueExpr(selectorExpr.X); err != nil {
+		return true, fmt.Errorf("failed to write wrapper type method receiver: %w", err)
+	}
+
+	// Add other arguments
+	if len(exp.Args) > 0 {
+		c.tsw.WriteLiterally(", ")
+		for i, arg := range exp.Args {
+			if i != 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			if err := c.WriteValueExpr(arg); err != nil {
+				return true, fmt.Errorf("failed to write wrapper type method argument %d: %w", i, err)
+			}
+		}
+	}
+
+	c.tsw.WriteLiterally(")")
+	return true, nil
+}