expo-modules-macros 0.30.0 → 0.32.0

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

@@ -40,6 +40,94 @@ internal func diagnoseJSNameCollisions(
   }
 }
 
+/// The JavaScript object that a set of `@JS` members binds onto, for `diagnoseReservedJSNames`.
+internal enum JSBindingTarget {
+  /// The module object of an `@ExpoModule` class.
+  case module
+  /// The prototype of a shared object class, which holds the instance members.
+  case prototype
+  /// The constructor of a shared object class, which holds the static members.
+  case constructor
+
+  /// The names that JavaScript already gives a meaning on this object, with what binding a member
+  /// under one would break.
+  var reservedNames: [String: String] {
+    let proto = "setting '__proto__' on an object replaces its prototype instead of adding a member"
+    switch self {
+    case .module:
+      return ["__proto__": proto]
+    case .prototype:
+      return [
+        "__proto__": proto,
+        "constructor": "a member named 'constructor' replaces the prototype's reference to the class",
+      ]
+    case .constructor:
+      return [
+        "__proto__": proto,
+        "prototype": "a static member named 'prototype' replaces the prototype that holds the instance members",
+      ]
+    }
+  }
+}
+
+/// Reports each `@JS` member whose JavaScript name JavaScript already gives a meaning on the object that
+/// the member binds onto, such as `constructor` on a shared object's prototype.
+internal func diagnoseReservedJSNames(
+  functions: [JSFunction],
+  properties: [JSProperty],
+  on target: JSBindingTarget,
+  in context: some MacroExpansionContext
+) {
+  let members = functions.map(BoundMember.init(function:)) + properties.map(BoundMember.init(property:))
+  for member in members {
+    guard let reason = target.reservedNames[member.jsName] else {
+      continue
+    }
+    context.diagnose(
+      Diagnostic(
+        node: member.nameToken,
+        message: ReservedJSNameMessage(
+          "The JavaScript name '\(member.jsName)' can't be bound: \(reason). Give the \(member.kind) another name with \(member.renaming)."
+        )
+      )
+    )
+  }
+}
+
+/// Reports each `@Event` property of a class body whose JavaScript event name an earlier `@Event`
+/// property already uses. Both properties emit under that name, so a listener can't tell which one fired.
+internal func diagnoseEventNameCollisions(in memberBlock: MemberBlockSyntax, in context: some MacroExpansionContext) {
+  var firstEvents: [String: TokenSyntax] = [:]
+
+  for member in memberBlock.members {
+    guard let varDecl = member.decl.as(VariableDeclSyntax.self),
+      let attribute = varDecl.attributes.firstAttribute(named: "Event"),
+      let jsName = eventJSName(of: varDecl, attribute: attribute),
+      let nameToken = varDecl.bindings.first?.pattern.as(IdentifierPatternSyntax.self)?.identifier
+    else {
+      continue
+    }
+    guard let first = firstEvents[jsName] else {
+      firstEvents[jsName] = nameToken
+      continue
+    }
+    context.diagnose(
+      Diagnostic(
+        node: nameToken,
+        message: EventNameCollisionMessage(
+          "The event name '\(jsName)' is already used by the earlier @Event '\(first.text)'. Both properties emit the same event, so a JavaScript listener can't tell them apart. Give one of them another name with @Event(\"...\")."
+        ),
+        notes: [
+          Note(
+            node: Syntax(first),
+            message: JSNameCollisionNote("'\(jsName)' is first used here", id: "event-name-collision-first")
+          )
+        ]
+      )
+    )
+  }
+}
+
 private struct BoundMember {
   let jsName: String
   /// How the message names the member, such as `@JS function`.
@@ -74,11 +162,32 @@ private struct JSNameCollisionMessage: DiagnosticMessage {
   }
 }
 
-private struct JSNameCollisionNote: NoteMessage {
+private struct ReservedJSNameMessage: DiagnosticMessage {
+  let message: String
+  let diagnosticID = MessageID(domain: "ExpoModulesMacros", id: "js-reserved-name")
+  let severity: DiagnosticSeverity = .error
+
+  init(_ message: String) {
+    self.message = message
+  }
+}
+
+private struct EventNameCollisionMessage: DiagnosticMessage {
   let message: String
-  let noteID = MessageID(domain: "ExpoModulesMacros", id: "js-name-collision-first")
+  let diagnosticID = MessageID(domain: "ExpoModulesMacros", id: "event-name-collision")
+  let severity: DiagnosticSeverity = .warning
 
   init(_ message: String) {
     self.message = message
   }
 }
+
+private struct JSNameCollisionNote: NoteMessage {
+  let message: String
+  let noteID: MessageID
+
+  init(_ message: String, id: String = "js-name-collision-first") {
+    self.message = message
+    self.noteID = MessageID(domain: "ExpoModulesMacros", id: id)
+  }
+}

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

@@ -13,8 +13,8 @@ internal func jsNameArgument(of attribute: AttributeSyntax) -> String? {
   return segment.content.text
 }
 
-/// 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
+/// True if the attribute lists the given option member, e.g. `@JS(.concurrent)`, `@Event(.inline)` or
+/// `@Event("name", EventOptions.inline)` -> 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.
@@ -276,20 +276,6 @@ internal func hasDefaultValue(_ parameter: FunctionParameterSyntax) -> Bool {
   return parameter.defaultValue != nil
 }
 
-/// 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
-/// they stay callable from any thread.
-internal func isSyncEventMember(_ decl: DeclSyntaxProtocol) -> Bool {
-  guard let varDecl = decl.as(VariableDeclSyntax.self),
-    let attribute = varDecl.attributes.firstAttribute(named: "Event")
-  else {
-    return false
-  }
-  return hasOption(attribute, named: "sync")
-}
-
 /// Reads a labeled array-literal argument of an attribute, e.g. `@ExpoModule(classes: [Foo.self, Bar.self])`,
 /// and returns the type names referenced (e.g. `["Foo", "Bar"]`). Each element must be a
 /// `<TypeName>.self` member-access expression; non-conforming elements are skipped silently.
@@ -363,6 +349,19 @@ internal func memberHasJSAttribute(_ decl: DeclSyntaxProtocol) -> Bool {
   return false
 }
 
+/// The generic parameter clause of a `@JS` function or initializer, or `nil` when it has none. The
+/// binding decodes each argument by its static type, so a generic member can't be bound: `@JS` reports
+/// it, and `@ExpoModule` and `@SharedObject` leave it out.
+internal func jsGenericParameterClause(of decl: DeclSyntaxProtocol) -> GenericParameterClauseSyntax? {
+  if let funcDecl = decl.as(FunctionDeclSyntax.self) {
+    return funcDecl.genericParameterClause
+  }
+  if let initDecl = decl.as(InitializerDeclSyntax.self) {
+    return initDecl.genericParameterClause
+  }
+  return nil
+}
+
 /// Decides whether the macro should stamp `@JavaScriptActor` on a `@JS`-marked member.
 /// The macro defers to the user when they've already chosen an isolation:
 /// - the member opted out with `@JS(.concurrent)`

package/build/types.d.ts

@@ -260,8 +260,8 @@ export interface ExportedEvent extends ExportedAccess, ExportedAvailability {
     jsName: string;
     /** The payload type, absent for a no-payload `() -> Void` event. */
     payload?: TypeNode;
-    /** `@Event(.sync)`, dispatching inline on the JS thread instead of scheduling. */
-    sync: boolean;
+    /** How the event is dispatched: the default `scheduled`, or the `.inline` or `.blocking` option. */
+    dispatch: 'scheduled' | 'inline' | 'blocking';
 }
 /** The `@JS init` of a shared object: the constructor JS calls with `new`. */
 export interface ExportedInitializer extends ExportedAccess, ExportedAvailability {
@@ -480,5 +480,5 @@ export interface ExpandResult {
  * as a clear error instead of silently misread fields.
  */
 export declare const SUPPORTED_SCAN_MODULES_SCHEMA_VERSION = 2;
-export declare const SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 10;
+export declare const SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 11;
 export declare const SUPPORTED_EXPAND_SCHEMA_VERSION = 1;

package/build/types.js

@@ -12,5 +12,5 @@ exports.SUPPORTED_EXPAND_SCHEMA_VERSION = exports.SUPPORTED_SCAN_EXPORTS_SCHEMA_
  * as a clear error instead of silently misread fields.
  */
 exports.SUPPORTED_SCAN_MODULES_SCHEMA_VERSION = 2;
-exports.SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 10;
+exports.SUPPORTED_SCAN_EXPORTS_SCHEMA_VERSION = 11;
 exports.SUPPORTED_EXPAND_SCHEMA_VERSION = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.30.0",
+  "version": "0.32.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.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"
+    "@expo/modules-macros-linux-arm64": "0.32.0",
+    "@expo/modules-macros-linux-x64": "0.32.0",
+    "@expo/modules-macros-win32-arm64": "0.32.0",
+    "@expo/modules-macros-win32-x64": "0.32.0"
   }
 }