expo-modules-macros 0.23.1 → 0.25.0

package/apple/Sources/ExpoModulesMacros/ClosureArguments.swift

@@ -141,7 +141,17 @@ private func closureLiteralLines(_ closure: JSClosureType, callback: String) ->
   let parameters = closure.parameters.indices.map { "p\($0)" }
   let header = parameters.isEmpty ? "{ @Sendable in" : "{ @Sendable \(parameters.joined(separator: ", ")) in"
 
+  // A sync closure with parameters passes them as one value, a tuple when there are several, and an
+  // `emplacing` closure moves each one into the arguments buffer at its index. Capturing the
+  // parameters instead would send non-`Sendable` values to the `@JavaScriptActor` closure, which
+  // Swift 6 rejects. The closure captures nothing, so it needs no allocation. Without parameters
+  // there is nothing to emplace, and `invokeAsync` takes the parameters variadically.
+  let emplaces = !closure.isAsync && !parameters.isEmpty
   var arguments = parameters
+  if emplaces {
+    let values = parameters.count == 1 ? "p0" : "(" + parameters.joined(separator: ", ") + ")"
+    arguments = [values, "argumentCount: \(parameters.count)"]
+  }
   if let returnType = closure.returnType {
     arguments.append("returning: \(expressionType(returnType)).self")
   }
@@ -156,6 +166,14 @@ private func closureLiteralLines(_ closure: JSClosureType, callback: String) ->
     call = "\(callback).invokeDetached(\(argumentList))"
   }
 
+  if emplaces {
+    var lines = [header, "  \(call) { _values, _arguments, _runtime in"]
+    for index in parameters.indices {
+      let value = parameters.count == 1 ? "_values" : "_values.\(index)"
+      lines.append("    try _arguments.emplace(\(value), at: \(index), in: _runtime)")
+    }
+    return lines + ["  }", "}"]
+  }
   guard closure.isAsync && !closure.isThrowing else {
     return [header, "  " + call, "}"]
   }

package/apple/Sources/ExpoModulesMacros/DecorateModuleBuilder.swift

@@ -152,9 +152,9 @@ internal struct JSFunction {
     } else {
       // One call shape per accepted arity, branching on `arguments.count`. A branch decodes a
       // trailing slot before the call, so this is a `switch` statement (not an expression): a
-      // value-returning function declares `result` up front and each branch assigns it.
+      // value-returning function declares `value` up front and each branch assigns it.
       if let returnType {
-        lines.append("let result: \(expressionType(returnType))")
+        lines.append("let value: \(expressionType(returnType))")
       }
       lines.append("switch arguments.count {")
       for arity in required...maximum {
@@ -163,7 +163,7 @@ internal struct JSFunction {
         for index in required..<arity {
           lines.append(contentsOf: decodeLines(at: index).map { "  " + $0 })
         }
-        let assignment = returnType != nil ? "result = " : ""
+        let assignment = returnType != nil ? "value = " : ""
         lines.append("  \(assignment)\(callExpression(receiver: receiver, arity: arity))")
       }
       lines.append("}")
@@ -268,7 +268,7 @@ internal struct JSFunction {
   }
 
   /// The flat (single-arity) call-and-encode lines used when no trailing parameter is omittable:
-  /// `let result = <callee>.f(...)` then the return encode (or just `<callee>.f(...)` for a function
+  /// `let value = <callee>.f(...)` then the encode (or just `<callee>.f(...)` for a function
   /// that returns nothing).
   private func callAndEncodeLines(receiver: Receiver, arity: Int, decodingFrom: Int) -> [String] {
     var lines: [String] = []
@@ -276,7 +276,7 @@ internal struct JSFunction {
       lines.append(contentsOf: decodeLines(at: index))
     }
     if returnType != nil {
-      lines.append("let result = \(callExpression(receiver: receiver, arity: arity))")
+      lines.append("let value = \(callExpression(receiver: receiver, arity: arity))")
       lines.append(contentsOf: encodeResultLines())
     } else {
       lines.append(callExpression(receiver: receiver, arity: arity))
@@ -290,8 +290,9 @@ internal struct JSFunction {
   /// `toJavaScriptValue(in:)` except for `Int`/`UInt`, where it range-checks
   /// and throws instead of silently encoding an out-of-safe-range value as a lossy number — the
   /// catchable error is the right behavior, and matches how non-primitive integers already encode. A
-  /// no-return function has nothing to encode: its binding closure returns `Void` (see
-  /// `decorateStatements(object:receiver:)`).
+  /// no-return function has nothing to encode, so its binding closure leaves the result slot empty (see
+  /// `decorateStatements(object:receiver:)`). A synchronous function encodes straight into the
+  /// engine's result slot, so a number, a boolean or a string never becomes a `JavaScriptValue`.
   ///
   /// For an `async` function the encode must run on the JS thread. An `async` body may suspend and
   /// resume on an arbitrary cooperative-pool thread, and encoding a heap-allocated JS value (a string,
@@ -303,15 +304,15 @@ internal struct JSFunction {
     guard let returnType else {
       return []
     }
-    let encode = "try \(encodeCall(returnType, freeForm: returnFreeForm, of: "result"))"
     if isAsync {
+      let encode = "try \(encodeCall(returnType, freeForm: returnFreeForm, of: "result"))"
       return [
         "return try await runtime.execute {",
         "  return \(encode)",
         "}",
       ]
     }
-    return ["return \(encode)"]
+    return [encodeIntoSlotStatement(returnType, freeForm: returnFreeForm, of: "value")]
   }
 
   /// The `setProperty` statement that installs this function on the JS object. The decode-call-encode
@@ -331,19 +332,18 @@ internal struct JSFunction {
     // differ only in what they return. A module ignores `this`; a shared object unwraps it (still
     // borrowed) — an async binding does so in its synchronous decode phase, before the borrow ends.
     // The parameter list is parenthesized and fully typed, since Swift rejects a type annotation on
-    // a shorthand `{ [capture] name, name in }` parameter; for a sync binding the explicit
-    // `JavaScriptUnownedValue` also selects the (otherwise `@_disfavoredOverload`) unowned-`this`
-    // overload.
-    // A sync function that returns nothing binds through the `Void` overload, which leaves JS's
-    // result as `undefined` without building and writing a value. The closure declares `-> Void`
-    // because a body of several statements without a `return` is otherwise ambiguous between the
-    // two unowned-`this` overloads.
+    // a shorthand `{ [capture] name, name in }` parameter.
+    // A sync function binds through the result-slot overload (`JavaScriptRuntime.HostFunctionClosure`):
+    // it encodes its result into the slot and gets the runtime as a parameter. A function that returns
+    // nothing writes nothing, so JS gets `undefined` without a value being built.
     let captures = receiver.captureClause
-    let parameters = "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
-    let returnClause = returnType == nil && !isAsync ? " -> Void" : ""
+    let parameters =
+      isAsync
+      ? "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
+      : resultSlotClosureParameters
 
     return """
-        \(object).setProperty("\(jsName)") { \(captures)\(parameters)\(returnClause) in
+        \(object).setProperty("\(jsName)") { \(captures)\(parameters) in
       \(bodyStatements(receiver: receiver, indent: "    "))
         }
       """
@@ -419,8 +419,16 @@ internal struct JSProperty {
     } else {
       encode = "\(callee).\(swiftName).toJavaScriptValue(in: runtime)"
     }
+    // A getter encodes straight into the engine's result slot. A lazy getter needs the encoded value as
+    // a `JavaScriptValue` to define it on `this` as well, and then moves it into the slot.
     let getBody: String
-    if isLazy {
+    if !isLazy {
+      if let valueType {
+        getBody = encodeIntoSlotStatement(valueType, freeForm: freeForm, of: "\(callee).\(swiftName)")
+      } else {
+        getBody = "result.emplace(\(encode))"
+      }
+    } else {
       let define = "this.getObject(in: runtime).defineProperty(\"\(jsName)\", value: value, options: [.enumerable])"
       // A module getter ignores `this` otherwise, so it can be anything, and only an object can hold the
       // value. A shared object's unwrap has already checked that `this` is an object.
@@ -428,9 +436,7 @@ internal struct JSProperty {
         receiver.unwrapStatement == nil
         ? "if this.isObject() {\n  \(define)\n}"
         : define
-      getBody = "let value = \(encode)\n\(defineStatement)\nreturn value"
-    } else {
-      getBody = "return \(encode)"
+      getBody = "let value = \(encode)\n\(defineStatement)\nresult.emplace(value)"
     }
     lines.append(
       accessorClosure(descriptorName, "get", receiver: receiver, body: "\(unwrap)\(getBody)")
@@ -444,13 +450,7 @@ internal struct JSProperty {
       let decode = decodeCall(valueType, freeForm: freeForm, from: "arguments.unownedValue(at: 0)")
       let setDecode = "\(callee).\(swiftName) = try \(decode)"
       lines.append(
-        accessorClosure(
-          descriptorName,
-          "set",
-          receiver: receiver,
-          returnsVoid: true,
-          body: "\(unwrap)\(setDecode)"
-        )
+        accessorClosure(descriptorName, "set", receiver: receiver, body: "\(unwrap)\(setDecode)")
       )
     }
 
@@ -465,13 +465,10 @@ internal struct JSProperty {
 
   /// One `descriptor.setProperty("get"/"set") { … }` accessor entry. The capture list follows the
   /// receiver: a module captures `self` strong; a shared object captures nothing of the instance.
-  /// A setter passes `returnsVoid`, so its closure declares `-> Void` and binds through the `Void`
-  /// overload, like a function that returns nothing.
   private func accessorClosure(
     _ descriptorName: String,
     _ key: String,
     receiver: Receiver,
-    returnsVoid: Bool = false,
     body: String
   ) -> String {
     let captures = receiver.captureClause
@@ -482,21 +479,36 @@ internal struct JSProperty {
       .split(separator: "\n", omittingEmptySubsequences: false)
       .map { "  \($0)" }
       .joined(separator: "\n")
-    // Property `get`/`set` accessors are always synchronous, so they bind through the unowned-`this`
+    // Property `get`/`set` accessors are always synchronous, so they bind through the result-slot
     // `setProperty` overload like sync functions. The parameter list is parenthesized and fully typed
-    // because Swift rejects a type annotation on a shorthand closure parameter; the explicit
-    // `borrowing JavaScriptUnownedValue` selects the unowned-`this` overload. A module ignores `this`;
-    // a shared object unwraps it in the body.
-    let parameters = "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer)"
-    let returnClause = returnsVoid ? " -> Void" : ""
+    // because Swift rejects a type annotation on a shorthand closure parameter. A module ignores `this`;
+    // a shared object unwraps it in the body. A setter writes nothing, so JS gets `undefined`.
     return """
-      \(descriptorName).setProperty("\(key)") { \(captures)\(parameters)\(returnClause) in
+      \(descriptorName).setProperty("\(key)") { \(captures)\(resultSlotClosureParameters) in
       \(indentedBody)
       }
       """
   }
 }
 
+/// The parameter list of a binding closure that writes its result into the engine's result slot
+/// (`JavaScriptRuntime.HostFunctionClosure`). The closure gets the runtime as a parameter, which shadows
+/// the decorator's `runtime`, so it doesn't capture it.
+private let resultSlotClosureParameters =
+  "(this: borrowing JavaScriptUnownedValue, arguments: consuming JavaScriptValuesBuffer, "
+  + "result: borrowing JavaScriptValue.Slot, runtime: borrowing JavaScriptRuntime)"
+
+/// The statement that encodes `valueExpression` of a boundary type into the result slot `result`. A type
+/// that mentions `Any` has no `encode(_:into:in:)`, so its free-form encode result is moved into the slot.
+private func encodeIntoSlotStatement(_ type: String, freeForm: FreeFormConversion?, of valueExpression: String)
+  -> String
+{
+  if freeForm != nil {
+    return "result.emplace(try \(encodeCall(type, freeForm: freeForm, of: valueExpression)))"
+  }
+  return "try \(expressionType(type)).encode(\(valueExpression), into: result, in: runtime)"
+}
+
 /// The body shared by every decorator phase: every `@JS func` bound via an inlined `setProperty`
 /// closure and every `@JS var` via a `defineProperty` accessor, joined for the function body. `object`
 /// is the local the bindings decorate (matching the entry point's argument label); `receiver` selects

package/apple/Sources/ExpoModulesMacros/RecordMacro.swift

@@ -477,7 +477,9 @@ private func toObjectMethod() -> DeclSyntax {
 /// property's declared default (inlined) when undefined; optional properties become `nil` when
 /// undefined/null. It's the unowned overload: an owning value decodes through `JavaScriptDecodable`'s
 /// default, which forwards to it. `encode` builds the JS object, writing each property. Its parameter
-/// names the type, because a class can't take `Self` as a parameter type.
+/// names the type, because a class can't take `Self` as a parameter type. `encode(_:into:in:)` builds
+/// the same object and moves it into the slot (an array element, an argument or a result), with no
+/// `JavaScriptValue` in between.
 private func javaScriptCodableWitnesses(
   properties: [RecordProperty],
   typeName: String,
@@ -491,11 +493,12 @@ private func javaScriptCodableWitnesses(
   let lookupLines = cachesPropNames ? propNamesLookupLines() : []
   let readLines = lookupLines + jsObjectReadLines(properties: properties, cachesPropNames: cachesPropNames)
   let decodeBody = objectLine + "\n" + factoryBody(properties: properties, readLines: readLines)
-  let encodeLines =
+  let objectLines =
     ["  let object = runtime.createObject()"]
     + lookupLines
     + objectWriteLines(properties: properties, of: "value", cachesPropNames: cachesPropNames)
-    + ["  return object.takeValue()"]
+  let encodeLines = objectLines + ["  return object.takeValue()"]
+  let encodeIntoSlotLines = objectLines + ["  slot.emplace(object)"]
   return [
     """
     @JavaScriptActor
@@ -509,12 +512,23 @@ private func javaScriptCodableWitnesses(
     \(raw: encodeLines.joined(separator: "\n"))
     }
     """,
+    """
+    @JavaScriptActor
+    public static func encode(
+      _ value: \(raw: typeName),
+      into slot: borrowing JavaScriptValue.Slot,
+      in runtime: borrowing JavaScriptRuntime
+    ) throws {
+    \(raw: encodeIntoSlotLines.joined(separator: "\n"))
+    }
+    """,
   ]
 }
 
 /// The statements that write each property of `record` (`self` or the `encode` parameter) into the
-/// `object` local, encoding it with `JavaScriptEncodable.encode` or, for a free-form property, the
-/// matching `JavaScriptValue` free-form method.
+/// `object` local. A property is encoded straight into the engine value that `setProperty` writes, through
+/// `JavaScriptEncodable.encode(_:into:in:)`, so a number, a boolean or a string never becomes a
+/// `JavaScriptValue`. A free-form property goes through the matching `JavaScriptValue` free-form method.
 private func objectWriteLines(properties: [RecordProperty], of record: String, cachesPropNames: Bool) -> [String] {
   return properties.enumerated().map { index, property in
     let value = "\(record).\(property.name)"
@@ -529,7 +543,8 @@ private func objectWriteLines(properties: [RecordProperty], of record: String, c
       // The explicit `as Any` keeps an optional property from warning about its implicit coercion.
       encode = "try JavaScriptValue.encodeAny(\(value) as Any, in: runtime)"
     case nil:
-      encode = "try \(expressionType(property.type)).encode(\(value), in: runtime)"
+      let propName = propNameArgument(for: property, at: index, cached: cachesPropNames)
+      return "  try object.setProperty(\(propName), encoding: \(value), in: runtime)"
     }
     let propName = propNameArgument(for: property, at: index, cached: cachesPropNames)
     return "  object.setProperty(\(propName), value: \(encode))"

package/apple/Sources/ExpoModulesMacros/UnionMacro.swift

@@ -64,6 +64,7 @@ public struct UnionMacro: MemberMacro, ExtensionMacro {
     members.append(decodableKindsProperty(union: union))
     members.append(decodeMethod(union: union))
     members.append(encodeMethod(union: union))
+    members.append(encodeIntoSlotMethod(union: union))
     members.append(contentsOf: accessorMethods(union: union))
     members.append(payloadTypeNameProperty(union: union))
     return members
@@ -322,6 +323,30 @@ private func encodeMethod(union: UnionType) -> DeclSyntax {
     """
 }
 
+/// `encode(_:into:in:)`: the same `switch` as `encode(_:in:)`, with each payload encoded straight into the
+/// slot through the payload type's own `encode(_:into:in:)`. A payload that is a number, a boolean or a
+/// string is then constructed in the slot (an array element, an argument or a result), with no
+/// `JavaScriptValue` in between.
+private func encodeIntoSlotMethod(union: UnionType) -> DeclSyntax {
+  var lines: [String] = ["  switch value {"]
+  for unionCase in union.cases {
+    lines.append("  case \(unionCase.pattern):")
+    lines.append("    try \(expressionType(unionCase.payloadType)).encode(payload, into: slot, in: runtime)")
+  }
+  lines.append("  }")
+  let body = lines.joined(separator: "\n")
+  return """
+    @JavaScriptActor
+    public static func encode(
+      _ value: Self,
+      into slot: borrowing JavaScriptValue.Slot,
+      in runtime: borrowing JavaScriptRuntime
+    ) throws {
+    \(raw: body)
+    }
+    """
+}
+
 /// `as(_:)`: a typed accessor per case, selected by the payload's metatype rather than the case name,
 /// so a caller that only knows the type it wants writes `try value.as(String.self)` and gets a `String`.
 /// When

package/package.json

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