expo-modules-macros 0.24.0 → 0.26.0

package/README.md

@@ -25,12 +25,14 @@ This package lists them as optional dependencies, and their `os`, `cpu` and (on
 # Macros
 
 - **`@ExpoModule(_ name: String? = nil, classes: [Any.Type] = [])`** on a class. Turns the class into a module: binds its `@JS` members into the module's JavaScript object and resolves the module name from the argument, falling back to the class name. It also synthesizes everything inheriting from `Module` used to provide, so a module class can carry any superclass, or none.
-- **`@JS(_ jsName: String? = nil, _ options: JSOptions...)`** on a member of a module or shared object. Marks a function, property or initializer for export. `@ExpoModule` and `@SharedObject` bind each marked member straight into the JavaScript object, with the argument decoding, the call and the result encoding inlined, so there is no dynamic per-call path. The JS name defaults to the Swift name; pass a string to override it. Two `@JS` members with the same JS name on one JavaScript object are a compile-time error, since JavaScript could reach only one of them. A shared object's static and instance members bind onto different objects, so they can share a name. The macro also checks that every type crossing the boundary is convertible in the direction it travels, so a bad type is reported on the author's own declaration rather than on the enclosing type. A `lazy var` is read-only from JavaScript. On the first read, its getter stores the value as a data property on the JavaScript object, so later reads don't call into native code. On a frozen object the value isn't stored, and each read calls the getter. The `.concurrent` option moves an `async` body off the JavaScript thread while still decoding and encoding on it. The `.withAsync("name")` option binds a synchronous function a second time under that name, as a function that returns a promise and runs the body on the concurrent thread pool. That function isn't isolated to the JavaScript thread, so its body must be safe to run on any thread. The macro reports a function isolated to a global actor through its own attribute or its type's. When the isolation comes from elsewhere, such as a protocol or the module's default isolation, the error points into the generated code, so mark the function `nonisolated`. A function or initializer can take a closure argument, such as `(Point) throws -> Size` or `(String) async throws -> Data`. JavaScript passes a function for it, and native code can store the closure and call it from any thread. A closure that throws or returns a value blocks the caller until JavaScript returns, and an `async` closure suspends instead and awaits a promise that the function returns. A closure that returns a value must be `throws`, so that an error from JavaScript can reach the caller. A non-throwing `Void` closure returns before JavaScript reads its arguments, so don't change a class instance after passing it to one.
+- **`@JS(_ jsName: String? = nil, _ options: JSOptions...)`** on a member of a module or shared object. Marks a function, property or initializer for export. `@ExpoModule` and `@SharedObject` bind each marked member straight into the JavaScript object, with the argument decoding, the call and the result encoding inlined, so there is no dynamic per-call path. The JS name defaults to the Swift name; pass a string to override it. Two `@JS` members with the same JS name on one JavaScript object are a compile-time error, since JavaScript could reach only one of them. A shared object's static and instance members bind onto different objects, so they can share a name. The macro also checks that every type crossing the boundary is convertible in the direction it travels. Outside a module or shared object, a bad type is reported on the author's own declaration. In an `@ExpoModule` or `@SharedObject` class, the class macro makes the check, since only it sees the type aliases in the class body, so the error is reported on the class and names the member and its argument labels, such as `local function 'move(_:by:returning:)' requires that 'Point' conform to 'JavaScriptEncodable'`. A `lazy var` is read-only from JavaScript. On the first read, its getter stores the value as a data property on the JavaScript object, so later reads don't call into native code. On a frozen object the value isn't stored, and each read calls the getter. The `.concurrent` option moves an `async` body off the JavaScript thread while still decoding and encoding on it. The `.withAsync("name")` option binds a synchronous function a second time under that name, as a function that returns a promise and runs the body on the concurrent thread pool. That function isn't isolated to the JavaScript thread, so its body must be safe to run on any thread. The macro reports a function isolated to a global actor through its own attribute or its type's. When the isolation comes from elsewhere, such as a protocol or the module's default isolation, the error points into the generated code, so mark the function `nonisolated`. A function or initializer can take a closure argument, such as `(Point) throws -> Size` or `(String) async throws -> Data`. JavaScript passes a function for it, and native code can store the closure and call it from any thread. A closure that throws or returns a value blocks the caller until JavaScript returns, and an `async` closure suspends instead and awaits a promise that the function returns. A closure that returns a value must be `throws`, so that an error from JavaScript can reach the caller. A non-throwing `Void` closure returns before JavaScript reads its arguments, so don't change a class instance after passing it to one.
 - **`@Event(_ name: String? = nil, sync: Bool = false)`** on a function-typed `var`. Expands the property into a closure that emits the event, so calling the property sends it to JavaScript with the closure's parameter as the payload. The JS name defaults to the property name with a leading `on` stripped. `sync: true` dispatches inline instead of asynchronously.
 - **`@SharedObject(_ name: String? = nil)`** on a subclass of `SharedObject`, direct or not, such as a `SharedRef<T>` subclass. Binds the class's `@JS` members through the `SharedObject` hooks that core calls when it builds the JavaScript class, and emits the JS class name, which defaults to the class name. A module exposes the class through `@ExpoModule(classes:)`, which only accepts `SharedObject` subclasses.
 - **`@Record()`** on a struct, or on a final class with no inheritance clause (declare a class's protocol conformances in an extension). Treats every non-static, non-private, non-computed stored property as a field, with no per-field wrapper, and synthesizes the memberwise initializer, the conversions in both directions, and the `Record` conformance. Requiredness is inferred: a default value makes a field optional, an optional type makes it nullable and optional.
 - **`@Union()`** on an enum whose cases each carry one associated value. Models a TypeScript union. Synthesizes the conversions in both directions, a typed accessor per payload type, and the `JavaScriptDecodable` and `JavaScriptEncodable` conformances. Decoding is ordered: the first case whose payload decodes wins, so the more specific case goes first.
 
+A tuple can cross the boundary as a `@JS` argument, result or property, a `@Record` property, a `@Union` payload, an `@Event` payload, or a parameter or result of a closure argument that isn't `async`. An unlabeled tuple such as `(Int, String)` maps to an array with one value per element, and a labeled tuple such as `(x: Double, y: Double)` to an object with one property per label. A tuple must have two or more elements, all labeled or none, and each element must be convertible. Tuples nest in other tuples, optionals, arrays and `String`-keyed dictionaries. `@ExpoModule` and `@SharedObject` also resolve a type alias of a tuple, such as `typealias Span = (start: Int, end: Int)`, when the class body declares it. A macro sees only the declaration it is attached to, so an alias declared anywhere else doesn't resolve.
+
 How that looks in a module:
 
 ```swift

package/apple/Sources/ExpoModulesMacros/ClosureArguments.swift

@@ -146,13 +146,20 @@ private func closureLiteralLines(_ closure: JSClosureType, callback: String) ->
   // parameters instead would send non-`Sendable` values to the `@JavaScriptActor` closure, which
   // Swift 6 rejects. The closure captures nothing, so it needs no allocation. Without parameters
   // there is nothing to emplace, and `invokeAsync` takes the parameters variadically.
-  let emplaces = !closure.isAsync && !parameters.isEmpty
+  //
+  // A result type that holds a tuple can't be passed as `returning:`, so a sync closure returning one
+  // decodes it through a `decoding:` closure, which only the `emplacing` variant takes. With no
+  // parameters it emplaces nothing.
+  let returnTuple = closure.returnType.flatMap { tupleConversion(of: $0) }
+  let emplaces = !closure.isAsync && (!parameters.isEmpty || returnTuple != nil)
   var arguments = parameters
   if emplaces {
     let values = parameters.count == 1 ? "p0" : "(" + parameters.joined(separator: ", ") + ")"
     arguments = [values, "argumentCount: \(parameters.count)"]
   }
-  if let returnType = closure.returnType {
+  if let returnTuple {
+    arguments.append("decoding: \(elementClosure(returning: returnTuple.decodeExpression(of: "value")))")
+  } else if let returnType = closure.returnType {
     arguments.append("returning: \(expressionType(returnType)).self")
   }
   let argumentList = arguments.joined(separator: ", ")
@@ -168,9 +175,14 @@ private func closureLiteralLines(_ closure: JSClosureType, callback: String) ->
 
   if emplaces {
     var lines = [header, "  \(call) { _values, _arguments, _runtime in"]
-    for index in parameters.indices {
+    for (index, parameter) in closure.parameters.enumerated() {
       let value = parameters.count == 1 ? "_values" : "_values.\(index)"
-      lines.append("    try _arguments.emplace(\(value), at: \(index), in: _runtime)")
+      // A parameter that holds a tuple has no `encode(_:into:in:)`, so its encoded value is moved in.
+      if let tuple = tupleConversion(of: parameter.type) {
+        lines.append("    _arguments.emplace(try \(tuple.encodeExpression(of: value, in: "_runtime")), at: \(index))")
+      } else {
+        lines.append("    try _arguments.emplace(\(value), at: \(index), in: _runtime)")
+      }
     }
     return lines + ["  }", "}"]
   }
@@ -336,6 +348,18 @@ private func diagnoseClosure(_ closure: JSClosureType, in context: some MacroExp
           )
         )
       )
+    } else if closure.isAsync && tupleConversion(of: type) != nil {
+      // `invokeAsync` takes its arguments and result as `JavaScriptEncodable` / `JavaScriptDecodable`
+      // types, and a type that holds a tuple can't conform.
+      context.diagnose(
+        Diagnostic(
+          node: type,
+          message: ClosureDiagnosticMessage(
+            "An async @JS closure argument can't take or return a tuple. Use a @Record type, or a closure that isn't async.",
+            id: "js-closure-async-tuple"
+          )
+        )
+      )
     }
   }
 

package/apple/Sources/ExpoModulesMacros/DecorateModuleBuilder.swift

@@ -152,9 +152,9 @@ internal struct JSFunction {
     } else {
       // One call shape per accepted arity, branching on `arguments.count`. A branch decodes a
       // trailing slot before the call, so this is a `switch` statement (not an expression): a
-      // value-returning function declares `result` up front and each branch assigns it.
+      // value-returning function declares `value` up front and each branch assigns it.
       if let returnType {
-        lines.append("let result: \(expressionType(returnType))")
+        lines.append("let value: \(expressionType(returnType))")
       }
       lines.append("switch arguments.count {")
       for arity in required...maximum {
@@ -163,7 +163,7 @@ internal struct JSFunction {
         for index in required..<arity {
           lines.append(contentsOf: decodeLines(at: index).map { "  " + $0 })
         }
-        let assignment = returnType != nil ? "result = " : ""
+        let assignment = returnType != nil ? "value = " : ""
         lines.append("  \(assignment)\(callExpression(receiver: receiver, arity: arity))")
       }
       lines.append("}")
@@ -268,7 +268,7 @@ internal struct JSFunction {
   }
 
   /// The flat (single-arity) call-and-encode lines used when no trailing parameter is omittable:
-  /// `let result = <callee>.f(...)` then the return encode (or just `<callee>.f(...)` for a function
+  /// `let value = <callee>.f(...)` then the encode (or just `<callee>.f(...)` for a function
   /// that returns nothing).
   private func callAndEncodeLines(receiver: Receiver, arity: Int, decodingFrom: Int) -> [String] {
     var lines: [String] = []
@@ -276,7 +276,7 @@ internal struct JSFunction {
       lines.append(contentsOf: decodeLines(at: index))
     }
     if returnType != nil {
-      lines.append("let result = \(callExpression(receiver: receiver, arity: arity))")
+      lines.append("let value = \(callExpression(receiver: receiver, arity: arity))")
       lines.append(contentsOf: encodeResultLines())
     } else {
       lines.append(callExpression(receiver: receiver, arity: arity))
@@ -290,8 +290,9 @@ internal struct JSFunction {
   /// `toJavaScriptValue(in:)` except for `Int`/`UInt`, where it range-checks
   /// and throws instead of silently encoding an out-of-safe-range value as a lossy number — the
   /// catchable error is the right behavior, and matches how non-primitive integers already encode. A
-  /// no-return function has nothing to encode: its binding closure returns `Void` (see
-  /// `decorateStatements(object:receiver:)`).
+  /// no-return function has nothing to encode, so its binding closure leaves the result slot empty (see
+  /// `decorateStatements(object:receiver:)`). A synchronous function encodes straight into the
+  /// engine's result slot, so a number, a boolean or a string never becomes a `JavaScriptValue`.
   ///
   /// For an `async` function the encode must run on the JS thread. An `async` body may suspend and
   /// resume on an arbitrary cooperative-pool thread, and encoding a heap-allocated JS value (a string,
@@ -303,15 +304,15 @@ internal struct JSFunction {
     guard let returnType else {
       return []
     }
-    let encode = "try \(encodeCall(returnType, freeForm: returnFreeForm, of: "result"))"
     if isAsync {
+      let encode = "try \(encodeCall(returnType, freeForm: returnFreeForm, of: "result"))"
       return [
         "return try await runtime.execute {",
         "  return \(encode)",
         "}",
       ]
     }
-    return ["return \(encode)"]
+    return [encodeIntoSlotStatement(returnType, freeForm: returnFreeForm, of: "value")]
   }
 
   /// The `setProperty` statement that installs this function on the JS object. The decode-call-encode
@@ -331,19 +332,18 @@ internal struct JSFunction {
     // differ only in what they return. A module ignores `this`; a shared object unwraps it (still
     // borrowed) — an async binding does so in its synchronous decode phase, before the borrow ends.
     // The parameter list is parenthesized and fully typed, since Swift rejects a type annotation on
-    // a shorthand `{ [capture] name, name in }` parameter; for a sync binding the explicit
-    // `JavaScriptUnownedValue` also selects the (otherwise `@_disfavoredOverload`) unowned-`this`
-    // overload.
-    // A sync function that returns nothing binds through the `Void` overload, which leaves JS's
-    // result as `undefined` without building and writing a value. The closure declares `-> Void`
-    // because a body of several statements without a `return` is otherwise ambiguous between the
-    // two unowned-`this` overloads.
+    // a shorthand `{ [capture] name, name in }` parameter.
+    // A sync function binds through the result-slot overload (`JavaScriptRuntime.HostFunctionClosure`):
+    // it encodes its result into the slot and gets the runtime as a parameter. A function that returns
+    // nothing writes nothing, so JS gets `undefined` without a value being built.
     let captures = receiver.captureClause
-    let parameters = "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
-    let returnClause = returnType == nil && !isAsync ? " -> Void" : ""
+    let parameters =
+      isAsync
+      ? "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
+      : resultSlotClosureParameters
 
     return """
-        \(object).setProperty("\(jsName)") { \(captures)\(parameters)\(returnClause) in
+        \(object).setProperty("\(jsName)") { \(captures)\(parameters) in
       \(bodyStatements(receiver: receiver, indent: "    "))
         }
       """
@@ -419,8 +419,16 @@ internal struct JSProperty {
     } else {
       encode = "\(callee).\(swiftName).toJavaScriptValue(in: runtime)"
     }
+    // A getter encodes straight into the engine's result slot. A lazy getter needs the encoded value as
+    // a `JavaScriptValue` to define it on `this` as well, and then moves it into the slot.
     let getBody: String
-    if isLazy {
+    if !isLazy {
+      if let valueType {
+        getBody = encodeIntoSlotStatement(valueType, freeForm: freeForm, of: "\(callee).\(swiftName)")
+      } else {
+        getBody = "result.emplace(\(encode))"
+      }
+    } else {
       let define = "this.getObject(in: runtime).defineProperty(\"\(jsName)\", value: value, options: [.enumerable])"
       // A module getter ignores `this` otherwise, so it can be anything, and only an object can hold the
       // value. A shared object's unwrap has already checked that `this` is an object.
@@ -428,9 +436,7 @@ internal struct JSProperty {
         receiver.unwrapStatement == nil
         ? "if this.isObject() {\n  \(define)\n}"
         : define
-      getBody = "let value = \(encode)\n\(defineStatement)\nreturn value"
-    } else {
-      getBody = "return \(encode)"
+      getBody = "let value = \(encode)\n\(defineStatement)\nresult.emplace(value)"
     }
     lines.append(
       accessorClosure(descriptorName, "get", receiver: receiver, body: "\(unwrap)\(getBody)")
@@ -444,13 +450,7 @@ internal struct JSProperty {
       let decode = decodeCall(valueType, freeForm: freeForm, from: "arguments.unownedValue(at: 0)")
       let setDecode = "\(callee).\(swiftName) = try \(decode)"
       lines.append(
-        accessorClosure(
-          descriptorName,
-          "set",
-          receiver: receiver,
-          returnsVoid: true,
-          body: "\(unwrap)\(setDecode)"
-        )
+        accessorClosure(descriptorName, "set", receiver: receiver, body: "\(unwrap)\(setDecode)")
       )
     }
 
@@ -465,13 +465,10 @@ internal struct JSProperty {
 
   /// One `descriptor.setProperty("get"/"set") { … }` accessor entry. The capture list follows the
   /// receiver: a module captures `self` strong; a shared object captures nothing of the instance.
-  /// A setter passes `returnsVoid`, so its closure declares `-> Void` and binds through the `Void`
-  /// overload, like a function that returns nothing.
   private func accessorClosure(
     _ descriptorName: String,
     _ key: String,
     receiver: Receiver,
-    returnsVoid: Bool = false,
     body: String
   ) -> String {
     let captures = receiver.captureClause
@@ -482,21 +479,37 @@ internal struct JSProperty {
       .split(separator: "\n", omittingEmptySubsequences: false)
       .map { "  \($0)" }
       .joined(separator: "\n")
-    // Property `get`/`set` accessors are always synchronous, so they bind through the unowned-`this`
+    // Property `get`/`set` accessors are always synchronous, so they bind through the result-slot
     // `setProperty` overload like sync functions. The parameter list is parenthesized and fully typed
-    // because Swift rejects a type annotation on a shorthand closure parameter; the explicit
-    // `borrowing JavaScriptUnownedValue` selects the unowned-`this` overload. A module ignores `this`;
-    // a shared object unwraps it in the body.
-    let parameters = "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
-    let returnClause = returnsVoid ? " -> Void" : ""
+    // because Swift rejects a type annotation on a shorthand closure parameter. A module ignores `this`;
+    // a shared object unwraps it in the body. A setter writes nothing, so JS gets `undefined`.
     return """
-      \(descriptorName).setProperty("\(key)") { \(captures)\(parameters)\(returnClause) in
+      \(descriptorName).setProperty("\(key)") { \(captures)\(resultSlotClosureParameters) in
       \(indentedBody)
       }
       """
   }
 }
 
+/// The parameter list of a binding closure that writes its result into the engine's result slot
+/// (`JavaScriptRuntime.HostFunctionClosure`). The closure gets the runtime as a parameter, which shadows
+/// the decorator's `runtime`, so it doesn't capture it.
+private let resultSlotClosureParameters =
+  "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer, "
+  + "result: borrowing JavaScriptValue.Slot, runtime: borrowing JavaScriptRuntime)"
+
+/// The statement that encodes `valueExpression` of a boundary type into the result slot `result`. A type
+/// that mentions `Any` and a tuple have no `encode(_:into:in:)`, so their encode result is moved into
+/// the slot.
+private func encodeIntoSlotStatement(_ type: String, freeForm: FreeFormConversion?, of valueExpression: String)
+  -> String
+{
+  if freeForm != nil || tupleConversion(of: type) != nil {
+    return "result.emplace(try \(encodeCall(type, freeForm: freeForm, of: valueExpression)))"
+  }
+  return "try \(expressionType(type)).encode(\(valueExpression), into: result, in: runtime)"
+}
+
 /// The body shared by every decorator phase: every `@JS func` bound via an inlined `setProperty`
 /// closure and every `@JS var` via a `defineProperty` accessor, joined for the function body. `object`
 /// is the local the bindings decorate (matching the entry point's argument label); `receiver` selects

package/apple/Sources/ExpoModulesMacros/EventMacro.swift

@@ -53,11 +53,19 @@ public struct EventMacro: AccessorMacro {
     // The closure's parameter and return types are inferred from the property's declared type
     // through the getter, so the body never has to spell the payload type. A sync event calls
     // `emitSync` (inline dispatch, JS thread only); the default calls the scheduling `emit`.
+    // A payload that holds a tuple can't conform to the payload protocols, so it's passed with a
+    // closure that encodes it.
     let emitMethod = event.isSync ? "emitSync" : "emit"
-    let closure =
-      event.hasPayload
-      ? "{ [weak self] payload in self?.\(emitMethod)(event: \"\(event.jsName)\", payload: payload) }"
-      : "{ [weak self] in self?.\(emitMethod)(event: \"\(event.jsName)\") }"
+    let closure: String
+    if let tuple = event.payloadType.flatMap({ tupleConversion(of: $0) }) {
+      let encode = elementClosure(returning: tuple.encodeExpression(of: "value"))
+      closure =
+        "{ [weak self] payload in self?.\(emitMethod)(event: \"\(event.jsName)\", payload: payload, encode: \(encode)) }"
+    } else if event.hasPayload {
+      closure = "{ [weak self] payload in self?.\(emitMethod)(event: \"\(event.jsName)\", payload: payload) }"
+    } else {
+      closure = "{ [weak self] in self?.\(emitMethod)(event: \"\(event.jsName)\") }"
+    }
     return [
       """
       get {
@@ -85,15 +93,20 @@ extension EventMacro: PeerMacro {
     // through `self.emit`). Named after the member so the member shows up in either diagnostic,
     // and asserting the enclosing type by its spelled name so the conformance error names the
     // user's type rather than 'Self'.
+    //
+    // A payload that holds a tuple is encoded element by element (see `TupleConversion`), so the types
+    // in it are asserted `JavaScriptEncodable`, which the encode closure needs, in its place.
     let name = event.swiftName
-    let payload = event.payloadType.flatMap { assertableBoundaryType($0, constraint: jsConvertibleProtocolName) }
+    let tupleElementTypes = event.payloadType.flatMap { tupleConversion(of: $0)?.conformingTypes }
+    let payloadConstraint = tupleElementTypes == nil ? jsConvertibleProtocolName : javaScriptEncodableProtocolName
+    let payloads =
+      tupleElementTypes.map { distinctAssertableTypes($0, constraint: payloadConstraint) }
+      ?? event.payloadType.flatMap { assertableBoundaryType($0, constraint: payloadConstraint) }.map { [$0] } ?? []
     let owner = enclosingTypeName(in: context) ?? "Self"
     let emitterParameter = opaqueMetatypeParameter(constraint: eventEmitterProtocolName)
-    let helper =
-      payload != nil
-      ? "func \(name)(\(opaqueMetatypeParameter(constraint: jsConvertibleProtocolName)), \(emitterParameter)) {}"
-      : "func \(name)(\(emitterParameter)) {}"
-    let call = payload.map { "\(name)(\($0).self, \(owner).self)" } ?? "\(name)(\(owner).self)"
+    let payloadParameters = payloads.map { _ in opaqueMetatypeParameter(constraint: payloadConstraint) }
+    let helper = "func \(name)(\((payloadParameters + [emitterParameter]).joined(separator: ", "))) {}"
+    let call = "\(name)(\((payloads + [owner]).map { "\($0).self" }.joined(separator: ", ")))"
     let peerName = derivedIdentifier(from: name, prefix: "_assertTypesConformance_")
     return [
       """

package/apple/Sources/ExpoModulesMacros/ExpoModuleMacro.swift

@@ -49,9 +49,15 @@ public struct ExpoModuleMacro: MemberMacro {
     // DSL entry.
     var functions: [JSFunction] = []
     var properties: [JSProperty] = []
+    var assertions: [MemberConformanceAssertion] = []
+    let aliases = TupleTypeAliases(in: classDecl.memberBlock)
 
     for member in classDecl.memberBlock.members {
-      let decl = member.decl
+      // The types of a `@JS` member are read with the class's tuple aliases resolved.
+      let decl = aliases.resolving(member.decl)
+      if memberHasJSAttribute(decl), let assertion = jsConformanceAssertionBody(for: decl) {
+        assertions.append(assertion)
+      }
 
       if let funcDecl = decl.as(FunctionDeclSyntax.self),
         let attribute = funcDecl.attributes.firstAttribute(named: "JS")
@@ -126,6 +132,12 @@ public struct ExpoModuleMacro: MemberMacro {
       emitted.append(buildDecorateJavaScriptObject(functions: functions, properties: properties))
     }
 
+    // The conformance assertions of the `@JS` members, which `@JS` leaves to this macro (see
+    // `jsConformanceAssertionBody`).
+    if let assertion = classConformanceAssertions(assertions) {
+      emitted.append(assertion)
+    }
+
     return emitted
   }
 }

package/apple/Sources/ExpoModulesMacros/JSMacro.swift

@@ -37,21 +37,43 @@ public struct JSMacro: PeerMacro {
     diagnoseConcurrentOption(of: node, on: declaration, in: context)
     diagnoseAsyncVariantOption(of: node, on: declaration, in: context)
 
-    guard let member = boundaryMember(of: declaration),
-      let assertion = directionalConformanceAssertion(
-        name: member.name,
-        decodableTypes: member.decodableTypes,
-        encodableType: member.encodableType,
-        callbackArgumentTypes: member.callbackArgumentTypes,
-        isStatic: member.isStatic
-      )
-    else {
+    // In an `@ExpoModule` or `@SharedObject` class, the class macro emits the assertion instead: it sees
+    // the type aliases declared in the class body, which this macro can't (see `TupleTypeAliases`).
+    guard !isInBindingClass(context), let assertion = jsConformanceAssertion(for: declaration) else {
       return []
     }
     return [assertion]
   }
 }
 
+/// The conformance-assertion peer for a `@JS` member, or `nil` when the member has no type to assert.
+private func jsConformanceAssertion(for declaration: some DeclSyntaxProtocol) -> DeclSyntax? {
+  guard let member = boundaryMember(of: declaration) else {
+    return nil
+  }
+  return directionalConformanceAssertion(name: member.name, types: member.types, isStatic: member.isStatic)
+}
+
+/// The conformance assertion of a `@JS` member, for an `@ExpoModule` or `@SharedObject` class to fold
+/// into its `_assertTypesConformance()` (see `classConformanceAssertions`), or `nil` when the member has
+/// no type to assert.
+internal func jsConformanceAssertionBody(for declaration: some DeclSyntaxProtocol) -> MemberConformanceAssertion? {
+  guard let member = boundaryMember(of: declaration) else {
+    return nil
+  }
+  return memberConformanceAssertion(name: member.name, types: member.types)
+}
+
+/// True when the member is declared directly in an `@ExpoModule` or `@SharedObject` class, whose macro
+/// binds it.
+private func isInBindingClass(_ context: some MacroExpansionContext) -> Bool {
+  guard let classDecl = context.lexicalContext.first?.as(ClassDeclSyntax.self) else {
+    return false
+  }
+  return classDecl.attributes.firstAttribute(named: "ExpoModule") != nil
+    || classDecl.attributes.firstAttribute(named: "SharedObject") != nil
+}
+
 /// Emits the diagnostic for `@JS(.concurrent)` on a member that can't take it. The option maps to
 /// Swift's `@concurrent`, which requires an `async` function: a synchronous member has nowhere to
 /// suspend, and a property or initializer can't be async at all. Diagnosing here points at the
@@ -323,28 +345,24 @@ private struct JSFixItMessage: FixItMessage {
   }
 }
 
-/// What an assertion peer needs about the `@JS` member it sits beside: a name (to keep the peer unique
-/// among siblings), the boundary types split by conversion direction, and whether the member is
-/// type-level. Arguments (and a settable property's incoming value) are decoded; return values (and a
-/// property's outgoing value) are encoded, so each is asserted against the protocol for its direction.
+/// What an assertion needs about a `@JS` member: a name (which names the helper), the boundary types in
+/// signature order, each with the protocol for the direction it travels and its argument label, and
+/// whether the member is type-level. Arguments (and a settable property's incoming value) are decoded;
+/// return values (and a property's outgoing value) are encoded, so each is asserted against the
+/// protocol for its direction.
 private struct BoundaryMember {
   let name: String
-  /// Types decoded from JS: function/constructor arguments, a settable property's value type, and the
-  /// return types of closure arguments.
-  let decodableTypes: [String]
-  /// The single type encoded to JS: a function's return type, or a property's value type on read;
-  /// `nil` when the member produces nothing JS-visible (a `Void` function).
-  let encodableType: String?
-  /// The parameter types of closure arguments, encoded to JS when native code calls the closure.
-  var callbackArgumentTypes: [String] = []
+  /// The types crossing the boundary, in signature order.
+  let types: [AssertedType]
   /// True for `static`/`class` members, so the peer is emitted in the same metatype context.
   let isStatic: Bool
 }
 
-/// Reads the boundary member off a `@JS` declaration, splitting its types by conversion direction. A
-/// function contributes its parameter types (decodable) and its return type when non-Void (encodable);
-/// an initializer contributes its parameter types; a property contributes its value type as encodable
-/// (the getter) and also as decodable when settable (the setter). Composed types (`[Int]`, `String?`,
+/// Reads the boundary member off a `@JS` declaration, with each type's conversion direction. A function
+/// contributes its parameter types (decodable) under their argument labels and its return type when
+/// non-Void (encodable) under `returning`; an initializer contributes its parameter types; a property
+/// contributes its value type, unlabeled, as decodable when settable (the setter) and as encodable (the
+/// getter). Composed types (`[Int]`, `String?`,
 /// …) are kept verbatim, their conditional conformances transitively constraining the elements. A type
 /// that mentions `Any` is left out: it converts through the free-form methods, or is diagnosed by
 /// `diagnoseFreeFormTypes`. Returns `nil` for declaration kinds `@JS` doesn't read types from, a
@@ -352,30 +370,28 @@ private struct BoundaryMember {
 /// mentions `Any`.
 private func boundaryMember(of declaration: some DeclSyntaxProtocol) -> BoundaryMember? {
   if let funcDecl = declaration.as(FunctionDeclSyntax.self) {
-    let argumentTypes = argumentBoundaryTypes(of: funcDecl.signature.parameterClause.parameters)
-    let returnType = funcDecl.signature.returnClause?.type
-    let encodableType = returnType.flatMap {
-      isVoidType($0) || containsFunctionType($0) || mentionsFreeFormAny($0) ? nil : $0.trimmedDescription
+    var types = argumentBoundaryTypes(of: funcDecl.signature.parameterClause.parameters)
+    if let returnType = funcDecl.signature.returnClause?.type,
+      !isVoidType(returnType) && !containsFunctionType(returnType) && !mentionsFreeFormAny(returnType)
+    {
+      types.append(
+        AssertedType(
+          label: "returning",
+          type: returnType.trimmedDescription,
+          constraint: javaScriptEncodableProtocolName
+        )
+      )
     }
-    return BoundaryMember(
-      name: funcDecl.name.text,
-      decodableTypes: argumentTypes.decodable,
-      encodableType: encodableType,
-      callbackArgumentTypes: argumentTypes.callbackArguments,
-      isStatic: isTypeLevel(funcDecl.modifiers)
-    )
+    return BoundaryMember(name: funcDecl.name.text, types: types, isStatic: isTypeLevel(funcDecl.modifiers))
   }
 
   if let initDecl = declaration.as(InitializerDeclSyntax.self) {
     // A constructor decodes its arguments like a function does, and the instance it returns isn't
     // encoded. The name is escaped because it also names the assertion's nested helper, and `init` is
     // a keyword.
-    let argumentTypes = argumentBoundaryTypes(of: initDecl.signature.parameterClause.parameters)
     return BoundaryMember(
       name: "`init`",
-      decodableTypes: argumentTypes.decodable,
-      encodableType: nil,
-      callbackArgumentTypes: argumentTypes.callbackArguments,
+      types: argumentBoundaryTypes(of: initDecl.signature.parameterClause.parameters),
       isStatic: false
     )
   }
@@ -395,10 +411,11 @@ private func boundaryMember(of declaration: some DeclSyntaxProtocol) -> Boundary
     let typeText = type.trimmedDescription
     let isVar = varDecl.bindingSpecifier.tokenKind == .keyword(.var)
     let isSettable = isVar && !isLazy(varDecl.modifiers) && bindingIsSettable(binding)
+    let decodable = AssertedType(label: nil, type: typeText, constraint: javaScriptDecodableProtocolName)
+    let encodable = AssertedType(label: nil, type: typeText, constraint: javaScriptEncodableProtocolName)
     return BoundaryMember(
       name: identifier.identifier.text,
-      decodableTypes: isSettable ? [typeText] : [],
-      encodableType: typeText,
+      types: (isSettable ? [decodable] : []) + [encodable],
       isStatic: isTypeLevel(varDecl.modifiers)
     )
   }
@@ -406,18 +423,16 @@ private func boundaryMember(of declaration: some DeclSyntaxProtocol) -> Boundary
   return nil
 }
 
-/// The boundary types of a function's or constructor's arguments: an argument is decoded from JS, and
-/// a closure argument instead contributes its parameter types (encoded when native code calls it) and
-/// its return type (decoded).
-private func argumentBoundaryTypes(
-  of parameters: FunctionParameterListSyntax
-) -> (decodable: [String], callbackArguments: [String]) {
+/// The boundary types of a function's or constructor's arguments, under their argument labels: an
+/// argument is decoded from JS, and a closure argument instead contributes its parameter types (encoded
+/// when native code calls it) and its return type (decoded).
+private func argumentBoundaryTypes(of parameters: FunctionParameterListSyntax) -> [AssertedType] {
   // A closure argument moves data the other way: JS receives its parameters and returns its result.
   // A closure in any other position is diagnosed by `diagnoseClosureTypes` and left out here, since
   // its metatype isn't a valid expression in the assertion.
-  var decodableTypes: [String] = []
-  var callbackArgumentTypes: [String] = []
+  var types: [AssertedType] = []
   for parameter in parameters {
+    let label = parameter.firstName.tokenKind == .wildcard ? nil : parameter.firstName.text
     // The specifier isn't part of the asserted type, and a parameter with one the binding can't honor
     // is reported by `diagnoseParameterSpecifiers` and not asserted.
     let specified = SpecifiedType(parameter.type)
@@ -426,23 +441,25 @@ private func argumentBoundaryTypes(
     }
     guard let closure = JSClosureType(specified.type) else {
       if !containsFunctionType(specified.type) && !mentionsFreeFormAny(specified.type) {
-        decodableTypes.append(specified.type.trimmedDescription)
+        let type = specified.type.trimmedDescription
+        types.append(AssertedType(label: label, type: type, constraint: javaScriptDecodableProtocolName))
       }
       continue
     }
     // A closure type that mentions `Any` is reported by `diagnoseClosureTypes` instead.
     for parameter in closure.parameters
     where !containsFunctionType(parameter.type) && !mentionsFreeFormAny(parameter.type) {
-      callbackArgumentTypes.append(parameter.type.trimmedDescription)
+      let type = parameter.type.trimmedDescription
+      types.append(AssertedType(label: label, type: type, constraint: javaScriptEncodableProtocolName))
     }
     let closureReturnType = closure.functionType.returnClause.type
     if let returnType = closure.returnType,
       !containsFunctionType(closureReturnType) && !mentionsFreeFormAny(closureReturnType)
     {
-      decodableTypes.append(returnType)
+      types.append(AssertedType(label: label, type: returnType, constraint: javaScriptDecodableProtocolName))
     }
   }
-  return (decodableTypes, callbackArgumentTypes)
+  return types
 }
 
 /// True when a return clause is written as `Void` / `()` — nothing crosses the boundary, so it needs

package/apple/Sources/ExpoModulesMacros/MacroHelpers.swift

@@ -493,23 +493,30 @@ internal func expressionType(_ type: String) -> String {
 
 /// The decode expression for a boundary type read from `valueExpression` (a `JavaScriptUnownedValue`),
 /// as it appears after `try`. A type that mentions `Any` can't conform to `JavaScriptDecodable`, so it
-/// decodes through the `JavaScriptValue` free-form methods its `freeForm` conversion names; every other
-/// type decodes through its own static `decode`, spelled in expression position (`T!` rewritten to
-/// `T?`).
+/// decodes through the `JavaScriptValue` free-form methods its `freeForm` conversion names, and a tuple
+/// through the `JavaScriptValue` tuple methods (see `TupleConversion`); every other type decodes through
+/// its own static `decode`, spelled in expression position (`T!` rewritten to `T?`).
 internal func decodeCall(_ type: String, freeForm: FreeFormConversion?, from valueExpression: String) -> String {
   if let freeForm {
     return freeForm.decodeExpression(of: valueExpression, as: expressionType(type))
   }
+  if let tuple = tupleConversion(of: type) {
+    return tuple.decodeExpression(of: valueExpression)
+  }
   return "\(expressionType(type)).decode(\(valueExpression), in: runtime)"
 }
 
 /// The encode expression for the native value `valueExpression` of a boundary type, as it appears
 /// after `try`. The counterpart of `decodeCall`: a type that mentions `Any` encodes through the
-/// `JavaScriptValue` free-form methods, and every other type through its own static `encode`.
+/// `JavaScriptValue` free-form methods, a tuple through the `JavaScriptValue` tuple methods, and every
+/// other type through its own static `encode`.
 internal func encodeCall(_ type: String, freeForm: FreeFormConversion?, of valueExpression: String) -> String {
   if let freeForm {
     return freeForm.encodeExpression(of: valueExpression)
   }
+  if let tuple = tupleConversion(of: type) {
+    return tuple.encodeExpression(of: valueExpression)
+  }
   return "\(expressionType(type)).encode(\(valueExpression), in: runtime)"
 }