expo-modules-macros 0.23.0 → 0.23.1

package/apple/Sources/ExpoModulesMacros/EventMacro.swift

@@ -80,18 +80,19 @@ extension EventMacro: PeerMacro {
       return []
     }
     // One nested helper asserts everything in a single call: the payload type is JS-convertible
-    // (the `P` parameter, dropped for no-payload events and known-conforming primitives) and the
-    // enclosing type can emit (the `E` parameter, always present since any `@Event` dispatches
+    // (the first parameter, dropped for no-payload events and known-conforming primitives) and the
+    // enclosing type can emit (the last parameter, always present since any `@Event` dispatches
     // 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'.
     let name = event.swiftName
     let payload = event.payloadType.flatMap { assertableBoundaryType($0, constraint: jsConvertibleProtocolName) }
     let owner = enclosingTypeName(in: context) ?? "Self"
+    let emitterParameter = opaqueMetatypeParameter(constraint: eventEmitterProtocolName)
     let helper =
       payload != nil
-      ? "func \(name)<P: \(jsConvertibleProtocolName), E: \(eventEmitterProtocolName)>(_: P.Type, _: E.Type) {}"
-      : "func \(name)<E: \(eventEmitterProtocolName)>(_: E.Type) {}"
+      ? "func \(name)(\(opaqueMetatypeParameter(constraint: jsConvertibleProtocolName)), \(emitterParameter)) {}"
+      : "func \(name)(\(emitterParameter)) {}"
     let call = payload.map { "\(name)(\($0).self, \(owner).self)" } ?? "\(name)(\(owner).self)"
     let peerName = derivedIdentifier(from: name, prefix: "_assertTypesConformance_")
     return [

package/apple/Sources/ExpoModulesMacros/RecordMacro.swift

@@ -43,14 +43,17 @@ import SwiftSyntaxMacros
 /// (`from(dictionary:)` / `toDictionary(appContext:)`), since `JavaScriptCodable` only converts JS
 /// values, not native `Any`. Both spell types as `public` symbols so the synthesized code compiles inside
 /// user modules without any internal core symbols. Every property type must therefore conform to both
-/// `AnyArgument` and `JavaScriptDecodable & JavaScriptEncodable`.
+/// `AnyArgument` and `JavaScriptDecodable & JavaScriptEncodable`. The conformance assertion checks only
+/// the JS codable protocols; the compiler reports a missing `AnyArgument` at the `getDynamicType()`
+/// call.
 ///
 /// A property whose type mentions `Any` (`Any?`, `[String: Any]?`, `[String: [Any]]`, …) can't conform to
-/// the JS codable protocols. On the JS-value paths it converts through the `JavaScriptValue` free-form
-/// methods instead: `decodeAny`/`decodeAnyArray`/`decodeAnyDictionary` and the matching `encodeAny…`
-/// for `Any`, `[Any]` and `[String: Any]` (optional or not), and the generic `decodeAny(_:as:in:)` /
-/// `encodeAny(_:in:)` for any other type. Such a property only needs `AnyArgument` for the dictionary
-/// paths, and a bare `Any` needs nothing, since the dictionary paths pass it through unchanged.
+/// the JS codable protocols, so it isn't asserted. On the JS-value paths it converts through the
+/// `JavaScriptValue` free-form methods instead: `decodeAny`/`decodeAnyArray`/`decodeAnyDictionary` and
+/// the matching `encodeAny…` for `Any`, `[Any]` and `[String: Any]` (optional or not), and the generic
+/// `decodeAny(_:as:in:)` / `encodeAny(_:in:)` for any other type. Such a property only needs
+/// `AnyArgument` for the dictionary paths, and a bare `Any` needs nothing, since the dictionary paths
+/// pass it through unchanged.
 ///
 /// A record class must be `final` and have no inheritance clause. The synthesized factories construct
 /// `Self` through the memberwise init, which only a final class can do without a `required` init, and
@@ -87,23 +90,16 @@ public struct RecordMacro: MemberMacro, ExtensionMacro {
 
     var members: [DeclSyntax] = []
 
-    // A single never-called member that makes the compiler verify each property type is convertible
-    // both ways (the JS-value paths call `decode`/`encode`; the native-`Any` dictionary paths call
-    // the dynamic-type API). Each property keeps its own named assertion inside, so the compiler's
-    // conformance diagnostic names the offending property (see `typeConformanceAssertions`). Emitted
-    // first so that, for a non-conforming type, this clear "requires that '…' conform to '…'" error
-    // is reported ahead of the noisier "no member 'decode'"/"getDynamicType" errors from the
-    // conversion code below.
+    // A single never-called member that makes the compiler verify each property type converts both
+    // ways (the JS-value paths call `decode`/`encode`). Each property keeps its own named assertion
+    // inside, so the compiler's conformance diagnostic names the offending property (see
+    // `typeConformanceAssertions`). Emitted first so that, for a non-conforming type, this clear
+    // "requires that '…' conform to '…'" error is reported ahead of the noisier "no member 'decode'"
+    // errors from the conversion code below.
     let assertions = properties.map { property in
-      // A bare `Any` can't conform to anything and needs no conformance, since every path converts it
-      // without one.
-      ConformanceAssertion(
-        name: property.name,
-        types: property.freeForm?.isBareAny == true ? [] : [property.type],
-        constraint: property.freeForm != nil ? jsConvertibleProtocolName : nil
-      )
+      ConformanceAssertion(name: property.name, types: property.freeForm == nil ? [property.type] : [])
     }
-    if let assertionMember = typeConformanceAssertions(for: assertions, constraint: recordFieldProtocolName) {
+    if let assertionMember = typeConformanceAssertions(for: assertions, constraint: javaScriptCodableProtocolName) {
       members.append(assertionMember)
     }
 

package/apple/Sources/ExpoModulesMacros/TypeConformanceAssertion.swift

@@ -1,9 +1,8 @@
 import SwiftSyntax
 import SwiftSyntaxBuilder
 
-/// The protocol that every type crossing the JS boundary must conform to. Centralized here so the
-/// eventual rename (this is a placeholder name) is a single edit, and shared by the macros whose
-/// generated conversions go through the dynamic-type API (`@Record`, `@Event`).
+/// The protocol of the 1.0 dynamic-type API (`getDynamicType()`). `@Event` asserts payload types
+/// against it.
 internal let jsConvertibleProtocolName = "AnyArgument"
 
 /// The constraint a `@JS` boundary type must satisfy, by direction: an argument (and a settable
@@ -15,23 +14,10 @@ internal let jsConvertibleProtocolName = "AnyArgument"
 internal let javaScriptDecodableProtocolName = "JavaScriptDecodable"
 internal let javaScriptEncodableProtocolName = "JavaScriptEncodable"
 
-/// The constraint a `@Record` property type must satisfy: it must be both `AnyArgument` (the
-/// `from(dictionary:)` / `toDictionary(appContext:)` paths still convert native `Any` through the
-/// dynamic-type API) and `JavaScriptDecodable & JavaScriptEncodable` (the `from(object:)` /
-/// `toObject(appContext:)` paths convert JS values through `decode`/`encode`). A record field has to
-/// support both directions, so the assertion requires the intersection.
-///
-/// The exception is a property whose type mentions `Any` (`[String: Any]?`, `[Any]`, …): it can't
-/// conform to the JS codable protocols, so the JS-value paths convert it through the `JavaScriptValue`
-/// free-form methods, and it's asserted against `jsConvertibleProtocolName` alone for the dictionary
-/// paths.
-internal let recordFieldProtocolName = "AnyArgument & JavaScriptDecodable & JavaScriptEncodable"
-
-/// The constraint a `@Union` case payload type must satisfy: the union decodes by trying each payload's
-/// `decode` and encodes through the matching payload's `encode`, so every alternative must convert in
-/// both directions. Unlike a `@Record` field, a union never crosses the native-`Any` dictionary path, so
-/// `AnyArgument` is not required.
-internal let unionPayloadProtocolName = "JavaScriptDecodable & JavaScriptEncodable"
+/// The constraint a `@Record` property type and a `@Union` case payload type must satisfy. A record
+/// decodes and encodes each property, and a union decodes by trying each payload's `decode` and
+/// encodes through the matching payload's `encode`, so both convert in both directions.
+internal let javaScriptCodableProtocolName = "JavaScriptDecodable & JavaScriptEncodable"
 
 /// The protocol a type must conform to for `self.emit(event:…)` to resolve; core conforms
 /// `BaseModule` and `SharedObject` to it. Asserted by `@Event` so attaching it to a type that can't
@@ -52,20 +38,15 @@ internal struct ConformanceAssertion {
   /// Declared types as written. Composed types (`[Int]`, `String?`, …) are kept verbatim — their
   /// conditional conformances transitively constrain the elements.
   let types: [String]
-  /// The constraint for this member's types, overriding the one passed to `typeConformanceAssertions`.
-  /// `@Record` uses it to assert only `AnyArgument` for a property that mentions `Any`, which can't be
-  /// `JavaScriptDecodable & JavaScriptEncodable`.
-  var constraint: String? = nil
 }
 
 /// 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
 /// `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 `A0…` generic
-/// parameter per asserted argument and a single `Return` parameter for the value, called once with
-/// every type's metatype; naming the helper after the member puts the member in the compiler's
-/// diagnostic, and the per-slot constraint reports the offending type against the protocol for *its*
-/// direction.
+/// 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.
 ///
 /// `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.
@@ -87,31 +68,18 @@ internal func directionalConformanceAssertion(
     return nil
   }
 
-  // Build the generic parameter list and the matching call arguments in lockstep: one `A0…` slot
-  // constrained `JavaScriptDecodable` per argument, one `E0…` slot constrained `JavaScriptEncodable`
-  // per closure-argument parameter, and a single `Return` slot constrained `JavaScriptEncodable` for
-  // the return/getter value (there's only ever one, so it isn't indexed). Every slot suppresses
-  // `Copyable`, so a non-copyable boundary type such as `JavaScriptValue` can fill it.
-  var parameters: [String] = []
-  var typeParameters: [String] = []
-  var arguments: [String] = []
-  for (index, type) in decodables.enumerated() {
-    parameters.append("A\(index): \(javaScriptDecodableProtocolName) & ~Copyable")
-    typeParameters.append("_: A\(index).Type")
-    arguments.append("\(type).self")
-  }
-  for (index, type) in callbackArguments.enumerated() {
-    parameters.append("E\(index): \(javaScriptEncodableProtocolName) & ~Copyable")
-    typeParameters.append("_: E\(index).Type")
-    arguments.append("\(type).self")
-  }
-  if let encodable {
-    parameters.append("Return: \(javaScriptEncodableProtocolName) & ~Copyable")
-    typeParameters.append("_: Return.Type")
-    arguments.append("\(encodable).self")
-  }
-
-  let helper = "func \(name)<\(parameters.joined(separator: ", "))>(\(typeParameters.joined(separator: ", "))) {}"
+  // 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_")
@@ -132,9 +100,9 @@ internal func directionalConformanceAssertion(
 /// caller emits nothing.
 internal func typeConformanceAssertions(
   for assertions: [ConformanceAssertion],
-  constraint: String = jsConvertibleProtocolName
+  constraint: String
 ) -> DeclSyntax? {
-  let bodies = assertions.compactMap { conformanceAssertionBody($0, constraint: $0.constraint ?? constraint) }
+  let bodies = assertions.compactMap { conformanceAssertionBody($0, constraint: constraint) }
   guard !bodies.isEmpty else {
     return nil
   }
@@ -186,25 +154,33 @@ private func setsConform(to constraint: String) -> Bool {
   }
 }
 
-/// The assertion's body fragment: a nested generic helper named after the member, plus one call per
-/// distinct type that needs an assertion. Nesting the helper keeps the constraint entirely local — no
-/// shared symbol, nothing to collide, nothing left in the type's namespace — and naming it after the
-/// member puts the member's name in the compiler's conformance diagnostic. Returns `nil` when every
-/// type was known to conform or the list was empty.
+/// The assertion's body fragment: a nested helper named after the member, plus one call per distinct
+/// type that needs an assertion. Nesting the helper keeps the constraint entirely local — no shared
+/// symbol, nothing to collide, nothing left in the type's namespace — and naming it after the member
+/// puts the member's name in the compiler's conformance diagnostic. Returns `nil` when every type was
+/// known to conform or the list was empty.
 private func conformanceAssertionBody(
   _ assertion: ConformanceAssertion,
-  constraint: String = jsConvertibleProtocolName
+  constraint: String
 ) -> String? {
   let distinct = distinctAssertableTypes(assertion.types, constraint: constraint)
   guard !distinct.isEmpty else {
     return nil
   }
 
-  var lines = ["func \(assertion.name)<T: \(constraint)>(_: T.Type) {}"]
+  var lines = ["func \(assertion.name)(\(opaqueMetatypeParameter(constraint: constraint))) {}"]
   lines.append(contentsOf: distinct.map { "\(assertion.name)(\($0).self)" })
   return lines.joined(separator: "\n")
 }
 
+/// An unlabeled parameter that takes the metatype of any type satisfying `constraint`, for an
+/// assertion helper.
+internal func opaqueMetatypeParameter(constraint: String) -> String {
+  // A named generic parameter would shadow a generic parameter of the same name on an enclosing
+  // type, which is an error. An opaque parameter declares no name.
+  return "_: (some \(constraint)).Type"
+}
+
 /// 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] {

package/apple/Sources/ExpoModulesMacros/UnionMacro.swift

@@ -57,7 +57,7 @@ public struct UnionMacro: MemberMacro, ExtensionMacro {
     // reports the clear "requires that '…' conform to …" error ahead of the noisier "no member
     // 'decode'"/"'encode'" errors from the conversion code below.
     let assertions = union.cases.map { ConformanceAssertion(name: $0.name, types: [$0.payloadType]) }
-    if let assertionMember = typeConformanceAssertions(for: assertions, constraint: unionPayloadProtocolName) {
+    if let assertionMember = typeConformanceAssertions(for: assertions, constraint: javaScriptCodableProtocolName) {
       members.append(assertionMember)
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.23.0",
+  "version": "0.23.1",
   "description": "Swift macro plugin for Expo modules",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -26,9 +26,9 @@
     "typescript": "^5.4.0"
   },
   "optionalDependencies": {
-    "@expo/modules-macros-linux-arm64": "0.23.0",
-    "@expo/modules-macros-linux-x64": "0.23.0",
-    "@expo/modules-macros-win32-arm64": "0.23.0",
-    "@expo/modules-macros-win32-x64": "0.23.0"
+    "@expo/modules-macros-linux-arm64": "0.23.1",
+    "@expo/modules-macros-linux-x64": "0.23.1",
+    "@expo/modules-macros-win32-arm64": "0.23.1",
+    "@expo/modules-macros-win32-x64": "0.23.1"
   }
 }