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

package/lib/generators/modules/GenerateModuleObjCpp/serializeMethod.js.flow

@@ -11,23 +11,23 @@
 'use strict';
 
 import type {
-  Nullable,
   NamedShape,
   NativeModuleParamTypeAnnotation,
-  NativeModuleReturnTypeAnnotation,
   NativeModulePropertyShape,
+  NativeModuleReturnTypeAnnotation,
+  Nullable,
 } from '../../../CodegenSchema';
-
 import type {AliasResolver} from '../Utils';
 import type {StructCollector} from './StructCollector';
 
-const invariant = require('invariant');
-const {getNamespacedStructName} = require('./Utils');
-const {capitalize} = require('../../Utils');
 const {
-  wrapNullable,
   unwrapNullable,
+  wrapNullable,
 } = require('../../../parsers/parsers-commons');
+const {wrapOptional} = require('../../TypeUtils/Objective-C');
+const {capitalize} = require('../../Utils');
+const {getNamespacedStructName} = require('./Utils');
+const invariant = require('invariant');
 
 const ProtocolMethodTemplate = ({
   returnObjCType,
@@ -189,11 +189,7 @@ function getParamObjCType(
 ): $ReadOnly<{objCType: string, isStruct: boolean}> {
   const {name: paramName, typeAnnotation: nullableTypeAnnotation} = param;
   const [typeAnnotation, nullable] = unwrapNullable(nullableTypeAnnotation);
-  const notRequired = param.optional || nullable;
-
-  function wrapIntoNullableIfNeeded(generatedType: string) {
-    return nullable ? `${generatedType} _Nullable` : generatedType;
-  }
+  const isRequired = !param.optional && !nullable;
 
   const isStruct = (objCType: string) => ({
     isStruct: true,
@@ -221,7 +217,7 @@ function getParamObjCType(
        *   type Animal = {};
        *   Array<Animal> => NSArray<JS::NativeSampleTurboModule::Animal *>, etc.
        */
-      return notStruct(wrapIntoNullableIfNeeded('NSArray *'));
+      return notStruct(wrapOptional('NSArray *', !nullable));
     }
   }
 
@@ -252,7 +248,7 @@ function getParamObjCType(
     case 'ReservedTypeAnnotation':
       switch (structTypeAnnotation.name) {
         case 'RootTag':
-          return notStruct(notRequired ? 'NSNumber *' : 'double');
+          return notStruct(isRequired ? 'double' : 'NSNumber *');
         default:
           (structTypeAnnotation.name: empty);
           throw new Error(
@@ -260,30 +256,30 @@ function getParamObjCType(
           );
       }
     case 'StringTypeAnnotation':
-      return notStruct(wrapIntoNullableIfNeeded('NSString *'));
+      return notStruct(wrapOptional('NSString *', !nullable));
     case 'NumberTypeAnnotation':
-      return notStruct(notRequired ? 'NSNumber *' : 'double');
+      return notStruct(isRequired ? 'double' : 'NSNumber *');
     case 'FloatTypeAnnotation':
-      return notStruct(notRequired ? 'NSNumber *' : 'double');
+      return notStruct(isRequired ? 'float' : 'NSNumber *');
     case 'DoubleTypeAnnotation':
-      return notStruct(notRequired ? 'NSNumber *' : 'double');
+      return notStruct(isRequired ? 'double' : 'NSNumber *');
     case 'Int32TypeAnnotation':
-      return notStruct(notRequired ? 'NSNumber *' : 'double');
+      return notStruct(isRequired ? 'NSInteger' : 'NSNumber *');
     case 'BooleanTypeAnnotation':
-      return notStruct(notRequired ? 'NSNumber *' : 'BOOL');
+      return notStruct(isRequired ? 'BOOL' : 'NSNumber *');
     case 'EnumDeclaration':
       switch (typeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return notStruct(notRequired ? 'NSNumber *' : 'double');
+          return notStruct(isRequired ? 'double' : 'NSNumber *');
         case 'StringTypeAnnotation':
-          return notStruct(wrapIntoNullableIfNeeded('NSString *'));
+          return notStruct(wrapOptional('NSString *', !nullable));
         default:
           throw new Error(
             `Unsupported enum type for param "${paramName}" in ${methodName}. Found: ${typeAnnotation.type}`,
           );
       }
     case 'GenericObjectTypeAnnotation':
-      return notStruct(wrapIntoNullableIfNeeded('NSDictionary *'));
+      return notStruct(wrapOptional('NSDictionary *', !nullable));
     default:
       (structTypeAnnotation.type: empty);
       throw new Error(
@@ -297,10 +293,7 @@ function getReturnObjCType(
   nullableTypeAnnotation: Nullable<NativeModuleReturnTypeAnnotation>,
 ): string {
   const [typeAnnotation, nullable] = unwrapNullable(nullableTypeAnnotation);
-
-  function wrapIntoNullableIfNeeded(generatedType: string) {
-    return nullable ? `${generatedType} _Nullable` : generatedType;
-  }
+  const isRequired = !nullable;
 
   switch (typeAnnotation.type) {
     case 'VoidTypeAnnotation':
@@ -308,24 +301,25 @@ function getReturnObjCType(
     case 'PromiseTypeAnnotation':
       return 'void';
     case 'ObjectTypeAnnotation':
-      return wrapIntoNullableIfNeeded('NSDictionary *');
+      return wrapOptional('NSDictionary *', isRequired);
     case 'TypeAliasTypeAnnotation':
-      return wrapIntoNullableIfNeeded('NSDictionary *');
+      return wrapOptional('NSDictionary *', isRequired);
     case 'ArrayTypeAnnotation':
       if (typeAnnotation.elementType == null) {
-        return wrapIntoNullableIfNeeded('NSArray<id<NSObject>> *');
+        return wrapOptional('NSArray<id<NSObject>> *', isRequired);
       }
 
-      return wrapIntoNullableIfNeeded(
+      return wrapOptional(
         `NSArray<${getReturnObjCType(
           methodName,
           typeAnnotation.elementType,
         )}> *`,
+        isRequired,
       );
     case 'ReservedTypeAnnotation':
       switch (typeAnnotation.name) {
         case 'RootTag':
-          return wrapIntoNullableIfNeeded('NSNumber *');
+          return wrapOptional('NSNumber *', isRequired);
         default:
           (typeAnnotation.name: empty);
           throw new Error(
@@ -335,23 +329,23 @@ function getReturnObjCType(
     case 'StringTypeAnnotation':
       // TODO: Can NSString * returns not be _Nullable?
       // In the legacy codegen, we don't surround NSSTring * with _Nullable
-      return wrapIntoNullableIfNeeded('NSString *');
+      return wrapOptional('NSString *', isRequired);
     case 'NumberTypeAnnotation':
-      return wrapIntoNullableIfNeeded('NSNumber *');
+      return wrapOptional('NSNumber *', isRequired);
     case 'FloatTypeAnnotation':
-      return wrapIntoNullableIfNeeded('NSNumber *');
+      return wrapOptional('NSNumber *', isRequired);
     case 'DoubleTypeAnnotation':
-      return wrapIntoNullableIfNeeded('NSNumber *');
+      return wrapOptional('NSNumber *', isRequired);
     case 'Int32TypeAnnotation':
-      return wrapIntoNullableIfNeeded('NSNumber *');
+      return wrapOptional('NSNumber *', isRequired);
     case 'BooleanTypeAnnotation':
-      return wrapIntoNullableIfNeeded('NSNumber *');
+      return wrapOptional('NSNumber *', isRequired);
     case 'EnumDeclaration':
       switch (typeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrapIntoNullableIfNeeded('NSNumber *');
+          return wrapOptional('NSNumber *', isRequired);
         case 'StringTypeAnnotation':
-          return wrapIntoNullableIfNeeded('NSString *');
+          return wrapOptional('NSString *', isRequired);
         default:
           throw new Error(
             `Unsupported enum return type for ${methodName}. Found: ${typeAnnotation.type}`,
@@ -360,20 +354,20 @@ function getReturnObjCType(
     case 'UnionTypeAnnotation':
       switch (typeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrapIntoNullableIfNeeded('NSNumber *');
+          return wrapOptional('NSNumber *', isRequired);
         case 'ObjectTypeAnnotation':
-          return wrapIntoNullableIfNeeded('NSDictionary *');
+          return wrapOptional('NSDictionary *', isRequired);
         case 'StringTypeAnnotation':
           // TODO: Can NSString * returns not be _Nullable?
           // In the legacy codegen, we don't surround NSSTring * with _Nullable
-          return wrapIntoNullableIfNeeded('NSString *');
+          return wrapOptional('NSString *', isRequired);
         default:
           throw new Error(
             `Unsupported union return type for ${methodName}, found: ${typeAnnotation.memberType}"`,
           );
       }
     case 'GenericObjectTypeAnnotation':
-      return wrapIntoNullableIfNeeded('NSDictionary *');
+      return wrapOptional('NSDictionary *', isRequired);
     default:
       (typeAnnotation.type: 'MixedTypeAnnotation');
       throw new Error(

package/lib/generators/modules/GenerateModuleObjCpp/source/serializeModule.js

@@ -22,34 +22,32 @@ const ModuleTemplate = ({
     }),
   )
   .join('\n')}
-namespace facebook {
-  namespace react {
-    ${methodSerializationOutputs
-      .map(serializedMethodParts =>
-        InlineHostFunctionTemplate({
-          hasteModuleName,
-          methodName: serializedMethodParts.methodName,
-          returnJSType: serializedMethodParts.returnJSType,
-          selector: serializedMethodParts.selector,
-        }),
-      )
-      .join('\n')}
+namespace facebook::react {
+  ${methodSerializationOutputs
+    .map(serializedMethodParts =>
+      InlineHostFunctionTemplate({
+        hasteModuleName,
+        methodName: serializedMethodParts.methodName,
+        returnJSType: serializedMethodParts.returnJSType,
+        selector: serializedMethodParts.selector,
+      }),
+    )
+    .join('\n')}
 
-    ${hasteModuleName}SpecJSI::${hasteModuleName}SpecJSI(const ObjCTurboModule::InitParams &params)
-      : ObjCTurboModule(params) {
-        ${methodSerializationOutputs
-          .map(({methodName, structParamRecords, argCount}) =>
-            MethodMapEntryTemplate({
-              hasteModuleName,
-              methodName,
-              structParamRecords,
-              argCount,
-            }),
-          )
-          .join('\n' + ' '.repeat(8))}
-    }
-  } // namespace react
-} // namespace facebook`;
+  ${hasteModuleName}SpecJSI::${hasteModuleName}SpecJSI(const ObjCTurboModule::InitParams &params)
+    : ObjCTurboModule(params) {
+      ${methodSerializationOutputs
+        .map(({methodName, structParamRecords, argCount}) =>
+          MethodMapEntryTemplate({
+            hasteModuleName,
+            methodName,
+            structParamRecords,
+            argCount,
+          }),
+        )
+        .join('\n' + ' '.repeat(8))}
+  }
+} // namespace facebook::react`;
 const RCTCxxConvertCategoryTemplate = ({
   hasteModuleName,
   structName,

package/lib/generators/modules/GenerateModuleObjCpp/source/serializeModule.js.flow

@@ -10,11 +10,11 @@
 
 'use strict';
 
-import type {Struct} from '../StructCollector';
 import type {
   MethodSerializationOutput,
   StructParameterRecord,
 } from '../serializeMethod';
+import type {Struct} from '../StructCollector';
 
 const ModuleTemplate = ({
   hasteModuleName,
@@ -29,34 +29,32 @@ const ModuleTemplate = ({
     RCTCxxConvertCategoryTemplate({hasteModuleName, structName: struct.name}),
   )
   .join('\n')}
-namespace facebook {
-  namespace react {
-    ${methodSerializationOutputs
-      .map(serializedMethodParts =>
-        InlineHostFunctionTemplate({
-          hasteModuleName,
-          methodName: serializedMethodParts.methodName,
-          returnJSType: serializedMethodParts.returnJSType,
-          selector: serializedMethodParts.selector,
-        }),
-      )
-      .join('\n')}
+namespace facebook::react {
+  ${methodSerializationOutputs
+    .map(serializedMethodParts =>
+      InlineHostFunctionTemplate({
+        hasteModuleName,
+        methodName: serializedMethodParts.methodName,
+        returnJSType: serializedMethodParts.returnJSType,
+        selector: serializedMethodParts.selector,
+      }),
+    )
+    .join('\n')}
 
-    ${hasteModuleName}SpecJSI::${hasteModuleName}SpecJSI(const ObjCTurboModule::InitParams &params)
-      : ObjCTurboModule(params) {
-        ${methodSerializationOutputs
-          .map(({methodName, structParamRecords, argCount}) =>
-            MethodMapEntryTemplate({
-              hasteModuleName,
-              methodName,
-              structParamRecords,
-              argCount,
-            }),
-          )
-          .join('\n' + ' '.repeat(8))}
-    }
-  } // namespace react
-} // namespace facebook`;
+  ${hasteModuleName}SpecJSI::${hasteModuleName}SpecJSI(const ObjCTurboModule::InitParams &params)
+    : ObjCTurboModule(params) {
+      ${methodSerializationOutputs
+        .map(({methodName, structParamRecords, argCount}) =>
+          MethodMapEntryTemplate({
+            hasteModuleName,
+            methodName,
+            structParamRecords,
+            argCount,
+          }),
+        )
+        .join('\n' + ' '.repeat(8))}
+  }
+} // namespace facebook::react`;
 
 const RCTCxxConvertCategoryTemplate = ({
   hasteModuleName,

package/lib/generators/modules/Utils.js

@@ -10,6 +10,76 @@
 
 'use strict';
 
+function _slicedToArray(arr, i) {
+  return (
+    _arrayWithHoles(arr) ||
+    _iterableToArrayLimit(arr, i) ||
+    _unsupportedIterableToArray(arr, i) ||
+    _nonIterableRest()
+  );
+}
+function _nonIterableRest() {
+  throw new TypeError(
+    'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
+  );
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === 'string') return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === 'Object' && o.constructor) n = o.constructor.name;
+  if (n === 'Map' || n === 'Set') return Array.from(o);
+  if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _iterableToArrayLimit(arr, i) {
+  var _i =
+    null == arr
+      ? null
+      : ('undefined' != typeof Symbol && arr[Symbol.iterator]) ||
+        arr['@@iterator'];
+  if (null != _i) {
+    var _s,
+      _e,
+      _x,
+      _r,
+      _arr = [],
+      _n = !0,
+      _d = !1;
+    try {
+      if (((_x = (_i = _i.call(arr)).next), 0 === i)) {
+        if (Object(_i) !== _i) return;
+        _n = !1;
+      } else
+        for (
+          ;
+          !(_n = (_s = _x.call(_i)).done) &&
+          (_arr.push(_s.value), _arr.length !== i);
+          _n = !0
+        );
+    } catch (err) {
+      (_d = !0), (_e = err);
+    } finally {
+      try {
+        if (!_n && null != _i.return && ((_r = _i.return()), Object(_r) !== _r))
+          return;
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+const _require = require('../../parsers/parsers-commons'),
+  unwrapNullable = _require.unwrapNullable;
 const invariant = require('invariant');
 function createAliasResolver(aliasMap) {
   return aliasName => {
@@ -28,6 +98,32 @@ function getModules(schema) {
     return modules;
   }, {});
 }
+function isDirectRecursiveMember(
+  parentObjectAliasName,
+  nullableTypeAnnotation,
+) {
+  const _unwrapNullable = unwrapNullable(nullableTypeAnnotation),
+    _unwrapNullable2 = _slicedToArray(_unwrapNullable, 1),
+    typeAnnotation = _unwrapNullable2[0];
+  return (
+    parentObjectAliasName !== undefined &&
+    typeAnnotation.name === parentObjectAliasName
+  );
+}
+function isArrayRecursiveMember(parentObjectAliasName, nullableTypeAnnotation) {
+  var _typeAnnotation$eleme;
+  const _unwrapNullable3 = unwrapNullable(nullableTypeAnnotation),
+    _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 1),
+    typeAnnotation = _unwrapNullable4[0];
+  return (
+    parentObjectAliasName !== undefined &&
+    typeAnnotation.type === 'ArrayTypeAnnotation' &&
+    ((_typeAnnotation$eleme = typeAnnotation.elementType) === null ||
+    _typeAnnotation$eleme === void 0
+      ? void 0
+      : _typeAnnotation$eleme.name) === parentObjectAliasName
+  );
+}
 function getAreEnumMembersInteger(members) {
   return !members.some(m => `${m.value}`.includes('.'));
 }
@@ -35,4 +131,6 @@ module.exports = {
   createAliasResolver,
   getModules,
   getAreEnumMembersInteger,
+  isDirectRecursiveMember,
+  isArrayRecursiveMember,
 };

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

@@ -11,13 +11,16 @@
 'use strict';
 
 import type {
-  SchemaType,
   NativeModuleAliasMap,
+  NativeModuleEnumMembers,
   NativeModuleObjectTypeAnnotation,
   NativeModuleSchema,
-  NativeModuleEnumMembers,
+  NativeModuleTypeAnnotation,
+  Nullable,
+  SchemaType,
 } from '../../CodegenSchema';
 
+const {unwrapNullable} = require('../../parsers/parsers-commons');
 const invariant = require('invariant');
 
 export type AliasResolver = (
@@ -48,6 +51,33 @@ function getModules(
   );
 }
 
+function isDirectRecursiveMember(
+  parentObjectAliasName: ?string,
+  nullableTypeAnnotation: Nullable<NativeModuleTypeAnnotation>,
+): boolean {
+  const [typeAnnotation] = unwrapNullable<NativeModuleTypeAnnotation>(
+    nullableTypeAnnotation,
+  );
+  return (
+    parentObjectAliasName !== undefined &&
+    typeAnnotation.name === parentObjectAliasName
+  );
+}
+
+function isArrayRecursiveMember(
+  parentObjectAliasName: ?string,
+  nullableTypeAnnotation: Nullable<NativeModuleTypeAnnotation>,
+): boolean {
+  const [typeAnnotation] = unwrapNullable<NativeModuleTypeAnnotation>(
+    nullableTypeAnnotation,
+  );
+  return (
+    parentObjectAliasName !== undefined &&
+    typeAnnotation.type === 'ArrayTypeAnnotation' &&
+    typeAnnotation.elementType?.name === parentObjectAliasName
+  );
+}
+
 function getAreEnumMembersInteger(members: NativeModuleEnumMembers): boolean {
   return !members.some(m => `${m.value}`.includes('.'));
 }
@@ -56,4 +86,6 @@ module.exports = {
   createAliasResolver,
   getModules,
   getAreEnumMembersInteger,
+  isDirectRecursiveMember,
+  isArrayRecursiveMember,
 };