expo-modules-macros 0.30.0 → 0.32.0

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

@@ -285,7 +285,9 @@ final class SurfaceVisitor: SyntaxVisitor {
       return []
     }
     let override = stringArgument(of: attribute)
-    let isSync = hasEventOption(attribute, named: "sync")
+    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,8 +706,8 @@ private func isVoidEventReturn(_ type: TypeSyntax) -> Bool {
   return text == "Void" || text == "()" || text == "Swift.Void"
 }
 
-/// 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
+/// 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 {

package/apple/Sources/ExpoModulesMacrosCore/Macros/EventMacro.swift

@@ -29,15 +29,15 @@ import SwiftSyntaxMacros
 /// The synthesized property is deliberately **not** isolated to `@JavaScriptActor`, unlike `@JS`
 /// members: `emit` is itself non-isolated and schedules the dispatch onto the JS thread internally,
 /// so the event is callable from any thread or isolation with no actor hop at the call site. It is
-/// also self-contained: `@ExpoModule`/`@SharedObject` neither collect `@Event` members nor register
-/// their names anywhere.
+/// also self-contained: `@ExpoModule`/`@SharedObject` don't register `@Event` members anywhere. They
+/// read the event names only to warn when two events share one (see `diagnoseEventNameCollisions`).
 ///
-/// `@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
-/// `self.onTick(…)` usage; a closure stored or handed off escapes it, after which `emitSync` runs
-/// wherever the caller invokes it.
+/// Two options change how the event is dispatched, and each one calls its own `EventEmitter` method,
+/// which is callable from any thread as well:
+/// - `@Event(.inline)` calls `emitInline`: on the JS thread the listeners run before the call
+///   returns; on any other thread the event is scheduled, the same as `emit`. It never blocks.
+/// - `@Event(.blocking)` calls `emitBlocking`: the listeners run before the call returns on any
+///   thread, so a call from another thread blocks until the JS thread runs them.
 ///
 /// As a **peer**, the macro emits a never-called conformance assertion (see
 /// `TypeConformanceAssertion.swift`) checking that the payload type is JS-convertible and that the
@@ -51,11 +51,10 @@ public struct EventMacro: AccessorMacro {
   ) throws -> [AccessorDeclSyntax] {
     let event = try validatedEvent(of: node, on: declaration)
     // The closure's parameter and return types are inferred from the property's declared type
-    // through the getter, so the body never has to spell the payload type. A sync event calls
-    // `emitSync` (inline dispatch, JS thread only); the default calls the scheduling `emit`.
-    // A payload that holds a tuple can't conform to the payload protocols, so it's passed with a
-    // closure that encodes it.
-    let emitMethod = event.isSync ? "emitSync" : "emit"
+    // through the getter, so the body never has to spell the payload type. The dispatch option
+    // picks the `EventEmitter` method. A payload that holds a tuple can't conform to the payload
+    // protocols, so it's passed with a closure that encodes it.
+    let emitMethod = event.dispatch.emitMethod
     let closure: String
     if let tuple = event.payloadType.flatMap({ tupleConversion(of: $0) }) {
       let encode = encoderClosure(encoding: tuple.encodeCall(of: "value", into: "slot"))
@@ -96,9 +95,13 @@ extension EventMacro: PeerMacro {
     //
     // A payload that holds a tuple is encoded element by element (see `TupleConversion`), so the types
     // in it are asserted `JavaScriptEncodable`, which the encode closure needs, in its place.
+    // `emitInline` and `emitBlocking` take only `JavaScriptEncodable` payloads, so with those options
+    // the payload is asserted `JavaScriptEncodable` too.
     let name = event.swiftName
     let tupleElementTypes = event.payloadType.flatMap { tupleConversion(of: $0)?.conformingTypes }
-    let payloadConstraint = tupleElementTypes == nil ? jsConvertibleProtocolName : javaScriptEncodableProtocolName
+    let payloadConstraint =
+      tupleElementTypes == nil && event.dispatch == .scheduled
+      ? jsConvertibleProtocolName : javaScriptEncodableProtocolName
     let payloads =
       tupleElementTypes.map { distinctAssertableTypes($0, constraint: payloadConstraint) }
       ?? event.payloadType.flatMap { assertableBoundaryType($0, constraint: payloadConstraint) }.map { [$0] } ?? []
@@ -127,8 +130,8 @@ 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)`) via `emitSync`.
-  let isSync: Bool
+  /// How the event is dispatched, from the `.inline` or `.blocking` option.
+  let dispatch: EventDispatch
 
   var hasPayload: Bool {
     return payloadType != nil
@@ -208,14 +211,98 @@ private func validatedEvent(
   }
 
   let swiftName = identifier.identifier.text
+  let dispatch = try eventDispatch(of: node)
   return EventMember(
     swiftName: swiftName,
     jsName: jsNameArgument(of: node) ?? defaultEventName(for: withoutBackticks(swiftName)),
     payloadType: functionType.parameters.first?.type.trimmedDescription,
-    isSync: hasOption(node, named: "sync")
+    dispatch: dispatch
   )
 }
 
+/// How an `@Event` is dispatched to JavaScript, picked by its option.
+private enum EventDispatch {
+  case scheduled
+  case inline
+  case blocking
+
+  var emitMethod: String {
+    switch self {
+    case .scheduled:
+      return "emit"
+    case .inline:
+      return "emitInline"
+    case .blocking:
+      return "emitBlocking"
+    }
+  }
+}
+
+/// Reads the dispatch option of an `@Event` attribute. `.inline` and `.blocking` exclude each other.
+private func eventDispatch(of node: AttributeSyntax) throws -> EventDispatch {
+  let isInline = hasOption(node, named: "inline")
+  let isBlocking = hasOption(node, named: "blocking")
+  if isInline && isBlocking {
+    throw conflictingOptionsDiagnostic(in: node)
+  }
+  if isInline {
+    return .inline
+  }
+  if isBlocking {
+    return .blocking
+  }
+  return .scheduled
+}
+
+/// The error for `@Event(.inline, .blocking)`, with a single Fix-It that removes the option written
+/// last. One Fix-It (rather than one for each option) lets the `fix` command apply it, since it skips
+/// a diagnostic with alternatives.
+private func conflictingOptionsDiagnostic(in node: AttributeSyntax) -> DiagnosticsError {
+  let message = EventDiagnosticMessage(
+    "@Event can't be both '.inline' and '.blocking'; '.blocking' also runs the listeners inline on the JS thread, so remove one of the options",
+    id: "event-conflicting-options"
+  )
+  guard let arguments = node.arguments?.as(LabeledExprListSyntax.self),
+    let index = arguments.lastIndex(where: { isDispatchOption($0.expression) })
+  else {
+    return DiagnosticsError(diagnostics: [Diagnostic(node: node, message: message)])
+  }
+  let removed = arguments[index]
+  var remaining = Array(arguments)
+  remaining.removeAll { $0.id == removed.id }
+  // The argument before the removed one keeps its comma only when another argument follows it.
+  if let last = remaining.indices.last {
+    remaining[last] = remaining[last].with(\.trailingComma, nil)
+  }
+  let optionName = removed.expression.as(MemberAccessExprSyntax.self)?.declName.baseName.text ?? "option"
+  let fixIt = FixIt(
+    message: EventFixItMessage("Remove '.\(optionName)'", id: "event-remove-option"),
+    changes: [
+      .replace(oldNode: Syntax(arguments), newNode: Syntax(LabeledExprListSyntax(remaining)))
+    ]
+  )
+  return DiagnosticsError(diagnostics: [Diagnostic(node: node, message: message, fixIts: [fixIt])])
+}
+
+/// True when the expression is the `.inline` or `.blocking` option (or `EventOptions.<option>`).
+private func isDispatchOption(_ expression: ExprSyntax) -> Bool {
+  guard let member = expression.as(MemberAccessExprSyntax.self) else {
+    return false
+  }
+  let name = member.declName.baseName.text
+  return name == "inline" || name == "blocking"
+}
+
+/// The JS name of an `@Event` property: the `@Event("…")` override, or the default name derived from
+/// the property name. `nil` when the declaration isn't a single named property, which the macro reports.
+internal func eventJSName(of varDecl: VariableDeclSyntax, attribute: AttributeSyntax) -> String? {
+  guard varDecl.bindings.count == 1, let identifier = varDecl.bindings.first?.pattern.as(IdentifierPatternSyntax.self)
+  else {
+    return nil
+  }
+  return jsNameArgument(of: attribute) ?? defaultEventName(for: withoutBackticks(identifier.identifier.text))
+}
+
 // MARK: - Default event name
 
 /// The default JS event name for a property: the Swift name with the conventional `on` prefix

package/apple/Sources/ExpoModulesMacrosCore/Macros/ExpoModuleMacro.swift

@@ -63,6 +63,16 @@ public struct ExpoModuleMacro: MemberMacro {
     for member in classDecl.memberBlock.members {
       // The types of a `@JS` member are read with the class's tuple aliases resolved.
       let decl = aliases.resolving(member.decl)
+      // A generic member is reported by `@JS` and left out, so the build has no errors in its binding.
+      if memberHasJSAttribute(decl) && jsGenericParameterClause(of: decl) != nil {
+        continue
+      }
+      // So is a `static` or `class` member: the module object binds only instance members.
+      if memberHasJSAttribute(decl),
+        let modifiers = decl.asProtocol(WithModifiersSyntax.self)?.modifiers, isTypeLevel(modifiers)
+      {
+        continue
+      }
       if memberHasJSAttribute(decl), let assertion = jsConformanceAssertionBody(for: decl) {
         assertions.append(assertion)
       }
@@ -86,6 +96,8 @@ public struct ExpoModuleMacro: MemberMacro {
     }
 
     diagnoseJSNameCollisions(functions: functions, properties: properties, in: context)
+    diagnoseReservedJSNames(functions: functions, properties: properties, on: .module, in: context)
+    diagnoseEventNameCollisions(in: classDecl.memberBlock, in: context)
 
     var emitted: [DeclSyntax] = []
 
@@ -167,10 +179,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)` 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),
+    if memberHasJSAttribute(member),
       shouldStampJavaScriptActor(on: member, enclosedBy: declaration)
     {
       attributes.append("@JavaScriptActor")

package/apple/Sources/ExpoModulesMacrosCore/Macros/JSMacro.swift

@@ -31,6 +31,20 @@ public struct JSMacro: PeerMacro {
     providingPeersOf declaration: some DeclSyntaxProtocol,
     in context: some MacroExpansionContext
   ) throws -> [DeclSyntax] {
+    diagnosePlacement(of: node, on: declaration, in: context)
+    if let genericParameterClause = jsGenericParameterClause(of: declaration) {
+      context.diagnose(
+        Diagnostic(
+          node: genericParameterClause,
+          message: JSDiagnosticMessage(
+            "A @JS function or initializer can't be generic: the binding decodes each argument and encodes the result by its static type, which a generic parameter doesn't have. Use a concrete type, a @Union of the types, or 'JavaScriptValue'.",
+            id: "js-generic-member",
+            severity: .error
+          )
+        )
+      )
+      return []
+    }
     diagnoseParameterSpecifiers(in: declaration, in: context)
     diagnoseFreeFormTypes(in: declaration, in: context)
     diagnoseClosureTypes(in: declaration, in: context)
@@ -75,6 +89,116 @@ private func isInBindingClass(_ context: some MacroExpansionContext) -> Bool {
     || classDecl.attributes.firstAttribute(named: "SharedObject") != nil
 }
 
+/// Reports a `@JS` attribute that no macro binds, so the member would be missing in JavaScript without
+/// an error:
+/// - on a declaration other than a function, property or initializer, such as a subscript;
+/// - on a member of an extension, since `@ExpoModule` and `@SharedObject` read only the class body;
+/// - on a member of a type that isn't an `@ExpoModule` or `@SharedObject` class;
+/// - on a `static` or `class` member of an `@ExpoModule` class, since JavaScript gets only the instance;
+/// - on an initializer of an `@ExpoModule` class, since JavaScript doesn't construct a module.
+private func diagnosePlacement(
+  of node: AttributeSyntax,
+  on declaration: some DeclSyntaxProtocol,
+  in context: some MacroExpansionContext
+) {
+  guard
+    declaration.is(FunctionDeclSyntax.self) || declaration.is(VariableDeclSyntax.self)
+      || declaration.is(InitializerDeclSyntax.self)
+  else {
+    let kind = declaration.is(SubscriptDeclSyntax.self) ? "a subscript" : "this declaration"
+    context.diagnose(
+      Diagnostic(
+        node: node,
+        message: JSDiagnosticMessage(
+          "@JS applies to a function, property or initializer, so \(kind) isn't bound to JavaScript. Expose a @JS function instead.",
+          id: "js-unsupported-declaration",
+          severity: .error
+        )
+      )
+    )
+    return
+  }
+  if let extensionDecl = context.lexicalContext.first?.as(ExtensionDeclSyntax.self) {
+    let typeName = extensionDecl.extendedType.trimmedDescription
+    context.diagnose(
+      Diagnostic(
+        node: node,
+        message: JSDiagnosticMessage(
+          "A @JS member of an extension isn't bound to JavaScript: @ExpoModule and @SharedObject bind only the @JS members declared in the class body. Move the member into the declaration of '\(typeName)'.",
+          id: "js-in-extension",
+          severity: .error
+        )
+      )
+    )
+    return
+  }
+  if let enclosingType = context.lexicalContext.first, enclosingType.isProtocol(DeclGroupSyntax.self),
+    !isInBindingClass(context)
+  {
+    let typeName = enclosingType.asProtocol(NamedDeclSyntax.self).map { "'\($0.name.text)'" } ?? "this type"
+    context.diagnose(
+      Diagnostic(
+        node: node,
+        message: JSDiagnosticMessage(
+          "A @JS member of \(typeName) isn't bound to JavaScript: only an @ExpoModule or @SharedObject class binds its @JS members. Add one of these macros to \(typeName), or move the member into such a class.",
+          id: "js-outside-binding-class",
+          severity: .error
+        )
+      )
+    )
+    return
+  }
+  if let modifiers = declaration.asProtocol(WithModifiersSyntax.self)?.modifiers, isTypeLevel(modifiers),
+    let classDecl = context.lexicalContext.first?.as(ClassDeclSyntax.self),
+    classDecl.attributes.firstAttribute(named: "ExpoModule") != nil
+  {
+    context.diagnose(
+      Diagnostic(
+        node: node,
+        message: JSDiagnosticMessage(
+          "A @JS member of an @ExpoModule class can't be 'static' or 'class': JavaScript gets one module object, and @ExpoModule binds the members of the instance to it. Make the member an instance member.",
+          id: "js-module-static-member",
+          severity: .error
+        )
+      )
+    )
+    return
+  }
+  if let initDecl = declaration.as(InitializerDeclSyntax.self),
+    let classDecl = context.lexicalContext.first?.as(ClassDeclSyntax.self),
+    classDecl.attributes.firstAttribute(named: "ExpoModule") != nil
+  {
+    context.diagnose(
+      Diagnostic(
+        node: node,
+        message: JSDiagnosticMessage(
+          "@JS on an initializer of an @ExpoModule class isn't bound to JavaScript: JavaScript doesn't construct a module, it gets the instance that the app context creates. Remove @JS, or construct a @SharedObject class from JavaScript instead.",
+          id: "js-module-initializer",
+          severity: .error
+        ),
+        fixIts: removeAttributeFixIts(node, before: initDecl.initKeyword)
+      )
+    )
+  }
+}
+
+/// The fix-it that removes a `@JS` attribute written on its own line, with the line break and
+/// indentation before it. The macro gets the attribute without the trivia after it, so when the
+/// declaration starts on the line of the attribute (`@JS init()`), the fix-it can't tell how much
+/// space to remove, and there is none. It edits only the text of the attribute, since the declaration
+/// that a peer macro gets can carry attributes that other macros added.
+private func removeAttributeFixIts(_ node: AttributeSyntax, before keyword: TokenSyntax) -> [FixIt] {
+  guard keyword.leadingTrivia.contains(where: \.isNewline) else {
+    return []
+  }
+  return [
+    FixIt(
+      message: JSFixItMessage("Remove '@JS'", id: "js-remove-attribute"),
+      changes: [.replaceText(range: node.position..<node.endPosition, with: "", in: Syntax(node))]
+    )
+  ]
+}
+
 /// Emits the diagnostic for `@JS(.concurrent)` on a member that can't take it. The option maps to
 /// Swift's `@concurrent`, which requires an `async` function: a synchronous member has nowhere to
 /// suspend, and a property or initializer can't be async at all. Diagnosing here points at the

package/apple/Sources/ExpoModulesMacrosCore/Macros/RecordMacro.swift

@@ -81,6 +81,12 @@ public struct RecordMacro: MemberMacro, ExtensionMacro {
     // the author's version stand — the factories only need *an* `init(<properties>)` and `Record` only
     // needs *an* `init()`, regardless of who wrote them.
     let existingInitLabels = initializerParameterLabels(of: declaration)
+    if !existingInitLabels.contains(properties.map { $0.key }) {
+      let diagnostics = unsetPrivatePropertyDiagnostics(of: declaration)
+      guard diagnostics.isEmpty else {
+        throw DiagnosticsError(diagnostics: diagnostics)
+      }
+    }
 
     var members: [DeclSyntax] = []
 
@@ -227,6 +233,10 @@ private func recordProperties(
       guard let ident = binding.pattern.as(IdentifierPatternSyntax.self) else {
         continue
       }
+      // The memberwise init sets every property, and a `let` with a default value can't be set again.
+      if varDecl.bindingSpecifier.tokenKind == .keyword(.let), binding.initializer != nil {
+        throw DiagnosticsError(diagnostics: [letWithDefaultDiagnostic(for: varDecl, name: ident.identifier.text)])
+      }
       // Prefer the explicit annotation. When it's omitted, recover the type from a literal default
       // (Swift's own default-literal type) — covers the common `var name = "foo"` case. Anything
       // whose type a syntactic macro can't determine (calls, collections, member access) still needs
@@ -637,6 +647,64 @@ private func unsupportedClassDiagnostics(of declaration: some DeclGroupSyntax) -
   return diagnostics
 }
 
+/// The errors for the `private` and `fileprivate` stored properties that the synthesized memberwise
+/// initializer would leave without a value. Such a property isn't a record property, so the initializer
+/// doesn't set it, and it needs a default value. An optional `var` starts as `nil`, so it needs none.
+private func unsetPrivatePropertyDiagnostics(of declaration: some DeclGroupSyntax) -> [Diagnostic] {
+  var diagnostics: [Diagnostic] = []
+  for member in declaration.memberBlock.members {
+    guard let varDecl = member.decl.as(VariableDeclSyntax.self),
+      let access = varDecl.modifiers.first(where: {
+        $0.name.tokenKind == .keyword(.private) || $0.name.tokenKind == .keyword(.fileprivate)
+      }),
+      !varDecl.modifiers.contains(where: {
+        $0.name.tokenKind == .keyword(.static) || $0.name.tokenKind == .keyword(.class)
+          || $0.name.tokenKind == .keyword(.lazy)
+      })
+    else {
+      continue
+    }
+    let isVar = varDecl.bindingSpecifier.tokenKind == .keyword(.var)
+    for binding in varDecl.bindings where binding.accessorBlock == nil && binding.initializer == nil {
+      guard let ident = binding.pattern.as(IdentifierPatternSyntax.self),
+        !(isVar && binding.typeAnnotation.map { isOptionalType($0.type) } == true)
+      else {
+        continue
+      }
+      diagnostics.append(
+        Diagnostic(
+          node: ident,
+          message: RecordDiagnosticMessage(
+            "@Record leaves out the \(access.name.text) property '\(ident.identifier.text)', so the synthesized initializer doesn't set it. Give it a default value, or remove '\(access.name.text)' to make it a record property",
+            id: "record-unset-private-property"
+          )
+        )
+      )
+    }
+  }
+  return diagnostics
+}
+
+/// The error for a `let` property with a default value, attached to the `let` keyword and carrying a
+/// fix-it that replaces it with `var`. The default still applies when JavaScript omits the property.
+private func letWithDefaultDiagnostic(for varDecl: VariableDeclSyntax, name: String) -> Diagnostic {
+  let specifier = varDecl.bindingSpecifier
+  let fixIt = FixIt(
+    message: RecordFixItMessage("Replace 'let' with 'var'", id: "record-let-to-var"),
+    changes: [
+      .replace(oldNode: Syntax(specifier), newNode: Syntax(specifier.with(\.tokenKind, .keyword(.var))))
+    ]
+  )
+  return Diagnostic(
+    node: specifier,
+    message: RecordDiagnosticMessage(
+      "@Record property '\(name)' is a 'let' with a default value, so the synthesized initializer can't set it from JavaScript. Make it a 'var', and the default applies when JavaScript omits the property, or make it 'static' or 'private' to leave it out of the record",
+      id: "record-let-with-default"
+    ),
+    fixIts: [fixIt]
+  )
+}
+
 /// The fix-it for a record class that isn't `final`: add the modifier right before `class`.
 private func markFinalFixIt(for classDecl: ClassDeclSyntax) -> FixIt {
   // The new modifier takes over the leading trivia of `class` (the line break after the attribute

package/apple/Sources/ExpoModulesMacrosCore/Macros/SharedObjectMacro.swift

@@ -1,3 +1,4 @@
+import SwiftDiagnostics
 import SwiftSyntax
 import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
@@ -42,9 +43,13 @@ public struct SharedObjectMacro: MemberMacro {
       in: context
     )
 
-    // The superclass isn't checked here: the macro sees only this declaration, so it can't tell an
+    // A class without an inheritance clause has no superclass, so it can't be a `SharedObject`. Any
+    // other superclass isn't checked: 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
     // class that isn't a `SharedObject` subclass on the `_jsName` override, which is always emitted.
+    if classDecl.inheritanceClause == nil {
+      throw DiagnosticsError(diagnostics: [missingBaseClassDiagnostic(for: classDecl)])
+    }
     let typeName = classDecl.name.text
     let jsName = jsNameArgument(of: node) ?? withoutBackticks(typeName)
 
@@ -71,6 +76,10 @@ public struct SharedObjectMacro: MemberMacro {
     for member in classDecl.memberBlock.members {
       // The types of a `@JS` member are read with the class's tuple aliases resolved.
       let decl = aliases.resolving(member.decl)
+      // A generic member is reported by `@JS` and left out, so the build has no errors in its binding.
+      if memberHasJSAttribute(decl) && jsGenericParameterClause(of: decl) != nil {
+        continue
+      }
       if memberHasJSAttribute(decl), let assertion = jsConformanceAssertionBody(for: decl) {
         assertions.append(assertion)
       }
@@ -114,6 +123,19 @@ public struct SharedObjectMacro: MemberMacro {
 
     diagnoseJSNameCollisions(functions: instanceFunctions, properties: instanceProperties, in: context)
     diagnoseJSNameCollisions(functions: staticFunctions, properties: staticProperties, in: context)
+    diagnoseReservedJSNames(
+      functions: instanceFunctions,
+      properties: instanceProperties,
+      on: .prototype,
+      in: context
+    )
+    diagnoseReservedJSNames(
+      functions: staticFunctions,
+      properties: staticProperties,
+      on: .constructor,
+      in: context
+    )
+    diagnoseEventNameCollisions(in: classDecl.memberBlock, in: context)
 
     // The resolved JS class name, read by core when it builds the class. An `override` of the
     // `SharedObject` class property, so core reads it through the concrete type's metatype.
@@ -171,10 +193,7 @@ extension SharedObjectMacro: MemberAttributeMacro {
     providingAttributesFor member: some DeclSyntaxProtocol,
     in context: some MacroExpansionContext
   ) throws -> [AttributeSyntax] {
-    // `@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 {
+    guard memberHasJSAttribute(member) else {
       return []
     }
     // `@JS(.concurrent)` opts the member out of the JS-thread stamp and onto the concurrent pool.
@@ -202,3 +221,59 @@ extension SharedObjectMacro: ExtensionMacro {
     return [sendable]
   }
 }
+
+/// The error for a `@SharedObject` class without an inheritance clause, with a fix-it that makes it
+/// inherit from `SharedObject`: `class Cache {` becomes `class Cache: SharedObject {`.
+private func missingBaseClassDiagnostic(for classDecl: ClassDeclSyntax) -> Diagnostic {
+  // The name carries the space before `{` as trailing trivia, so move it onto the clause to keep the
+  // spacing.
+  let name = classDecl.name
+  let clause = InheritanceClauseSyntax(
+    colon: .colonToken(trailingTrivia: .space),
+    inheritedTypes: InheritedTypeListSyntax([
+      InheritedTypeSyntax(type: TypeSyntax(IdentifierTypeSyntax(name: .identifier("SharedObject"))))
+    ])
+  )
+  let fixIt = FixIt(
+    message: SharedObjectFixItMessage("Inherit from 'SharedObject'", id: "sharedobject-add-base-class"),
+    changes: [
+      .replace(
+        oldNode: Syntax(classDecl),
+        newNode: Syntax(
+          classDecl
+            .with(\.name, name.with(\.trailingTrivia, []))
+            .with(\.inheritanceClause, clause.with(\.trailingTrivia, name.trailingTrivia))
+        )
+      )
+    ]
+  )
+  return Diagnostic(
+    node: name,
+    message: SharedObjectDiagnosticMessage(
+      "@SharedObject class '\(name.text)' must inherit from 'SharedObject', directly or through another class such as 'SharedRef'. Add ': SharedObject' to the class declaration.",
+      id: "sharedobject-missing-base-class"
+    ),
+    fixIts: [fixIt]
+  )
+}
+
+private struct SharedObjectDiagnosticMessage: DiagnosticMessage {
+  let message: String
+  let diagnosticID: MessageID
+  let severity: DiagnosticSeverity = .error
+
+  init(_ message: String, id: String) {
+    self.message = message
+    self.diagnosticID = MessageID(domain: "ExpoModulesMacros", id: id)
+  }
+}
+
+private struct SharedObjectFixItMessage: FixItMessage {
+  let message: String
+  let fixItID: MessageID
+
+  init(_ message: String, id: String) {
+    self.message = message
+    self.fixItID = MessageID(domain: "ExpoModulesMacros", id: id)
+  }
+}