@react-native/codegen 0.72.2 → 0.72.3

package/lib/parsers/error-utils.js

@@ -24,6 +24,8 @@ const _require = require('./errors'),
     _require.IncorrectModuleRegistryCallArityParserError,
   IncorrectModuleRegistryCallTypeParameterParserError =
     _require.IncorrectModuleRegistryCallTypeParameterParserError,
+  IncorrectModuleRegistryCallArgumentTypeParserError =
+    _require.IncorrectModuleRegistryCallArgumentTypeParserError,
   UnsupportedObjectPropertyValueTypeAnnotationParserError =
     _require.UnsupportedObjectPropertyValueTypeAnnotationParserError,
   UntypedModuleRegistryCallParserError =
@@ -249,6 +251,42 @@ function throwIfArrayElementTypeAnnotationIsUnsupported(
     );
   }
 }
+function throwIfIncorrectModuleRegistryCallArgument(
+  nativeModuleName,
+  callExpressionArg,
+  methodName,
+) {
+  if (
+    callExpressionArg.type !== 'StringLiteral' &&
+    callExpressionArg.type !== 'Literal'
+  ) {
+    const type = callExpressionArg.type;
+    throw new IncorrectModuleRegistryCallArgumentTypeParserError(
+      nativeModuleName,
+      callExpressionArg,
+      methodName,
+      type,
+    );
+  }
+}
+function throwIfPartialNotAnnotatingTypeParameter(
+  typeAnnotation,
+  types,
+  parser,
+) {
+  const annotatedElement = parser.extractAnnotatedElement(
+    typeAnnotation,
+    types,
+  );
+  if (!annotatedElement) {
+    throw new Error('Partials only support annotating a type parameter.');
+  }
+}
+function throwIfPartialWithMoreParameter(typeAnnotation) {
+  if (typeAnnotation.typeParameters.params.length !== 1) {
+    throw new Error('Partials only support annotating exactly one parameter.');
+  }
+}
 module.exports = {
   throwIfModuleInterfaceIsMisnamed,
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
@@ -263,4 +301,7 @@ module.exports = {
   throwIfMoreThanOneModuleInterfaceParserError,
   throwIfUnsupportedFunctionParamTypeAnnotationParserError,
   throwIfArrayElementTypeAnnotationIsUnsupported,
+  throwIfIncorrectModuleRegistryCallArgument,
+  throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter,
 };

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

@@ -13,6 +13,7 @@
 import type {NativeModuleTypeAnnotation} from '../CodegenSchema';
 import type {ParserType} from './errors';
 import type {Parser} from './parser';
+import type {TypeDeclarationMap} from '../parsers/utils';
 
 const {
   MisnamedModuleInterfaceParserError,
@@ -22,6 +23,7 @@ const {
   UnusedModuleInterfaceParserError,
   IncorrectModuleRegistryCallArityParserError,
   IncorrectModuleRegistryCallTypeParameterParserError,
+  IncorrectModuleRegistryCallArgumentTypeParserError,
   UnsupportedObjectPropertyValueTypeAnnotationParserError,
   UntypedModuleRegistryCallParserError,
   UnsupportedModulePropertyParserError,
@@ -260,6 +262,46 @@ function throwIfArrayElementTypeAnnotationIsUnsupported(
   }
 }
 
+function throwIfIncorrectModuleRegistryCallArgument(
+  nativeModuleName: string,
+  callExpressionArg: $FlowFixMe,
+  methodName: string,
+) {
+  if (
+    callExpressionArg.type !== 'StringLiteral' &&
+    callExpressionArg.type !== 'Literal'
+  ) {
+    const {type} = callExpressionArg;
+    throw new IncorrectModuleRegistryCallArgumentTypeParserError(
+      nativeModuleName,
+      callExpressionArg,
+      methodName,
+      type,
+    );
+  }
+}
+
+function throwIfPartialNotAnnotatingTypeParameter(
+  typeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+  parser: Parser,
+) {
+  const annotatedElement = parser.extractAnnotatedElement(
+    typeAnnotation,
+    types,
+  );
+
+  if (!annotatedElement) {
+    throw new Error('Partials only support annotating a type parameter.');
+  }
+}
+
+function throwIfPartialWithMoreParameter(typeAnnotation: $FlowFixMe) {
+  if (typeAnnotation.typeParameters.params.length !== 1) {
+    throw new Error('Partials only support annotating exactly one parameter.');
+  }
+}
+
 module.exports = {
   throwIfModuleInterfaceIsMisnamed,
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
@@ -274,4 +316,7 @@ module.exports = {
   throwIfMoreThanOneModuleInterfaceParserError,
   throwIfUnsupportedFunctionParamTypeAnnotationParserError,
   throwIfArrayElementTypeAnnotationIsUnsupported,
+  throwIfIncorrectModuleRegistryCallArgument,
+  throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter,
 };

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

@@ -72,22 +72,20 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
-const _require = require('../utils'),
-  getTypes = _require.getTypes;
-const _require2 = require('./commands'),
-  getCommands = _require2.getCommands;
-const _require3 = require('./events'),
-  getEvents = _require3.getEvents;
-const _require4 = require('./extends'),
-  getExtendsProps = _require4.getExtendsProps,
-  removeKnownExtends = _require4.removeKnownExtends;
-const _require5 = require('./options'),
-  getCommandOptions = _require5.getCommandOptions,
-  getOptions = _require5.getOptions;
-const _require6 = require('./props'),
-  getProps = _require6.getProps;
-const _require7 = require('./componentsUtils.js'),
-  getProperties = _require7.getProperties;
+const _require = require('./commands'),
+  getCommands = _require.getCommands;
+const _require2 = require('./events'),
+  getEvents = _require2.getEvents;
+const _require3 = require('./extends'),
+  getExtendsProps = _require3.getExtendsProps,
+  removeKnownExtends = _require3.removeKnownExtends;
+const _require4 = require('./options'),
+  getCommandOptions = _require4.getCommandOptions,
+  getOptions = _require4.getOptions;
+const _require5 = require('./props'),
+  getProps = _require5.getProps;
+const _require6 = require('./componentsUtils.js'),
+  getProperties = _require6.getProperties;
 
 /* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
  * LTI update could not be added via codemod */
@@ -229,16 +227,14 @@ function getCommandProperties(
 }
 
 // $FlowFixMe[signature-verification-failure] there's no flowtype for AST
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function buildComponentSchema(ast) {
+function buildComponentSchema(ast, parser) {
   const _findComponentConfig = findComponentConfig(ast),
     componentName = _findComponentConfig.componentName,
     propsTypeName = _findComponentConfig.propsTypeName,
     commandTypeName = _findComponentConfig.commandTypeName,
     commandOptionsExpression = _findComponentConfig.commandOptionsExpression,
     optionsExpression = _findComponentConfig.optionsExpression;
-  const types = getTypes(ast);
+  const types = parser.getTypes(ast);
   const propProperties = getProperties(propsTypeName, types);
   const commandOptions = getCommandOptions(commandOptionsExpression);
   const commandProperties = getCommandProperties(

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

@@ -9,11 +9,11 @@
  */
 
 'use strict';
+import type {Parser} from '../../parser';
 import type {TypeDeclarationMap} from '../../utils';
 import type {CommandOptions} from './options';
-import type {ComponentSchemaBuilderConfig} from './schema.js';
+import type {ComponentSchemaBuilderConfig} from '../../schema.js';
 
-const {getTypes} = require('../utils');
 const {getCommands} = require('./commands');
 const {getEvents} = require('./events');
 const {getExtendsProps, removeKnownExtends} = require('./extends');
@@ -180,9 +180,10 @@ function getCommandProperties(
 }
 
 // $FlowFixMe[signature-verification-failure] there's no flowtype for AST
-/* $FlowFixMe[missing-local-annot] The type annotation(s) required by Flow's
- * LTI update could not be added via codemod */
-function buildComponentSchema(ast): ComponentSchemaBuilderConfig {
+function buildComponentSchema(
+  ast: $FlowFixMe,
+  parser: Parser,
+): ComponentSchemaBuilderConfig {
   const {
     componentName,
     propsTypeName,
@@ -191,7 +192,7 @@ function buildComponentSchema(ast): ComponentSchemaBuilderConfig {
     optionsExpression,
   } = findComponentConfig(ast);
 
-  const types = getTypes(ast);
+  const types = parser.getTypes(ast);
 
   const propProperties = getProperties(propsTypeName, types);
   const commandOptions = getCommandOptions(commandOptionsExpression);

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

@@ -145,8 +145,7 @@ const _require = require('../../utils'),
   isModuleRegistryCall = _require.isModuleRegistryCall,
   verifyPlatforms = _require.verifyPlatforms;
 const _require2 = require('../utils'),
-  resolveTypeAnnotation = _require2.resolveTypeAnnotation,
-  getTypes = _require2.getTypes;
+  resolveTypeAnnotation = _require2.resolveTypeAnnotation;
 const _require3 = require('../../parsers-commons'),
   unwrapNullable = _require3.unwrapNullable,
   wrapNullable = _require3.wrapNullable,
@@ -176,8 +175,6 @@ const _require4 = require('../../parsers-primitives'),
 const _require5 = require('../../errors'),
   UnsupportedTypeAnnotationParserError =
     _require5.UnsupportedTypeAnnotationParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError =
-    _require5.IncorrectModuleRegistryCallArgumentTypeParserError,
   UnsupportedGenericParserError = _require5.UnsupportedGenericParserError;
 const _require6 = require('../../error-utils'),
   throwIfModuleInterfaceNotFound = _require6.throwIfModuleInterfaceNotFound,
@@ -190,9 +187,14 @@ const _require6 = require('../../error-utils'),
     _require6.throwIfMoreThanOneModuleRegistryCalls,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError =
     _require6.throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfIncorrectModuleRegistryCallArgument =
+    _require6.throwIfIncorrectModuleRegistryCallArgument,
   throwIfUntypedModule = _require6.throwIfUntypedModule,
   throwIfMoreThanOneModuleInterfaceParserError =
-    _require6.throwIfMoreThanOneModuleInterfaceParserError;
+    _require6.throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfPartialNotAnnotatingTypeParameter =
+    _require6.throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter = _require6.throwIfPartialWithMoreParameter;
 const language = 'Flow';
 function translateTypeAnnotation(
   hasteModuleName,
@@ -288,18 +290,16 @@ function translateTypeAnnotation(
           return emitGenericObject(nullable);
         }
         case '$Partial': {
-          if (typeAnnotation.typeParameters.params.length !== 1) {
-            throw new Error(
-              'Partials only support annotating exactly one parameter.',
-            );
-          }
-          const annotatedElement =
-            types[typeAnnotation.typeParameters.params[0].id.name];
-          if (!annotatedElement) {
-            throw new Error(
-              'Partials only support annotating a type parameter.',
-            );
-          }
+          throwIfPartialWithMoreParameter(typeAnnotation);
+          const annotatedElement = parser.extractAnnotatedElement(
+            typeAnnotation,
+            types,
+          );
+          throwIfPartialNotAnnotatingTypeParameter(
+            typeAnnotation,
+            types,
+            parser,
+          );
           const properties = annotatedElement.right.properties.map(prop => {
             return {
               name: prop.key.name,
@@ -444,14 +444,6 @@ function translateTypeAnnotation(
     }
   }
 }
-function isModuleInterface(node) {
-  return (
-    node.type === 'InterfaceDeclaration' &&
-    node.extends.length === 1 &&
-    node.extends[0].type === 'InterfaceExtends' &&
-    node.extends[0].id.name === 'TurboModule'
-  );
-}
 function buildModuleSchema(
   hasteModuleName,
   /**
@@ -461,8 +453,10 @@ function buildModuleSchema(
   tryParse,
   parser,
 ) {
-  const types = getTypes(ast);
-  const moduleSpecs = Object.values(types).filter(isModuleInterface);
+  const types = parser.getTypes(ast);
+  const moduleSpecs = Object.values(types).filter(t =>
+    parser.isModuleInterface(t),
+  );
   throwIfModuleInterfaceNotFound(
     moduleSpecs.length,
     hasteModuleName,
@@ -507,15 +501,11 @@ function buildModuleSchema(
       methodName,
       callExpression.arguments.length,
     );
-    if (callExpression.arguments[0].type !== 'Literal') {
-      const type = callExpression.arguments[0].type;
-      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
-        hasteModuleName,
-        callExpression.arguments[0],
-        methodName,
-        type,
-      );
-    }
+    throwIfIncorrectModuleRegistryCallArgument(
+      hasteModuleName,
+      callExpression.arguments[0],
+      methodName,
+    );
     const $moduleName = callExpression.arguments[0].value;
     throwIfUntypedModule(
       typeArguments,

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

@@ -25,7 +25,7 @@ import type {Parser} from '../../parser';
 import type {ParserErrorCapturer, TypeDeclarationMap} from '../../utils';
 
 const {visit, isModuleRegistryCall, verifyPlatforms} = require('../../utils');
-const {resolveTypeAnnotation, getTypes} = require('../utils');
+const {resolveTypeAnnotation} = require('../utils');
 const {
   unwrapNullable,
   wrapNullable,
@@ -56,7 +56,6 @@ const {
 
 const {
   UnsupportedTypeAnnotationParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError,
   UnsupportedGenericParserError,
 } = require('../../errors');
 
@@ -67,8 +66,11 @@ const {
   throwIfWrongNumberOfCallExpressionArgs,
   throwIfMoreThanOneModuleRegistryCalls,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfIncorrectModuleRegistryCallArgument,
   throwIfUntypedModule,
   throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter,
 } = require('../../error-utils');
 
 const language = 'Flow';
@@ -162,20 +164,18 @@ function translateTypeAnnotation(
           return emitGenericObject(nullable);
         }
         case '$Partial': {
-          if (typeAnnotation.typeParameters.params.length !== 1) {
-            throw new Error(
-              'Partials only support annotating exactly one parameter.',
-            );
-          }
+          throwIfPartialWithMoreParameter(typeAnnotation);
 
-          const annotatedElement =
-            types[typeAnnotation.typeParameters.params[0].id.name];
+          const annotatedElement = parser.extractAnnotatedElement(
+            typeAnnotation,
+            types,
+          );
 
-          if (!annotatedElement) {
-            throw new Error(
-              'Partials only support annotating a type parameter.',
-            );
-          }
+          throwIfPartialNotAnnotatingTypeParameter(
+            typeAnnotation,
+            types,
+            parser,
+          );
 
           const properties = annotatedElement.right.properties.map(prop => {
             return {
@@ -330,15 +330,6 @@ function translateTypeAnnotation(
   }
 }
 
-function isModuleInterface(node: $FlowFixMe) {
-  return (
-    node.type === 'InterfaceDeclaration' &&
-    node.extends.length === 1 &&
-    node.extends[0].type === 'InterfaceExtends' &&
-    node.extends[0].id.name === 'TurboModule'
-  );
-}
-
 function buildModuleSchema(
   hasteModuleName: string,
   /**
@@ -348,9 +339,9 @@ function buildModuleSchema(
   tryParse: ParserErrorCapturer,
   parser: Parser,
 ): NativeModuleSchema {
-  const types = getTypes(ast);
+  const types = parser.getTypes(ast);
   const moduleSpecs = (Object.values(types): $ReadOnlyArray<$FlowFixMe>).filter(
-    isModuleInterface,
+    t => parser.isModuleInterface(t),
   );
 
   throwIfModuleInterfaceNotFound(
@@ -404,15 +395,11 @@ function buildModuleSchema(
       callExpression.arguments.length,
     );
 
-    if (callExpression.arguments[0].type !== 'Literal') {
-      const {type} = callExpression.arguments[0];
-      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
-        hasteModuleName,
-        callExpression.arguments[0],
-        methodName,
-        type,
-      );
-    }
+    throwIfIncorrectModuleRegistryCallArgument(
+      hasteModuleName,
+      callExpression.arguments[0],
+      methodName,
+    );
 
     const $moduleName = callExpression.arguments[0].value;
 

package/lib/parsers/flow/parser.js

@@ -46,7 +46,7 @@ const _require2 = require('./Visitor'),
   Visitor = _require2.Visitor;
 const _require3 = require('./components'),
   buildComponentSchema = _require3.buildComponentSchema;
-const _require4 = require('./components/schema'),
+const _require4 = require('../schema.js'),
   wrapComponentSchema = _require4.wrapComponentSchema;
 const _require5 = require('./modules'),
   buildModuleSchema = _require5.buildModuleSchema;
@@ -193,6 +193,57 @@ class FlowParser {
       };
     });
   }
+  isModuleInterface(node) {
+    return (
+      node.type === 'InterfaceDeclaration' &&
+      node.extends.length === 1 &&
+      node.extends[0].type === 'InterfaceExtends' &&
+      node.extends[0].id.name === 'TurboModule'
+    );
+  }
+  extractAnnotatedElement(typeAnnotation, types) {
+    return types[typeAnnotation.typeParameters.params[0].id.name];
+  }
+
+  /**
+   * This FlowFixMe is supposed to refer to an InterfaceDeclaration or TypeAlias
+   * declaration type. Unfortunately, we don't have those types, because flow-parser
+   * generates them, and flow-parser is not type-safe. In the future, we should find
+   * a way to get these types from our flow parser library.
+   *
+   * TODO(T71778680): Flow type AST Nodes
+   */
+
+  getTypes(ast) {
+    return ast.body.reduce((types, node) => {
+      if (
+        node.type === 'ExportNamedDeclaration' &&
+        node.exportKind === 'type'
+      ) {
+        if (
+          node.declaration != null &&
+          (node.declaration.type === 'TypeAlias' ||
+            node.declaration.type === 'InterfaceDeclaration')
+        ) {
+          types[node.declaration.id.name] = node.declaration;
+        }
+      } else if (
+        node.type === 'ExportNamedDeclaration' &&
+        node.exportKind === 'value' &&
+        node.declaration &&
+        node.declaration.type === 'EnumDeclaration'
+      ) {
+        types[node.declaration.id.name] = node.declaration;
+      } else if (
+        node.type === 'TypeAlias' ||
+        node.type === 'InterfaceDeclaration' ||
+        node.type === 'EnumDeclaration'
+      ) {
+        types[node.id.name] = node;
+      }
+      return types;
+    }, {});
+  }
 }
 module.exports = {
   FlowParser,

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

@@ -21,6 +21,7 @@ import type {
 } from '../../CodegenSchema';
 import type {ParserType} from '../errors';
 import type {Parser} from '../parser';
+import type {TypeDeclarationMap} from '../utils';
 
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
@@ -28,7 +29,7 @@ const flowParser = require('flow-parser');
 const {buildSchema} = require('../parsers-commons');
 const {Visitor} = require('./Visitor');
 const {buildComponentSchema} = require('./components');
-const {wrapComponentSchema} = require('./components/schema');
+const {wrapComponentSchema} = require('../schema.js');
 const {buildModuleSchema} = require('./modules');
 
 const fs = require('fs');
@@ -196,6 +197,62 @@ class FlowParser implements Parser {
       value: member.init?.value ?? member.id.name,
     }));
   }
+
+  isModuleInterface(node: $FlowFixMe): boolean {
+    return (
+      node.type === 'InterfaceDeclaration' &&
+      node.extends.length === 1 &&
+      node.extends[0].type === 'InterfaceExtends' &&
+      node.extends[0].id.name === 'TurboModule'
+    );
+  }
+
+  extractAnnotatedElement(
+    typeAnnotation: $FlowFixMe,
+    types: TypeDeclarationMap,
+  ): $FlowFixMe {
+    return types[typeAnnotation.typeParameters.params[0].id.name];
+  }
+
+  /**
+   * This FlowFixMe is supposed to refer to an InterfaceDeclaration or TypeAlias
+   * declaration type. Unfortunately, we don't have those types, because flow-parser
+   * generates them, and flow-parser is not type-safe. In the future, we should find
+   * a way to get these types from our flow parser library.
+   *
+   * TODO(T71778680): Flow type AST Nodes
+   */
+
+  getTypes(ast: $FlowFixMe): TypeDeclarationMap {
+    return ast.body.reduce((types, node) => {
+      if (
+        node.type === 'ExportNamedDeclaration' &&
+        node.exportKind === 'type'
+      ) {
+        if (
+          node.declaration != null &&
+          (node.declaration.type === 'TypeAlias' ||
+            node.declaration.type === 'InterfaceDeclaration')
+        ) {
+          types[node.declaration.id.name] = node.declaration;
+        }
+      } else if (
+        node.type === 'ExportNamedDeclaration' &&
+        node.exportKind === 'value' &&
+        node.declaration &&
+        node.declaration.type === 'EnumDeclaration'
+      ) {
+        types[node.declaration.id.name] = node.declaration;
+      } else if (
+        node.type === 'TypeAlias' ||
+        node.type === 'InterfaceDeclaration' ||
+        node.type === 'EnumDeclaration'
+      ) {
+        types[node.id.name] = node;
+      }
+      return types;
+    }, {});
+  }
 }
 
 module.exports = {

package/lib/parsers/flow/utils.js

@@ -10,43 +10,6 @@
 
 'use strict';
 
-/**
- * This FlowFixMe is supposed to refer to an InterfaceDeclaration or TypeAlias
- * declaration type. Unfortunately, we don't have those types, because flow-parser
- * generates them, and flow-parser is not type-safe. In the future, we should find
- * a way to get these types from our flow parser library.
- *
- * TODO(T71778680): Flow type AST Nodes
- */
-
-function getTypes(ast) {
-  return ast.body.reduce((types, node) => {
-    if (node.type === 'ExportNamedDeclaration' && node.exportKind === 'type') {
-      if (
-        node.declaration != null &&
-        (node.declaration.type === 'TypeAlias' ||
-          node.declaration.type === 'InterfaceDeclaration')
-      ) {
-        types[node.declaration.id.name] = node.declaration;
-      }
-    } else if (
-      node.type === 'ExportNamedDeclaration' &&
-      node.exportKind === 'value' &&
-      node.declaration &&
-      node.declaration.type === 'EnumDeclaration'
-    ) {
-      types[node.declaration.id.name] = node.declaration;
-    } else if (
-      node.type === 'TypeAlias' ||
-      node.type === 'InterfaceDeclaration' ||
-      node.type === 'EnumDeclaration'
-    ) {
-      types[node.id.name] = node;
-    }
-    return types;
-  }, {});
-}
-
 // $FlowFixMe[unclear-type] there's no flowtype for ASTs
 
 const invariant = require('invariant');
@@ -118,5 +81,4 @@ function getValueFromTypes(value, types) {
 module.exports = {
   getValueFromTypes,
   resolveTypeAnnotation,
-  getTypes,
 };

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

@@ -12,43 +12,6 @@
 
 import type {TypeResolutionStatus, TypeDeclarationMap} from '../utils';
 
-/**
- * This FlowFixMe is supposed to refer to an InterfaceDeclaration or TypeAlias
- * declaration type. Unfortunately, we don't have those types, because flow-parser
- * generates them, and flow-parser is not type-safe. In the future, we should find
- * a way to get these types from our flow parser library.
- *
- * TODO(T71778680): Flow type AST Nodes
- */
-
-function getTypes(ast: $FlowFixMe): TypeDeclarationMap {
-  return ast.body.reduce((types, node) => {
-    if (node.type === 'ExportNamedDeclaration' && node.exportKind === 'type') {
-      if (
-        node.declaration != null &&
-        (node.declaration.type === 'TypeAlias' ||
-          node.declaration.type === 'InterfaceDeclaration')
-      ) {
-        types[node.declaration.id.name] = node.declaration;
-      }
-    } else if (
-      node.type === 'ExportNamedDeclaration' &&
-      node.exportKind === 'value' &&
-      node.declaration &&
-      node.declaration.type === 'EnumDeclaration'
-    ) {
-      types[node.declaration.id.name] = node.declaration;
-    } else if (
-      node.type === 'TypeAlias' ||
-      node.type === 'InterfaceDeclaration' ||
-      node.type === 'EnumDeclaration'
-    ) {
-      types[node.id.name] = node;
-    }
-    return types;
-  }, {});
-}
-
 // $FlowFixMe[unclear-type] there's no flowtype for ASTs
 export type ASTNode = Object;
 
@@ -134,5 +97,4 @@ function getValueFromTypes(value: ASTNode, types: TypeDeclarationMap): ASTNode {
 module.exports = {
   getValueFromTypes,
   resolveTypeAnnotation,
-  getTypes,
 };