expo-modules-macros 0.21.0 → 0.22.0

package/apple/Sources/ExpoModulesMacros/SharedObjectMacro.swift

@@ -2,26 +2,24 @@ import SwiftSyntax
 import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
 
-/**
- Member macro applied to a `SharedObject` subclass. Scans the class body for
- declarations marked with `@JS` and synthesizes `_synthesizedClassDefinition()`,
- returning a `ClassDefinition` ready to drop into a module's `Class { ... }` slot.
-
-   @SharedObject
-   final class Cache: SharedObject {
-     @JS
-     init(name: String) { self.name = name }
-
-     @JS
-     func get(_ key: String) -> String? { ... }
-
-     @JS
-     var size: Int { 42 }
-   }
-
- The companion `@ExpoModule(classes: [Cache.self])` wires the resulting
- definition into the module's exposed surface.
- */
+/// Member macro applied to a `SharedObject` subclass. Scans the class body for
+/// declarations marked with `@JS` and synthesizes `_synthesizedClassDefinition()`,
+/// returning a `ClassDefinition` ready to drop into a module's `Class { ... }` slot.
+///
+///   @SharedObject
+///   final class Cache: SharedObject {
+///     @JS
+///     init(name: String) { self.name = name }
+///
+///     @JS
+///     func get(_ key: String) -> String? { ... }
+///
+///     @JS
+///     var size: Int { 42 }
+///   }
+///
+/// The companion `@ExpoModule(classes: [Cache.self])` wires the resulting
+/// definition into the module's exposed surface.
 public struct SharedObjectMacro: MemberMacro {
   public static func expansion(
     of node: AttributeSyntax,
@@ -35,7 +33,8 @@ public struct SharedObjectMacro: MemberMacro {
 
     guard inheritsFromSharedObject(classDecl) else {
       throw MacroExpansionErrorMessage(
-        "@SharedObject class must inherit from SharedObject. Add `: SharedObject` to the class declaration.")
+        "@SharedObject class must inherit from SharedObject. Add `: SharedObject` to the class declaration."
+      )
     }
 
     let typeName = classDecl.name.text
@@ -62,28 +61,33 @@ public struct SharedObjectMacro: MemberMacro {
       let decl = member.decl
 
       if let initDecl = decl.as(InitializerDeclSyntax.self),
-        initDecl.attributes.firstAttribute(named: "JS") != nil {
+        initDecl.attributes.firstAttribute(named: "JS") != nil
+      {
         if constructor != nil {
           throw MacroExpansionErrorMessage(
-            "@SharedObject classes can have at most one @JS initializer; JavaScript classes have a single constructor.")
+            "@SharedObject classes can have at most one @JS initializer; JavaScript classes have a single constructor."
+          )
         }
         constructor = JSConstructor(initDecl: initDecl)
         continue
       }
 
       if let funcDecl = decl.as(FunctionDeclSyntax.self),
-        let attribute = funcDecl.attributes.firstAttribute(named: "JS") {
+        let attribute = funcDecl.attributes.firstAttribute(named: "JS")
+      {
         let function = JSFunction(funcDecl: funcDecl, attribute: attribute)
+        let bound = [function] + (function.asyncVariant.map { [$0] } ?? [])
         if isTypeLevel(funcDecl.modifiers) {
-          staticFunctions.append(function)
+          staticFunctions.append(contentsOf: bound)
         } else {
-          instanceFunctions.append(function)
+          instanceFunctions.append(contentsOf: bound)
         }
         continue
       }
 
       if let varDecl = decl.as(VariableDeclSyntax.self),
-        let attribute = varDecl.attributes.firstAttribute(named: "JS") {
+        let attribute = varDecl.attributes.firstAttribute(named: "JS")
+      {
         let collected = collectProperties(varDecl: varDecl, attribute: attribute)
         if isTypeLevel(varDecl.modifiers) {
           staticProperties.append(contentsOf: collected)
@@ -97,7 +101,8 @@ public struct SharedObjectMacro: MemberMacro {
     diagnoseJSNameCollisions(functions: staticFunctions, properties: staticProperties, in: context)
 
     let lines = entries.map { "    \($0)" }.joined(separator: "\n")
-    let body = entries.isEmpty
+    let body =
+      entries.isEmpty
       ? "  return Class(\"\(jsName)\", \(typeName).self) {\n  }"
       : "  return Class(\"\(jsName)\", \(typeName).self) {\n\(lines)\n  }"
 
@@ -117,14 +122,22 @@ public struct SharedObjectMacro: MemberMacro {
     if !instanceFunctions.isEmpty || !instanceProperties.isEmpty {
       emitted.append(
         buildDecorateSharedObjectPhase(
-          phase: .prototype, functions: instanceFunctions, properties: instanceProperties,
-          typeName: typeName))
+          phase: .prototype,
+          functions: instanceFunctions,
+          properties: instanceProperties,
+          typeName: typeName
+        )
+      )
     }
     if !staticFunctions.isEmpty || !staticProperties.isEmpty {
       emitted.append(
         buildDecorateSharedObjectPhase(
-          phase: .constructor, functions: staticFunctions, properties: staticProperties,
-          typeName: typeName))
+          phase: .constructor,
+          functions: staticFunctions,
+          properties: staticProperties,
+          typeName: typeName
+        )
+      )
     }
     if let constructor {
       emitted.append(constructor.buildConstructor(typeName: typeName))

package/apple/Sources/ExpoModulesMacros/TypeConformanceAssertion.swift

@@ -1,4 +1,5 @@
 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
@@ -38,7 +39,8 @@ internal let unionPayloadProtocolName = "JavaScriptDecodable & JavaScriptEncodab
 internal let eventEmitterProtocolName = "EventEmitter"
 
 /// Types we never assert because they're statically known to conform: the JS primitives. Asserting
-/// them would only add noise to the expansion.
+/// them would only add noise to the expansion. `isKnownConforming` extends this to the containers built
+/// from them.
 private let knownConformingPrimitives: Set<String> = ["Bool", "Int", "Double", "String"]
 
 /// One member's worth of conformance assertion: a name (the member it stands for) and the declared
@@ -60,7 +62,7 @@ internal struct ConformanceAssertion {
 /// 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 non-primitive argument and a single `Return` parameter for the value, called once with
+/// 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.
@@ -68,9 +70,9 @@ internal struct ConformanceAssertion {
 /// `decodableTypes` are the argument types (and a settable property's value type); `encodableType` is
 /// the single return type (or a property's value type on read), or `nil` when there's none.
 /// `callbackArgumentTypes` are the parameter types of closure arguments, which are encoded when native
-/// code calls the closure. Primitives are dropped from each; when nothing is left in any of them,
-/// returns `nil` so the caller emits no peer. `isStatic` mirrors a `static`/`class` member so the peer
-/// sits in the right metatype context.
+/// code calls the closure. Types known to conform are dropped from each; when nothing is left in any of
+/// them, returns `nil` so the caller emits no peer. `isStatic` mirrors a `static`/`class` member so the
+/// peer sits in the right metatype context.
 internal func directionalConformanceAssertion(
   name: String,
   decodableTypes: [String],
@@ -78,9 +80,9 @@ internal func directionalConformanceAssertion(
   callbackArgumentTypes: [String] = [],
   isStatic: Bool
 ) -> DeclSyntax? {
-  let decodables = distinctAssertableTypes(decodableTypes)
-  let callbackArguments = distinctAssertableTypes(callbackArgumentTypes)
-  let encodable = encodableType.flatMap(assertableBoundaryType)
+  let decodables = distinctAssertableTypes(decodableTypes, constraint: javaScriptDecodableProtocolName)
+  let callbackArguments = distinctAssertableTypes(callbackArgumentTypes, constraint: javaScriptEncodableProtocolName)
+  let encodable = encodableType.flatMap { assertableBoundaryType($0, constraint: javaScriptEncodableProtocolName) }
   guard !decodables.isEmpty || !callbackArguments.isEmpty || encodable != nil else {
     return nil
   }
@@ -126,7 +128,7 @@ internal func directionalConformanceAssertion(
 /// per property. Each assertion keeps its own named nested helper, so the per-member naming in the
 /// diagnostic is preserved even though they share one peer.
 ///
-/// Returns `nil` when no assertion has anything left to verify (all primitives / empty), so the
+/// Returns `nil` when no assertion has anything left to verify (all known to conform / empty), so the
 /// caller emits nothing.
 internal func typeConformanceAssertions(
   for assertions: [ConformanceAssertion],
@@ -143,30 +145,57 @@ internal func typeConformanceAssertions(
     """
 }
 
-/// The type to assert for a boundary type as written, or `nil` when nothing needs asserting: an
-/// exactly-free-form type (converted through the `JavaScriptValue` free-form methods) and a
-/// known-conforming primitive both return `nil`; everything else is unwrapped of trailing optionals
-/// and asserted. Shared with `@Event`, where an *optional* free-form type (`[String: Any]?`) is kept
-/// and asserted for a clean diagnostic. `@JS` leaves out every type that mentions `Any` before it gets
-/// here.
-internal func assertableBoundaryType(_ type: String) -> String? {
+/// The type to assert against `constraint` for a boundary type as written, or `nil` when nothing needs
+/// asserting: an exactly-free-form type (converted through the `JavaScriptValue` free-form methods) and
+/// a type known to conform (see `isKnownConforming`) both return `nil`; everything else is unwrapped of
+/// trailing optionals and asserted. Shared with `@Event`, where an *optional* free-form type
+/// (`[String: Any]?`) is kept and asserted for a clean diagnostic. `@JS` leaves out every type that
+/// mentions `Any` before it gets here.
+internal func assertableBoundaryType(_ type: String, constraint: String) -> String? {
   guard !isFreeFormBoundaryType(type) else {
     return nil
   }
-  let unwrapped = unwrappedOptional(type)
-  return knownConformingPrimitives.contains(unwrapped) ? nil : unwrapped
+  guard !isKnownConforming(TypeSyntax(stringLiteral: type), setsConform: setsConform(to: constraint)) else {
+    return nil
+  }
+  return unwrappedOptional(type)
+}
+
+/// True when `type` is known to conform without an assertion: a JS primitive, or an optional, array,
+/// `String`-keyed dictionary or set of such a type, at any depth (`[[Int]]`, `[String: [Double]]?`,
+/// `Set<String>`). Each of these containers conforms whenever its element does. A set counts only when
+/// `setsConform` is true. Anything else, such as a dictionary with another key type, returns `false`.
+private func isKnownConforming(_ type: TypeSyntax, setsConform: Bool) -> Bool {
+  if let identifier = type.as(IdentifierTypeSyntax.self), identifier.genericArgumentClause == nil {
+    return knownConformingPrimitives.contains(identifier.name.text)
+  }
+  if let element = optionalWrappedType(type) ?? arrayElementType(type) ?? stringKeyedDictionaryValueType(type) {
+    return isKnownConforming(element, setsConform: setsConform)
+  }
+  if setsConform, let element = setElementType(type) {
+    return isKnownConforming(element, setsConform: setsConform)
+  }
+  return false
+}
+
+/// True when `Set` conforms to `constraint`. Core conforms it to the JS codable protocols but not to
+/// `AnyArgument`.
+private func setsConform(to constraint: String) -> Bool {
+  return !constraint.split(separator: "&").contains { protocolName in
+    protocolName.filter { !$0.isWhitespace } == jsConvertibleProtocolName
+  }
 }
 
 /// The assertion's body fragment: a nested generic helper named after the member, plus one call per
-/// distinct non-primitive type. 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
-/// a known-conforming primitive or the list was empty.
+/// 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
 ) -> String? {
-  let distinct = distinctAssertableTypes(assertion.types)
+  let distinct = distinctAssertableTypes(assertion.types, constraint: constraint)
   guard !distinct.isEmpty else {
     return nil
   }
@@ -176,12 +205,13 @@ private func conformanceAssertionBody(
   return lines.joined(separator: "\n")
 }
 
-/// The distinct types to assert from a list, mapping each through `assertableBoundaryType` (which
-/// drops what needs no assertion) and deduping in first-seen order.
-private func distinctAssertableTypes(_ types: [String]) -> [String] {
+/// The distinct types to assert against `constraint` from a list, mapping each through
+/// `assertableBoundaryType` (which drops what needs no assertion) and deduping in first-seen order.
+private func distinctAssertableTypes(_ types: [String], constraint: String) -> [String] {
   var seen: Set<String> = []
   var distinct: [String] = []
-  for type in types.compactMap(assertableBoundaryType) where seen.insert(type).inserted {
+  let assertable = types.compactMap { assertableBoundaryType($0, constraint: constraint) }
+  for type in assertable where seen.insert(type).inserted {
     distinct.append(type)
   }
   return distinct

package/apple/Sources/ExpoModulesMacros/UnionMacro.swift

@@ -154,7 +154,8 @@ private func validatedUnion(of declaration: some DeclGroupSyntax) throws -> Unio
         message: UnionDiagnosticMessage(
           "@Union cannot be applied to a generic enum: each case's payload type must be concrete so the macro can select its converter.",
           id: "union-generic-enum"
-        ))
+        )
+      )
     ])
   }
 
@@ -175,7 +176,9 @@ private func validatedUnion(of declaration: some DeclGroupSyntax) throws -> Unio
             message: UnionDiagnosticMessage(
               "@Union case '\(name)' must carry exactly one associated value: the type this alternative decodes from. A payload-less enum is not a union; make it a raw-value enum conforming to 'Enumerable' instead.",
               id: "union-case-without-payload"
-            )))
+            )
+          )
+        )
         continue
       }
       guard parameters.count == 1, let parameter = parameters.first else {
@@ -185,7 +188,9 @@ private func validatedUnion(of declaration: some DeclGroupSyntax) throws -> Unio
             message: UnionDiagnosticMessage(
               "@Union case '\(name)' must carry exactly one associated value, but has \(parameters.count). Group them in a @Record type and use it as the single payload.",
               id: "union-case-with-multiple-payloads"
-            )))
+            )
+          )
+        )
         continue
       }
 
@@ -206,7 +211,9 @@ private func validatedUnion(of declaration: some DeclGroupSyntax) throws -> Unio
             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
       }
 
@@ -223,7 +230,9 @@ private func validatedUnion(of declaration: some DeclGroupSyntax) throws -> Unio
             message: UnionDiagnosticMessage(
               "@Union case '\(name)' repeats the payload type '\(payloadType)' of case '\(earlierCase)' and can never be decoded: alternatives are tried in declaration order and the first match wins.",
               id: "union-duplicate-payload-type"
-            )))
+            )
+          )
+        )
         continue
       }
       seenPayloadTypes[normalizedType] = name
@@ -261,12 +270,15 @@ private func decodeMethod(union: UnionType) -> DeclSyntax {
   var lines: [String] = ["  let kind = JavaScriptValueKinds(of: value)"]
   for unionCase in union.cases {
     let payloadType = expressionType(unionCase.payloadType)
-    lines.append("  if \(payloadType).decodableKinds.contains(kind), let payload = try? \(payloadType).decode(value, in: runtime) {")
+    lines.append(
+      "  if \(payloadType).decodableKinds.contains(kind), let payload = try? \(payloadType).decode(value, in: runtime) {"
+    )
     lines.append("    return \(unionCase.construction)")
     lines.append("  }")
   }
   let expected = union.cases.map { "\"\($0.payloadType)\"" }.joined(separator: ", ")
-  let mismatch = "(unionName: \"\(union.name)\", received: value.copied(in: runtime).kind.rawValue, expected: [\(expected)])"
+  let mismatch =
+    "(unionName: \"\(union.name)\", received: value.copied(in: runtime).kind.rawValue, expected: [\(expected)])"
   lines.append("  throw Exceptions.UnionCaseMismatch(\(mismatch))")
   let body = lines.joined(separator: "\n")
   return """
@@ -322,7 +334,8 @@ private func encodeMethod(union: UnionType) -> DeclSyntax {
 private func accessorMethods(union: UnionType) -> [DeclSyntax] {
   return union.cases.map { unionCase in
     let payloadType = expressionType(unionCase.payloadType)
-    let mismatch = "(unionName: \"\(union.name)\", received: _payloadTypeName, expected: [\"\(unionCase.payloadType)\"])"
+    let mismatch =
+      "(unionName: \"\(union.name)\", received: _payloadTypeName, expected: [\"\(unionCase.payloadType)\"])"
     return """
       public func `as`(_ type: \(raw: payloadType).Type) throws -> \(raw: payloadType) {
         if case \(raw: unionCase.pattern) = self {
@@ -369,7 +382,8 @@ private func defaultValueDiagnostic(
         newNode: Syntax(
           parameter
             .with(\.type, parameter.type.with(\.trailingTrivia, []))
-            .with(\.defaultValue, nil))
+            .with(\.defaultValue, nil)
+        )
       )
     ]
   )

package/apple/Sources/ExpoModulesMacros/ViewPropsMacro.swift

@@ -84,7 +84,8 @@ public struct ViewPropsMacro: MemberMacro, ExtensionMacro {
     // stored constant with the mask already folded rather than a computed property rebuilding an
     // array literal per call. The macro knows the bit count, so the literal is exact: n props
     // occupy bits 0..<n, which is the low n bits set.
-    let allPropsMask = props.valueProps.isEmpty
+    let allPropsMask =
+      props.valueProps.isEmpty
       ? "0"
       : "0b" + String(repeating: "1", count: props.valueProps.count)
 
@@ -206,7 +207,8 @@ private func innerFunctionType(of type: TypeSyntax) -> TypeSyntax? {
   guard let tuple = type.as(TupleTypeSyntax.self),
     tuple.elements.count == 1,
     let only = tuple.elements.first,
-    only.type.is(FunctionTypeSyntax.self) else {
+    only.type.is(FunctionTypeSyntax.self)
+  else {
     return nil
   }
   return only.type
@@ -322,7 +324,8 @@ private func validatedViewProps(of declaration: some DeclGroupSyntax) throws ->
       // (`var title = ""`). Anything a syntactic macro can't resolve still needs an annotation,
       // since the decode surface names the type.
       let declaredType = binding.typeAnnotation?.type
-      let resolvedType = declaredType?.trimmedDescription
+      let resolvedType =
+        declaredType?.trimmedDescription
         ?? binding.initializer.flatMap { inferredLiteralType(of: $0.value) }
       guard let resolvedType else {
         throw MacroExpansionErrorMessage(
@@ -390,7 +393,8 @@ private func underlyingFunctionType(of type: TypeSyntax) -> FunctionTypeSyntax?
   if let identifier = type.as(IdentifierTypeSyntax.self),
     identifier.name.text == "Optional",
     let argument = identifier.genericArgumentClause?.arguments.first,
-    case .type(let wrapped) = argument.argument {
+    case .type(let wrapped) = argument.argument
+  {
     return underlyingFunctionType(of: wrapped)
   }
   return nil
@@ -404,7 +408,8 @@ private func underlyingFunctionType(of type: TypeSyntax) -> FunctionTypeSyntax?
 private func propNameEnum(valueProps: [ViewProp]) -> DeclSyntax {
   // An escaped case takes its raw value from the bare identifier already, but spelling it out keeps
   // the wire key visible in the generated source and independent of that implicit rule.
-  let cases = valueProps
+  let cases =
+    valueProps
     .map { prop in
       prop.name == prop.wireName
         ? "  case \(prop.name)"

package/apple/Sources/ExpoModulesScanner/CLI.swift

@@ -50,7 +50,9 @@ public enum ScannerCLI {
       // scan-modules is platform-agnostic: each reported module carries the platforms that include
       // it, and the consumer filters. An option selecting one platform would silently drop data.
       guard platform == nil else {
-        return usageError("scan-modules does not take --platform; each module reports its 'platforms' and the consumer filters")
+        return usageError(
+          "scan-modules does not take --platform; each module reports its 'platforms' and the consumer filters"
+        )
       }
       guard !paths.isEmpty else {
         return usageError("scan-modules requires at least one path")

package/apple/Sources/ExpoModulesScanner/Core/DetectionVisitor.swift

@@ -94,11 +94,13 @@ final class DetectionVisitor: SyntaxVisitor {
       if node.is(SourceFileSyntax.self) {
         return true
       }
-      guard node.is(CodeBlockItemListSyntax.self)
-        || node.is(CodeBlockItemSyntax.self)
-        || node.is(IfConfigClauseSyntax.self)
-        || node.is(IfConfigClauseListSyntax.self)
-        || node.is(IfConfigDeclSyntax.self) else {
+      guard
+        node.is(CodeBlockItemListSyntax.self)
+          || node.is(CodeBlockItemSyntax.self)
+          || node.is(IfConfigClauseSyntax.self)
+          || node.is(IfConfigClauseListSyntax.self)
+          || node.is(IfConfigDeclSyntax.self)
+      else {
         return false
       }
       current = node.parent
@@ -118,7 +120,8 @@ final class DetectionVisitor: SyntaxVisitor {
     for element in attributes {
       guard let attribute = element.as(AttributeSyntax.self),
         let macro = DetectedMacro(rawValue: attribute.attributeName.trimmedDescription),
-        detectedMacros.contains(macro) else {
+        detectedMacros.contains(macro)
+      else {
         continue
       }
       let location = converter.location(for: node.positionAfterSkippingLeadingTrivia)
@@ -174,7 +177,8 @@ func stringArgument(of attribute: AttributeSyntax) -> String? {
     first.label == nil,
     let str = first.expression.as(StringLiteralExprSyntax.self),
     let segment = str.segments.first?.as(StringSegmentSyntax.self),
-    str.segments.count == 1 else {
+    str.segments.count == 1
+  else {
     return nil
   }
   return segment.content.text

package/apple/Sources/ExpoModulesScanner/Core/ScanBuildConfiguration.swift

@@ -50,7 +50,8 @@ struct ScanBuildConfiguration: BuildConfiguration {
     // "yes" would surface a declaration that doesn't exist in the real build.
     guard importPath.count == 1,
       case .unversioned = version,
-      let frameworkPlatforms = sdkFrameworkPlatforms[module] else {
+      let frameworkPlatforms = sdkFrameworkPlatforms[module]
+    else {
       throw ScanConfigurationError("cannot evaluate 'canImport(\(module))' in a static scan")
     }
     return frameworkPlatforms.contains(platform.lowercased())

package/apple/Sources/ExpoModulesScanner/Core/SourceScan.swift

@@ -1,10 +1,11 @@
+import SwiftParser
+import SwiftSyntax
+
 #if canImport(FoundationEssentials)
 import FoundationEssentials
 #else
 import Foundation
 #endif
-import SwiftParser
-import SwiftSyntax
 
 /// Walks `paths`, and for each `.swift` file that might contain one of `macros` or one of
 /// `conformances` (the pre-filter passes it), reads the source and hands it to `process` along with the
@@ -251,11 +252,13 @@ private func swiftFiles(inDirectoryAtPath directory: String, fileManager: FileMa
 /// The walk is the dominant cost of a whole-tree scan, and skipping that per-entry stat measurably
 /// shortens it.
 private func swiftFiles(inDirectory directory: URL, fileManager: FileManager) -> [String] {
-  guard let enumerator = fileManager.enumerator(
-    at: directory,
-    includingPropertiesForKeys: nil,
-    options: [.skipsHiddenFiles]
-  ) else {
+  guard
+    let enumerator = fileManager.enumerator(
+      at: directory,
+      includingPropertiesForKeys: nil,
+      options: [.skipsHiddenFiles]
+    )
+  else {
     return []
   }
 

package/apple/Sources/ExpoModulesScanner/Exports/Availability.swift

@@ -70,7 +70,8 @@ private struct Availability {
         for element in attributes {
           if let attribute = element.as(AttributeSyntax.self),
             attribute.attributeName.trimmedDescription == "available",
-            case .availability(let arguments) = attribute.arguments {
+            case .availability(let arguments) = attribute.arguments
+          {
             read(arguments, readsDeprecation: isOwn)
           }
         }
@@ -110,7 +111,8 @@ private struct Availability {
       for argument in arguments {
         if case .availabilityVersionRestriction(let restriction) = argument.argument,
           let platform = availabilityPlatformNames[restriction.platform.text],
-          let version = restriction.version {
+          let version = restriction.version
+        {
           raiseIntroduced(on: platform, to: version.trimmedDescription)
         }
       }
@@ -218,7 +220,8 @@ private func decodedText(of literal: SimpleStringLiteralExprSyntax) -> String {
     case "u":
       if text[index...].hasPrefix("{"), let close = text[index...].firstIndex(of: "}"),
         let scalarValue = UInt32(text[text.index(after: index)..<close], radix: 16),
-        let scalar = Unicode.Scalar(scalarValue) {
+        let scalar = Unicode.Scalar(scalarValue)
+      {
         result.unicodeScalars.append(scalar)
         index = text.index(after: close)
       } else {

package/apple/Sources/ExpoModulesScanner/Exports/ExportedSurface.swift

@@ -67,10 +67,11 @@ struct ExportedParameter: Encodable, Equatable {
 
 /// One `@JS func` on a module or shared object.
 struct ExportedFunction: Encodable, Equatable {
-  /// The Swift declaration name.
+  /// The Swift declaration name. A function with `.withAsync("x")` has two entries with this name.
   let name: String
 
-  /// The JS name it binds under: the `@JS("x")` override, else `name`.
+  /// The JS name it binds under: the `@JS("x")` override, else `name`. The second entry of a function
+  /// with `.withAsync("x")` binds under `x`.
   let jsName: String
 
   var parameters: [ExportedParameter]

package/apple/Sources/ExpoModulesScanner/Exports/ResolveRefs.swift

@@ -44,7 +44,11 @@ struct RefIndex {
     }
     for sharedObject in surface.sharedObjects {
       entries[sharedObject.name] = Entry(
-        name: sharedObject.name, kind: .sharedObject, jsType: .object, jsName: sharedObject.jsName)
+        name: sharedObject.name,
+        kind: .sharedObject,
+        jsType: .object,
+        jsName: sharedObject.jsName
+      )
     }
     for union in surface.unions {
       // A union crosses as whichever alternative matched, so its category is only meaningful per
@@ -53,7 +57,10 @@ struct RefIndex {
     }
     for enumeration in surface.enums {
       entries[enumeration.name] = Entry(
-        name: enumeration.name, kind: .enum, jsType: jsType(ofRawType: enumeration.rawType))
+        name: enumeration.name,
+        kind: .enum,
+        jsType: jsType(ofRawType: enumeration.rawType)
+      )
     }
   }
 
@@ -113,7 +120,8 @@ extension TypeNode {
       return .ref(
         name: entry.name,
         refKind: entry.kind,
-        jsTypeOverride: entry.jsType == .object ? nil : entry.jsType)
+        jsTypeOverride: entry.jsType == .object ? nil : entry.jsType
+      )
     case .optional(let wrapped):
       return .optional(wrapped: wrapped.resolvingRefs(using: index, in: scope))
     case .array(let element):
@@ -121,7 +129,8 @@ extension TypeNode {
     case .dictionary(let key, let value):
       return .dictionary(
         key: key.resolvingRefs(using: index, in: scope),
-        value: value.resolvingRefs(using: index, in: scope))
+        value: value.resolvingRefs(using: index, in: scope)
+      )
     case .promise(let value):
       return .promise(value: value.resolvingRefs(using: index, in: scope))
     case .function(let parameters, let returns, let isAsync, let isThrowing):
@@ -153,7 +162,8 @@ extension ExportedSurface {
         resolved.events = module.events.map { $0.resolvingRefs(using: index, in: module.name) }
         resolved.classes = module.classes.map { exportedClass in
           guard let entry = index.lookup(exportedClass.name, in: module.name),
-            entry.kind == .sharedObject else {
+            entry.kind == .sharedObject
+          else {
             return exportedClass
           }
           return ExportedClass(name: entry.name, jsName: entry.jsName)

package/apple/Sources/ExpoModulesScanner/Exports/ScanExports.swift

@@ -1,10 +1,11 @@
+import SwiftParser
+import SwiftSyntax
+
 #if canImport(FoundationEssentials)
 import FoundationEssentials
 #else
 import Foundation
 #endif
-import SwiftParser
-import SwiftSyntax
 
 extension Scanner {
   /// Runs `scan-exports` over `paths`, prints the JSON report to stdout, and returns the exit code
@@ -58,7 +59,11 @@ func scanExports(paths: [String]) -> ScanExportsResult {
   // Refs resolve only once every file has been walked: a type parsed in one file may name a type
   // declared in another, so the full set of declarations has to exist before any lookup is valid.
   let surface = ExportedSurface(
-    modules: modules, sharedObjects: sharedObjects, records: records, enums: enums, unions: unions
+    modules: modules,
+    sharedObjects: sharedObjects,
+    records: records,
+    enums: enums,
+    unions: unions
   ).resolvingRefs()
 
   return ScanExportsResult(