@expo/expo-modules-macros-plugin 0.6.0 → 0.6.2

package/apple/Sources/ExpoModulesMacros/DecorateModuleBuilder.swift

@@ -60,7 +60,7 @@ internal struct JSFunction {
     let maximum = parameters.count
     var lines: [String] = []
 
-    if let unwrap = receiver.unwrapStatement {
+    if let unwrap = receiver.unwrapStatement(isAsync: isAsync) {
       lines.append(unwrap)
     }
 
@@ -90,23 +90,21 @@ internal struct JSFunction {
       // No omittable trailing run: a single flat call with every argument decoded.
       lines.append(contentsOf: callAndEncodeLines(receiver: receiver, arity: maximum, decodingFrom: required))
     } else {
-      // One call shape per accepted arity. Each branch decodes only the trailing slots it has and
-      // fills the rest (defaulted params drop their label so Swift applies the default; optional
-      // params are passed `nil`). A value-returning function binds the result from a `switch`
-      // expression and encodes once after it; a no-return one calls inline in a `switch` statement
-      // and returns `.undefined`.
-      if returnType != nil {
-        lines.append("let result = switch arguments.count {")
-      } else {
-        lines.append("switch arguments.count {")
+      // 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.
+      if let returnType {
+        lines.append("let result: \(expressionType(returnType))")
       }
+      lines.append("switch arguments.count {")
       for arity in required...maximum {
         let label = arity == maximum ? "default:" : "case \(arity):"
         lines.append(label)
         for index in required..<arity {
           lines.append("  " + decodeStatement(at: index))
         }
-        lines.append("  \(callExpression(receiver: receiver, arity: arity))")
+        let assignment = returnType != nil ? "result = " : ""
+        lines.append("  \(assignment)\(callExpression(receiver: receiver, arity: arity))")
       }
       lines.append("}")
       lines.append(contentsOf: encodeResultLines())
@@ -255,8 +253,9 @@ internal struct JSProperty {
     let callee = receiver.callee
     let object = receiver.decoratedObject
     // A shared object's accessors unwrap the JS `this` into `_self` before reading/writing; a module
-    // reads `self` directly. The unwrap leads each accessor body.
-    let unwrap = receiver.unwrapStatement.map { "\($0)\n" } ?? ""
+    // reads `self` directly. The unwrap leads each accessor body. Property accessors are synchronous, so
+    // they take the borrowed unowned `this`.
+    let unwrap = receiver.unwrapStatement(isAsync: false).map { "\($0)\n" } ?? ""
     var lines: [String] = []
 
     lines.append("let \(descriptorName) = runtime.createObject()")
@@ -340,7 +339,7 @@ internal func buildDecorateJavaScriptObject(functions: [JSFunction], properties:
   let body = decorateBody(functions: functions, properties: properties, receiver: .module)
   return """
     @JavaScriptActor
-    public func _decorateModule(object: borrowing JavaScriptObject, in runtime: JavaScriptRuntime, appContext: AppContext) throws {
+    public func _decorateModule(object: borrowing JavaScriptObject, in runtime: JavaScriptRuntime) throws {
     \(raw: body)
     }
     """
@@ -361,7 +360,7 @@ internal func buildDecorateSharedObject(
   let body = decorateBody(functions: functions, properties: properties, receiver: .sharedObject(typeName: typeName))
   return """
     @JavaScriptActor
-    public override class func _decorateSharedObject(prototype: borrowing JavaScriptObject, in runtime: JavaScriptRuntime, appContext: AppContext) throws {
+    public override class func _decorateSharedObject(prototype: borrowing JavaScriptObject, in runtime: JavaScriptRuntime) throws {
     \(raw: body)
     }
     """

package/apple/Sources/ExpoModulesMacros/JSConstructor.swift

@@ -42,14 +42,12 @@ internal struct JSConstructor {
       .joined(separator: "\n")
   }
 
-  /// The `_constructSharedObject` entry point the runtime calls to build an instance from JS
-  /// arguments. Overrides the base `SharedObject` class method so core can dispatch to it through the
-  /// concrete type's metatype; the body returns the concrete instance, which promotes to the base
-  /// `SharedObject?` return type. `this`/`appContext` may go unreferenced, which is harmless.
+  /// Builds an instance from the JS arguments. Overrides the base `SharedObject` class method; returns
+  /// the concrete instance, which promotes to the base `SharedObject?` return type.
   func buildConstructor(typeName: String) -> DeclSyntax {
     return """
       @JavaScriptActor
-      public override class func _constructSharedObject(this: JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime, appContext: AppContext) throws -> SharedObject? {
+      public override class func _constructSharedObject(this: JavaScriptValue, arguments: borrowing JavaScriptValuesBuffer, in runtime: JavaScriptRuntime) throws -> SharedObject? {
       \(raw: bodyStatements(typeName: typeName, indent: "  "))
       }
       """

package/apple/Sources/ExpoModulesMacros/MacroHelpers.swift

@@ -145,14 +145,13 @@ internal func memberHasJSAttribute(_ decl: DeclSyntaxProtocol) -> Bool {
   return false
 }
 
-/**
- 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 `nonisolated` modifier is present on the member
- - any attribute whose name matches a known global actor (`@MainActor`, `@JavaScriptActor`)
-   or follows the `*Actor` naming convention is present on the member or its enclosing type
- Async members never get the stamp because `AsyncFunction` controls their dispatch separately.
- */
+/// 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 `nonisolated` modifier is present on the member
+/// - any attribute whose name matches a known global actor (`@MainActor`, `@JavaScriptActor`)
+///   or follows the `*Actor` naming convention is present on the member or its enclosing type
+/// `async` members are stamped too: an `async` function starts its execution on the JS thread and
+/// stays there until the first suspension point, where it may hop to another executor.
 internal func shouldStampJavaScriptActor(
   on member: DeclSyntaxProtocol,
   enclosedBy enclosing: some DeclGroupSyntax
@@ -162,11 +161,6 @@ internal func shouldStampJavaScriptActor(
     return false
   }
 
-  if let funcDecl = member.as(FunctionDeclSyntax.self),
-    funcDecl.signature.effectSpecifiers?.asyncSpecifier != nil {
-    return false
-  }
-
   let memberAttributes = memberAttributes(of: member)
   if memberAttributes.contains(where: hasGlobalActorShape) {
     return false

package/apple/Sources/ExpoModulesMacros/Receiver.swift

@@ -33,14 +33,19 @@ internal enum Receiver {
   }
 
   /// The leading body line binding the receiver, or `nil` for a module (it reads `self` directly). For a
-  /// shared object, `native(from:as:)` recovers the typed instance from the borrowed `this`, throwing on
-  /// a foreign object or a type mismatch.
-  var unwrapStatement: String? {
+  /// shared object, `native(from:as:)` recovers the typed instance from `this`, throwing on a foreign
+  /// object or a type mismatch.
+  ///
+  /// The `this` object comes from the borrowed `JavaScriptUnownedValue` in a sync binding (`asObject(in:)`)
+  /// and from the owning `JavaScriptValue` in an async one (`asObject()`). An async binding must take an
+  /// owning `this` because a borrowed unowned value can't survive the closure's suspension points.
+  func unwrapStatement(isAsync: Bool) -> String? {
     switch self {
     case .module:
       return nil
     case .sharedObject(let typeName):
-      return "let _self = try SharedObject.native(from: this.asObject(in: runtime), as: \(typeName).self)"
+      let thisObject = isAsync ? "this.asObject()" : "this.asObject(in: runtime)"
+      return "let _self = try SharedObject.native(from: \(thisObject), as: \(typeName).self)"
     }
   }
 

package/package.json

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