expo-modules-macros 0.25.0 → 0.27.0

package/apple/Sources/ExpoModulesMacros/{JSMacro.swift → Macros/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/{RecordMacro.swift → Macros/RecordMacro.swift}

@@ -423,10 +423,17 @@ private func dictionaryReadLines(properties: [RecordProperty]) -> [String] {
     let entry = "entry\(index)"
     let exprType = expressionType(property.type)
     let isBareAny = property.freeForm?.isBareAny == true
-    let cast =
-      isBareAny
-      ? entry
-      : "try \(exprType).getDynamicType().cast(\(entry), appContext: appContext) as! \(exprType)"
+    let cast: String
+    if isBareAny {
+      cast = entry
+    } else if tupleConversion(of: property.type) != nil {
+      // A type that holds a tuple has no dynamic type, so the dictionary value must already be of the
+      // property's type.
+      cast =
+        "try { () throws -> \(exprType) in guard let value = \(entry) as? \(exprType) else { throw Conversions.ConvertingException<\(exprType)>(\(entry)) }; return value }()"
+    } else {
+      cast = "try \(exprType).getDynamicType().cast(\(entry), appContext: appContext) as! \(exprType)"
+    }
     lines.append("  let \(entry) = dictionary[\"\(property.key)\"]")
     if property.isRequired {
       lines.append("  guard let \(entry) else {")
@@ -544,7 +551,13 @@ private func objectWriteLines(properties: [RecordProperty], of record: String, c
       encode = "try JavaScriptValue.encodeAny(\(value) as Any, in: runtime)"
     case nil:
       let propName = propNameArgument(for: property, at: index, cached: cachesPropNames)
-      return "  try object.setProperty(\(propName), encoding: \(value), in: runtime)"
+      // A type that holds a tuple has no `encode(_:into:in:)`, so the tuple methods encode it into the
+      // property's slot.
+      if let tuple = tupleConversion(of: property.type) {
+        return
+          "  try object.setProperty(\(propName)) { slot, runtime in try \(tuple.encodeCall(of: value, into: "slot")) }"
+      }
+      return "  try object.setProperty(\(propName), encoding: \(value))"
     }
     let propName = propNameArgument(for: property, at: index, cached: cachesPropNames)
     return "  object.setProperty(\(propName), value: \(encode))"

package/apple/Sources/ExpoModulesMacros/{SharedObjectMacro.swift → Macros/SharedObjectMacro.swift}

@@ -50,9 +50,15 @@ public struct SharedObjectMacro: MemberMacro {
     var staticFunctions: [JSFunction] = []
     var staticProperties: [JSProperty] = []
     var constructor: JSConstructor?
+    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 initDecl = decl.as(InitializerDeclSyntax.self),
         initDecl.attributes.firstAttribute(named: "JS") != nil
@@ -129,6 +135,12 @@ public struct SharedObjectMacro: MemberMacro {
       emitted.append(constructor.buildConstructor(typeName: typeName))
     }
 
+    // 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/{UnionMacro.swift → Macros/UnionMacro.swift}

@@ -270,9 +270,9 @@ private func validatedUnion(of declaration: some DeclGroupSyntax) throws -> Unio
 private func decodeMethod(union: UnionType) -> DeclSyntax {
   var lines: [String] = ["  let kind = JavaScriptValueKinds(of: value)"]
   for unionCase in union.cases {
-    let payloadType = expressionType(unionCase.payloadType)
+    let conversion = payloadConversion(unionCase)
     lines.append(
-      "  if \(payloadType).decodableKinds.contains(kind), let payload = try? \(payloadType).decode(value, in: runtime) {"
+      "  if \(conversion.decodableKindsExpression).contains(kind), let payload = try? \(conversion.decodeExpression(of: "value")) {"
     )
     lines.append("    return \(unionCase.construction)")
     lines.append("  }")
@@ -293,7 +293,7 @@ private func decodeMethod(union: UnionType) -> DeclSyntax {
 /// `decodableKinds`: the union of the payloads' kinds, so a union nested in another union, or wrapped
 /// in an optional, is skipped as precisely as its payloads are.
 private func decodableKindsProperty(union: UnionType) -> DeclSyntax {
-  let kinds = union.cases.map { "\(expressionType($0.payloadType)).decodableKinds" }
+  let kinds = union.cases.map { payloadConversion($0).decodableKindsExpression }
   // An option set's array literal is the union of its elements, which reads like the case list. The
   // optimizer folds it to a constant after specialization, the same as a chain of `union(_:)` calls.
   let expression = kinds.count == 1 ? kinds[0] : "[\(kinds.joined(separator: ", "))]"
@@ -311,7 +311,7 @@ private func encodeMethod(union: UnionType) -> DeclSyntax {
   var lines: [String] = ["  switch value {"]
   for unionCase in union.cases {
     lines.append("  case \(unionCase.pattern):")
-    lines.append("    return try \(expressionType(unionCase.payloadType)).encode(payload, in: runtime)")
+    lines.append("    return try \(payloadConversion(unionCase).encodeExpression(of: "payload"))")
   }
   lines.append("  }")
   let body = lines.joined(separator: "\n")
@@ -331,7 +331,12 @@ private func encodeIntoSlotMethod(union: UnionType) -> DeclSyntax {
   var lines: [String] = ["  switch value {"]
   for unionCase in union.cases {
     lines.append("  case \(unionCase.pattern):")
-    lines.append("    try \(expressionType(unionCase.payloadType)).encode(payload, into: slot, in: runtime)")
+    if let tuple = tupleConversion(of: unionCase.payloadType) {
+      // A payload that holds a tuple has no `encode(_:into:in:)`, so the tuple methods encode it into the slot.
+      lines.append("    try \(tuple.encodeCall(of: "payload", into: "slot"))")
+    } else {
+      lines.append("    try \(expressionType(unionCase.payloadType)).encode(payload, into: slot, in: runtime)")
+    }
   }
   lines.append("  }")
   let body = lines.joined(separator: "\n")
@@ -439,3 +444,9 @@ private struct UnionFixItMessage: FixItMessage {
     self.fixItID = MessageID(domain: "ExpoModulesMacros", id: id)
   }
 }
+
+/// How a case's payload converts: through the tuple methods when it holds a tuple (see
+/// `TupleConversion`), and through its own `decode` / `encode` otherwise.
+private func payloadConversion(_ unionCase: UnionCase) -> TupleConversion {
+  return tupleConversion(of: unionCase.payloadType) ?? .conforming(type: unionCase.payloadType)
+}

package/apple/Sources/ExpoModulesMacros/Plugin.swift

@@ -1,4 +1,4 @@
-import ExpoModulesScanner
+import ExpoModulesCLI
 import SwiftCompilerPlugin
 import SwiftSyntaxMacros
 
@@ -11,23 +11,14 @@ import CRT
 #endif
 
 struct ExpoModulesMacrosPlugin: CompilerPlugin {
-  let providingMacros: [Macro.Type] = [
-    OptimizedFunctionAttachedMacro.self,
-    JSMacro.self,
-    EventMacro.self,
-    ExpoModuleMacro.self,
-    SharedObjectMacro.self,
-    RecordMacro.self,
-    UnionMacro.self,
-    ViewPropsMacro.self,
-    ExpoViewMacro.self,
-  ]
+  let providingMacros: [Macro.Type] = ProvidedMacro.all.map(\.type)
 }
 
 /// The executable doubles as the scanner CLI. The compiler always launches a plugin executable
 /// without arguments and speaks the plugin protocol over stdin, so any argument means a scanner
 /// invocation (`ExpoModulesMacros scan-modules <path>...`); with none, this starts the plugin
-/// server exactly as `@main` on the `CompilerPlugin` type would.
+/// server exactly as `@main` on the `CompilerPlugin` type would. The CLI gets `expandMacros`, so
+/// `expand` runs the macros of this executable.
 @main
 enum EntryPoint {
   static func main() throws {
@@ -35,7 +26,11 @@ enum EntryPoint {
     if arguments.isEmpty {
       try ExpoModulesMacrosPlugin.main()
     } else {
-      exit(ScannerCLI.run(arguments: arguments))
+      let expander = MacroExpander(
+        attributeNames: Set(ProvidedMacro.all.map(\.name)),
+        expand: expandMacros
+      )
+      exit(ScannerCLI.run(arguments: arguments, expander: expander))
     }
   }
 }

package/apple/Sources/ExpoModulesMacros/ProvidedMacros.swift

@@ -0,0 +1,31 @@
+import SwiftSyntax
+import SwiftSyntaxMacros
+
+/// A macro that the plugin provides, with the attribute name and the extension conformances of its
+/// declaration in `expo-modules-core`.
+struct ProvidedMacro {
+  let name: String
+  let type: Macro.Type
+  var conformances: [TypeSyntax] = []
+
+  /// Every macro of the plugin. The compiler gets the types from `providingMacros`, and `expand`
+  /// matches the attributes by name and passes the same conformances as the compiler, so both read
+  /// this list.
+  static var all: [ProvidedMacro] {
+    [
+      ProvidedMacro(name: "OptimizedFunction", type: OptimizedFunctionAttachedMacro.self),
+      ProvidedMacro(name: "JS", type: JSMacro.self),
+      ProvidedMacro(name: "Event", type: EventMacro.self),
+      ProvidedMacro(name: "ExpoModule", type: ExpoModuleMacro.self, conformances: ["AnyModule"]),
+      ProvidedMacro(name: "SharedObject", type: SharedObjectMacro.self),
+      ProvidedMacro(name: "Record", type: RecordMacro.self, conformances: ["Record"]),
+      ProvidedMacro(
+        name: "Union",
+        type: UnionMacro.self,
+        conformances: ["JavaScriptDecodable", "JavaScriptEncodable"]
+      ),
+      ProvidedMacro(name: "ViewProps", type: ViewPropsMacro.self, conformances: ["AnyViewProps"]),
+      ProvidedMacro(name: "ExpoView", type: ExpoViewMacro.self),
+    ]
+  }
+}

package/apple/Sources/ExpoModulesMacros/{ClosureArguments.swift → Support/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,16 @@ 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 the tuple methods encode it into the
+      // argument's slot.
+      if let tuple = tupleConversion(of: parameter.type) {
+        let encode = tuple.encodeCall(of: value, into: "slot", in: "_runtime")
+        lines.append("    try _arguments.emplace(at: \(index)) { slot in try \(encode) }")
+      } else {
+        lines.append("    try _arguments.emplace(\(value), at: \(index), in: _runtime)")
+      }
     }
     return lines + ["  }", "}"]
   }
@@ -336,6 +350,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 → Support/DecorateModuleBuilder.swift}

@@ -499,13 +499,17 @@ private let resultSlotClosureParameters =
   + "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` has no `encode(_:into:in:)`, so its free-form encode result is moved into the slot.
+/// that mentions `Any` has no `encode(_:into:in:)`, so its free-form encode result is moved into the slot,
+/// and a type that holds a tuple is encoded into the slot by the tuple methods.
 private func encodeIntoSlotStatement(_ type: String, freeForm: FreeFormConversion?, of valueExpression: String)
   -> String
 {
   if freeForm != nil {
     return "result.emplace(try \(encodeCall(type, freeForm: freeForm, of: valueExpression)))"
   }
+  if let tuple = tupleConversion(of: type) {
+    return "try \(tuple.encodeCall(of: valueExpression, into: "result"))"
+  }
   return "try \(expressionType(type)).encode(\(valueExpression), into: result, in: runtime)"
 }
 

package/apple/Sources/ExpoModulesMacros/{MacroHelpers.swift → Support/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)"
 }