ArrayBuffer support to C++ TurboModules (#56729)

Summary:
Adds `ArrayBuffer` support to C++ TurboModules. This includes:

- Codegen support for `ArrayBufferTypeAnnotation` in module specs
- `AsyncArrayBuffer` — a move-only bridging type for holding ArrayBuffer data off the JS thread
- `Bridging<AsyncArrayBuffer>::toJs` for resolving promises with native-backed or owned-bytes buffers

iOS and Android support will follow in separate PRs. The new codegen type is currently restricted to C++ TurboModules via `excludedPlatforms: ['iOS', 'android']`.

## Changelog:

[GENERAL] [ADDED] - Add `ArrayBuffer` support to C++ TurboModules

Pull Request resolved: #56729

Test Plan:
- JS parser/generators tests added.
 - New bridging unit tests in `BridgingTest.cpp` cover `AsyncArrayBuffer` construction and JS bridging.
 - `rn-tester`: `getArrayBuffer`, `processAsyncBuffer`, and `getAsyncBuffer` methods added to `NativeCxxModuleExample` in demo app.

```
[chpurrer@54913.od /data/sandcastle/boxes/fbsource (a00a9a84e7)]$ buck test //xplat/js/react-native-github/packages/react-native/ReactCommon/react/bridging:tests
↷ Skip: fbsource//xplat/js/react-native-github/packages/react-native/ReactCommon/react/bridging:tests - BridgingTest.asyncArrayBufferBorrowNativeBackedTest (0.0s)
Note: Google Test filter = BridgingTest.asyncArrayBufferBorrowNativeBackedTest
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from BridgingTest
[ RUN      ] BridgingTest.asyncArrayBufferBorrowNativeBackedTest
xplat/js/react-native-github/packages/react-native/ReactCommon/react/bridging/tests/BridgingTest.cpp:865: Skipped
Runtime does not expose tryGetMutableBuffer; borrow always throws

[  SKIPPED ] BridgingTest.asyncArrayBufferBorrowNativeBackedTest (7 ms)
[----------] 1 test from BridgingTest (7 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (7 ms total)
[  PASSED  ] 0 tests.
[  SKIPPED ] 1 test, listed below:
[  SKIPPED ] BridgingTest.asyncArrayBufferBorrowNativeBackedTest

Buck UI: https://www.internalfb.com/buck2/4a7fa180-4ce6-4dcf-b685-45d183bd4091
Test UI: https://www.internalfb.com/intern/testinfra/testrun/30680772470375729
Network: Up: 0B  Down: 0B  (reSessionID-9a7e839f-b20c-4d94-944f-8d1720e694f8)
Command: test.
Time elapsed: 3.0s
Buck UI: https://www.internalfb.com/buck2/4a7fa180-4ce6-4dcf-b685-45d183bd4091
Tests finished: Pass 31. Fail 0. Timeout 0. Fatal 0. Skip 1. Omit 0. Infra Failure 0. Build failure 0
[chpurrer@54913.od /data/sandcastle/boxes/fbsource (a00a9a84e7)]$
```

## RNTester-ios
```
buck install -r rntester-ios
```
 https://pxl.cl/9TgTf

Reviewed By: javache

Differential Revision: D105629442

Pulled By: christophpurrer

fbshipit-source-id: 91f6e3d16f69ba792469e02d6e539794e70b7101

Author: paradowstack

packages/react-native-codegen/src/CodegenSchema.d.ts

@@ -46,6 +46,10 @@ export interface VoidTypeAnnotation {
   readonly type: 'VoidTypeAnnotation';
 }
 
+export interface ArrayBufferTypeAnnotation {
+  readonly type: 'ArrayBufferTypeAnnotation';
+}
+
 export interface BooleanLiteralTypeAnnotation {
   readonly type: 'BooleanLiteralTypeAnnotation';
   readonly value: boolean;
@@ -417,7 +421,8 @@ export type NativeModuleEventEmitterTypeAnnotation =
   | ArrayTypeAnnotation<NativeModuleEventEmitterBaseTypeAnnotation>;
 
 export type NativeModuleBaseTypeAnnotation =
-  NativeModuleStringTypeAnnotation
+  ArrayBufferTypeAnnotation
+  | NativeModuleStringTypeAnnotation
   | StringLiteralTypeAnnotation
   | StringLiteralUnionTypeAnnotation
   | NativeModuleNumberTypeAnnotation

packages/react-native-codegen/src/CodegenSchema.js

@@ -68,6 +68,10 @@ export type VoidTypeAnnotation = Readonly<{
   type: 'VoidTypeAnnotation',
 }>;
 
+export type ArrayBufferTypeAnnotation = Readonly<{
+  type: 'ArrayBufferTypeAnnotation',
+}>;
+
 export type ObjectTypeAnnotation<+T> = Readonly<{
   type: 'ObjectTypeAnnotation',
   properties: ReadonlyArray<NamedShape<T>>,
@@ -411,6 +415,7 @@ export type NativeModuleEventEmitterTypeAnnotation =
   | ArrayTypeAnnotation<NativeModuleEventEmitterBaseTypeAnnotation>;
 
 export type NativeModuleBaseTypeAnnotation =
+  | ArrayBufferTypeAnnotation
   | StringTypeAnnotation
   | StringLiteralTypeAnnotation
   | StringLiteralUnionTypeAnnotation

packages/react-native-codegen/src/generators/modules/GenerateModuleH.js

@@ -146,6 +146,8 @@ function serializeArg(
       return wrap(val => `${val}.asObject(rt)`);
     case 'MixedTypeAnnotation':
       return wrap(val => `jsi::Value(rt, ${val})`);
+    case 'ArrayBufferTypeAnnotation':
+      return wrap(val => `${val}.asObject(rt).getArrayBuffer(rt)`);
     default:
       realTypeAnnotation.type as empty;
       throw new Error(
@@ -307,6 +309,8 @@ function translatePrimitiveJSTypeToCpp(
       return wrapOptional('jsi::Value', isRequired);
     case 'MixedTypeAnnotation':
       return wrapOptional('jsi::Value', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      return wrapOptional('jsi::ArrayBuffer', isRequired);
     default:
       realTypeAnnotation.type as empty;
       throw new Error(createErrorMessage(realTypeAnnotation.type));

packages/react-native-codegen/src/generators/modules/GenerateModuleJavaSpec.js

@@ -267,6 +267,10 @@ function translateFunctionParamToJavaType(
     case 'FunctionTypeAnnotation':
       imports.add('com.facebook.react.bridge.Callback');
       return wrapOptional('Callback', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -361,6 +365,10 @@ function translateFunctionReturnTypeToJavaType(
     case 'ArrayTypeAnnotation':
       imports.add('com.facebook.react.bridge.WritableArray');
       return wrapOptional('WritableArray', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -443,6 +451,10 @@ function getFalsyReturnStatementFromReturnType(
       return 'return null;';
     case 'ArrayTypeAnnotation':
       return 'return null;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `${createErrorMessage(realTypeAnnotation.type)} ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(createErrorMessage(realTypeAnnotation.type));

packages/react-native-codegen/src/generators/modules/GenerateModuleJniCpp.js

@@ -216,6 +216,8 @@ function translateReturnTypeToKind(
       return 'ObjectKind';
     case 'ArrayTypeAnnotation':
       return 'ArrayKind';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -303,6 +305,8 @@ function translateParamTypeToJniType(
       return 'Lcom/facebook/react/bridge/ReadableArray;';
     case 'FunctionTypeAnnotation':
       return 'Lcom/facebook/react/bridge/Callback;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -387,6 +391,8 @@ function translateReturnTypeToJniType(
       return 'Lcom/facebook/react/bridge/WritableMap;';
     case 'ArrayTypeAnnotation':
       return 'Lcom/facebook/react/bridge/WritableArray;';
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error('ArrayBuffer is only supported for C++ TurboModules.');
     default:
       realTypeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(

packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/StructCollector.js

@@ -132,6 +132,10 @@ class StructCollector {
         return wrapNullable(nullable, typeAnnotation);
       case 'MixedTypeAnnotation':
         throw new Error('Mixed types are unsupported in structs');
+      case 'ArrayBufferTypeAnnotation':
+        throw new Error(
+          'ArrayBuffer is unsupported in TurboModule struct types.',
+        );
       case 'UnionTypeAnnotation':
         try {
           const validUnionType = parseValidUnionType(typeAnnotation);

packages/react-native-codegen/src/generators/modules/GenerateModuleObjCpp/serializeMethod.js

@@ -387,6 +387,10 @@ function getReturnObjCType(
       }
     case 'GenericObjectTypeAnnotation':
       return wrapOptional('NSDictionary *', isRequired);
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `Unsupported return type for ${methodName}: ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       typeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(
@@ -459,6 +463,10 @@ function getReturnJSType(
           validUnionType as empty;
           throw new Error(`Unsupported union member types`);
       }
+    case 'ArrayBufferTypeAnnotation':
+      throw new Error(
+        `Unsupported return type for ${methodName}: ArrayBuffer is only supported for C++ TurboModules.`,
+      );
     default:
       typeAnnotation.type as 'MixedTypeAnnotation';
       throw new Error(

packages/react-native-codegen/src/generators/modules/__test_fixtures__/fixtures.js

@@ -2600,6 +2600,89 @@ const CXX_ONLY_NATIVE_MODULES: SchemaType = {
   },
 };
 
+const ARRAY_BUFFER_NATIVE_MODULE: SchemaType = {
+  modules: {
+    NativeSampleTurboModule: {
+      type: 'NativeModule',
+      aliasMap: {},
+      enumMap: {},
+      spec: {
+        eventEmitters: [],
+        methods: [
+          {
+            name: 'getArrayBuffer',
+            optional: false,
+            typeAnnotation: {
+              type: 'FunctionTypeAnnotation',
+              returnTypeAnnotation: {
+                type: 'ArrayBufferTypeAnnotation',
+              },
+              params: [],
+            },
+          },
+          {
+            name: 'voidArrayBuffer',
+            optional: false,
+            typeAnnotation: {
+              type: 'FunctionTypeAnnotation',
+              returnTypeAnnotation: {
+                type: 'VoidTypeAnnotation',
+              },
+              params: [
+                {
+                  name: 'arg',
+                  optional: false,
+                  typeAnnotation: {
+                    type: 'ArrayBufferTypeAnnotation',
+                  },
+                },
+              ],
+            },
+          },
+          {
+            name: 'voidNullableArrayBuffer',
+            optional: false,
+            typeAnnotation: {
+              type: 'FunctionTypeAnnotation',
+              returnTypeAnnotation: {
+                type: 'VoidTypeAnnotation',
+              },
+              params: [
+                {
+                  name: 'arg',
+                  optional: false,
+                  typeAnnotation: {
+                    type: 'NullableTypeAnnotation',
+                    typeAnnotation: {
+                      type: 'ArrayBufferTypeAnnotation',
+                    },
+                  },
+                },
+              ],
+            },
+          },
+          {
+            name: 'promiseArrayBuffer',
+            optional: false,
+            typeAnnotation: {
+              type: 'FunctionTypeAnnotation',
+              returnTypeAnnotation: {
+                type: 'PromiseTypeAnnotation',
+                elementType: {
+                  type: 'ArrayBufferTypeAnnotation',
+                },
+              },
+              params: [],
+            },
+          },
+        ],
+      },
+      moduleName: 'SampleTurboModule',
+      excludedPlatforms: ['iOS', 'android'],
+    },
+  },
+};
+
 const SAMPLE_WITH_UPPERCASE_NAME: SchemaType = {
   modules: {
     NativeSampleTurboModule: {
@@ -2793,6 +2876,7 @@ const STRING_LITERALS: SchemaType = {
 };
 
 module.exports = {
+  array_buffer_native_module: ARRAY_BUFFER_NATIVE_MODULE,
   complex_objects: COMPLEX_OBJECTS,
   two_modules_different_files: TWO_MODULES_DIFFERENT_FILES,
   empty_native_modules: EMPTY_NATIVE_MODULES,

packages/react-native-codegen/src/generators/modules/__tests__/__snapshots__/GenerateModuleH-test.js.snap

@@ -38,6 +38,75 @@ private:
 }
 `;
 
+exports[`GenerateModuleH can generate fixture array_buffer_native_module 1`] = `
+Map {
+  "array_buffer_native_moduleJSI.h" => "/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+template <typename T>
+class JSI_EXPORT NativeSampleTurboModuleCxxSpec : public TurboModule {
+public:
+  static constexpr std::string_view kModuleName = \\"SampleTurboModule\\";
+
+protected:
+  NativeSampleTurboModuleCxxSpec(std::shared_ptr<CallInvoker> jsInvoker) : TurboModule(std::string{NativeSampleTurboModuleCxxSpec::kModuleName}, jsInvoker) {
+    methodMap_[\\"getArrayBuffer\\"] = MethodMetadata {.argCount = 0, .invoker = __getArrayBuffer};
+    methodMap_[\\"voidArrayBuffer\\"] = MethodMetadata {.argCount = 1, .invoker = __voidArrayBuffer};
+    methodMap_[\\"voidNullableArrayBuffer\\"] = MethodMetadata {.argCount = 1, .invoker = __voidNullableArrayBuffer};
+    methodMap_[\\"promiseArrayBuffer\\"] = MethodMetadata {.argCount = 0, .invoker = __promiseArrayBuffer};
+  }
+  
+private:
+  static jsi::Value __getArrayBuffer(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* /*args*/, size_t /*count*/) {
+    static_assert(
+      bridging::getParameterCount(&T::getArrayBuffer) == 1,
+      \\"Expected getArrayBuffer(...) to have 1 parameters\\");
+    return bridging::callFromJs<jsi::ArrayBuffer>(rt, &T::getArrayBuffer,  static_cast<NativeSampleTurboModuleCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule));
+  }
+
+  static jsi::Value __voidArrayBuffer(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::voidArrayBuffer) == 2,
+      \\"Expected voidArrayBuffer(...) to have 2 parameters\\");
+    bridging::callFromJs<void>(rt, &T::voidArrayBuffer,  static_cast<NativeSampleTurboModuleCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 ? throw jsi::JSError(rt, \\"Expected argument in position 0 to be passed\\") : args[0].asObject(rt).getArrayBuffer(rt));return jsi::Value::undefined();
+  }
+
+  static jsi::Value __voidNullableArrayBuffer(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::voidNullableArrayBuffer) == 2,
+      \\"Expected voidNullableArrayBuffer(...) to have 2 parameters\\");
+    bridging::callFromJs<void>(rt, &T::voidNullableArrayBuffer,  static_cast<NativeSampleTurboModuleCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 || args[0].isNull() || args[0].isUndefined() ? std::nullopt : std::make_optional(args[0].asObject(rt).getArrayBuffer(rt)));return jsi::Value::undefined();
+  }
+
+  static jsi::Value __promiseArrayBuffer(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* /*args*/, size_t /*count*/) {
+    static_assert(
+      bridging::getParameterCount(&T::promiseArrayBuffer) == 1,
+      \\"Expected promiseArrayBuffer(...) to have 1 parameters\\");
+    return bridging::callFromJs<jsi::Value>(rt, &T::promiseArrayBuffer,  static_cast<NativeSampleTurboModuleCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule));
+  }
+};
+
+} // namespace facebook::react
+",
+}
+`;
+
 exports[`GenerateModuleH can generate fixture complex_objects 1`] = `
 Map {
   "complex_objectsJSI.h" => "/**

packages/react-native-codegen/src/generators/modules/__tests__/__snapshots__/GenerateModuleHObjCpp-test.js.snap

@@ -65,6 +65,47 @@ namespace facebook::react {
 }
 `;
 
+exports[`GenerateModuleHObjCpp can generate fixture array_buffer_native_module 1`] = `
+Map {
+  "array_buffer_native_module.h" => "/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#ifndef __cplusplus
+#error This file must be compiled as Obj-C++. If you are importing it, you must change your file extension to .mm.
+#endif
+
+// Avoid multiple includes of array_buffer_native_module symbols
+#ifndef array_buffer_native_module_H
+#define array_buffer_native_module_H
+
+#import <Foundation/Foundation.h>
+#import <RCTRequired/RCTRequired.h>
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <RCTTypeSafety/RCTTypedModuleConstants.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTCxxConvert.h>
+#import <React/RCTManagedPointer.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <optional>
+#import <vector>
+
+
+
+#endif // array_buffer_native_module_H
+",
+}
+`;
+
 exports[`GenerateModuleHObjCpp can generate fixture complex_objects 1`] = `
 Map {
   "complex_objects.h" => "/**