expo-modules-macros 0.27.1 → 0.29.0

package/apple/Sources/ExpoModulesMacrosCore/Support/SendableConformance.swift

@@ -0,0 +1,36 @@
+import SwiftSyntax
+import SwiftSyntaxBuilder
+
+/// The `@unchecked Sendable` conformance that `@ExpoModule` and `@SharedObject` add to their class, or
+/// `nil` when the class already conforms. The compiler leaves `Sendable` out of `protocols` when the
+/// class already conforms, also through a superclass. The inheritance clause is checked too, so that
+/// `expand`, which passes every declared conformance, gives the same result for a class that spells
+/// out its own conformance.
+///
+/// A module or shared object is called from more than one thread: `.withAsync` runs a function on
+/// the concurrent thread pool, and native code calls events and closures from any thread. The class
+/// can't be checked `Sendable`, because `Module` and `SharedObject` aren't `Sendable`, so
+/// `@unchecked Sendable` is the only conformance it can have.
+internal func uncheckedSendableExtension(
+  for type: some TypeSyntaxProtocol,
+  of declaration: some DeclGroupSyntax,
+  conformingTo protocols: [TypeSyntax]
+) -> ExtensionDeclSyntax? {
+  guard protocols.contains(where: { $0.trimmedDescription == "Sendable" }) else {
+    return nil
+  }
+  let inherited = declaration.inheritanceClause?.inheritedTypes ?? []
+  if inherited.contains(where: { isSendable($0.type) }) {
+    return nil
+  }
+  let conformance: DeclSyntax = "extension \(type.trimmed): @unchecked Sendable {}"
+  return conformance.cast(ExtensionDeclSyntax.self)
+}
+
+/// Whether an inherited type is `Sendable`, with or without attributes such as `@unchecked`.
+private func isSendable(_ type: TypeSyntax) -> Bool {
+  if let attributed = type.as(AttributedTypeSyntax.self) {
+    return isSendable(attributed.baseType)
+  }
+  return baseIdentifier(of: type) == "Sendable"
+}

package/apple/Sources/ExpoModulesMacrosTool/main.swift

@@ -0,0 +1,27 @@
+import ExpoModulesCLI
+import ExpoModulesMacrosCore
+
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif os(Windows)
+import CRT
+#endif
+
+// The binary that this package ships as `ExpoModulesMacros`: the compiler plugin, which CocoaPods
+// builds load, and the scanner CLI, which `expo-modules-autolinking` and `expo-modules-cli` run. The
+// compiler always launches a plugin executable without arguments and speaks the plugin protocol over
+// stdin, so any argument means a scanner invocation (`ExpoModulesMacros scan-modules <path>...`);
+// with none, this starts the plugin server. The CLI gets `expandMacros`, so `expand` runs the macros
+// of this executable.
+let arguments = Array(CommandLine.arguments.dropFirst())
+if arguments.isEmpty {
+  try runPluginServer()
+} else {
+  let expander = MacroExpander(
+    attributeNames: Set(ProvidedMacro.all.map(\.name)),
+    expand: expandMacros
+  )
+  exit(ScannerCLI.run(arguments: arguments, expander: expander))
+}

package/build/types.d.ts

@@ -281,16 +281,24 @@ export interface ExportedSharedObject extends ExportedAccess, ExportedAvailabili
      * which every JS object inherits.
      */
     initializer?: ExportedInitializer;
-    /** What the class inherits from `SharedRef<T>`, or absent when its superclass isn't `SharedRef`. */
+    /**
+     * What the class inherits from `SharedRef<T>`, directly or through another scanned `@SharedObject`
+     * class, or absent when it doesn't inherit `SharedRef`.
+     */
     sharedRef?: ExportedSharedRef;
+    /**
+     * The class's `@JS` members include the ones it inherits from scanned `@SharedObject` superclasses,
+     * the inherited ones first. An own member replaces an inherited one with the same JS name.
+     */
     functions: ExportedFunction[];
     properties: ExportedProperty[];
     events: ExportedEvent[];
     file: string;
 }
 /**
- * The `SharedRef<T>` superclass of a shared object. Only the superclass written on the class is read,
- * so a class that inherits `SharedRef` through another subclass has none.
+ * The `SharedRef<T>` superclass of a shared object. A class that inherits `SharedRef` through another
+ * `@SharedObject` class reports the `T` of that class. A class that inherits it through a class the
+ * scan doesn't report has none.
  */
 export interface ExportedSharedRef {
     /** The `T` in `SharedRef<T>`: the native type the object holds, which JS never sees. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-macros",
-  "version": "0.27.1",
+  "version": "0.29.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.27.1",
-    "@expo/modules-macros-linux-x64": "0.27.1",
-    "@expo/modules-macros-win32-arm64": "0.27.1",
-    "@expo/modules-macros-win32-x64": "0.27.1"
+    "@expo/modules-macros-linux-arm64": "0.29.0",
+    "@expo/modules-macros-linux-x64": "0.29.0",
+    "@expo/modules-macros-win32-arm64": "0.29.0",
+    "@expo/modules-macros-win32-x64": "0.29.0"
   }
 }

package/apple/Package.swift

@@ -1,66 +0,0 @@
-// swift-tools-version: 6.2
-// The swift-tools-version declares the minimum version of Swift required to build this package.
-
-import CompilerPluginSupport
-import Foundation
-import PackageDescription
-
-let package = Package(
-  name: "ExpoModulesMacros",
-  platforms: [.macOS(.v13)],
-  dependencies: [
-    .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "604.0.0-latest")
-  ],
-  targets: [
-    // The plugin executable doubles as the scanner CLI: the compiler launches it without arguments
-    // and speaks the plugin protocol over stdin, while an invocation with arguments dispatches into
-    // `ScannerCLI` (see the entry point in Plugin.swift). Sharing the binary keeps the package to a
-    // single shipped executable; the scanner adds little on top of the SwiftSyntax the macros
-    // already link.
-    .macro(
-      name: "ExpoModulesMacros",
-      dependencies: [
-        "ExpoModulesCLI",
-        .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
-        .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
-        // For `expand`, which runs the macros in process.
-        .product(name: "SwiftSyntaxMacroExpansion", package: "swift-syntax"),
-        .product(name: "SwiftParser", package: "swift-syntax"),
-        .product(name: "SwiftParserDiagnostics", package: "swift-syntax"),
-        .product(name: "SwiftBasicFormat", package: "swift-syntax"),
-      ]
-    ),
-    .target(
-      name: "ExpoModulesCLI",
-      dependencies: [
-        .product(name: "SwiftSyntax", package: "swift-syntax"),
-        .product(name: "SwiftParser", package: "swift-syntax"),
-        .product(name: "SwiftIfConfig", 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: [
-        "ExpoModulesMacros",
-        "ExpoModulesCLI",
-        .product(name: "SwiftSyntaxMacrosGenericTestSupport", package: "swift-syntax"),
-      ]
-    )
-  )
-  package.targets.append(
-    .testTarget(
-      name: "ExpoModulesCLITests",
-      dependencies: [
-        "ExpoModulesCLI",
-        .product(name: "SwiftParser", package: "swift-syntax"),
-      ]
-    )
-  )
-}

package/apple/Sources/ExpoModulesMacros/Plugin.swift

@@ -1,36 +0,0 @@
-import ExpoModulesCLI
-import SwiftCompilerPlugin
-import SwiftSyntaxMacros
-
-#if canImport(Darwin)
-import Darwin
-#elseif canImport(Glibc)
-import Glibc
-#elseif os(Windows)
-import CRT
-#endif
-
-struct ExpoModulesMacrosPlugin: CompilerPlugin {
-  let providingMacros: [Macro.Type] = ProvidedMacro.all.map(\.type)
-}
-
-/// The executable doubles as the scanner CLI. The compiler always launches a plugin executable
-/// without arguments and speaks the plugin protocol over stdin, so any argument means a scanner
-/// invocation (`ExpoModulesMacros scan-modules <path>...`); with none, this starts the plugin
-/// server exactly as `@main` on the `CompilerPlugin` type would. The CLI gets `expandMacros`, so
-/// `expand` runs the macros of this executable.
-@main
-enum EntryPoint {
-  static func main() throws {
-    let arguments = Array(CommandLine.arguments.dropFirst())
-    if arguments.isEmpty {
-      try ExpoModulesMacrosPlugin.main()
-    } else {
-      let expander = MacroExpander(
-        attributeNames: Set(ProvidedMacro.all.map(\.name)),
-        expand: expandMacros
-      )
-      exit(ScannerCLI.run(arguments: arguments, expander: expander))
-    }
-  }
-}