Example of using Meta's c++ JSI codegen

.gitattributes

@@ -12,6 +12,7 @@
 # Spec Codegen uses LF
 *Spec.g.h eol=lf
 /vnext/codegen/** eol=lf
+/vnext/Microsoft.ReactNative.IntegrationTests/codegen/** eol=lf
 /packages/sample-apps/codegen/** eol=lf
 
 # Force Visual Studio project files (mostly XML) to CRLF

change/@react-native-windows-cli-fa61a3c9-9d92-4acb-827e-63b92770d0f6.json

@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "Enable ability to codegen JSI C++ TurboModule specs",
+  "packageName": "@react-native-windows/cli",
+  "email": "30809111+acoates-ms@users.noreply.github.com",
+  "dependentChangeType": "patch"
+}

change/@react-native-windows-codegen-cf208af5-cab0-4f53-978d-b7f54c60df9e.json

@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "Enable ability to codegen JSI C++ TurboModule specs",
+  "packageName": "@react-native-windows/codegen",
+  "email": "30809111+acoates-ms@users.noreply.github.com",
+  "dependentChangeType": "patch"
+}

change/react-native-windows-714c935b-779f-4733-8803-4c3ac23aedfe.json

@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "Update codegen version",
+  "packageName": "react-native-windows",
+  "email": "30809111+acoates-ms@users.noreply.github.com",
+  "dependentChangeType": "patch"
+}

packages/@react-native-windows/cli/src/codegen.ts

@@ -103,18 +103,25 @@ export class CodeGenWindows {
       ? path.join(this.root, pkgJson.codegenConfig.jsSrcsDir)
       : this.root;
 
+    const generators = pkgJson.codegenConfig.windows.generators ?? [
+      'modulesWindows',
+    ];
+
     const jsRootPathRelative = path.relative(process.cwd(), jsRootDir);
     const options = {
       files: [
         `${jsRootPathRelative}${
           jsRootPathRelative ? '/' : ''
         }**/*Native*.[jt]s`,
       ],
-      namespace: projectNamespace,
       libraryName: projectName,
-      outdir: path.join(this.root, 'codegen'),
-      methodonly: false,
-      ts: false,
+      methodOnly: false,
+      modulesCxx: generators.indexOf('modulesCxx') !== -1,
+      modulesTypeScriptTypes:
+        generators.indexOf('modulesTypeScriptTypes') !== -1,
+      modulesWindows: generators.indexOf('modulesWindows') !== -1,
+      namespace: projectNamespace,
+      outputDirectory: path.join(this.root, 'codegen'),
       test: !!this.options.check,
     };
 

packages/@react-native-windows/codegen/src/Cli.ts

@@ -18,17 +18,27 @@ const argv = yargs.options({
     array: true,
     describe: 'glob patterns for files which contains specs',
   },
-  ts: {
+  modulesTypeScriptTypes: {
     type: 'boolean',
     describe: 'generate turbo module definition files in TypeScript',
     default: false,
   },
-  methodonly: {
+  modulesCxx: {
+    type: 'boolean',
+    describe: 'generate C++ JSI turbo module spec files',
+    default: false,
+  },
+  modulesWindows: {
+    type: 'boolean',
+    describe: 'generate turbo module spec files for REACT_MODULE',
+    default: false,
+  },
+  methodOnly: {
     type: 'boolean',
     describe: 'generate only method metadata in C++ turbo module spec',
     default: false,
   },
-  outdir: {
+  outputDirectory: {
     type: 'string',
     describe: 'output directory',
     default: 'codegen',

packages/@react-native-windows/codegen/src/generators/GenerateNM2.ts

@@ -44,11 +44,11 @@ struct ::_MODULE_NAME_::Spec : winrt::Microsoft::ReactNative::TurboModuleSpec {
 `;
 
 export function createNM2Generator({
+  methodOnly,
   namespace,
-  methodonly,
 }: {
+  methodOnly: boolean;
   namespace: string;
-  methodonly: boolean;
 }) {
   return (
     _libraryName: string,
@@ -85,7 +85,7 @@ ${methods[0]}
 
         // prepare constants
         const constants = generateValidateConstants(nativeModule, aliases);
-        if (constants !== undefined && !methodonly) {
+        if (constants !== undefined && !methodOnly) {
           tuples = `
   static constexpr auto constants = std::tuple{
 ${constants[0]}

packages/@react-native-windows/codegen/src/index.ts

@@ -33,12 +33,14 @@ const schemaValidator = require(path.resolve(
 
 interface Options {
   libraryName: string;
-  schema: SchemaType;
-  outputDirectory: string;
+  methodOnly: boolean;
+  modulesCxx: boolean;
   moduleSpecName: string;
+  modulesTypeScriptTypes: boolean;
+  modulesWindows: boolean;
   namespace: string;
-  methodonly: boolean;
-  ts: boolean;
+  outputDirectory: string;
+  schema: SchemaType;
 }
 
 interface Config {
@@ -179,12 +181,14 @@ export function combineSchemas(files: string[]): SchemaType {
 export function generate(
   {
     libraryName,
-    schema,
-    outputDirectory,
+    methodOnly,
+    modulesCxx,
     moduleSpecName,
+    modulesTypeScriptTypes,
+    modulesWindows,
     namespace,
-    methodonly,
-    ts,
+    outputDirectory,
+    schema,
   }: Options,
   {/*generators,*/ test}: Config,
 ): boolean {
@@ -204,10 +208,18 @@ export function generate(
   );
 
   const generateNM2 = createNM2Generator({
+    methodOnly,
     namespace,
-    methodonly,
   });
 
+  const generateJsiModuleH = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/modules/GenerateModuleH',
+  )).generate;
+  const generateJsiModuleCpp = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/modules/GenerateModuleCpp',
+  )).generate;
   const generatorPropsH = require(path.resolve(
     rncodegenPath,
     'lib/generators/components/GeneratePropsH',
@@ -237,33 +249,43 @@ export function generate(
     'lib/generators/components/GenerateEventEmitterCpp',
   )).generate;
 
-  normalizeFileMap(
-    generateNM2(libraryName, schema, moduleSpecName),
-    outputDirectory,
-    generatedFiles,
-  );
+  const moduleGenerators = [];
 
-  if (ts) {
-    normalizeFileMap(
-      generateTypeScript(libraryName, schema, moduleSpecName),
-      outputDirectory,
-      generatedFiles,
-    );
+  if (modulesWindows) {
+    moduleGenerators.push(generateNM2);
   }
 
+  if (modulesCxx) {
+    moduleGenerators.push(generateJsiModuleH);
+    moduleGenerators.push(generateJsiModuleCpp);
+  }
+
+  if (modulesTypeScriptTypes) {
+    moduleGenerators.push(generateTypeScript);
+  }
+
+  moduleGenerators.forEach(generator => {
+    const generated: Map<string, string> = generator(
+      libraryName,
+      schema,
+      moduleSpecName,
+    );
+    normalizeFileMap(generated, outputDirectory, generatedFiles);
+  });
+
   if (
     Object.keys(schema.modules).some(
       moduleName => schema.modules[moduleName].type === 'Component',
     )
   ) {
     const componentGenerators = [
-      generatorPropsH,
-      generatorPropsCPP,
-      generatorShadowNodeH,
-      generatorShadowNodeCPP,
       generatorComponentDescriptorH,
-      generatorEventEmitterH,
       generatorEventEmitterCPP,
+      generatorEventEmitterH,
+      generatorPropsCPP,
+      generatorPropsH,
+      generatorShadowNodeCPP,
+      generatorShadowNodeH,
     ];
 
     componentGenerators.forEach(generator => {
@@ -287,10 +309,12 @@ export type CodeGenOptions = {
   file?: string;
   files?: string[];
   libraryName: string;
-  outdir: string;
+  methodOnly: boolean;
+  modulesCxx: boolean;
+  modulesTypeScriptTypes: boolean;
+  modulesWindows: boolean;
   namespace: string;
-  methodonly: boolean;
-  ts: boolean;
+  outputDirectory: string;
   test: boolean;
 };
 
@@ -304,17 +328,25 @@ export function runCodeGen(options: CodeGenOptions): boolean {
 
   const libraryName = options.libraryName;
   const moduleSpecName = 'moduleSpecName';
-  const outputDirectory = options.outdir;
-  const {namespace, methodonly, ts} = options;
+  const {
+    methodOnly,
+    modulesCxx,
+    modulesTypeScriptTypes,
+    modulesWindows,
+    namespace,
+    outputDirectory,
+  } = options;
   return generate(
     {
       libraryName,
-      schema,
-      outputDirectory,
+      methodOnly,
+      modulesCxx,
       moduleSpecName,
+      modulesTypeScriptTypes,
+      modulesWindows,
       namespace,
-      methodonly,
-      ts,
+      outputDirectory,
+      schema,
     },
     {generators: [], test: options.test},
   );

packages/sample-apps/codegen/NativeMyJsiModuleSpec.g.h

@@ -0,0 +1,101 @@
+
+/*
+ * This file is auto-generated from a NativeModule spec file in js.
+ *
+ * This is a C++ Spec class that should be used with MakeTurboModuleProvider to register native modules
+ * in a way that also verifies at compile time that the native module matches the interface required
+ * by the TurboModule JS spec.
+ */
+#pragma once
+
+#include "NativeModules.h"
+#include <tuple>
+
+namespace SampleLibraryCodegen {
+
+REACT_STRUCT(MyJsiModuleSpec_Constants)
+struct MyJsiModuleSpec_Constants {
+    REACT_FIELD(const1)
+    bool const1;
+    REACT_FIELD(const2)
+    double const2;
+    REACT_FIELD(const3)
+    std::string const3;
+};
+
+struct MyJsiModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto constants = std::tuple{
+      TypedConstant<MyJsiModuleSpec_Constants>{0},
+  };
+  static constexpr auto methods = std::tuple{
+      Method<void() noexcept>{0, L"voidFunc"},
+      SyncMethod<bool(bool) noexcept>{1, L"getBool"},
+      SyncMethod<double(double) noexcept>{2, L"getNumber"},
+      SyncMethod<std::string(std::string) noexcept>{3, L"getString"},
+      SyncMethod<::React::JSValueArray(::React::JSValueArray) noexcept>{4, L"getArray"},
+      SyncMethod<::React::JSValue(::React::JSValue) noexcept>{5, L"getObject"},
+      SyncMethod<::React::JSValue(double, std::string, ::React::JSValue) noexcept>{6, L"getValue"},
+      Method<void(Callback<std::string>) noexcept>{7, L"getValueWithCallback"},
+      Method<void(bool, Promise<::React::JSValue>) noexcept>{8, L"getValueWithPromise"},
+  };
+
+  template <class TModule>
+  static constexpr void ValidateModule() noexcept {
+    constexpr auto constantCheckResults = CheckConstants<TModule, MyJsiModuleSpec>();
+    constexpr auto methodCheckResults = CheckMethods<TModule, MyJsiModuleSpec>();
+
+    REACT_SHOW_CONSTANT_SPEC_ERRORS(
+          0,
+          "MyJsiModuleSpec_Constants",
+          "    REACT_GET_CONSTANTS(GetConstants) MyJsiModuleSpec_Constants GetConstants() noexcept {/*implementation*/}\n"
+          "    REACT_GET_CONSTANTS(GetConstants) static MyJsiModuleSpec_Constants GetConstants() noexcept {/*implementation*/}\n");
+
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          0,
+          "voidFunc",
+          "    REACT_METHOD(voidFunc) void voidFunc() noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(voidFunc) static void voidFunc() noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          1,
+          "getBool",
+          "    REACT_SYNC_METHOD(getBool) bool getBool(bool arg) noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getBool) static bool getBool(bool arg) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          2,
+          "getNumber",
+          "    REACT_SYNC_METHOD(getNumber) double getNumber(double arg) noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getNumber) static double getNumber(double arg) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          3,
+          "getString",
+          "    REACT_SYNC_METHOD(getString) std::string getString(std::string arg) noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getString) static std::string getString(std::string arg) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          4,
+          "getArray",
+          "    REACT_SYNC_METHOD(getArray) ::React::JSValueArray getArray(::React::JSValueArray && arg) noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getArray) static ::React::JSValueArray getArray(::React::JSValueArray && arg) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          5,
+          "getObject",
+          "    REACT_SYNC_METHOD(getObject) ::React::JSValue getObject(::React::JSValue && arg) noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getObject) static ::React::JSValue getObject(::React::JSValue && arg) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          6,
+          "getValue",
+          "    REACT_SYNC_METHOD(getValue) ::React::JSValue getValue(double x, std::string y, ::React::JSValue && z) noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getValue) static ::React::JSValue getValue(double x, std::string y, ::React::JSValue && z) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          7,
+          "getValueWithCallback",
+          "    REACT_METHOD(getValueWithCallback) void getValueWithCallback(std::function<void(std::string)> const & callback) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getValueWithCallback) static void getValueWithCallback(std::function<void(std::string)> const & callback) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          8,
+          "getValueWithPromise",
+          "    REACT_METHOD(getValueWithPromise) void getValueWithPromise(bool error, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getValueWithPromise) static void getValueWithPromise(bool error, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+  }
+};
+
+} // namespace SampleLibraryCodegen