expo-modules-macros 0.28.0 → 0.30.0

package/apple/Sources/ExpoModulesCLI/Commands/Expand/ExpandReport.swift

@@ -67,13 +67,29 @@ public struct ExpansionDiagnostic: Codable, Equatable, Sendable {
   /// The messages of the Fix-Its, for example `replace 'var' with 'let'`.
   public let fixIts: [String]
 
+  /// The edits of each Fix-It in `fixIts`, in the original file, for `fix`. The edits of a Fix-It are
+  /// empty when they aren't in the original file, and this is empty for a diagnostic whose Fix-Its
+  /// `fix` doesn't apply, such as a syntax error. Not part of the JSON report, nor of equality, so a
+  /// diagnostic is equal to itself after a JSON round trip.
+  public var fixItEdits: [[ExpansionEdit]] = []
+
+  private enum CodingKeys: String, CodingKey {
+    case severity, message, line, column, notes, fixIts
+  }
+
+  public static func == (lhs: Self, rhs: Self) -> Bool {
+    lhs.severity == rhs.severity && lhs.message == rhs.message && lhs.line == rhs.line
+      && lhs.column == rhs.column && lhs.notes == rhs.notes && lhs.fixIts == rhs.fixIts
+  }
+
   public init(
     severity: Severity,
     message: String,
     line: Int,
     column: Int,
     notes: [ExpansionNote] = [],
-    fixIts: [String] = []
+    fixIts: [String] = [],
+    fixItEdits: [[ExpansionEdit]] = []
   ) {
     self.severity = severity
     self.message = message
@@ -81,6 +97,26 @@ public struct ExpansionDiagnostic: Codable, Equatable, Sendable {
     self.column = column
     self.notes = notes
     self.fixIts = fixIts
+    self.fixItEdits = fixItEdits
+  }
+}
+
+/// A change of one range of the original file: `original`, which starts at `offset`, becomes
+/// `replacement`.
+public struct ExpansionEdit: Equatable, Sendable {
+  /// The UTF-8 offset in the original file.
+  public let offset: Int
+
+  /// The text that the edit replaces, so `fix` can check that the file still has it there. Empty
+  /// for an insertion.
+  public let original: String
+
+  public let replacement: String
+
+  public init(offset: Int, original: String, replacement: String) {
+    self.offset = offset
+    self.original = original
+    self.replacement = replacement
   }
 }
 

package/apple/Sources/{ExpoModulesMacros → ExpoModulesCLI/Commands}/Expand/MacroExpander.swift

@@ -1,4 +1,4 @@
-import ExpoModulesCLI
+import ExpoModulesMacrosCore
 import SwiftBasicFormat
 import SwiftDiagnostics
 import SwiftParser
@@ -34,13 +34,18 @@ public func expandMacros(source: String, file: String, symbols: [String]) -> Exp
   }
   let originalDeclarations = OriginalDeclarations(tree)
   diagnostics += context.diagnostics.map { diagnostic in
-    expansionDiagnostic(diagnostic) { position, node in
-      let location = context.location(for: position, anchoredAt: node, fileName: file)
-      if let original = originalDeclarations.position(of: position, in: node, shiftedOffset: location.offset) {
+    let location = { (position: AbsolutePosition, node: Syntax) -> SourceLocation in
+      let declarationStart = context.location(for: node.root.position, anchoredAt: node, fileName: file).offset
+      if let original = originalDeclarations.position(of: position, in: node, declarationStart: declarationStart) {
         return converter.location(for: original)
       }
-      return location
+      return context.location(for: position, anchoredAt: node, fileName: file)
     }
+    var result = expansionDiagnostic(diagnostic, location: location)
+    result.fixItEdits = diagnostic.fixIts.map { fixIt in
+      originalEdits(of: fixIt) { location($0, $1).offset } ?? []
+    }
+    return result
   }
   diagnostics.sort { ($0.line, $0.column) < ($1.line, $1.column) }
 
@@ -203,6 +208,93 @@ private func expansionDiagnostic(
   )
 }
 
+/// The edits of `fixIt` in the original file, or `nil` when one of them isn't in the tree of the node
+/// that it changes. `offset` maps a position in the tree of a node to its UTF-8 offset in the original
+/// file.
+///
+/// A Fix-It that replaces a node replaces all of it, but the tree that a macro gets isn't always the
+/// original declaration: in a module, a `@JS` member also has the attributes that `@ExpoModule` adds.
+/// So each edit is reduced to the bytes that it changes, for example the `async ` that it inserts
+/// into a signature, which are in the original file too. The macro system detaches the attribute
+/// from the declaration, so a change has its own tree, which can differ from the diagnostic's.
+private func originalEdits(
+  of fixIt: FixIt,
+  offset: (AbsolutePosition, Syntax) -> Int
+) -> [ExpansionEdit]? {
+  var edits: [ExpansionEdit] = []
+  for change in fixIt.changes {
+    // `FixIt.edits` drops an edit that overlaps an earlier one; this applies the same rule.
+    guard let edit = FixIt(message: fixIt.message, changes: [change]).edits.first else {
+      continue
+    }
+    let node = changedNode(change)
+    let root = node.root
+    let text = Array(root.description.utf8)
+    let start = edit.range.lowerBound.utf8Offset - root.position.utf8Offset
+    let end = edit.range.upperBound.utf8Offset - root.position.utf8Offset
+    guard 0 <= start, start <= end, end <= text.count else {
+      return nil
+    }
+    let old = text[start..<end]
+    let new = Array(edit.replacement.utf8)
+    let (prefix, suffix) = commonAffixLengths(Array(old), new)
+    guard prefix + suffix < max(old.count, new.count) else {
+      continue
+    }
+    let changedStart = edit.range.lowerBound.advanced(by: prefix)
+    let originalEdit = ExpansionEdit(
+      offset: offset(changedStart, node),
+      original: String(decoding: old.dropFirst(prefix).dropLast(suffix), as: UTF8.self),
+      replacement: String(decoding: new.dropFirst(prefix).dropLast(suffix), as: UTF8.self)
+    )
+    if !edits.contains(where: { overlaps($0, originalEdit) }) {
+      edits.append(originalEdit)
+    }
+  }
+  return edits
+}
+
+/// The node in the tree that `change` edits.
+private func changedNode(_ change: FixIt.Change) -> Syntax {
+  switch change {
+  case .replace(let oldNode, _):
+    oldNode
+  case .replaceLeadingTrivia(let token, _), .replaceTrailingTrivia(let token, _):
+    Syntax(token)
+  case .replaceChild(let data):
+    Syntax(data.parent)
+  case .replaceText(_, _, let node):
+    node
+  }
+}
+
+/// Whether two edits change the same bytes of the original file.
+private func overlaps(_ a: ExpansionEdit, _ b: ExpansionEdit) -> Bool {
+  a.offset < b.offset + b.original.utf8.count && b.offset < a.offset + a.original.utf8.count
+}
+
+/// The lengths of the longest common prefix and suffix of `old` and `new` that don't overlap, at
+/// character boundaries, so the bytes between them are valid UTF-8 on both sides.
+private func commonAffixLengths(_ old: [UInt8], _ new: [UInt8]) -> (prefix: Int, suffix: Int) {
+  let isContinuation = { (bytes: [UInt8], index: Int) in index < bytes.count && bytes[index] & 0xC0 == 0x80 }
+  let shorter = min(old.count, new.count)
+  var prefix = 0
+  while prefix < shorter && old[prefix] == new[prefix] {
+    prefix += 1
+  }
+  while prefix > 0 && (isContinuation(old, prefix) || isContinuation(new, prefix)) {
+    prefix -= 1
+  }
+  var suffix = 0
+  while suffix < shorter - prefix && old[old.count - 1 - suffix] == new[new.count - 1 - suffix] {
+    suffix += 1
+  }
+  while suffix > 0 && (isContinuation(old, old.count - suffix) || isContinuation(new, new.count - suffix)) {
+    suffix -= 1
+  }
+  return (prefix, suffix)
+}
+
 private func severity(_ severity: DiagnosticSeverity) -> ExpansionDiagnostic.Severity {
   switch severity {
   case .error: .error
@@ -223,51 +315,50 @@ private func severity(_ severity: DiagnosticSeverity) -> ExpansionDiagnostic.Sev
 /// every position after the added attributes is off by their length. A diagnostic in a parameter
 /// type of a `@JS` function would be on the next line.
 ///
-/// The text from the keyword of the declaration (`func`, `var`, `init`) to its end is the same in
-/// both, so this finds the original declaration by that text and moves the position by the offset of
-/// the keyword. A position before the keyword, in the attributes or the modifiers, isn't mapped.
+/// The start of the declaration is before the added attributes, so the macro system maps it to the
+/// start of the original declaration. The text from the keyword of the declaration (`func`, `var`,
+/// `init`) to its end is the same in both, so this moves the position by the offset of the keyword
+/// in the original declaration. A position before the keyword, in the attributes or the modifiers,
+/// isn't mapped.
 private struct OriginalDeclarations {
-  /// The positions of the keywords of the declarations in the original file, in source order, by the
-  /// text from the keyword to the end of the declaration.
-  private let keywordPositions: [String: [AbsolutePosition]]
+  /// The declarations in the original file by the UTF-8 offset of their start, with their leading
+  /// trivia: the text from the keyword to the end of each, and the position of its keyword.
+  private let declarations: [Int: [(text: String, keyword: AbsolutePosition)]]
 
   init(_ tree: SourceFileSyntax) {
     let collector = DeclarationCollector(viewMode: .sourceAccurate)
     collector.walk(tree)
-    var keywordPositions: [String: [AbsolutePosition]] = [:]
+    var declarations: [Int: [(text: String, keyword: AbsolutePosition)]] = [:]
     for declaration in collector.declarations {
       guard let keyword = keywordToken(of: declaration) else {
         continue
       }
-      keywordPositions[textFromKeyword(keyword, of: declaration), default: []].append(
-        keyword.positionAfterSkippingLeadingTrivia
+      declarations[declaration.position.utf8Offset, default: []].append(
+        (textFromKeyword(keyword, of: declaration), keyword.positionAfterSkippingLeadingTrivia)
       )
     }
-    self.keywordPositions = keywordPositions
+    self.declarations = declarations
   }
 
   /// The position in the original file of `position` in `node`, or `nil` when `node` is in the
-  /// original file, isn't in a detached declaration, or is before its keyword.
+  /// original file, isn't in a detached declaration, is before its keyword, or no declaration with its
+  /// text starts at `declarationStart`.
   ///
-  /// `shiftedOffset` is the offset that the macro system maps `position` to. The added attributes
-  /// only move it forward, so when declarations with the same text are in the file, the one it is
-  /// in is the last one that starts at or before that offset.
-  func position(of position: AbsolutePosition, in node: Syntax, shiftedOffset: Int) -> AbsolutePosition? {
+  /// `declarationStart` is the offset that the macro system maps the start of the detached
+  /// declaration to.
+  func position(of position: AbsolutePosition, in node: Syntax, declarationStart: Int) -> AbsolutePosition? {
     guard !node.root.is(SourceFileSyntax.self),
       let declaration = node.root.as(DeclSyntax.self),
       let keyword = keywordToken(of: declaration),
       position >= keyword.positionAfterSkippingLeadingTrivia,
-      let candidates = keywordPositions[textFromKeyword(keyword, of: declaration)]
+      let original = declarations[declarationStart]?.first(where: {
+        $0.text == textFromKeyword(keyword, of: declaration)
+      })
     else {
       return nil
     }
     let offset = position.utf8Offset - keyword.positionAfterSkippingLeadingTrivia.utf8Offset
-    let shiftedKeyword = shiftedOffset - offset
-    guard let originalKeyword = candidates.last(where: { $0.utf8Offset <= shiftedKeyword }) ?? candidates.first
-    else {
-      return nil
-    }
-    return AbsolutePosition(utf8Offset: originalKeyword.utf8Offset + offset)
+    return AbsolutePosition(utf8Offset: original.keyword.utf8Offset + offset)
   }
 }
 

package/apple/Sources/ExpoModulesCLI/Commands/Expand/RunExpand.swift

@@ -75,6 +75,23 @@ struct ExpandInputError: Error, Equatable {
 /// and only the files that use one of the macros are expanded, with their absolute paths. A file that
 /// a directory also contains is expanded once.
 func expandFiles(options: ExpandOptions, expander: MacroExpander) -> Result<ExpandResult, ExpandInputError> {
+  expandSources(options: options, expander: expander).map { sources in
+    let files = sources.map(\.expanded)
+    return ExpandResult(
+      schemaVersion: expandSchemaVersion,
+      files: options.diagnosticsOnly
+        ? files.map { ExpandedFile(file: $0.file, expansions: [], diagnostics: $0.diagnostics) }
+        : files
+    )
+  }
+}
+
+/// The files of `options` with their sources, expanded with `expander`, as `expandFiles` describes.
+/// `fix` uses it too, because it edits the sources.
+func expandSources(
+  options: ExpandOptions,
+  expander: MacroExpander
+) -> Result<[(source: String, expanded: ExpandedFile)], ExpandInputError> {
   let prefilter = MacroPrefilter(attributeNames: expander.attributeNames)
   var sources: [(file: String, source: String)] = []
   var seen: Set<String> = []
@@ -107,9 +124,9 @@ func expandFiles(options: ExpandOptions, expander: MacroExpander) -> Result<Expa
     }
   }
 
-  let files = sources.map { expander.expand($0.source, $0.file, options.symbols) }
+  let files = sources.map { (source: $0.source, expanded: expander.expand($0.source, $0.file, options.symbols)) }
 
-  let found = Set(files.flatMap { $0.expansions.compactMap(\.symbol) })
+  let found = Set(files.flatMap { $0.expanded.expansions.compactMap(\.symbol) })
   if let missing = options.symbols.first(where: { !found.contains($0) }) {
     return .failure(
       ExpandInputError(
@@ -119,14 +136,7 @@ func expandFiles(options: ExpandOptions, expander: MacroExpander) -> Result<Expa
     )
   }
 
-  return .success(
-    ExpandResult(
-      schemaVersion: expandSchemaVersion,
-      files: options.diagnosticsOnly
-        ? files.map { ExpandedFile(file: $0.file, expansions: [], diagnostics: $0.diagnostics) }
-        : files
-    )
-  )
+  return .success(files)
 }
 
 /// The expanded sources as text. A single expansion is printed as it is; more than one each get a

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

@@ -0,0 +1,228 @@
+#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 the last pass still applied a
+  /// Fix-It, so the source can have more.
+  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.
+  static func runFix(options: FixOptions, expander: MacroExpander) -> Int32 {
+    let sources: [(source: String, 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 failed = false
+    for (source, 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 {
+          try writeSource(fixed.source, toFile: expanded.file)
+        } catch {
+          writeToStandardError("error: could not write '\(expanded.file)': \(error)\n")
+          failed = true
+          continue
+        }
+      }
+      writeToStandardOutput(renderAppliedFixIts(fixed, file: expanded.file))
+      appliedCount += fixed.applied.count
+      fixedFiles += 1
+    }
+
+    writeToStandardOutput(renderFixSummary(applied: appliedCount, files: fixedFiles, dryRun: options.dryRun))
+    return failed ? 1 : 0
+  }
+}
+
+/// Writes `source` to the file at `path` in place, so a symbolic link keeps pointing to the file and a
+/// hard link keeps sharing it, and a writable file can be written in a read-only directory. Keeps the
+/// UTF-8 byte order mark of the file, which the source doesn't have because reading it as a `String`
+/// removes it.
+func writeSource(_ source: String, toFile path: String) throws {
+  let url = URL(fileURLWithPath: path)
+  let byteOrderMark: [UInt8] = [0xEF, 0xBB, 0xBF]
+  let hasByteOrderMark = try Data(contentsOf: url).starts(with: byteOrderMark)
+  try Data((hasByteOrderMark ? byteOrderMark : []) + Array(source.utf8)).write(to: url)
+}
+
+/// 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
+  }
+  return FixedSource(
+    source: fixed.source,
+    fixIts: applied + fixed.fixIts.filter { $0.skipReason != nil },
+    reachedPassLimit: !fixed.applied.isEmpty
+  )
+}
+
+/// 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.`
+func renderFixSummary(applied: Int, files: Int, dryRun: Bool) -> String {
+  guard applied > 0 else {
+    return "No Fix-Its to apply.\n"
+  }
+  let fixIts = "\(applied) Fix-It\(applied == 1 ? "" : "s")"
+  let fileCount = "\(files) file\(files == 1 ? "" : "s")"
+  return "\(dryRun ? "Would apply" : "Applied") \(fixIts) in \(fileCount).\n"
+}

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

@@ -207,7 +207,7 @@ 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.
+  /// `@Event(.sync)`, dispatching inline on the JS thread instead of scheduling.
   let isSync: Bool
 
   /// The spelled access modifier, or `nil` when none is written.

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

@@ -285,7 +285,7 @@ final class SurfaceVisitor: SyntaxVisitor {
       return []
     }
     let override = stringArgument(of: attribute)
-    let isSync = boolArgument(of: attribute, label: "sync") == true
+    let isSync = hasEventOption(attribute, named: "sync")
     var result: [ExportedEvent] = []
 
     for binding in varDecl.bindings {
@@ -704,18 +704,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(.sync)` or
+/// `@Event("name", EventOptions.sync)`). 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