expo-modules-macros 0.19.1 → 0.21.0

package/apple/Sources/ExpoModulesMacros/EventMacro.swift

@@ -122,7 +122,7 @@ private struct EventMember {
 /// Validates the declaration `@Event` is attached to and reads the event out of it. The checks
 /// mirror what the expansion relies on: a single-binding instance `var` (the macro synthesizes a
 /// computed getter, so `let`, accessors, and initializers are all incompatible) whose type is a
-/// function type returning `Void` with at most one payload parameter.
+/// function type returning `Void` with at most one payload parameter, which holds no closure.
 private func validatedEvent(
   of node: AttributeSyntax,
   on declaration: some DeclSyntaxProtocol
@@ -169,6 +169,17 @@ private func validatedEvent(
     throw MacroExpansionErrorMessage(
       "@Event function type takes at most one payload parameter; combine multiple values into a single record")
   }
+  // The payload is encoded to JavaScript, and a native closure can't be encoded.
+  if let payloadClosure = functionType.parameters.first.flatMap({ firstFunctionType(in: $0.type) }) {
+    throw DiagnosticsError(diagnostics: [
+      Diagnostic(
+        node: payloadClosure,
+        message: EventDiagnosticMessage(
+          "@Event payload can't hold a closure: the payload is encoded to JavaScript, and a native closure can't be encoded.",
+          id: "event-closure-payload"
+        ))
+    ])
+  }
 
   let swiftName = identifier.identifier.text
   return EventMember(

package/apple/Sources/ExpoModulesMacros/ExpoModuleMacro.swift

@@ -73,6 +73,8 @@ public struct ExpoModuleMacro: MemberMacro {
       }
     }
 
+    diagnoseJSNameCollisions(functions: functions, properties: properties, in: context)
+
     let body: String
     if entries.isEmpty {
       body = "  return []"

package/apple/Sources/ExpoModulesMacros/JSNameCollisions.swift

@@ -0,0 +1,64 @@
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxMacros
+
+/// Reports each `@JS` member whose JavaScript name an earlier `@JS` member already binds on the same
+/// JavaScript object. Pass the members of one object only: a shared object's static members bind onto
+/// the constructor and its instance members onto the prototype, so the two sets are checked separately.
+internal func diagnoseJSNameCollisions(
+  functions: [JSFunction],
+  properties: [JSProperty],
+  in context: some MacroExpansionContext
+) {
+  // Each member binds with its own `setProperty` or `defineProperty` call, so of two members with one
+  // name, JavaScript would reach only one. Members are compared in source order, so the error lands on
+  // every member after the first, whichever kind each one is.
+  let members =
+    functions.map { BoundMember(jsName: $0.jsName, kind: "function", nameToken: $0.nameToken) }
+    + properties.map { BoundMember(jsName: $0.jsName, kind: "property", nameToken: $0.nameToken) }
+  var firstMembers: [String: BoundMember] = [:]
+
+  for member in members.sorted(by: { $0.nameToken.position < $1.nameToken.position }) {
+    guard let first = firstMembers[member.jsName] else {
+      firstMembers[member.jsName] = member
+      continue
+    }
+    context.diagnose(
+      Diagnostic(
+        node: member.nameToken,
+        message: JSNameCollisionMessage(
+          "The JavaScript name '\(member.jsName)' is already bound by an earlier @JS \(first.kind). A JavaScript object holds one member per name, so JavaScript could reach only one of them. Give one of them another name with @JS(\"...\")."
+        ),
+        notes: [
+          Note(
+            node: Syntax(first.nameToken),
+            message: JSNameCollisionNote("'\(member.jsName)' is first bound here"))
+        ]
+      ))
+  }
+}
+
+private struct BoundMember {
+  let jsName: String
+  let kind: String
+  let nameToken: TokenSyntax
+}
+
+private struct JSNameCollisionMessage: DiagnosticMessage {
+  let message: String
+  let diagnosticID = MessageID(domain: "ExpoModulesMacros", id: "js-name-collision")
+  let severity: DiagnosticSeverity = .error
+
+  init(_ message: String) {
+    self.message = message
+  }
+}
+
+private struct JSNameCollisionNote: NoteMessage {
+  let message: String
+  let noteID = MessageID(domain: "ExpoModulesMacros", id: "js-name-collision-first")
+
+  init(_ message: String) {
+    self.message = message
+  }
+}

package/apple/Sources/ExpoModulesMacros/MacroHelpers.swift

@@ -441,7 +441,8 @@ internal func collectProperties(
       valueType: valueType,
       // A literal-inferred type never mentions `Any`, so only an explicit annotation can be free-form.
       freeForm: binding.typeAnnotation.flatMap { freeFormConversion(of: $0.type) },
-      isSettable: isVar && bindingIsSettable(binding)
+      isSettable: isVar && bindingIsSettable(binding),
+      nameToken: ident.identifier
     )
   }
 }

package/apple/Sources/ExpoModulesMacros/RecordMacro.swift

@@ -1,3 +1,4 @@
+import SwiftDiagnostics
 import SwiftSyntax
 import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
@@ -8,14 +9,16 @@ import SwiftSyntaxMacros
  needed — and synthesizes the conversion surface from the property's static type:
 
  - an explicit memberwise `init` (so the static factories have a single construction point),
- - `from(object:appContext:)` — the fast path, reading each property straight off a
-   `JavaScriptObject`,
- - `from(dictionary:appContext:)` — reading each property from a `[String: Any]` dictionary,
- - `toDictionary(appContext:)` and `toObject(appContext:)` for the write side.
+ - `decode(_:in:)` and `encode(_:in:)` — the fast paths, reading each property straight off a JS
+   object and writing it straight into one,
+ - `from(object:appContext:)` and `toObject(appContext:)`, which forward to `decode` and `encode`,
+ - `from(dictionary:appContext:)` and `toDictionary(appContext:)` — converting each property from and
+   to a `[String: Any]` dictionary.
 
- The type is auto-conformed to `Record` (a core protocol whose requirements are exactly this
- surface); the synthesized methods override `Record`'s reflection-based defaults. Author-facing
- shape — no conformance to spell out:
+ The type is auto-conformed to `Record` (a core protocol whose requirements are this surface); the
+ synthesized methods override `Record`'s reflection-based defaults, and the synthesized `decode` and
+ `encode` replace its default `JavaScriptCodable` witnesses. Author-facing shape — no conformance to
+ spell out:
 
    @Record
    struct Options {
@@ -30,7 +33,7 @@ import SwiftSyntaxMacros
  default is required (the factories throw when the source omits it).
 
  The JS-value paths convert through `JavaScriptDecodable.decode` / `JavaScriptEncodable.encode`
- (`from(object:)` / `toObject(appContext:)`); the native-`Any` dictionary paths still go through the
+ (`decode(_:in:)` / `encode(_:in:)`); the native-`Any` dictionary paths still go through the
  public dynamic-type API — `T.getDynamicType()` plus `cast(_:appContext:)` / `convertToJS(_:appContext:)`
  (`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
@@ -54,10 +57,15 @@ public struct RecordMacro: MemberMacro, ExtensionMacro {
     conformingTo protocols: [TypeSyntax],
     in context: some MacroExpansionContext
   ) throws -> [DeclSyntax] {
-    let isClass = declaration.is(ClassDeclSyntax.self)
-    guard declaration.is(StructDeclSyntax.self) || isClass else {
+    let typeName: String
+    if let structDecl = declaration.as(StructDeclSyntax.self) {
+      typeName = structDecl.name.text
+    } else if let classDecl = declaration.as(ClassDeclSyntax.self) {
+      typeName = classDecl.name.text
+    } else {
       throw MacroExpansionErrorMessage("@Record can only be applied to a struct or class")
     }
+    let isClass = declaration.is(ClassDeclSyntax.self)
 
     let properties = try recordProperties(of: declaration)
     let inheritsRecord = isClass && classHasInheritance(declaration)
@@ -98,10 +106,13 @@ public struct RecordMacro: MemberMacro, ExtensionMacro {
     if !existingInitLabels.contains(properties.map { $0.key }) {
       members.append(memberwiseInit(properties: properties))
     }
-    members.append(fromJSObjectFactory(properties: properties))
+    members.append(fromJSObjectFactory(properties: properties, inheritsRecord: inheritsRecord))
     members.append(fromDictionaryFactory(properties: properties))
     members.append(toDictionaryMethod(properties: properties, inheritsRecord: inheritsRecord))
     members.append(toObjectMethod(properties: properties, inheritsRecord: inheritsRecord))
+    if !inheritsRecord {
+      members.append(contentsOf: javaScriptCodableWitnesses(properties: properties, typeName: typeName))
+    }
     return members
   }
 
@@ -226,8 +237,21 @@ private func recordProperties(
           "@Record properties must declare an explicit type — '\(ident.identifier.text)' has none"
         )
       }
-      // A literal-inferred type never mentions `Any`, so only an explicit annotation can be free-form.
+      // A literal-inferred type never mentions `Any` or a closure, so only an explicit annotation can.
       let annotatedType = binding.typeAnnotation?.type
+      // A closure has no `decode`, `encode` or dynamic type, and the record converts every property both
+      // ways. A JavaScript function decodes into a native closure only as a `@JS` argument; a native
+      // closure can't be encoded.
+      if let functionType = annotatedType.flatMap(firstFunctionType(in:)) {
+        throw DiagnosticsError(diagnostics: [
+          Diagnostic(
+            node: functionType,
+            message: RecordDiagnosticMessage(
+              "@Record property '\(ident.identifier.text)' can't hold a closure: a record property is also encoded to JavaScript, and a native closure can't be encoded",
+              id: "record-closure-property"
+            ))
+        ])
+      }
       let freeForm = try annotatedType.flatMap { annotatedType -> FreeFormConversion? in
         guard mentionsFreeFormAny(annotatedType) else {
           return nil
@@ -312,15 +336,24 @@ private func memberwiseInit(properties: [RecordProperty]) -> DeclSyntax {
 }
 
 /**
- `from(object:appContext:)` — reads each property off the `JavaScriptObject` into a local,
- then constructs the record through the memberwise init. Required properties throw when
- undefined; defaulted properties fall back to the property's declared default (inlined) when
- undefined; optional properties become `nil` when undefined/null. Each property is decoded with
- `JavaScriptDecodable.decode`, so the factory binds the `runtime` from the app context once and
- threads it to every read. A free-form property decodes through the `JavaScriptValue` free-form
- methods, which take the runtime too.
+ `from(object:appContext:)`. A record forwards to its own unowned `decode(_:in:)` witness (see
+ `javaScriptCodableWitnesses`), which holds the property reads. A subclass, which gets no witnesses,
+ reads the properties here, in the app context's runtime.
  */
-private func fromJSObjectFactory(properties: [RecordProperty]) -> DeclSyntax {
+private func fromJSObjectFactory(properties: [RecordProperty], inheritsRecord: Bool) -> DeclSyntax {
+  guard inheritsRecord else {
+    // The record declares only the unowned `decode`, so the call lends the value unowned. With an owning
+    // value it would reach an owning `decode` default, and `Record`'s converts through this factory.
+    return """
+      @JavaScriptActor
+      public static func from(object: borrowing JavaScriptObject, appContext: AppContext) throws -> Self {
+        let runtime = try appContext.runtime
+        return try object.asValue().withUnownedValue(in: runtime) { unownedValue in
+          return try decode(unownedValue, in: runtime)
+        }
+      }
+      """
+  }
   var lines: [String] = []
   // Only bind the runtime when there's a property to decode — an empty record's factory would
   // otherwise leave it unused.
@@ -328,11 +361,10 @@ private func fromJSObjectFactory(properties: [RecordProperty]) -> DeclSyntax {
     lines.append("  let runtime = try appContext.runtime")
   }
   lines.append(factoryBody(properties: properties, readLines: jsObjectReadLines(properties: properties)))
-  let body = lines.joined(separator: "\n")
   return """
     @JavaScriptActor
     public static func from(object: borrowing JavaScriptObject, appContext: AppContext) throws -> Self {
-    \(raw: body)
+    \(raw: lines.joined(separator: "\n"))
     }
     """
 }
@@ -359,69 +391,68 @@ private func fromDictionaryFactory(properties: [RecordProperty]) -> DeclSyntax {
 private func factoryBody(properties: [RecordProperty], readLines: [String]) -> String {
   var lines: [String] = []
   lines.append(contentsOf: readLines)
-  let initArgs = properties.map { "\($0.name): \($0.name)" }.joined(separator: ", ")
+  let initArgs = properties.enumerated().map { "\($1.name): \(fieldLocal($0))" }.joined(separator: ", ")
   lines.append("  return Self(\(initArgs))")
   return lines.joined(separator: "\n")
 }
 
-/// Per-property read statements for the JS-object factory, each producing a `let <name>` by decoding
-/// the JS value with `JavaScriptDecodable.decode` (recovering the app context from `runtime` itself).
-/// A free-form property decodes through the `JavaScriptValue` free-form methods instead; for an optional
-/// free-form shape, `undefined`/`null` map to `nil` around the call, just like `Optional.decode`.
+/// The local that holds the value of the property at `index` in a factory. It's numbered rather than
+/// named after the property, so no property can collide with it or with the factory's other parameters
+/// and locals (`object`, `runtime`, `dictionary`, `appContext`).
+private func fieldLocal(_ index: Int) -> String {
+  return "field\(index)"
+}
+
+/// Per-property read statements, each producing a `let field<index>` from the property of the JS object
+/// named `object`. The property is lent to a closure as a `JavaScriptUnownedValue` and decoded there the
+/// same way as a `@JS` argument (see `decodeCall`), so the read doesn't allocate a `JavaScriptValue`.
+/// Only the generic free-form decode copies the value into one.
 private func jsObjectReadLines(properties: [RecordProperty]) -> [String] {
   var lines: [String] = []
-  for property in properties {
+  for (index, property) in properties.enumerated() {
     let valueVar = derivedIdentifier(from: property.name, suffix: "JSValue")
-    let exprType = expressionType(property.type)
-    let decode: String
-    switch property.freeForm {
-    case .shape(let decodeMethod, _, let isOptional, _):
-      let call = "try JavaScriptValue.\(decodeMethod)(\(valueVar), in: runtime)"
-      decode = isOptional ? "\(valueVar).isUndefined() || \(valueVar).isNull() ? nil : \(call)" : call
-    case .generic:
-      decode = "try JavaScriptValue.decodeAny(\(valueVar), as: \(exprType).self, in: runtime)"
-    case nil:
-      decode = "try \(exprType).decode(\(valueVar), in: runtime)"
-    }
-    lines.append("  let \(valueVar) = object.getProperty(\"\(property.key)\")")
+    let decode = "try \(decodeCall(property.type, freeForm: property.freeForm, from: valueVar))"
+    lines.append("  let \(fieldLocal(index)) = try object.withUnownedProperty(\"\(property.key)\") { \(valueVar) in")
     if property.isRequired {
-      lines.append("  guard !\(valueVar).isUndefined() else {")
-      lines.append("    throw RecordPropertyRequiredException(\"\(property.key)\")")
-      lines.append("  }")
-      lines.append("  let \(property.name) = \(decode)")
+      lines.append("    guard !\(valueVar).isUndefined() else {")
+      lines.append("      throw RecordPropertyRequiredException(\"\(property.key)\")")
+      lines.append("    }")
+      lines.append("    return \(decode)")
     } else if property.isOptional {
-      // `Optional.decode` (and the free-form reads above) already map `undefined`/`null` to `nil`, so
-      // the read is a plain decode.
-      lines.append("  let \(property.name) = \(decode)")
+      // `Optional.decode` (and the free-form decodes of optional shapes) already map `undefined` and
+      // `null` to `nil`, so the read is a plain decode.
+      lines.append("    return \(decode)")
     } else {
-      lines.append("  let \(property.name) = \(valueVar).isUndefined() ? \(property.defaultValue!) : \(decode)")
+      lines.append("    return \(valueVar).isUndefined() ? \(property.defaultValue!) : \(decode)")
     }
+    lines.append("  }")
   }
   return lines
 }
 
-/// Per-property read statements for the dictionary factory, each producing a `let <name>`. A bare `Any`
-/// property has no dynamic type to cast through, and the dictionary value already is an `Any`, so it's
-/// read unchanged.
+/// Per-property read statements for the dictionary factory, each producing a `let field<index>` from the
+/// raw dictionary value in `entry<index>`. A bare `Any` property has no dynamic type to cast through, and
+/// the dictionary value already is an `Any`, so it's read unchanged.
 private func dictionaryReadLines(properties: [RecordProperty]) -> [String] {
   var lines: [String] = []
-  for property in properties {
-    let valueVar = derivedIdentifier(from: property.name, suffix: "Value")
+  for (index, property) in properties.enumerated() {
+    let field = fieldLocal(index)
+    let entry = "entry\(index)"
     let exprType = expressionType(property.type)
     let isBareAny = property.freeForm?.isBareAny == true
     let cast = isBareAny
-      ? valueVar
-      : "try \(exprType).getDynamicType().cast(\(valueVar), appContext: appContext) as! \(exprType)"
-    lines.append("  let \(valueVar) = dictionary[\"\(property.key)\"]")
+      ? entry
+      : "try \(exprType).getDynamicType().cast(\(entry), appContext: appContext) as! \(exprType)"
+    lines.append("  let \(entry) = dictionary[\"\(property.key)\"]")
     if property.isRequired {
-      lines.append("  guard let \(valueVar) else {")
+      lines.append("  guard let \(entry) else {")
       lines.append("    throw RecordPropertyRequiredException(\"\(property.key)\")")
       lines.append("  }")
-      lines.append("  let \(property.name) = \(cast)")
+      lines.append("  let \(field) = \(cast)")
     } else if property.isOptional {
-      lines.append("  let \(property.name): \(property.type) = (\(valueVar) == nil || \(valueVar)! is NSNull) ? nil : \(cast)")
+      lines.append("  let \(field): \(property.type) = (\(entry) == nil || \(entry)! is NSNull) ? nil : \(cast)")
     } else {
-      lines.append("  let \(property.name) = \(valueVar) == nil ? \(property.defaultValue!) : \(isBareAny ? valueVar + "!" : cast)")
+      lines.append("  let \(field) = \(entry) == nil ? \(property.defaultValue!) : \(isBareAny ? entry + "!" : cast)")
     }
   }
   return lines
@@ -460,51 +491,94 @@ private func toDictionaryMethod(properties: [RecordProperty], inheritsRecord: Bo
 }
 
 /**
- `toObject(appContext:)` — builds a `JavaScriptObject` directly, encoding each property with
- `JavaScriptEncodable.encode` (or, for a free-form property, the matching `JavaScriptValue` free-form
- method). The fast write path mirroring `from(object:)`. The `runtime` is bound
- from the app context once and threaded to every write. Subclasses chain to `super` so inherited
- properties are written first.
+ `toObject(appContext:)`. A record forwards to its own `encode(_:in:)` witness (see
+ `javaScriptCodableWitnesses`), which holds the property writes. A subclass, which gets no witnesses,
+ overrides it to chain to `super`, so inherited properties are written first, and writes its own
+ properties in the app context's runtime.
  */
 private func toObjectMethod(properties: [RecordProperty], inheritsRecord: Bool) -> DeclSyntax {
-  let overrideKeyword = inheritsRecord ? "override " : ""
+  guard inheritsRecord else {
+    return """
+      @JavaScriptActor
+      public func toObject(appContext: AppContext) throws -> JavaScriptObject {
+        return try Self.encode(self, in: appContext.runtime).asObject()
+      }
+      """
+  }
   var lines: [String] = []
-  // The base case needs the runtime to create the object; the inheriting case only needs it when
-  // there's a property to encode (it chains to `super` for the object itself). Binding it when unused
-  // would warn.
-  if !inheritsRecord || !properties.isEmpty {
+  // The runtime is only needed when there's a property to encode (the object itself comes from
+  // `super`). Binding it when unused would warn.
+  if !properties.isEmpty {
     lines.append("  let runtime = try appContext.runtime")
   }
-  if inheritsRecord {
-    lines.append("  let object = try super.toObject(appContext: appContext)")
-  } else {
-    lines.append("  let object = runtime.createObject()")
-  }
-  for property in properties {
-    let exprType = expressionType(property.type)
+  lines.append("  let object = try super.toObject(appContext: appContext)")
+  lines.append(contentsOf: objectWriteLines(properties: properties, of: "self"))
+  lines.append("  return object")
+  return """
+    @JavaScriptActor
+    public override func toObject(appContext: AppContext) throws -> JavaScriptObject {
+    \(raw: lines.joined(separator: "\n"))
+    }
+    """
+}
+
+/**
+ The record's own `JavaScriptDecodable` and `JavaScriptEncodable` witnesses, which convert in the
+ runtime they're given. Without them the record would convert through `Record`'s default witnesses,
+ which recover the app context from the runtime and convert in the app context's runtime.
+
+ `decode` reads each property off the JS object into a local, then constructs the record through the
+ memberwise init. Required properties throw when undefined; defaulted properties fall back to the
+ 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.
+ */
+private func javaScriptCodableWitnesses(properties: [RecordProperty], typeName: String) -> [DeclSyntax] {
+  // An empty record still decodes only from an object, but has no property to read off it.
+  let objectLine = properties.isEmpty
+    ? "  _ = try value.asObject(in: runtime)"
+    : "  let object = try value.asObject(in: runtime)"
+  let decodeBody = objectLine + "\n" + factoryBody(properties: properties, readLines: jsObjectReadLines(properties: properties))
+  let encodeLines = ["  let object = runtime.createObject()"]
+    + objectWriteLines(properties: properties, of: "value")
+    + ["  return object.asValue()"]
+  return [
+    """
+    @JavaScriptActor
+    public static func decode(_ value: borrowing JavaScriptUnownedValue, in runtime: borrowing JavaScriptRuntime) throws -> Self {
+    \(raw: decodeBody)
+    }
+    """,
+    """
+    @JavaScriptActor
+    public static func encode(_ value: \(raw: typeName), in runtime: borrowing JavaScriptRuntime) throws -> JavaScriptValue {
+    \(raw: encodeLines.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.
+private func objectWriteLines(properties: [RecordProperty], of record: String) -> [String] {
+  return properties.map { property in
+    let value = "\(record).\(property.name)"
     let encode: String
     switch property.freeForm {
     case .shape(_, let encodeMethod, let isOptional, _):
       encode = isOptional
-        ? "self.\(property.name) == nil ? .null() : try JavaScriptValue.\(encodeMethod)(self.\(property.name)!, in: runtime)"
-        : "try JavaScriptValue.\(encodeMethod)(self.\(property.name), in: runtime)"
+        ? "\(value) == nil ? .null() : try JavaScriptValue.\(encodeMethod)(\(value)!, in: runtime)"
+        : "try JavaScriptValue.\(encodeMethod)(\(value), in: runtime)"
     case .generic:
       // The explicit `as Any` keeps an optional property from warning about its implicit coercion.
-      encode = "try JavaScriptValue.encodeAny(self.\(property.name) as Any, in: runtime)"
+      encode = "try JavaScriptValue.encodeAny(\(value) as Any, in: runtime)"
     case nil:
-      encode = "try \(exprType).encode(self.\(property.name), in: runtime)"
+      encode = "try \(expressionType(property.type)).encode(\(value), in: runtime)"
     }
-    lines.append("  object.setProperty(\"\(property.key)\", value: \(encode))")
+    return "  object.setProperty(\"\(property.key)\", value: \(encode))"
   }
-  lines.append("  return object")
-  let body = lines.joined(separator: "\n")
-
-  return """
-    @JavaScriptActor
-    public \(raw: overrideKeyword)func toObject(appContext: AppContext) throws -> JavaScriptObject {
-    \(raw: body)
-    }
-    """
 }
 
 // MARK: - Helpers
@@ -545,3 +619,14 @@ private func classHasInheritance(_ declaration: some DeclGroupSyntax) -> Bool {
   }
   return true
 }
+
+private struct RecordDiagnosticMessage: DiagnosticMessage {
+  let message: String
+  let diagnosticID: MessageID
+  let severity: DiagnosticSeverity = .error
+
+  init(_ message: String, id: String) {
+    self.message = message
+    self.diagnosticID = MessageID(domain: "ExpoModulesMacros", id: id)
+  }
+}

package/apple/Sources/ExpoModulesMacros/SharedObjectMacro.swift

@@ -93,6 +93,9 @@ public struct SharedObjectMacro: MemberMacro {
       }
     }
 
+    diagnoseJSNameCollisions(functions: instanceFunctions, properties: instanceProperties, in: context)
+    diagnoseJSNameCollisions(functions: staticFunctions, properties: staticProperties, in: context)
+
     let lines = entries.map { "    \($0)" }.joined(separator: "\n")
     let body = entries.isEmpty
       ? "  return Class(\"\(jsName)\", \(typeName).self) {\n  }"

package/apple/Sources/ExpoModulesMacros/UnionMacro.swift

@@ -141,7 +141,8 @@ private struct UnionCase {
 
 /// Reads and validates the union off the attached declaration. Every check is a compile error located
 /// on the offending node: the macro must be on a non-generic `enum` with at least one case, and every
-/// case must carry exactly one associated value, its payload type distinct from every earlier case's.
+/// case must carry exactly one associated value that holds no closure, its payload type distinct from
+/// every earlier case's.
 private func validatedUnion(of declaration: some DeclGroupSyntax) throws -> UnionType {
   guard let enumDecl = declaration.as(EnumDeclSyntax.self) else {
     throw MacroExpansionErrorMessage("@Union can only be applied to an enum")
@@ -197,6 +198,18 @@ private func validatedUnion(of declaration: some DeclGroupSyntax) throws -> Unio
         continue
       }
 
+      // A payload is decoded from and encoded to JavaScript, and a native closure can't be encoded.
+      if let payloadClosure = firstFunctionType(in: parameter.type) {
+        diagnostics.append(
+          Diagnostic(
+            node: payloadClosure,
+            message: UnionDiagnosticMessage(
+              "@Union case '\(name)' can't carry a closure: the payload is also encoded to JavaScript, and a native closure can't be encoded.",
+              id: "union-closure-payload"
+            )))
+        continue
+      }
+
       let payloadType = parameter.type.trimmedDescription
       // Alternatives decode in declaration order and the first success wins, so a case whose payload
       // type repeats an earlier case's is unreachable: an exact-spelling duplicate is an error. (An