expo-modules-macros 0.29.0 → 0.31.0

package/apple/Sources/ExpoModulesCLI/Commands/Fix/RunFix.swift

@@ -0,0 +1,290 @@
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
+/// The options of `fix`, parsed by `ScannerCLI`.
+struct FixOptions: Equatable {
+  var paths: [String] = []
+  var symbols: [String] = []
+  var dryRun = false
+  var onlyErrors = false
+}
+
+/// A Fix-It that `fix` applied or skipped, at the location of its diagnostic.
+struct FixItReport: Equatable {
+  let line: Int
+  let column: Int
+  let message: String
+
+  /// Why `fix` skipped the Fix-It, or `nil` when it applied it.
+  let skipReason: String?
+}
+
+/// The result of applying the Fix-Its of one file.
+struct FixedSource: Equatable {
+  /// The source with the applied Fix-Its.
+  let source: String
+  let fixIts: [FixItReport]
+
+  /// Whether `fixSource` stopped after `maxFixPasses` passes while Fix-Its were left to apply.
+  var reachedPassLimit = false
+
+  var applied: [FixItReport] {
+    fixIts.filter { $0.skipReason == nil }
+  }
+}
+
+extension Scanner {
+  /// Runs `fix`: expands the macros in each file like `expand` and applies the Fix-Its of their
+  /// diagnostics to the file, in place (see `fixSource`). It doesn't format the file.
+  ///
+  /// Each applied Fix-It is printed to stdout as `<file>:<line>:<column>: fix-it: <message>` after its
+  /// file is written, followed by a summary, and each skipped one to stderr as a warning. With
+  /// `--dry-run`, the files aren't written. A file that can't be written is reported and the others are
+  /// still fixed. The exit code is `0` also when a Fix-It is skipped, `1` when a file can't be written,
+  /// and `2` for an input that `expand` doesn't take.
+  ///
+  /// `write` writes a fixed file and returns whether it changed it (see `writeFixedSource`); tests
+  /// replace it. A file that another path already fixed, through a hard link, isn't printed or counted
+  /// again.
+  static func runFix(
+    options: FixOptions,
+    expander: MacroExpander,
+    write: (_ source: String, _ path: String, _ original: Data) throws -> Bool = writeFixedSource
+  ) -> Int32 {
+    let sources: [(source: String, contents: Data, expanded: ExpandedFile)]
+    switch expandSources(options: ExpandOptions(paths: options.paths, symbols: options.symbols), expander: expander) {
+    case .success(let expanded):
+      sources = expanded
+    case .failure(let error):
+      writeToStandardError("error: \(error.message)\n")
+      return 2
+    }
+
+    var appliedCount = 0
+    var fixedFiles = 0
+    var failedFiles = 0
+    for (source, contents, expanded) in sources {
+      let fixed = fixSource(
+        source,
+        expanded: expanded,
+        symbols: options.symbols,
+        onlyErrors: options.onlyErrors,
+        expander: expander
+      )
+      writeToStandardError(renderSkippedFixIts(fixed, file: expanded.file))
+      guard !fixed.applied.isEmpty else {
+        continue
+      }
+      if !options.dryRun {
+        do {
+          guard try write(fixed.source, expanded.file, contents) else {
+            continue
+          }
+        } catch {
+          writeToStandardError("error: could not write '\(expanded.file)': \(error)\n")
+          failedFiles += 1
+          continue
+        }
+      }
+      writeToStandardOutput(renderAppliedFixIts(fixed, file: expanded.file))
+      appliedCount += fixed.applied.count
+      fixedFiles += 1
+    }
+
+    writeToStandardOutput(
+      renderFixSummary(applied: appliedCount, files: fixedFiles, failed: failedFiles, dryRun: options.dryRun)
+    )
+    return failedFiles > 0 ? 1 : 0
+  }
+}
+
+/// Why `writeFixedSource` didn't write a file.
+struct FixWriteError: Error, CustomStringConvertible {
+  let description: String
+}
+
+/// Writes `source`, the fixed source of the file at `path`, whose contents were `original`, and
+/// returns whether it changed the file.
+///
+/// The file must still have the contents that `fix` read, so a change that an editor saved meanwhile
+/// isn't lost. A file that already has the fixed contents, because `fix` wrote it through another
+/// hard link, is left as it is. It keeps the UTF-8 byte order mark of the file, which `readSource`
+/// removes from the source.
+///
+/// The file is written in place, so on macOS and Linux its links, permissions, owner, extended
+/// attributes and ACLs stay, and a read-only file isn't written. When the write fails, the original contents are written back,
+/// and the error tells whether the file is unchanged. When that fails too, the original contents are
+/// saved to a file in the temporary directory, which the error names.
+@discardableResult
+func writeFixedSource(_ source: String, toFile path: String, original: Data) throws -> Bool {
+  let url = URL(fileURLWithPath: path)
+  let contents = Data((original.starts(with: utf8ByteOrderMark) ? utf8ByteOrderMark : []) + Array(source.utf8))
+  guard let current = try? Data(contentsOf: url) else {
+    throw FixWriteError(description: "the file can't be read anymore")
+  }
+  guard current != contents else {
+    return false
+  }
+  guard current == original else {
+    throw FixWriteError(description: "the file changed after fix read it")
+  }
+  do {
+    try contents.write(to: url)
+  } catch {
+    if (try? Data(contentsOf: url)) != original {
+      try? original.write(to: url)
+    }
+    if (try? Data(contentsOf: url)) == original {
+      throw FixWriteError(description: "\(error); the file is unchanged")
+    }
+    let backup = FileManager.default.temporaryDirectory.appendingPathComponent(
+      "\(url.lastPathComponent).\(UUID().uuidString).original"
+    )
+    let saved = (try? original.write(to: backup)) != nil
+    throw FixWriteError(
+      description: "\(error); the file can be incomplete"
+        + (saved ? ", and its original contents are in '\(backup.path)'" : "")
+    )
+  }
+  return true
+}
+
+/// The most times that `fixSource` expands a file again after applying Fix-Its.
+let maxFixPasses = 10
+
+/// Applies the Fix-Its of `expanded`, the expansion of `source`, to `source`. A macro can stop at its
+/// first error, so after applying Fix-Its, this expands the result again and applies the new Fix-Its,
+/// until none applies or after `maxFixPasses` passes. The location of an applied Fix-It is in the
+/// source of its pass. The skipped Fix-Its are those of the last pass. With `onlyErrors`, the Fix-Its
+/// of warnings and other diagnostics that aren't errors are left out.
+func fixSource(
+  _ source: String,
+  expanded: ExpandedFile,
+  symbols: [String],
+  onlyErrors: Bool = false,
+  expander: MacroExpander
+) -> FixedSource {
+  let selected = { (diagnostics: [ExpansionDiagnostic]) in
+    onlyErrors ? diagnostics.filter { $0.severity == .error } : diagnostics
+  }
+  var fixed = applyFixIts(to: source, diagnostics: selected(expanded.diagnostics))
+  var applied = fixed.applied
+  for _ in 1..<maxFixPasses where !fixed.applied.isEmpty {
+    let diagnostics = expander.expand(fixed.source, expanded.file, symbols).diagnostics
+    fixed = applyFixIts(to: fixed.source, diagnostics: selected(diagnostics))
+    applied += fixed.applied
+  }
+  // After the last pass, expand once more to tell whether Fix-Its are left.
+  let reachedPassLimit =
+    !fixed.applied.isEmpty
+    && !applyFixIts(
+      to: fixed.source,
+      diagnostics: selected(expander.expand(fixed.source, expanded.file, symbols).diagnostics)
+    ).applied.isEmpty
+  return FixedSource(
+    source: fixed.source,
+    fixIts: applied + fixed.fixIts.filter { $0.skipReason != nil },
+    reachedPassLimit: reachedPassLimit
+  )
+}
+
+/// Applies the Fix-Its of `diagnostics` to `source`, which is the file that they were reported for.
+///
+/// A diagnostic with more than one Fix-It is skipped, because they are alternatives. So is a Fix-It
+/// whose edits aren't in the file, or whose edits overlap the edits of a Fix-It before it. A Fix-It
+/// with the same edits as one before it, which a macro can report twice, is left out. A diagnostic
+/// without `fixItEdits`, such as a syntax error, is left out too.
+func applyFixIts(to source: String, diagnostics: [ExpansionDiagnostic]) -> FixedSource {
+  let text = Array(source.utf8)
+  var accepted: [ExpansionEdit] = []
+  var reports: [FixItReport] = []
+
+  for diagnostic in diagnostics
+  where !diagnostic.fixIts.isEmpty && diagnostic.fixItEdits.count == diagnostic.fixIts.count {
+    let report = { (message: String, reason: String?) in
+      reports.append(
+        FixItReport(line: diagnostic.line, column: diagnostic.column, message: message, skipReason: reason)
+      )
+    }
+    guard diagnostic.fixIts.count == 1, let message = diagnostic.fixIts.first, let edits = diagnostic.fixItEdits.first
+    else {
+      for message in diagnostic.fixIts {
+        report(message, "the diagnostic has \(diagnostic.fixIts.count) Fix-Its to choose from")
+      }
+      continue
+    }
+    if !edits.isEmpty && edits.allSatisfy(accepted.contains) {
+      continue
+    }
+    guard !edits.isEmpty, edits.allSatisfy({ matches($0, in: text) }) else {
+      report(message, "its edits aren't in the file")
+      continue
+    }
+    let overlaps = edits.enumerated().contains { index, edit in
+      (accepted + edits.prefix(index)).contains { overlap(edit, $0) }
+    }
+    guard !overlaps else {
+      report(message, "it overlaps another Fix-It")
+      continue
+    }
+    accepted += edits
+    report(message, nil)
+  }
+
+  var fixed = text
+  for edit in accepted.sorted(by: { $0.offset > $1.offset }) {
+    fixed.replaceSubrange(edit.offset..<(edit.offset + edit.original.utf8.count), with: Array(edit.replacement.utf8))
+  }
+  return FixedSource(source: String(decoding: fixed, as: UTF8.self), fixIts: reports)
+}
+
+/// Whether `text` has the original text of `edit` at its offset.
+private func matches(_ edit: ExpansionEdit, in text: [UInt8]) -> Bool {
+  let original = Array(edit.original.utf8)
+  return edit.offset >= 0 && edit.offset + original.count <= text.count
+    && text[edit.offset..<(edit.offset + original.count)].elementsEqual(original)
+}
+
+/// Whether two edits change the same bytes, or insert at the same offset, where their order would
+/// matter.
+private func overlap(_ a: ExpansionEdit, _ b: ExpansionEdit) -> Bool {
+  let aEnd = a.offset + a.original.utf8.count
+  let bEnd = b.offset + b.original.utf8.count
+  return a.offset == b.offset || (a.offset < bEnd && b.offset < aEnd)
+}
+
+/// The applied Fix-Its of `fixed`, one line each.
+func renderAppliedFixIts(_ fixed: FixedSource, file: String) -> String {
+  fixed.applied.map { "\(file):\($0.line):\($0.column): fix-it: \($0.message)\n" }.joined()
+}
+
+/// The warnings for the skipped Fix-Its of `fixed`, and for reaching the pass limit.
+func renderSkippedFixIts(_ fixed: FixedSource, file: String) -> String {
+  var text = ""
+  for fixIt in fixed.fixIts {
+    if let reason = fixIt.skipReason {
+      text += "\(file):\(fixIt.line):\(fixIt.column): warning: skipped fix-it '\(fixIt.message)': \(reason)\n"
+    }
+  }
+  if fixed.reachedPassLimit {
+    text += "\(file): warning: stopped after \(maxFixPasses) passes; run fix again for the Fix-Its left\n"
+  }
+  return text
+}
+
+/// The summary line of `fix`, for example `Applied 3 Fix-Its in 2 files.` or, when files couldn't be
+/// written, `Applied 1 Fix-It in 1 file. Could not write 1 file.`
+func renderFixSummary(applied: Int, files: Int, failed: Int = 0, dryRun: Bool) -> String {
+  let count = { (n: Int, noun: String) in "\(n) \(noun)\(n == 1 ? "" : "s")" }
+  var parts: [String] = []
+  if applied > 0 {
+    parts.append("\(dryRun ? "Would apply" : "Applied") \(count(applied, "Fix-It")) in \(count(files, "file")).")
+  }
+  if failed > 0 {
+    parts.append("Could not write \(count(failed, "file")).")
+  }
+  return (parts.isEmpty ? "No Fix-Its to apply." : parts.joined(separator: " ")) + "\n"
+}

package/apple/Sources/ExpoModulesCLI/Commands/ScanExports/ExportedSurface.swift

@@ -207,8 +207,8 @@ struct ExportedEvent: Encodable, Equatable {
   /// The single payload parameter's type, or `nil` for a no-payload `() -> Void` event.
   var payload: TypeNode?
 
-  /// `@Event(sync: true)`, dispatching inline on the JS thread instead of scheduling.
-  let isSync: Bool
+  /// How the event is dispatched: the default `scheduled`, or the `.inline` or `.blocking` option.
+  let dispatch: ExportedEventDispatch
 
   /// The spelled access modifier, or `nil` when none is written.
   let accessLevel: String?
@@ -216,8 +216,7 @@ struct ExportedEvent: Encodable, Equatable {
   let platforms: [ExportedPlatform]
 
   private enum CodingKeys: String, CodingKey {
-    case name, jsName, payload, accessLevel, platforms
-    case isSync = "sync"
+    case name, jsName, payload, dispatch, accessLevel, platforms
   }
 
   func encode(to encoder: Encoder) throws {
@@ -225,7 +224,7 @@ struct ExportedEvent: Encodable, Equatable {
     try container.encode(name, forKey: .name)
     try container.encode(jsName, forKey: .jsName)
     try container.encodeIfPresent(payload, forKey: .payload)
-    try container.encode(isSync, forKey: .isSync)
+    try container.encode(dispatch, forKey: .dispatch)
     try container.encodeIfPresent(accessLevel, forKey: .accessLevel)
     try container.encode(platforms, forKey: .platforms)
   }
@@ -471,6 +470,13 @@ struct ExportedSurface: Encodable, Equatable {
   let unions: [ExportedUnion]
 }
 
+/// How an `@Event` is dispatched to JavaScript, from its option. Mirrors `EventDispatch` in the macros.
+enum ExportedEventDispatch: String, Encodable, Equatable {
+  case scheduled
+  case inline
+  case blocking
+}
+
 /// Version of the `scan-exports` output shape. Bumped on any breaking change to the envelope or to
 /// anything under `exports`, so a consumer can verify it understands the output before trusting it.
 /// Versioned independently of `scanModulesSchemaVersion`: the two commands serve different consumers
@@ -481,8 +487,9 @@ struct ExportedSurface: Encodable, Equatable {
 /// declarations in `#if` blocks, adds `platforms` (with deprecations), `accessLevel`, and
 /// `defaultValue`, and replaces `constructorParameters` with `initializer`; version 9 adds the
 /// `sharedRef` type kind and the `sharedRef` of a shared object; version 10 adds the `tuple` and `object` type kinds (named after a tuple alias)
-/// and resolves the tuple type aliases declared in `@ExpoModule` and `@SharedObject` classes.
-let scanExportsSchemaVersion = 10
+/// and resolves the tuple type aliases declared in `@ExpoModule` and `@SharedObject` classes; version 11
+/// replaces the `sync` flag of an event with `dispatch`.
+let scanExportsSchemaVersion = 11
 
 /// The `scan-exports` result: the surface plus the run's stats. A distinct envelope from
 /// `ScanModulesResult` (different consumer: TS generation vs. autolinking).

package/apple/Sources/ExpoModulesCLI/Commands/ScanExports/SurfaceVisitor.swift

@@ -285,7 +285,9 @@ final class SurfaceVisitor: SyntaxVisitor {
       return []
     }
     let override = stringArgument(of: attribute)
-    let isSync = boolArgument(of: attribute, label: "sync") == true
+    let dispatch: ExportedEventDispatch =
+      hasEventOption(attribute, named: "inline")
+      ? .inline : hasEventOption(attribute, named: "blocking") ? .blocking : .scheduled
     var result: [ExportedEvent] = []
 
     for binding in varDecl.bindings {
@@ -306,7 +308,7 @@ final class SurfaceVisitor: SyntaxVisitor {
           name: name,
           jsName: override ?? defaultEventName(for: name),
           payload: functionType.parameters.first.map { typeNode(from: $0.type) },
-          isSync: isSync,
+          dispatch: dispatch,
           accessLevel: spelledAccessLevel(of: varDecl.modifiers),
           platforms: platforms
         )
@@ -704,18 +706,16 @@ private func isVoidEventReturn(_ type: TypeSyntax) -> Bool {
   return text == "Void" || text == "()" || text == "Swift.Void"
 }
 
-/// The value of a labeled boolean macro argument (`@Event(sync: true)`), or `nil` when absent.
-private func boolArgument(of attribute: AttributeSyntax, label: String) -> Bool? {
+/// True if an `@Event` attribute lists the given option member (`@Event(.inline)` or
+/// `@Event("name", EventOptions.inline)`). Like `hasOption` in the macros, but without the array-literal
+/// branch, which `EventOptions...` doesn't accept.
+private func hasEventOption(_ attribute: AttributeSyntax, named option: String) -> Bool {
   guard let arguments = attribute.arguments?.as(LabeledExprListSyntax.self) else {
-    return nil
+    return false
   }
-  for argument in arguments where argument.label?.text == label {
-    guard let literal = argument.expression.as(BooleanLiteralExprSyntax.self) else {
-      return nil
-    }
-    return literal.literal.tokenKind == .keyword(.true)
+  return arguments.contains { argument in
+    argument.expression.as(MemberAccessExprSyntax.self)?.declName.baseName.text == option
   }
-  return nil
 }
 
 /// The name in a `@JS` attribute's `.withAsync("name")` option, in the arguments or inside an array

package/apple/Sources/ExpoModulesCLI/Commands/ScanModules/ScanModules.swift

@@ -34,19 +34,19 @@ public enum Scanner {
   }
 }
 
-/// One module in the `scan-modules` output. Trimmed to what `expo-modules-autolinking` needs to
-/// register a module: the Swift class name, the JS name it registers under, the platforms that
-/// include it, and the file it's in. The richer fields the visitor captures (declaration kind, raw
-/// macro arguments, line/column) are dropped here — they're redundant for this command (the macro
-/// is always `@ExpoModule` on a class) and the deep `scan-exports` surface carries the richer
-/// per-member detail instead.
-struct ScannedModule: Codable, Equatable {
-  /// The Swift class name the module is declared as.
+/// One class in the `scan-modules` output: an `@ExpoModule` class in `modules`, or a `@SharedObject`
+/// class in `sharedObjects`. Trimmed to what `expo-modules-autolinking` needs to register the class:
+/// the Swift class name, the JS name it registers under, the platforms that include it, and the file
+/// it's in. The richer fields the visitor captures (declaration kind, raw macro arguments,
+/// line/column) are dropped here, because this command doesn't need them (the macro is always on a
+/// class) and the deep `scan-exports` surface carries the richer per-member detail instead.
+struct ScannedClass: Codable, Equatable {
+  /// The Swift class name.
   let name: String
 
-  /// The fully-resolved JS module name: the `@ExpoModule("Foo")` override when present, otherwise the
-  /// class name. Resolved here (rather than left `nil`) so it matches how the macro derives the name
-  /// and the consumer never has to apply the fallback itself.
+  /// The fully-resolved JS name: the `@ExpoModule("Foo")` or `@SharedObject("Foo")` override when
+  /// present, otherwise the class name. Resolved here (rather than left `nil`) so it matches how the
+  /// macro derives the name and the consumer never has to apply the fallback itself.
   let jsName: String
 
   /// The class's spelled access modifier (`open`, `public`, `package`, `fileprivate`, `private`),
@@ -56,20 +56,21 @@ struct ScannedModule: Codable, Equatable {
   let accessLevel: String
 
   /// The Apple OSes whose builds include this class, spelled as `os(...)` spells them and compared
-  /// case-sensitively. An unconditional module lists every OS. Empty means no build is known to
+  /// case-sensitively. An unconditional class lists every OS. Empty means no build is known to
   /// include it, because the enclosing conditions depend on flags not asserted with `--define` or
   /// on conditions a static scan cannot answer (those are reported in `warnings`). The consumer
   /// must not assume such a class exists.
   let platforms: [String]
 
-  /// Source file the module was found in, relative to the path the scanner was invoked with.
+  /// Source file the class was found in, relative to the path the scanner was invoked with.
   let file: String
 }
 
 /// Version of the `scan-modules` output shape. Bumped on any breaking change to the envelope or to
-/// `ScannedModule`, so `expo-modules-autolinking` can verify it understands the output before
+/// `ScannedClass`, so `expo-modules-autolinking` can verify it understands the output before
 /// trusting it (and fall back to config-declared modules when it doesn't). Version 2 added the
-/// per-module `platforms` list and made the module list platform-agnostic.
+/// per-module `platforms` list and made the module list platform-agnostic. A new field that older
+/// consumers can ignore, such as `sharedObjects`, doesn't change the version.
 let scanModulesSchemaVersion = 2
 
 /// The `scan-modules` result: the detected modules plus the stats describing the run. Encoded as the
@@ -77,7 +78,11 @@ let scanModulesSchemaVersion = 2
 /// serve different consumers and don't share an envelope.)
 struct ScanModulesResult: Codable, Equatable {
   let schemaVersion: Int
-  let modules: [ScannedModule]
+  let modules: [ScannedClass]
+
+  /// The top-level `@SharedObject` classes, in the same order and with the same platform rules as
+  /// `modules`.
+  let sharedObjects: [ScannedClass]
 
   /// Warnings for `#if` conditions the scan couldn't answer statically (see `ScanWarning`). Carried
   /// in the report rather than on stderr so the consumer can attach them to its own output.
@@ -97,25 +102,28 @@ private let platformUniverse: [(condition: String, reported: String)] = [
   (condition: "visionOS", reported: "visionOS"),
 ]
 
-/// Scans the given paths for top-level `@ExpoModule` types and returns every module found in any
+/// Scans the given paths for top-level `@ExpoModule` and `@SharedObject` types and returns every one
+/// found in any
 /// `#if` branch (in file then source order), each with the platforms whose builds include it, plus
 /// the stats for the run — the `scan-modules` command. Kept separate from the public entry (and
 /// `internal`) so tests can drive it without going through argv/stdout.
 ///
 /// Each file is parsed once and walked once per platform (plus once unconditionally to enumerate
-/// every module): a module's `platforms` are the OSes whose evaluated walk reached it, given the
+/// every type): a type's `platforms` are the OSes whose evaluated walk reached it, given the
 /// asserted `defines`. The scanner reports the facts; filtering to the platform being linked is the
 /// consumer's call.
 func scanModules(paths: [String], defines: Set<String> = []) -> ScanModulesResult {
-  var modules: [ScannedModule] = []
+  var modules: [ScannedClass] = []
+  var sharedObjects: [ScannedClass] = []
   var warnings: [ScanWarning] = []
   var seenWarnings = Set<ScanWarning>()
 
-  let stats = scanFiles(paths: paths, macros: [.expoModule]) { source, file in
+  let macros: Set<DetectedMacro> = [.expoModule, .sharedObject]
+  let stats = scanFiles(paths: paths, macros: macros) { source, file in
     let tree = Parser.parse(source: source)
 
-    // The unconditional walk enumerates every module in the file, in source order.
-    let allModules = DetectionVisitor(file: file, tree: tree, detectedMacros: [.expoModule], configuration: nil)
+    // The unconditional walk enumerates every type in the file, in source order.
+    let allModules = DetectionVisitor(file: file, tree: tree, detectedMacros: macros, configuration: nil)
     allModules.walk(tree)
 
     // One evaluated walk per OS attributes each module to the platforms that include it. The walks
@@ -126,7 +134,7 @@ func scanModules(paths: [String], defines: Set<String> = []) -> ScanModulesResul
       let visitor = DetectionVisitor(
         file: file,
         tree: tree,
-        detectedMacros: [.expoModule],
+        detectedMacros: macros,
         configuration: configuration
       )
       visitor.walk(tree)
@@ -140,24 +148,30 @@ func scanModules(paths: [String], defines: Set<String> = []) -> ScanModulesResul
       }
     }
 
-    for detection in allModules.detections {
-      // Resolve the JS name the way the macro does: explicit `@ExpoModule("Foo")` override, else
-      // the class name.
-      modules.append(
-        ScannedModule(
-          name: detection.name,
-          jsName: detection.jsName ?? detection.name,
-          accessLevel: detection.accessLevel,
-          platforms: platformsByDetection[detectionKey(detection)] ?? [],
-          file: detection.file
-        )
+    // The macros reject anything but a class, so a struct with one of them is never registered.
+    for detection in allModules.detections where detection.declarationKind == "class" {
+      // Resolve the JS name the way the macro does: explicit `@ExpoModule("Foo")` or
+      // `@SharedObject("Foo")` override, else the class name.
+      let scanned = ScannedClass(
+        name: detection.name,
+        jsName: detection.jsName ?? detection.name,
+        accessLevel: detection.accessLevel,
+        platforms: platformsByDetection[detectionKey(detection)] ?? [],
+        file: detection.file
       )
+      switch detection.macro {
+      case .sharedObject:
+        sharedObjects.append(scanned)
+      default:
+        modules.append(scanned)
+      }
     }
   }
 
   return ScanModulesResult(
     schemaVersion: scanModulesSchemaVersion,
     modules: modules,
+    sharedObjects: sharedObjects,
     warnings: warnings,
     stats: stats
   )