expo-modules-macros 0.31.0 → 0.33.0

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/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

@@ -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)
   }
@@ -159,6 +161,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? {
@@ -349,6 +362,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/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.31.0",
+  "version": "0.33.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.31.0",
-    "@expo/modules-macros-linux-x64": "0.31.0",
-    "@expo/modules-macros-win32-arm64": "0.31.0",
-    "@expo/modules-macros-win32-x64": "0.31.0"
+    "@expo/modules-macros-linux-arm64": "0.33.0",
+    "@expo/modules-macros-linux-x64": "0.33.0",
+    "@expo/modules-macros-win32-arm64": "0.33.0",
+    "@expo/modules-macros-win32-x64": "0.33.0"
   }
 }