chore: Expand Codegen emitCommonTypes function adding the remaining basic types (#36706)

Summary:
[Codegen 81] This PR expands the  `emitCommonTypes` function adding support for the remaining basic types and adding
a `convertKeywordToTypeannotation` function to the codegen Parser class and implementing it in the Flow and TypeScript parsers as requested on #34872

## Changelog:

[Internal] [Added] - Expand Codegen emitCommonTypes function adding the remaining basic types

Pull Request resolved: #36706

Test Plan: Run `yarn jest react-native-codegen` and ensure CI is green

Reviewed By: christophpurrer

Differential Revision: D44504571

Pulled By: cipolleschi

fbshipit-source-id: 220d9bc0cc39614002a67dafd626e5a4878a1447

Author: gabrieldonadel

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

@@ -31,15 +31,10 @@ const {
 } = require('../../parsers-commons');
 const {
   emitArrayType,
-  emitBoolean,
   emitFunction,
-  emitNumber,
   emitGenericObject,
   emitPromise,
   emitRootTag,
-  emitVoid,
-  emitString,
-  emitMixed,
   emitUnion,
   emitCommonTypes,
   typeAliasResolution,
@@ -207,18 +202,6 @@ function translateTypeAnnotation(
         nullable,
       );
     }
-    case 'BooleanTypeAnnotation': {
-      return emitBoolean(nullable);
-    }
-    case 'NumberTypeAnnotation': {
-      return emitNumber(nullable);
-    }
-    case 'VoidTypeAnnotation': {
-      return emitVoid(nullable);
-    }
-    case 'StringTypeAnnotation': {
-      return emitString(nullable);
-    }
     case 'FunctionTypeAnnotation': {
       return emitFunction(
         nullable,
@@ -243,13 +226,6 @@ function translateTypeAnnotation(
         memberType: 'StringTypeAnnotation',
       });
     }
-    case 'MixedTypeAnnotation': {
-      if (cxxOnly) {
-        return emitMixed(nullable);
-      } else {
-        return emitGenericObject(nullable);
-      }
-    }
     case 'EnumStringBody':
     case 'EnumNumberBody': {
       return typeEnumResolution(
@@ -262,11 +238,26 @@ function translateTypeAnnotation(
       );
     }
     default: {
-      throw new UnsupportedTypeAnnotationParserError(
+      const commonType = emitCommonTypes(
         hasteModuleName,
+        types,
         typeAnnotation,
-        parser.language(),
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
       );
+
+      if (!commonType) {
+        throw new UnsupportedTypeAnnotationParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return commonType;
     }
   }
 }

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

@@ -67,7 +67,7 @@ class FlowParser implements Parser {
   }
 
   nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string {
-    return typeAnnotation.id.name;
+    return typeAnnotation?.id?.name;
   }
 
   checkIfInvalidModule(typeArguments: $FlowFixMe): boolean {
@@ -325,6 +325,10 @@ class FlowParser implements Parser {
   bodyProperties(typeAlias: $FlowFixMe): $ReadOnlyArray<$FlowFixMe> {
     return typeAlias.body.properties;
   }
+
+  convertKeywordToTypeAnnotation(keyword: string): string {
+    return keyword;
+  }
 }
 
 module.exports = {

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

@@ -248,4 +248,11 @@ export interface Parser {
    * @returns: an array of properties.
    */
   bodyProperties(typeAlias: $FlowFixMe): $ReadOnlyArray<$FlowFixMe>;
+
+  /**
+   * Given a keyword convert it to TypeAnnotation.
+   * @parameter keyword
+   * @returns: converted TypeAnnotation to Keywords
+   */
+  convertKeywordToTypeAnnotation(keyword: string): string;
 }

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

@@ -239,4 +239,8 @@ export class MockedParser implements Parser {
   bodyProperties(typeAlias: $FlowFixMe): $ReadOnlyArray<$FlowFixMe> {
     return typeAlias.body.properties;
   }
+
+  convertKeywordToTypeAnnotation(keyword: string): string {
+    return keyword;
+  }
 }

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

@@ -521,9 +521,6 @@ function emitCommonTypes(
   nullable: boolean,
   parser: Parser,
 ): $FlowFixMe {
-  const genericTypeAnnotationName =
-    parser.nameForGenericTypeAnnotation(typeAnnotation);
-
   const typeMap = {
     Stringish: emitStringish,
     Int32: emitInt32,
@@ -533,8 +530,25 @@ function emitCommonTypes(
     Object: emitGenericObject,
     $Partial: emitPartial,
     Partial: emitPartial,
+    BooleanTypeAnnotation: emitBoolean,
+    NumberTypeAnnotation: emitNumber,
+    VoidTypeAnnotation: emitVoid,
+    StringTypeAnnotation: emitString,
+    MixedTypeAnnotation: cxxOnly ? emitMixed : emitGenericObject,
   };
 
+  const typeAnnotationName = parser.convertKeywordToTypeAnnotation(
+    typeAnnotation.type,
+  );
+
+  const simpleEmitter = typeMap[typeAnnotationName];
+  if (simpleEmitter) {
+    return simpleEmitter(nullable);
+  }
+
+  const genericTypeAnnotationName =
+    parser.nameForGenericTypeAnnotation(typeAnnotation);
+
   const emitter = typeMap[genericTypeAnnotationName];
   if (!emitter) {
     return null;

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

@@ -34,15 +34,10 @@ const {parseObjectProperty} = require('../../parsers-commons');
 
 const {
   emitArrayType,
-  emitBoolean,
   emitFunction,
-  emitNumber,
   emitGenericObject,
   emitPromise,
   emitRootTag,
-  emitVoid,
-  emitString,
-  emitMixed,
   emitUnion,
   emitCommonTypes,
   typeAliasResolution,
@@ -353,18 +348,6 @@ function translateTypeAnnotation(
         parser,
       );
     }
-    case 'TSBooleanKeyword': {
-      return emitBoolean(nullable);
-    }
-    case 'TSNumberKeyword': {
-      return emitNumber(nullable);
-    }
-    case 'TSVoidKeyword': {
-      return emitVoid(nullable);
-    }
-    case 'TSStringKeyword': {
-      return emitString(nullable);
-    }
     case 'TSFunctionType': {
       return emitFunction(
         nullable,
@@ -382,18 +365,27 @@ function translateTypeAnnotation(
     case 'TSUnionType': {
       return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
     }
-    case 'TSUnknownKeyword': {
-      if (cxxOnly) {
-        return emitMixed(nullable);
-      }
-      // Fallthrough
-    }
     default: {
-      throw new UnsupportedTypeAnnotationParserError(
+      const commonType = emitCommonTypes(
         hasteModuleName,
+        types,
         typeAnnotation,
-        parser.language(),
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
       );
+
+      if (!commonType) {
+        throw new UnsupportedTypeAnnotationParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return commonType;
     }
   }
 }

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

@@ -67,7 +67,7 @@ class TypeScriptParser implements Parser {
   }
 
   nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string {
-    return typeAnnotation.typeName.name;
+    return typeAnnotation?.typeName?.name;
   }
 
   checkIfInvalidModule(typeArguments: $FlowFixMe): boolean {
@@ -311,6 +311,23 @@ class TypeScriptParser implements Parser {
   bodyProperties(typeAlias: TypeDeclarationMap): $ReadOnlyArray<$FlowFixMe> {
     return typeAlias.body.body;
   }
+
+  convertKeywordToTypeAnnotation(keyword: string): string {
+    switch (keyword) {
+      case 'TSBooleanKeyword':
+        return 'BooleanTypeAnnotation';
+      case 'TSNumberKeyword':
+        return 'NumberTypeAnnotation';
+      case 'TSVoidKeyword':
+        return 'VoidTypeAnnotation';
+      case 'TSStringKeyword':
+        return 'StringTypeAnnotation';
+      case 'TSUnknownKeyword':
+        return 'MixedTypeAnnotation';
+    }
+
+    return keyword;
+  }
 }
 
 module.exports = {