goscript 0.0.21 → 0.0.22

package/compiler/expr.go

@@ -0,0 +1,356 @@
+package compiler
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"github.com/pkg/errors"
+)
+
+// WriteIndexExpr translates a Go index expression (a[b]) to its TypeScript equivalent.
+func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
+	// Handle map access: use Map.get() instead of brackets for reading values
+	if tv, ok := c.pkg.TypesInfo.Types[exp.X]; ok {
+		// Check if it's a map type
+		if mapType, isMap := tv.Type.Underlying().(*types.Map); isMap {
+			c.tsw.WriteLiterally("$.mapGet(")
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(exp.Index); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+
+			// Generate the zero value as the default value for mapGet
+			c.WriteZeroValueForType(mapType.Elem())
+			c.tsw.WriteLiterally(")")
+			return nil
+		}
+	}
+
+	// Regular array/slice access: use brackets
+	if err := c.WriteValueExpr(exp.X); err != nil {
+		return err
+	}
+	c.tsw.WriteLiterally("![") // non-null assertion
+	if err := c.WriteValueExpr(exp.Index); err != nil {
+		return err
+	}
+	c.tsw.WriteLiterally("]")
+	return nil
+}
+
+// WriteTypeAssertExpr translates a Go type assertion expression (e.g., `x.(T)`)
+// into a TypeScript call to `$.typeAssert<T_ts>(x_ts, 'TypeName').value`.
+// The `$.typeAssert` runtime function handles the actual type check and panic
+// if the assertion fails. The `.value` access is used because in an expression
+// context, we expect the asserted value directly. The `TypeName` string is used
+// by the runtime for error messages.
+func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
+	// Generate a call to $.typeAssert
+	c.tsw.WriteLiterally("$.typeAssert<")
+	c.WriteTypeExpr(exp.Type) // Write the asserted type for the generic
+	c.tsw.WriteLiterally(">(")
+	if err := c.WriteValueExpr(exp.X); err != nil { // The interface expression
+		return fmt.Errorf("failed to write interface expression in type assertion expression: %w", err)
+	}
+	c.tsw.WriteLiterally(", ")
+
+	// Write the type description instead of just the type name
+	// This ensures we generate proper type info objects for all types
+
+	// Unwrap parenthesized expressions to handle cases like r.((<-chan T))
+	typeExpr := exp.Type
+	for {
+		if parenExpr, ok := typeExpr.(*ast.ParenExpr); ok {
+			typeExpr = parenExpr.X
+		} else {
+			break
+		}
+	}
+
+	c.writeTypeDescription(typeExpr)
+
+	c.tsw.WriteLiterally(")") // Just close the parenthesis, don't access .value directly
+	return nil
+}
+
+// isPointerComparison checks if a binary expression `exp` involves comparing
+// two pointer types. It uses `go/types` information to determine the types
+// of the left (X) and right (Y) operands of the binary expression.
+// Returns `true` if both operands are determined to be pointer types,
+// `false` otherwise. This is used to apply specific comparison semantics
+// for pointers (e.g., comparing the box objects directly).
+func (c *GoToTSCompiler) isPointerComparison(exp *ast.BinaryExpr) bool {
+	leftType := c.pkg.TypesInfo.TypeOf(exp.X)
+	rightType := c.pkg.TypesInfo.TypeOf(exp.Y)
+	if leftType != nil && rightType != nil {
+		if _, leftIsPtr := leftType.(*types.Pointer); leftIsPtr {
+			if _, rightIsPtr := rightType.(*types.Pointer); rightIsPtr {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// getTypeNameString returns a string representation of a Go type expression (`ast.Expr`).
+// It handles simple identifiers (e.g., `MyType`) and selector expressions
+// (e.g., `pkg.Type`). For more complex or unrecognized type expressions,
+// it returns "unknown". This string is primarily used for runtime error messages,
+// such as in type assertions.
+func (c *GoToTSCompiler) getTypeNameString(typeExpr ast.Expr) string {
+	switch t := typeExpr.(type) {
+	case *ast.Ident:
+		return t.Name
+	case *ast.SelectorExpr:
+		// For imported types like pkg.Type
+		if ident, ok := t.X.(*ast.Ident); ok {
+			return fmt.Sprintf("%s.%s", ident.Name, t.Sel.Name)
+		}
+	}
+	// Default case, use a placeholder for complex types
+	return "unknown"
+}
+
+// WriteBinaryExpr translates a Go binary expression (`ast.BinaryExpr`) into its
+// TypeScript equivalent.
+// It handles several cases:
+//   - Channel send (`ch <- val`): Becomes `await ch.send(val)`.
+//   - Nil comparison for pointers (`ptr == nil` or `ptr != nil`): Compares the
+//     pointer (which may be a box object or `null`) directly to `null` using
+//     the translated operator (`==` or `!=`).
+//   - Pointer comparison (non-nil, `ptr1 == ptr2` or `ptr1 != ptr2`): Compares
+//     the box objects directly using strict equality (`===` or `!==`).
+//   - Bitwise operations (`&`, `|`, `^`, `<<`, `>>`, `&^`): The expression is wrapped
+//     in parentheses `()` to ensure correct precedence in TypeScript, and operators
+//     are mapped (e.g., `&^` might need special handling or is mapped to a runtime helper).
+//   - Other binary operations (arithmetic, logical, comparison): Operands are
+//     translated using `WriteValueExpr`, and the operator is mapped to its TypeScript
+//     equivalent using `TokenToTs`.
+//
+// Unhandled operators result in a comment and a placeholder.
+func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
+	// Handle special cases like channel send
+	if exp.Op == token.ARROW {
+		// Channel send: ch <- val becomes await ch.send(val)
+		c.tsw.WriteLiterally("await ")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write channel send target: %w", err)
+		}
+		c.tsw.WriteLiterally(".send(")
+		if err := c.WriteValueExpr(exp.Y); err != nil {
+			return fmt.Errorf("failed to write channel send value: %w", err)
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	}
+
+	// Check if this is a nil comparison for a pointer
+	isNilComparison := false
+	var ptrExpr ast.Expr
+	if (exp.Op == token.EQL || exp.Op == token.NEQ) && c.pkg != nil && c.pkg.TypesInfo != nil {
+		if leftIdent, ok := exp.Y.(*ast.Ident); ok && leftIdent.Name == "nil" {
+			leftType := c.pkg.TypesInfo.TypeOf(exp.X)
+			if _, isPtr := leftType.(*types.Pointer); isPtr {
+				isNilComparison = true
+				ptrExpr = exp.X
+			}
+		} else if rightIdent, ok := exp.X.(*ast.Ident); ok && rightIdent.Name == "nil" {
+			rightType := c.pkg.TypesInfo.TypeOf(exp.Y)
+			if _, isPtr := rightType.(*types.Pointer); isPtr {
+				isNilComparison = true
+				ptrExpr = exp.Y
+			}
+		}
+	}
+
+	if isNilComparison {
+		// Compare the box object directly to null
+		if err := c.WriteValueExpr(ptrExpr); err != nil {
+			return fmt.Errorf("failed to write pointer expression in nil comparison: %w", err)
+		}
+		c.tsw.WriteLiterally(" ")
+		tokStr, ok := TokenToTs(exp.Op)
+		if !ok {
+			return errors.Errorf("unhandled binary op: %s", exp.Op.String())
+		}
+		c.tsw.WriteLiterally(tokStr)
+		c.tsw.WriteLiterally(" null")
+		return nil
+	}
+
+	// Check if this is a pointer comparison (non-nil)
+	// Compare the box objects directly using === or !==
+	if c.isPointerComparison(exp) {
+		c.tsw.WriteLiterally("(") // Wrap comparison
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write binary expression left operand: %w", err)
+		}
+		c.tsw.WriteLiterally(" ")
+		// Use === for == and !== for !=
+		tokStr := ""
+		switch exp.Op {
+		case token.EQL:
+			tokStr = "==="
+		case token.NEQ:
+			tokStr = "!=="
+		default:
+			return errors.Errorf("unhandled pointer comparison op: %s", exp.Op.String())
+		}
+		c.tsw.WriteLiterally(tokStr)
+		c.tsw.WriteLiterally(" ")
+		if err := c.WriteValueExpr(exp.Y); err != nil {
+			return fmt.Errorf("failed to write binary expression right operand: %w", err)
+		}
+		c.tsw.WriteLiterally(")") // Close wrap
+		return nil
+	}
+
+	// Check if the operator is a bitwise operator
+	isBitwise := false
+	switch exp.Op {
+	case token.AND, token.OR, token.XOR, token.SHL, token.SHR, token.AND_NOT:
+		isBitwise = true
+	}
+
+	if isBitwise {
+		c.tsw.WriteLiterally("(") // Add opening parenthesis for bitwise operations
+	}
+
+	if err := c.WriteValueExpr(exp.X); err != nil {
+		return fmt.Errorf("failed to write binary expression left operand: %w", err)
+	}
+	c.tsw.WriteLiterally(" ")
+	tokStr, ok := TokenToTs(exp.Op)
+	if !ok {
+		return errors.Errorf("unhandled binary op: %s", exp.Op.String())
+	}
+	c.tsw.WriteLiterally(tokStr)
+	c.tsw.WriteLiterally(" ")
+	if err := c.WriteValueExpr(exp.Y); err != nil {
+		return fmt.Errorf("failed to write binary expression right operand: %w", err)
+	}
+
+	if isBitwise {
+		c.tsw.WriteLiterally(")") // Add closing parenthesis for bitwise operations
+	}
+
+	return nil
+}
+
+// WriteUnaryExpr translates a Go unary expression (`ast.UnaryExpr`) into its
+// TypeScript equivalent.
+// It handles several unary operations:
+// - Channel receive (`<-ch`): Becomes `await ch.receive()`.
+// - Address-of (`&var`):
+//   - If `var` is a boxed variable (its address was taken), `&var` evaluates
+//     to the box itself (i.e., `varName` in TypeScript, which holds the box).
+//   - Otherwise (e.g., `&unboxedVar`, `&MyStruct{}`, `&FuncCall()`), it evaluates
+//     the operand `var`. The resulting TypeScript value (e.g., a new object instance)
+//     acts as the "pointer". Boxing decisions for such pointers are handled at
+//     the assignment site.
+//   - Other unary operators (`+`, `-`, `!`, `^`): Mapped to their TypeScript
+//     equivalents (e.g., `+`, `-`, `!`, `~` for bitwise NOT). Parentheses are added
+//     around the operand if it's a binary or unary expression to maintain precedence.
+//
+// Unhandled operators result in a comment and an attempt to write the operator
+// token directly. Postfix operators (`++`, `--`) are expected to be handled by
+// their statement contexts (e.g., `IncDecStmt`).
+func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
+	if exp.Op == token.ARROW {
+		// Channel receive: <-ch becomes await ch.receive()
+		c.tsw.WriteLiterally("await ")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write channel receive operand: %w", err)
+		}
+		c.tsw.WriteLiterally(".receive()")
+		return nil
+	}
+
+	if exp.Op == token.AND { // Address-of operator (&)
+		// If the operand is an identifier for a variable that is boxed,
+		// the result of & is the box itself.
+		if ident, ok := exp.X.(*ast.Ident); ok {
+			var obj types.Object
+			obj = c.pkg.TypesInfo.Uses[ident]
+			if obj == nil {
+				obj = c.pkg.TypesInfo.Defs[ident]
+			}
+			if obj != nil && c.analysis.NeedsBoxed(obj) {
+				// &boxedVar -> boxedVar (the box itself)
+				c.tsw.WriteLiterally(ident.Name) // Write the identifier name (which holds the box)
+				return nil
+			}
+		}
+
+		// Otherwise (&unboxedVar, &CompositeLit{}, &FuncCall(), etc.),
+		// the address-of operator in Go, when used to create a pointer,
+		// translates to simply evaluating the operand in TypeScript.
+		// The resulting value (e.g., a new object instance) acts as the "pointer".
+		// Boxing decisions are handled at the assignment site based on the LHS variable.
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write &-operand: %w", err)
+		}
+
+		return nil
+	}
+
+	// Handle other unary operators (+, -, !, ^)
+	tokStr, ok := TokenToTs(exp.Op)
+	if !ok {
+		return errors.Errorf("unhandled unary op: %s", exp.Op.String())
+	}
+	c.tsw.WriteLiterally(tokStr)
+
+	// Add space if operator is not postfix (e.g., !)
+	if exp.Op != token.INC && exp.Op != token.DEC {
+		// Check if operand needs parentheses (e.g., !(-a))
+		// Basic check: if operand is binary or unary, add parens
+		needsParens := false
+		switch exp.X.(type) {
+		case *ast.BinaryExpr, *ast.UnaryExpr:
+			needsParens = true
+		}
+		if needsParens {
+			c.tsw.WriteLiterally("(")
+		}
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write unary expression operand: %w", err)
+		}
+		if needsParens {
+			c.tsw.WriteLiterally(")")
+		}
+	} else {
+		// Postfix operators (++, --) - operand written first by caller (e.g., IncDecStmt)
+		// This function shouldn't be called directly for ++/-- in expression context in valid Go?
+		// If it is, write the operand.
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return fmt.Errorf("failed to write unary expression operand for postfix op: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// WriteKeyValueExpr translates a Go key-value pair expression (`ast.KeyValueExpr`),
+// typically found within composite literals (for structs, maps, or arrays with
+// indexed elements), into its TypeScript object property equivalent: `key: value`.
+// Both the key and the value expressions are recursively translated using
+// `WriteValueExpr`. The original Go casing for keys is preserved.
+// For example, `MyField: 123` in Go becomes `MyField: 123` in TypeScript.
+func (c *GoToTSCompiler) WriteKeyValueExpr(exp *ast.KeyValueExpr) error {
+	// Keep original Go casing for keys
+	if err := c.WriteValueExpr(exp.Key); err != nil {
+		return fmt.Errorf("failed to write key-value expression key: %w", err)
+	}
+	c.tsw.WriteLiterally(": ")
+	if err := c.WriteValueExpr(exp.Value); err != nil {
+		return fmt.Errorf("failed to write key-value expression value: %w", err)
+	}
+	return nil
+}

package/compiler/field.go

@@ -0,0 +1,169 @@
+package compiler
+
+import "go/ast"
+
+// WriteFieldList translates a Go field list (`ast.FieldList`), which can represent
+// function parameters, function results, or struct fields, into its TypeScript equivalent.
+//   - If `isArguments` is true (for function parameters/results):
+//     It iterates through `a.List`, writing each field as `name: type`. Parameter
+//     names and types are written using `WriteField` and `WriteGoType` respectively.
+//     Multiple parameters are comma-separated.
+//   - If `isArguments` is false (for struct fields):
+//     It writes an opening brace `{`, indents, then writes each field definition
+//     using `WriteField`, followed by a closing brace `}`. If the field list is
+//     empty or nil, it simply writes `{}`.
+//
+// This function is a key part of generating TypeScript type signatures for functions
+// and interfaces, as well as struct type definitions.
+func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
+	if !isArguments && (a == nil || a.NumFields() == 0) {
+		c.tsw.WriteLiterally("{}")
+		return
+	}
+
+	if !isArguments && a.Opening.IsValid() {
+		c.tsw.WriteLine("{")
+		c.tsw.Indent(1)
+	}
+
+	// Check if this is a variadic function parameter list
+	isVariadic := false
+	if isArguments && a != nil && len(a.List) > 0 {
+		lastParam := a.List[len(a.List)-1]
+		if _, ok := lastParam.Type.(*ast.Ellipsis); ok {
+			isVariadic = true
+		}
+	}
+
+	if isArguments && isVariadic {
+		// Handle non-variadic parameters first
+		for i, field := range a.List[:len(a.List)-1] {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+
+			// Handle multiple parameter names for the same type
+			for j, name := range field.Names {
+				if j > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.tsw.WriteLiterally(name.Name)
+				c.tsw.WriteLiterally(": ")
+				typ := c.pkg.TypesInfo.TypeOf(field.Type)
+				c.WriteGoType(typ)
+			}
+		}
+
+		// Handle the variadic parameter
+		lastParam := a.List[len(a.List)-1]
+		if len(a.List) > 1 {
+			c.tsw.WriteLiterally(", ")
+		}
+
+		for i, name := range lastParam.Names {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.tsw.WriteLiterally("...")
+			c.tsw.WriteLiterally(name.Name)
+		}
+
+		c.tsw.WriteLiterally(": ")
+		if ellipsis, ok := lastParam.Type.(*ast.Ellipsis); ok {
+			c.WriteTypeExpr(ellipsis.Elt)
+			c.tsw.WriteLiterally("[]")
+		}
+	} else {
+		// Handle regular parameter list for function declarations
+		for i, field := range a.List {
+			if i > 0 && isArguments {
+				c.tsw.WriteLiterally(", ")
+			}
+
+			if isArguments {
+				// For function parameters with multiple names, write each with its type
+				for j, name := range field.Names {
+					if j > 0 {
+						c.tsw.WriteLiterally(", ")
+					}
+					c.tsw.WriteLiterally(name.Name)
+					c.tsw.WriteLiterally(": ")
+					typ := c.pkg.TypesInfo.TypeOf(field.Type)
+					c.WriteGoType(typ) // Use WriteGoType for parameter type
+				}
+			} else {
+				// For struct fields and other non-argument fields
+				c.WriteField(field, false)
+			}
+		}
+	}
+
+	if !isArguments && a.Closing.IsValid() {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLine("}")
+	}
+}
+
+// WriteField translates a single Go field (`ast.Field`) from a field list
+// (e.g., in a struct type or function signature) into its TypeScript representation.
+// - If `isArguments` is false (struct field):
+//   - Documentation comments (`field.Doc`, `field.Comment`) are preserved.
+//   - If the field is anonymous (embedded), it's skipped as promotions are handled
+//     elsewhere (e.g., during struct class generation).
+//   - For named fields, it writes `public fieldName: FieldType_ts`. The field name
+//     retains its Go casing. The type is translated using `WriteGoType`.
+//   - Go struct tags (`field.Tag`) are written as a trailing comment.
+//
+// - If `isArguments` is true (function parameter):
+//   - It writes the parameter name (retaining Go casing). The type is handled
+//     by the caller (`WriteFieldList`).
+//
+// This function is used by `WriteFieldList` to process individual items within
+// parameter lists and struct field definitions.
+func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
+	if !isArguments {
+		if field.Doc != nil {
+			c.WriteDoc(field.Doc)
+		}
+		if field.Comment != nil {
+			c.WriteDoc(field.Comment)
+		}
+	}
+
+	// Check if this is an embedded field (anonymous field)
+	if len(field.Names) == 0 && !isArguments {
+		// This is an embedded field, so we're adding promotions instead of declaring it directly
+		return
+	}
+
+	for i, name := range field.Names {
+		if i > 0 && isArguments {
+			c.tsw.WriteLiterally(", ")
+		}
+
+		// argument names: keep original casing, no access modifier
+		if isArguments {
+			c.tsw.WriteLiterally(name.Name)
+			// Argument type is handled in WriteFieldList, so continue
+			continue
+		} else {
+			// All struct fields are public in TypeScript, keeping original Go casing
+			c.tsw.WriteLiterally("public ")
+			c.tsw.WriteLiterally(name.Name)
+		}
+
+		// write type for struct fields (not arguments)
+		c.tsw.WriteLiterally(": ")
+		typ := c.pkg.TypesInfo.TypeOf(field.Type)
+		c.WriteGoType(typ) // Use WriteGoType for field type
+
+		if !isArguments {
+			// write tag comment if any for struct fields
+			if field.Tag != nil {
+				c.tsw.WriteCommentLinef("tag: %s", field.Tag.Value)
+			} else {
+				c.tsw.WriteLine("") // No semicolon
+			}
+		}
+	}
+}

package/compiler/lit.go

@@ -0,0 +1,99 @@
+package compiler
+
+import (
+	"go/ast"
+	"go/token"
+	"strconv"
+)
+
+// WriteBasicLit translates a Go basic literal (`ast.BasicLit`) into its
+// TypeScript equivalent.
+//   - Character literals (e.g., `'a'`, `'\n'`) are translated to their numeric
+//     Unicode code point (e.g., `97`, `10`). Escape sequences are handled.
+//   - Integer, float, imaginary, and string literals are written directly as their
+//     `exp.Value` string, which typically corresponds to valid TypeScript syntax
+//     (e.g., `123`, `3.14`, `"hello"`). Imaginary literals might need special
+//     handling if they are to be fully supported beyond direct string output.
+func (c *GoToTSCompiler) WriteBasicLit(exp *ast.BasicLit) {
+	if exp.Kind == token.CHAR {
+		// Go char literal 'x' is a rune (int32). Translate to its numeric code point.
+		// Use strconv.UnquoteChar to handle escape sequences correctly.
+		val, _, _, err := strconv.UnquoteChar(exp.Value[1:len(exp.Value)-1], '\'')
+		if err != nil {
+			c.tsw.WriteCommentInlinef("error parsing char literal %s: %v", exp.Value, err)
+			c.tsw.WriteLiterally("0") // Default to 0 on error
+		} else {
+			c.tsw.WriteLiterallyf("%d", val)
+		}
+	} else {
+		// Other literals (INT, FLOAT, STRING, IMAG)
+		c.tsw.WriteLiterally(exp.Value)
+	}
+}
+
+// WriteFuncLitValue translates a Go function literal (`ast.FuncLit`) into a
+// TypeScript arrow function.
+// The translation results in: `[async] (param1: type1, ...) : returnType => { ...body... }`.
+//   - The `async` keyword is prepended if `c.analysis.IsFuncLitAsync(exp)`
+//     indicates the function literal contains asynchronous operations.
+//   - Parameters are translated using `WriteFieldList`.
+//   - The return type is determined similarly to `WriteFuncType`:
+//   - `void` for no results.
+//   - `resultType` for a single unnamed result.
+//   - `[typeA, typeB]` for multiple or named results.
+//   - Wrapped in `Promise<>` if `async`.
+//   - The function body (`exp.Body`) is translated using `WriteStmt`.
+func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
+	// Determine if the function literal should be async
+	isAsync := c.analysis.IsFuncLitAsync(exp)
+
+	if isAsync {
+		c.tsw.WriteLiterally("async ")
+	}
+
+	// Write arrow function: (params) => { body }
+	c.tsw.WriteLiterally("(")
+
+	// Use WriteFieldList which now handles variadic parameters
+	c.WriteFieldList(exp.Type.Params, true) // true = arguments
+
+	c.tsw.WriteLiterally(")")
+
+	// Handle return type for function literals
+	if exp.Type.Results != nil && len(exp.Type.Results.List) > 0 {
+		c.tsw.WriteLiterally(": ")
+		if isAsync {
+			c.tsw.WriteLiterally("Promise<")
+		}
+		if len(exp.Type.Results.List) == 1 && len(exp.Type.Results.List[0].Names) == 0 {
+			c.WriteTypeExpr(exp.Type.Results.List[0].Type)
+		} else {
+			c.tsw.WriteLiterally("[")
+			for i, field := range exp.Type.Results.List {
+				if i > 0 {
+					c.tsw.WriteLiterally(", ")
+				}
+				c.WriteTypeExpr(field.Type)
+			}
+			c.tsw.WriteLiterally("]")
+		}
+		if isAsync {
+			c.tsw.WriteLiterally(">")
+		}
+	} else {
+		if isAsync {
+			c.tsw.WriteLiterally(": Promise<void>")
+		} else {
+			c.tsw.WriteLiterally(": void")
+		}
+	}
+
+	c.tsw.WriteLiterally(" => ")
+
+	// Write function body
+	if err := c.WriteStmt(exp.Body); err != nil {
+		return err
+	}
+
+	return nil
+}