Chore: mv translateFunctionTypeAnnotation fn > parsers-commons.js

packages/react-native-codegen/src/parsers/flow/modules/index.js

@@ -33,6 +33,7 @@ const {
   parseObjectProperty,
   emitUnionTypeAnnotation,
   translateDefault,
+  translateFunctionTypeAnnotation,
 } = require('../../parsers-commons');
 const {
   emitBoolean,
@@ -49,7 +50,6 @@ const {
   emitStringish,
   emitMixedTypeAnnotation,
   typeAliasResolution,
-  translateFunctionTypeAnnotation,
 } = require('../../parsers-primitives');
 
 const {

packages/react-native-codegen/src/parsers/parsers-commons.js

@@ -17,6 +17,8 @@ import type {
   NativeModuleEnumDeclaration,
   NativeModuleSchema,
   NativeModuleTypeAnnotation,
+  NativeModuleFunctionTypeAnnotation,
+  NativeModuleParamTypeAnnotation,
   NativeModuleUnionTypeAnnotation,
   Nullable,
   SchemaType,
@@ -25,15 +27,21 @@ import type {ParserType} from './errors';
 import type {Parser} from './parser';
 import type {ParserErrorCapturer, TypeDeclarationMap} from './utils';
 
-const {throwIfPropertyValueTypeIsUnsupported} = require('./error-utils');
+const {
+  throwIfPropertyValueTypeIsUnsupported,
+  throwIfUnsupportedFunctionParamTypeAnnotationParserError,
+  throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
+} = require('./error-utils');
 const {
   MissingTypeParameterGenericParserError,
   MoreThanOneTypeParameterGenericParserError,
   UnsupportedEnumDeclarationParserError,
   UnsupportedGenericParserError,
   UnsupportedObjectPropertyTypeAnnotationParserError,
   UnsupportedUnionTypeAnnotationParserError,
+  UnnamedFunctionParamParserError,
 } = require('./errors');
+
 const invariant = require('invariant');
 
 function wrapModuleSchema(
@@ -259,6 +267,141 @@ function translateDefault(
   );
 }
 
+function getTypeAnnotationParameters(
+  typeAnnotation: $FlowFixMe,
+  language: ParserType,
+): $ReadOnlyArray<$FlowFixMe> {
+  return language === 'Flow'
+    ? typeAnnotation.params
+    : typeAnnotation.parameters;
+}
+
+function getFunctionNameFromParameter(
+  param: NamedShape<Nullable<NativeModuleParamTypeAnnotation>>,
+  language: ParserType,
+): $FlowFixMe {
+  return language === 'Flow' ? param.name : param.typeAnnotation;
+}
+
+function getParameterName(param: $FlowFixMe, language: ParserType): string {
+  return language === 'Flow' ? param.name.name : param.name;
+}
+
+function getParameterTypeAnnotation(
+  param: $FlowFixMe,
+  language: ParserType,
+): $FlowFixMe {
+  return language === 'Flow'
+    ? param.typeAnnotation
+    : param.typeAnnotation.typeAnnotation;
+}
+
+function getTypeAnnotationReturnType(
+  typeAnnotation: $FlowFixMe,
+  language: ParserType,
+): $FlowFixMe {
+  return language === 'Flow'
+    ? typeAnnotation.returnType
+    : typeAnnotation.typeAnnotation.typeAnnotation;
+}
+
+function translateFunctionTypeAnnotation(
+  hasteModuleName: string,
+  // TODO(T108222691): Use flow-types for @babel/parser
+  // TODO(T71778680): This is a FunctionTypeAnnotation. Type this.
+  typeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+  aliasMap: {...NativeModuleAliasMap},
+  tryParse: ParserErrorCapturer,
+  cxxOnly: boolean,
+  translateTypeAnnotation: $FlowFixMe,
+  language: ParserType,
+): NativeModuleFunctionTypeAnnotation {
+  type Param = NamedShape<Nullable<NativeModuleParamTypeAnnotation>>;
+  const params: Array<Param> = [];
+
+  for (const param of getTypeAnnotationParameters(typeAnnotation, language)) {
+    const parsedParam = tryParse(() => {
+      if (getFunctionNameFromParameter(param, language) == null) {
+        throw new UnnamedFunctionParamParserError(
+          param,
+          hasteModuleName,
+          language,
+        );
+      }
+
+      const paramName = getParameterName(param, language);
+
+      const [paramTypeAnnotation, isParamTypeAnnotationNullable] =
+        unwrapNullable<$FlowFixMe>(
+          translateTypeAnnotation(
+            hasteModuleName,
+            getParameterTypeAnnotation(param, language),
+            types,
+            aliasMap,
+            tryParse,
+            cxxOnly,
+          ),
+        );
+
+      if (
+        paramTypeAnnotation.type === 'VoidTypeAnnotation' ||
+        paramTypeAnnotation.type === 'PromiseTypeAnnotation'
+      ) {
+        return throwIfUnsupportedFunctionParamTypeAnnotationParserError(
+          hasteModuleName,
+          param.typeAnnotation,
+          paramName,
+          paramTypeAnnotation.type,
+        );
+      }
+
+      return {
+        name: paramName,
+        optional: Boolean(param.optional),
+        typeAnnotation: wrapNullable(
+          isParamTypeAnnotationNullable,
+          paramTypeAnnotation,
+        ),
+      };
+    });
+
+    if (parsedParam != null) {
+      params.push(parsedParam);
+    }
+  }
+
+  const [returnTypeAnnotation, isReturnTypeAnnotationNullable] =
+    unwrapNullable<$FlowFixMe>(
+      translateTypeAnnotation(
+        hasteModuleName,
+        getTypeAnnotationReturnType(typeAnnotation, language),
+        types,
+        aliasMap,
+        tryParse,
+        cxxOnly,
+      ),
+    );
+
+  throwIfUnsupportedFunctionReturnTypeAnnotationParserError(
+    hasteModuleName,
+    typeAnnotation,
+    'FunctionTypeAnnotation',
+    language,
+    cxxOnly,
+    returnTypeAnnotation.type,
+  );
+
+  return {
+    type: 'FunctionTypeAnnotation',
+    returnTypeAnnotation: wrapNullable(
+      isReturnTypeAnnotationNullable,
+      returnTypeAnnotation,
+    ),
+    params,
+  };
+}
+
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
@@ -268,4 +411,5 @@ module.exports = {
   parseObjectProperty,
   emitUnionTypeAnnotation,
   translateDefault,
+  translateFunctionTypeAnnotation,
 };

packages/react-native-codegen/src/parsers/parsers-primitives.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow strict-local
+ * @flow strict
  * @format
  */
 
@@ -14,15 +14,13 @@ import type {
   BooleanTypeAnnotation,
   DoubleTypeAnnotation,
   Int32TypeAnnotation,
-  NamedShape,
   NativeModuleAliasMap,
   NativeModuleBaseTypeAnnotation,
   NativeModuleFloatTypeAnnotation,
   NativeModuleFunctionTypeAnnotation,
   NativeModuleGenericObjectTypeAnnotation,
   NativeModuleMixedTypeAnnotation,
   NativeModuleNumberTypeAnnotation,
-  NativeModuleParamTypeAnnotation,
   NativeModulePromiseTypeAnnotation,
   NativeModuleTypeAliasTypeAnnotation,
   Nullable,
@@ -39,15 +37,10 @@ import type {
   TypeDeclarationMap,
 } from './utils';
 
-const {
-  throwIfUnsupportedFunctionParamTypeAnnotationParserError,
-  throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
-} = require('./error-utils');
-const {UnnamedFunctionParamParserError} = require('./errors');
 const {
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
-  unwrapNullable,
   wrapNullable,
+  translateFunctionTypeAnnotation,
 } = require('./parsers-commons');
 
 function emitBoolean(nullable: boolean): Nullable<BooleanTypeAnnotation> {
@@ -221,138 +214,6 @@ function emitFloat(
   });
 }
 
-function getTypeAnnotationParameters(
-  typeAnnotation: $FlowFixMe,
-  language: ParserType,
-): $ReadOnlyArray<$FlowFixMe> {
-  return language === 'Flow'
-    ? typeAnnotation.params
-    : typeAnnotation.parameters;
-}
-
-function getFunctionNameFromParameter(
-  param: NamedShape<Nullable<NativeModuleParamTypeAnnotation>>,
-  language: ParserType,
-) {
-  return language === 'Flow' ? param.name : param.typeAnnotation;
-}
-
-function getParameterName(param: $FlowFixMe, language: ParserType): string {
-  return language === 'Flow' ? param.name.name : param.name;
-}
-
-function getParameterTypeAnnotation(param: $FlowFixMe, language: ParserType) {
-  return language === 'Flow'
-    ? param.typeAnnotation
-    : param.typeAnnotation.typeAnnotation;
-}
-
-function getTypeAnnotationReturnType(
-  typeAnnotation: $FlowFixMe,
-  language: ParserType,
-) {
-  return language === 'Flow'
-    ? typeAnnotation.returnType
-    : typeAnnotation.typeAnnotation.typeAnnotation;
-}
-
-function translateFunctionTypeAnnotation(
-  hasteModuleName: string,
-  // TODO(T108222691): Use flow-types for @babel/parser
-  // TODO(T71778680): This is a FunctionTypeAnnotation. Type this.
-  typeAnnotation: $FlowFixMe,
-  types: TypeDeclarationMap,
-  aliasMap: {...NativeModuleAliasMap},
-  tryParse: ParserErrorCapturer,
-  cxxOnly: boolean,
-  translateTypeAnnotation: $FlowFixMe,
-  language: ParserType,
-): NativeModuleFunctionTypeAnnotation {
-  type Param = NamedShape<Nullable<NativeModuleParamTypeAnnotation>>;
-  const params: Array<Param> = [];
-
-  for (const param of getTypeAnnotationParameters(typeAnnotation, language)) {
-    const parsedParam = tryParse(() => {
-      if (getFunctionNameFromParameter(param, language) == null) {
-        throw new UnnamedFunctionParamParserError(
-          param,
-          hasteModuleName,
-          language,
-        );
-      }
-
-      const paramName = getParameterName(param, language);
-
-      const [paramTypeAnnotation, isParamTypeAnnotationNullable] =
-        unwrapNullable<$FlowFixMe>(
-          translateTypeAnnotation(
-            hasteModuleName,
-            getParameterTypeAnnotation(param, language),
-            types,
-            aliasMap,
-            tryParse,
-            cxxOnly,
-          ),
-        );
-
-      if (
-        paramTypeAnnotation.type === 'VoidTypeAnnotation' ||
-        paramTypeAnnotation.type === 'PromiseTypeAnnotation'
-      ) {
-        return throwIfUnsupportedFunctionParamTypeAnnotationParserError(
-          hasteModuleName,
-          param.typeAnnotation,
-          paramName,
-          paramTypeAnnotation.type,
-        );
-      }
-
-      return {
-        name: paramName,
-        optional: Boolean(param.optional),
-        typeAnnotation: wrapNullable(
-          isParamTypeAnnotationNullable,
-          paramTypeAnnotation,
-        ),
-      };
-    });
-
-    if (parsedParam != null) {
-      params.push(parsedParam);
-    }
-  }
-
-  const [returnTypeAnnotation, isReturnTypeAnnotationNullable] =
-    unwrapNullable<$FlowFixMe>(
-      translateTypeAnnotation(
-        hasteModuleName,
-        getTypeAnnotationReturnType(typeAnnotation, language),
-        types,
-        aliasMap,
-        tryParse,
-        cxxOnly,
-      ),
-    );
-
-  throwIfUnsupportedFunctionReturnTypeAnnotationParserError(
-    hasteModuleName,
-    typeAnnotation,
-    'FunctionTypeAnnotation',
-    language,
-    cxxOnly,
-    returnTypeAnnotation.type,
-  );
-
-  return {
-    type: 'FunctionTypeAnnotation',
-    returnTypeAnnotation: wrapNullable(
-      isReturnTypeAnnotationNullable,
-      returnTypeAnnotation,
-    ),
-    params,
-  };
-}
-
 module.exports = {
   emitBoolean,
   emitDouble,
@@ -368,5 +229,4 @@ module.exports = {
   emitStringish,
   emitMixedTypeAnnotation,
   typeAliasResolution,
-  translateFunctionTypeAnnotation,
 };

packages/react-native-codegen/src/parsers/typescript/modules/index.js

@@ -32,6 +32,7 @@ const {
   parseObjectProperty,
   emitUnionTypeAnnotation,
   translateDefault,
+  translateFunctionTypeAnnotation,
 } = require('../../parsers-commons');
 const {
   emitBoolean,
@@ -48,7 +49,6 @@ const {
   emitStringish,
   emitMixedTypeAnnotation,
   typeAliasResolution,
-  translateFunctionTypeAnnotation,
 } = require('../../parsers-primitives');
 const {
   UnsupportedArrayElementTypeAnnotationParserError,