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

package/.github/workflows/publish.yml

@@ -97,7 +97,9 @@ jobs:
         run: |
           version="${{ steps.bump.outputs.version }}"
           git commit -am "Release $version"
-          git tag "$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

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

@@ -42,6 +42,12 @@ 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)._synthesizedClassDefinition()")
     }
@@ -51,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
       }
 
@@ -94,6 +100,13 @@ public struct ExpoModuleMacro: MemberMacro {
       """
     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 emitted
   }
 }
@@ -215,17 +228,6 @@ private func hasAppContextInitializer(_ classDecl: ClassDeclSyntax) -> Bool {
 
 // MARK: - Member builders
 
-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))"
-}
-
 private func buildPropertyEntries(
   varDecl: VariableDeclSyntax,
   attribute: AttributeSyntax

package/package.json

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