expo-modules-macros 0.28.0 → 0.30.0

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
   )

package/apple/Sources/ExpoModulesMacros/main.swift

@@ -0,0 +1,6 @@
+import ExpoModulesMacrosCore
+
+// The plugin executable that SwiftPM builds for the packages that depend on the
+// `ExpoModulesMacrosPlugin` product. It only serves the macros, so it doesn't link the CLI; the
+// binary that this package ships is `ExpoModulesMacrosTool`, which does both.
+try runPluginServer()

package/apple/Sources/{ExpoModulesMacros → ExpoModulesMacrosCore}/Macros/EventMacro.swift

@@ -32,7 +32,7 @@ import SwiftSyntaxMacros
 /// also self-contained: `@ExpoModule`/`@SharedObject` neither collect `@Event` members nor register
 /// their names anywhere.
 ///
-/// `@Event(sync: true)` opts into **synchronous dispatch**: the closure calls `emitSync` (inline
+/// `@Event(.sync)` opts into **synchronous dispatch**: the closure calls `emitSync` (inline
 /// conversion + dispatch, no scheduling) instead of `emit`, and `@ExpoModule`/`@SharedObject` stamp
 /// the member `@JavaScriptActor` so the compiler forces the call site onto the JS thread, the
 /// inverse of the async default. The isolation is on the property access, so it guards the inline
@@ -127,7 +127,7 @@ private struct EventMember {
   let jsName: String
   /// The payload type as written, or `nil` for a no-payload `() -> Void` event.
   let payloadType: String?
-  /// Whether the event dispatches synchronously (`@Event(sync: true)`) via `emitSync`.
+  /// Whether the event dispatches synchronously (`@Event(.sync)`) via `emitSync`.
   let isSync: Bool
 
   var hasPayload: Bool {
@@ -212,7 +212,7 @@ private func validatedEvent(
     swiftName: swiftName,
     jsName: jsNameArgument(of: node) ?? defaultEventName(for: withoutBackticks(swiftName)),
     payloadType: functionType.parameters.first?.type.trimmedDescription,
-    isSync: boolArgument(of: node, label: "sync") == true
+    isSync: hasOption(node, named: "sync")
   )
 }
 

package/apple/Sources/{ExpoModulesMacros → ExpoModulesMacrosCore}/Macros/ExpoModuleMacro.swift

@@ -38,6 +38,13 @@ public struct ExpoModuleMacro: MemberMacro {
     guard let classDecl = declaration.as(ClassDeclSyntax.self) else {
       throw MacroExpansionErrorMessage("@ExpoModule can only be applied to a class")
     }
+    diagnoseNonPublicClass(
+      classDecl,
+      macroName: "@ExpoModule",
+      reason: "register it",
+      idPrefix: "expomodule",
+      in: context
+    )
 
     // The module name is fully resolved here (the explicit `@ExpoModule("…")` argument, else the
     // class name) and emitted as a non-optional `_jsName` static below — so the
@@ -160,7 +167,7 @@ extension ExpoModuleMacro: MemberAttributeMacro {
     // checked at compile time. Skipped when the member already chose an isolation
     // (`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
+    // `@Event(.sync)` 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),

package/apple/Sources/{ExpoModulesMacros → ExpoModulesMacrosCore}/Macros/JSMacro.swift

@@ -36,6 +36,7 @@ public struct JSMacro: PeerMacro {
     diagnoseClosureTypes(in: declaration, in: context)
     diagnoseConcurrentOption(of: node, on: declaration, in: context)
     diagnoseAsyncVariantOption(of: node, on: declaration, in: context)
+    diagnoseJavaScriptValuesOffThread(of: node, on: declaration, in: context)
 
     // In an `@ExpoModule` or `@SharedObject` class, the class macro emits the assertion instead: it sees
     // the type aliases declared in the class body, which this macro can't (see `TupleTypeAliases`).
@@ -83,7 +84,7 @@ private func diagnoseConcurrentOption(
   on declaration: some DeclSyntaxProtocol,
   in context: some MacroExpansionContext
 ) {
-  guard hasJSOption(node, named: "concurrent") else {
+  guard hasOption(node, named: "concurrent") else {
     return
   }
   if let funcDecl = declaration.as(FunctionDeclSyntax.self) {
@@ -248,6 +249,58 @@ private func insertAsyncFixIt(for funcDecl: FunctionDeclSyntax) -> FixIt {
 /// `consuming`, `sending`) are fine: the binding passes the decoded value under whichever convention
 /// the parameter asks for. The specifier is left off the decode and the assertion (see
 /// `SpecifiedType`); a parameter reported here is also left out of the assertion.
+/// The JSI types that own an engine value and release it wherever they are dropped. Such a value is
+/// valid only on the JavaScript thread. `JavaScriptPromise` releases its value on the JavaScript
+/// thread, and `JavaScriptRef` and `JavaScriptCallback` exist to carry a value across threads, so they
+/// aren't listed.
+private let javaScriptThreadBoundTypes: Set<String> = [
+  "JavaScriptValue", "JavaScriptObject", "JavaScriptFunction", "JavaScriptArray", "JavaScriptArrayBuffer",
+  "JavaScriptTypedArray", "JavaScriptBigInt", "JavaScriptWeakObject",
+]
+
+/// Emits the diagnostic for a JSI value parameter of a `@JS(.concurrent)` function or of the variant
+/// that `@JS(.withAsync("name"))` adds. Both run the body on the concurrent thread pool, never on the
+/// JavaScript thread, so the body can't use the value, and the value is released off the JavaScript
+/// thread too.
+private func diagnoseJavaScriptValuesOffThread(
+  of node: AttributeSyntax,
+  on declaration: some DeclSyntaxProtocol,
+  in context: some MacroExpansionContext
+) {
+  guard let funcDecl = declaration.as(FunctionDeclSyntax.self) else {
+    return
+  }
+  let option: String
+  let reason: String
+  if hasOption(node, named: "concurrent") {
+    option = ".concurrent"
+    reason = "'.concurrent' runs the body on the concurrent thread pool"
+  } else if asyncVariantOption(of: node) != nil {
+    option = ".withAsync"
+    reason = "the variant that '.withAsync' adds runs the function on the concurrent thread pool"
+  } else {
+    return
+  }
+  for parameter in funcDecl.signature.parameterClause.parameters {
+    let type = SpecifiedType(parameter.type).type
+    guard let name = baseIdentifier(of: optionalWrappedType(type) ?? type), javaScriptThreadBoundTypes.contains(name)
+    else {
+      continue
+    }
+    let parameterName = (parameter.secondName ?? parameter.firstName).text
+    context.diagnose(
+      Diagnostic(
+        node: parameter.type,
+        message: JSDiagnosticMessage(
+          "'\(parameterName)' can't be a '\(name)' in a '\(option)' function: \(reason), and a JavaScript value is valid only on the JavaScript thread. Take a native type that the value decodes to, such as a @Record or [String: Any], or remove '\(option)'.",
+          id: "js-javascript-value-off-thread",
+          severity: .error
+        )
+      )
+    )
+  }
+}
+
 private func diagnoseParameterSpecifiers(
   in declaration: some DeclSyntaxProtocol,
   in context: some MacroExpansionContext

package/apple/Sources/{ExpoModulesMacros → ExpoModulesMacrosCore}/Macros/SharedObjectMacro.swift

@@ -8,7 +8,7 @@ import SwiftSyntaxMacros
 /// is emitted as a `_jsName` override.
 ///
 ///   @SharedObject
-///   final class Cache: SharedObject {
+///   public final class Cache: SharedObject {
 ///     @JS
 ///     init(name: String) { self.name = name }
 ///
@@ -34,6 +34,13 @@ public struct SharedObjectMacro: MemberMacro {
     guard let classDecl = declaration.as(ClassDeclSyntax.self) else {
       throw MacroExpansionErrorMessage("@SharedObject can only be applied to a class")
     }
+    diagnoseNonPublicClass(
+      classDecl,
+      macroName: "@SharedObject",
+      reason: "export it",
+      idPrefix: "sharedobject",
+      in: context
+    )
 
     // The superclass isn't checked here: the macro sees only this declaration, so it can't tell an
     // indirect subclass (`class Thumbnail: ImageRef`) from an unrelated class. The compiler reports a
@@ -164,7 +171,7 @@ extension SharedObjectMacro: MemberAttributeMacro {
     providingAttributesFor member: some DeclSyntaxProtocol,
     in context: some MacroExpansionContext
   ) throws -> [AttributeSyntax] {
-    // `@Event(sync: true)` members are stamped alongside `@JS` ones: a sync event dispatches
+    // `@Event(.sync)` members are stamped alongside `@JS` ones: a sync event dispatches
     // inline, so the isolation forces its call site onto the JS thread. Async events (the
     // default) stay unstamped — their `emit` schedules onto the JS thread itself.
     guard memberHasJSAttribute(member) || isSyncEventMember(member) else {

package/apple/Sources/{ExpoModulesMacros → ExpoModulesMacrosCore}/Macros/ViewPropsMacro.swift

@@ -139,23 +139,37 @@ private func fieldAttributeDiagnostic(
   for attribute: AttributeSyntax,
   on varDecl: VariableDeclSyntax
 ) -> Diagnostic {
-  // Rebuild the attribute list without this entry, so the fix-it removes the attribute and the
-  // trivia it carried rather than leaving a blank line behind.
-  var attributes = varDecl.attributes
-  if let index = attributes.firstIndex(where: { element in
+  // The token after the attribute takes over the trivia of the attribute: the line break,
+  // indentation and comments before it, and the comments after it. Its own leading whitespace is
+  // left out unless a comment comes before it, so `@Field var size` and `@Field` on its own line both
+  // become `var size` on the line of the attribute, and `@Field // note` keeps the line break after
+  // the comment.
+  var newDecl = varDecl
+  if let next = attribute.lastToken(viewMode: .sourceAccurate)?.nextToken(viewMode: .sourceAccurate) {
+    let comments = Trivia(pieces: attribute.trailingTrivia.pieces.drop(while: \.isWhitespace))
+    let nextTrivia =
+      comments.isEmpty ? Trivia(pieces: next.leadingTrivia.pieces.drop(while: \.isWhitespace)) : next.leadingTrivia
+    newDecl =
+      LeadingTriviaRewriter(token: next.id, trivia: attribute.leadingTrivia + comments + nextTrivia)
+      .rewrite(varDecl).cast(VariableDeclSyntax.self)
+  }
+  // Then remove the attribute with its trivia, so it doesn't leave a blank line behind. The rewritten
+  // declaration is a new tree, so the attribute is found by its place in the list.
+  if let index = varDecl.attributes.firstIndex(where: { element in
     guard case .attribute(let candidate) = element else {
       return false
     }
     return candidate == attribute
   }) {
-    attributes.remove(at: index)
+    let offset = varDecl.attributes.distance(from: varDecl.attributes.startIndex, to: index)
+    newDecl.attributes.remove(at: newDecl.attributes.index(newDecl.attributes.startIndex, offsetBy: offset))
   }
   let fixIt = FixIt(
     message: ViewPropsFixItMessage("Remove the '@Field' attribute", id: "viewprops-remove-field"),
     changes: [
       .replace(
         oldNode: Syntax(varDecl),
-        newNode: Syntax(varDecl.with(\.attributes, attributes))
+        newNode: Syntax(newDecl)
       )
     ]
   )
@@ -166,6 +180,22 @@ private func fieldAttributeDiagnostic(
   return Diagnostic(node: attribute, message: message, fixIts: [fixIt])
 }
 
+/// Replaces the leading trivia of one token.
+private final class LeadingTriviaRewriter: SyntaxRewriter {
+  private let token: SyntaxIdentifier
+  private let trivia: Trivia
+
+  init(token: SyntaxIdentifier, trivia: Trivia) {
+    self.token = token
+    self.trivia = trivia
+    super.init(viewMode: .sourceAccurate)
+  }
+
+  override func visit(_ token: TokenSyntax) -> TokenSyntax {
+    token.id == self.token ? token.with(\.leadingTrivia, trivia) : token
+  }
+}
+
 /// The error for an optional event prop, attached to the declared type and carrying a fix-it that
 /// unwraps it. Events are registered once at view creation from a static name list, so there is no
 /// shape that could express "sometimes emitted".

package/apple/Sources/ExpoModulesMacrosCore/PluginServer.swift

@@ -0,0 +1,40 @@
+@_spi(PluginMessage) import SwiftCompilerPluginMessageHandling
+import SwiftSyntaxMacros
+
+/// The module name that `expo-modules-core` passes to `#externalMacro`, and the name of the macro
+/// target that SwiftPM loads as the plugin.
+private let pluginModuleName = "ExpoModulesMacros"
+
+/// Runs the compiler plugin server on stdin and stdout until the compiler closes the connection.
+///
+/// `CompilerPlugin.main()` finds a macro by comparing `String(reflecting:)` of each type with
+/// `<module>.<type>` from `#externalMacro`. The macro types live in this module, not in a module
+/// named `ExpoModulesMacros`, so both executables that serve the plugin (the SwiftPM macro target and
+/// the shipped tool) use this provider, which matches the type name under the plugin module name.
+public func runPluginServer() throws {
+  let connection = try StandardIOMessageConnection()
+  let listener = CompilerPluginMessageListener(connection: connection, provider: ProvidedMacroProvider())
+  try listener.main()
+}
+
+private struct ProvidedMacroProvider: PluginProvider {
+  let macros: [String: Macro.Type] = Dictionary(
+    uniqueKeysWithValues: ProvidedMacro.all.map { (String(describing: $0.type), $0.type) }
+  )
+
+  func resolveMacro(moduleName: String, typeName: String) throws -> Macro.Type {
+    guard moduleName == pluginModuleName, let type = macros[typeName] else {
+      throw UnknownMacroError(moduleName: moduleName, typeName: typeName)
+    }
+    return type
+  }
+}
+
+private struct UnknownMacroError: Error, CustomStringConvertible {
+  let moduleName: String
+  let typeName: String
+
+  var description: String {
+    "macro implementation type '\(moduleName).\(typeName)' could not be found in the Expo Modules macro plugin"
+  }
+}

package/apple/Sources/{ExpoModulesMacros → ExpoModulesMacrosCore}/ProvidedMacros.swift

@@ -3,15 +3,15 @@ import SwiftSyntaxMacros
 
 /// A macro that the plugin provides, with the attribute name and the extension conformances of its
 /// declaration in `expo-modules-core`.
-struct ProvidedMacro {
-  let name: String
-  let type: Macro.Type
-  var conformances: [TypeSyntax] = []
+public struct ProvidedMacro {
+  public let name: String
+  public let type: Macro.Type
+  public var conformances: [TypeSyntax] = []
 
   /// Every macro of the plugin. The compiler gets the types from `providingMacros`, and `expand`
   /// matches the attributes by name and passes the same conformances as the compiler, so both read
   /// this list.
-  static var all: [ProvidedMacro] {
+  public static var all: [ProvidedMacro] {
     [
       ProvidedMacro(name: "OptimizedFunction", type: OptimizedFunctionAttachedMacro.self),
       ProvidedMacro(name: "JS", type: JSMacro.self),

package/apple/Sources/{ExpoModulesMacros → ExpoModulesMacrosCore}/Support/MacroHelpers.swift

@@ -13,26 +13,12 @@ internal func jsNameArgument(of attribute: AttributeSyntax) -> String? {
   return segment.content.text
 }
 
-/// Reads a labeled boolean-literal argument of an attribute, e.g. `@Event(sync: true)` -> true.
-/// Returns nil if the attribute has no argument with that label or its value isn't a boolean literal.
-internal func boolArgument(of attribute: AttributeSyntax, label: String) -> Bool? {
-  guard let args = attribute.arguments?.as(LabeledExprListSyntax.self) else {
-    return nil
-  }
-  for arg in args where arg.label?.text == label {
-    guard let literal = arg.expression.as(BooleanLiteralExprSyntax.self) else {
-      return nil
-    }
-    return literal.literal.tokenKind == .keyword(.true)
-  }
-  return nil
-}
-
-/// True if the attribute lists the given `JSOptions` member, e.g. `@JS(.concurrent)` or
-/// `@JS("name", [.concurrent])` -> true for "concurrent". Options are written as member-access
-/// expressions (`.concurrent`), optionally inside an array literal when more than one is combined, so
-/// both spellings are scanned. The leading string literal, when present, is the JS name and is skipped.
-internal func hasJSOption(_ attribute: AttributeSyntax, named option: String) -> Bool {
+/// True if the attribute lists the given option member, e.g. `@JS(.concurrent)`, `@Event(.sync)` or
+/// `@Event("name", EventOptions.sync)` -> true for the matching name. Options are written as
+/// member-access expressions, one per variadic argument. Array literals are scanned too, though the
+/// variadic declarations in `expo-modules-core` don't accept them. The leading string literal, when
+/// present, is the JS name and is skipped.
+internal func hasOption(_ attribute: AttributeSyntax, named option: String) -> Bool {
   guard let args = attribute.arguments?.as(LabeledExprListSyntax.self) else {
     return false
   }
@@ -49,7 +35,7 @@ internal func hasJSOption(_ attribute: AttributeSyntax, named option: String) ->
   return false
 }
 
-/// True when the expression is the member access `.<option>` (or `JSOptions.<option>`).
+/// True when the expression is the member access `.<option>` (or `JSOptions.<option>`, `EventOptions.<option>`).
 private func namesOption(_ expression: ExprSyntax, _ option: String) -> Bool {
   guard let member = expression.as(MemberAccessExprSyntax.self) else {
     return false
@@ -64,7 +50,7 @@ internal func isConcurrentJSMember(_ decl: DeclSyntaxProtocol) -> Bool {
   guard let attribute = memberAttributes(of: decl).firstAttribute(named: "JS") else {
     return false
   }
-  return hasJSOption(attribute, named: "concurrent")
+  return hasOption(attribute, named: "concurrent")
 }
 
 /// The `.withAsync("name")` option of a `@JS` attribute, e.g. `@JS(.withAsync("loadAsync"))` or
@@ -74,7 +60,7 @@ internal func asyncVariantOption(of attribute: AttributeSyntax) -> FunctionCallE
   return asyncVariantOptions(of: attribute).first
 }
 
-/// Every `.withAsync(...)` option of a `@JS` attribute, in source order. Like `hasJSOption`, it scans
+/// Every `.withAsync(...)` option of a `@JS` attribute, in source order. Like `hasOption`, it scans
 /// the arguments and the elements of an array literal.
 internal func asyncVariantOptions(of attribute: AttributeSyntax) -> [FunctionCallExprSyntax] {
   guard let args = attribute.arguments?.as(LabeledExprListSyntax.self) else {
@@ -290,7 +276,7 @@ internal func hasDefaultValue(_ parameter: FunctionParameterSyntax) -> Bool {
   return parameter.defaultValue != nil
 }
 
-/// True if the declaration is a `@Event(sync: true)` property. A sync event dispatches inline on the
+/// True if the declaration is a `@Event(.sync)` property. A sync event dispatches inline on the
 /// JS thread instead of scheduling, so `@ExpoModule`/`@SharedObject` stamp it with `@JavaScriptActor`,
 /// making "must be called on the JS thread" a compile-time guarantee at the call site. Async events
 /// (the default) are deliberately not stamped: their `emit` schedules onto the JS thread itself, so
@@ -301,7 +287,7 @@ internal func isSyncEventMember(_ decl: DeclSyntaxProtocol) -> Bool {
   else {
     return false
   }
-  return boolArgument(of: attribute, label: "sync") == true
+  return hasOption(attribute, named: "sync")
 }
 
 /// Reads a labeled array-literal argument of an attribute, e.g. `@ExpoModule(classes: [Foo.self, Bar.self])`,
@@ -524,7 +510,7 @@ internal func encodeCall(_ type: String, freeForm: FreeFormConversion?, of value
 /// `name` without the backticks that escape it: `` `default` `` becomes `default`. Swift needs the
 /// backticks in every identifier position, but a name JavaScript sees (a JS member name, an event
 /// name, a record key) is the bare name.
-internal func withoutBackticks(_ name: String) -> String {
+public func withoutBackticks(_ name: String) -> String {
   var name = Substring(name)
   while name.first == "`" {
     name.removeFirst()

package/apple/Sources/ExpoModulesMacrosCore/Support/PublicAccess.swift

@@ -0,0 +1,105 @@
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxMacros
+
+/// Warns when a class that autolinking exports isn't `public` or `open`. Autolinking generates the modules
+/// provider in the app target, so it can reference only public classes of other modules. The warning has a
+/// fix-it that makes the class `public`. A local class is skipped, because it can't have an access modifier.
+internal func diagnoseNonPublicClass(
+  _ classDecl: ClassDeclSyntax,
+  macroName: String,
+  reason: String,
+  idPrefix: String,
+  in context: some MacroExpansionContext
+) {
+  guard !isLocal(context: context) else {
+    return
+  }
+  let accessModifier = classDecl.modifiers.first { accessLevelKeywords.contains($0.name.tokenKind) }
+  if let accessModifier,
+    [.keyword(.public), .keyword(.open)].contains(accessModifier.name.tokenKind)
+  {
+    return
+  }
+  let name = classDecl.name.text
+  context.diagnose(
+    Diagnostic(
+      node: accessModifier.map(Syntax.init) ?? Syntax(classDecl.classKeyword),
+      message: PublicAccessDiagnosticMessage(
+        "\(macroName) class '\(name)' should be public or open, so that the modules provider that autolinking generates in the app target can \(reason)",
+        id: "\(idPrefix)-class-not-public"
+      ),
+      fixIts: [makePublicFixIt(for: classDecl, replacing: accessModifier, idPrefix: idPrefix)]
+    )
+  )
+}
+
+private let accessLevelKeywords: [TokenKind] = [
+  .keyword(.open), .keyword(.public), .keyword(.package), .keyword(.internal), .keyword(.fileprivate),
+  .keyword(.private),
+]
+
+/// True when the declaration is inside a function, closure or another scope that isn't a type or an extension.
+private func isLocal(context: some MacroExpansionContext) -> Bool {
+  return context.lexicalContext.contains { node in
+    return !node.is(ClassDeclSyntax.self) && !node.is(StructDeclSyntax.self) && !node.is(EnumDeclSyntax.self)
+      && !node.is(ActorDeclSyntax.self) && !node.is(ExtensionDeclSyntax.self)
+  }
+}
+
+/// The fix-it for a class that isn't public: replace its access modifier with `public`, or add `public` before
+/// its other modifiers.
+private func makePublicFixIt(
+  for classDecl: ClassDeclSyntax,
+  replacing accessModifier: DeclModifierSyntax?,
+  idPrefix: String
+) -> FixIt {
+  let message = PublicAccessFixItMessage("Make the class 'public'", id: "\(idPrefix)-class-insert-public")
+  if let accessModifier {
+    let newModifier = accessModifier.with(\.name, accessModifier.name.with(\.tokenKind, .keyword(.public)))
+    return FixIt(message: message, changes: [.replace(oldNode: Syntax(accessModifier), newNode: Syntax(newModifier))])
+  }
+  // The new modifier takes over the leading trivia of the first modifier or of `class` (the line break after the
+  // attribute), so it lands where the declaration started.
+  let newDecl: ClassDeclSyntax
+  if let firstModifier = classDecl.modifiers.first {
+    let publicModifier = DeclModifierSyntax(
+      name: .keyword(.public, leadingTrivia: firstModifier.leadingTrivia, trailingTrivia: .space)
+    )
+    var modifiers = classDecl.modifiers
+    modifiers[modifiers.startIndex] = firstModifier.with(\.leadingTrivia, [])
+    modifiers.insert(publicModifier, at: modifiers.startIndex)
+    newDecl = classDecl.with(\.modifiers, modifiers)
+  } else {
+    let classKeyword = classDecl.classKeyword
+    let publicModifier = DeclModifierSyntax(
+      name: .keyword(.public, leadingTrivia: classKeyword.leadingTrivia, trailingTrivia: .space)
+    )
+    newDecl =
+      classDecl
+      .with(\.modifiers, [publicModifier])
+      .with(\.classKeyword, classKeyword.with(\.leadingTrivia, []))
+  }
+  return FixIt(message: message, changes: [.replace(oldNode: Syntax(classDecl), newNode: Syntax(newDecl))])
+}
+
+private struct PublicAccessDiagnosticMessage: DiagnosticMessage {
+  let message: String
+  let diagnosticID: MessageID
+  let severity: DiagnosticSeverity = .warning
+
+  init(_ message: String, id: String) {
+    self.message = message
+    self.diagnosticID = MessageID(domain: "ExpoModulesMacros", id: id)
+  }
+}
+
+private struct PublicAccessFixItMessage: FixItMessage {
+  let message: String
+  let fixItID: MessageID
+
+  init(_ message: String, id: String) {
+    self.message = message
+    self.fixItID = MessageID(domain: "ExpoModulesMacros", id: id)
+  }
+}