expo-modules-macros 0.32.0 → 0.34.0

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

@@ -1,10 +1,10 @@
 import SwiftSyntax
 
-/// Extracts the full JS-exported surface of every `@ExpoModule`, `@SharedObject`, and `@Record` type:
-/// their `@JS` members and record properties. The deep counterpart to `DetectionVisitor`.
-/// Recognition is purely syntactic and re-reads what the macros read (the macro target can't be
-/// imported), so it stays in step with `JSFunction` / `JSProperty` / `JSConstructor` /
-/// `RecordProperty`.
+/// Extracts the full JS-exported surface of every `@ExpoModule`, `@SharedObject`, `@Record`,
+/// `@ExpoView`, and `@ViewProps` type: their `@JS` members, record properties, view props, and view
+/// events. The deep counterpart to `DetectionVisitor`. Recognition is purely syntactic and re-reads
+/// what the macros read (the macro target can't be imported), so it stays in step with `JSFunction` /
+/// `JSProperty` / `JSConstructor` / `RecordProperty` / `validatedViewProps`.
 ///
 /// Types nested in another type's body, or in a file-scope `extension`, are reported under their
 /// qualified Swift name (`Options.Encoding`), so a ref to one can be resolved from the scope it is
@@ -12,10 +12,10 @@ import SwiftSyntax
 ///
 /// Each declaration and member reports the platforms that build it (see `PlatformResolver`), and one
 /// that no platform builds is not reported. `#if` is read only where the runtime sees what it holds:
-/// around types, `@Event` members, and enum cases. `@ExpoModule`, `@SharedObject`, `@Record`, and
-/// `@Union` read only the members written directly in the type body, so `@JS` members, record
-/// properties, and union cases in a `#if` clause are never bound and are not reported. An `@Event`
-/// expands on its own declaration, and the compiler reads enum cases itself.
+/// around types, `@Event` members, and enum cases. `@ExpoModule`, `@SharedObject`, `@Record`,
+/// `@Union`, and `@ViewProps` read only the members written directly in the type body, so `@JS`
+/// members, record properties, union cases, and view props in a `#if` clause are never bound and are
+/// not reported. An `@Event` expands on its own declaration, and the compiler reads enum cases itself.
 final class SurfaceVisitor: SyntaxVisitor {
   private let file: String
   private let platformResolver: PlatformResolver
@@ -24,6 +24,10 @@ final class SurfaceVisitor: SyntaxVisitor {
   private(set) var records: [ExportedRecord] = []
   private(set) var enums: [ExportedEnum] = []
   private(set) var unions: [ExportedUnion] = []
+  private(set) var views: [ExportedView] = []
+  /// The `@ViewProps` structs, which `ExportedSurface.joiningViewProps(_:)` copies into the views once
+  /// every file has been walked.
+  private(set) var viewProps: [ViewPropsDeclaration] = []
 
   init(file: String, tree: SourceFileSyntax) {
     self.file = file
@@ -120,8 +124,8 @@ final class SurfaceVisitor: SyntaxVisitor {
   }
 
   /// Routes a class or struct to the right collector based on which Expo macro it carries. A type
-  /// carrying none of them is ignored. `@Record` and `@ExpoModule`/`@SharedObject` are mutually
-  /// exclusive in practice, so the first match wins.
+  /// carrying none of them is ignored. The macros are mutually exclusive in practice, so the first
+  /// match wins.
   ///
   /// `name` is the declared name and `scope` the names of the types enclosing it. The reported `name`
   /// is qualified with the scope, while a default `jsName` is the declared name alone, as the macros
@@ -201,6 +205,38 @@ final class SurfaceVisitor: SyntaxVisitor {
           file: file
         )
       )
+      return
+    }
+
+    // `@ExpoView` applies only to a class, and needs the props type as its generic argument.
+    if node.is(ClassDeclSyntax.self),
+      let attribute = attributes.firstAttribute(named: DetectedMacro.expoView.rawValue),
+      let propsType = genericArgumentType(of: attribute)
+    {
+      // Only a file-scope view is reported, as `scan-modules` reports only those.
+      guard scope.isEmpty else {
+        return
+      }
+      // `props` and `events` are filled in by `ExportedSurface.joiningViewProps(_:)`, since the
+      // `@ViewProps` struct can be declared in another file.
+      views.append(
+        ExportedView(
+          name: qualified,
+          jsName: name,
+          propsType: String(propsType.trimmedDescription.filter { $0 != "`" }),
+          propsTypeLookupName: spellingWithoutGenericArguments(of: propsType),
+          accessLevel: accessLevel,
+          platforms: platforms,
+          file: file
+        )
+      )
+      return
+    }
+
+    // `@ViewProps` applies only to a struct.
+    if node.is(StructDeclSyntax.self), attributes.firstAttribute(named: DetectedMacro.viewProps.rawValue) != nil {
+      let (props, events) = collectViewProps(members)
+      viewProps.append(ViewPropsDeclaration(name: qualified, props: props, events: events, platforms: platforms))
     }
   }
 
@@ -425,7 +461,7 @@ final class SurfaceVisitor: SyntaxVisitor {
     // `@Record` reads only the properties written directly in the body, so `#if` is not looked into.
     for member in members {
       guard let varDecl = member.decl.as(VariableDeclSyntax.self),
-        !isExcludedRecordModifier(varDecl.modifiers)
+        !isExcludedByModifier(varDecl.modifiers)
       else {
         continue
       }
@@ -459,6 +495,76 @@ final class SurfaceVisitor: SyntaxVisitor {
     return properties
   }
 
+  /// The value props and events of a `@ViewProps` struct, mirroring `validatedViewProps` in the macro:
+  /// every binding of a `var` or `let` that no modifier excludes, except a computed one. A property
+  /// with `willSet`/`didSet` or a `set` counts, as in the macro. A function-typed property is an event,
+  /// and every other one a value prop.
+  ///
+  /// The scan stays lenient where the macro reports an error, and leaves out only what can't be
+  /// described: a property whose type can't be determined, an optional function type, and an event
+  /// that doesn't return `Void`. A value prop the macro rejects for another reason, such as a `let` or
+  /// a missing default, is still reported.
+  private func collectViewProps(
+    _ members: MemberBlockItemListSyntax
+  ) -> (props: [ExportedViewProp], events: [ExportedViewEvent]) {
+    var props: [ExportedViewProp] = []
+    var events: [ExportedViewEvent] = []
+
+    // `@ViewProps` reads only the properties written directly in the body, so `#if` is not looked into.
+    for member in members {
+      guard let varDecl = member.decl.as(VariableDeclSyntax.self),
+        !isExcludedByModifier(varDecl.modifiers)
+      else {
+        continue
+      }
+      let platforms = platformResolver.platforms(of: varDecl)
+      guard !platforms.isEmpty else {
+        continue
+      }
+      for binding in varDecl.bindings {
+        if binding.accessorBlock != nil && !isSettable(binding: binding, isLet: false) {
+          continue
+        }
+        guard let ident = binding.pattern.as(IdentifierPatternSyntax.self) else {
+          continue
+        }
+        let name = ident.identifier.identifierName
+        let annotation = binding.typeAnnotation?.type
+
+        if let annotation, let functionType = viewEventFunctionType(of: annotation) {
+          // An optional function type and a non-`Void` result are errors in the macro.
+          guard !isOptionalEventType(annotation), isVoidEventReturn(functionType.returnClause.type) else {
+            continue
+          }
+          let parameters = functionType.parameters
+          events.append(
+            ExportedViewEvent(
+              name: name,
+              payload: parameters.count == 1 ? parameters.first.map { typeNode(from: $0.type) } : nil,
+              accessLevel: spelledAccessLevel(of: varDecl.modifiers),
+              platforms: platforms
+            )
+          )
+          continue
+        }
+
+        guard let type = valueTypeNode(annotation: annotation, initializer: binding.initializer?.value) else {
+          continue
+        }
+        props.append(
+          ExportedViewProp(
+            name: name,
+            type: type,
+            defaultValue: binding.initializer?.value.trimmedDescription,
+            accessLevel: spelledAccessLevel(of: varDecl.modifiers),
+            platforms: platforms
+          )
+        )
+      }
+    }
+    return (props, events)
+  }
+
   /// The declared cases of an enum, in source order. One `case` declaration can introduce several
   /// cases (`case a, b`), so each element is read separately. A case carrying associated values is
   /// skipped: it has no raw value, so it can't cross the boundary as one.
@@ -533,8 +639,10 @@ final class SurfaceVisitor: SyntaxVisitor {
 
   /// Projects a parameter clause into `ExportedParameter`s: label = first name, name = second (else
   /// first), `optional` when it has a default value or an optional type, and the default as written.
+  /// A parameter that takes the JavaScript runtime (its type is written as `JavaScriptRuntime`) is left
+  /// out: the binding passes the runtime itself, and JavaScript doesn't see the parameter.
   private func parameters(of clause: FunctionParameterClauseSyntax) -> [ExportedParameter] {
-    clause.parameters.map { parameter in
+    clause.parameters.filter { !takesRuntime($0) }.map { parameter in
       let label = parameter.firstName.identifierName
       let name = parameter.secondName?.identifierName ?? label
       return ExportedParameter(
@@ -694,6 +802,35 @@ private func underlyingFunctionType(of type: TypeSyntax?) -> FunctionTypeSyntax?
   return type.as(FunctionTypeSyntax.self)
 }
 
+/// True when a parameter takes the JavaScript runtime: its type, without specifiers such as `borrowing`,
+/// is written as `JavaScriptRuntime` or `….JavaScriptRuntime`, or as an optional of it. This matches
+/// `isRuntimeParameter` in the macros: a type that also carries attributes (`@Sendable`) isn't one.
+private func takesRuntime(_ parameter: FunctionParameterSyntax) -> Bool {
+  var type = parameter.type
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    guard attributed.attributes.isEmpty else {
+      return false
+    }
+    type = attributed.baseType
+  }
+  if let optional = type.as(OptionalTypeSyntax.self) {
+    type = optional.wrappedType
+  } else if let implicitlyUnwrapped = type.as(ImplicitlyUnwrappedOptionalTypeSyntax.self) {
+    type = implicitlyUnwrapped.wrappedType
+  } else if let identifier = type.as(IdentifierTypeSyntax.self), identifier.name.text == "Optional",
+    let argument = identifier.genericArgumentClause?.arguments.first, case .type(let wrapped) = argument.argument
+  {
+    type = wrapped
+  }
+  if let identifier = type.as(IdentifierTypeSyntax.self) {
+    return identifier.name.text == "JavaScriptRuntime"
+  }
+  if let member = type.as(MemberTypeSyntax.self) {
+    return member.name.text == "JavaScriptRuntime"
+  }
+  return false
+}
+
 /// True when an event's function type returns `Void`. The shared `isVoidType` is not reused: it
 /// accepts neither `Swift.Void` nor a parenthesized `(Void)`, so it would drop valid events.
 private func isVoidEventReturn(_ type: TypeSyntax) -> Bool {
@@ -706,6 +843,44 @@ private func isVoidEventReturn(_ type: TypeSyntax) -> Bool {
   return text == "Void" || text == "()" || text == "Swift.Void"
 }
 
+/// The function type a `@ViewProps` property declares, or `nil` when the type isn't a function.
+/// Unwraps parentheses, attributes (`@Sendable`), and the optional spellings `T?`, `T!`, and
+/// `Optional<T>`, like `underlyingFunctionType` in `ViewPropsMacro`.
+private func viewEventFunctionType(of type: TypeSyntax) -> FunctionTypeSyntax? {
+  if let functionType = type.as(FunctionTypeSyntax.self) {
+    return functionType
+  }
+  if let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1, let only = tuple.elements.first {
+    return viewEventFunctionType(of: only.type)
+  }
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return viewEventFunctionType(of: attributed.baseType)
+  }
+  if let optional = type.as(OptionalTypeSyntax.self) {
+    return viewEventFunctionType(of: optional.wrappedType)
+  }
+  if let implicitlyUnwrapped = type.as(ImplicitlyUnwrappedOptionalTypeSyntax.self) {
+    return viewEventFunctionType(of: implicitlyUnwrapped.wrappedType)
+  }
+  if let identifier = type.as(IdentifierTypeSyntax.self),
+    identifier.name.text == "Optional",
+    let argument = identifier.genericArgumentClause?.arguments.first,
+    case .type(let wrapped) = argument.argument
+  {
+    return viewEventFunctionType(of: wrapped)
+  }
+  return nil
+}
+
+/// True when a `@ViewProps` event is written as an optional (`(() -> Void)?`, also after attributes),
+/// which the macro rejects. Like the macros' `isOptionalType`, it reads only the outermost type.
+private func isOptionalEventType(_ type: TypeSyntax) -> Bool {
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return isOptionalEventType(attributed.baseType)
+  }
+  return isOptionalType(type)
+}
+
 /// 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.
@@ -836,9 +1011,10 @@ private func isTypeLevel(_ modifiers: DeclModifierListSyntax) -> Bool {
   }
 }
 
-/// True when a modifier excludes a property from being a `@Record` field (`static`, `class`,
-/// `private`, `fileprivate`, `lazy`), mirroring `RecordMacro.isExcludedByModifier`.
-private func isExcludedRecordModifier(_ modifiers: DeclModifierListSyntax) -> Bool {
+/// True when a modifier excludes a property from being a `@Record` field or a `@ViewProps` prop
+/// (`static`, `class`, `private`, `fileprivate`, `lazy`), mirroring `isExcludedByModifier` in the
+/// macros.
+private func isExcludedByModifier(_ modifiers: DeclModifierListSyntax) -> Bool {
   modifiers.contains { modifier in
     switch modifier.name.tokenKind {
     case .keyword(.static), .keyword(.class), .keyword(.private), .keyword(.fileprivate), .keyword(.lazy):
@@ -951,9 +1127,17 @@ func rawValueType(of clause: InheritanceClauseSyntax?) -> TypeNode? {
   return typeNode(from: first)
 }
 
-/// True when a type is written as an optional: `T?`, `T!`, or `Optional<T>`, mirroring the macros'
-/// `isOptionalType`.
+/// True when a type is written as an optional: `T?`, `T!`, or `Optional<T>`, also in parentheses
+/// (`(T?)`) or behind attributes, mirroring the macros' `isOptionalType`.
 private func isOptionalType(_ type: TypeSyntax) -> Bool {
+  if let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1, let only = tuple.elements.first,
+    only.firstName == nil
+  {
+    return isOptionalType(only.type)
+  }
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return isOptionalType(attributed.baseType)
+  }
   if type.is(OptionalTypeSyntax.self) || type.is(ImplicitlyUnwrappedOptionalTypeSyntax.self) {
     return true
   }
@@ -963,13 +1147,14 @@ private func isOptionalType(_ type: TypeSyntax) -> Bool {
   return false
 }
 
-/// The first attribute whose spelled name matches `name`. A local copy of the macros' helper (the
-/// macro target can't be imported here).
+/// The first attribute whose name matches `name` as `attributeName(of:)` reads it, so
+/// `@ExpoView<CardProps>` and `@ExpoModulesCore.ExpoView<CardProps>` match `ExpoView`. A local copy of
+/// the macros' helper (the macro target can't be imported here).
 extension AttributeListSyntax {
   fileprivate func firstAttribute(named name: String) -> AttributeSyntax? {
     for element in self {
       if let attribute = element.as(AttributeSyntax.self),
-        attribute.attributeName.trimmedDescription == name
+        attributeName(of: attribute) == name
       {
         return attribute
       }

package/apple/Sources/ExpoModulesCLI/Commands/ScanModules/ScanModules.swift

@@ -34,8 +34,8 @@ public enum Scanner {
   }
 }
 
-/// 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:
+/// One class in the `scan-modules` output: an `@ExpoModule` class in `modules`, a `@SharedObject`
+/// class in `sharedObjects`, or an `@ExpoView` class in `views`. 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
@@ -45,7 +45,7 @@ struct ScannedClass: Codable, Equatable {
   let name: String
 
   /// 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
+  /// present, otherwise the class name. `@ExpoView` takes no name, so a view's JS name is its 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
 
@@ -70,7 +70,7 @@ struct ScannedClass: Codable, Equatable {
 /// `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. A new field that older
-/// consumers can ignore, such as `sharedObjects`, doesn't change the version.
+/// consumers can ignore, such as `sharedObjects` or `views`, doesn't change the version.
 let scanModulesSchemaVersion = 2
 
 /// The `scan-modules` result: the detected modules plus the stats describing the run. Encoded as the
@@ -84,6 +84,10 @@ struct ScanModulesResult: Codable, Equatable {
   /// `modules`.
   let sharedObjects: [ScannedClass]
 
+  /// The top-level `@ExpoView` classes, in the same order and with the same platform rules as
+  /// `modules`.
+  let views: [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.
   let warnings: [ScanWarning]
@@ -102,7 +106,7 @@ private let platformUniverse: [(condition: String, reported: String)] = [
   (condition: "visionOS", reported: "visionOS"),
 ]
 
-/// Scans the given paths for top-level `@ExpoModule` and `@SharedObject` types and returns every one
+/// Scans the given paths for top-level `@ExpoModule`, `@SharedObject` and `@ExpoView` 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
@@ -115,10 +119,11 @@ private let platformUniverse: [(condition: String, reported: String)] = [
 func scanModules(paths: [String], defines: Set<String> = []) -> ScanModulesResult {
   var modules: [ScannedClass] = []
   var sharedObjects: [ScannedClass] = []
+  var views: [ScannedClass] = []
   var warnings: [ScanWarning] = []
   var seenWarnings = Set<ScanWarning>()
 
-  let macros: Set<DetectedMacro> = [.expoModule, .sharedObject]
+  let macros: Set<DetectedMacro> = [.expoModule, .sharedObject, .expoView]
   let stats = scanFiles(paths: paths, macros: macros) { source, file in
     let tree = Parser.parse(source: source)
 
@@ -162,6 +167,8 @@ func scanModules(paths: [String], defines: Set<String> = []) -> ScanModulesResul
       switch detection.macro {
       case .sharedObject:
         sharedObjects.append(scanned)
+      case .expoView:
+        views.append(scanned)
       default:
         modules.append(scanned)
       }
@@ -172,6 +179,7 @@ func scanModules(paths: [String], defines: Set<String> = []) -> ScanModulesResul
     schemaVersion: scanModulesSchemaVersion,
     modules: modules,
     sharedObjects: sharedObjects,
+    views: views,
     warnings: warnings,
     stats: stats
   )

package/apple/Sources/ExpoModulesCLI/Core/Detection.swift

@@ -7,6 +7,8 @@ enum DetectedMacro: String, Codable, CaseIterable {
   case sharedObject = "SharedObject"
   case record = "Record"
   case union = "Union"
+  case expoView = "ExpoView"
+  case viewProps = "ViewProps"
 }
 
 /// A single argument passed to a macro, e.g. `"Foo"` or `classes: [Bar.self]`. The label is `nil`
@@ -43,6 +45,10 @@ struct Detection: Codable, Equatable {
   /// `@SharedObject("Baz")`, otherwise `nil` (the name defaults to `name` at expansion time).
   let jsName: String?
 
+  /// The generic argument of the attribute as written, which is the props type of `@ExpoView<CardProps>`,
+  /// otherwise `nil`.
+  var genericArgument: String? = nil
+
   /// Every argument passed to the macro, in source order, e.g. `@ExpoModule("Foo", classes: [Bar.self])`
   /// yields a positional `"Foo"` and a `classes:` argument. Empty when the macro is written bare.
   let arguments: [MacroArgument]

package/apple/Sources/ExpoModulesCLI/Core/DetectionVisitor.swift

@@ -3,7 +3,7 @@ import SwiftIfConfig
 import SwiftSyntax
 
 /// Walks a parsed source file and records top-level declarations carrying `@ExpoModule`, `@JS`,
-/// `@SharedObject`, or `@Record`. Only file-scope declarations are considered: these macros apply to
+/// `@SharedObject`, `@Record`, `@Union`, `@ExpoView`, or `@ViewProps`. Only file-scope declarations are considered: these macros apply to
 /// top-level types, so descending into type and function bodies would only surface false positives.
 /// Recognition mirrors the macros themselves — a purely syntactic match on the spelled attribute
 /// name — so it sees the same declarations the compiler would hand the plugin, without compiling
@@ -119,7 +119,7 @@ final class DetectionVisitor: SyntaxVisitor {
   ) {
     for element in attributes {
       guard let attribute = element.as(AttributeSyntax.self),
-        let macro = DetectedMacro(rawValue: attribute.attributeName.trimmedDescription),
+        let macro = DetectedMacro(rawValue: attributeName(of: attribute)),
         detectedMacros.contains(macro)
       else {
         continue
@@ -132,6 +132,7 @@ final class DetectionVisitor: SyntaxVisitor {
           declarationKind: kind,
           accessLevel: accessLevel(of: modifiers),
           jsName: stringArgument(of: attribute),
+          genericArgument: genericArgument(of: attribute),
           arguments: arguments(of: attribute),
           file: file,
           line: location.line,
@@ -155,6 +156,44 @@ private func accessLevel(of modifiers: DeclModifierListSyntax) -> String {
   return "internal"
 }
 
+/// The attribute's name without a generic argument clause, so `@ExpoView<CardProps>` is `ExpoView`. A
+/// name qualified with the module that declares the macros is read without the module, so
+/// `@ExpoModulesCore.ExpoView<CardProps>` is `ExpoView` too.
+func attributeName(of attribute: AttributeSyntax) -> String {
+  if let identifier = attribute.attributeName.as(IdentifierTypeSyntax.self) {
+    return identifier.name.text
+  }
+  if let member = attribute.attributeName.as(MemberTypeSyntax.self),
+    member.baseType.as(IdentifierTypeSyntax.self)?.name.text == macrosModuleName
+  {
+    return member.name.text
+  }
+  return attribute.attributeName.trimmedDescription
+}
+
+/// The module that declares the macros, which an attribute may be qualified with:
+/// `@ExpoModulesCore.ExpoView<CardProps>`.
+let macrosModuleName = "ExpoModulesCore"
+
+/// The first generic argument of the attribute as written, e.g. `@ExpoView<CardProps>` -> "CardProps".
+/// Returns `nil` when the attribute has no generic argument clause.
+private func genericArgument(of attribute: AttributeSyntax) -> String? {
+  return genericArgumentType(of: attribute)?.trimmedDescription
+}
+
+/// The first generic argument of the attribute, `CardProps` in `@ExpoView<CardProps>` and in
+/// `@ExpoModulesCore.ExpoView<CardProps>`, or `nil` when the attribute has no generic argument clause.
+/// Like `genericArgument(of:)` in `ExpoViewMacro`.
+func genericArgumentType(of attribute: AttributeSyntax) -> TypeSyntax? {
+  let clause =
+    attribute.attributeName.as(IdentifierTypeSyntax.self)?.genericArgumentClause
+    ?? attribute.attributeName.as(MemberTypeSyntax.self)?.genericArgumentClause
+  guard let first = clause?.arguments.first, case .type(let type) = first.argument else {
+    return nil
+  }
+  return type
+}
+
 /// Every argument passed to the attribute, in source order, each as a label (or `nil` when
 /// positional) plus the value expression's source text. Returns an empty array when the attribute
 /// is written bare (`@ExpoModule`) or with empty parens.

package/apple/Sources/ExpoModulesCLI/Core/SourceScan.swift

@@ -106,9 +106,10 @@ struct MacroPrefilter {
   }
 
   /// A pre-filter for attributes that `DetectedMacro` doesn't list, such as every macro that `expand`
-  /// runs.
+  /// runs. Each name also matches qualified with the module that declares the macros
+  /// (`@ExpoModulesCore.ExpoView`), since the scanners read that spelling as the bare one.
   init(attributeNames: Set<String>, conformances: Set<String> = []) {
-    attributes = attributeNames.map { Array($0.utf8) }
+    attributes = attributeNames.flatMap { [Array($0.utf8), Array("\(macrosModuleName).\($0)".utf8)] }
     bareNames = conformances.map { Array($0.utf8) }
   }