codegen: add handleGenericTypeAnnotation in parser-commons

Author: tarunrajput

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

@@ -25,6 +25,8 @@ import {
   getCommandOptions,
   getOptions,
   getCommandTypeNameAndOptionsExpression,
+  getTypeResolutionStatus,
+  handleGenericTypeAnnotation,
 } from '../parsers-commons';
 import type {ParserType} from '../errors';
 
@@ -1544,3 +1546,120 @@ describe('getCommandTypeNameAndOptionsExpression', () => {
     });
   });
 });
+
+describe('getTypeResolutionStatus', () => {
+  it('returns type resolution status for a type declaration', () => {
+    const typeAnnotation = {
+      id: {
+        name: 'TypeAnnotationName',
+      },
+    };
+    expect(
+      getTypeResolutionStatus('alias', typeAnnotation, flowParser),
+    ).toEqual({
+      successful: true,
+      type: 'alias',
+      name: 'TypeAnnotationName',
+    });
+  });
+
+  it('returns type resolution status for an enum declaration', () => {
+    const typeAnnotation = {
+      id: {
+        name: 'TypeAnnotationName',
+      },
+    };
+    expect(getTypeResolutionStatus('enum', typeAnnotation, flowParser)).toEqual(
+      {
+        successful: true,
+        type: 'enum',
+        name: 'TypeAnnotationName',
+      },
+    );
+  });
+});
+
+describe('handleGenericTypeAnnotation', () => {
+  it('returns when TypeAnnotation is a type declaration', () => {
+    const typeAnnotation = {
+      id: {
+        name: 'TypeAnnotationName',
+      },
+    };
+    const resolvedTypeAnnotation = {
+      type: 'TypeAlias',
+      right: {
+        type: 'TypeAnnotation',
+      },
+    };
+    expect(
+      handleGenericTypeAnnotation(
+        typeAnnotation,
+        resolvedTypeAnnotation,
+        flowParser,
+      ),
+    ).toEqual({
+      typeAnnotation: {
+        type: 'TypeAnnotation',
+      },
+      typeResolutionStatus: {
+        successful: true,
+        type: 'alias',
+        name: 'TypeAnnotationName',
+      },
+    });
+  });
+
+  it('returns when TypeAnnotation is an enum declaration', () => {
+    const typeAnnotation = {
+      id: {
+        name: 'TypeAnnotationName',
+      },
+    };
+    const resolvedTypeAnnotation = {
+      type: 'EnumDeclaration',
+      body: {
+        type: 'TypeAnnotation',
+      },
+    };
+    expect(
+      handleGenericTypeAnnotation(
+        typeAnnotation,
+        resolvedTypeAnnotation,
+        flowParser,
+      ),
+    ).toEqual({
+      typeAnnotation: {
+        type: 'TypeAnnotation',
+      },
+      typeResolutionStatus: {
+        successful: true,
+        type: 'enum',
+        name: 'TypeAnnotationName',
+      },
+    });
+  });
+
+  it('throws when the non GenericTypeAnnotation is unsupported', () => {
+    const typeAnnotation = {
+      type: 'UnsupportedTypeAnnotation',
+      id: {
+        name: 'UnsupportedType',
+      },
+    };
+    const resolvedTypeAnnotation = {
+      type: 'UnsupportedTypeAnnotation',
+    };
+    expect(() =>
+      handleGenericTypeAnnotation(
+        typeAnnotation,
+        resolvedTypeAnnotation,
+        flowParser,
+      ),
+    ).toThrow(
+      new Error(
+        `A non GenericTypeAnnotation must be a type declaration ('${flowParser.typeAlias}') or enum ('${flowParser.enumDeclaration}'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
+      ),
+    );
+  });
+});

packages/react-native-codegen/src/parsers/flow/parser.js

@@ -47,11 +47,14 @@ const {flowTranslateTypeAnnotation} = require('./modules');
 // $FlowFixMe[untyped-import] there's no flowtype flow-parser
 const flowParser = require('flow-parser');
 
-const {buildSchema} = require('../parsers-commons');
+const {
+  buildSchema,
+  buildModuleSchema,
+  handleGenericTypeAnnotation,
+} = require('../parsers-commons');
 const {Visitor} = require('../parsers-primitives');
 const {buildComponentSchema} = require('./components');
 const {wrapComponentSchema} = require('../schema.js');
-const {buildModuleSchema} = require('../parsers-commons.js');
 
 const fs = require('fs');
 
@@ -402,36 +405,16 @@ class FlowParser implements Parser {
         break;
       }
 
-      const resolvedTypeAnnotation = types[node.id.name];
+      const typeAnnotationName = this.nameForGenericTypeAnnotation(node);
+      const resolvedTypeAnnotation = types[typeAnnotationName];
       if (resolvedTypeAnnotation == null) {
         break;
       }
 
-      switch (resolvedTypeAnnotation.type) {
-        case parser.typeAlias: {
-          typeResolutionStatus = {
-            successful: true,
-            type: 'alias',
-            name: node.id.name,
-          };
-          node = resolvedTypeAnnotation.right;
-          break;
-        }
-        case parser.enumDeclaration: {
-          typeResolutionStatus = {
-            successful: true,
-            type: 'enum',
-            name: node.id.name,
-          };
-          node = resolvedTypeAnnotation.body;
-          break;
-        }
-        default: {
-          throw new TypeError(
-            `A non GenericTypeAnnotation must be a type declaration ('${parser.typeAlias}') or enum ('${parser.enumDeclaration}'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
-          );
-        }
-      }
+      const {typeAnnotation: typeAnnotationNode, typeResolutionStatus: status} =
+        handleGenericTypeAnnotation(node, resolvedTypeAnnotation, this);
+      typeResolutionStatus = status;
+      node = typeAnnotationNode;
     }
 
     return {

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

@@ -30,7 +30,12 @@ import type {
 
 import type {Parser} from './parser';
 import type {ParserType} from './errors';
-import type {ParserErrorCapturer, TypeDeclarationMap, PropAST} from './utils';
+import type {
+  ParserErrorCapturer,
+  TypeDeclarationMap,
+  PropAST,
+  TypeResolutionStatus,
+} from './utils';
 import type {ComponentSchemaBuilderConfig} from './schema.js';
 
 const {
@@ -898,6 +903,79 @@ function getEventArgument(
   };
 }
 
+function getTypeResolutionStatus(
+  type: 'alias' | 'enum',
+  typeAnnotation: $FlowFixMe,
+  parser: Parser,
+): TypeResolutionStatus {
+  return {
+    successful: true,
+    type,
+    name: parser.nameForGenericTypeAnnotation(typeAnnotation),
+  };
+}
+
+function handleGenericTypeAnnotation(
+  typeAnnotation: $FlowFixMe,
+  resolvedTypeAnnotation: TypeDeclarationMap,
+  parser: Parser,
+): {
+  typeAnnotation: $FlowFixMe,
+  typeResolutionStatus: TypeResolutionStatus,
+} {
+  const parserType = parser.language();
+  let typeResolutionStatus;
+  let node;
+
+  switch (resolvedTypeAnnotation.type) {
+    case parser.typeAlias: {
+      typeResolutionStatus = getTypeResolutionStatus(
+        'alias',
+        typeAnnotation,
+        parser,
+      );
+      node =
+        parserType === 'Flow'
+          ? resolvedTypeAnnotation.right
+          : resolvedTypeAnnotation.typeAnnotation;
+      break;
+    }
+    case parser.enumDeclaration: {
+      typeResolutionStatus = getTypeResolutionStatus(
+        'enum',
+        typeAnnotation,
+        parser,
+      );
+      node =
+        parserType === 'Flow'
+          ? resolvedTypeAnnotation.body
+          : resolvedTypeAnnotation;
+      break;
+    }
+    case 'TSInterfaceDeclaration': {
+      typeResolutionStatus = getTypeResolutionStatus(
+        'alias',
+        typeAnnotation,
+        parser,
+      );
+      node = resolvedTypeAnnotation;
+      break;
+    }
+    default: {
+      const errorMsg =
+        parserType === 'Flow'
+          ? `A non GenericTypeAnnotation must be a type declaration ('${parser.typeAlias}') or enum ('${parser.enumDeclaration}'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`
+          : `A non GenericTypeAnnotation must be a type declaration ('${parser.typeAlias}'), an interface ('${parser.interfaceDeclaration}'), or enum ('${parser.enumDeclaration}'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`;
+      throw new TypeError(errorMsg);
+    }
+  }
+
+  return {
+    typeAnnotation: node,
+    typeResolutionStatus,
+  };
+}
+
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
@@ -920,4 +998,6 @@ module.exports = {
   extendsForProp,
   buildPropSchema,
   getEventArgument,
+  handleGenericTypeAnnotation,
+  getTypeResolutionStatus,
 };

packages/react-native-codegen/src/parsers/typescript/parser.js

@@ -45,7 +45,10 @@ const {buildSchema} = require('../parsers-commons');
 const {Visitor} = require('../parsers-primitives');
 const {buildComponentSchema} = require('./components');
 const {wrapComponentSchema} = require('../schema.js');
-const {buildModuleSchema} = require('../parsers-commons.js');
+const {
+  buildModuleSchema,
+  handleGenericTypeAnnotation,
+} = require('../parsers-commons.js');
 const {parseTopLevelType} = require('./parseTopLevelType');
 const {
   getSchemaInfo,
@@ -400,45 +403,16 @@ class TypeScriptParser implements Parser {
         break;
       }
 
-      const resolvedTypeAnnotation = types[node.typeName.name];
+      const typeAnnotationName = this.nameForGenericTypeAnnotation(node);
+      const resolvedTypeAnnotation = types[typeAnnotationName];
       if (resolvedTypeAnnotation == null) {
         break;
       }
 
-      switch (resolvedTypeAnnotation.type) {
-        case parser.typeAlias: {
-          typeResolutionStatus = {
-            successful: true,
-            type: 'alias',
-            name: node.typeName.name,
-          };
-          node = resolvedTypeAnnotation.typeAnnotation;
-          break;
-        }
-        case parser.interfaceDeclaration: {
-          typeResolutionStatus = {
-            successful: true,
-            type: 'alias',
-            name: node.typeName.name,
-          };
-          node = resolvedTypeAnnotation;
-          break;
-        }
-        case parser.enumDeclaration: {
-          typeResolutionStatus = {
-            successful: true,
-            type: 'enum',
-            name: node.typeName.name,
-          };
-          node = resolvedTypeAnnotation;
-          break;
-        }
-        default: {
-          throw new TypeError(
-            `A non GenericTypeAnnotation must be a type declaration ('${parser.typeAlias}'), an interface ('${parser.interfaceDeclaration}'), or enum ('${parser.enumDeclaration}'). Instead, got the unsupported ${resolvedTypeAnnotation.type}.`,
-          );
-        }
-      }
+      const {typeAnnotation: typeAnnotationNode, typeResolutionStatus: status} =
+        handleGenericTypeAnnotation(node, resolvedTypeAnnotation, this);
+      typeResolutionStatus = status;
+      node = typeAnnotationNode;
     }
 
     return {