fix(ios): serve the react/ namespace as a module for SPM consumers

React.framework is a clang module; when an SPM consumer precompiles it, a
modular React/ header that #imports <react/...> hit
-Wnon-modular-include-in-framework-module because the lowercase react/
namespace (served from ReactNativeHeaders, per R1's Linux/Windows-safe layout)
was deliberately kept out of any module.

Give react/ a module where it already lives instead of relocating it (relocation
would require case-folding react.framework -> React.framework, which only works
on case-insensitive filesystems):

- headers-spec.js: drop the react/ namespace-module exemption so its
  objc-modular-candidates get a module; emit that module as
  ReactNativeHeaders_react (a module literally named 'react' would alias the
  React framework module on a case-insensitive filesystem). Module names are
  internal; <react/...> still resolves by header path and is now modular.
- headers-inventory.js: classify C++ default member initializers in aggregates
  (e.g. struct { NSString *family = nil; } in RCTFontProperties.h) as ObjC++ so
  these are not misclassified objc-modular-candidate and pulled into a plain
  ObjC module they cannot compile in.

The unguarded ObjC/C react/ headers (e.g. JSRuntimeFactoryCAPI.h) now resolve
modularly; the C++ react/renderer/* includes are #ifdef __cplusplus-guarded and
skipped during the ObjC module emit, so they need no module.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: chrfalch

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

@@ -148,7 +148,7 @@ function scanHeader(text /*: string */) /*: {
   const objcRe =
     /^\s*(@(interface|protocol|implementation|class\s|end)|NS_ASSUME_NONNULL_BEGIN)/;
   const cxxRe =
-    /^\s*(namespace\s+[A-Za-z_]|template\s*<|extern\s+"C\+\+"|using\s+(namespace\s|[A-Za-z_]\w*\s*=))/;
+    /^\s*(namespace\s+[A-Za-z_]|template\s*<|extern\s+"C\+\+"|enum\s+class\b|constexpr\b|using\s+(namespace\s|[A-Za-z_]\w*\s*=))/;
 
   for (const rawLine of text.split('\n')) {
     const line = rawLine.replace(/\/\/.*$/, '');
@@ -197,6 +197,22 @@ function scanHeader(text /*: string */) /*: {
       }
     }
   }
+
+  // C++ default member initializer inside an aggregate, e.g.
+  //   struct RCTFontProperties { NSString *family = nil; CGFloat size = NAN; };
+  // Illegal in C/ObjC, so the header is really ObjC++ and cannot compile in a
+  // plain ObjC module. The keyword scan above misses it (no namespace/template/
+  // class keyword). Detect a `struct`/`class` body that contains a member
+  // declaration carrying an `=` initializer. Whole-text (not per-line) so the
+  // aggregate context is required, avoiding false positives on file-scope
+  // definitions. Unguarded by construction (definitions can't sit under a
+  // pure `#ifdef __cplusplus` and still be the ObjC surface).
+  const aggregateMemberInitRe =
+    /\b(?:struct|class)\s+[A-Za-z_]\w*[^;{}]*\{[^{}]*?\b[A-Za-z_][\w\s:<>,]*\**\s+\*?[A-Za-z_]\w*\s*=\s*[^;{}]+;/s;
+  if (aggregateMemberInitRe.test(text)) {
+    hasUnguardedCxx = true;
+  }
+
   return {includes, hasObjC, hasUnguardedCxx, hasGuardedCxx};
 }
 

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

@@ -161,12 +161,16 @@ function planFromInventory(manifest /*: any */) /*: HeadersSpecPlan */ {
     if (np.startsWith('React/') && isUmbrellaSafe(h)) {
       umbrella.push(np);
     }
-    // R5: namespace modules (only for ReactNativeHeaders namespaces). `react/`
-    // is exempt — its few modular candidates stay textual so no `react` module
-    // aliases the `React` framework module.
+    // R5: namespace modules (only for ReactNativeHeaders namespaces). Every
+    // namespace with modular candidates gets a module so that React.framework's
+    // modular headers can `#import <ns/...>` as a MODULAR include (otherwise
+    // clang's -Wnon-modular-include-in-framework-module rejects it). `react/` is
+    // included here too — its module is renamed in renderNamespaceModuleMap so a
+    // `react` module never aliases the `React` framework module on a
+    // case-insensitive filesystem.
     if (entryList === reactNativeHeaders) {
       const ns = np.split('/')[0];
-      if (ns !== 'react' && MODULE_IDENT_RE.test(ns) && isUmbrellaSafe(h)) {
+      if (MODULE_IDENT_RE.test(ns) && isUmbrellaSafe(h)) {
         if (!namespaceModules[ns]) {
           namespaceModules[ns] = [];
         }
@@ -214,10 +218,18 @@ function renderUmbrellaHeader(umbrella /*: Array<string> */) /*: string */ {
 function renderNamespaceModuleMap(
   namespaceModules /*: {[string]: Array<string>} */,
 ) /*: string */ {
+  // The module NAME is internal to clang's module graph (consumers never
+  // `@import` these; they `#import <ns/...>` and clang maps the header to its
+  // module). It only has to be unique and must not alias the `React` framework
+  // module on a case-insensitive filesystem — so the lowercase `react`
+  // namespace is given a distinct module name. Header paths are unchanged, so
+  // `<react/...>` still resolves and is now a modular include.
+  const moduleNameFor = (ns /*: string */) /*: string */ =>
+    ns === 'react' ? 'ReactNativeHeaders_react' : ns;
   const blocks = [];
   for (const ns of Object.keys(namespaceModules).sort()) {
     blocks.push(
-      `module ${ns} {\n` +
+      `module ${moduleNameFor(ns)} {\n` +
         namespaceModules[ns].map(hh => `  header "${hh}"`).join('\n') +
         `\n  export *\n}`,
     );