expo-modules-macros 0.24.0 → 0.26.0

package/apple/Sources/ExpoModulesMacros/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 {")
@@ -477,7 +484,9 @@ private func toObjectMethod() -> DeclSyntax {
 /// property's declared default (inlined) when undefined; optional properties become `nil` when
 /// undefined/null. It's the unowned overload: an owning value decodes through `JavaScriptDecodable`'s
 /// default, which forwards to it. `encode` builds the JS object, writing each property. Its parameter
-/// names the type, because a class can't take `Self` as a parameter type.
+/// names the type, because a class can't take `Self` as a parameter type. `encode(_:into:in:)` builds
+/// the same object and moves it into the slot (an array element, an argument or a result), with no
+/// `JavaScriptValue` in between.
 private func javaScriptCodableWitnesses(
   properties: [RecordProperty],
   typeName: String,
@@ -491,11 +500,12 @@ private func javaScriptCodableWitnesses(
   let lookupLines = cachesPropNames ? propNamesLookupLines() : []
   let readLines = lookupLines + jsObjectReadLines(properties: properties, cachesPropNames: cachesPropNames)
   let decodeBody = objectLine + "\n" + factoryBody(properties: properties, readLines: readLines)
-  let encodeLines =
+  let objectLines =
     ["  let object = runtime.createObject()"]
     + lookupLines
     + objectWriteLines(properties: properties, of: "value", cachesPropNames: cachesPropNames)
-    + ["  return object.takeValue()"]
+  let encodeLines = objectLines + ["  return object.takeValue()"]
+  let encodeIntoSlotLines = objectLines + ["  slot.emplace(object)"]
   return [
     """
     @JavaScriptActor
@@ -509,12 +519,23 @@ private func javaScriptCodableWitnesses(
     \(raw: encodeLines.joined(separator: "\n"))
     }
     """,
+    """
+    @JavaScriptActor
+    public static func encode(
+      _ value: \(raw: typeName),
+      into slot: borrowing JavaScriptValue.Slot,
+      in runtime: borrowing JavaScriptRuntime
+    ) throws {
+    \(raw: encodeIntoSlotLines.joined(separator: "\n"))
+    }
+    """,
   ]
 }
 
 /// The statements that write each property of `record` (`self` or the `encode` parameter) into the
-/// `object` local, encoding it with `JavaScriptEncodable.encode` or, for a free-form property, the
-/// matching `JavaScriptValue` free-form method.
+/// `object` local. A property is encoded straight into the engine value that `setProperty` writes, through
+/// `JavaScriptEncodable.encode(_:into:in:)`, so a number, a boolean or a string never becomes a
+/// `JavaScriptValue`. A free-form property goes through the matching `JavaScriptValue` free-form method.
 private func objectWriteLines(properties: [RecordProperty], of record: String, cachesPropNames: Bool) -> [String] {
   return properties.enumerated().map { index, property in
     let value = "\(record).\(property.name)"
@@ -529,7 +550,12 @@ private func objectWriteLines(properties: [RecordProperty], of record: String, c
       // The explicit `as Any` keeps an optional property from warning about its implicit coercion.
       encode = "try JavaScriptValue.encodeAny(\(value) as Any, in: runtime)"
     case nil:
-      encode = "try \(expressionType(property.type)).encode(\(value), in: runtime)"
+      let propName = propNameArgument(for: property, at: index, cached: cachesPropNames)
+      // A type that holds a tuple has no `encode(_:into:in:)`, so its encoded value is written instead.
+      if let tuple = tupleConversion(of: property.type) {
+        return "  object.setProperty(\(propName), value: try \(tuple.encodeExpression(of: value)))"
+      }
+      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

@@ -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/TupleTypes.swift

@@ -0,0 +1,234 @@
+import SwiftSyntax
+
+/// Recognition of boundary types that hold a tuple, and the conversions the macros emit for them. A
+/// tuple can't conform to a protocol, so neither it nor an array, optional or dictionary of tuples can
+/// convert through the usual `T.decode` / `T.encode` path. Such a type converts through the
+/// `JavaScriptValue` tuple and container methods instead, which take one closure per element, so the
+/// conversion follows the structure of the type: a tuple, optional, array or `String`-keyed dictionary
+/// that holds a tuple converts through the matching method, and every other type in it through its own
+/// `decode` / `encode`.
+///
+/// An unlabeled tuple maps to a JavaScript array with one value per element, and a labeled tuple to an
+/// object with one property per label. Recognized are tuples of two or more elements where either every
+/// element is labeled or none is. `TypeConformanceAssertion` asserts the types that convert through
+/// their own `decode` / `encode` (see `conformingTypes`) in place of the whole type.
+internal enum TupleConversion {
+  /// A type that holds no tuple, which converts through its own `decode` / `encode`.
+  case conforming(type: String)
+  /// A tuple: the conversion of each element, with one label per element for a labeled tuple.
+  case tuple(elements: [TupleConversion], labels: [String]?)
+  /// An optional of a type that holds a tuple.
+  indirect case optional(wrapped: TupleConversion)
+  /// An array of a type that holds a tuple.
+  indirect case array(element: TupleConversion)
+  /// A `String`-keyed dictionary whose values hold a tuple.
+  indirect case dictionary(value: TupleConversion)
+
+  /// The decode expression, as it appears after `try`, for a value read from `valueExpression` (a
+  /// `JavaScriptUnownedValue`). A tuple whose elements all conform passes the element types; any other
+  /// tuple and every container pass closures, which take the value and the runtime as parameters that
+  /// shadow the outer ones, so a closure captures nothing.
+  func decodeExpression(of valueExpression: String) -> String {
+    switch self {
+    case .conforming(let type):
+      return "\(expressionType(type)).decode(\(valueExpression), in: runtime)"
+    case .tuple(let elements, let labels):
+      if let types = conformingElementTypes(elements) {
+        let metatypes = types.map { "\(expressionType($0)).self" }.joined(separator: ", ")
+        let arguments = [valueExpression] + labelsArgument(labels) + ["as: \(metatypes)", "in: runtime"]
+        return "JavaScriptValue.decodeTuple(\(arguments.joined(separator: ", ")))"
+      }
+      let closures = elements.map { elementClosure(returning: $0.decodeExpression(of: "value")) }
+      let arguments = [valueExpression] + labelsArgument(labels) + ["in: runtime"] + closures
+      return "JavaScriptValue.decodeTuple(\(arguments.joined(separator: ", ")))"
+    case .optional(let wrapped):
+      return containerDecode("decodeOptional", label: "wrapped", inner: wrapped, of: valueExpression)
+    case .array(let element):
+      return containerDecode("decodeArray", label: "element", inner: element, of: valueExpression)
+    case .dictionary(let value):
+      return containerDecode("decodeDictionary", label: "value", inner: value, of: valueExpression)
+    }
+  }
+
+  /// The encode expression, as it appears after `try`, for the value `valueExpression` in the runtime
+  /// named `runtime`. A tuple whose elements all conform needs no closures. The tuple method takes an
+  /// unlabeled tuple, so a labeled one is coerced to its unlabeled type first.
+  func encodeExpression(of valueExpression: String, in runtime: String = "runtime") -> String {
+    switch self {
+    case .conforming(let type):
+      return "\(expressionType(type)).encode(\(valueExpression), in: \(runtime))"
+    case .tuple(let elements, let labels):
+      let value = labels == nil ? valueExpression : "\(valueExpression) as \(unlabeledType)"
+      let closures =
+        conformingElementTypes(elements) == nil
+        ? elements.map { elementClosure(returning: $0.encodeExpression(of: "value")) } : []
+      let arguments = [value] + labelsArgument(labels) + ["in: \(runtime)"] + closures
+      return "JavaScriptValue.encodeTuple(\(arguments.joined(separator: ", ")))"
+    case .optional(let wrapped):
+      return containerEncode("encodeOptional", label: "wrapped", inner: wrapped, of: valueExpression, in: runtime)
+    case .array(let element):
+      return containerEncode("encodeArray", label: "element", inner: element, of: valueExpression, in: runtime)
+    case .dictionary(let value):
+      return containerEncode("encodeDictionary", label: "value", inner: value, of: valueExpression, in: runtime)
+    }
+  }
+
+  /// The JavaScript value kinds the decode accepts, as an expression of type `JavaScriptValueKinds`, for
+  /// a `@Union` that picks a payload by kind. Mirrors the kinds of the matching `JavaScriptCodable`
+  /// conformances: an array decodes a non-array value as a single element.
+  var decodableKindsExpression: String {
+    switch self {
+    case .conforming(let type):
+      return "\(expressionType(type)).decodableKinds"
+    case .tuple:
+      return "JavaScriptValueKinds.object"
+    case .optional(let wrapped):
+      return "\(wrapped.decodableKindsExpression).union([.null, .undefined])"
+    case .array(let element):
+      return "\(element.decodableKindsExpression).union(JavaScriptValueKinds.object)"
+    case .dictionary:
+      return "JavaScriptValueKinds.object"
+    }
+  }
+
+  /// The types in the structure that convert through their own `decode` / `encode`, in order, as
+  /// written.
+  var conformingTypes: [String] {
+    switch self {
+    case .conforming(let type):
+      return [type]
+    case .tuple(let elements, _):
+      return elements.flatMap(\.conformingTypes)
+    case .optional(let inner), .array(let inner), .dictionary(let inner):
+      return inner.conformingTypes
+    }
+  }
+
+  /// The type spelled in expression position, with tuple labels kept for nested tuples.
+  private var spelledType: String {
+    switch self {
+    case .conforming(let type):
+      return expressionType(type)
+    case .tuple(let elements, let labels):
+      let spelled = elements.enumerated().map { index, element in
+        labels.map { "\($0[index]): \(element.spelledType)" } ?? element.spelledType
+      }
+      return "(\(spelled.joined(separator: ", ")))"
+    case .optional(let wrapped):
+      return "\(wrapped.spelledType)?"
+    case .array(let element):
+      return "[\(element.spelledType)]"
+    case .dictionary(let value):
+      return "[String: \(value.spelledType)]"
+    }
+  }
+
+  /// The type of a tuple with its own labels dropped. Labels of nested tuples are kept, since the
+  /// nested conversion handles them.
+  private var unlabeledType: String {
+    guard case .tuple(let elements, _) = self else {
+      return spelledType
+    }
+    return "(\(elements.map(\.spelledType).joined(separator: ", ")))"
+  }
+
+  private func containerDecode(
+    _ method: String,
+    label: String,
+    inner: TupleConversion,
+    of valueExpression: String
+  ) -> String {
+    return
+      "JavaScriptValue.\(method)(\(valueExpression), in: runtime, \(label): \(elementClosure(returning: inner.decodeExpression(of: "value"))))"
+  }
+
+  private func containerEncode(
+    _ method: String,
+    label: String,
+    inner: TupleConversion,
+    of valueExpression: String,
+    in runtime: String
+  ) -> String {
+    return
+      "JavaScriptValue.\(method)(\(valueExpression), in: \(runtime), \(label): \(elementClosure(returning: inner.encodeExpression(of: "value"))))"
+  }
+
+  /// The types of a tuple's elements when every element converts through its own `decode` /
+  /// `encode`, so the tuple can use the overloads that take no closures; `nil` otherwise.
+  private func conformingElementTypes(_ elements: [TupleConversion]) -> [String]? {
+    var types: [String] = []
+    for element in elements {
+      guard case .conforming(let type) = element else {
+        return nil
+      }
+      types.append(type)
+    }
+    return types
+  }
+
+  private func labelsArgument(_ labels: [String]?) -> [String] {
+    guard let labels else {
+      return []
+    }
+    return ["labels: [\(labels.map { "\"\($0)\"" }.joined(separator: ", "))]"]
+  }
+}
+
+/// The conversion for a boundary type that holds a tuple, or `nil` when the type holds no tuple the
+/// tuple methods convert (a single parenthesized type, a tuple that labels only some elements, or one
+/// with a variadic element converts as it's written, and fails its conformance assertion).
+internal func tupleConversion(of type: TypeSyntax) -> TupleConversion? {
+  let conversion = structure(of: type)
+  guard case .conforming = conversion else {
+    return conversion
+  }
+  return nil
+}
+
+/// The conversion for a boundary type written as a string. See `tupleConversion(of:)`.
+internal func tupleConversion(of type: String) -> TupleConversion? {
+  return tupleConversion(of: TypeSyntax(stringLiteral: type))
+}
+
+/// The conversion of `type`, which is `.conforming` when the type holds no recognized tuple.
+private func structure(of type: TypeSyntax) -> TupleConversion {
+  let conforming = TupleConversion.conforming(type: type.trimmedDescription)
+  if let tuple = type.as(TupleTypeSyntax.self) {
+    // `(T)` is the same type as `T`.
+    if tuple.elements.count == 1, let only = tuple.elements.first, only.firstName == nil {
+      return structure(of: only.type)
+    }
+    guard tuple.elements.count >= 2,
+      tuple.elements.allSatisfy({ $0.ellipsis == nil && $0.inoutKeyword == nil })
+    else {
+      return conforming
+    }
+    let labels = tuple.elements.compactMap { $0.firstName?.text }
+    guard labels.isEmpty || labels.count == tuple.elements.count else {
+      return conforming
+    }
+    return .tuple(elements: tuple.elements.map { structure(of: $0.type) }, labels: labels.isEmpty ? nil : labels)
+  }
+  let inner: TupleConversion
+  let wrap: (TupleConversion) -> TupleConversion
+  if let wrapped = optionalWrappedType(type) {
+    (inner, wrap) = (structure(of: wrapped), TupleConversion.optional)
+  } else if let element = arrayElementType(type) {
+    (inner, wrap) = (structure(of: element), TupleConversion.array)
+  } else if let value = stringKeyedDictionaryValueType(type) {
+    (inner, wrap) = (structure(of: value), TupleConversion.dictionary)
+  } else {
+    return conforming
+  }
+  // A container that holds no tuple conforms as a whole.
+  if case .conforming = inner {
+    return conforming
+  }
+  return wrap(inner)
+}
+
+/// An element closure that returns `expression`, as it appears after `try`. It takes the value and
+/// the runtime as parameters, which shadow the outer ones, so it captures nothing.
+internal func elementClosure(returning expression: String) -> String {
+  return "{ value, runtime in return try \(expression) }"
+}

package/apple/Sources/ExpoModulesMacros/TypeAliases.swift

@@ -0,0 +1,75 @@
+import SwiftSyntax
+
+/// The type aliases declared in the body of a class whose aliased type holds a tuple (see
+/// `TupleConversion`), resolved to that type. A macro sees only the declaration it's attached to, so
+/// `@ExpoModule` and `@SharedObject` collect the aliases from their class body, and resolve them in
+/// the `@JS` members they bind before reading the members' types: an alias of a tuple can't convert
+/// through `decode` / `encode` under its own name, because the tuple can't conform.
+///
+/// An alias declared anywhere else (at file level, in an extension or in another type) isn't visible
+/// to the macros, so it converts under its own name and fails its conformance assertion. A generic
+/// alias isn't resolved either.
+internal struct TupleTypeAliases {
+  /// The resolved type of each alias, by name.
+  private let resolved: [String: TypeSyntax]
+
+  init(in memberBlock: MemberBlockSyntax) {
+    var declared: [String: TypeSyntax] = [:]
+    for member in memberBlock.members {
+      guard let alias = member.decl.as(TypeAliasDeclSyntax.self), alias.genericParameterClause == nil else {
+        continue
+      }
+      declared[alias.name.text] = alias.initializer.value
+    }
+    // Aliases may refer to each other, so each one is resolved through the others. An alias that refers
+    // back to itself is invalid Swift, and is left as written after `declared.count` rounds.
+    var resolved = declared
+    for _ in 0..<declared.count {
+      let rewriter = AliasRewriter(aliases: resolved)
+      resolved = resolved.mapValues { rewriter.rewrite($0).cast(TypeSyntax.self) }
+    }
+    self.resolved = resolved.filter { tupleConversion(of: $0.value) != nil }
+  }
+
+  /// True when the class body declares no alias that holds a tuple.
+  var isEmpty: Bool {
+    return resolved.isEmpty
+  }
+
+  /// `node` with each reference to an alias that holds a tuple replaced by the aliased type.
+  func resolving<Node: SyntaxProtocol>(_ node: Node) -> Node {
+    guard !resolved.isEmpty else {
+      return node
+    }
+    return AliasRewriter(aliases: resolved).rewrite(node).cast(Node.self)
+  }
+}
+
+/// Replaces each type reference to an alias by the aliased type: a bare name (`Pair`) or one qualified
+/// with `Self` (`Self.Pair`). A name with generic arguments isn't an alias reference, since the
+/// resolved aliases aren't generic.
+private final class AliasRewriter: SyntaxRewriter {
+  let aliases: [String: TypeSyntax]
+
+  init(aliases: [String: TypeSyntax]) {
+    self.aliases = aliases
+    super.init(viewMode: .sourceAccurate)
+  }
+
+  override func visit(_ node: IdentifierTypeSyntax) -> TypeSyntax {
+    guard node.genericArgumentClause == nil, let aliased = aliases[node.name.text] else {
+      return TypeSyntax(node)
+    }
+    return aliased.with(\.leadingTrivia, node.leadingTrivia).with(\.trailingTrivia, node.trailingTrivia)
+  }
+
+  override func visit(_ node: MemberTypeSyntax) -> TypeSyntax {
+    guard node.baseType.as(IdentifierTypeSyntax.self)?.name.text == "Self",
+      node.genericArgumentClause == nil,
+      let aliased = aliases[node.name.text]
+    else {
+      return super.visit(node)
+    }
+    return aliased.with(\.leadingTrivia, node.leadingTrivia).with(\.trailingTrivia, node.trailingTrivia)
+  }
+}

package/apple/Sources/ExpoModulesMacros/TypeConformanceAssertion.swift

@@ -40,57 +40,78 @@ internal struct ConformanceAssertion {
   let types: [String]
 }
 
+/// One type crossing the boundary for a member, as a parameter of the member's assertion helper: the
+/// type as written, the protocol it must conform to for the direction it travels, and the argument label
+/// it's passed under.
+internal struct AssertedType {
+  /// The argument label, or `nil` for an unlabeled parameter.
+  let label: String?
+  /// The type as written.
+  let type: String
+  /// `JavaScriptDecodable` for a type decoded from JavaScript, `JavaScriptEncodable` for one encoded to it.
+  let constraint: String
+}
+
 /// A directional conformance-assertion peer for a `@JS` member: a never-called `private func` whose
-/// body asserts each argument type is `JavaScriptDecodable` and the return/getter type is
+/// body asserts that each argument type is `JavaScriptDecodable` and the return or getter type is
 /// `JavaScriptEncodable`, matching how the generated binding converts each (decode on the way in,
-/// encode on the way out). The check is a single member-named nested helper with one opaque metatype
-/// parameter per asserted type, called once with every type's metatype; naming the helper after the
-/// member puts the member in the compiler's diagnostic, and the per-parameter constraint reports the
-/// offending type against the protocol for *its* direction.
+/// encode on the way out). The body is a local helper named after the member, with one opaque metatype
+/// parameter per asserted type, called once with every type's metatype (see
+/// `memberConformanceAssertion`). Naming the helper after the member and its labels puts the member in
+/// the compiler's diagnostic, and the per-parameter constraint reports the offending type against the
+/// protocol for its direction.
 ///
-/// `decodableTypes` are the argument types (and a settable property's value type); `encodableType` is
-/// the single return type (or a property's value type on read), or `nil` when there's none.
-/// `callbackArgumentTypes` are the parameter types of closure arguments, which are encoded when native
-/// code calls the closure. Types known to conform are dropped from each; when nothing is left in any of
-/// them, returns `nil` so the caller emits no peer. `isStatic` mirrors a `static`/`class` member so the
-/// peer sits in the right metatype context.
-internal func directionalConformanceAssertion(
-  name: String,
-  decodableTypes: [String],
-  encodableType: String?,
-  callbackArgumentTypes: [String] = [],
-  isStatic: Bool
-) -> DeclSyntax? {
-  let decodables = distinctAssertableTypes(decodableTypes, constraint: javaScriptDecodableProtocolName)
-  let callbackArguments = distinctAssertableTypes(callbackArgumentTypes, constraint: javaScriptEncodableProtocolName)
-  let encodable = encodableType.flatMap { assertableBoundaryType($0, constraint: javaScriptEncodableProtocolName) }
-  guard !decodables.isEmpty || !callbackArguments.isEmpty || encodable != nil else {
+/// Returns `nil` when every type is known to conform, so the caller emits no peer. `isStatic` mirrors a
+/// `static`/`class` member so the peer sits in the right metatype context.
+internal func directionalConformanceAssertion(name: String, types: [AssertedType], isStatic: Bool) -> DeclSyntax? {
+  guard let assertion = memberConformanceAssertion(name: name, types: types) else {
     return nil
   }
-
-  // Arguments are constrained `JavaScriptDecodable`, and closure-argument parameters and the
-  // return/getter value `JavaScriptEncodable`. Every parameter suppresses `Copyable`, so a
-  // non-copyable boundary type such as `JavaScriptValue` can fill it.
-  let encodables = callbackArguments + [encodable].compactMap { $0 }
-  let decodableParameter = opaqueMetatypeParameter(constraint: "\(javaScriptDecodableProtocolName) & ~Copyable")
-  let encodableParameter = opaqueMetatypeParameter(constraint: "\(javaScriptEncodableProtocolName) & ~Copyable")
-  let parameters =
-    Array(repeating: decodableParameter, count: decodables.count)
-    + Array(repeating: encodableParameter, count: encodables.count)
-  let arguments = (decodables + encodables).map { "\($0).self" }
-
-  let helper = "func \(name)(\(parameters.joined(separator: ", "))) {}"
-  let call = "\(name)(\(arguments.joined(separator: ", ")))"
   let staticKeyword = isStatic ? "static " : ""
   let peerName = derivedIdentifier(from: name, prefix: "_assertTypesConformance_")
   return """
     private \(raw: staticKeyword)func \(raw: peerName)() {
-    \(raw: helper)
-    \(raw: call)
+    \(raw: assertion.helper)
+    \(raw: assertion.call)
     }
     """
 }
 
+/// The local helper of a member's conformance assertion and its call, or `nil` when every type is known
+/// to conform. The helper is named after the member and takes the labels of the types, so the
+/// diagnostic reads like the member's signature, such as `local function 'move(_:by:returning:)'
+/// requires that 'Point' conform to 'JavaScriptEncodable'`. A type that holds a tuple contributes the
+/// types in it (see `distinctAssertableTypes`), under its label. Every parameter suppresses `Copyable`,
+/// so a non-copyable boundary type such as `JavaScriptValue` can fill it.
+internal func memberConformanceAssertion(name: String, types: [AssertedType]) -> MemberConformanceAssertion? {
+  var seen: Set<String> = []
+  var parameters: [AssertedType] = []
+  for asserted in types {
+    for type in distinctAssertableTypes([asserted.type], constraint: asserted.constraint) {
+      let key = "\(asserted.label ?? "_") \(type) \(asserted.constraint)"
+      if seen.insert(key).inserted {
+        parameters.append(AssertedType(label: asserted.label, type: type, constraint: asserted.constraint))
+      }
+    }
+  }
+  guard !parameters.isEmpty else {
+    return nil
+  }
+  let declared = parameters.map { parameter in
+    let metatype = "(some \(parameter.constraint) & ~Copyable).Type"
+    return parameter.label.map { "\($0) _: \(metatype)" } ?? "_: \(metatype)"
+  }
+  let passed = parameters.map { parameter in
+    return parameter.label.map { "\($0): \(parameter.type).self" } ?? "\(parameter.type).self"
+  }
+  let labels = parameters.map { "\($0.label ?? "_"):" }.joined()
+  return MemberConformanceAssertion(
+    signature: "\(name)(\(labels))",
+    helper: "func \(name)(\(declared.joined(separator: ", "))) {}",
+    call: "\(name)(\(passed.joined(separator: ", ")))"
+  )
+}
+
 /// One conformance-assertion peer covering several members' assertions at once — used by `@Record`,
 /// which folds every property into a single `_assertTypesConformance()` rather than emitting a peer
 /// per property. Each assertion keeps its own named nested helper, so the per-member naming in the
@@ -182,11 +203,16 @@ internal func opaqueMetatypeParameter(constraint: String) -> String {
 }
 
 /// The distinct types to assert against `constraint` from a list, mapping each through
-/// `assertableBoundaryType` (which drops what needs no assertion) and deduping in first-seen order.
-private func distinctAssertableTypes(_ types: [String], constraint: String) -> [String] {
+/// `assertableBoundaryType` (which drops what needs no assertion) and deduping in first-seen order. A
+/// type that holds a tuple converts element by element (see `TupleConversion`), so the types in it that
+/// convert through their own `decode` / `encode` are asserted in its place.
+internal func distinctAssertableTypes(_ types: [String], constraint: String) -> [String] {
   var seen: Set<String> = []
   var distinct: [String] = []
-  let assertable = types.compactMap { assertableBoundaryType($0, constraint: constraint) }
+  let assertable = types.flatMap { type in
+    let elementTypes = tupleConversion(of: type)?.conformingTypes ?? [type]
+    return elementTypes.compactMap { assertableBoundaryType($0, constraint: constraint) }
+  }
   for type in assertable where seen.insert(type).inserted {
     distinct.append(type)
   }
@@ -207,3 +233,40 @@ private func unwrappedOptional(_ type: String) -> String {
   }
   return String(result)
 }
+
+/// The conformance assertion of one member: a local helper function named after the member, which takes
+/// the metatype of each asserted type, and its call.
+internal struct MemberConformanceAssertion {
+  /// The helper's full name with its argument labels, such as `load(_:)`.
+  let signature: String
+  /// The helper's declaration.
+  let helper: String
+  /// The call of the helper with each asserted type's metatype.
+  let call: String
+}
+
+/// One assertion member covering the `@JS` members of an `@ExpoModule` or `@SharedObject` class, which
+/// the class macro emits in place of the `@JS` peers: each member's helper and its call, in member order.
+/// The helpers are local functions, so two helpers with the same name and labels (members that differ
+/// only by argument types) would redeclare the same function: such a helper sits in its own `do` block.
+/// Returns `nil` when no member has a type to assert.
+internal func classConformanceAssertions(_ assertions: [MemberConformanceAssertion]) -> DeclSyntax? {
+  guard !assertions.isEmpty else {
+    return nil
+  }
+  var signatureCounts: [String: Int] = [:]
+  for assertion in assertions {
+    signatureCounts[assertion.signature, default: 0] += 1
+  }
+  let lines = assertions.flatMap { assertion in
+    guard signatureCounts[assertion.signature, default: 0] > 1 else {
+      return [assertion.helper, assertion.call]
+    }
+    return ["do {", "  \(assertion.helper)", "  \(assertion.call)", "}"]
+  }
+  return """
+    private func _assertTypesConformance() {
+    \(raw: lines.joined(separator: "\n"))
+    }
+    """
+}