expo-modules-macros 0.21.0 → 0.23.0

package/apple/Sources/ExpoModulesMacros/DecorateModuleBuilder.swift

@@ -13,18 +13,27 @@ import SwiftSyntax
 /// unwrap, arity guard, argument decode, all while `this` and the arguments are still valid)
 /// and returns the async body (call and result encode), so nothing JSI-owned crosses the asynchronous
 /// boundary and JS gets a promise.
+///
+/// A synchronous function marked `@JS(.withAsync("name"))` also binds a promise-returning variant
+/// under that name (see `asyncVariant`). It decodes and encodes like an `async` function, and calls
+/// the function on the concurrent pool.
 internal struct JSFunction {
   let swiftName: String
-  let jsName: String
+  private(set) var jsName: String
   let parameters: [FunctionParameterSyntax]
   /// The declared return type as written, or `nil` when the function returns `Void`/nothing.
   let returnType: String?
   /// How the return value encodes when its type mentions `Any`, or `nil` for any other type.
   let returnFreeForm: FreeFormConversion?
   let isThrowing: Bool
-  let isAsync: Bool
+  private(set) var isAsync: Bool
   /// The function's name in the source, where a JavaScript name collision is reported.
-  let nameToken: TokenSyntax
+  private(set) var nameToken: TokenSyntax
+  /// The name from `.withAsync("name")` and its token, or `nil` when the attribute doesn't list it.
+  private var asyncVariantName: (name: String, token: TokenSyntax)?
+  /// True for the binding `asyncVariant` returns: it calls the synchronous function on the concurrent
+  /// pool instead of on the JavaScript thread.
+  private(set) var isAsyncVariant = false
 
   init(funcDecl: FunctionDeclSyntax, attribute: AttributeSyntax) {
     self.swiftName = funcDecl.name.text
@@ -39,6 +48,23 @@ internal struct JSFunction {
     let effectSpecifiers = funcDecl.signature.effectSpecifiers
     self.isThrowing = effectSpecifiers?.throwsClause?.throwsSpecifier != nil
     self.isAsync = effectSpecifiers?.asyncSpecifier != nil
+    self.asyncVariantName = asyncVariantOption(of: attribute).flatMap(asyncVariantName(of:))
+  }
+
+  /// The promise-returning binding that `.withAsync("name")` adds next to a synchronous function, or
+  /// `nil` when the attribute doesn't list it. An `async` function gets none: `@JS` reports the option
+  /// there.
+  var asyncVariant: JSFunction? {
+    guard let asyncVariantName, !isAsync else {
+      return nil
+    }
+    var variant = self
+    variant.jsName = asyncVariantName.name
+    variant.nameToken = asyncVariantName.token
+    variant.isAsync = true
+    variant.isAsyncVariant = true
+    variant.asyncVariantName = nil
+    return variant
   }
 
   /// The number of leading parameters that must always be supplied: the total minus the maximal
@@ -79,14 +105,16 @@ internal struct JSFunction {
         guard arguments.count == \(maximum) else {
           throw Exceptions.ArgumentsRangeMismatch((functionName: "\(jsName)", received: arguments.count, required: \(required), maximum: \(maximum)))
         }
-        """)
+        """
+      )
     } else {
       lines.append(
         """
         guard arguments.count >= \(required) && arguments.count <= \(maximum) else {
           throw Exceptions.ArgumentsRangeMismatch((functionName: "\(jsName)", received: arguments.count, required: \(required), maximum: \(maximum)))
         }
-        """)
+        """
+      )
     }
 
     // Decode the required prefix once — these slots are present in every accepted arity, so the
@@ -142,7 +170,8 @@ internal struct JSFunction {
       lines.append(contentsOf: encodeResultLines())
     }
 
-    return lines
+    return
+      lines
       .flatMap { $0.split(separator: "\n", omittingEmptySubsequences: false) }
       .map { indent + $0 }
       .joined(separator: "\n")
@@ -152,14 +181,22 @@ internal struct JSFunction {
   /// the function's async body (`AsyncFunctionBody`), awaiting the call and encoding the result. It
   /// captures only what the call needs — the decoded `arg<i>` locals, the receiver, and `runtime`
   /// for the encode — never `this` or the arguments buffer, which are only valid for the duration
-  /// of the host call.
+  /// of the host call. The `asyncVariant` binding awaits its call on the concurrent pool instead.
   private func asyncBodyLines(receiver: Receiver, arity: Int) -> [String] {
     var lines: [String] = ["return {"]
+    let call =
+      isAsyncVariant
+      ? concurrentCallExpression(receiver: receiver, arity: arity)
+      : callExpression(receiver: receiver, arity: arity)
+    // The concurrent call spans several lines, so each of its lines is indented into the body.
+    let indented = { (statement: String) in
+      statement.split(separator: "\n", omittingEmptySubsequences: false).map { "  " + $0 }
+    }
     if returnType != nil {
-      lines.append("  let result = \(callExpression(receiver: receiver, arity: arity))")
+      lines.append(contentsOf: indented("let result = \(call)"))
       lines.append(contentsOf: encodeResultLines().map { "  " + $0 })
     } else {
-      lines.append("  \(callExpression(receiver: receiver, arity: arity))")
+      lines.append(contentsOf: indented(call))
       lines.append("  return .undefined()")
     }
     lines.append("}")
@@ -179,10 +216,36 @@ internal struct JSFunction {
     )
   }
 
-  /// The `<callee>.<name>(...)` call for the given arity. Slots `0..<arity` are passed their decoded
+  /// The `<callee>.<name>(...)` call for the given arity, with the arguments from `callArguments`.
+  private func callExpression(receiver: Receiver, arity: Int) -> String {
+    // `try` only for a throwing function. An `async` call that doesn't throw must not get one, or the
+    // expansion warns that no throwing call occurs within the `try` expression.
+    let tryKeyword = isThrowing ? "try " : ""
+    let awaitKeyword = isAsync ? "await " : ""
+    return "\(tryKeyword)\(awaitKeyword)\(receiver.callee).\(swiftName)(\(callArguments(arity: arity)))"
+  }
+
+  /// The call of the `asyncVariant` binding for the given arity: the synchronous function runs in a
+  /// `@concurrent` closure, so it leaves the JavaScript thread, and the body continues once it returns.
+  private func concurrentCallExpression(receiver: Receiver, arity: Int) -> String {
+    // The closure captures the receiver and the decoded arguments, so Swift 6 requires them to be
+    // `Sendable`, as it does for the receiver and arguments of a `.concurrent` call. The signature is
+    // spelled out because `@concurrent` needs an `async` closure, and a body without `await` would
+    // infer a synchronous one.
+    let tryKeyword = isThrowing ? "try " : ""
+    let effects = isThrowing ? "async throws" : "async"
+    let returnClause = returnType.map { " -> \(expressionType($0))" } ?? ""
+    return """
+      \(tryKeyword)await { @concurrent () \(effects)\(returnClause) in
+        \(tryKeyword)\(receiver.callee).\(swiftName)(\(callArguments(arity: arity)))
+      }()
+      """
+  }
+
+  /// The argument list of a call for the given arity. Slots `0..<arity` are passed their decoded
   /// `arg<i>`; a trailing optional-without-default slot that this arity omits is passed `nil`; a
   /// trailing defaulted slot that this arity omits is dropped entirely so Swift applies its default.
-  private func callExpression(receiver: Receiver, arity: Int) -> String {
+  private func callArguments(arity: Int) -> String {
     var callArguments: [String] = []
     for (index, parameter) in parameters.enumerated() {
       let label = parameter.firstName.text
@@ -201,11 +264,7 @@ internal struct JSFunction {
       }
       callArguments.append(label == "_" ? value : "\(label): \(value)")
     }
-    // `try` only for a throwing function. An `async` call that doesn't throw must not get one, or the
-    // expansion warns that no throwing call occurs within the `try` expression.
-    let tryKeyword = isThrowing ? "try " : ""
-    let awaitKeyword = isAsync ? "await " : ""
-    return "\(tryKeyword)\(awaitKeyword)\(receiver.callee).\(swiftName)(\(callArguments.joined(separator: ", ")))"
+    return callArguments.joined(separator: ", ")
   }
 
   /// The flat (single-arity) call-and-encode lines used when no trailing parameter is omittable:
@@ -304,6 +363,13 @@ internal struct JSFunction {
 /// writes `<callee>.<name> = …`. Decode/encode of the value go through `JavaScriptDecodable.decode` /
 /// `JavaScriptEncodable.encode` (or the free-form methods for a type that mentions `Any`), the same
 /// path as functions.
+///
+/// A `lazy var` binds a getter only, on a configurable accessor. On the first read the getter defines
+/// the encoded value as a data property on the JS `this` with `defineProperty`, so later reads don't
+/// call into native code. The data property goes on `this`, not on the object that holds the accessor,
+/// so each shared object instance stores its own value. `defineProperty` leaves a frozen object
+/// unchanged, so there the property stays an accessor. A `this` that isn't an object doesn't fail the read
+/// either: the getter still returns the value.
 internal struct JSProperty {
   let swiftName: String
   let jsName: String
@@ -314,8 +380,10 @@ internal struct JSProperty {
   /// How the value converts when its type mentions `Any`, or `nil` for any other type.
   let freeForm: FreeFormConversion?
   /// Whether the property is settable from JS: `true` for a stored `var` or a computed `var` with an
-  /// explicit `set` accessor; `false` for a getter-only computed `var` or a `let`.
+  /// explicit `set` accessor; `false` for a getter-only computed `var`, a `lazy var` or a `let`.
   let isSettable: Bool
+  /// Whether the property is a `lazy var`, whose getter replaces the accessor with the first value.
+  let isLazy: Bool
   /// The property's name in the source, where a JavaScript name collision is reported.
   let nameToken: TokenSyntax
 
@@ -336,18 +404,37 @@ internal struct JSProperty {
 
     lines.append("let \(descriptorName) = runtime.createObject()")
     lines.append("\(descriptorName).setProperty(\"enumerable\", value: true)")
+    if isLazy {
+      // The getter redefines the property on `this`, which needs a configurable accessor when `this`
+      // is the object that holds it (a module).
+      lines.append("\(descriptorName).setProperty(\"configurable\", value: true)")
+    }
 
     // Getter: read `<callee>.<name>` and encode the result back to JS through `encode`. When the value
     // type couldn't be inferred (no annotation and no literal default, rare for a stored var) there's
     // no static type to call `encode` on, so the value's own `toJavaScriptValue(in:)` is the fallback.
-    let getEncode: String
+    let encode: String
     if let valueType {
-      getEncode = "return try \(encodeCall(valueType, freeForm: freeForm, of: "\(callee).\(swiftName)"))"
+      encode = "try \(encodeCall(valueType, freeForm: freeForm, of: "\(callee).\(swiftName)"))"
     } else {
-      getEncode = "return \(callee).\(swiftName).toJavaScriptValue(in: runtime)"
+      encode = "\(callee).\(swiftName).toJavaScriptValue(in: runtime)"
+    }
+    let getBody: String
+    if isLazy {
+      let define = "this.getObject(in: runtime).defineProperty(\"\(jsName)\", value: value, options: [.enumerable])"
+      // A module getter ignores `this` otherwise, so it can be anything, and only an object can hold the
+      // value. A shared object's unwrap has already checked that `this` is an object.
+      let defineStatement =
+        receiver.unwrapStatement == nil
+        ? "if this.isObject() {\n  \(define)\n}"
+        : define
+      getBody = "let value = \(encode)\n\(defineStatement)\nreturn value"
+    } else {
+      getBody = "return \(encode)"
     }
     lines.append(
-      accessorClosure(descriptorName, "get", receiver: receiver, body: "\(unwrap)\(getEncode)"))
+      accessorClosure(descriptorName, "get", receiver: receiver, body: "\(unwrap)\(getBody)")
+    )
 
     // Setter: decode argument 0 by the static type through `decode` and write `<callee>.<name>`. A
     // typed setter needs a known value type; when the type couldn't be inferred the property is bound
@@ -358,12 +445,19 @@ internal struct JSProperty {
       let setDecode = "\(callee).\(swiftName) = try \(decode)"
       lines.append(
         accessorClosure(
-          descriptorName, "set", receiver: receiver, returnsVoid: true, body: "\(unwrap)\(setDecode)"))
+          descriptorName,
+          "set",
+          receiver: receiver,
+          returnsVoid: true,
+          body: "\(unwrap)\(setDecode)"
+        )
+      )
     }
 
     lines.append("\(object).defineProperty(\"\(jsName)\", descriptor: \(descriptorName))")
 
-    return lines
+    return
+      lines
       .flatMap { $0.split(separator: "\n", omittingEmptySubsequences: false) }
       .map { "  " + $0 }
       .joined(separator: "\n")
@@ -374,12 +468,17 @@ internal struct JSProperty {
   /// A setter passes `returnsVoid`, so its closure declares `-> Void` and binds through the `Void`
   /// overload, like a function that returns nothing.
   private func accessorClosure(
-    _ descriptorName: String, _ key: String, receiver: Receiver, returnsVoid: Bool = false, body: String
+    _ descriptorName: String,
+    _ key: String,
+    receiver: Receiver,
+    returnsVoid: Bool = false,
+    body: String
   ) -> String {
     let captures = receiver.captureClause
     // Indent each line of a (possibly multi-line) body to sit one level inside the closure; a bare
     // `\(body)` interpolation would only indent the first line.
-    let indentedBody = body
+    let indentedBody =
+      body
       .split(separator: "\n", omittingEmptySubsequences: false)
       .map { "  \($0)" }
       .joined(separator: "\n")
@@ -404,7 +503,10 @@ internal struct JSProperty {
 /// how each binding reaches its Swift value (module `self`, shared-object instance `_self`, or the
 /// metatype for a static member).
 private func decorateBody(
-  functions: [JSFunction], properties: [JSProperty], object: String, receiver: Receiver
+  functions: [JSFunction],
+  properties: [JSProperty],
+  object: String,
+  receiver: Receiver
 ) -> String {
   let functionBody = functions.map { $0.decorateStatements(object: object, receiver: receiver) }
   let propertyBody = properties.map { $0.decorateStatements(object: object, receiver: receiver) }
@@ -421,7 +523,11 @@ private func decorateBody(
 /// receiver; the shared-object counterpart is `buildDecorateSharedObjectPhase`.
 internal func buildDecorateJavaScriptObject(functions: [JSFunction], properties: [JSProperty]) -> DeclSyntax {
   let body = decorateBody(
-    functions: functions, properties: properties, object: Phase.object.rawValue, receiver: .module)
+    functions: functions,
+    properties: properties,
+    object: Phase.object.rawValue,
+    receiver: .module
+  )
   return """
     @JavaScriptActor
     public func _decorateModule(object: borrowing JavaScriptObject, in runtime: JavaScriptRuntime) throws {
@@ -442,13 +548,21 @@ internal func buildDecorateJavaScriptObject(functions: [JSFunction], properties:
 /// which builds an instance and is emitted separately (see `JSConstructor.buildConstructor`). Each phase
 /// is emitted only when the type has a member for it.
 internal func buildDecorateSharedObjectPhase(
-  phase: Phase, functions: [JSFunction], properties: [JSProperty], typeName: String
+  phase: Phase,
+  functions: [JSFunction],
+  properties: [JSProperty],
+  typeName: String
 ) -> DeclSyntax {
-  let receiver: Receiver = phase == .constructor
+  let receiver: Receiver =
+    phase == .constructor
     ? .staticMember(typeName: typeName)
     : .sharedObject(typeName: typeName)
   let body = decorateBody(
-    functions: functions, properties: properties, object: phase.rawValue, receiver: receiver)
+    functions: functions,
+    properties: properties,
+    object: phase.rawValue,
+    receiver: receiver
+  )
   return """
     @JavaScriptActor
     public override class func _decorateSharedObject(\(raw: phase.rawValue): borrowing JavaScriptObject, in runtime: JavaScriptRuntime) throws {

package/apple/Sources/ExpoModulesMacros/EventMacro.swift

@@ -54,7 +54,8 @@ public struct EventMacro: AccessorMacro {
     // through the getter, so the body never has to spell the payload type. A sync event calls
     // `emitSync` (inline dispatch, JS thread only); the default calls the scheduling `emit`.
     let emitMethod = event.isSync ? "emitSync" : "emit"
-    let closure = event.hasPayload
+    let closure =
+      event.hasPayload
       ? "{ [weak self] payload in self?.\(emitMethod)(event: \"\(event.jsName)\", payload: payload) }"
       : "{ [weak self] in self?.\(emitMethod)(event: \"\(event.jsName)\") }"
     return [
@@ -85,9 +86,10 @@ extension EventMacro: PeerMacro {
     // 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)
+    let payload = event.payloadType.flatMap { assertableBoundaryType($0, constraint: jsConvertibleProtocolName) }
     let owner = enclosingTypeName(in: context) ?? "Self"
-    let helper = payload != nil
+    let helper =
+      payload != nil
       ? "func \(name)<P: \(jsConvertibleProtocolName), E: \(eventEmitterProtocolName)>(_: P.Type, _: E.Type) {}"
       : "func \(name)<E: \(eventEmitterProtocolName)>(_: E.Type) {}"
     let call = payload.map { "\(name)(\($0).self, \(owner).self)" } ?? "\(name)(\(owner).self)"
@@ -132,7 +134,8 @@ private func validatedEvent(
   }
   if varDecl.attributes.firstAttribute(named: "JS") != nil {
     throw MacroExpansionErrorMessage(
-      "@Event and @JS cannot be combined on the same property; an event is exposed to JS on its own, so remove one of the attributes")
+      "@Event and @JS cannot be combined on the same property; an event is exposed to JS on its own, so remove one of the attributes"
+    )
   }
   // The compiler also rejects accessor macros on a `let`, but with a generic message; this one says
   // what to do instead and carries the fix-it doing it. The synthesized property is getter-only, so
@@ -142,32 +145,40 @@ private func validatedEvent(
   }
   if varDecl.modifiers.contains(where: isTypeLevelModifier) {
     throw MacroExpansionErrorMessage(
-      "@Event must be an instance property; events are emitted from a module or shared object instance.")
+      "@Event must be an instance property; events are emitted from a module or shared object instance."
+    )
   }
   guard varDecl.bindings.count == 1, let binding = varDecl.bindings.first,
-    let identifier = binding.pattern.as(IdentifierPatternSyntax.self) else {
+    let identifier = binding.pattern.as(IdentifierPatternSyntax.self)
+  else {
     throw MacroExpansionErrorMessage(
-      "@Event must be applied to a single named property; declare each event separately")
+      "@Event must be applied to a single named property; declare each event separately"
+    )
   }
   if binding.initializer != nil {
     throw MacroExpansionErrorMessage(
-      "@Event property cannot have an initial value; the macro synthesizes the closure")
+      "@Event property cannot have an initial value; the macro synthesizes the closure"
+    )
   }
   if binding.accessorBlock != nil {
     throw MacroExpansionErrorMessage(
-      "@Event property cannot declare its own accessors; the macro synthesizes the getter")
+      "@Event property cannot declare its own accessors; the macro synthesizes the getter"
+    )
   }
   guard let functionType = underlyingFunctionType(of: binding.typeAnnotation?.type) else {
     throw MacroExpansionErrorMessage(
-      "@Event property must declare a function type, such as '(Payload) -> Void' or '() -> Void'")
+      "@Event property must declare a function type, such as '(Payload) -> Void' or '() -> Void'"
+    )
   }
   guard isVoidReturn(functionType.returnClause.type) else {
     throw MacroExpansionErrorMessage(
-      "@Event function type must return 'Void'; an event dispatches to JS and has no return value")
+      "@Event function type must return 'Void'; an event dispatches to JS and has no return value"
+    )
   }
   guard functionType.parameters.count <= 1 else {
     throw MacroExpansionErrorMessage(
-      "@Event function type takes at most one payload parameter; combine multiple values into a single record")
+      "@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) }) {
@@ -177,7 +188,8 @@ private func validatedEvent(
         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"
-        ))
+        )
+      )
     ])
   }
 
@@ -321,7 +333,8 @@ private func underlyingFunctionType(of type: TypeSyntax?) -> FunctionTypeSyntax?
     return underlyingFunctionType(of: attributed.baseType)
   }
   if let tuple = type.as(TupleTypeSyntax.self),
-    tuple.elements.count == 1, let element = tuple.elements.first, element.firstName == nil {
+    tuple.elements.count == 1, let element = tuple.elements.first, element.firstName == nil
+  {
     return underlyingFunctionType(of: element.type)
   }
   return type.as(FunctionTypeSyntax.self)
@@ -334,7 +347,8 @@ private func underlyingFunctionType(of type: TypeSyntax?) -> FunctionTypeSyntax?
 private func isVoidReturn(_ type: TypeSyntax) -> Bool {
   // Peel single-element, unlabeled parentheses: `(Void)` and `(())` are the same type as their content.
   if let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1,
-    let element = tuple.elements.first, element.firstName == nil {
+    let element = tuple.elements.first, element.firstName == nil
+  {
     return isVoidReturn(element.type)
   }
   let text = type.trimmedDescription

package/apple/Sources/ExpoModulesMacros/ExpoModuleMacro.swift

@@ -2,34 +2,31 @@ import SwiftSyntax
 import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
 
-/**
- Macro applied to a module class. It plays three roles, each implemented in its own
- extension below:
-
- - `MemberMacro`: binds `@JS`-marked members directly into the module's JS object via the
-   synthesized `_decorateModule`, and emits the resolved module name as a non-optional
-   `_jsName` static (no `Name(…)` DSL element). It also synthesizes a
-   framework-internal `_synthesizedDefinition()` returning `[AnyDefinition]` (now carrying
-   only nested `classes` entries) that `expo-modules-core` merges into the module's
-   definition. When the class doesn't already inherit `Module`/`BaseModule`, it also
-   synthesizes the `appContext` storage and `init(appContext:)` those base classes provide.
- - `MemberAttributeMacro`: stamps `@JavaScriptActor` on `@JS` sync members and
-   `@ModuleDefinitionBuilder` on a `definition()` method.
- - `ExtensionMacro`: adds the `AnyModule` conformance when the class doesn't inherit it.
-
- Inheriting from `Module` is therefore optional — a class can carry any superclass (or
- none) and still be a module, because everything inheritance used to provide is synthesized.
-
-   @ExpoModule
-   public final class MyModule {
-     public func definition() -> ModuleDefinition {
-       Name("MyModule")
-     }
-
-     @JS
-     func greet(name: String) -> String { "Hi, \(name)" }
-   }
- */
+/// Macro applied to a module class. It plays three roles, each implemented in its own
+/// extension below:
+///
+/// - `MemberMacro`: binds `@JS`-marked members directly into the module's JS object via the
+///   synthesized `_decorateModule`, and emits the resolved module name as a non-optional
+///   `_jsName` static (no `Name(…)` DSL element). The `classes:` and `views:` arguments become
+///   `_classTypes` and `_viewTypes` statics that `expo-modules-core` registers by type.
+///   When the class doesn't already inherit `Module`/`BaseModule`, it also
+///   synthesizes the `appContext` storage and `init(appContext:)` those base classes provide.
+/// - `MemberAttributeMacro`: stamps `@JavaScriptActor` on `@JS` sync members and
+///   `@ModuleDefinitionBuilder` on a `definition()` method.
+/// - `ExtensionMacro`: adds the `AnyModule` conformance when the class doesn't inherit it.
+///
+/// Inheriting from `Module` is therefore optional — a class can carry any superclass (or
+/// none) and still be a module, because everything inheritance used to provide is synthesized.
+///
+///   @ExpoModule
+///   public final class MyModule {
+///     public func definition() -> ModuleDefinition {
+///       Name("MyModule")
+///     }
+///
+///     @JS
+///     func greet(name: String) -> String { "Hi, \(name)" }
+///   }
 public struct ExpoModuleMacro: MemberMacro {
   public static func expansion(
     of node: AttributeSyntax,
@@ -46,43 +43,36 @@ public struct ExpoModuleMacro: MemberMacro {
     // macro no longer emits a `Name(…)` DSL entry. Core reads the static for the module name,
     // ahead of its type-name fallback (which then only applies to non-macro DSL modules).
     let moduleName = jsNameArgument(of: node) ?? withoutBackticks(classDecl.name.text)
-    var entries: [String] = []
 
     // `@JS func`s (sync and async) and `@JS var`s are bound directly into the JS object by the
     // synthesized `_decorateModule` rather than described with a `Function(...)` / `Property(...)`
-    // DSL entry, so they're collected here instead of appended to `entries`.
+    // DSL entry.
     var functions: [JSFunction] = []
     var properties: [JSProperty] = []
 
-    for typeName in classListArgument(of: node, label: "classes") {
-      entries.append("\(typeName)._synthesizedClassDefinition()")
-    }
-
     for member in classDecl.memberBlock.members {
       let decl = member.decl
 
       if let funcDecl = decl.as(FunctionDeclSyntax.self),
-        let attribute = funcDecl.attributes.firstAttribute(named: "JS") {
-        functions.append(JSFunction(funcDecl: funcDecl, attribute: attribute))
+        let attribute = funcDecl.attributes.firstAttribute(named: "JS")
+      {
+        let function = JSFunction(funcDecl: funcDecl, attribute: attribute)
+        functions.append(function)
+        if let variant = function.asyncVariant {
+          functions.append(variant)
+        }
         continue
       }
 
       if let varDecl = decl.as(VariableDeclSyntax.self),
-        let attribute = varDecl.attributes.firstAttribute(named: "JS") {
+        let attribute = varDecl.attributes.firstAttribute(named: "JS")
+      {
         properties.append(contentsOf: collectProperties(varDecl: varDecl, attribute: attribute))
       }
     }
 
     diagnoseJSNameCollisions(functions: functions, properties: properties, in: context)
 
-    let body: String
-    if entries.isEmpty {
-      body = "  return []"
-    } else {
-      let lines = entries.map { "    \($0)" }.joined(separator: ",\n")
-      body = "  return [\n\(lines)\n  ]"
-    }
-
     var emitted: [DeclSyntax] = []
 
     // The fully-resolved module name as a non-optional stored constant. Core reads this
@@ -90,6 +80,16 @@ public struct ExpoModuleMacro: MemberMacro {
     // JS object name, so they can't diverge.
     emitted.append("public static let _jsName = \"\(raw: moduleName)\"")
 
+    // Shared object classes are registered by type: core builds each JavaScript class from the
+    // `@SharedObject` hooks, with the name from the class's `_jsName`. The element type makes the
+    // compiler reject a class that isn't a `SharedObject` subclass. Emitted only when the argument is
+    // present, so a module without classes gains nothing.
+    let classTypes = classListArgument(of: node, label: "classes")
+    if !classTypes.isEmpty {
+      let entries = classTypes.map { "\($0).self" }.joined(separator: ", ")
+      emitted.append("public static let _classTypes: [SharedObject.Type] = [\(raw: entries)]")
+    }
+
     // View classes are registered by type, not spliced as definitions: an `@ExpoView` emits no
     // definition function, so there is nothing to call on each entry. Core reads a view's props
     // type from its `Props` typealias and its event names from that type's `_eventNames`, both
@@ -119,15 +119,6 @@ public struct ExpoModuleMacro: MemberMacro {
       }
     }
 
-    // Always emitted: the definition is derived from the class name and `@JS` members,
-    // independent of any `definition()` the user wrote.
-    let method: DeclSyntax = """
-      public func _synthesizedDefinition() -> [AnyDefinition] {
-      \(raw: body)
-      }
-      """
-    emitted.append(method)
-
     // Direct JSI binding: one `_decorateModule` that binds each `@JS func` (inlined `setProperty`
     // closure) and each `@JS var` (a `defineProperty` get/set accessor) into the module's JS object.
     // Only emitted when there's at least one member to bind.
@@ -154,12 +145,14 @@ extension ExpoModuleMacro: MemberAttributeMacro {
 
     // `@JS` sync members run on the JS thread; stamp `@JavaScriptActor` so isolation is
     // checked at compile time. Skipped when the member already chose an isolation
-    // (`async`, `nonisolated`, or another global actor) — see `shouldStampJavaScriptActor`.
+    // (`nonisolated` or another global actor), or when `.concurrent` or `.withAsync("name")` runs
+    // it on the concurrent pool. See `shouldStampJavaScriptActor`.
     // `@Event(sync: true)` members get the stamp too: a sync event dispatches inline, so the
     // isolation forces its call site onto the JS thread. Async events (the default) are
     // deliberately left unstamped — their `emit` schedules onto the JS thread itself.
     if memberHasJSAttribute(member) || isSyncEventMember(member),
-      shouldStampJavaScriptActor(on: member, enclosedBy: declaration) {
+      shouldStampJavaScriptActor(on: member, enclosedBy: declaration)
+    {
       attributes.append("@JavaScriptActor")
     }
 
@@ -174,7 +167,8 @@ extension ExpoModuleMacro: MemberAttributeMacro {
     // they already wrote `@ModuleDefinitionBuilder` themselves, which would otherwise be
     // a duplicate attribute.
     if isModuleDefinitionFunction(member),
-      !memberAttributes(of: member).contains(where: { hasAttributeName($0, "ModuleDefinitionBuilder") }) {
+      !memberAttributes(of: member).contains(where: { hasAttributeName($0, "ModuleDefinitionBuilder") })
+    {
       attributes.append("@ModuleDefinitionBuilder")
     }
 
@@ -186,7 +180,8 @@ private func isModuleDefinitionFunction(_ member: some DeclSyntaxProtocol) -> Bo
   guard let funcDecl = member.as(FunctionDeclSyntax.self),
     funcDecl.name.text == "definition",
     funcDecl.signature.parameterClause.parameters.isEmpty,
-    let returnType = funcDecl.signature.returnClause?.type else {
+    let returnType = funcDecl.signature.returnClause?.type
+  else {
     return false
   }
   return baseIdentifier(of: returnType) == "ModuleDefinition"
@@ -215,7 +210,8 @@ extension ExpoModuleMacro: ExtensionMacro {
     // These base types already supply `AnyModule`; emitting a second conformance here
     // would be redundant and error.
     if let classDecl = declaration.as(ClassDeclSyntax.self),
-      inheritsFromAny(classDecl, names: ["Module", "BaseModule", "AnyModule"]) {
+      inheritsFromAny(classDecl, names: ["Module", "BaseModule", "AnyModule"])
+    {
       return []
     }
     let conformance: DeclSyntax = "extension \(type.trimmed): AnyModule {}"
@@ -232,7 +228,8 @@ private func hasStoredProperty(_ classDecl: ClassDeclSyntax, named name: String)
     }
     for binding in varDecl.bindings {
       if let identifier = binding.pattern.as(IdentifierPatternSyntax.self),
-        identifier.identifier.text == name {
+        identifier.identifier.text == name
+      {
         return true
       }
     }
@@ -240,14 +237,12 @@ private func hasStoredProperty(_ classDecl: ClassDeclSyntax, named name: String)
   return false
 }
 
-/**
- True if the class declares an initializer that satisfies the `init(appContext:)` protocol
- requirement: a single parameter labeled `appContext` whose type is written as `AppContext`
- (or `…​.AppContext`). Both must match — the label is part of the requirement, so
- `init(c: AppContext)` does *not* satisfy it (we still synthesize ours), and the type guards
- against a same-labeled init of an unrelated type. A macro can't resolve types, so this is a
- syntactic match on the spelled name.
- */
+/// True if the class declares an initializer that satisfies the `init(appContext:)` protocol
+/// requirement: a single parameter labeled `appContext` whose type is written as `AppContext`
+/// (or `…​.AppContext`). Both must match — the label is part of the requirement, so
+/// `init(c: AppContext)` does *not* satisfy it (we still synthesize ours), and the type guards
+/// against a same-labeled init of an unrelated type. A macro can't resolve types, so this is a
+/// syntactic match on the spelled name.
 private func hasAppContextInitializer(_ classDecl: ClassDeclSyntax) -> Bool {
   for member in classDecl.memberBlock.members {
     guard let initDecl = member.decl.as(InitializerDeclSyntax.self) else {