expo-modules-macros 0.21.0 → 0.22.0

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,32 @@ 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). 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)" }
+///   }
 public struct ExpoModuleMacro: MemberMacro {
   public static func expansion(
     of node: AttributeSyntax,
@@ -62,13 +60,19 @@ public struct ExpoModuleMacro: MemberMacro {
       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))
       }
     }
@@ -154,12 +158,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 +180,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 +193,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 +223,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 +241,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 +250,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 {

package/apple/Sources/ExpoModulesMacros/ExpoModulesOptimizedMacro.swift

@@ -34,7 +34,8 @@ public struct OptimizedFunctionAttachedMacro: PeerMacro {
   ) throws -> [DeclSyntax] {
     guard let funcDecl = declaration.as(FunctionDeclSyntax.self) else {
       throw MacroExpansionErrorMessage(
-        "@OptimizedFunction can only be attached to function declarations")
+        "@OptimizedFunction can only be attached to function declarations"
+      )
     }
 
     let functionName = funcDecl.name.text

package/apple/Sources/ExpoModulesMacros/FreeFormTypes.swift

@@ -178,72 +178,13 @@ internal func isAnyType(_ type: some SyntaxProtocol) -> Bool {
   if let member = type.as(MemberTypeSyntax.self),
     member.name.text == "Any",
     member.genericArgumentClause == nil,
-    let base = member.baseType.as(IdentifierTypeSyntax.self) {
+    let base = member.baseType.as(IdentifierTypeSyntax.self)
+  {
     return base.name.text == "Swift"
   }
   return false
 }
 
-/// The element type of `[T]` or `Array<T>`, or `nil` for any other type.
-private func arrayElementType(_ type: TypeSyntax) -> TypeSyntax? {
-  if let array = type.as(ArrayTypeSyntax.self) {
-    return array.element
-  }
-  guard let arguments = genericArguments(of: type, named: "Array"), arguments.count == 1 else {
-    return nil
-  }
-  return arguments[0]
-}
-
-/// The value type of `[String: V]` or `Dictionary<String, V>`, or `nil` for any other type, including a
-/// dictionary with a different key type.
-private func stringKeyedDictionaryValueType(_ type: TypeSyntax) -> TypeSyntax? {
-  if let dictionary = type.as(DictionaryTypeSyntax.self) {
-    return isStringType(dictionary.key) ? dictionary.value : nil
-  }
-  guard let arguments = genericArguments(of: type, named: "Dictionary"), arguments.count == 2 else {
-    return nil
-  }
-  return isStringType(arguments[0]) ? arguments[1] : nil
-}
-
-/// The type arguments of a generic type spelled `<name><…>` (or `Swift.<name><…>`), or `nil` when the
-/// type has another name or no type arguments.
-private func genericArguments(of type: TypeSyntax, named name: String) -> [TypeSyntax]? {
-  let clause: GenericArgumentClauseSyntax?
-  if let identifier = type.as(IdentifierTypeSyntax.self), identifier.name.text == name {
-    clause = identifier.genericArgumentClause
-  } else if let member = type.as(MemberTypeSyntax.self),
-    member.name.text == name,
-    member.baseType.as(IdentifierTypeSyntax.self)?.name.text == "Swift" {
-    clause = member.genericArgumentClause
-  } else {
-    return nil
-  }
-  guard let clause else {
-    return nil
-  }
-  var types: [TypeSyntax] = []
-  for argument in clause.arguments {
-    guard case .type(let type) = argument.argument else {
-      return nil
-    }
-    types.append(type)
-  }
-  return types
-}
-
-/// True when the type is `String` or `Swift.String`.
-private func isStringType(_ type: TypeSyntax) -> Bool {
-  if let identifier = type.as(IdentifierTypeSyntax.self) {
-    return identifier.name.text == "String" && identifier.genericArgumentClause == nil
-  }
-  if let member = type.as(MemberTypeSyntax.self), member.name.text == "String" {
-    return member.baseType.as(IdentifierTypeSyntax.self)?.name.text == "Swift"
-  }
-  return false
-}
-
 /// Walks a type looking for `Any` (or `Swift.Any`) anywhere inside it.
 private final class AnyTypeFinder: SyntaxVisitor {
   var found = false

package/apple/Sources/ExpoModulesMacros/JSConstructor.swift

@@ -23,7 +23,8 @@ internal struct JSConstructor {
       guard arguments.count == \(parameters.count) else {
         throw Exceptions.ArgumentsRangeMismatch((functionName: "\(typeName)", received: arguments.count, required: \(parameters.count), maximum: \(parameters.count)))
       }
-      """)
+      """
+    )
 
     var callArguments: [String] = []
     for (index, parameter) in parameters.enumerated() {
@@ -32,7 +33,8 @@ internal struct JSConstructor {
           type: parameter.type,
           into: "arg\(index)",
           from: "arguments.unownedValue(at: \(index))"
-        ))
+        )
+      )
 
       let label = parameter.firstName.text
       callArguments.append(label == "_" ? "arg\(index)" : "\(label): arg\(index)")
@@ -40,7 +42,8 @@ internal struct JSConstructor {
 
     lines.append("return \(typeName)(\(callArguments.joined(separator: ", ")))")
 
-    return lines
+    return
+      lines
       .flatMap { $0.split(separator: "\n", omittingEmptySubsequences: false) }
       .map { indent + $0 }
       .joined(separator: "\n")