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

package/apple/Sources/ExpoModulesMacros/SharedObjectMacro.swift

@@ -0,0 +1,188 @@
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+/**
+ Member macro applied to a `SharedObject` subclass. Scans the class body for
+ declarations marked with `@JS` and synthesizes `_synthesizedClassDefinition()`,
+ returning a `ClassDefinition` ready to drop into a module's `Class { ... }` slot.
+
+   @SharedObject
+   final class Cache: SharedObject {
+     @JS
+     init(name: String) { self.name = name }
+
+     @JS
+     func get(_ key: String) -> String? { ... }
+
+     @JS
+     var size: Int { 42 }
+   }
+
+ The companion `@ExpoModule(classes: [Cache.self])` wires the resulting
+ definition into the module's exposed surface.
+ */
+public struct SharedObjectMacro: MemberMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingMembersOf declaration: some DeclGroupSyntax,
+    conformingTo protocols: [TypeSyntax],
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    guard let classDecl = declaration.as(ClassDeclSyntax.self) else {
+      throw MacroExpansionErrorMessage("@SharedObject can only be applied to a class")
+    }
+
+    guard inheritsFromSharedObject(classDecl) else {
+      throw MacroExpansionErrorMessage(
+        "@SharedObject class must inherit from SharedObject. Add `: SharedObject` to the class declaration.")
+    }
+
+    let typeName = classDecl.name.text
+    let jsName = jsNameArgument(of: node) ?? typeName
+
+    var entries: [String] = []
+    var sawConstructor = false
+
+    for member in classDecl.memberBlock.members {
+      let decl = member.decl
+
+      if let initDecl = decl.as(InitializerDeclSyntax.self),
+        initDecl.attributes.firstAttribute(named: "JS") != nil {
+        if sawConstructor {
+          throw MacroExpansionErrorMessage(
+            "@SharedObject classes can have at most one @JS initializer; JavaScript classes have a single constructor.")
+        }
+        sawConstructor = true
+        entries.append(buildConstructorEntry(initDecl: initDecl, typeName: typeName))
+        continue
+      }
+
+      if let funcDecl = decl.as(FunctionDeclSyntax.self),
+        let attribute = funcDecl.attributes.firstAttribute(named: "JS") {
+        entries.append(
+          buildClassFunctionEntry(funcDecl: funcDecl, attribute: attribute, typeName: typeName))
+        continue
+      }
+
+      if let varDecl = decl.as(VariableDeclSyntax.self),
+        let attribute = varDecl.attributes.firstAttribute(named: "JS") {
+        entries.append(
+          contentsOf: buildClassPropertyEntries(
+            varDecl: varDecl, attribute: attribute, typeName: typeName))
+      }
+    }
+
+    let lines = entries.map { "    \($0)" }.joined(separator: "\n")
+    let body = entries.isEmpty
+      ? "  return Class(\"\(jsName)\", \(typeName).self) {\n  }"
+      : "  return Class(\"\(jsName)\", \(typeName).self) {\n\(lines)\n  }"
+
+    let method: DeclSyntax = """
+      public static func _synthesizedClassDefinition() -> ClassDefinition {
+      \(raw: body)
+      }
+      """
+
+    return [method]
+  }
+}
+
+extension SharedObjectMacro: MemberAttributeMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo declaration: some DeclGroupSyntax,
+    providingAttributesFor member: some DeclSyntaxProtocol,
+    in context: some MacroExpansionContext
+  ) throws -> [AttributeSyntax] {
+    guard memberHasJSAttribute(member),
+      shouldStampJavaScriptActor(on: member, enclosedBy: declaration) else {
+      return []
+    }
+    return ["@JavaScriptActor"]
+  }
+}
+
+// MARK: - Inheritance check
+
+private func inheritsFromSharedObject(_ classDecl: ClassDeclSyntax) -> Bool {
+  return inheritsFromAny(classDecl, names: ["SharedObject"])
+}
+
+// MARK: - Class-scope entry builders
+
+private func buildClassFunctionEntry(
+  funcDecl: FunctionDeclSyntax,
+  attribute: AttributeSyntax,
+  typeName: String
+) -> String {
+  let swiftName = funcDecl.name.text
+  let jsName = jsNameArgument(of: attribute) ?? swiftName
+  let effects = funcDecl.signature.effectSpecifiers
+  let isAsync = effects?.asyncSpecifier != nil
+  let isThrowing = effects?.throwsClause?.throwsSpecifier != nil
+  let dslEntry = isAsync ? "AsyncFunction" : "Function"
+
+  let params = funcDecl.signature.parameterClause.parameters
+  let closureParamList: String
+  let callArgList: String
+  if params.isEmpty {
+    closureParamList = "(this: \(typeName))"
+    callArgList = ""
+  } else {
+    let typedParams = params.enumerated().map { index, param in
+      "_ arg\(index): \(param.type.trimmedDescription)"
+    }.joined(separator: ", ")
+    closureParamList = "(this: \(typeName), \(typedParams))"
+
+    callArgList = params.enumerated().map { index, param in
+      let label = param.firstName.text
+      return label == "_" ? "arg\(index)" : "\(label): arg\(index)"
+    }.joined(separator: ", ")
+  }
+
+  let awaitKeyword = isAsync ? "await " : ""
+  let tryKeyword = (isAsync || isThrowing) ? "try " : ""
+  let callExpr = "\(tryKeyword)\(awaitKeyword)this.\(swiftName)(\(callArgList))"
+
+  return "\(dslEntry)(\"\(jsName)\") { \(closureParamList) in \(callExpr) }"
+}
+
+private func buildClassPropertyEntries(
+  varDecl: VariableDeclSyntax,
+  attribute: AttributeSyntax,
+  typeName: String
+) -> [String] {
+  let jsNameOverride = jsNameArgument(of: attribute)
+
+  return varDecl.bindings.compactMap { binding in
+    guard let ident = binding.pattern.as(IdentifierPatternSyntax.self) else {
+      return nil
+    }
+    let swiftName = ident.identifier.text
+    let jsName = jsNameOverride ?? swiftName
+    return "Property(\"\(jsName)\") { (this: \(typeName)) in this.\(swiftName) }"
+  }
+}
+
+private func buildConstructorEntry(
+  initDecl: InitializerDeclSyntax,
+  typeName: String
+) -> String {
+  let params = initDecl.signature.parameterClause.parameters
+
+  if params.isEmpty {
+    return "Constructor { \(typeName)() }"
+  }
+
+  let argList = params.enumerated().map { index, param in
+    "_ arg\(index): \(param.type.trimmedDescription)"
+  }.joined(separator: ", ")
+
+  let callArgs = params.enumerated().map { index, param in
+    let label = param.firstName.text
+    return label == "_" ? "arg\(index)" : "\(label): arg\(index)"
+  }.joined(separator: ", ")
+
+  return "Constructor { (\(argList)) in \(typeName)(\(callArgs)) }"
+}

package/apple/build.js

@@ -1,21 +1,138 @@
 #!/usr/bin/env node
 
-const { execSync } = require('node:child_process');
-const fs = require('node:fs');
+const childProcess = require('node:child_process');
+const fs = require('node:fs/promises');
+const os = require('node:os');
 const path = require('node:path');
+const { promisify } = require('node:util');
 
-try {
-  execSync('swift build -c release', { stdio: 'inherit', cwd: __dirname });
+const execFile = promisify(childProcess.execFile);
 
-  fs.rmSync(path.join(__dirname, 'ExpoModulesMacros-tool'), { force: true });
+/**
+ * Runs a command and resolves when it exits successfully.
+ */
+function spawnAsync(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = childProcess.spawn(command, args, { stdio: 'inherit', ...options });
+    child.once('error', reject);
+    child.once('close', (code, signal) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`\`${command} ${args.join(' ')}\` exited with ${signal ?? `code ${code}`}`));
+      }
+    });
+  });
+}
+
+/**
+ * Builds the macro plugin for the given architecture and returns the path to the built binary.
+ * SwiftPM always builds macro tools for the host architecture, so the x86_64 slice
+ * is built by running the whole toolchain under Rosetta with `arch -${arch}`.
+ */
+async function buildForArch(arch) {
+  const buildArgs = ['build', '-c', 'release'];
+  if (arch === os.machine()) {
+    await spawnAsync('swift', buildArgs, { cwd: __dirname });
+  } else {
+    await spawnAsync('arch', [`-${arch}`, 'swift', ...buildArgs], { cwd: __dirname });
+  }
+
+  const binPath = path.join(__dirname, `.build/${arch}-apple-macosx/release/ExpoModulesMacros-tool`);
+  try {
+    await fs.access(binPath);
+  } catch {
+    throw new Error(`Could not find the built ExpoModulesMacros-tool at ${binPath}`);
+  }
+  return binPath;
+}
+
+/**
+ * Checks whether the Swift toolchain actually runs for the given architecture by
+ * verifying the host target triple it reports, e.g. `Target: x86_64-apple-macosx26.0`
+ * under Rosetta. Exit status alone is not enough: if `arch` ever fell back to the
+ * native architecture, the probe would pass but the build would produce a wrong slice.
+ */
+async function canRunSwiftForArch(arch) {
+  try {
+    const { stdout } = await execFile('arch', [`-${arch}`, 'swift', '--version']);
+    return stdout.includes(`${arch}-apple`);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checks whether the toolchain can build for the given architecture.
+ * Building x86_64 on Apple Silicon requires Rosetta, so when it is missing,
+ * try to install it before giving up.
+ */
+async function canBuildForArch(arch) {
+  if (arch === os.machine()) {
+    return true;
+  }
+  if (await canRunSwiftForArch(arch)) {
+    return true;
+  }
+  if (arch === 'x86_64' && os.machine() === 'arm64') {
+    try {
+      console.log('Installing Rosetta to build the x86_64 slice...');
+      await spawnAsync('sudo', ['softwareupdate', '--install-rosetta', '--agree-to-license']);
+      return await canRunSwiftForArch(arch);
+    } catch {
+      // No sudo access or the install failed - fall through to the unsupported arch warning.
+    }
+  }
+  return false;
+}
 
-  fs.copyFileSync(
-    path.join(__dirname, '.build/arm64-apple-macosx/release/ExpoModulesMacros-tool'),
-    path.join(__dirname, 'ExpoModulesMacros-tool')
-  );
+/**
+ * Asserts that the built binary contains a slice for each of the given architectures.
+ */
+async function verifyArchs(binaryPath, archs) {
+  const { stdout } = await execFile('lipo', ['-archs', binaryPath]);
+  const builtArchs = stdout.trim().split(/\s+/);
+  for (const arch of archs) {
+    if (!builtArchs.includes(arch)) {
+      throw new Error(`The built binary at ${binaryPath} is missing the ${arch} slice`);
+    }
+  }
+}
+
+async function main() {
+  const outputPath = path.join(__dirname, 'ExpoModulesMacros-tool');
+
+  const archs = [];
+  for (const arch of ['arm64', 'x86_64']) {
+    if (await canBuildForArch(arch)) {
+      archs.push(arch);
+    } else {
+      console.warn(`The Swift toolchain cannot run for ${arch} - the built binary will not support ${arch} Macs.`);
+    }
+  }
+  if (archs.length === 0) {
+    throw new Error('The Swift toolchain is not available for any supported architecture');
+  }
+
+  // Builds run sequentially as SwiftPM locks the shared .build directory.
+  const binPaths = [];
+  for (const arch of archs) {
+    binPaths.push(await buildForArch(arch));
+  }
 
-  execSync('strip ExpoModulesMacros-tool', { stdio: 'inherit', cwd: __dirname });
-} catch (error) {
+  await fs.rm(outputPath, { force: true });
+  if (binPaths.length > 1) {
+    await spawnAsync('lipo', ['-create', ...binPaths, '-output', outputPath]);
+  } else {
+    await fs.copyFile(binPaths[0], outputPath);
+  }
+
+  await spawnAsync('strip', [outputPath]);
+  await verifyArchs(outputPath, archs);
+  await spawnAsync('lipo', ['-info', outputPath]);
+}
+
+main().catch((error) => {
   console.error('Build failed:', error.message);
   process.exit(1);
-}
+});

package/package.json

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