♻️ (codegen) extract assertGenericTypeAnnotationHasExactlyOneTypeParameter to parsers-commons

Author: Antoine Doubovetzky

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

@@ -11,6 +11,9 @@
 
 'use-strict';
 
+import {IncorrectlyParameterizedGenericParserError} from '../errors';
+import {assertGenericTypeAnnotationHasExactlyOneTypeParameter} from '../parsers-commons';
+
 const {wrapNullable, unwrapNullable} = require('../parsers-commons.js');
 
 describe('wrapNullable', () => {
@@ -78,3 +81,94 @@ describe('unwrapNullable', () => {
     });
   });
 });
+
+describe('assertGenericTypeAnnotationHasExactlyOneTypeParameter', () => {
+  it('throws an IncorrectlyParameterizedGenericParserError if typeParameters is null', () => {
+    const moduleName = 'testModuleName';
+    const typeAnnotation = {
+      typeParameters: null,
+      id: {
+        name: 'typeAnnotationName',
+      },
+    };
+    expect(() =>
+      assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+        moduleName,
+        typeAnnotation,
+        'Flow',
+      ),
+    ).toThrow(IncorrectlyParameterizedGenericParserError);
+  });
+
+  it("throws an error if typeAnnotation.typeParameters.type doesn't have the correct value depending on language", () => {
+    const moduleName = 'testModuleName';
+    const flowTypeAnnotation = {
+      typeParameters: {
+        type: 'TypeParameterInstantiation',
+      },
+      id: {
+        name: 'typeAnnotationName',
+      },
+    };
+    expect(() =>
+      assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+        moduleName,
+        flowTypeAnnotation,
+        'Flow',
+      ),
+    ).toThrow(Error);
+
+    const typeScriptTypeAnnotation = {
+      typeParameters: {
+        type: 'TypeParameterInstantiation',
+      },
+      typeName: {
+        name: 'typeAnnotationName',
+      },
+    };
+    expect(() =>
+      assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+        moduleName,
+        typeScriptTypeAnnotation,
+        'TypeScript',
+      ),
+    ).toThrow(Error);
+  });
+
+  it("throws an IncorrectlyParameterizedGenericParserError if typeParameters don't have 1 exactly parameter", () => {
+    const moduleName = 'testModuleName';
+    const typeAnnotationWithTwoParams = {
+      typeParameters: {
+        params: [1, 2],
+        type: 'TypeParameterInstantiation',
+      },
+      id: {
+        name: 'typeAnnotationName',
+      },
+    };
+    expect(() =>
+      assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+        moduleName,
+        typeAnnotationWithTwoParams,
+        'Flow',
+      ),
+    ).toThrow(IncorrectlyParameterizedGenericParserError);
+
+    const typeAnnotationWithNoParams = {
+      typeParameters: {
+        params: [],
+        type: 'TypeParameterInstantiation',
+      },
+      id: {
+        name: 'typeAnnotationName',
+      },
+    };
+    expect(() =>
+      assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+        moduleName,
+        typeAnnotationWithNoParams,
+        'Flow',
+      ),
+    ).toThrow(IncorrectlyParameterizedGenericParserError);
+  });
+});

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

@@ -4,15 +4,15 @@
  * 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
  */
 
 'use strict';
 
 const invariant = require('invariant');
 
-type ParserType = 'Flow' | 'TypeScript';
+export type ParserType = 'Flow' | 'TypeScript';
 
 class ParserError extends Error {
   nodes: $ReadOnlyArray<$FlowFixMe>;

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

@@ -32,7 +32,11 @@ const {
   visit,
   isModuleRegistryCall,
 } = require('../utils.js');
-const {unwrapNullable, wrapNullable} = require('../../parsers-commons');
+const {
+  unwrapNullable,
+  wrapNullable,
+  assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+} = require('../../parsers-commons');
 const {
   emitBoolean,
   emitDouble,
@@ -42,7 +46,6 @@ const {
   typeAliasResolution,
 } = require('../../parsers-primitives');
 const {
-  IncorrectlyParameterizedGenericParserError,
   MisnamedModuleInterfaceParserError,
   ModuleInterfaceNotFoundParserError,
   MoreThanOneModuleInterfaceParserError,
@@ -96,6 +99,7 @@ function translateTypeAnnotation(
           assertGenericTypeAnnotationHasExactlyOneTypeParameter(
             hasteModuleName,
             typeAnnotation,
+            language,
           );
 
           return wrapNullable(nullable, {
@@ -107,6 +111,7 @@ function translateTypeAnnotation(
           assertGenericTypeAnnotationHasExactlyOneTypeParameter(
             hasteModuleName,
             typeAnnotation,
+            language,
           );
 
           try {
@@ -182,6 +187,7 @@ function translateTypeAnnotation(
           assertGenericTypeAnnotationHasExactlyOneTypeParameter(
             hasteModuleName,
             typeAnnotation,
+            language,
           );
 
           const [paramType, isParamNullable] = unwrapNullable(
@@ -411,35 +417,6 @@ function translateTypeAnnotation(
   }
 }
 
-function assertGenericTypeAnnotationHasExactlyOneTypeParameter(
-  moduleName: string,
-  /**
-   * TODO(T71778680): This is a GenericTypeAnnotation. Flow type this node
-   */
-  typeAnnotation: $FlowFixMe,
-) {
-  if (typeAnnotation.typeParameters == null) {
-    throw new IncorrectlyParameterizedGenericParserError(
-      moduleName,
-      typeAnnotation,
-      language,
-    );
-  }
-
-  invariant(
-    typeAnnotation.typeParameters.type === 'TypeParameterInstantiation',
-    "assertGenericTypeAnnotationHasExactlyOneTypeParameter: Type parameters must be an AST node of type 'TypeParameterInstantiation'",
-  );
-
-  if (typeAnnotation.typeParameters.params.length !== 1) {
-    throw new IncorrectlyParameterizedGenericParserError(
-      moduleName,
-      typeAnnotation,
-      language,
-    );
-  }
-}
-
 function translateFunctionTypeAnnotation(
   hasteModuleName: string,
   // TODO(T71778680): This is a FunctionTypeAnnotation. Type this.

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

@@ -16,6 +16,10 @@ import type {
   NativeModuleTypeAnnotation,
   Nullable,
 } from '../CodegenSchema.js';
+import {IncorrectlyParameterizedGenericParserError} from './errors';
+import type {ParserType} from './errors';
+
+const invariant = require('invariant');
 
 function wrapModuleSchema(
   nativeModuleSchema: NativeModuleSchema,
@@ -52,8 +56,44 @@ function wrapNullable<+T: NativeModuleTypeAnnotation>(
   };
 }
 
+function assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+  moduleName: string,
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  typeAnnotation: $FlowFixMe,
+  language: ParserType,
+) {
+  if (typeAnnotation.typeParameters == null) {
+    throw new IncorrectlyParameterizedGenericParserError(
+      moduleName,
+      typeAnnotation,
+      language,
+    );
+  }
+
+  const typeAnnotationType =
+    language === 'TypeScript'
+      ? 'TSTypeParameterInstantiation'
+      : 'TypeParameterInstantiation';
+
+  invariant(
+    typeAnnotation.typeParameters.type === typeAnnotationType,
+    `assertGenericTypeAnnotationHasExactlyOneTypeParameter: Type parameters must be an AST node of type '${typeAnnotationType}'`,
+  );
+
+  if (typeAnnotation.typeParameters.params.length !== 1) {
+    throw new IncorrectlyParameterizedGenericParserError(
+      moduleName,
+      typeAnnotation,
+      language,
+    );
+  }
+}
+
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
   wrapNullable,
+  assertGenericTypeAnnotationHasExactlyOneTypeParameter,
 };

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

@@ -32,7 +32,11 @@ const {
   visit,
   isModuleRegistryCall,
 } = require('../utils.js');
-const {unwrapNullable, wrapNullable} = require('../../parsers-commons');
+const {
+  unwrapNullable,
+  wrapNullable,
+  assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+} = require('../../parsers-commons');
 const {
   emitBoolean,
   emitDouble,
@@ -42,7 +46,6 @@ const {
   typeAliasResolution,
 } = require('../../parsers-primitives');
 const {
-  IncorrectlyParameterizedGenericParserError,
   MisnamedModuleInterfaceParserError,
   ModuleInterfaceNotFoundParserError,
   MoreThanOneModuleInterfaceParserError,
@@ -65,7 +68,6 @@ const {
   IncorrectModuleRegistryCallArgumentTypeParserError,
 } = require('../../errors.js');
 
-const invariant = require('invariant');
 const language = 'TypeScript';
 
 function nullGuard<T>(fn: () => T): ?T {
@@ -208,6 +210,7 @@ function translateTypeAnnotation(
           assertGenericTypeAnnotationHasExactlyOneTypeParameter(
             hasteModuleName,
             typeAnnotation,
+            language,
           );
 
           return wrapNullable(nullable, {
@@ -219,6 +222,7 @@ function translateTypeAnnotation(
           assertGenericTypeAnnotationHasExactlyOneTypeParameter(
             hasteModuleName,
             typeAnnotation,
+            language,
           );
 
           return translateArrayTypeAnnotation(
@@ -447,35 +451,6 @@ function translateTypeAnnotation(
   }
 }
 
-function assertGenericTypeAnnotationHasExactlyOneTypeParameter(
-  moduleName: string,
-  /**
-   * TODO(T108222691): Use flow-types for @babel/parser
-   */
-  typeAnnotation: $FlowFixMe,
-) {
-  if (typeAnnotation.typeParameters == null) {
-    throw new IncorrectlyParameterizedGenericParserError(
-      moduleName,
-      typeAnnotation,
-      language,
-    );
-  }
-
-  invariant(
-    typeAnnotation.typeParameters.type === 'TSTypeParameterInstantiation',
-    "assertGenericTypeAnnotationHasExactlyOneTypeParameter: Type parameters must be an AST node of type 'TSTypeParameterInstantiation'",
-  );
-
-  if (typeAnnotation.typeParameters.params.length !== 1) {
-    throw new IncorrectlyParameterizedGenericParserError(
-      moduleName,
-      typeAnnotation,
-      language,
-    );
-  }
-}
-
 function translateFunctionTypeAnnotation(
   hasteModuleName: string,
   // TODO(T108222691): Use flow-types for @babel/parser