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

package/.github/workflows/publish.yml

@@ -0,0 +1,118 @@
+name: Publish
+
+on:
+  workflow_dispatch:
+    inputs:
+      release_type:
+        description: Release type
+        type: choice
+        required: true
+        default: patch
+        options:
+          - patch
+          - minor
+          - major
+          - prepatch
+          - preminor
+          - premajor
+          - prerelease
+
+concurrency:
+  group: publish-${{ github.workflow }}
+  cancel-in-progress: false
+
+jobs:
+  publish:
+    name: Build and publish to npm
+    # Builds the native macOS tool binary, so it must run on macOS.
+    # The package declares swift-tools-version 6.2, which requires Xcode 26+.
+    runs-on: macos-26
+    permissions:
+      # Required for npm trusted publishing (OIDC) and provenance.
+      id-token: write
+      # Required to push the version bump commit/tag and create the release.
+      contents: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
+        with:
+          # The default token lets gh create the release and push the bump
+          # commit/tag. Note: commits pushed with GITHUB_TOKEN do NOT trigger
+          # other workflows (e.g. the Swift CI), by GitHub's design.
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Node
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+
+      - name: Update npm
+        # Trusted publishing requires npm >= 11.5.1.
+        run: npm install -g npm@latest
+
+      - name: Configure git
+        run: |
+          git config user.name "expo-bot"
+          git config user.email "expo-bot@users.noreply.github.com"
+
+      - name: Bump version
+        id: bump
+        # Only edit package.json here; the commit, tag and release are created
+        # at the end so a failed build/publish leaves the branch untouched.
+        run: |
+          version=$(npm version "${{ inputs.release_type }}" --no-git-tag-version)
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+          echo "Bumping to $version"
+
+      - name: Select Xcode
+        # Pin to an Xcode that ships Swift 6.2 (required by Package.swift).
+        run: sudo xcode-select -switch /Applications/Xcode_26.4.1.app
+
+      - name: Cache SwiftPM build
+        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
+        with:
+          path: apple/.build
+          key: spm-${{ runner.os }}-${{ hashFiles('apple/Package.resolved') }}
+          restore-keys: |
+            spm-${{ runner.os }}-
+
+      - name: Resolve dependencies
+        run: swift package resolve
+        working-directory: apple
+
+      - name: Build release tool
+        # Runs apple/build.js: builds the release plugin binary,
+        # copies it to apple/ExpoModulesMacros-tool, and strips it.
+        run: npm run build
+
+      - name: Publish
+        # Authentication is handled via OIDC trusted publishing — no token needed.
+        # npm generates provenance automatically when publishing via OIDC.
+        run: npm publish --access public
+
+      # Everything below only runs once the publish above has succeeded.
+
+      - name: Commit, tag and push
+        run: |
+          version="${{ steps.bump.outputs.version }}"
+          git commit -am "Release $version"
+          # Use an annotated tag so `git push --follow-tags` actually pushes it
+          # (--follow-tags ignores lightweight tags).
+          git tag -a "$version" -m "Release $version"
+          git push --follow-tags origin HEAD
+
+      - name: Create GitHub release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        # Tag prerelease versions (those containing a hyphen) as prereleases.
+        run: |
+          version="${{ steps.bump.outputs.version }}"
+          prerelease=""
+          case "$version" in
+            *-*) prerelease="--prerelease" ;;
+          esac
+          gh release create "$version" \
+            --title "$version" \
+            --generate-notes \
+            $prerelease

package/.github/workflows/swift.yml

@@ -0,0 +1,59 @@
+name: Swift
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch: {}
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+defaults:
+  run:
+    working-directory: apple
+
+jobs:
+  build-and-test:
+    name: Build & test
+    # The package declares swift-tools-version 6.2, which requires Xcode 26+.
+    runs-on: macos-26
+    steps:
+      - name: Checkout
+        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
+
+      - name: Select Xcode
+        # Pin to an Xcode that ships Swift 6.2 (required by Package.swift).
+        run: sudo xcode-select -switch /Applications/Xcode_26.4.1.app
+
+      - name: Cache SwiftPM build
+        uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4
+        with:
+          path: apple/.build
+          key: spm-${{ runner.os }}-${{ hashFiles('apple/Package.resolved') }}
+          restore-keys: |
+            spm-${{ runner.os }}-
+
+      - name: Resolve dependencies
+        run: swift package resolve
+
+      - name: Build release tool
+        # Runs `npm run build` (apple/build.js): builds the universal
+        # (arm64 + x86_64) release plugin binary, copies it to
+        # apple/ExpoModulesMacros-tool, and strips it.
+        working-directory: ${{ github.workspace }}
+        run: npm run build
+
+      - name: Verify universal binary
+        run: |
+          archs="$(lipo -archs ExpoModulesMacros-tool)"
+          echo "Architectures: $archs"
+          case "$archs" in *arm64*) ;; *) echo "Missing arm64 slice"; exit 1;; esac
+          case "$archs" in *x86_64*) ;; *) echo "Missing x86_64 slice"; exit 1;; esac
+          arch -arm64 ./ExpoModulesMacros-tool < /dev/null
+          arch -x86_64 ./ExpoModulesMacros-tool < /dev/null
+
+      - name: Test
+        run: swift test -v

package/apple/Package.swift

@@ -2,6 +2,7 @@
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import CompilerPluginSupport
+import Foundation
 import PackageDescription
 
 let package = Package(
@@ -18,8 +19,14 @@ let package = Package(
         .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
         .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
       ]
-    ),
+    )
+  ]
+)
 
+// The Tests directory is excluded from the published npm package,
+// so only declare the test target when building from the repository.
+if FileManager.default.fileExists(atPath: Context.packageDirectory + "/Tests") {
+  package.targets.append(
     .testTarget(
       name: "ExpoModulesMacrosTests",
       dependencies: [
@@ -27,6 +34,6 @@ let package = Package(
         .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax"),
         .product(name: "SwiftSyntaxMacrosGenericTestSupport", package: "swift-syntax"),
       ]
-    ),
-  ]
-)
+    )
+  )
+}

package/apple/Sources/ExpoModulesMacros/DecorateFunctionBuilder.swift

@@ -0,0 +1,174 @@
+import SwiftSyntax
+
+/**
+ A `@JS func` collected for **direct JSI binding**. Instead of describing the function with a
+ `Function(...)` / `AsyncFunction(...)` DSL entry that the runtime interprets per call,
+ `@ExpoModule` synthesizes a `_decorateModule` that binds each such function into the module's JS object
+ via the closure-taking `JavaScriptObject.setProperty(_:)`, with the decode-call-encode body
+ inlined into the closure. This omits the `[Any]`/`toTuple` dynamic-call path: every argument is
+ decoded individually by its static type.
+
+ The receiver is the module's real `self` (a module is a singleton instance), so the body calls
+ `self.<name>(...)` directly and ignores the JS `this`. An `async` `@JS func` produces an `async`
+ closure body and is installed through the async `setProperty(_:)` overload (so JS gets a promise).
+ */
+internal struct JSFunction {
+  let swiftName: String
+  let jsName: String
+  let parameters: [FunctionParameterSyntax]
+  /// The declared return type as written, or `nil` when the function returns `Void`/nothing.
+  let returnType: String?
+  let isThrowing: Bool
+  let isAsync: Bool
+
+  init(funcDecl: FunctionDeclSyntax, attribute: AttributeSyntax) {
+    self.swiftName = funcDecl.name.text
+    self.jsName = jsNameArgument(of: attribute) ?? funcDecl.name.text
+    self.parameters = Array(funcDecl.signature.parameterClause.parameters)
+
+    let declaredReturnType = funcDecl.signature.returnClause?.type
+    self.returnType = isVoidType(declaredReturnType) ? nil : declaredReturnType?.trimmedDescription
+
+    let effectSpecifiers = funcDecl.signature.effectSpecifiers
+    self.isThrowing = effectSpecifiers?.throwsClause?.throwsSpecifier != nil
+    self.isAsync = effectSpecifiers?.asyncSpecifier != nil
+  }
+
+  /**
+   The `#name` host-function body: a `@JavaScriptActor private func` matching the
+   `createFunction` closure shape `(this, arguments) throws -> JavaScriptValue`, threading
+   `appContext`/`runtime` in as parameters. It checks arity, decodes each argument by its static
+   type — primitives through a direct typed accessor (`asDouble()`, …) on a borrowed
+   `JavaScriptUnownedValue`, other types through the
+   `T.getDynamicType()` converter — calls `self.<name>(...)`, and converts the result back to JS.
+   */
+  /// The decode-call-encode statements that form the host-function body, indented with the given
+  /// prefix. Arity guard, then per-argument decode (primitives via a direct typed accessor like
+  /// `asDouble()` on a zero-copy `arguments.unownedValue(at:)`, others via `getDynamicType().cast(...)`),
+  /// the `self.<name>(...)` call, and the
+  /// result encode (primitives via `toJavaScriptValue(in:)`, others via `castToJS(...)`).
+  private func bodyStatements(indent: String) -> String {
+    var lines: [String] = []
+
+    lines.append(
+      """
+      guard arguments.count == \(parameters.count) else {
+        throw Exception(name: "InvalidArgumentCount", description: "Function '\(jsName)' expects \(parameters.count) argument(s), but got \\(arguments.count)")
+      }
+      """)
+
+    var callArguments: [String] = []
+    for (index, parameter) in parameters.enumerated() {
+      let type = parameter.type.trimmedDescription
+
+      // Primitives decode through a direct typed accessor (`asDouble()`, etc.) on a borrowed
+      // `JavaScriptUnownedValue` — no owning `JavaScriptValue` allocation, no `jsi::Value` copy, no
+      // `getDynamicType()` allocation, no `Any` boxing, no force-cast — while still validating and
+      // throwing `TypeError` on a mismatch. Other types fall back to the dynamic converter, which
+      // needs an owning value, so they index the buffer directly.
+      if let accessor = fastDecodeAccessor(for: type) {
+        lines.append("let arg\(index) = try arguments.unownedValue(at: \(index)).\(accessor)()")
+      } else {
+        lines.append(
+          "let arg\(index) = try \(type).getDynamicType().cast(jsValue: arguments[\(index)], appContext: appContext) as! \(type)")
+      }
+
+      let label = parameter.firstName.text
+      callArguments.append(label == "_" ? "arg\(index)" : "\(label): arg\(index)")
+    }
+
+    let tryKeyword = (isThrowing || isAsync) ? "try " : ""
+    let awaitKeyword = isAsync ? "await " : ""
+    let callExpression =
+      "\(tryKeyword)\(awaitKeyword)self.\(swiftName)(\(callArguments.joined(separator: ", ")))"
+
+    if let returnType {
+      lines.append("let result = \(callExpression)")
+      // Primitives encode through `toJavaScriptValue(in:)` (the typed `JavaScriptRepresentable`
+      // conversion) — no `Any`, no dynamic-type allocation. Others go through the dynamic converter.
+      if fastDecodeAccessor(for: returnType) != nil {
+        lines.append("return result.toJavaScriptValue(in: runtime)")
+      } else {
+        lines.append("return try \(returnType).getDynamicType().castToJS(result, appContext: appContext, in: runtime)")
+      }
+    } else {
+      lines.append(callExpression)
+      lines.append("return .undefined")
+    }
+
+    return lines
+      .flatMap { $0.split(separator: "\n", omittingEmptySubsequences: false) }
+      .map { indent + $0 }
+      .joined(separator: "\n")
+  }
+
+  /// The `setProperty` statement that installs this function on the JS object. The decode-call-encode
+  /// body is inlined directly into the closure passed to the closure-taking `setProperty` overload
+  /// (which creates the host function under the hood) — no separate named binding. For an `async`
+  /// function the body `await`s the call, which selects the async `setProperty` overload (so JS
+  /// receives a promise).
+  ///
+  /// Capture mirrors core's `SyncFunctionDefinition.build`: `self` (the module) is captured
+  /// **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.
+  var decorateStatements: String {
+    return """
+        object.setProperty("\(jsName)") { [weak appContext, self] this, arguments in
+          guard let appContext else {
+            throw Exceptions.AppContextLost()
+          }
+      \(bodyStatements(indent: "    "))
+        }
+      """
+  }
+}
+
+/**
+ The single generated function that decorates the module's JS object. Core supplies the object;
+ this binds every `@JS func` into it via one inlined `setProperty` closure per function. Mirrors
+ core's `ObjectDefinition.decorate(object:)`, including its `borrowing` object parameter (it
+ mutates through the reference without reassigning or taking ownership). Named `_decorateModule`
+ with the leading-underscore convention for synthesized members the **runtime calls by name**; the
+ `ExpoModule` suffix names the `@ExpoModule` macro it came from (a shared object's counterpart is
+ `_decorateSharedObject`).
+ */
+internal func buildDecorateJavaScriptObject(functions: [JSFunction]) -> DeclSyntax {
+  let body = functions.map { $0.decorateStatements }.joined(separator: "\n")
+  return """
+    @JavaScriptActor
+    public func _decorateModule(object: borrowing JavaScriptObject, in runtime: JavaScriptRuntime, appContext: AppContext) throws {
+    \(raw: body)
+    }
+    """
+}
+
+/// The throwing `JavaScriptUnownedValue` accessor that decodes the given primitive type directly,
+/// bypassing the dynamic-type converter (`asDouble()` for `Double`, etc.). Returns `nil` for
+/// types without a dedicated accessor — arrays, records, optionals, shared objects, other numeric
+/// widths — which decode through `getDynamicType().cast(...)`.
+private func fastDecodeAccessor(for type: String) -> String? {
+  switch type {
+  case "Bool":
+    return "asBool"
+  case "Int":
+    return "asInt"
+  case "Double":
+    return "asDouble"
+  case "String":
+    return "asString"
+  default:
+    return nil
+  }
+}
+
+/// True when a return clause is absent or written as `Void` / `()` — i.e. the function returns
+/// nothing JS-visible, so the binding returns `.undefined`.
+private func isVoidType(_ type: TypeSyntax?) -> Bool {
+  guard let type else {
+    return true
+  }
+  let text = type.trimmedDescription
+  return text == "Void" || text == "()"
+}

package/apple/Sources/ExpoModulesMacros/ExpoModuleMacro.swift

@@ -3,13 +3,23 @@ import SwiftSyntaxBuilder
 import SwiftSyntaxMacros
 
 /**
- Member macro applied to a `Module` subclass. Scans the class body for declarations
- marked with `@JS` and synthesizes a framework-internal `_exposedDefinition()`
- method returning `[AnyDefinition]`. `expo-modules-core` calls it automatically
- and merges the result into the module's definition.
+ Macro applied to a module class. It plays three roles, each implemented in its own
+ extension below:
+
+ - `MemberMacro`: scans the class body for `@JS`-marked declarations and synthesizes a
+   framework-internal `_synthesizedDefinition()` returning `[AnyDefinition]`, which
+   `expo-modules-core` calls automatically and merges into the module's definition. When
+   the class doesn't already inherit `Module`/`BaseModule`, it also synthesizes the
+   `appContext` storage and `init(appContext:)` those base classes would have provided.
+ - `MemberAttributeMacro`: stamps `@JavaScriptActor` on `@JS` sync members and
+   `@ModuleDefinitionBuilder` on a `definition()` method.
+ - `ExtensionMacro`: adds the `AnyModule` conformance when the class doesn't inherit it.
+
+ Inheriting from `Module` is therefore optional — a class can carry any superclass (or
+ none) and still be a module, because everything inheritance used to provide is synthesized.
 
    @ExpoModule
-   public final class MyModule: Module {
+   public final class MyModule {
      public func definition() -> ModuleDefinition {
        Name("MyModule")
      }
@@ -32,8 +42,14 @@ public struct ExpoModuleMacro: MemberMacro {
     let moduleName = jsNameArgument(of: node) ?? classDecl.name.text
     var entries: [String] = ["Name(\"\(moduleName)\")"]
 
+    // `@JS func`s (sync and async) are bound directly into the JS object by the synthesized
+    // `_decorateModule` rather than described with a `Function(...)` / `AsyncFunction(...)` DSL entry,
+    // so they're collected here instead of appended to `entries`. Properties still go through
+    // the DSL for now.
+    var functions: [JSFunction] = []
+
     for typeName in classListArgument(of: node, label: "classes") {
-      entries.append("\(typeName)._exposedClassDefinition()")
+      entries.append("\(typeName)._synthesizedClassDefinition()")
     }
 
     for member in classDecl.memberBlock.members {
@@ -41,7 +57,7 @@ public struct ExpoModuleMacro: MemberMacro {
 
       if let funcDecl = decl.as(FunctionDeclSyntax.self),
         let attribute = funcDecl.attributes.firstAttribute(named: "JS") {
-        entries.append(buildFunctionEntry(funcDecl: funcDecl, attribute: attribute))
+        functions.append(JSFunction(funcDecl: funcDecl, attribute: attribute))
         continue
       }
 
@@ -54,29 +70,164 @@ public struct ExpoModuleMacro: MemberMacro {
     let lines = entries.map { "    \($0)" }.joined(separator: ",\n")
     let body = "  return [\n\(lines)\n  ]"
 
+    var emitted: [DeclSyntax] = []
+
+    // `Module`/`BaseModule` already provide `appContext` storage and the
+    // `init(appContext:)` requirement, so we only synthesize them for classes that
+    // inherit from neither. Each is skipped individually if the user wrote their own,
+    // to avoid emitting a duplicate declaration.
+    if !inheritsFromAny(classDecl, names: ["Module", "BaseModule"]) {
+      if !hasStoredProperty(classDecl, named: "appContext") {
+        emitted.append("public weak var appContext: AppContext?")
+      }
+      if !hasAppContextInitializer(classDecl) {
+        emitted.append(
+          """
+          public required init(appContext: AppContext) {
+            self.appContext = appContext
+          }
+          """
+        )
+      }
+    }
+
+    // Always emitted: the definition is derived from the class name and `@JS` members,
+    // independent of any `definition()` the user wrote.
     let method: DeclSyntax = """
-      public func _exposedDefinition() -> [AnyDefinition] {
+      public func _synthesizedDefinition() -> [AnyDefinition] {
       \(raw: body)
       }
       """
+    emitted.append(method)
+
+    // Direct JSI binding: one `_decorateModule` that binds each `@JS func` into the module's JS object,
+    // with the decode-call-encode body inlined into each closure. Only emitted when there are
+    // functions to bind.
+    if !functions.isEmpty {
+      emitted.append(buildDecorateJavaScriptObject(functions: functions))
+    }
 
-    return [method]
+    return emitted
   }
 }
 
-// MARK: - Member builders
+extension ExpoModuleMacro: MemberAttributeMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo declaration: some DeclGroupSyntax,
+    providingAttributesFor member: some DeclSyntaxProtocol,
+    in context: some MacroExpansionContext
+  ) throws -> [AttributeSyntax] {
+    // This macro is invoked once per member and may attach more than one attribute,
+    // so we collect into an array rather than returning early. The two checks below are
+    // independent — a given member matches at most one in practice, but they're written
+    // so neither precludes the other.
+    var attributes: [AttributeSyntax] = []
+
+    // `@JS` sync members run on the JS thread; stamp `@JavaScriptActor` so isolation is
+    // checked at compile time. Skipped when the member already chose an isolation
+    // (`async`, `nonisolated`, or another global actor) — see `shouldStampJavaScriptActor`.
+    if memberHasJSAttribute(member),
+      shouldStampJavaScriptActor(on: member, enclosedBy: declaration) {
+      attributes.append("@JavaScriptActor")
+    }
 
-private func buildFunctionEntry(
-  funcDecl: FunctionDeclSyntax,
-  attribute: AttributeSyntax
-) -> String {
-  let swiftName = funcDecl.name.text
-  let jsName = jsNameArgument(of: attribute) ?? swiftName
-  let isAsync = funcDecl.signature.effectSpecifiers?.asyncSpecifier != nil
-  let dslEntry = isAsync ? "AsyncFunction" : "Function"
-  return "\(dslEntry)(\"\(jsName)\", \(swiftName))"
+    // Apply the result builder to `definition()` so the user doesn't have to. Skipped if
+    // they already wrote `@ModuleDefinitionBuilder` themselves, which would otherwise be
+    // a duplicate attribute.
+    if isModuleDefinitionFunction(member),
+      !memberAttributes(of: member).contains(where: { hasAttributeName($0, "ModuleDefinitionBuilder") }) {
+      attributes.append("@ModuleDefinitionBuilder")
+    }
+
+    return attributes
+  }
 }
 
+private func isModuleDefinitionFunction(_ member: some DeclSyntaxProtocol) -> Bool {
+  guard let funcDecl = member.as(FunctionDeclSyntax.self),
+    funcDecl.name.text == "definition",
+    funcDecl.signature.parameterClause.parameters.isEmpty,
+    let returnType = funcDecl.signature.returnClause?.type else {
+    return false
+  }
+  return baseIdentifier(of: returnType) == "ModuleDefinition"
+}
+
+private func hasAttributeName(_ element: AttributeListSyntax.Element, _ name: String) -> Bool {
+  guard let attribute = element.as(AttributeSyntax.self) else {
+    return false
+  }
+  return attribute.attributeName.trimmedDescription == name
+}
+
+extension ExpoModuleMacro: ExtensionMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo declaration: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
+    in context: some MacroExpansionContext
+  ) throws -> [ExtensionDeclSyntax] {
+    // `protocols` is empty when the compiler already sees the conformance (e.g. it's
+    // spelled in the declaration), in which case there's nothing for us to add.
+    guard !protocols.isEmpty else {
+      return []
+    }
+    // These base types already supply `AnyModule`; emitting a second conformance here
+    // would be redundant and error.
+    if let classDecl = declaration.as(ClassDeclSyntax.self),
+      inheritsFromAny(classDecl, names: ["Module", "BaseModule", "AnyModule"]) {
+      return []
+    }
+    let conformance: DeclSyntax = "extension \(type.trimmed): AnyModule {}"
+    return [conformance.cast(ExtensionDeclSyntax.self)]
+  }
+}
+
+// MARK: - Synthesized-member detection
+
+private func hasStoredProperty(_ classDecl: ClassDeclSyntax, named name: String) -> Bool {
+  for member in classDecl.memberBlock.members {
+    guard let varDecl = member.decl.as(VariableDeclSyntax.self) else {
+      continue
+    }
+    for binding in varDecl.bindings {
+      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self),
+        identifier.identifier.text == name {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+/**
+ True if the class declares an initializer that satisfies the `init(appContext:)` protocol
+ requirement: a single parameter labeled `appContext` whose type is written as `AppContext`
+ (or `…​.AppContext`). Both must match — the label is part of the requirement, so
+ `init(c: AppContext)` does *not* satisfy it (we still synthesize ours), and the type guards
+ against a same-labeled init of an unrelated type. A macro can't resolve types, so this is a
+ syntactic match on the spelled name.
+ */
+private func hasAppContextInitializer(_ classDecl: ClassDeclSyntax) -> Bool {
+  for member in classDecl.memberBlock.members {
+    guard let initDecl = member.decl.as(InitializerDeclSyntax.self) else {
+      continue
+    }
+    let params = initDecl.signature.parameterClause.parameters
+    guard params.count == 1, let param = params.first else {
+      continue
+    }
+    if param.firstName.text == "appContext", baseIdentifier(of: param.type) == "AppContext" {
+      return true
+    }
+  }
+  return false
+}
+
+// MARK: - Member builders
+
 private func buildPropertyEntries(
   varDecl: VariableDeclSyntax,
   attribute: AttributeSyntax