feat(ios): emit per-namespace umbrella for React_RCTAppDelegate (R10)

The flattened ReactNativeHeaders layout ships the individual
React_RCTAppDelegate/*.h headers but no per-namespace umbrella. Consumers like
Expo probe `<React_RCTAppDelegate/React_RCTAppDelegate-umbrella.h>` via
__has_include (RCTAppDelegateUmbrella.h); with the umbrella gone the probe
fails and RCTReactNativeFactory / RCTRootViewFactory are never declared,
breaking the Expo pod's clang module.

Add R10: emit a per-namespace umbrella (content DERIVED from namespaceModules
so it can't drift — e.g. RCTArchConfiguratorProtocol.h, gone from this branch,
is correctly omitted) and add it to that namespace's module so the import stays
modular under explicit modules. Targeted via UMBRELLA_NAMESPACES (currently just
React_RCTAppDelegate, the only umbrella Expo imports); fails closed if a listed
namespace loses its modular headers.

Author: chrfalch

packages/react-native/scripts/ios-prebuild/__tests__/headers-spec-test.js

@@ -10,19 +10,27 @@
 
 'use strict';
 
-const {planFromInventory, renderReactModuleMap} = require('../headers-spec');
+const fs = require('fs');
+const {
+  planFromInventory,
+  renderNamespaceModuleMap,
+  renderReactModuleMap,
+} = require('../headers-spec');
+
+// isUmbrellaSafe reads each header's source to reject extern-inline defs. Stub
+// it to empty so synthetic objc-modular-candidate headers count as umbrella-safe
+// (and thus land in namespaceModules), making these tests deterministic.
+jest.spyOn(fs, 'readFileSync').mockReturnValue('');
 
-// Minimal inventory entry. isUmbrellaSafe reads the source off disk for React/
-// headers; the synthetic paths don't exist so it falls back to false — which is
-// fine here, these tests exercise the R9 allowlist, not umbrella membership.
 const entry = (naturalPath /*: string */, bucket /*: string */) => ({
   naturalPath,
   bucket,
   lang: 'objc',
   identities: [{source: `does/not/exist/${naturalPath}`}],
 });
 
-// A manifest that satisfies the R9 private-header allowlist.
+// A manifest satisfying both the R9 private-header allowlist and the R10
+// umbrella-namespace allowlist (React_RCTAppDelegate).
 const validManifest = () => ({
   headers: [
     entry('React/RCTBridge+Private.h', 'objc-modular-candidate'),
@@ -32,6 +40,15 @@ const validManifest = () => ({
     entry('React/RCTMountingManager.h', 'objc-blocked'),
     entry('React/RCTSurfacePresenter.h', 'objc-blocked'),
     entry('React/RCTViewComponentView.h', 'objc-blocked'),
+    entry(
+      'React_RCTAppDelegate/RCTReactNativeFactory.h',
+      'objc-modular-candidate',
+    ),
+    entry(
+      'React_RCTAppDelegate/RCTRootViewFactory.h',
+      'objc-modular-candidate',
+    ),
+    entry('React_RCTAppDelegate/RCTAppDelegate.h', 'objc-modular-candidate'),
   ],
 });
 
@@ -84,3 +101,42 @@ describe('planFromInventory R9 validation', () => {
     expect(() => planFromInventory(m)).toThrow(/not 'objc-modular-candidate'/);
   });
 });
+
+describe('R10 per-namespace umbrella (React_RCTAppDelegate)', () => {
+  test('emits a derived umbrella for the namespace', () => {
+    const plan = planFromInventory(validManifest());
+    const u = plan.namespaceUmbrellas.find(
+      x => x.relPath === 'React_RCTAppDelegate/React_RCTAppDelegate-umbrella.h',
+    );
+    expect(u).toBeDefined();
+    if (u == null) {
+      return;
+    }
+    // Imports are relative to the namespace dir, derived from the live set.
+    expect(u.content).toContain('#import "RCTReactNativeFactory.h"');
+    expect(u.content).toContain('#import "RCTRootViewFactory.h"');
+    expect(u.content).toContain('#import "RCTAppDelegate.h"');
+    expect(u.content).toContain('#ifdef __OBJC__');
+    // No CocoaPods version boilerplate.
+    expect(u.content).not.toContain('FOUNDATION_EXPORT');
+  });
+
+  test('module map lists the umbrella so the import stays modular', () => {
+    const plan = planFromInventory(validManifest());
+    const mm = renderNamespaceModuleMap(plan.namespaceModules);
+    expect(mm).toContain('module React_RCTAppDelegate {');
+    expect(mm).toContain(
+      'header "React_RCTAppDelegate/React_RCTAppDelegate-umbrella.h"',
+    );
+  });
+
+  test('fails closed when the umbrella namespace lost its modular headers', () => {
+    const m = validManifest();
+    m.headers = m.headers.filter(
+      x => !x.naturalPath.startsWith('React_RCTAppDelegate/'),
+    );
+    expect(() => planFromInventory(m)).toThrow(
+      /umbrella namespace 'React_RCTAppDelegate'/,
+    );
+  });
+});

packages/react-native/scripts/ios-prebuild/headers-compose.js

@@ -180,6 +180,14 @@ function buildReactNativeHeadersXcframework(
       console.warn(`headers-compose: hermes headers missing at ${src}`);
     }
   }
+  // R10: per-namespace umbrella headers (e.g. React_RCTAppDelegate-umbrella.h)
+  // that consumers like Expo probe via __has_include. Must be staged before the
+  // module map references them.
+  for (const u of plan.namespaceUmbrellas) {
+    const dest = path.join(stage, u.relPath);
+    fs.mkdirSync(path.dirname(dest), {recursive: true});
+    fs.writeFileSync(dest, u.content);
+  }
   fs.writeFileSync(
     path.join(stage, 'module.modulemap'),
     renderNamespaceModuleMap(plan.namespaceModules),

packages/react-native/scripts/ios-prebuild/headers-spec.js

@@ -81,6 +81,8 @@ export type HeadersSpecPlan = {
   umbrella: Array<string>,
   // R5: plain modules for ReactNativeHeaders' module.modulemap
   namespaceModules: {[ns: string]: Array<string>},
+  // R10: per-namespace umbrella headers emitted into ReactNativeHeaders.
+  namespaceUmbrellas: Array<{relPath: string, content: string}>,
   // R9: private headers added to the React module map (allowlist).
   privateReactHeaders: {modular: Array<string>, textual: Array<string>},
   collisions: Array<string>,
@@ -175,6 +177,32 @@ function isUmbrellaSafe(h /*: any */) /*: boolean */ {
   }
 }
 
+// R10: per-namespace umbrella headers. Some consumers (e.g. Expo's
+// RCTAppDelegateUmbrella.h) probe
+// `<React_RCTAppDelegate/React_RCTAppDelegate-umbrella.h>` via __has_include.
+// The flattened ReactNativeHeaders layout (R2/R5) ships the individual
+// namespace headers but no umbrella, so the probe fails and e.g.
+// RCTReactNativeFactory / RCTRootViewFactory are never declared. Re-emit a
+// per-namespace umbrella for the namespaces consumers probe — content DERIVED
+// from namespaceModules (R5) so it can't drift — and add it to that
+// namespace's module so the import stays modular under explicit modules.
+// Targeted (not all namespaces): only those a consumer imports as
+// `<ns/ns-umbrella.h>`. Extend as the ecosystem surfaces more.
+const UMBRELLA_NAMESPACES /*: Array<string> */ = ['React_RCTAppDelegate'];
+
+// Renders a per-namespace umbrella that re-imports the namespace's modular
+// headers. Paths are relative to the namespace dir (where the umbrella lives),
+// so the first `<ns>/` segment is stripped.
+function renderNamespaceUmbrella(
+  ns /*: string */,
+  headers /*: Array<string> */,
+) /*: string */ {
+  const imports = headers
+    .map(np => `#import "${np.slice(ns.length + 1)}"`)
+    .join('\n');
+  return `#ifdef __OBJC__\n#import <UIKit/UIKit.h>\n#endif\n\n${imports}\n`;
+}
+
 /**
  * Computes the full layout plan from the header inventory manifest
  * (build/header-inventory.json — regenerate with header-inventory.js).
@@ -246,12 +274,30 @@ function planFromInventory(manifest /*: any */) /*: HeadersSpecPlan */ {
     namespaceModules[ns].sort();
   }
 
+  // R10: fail closed if a probed umbrella namespace lost all its modular
+  // headers (removed/renamed) — the umbrella would silently vanish and
+  // re-break consumers like Expo.
+  const namespaceUmbrellas = UMBRELLA_NAMESPACES.map(ns => {
+    const headers = namespaceModules[ns];
+    if (headers == null || headers.length === 0) {
+      throw new Error(
+        `R10: umbrella namespace '${ns}' has no modular headers in the ` +
+          `inventory (removed/renamed?). Update UMBRELLA_NAMESPACES.`,
+      );
+    }
+    return {
+      relPath: `${ns}/${ns}-umbrella.h`,
+      content: renderNamespaceUmbrella(ns, headers),
+    };
+  });
+
   return {
     react,
     reactNativeHeaders,
     depsNamespaces: DEPS_NAMESPACES,
     umbrella,
     namespaceModules,
+    namespaceUmbrellas,
     privateReactHeaders: PRIVATE_REACT_HEADERS,
     collisions,
   };
@@ -304,9 +350,16 @@ function renderNamespaceModuleMap(
     ns === 'react' ? 'ReactNativeHeaders_react' : ns;
   const blocks = [];
   for (const ns of Object.keys(namespaceModules).sort()) {
+    const headerLines = namespaceModules[ns].map(hh => `  header "${hh}"`);
+    // R10: the per-namespace umbrella is itself a module member, so importing
+    // it stays modular (otherwise it re-trips -Wnon-modular-include inside the
+    // consumer's framework module).
+    if (UMBRELLA_NAMESPACES.includes(ns)) {
+      headerLines.push(`  header "${ns}/${ns}-umbrella.h"`);
+    }
     blocks.push(
       `module ${moduleNameFor(ns)} {\n` +
-        namespaceModules[ns].map(hh => `  header "${hh}"`).join('\n') +
+        headerLines.join('\n') +
         `\n  export *\n}`,
     );
   }