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

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeConstantsStruct.js.flow

@@ -10,14 +10,17 @@
 
 'use strict';
 
-const {getSafePropertyName, getNamespacedStructName} = require('../Utils');
-const {capitalize} = require('../../../Utils');
-
 import type {Nullable} from '../../../../CodegenSchema';
-import type {StructTypeAnnotation, ConstantsStruct} from '../StructCollector';
+import type {ConstantsStruct, StructTypeAnnotation} from '../StructCollector';
 import type {StructSerilizationOutput} from './serializeStruct';
 
 const {unwrapNullable} = require('../../../../parsers/parsers-commons');
+const {wrapOptional: wrapCxxOptional} = require('../../../TypeUtils/Cxx');
+const {
+  wrapOptional: wrapObjCOptional,
+} = require('../../../TypeUtils/Objective-C');
+const {capitalize} = require('../../../Utils');
+const {getNamespacedStructName, getSafePropertyName} = require('../Utils');
 
 const StructTemplate = ({
   hasteModuleName,
@@ -79,15 +82,12 @@ function toObjCType(
 ): string {
   const [typeAnnotation, nullable] = unwrapNullable(nullableTypeAnnotation);
   const isRequired = !nullable && !isOptional;
-  const wrapOptional = (type: string) => {
-    return isRequired ? type : `std::optional<${type}>`;
-  };
 
   switch (typeAnnotation.type) {
     case 'ReservedTypeAnnotation':
       switch (typeAnnotation.name) {
         case 'RootTag':
-          return wrapOptional('double');
+          return wrapCxxOptional('double', isRequired);
         default:
           (typeAnnotation.name: empty);
           throw new Error(`Unknown prop type, found: ${typeAnnotation.name}"`);
@@ -95,19 +95,19 @@ function toObjCType(
     case 'StringTypeAnnotation':
       return 'NSString *';
     case 'NumberTypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'FloatTypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'Int32TypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'DoubleTypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'BooleanTypeAnnotation':
-      return wrapOptional('bool');
+      return wrapCxxOptional('bool', isRequired);
     case 'EnumDeclaration':
       switch (typeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrapOptional('double');
+          return wrapCxxOptional('double', isRequired);
         case 'StringTypeAnnotation':
           return 'NSString *';
         default:
@@ -116,17 +116,18 @@ function toObjCType(
           );
       }
     case 'GenericObjectTypeAnnotation':
-      return isRequired ? 'id<NSObject> ' : 'id<NSObject> _Nullable ';
+      return wrapObjCOptional('id<NSObject>', isRequired);
     case 'ArrayTypeAnnotation':
       if (typeAnnotation.elementType == null) {
-        return isRequired ? 'id<NSObject> ' : 'id<NSObject> _Nullable ';
+        return wrapObjCOptional('id<NSObject>', isRequired);
       }
 
-      return wrapOptional(
+      return wrapCxxOptional(
         `std::vector<${toObjCType(
           hasteModuleName,
           typeAnnotation.elementType,
         )}>`,
+        isRequired,
       );
     case 'TypeAliasTypeAnnotation':
       const structName = capitalize(typeAnnotation.name);
@@ -134,7 +135,7 @@ function toObjCType(
         hasteModuleName,
         structName,
       );
-      return wrapOptional(`${namespacedStructName}::Builder`);
+      return wrapCxxOptional(`${namespacedStructName}::Builder`, isRequired);
     default:
       (typeAnnotation.type: empty);
       throw new Error(

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeRegularStruct.js

@@ -78,13 +78,17 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('../Utils'),
-  getSafePropertyName = _require.getSafePropertyName,
-  getNamespacedStructName = _require.getNamespacedStructName;
-const _require2 = require('../../../Utils'),
-  capitalize = _require2.capitalize;
-const _require3 = require('../../../../parsers/parsers-commons'),
-  unwrapNullable = _require3.unwrapNullable;
+const _require = require('../../../../parsers/parsers-commons'),
+  unwrapNullable = _require.unwrapNullable;
+const _require2 = require('../../../TypeUtils/Cxx'),
+  wrapCxxOptional = _require2.wrapOptional;
+const _require3 = require('../../../TypeUtils/Objective-C'),
+  wrapObjCOptional = _require3.wrapOptional;
+const _require4 = require('../../../Utils'),
+  capitalize = _require4.capitalize;
+const _require5 = require('../Utils'),
+  getNamespacedStructName = _require5.getNamespacedStructName,
+  getSafePropertyName = _require5.getSafePropertyName;
 const StructTemplate = ({
   hasteModuleName,
   structName,
@@ -126,14 +130,11 @@ function toObjCType(
     typeAnnotation = _unwrapNullable2[0],
     nullable = _unwrapNullable2[1];
   const isRequired = !nullable && !isOptional;
-  const wrapOptional = type => {
-    return isRequired ? type : `std::optional<${type}>`;
-  };
   switch (typeAnnotation.type) {
     case 'ReservedTypeAnnotation':
       switch (typeAnnotation.name) {
         case 'RootTag':
-          return wrapOptional('double');
+          return wrapCxxOptional('double', isRequired);
         default:
           typeAnnotation.name;
           throw new Error(`Unknown prop type, found: ${typeAnnotation.name}"`);
@@ -141,19 +142,19 @@ function toObjCType(
     case 'StringTypeAnnotation':
       return 'NSString *';
     case 'NumberTypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'FloatTypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'Int32TypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'DoubleTypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'BooleanTypeAnnotation':
-      return wrapOptional('bool');
+      return wrapCxxOptional('bool', isRequired);
     case 'EnumDeclaration':
       switch (typeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrapOptional('double');
+          return wrapCxxOptional('double', isRequired);
         case 'StringTypeAnnotation':
           return 'NSString *';
         default:
@@ -162,16 +163,17 @@ function toObjCType(
           );
       }
     case 'GenericObjectTypeAnnotation':
-      return isRequired ? 'id<NSObject> ' : 'id<NSObject> _Nullable';
+      return wrapObjCOptional('id<NSObject>', isRequired);
     case 'ArrayTypeAnnotation':
       if (typeAnnotation.elementType == null) {
-        return isRequired ? 'id<NSObject> ' : 'id<NSObject> _Nullable';
+        return wrapObjCOptional('id<NSObject>', isRequired);
       }
-      return wrapOptional(
+      return wrapCxxOptional(
         `facebook::react::LazyVector<${toObjCType(
           hasteModuleName,
           typeAnnotation.elementType,
         )}>`,
+        isRequired,
       );
     case 'TypeAliasTypeAnnotation':
       const structName = capitalize(typeAnnotation.name);
@@ -179,7 +181,7 @@ function toObjCType(
         hasteModuleName,
         structName,
       );
-      return wrapOptional(namespacedStructName);
+      return wrapCxxOptional(namespacedStructName, isRequired);
     default:
       typeAnnotation.type;
       throw new Error(

package/lib/generators/modules/GenerateModuleObjCpp/header/serializeRegularStruct.js.flow

@@ -10,14 +10,17 @@
 
 'use strict';
 
-const {getSafePropertyName, getNamespacedStructName} = require('../Utils');
-const {capitalize} = require('../../../Utils');
-
 import type {Nullable} from '../../../../CodegenSchema';
-import type {StructTypeAnnotation, RegularStruct} from '../StructCollector';
+import type {RegularStruct, StructTypeAnnotation} from '../StructCollector';
 import type {StructSerilizationOutput} from './serializeStruct';
 
 const {unwrapNullable} = require('../../../../parsers/parsers-commons');
+const {wrapOptional: wrapCxxOptional} = require('../../../TypeUtils/Cxx');
+const {
+  wrapOptional: wrapObjCOptional,
+} = require('../../../TypeUtils/Objective-C');
+const {capitalize} = require('../../../Utils');
+const {getNamespacedStructName, getSafePropertyName} = require('../Utils');
 
 const StructTemplate = ({
   hasteModuleName,
@@ -70,15 +73,12 @@ function toObjCType(
 ): string {
   const [typeAnnotation, nullable] = unwrapNullable(nullableTypeAnnotation);
   const isRequired = !nullable && !isOptional;
-  const wrapOptional = (type: string) => {
-    return isRequired ? type : `std::optional<${type}>`;
-  };
 
   switch (typeAnnotation.type) {
     case 'ReservedTypeAnnotation':
       switch (typeAnnotation.name) {
         case 'RootTag':
-          return wrapOptional('double');
+          return wrapCxxOptional('double', isRequired);
         default:
           (typeAnnotation.name: empty);
           throw new Error(`Unknown prop type, found: ${typeAnnotation.name}"`);
@@ -86,19 +86,19 @@ function toObjCType(
     case 'StringTypeAnnotation':
       return 'NSString *';
     case 'NumberTypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'FloatTypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'Int32TypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'DoubleTypeAnnotation':
-      return wrapOptional('double');
+      return wrapCxxOptional('double', isRequired);
     case 'BooleanTypeAnnotation':
-      return wrapOptional('bool');
+      return wrapCxxOptional('bool', isRequired);
     case 'EnumDeclaration':
       switch (typeAnnotation.memberType) {
         case 'NumberTypeAnnotation':
-          return wrapOptional('double');
+          return wrapCxxOptional('double', isRequired);
         case 'StringTypeAnnotation':
           return 'NSString *';
         default:
@@ -107,16 +107,17 @@ function toObjCType(
           );
       }
     case 'GenericObjectTypeAnnotation':
-      return isRequired ? 'id<NSObject> ' : 'id<NSObject> _Nullable';
+      return wrapObjCOptional('id<NSObject>', isRequired);
     case 'ArrayTypeAnnotation':
       if (typeAnnotation.elementType == null) {
-        return isRequired ? 'id<NSObject> ' : 'id<NSObject> _Nullable';
+        return wrapObjCOptional('id<NSObject>', isRequired);
       }
-      return wrapOptional(
+      return wrapCxxOptional(
         `facebook::react::LazyVector<${toObjCType(
           hasteModuleName,
           typeAnnotation.elementType,
         )}>`,
+        isRequired,
       );
     case 'TypeAliasTypeAnnotation':
       const structName = capitalize(typeAnnotation.name);
@@ -124,7 +125,7 @@ function toObjCType(
         hasteModuleName,
         structName,
       );
-      return wrapOptional(namespacedStructName);
+      return wrapCxxOptional(namespacedStructName, isRequired);
     default:
       (typeAnnotation.type: empty);
       throw new Error(

package/lib/generators/modules/GenerateModuleObjCpp/index.js

@@ -13,14 +13,14 @@
 const _require = require('../Utils'),
   createAliasResolver = _require.createAliasResolver,
   getModules = _require.getModules;
-const _require2 = require('./StructCollector'),
-  StructCollector = _require2.StructCollector;
-const _require3 = require('./header/serializeStruct'),
-  serializeStruct = _require3.serializeStruct;
-const _require4 = require('./serializeMethod'),
-  serializeMethod = _require4.serializeMethod;
-const _require5 = require('./source/serializeModule'),
-  serializeModuleSource = _require5.serializeModuleSource;
+const _require2 = require('./header/serializeStruct'),
+  serializeStruct = _require2.serializeStruct;
+const _require3 = require('./serializeMethod'),
+  serializeMethod = _require3.serializeMethod;
+const _require4 = require('./source/serializeModule'),
+  serializeModuleSource = _require4.serializeModuleSource;
+const _require5 = require('./StructCollector'),
+  StructCollector = _require5.StructCollector;
 const ModuleDeclarationTemplate = ({
   hasteModuleName,
   structDeclarations,
@@ -31,17 +31,15 @@ const ModuleDeclarationTemplate = ({
 ${protocolMethods}
 
 @end
-namespace facebook {
-  namespace react {
-    /**
-     * ObjC++ class for module '${hasteModuleName}'
-     */
-    class JSI_EXPORT ${hasteModuleName}SpecJSI : public ObjCTurboModule {
-    public:
-      ${hasteModuleName}SpecJSI(const ObjCTurboModule::InitParams &params);
-    };
-  } // namespace react
-} // namespace facebook`;
+namespace facebook::react {
+  /**
+   * ObjC++ class for module '${hasteModuleName}'
+   */
+  class JSI_EXPORT ${hasteModuleName}SpecJSI : public ObjCTurboModule {
+  public:
+    ${hasteModuleName}SpecJSI(const ObjCTurboModule::InitParams &params);
+  };
+} // namespace facebook::react`;
 const HeaderFileTemplate = ({
   moduleDeclarations,
   structInlineMethods,
@@ -98,7 +96,7 @@ const SourceFileTemplate = ({headerFileName, moduleImplementations}) => `/**
 ${moduleImplementations}
 `;
 module.exports = {
-  generate(libraryName, schema, packageName, assumeNonnull) {
+  generate(libraryName, schema, packageName, assumeNonnull, headerPrefix) {
     const nativeModules = getModules(schema);
     const moduleDeclarations = [];
     const structInlineMethods = [];

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

@@ -10,16 +10,14 @@
 
 'use strict';
 import type {NativeModulePropertyShape} from '../../../CodegenSchema';
-
 import type {SchemaType} from '../../../CodegenSchema';
 import type {MethodSerializationOutput} from './serializeMethod';
 
 const {createAliasResolver, getModules} = require('../Utils');
-
-const {StructCollector} = require('./StructCollector');
 const {serializeStruct} = require('./header/serializeStruct');
 const {serializeMethod} = require('./serializeMethod');
 const {serializeModuleSource} = require('./source/serializeModule');
+const {StructCollector} = require('./StructCollector');
 
 type FilesOutput = Map<string, string>;
 
@@ -37,17 +35,15 @@ const ModuleDeclarationTemplate = ({
 ${protocolMethods}
 
 @end
-namespace facebook {
-  namespace react {
-    /**
-     * ObjC++ class for module '${hasteModuleName}'
-     */
-    class JSI_EXPORT ${hasteModuleName}SpecJSI : public ObjCTurboModule {
-    public:
-      ${hasteModuleName}SpecJSI(const ObjCTurboModule::InitParams &params);
-    };
-  } // namespace react
-} // namespace facebook`;
+namespace facebook::react {
+  /**
+   * ObjC++ class for module '${hasteModuleName}'
+   */
+  class JSI_EXPORT ${hasteModuleName}SpecJSI : public ObjCTurboModule {
+  public:
+    ${hasteModuleName}SpecJSI(const ObjCTurboModule::InitParams &params);
+  };
+} // namespace facebook::react`;
 
 const HeaderFileTemplate = ({
   moduleDeclarations,
@@ -122,6 +118,7 @@ module.exports = {
     schema: SchemaType,
     packageName?: string,
     assumeNonnull: boolean,
+    headerPrefix?: string,
   ): FilesOutput {
     const nativeModules = getModules(schema);
 

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

@@ -78,14 +78,16 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
+const _require = require('../../../parsers/parsers-commons'),
+  unwrapNullable = _require.unwrapNullable,
+  wrapNullable = _require.wrapNullable;
+const _require2 = require('../../TypeUtils/Objective-C'),
+  wrapOptional = _require2.wrapOptional;
+const _require3 = require('../../Utils'),
+  capitalize = _require3.capitalize;
+const _require4 = require('./Utils'),
+  getNamespacedStructName = _require4.getNamespacedStructName;
 const invariant = require('invariant');
-const _require = require('./Utils'),
-  getNamespacedStructName = _require.getNamespacedStructName;
-const _require2 = require('../../Utils'),
-  capitalize = _require2.capitalize;
-const _require3 = require('../../../parsers/parsers-commons'),
-  wrapNullable = _require3.wrapNullable,
-  unwrapNullable = _require3.unwrapNullable;
 const ProtocolMethodTemplate = ({returnObjCType, methodName, params}) =>
   `- (${returnObjCType})${methodName}${params};`;
 function serializeMethod(
@@ -226,10 +228,7 @@ function getParamObjCType(
     _unwrapNullable8 = _slicedToArray(_unwrapNullable7, 2),
     typeAnnotation = _unwrapNullable8[0],
     nullable = _unwrapNullable8[1];
-  const notRequired = param.optional || nullable;
-  function wrapIntoNullableIfNeeded(generatedType) {
-    return nullable ? `${generatedType} _Nullable` : generatedType;
-  }
+  const isRequired = !param.optional && !nullable;
   const isStruct = objCType => ({
     isStruct: true,
     objCType,
@@ -255,7 +254,7 @@ function getParamObjCType(
        *   type Animal = {};
        *   Array<Animal> => NSArray<JS::NativeSampleTurboModule::Animal *>, etc.
        */
-      return notStruct(wrapIntoNullableIfNeeded('NSArray *'));
+      return notStruct(wrapOptional('NSArray *', !nullable));
     }
   }
   const _unwrapNullable9 = unwrapNullable(
@@ -285,7 +284,7 @@ function getParamObjCType(
     case 'ReservedTypeAnnotation':
       switch (structTypeAnnotation.name) {
         case 'RootTag':
-          return notStruct(notRequired ? 'NSNumber *' : 'double');
+          return notStruct(isRequired ? 'double' : 'NSNumber *');
         default:
           structTypeAnnotation.name;
           throw new Error(
@@ -293,30 +292,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;
       throw new Error(
@@ -329,32 +328,31 @@ function getReturnObjCType(methodName, nullableTypeAnnotation) {
     _unwrapNullable12 = _slicedToArray(_unwrapNullable11, 2),
     typeAnnotation = _unwrapNullable12[0],
     nullable = _unwrapNullable12[1];
-  function wrapIntoNullableIfNeeded(generatedType) {
-    return nullable ? `${generatedType} _Nullable` : generatedType;
-  }
+  const isRequired = !nullable;
   switch (typeAnnotation.type) {
     case 'VoidTypeAnnotation':
       return 'void';
     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;
           throw new Error(
@@ -364,23 +362,23 @@ function getReturnObjCType(methodName, nullableTypeAnnotation) {
     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}`,
@@ -389,20 +387,20 @@ function getReturnObjCType(methodName, nullableTypeAnnotation) {
     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;
       throw new Error(