[Codegen 78 & 79]: Merge TS & Flow parsers' logic for Partial case to emitPartial fn & commonTypes cases into emitCommonTypes fn

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

@@ -28,6 +28,8 @@ const {
   emitString,
   emitStringish,
   emitMixed,
+  emitPartial,
+  emitCommonTypes,
   typeAliasResolution,
   typeEnumResolution,
   Visitor,
@@ -1253,3 +1255,243 @@ describe('Visitor', () => {
     });
   });
 });
+
+describe('emitPartial', () => {
+  const hasteModuleName = 'SampleTurboModule';
+  function emitPartialForUnitTest(
+    typeAnnotation: $FlowFixMe,
+    nullable: boolean,
+  ): $FlowFixMe {
+    return emitPartial(
+      hasteModuleName,
+      typeAnnotation,
+      /* types: TypeDeclarationMap */
+      {},
+      /* aliasMap: {...NativeModuleAliasMap} */
+      {},
+      /* enumMap: {...NativeModuleEnumMap} */
+      {},
+      /* tryParse: ParserErrorCapturer */
+      // $FlowFixMe[missing-local-annot]
+      function <T>(_: () => T) {
+        return null;
+      },
+      /* cxxOnly: boolean */
+      false,
+      nullable,
+      parser,
+    );
+  }
+
+  describe("when 'typeAnnotation' doesn't have exactly 'one' typeParameter", () => {
+    const nullable = false;
+    const typeAnnotation = {
+      typeParameters: {
+        params: [1, 2],
+        type: 'TypeParameterInstantiation',
+      },
+      id: {
+        name: 'typeAnnotationName',
+      },
+    };
+
+    it('throws an error', () => {
+      expect(() => emitPartialForUnitTest(typeAnnotation, nullable)).toThrow(
+        'Partials only support annotating exactly one parameter.',
+      );
+    });
+  });
+
+  describe('when Partial Not annotating type parameter', () => {
+    const nullable = false;
+    const typeAnnotation = {
+      typeParameters: {
+        params: [
+          {
+            id: {
+              name: 'TypeDeclaration',
+            },
+          },
+        ],
+      },
+      id: {
+        name: 'typeAnnotationName',
+      },
+    };
+
+    it('throws an error', () => {
+      expect(() => emitPartialForUnitTest(typeAnnotation, nullable)).toThrow(
+        'Partials only support annotating a type parameter.',
+      );
+    });
+  });
+});
+
+describe('emitCommonTypes', () => {
+  const hasteModuleName = 'SampleTurboModule';
+
+  function emitCommonTypesForUnitTest(
+    typeAnnotation: $FlowFixMe,
+    nullable: boolean,
+  ): $FlowFixMe {
+    return emitCommonTypes(
+      hasteModuleName,
+      /* types: TypeDeclarationMap */
+      {},
+      typeAnnotation,
+      /* aliasMap: {...NativeModuleAliasMap} */
+      {},
+      /* enumMap: {...NativeModuleEnumMap} */
+      {},
+      /* tryParse: ParserErrorCapturer */
+      // $FlowFixMe[missing-local-annot]
+      function <T>(_: () => T) {
+        return null;
+      },
+      /* cxxOnly: boolean */
+      false,
+      nullable,
+      parser,
+    );
+  }
+
+  describe("when 'typeAnnotation.id.name' is 'Stringish'", () => {
+    const typeAnnotation = {
+      typeParameters: {
+        params: [1, 2],
+        type: 'StringTypeAnnotation',
+      },
+      id: {
+        name: 'Stringish',
+      },
+    };
+    const expected = {
+      type: 'StringTypeAnnotation',
+    };
+    const result = emitCommonTypesForUnitTest(typeAnnotation, false);
+
+    it("returns 'StringTypeAnnotation'", () => {
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe("when 'typeAnnotation.id.name' is 'Int32'", () => {
+    const typeAnnotation = {
+      typeParameters: {
+        params: [1, 2],
+        type: 'Int32TypeAnnotation',
+      },
+      id: {
+        name: 'Int32',
+      },
+    };
+    const expected = {
+      type: 'Int32TypeAnnotation',
+    };
+    const result = emitCommonTypesForUnitTest(typeAnnotation, false);
+
+    it("returns 'Int32TypeAnnotation'", () => {
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe("when 'typeAnnotation.id.name' is 'Double'", () => {
+    const typeAnnotation = {
+      typeParameters: {
+        params: [1, 2],
+        type: 'DoubleTypeAnnotation',
+      },
+      id: {
+        name: 'Double',
+      },
+    };
+    const expected = {
+      type: 'DoubleTypeAnnotation',
+    };
+    const result = emitCommonTypesForUnitTest(typeAnnotation, false);
+
+    it("returns 'DoubleTypeAnnotation'", () => {
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe("when 'typeAnnotation.id.name' is 'Float'", () => {
+    const typeAnnotation = {
+      typeParameters: {
+        params: [1, 2],
+        type: 'FloatTypeAnnotation',
+      },
+      id: {
+        name: 'Float',
+      },
+    };
+    const expected = {
+      type: 'FloatTypeAnnotation',
+    };
+    const result = emitCommonTypesForUnitTest(typeAnnotation, false);
+
+    it("returns 'FloatTypeAnnotation'", () => {
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe("when 'typeAnnotation.id.name' is 'UnsafeObject'", () => {
+    const typeAnnotation = {
+      typeParameters: {
+        params: [1, 2],
+        type: 'GenericObjectTypeAnnotation',
+      },
+      id: {
+        name: 'UnsafeObject',
+      },
+    };
+    const expected = {
+      type: 'GenericObjectTypeAnnotation',
+    };
+    const result = emitCommonTypesForUnitTest(typeAnnotation, false);
+
+    it("returns 'GenericObjectTypeAnnotation'", () => {
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe("when 'typeAnnotation.id.name' is 'Object'", () => {
+    const typeAnnotation = {
+      typeParameters: {
+        params: [1, 2],
+        type: 'GenericObjectTypeAnnotation',
+      },
+      id: {
+        name: 'Object',
+      },
+    };
+    const expected = {
+      type: 'GenericObjectTypeAnnotation',
+    };
+    const result = emitCommonTypesForUnitTest(typeAnnotation, false);
+
+    it("returns 'GenericObjectTypeAnnotation'", () => {
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe("when 'typeAnnotation.id.name' is '$Partial' i.e. Object", () => {
+    const typeAnnotation = {
+      typeParameters: {
+        params: [1],
+        type: 'GenericObjectTypeAnnotation',
+      },
+      id: {
+        name: 'Object',
+      },
+    };
+    const expected = {
+      type: 'GenericObjectTypeAnnotation',
+    };
+    const result = emitCommonTypesForUnitTest(typeAnnotation, false);
+
+    it("returns 'GenericObjectTypeAnnotation'", () => {
+      expect(result).toEqual(expected);
+    });
+  });
+});

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

@@ -32,20 +32,16 @@ const {
 const {
   emitArrayType,
   emitBoolean,
-  emitDouble,
-  emitFloat,
   emitFunction,
   emitNumber,
-  emitInt32,
   emitGenericObject,
-  emitObject,
   emitPromise,
   emitRootTag,
   emitVoid,
   emitString,
-  emitStringish,
   emitMixed,
   emitUnion,
+  emitCommonTypes,
   typeAliasResolution,
   typeEnumResolution,
 } = require('../../parsers-primitives');
@@ -55,11 +51,6 @@ const {
   UnsupportedGenericParserError,
 } = require('../../errors');
 
-const {
-  throwIfPartialNotAnnotatingTypeParameter,
-  throwIfPartialWithMoreParameter,
-} = require('../../error-utils');
-
 function translateTypeAnnotation(
   hasteModuleName: string,
   /**
@@ -132,55 +123,27 @@ function translateTypeAnnotation(
 
           return wrapNullable(nullable || isParamNullable, paramType);
         }
-        case 'Stringish': {
-          return emitStringish(nullable);
-        }
-        case 'Int32': {
-          return emitInt32(nullable);
-        }
-        case 'Double': {
-          return emitDouble(nullable);
-        }
-        case 'Float': {
-          return emitFloat(nullable);
-        }
-        case 'UnsafeObject':
-        case 'Object': {
-          return emitGenericObject(nullable);
-        }
-        case 'Partial':
-        case '$Partial': {
-          throwIfPartialWithMoreParameter(typeAnnotation);
-
-          const annotatedElement = parser.extractAnnotatedElement(
-            typeAnnotation,
-            types,
-          );
-
-          throwIfPartialNotAnnotatingTypeParameter(
-            typeAnnotation,
-            types,
-            parser,
-          );
-
-          const properties = parser.computePartialProperties(
-            annotatedElement.right.properties,
+        default: {
+          const commonType = emitCommonTypes(
             hasteModuleName,
             types,
+            typeAnnotation,
             aliasMap,
             enumMap,
             tryParse,
             cxxOnly,
-          );
-
-          return emitObject(nullable, properties);
-        }
-        default: {
-          throw new UnsupportedGenericParserError(
-            hasteModuleName,
-            typeAnnotation,
+            nullable,
             parser,
           );
+
+          if (!commonType) {
+            throw new UnsupportedGenericParserError(
+              hasteModuleName,
+              typeAnnotation,
+              parser,
+            );
+          }
+          return commonType;
         }
       }
     }

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

@@ -313,6 +313,10 @@ class FlowParser implements Parser {
       componentName: funcArgumentParams[0].value,
     };
   }
+
+  getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe {
+    return annotatedElement.right.properties;
+  }
 }
 
 module.exports = {

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

@@ -229,4 +229,11 @@ export interface Parser {
     typeArgumentParams: $FlowFixMe,
     funcArgumentParams: $FlowFixMe,
   ): {[string]: string};
+
+  /**
+   * Given a annotatedElement, it returns the properties of annotated element.
+   * @parameter annotatedElement: the annotated element.
+   * @returns: the properties of annotated element.
+   */
+  getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe;
 }

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

@@ -227,4 +227,8 @@ export class MockedParser implements Parser {
       componentName: funcArgumentParams[0].value,
     };
   }
+
+  getAnnotatedElementProperties(annotatedElement: $FlowFixMe): $FlowFixMe {
+    return annotatedElement.right.properties;
+  }
 }