@react-native/codegen 0.72.1 → 0.72.2

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

@@ -153,7 +153,6 @@ const _require3 = require('../../parsers-commons'),
   assertGenericTypeAnnotationHasExactlyOneTypeParameter =
     _require3.assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   parseObjectProperty = _require3.parseObjectProperty,
-  translateDefault = _require3.translateDefault,
   buildPropertySchema = _require3.buildPropertySchema;
 const _require4 = require('../../parsers-primitives'),
   emitArrayType = _require4.emitArrayType,
@@ -163,6 +162,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 +172,13 @@ 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;
+    _require5.IncorrectModuleRegistryCallArgumentTypeParserError,
+  UnsupportedGenericParserError = _require5.UnsupportedGenericParserError;
 const _require6 = require('../../error-utils'),
   throwIfModuleInterfaceNotFound = _require6.throwIfModuleInterfaceNotFound,
   throwIfModuleInterfaceIsMisnamed = _require6.throwIfModuleInterfaceIsMisnamed,
@@ -192,10 +193,7 @@ const _require6 = require('../../error-utils'),
   throwIfUntypedModule = _require6.throwIfUntypedModule,
   throwIfMoreThanOneModuleInterfaceParserError =
     _require6.throwIfMoreThanOneModuleInterfaceParserError;
-const _require7 = require('../parser'),
-  FlowParser = _require7.FlowParser;
 const language = 'Flow';
-const parser = new FlowParser();
 function translateTypeAnnotation(
   hasteModuleName,
   /**
@@ -204,8 +202,10 @@ function translateTypeAnnotation(
   flowTypeAnnotation,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
+  parser,
 ) {
   const _resolveTypeAnnotatio = resolveTypeAnnotation(
       flowTypeAnnotation,
@@ -213,7 +213,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 +228,7 @@ function translateTypeAnnotation(
             nullable,
             types,
             aliasMap,
+            enumMap,
             tryParse,
             cxxOnly,
             translateTypeAnnotation,
@@ -241,6 +242,7 @@ function translateTypeAnnotation(
             parser,
             types,
             aliasMap,
+            enumMap,
             cxxOnly,
             nullable,
             translateTypeAnnotation,
@@ -258,8 +260,10 @@ function translateTypeAnnotation(
                 typeAnnotation.typeParameters.params[0],
                 types,
                 aliasMap,
+                enumMap,
                 tryParse,
                 cxxOnly,
+                parser,
               ),
             ),
             _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
@@ -281,20 +285,72 @@ function translateTypeAnnotation(
         }
         case 'UnsafeObject':
         case 'Object': {
-          return emitObject(nullable);
+          return emitGenericObject(nullable);
+        }
+        case '$Partial': {
+          if (typeAnnotation.typeParameters.params.length !== 1) {
+            throw new Error(
+              'Partials only support annotating exactly one parameter.',
+            );
+          }
+          const annotatedElement =
+            types[typeAnnotation.typeParameters.params[0].id.name];
+          if (!annotatedElement) {
+            throw new Error(
+              'Partials only support annotating a type parameter.',
+            );
+          }
+          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,
@@ -389,6 +459,7 @@ function buildModuleSchema(
    */
   ast,
   tryParse,
+  parser,
 ) {
   const types = getTypes(ast);
   const moduleSpecs = Object.values(types).filter(isModuleInterface);
@@ -421,13 +492,11 @@ function buildModuleSchema(
       hasteModuleName,
       moduleSpec,
       callExpressions,
-      language,
     );
     throwIfMoreThanOneModuleRegistryCalls(
       hasteModuleName,
       callExpressions,
       callExpressions.length,
-      language,
     );
     const callExpression = callExpressions[0];
     const typeArguments = callExpression.typeArguments;
@@ -437,7 +506,6 @@ function buildModuleSchema(
       callExpression,
       methodName,
       callExpression.arguments.length,
-      language,
     );
     if (callExpression.arguments[0].type !== 'Literal') {
       const type = callExpression.arguments[0].type;
@@ -446,7 +514,6 @@ function buildModuleSchema(
         callExpression.arguments[0],
         methodName,
         type,
-        language,
       );
     }
     const $moduleName = callExpression.arguments[0].value;
@@ -456,7 +523,6 @@ function buildModuleSchema(
       callExpression,
       methodName,
       $moduleName,
-      language,
     );
     throwIfIncorrectModuleRegistryCallTypeParameterParserError(
       hasteModuleName,
@@ -481,29 +547,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 +585,8 @@ function buildModuleSchema(
       }),
       {
         type: 'NativeModule',
-        aliases: {},
+        aliasMap: {},
+        enumMap: {},
         spec: {
           properties: [],
         },

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

@@ -13,12 +13,15 @@
 import type {
   NamedShape,
   NativeModuleAliasMap,
+  NativeModuleEnumMap,
   NativeModuleBaseTypeAnnotation,
   NativeModuleTypeAnnotation,
   NativeModulePropertyShape,
   NativeModuleSchema,
   Nullable,
 } from '../../../CodegenSchema';
+
+import type {Parser} from '../../parser';
 import type {ParserErrorCapturer, TypeDeclarationMap} from '../../utils';
 
 const {visit, isModuleRegistryCall, verifyPlatforms} = require('../../utils');
@@ -28,7 +31,6 @@ const {
   wrapNullable,
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   parseObjectProperty,
-  translateDefault,
   buildPropertySchema,
 } = require('../../parsers-commons');
 const {
@@ -39,6 +41,7 @@ const {
   emitFunction,
   emitNumber,
   emitInt32,
+  emitGenericObject,
   emitObject,
   emitPromise,
   emitRootTag,
@@ -48,12 +51,13 @@ const {
   emitMixed,
   emitUnion,
   typeAliasResolution,
-  translateArrayTypeAnnotation,
+  typeEnumResolution,
 } = require('../../parsers-primitives');
 
 const {
   UnsupportedTypeAnnotationParserError,
   IncorrectModuleRegistryCallArgumentTypeParserError,
+  UnsupportedGenericParserError,
 } = require('../../errors');
 
 const {
@@ -67,10 +71,7 @@ const {
   throwIfMoreThanOneModuleInterfaceParserError,
 } = require('../../error-utils');
 
-const {FlowParser} = require('../parser');
-
 const language = 'Flow';
-const parser = new FlowParser();
 
 function translateTypeAnnotation(
   hasteModuleName: string,
@@ -80,10 +81,12 @@ function translateTypeAnnotation(
   flowTypeAnnotation: $FlowFixMe,
   types: TypeDeclarationMap,
   aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
   tryParse: ParserErrorCapturer,
   cxxOnly: boolean,
+  parser: Parser,
 ): Nullable<NativeModuleTypeAnnotation> {
-  const {nullable, typeAnnotation, typeAliasResolutionStatus} =
+  const {nullable, typeAnnotation, typeResolutionStatus} =
     resolveTypeAnnotation(flowTypeAnnotation, types);
 
   switch (typeAnnotation.type) {
@@ -100,6 +103,7 @@ function translateTypeAnnotation(
             nullable,
             types,
             aliasMap,
+            enumMap,
             tryParse,
             cxxOnly,
             translateTypeAnnotation,
@@ -113,6 +117,7 @@ function translateTypeAnnotation(
             parser,
             types,
             aliasMap,
+            enumMap,
             cxxOnly,
             nullable,
             translateTypeAnnotation,
@@ -131,8 +136,10 @@ function translateTypeAnnotation(
               typeAnnotation.typeParameters.params[0],
               types,
               aliasMap,
+              enumMap,
               tryParse,
               cxxOnly,
+              parser,
             ),
           );
 
@@ -152,20 +159,77 @@ function translateTypeAnnotation(
         }
         case 'UnsafeObject':
         case 'Object': {
-          return emitObject(nullable);
+          return emitGenericObject(nullable);
+        }
+        case '$Partial': {
+          if (typeAnnotation.typeParameters.params.length !== 1) {
+            throw new Error(
+              'Partials only support annotating exactly one parameter.',
+            );
+          }
+
+          const annotatedElement =
+            types[typeAnnotation.typeParameters.params[0].id.name];
+
+          if (!annotatedElement) {
+            throw new Error(
+              'Partials only support annotating a type parameter.',
+            );
+          }
+
+          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]
@@ -181,6 +245,7 @@ function translateTypeAnnotation(
                   hasteModuleName,
                   types,
                   aliasMap,
+                  enumMap,
                   tryParse,
                   cxxOnly,
                   nullable,
@@ -194,7 +259,7 @@ function translateTypeAnnotation(
       };
 
       return typeAliasResolution(
-        typeAliasResolutionStatus,
+        typeResolutionStatus,
         objectTypeAnnotation,
         aliasMap,
         nullable,
@@ -219,10 +284,11 @@ function translateTypeAnnotation(
         typeAnnotation,
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
         translateTypeAnnotation,
-        language,
+        parser,
       );
     }
     case 'UnionTypeAnnotation': {
@@ -238,8 +304,21 @@ 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(
@@ -267,6 +346,7 @@ function buildModuleSchema(
    */
   ast: $FlowFixMe,
   tryParse: ParserErrorCapturer,
+  parser: Parser,
 ): NativeModuleSchema {
   const types = getTypes(ast);
   const moduleSpecs = (Object.values(types): $ReadOnlyArray<$FlowFixMe>).filter(
@@ -305,14 +385,12 @@ function buildModuleSchema(
       hasteModuleName,
       moduleSpec,
       callExpressions,
-      language,
     );
 
     throwIfMoreThanOneModuleRegistryCalls(
       hasteModuleName,
       callExpressions,
       callExpressions.length,
-      language,
     );
 
     const [callExpression] = callExpressions;
@@ -324,7 +402,6 @@ function buildModuleSchema(
       callExpression,
       methodName,
       callExpression.arguments.length,
-      language,
     );
 
     if (callExpression.arguments[0].type !== 'Literal') {
@@ -334,7 +411,6 @@ function buildModuleSchema(
         callExpression.arguments[0],
         methodName,
         type,
-        language,
       );
     }
 
@@ -346,7 +422,6 @@ function buildModuleSchema(
       callExpression,
       methodName,
       $moduleName,
-      language,
     );
 
     throwIfIncorrectModuleRegistryCallTypeParameterParserError(
@@ -374,29 +449,37 @@ function buildModuleSchema(
     .filter(property => property.type === 'ObjectTypeProperty')
     .map<?{
       aliasMap: NativeModuleAliasMap,
+      enumMap: NativeModuleEnumMap,
       propertyShape: NativeModulePropertyShape,
     }>(property => {
       const aliasMap: {...NativeModuleAliasMap} = {};
+      const enumMap: {...NativeModuleEnumMap} = {};
       return tryParse(() => ({
         aliasMap: aliasMap,
+        enumMap: enumMap,
         propertyShape: buildPropertySchema(
           hasteModuleName,
           property,
           types,
           aliasMap,
+          enumMap,
           tryParse,
           cxxOnly,
-          language,
           resolveTypeAnnotation,
           translateTypeAnnotation,
+          parser,
         ),
       }));
     })
     .filter(Boolean)
     .reduce(
-      (moduleSchema: NativeModuleSchema, {aliasMap, propertyShape}) => ({
+      (
+        moduleSchema: NativeModuleSchema,
+        {aliasMap, enumMap, propertyShape},
+      ) => ({
         type: 'NativeModule',
-        aliases: {...moduleSchema.aliases, ...aliasMap},
+        aliasMap: {...moduleSchema.aliasMap, ...aliasMap},
+        enumMap: {...moduleSchema.enumMap, ...enumMap},
         spec: {
           properties: [...moduleSchema.spec.properties, propertyShape],
         },
@@ -405,7 +488,8 @@ function buildModuleSchema(
       }),
       {
         type: 'NativeModule',
-        aliases: {},
+        aliasMap: {},
+        enumMap: {},
         spec: {properties: []},
         moduleName,
         excludedPlatforms:

package/lib/parsers/flow/parser.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type {Parser} from '../parser';
+
+export declare class FlowParser implements Parser{}