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

package/apple/Sources/ExpoModulesMacros/SharedObjectMacro.swift

@@ -4,7 +4,7 @@ import SwiftSyntaxMacros
 
 /**
  Member macro applied to a `SharedObject` subclass. Scans the class body for
- declarations marked with `@JS` and synthesizes `_exposedClassDefinition()`,
+ declarations marked with `@JS` and synthesizes `_synthesizedClassDefinition()`,
  returning a `ClassDefinition` ready to drop into a module's `Class { ... }` slot.
 
    @SharedObject
@@ -79,7 +79,7 @@ public struct SharedObjectMacro: MemberMacro {
       : "  return Class(\"\(jsName)\", \(typeName).self) {\n\(lines)\n  }"
 
     let method: DeclSyntax = """
-      public static func _exposedClassDefinition() -> ClassDefinition {
+      public static func _synthesizedClassDefinition() -> ClassDefinition {
       \(raw: body)
       }
       """
@@ -88,28 +88,25 @@ public struct SharedObjectMacro: MemberMacro {
   }
 }
 
-// MARK: - Inheritance check
-
-private func inheritsFromSharedObject(_ classDecl: ClassDeclSyntax) -> Bool {
-  guard let inherited = classDecl.inheritanceClause?.inheritedTypes else {
-    return false
-  }
-  for entry in inherited {
-    if baseIdentifier(of: entry.type) == "SharedObject" {
-      return true
+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"]
   }
-  return false
 }
 
-private func baseIdentifier(of type: TypeSyntax) -> String? {
-  if let identifier = type.as(IdentifierTypeSyntax.self) {
-    return identifier.name.text
-  }
-  if let member = type.as(MemberTypeSyntax.self) {
-    return member.name.text
-  }
-  return nil
+// MARK: - Inheritance check
+
+private func inheritsFromSharedObject(_ classDecl: ClassDeclSyntax) -> Bool {
+  return inheritsFromAny(classDecl, names: ["SharedObject"])
 }
 
 // MARK: - Class-scope entry builders

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.9",
+  "version": "0.2.0",
   "description": "Swift macro plugin for Expo modules",
   "license": "MIT",
   "author": "650 Industries, Inc.",