expo-modules-macros 0.32.0 → 0.34.0

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

@@ -39,6 +39,10 @@ import SwiftSyntaxMacros
 ///   event without an initial value an empty closure (`{}`, `{ _ in }`, ...) and leaves the value
 ///   props at their initial values. It is never generated when the type declares its own `init()`.
 ///   Like any initializer in the struct body, the generated one removes the memberwise initializer.
+/// - `_resetViewProp(_:in:)`: sets one value prop back to its default, by assigning the property's
+///   initial value or `nil`, so a reset evaluates only that prop's default. It is a static member of
+///   the struct body, because an initial value can name a static member without `Self.` or a member of
+///   an enclosing type, which an instance method or the extension can't.
 ///
 /// An event's function type must return `Void`, because JavaScript can't return a value to it.
 ///
@@ -47,7 +51,16 @@ import SwiftSyntaxMacros
 /// - `allProps`: every bit set, the changed set on the first application.
 /// - `propSet(for:)`: one name's bit, for folding raw changed keys into the mask.
 /// - `_decode(_:from:in:)`: assigns one value prop from a JavaScript value. `null` and `undefined`
-///   reset it to its value in `Self()`, and any other value decodes through `JavaScriptDecodable`.
+///   reset it with `_resetViewProp(_:in:)`, and any other value decodes through
+///   `JavaScriptDecodable`.
+///
+/// `_decode` and `_resetViewProp` run on the JavaScript actor. The other generated types and members
+/// and the conformance are `nonisolated`, so core can use them on any thread also when the module
+/// builds with a default isolation, such as `-default-isolation MainActor`. The props' own
+/// declarations still take that isolation, so a struct with an event prop, a value prop whose type
+/// isn't `Sendable`, or a computed prop needs `nonisolated` on its declaration, and the author's
+/// `init()` must be `nonisolated` too. So must a conformance that the author declares
+/// (`: nonisolated AnyViewProps`).
 ///
 /// Author-facing shape — no conformance to spell out:
 ///
@@ -83,6 +96,9 @@ public struct ViewPropsMacro: MemberMacro, ExtensionMacro {
     if let initializer = defaultInitializer(props: props) {
       members.append(initializer)
     }
+    if let reset = resetFunction(valueProps: props.valueProps) {
+      members.append(reset)
+    }
     return members
   }
 
@@ -120,29 +136,33 @@ public struct ViewPropsMacro: MemberMacro, ExtensionMacro {
       ? "0"
       : "0b" + String(repeating: "1", count: props.valueProps.count)
 
-    // With no value prop there's nothing to switch over, so return the empty set.
+    // With no value prop, `PropName` has no case, so the function can't be called and its body is
+    // empty, like the one of `_decode`. Swift reports any statement in it, also an empty `switch`, as
+    // "will never be executed". The body starts with a line break, so the empty one closes on the
+    // next line.
     let propSetBody: String
     if props.valueProps.isEmpty {
-      propSetBody = "    return []"
+      propSetBody = ""
     } else {
       let cases = props.valueProps
         .map { "    case .\($0.name):\n      return .\($0.name)" }
         .joined(separator: "\n")
-      propSetBody = "    switch name {\n\(cases)\n    }"
+      propSetBody = "\n    switch name {\n\(cases)\n    }"
     }
 
     let decodeBody = decodeFunctionBody(valueProps: props.valueProps)
 
-    let conformanceClause = alreadyConforms ? "" : ": \(viewPropsProtocolName)"
+    // `nonisolated` keeps the conformance and its members usable on the JavaScript thread when the
+    // module builds with a default isolation, which would otherwise isolate them to the main actor.
+    let conformanceClause = alreadyConforms ? "" : ": nonisolated \(viewPropsProtocolName)"
     let ext: DeclSyntax = """
       extension \(type.trimmed)\(raw: conformanceClause) {
-        public static let allProps = PropSet(rawValue: \(raw: allPropsMask))
+        nonisolated public static let allProps = PropSet(rawValue: \(raw: allPropsMask))
 
         /// `@inlinable` so core's raw-key fold can inline the lookup across the module boundary:
         /// it runs once per changed key per props batch.
         @inlinable
-        public static func propSet(for name: PropName) -> PropSet {
-      \(raw: propSetBody)
+        nonisolated public static func propSet(for name: PropName) -> PropSet {\(raw: propSetBody)
         }
 
         @JavaScriptActor
@@ -488,9 +508,11 @@ private struct ViewProp {
   /// The property's declared type, verbatim, or the type of its literal initial value. `_decode`
   /// doesn't spell it: the decoded type is inferred from the assignment.
   let type: String
-  /// Whether the prop is computed with a `mutating get`, which `_decode` can only read from a
+  /// Whether the prop is computed with a `mutating get`, which `_resetViewProp` can only read from a
   /// mutable value.
   let hasMutatingGetter: Bool
+  /// What `_resetViewProp` assigns when React removes the prop. Events aren't reset.
+  let defaultValue: PropDefault
 
   /// The name with any escaping backticks removed: the JS-visible key, so the enum's raw value and
   /// `_eventNames` both read `"default"`, never `` "`default`" ``.
@@ -499,6 +521,49 @@ private struct ViewProp {
   }
 }
 
+/// The value that a value prop goes back to when React removes it. Each one equals the prop's value
+/// in `Self()`.
+private enum PropDefault {
+  /// The initial value of a stored property, as written. Evaluating it again gives the value that
+  /// `Self()` gives the property.
+  case initialValue(ExprSyntax)
+  /// The implicit `nil` of a `var` whose type is written as `T?` or `T!`.
+  case implicitNil
+  /// The prop's value in a new `Self()`, when the macro can't tell it from the declaration: the
+  /// struct declares its own `init()`, which can set any value, the prop is computed, the property
+  /// has an attribute, such as a property wrapper, whose value after `init(wrappedValue:)` can differ
+  /// from its initial value, or the initial value has a `#` expression, such as `#function` or
+  /// `#line`, whose value depends on where it's evaluated.
+  case newInstance
+}
+
+/// The default of a property with the given binding, for a struct that does or doesn't declare its own
+/// `init()`.
+private func propDefault(
+  of binding: PatternBindingSyntax,
+  in varDecl: VariableDeclSyntax,
+  declaredType: TypeSyntax?,
+  declaresUsableInitializer: Bool
+) -> PropDefault {
+  if declaresUsableInitializer || !isStoredBinding(binding) || !varDecl.attributes.isEmpty {
+    return .newInstance
+  }
+  if let initializer = binding.initializer {
+    // A macro expansion, also a literal such as `#function`, can depend on where it's evaluated, so
+    // a copy in `_resetViewProp` could give another value.
+    let hasPoundExpression = initializer.value.tokens(viewMode: .sourceAccurate).contains {
+      $0.tokenKind == .pound
+    }
+    return hasPoundExpression ? .newInstance : .initialValue(initializer.value)
+  }
+  if varDecl.bindingSpecifier.tokenKind == .keyword(.var), let declaredType, hasImplicitNilDefault(declaredType) {
+    return .implicitNil
+  }
+  // A value prop without a default is reported, so this is only reached for an event, which isn't
+  // reset.
+  return .newInstance
+}
+
 /// An event prop declared without an initial value, which the generated `init()` assigns.
 private struct EventDefault {
   /// The property name as written, backticks included.
@@ -664,7 +729,17 @@ private func validatedViewProps(
       // Only stored storage takes an initial value; a computed prop with a setter needs none.
       let needsInitialValue =
         binding.initializer == nil && isStoredBinding(binding) && !declaresUsableInitializer
-      let prop = ViewProp(name: name, type: resolvedType, hasMutatingGetter: hasMutatingGetter(binding))
+      let prop = ViewProp(
+        name: name,
+        type: resolvedType,
+        hasMutatingGetter: hasMutatingGetter(binding),
+        defaultValue: propDefault(
+          of: binding,
+          in: varDecl,
+          declaredType: declaredType,
+          declaresUsableInitializer: declaresUsableInitializer
+        )
+      )
       if let eventFunctionType {
         // An event is dispatched to JavaScript, which can't hand a value back to the caller.
         if !returnsVoid(eventFunctionType) {
@@ -861,17 +936,6 @@ private func isVoidType(_ type: TypeSyntax) -> Bool {
   return ["Void", "Swift.Void"].contains(type.trimmedDescription)
 }
 
-/// The type inside any number of unlabeled one-element parentheses: `(T)` and `((T))` are `T`. A
-/// label would make it a tuple, which Swift rejects with a single element anyway.
-private func withoutParentheses(_ type: TypeSyntax) -> TypeSyntax {
-  guard let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1, let only = tuple.elements.first,
-    only.firstName == nil
-  else {
-    return type
-  }
-  return withoutParentheses(only.type)
-}
-
 /// True if the binding is computed with a `mutating get`.
 private func hasMutatingGetter(_ binding: PatternBindingSyntax) -> Bool {
   guard case .accessors(let accessors) = binding.accessorBlock?.accessors else {
@@ -937,6 +1001,10 @@ private func underlyingFunctionType(of type: TypeSyntax) -> FunctionTypeSyntax?
 /// Emitted even when empty, so a props type with only events still conforms. An enum with no cases
 /// can't declare a raw type, so the empty one conforms to `RawRepresentable` by hand, with `String`
 /// as its `RawValue` like the others.
+///
+/// The enum is `@frozen`, so the `switch` in the `@inlinable` `propSet(for:)` compiles in a module
+/// built with library evolution, where it would otherwise need a case for unknown values. The cases
+/// and their order are already part of the ABI, as the bits of `PropSet`.
 private func propNameEnum(valueProps: [ViewProp]) -> DeclSyntax {
   // An escaped case takes its raw value from the bare identifier already, but spelling it out keeps
   // the wire key visible in the generated source and independent of that implicit rule.
@@ -950,7 +1018,7 @@ private func propNameEnum(valueProps: [ViewProp]) -> DeclSyntax {
     .joined(separator: "\n")
   if valueProps.isEmpty {
     return """
-      public enum PropName: RawRepresentable, CaseIterable {
+      @frozen nonisolated public enum PropName: RawRepresentable, CaseIterable {
         public init?(rawValue: String) {
           return nil
         }
@@ -963,7 +1031,7 @@ private func propNameEnum(valueProps: [ViewProp]) -> DeclSyntax {
       """
   }
   return """
-    public enum PropName: String, CaseIterable {
+    @frozen nonisolated public enum PropName: String, CaseIterable {
     \(raw: cases)
     }
     """
@@ -981,7 +1049,7 @@ private func propSetStruct(valueProps: [ViewProp]) -> DeclSyntax {
 
   if valueProps.isEmpty {
     return """
-      public struct PropSet: OptionSet, Sendable {
+      nonisolated public struct PropSet: OptionSet, Sendable {
         public let rawValue: UInt64
 
         public init(rawValue: UInt64) {
@@ -991,7 +1059,7 @@ private func propSetStruct(valueProps: [ViewProp]) -> DeclSyntax {
       """
   }
   return """
-    public struct PropSet: OptionSet, Sendable {
+    nonisolated public struct PropSet: OptionSet, Sendable {
       public let rawValue: UInt64
 
       public init(rawValue: UInt64) {
@@ -1009,31 +1077,23 @@ private func propSetStruct(valueProps: [ViewProp]) -> DeclSyntax {
 private func eventNamesConstant(eventProps: [ViewProp]) -> DeclSyntax {
   let names = eventProps.map { "\"\($0.wireName)\"" }.joined(separator: ", ")
   return """
-    public static let _eventNames: [String] = [\(raw: names)]
+    nonisolated public static let _eventNames: [String] = [\(raw: names)]
     """
 }
 
 /// The body of `_decode`, which core calls once per changed prop. React sends a removed prop as
-/// `null`, so `null` and `undefined` reset the prop to its value in a fresh `Self()`; any other value
-/// decodes through `JavaScriptDecodable`, with the type inferred from the assignment. The helper is a
-/// static member of `AnyViewProps`, reached through `Self.`, so a prop named `_decodeViewProp`
-/// doesn't shadow it. The checks run
-/// once, before the switch, so each case is a single assignment. Members are reached through `self.`
-/// so that a prop named like a parameter (`value`, `runtime`) isn't shadowed by it.
+/// `null`, so `null` and `undefined` reset the prop with `_resetViewProp`; any other value decodes
+/// through `JavaScriptDecodable`, with the type inferred from the assignment. `_decodeViewProp` is a
+/// static member of `AnyViewProps`, reached through `Self.`, so a prop with the same name doesn't
+/// shadow it. The checks run once, before the switch, so each case is a single assignment. Members
+/// are reached through `self.` so that a prop named like a parameter (`value`, `runtime`) isn't
+/// shadowed by it.
 ///
 /// With no value prop the body is empty: `PropName` is uninhabited, so the function is never called.
-///
-/// `defaults` is a `var` only when a prop has a `mutating get`, which can't be read from a constant.
-/// Otherwise it's a `let`, so the common case gets no "never mutated" warning.
 private func decodeFunctionBody(valueProps: [ViewProp]) -> String {
   if valueProps.isEmpty {
     return ""
   }
-  let defaultsSpecifier = valueProps.contains(where: \.hasMutatingGetter) ? "var" : "let"
-  let resetCases =
-    valueProps
-    .map { "      case .\($0.name):\n        self.\($0.name) = defaults.\($0.name)" }
-    .joined(separator: "\n")
   let decodeCases =
     valueProps
     .map { "    case .\($0.name):\n      self.\($0.name) = try Self._decodeViewProp(value, in: runtime)" }
@@ -1043,10 +1103,7 @@ private func decodeFunctionBody(valueProps: [ViewProp]) -> String {
   return """
 
         if value.isNull() || value.isUndefined() {
-          \(defaultsSpecifier) defaults = Self()
-          switch name {
-    \(resetCases)
-          }
+          Self._resetViewProp(name, in: &self)
           return
         }
         switch name {
@@ -1055,6 +1112,79 @@ private func decodeFunctionBody(valueProps: [ViewProp]) -> String {
     """
 }
 
+/// `_resetViewProp(_:in:)`, which sets one value prop back to its default when React removes it. Each
+/// case assigns the prop's initial value or `nil`, so a reset evaluates only that prop's default. A
+/// prop whose default the macro can't tell from the declaration reads it from a new `Self()`.
+///
+/// A static function of the struct body resolves names as a property initializer does: a static
+/// member without `Self.` and a member of an enclosing type, which `_decode` in the extension can't
+/// name. The parameters are `_name` and `_props`, with a number after the name when an initial value
+/// uses it, so they don't hide a declaration that an initial value names.
+///
+/// A default argument such as `#function` or `#line` of a function that an initial value calls gets
+/// the location of `_resetViewProp`, which the macro can't see.
+///
+/// `nil` with no value prop: `PropName` is uninhabited, so `_decode` never resets.
+private func resetFunction(valueProps: [ViewProp]) -> DeclSyntax? {
+  if valueProps.isEmpty {
+    return nil
+  }
+  let usedNames = Set(
+    valueProps.flatMap { prop -> [String] in
+      guard case .initialValue(let expression) = prop.defaultValue else {
+        return []
+      }
+      return expression.tokens(viewMode: .sourceAccurate).compactMap { token in
+        guard case .identifier(let text) = token.tokenKind else {
+          return nil
+        }
+        return withoutBackticks(text)
+      }
+    }
+  )
+  let nameParameter = unusedName("_name", in: usedNames)
+  let propsParameter = unusedName("_props", in: usedNames)
+  let cases =
+    valueProps
+    .map { prop -> String in
+      let assignment: String
+      switch prop.defaultValue {
+      case .initialValue(let expression):
+        assignment = "\(propsParameter).\(prop.name) = \(expression.trimmedDescription)"
+      case .implicitNil:
+        assignment = "\(propsParameter).\(prop.name) = nil"
+      case .newInstance where prop.hasMutatingGetter:
+        // A mutating getter can't be read from a constant. The local is scoped to its case, where
+        // no initial value is copied.
+        assignment = "var _defaults = Self()\n    \(propsParameter).\(prop.name) = _defaults.\(prop.name)"
+      case .newInstance:
+        assignment = "\(propsParameter).\(prop.name) = Self().\(prop.name)"
+      }
+      return "  case .\(prop.name):\n    \(assignment)"
+    }
+    .joined(separator: "\n")
+  return """
+    @JavaScriptActor
+    static func _resetViewProp(_ \(raw: nameParameter): PropName, in \(raw: propsParameter): inout Self) {
+      switch \(raw: nameParameter) {
+    \(raw: cases)
+      }
+    }
+    """
+}
+
+/// `base`, or `base` with the lowest number after it that gives a name not in `names`.
+private func unusedName(_ base: String, in names: Set<String>) -> String {
+  if !names.contains(base) {
+    return base
+  }
+  var number = 1
+  while names.contains("\(base)\(number)") {
+    number += 1
+  }
+  return "\(base)\(number)"
+}
+
 /// The public `init()` that `AnyViewProps` requires, when Swift's own can't satisfy it: it gives each
 /// event prop without an initial value an empty closure, and leaves the value props at their initial
 /// values. `nil` when the type declares a usable `init()`, or when Swift's `init()` is enough (see
@@ -1065,7 +1195,7 @@ private func defaultInitializer(props: ViewPropsModel) -> DeclSyntax? {
   }
   if props.eventDefaults.isEmpty {
     return """
-      public init() {
+      nonisolated public init() {
       }
       """
   }
@@ -1073,7 +1203,7 @@ private func defaultInitializer(props: ViewPropsModel) -> DeclSyntax? {
     .map { "  self.\($0.name) = \($0.emptyClosure)" }
     .joined(separator: "\n")
   return """
-    public init() {
+    nonisolated public init() {
     \(raw: assignments)
     }
     """

package/apple/Sources/ExpoModulesMacrosCore/ProvidedMacros.swift

@@ -25,7 +25,7 @@ public struct ProvidedMacro {
         conformances: ["JavaScriptDecodable", "JavaScriptEncodable"]
       ),
       ProvidedMacro(name: "ViewProps", type: ViewPropsMacro.self, conformances: ["AnyViewProps"]),
-      ProvidedMacro(name: "ExpoView", type: ExpoViewMacro.self),
+      ProvidedMacro(name: "ExpoView", type: ExpoViewMacro.self, conformances: ["AnyNativeView"]),
     ]
   }
 }

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

@@ -17,10 +17,17 @@ import SwiftSyntax
 /// A synchronous function marked `@JS(.withAsync("name"))` also binds a promise-returning variant
 /// under that name (see `asyncVariant`). It decodes and encodes like an `async` function, and calls
 /// the function on the concurrent pool.
+///
+/// A synchronous function can take the JavaScript runtime as its last parameter,
+/// `in runtime: borrowing JavaScriptRuntime`. JavaScript doesn't see it: the binding passes the runtime
+/// of the call.
 internal struct JSFunction {
   let swiftName: String
   private(set) var jsName: String
+  /// The parameters that take JavaScript arguments, without the runtime parameter.
   let parameters: [FunctionParameterSyntax]
+  /// The label of the parameter that takes the JavaScript runtime, or `nil` when the function has none.
+  private let runtimeLabel: String?
   /// The declared return type as written, or `nil` when the function returns `Void`/nothing.
   let returnType: String?
   /// How the return value encodes when its type mentions `Any`, or `nil` for any other type.
@@ -39,7 +46,9 @@ internal struct JSFunction {
     self.swiftName = funcDecl.name.text
     self.jsName = jsNameArgument(of: attribute) ?? withoutBackticks(funcDecl.name.text)
     self.nameToken = funcDecl.name
-    self.parameters = Array(funcDecl.signature.parameterClause.parameters)
+    let declaredParameters = funcDecl.signature.parameterClause.parameters
+    self.parameters = declaredParameters.filter { !isRuntimeParameter($0) }
+    self.runtimeLabel = declaredParameters.first(where: isRuntimeParameter)?.firstName.text
 
     let declaredReturnType = funcDecl.signature.returnClause?.type
     self.returnType = isVoidType(declaredReturnType) ? nil : declaredReturnType?.trimmedDescription
@@ -264,6 +273,9 @@ internal struct JSFunction {
       }
       callArguments.append(label == "_" ? value : "\(label): \(value)")
     }
+    if let runtimeLabel {
+      callArguments.append(runtimeLabel == "_" ? "runtime" : "\(runtimeLabel): runtime")
+    }
     return callArguments.joined(separator: ", ")
   }
 
@@ -338,12 +350,14 @@ internal struct JSFunction {
     // returns nothing binds through the `Void` overload (`JavaScriptRuntime.VoidFunctionClosure`)
     // instead, which leaves JS's result as `undefined`. A call through it is faster than through a
     // result-slot closure that writes nothing. The closure declares `-> Void` because a body of several
-    // statements without a `return` is otherwise ambiguous between the overloads.
+    // statements without a `return` is otherwise ambiguous between the overloads. A function that takes
+    // the runtime binds through the result-slot overload even when it returns nothing, so it gets the
+    // runtime as the closure's parameter instead of capturing the decorator's.
     let captures = receiver.captureClause
     let parameters =
       isAsync
       ? "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
-      : returnType == nil
+      : returnType == nil && runtimeLabel == nil
         ? "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer) -> Void"
         : resultSlotClosureParameters
 

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

@@ -4,12 +4,18 @@ import SwiftSyntax
 /// have a single constructor). Instead of a `Constructor { … }` DSL entry, the macro synthesizes an
 /// override of `SharedObject._constructSharedObject(...)` that decodes the JS arguments and returns a
 /// fresh instance; unlike the method/property bindings it produces the native instance rather than
-/// recovering one.
+/// recovering one. Like a function, it can take the JavaScript runtime as its last parameter.
 internal struct JSConstructor {
+  /// The parameters that take JavaScript arguments, without the runtime parameter.
   let parameters: [FunctionParameterSyntax]
+  /// The label of the parameter that takes the JavaScript runtime, or `nil` when the initializer has
+  /// none.
+  private let runtimeLabel: String?
 
   init(initDecl: InitializerDeclSyntax) {
-    self.parameters = Array(initDecl.signature.parameterClause.parameters)
+    let declaredParameters = initDecl.signature.parameterClause.parameters
+    self.parameters = declaredParameters.filter { !isRuntimeParameter($0) }
+    self.runtimeLabel = declaredParameters.first(where: isRuntimeParameter)?.firstName.text
   }
 
   /// The body statements, indented with `indent`: arity guard, per-argument decode through
@@ -39,6 +45,9 @@ internal struct JSConstructor {
       let label = parameter.firstName.text
       callArguments.append(label == "_" ? "arg\(index)" : "\(label): arg\(index)")
     }
+    if let runtimeLabel {
+      callArguments.append(runtimeLabel == "_" ? "runtime" : "\(runtimeLabel): runtime")
+    }
 
     lines.append("return \(typeName)(\(callArguments.joined(separator: ", ")))")
 

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

@@ -111,9 +111,11 @@ internal func hasAsyncVariant(_ decl: DeclSyntaxProtocol) -> Bool {
   return asyncVariantOption(of: attribute) != nil
 }
 
-/// True if the type is written as an optional: `T?`, `T!`, or the explicit `Optional<T>`. Used to
-/// decide argument requiredness (an optional parameter may be omitted) and record-field nullability.
+/// True if the type is written as an optional: `T?`, `T!`, or the explicit `Optional<T>`, also in
+/// parentheses (`(T?)`), which Swift treats as the same type. Used to decide argument requiredness (an
+/// optional parameter may be omitted) and record-field nullability.
 internal func isOptionalType(_ type: TypeSyntax) -> Bool {
+  let type = withoutParentheses(type)
   if let attributed = type.as(AttributedTypeSyntax.self) {
     return isOptionalType(attributed.baseType)
   }
@@ -126,6 +128,17 @@ internal func isOptionalType(_ type: TypeSyntax) -> Bool {
   return false
 }
 
+/// True when the parameter takes the JavaScript runtime instead of a JavaScript argument: its type,
+/// without specifiers, is written as `JavaScriptRuntime` (or `….JavaScriptRuntime`), or as an optional
+/// of it. The binding passes the runtime of the call, and JavaScript doesn't see the parameter. `@JS`
+/// requires it to be the last parameter, labeled `in` or `runtime`, `borrowing` and not optional (see
+/// `diagnoseRuntimeParameter`). A macro can't resolve types, so a typealias or a subclass of
+/// `JavaScriptRuntime` isn't detected.
+internal func isRuntimeParameter(_ parameter: FunctionParameterSyntax) -> Bool {
+  let type = SpecifiedType(parameter.type).type
+  return baseIdentifier(of: optionalWrappedType(type) ?? type) == "JavaScriptRuntime"
+}
+
 /// A parameter's type split from the specifiers written in front of it (`borrowing`, `consuming`,
 /// `sending`, `inout`, `isolated`, ...). The specifiers aren't part of the type: the decode call and
 /// the conformance assertion need the bare type (`borrowing Point.decode(...)` isn't valid Swift), and
@@ -159,6 +172,17 @@ internal struct SpecifiedType {
 /// a fresh decoded value satisfies either way.
 internal let ownershipSpecifiers: Set<String> = ["borrowing", "consuming", "sending", "__shared", "__owned"]
 
+/// The type inside any number of unlabeled one-element parentheses: `(T)` and `((T))` are `T`. A
+/// label would make it a tuple, which Swift rejects with a single element anyway.
+internal func withoutParentheses(_ type: TypeSyntax) -> TypeSyntax {
+  guard let tuple = type.as(TupleTypeSyntax.self), tuple.elements.count == 1, let only = tuple.elements.first,
+    only.firstName == nil
+  else {
+    return type
+  }
+  return withoutParentheses(only.type)
+}
+
 /// The type wrapped by one optional layer (`T?`, `T!` or `Optional<T>`), or `nil` when the type isn't
 /// optional.
 internal func optionalWrappedType(_ type: TypeSyntax) -> TypeSyntax? {
@@ -607,8 +631,9 @@ internal func isExcludedByModifier(_ modifiers: DeclModifierListSyntax) -> Bool
 
 /// True if the type's inheritance clause already lists a protocol with the given name. Matches
 /// either the bare identifier (`Record`) or a qualified member access ending in the name
-/// (`ExpoModulesCore.Record`). Used by the extension macros to skip a conformance the author already
-/// spelled out. Works for `struct`, `class`, and `enum` declarations; any other declaration kind has no
+/// (`ExpoModulesCore.Record`), also with `nonisolated` or an attribute such as `@preconcurrency`
+/// before it. Used by the extension macros to skip a conformance the author already spelled out.
+/// Works for `struct`, `class`, and `enum` declarations; any other declaration kind has no
 /// inheritance clause to read and reports `false`.
 internal func inheritsProtocol(named name: String, in declaration: some DeclGroupSyntax) -> Bool {
   let inheritanceClause: InheritanceClauseSyntax?
@@ -624,5 +649,11 @@ internal func inheritsProtocol(named name: String, in declaration: some DeclGrou
   guard let inherited = inheritanceClause?.inheritedTypes else {
     return false
   }
-  return inherited.contains { baseIdentifier(of: $0.type) == name }
+  return inherited.contains { entry in
+    var type = entry.type
+    while let attributed = type.as(AttributedTypeSyntax.self) {
+      type = attributed.baseType
+    }
+    return baseIdentifier(of: type) == name
+  }
 }

package/apple/Sources/ExpoModulesMacrosPlugin/ExpoModulesMacrosPlugin.swift

@@ -0,0 +1 @@
+// Empty on purpose: this target only carries the dependency on the macro target (see Package.swift).

package/build/types.d.ts

@@ -368,6 +368,58 @@ export interface ExportedUnion extends ExportedAccess, ExportedAvailability {
     members: ExportedUnionMember[];
     file: string;
 }
+/**
+ * One value prop of a `@ViewProps` struct: a stored property that isn't function-typed. It has no
+ * `required`: native code resets a prop that React leaves out to its default, so JS can always omit
+ * one.
+ */
+export interface ExportedViewProp extends ExportedAccess, ExportedAvailability {
+    name: string;
+    type: TypeNode;
+    /** Optional-typed: true exactly when `type` is an `optional` node. */
+    optional: boolean;
+    /** The initial value as Swift source text, absent when none is written. */
+    defaultValue?: string;
+}
+/**
+ * One event of a `@ViewProps` struct: a function-typed stored property. Its name is the React prop
+ * name as written, with no `on` prefix stripped, so it has no `jsName`.
+ */
+export interface ExportedViewEvent extends ExportedAccess, ExportedAvailability {
+    /** The Swift property name, e.g. `onTap`. */
+    name: string;
+    /**
+     * The type of the function's single parameter, absent when it takes none (`() -> Void`) or more
+     * than one.
+     */
+    payload?: TypeNode;
+}
+/**
+ * An `@ExpoView` class with the props and events of the `@ViewProps` struct in its generic argument.
+ * It is reported on its own rather than under a module.
+ */
+export interface ExportedView extends ExportedAccess, ExportedAvailability {
+    /** The Swift class name. Only a view declared at file scope is reported. */
+    name: string;
+    /** The name the view registers under. `@ExpoView` takes no name, so it is always the class name. */
+    jsName: string;
+    /**
+     * The props type: the generic argument of `@ExpoView<CardProps>`, as written without backticks
+     * (`ExternalProps<Int>`), or the qualified name of the scanned `@ViewProps` struct it names
+     * (`CardView.Props`).
+     */
+    propsType: string;
+    /**
+     * The value props of the `@ViewProps` struct, in declaration order. Absent when the scan declares
+     * no struct named `propsType` on a platform of the view, so unknown props differ from no props. A
+     * struct declared in several `#if` branches contributes the props of each declaration whose
+     * platforms overlap the view's, and each prop keeps its own `platforms`.
+     */
+    props?: ExportedViewProp[];
+    /** The events of the `@ViewProps` struct, in declaration order. Absent when `props` is absent. */
+    events?: ExportedViewEvent[];
+    file: string;
+}
 /** The exported types grouped by kind. */
 export interface ExportedSurface {
     modules: ExportedModule[];
@@ -375,6 +427,7 @@ export interface ExportedSurface {
     records: ExportedRecord[];
     enums: ExportedEnum[];
     unions: ExportedUnion[];
+    views: ExportedView[];
 }
 /** A `#if` condition the scan couldn't answer statically. */
 export interface ScanWarning {
@@ -392,14 +445,14 @@ export interface ScanStats {
     durationMs: number;
 }
 /**
- * One class in the `scan-modules` output: an `@ExpoModule` class in `modules`, or a `@SharedObject`
- * class in `sharedObjects`.
+ * One class in the `scan-modules` output: an `@ExpoModule` class in `modules`, a `@SharedObject`
+ * class in `sharedObjects`, or an `@ExpoView` class in `views`.
  */
 export interface ScannedClass {
     name: string;
     /**
      * The resolved JS name: the `@ExpoModule("Foo")` or `@SharedObject("Foo")` override, else the class
-     * name.
+     * name. A view's JS name is its class name.
      */
     jsName: string;
     /**
@@ -422,6 +475,8 @@ export interface ScanModulesResult {
     modules: ScannedClass[];
     /** The top-level `@SharedObject` classes, with the same platform rules as `modules`. */
     sharedObjects: ScannedClass[];
+    /** The top-level `@ExpoView` classes, with the same platform rules as `modules`. */
+    views: ScannedClass[];
     warnings: ScanWarning[];
     stats: ScanStats;
 }

package/package.json

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