feat(spm): scaffold ObjC prefix header + read defines from s.xcconfig

chrfalch · claude · chrfalch · commit 810fff4cdb64 · 2026-06-17T15:33:42.000+02:00
Two fixes that, together with the prior scaffolder work, make
react-native-reanimated + react-native-worklets build end-to-end under SPM.

1. ObjC prefix header (replaces CocoaPods' generated prefix.pch). worklets'
   ObjC++ sources (IOSUIScheduler.mm, AssertJavaScriptQueue.h) use NSThread /
   dispatch_* / UIKit with NO explicit import — they rely on the prefix header
   CocoaPods auto-generates for every pod (imports Foundation + UIKit). SPM has
   no prefix-header mechanism, so the build failed with "use of undeclared
   identifier 'NSThread'". Fix: when a scaffolded target has ObjC(++) sources
   (.m/.mm), emit a `react-native-spm-prefix.h` at the dep root and `-include`
   it on the target (cSettings + cxxSettings). The `__OBJC__` guard makes it a
   no-op for plain C/C++; UIKit is `__has_include`-guarded. `-include` resolves
   the bare name via the dep-root header search path (".", ensured in translate).

2. Read defines from `s.xcconfig`, not just `pod_target_xcconfig`. worklets
   declares `-DWORKLETS_VERSION` in pod_target_xcconfig; reanimated declares
   `-DREANIMATED_VERSION` in `s.xcconfig`. The defines reader only scanned
   pod_target_xcconfig, so REANIMATED_VERSION was dropped → "use of undeclared
   identifier 'REANIMATED_VERSION_STRING'". Now scans pod_target_xcconfig,
   xcconfig, and user_target_xcconfig (deduped).

- SCAFFOLDER_VERSION 12 → 14 (output changed → regenerate existing scaffolds).
- spm-types.js: `needsObjCPrefix` on SpmScaffoldSpec.
- Tests: prefix emission + ObjC-source detection; defines lifted from s.xcconfig.

Verified end-to-end: `xcodebuild` of the ReactNativeReanimated scheme (which
builds worklets too) **BUILD SUCCEEDED** on a real RN 0.87 app — the complete
reanimated/worklets graph compiles and links via SPM. 336 spm tests pass.

Co-Authored-By: Claude Opus 4.8 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/packages/react-native/scripts/spm/__tests__/read-podspec-test.js b/packages/react-native/scripts/spm/__tests__/read-podspec-test.js
@@ -237,6 +237,32 @@ describe('flattenSubspecs', () => {
     expect(model.preprocessorDefines).toHaveLength(3);
   });
 
+  it('lifts defines from s.xcconfig too, not just pod_target_xcconfig (reanimated shape)', () => {
+    const raw = {
+      name: 'RNReanimated',
+      version: '4.4.1',
+      // reanimated declares its version define in `s.xcconfig`, not
+      // pod_target_xcconfig (where worklets puts it).
+      xcconfig: {
+        OTHER_CFLAGS: '$(inherited) -DREANIMATED_VERSION=4.4.1',
+      },
+      pod_target_xcconfig: {
+        'GCC_PREPROCESSOR_DEFINITIONS[config=*Debug*]':
+          '$(inherited) HERMES_ENABLE_DEBUGGER=1',
+      },
+    };
+    const model = flattenSubspecs(raw);
+    const byName = Object.fromEntries(
+      model.preprocessorDefines.map(d => [d.name, d]),
+    );
+    expect(byName.REANIMATED_VERSION).toEqual({
+      name: 'REANIMATED_VERSION',
+      value: '4.4.1',
+      config: null,
+    });
+    expect(byName.HERMES_ENABLE_DEBUGGER.config).toBe('debug');
+  });
+
   it('drops non-define flags and unresolved tokens from OTHER_CFLAGS', () => {
     const raw = {
       name: 'foo',
diff --git a/packages/react-native/scripts/spm/__tests__/scaffold-package-swift-test.js b/packages/react-native/scripts/spm/__tests__/scaffold-package-swift-test.js
@@ -172,6 +172,37 @@ describe('translatePodspecToSpmTarget', () => {
     }
   });
 
+  it('flags needsObjCPrefix (and adds "." to the search path) when the target has ObjC(++) sources', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'objc-scaffold-'));
+    try {
+      fs.writeFileSync(path.join(root, 'A.mm'), '');
+      const model = podspec({sourceFiles: ['A.mm', 'B.cpp']});
+      const spec = translatePodspecToSpmTarget(
+        model,
+        autolinkedDep({name: 'react-native-foo', root}),
+      );
+      expect(spec.needsObjCPrefix).toBe(true);
+      expect(spec.headerSearchPaths).toContain('.');
+    } finally {
+      fs.rmSync(root, {recursive: true, force: true});
+    }
+  });
+
+  it('does not flag needsObjCPrefix for a C++-only target', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cpp-scaffold-'));
+    try {
+      fs.writeFileSync(path.join(root, 'A.cpp'), '');
+      const model = podspec({sourceFiles: ['A.cpp']});
+      const spec = translatePodspecToSpmTarget(
+        model,
+        autolinkedDep({name: 'react-native-foo', root}),
+      );
+      expect(spec.needsObjCPrefix).toBe(false);
+    } finally {
+      fs.rmSync(root, {recursive: true, force: true});
+    }
+  });
+
   it('does not add "." for a single-segment header_mappings_dir', () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), 'rea-scaffold-'));
     try {
@@ -350,6 +381,7 @@ describe('emitScaffoldedPackageSwift', () => {
       sources: [],
       headerSearchPaths: [],
       preprocessorDefines: [],
+      needsObjCPrefix: false,
       coreReactNative: false,
       siblingNames: [],
       extraFrameworks: [],
@@ -455,6 +487,24 @@ describe('emitScaffoldedPackageSwift', () => {
     );
   });
 
+  it('-includes the ObjC prefix header in c/cxx settings when needsObjCPrefix is set', () => {
+    const withPrefix = emitScaffoldedPackageSwift(
+      baseSpec({needsObjCPrefix: true}),
+    );
+    expect(
+      (
+        withPrefix.match(
+          /\.unsafeFlags\(\["-include", "react-native-spm-prefix\.h"\]\)/g,
+        ) ?? []
+      ).length,
+    ).toBe(2); // cSettings + cxxSettings
+    // Not emitted for a C/C++-only target.
+    const noPrefix = emitScaffoldedPackageSwift(
+      baseSpec({needsObjCPrefix: false}),
+    );
+    expect(noPrefix).not.toContain('-include');
+  });
+
   it('emits preprocessor defines as .define(...) in c/cxx settings, escaping quoted values and honoring config', () => {
     const out = emitScaffoldedPackageSwift(
       baseSpec({
@@ -855,6 +905,7 @@ describe('SCAFFOLDER_VERSION', () => {
       sources: [],
       headerSearchPaths: [],
       preprocessorDefines: [],
+      needsObjCPrefix: false,
       coreReactNative: false,
       siblingNames: [],
       extraFrameworks: [],
diff --git a/packages/react-native/scripts/spm/read-podspec.js b/packages/react-native/scripts/spm/read-podspec.js
@@ -471,51 +471,64 @@ function flattenSubspecs(rawSpec /*: RawSpec */) /*: PodspecModel */ {
       seen.add(key);
       out.push({name, value, config});
     };
+    // Defines can live in the target xcconfig (pod_target_xcconfig) OR the
+    // aggregate/user xcconfig (`s.xcconfig` / user_target_xcconfig). worklets
+    // puts its version define in pod_target_xcconfig; reanimated puts its in
+    // `s.xcconfig` — scan all three.
+    const XCCONFIG_KEYS = [
+      'pod_target_xcconfig',
+      'xcconfig',
+      'user_target_xcconfig',
+    ];
     for (const layer of layers) {
-      // $FlowFixMe[incompatible-use] layer narrowed from `mixed`
-      const xc =
-        layer != null && typeof layer === 'object'
-          ? layer.pod_target_xcconfig
-          : null;
-      if (xc == null || typeof xc !== 'object') continue;
-      for (const rawKey of Object.keys(xc)) {
-        const cflags = /^OTHER_CFLAGS(?:\[config=\*(\w+)\*\])?$/i.exec(rawKey);
-        const ppDefs =
-          /^GCC_PREPROCESSOR_DEFINITIONS(?:\[config=\*(\w+)\*\])?$/i.exec(
+      if (layer == null || typeof layer !== 'object') continue;
+      for (const xcKey of XCCONFIG_KEYS) {
+        // $FlowFixMe[incompatible-use] layer narrowed from `mixed`
+        const xc = layer[xcKey];
+        if (xc == null || typeof xc !== 'object') continue;
+        for (const rawKey of Object.keys(xc)) {
+          const cflags = /^OTHER_CFLAGS(?:\[config=\*(\w+)\*\])?$/i.exec(
             rawKey,
           );
-        if (cflags == null && ppDefs == null) continue;
-        const cfgRaw = ((cflags?.[1] ?? ppDefs?.[1] ?? '') + '').toLowerCase();
-        const config =
-          cfgRaw === 'debug'
-            ? 'debug'
-            : cfgRaw === 'release'
-              ? 'release'
-              : null;
-        // $FlowFixMe[incompatible-use] xc value access is intentional
-        const val = xc[rawKey];
-        const strs =
-          typeof val === 'string'
-            ? [val]
-            : Array.isArray(val)
-              ? val.filter(v => typeof v === 'string')
-              : [];
-        for (const s of strs) {
-          for (const tok of shellTokenize(s)) {
-            if (tok === '$(inherited)') continue;
-            // OTHER_CFLAGS: only `-D` tokens are defines; others are flags.
-            // GCC_PREPROCESSOR_DEFINITIONS: every token is `NAME[=VALUE]`.
-            let body /*: ?string */ = null;
-            if (cflags != null) {
-              if (tok.startsWith('-D')) body = tok.slice(2);
-            } else {
-              body = tok;
+          const ppDefs =
+            /^GCC_PREPROCESSOR_DEFINITIONS(?:\[config=\*(\w+)\*\])?$/i.exec(
+              rawKey,
+            );
+          if (cflags == null && ppDefs == null) continue;
+          const cfgRaw = (
+            (cflags?.[1] ?? ppDefs?.[1] ?? '') + ''
+          ).toLowerCase();
+          const config =
+            cfgRaw === 'debug'
+              ? 'debug'
+              : cfgRaw === 'release'
+                ? 'release'
+                : null;
+          // $FlowFixMe[incompatible-use] xc value access is intentional
+          const val = xc[rawKey];
+          const strs =
+            typeof val === 'string'
+              ? [val]
+              : Array.isArray(val)
+                ? val.filter(v => typeof v === 'string')
+                : [];
+          for (const s of strs) {
+            for (const tok of shellTokenize(s)) {
+              if (tok === '$(inherited)') continue;
+              // OTHER_CFLAGS: only `-D` tokens are defines; others are flags.
+              // GCC_PREPROCESSOR_DEFINITIONS: every token is `NAME[=VALUE]`.
+              let body /*: ?string */ = null;
+              if (cflags != null) {
+                if (tok.startsWith('-D')) body = tok.slice(2);
+              } else {
+                body = tok;
+              }
+              if (body == null || body.length === 0) continue;
+              const eq = body.indexOf('=');
+              const name = eq >= 0 ? body.slice(0, eq) : body;
+              const value = eq >= 0 ? body.slice(eq + 1) : null;
+              add(name, value, config);
             }
-            if (body == null || body.length === 0) continue;
-            const eq = body.indexOf('=');
-            const name = eq >= 0 ? body.slice(0, eq) : body;
-            const value = eq >= 0 ? body.slice(eq + 1) : null;
-            add(name, value, config);
           }
         }
       }
diff --git a/packages/react-native/scripts/spm/scaffold-package-swift.js b/packages/react-native/scripts/spm/scaffold-package-swift.js
@@ -89,13 +89,36 @@ const {log} = makeLogger('scaffold-package-swift');
 // package exposes `<namespace/...>` to dependents; pod-style sibling deps
 // (reanimated's `s.dependency "RNWorklets"`) wired to their npm package. v11:
 // sibling .package path uses the libs/<SwiftName> symlink name, not the npm
-// name (fixes "package ... doesn't exist" on resolve).
-const SCAFFOLDER_VERSION = 12;
+// name (fixes "package ... doesn't exist" on resolve). v12: preprocessor
+// defines from pod_target_xcconfig emitted as `.define(...)`. v13: ObjC(++)
+// targets get an ambient-import prefix header (Foundation/UIKit) `-include`d,
+// replacing CocoaPods' generated prefix.pch.
+const SCAFFOLDER_VERSION = 14;
 const SCAFFOLDER_VERSION_LINE_RE = /^\/\/ AUTO-SCAFFOLDED-VERSION: (\d+)$/m;
 
 const AUTOGEN_MARKER =
   '// AUTO-GENERATED by scripts/generate-spm-autolinking.js';
 
+// CocoaPods auto-generates a `<Target>-prefix.pch` that imports Foundation +
+// UIKit into every ObjC translation unit, so pod sources can use NSThread /
+// dispatch / UIKit symbols without an explicit import. SPM has no prefix-header
+// mechanism, so we emit this file at the dep root and `-include` it on the
+// target (cSettings + cxxSettings) to reproduce that ambient import. The
+// `__OBJC__` guard makes it inert for plain C/C++ sources, and UIKit is
+// `__has_include`-guarded for platforms that lack it.
+const SCAFFOLD_PREFIX_HEADER = 'react-native-spm-prefix.h';
+const SCAFFOLD_PREFIX_HEADER_CONTENTS = `// AUTO-SCAFFOLDED by react-native spm scaffold — mirrors CocoaPods' default
+// prefix header so ObjC sources that rely on an implicit Foundation/UIKit
+// import compile under SPM (which has no prefix-header mechanism). Safe to
+// delete + regenerate via \`npx react-native spm scaffold\`.
+#ifdef __OBJC__
+#import <Foundation/Foundation.h>
+#if __has_include(<UIKit/UIKit.h>)
+#import <UIKit/UIKit.h>
+#endif
+#endif
+`;
+
 // Names of deps the scaffolder always refuses to touch — `react-native`
 // itself is handled by the xcframework subpackage, never as an autolinked
 // target.
@@ -276,6 +299,15 @@ function translatePodspecToSpmTarget(
     }
   }
 
+  // ObjC(++) sources may rely on CocoaPods' implicit prefix-header import of
+  // Foundation/UIKit. When present, emit + `-include` a prefix header (below).
+  // The prefix is `-include`d by bare name, so the dep root (".") must be on
+  // the header search path for clang to find it.
+  const needsObjCPrefix = expandedSources.some(f => /\.mm?$/.test(f));
+  if (needsObjCPrefix && !headerSearchPaths.includes('.')) {
+    headerSearchPaths.push('.');
+  }
+
   // SPM REQUIRES publicHeadersPath to be a real directory inside the target
   // when the target compiles C-family sources (default is "include" which
   // typically doesn't exist in a podspec-shaped dep). Pick the first
@@ -325,6 +357,7 @@ function translatePodspecToSpmTarget(
     sources: expandedSources,
     headerSearchPaths,
     preprocessorDefines: model.preprocessorDefines,
+    needsObjCPrefix,
     coreReactNative,
     siblingNames,
     extraFrameworks: model.frameworks,
@@ -411,11 +444,20 @@ function emitScaffoldedPackageSwift(
     ].filter(e => e.length > 0);
     return `[${parts.join(', ')}]`;
   };
-  const cSettings = settingsEntries([]);
+  // Force-include the ambient-import prefix header on ObjC(++) sources (the
+  // `__OBJC__` guard makes it a no-op for plain C/C++). `-include` resolves the
+  // bare name via the dep-root header search path (".", ensured in translate).
+  const prefixFlag = spec.needsObjCPrefix
+    ? `.unsafeFlags(["-include", "${SCAFFOLD_PREFIX_HEADER}"])`
+    : '';
+  const cSettings = settingsEntries([prefixFlag].filter(e => e.length > 0));
   const cxxSettings = settingsEntries(
-    customFlagsCxx.length > 0
-      ? [`.unsafeFlags([${customFlagsCxx.join(', ')}])`]
-      : [],
+    [
+      prefixFlag,
+      ...(customFlagsCxx.length > 0
+        ? [`.unsafeFlags([${customFlagsCxx.join(', ')}])`]
+        : []),
+    ].filter(e => e.length > 0),
   );
 
   // Linker frameworks: defaults + podspec-declared extras + weak frameworks.
@@ -768,6 +810,15 @@ function scaffoldPackageSwiftForDep(
 
   if (!ctx.dryRun) {
     fs.writeFileSync(pkgSwiftPath, content, 'utf8');
+    // Emit the ambient-import prefix header next to the manifest when the
+    // target has ObjC(++) sources (the manifest `-include`s it by bare name).
+    if (spec.needsObjCPrefix) {
+      fs.writeFileSync(
+        path.join(dep.root, SCAFFOLD_PREFIX_HEADER),
+        SCAFFOLD_PREFIX_HEADER_CONTENTS,
+        'utf8',
+      );
+    }
   }
 
   return {
diff --git a/packages/react-native/scripts/spm/spm-types.js b/packages/react-native/scripts/spm/spm-types.js
@@ -408,6 +408,10 @@ export type SpmScaffoldSpec = {
   // Preprocessor defines (resolved by pod ipc) — emitted as `.define(...)` in
   // cSettings + cxxSettings, honoring any per-config scope.
   preprocessorDefines: Array<PreprocessorDefine>,
+  // True when the target has ObjC(++) sources (.m/.mm). Drives emitting +
+  // `-include`ing a prefix header that ambient-imports Foundation/UIKit (which
+  // CocoaPods provides via a generated prefix.pch and SPM does not).
+  needsObjCPrefix: boolean,
   // Bucketed dependency references — pre-computed by the translation layer.
   // `coreReactNative` is true when ANY React-* / RCT* / RCT-Folly / glog
   // dep is present (so we add a single `.product(name: "ReactNative", ...)`).
