@react-native/codegen 0.74.0 → 0.75.0-nightly-20240221-a1171f79f

package/lib/generators/modules/GenerateModuleH.js.flow

@@ -10,33 +10,33 @@
 
 'use strict';
 import type {
-  NativeModuleBaseTypeAnnotation,
   NamedShape,
+  NativeModuleBaseTypeAnnotation,
 } from '../../CodegenSchema';
-
 import type {
-  Nullable,
-  SchemaType,
-  NativeModuleTypeAnnotation,
-  NativeModuleFunctionTypeAnnotation,
-  NativeModulePropertyShape,
   NativeModuleAliasMap,
   NativeModuleEnumMap,
   NativeModuleEnumMembers,
   NativeModuleEnumMemberType,
+  NativeModuleFunctionTypeAnnotation,
+  NativeModulePropertyShape,
+  NativeModuleTypeAnnotation,
+  Nullable,
+  SchemaType,
 } from '../../CodegenSchema';
-
 import type {AliasResolver} from './Utils';
 
+const {unwrapNullable} = require('../../parsers/parsers-commons');
+const {wrapOptional} = require('../TypeUtils/Cxx');
 const {getEnumName, toSafeCppString} = require('../Utils');
-
+const {indent} = require('../Utils');
 const {
   createAliasResolver,
-  getModules,
   getAreEnumMembersInteger,
+  getModules,
+  isArrayRecursiveMember,
+  isDirectRecursiveMember,
 } = require('./Utils');
-const {indent} = require('../Utils');
-const {unwrapNullable} = require('../../parsers/parsers-commons');
 
 type FilesOutput = Map<string, string>;
 
@@ -83,7 +83,7 @@ public:
 protected:
   ${hasteModuleName}CxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule(std::string{${hasteModuleName}CxxSpec::kModuleName}, jsInvoker),
-      delegate_(static_cast<T*>(this), jsInvoker) {}
+      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
 
 private:
   class Delegate : public ${hasteModuleName}CxxSpecJSI {
@@ -120,18 +120,17 @@ const FileTemplate = ({
 #include <ReactCommon/TurboModule.h>
 #include <react/bridging/Bridging.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 ${modules.join('\n\n')}
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react
 `;
 };
 
 function translatePrimitiveJSTypeToCpp(
   moduleName: string,
+  parentObjectAliasName: ?string,
   nullableTypeAnnotation: Nullable<NativeModuleTypeAnnotation>,
   optional: boolean,
   createErrorMessage: (typeName: string) => string,
@@ -141,22 +140,21 @@ function translatePrimitiveJSTypeToCpp(
   const [typeAnnotation, nullable] = unwrapNullable<NativeModuleTypeAnnotation>(
     nullableTypeAnnotation,
   );
-  const isRequired = !optional && !nullable;
-
+  const isRecursiveType = isDirectRecursiveMember(
+    parentObjectAliasName,
+    nullableTypeAnnotation,
+  );
+  const isRequired = (!optional && !nullable) || isRecursiveType;
   let realTypeAnnotation = typeAnnotation;
   if (realTypeAnnotation.type === 'TypeAliasTypeAnnotation') {
     realTypeAnnotation = resolveAlias(realTypeAnnotation.name);
   }
 
-  function wrap(type: string) {
-    return isRequired ? type : `std::optional<${type}>`;
-  }
-
   switch (realTypeAnnotation.type) {
     case 'ReservedTypeAnnotation':
       switch (realTypeAnnotation.name) {
         case 'RootTag':
-          return wrap('double');
+          return wrapOptional('double', isRequired);
         default:
           (realTypeAnnotation.name: empty);
           throw new Error(createErrorMessage(realTypeAnnotation.name));
@@ -164,53 +162,49 @@ function translatePrimitiveJSTypeToCpp(
     case 'VoidTypeAnnotation':
       return 'void';
     case 'StringTypeAnnotation':
-      return wrap('jsi::String');
+      return wrapOptional('jsi::String', isRequired);
     case 'NumberTypeAnnotation':
-      return wrap('double');
+      return wrapOptional('double', isRequired);
     case 'DoubleTypeAnnotation':
-      return wrap('double');
+      return wrapOptional('double', isRequired);
     case 'FloatTypeAnnotation':
-      return wrap('double');
+      return wrapOptional('double', isRequired);
     case 'Int32TypeAnnotation':
-      return wrap('int');
+      return wrapOptional('int', isRequired);
     case 'BooleanTypeAnnotation':
-      return wrap('bool');
+      return wrapOptional('bool', isRequired);
     case 'EnumDeclaration':
       switch (realTypeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return getAreEnumMembersInteger(
-            enumMap[realTypeAnnotation.name].members,
-          )
-            ? wrap('int')
-            : wrap('double');
+          return wrapOptional('jsi::Value', isRequired);
         case 'StringTypeAnnotation':
-          return wrap('jsi::String');
+          return wrapOptional('jsi::String', isRequired);
         default:
           throw new Error(createErrorMessage(realTypeAnnotation.type));
       }
     case 'GenericObjectTypeAnnotation':
-      return wrap('jsi::Object');
+      return wrapOptional('jsi::Object', isRequired);
     case 'UnionTypeAnnotation':
       switch (typeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrap('double');
+          return wrapOptional('double', isRequired);
         case 'ObjectTypeAnnotation':
-          return wrap('jsi::Object');
+          return wrapOptional('jsi::Object', isRequired);
         case 'StringTypeAnnotation':
-          return wrap('jsi::String');
+          return wrapOptional('jsi::String', isRequired);
         default:
           throw new Error(createErrorMessage(realTypeAnnotation.type));
       }
     case 'ObjectTypeAnnotation':
-      return wrap('jsi::Object');
+      return wrapOptional('jsi::Object', isRequired);
     case 'ArrayTypeAnnotation':
-      return wrap('jsi::Array');
+      return wrapOptional('jsi::Array', isRequired);
     case 'FunctionTypeAnnotation':
-      return wrap('jsi::Function');
+      return wrapOptional('jsi::Function', isRequired);
     case 'PromiseTypeAnnotation':
-      return wrap('jsi::Value');
+      return wrapOptional('jsi::Value', isRequired);
     case 'MixedTypeAnnotation':
-      return wrap('jsi::Value');
+      return wrapOptional('jsi::Value', isRequired);
     default:
       (realTypeAnnotation.type: empty);
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -224,10 +218,12 @@ function createStructsString(
   enumMap: NativeModuleEnumMap,
 ): string {
   const getCppType = (
+    parentObjectAlias: string,
     v: NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>,
   ) =>
     translatePrimitiveJSTypeToCpp(
       moduleName,
+      parentObjectAlias,
       v.typeAnnotation,
       false,
       typeName => `Unsupported type for param "${v.name}". Found: ${typeName}`,
@@ -235,33 +231,36 @@ function createStructsString(
       enumMap,
     );
 
-  return Object.keys(aliasMap)
-    .map(alias => {
-      const value = aliasMap[alias];
-      if (value.properties.length === 0) {
-        return '';
-      }
-      const structName = `${moduleName}Base${alias}`;
-      const templateParameterWithTypename = value.properties
-        .map((v, i) => `typename P${i}`)
-        .join(', ');
-      const templateParameter = value.properties
-        .map((v, i) => 'P' + i)
-        .join(', ');
-      const debugParameterConversion = value.properties
-        .map(
-          (v, i) => `  static ${getCppType(v)} ${
-            v.name
-          }ToJs(jsi::Runtime &rt, P${i} value) {
+  // TODO: T171006733 [Begin] Remove deprecated Cxx TMs structs after a new release.
+  return (
+    Object.keys(aliasMap)
+      .map(alias => {
+        const value = aliasMap[alias];
+        if (value.properties.length === 0) {
+          return '';
+        }
+        const structName = `${moduleName}Base${alias}`;
+        const structNameNew = `${moduleName}${alias}`;
+        const templateParameterWithTypename = value.properties
+          .map((v, i) => `typename P${i}`)
+          .join(', ');
+        const templateParameter = value.properties
+          .map((v, i) => 'P' + i)
+          .join(', ');
+        const debugParameterConversion = value.properties
+          .map(
+            (v, i) => `  static ${getCppType(alias, v)} ${
+              v.name
+            }ToJs(jsi::Runtime &rt, P${i} value) {
     return bridging::toJs(rt, value);
   }`,
-        )
-        .join('\n\n');
-      return `
+          )
+          .join('\n\n');
+        return `
 #pragma mark - ${structName}
 
 template <${templateParameterWithTypename}>
-struct ${structName} {
+struct [[deprecated("Use ${structNameNew} instead.")]] ${structName} {
 ${value.properties.map((v, i) => '  P' + i + ' ' + v.name).join(';\n')};
   bool operator==(const ${structName} &other) const {
     return ${value.properties
@@ -271,7 +270,7 @@ ${value.properties.map((v, i) => '  P' + i + ' ' + v.name).join(';\n')};
 };
 
 template <${templateParameterWithTypename}>
-struct ${structName}Bridging {
+struct [[deprecated("Use ${structNameNew}Bridging instead.")]] ${structName}Bridging {
   static ${structName}<${templateParameter}> fromJs(
       jsi::Runtime &rt,
       const jsi::Object &value,
@@ -311,8 +310,121 @@ ${value.properties
 };
 
 `;
-    })
-    .join('\n');
+      })
+      .join('\n') +
+    // TODO: T171006733 [End] Remove deprecated Cxx TMs structs after a new release.
+    Object.keys(aliasMap)
+      .map(alias => {
+        const value = aliasMap[alias];
+        if (value.properties.length === 0) {
+          return '';
+        }
+        const structName = `${moduleName}${alias}`;
+        const templateParameter = value.properties.filter(
+          v =>
+            !isDirectRecursiveMember(alias, v.typeAnnotation) &&
+            !isArrayRecursiveMember(alias, v.typeAnnotation),
+        );
+        const templateParameterWithTypename = templateParameter
+          .map((v, i) => `typename P${i}`)
+          .join(', ');
+        const templateParameterWithoutTypename = templateParameter
+          .map((v, i) => `P${i}`)
+          .join(', ');
+        let i = -1;
+        const templateMemberTypes = value.properties.map(v => {
+          if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+            return `std::unique_ptr<${structName}<${templateParameterWithoutTypename}>> ${v.name}`;
+          } else if (isArrayRecursiveMember(alias, v.typeAnnotation)) {
+            const [nullable] = unwrapNullable<NativeModuleTypeAnnotation>(
+              v.typeAnnotation,
+            );
+            return (
+              (nullable
+                ? `std::optional<std::vector<${structName}<${templateParameterWithoutTypename}>>>`
+                : `std::vector<${structName}<${templateParameterWithoutTypename}>>`) +
+              ` ${v.name}`
+            );
+          } else {
+            i++;
+            return `P${i} ${v.name}`;
+          }
+        });
+        const debugParameterConversion = value.properties
+          .map(
+            v => `  static ${getCppType(alias, v)} ${
+              v.name
+            }ToJs(jsi::Runtime &rt, decltype(types.${v.name}) value) {
+    return bridging::toJs(rt, value);
+  }`,
+          )
+          .join('\n\n');
+        return `
+#pragma mark - ${structName}
+
+template <${templateParameterWithTypename}>
+struct ${structName} {
+${templateMemberTypes.map(v => '  ' + v).join(';\n')};
+  bool operator==(const ${structName} &other) const {
+    return ${value.properties
+      .map(v => `${v.name} == other.${v.name}`)
+      .join(' && ')};
+  }
+};
+
+template <typename T>
+struct ${structName}Bridging {
+  static T types;
+
+  static T fromJs(
+      jsi::Runtime &rt,
+      const jsi::Object &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    T result{
+${value.properties
+  .map(v => {
+    if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+      return `      value.hasProperty(rt, "${v.name}") ? std::make_unique<T>(bridging::fromJs<T>(rt, value.getProperty(rt, "${v.name}"), jsInvoker)) : nullptr`;
+    } else {
+      return `      bridging::fromJs<decltype(types.${v.name})>(rt, value.getProperty(rt, "${v.name}"), jsInvoker)`;
+    }
+  })
+  .join(',\n')}};
+    return result;
+  }
+
+#ifdef DEBUG
+${debugParameterConversion}
+#endif
+
+  static jsi::Object toJs(
+      jsi::Runtime &rt,
+      const T &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    auto result = facebook::jsi::Object(rt);
+${value.properties
+  .map(v => {
+    if (isDirectRecursiveMember(alias, v.typeAnnotation)) {
+      return `    if (value.${v.name}) {
+        result.setProperty(rt, "${v.name}", bridging::toJs(rt, *value.${v.name}, jsInvoker));
+      }`;
+    } else if (v.optional) {
+      return `    if (value.${v.name}) {
+      result.setProperty(rt, "${v.name}", bridging::toJs(rt, value.${v.name}.value(), jsInvoker));
+    }`;
+    } else {
+      return `    result.setProperty(rt, "${v.name}", bridging::toJs(rt, value.${v.name}, jsInvoker));`;
+    }
+  })
+  .join('\n')}
+    return result;
+  }
+};
+
+`;
+      })
+      .join('\n')
+  );
 }
 
 type NativeEnumMemberValueType = 'std::string' | 'int32_t' | 'float';
@@ -346,7 +458,7 @@ const EnumTemplate = ({
   return `
 #pragma mark - ${enumName}
 
-enum ${enumName} { ${values} };
+enum class ${enumName} { ${values} };
 
 template <>
 struct Bridging<${enumName}> {
@@ -449,6 +561,7 @@ function translatePropertyToCpp(
   const paramTypes = propTypeAnnotation.params.map(param => {
     const translatedParam = translatePrimitiveJSTypeToCpp(
       moduleName,
+      null,
       param.typeAnnotation,
       param.optional,
       typeName =>
@@ -461,6 +574,7 @@ function translatePropertyToCpp(
 
   const returnType = translatePrimitiveJSTypeToCpp(
     moduleName,
+    null,
     propTypeAnnotation.returnTypeAnnotation,
     false,
     typeName => `Unsupported return type for ${prop.name}. Found: ${typeName}`,
@@ -493,6 +607,7 @@ module.exports = {
     schema: SchemaType,
     packageName?: string,
     assumeNonnull: boolean = false,
+    headerPrefix?: string,
   ): FilesOutput {
     const nativeModules = getModules(schema);
 

package/lib/generators/modules/GenerateModuleJavaSpec.js

@@ -78,11 +78,13 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('./Utils'),
-  createAliasResolver = _require.createAliasResolver,
-  getModules = _require.getModules;
-const _require2 = require('../../parsers/parsers-commons'),
-  unwrapNullable = _require2.unwrapNullable;
+const _require = require('../../parsers/parsers-commons'),
+  unwrapNullable = _require.unwrapNullable;
+const _require2 = require('../TypeUtils/Java'),
+  wrapOptional = _require2.wrapOptional;
+const _require3 = require('./Utils'),
+  createAliasResolver = _require3.createAliasResolver,
+  getModules = _require3.getModules;
 function FileTemplate(config) {
   const packageName = config.packageName,
     className = config.className,
@@ -152,16 +154,8 @@ function translateFunctionParamToJavaType(
     typeAnnotation = _unwrapNullable2[0],
     nullable = _unwrapNullable2[1];
   const isRequired = !optional && !nullable;
-  function wrapNullable(javaType, nullableType) {
-    if (!isRequired) {
-      imports.add('javax.annotation.Nullable');
-      return `@Nullable ${
-        nullableType !== null && nullableType !== void 0
-          ? nullableType
-          : javaType
-      }`;
-    }
-    return javaType;
+  if (!isRequired) {
+    imports.add('javax.annotation.Nullable');
   }
 
   // FIXME: support class alias for args
@@ -173,41 +167,41 @@ function translateFunctionParamToJavaType(
     case 'ReservedTypeAnnotation':
       switch (realTypeAnnotation.name) {
         case 'RootTag':
-          return wrapNullable('double', 'Double');
+          return wrapOptional('double', isRequired);
         default:
           realTypeAnnotation.name;
           throw new Error(createErrorMessage(realTypeAnnotation.name));
       }
     case 'StringTypeAnnotation':
-      return wrapNullable('String');
+      return wrapOptional('String', isRequired);
     case 'NumberTypeAnnotation':
-      return wrapNullable('double', 'Double');
+      return wrapOptional('double', isRequired);
     case 'FloatTypeAnnotation':
-      return wrapNullable('double', 'Double');
+      return wrapOptional('float', isRequired);
     case 'DoubleTypeAnnotation':
-      return wrapNullable('double', 'Double');
+      return wrapOptional('double', isRequired);
     case 'Int32TypeAnnotation':
-      return wrapNullable('double', 'Double');
+      return wrapOptional('int', isRequired);
     case 'BooleanTypeAnnotation':
-      return wrapNullable('boolean', 'Boolean');
+      return wrapOptional('boolean', isRequired);
     case 'EnumDeclaration':
       switch (realTypeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrapNullable('double', 'Double');
+          return wrapOptional('double', isRequired);
         case 'StringTypeAnnotation':
-          return wrapNullable('String');
+          return wrapOptional('String', isRequired);
         default:
           throw new Error(createErrorMessage(realTypeAnnotation.type));
       }
     case 'UnionTypeAnnotation':
       switch (typeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrapNullable('double', 'Double');
+          return wrapOptional('double', isRequired);
         case 'ObjectTypeAnnotation':
           imports.add('com.facebook.react.bridge.ReadableMap');
-          return wrapNullable('ReadableMap');
+          return wrapOptional('ReadableMap', isRequired);
         case 'StringTypeAnnotation':
-          return wrapNullable('String');
+          return wrapOptional('String', isRequired);
         default:
           throw new Error(
             `Unsupported union member returning value, found: ${realTypeAnnotation.memberType}"`,
@@ -215,17 +209,17 @@ function translateFunctionParamToJavaType(
       }
     case 'ObjectTypeAnnotation':
       imports.add('com.facebook.react.bridge.ReadableMap');
-      return wrapNullable('ReadableMap');
+      return wrapOptional('ReadableMap', isRequired);
     case 'GenericObjectTypeAnnotation':
       // Treat this the same as ObjectTypeAnnotation for now.
       imports.add('com.facebook.react.bridge.ReadableMap');
-      return wrapNullable('ReadableMap');
+      return wrapOptional('ReadableMap', isRequired);
     case 'ArrayTypeAnnotation':
       imports.add('com.facebook.react.bridge.ReadableArray');
-      return wrapNullable('ReadableArray');
+      return wrapOptional('ReadableArray', isRequired);
     case 'FunctionTypeAnnotation':
       imports.add('com.facebook.react.bridge.Callback');
-      return wrapNullable('Callback');
+      return wrapOptional('Callback', isRequired);
     default:
       realTypeAnnotation.type;
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -241,17 +235,10 @@ function translateFunctionReturnTypeToJavaType(
     _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 2),
     returnTypeAnnotation = _unwrapNullable4[0],
     nullable = _unwrapNullable4[1];
-  function wrapNullable(javaType, nullableType) {
-    if (nullable) {
-      imports.add('javax.annotation.Nullable');
-      return `@Nullable ${
-        nullableType !== null && nullableType !== void 0
-          ? nullableType
-          : javaType
-      }`;
-    }
-    return javaType;
+  if (nullable) {
+    imports.add('javax.annotation.Nullable');
   }
+  const isRequired = !nullable;
 
   // FIXME: support class alias for args
   let realTypeAnnotation = returnTypeAnnotation;
@@ -262,7 +249,7 @@ function translateFunctionReturnTypeToJavaType(
     case 'ReservedTypeAnnotation':
       switch (realTypeAnnotation.name) {
         case 'RootTag':
-          return wrapNullable('double', 'Double');
+          return wrapOptional('double', isRequired);
         default:
           realTypeAnnotation.name;
           throw new Error(createErrorMessage(realTypeAnnotation.name));
@@ -272,35 +259,35 @@ function translateFunctionReturnTypeToJavaType(
     case 'PromiseTypeAnnotation':
       return 'void';
     case 'StringTypeAnnotation':
-      return wrapNullable('String');
+      return wrapOptional('String', isRequired);
     case 'NumberTypeAnnotation':
-      return wrapNullable('double', 'Double');
+      return wrapOptional('double', isRequired);
     case 'FloatTypeAnnotation':
-      return wrapNullable('double', 'Double');
+      return wrapOptional('double', isRequired);
     case 'DoubleTypeAnnotation':
-      return wrapNullable('double', 'Double');
+      return wrapOptional('double', isRequired);
     case 'Int32TypeAnnotation':
-      return wrapNullable('double', 'Double');
+      return wrapOptional('double', isRequired);
     case 'BooleanTypeAnnotation':
-      return wrapNullable('boolean', 'Boolean');
+      return wrapOptional('boolean', isRequired);
     case 'EnumDeclaration':
       switch (realTypeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrapNullable('double', 'Double');
+          return wrapOptional('double', isRequired);
         case 'StringTypeAnnotation':
-          return wrapNullable('String');
+          return wrapOptional('String', isRequired);
         default:
           throw new Error(createErrorMessage(realTypeAnnotation.type));
       }
     case 'UnionTypeAnnotation':
       switch (realTypeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrapNullable('double', 'Double');
+          return wrapOptional('double', isRequired);
         case 'ObjectTypeAnnotation':
           imports.add('com.facebook.react.bridge.WritableMap');
-          return wrapNullable('WritableMap');
+          return wrapOptional('WritableMap', isRequired);
         case 'StringTypeAnnotation':
-          return wrapNullable('String');
+          return wrapOptional('String', isRequired);
         default:
           throw new Error(
             `Unsupported union member returning value, found: ${realTypeAnnotation.memberType}"`,
@@ -308,13 +295,13 @@ function translateFunctionReturnTypeToJavaType(
       }
     case 'ObjectTypeAnnotation':
       imports.add('com.facebook.react.bridge.WritableMap');
-      return wrapNullable('WritableMap');
+      return wrapOptional('WritableMap', isRequired);
     case 'GenericObjectTypeAnnotation':
       imports.add('com.facebook.react.bridge.WritableMap');
-      return wrapNullable('WritableMap');
+      return wrapOptional('WritableMap', isRequired);
     case 'ArrayTypeAnnotation':
       imports.add('com.facebook.react.bridge.WritableArray');
-      return wrapNullable('WritableArray');
+      return wrapOptional('WritableArray', isRequired);
     default:
       realTypeAnnotation.type;
       throw new Error(createErrorMessage(realTypeAnnotation.type));
@@ -468,7 +455,13 @@ function buildGetConstantsMethod(method, imports, resolveAlias) {
   return '';
 }
 module.exports = {
-  generate(libraryName, schema, packageName, assumeNonnull = false) {
+  generate(
+    libraryName,
+    schema,
+    packageName,
+    assumeNonnull = false,
+    headerPrefix,
+  ) {
     const files = new Map();
     const nativeModules = getModules(schema);
     const normalizedPackageName =