@expo/expo-modules-macros-plugin 0.2.0 → 0.2.1

package/apple/Sources/ExpoModulesMacros/DecorateFunctionBuilder.swift

@@ -112,17 +112,39 @@ internal struct JSFunction {
   /// **strong** — the host-function closure is what keeps the native callable alive for as long as
   /// JS can invoke it; its lifetime is bounded by the JS VM's garbage collection of the object.
   /// `appContext` is captured **weak** (and guarded) so it doesn't form a real retain cycle through
-  /// the app context.
+  /// the app context. When no argument or return value goes through the dynamic-type converter the
+  /// body never references `appContext`, so the capture and guard are omitted to avoid the
+  /// unused-capture warning.
   var decorateStatements: String {
-    return """
-        object.setProperty("\(jsName)") { [weak appContext, self] this, arguments in
-          guard let appContext else {
-            throw Exceptions.AppContextLost()
+    if usesAppContext {
+      return """
+          object.setProperty("\(jsName)") { [weak appContext, self] this, arguments in
+            guard let appContext else {
+              throw Exceptions.AppContextLost()
+            }
+        \(bodyStatements(indent: "    "))
           }
+        """
+    }
+    return """
+        object.setProperty("\(jsName)") { [self] this, arguments in
       \(bodyStatements(indent: "    "))
         }
       """
   }
+
+  /// True when the host-function body references `appContext` — i.e. some parameter or the return
+  /// type lacks a fast accessor and decodes/encodes through `getDynamicType()`, which threads
+  /// `appContext` in.
+  private var usesAppContext: Bool {
+    if parameters.contains(where: { fastDecodeAccessor(for: $0.type.trimmedDescription) == nil }) {
+      return true
+    }
+    if let returnType, fastDecodeAccessor(for: returnType) == nil {
+      return true
+    }
+    return false
+  }
 }
 
 /**

package/apple/Sources/ExpoModulesMacros/JSMacro.swift

@@ -1,29 +1,93 @@
 import SwiftSyntax
 import SwiftSyntaxMacros
 
-/**
- Marker macro applied to module / shared-object members that should be exposed to JavaScript.
- Expands to nothing on its own; `@ExpoModule` and `@SharedObject` discover declarations
- carrying this attribute and generate the corresponding `Function` / `AsyncFunction` /
- `Property` / `Constructor` registrations.
-
- Usage:
-
-   @JS
-   func greet(name: String) -> String { ... }
-
-   @JS("doWork")
-   func performWork() async throws { ... }
-
-   @JS
-   var status: String { "ok" }
- */
+/// Marker macro applied to module / shared-object members that should be exposed to JavaScript.
+/// `@ExpoModule` and `@SharedObject` discover declarations carrying this attribute and generate the
+/// corresponding `Function` / `AsyncFunction` / `Property` / `Constructor` registrations; that part
+/// of the expansion lives in those macros.
+///
+/// On its own, `@JS` emits one thing: a never-called peer that asserts every type crossing the JS
+/// boundary is JS-convertible. Because it's a **peer** of the marked member, a non-conforming type
+/// produces a compile error located on the user's own `@JS` declaration rather than on the enclosing
+/// `@ExpoModule`. The assertion mechanism itself is shared (see `typeConformanceAssertion`); `@JS`
+/// only supplies the boundary types it reads off the declaration.
+///
+/// Usage:
+///
+///   @JS
+///   func greet(name: String) -> String { ... }
+///
+///   @JS("doWork")
+///   func performWork() async throws { ... }
+///
+///   @JS
+///   var status: String { "ok" }
 public struct JSMacro: PeerMacro {
   public static func expansion(
     of node: AttributeSyntax,
     providingPeersOf declaration: some DeclSyntaxProtocol,
     in context: some MacroExpansionContext
   ) throws -> [DeclSyntax] {
-    return []
+    guard let member = boundaryMember(of: declaration),
+      let assertion = typeConformanceAssertion(
+        for: ConformanceAssertion(name: member.name, types: member.types),
+        isStatic: member.isStatic
+      ) else {
+      return []
+    }
+    return [assertion]
+  }
+}
+
+/// What an assertion peer needs about the `@JS` member it sits beside: a name (to keep the peer
+/// unique among siblings), the types crossing the JS boundary, and whether the member is type-level.
+private struct BoundaryMember {
+  let name: String
+  /// Boundary types as written. Composed types (`[Int]`, `String?`, …) are kept verbatim — their
+  /// conditional conformances transitively constrain the elements.
+  let types: [String]
+  /// True for `static`/`class` members, so the peer is emitted in the same metatype context.
+  let isStatic: Bool
+}
+
+/// Reads the boundary member off a `@JS` declaration. A function contributes its parameter types
+/// plus the return type (when non-Void); a property contributes its declared type. Returns `nil` for
+/// declaration kinds `@JS` doesn't read types from, or a property whose type isn't spelled out (a
+/// syntactic macro can't recover it), so no assertion is emitted there.
+private func boundaryMember(of declaration: some DeclSyntaxProtocol) -> BoundaryMember? {
+  if let funcDecl = declaration.as(FunctionDeclSyntax.self) {
+    var types = funcDecl.signature.parameterClause.parameters.map { $0.type.trimmedDescription }
+    if let returnType = funcDecl.signature.returnClause?.type, !isVoidType(returnType) {
+      types.append(returnType.trimmedDescription)
+    }
+    return BoundaryMember(name: funcDecl.name.text, types: types, isStatic: isTypeLevel(funcDecl.modifiers))
   }
+
+  if let varDecl = declaration.as(VariableDeclSyntax.self),
+    let binding = varDecl.bindings.first,
+    let identifier = binding.pattern.as(IdentifierPatternSyntax.self),
+    let type = binding.typeAnnotation?.type {
+    return BoundaryMember(
+      name: identifier.identifier.text,
+      types: [type.trimmedDescription],
+      isStatic: isTypeLevel(varDecl.modifiers)
+    )
+  }
+
+  return nil
+}
+
+/// True when the modifiers make the member type-level (`static` or `class`), so its assertion peer
+/// must be emitted in the same metatype context rather than as an instance member.
+private func isTypeLevel(_ modifiers: DeclModifierListSyntax) -> Bool {
+  return modifiers.contains {
+    $0.name.tokenKind == .keyword(.static) || $0.name.tokenKind == .keyword(.class)
+  }
+}
+
+/// True when a return clause is written as `Void` / `()` — nothing crosses the boundary, so it needs
+/// no conformance assertion. (A missing return clause never reaches here: `returnClause` is `nil`.)
+private func isVoidType(_ type: TypeSyntax) -> Bool {
+  let text = type.trimmedDescription
+  return text == "Void" || text == "()"
 }

package/apple/Sources/ExpoModulesMacros/RecordMacro.swift

@@ -59,6 +59,18 @@ public struct RecordMacro: MemberMacro, ExtensionMacro {
     let existingInitLabels = initializerParameterLabels(of: declaration)
 
     var members: [DeclSyntax] = []
+
+    // A single never-called member that makes the compiler verify each property type is
+    // JS-convertible (the conversions below go through its dynamic-type API). Each property keeps its
+    // own named assertion inside, so the compiler's conformance diagnostic names the offending
+    // property (see `typeConformanceAssertions`). Emitted first so that, for a non-conforming type,
+    // this clear "requires that '…' conform to '…'" error is reported ahead of the noisier
+    // "no member 'getDynamicType'" errors from the conversion code below.
+    let assertions = properties.map { ConformanceAssertion(name: $0.name, types: [$0.type]) }
+    if let assertionMember = typeConformanceAssertions(for: assertions) {
+      members.append(assertionMember)
+    }
+
     if !existingInitLabels.contains([]) {
       if let defaultInit = defaultInit(properties: properties, isClass: isClass) {
         members.append(defaultInit)

package/apple/Sources/ExpoModulesMacros/TypeConformanceAssertion.swift

@@ -0,0 +1,105 @@
+import SwiftSyntax
+
+/// The protocol that every type crossing the JS boundary must conform to. Centralized here so the
+/// eventual rename (this is a placeholder name) is a single edit, and shared by every macro that
+/// asserts the conformance (`@JS`, `@Record`, …).
+internal let jsConvertibleProtocolName = "AnyArgument"
+
+/// Types we never assert because they're statically known to conform and never reach the dynamic
+/// converter: the JS primitives. Asserting them would only add noise to the expansion. Kept here
+/// (rather than reusing the decode-path's `fastDecodeAccessor`) because "known-to-conform" is a
+/// concept that belongs with the assertion logic, not with how a value is decoded.
+private let knownConformingPrimitives: Set<String> = ["Bool", "Int", "Double", "String"]
+
+/// One member's worth of conformance assertion: a name (the member it stands for) and the declared
+/// types crossing the JS boundary for it. The name surfaces verbatim in the compiler's conformance
+/// diagnostic ("local function '<name>' requires that '<Type>' conform to …"), so it identifies the
+/// offending member in the error message on top of the location pointing at the user's declaration.
+internal struct ConformanceAssertion {
+  let name: String
+  /// Declared types as written. Composed types (`[Int]`, `String?`, …) are kept verbatim — their
+  /// conditional conformances transitively constrain the elements.
+  let types: [String]
+}
+
+/// A single conformance-assertion peer for a `@JS` member: a never-called `private func` whose body
+/// statically asserts the member's boundary types conform. The assertion is compile-time only — the
+/// function is never invoked, but Swift still type-checks its body, so a non-conforming type becomes
+/// a compile error. Emitted as a **peer** of the user's declaration, so that error lands on the
+/// user's own member rather than on the enclosing macro.
+///
+/// `isStatic` makes the peer `static`, mirroring a `static`/`class` member so it's emitted in the
+/// right metatype context (a peer of a type-level member can't be an instance method). `class func`
+/// members collapse to `static` here too: the peer is private and never called or overridden, so
+/// `static` is always sufficient.
+///
+/// Returns `nil` when nothing is left to assert (every type was a known-conforming primitive, or the
+/// list was empty), so the caller emits nothing in that case.
+internal func typeConformanceAssertion(for assertion: ConformanceAssertion, isStatic: Bool) -> DeclSyntax? {
+  guard let body = conformanceAssertionBody(assertion) else {
+    return nil
+  }
+  let staticKeyword = isStatic ? "static " : ""
+  return """
+    private \(raw: staticKeyword)func _assertTypesConformance_\(raw: assertion.name)() {
+    \(raw: body)
+    }
+    """
+}
+
+/// One conformance-assertion peer covering several members' assertions at once — used by `@Record`,
+/// which folds every property into a single `_assertTypesConformance()` rather than emitting a peer
+/// per property. Each assertion keeps its own named nested helper, so the per-member naming in the
+/// diagnostic is preserved even though they share one peer.
+///
+/// Returns `nil` when no assertion has anything left to verify (all primitives / empty), so the
+/// caller emits nothing.
+internal func typeConformanceAssertions(for assertions: [ConformanceAssertion]) -> DeclSyntax? {
+  let bodies = assertions.compactMap(conformanceAssertionBody)
+  guard !bodies.isEmpty else {
+    return nil
+  }
+  return """
+    private func _assertTypesConformance() {
+    \(raw: bodies.joined(separator: "\n"))
+    }
+    """
+}
+
+/// The assertion's body fragment: a nested generic helper named after the member, plus one call per
+/// distinct non-primitive type. Nesting the helper keeps the constraint entirely local — no shared
+/// symbol, nothing to collide, nothing left in the type's namespace — and naming it after the member
+/// puts the member's name in the compiler's conformance diagnostic. Returns `nil` when every type was
+/// a known-conforming primitive or the list was empty.
+private func conformanceAssertionBody(_ assertion: ConformanceAssertion) -> String? {
+  // Unwrap top-level optionals to the core type, then dedup so each type is asserted once even when
+  // it appears more than once; skip known primitives.
+  var seen: Set<String> = []
+  var distinct: [String] = []
+  for type in assertion.types.map(unwrappedOptional)
+  where !knownConformingPrimitives.contains(type) && seen.insert(type).inserted {
+    distinct.append(type)
+  }
+  guard !distinct.isEmpty else {
+    return nil
+  }
+
+  var lines = ["func \(assertion.name)<T: \(jsConvertibleProtocolName)>(_: T.Type) {}"]
+  lines.append(contentsOf: distinct.map { "\(assertion.name)(\($0).self)" })
+  return lines.joined(separator: "\n")
+}
+
+/// Strips every trailing optional marker (`?`/`!`) so the assertion targets the core wrapped type.
+/// `Optional<W>: AnyArgument` holds exactly when `W: AnyArgument` (and `T!` is just `T?`), so each
+/// layer is conformance-equivalent to its wrapped type. Asserting the core gives a cleaner diagnostic
+/// (the direct `requires that '<type>' conform`, not the conditional-conformance phrasing through
+/// `Optional`) and sidesteps that `T!.self` is invalid in metatype position. Only *trailing* markers
+/// are stripped, so `[Int?]` keeps its inner `?`; a longhand `Optional<W>` isn't peeled but is still
+/// asserted whole, which remains correct.
+private func unwrappedOptional(_ type: String) -> String {
+  var result = Substring(type)
+  while result.hasSuffix("?") || result.hasSuffix("!") {
+    result = result.dropLast()
+  }
+  return String(result)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/expo-modules-macros-plugin",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Swift macro plugin for Expo modules",
   "license": "MIT",
   "author": "650 Industries, Inc.",