@react-native/codegen 0.72.1 → 0.72.3

package/lib/parsers/flow/modules/index.js

@@ -145,15 +145,13 @@ const _require = require('../../utils'),
   isModuleRegistryCall = _require.isModuleRegistryCall,
   verifyPlatforms = _require.verifyPlatforms;
 const _require2 = require('../utils'),
-  resolveTypeAnnotation = _require2.resolveTypeAnnotation,
-  getTypes = _require2.getTypes;
+  resolveTypeAnnotation = _require2.resolveTypeAnnotation;
 const _require3 = require('../../parsers-commons'),
   unwrapNullable = _require3.unwrapNullable,
   wrapNullable = _require3.wrapNullable,
   assertGenericTypeAnnotationHasExactlyOneTypeParameter =
     _require3.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   parseObjectProperty = _require3.parseObjectProperty,
-  translateDefault = _require3.translateDefault,
   buildPropertySchema = _require3.buildPropertySchema;
 const _require4 = require('../../parsers-primitives'),
   emitArrayType = _require4.emitArrayType,
@@ -163,6 +161,7 @@ const _require4 = require('../../parsers-primitives'),
   emitFunction = _require4.emitFunction,
   emitNumber = _require4.emitNumber,
   emitInt32 = _require4.emitInt32,
+  emitGenericObject = _require4.emitGenericObject,
   emitObject = _require4.emitObject,
   emitPromise = _require4.emitPromise,
   emitRootTag = _require4.emitRootTag,
@@ -172,12 +171,11 @@ const _require4 = require('../../parsers-primitives'),
   emitMixed = _require4.emitMixed,
   emitUnion = _require4.emitUnion,
   typeAliasResolution = _require4.typeAliasResolution,
-  translateArrayTypeAnnotation = _require4.translateArrayTypeAnnotation;
+  typeEnumResolution = _require4.typeEnumResolution;
 const _require5 = require('../../errors'),
   UnsupportedTypeAnnotationParserError =
     _require5.UnsupportedTypeAnnotationParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError =
-    _require5.IncorrectModuleRegistryCallArgumentTypeParserError;
+  UnsupportedGenericParserError = _require5.UnsupportedGenericParserError;
 const _require6 = require('../../error-utils'),
   throwIfModuleInterfaceNotFound = _require6.throwIfModuleInterfaceNotFound,
   throwIfModuleInterfaceIsMisnamed = _require6.throwIfModuleInterfaceIsMisnamed,
@@ -189,13 +187,15 @@ const _require6 = require('../../error-utils'),
     _require6.throwIfMoreThanOneModuleRegistryCalls,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError =
     _require6.throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfIncorrectModuleRegistryCallArgument =
+    _require6.throwIfIncorrectModuleRegistryCallArgument,
   throwIfUntypedModule = _require6.throwIfUntypedModule,
   throwIfMoreThanOneModuleInterfaceParserError =
-    _require6.throwIfMoreThanOneModuleInterfaceParserError;
-const _require7 = require('../parser'),
-  FlowParser = _require7.FlowParser;
+    _require6.throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfPartialNotAnnotatingTypeParameter =
+    _require6.throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter = _require6.throwIfPartialWithMoreParameter;
 const language = 'Flow';
-const parser = new FlowParser();
 function translateTypeAnnotation(
   hasteModuleName,
   /**
@@ -204,8 +204,10 @@ function translateTypeAnnotation(
   flowTypeAnnotation,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
+  parser,
 ) {
   const _resolveTypeAnnotatio = resolveTypeAnnotation(
       flowTypeAnnotation,
@@ -213,7 +215,7 @@ function translateTypeAnnotation(
     ),
     nullable = _resolveTypeAnnotatio.nullable,
     typeAnnotation = _resolveTypeAnnotatio.typeAnnotation,
-    typeAliasResolutionStatus = _resolveTypeAnnotatio.typeAliasResolutionStatus;
+    typeResolutionStatus = _resolveTypeAnnotatio.typeResolutionStatus;
   switch (typeAnnotation.type) {
     case 'GenericTypeAnnotation': {
       switch (typeAnnotation.id.name) {
@@ -228,6 +230,7 @@ function translateTypeAnnotation(
             nullable,
             types,
             aliasMap,
+            enumMap,
             tryParse,
             cxxOnly,
             translateTypeAnnotation,
@@ -241,6 +244,7 @@ function translateTypeAnnotation(
             parser,
             types,
             aliasMap,
+            enumMap,
             cxxOnly,
             nullable,
             translateTypeAnnotation,
@@ -258,8 +262,10 @@ function translateTypeAnnotation(
                 typeAnnotation.typeParameters.params[0],
                 types,
                 aliasMap,
+                enumMap,
                 tryParse,
                 cxxOnly,
+                parser,
               ),
             ),
             _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
@@ -281,20 +287,70 @@ function translateTypeAnnotation(
         }
         case 'UnsafeObject':
         case 'Object': {
-          return emitObject(nullable);
+          return emitGenericObject(nullable);
+        }
+        case '$Partial': {
+          throwIfPartialWithMoreParameter(typeAnnotation);
+          const annotatedElement = parser.extractAnnotatedElement(
+            typeAnnotation,
+            types,
+          );
+          throwIfPartialNotAnnotatingTypeParameter(
+            typeAnnotation,
+            types,
+            parser,
+          );
+          const properties = annotatedElement.right.properties.map(prop => {
+            return {
+              name: prop.key.name,
+              optional: true,
+              typeAnnotation: translateTypeAnnotation(
+                hasteModuleName,
+                prop.value,
+                types,
+                aliasMap,
+                enumMap,
+                tryParse,
+                cxxOnly,
+                parser,
+              ),
+            };
+          });
+          return emitObject(nullable, properties);
         }
         default: {
-          return translateDefault(
+          throw new UnsupportedGenericParserError(
             hasteModuleName,
             typeAnnotation,
-            types,
-            nullable,
             parser,
           );
         }
       }
     }
     case 'ObjectTypeAnnotation': {
+      // if there is any indexer, then it is a dictionary
+      if (typeAnnotation.indexers) {
+        const indexers = typeAnnotation.indexers.filter(
+          member => member.type === 'ObjectTypeIndexer',
+        );
+        if (indexers.length > 0) {
+          // check the property type to prevent developers from using unsupported types
+          // the return value from `translateTypeAnnotation` is unused
+          const propertyType = indexers[0].value;
+          translateTypeAnnotation(
+            hasteModuleName,
+            propertyType,
+            types,
+            aliasMap,
+            enumMap,
+            tryParse,
+            cxxOnly,
+            parser,
+          );
+          // no need to do further checking
+          return emitGenericObject(nullable);
+        }
+      }
       const objectTypeAnnotation = {
         type: 'ObjectTypeAnnotation',
         // $FlowFixMe[missing-type-arg]
@@ -306,6 +362,7 @@ function translateTypeAnnotation(
                 hasteModuleName,
                 types,
                 aliasMap,
+                enumMap,
                 tryParse,
                 cxxOnly,
                 nullable,
@@ -317,7 +374,7 @@ function translateTypeAnnotation(
           .filter(Boolean),
       };
       return typeAliasResolution(
-        typeAliasResolutionStatus,
+        typeResolutionStatus,
         objectTypeAnnotation,
         aliasMap,
         nullable,
@@ -342,10 +399,11 @@ function translateTypeAnnotation(
         typeAnnotation,
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
         translateTypeAnnotation,
-        language,
+        parser,
       );
     }
     case 'UnionTypeAnnotation': {
@@ -361,10 +419,22 @@ function translateTypeAnnotation(
     case 'MixedTypeAnnotation': {
       if (cxxOnly) {
         return emitMixed(nullable);
+      } else {
+        return emitGenericObject(nullable);
       }
-      // Fallthrough
     }
-
+    case 'EnumStringBody':
+    case 'EnumNumberBody': {
+      return typeEnumResolution(
+        typeAnnotation,
+        typeResolutionStatus,
+        nullable,
+        hasteModuleName,
+        language,
+        enumMap,
+        parser,
+      );
+    }
     default: {
       throw new UnsupportedTypeAnnotationParserError(
         hasteModuleName,
@@ -374,14 +444,6 @@ function translateTypeAnnotation(
     }
   }
 }
-function isModuleInterface(node) {
-  return (
-    node.type === 'InterfaceDeclaration' &&
-    node.extends.length === 1 &&
-    node.extends[0].type === 'InterfaceExtends' &&
-    node.extends[0].id.name === 'TurboModule'
-  );
-}
 function buildModuleSchema(
   hasteModuleName,
   /**
@@ -389,9 +451,12 @@ function buildModuleSchema(
    */
   ast,
   tryParse,
+  parser,
 ) {
-  const types = getTypes(ast);
-  const moduleSpecs = Object.values(types).filter(isModuleInterface);
+  const types = parser.getTypes(ast);
+  const moduleSpecs = Object.values(types).filter(t =>
+    parser.isModuleInterface(t),
+  );
   throwIfModuleInterfaceNotFound(
     moduleSpecs.length,
     hasteModuleName,
@@ -421,13 +486,11 @@ function buildModuleSchema(
       hasteModuleName,
       moduleSpec,
       callExpressions,
-      language,
     );
     throwIfMoreThanOneModuleRegistryCalls(
       hasteModuleName,
       callExpressions,
       callExpressions.length,
-      language,
     );
     const callExpression = callExpressions[0];
     const typeArguments = callExpression.typeArguments;
@@ -437,18 +500,12 @@ function buildModuleSchema(
       callExpression,
       methodName,
       callExpression.arguments.length,
-      language,
     );
-    if (callExpression.arguments[0].type !== 'Literal') {
-      const type = callExpression.arguments[0].type;
-      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
-        hasteModuleName,
-        callExpression.arguments[0],
-        methodName,
-        type,
-        language,
-      );
-    }
+    throwIfIncorrectModuleRegistryCallArgument(
+      hasteModuleName,
+      callExpression.arguments[0],
+      methodName,
+    );
     const $moduleName = callExpression.arguments[0].value;
     throwIfUntypedModule(
       typeArguments,
@@ -456,7 +513,6 @@ function buildModuleSchema(
       callExpression,
       methodName,
       $moduleName,
-      language,
     );
     throwIfIncorrectModuleRegistryCallTypeParameterParserError(
       hasteModuleName,
@@ -481,29 +537,36 @@ function buildModuleSchema(
     .filter(property => property.type === 'ObjectTypeProperty')
     .map(property => {
       const aliasMap = {};
+      const enumMap = {};
       return tryParse(() => ({
         aliasMap: aliasMap,
+        enumMap: enumMap,
         propertyShape: buildPropertySchema(
           hasteModuleName,
           property,
           types,
           aliasMap,
+          enumMap,
           tryParse,
           cxxOnly,
-          language,
           resolveTypeAnnotation,
           translateTypeAnnotation,
+          parser,
         ),
       }));
     })
     .filter(Boolean)
     .reduce(
-      (moduleSchema, {aliasMap, propertyShape}) => ({
+      (moduleSchema, {aliasMap, enumMap, propertyShape}) => ({
         type: 'NativeModule',
-        aliases: _objectSpread(
-          _objectSpread({}, moduleSchema.aliases),
+        aliasMap: _objectSpread(
+          _objectSpread({}, moduleSchema.aliasMap),
           aliasMap,
         ),
+        enumMap: _objectSpread(
+          _objectSpread({}, moduleSchema.enumMap),
+          enumMap,
+        ),
         spec: {
           properties: [...moduleSchema.spec.properties, propertyShape],
         },
@@ -512,7 +575,8 @@ function buildModuleSchema(
       }),
       {
         type: 'NativeModule',
-        aliases: {},
+        aliasMap: {},
+        enumMap: {},
         spec: {
           properties: [],
         },