expo-modules-macros 0.29.0 → 0.30.0

package/apple/Sources/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])`,

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)
+  }
+}

package/build/types.d.ts

@@ -260,7 +260,7 @@ export interface ExportedEvent extends ExportedAccess, ExportedAvailability {
     jsName: string;
     /** The payload type, absent for a no-payload `() -> Void` event. */
     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. */
     sync: boolean;
 }
 /** The `@JS init` of a shared object: the constructor JS calls with `new`. */
@@ -391,10 +391,16 @@ export interface ScanStats {
     /** Wall-clock duration of the scan, in milliseconds. */
     durationMs: number;
 }
-/** One module in the `scan-modules` output. */
-export interface ScannedModule {
+/**
+ * One class in the `scan-modules` output: an `@ExpoModule` class in `modules`, or a `@SharedObject`
+ * class in `sharedObjects`.
+ */
+export interface ScannedClass {
     name: string;
-    /** The resolved JS name: the `@ExpoModule("Foo")` override, else the class name. */
+    /**
+     * The resolved JS name: the `@ExpoModule("Foo")` or `@SharedObject("Foo")` override, else the class
+     * name.
+     */
     jsName: string;
     /**
      * The spelled access level, or `internal` when none is written. The generated provider references
@@ -403,7 +409,7 @@ export interface ScannedModule {
     accessLevel: string;
     /**
      * The OSes whose builds include this class, resolved from the enclosing `#if` conditions. An
-     * unconditional module lists every OS. Empty means no build is known to include it, so don't
+     * unconditional class lists every OS. Empty means no build is known to include it, so don't
      * register it.
      */
     platforms: ScannedPlatform[];
@@ -412,7 +418,10 @@ export interface ScannedModule {
 /** The `scan-modules` result. */
 export interface ScanModulesResult {
     schemaVersion: number;
-    modules: ScannedModule[];
+    /** The top-level `@ExpoModule` classes. */
+    modules: ScannedClass[];
+    /** The top-level `@SharedObject` classes, with the same platform rules as `modules`. */
+    sharedObjects: ScannedClass[];
     warnings: ScanWarning[];
     stats: ScanStats;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Swift macro plugin for Expo modules",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -26,9 +26,9 @@
     "typescript": "^5.4.0"
   },
   "optionalDependencies": {
-    "@expo/modules-macros-linux-arm64": "0.29.0",
-    "@expo/modules-macros-linux-x64": "0.29.0",
-    "@expo/modules-macros-win32-arm64": "0.29.0",
-    "@expo/modules-macros-win32-x64": "0.29.0"
+    "@expo/modules-macros-linux-arm64": "0.30.0",
+    "@expo/modules-macros-linux-x64": "0.30.0",
+    "@expo/modules-macros-win32-arm64": "0.30.0",
+    "@expo/modules-macros-win32-x64": "0.30.0"
   }
 }