goscript 0.0.20 → 0.0.22

package/compiler/decl.go

@@ -0,0 +1,223 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+)
+
+// WriteDecls iterates through a slice of Go top-level declarations (`ast.Decl`)
+// and translates each one into its TypeScript equivalent.
+// It distinguishes between:
+// - Function declarations (`ast.FuncDecl`):
+//   - If it's a regular function (no receiver), it delegates to `WriteFuncDeclAsFunction`.
+//   - Methods (with receivers) are handled within `WriteTypeSpec` when their
+//     associated struct/type is defined, so they are skipped here.
+//   - General declarations (`ast.GenDecl`), which can contain imports, constants,
+//     variables, or type definitions: It iterates through `d.Specs` and calls
+//     `WriteSpec` for each specification.
+//
+// A newline is added after each processed declaration or spec group for readability.
+// Unknown declaration types result in a printed diagnostic message.
+func (c *GoToTSCompiler) WriteDecls(decls []ast.Decl) error {
+	for _, decl := range decls {
+		switch d := decl.(type) {
+		case *ast.FuncDecl:
+			// Only handle top-level functions here. Methods are handled within WriteTypeSpec.
+			if d.Recv == nil {
+				if err := c.WriteFuncDeclAsFunction(d); err != nil {
+					return err
+				}
+				c.tsw.WriteLine("") // Add space after function
+			}
+		case *ast.GenDecl:
+			for _, spec := range d.Specs {
+				if err := c.WriteSpec(spec); err != nil {
+					return err
+				}
+				c.tsw.WriteLine("") // Add space after spec
+			}
+		default:
+			fmt.Printf("unknown decl: %#v\n", decl)
+		}
+	}
+	return nil
+}
+
+// WriteFuncDeclAsFunction translates a Go function declaration (`ast.FuncDecl`)
+// that does not have a receiver (i.e., it's a regular function, not a method)
+// into a TypeScript function.
+//   - Go documentation comments (`decl.Doc`) are preserved.
+//   - If the Go function is exported (name starts with an uppercase letter) or is
+//     the `main` function, the `export` keyword is added to the TypeScript output.
+//   - If the `Analysis` data indicates the function is asynchronous, the `async`
+//     keyword is prepended.
+//   - The function signature (parameters and return type) is translated using `WriteFuncType`,
+//     passing the `isAsync` status.
+//   - The function body (`decl.Body`) is translated using `WriteStmt`.
+//
+// This function specifically handles top-level functions; methods are generated
+// by `WriteFuncDeclAsMethod` within the context of their type definition.
+func (c *GoToTSCompiler) WriteFuncDeclAsFunction(decl *ast.FuncDecl) error {
+	if decl.Recv != nil {
+		// This function should not be called for methods.
+		// Methods are handled by WriteFuncDeclAsMethod within WriteTypeSpec.
+		return nil
+	}
+
+	if decl.Doc != nil {
+		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 ")
+	}
+
+	// Check if this function is async using the analysis data
+	var isAsync bool
+	if obj := c.pkg.TypesInfo.Defs[decl.Name]; obj != nil {
+		isAsync = c.analysis.IsAsyncFunc(obj)
+	}
+	if isAsync {
+		c.tsw.WriteLiterally("async ")
+	}
+
+	c.tsw.WriteLiterally("function ")
+	if err := c.WriteValueExpr(decl.Name); err != nil { // Function name is a value identifier
+		return fmt.Errorf("failed to write function name: %w", err)
+	}
+
+	// WriteFuncType needs to be aware if the function is async
+	c.WriteFuncType(decl.Type, isAsync) // Write signature (params, return type)
+	c.tsw.WriteLiterally(" ")
+
+	if err := c.WriteStmt(decl.Body); err != nil {
+		return fmt.Errorf("failed to write function body: %w", err)
+	}
+
+	return nil
+}
+
+// WriteFuncDeclAsMethod translates a Go function declaration (`ast.FuncDecl`)
+// that has a receiver (i.e., it's a method) into a TypeScript class method.
+//   - It preserves Go documentation comments (`decl.Doc`).
+//   - The method is declared as `public`.
+//   - If the `Analysis` data indicates the method is asynchronous, the `async`
+//     keyword is prepended.
+//   - The method name retains its original Go casing.
+//   - Parameters and return types are translated using `WriteFieldList` and
+//     `WriteTypeExpr`, respectively. Async methods have their return types
+//     wrapped in `Promise<>`.
+//   - The method body is translated. If the Go receiver has a name (e.g., `(s *MyStruct)`),
+//     a `const receiverName = this;` binding is generated at the start of the
+//     TypeScript method body to make `this` available via the Go receiver's name.
+//     If the method body requires deferred cleanup (`NeedsDefer`), the appropriate
+//     `using __defer = new $.DisposableStack()` (or `AsyncDisposableStack`)
+//     is also generated.
+//
+// This function assumes it is called only for `FuncDecl` nodes that are methods.
+func (c *GoToTSCompiler) WriteFuncDeclAsMethod(decl *ast.FuncDecl) error {
+	if decl.Doc != nil {
+		c.WriteDoc(decl.Doc)
+	}
+
+	// Determine if method is async
+	var isAsync bool
+	if obj := c.pkg.TypesInfo.Defs[decl.Name]; obj != nil {
+		isAsync = c.analysis.IsAsyncFunc(obj)
+	}
+
+	// Methods are typically public in the TS output
+	c.tsw.WriteLiterally("public ")
+
+	// Add async modifier if needed
+	if isAsync {
+		c.tsw.WriteLiterally("async ")
+	}
+
+	// Keep original Go casing for method names
+	if err := c.WriteValueExpr(decl.Name); err != nil { // Method name is a value identifier
+		return err
+	}
+
+	// Write signature (parameters and return type)
+	// We adapt the logic from WriteFuncType here, but without the 'function' keyword
+	funcType := decl.Type
+	c.tsw.WriteLiterally("(")
+	if funcType.Params != nil {
+		c.WriteFieldList(funcType.Params, true) // true = arguments
+	}
+	c.tsw.WriteLiterally(")")
+
+	// Handle return type
+	if funcType.Results != nil && len(funcType.Results.List) > 0 {
+		c.tsw.WriteLiterally(": ")
+		if isAsync {
+			c.tsw.WriteLiterally("Promise<")
+		}
+		if len(funcType.Results.List) == 1 {
+			// Single return value
+			resultType := funcType.Results.List[0].Type
+			c.WriteTypeExpr(resultType)
+		} else {
+			// Multiple return values -> tuple type
+			c.tsw.WriteLiterally("[")
+			for i, field := range funcType.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.WriteTypeExpr(field.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		if isAsync {
+			c.tsw.WriteLiterally(">")
+		}
+	} else {
+		// No return value -> void
+		if isAsync {
+			c.tsw.WriteLiterally(": Promise<void>")
+		} else {
+			c.tsw.WriteLiterally(": void")
+		}
+	}
+
+	c.tsw.WriteLiterally(" ")
+
+	// Bind receiver name to this
+	if recvField := decl.Recv.List[0]; len(recvField.Names) > 0 {
+		recvName := recvField.Names[0].Name
+		if recvName != "_" {
+			c.tsw.WriteLine("{")
+			c.tsw.Indent(1)
+			c.tsw.WriteLinef("const %s = this", recvName)
+
+			// Add using statement if needed
+			if c.analysis.NeedsDefer(decl.Body) {
+				if c.analysis.IsInAsyncFunction(decl) {
+					c.tsw.WriteLine("await using __defer = new $.AsyncDisposableStack();")
+				} else {
+					c.tsw.WriteLine("using cleanup = new $.DisposableStack();")
+				}
+			}
+
+			// write method body without outer braces
+			for _, stmt := range decl.Body.List {
+				if err := c.WriteStmt(stmt); err != nil {
+					return fmt.Errorf("failed to write statement in function body: %w", err)
+				}
+			}
+			c.tsw.Indent(-1)
+			c.tsw.WriteLine("}")
+
+			return nil
+		}
+	}
+	// no named receiver, write whole body
+	if err := c.WriteStmt(decl.Body); err != nil {
+		return fmt.Errorf("failed to write function body: %w", err)
+	}
+
+	return nil
+}

package/compiler/expr-call.go

@@ -0,0 +1,423 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"github.com/pkg/errors"
+)
+
+// WriteCallExpr translates a Go function call expression (`ast.CallExpr`)
+// into its TypeScript equivalent.
+// It handles several Go built-in functions specially:
+// - `println(...)` becomes `console.log(...)`.
+// - `len(arg)` becomes `$.len(arg)`.
+// - `cap(arg)` becomes `$.cap(arg)`.
+// - `delete(m, k)` becomes `$.deleteMapEntry(m, k)`.
+// - `make(chan T, size)` becomes `$.makeChannel<T_ts>(size, zeroValueForT)`.
+// - `make(map[K]V)` becomes `$.makeMap<K_ts, V_ts>()`.
+// - `make([]T, len, cap)` becomes `$.makeSlice<T_ts>(len, cap)`.
+// - `string(runeVal)` becomes `String.fromCharCode(runeVal)`.
+// - `string([]runeVal)` or `string([]byteVal)` becomes `$.runesToString(sliceVal)`.
+// - `[]rune(stringVal)` becomes `$.stringToRunes(stringVal)`.
+// - `close(ch)` becomes `ch.close()`.
+// - `append(slice, elems...)` becomes `$.append(slice, elems...)`.
+// - `byte(val)` becomes `$.byte(val)`.
+// For other function calls:
+//   - If the `Analysis` data indicates the function is asynchronous (e.g., due to
+//     channel operations or `go`/`defer` usage within it), the call is prefixed with `await`.
+//   - Otherwise, it's translated as a standard TypeScript function call: `funcName(arg1, arg2)`.
+//
+// Arguments are recursively translated using `WriteValueExpr`.
+func (c *GoToTSCompiler) WriteCallExpr(exp *ast.CallExpr) error {
+	expFun := exp.Fun
+
+	// Handle any type conversion with nil argument
+	if len(exp.Args) == 1 {
+		if nilIdent, isIdent := exp.Args[0].(*ast.Ident); isIdent && nilIdent.Name == "nil" {
+			// Handle nil pointer to struct type conversions: (*struct{})(nil)
+			if starExpr, isStarExpr := expFun.(*ast.StarExpr); isStarExpr {
+				if _, isStructType := starExpr.X.(*ast.StructType); isStructType {
+					c.tsw.WriteLiterally("null")
+					return nil
+				}
+			}
+
+			c.tsw.WriteLiterally("null")
+			return nil
+		}
+	}
+
+	// Handle array type conversions like []rune(string)
+	if arrayType, isArrayType := expFun.(*ast.ArrayType); isArrayType {
+		// Check if it's a []rune type
+		if ident, isIdent := arrayType.Elt.(*ast.Ident); isIdent && ident.Name == "rune" {
+			// Check if the argument is a string
+			if len(exp.Args) == 1 {
+				arg := exp.Args[0]
+				if tv, ok := c.pkg.TypesInfo.Types[arg]; ok && tv.Type != nil {
+					if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && basic.Kind() == types.String {
+						// Translate []rune(stringValue) to $.stringToRunes(stringValue)
+						c.tsw.WriteLiterally("$.stringToRunes(")
+						if err := c.WriteValueExpr(arg); err != nil {
+							return fmt.Errorf("failed to write argument for []rune(string) conversion: %w", err)
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled []rune(string)
+					}
+				}
+			}
+		}
+	}
+
+	if funIdent, funIsIdent := expFun.(*ast.Ident); funIsIdent {
+		switch funIdent.String() {
+		case "println":
+			c.tsw.WriteLiterally("console.log(")
+			for i, arg := range exp.Args {
+				if i != 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				if err := c.WriteValueExpr(arg); err != nil {
+					return err
+				}
+			}
+			c.tsw.WriteLiterally(")")
+			return nil
+		case "len":
+			// Translate len(arg) to $.len(arg)
+			if len(exp.Args) == 1 {
+				c.tsw.WriteLiterally("$.len(")
+				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+					return err
+				}
+				c.tsw.WriteLiterally(")")
+				return nil // Handled len
+			}
+			return errors.New("unhandled len call with incorrect number of arguments")
+		case "cap":
+			// Translate cap(arg) to $.cap(arg)
+			if len(exp.Args) == 1 {
+				c.tsw.WriteLiterally("$.cap(")
+				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+					return err
+				}
+				c.tsw.WriteLiterally(")")
+				return nil // Handled cap
+			}
+			return errors.New("unhandled cap call with incorrect number of arguments")
+		case "delete":
+			// Translate delete(map, key) to $.deleteMapEntry(map, key)
+			if len(exp.Args) == 2 {
+				c.tsw.WriteLiterally("$.deleteMapEntry(")
+				if err := c.WriteValueExpr(exp.Args[0]); err != nil { // Map
+					return err
+				}
+				c.tsw.WriteLiterally(", ")
+				if err := c.WriteValueExpr(exp.Args[1]); err != nil { // Key
+					return err
+				}
+				c.tsw.WriteLiterally(")")
+				return nil // Handled delete
+			}
+			return errors.New("unhandled delete call with incorrect number of arguments")
+		case "make":
+			// First check if we have a channel type
+			if typ := c.pkg.TypesInfo.TypeOf(exp.Args[0]); typ != nil {
+				if chanType, ok := typ.Underlying().(*types.Chan); ok {
+					// Handle channel creation: make(chan T, bufferSize) or make(chan T)
+					c.tsw.WriteLiterally("$.makeChannel<")
+					c.WriteGoType(chanType.Elem())
+					c.tsw.WriteLiterally(">(")
+
+					// If buffer size is provided, add it
+					if len(exp.Args) >= 2 {
+						if err := c.WriteValueExpr(exp.Args[1]); err != nil {
+							return fmt.Errorf("failed to write buffer size in makeChannel: %w", err)
+						}
+					} else {
+						// Default to 0 (unbuffered channel)
+						c.tsw.WriteLiterally("0")
+					}
+
+					c.tsw.WriteLiterally(", ") // Add comma for zero value argument
+
+					// Write the zero value for the channel's element type
+					if chanType.Elem().String() == "struct{}" {
+						c.tsw.WriteLiterally("{}")
+					} else {
+						c.WriteZeroValueForType(chanType.Elem())
+					}
+
+					// Add direction parameter
+					c.tsw.WriteLiterally(", ")
+
+					// Determine channel direction
+					switch chanType.Dir() {
+					case types.SendRecv:
+						c.tsw.WriteLiterally("'both'")
+					case types.SendOnly:
+						c.tsw.WriteLiterally("'send'")
+					case types.RecvOnly:
+						c.tsw.WriteLiterally("'receive'")
+					default:
+						c.tsw.WriteLiterally("'both'") // Default to bidirectional
+					}
+
+					c.tsw.WriteLiterally(")")
+					return nil // Handled make for channel
+				}
+			}
+			// Handle make for slices: make([]T, len, cap) or make([]T, len)
+			if len(exp.Args) >= 1 {
+				// Handle map creation: make(map[K]V)
+				if mapType, ok := exp.Args[0].(*ast.MapType); ok {
+					c.tsw.WriteLiterally("$.makeMap<")
+					c.WriteTypeExpr(mapType.Key) // Write the key type
+					c.tsw.WriteLiterally(", ")
+					c.WriteTypeExpr(mapType.Value) // Write the value type
+					c.tsw.WriteLiterally(">()")
+					return nil // Handled make for map
+				}
+
+				// Handle slice creation
+				if _, ok := exp.Args[0].(*ast.ArrayType); ok {
+					// Get the slice type information
+					sliceType := c.pkg.TypesInfo.TypeOf(exp.Args[0])
+					if sliceType == nil {
+						return errors.New("could not get type information for slice in make call")
+					}
+					goElemType, ok := sliceType.Underlying().(*types.Slice)
+					if !ok {
+						return errors.New("expected slice type for make call")
+					}
+
+					c.tsw.WriteLiterally("$.makeSlice<")
+					c.WriteGoType(goElemType.Elem()) // 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 slice
+				}
+			}
+			// Fallthrough for unhandled make calls (e.g., channels)
+			return errors.New("unhandled make call")
+		case "string":
+			// Handle string() conversion
+			if len(exp.Args) == 1 {
+				arg := exp.Args[0]
+
+				// Case 1: Argument is a string literal string("...")
+				if basicLit, isBasicLit := arg.(*ast.BasicLit); isBasicLit && basicLit.Kind == token.STRING {
+					// Translate string("...") to "..." (no-op)
+					c.WriteBasicLit(basicLit)
+					return nil // Handled string literal conversion
+				}
+
+				// Case 2: Argument is a rune (int32) or a call to rune()
+				innerCall, isCallExpr := arg.(*ast.CallExpr)
+
+				if isCallExpr {
+					// Check if it's a call to rune()
+					if innerFunIdent, innerFunIsIdent := innerCall.Fun.(*ast.Ident); innerFunIsIdent && innerFunIdent.String() == "rune" {
+						// Translate string(rune(val)) to String.fromCharCode(val)
+						if len(innerCall.Args) == 1 {
+							c.tsw.WriteLiterally("String.fromCharCode(")
+							if err := c.WriteValueExpr(innerCall.Args[0]); err != nil {
+								return fmt.Errorf("failed to write argument for string(rune) conversion: %w", err)
+							}
+							c.tsw.WriteLiterally(")")
+							return nil // Handled string(rune)
+						}
+					}
+				}
+
+				// Handle direct string(int32) conversion
+				// This assumes 'rune' is int32
+				if tv, ok := c.pkg.TypesInfo.Types[arg]; ok {
+					if basic, isBasic := tv.Type.Underlying().(*types.Basic); isBasic && basic.Kind() == types.Int32 {
+						// Translate string(rune_val) to String.fromCharCode(rune_val)
+						c.tsw.WriteLiterally("String.fromCharCode(")
+						if err := c.WriteValueExpr(arg); err != nil {
+							return fmt.Errorf("failed to write argument for string(int32) conversion: %w", err)
+						}
+						c.tsw.WriteLiterally(")")
+						return nil // Handled string(int32)
+					}
+
+					// Case 3: Argument is a slice of runes or bytes string([]rune{...}) or string([]byte{...})
+					if sliceType, isSlice := tv.Type.Underlying().(*types.Slice); isSlice {
+						if basic, isBasic := sliceType.Elem().Underlying().(*types.Basic); isBasic {
+							// Handle both runes (int32) and bytes (uint8)
+							if basic.Kind() == types.Int32 || basic.Kind() == types.Uint8 {
+								// Translate string([]rune) or string([]byte) to $.runesToString(...)
+								c.tsw.WriteLiterally("$.runesToString(")
+								if err := c.WriteValueExpr(arg); err != nil {
+									return fmt.Errorf("failed to write argument for string([]rune/[]byte) conversion: %w", err)
+								}
+								c.tsw.WriteLiterally(")")
+								return nil // Handled string([]rune) or string([]byte)
+							}
+						}
+					}
+				}
+			}
+			// Return error for other unhandled string conversions
+			return fmt.Errorf("unhandled string conversion: %s", exp.Fun)
+		case "close":
+			// Translate close(ch) to ch.close()
+			if len(exp.Args) == 1 {
+				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+					return fmt.Errorf("failed to write channel in close call: %w", err)
+				}
+				c.tsw.WriteLiterally(".close()")
+				return nil // Handled close
+			}
+			return errors.New("unhandled close call with incorrect number of arguments")
+		case "append":
+			// Translate append(slice, elements...) to $.append(slice, elements...)
+			if len(exp.Args) >= 1 {
+				c.tsw.WriteLiterally("$.append(")
+				// The first argument is the slice
+				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+					return fmt.Errorf("failed to write slice in append call: %w", err)
+				}
+				// The remaining arguments are the elements to append
+				for i, arg := range exp.Args[1:] {
+					if i > 0 || len(exp.Args) > 1 { // Add comma before elements if there are any
+						c.tsw.WriteLiterally(", ")
+					}
+					if err := c.WriteValueExpr(arg); err != nil {
+						return fmt.Errorf("failed to write argument %d in append call: %w", i+1, err)
+					}
+				}
+				c.tsw.WriteLiterally(")")
+				return nil // Handled append
+			}
+			return errors.New("unhandled append call with incorrect number of arguments")
+		case "byte":
+			// Translate byte(val) to $.byte(val)
+			if len(exp.Args) == 1 {
+				c.tsw.WriteLiterally("$.byte(")
+				if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+					return err
+				}
+				c.tsw.WriteLiterally(")")
+				return nil // Handled byte
+			}
+			return errors.New("unhandled byte call with incorrect number of arguments")
+		default:
+			// Check if this is a type conversion to a function type
+			if funIdent != nil {
+				if obj := c.pkg.TypesInfo.Uses[funIdent]; obj != nil {
+					// Check if the object is a type name
+					if typeName, isType := obj.(*types.TypeName); isType {
+						// Make sure we have exactly one argument
+						if len(exp.Args) == 1 {
+							// Check if this is a function type
+							if _, isFuncType := typeName.Type().Underlying().(*types.Signature); isFuncType {
+								// For function types, we need to add a __goTypeName property
+								c.tsw.WriteLiterally("Object.assign(")
+
+								// Write the argument first
+								if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+									return fmt.Errorf("failed to write argument for function type cast: %w", err)
+								}
+
+								// Add the __goTypeName property with the function type name
+								c.tsw.WriteLiterallyf(", { __goTypeName: '%s' })", funIdent.String())
+								return nil // Handled function type cast
+							} else {
+								// For non-function types, use the TypeScript "as" operator
+								c.tsw.WriteLiterally("(")
+								if err := c.WriteValueExpr(exp.Args[0]); err != nil {
+									return fmt.Errorf("failed to write argument for type cast: %w", err)
+								}
+
+								// Then use the TypeScript "as" operator with the type name
+								c.tsw.WriteLiterallyf(" as %s)", funIdent.String())
+								return nil // Handled non-function type cast
+							}
+						}
+					}
+				}
+			}
+
+			// Check if this is an async function call
+			if funIdent != nil {
+				// Get the object for this function identifier
+				if obj := c.pkg.TypesInfo.Uses[funIdent]; obj != nil && c.analysis.IsAsyncFunc(obj) {
+					// This is an async function
+					c.tsw.WriteLiterally("await ")
+				}
+			}
+
+			// Not a special built-in, treat as a regular function call
+			if err := c.WriteValueExpr(expFun); err != nil {
+				return fmt.Errorf("failed to write function expression in call: %w", err)
+			}
+
+			if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
+				if _, ok := funType.Underlying().(*types.Signature); ok {
+					if _, isNamed := funType.(*types.Named); isNamed {
+						c.tsw.WriteLiterally("!")
+					}
+				}
+			}
+
+			c.tsw.WriteLiterally("(")
+			for i, arg := range exp.Args {
+				if i != 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				if err := c.WriteValueExpr(arg); err != nil {
+					return fmt.Errorf("failed to write argument %d in call: %w", i, err)
+				}
+			}
+			c.tsw.WriteLiterally(")")
+			return nil // Handled regular function call
+		}
+	} else {
+		// Not an identifier (e.g., method call on a value)
+		if err := c.WriteValueExpr(expFun); err != nil {
+			return fmt.Errorf("failed to write method expression in call: %w", err)
+		}
+
+		if funType := c.pkg.TypesInfo.TypeOf(expFun); funType != nil {
+			if _, ok := funType.Underlying().(*types.Signature); ok {
+				if _, isNamed := funType.(*types.Named); isNamed {
+					c.tsw.WriteLiterally("!")
+				}
+			}
+		}
+	}
+	c.tsw.WriteLiterally("(")
+	for i, arg := range exp.Args {
+		if i != 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		if err := c.WriteValueExpr(arg); err != nil {
+			return fmt.Errorf("failed to write argument %d in call: %w", i, err)
+		}
+	}
+	c.tsw.WriteLiterally(")")
+	return nil
+}