@react-native/codegen 0.84.0-nightly-20251203-a5e6addc6 → 0.84.0-nightly-20251205-95cc1e767

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

@@ -25,7 +25,7 @@ const {
   wrapNullable,
 } = require('../../../parsers/parsers-commons');
 const {wrapOptional} = require('../../TypeUtils/Objective-C');
-const {capitalize} = require('../../Utils');
+const {capitalize, parseValidUnionType} = require('../../Utils');
 const {getNamespacedStructName} = require('./Utils');
 const invariant = require('invariant');
 
@@ -259,8 +259,9 @@ function getParamObjCType(
       return notStruct(wrapOptional('NSString *', !nullable));
     case 'StringLiteralTypeAnnotation':
       return notStruct(wrapOptional('NSString *', !nullable));
-    case 'StringLiteralUnionTypeAnnotation':
-      return notStruct(wrapOptional('NSString *', !nullable));
+    case 'UnionTypeAnnotation':
+      // TODO(T247151345): Implement proper heterogeneous union support. This is unsafe.
+      return notStruct(wrapOptional('NSObject *', !nullable));
     case 'NumberTypeAnnotation':
       return notStruct(isRequired ? 'double' : 'NSNumber *');
     case 'NumberLiteralTypeAnnotation':
@@ -342,10 +343,6 @@ function getReturnObjCType(
       // TODO: Can NSString * returns not be _Nullable?
       // In the legacy codegen, we don't surround NSSTring * with _Nullable
       return wrapOptional('NSString *', isRequired);
-    case 'StringLiteralUnionTypeAnnotation':
-      // TODO: Can NSString * returns not be _Nullable?
-      // In the legacy codegen, we don't surround NSSTring * with _Nullable
-      return wrapOptional('NSString *', isRequired);
     case 'NumberTypeAnnotation':
       return wrapOptional('NSNumber *', isRequired);
     case 'NumberLiteralTypeAnnotation':
@@ -372,19 +369,21 @@ function getReturnObjCType(
           );
       }
     case 'UnionTypeAnnotation':
-      switch (typeAnnotation.memberType) {
-        case 'NumberTypeAnnotation':
+      const validUnionType = parseValidUnionType(typeAnnotation);
+      switch (validUnionType) {
+        case 'boolean':
           return wrapOptional('NSNumber *', isRequired);
-        case 'ObjectTypeAnnotation':
+        case 'number':
+          return wrapOptional('NSNumber *', isRequired);
+        case 'object':
           return wrapOptional('NSDictionary *', isRequired);
-        case 'StringTypeAnnotation':
+        case 'string':
           // TODO: Can NSString * returns not be _Nullable?
           // In the legacy codegen, we don't surround NSSTring * with _Nullable
           return wrapOptional('NSString *', isRequired);
         default:
-          throw new Error(
-            `Unsupported union return type for ${methodName}, found: ${typeAnnotation.memberType}"`,
-          );
+          (validUnionType: empty);
+          throw new Error(`Unsupported union member type`);
       }
     case 'GenericObjectTypeAnnotation':
       return wrapOptional('NSDictionary *', isRequired);
@@ -418,8 +417,6 @@ function getReturnJSType(
       return 'StringKind';
     case 'StringLiteralTypeAnnotation':
       return 'StringKind';
-    case 'StringLiteralUnionTypeAnnotation':
-      return 'StringKind';
     case 'NumberTypeAnnotation':
       return 'NumberKind';
     case 'NumberLiteralTypeAnnotation':
@@ -448,17 +445,19 @@ function getReturnJSType(
           );
       }
     case 'UnionTypeAnnotation':
-      switch (typeAnnotation.memberType) {
-        case 'NumberTypeAnnotation':
+      const validUnionType = parseValidUnionType(typeAnnotation);
+      switch (validUnionType) {
+        case 'boolean':
+          return 'BooleanKind';
+        case 'number':
           return 'NumberKind';
-        case 'ObjectTypeAnnotation':
+        case 'object':
           return 'ObjectKind';
-        case 'StringTypeAnnotation':
+        case 'string':
           return 'StringKind';
         default:
-          throw new Error(
-            `Unsupported return type for ${methodName}. Found: ${typeAnnotation.type}`,
-          );
+          (validUnionType: empty);
+          throw new Error(`Unsupported union member types`);
       }
     default:
       (typeAnnotation.type: 'MixedTypeAnnotation');

package/lib/parsers/error-utils.js

@@ -255,7 +255,7 @@ function throwIfArrayElementTypeAnnotationIsUnsupported(
     PromiseTypeAnnotation: 'Promise',
     // TODO: Added as a work-around for now until TupleTypeAnnotation are fully supported in both flow and TS
     // Right now they are partially treated as UnionTypeAnnotation
-    UnionTypeAnnotation: 'UnionTypeAnnotation',
+    // UnionTypeAnnotation: 'UnionTypeAnnotation',
   };
   if (type in TypeMap) {
     throw new UnsupportedArrayElementTypeAnnotationParserError(

package/lib/parsers/error-utils.js.flow

@@ -278,7 +278,7 @@ function throwIfArrayElementTypeAnnotationIsUnsupported(
     PromiseTypeAnnotation: 'Promise',
     // TODO: Added as a work-around for now until TupleTypeAnnotation are fully supported in both flow and TS
     // Right now they are partially treated as UnionTypeAnnotation
-    UnionTypeAnnotation: 'UnionTypeAnnotation',
+    // UnionTypeAnnotation: 'UnionTypeAnnotation',
   };
 
   if (type in TypeMap) {

package/lib/parsers/errors.js

@@ -265,20 +265,6 @@ class UnsupportedEnumDeclarationParserError extends ParserError {
   }
 }
 
-/**
- * Union parsing errors
- */
-
-class UnsupportedUnionTypeAnnotationParserError extends ParserError {
-  constructor(nativeModuleName, arrayElementTypeAST, types) {
-    super(
-      nativeModuleName,
-      arrayElementTypeAST,
-      `Union members must be of the same type, but multiple types were found ${types.join(', ')}'.`,
-    );
-  }
-}
-
 /**
  * Module parsing errors
  */
@@ -357,7 +343,6 @@ module.exports = {
   UnsupportedFunctionParamTypeAnnotationParserError,
   UnsupportedFunctionReturnTypeAnnotationParserError,
   UnsupportedEnumDeclarationParserError,
-  UnsupportedUnionTypeAnnotationParserError,
   UnsupportedModuleEventEmitterTypePropertyParserError,
   UnsupportedModuleEventEmitterPropertyParserError,
   UnsupportedModulePropertyParserError,

package/lib/parsers/errors.js.flow

@@ -10,7 +10,6 @@
 
 'use strict';
 
-import type {UnionTypeAnnotationMemberType} from '../CodegenSchema';
 import type {Parser} from './parser';
 
 export type ParserType = 'Flow' | 'TypeScript';
@@ -337,26 +336,6 @@ class UnsupportedEnumDeclarationParserError extends ParserError {
   }
 }
 
-/**
- * Union parsing errors
- */
-
-class UnsupportedUnionTypeAnnotationParserError extends ParserError {
-  constructor(
-    nativeModuleName: string,
-    arrayElementTypeAST: $FlowFixMe,
-    types: UnionTypeAnnotationMemberType[],
-  ) {
-    super(
-      nativeModuleName,
-      arrayElementTypeAST,
-      `Union members must be of the same type, but multiple types were found ${types.join(
-        ', ',
-      )}'.`,
-    );
-  }
-}
-
 /**
  * Module parsing errors
  */
@@ -460,7 +439,6 @@ module.exports = {
   UnsupportedFunctionParamTypeAnnotationParserError,
   UnsupportedFunctionReturnTypeAnnotationParserError,
   UnsupportedEnumDeclarationParserError,
-  UnsupportedUnionTypeAnnotationParserError,
   UnsupportedModuleEventEmitterTypePropertyParserError,
   UnsupportedModuleEventEmitterPropertyParserError,
   UnsupportedModulePropertyParserError,

package/lib/parsers/flow/components/events.js

@@ -107,7 +107,7 @@ function extractArrayElementType(typeAnnotation, name, parser) {
       };
     case 'UnionTypeAnnotation':
       return {
-        type: 'StringLiteralUnionTypeAnnotation',
+        type: 'UnionTypeAnnotation',
         types: typeAnnotation.types.map(option => ({
           type: 'StringLiteralTypeAnnotation',
           value: parser.getLiteralValue(option),

package/lib/parsers/flow/components/events.js.flow

@@ -115,7 +115,7 @@ function extractArrayElementType(
       };
     case 'UnionTypeAnnotation':
       return {
-        type: 'StringLiteralUnionTypeAnnotation',
+        type: 'UnionTypeAnnotation',
         types: typeAnnotation.types.map(option => ({
           type: 'StringLiteralTypeAnnotation',
           value: parser.getLiteralValue(option),

package/lib/parsers/flow/modules/index.js

@@ -220,7 +220,18 @@ function translateTypeAnnotation(
       );
     }
     case 'UnionTypeAnnotation': {
-      return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
+      return emitUnion(
+        nullable,
+        hasteModuleName,
+        typeAnnotation,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+        parser,
+      );
     }
     case 'NumberLiteralTypeAnnotation': {
       return emitNumberLiteral(nullable, typeAnnotation.value);

package/lib/parsers/flow/modules/index.js.flow

@@ -245,7 +245,18 @@ function translateTypeAnnotation(
       );
     }
     case 'UnionTypeAnnotation': {
-      return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
+      return emitUnion(
+        nullable,
+        hasteModuleName,
+        typeAnnotation,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+        parser,
+      );
     }
     case 'NumberLiteralTypeAnnotation': {
       return emitNumberLiteral(nullable, typeAnnotation.value);

package/lib/parsers/flow/parser.js

@@ -131,9 +131,6 @@ class FlowParser {
     };
     return [...new Set(membersTypes.map(remapLiteral))];
   }
-  getStringLiteralUnionTypeAnnotationStringLiterals(membersTypes) {
-    return membersTypes.map(item => item.value);
-  }
   parseFile(filename) {
     const contents = fs.readFileSync(filename, 'utf8');
     return this.parseString(contents, filename);

package/lib/parsers/flow/parser.js.flow

@@ -18,10 +18,10 @@ import type {
   NativeModuleEnumMember,
   NativeModuleEnumMemberType,
   NativeModuleParamTypeAnnotation,
+  NativeModuleUnionTypeAnnotationMemberType,
   Nullable,
   PropTypeAnnotation,
   SchemaType,
-  UnionTypeAnnotationMemberType,
 } from '../../CodegenSchema';
 import type {ParserType} from '../errors';
 import type {
@@ -111,7 +111,7 @@ class FlowParser implements Parser {
 
   remapUnionTypeAnnotationMemberNames(
     membersTypes: $FlowFixMe[],
-  ): UnionTypeAnnotationMemberType[] {
+  ): NativeModuleUnionTypeAnnotationMemberType[] {
     const remapLiteral = (item: $FlowFixMe) => {
       return item.type
         .replace('NumberLiteralTypeAnnotation', 'NumberTypeAnnotation')
@@ -121,12 +121,6 @@ class FlowParser implements Parser {
     return [...new Set(membersTypes.map(remapLiteral))];
   }
 
-  getStringLiteralUnionTypeAnnotationStringLiterals(
-    membersTypes: $FlowFixMe[],
-  ): string[] {
-    return membersTypes.map((item: $FlowFixMe) => item.value);
-  }
-
   parseFile(filename: string): SchemaType {
     const contents = fs.readFileSync(filename, 'utf8');
 

package/lib/parsers/parser.js.flow

@@ -18,10 +18,10 @@ import type {
   NativeModuleEnumMember,
   NativeModuleEnumMemberType,
   NativeModuleParamTypeAnnotation,
+  NativeModuleUnionTypeAnnotationMemberType,
   Nullable,
   PropTypeAnnotation,
   SchemaType,
-  UnionTypeAnnotationMemberType,
 } from '../CodegenSchema';
 import type {ParserType} from './errors';
 import type {
@@ -146,15 +146,7 @@ export interface Parser {
    */
   remapUnionTypeAnnotationMemberNames(
     types: $FlowFixMe,
-  ): UnionTypeAnnotationMemberType[];
-  /**
-   * Given a union annotation members types, it returns an array of string literals.
-   * @parameter membersTypes: union annotation members types
-   * @returns: an array of string literals.
-   */
-  getStringLiteralUnionTypeAnnotationStringLiterals(
-    types: $FlowFixMe,
-  ): string[];
+  ): NativeModuleUnionTypeAnnotationMemberType[];
   /**
    * Given the name of a file, it returns a Schema.
    * @parameter filename: the name of the file.

package/lib/parsers/parserMock.js

@@ -112,9 +112,6 @@ export class MockedParser {
   remapUnionTypeAnnotationMemberNames(membersTypes) {
     return [];
   }
-  getStringLiteralUnionTypeAnnotationStringLiterals(membersTypes) {
-    return [];
-  }
   parseFile(filename) {
     /* $FlowFixMe[incompatible-type] Natural Inference rollout. See
      * https://fburl.com/workplace/6291gfvu */

package/lib/parsers/parserMock.js.flow

@@ -18,10 +18,10 @@ import type {
   NativeModuleEnumMember,
   NativeModuleEnumMemberType,
   NativeModuleParamTypeAnnotation,
+  NativeModuleUnionTypeAnnotationMemberType,
   Nullable,
   PropTypeAnnotation,
   SchemaType,
-  UnionTypeAnnotationMemberType,
 } from '../CodegenSchema';
 import type {ParserType} from './errors';
 import type {
@@ -105,13 +105,7 @@ export class MockedParser implements Parser {
 
   remapUnionTypeAnnotationMemberNames(
     membersTypes: $FlowFixMe[],
-  ): UnionTypeAnnotationMemberType[] {
-    return [];
-  }
-
-  getStringLiteralUnionTypeAnnotationStringLiterals(
-    membersTypes: $FlowFixMe[],
-  ): string[] {
+  ): NativeModuleUnionTypeAnnotationMemberType[] {
     return [];
   }
 

package/lib/parsers/parsers-primitives.js

@@ -15,11 +15,7 @@ const {
   throwIfPartialNotAnnotatingTypeParameter,
   throwIfPartialWithMoreParameter,
 } = require('./error-utils');
-const {
-  ParserError,
-  UnsupportedTypeAnnotationParserError,
-  UnsupportedUnionTypeAnnotationParserError,
-} = require('./errors');
+const {ParserError, UnsupportedTypeAnnotationParserError} = require('./errors');
 const {
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   translateFunctionTypeAnnotation,
@@ -320,54 +316,51 @@ function emitFloatProp(name, optional) {
     },
   };
 }
-function emitUnion(nullable, hasteModuleName, typeAnnotation, parser) {
-  // Get all the literals by type
-  // Verify they are all the same
-  // If string, persist as StringLiteralUnionType
-  // If number, persist as NumberTypeAnnotation (TODO: Number literal)
-
-  const unionTypes = parser.remapUnionTypeAnnotationMemberNames(
-    typeAnnotation.types,
-  );
-
-  // Only support unionTypes of the same kind
-  if (unionTypes.length > 1) {
-    throw new UnsupportedUnionTypeAnnotationParserError(
-      hasteModuleName,
-      typeAnnotation,
-      unionTypes,
-    );
-  }
-  if (unionTypes[0] === 'StringTypeAnnotation') {
-    // Reprocess as a string literal union
-    return emitStringLiteralUnion(
-      nullable,
-      hasteModuleName,
-      typeAnnotation,
-      parser,
-    );
-  }
-  return wrapNullable(nullable, {
-    type: 'UnionTypeAnnotation',
-    memberType: unionTypes[0],
-  });
-}
-function emitStringLiteralUnion(
+function emitUnion(
   nullable,
   hasteModuleName,
   typeAnnotation,
+  types,
+  aliasMap,
+  enumMap,
+  tryParse,
+  cxxOnly,
+  translateTypeAnnotation,
   parser,
 ) {
-  const stringLiterals =
-    parser.getStringLiteralUnionTypeAnnotationStringLiterals(
-      typeAnnotation.types,
+  const unparsedMemberTypes = typeAnnotation.types;
+  const memberTypes = unparsedMemberTypes.map(memberType => {
+    const memberTypeAnnotation = translateTypeAnnotation(
+      hasteModuleName,
+      memberType,
+      types,
+      aliasMap,
+      enumMap,
+      tryParse,
+      cxxOnly,
+      parser,
     );
+    switch (memberTypeAnnotation.type) {
+      case 'StringTypeAnnotation':
+      case 'NumberTypeAnnotation':
+      case 'BooleanTypeAnnotation':
+      case 'NumberLiteralTypeAnnotation':
+      case 'StringLiteralTypeAnnotation':
+      case 'BooleanLiteralTypeAnnotation':
+      case 'ObjectTypeAnnotation':
+      case 'TypeAliasTypeAnnotation':
+        return memberTypeAnnotation;
+      default:
+        throw new UnsupportedTypeAnnotationParserError(
+          hasteModuleName,
+          memberType,
+          parser.language(),
+        );
+    }
+  });
   return wrapNullable(nullable, {
-    type: 'StringLiteralUnionTypeAnnotation',
-    types: stringLiterals.map(stringLiteral => ({
-      type: 'StringLiteralTypeAnnotation',
-      value: stringLiteral,
-    })),
+    type: 'UnionTypeAnnotation',
+    types: memberTypes,
   });
 }
 function translateArrayTypeAnnotation(
@@ -542,6 +535,7 @@ function emitCommonTypes(
     VoidTypeAnnotation: emitVoid,
     StringTypeAnnotation: emitString,
     MixedTypeAnnotation: cxxOnly ? emitMixed : emitGenericObject,
+    UnsafeMixed: cxxOnly ? emitMixed : emitGenericObject,
   };
   const typeAnnotationName = parser.convertKeywordToTypeAnnotation(
     typeAnnotation.type,
@@ -608,7 +602,7 @@ function emitUnionProp(name, optional, parser, typeAnnotation) {
     name,
     optional,
     typeAnnotation: {
-      type: 'StringLiteralUnionTypeAnnotation',
+      type: 'UnionTypeAnnotation',
       types: typeAnnotation.types.map(option => ({
         type: 'StringLiteralTypeAnnotation',
         value: parser.getLiteralValue(option),

package/lib/parsers/parsers-primitives.js.flow

@@ -31,12 +31,12 @@ import type {
   NativeModuleTypeAliasTypeAnnotation,
   NativeModuleTypeAnnotation,
   NativeModuleUnionTypeAnnotation,
+  NativeModuleUnionTypeAnnotationMemberType,
   Nullable,
   NumberLiteralTypeAnnotation,
   ObjectTypeAnnotation,
   ReservedTypeAnnotation,
   StringLiteralTypeAnnotation,
-  StringLiteralUnionTypeAnnotation,
   StringTypeAnnotation,
   VoidTypeAnnotation,
 } from '../CodegenSchema';
@@ -52,11 +52,7 @@ const {
   throwIfPartialNotAnnotatingTypeParameter,
   throwIfPartialWithMoreParameter,
 } = require('./error-utils');
-const {
-  ParserError,
-  UnsupportedTypeAnnotationParserError,
-  UnsupportedUnionTypeAnnotationParserError,
-} = require('./errors');
+const {ParserError, UnsupportedTypeAnnotationParserError} = require('./errors');
 const {
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   translateFunctionTypeAnnotation,
@@ -431,61 +427,53 @@ function emitUnion(
   nullable: boolean,
   hasteModuleName: string,
   typeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+  aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
+  tryParse: ParserErrorCapturer,
+  cxxOnly: boolean,
+  translateTypeAnnotation: $FlowFixMe,
   parser: Parser,
-): Nullable<
-  NativeModuleUnionTypeAnnotation | StringLiteralUnionTypeAnnotation,
-> {
-  // Get all the literals by type
-  // Verify they are all the same
-  // If string, persist as StringLiteralUnionType
-  // If number, persist as NumberTypeAnnotation (TODO: Number literal)
-
-  const unionTypes = parser.remapUnionTypeAnnotationMemberNames(
-    typeAnnotation.types,
-  );
+): Nullable<NativeModuleUnionTypeAnnotation> {
+  const unparsedMemberTypes: $ReadOnlyArray<$FlowFixMe> =
+    (typeAnnotation.types: $ReadOnlyArray<$FlowFixMe>);
 
-  // Only support unionTypes of the same kind
-  if (unionTypes.length > 1) {
-    throw new UnsupportedUnionTypeAnnotationParserError(
-      hasteModuleName,
-      typeAnnotation,
-      unionTypes,
-    );
-  }
+  const memberTypes = unparsedMemberTypes.map(
+    (memberType: $FlowFixMe): NativeModuleUnionTypeAnnotationMemberType => {
+      const memberTypeAnnotation = translateTypeAnnotation(
+        hasteModuleName,
+        memberType,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        parser,
+      );
 
-  if (unionTypes[0] === 'StringTypeAnnotation') {
-    // Reprocess as a string literal union
-    return emitStringLiteralUnion(
-      nullable,
-      hasteModuleName,
-      typeAnnotation,
-      parser,
-    );
-  }
+      switch (memberTypeAnnotation.type) {
+        case 'StringTypeAnnotation':
+        case 'NumberTypeAnnotation':
+        case 'BooleanTypeAnnotation':
+        case 'NumberLiteralTypeAnnotation':
+        case 'StringLiteralTypeAnnotation':
+        case 'BooleanLiteralTypeAnnotation':
+        case 'ObjectTypeAnnotation':
+        case 'TypeAliasTypeAnnotation':
+          return memberTypeAnnotation;
+        default:
+          throw new UnsupportedTypeAnnotationParserError(
+            hasteModuleName,
+            memberType,
+            parser.language(),
+          );
+      }
+    },
+  );
 
   return wrapNullable(nullable, {
     type: 'UnionTypeAnnotation',
-    memberType: unionTypes[0],
-  });
-}
-
-function emitStringLiteralUnion(
-  nullable: boolean,
-  hasteModuleName: string,
-  typeAnnotation: $FlowFixMe,
-  parser: Parser,
-): Nullable<StringLiteralUnionTypeAnnotation> {
-  const stringLiterals =
-    parser.getStringLiteralUnionTypeAnnotationStringLiterals(
-      typeAnnotation.types,
-    );
-
-  return wrapNullable(nullable, {
-    type: 'StringLiteralUnionTypeAnnotation',
-    types: stringLiterals.map(stringLiteral => ({
-      type: 'StringLiteralTypeAnnotation',
-      value: stringLiteral,
-    })),
+    types: memberTypes,
   });
 }
 
@@ -675,6 +663,7 @@ function emitCommonTypes(
     VoidTypeAnnotation: emitVoid,
     StringTypeAnnotation: emitString,
     MixedTypeAnnotation: cxxOnly ? emitMixed : emitGenericObject,
+    UnsafeMixed: cxxOnly ? emitMixed : emitGenericObject,
   };
 
   const typeAnnotationName = parser.convertKeywordToTypeAnnotation(
@@ -763,7 +752,7 @@ function emitUnionProp(
     name,
     optional,
     typeAnnotation: {
-      type: 'StringLiteralUnionTypeAnnotation',
+      type: 'UnionTypeAnnotation',
       types: typeAnnotation.types.map(option => ({
         type: 'StringLiteralTypeAnnotation',
         value: parser.getLiteralValue(option),

package/lib/parsers/typescript/components/events.js

@@ -115,7 +115,7 @@ function extractArrayElementType(typeAnnotation, name, parser) {
       };
     case 'TSUnionType':
       return {
-        type: 'StringLiteralUnionTypeAnnotation',
+        type: 'UnionTypeAnnotation',
         types: typeAnnotation.types.map(option => ({
           type: 'StringLiteralTypeAnnotation',
           value: parser.getLiteralValue(option),

package/lib/parsers/typescript/components/events.js.flow

@@ -127,7 +127,7 @@ function extractArrayElementType(
       };
     case 'TSUnionType':
       return {
-        type: 'StringLiteralUnionTypeAnnotation',
+        type: 'UnionTypeAnnotation',
         types: typeAnnotation.types.map(option => ({
           type: 'StringLiteralTypeAnnotation',
           value: parser.getLiteralValue(option),

package/lib/parsers/typescript/modules/index.js

@@ -380,7 +380,18 @@ function translateTypeAnnotation(
       );
     }
     case 'TSUnionType': {
-      return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
+      return emitUnion(
+        nullable,
+        hasteModuleName,
+        typeAnnotation,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+        parser,
+      );
     }
     case 'TSLiteralType': {
       const literal = typeAnnotation.literal;