@react-native/codegen 0.72.1 → 0.72.3

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

@@ -13,22 +13,24 @@
 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');
-const {resolveTypeAnnotation, getTypes} = require('../utils');
+const {resolveTypeAnnotation} = require('../utils');
 const {
   unwrapNullable,
   wrapNullable,
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   parseObjectProperty,
-  translateDefault,
   buildPropertySchema,
 } = require('../../parsers-commons');
 const {
@@ -39,6 +41,7 @@ const {
   emitFunction,
   emitNumber,
   emitInt32,
+  emitGenericObject,
   emitObject,
   emitPromise,
   emitRootTag,
@@ -48,12 +51,12 @@ const {
   emitMixed,
   emitUnion,
   typeAliasResolution,
-  translateArrayTypeAnnotation,
+  typeEnumResolution,
 } = require('../../parsers-primitives');
 
 const {
   UnsupportedTypeAnnotationParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError,
+  UnsupportedGenericParserError,
 } = require('../../errors');
 
 const {
@@ -63,14 +66,14 @@ const {
   throwIfWrongNumberOfCallExpressionArgs,
   throwIfMoreThanOneModuleRegistryCalls,
   throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfIncorrectModuleRegistryCallArgument,
   throwIfUntypedModule,
   throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfPartialNotAnnotatingTypeParameter,
+  throwIfPartialWithMoreParameter,
 } = require('../../error-utils');
 
-const {FlowParser} = require('../parser');
-
 const language = 'Flow';
-const parser = new FlowParser();
 
 function translateTypeAnnotation(
   hasteModuleName: string,
@@ -80,10 +83,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 +105,7 @@ function translateTypeAnnotation(
             nullable,
             types,
             aliasMap,
+            enumMap,
             tryParse,
             cxxOnly,
             translateTypeAnnotation,
@@ -113,6 +119,7 @@ function translateTypeAnnotation(
             parser,
             types,
             aliasMap,
+            enumMap,
             cxxOnly,
             nullable,
             translateTypeAnnotation,
@@ -131,8 +138,10 @@ function translateTypeAnnotation(
               typeAnnotation.typeParameters.params[0],
               types,
               aliasMap,
+              enumMap,
               tryParse,
               cxxOnly,
+              parser,
             ),
           );
 
@@ -152,20 +161,75 @@ 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]
@@ -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(
@@ -251,15 +330,6 @@ function translateTypeAnnotation(
   }
 }
 
-function isModuleInterface(node: $FlowFixMe) {
-  return (
-    node.type === 'InterfaceDeclaration' &&
-    node.extends.length === 1 &&
-    node.extends[0].type === 'InterfaceExtends' &&
-    node.extends[0].id.name === 'TurboModule'
-  );
-}
-
 function buildModuleSchema(
   hasteModuleName: string,
   /**
@@ -267,10 +337,11 @@ function buildModuleSchema(
    */
   ast: $FlowFixMe,
   tryParse: ParserErrorCapturer,
+  parser: Parser,
 ): NativeModuleSchema {
-  const types = getTypes(ast);
+  const types = parser.getTypes(ast);
   const moduleSpecs = (Object.values(types): $ReadOnlyArray<$FlowFixMe>).filter(
-    isModuleInterface,
+    t => parser.isModuleInterface(t),
   );
 
   throwIfModuleInterfaceNotFound(
@@ -305,14 +376,12 @@ function buildModuleSchema(
       hasteModuleName,
       moduleSpec,
       callExpressions,
-      language,
     );
 
     throwIfMoreThanOneModuleRegistryCalls(
       hasteModuleName,
       callExpressions,
       callExpressions.length,
-      language,
     );
 
     const [callExpression] = callExpressions;
@@ -324,19 +393,13 @@ function buildModuleSchema(
       callExpression,
       methodName,
       callExpression.arguments.length,
-      language,
     );
 
-    if (callExpression.arguments[0].type !== 'Literal') {
-      const {type} = callExpression.arguments[0];
-      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
-        hasteModuleName,
-        callExpression.arguments[0],
-        methodName,
-        type,
-        language,
-      );
-    }
+    throwIfIncorrectModuleRegistryCallArgument(
+      hasteModuleName,
+      callExpression.arguments[0],
+      methodName,
+    );
 
     const $moduleName = callExpression.arguments[0].value;
 
@@ -346,7 +409,6 @@ function buildModuleSchema(
       callExpression,
       methodName,
       $moduleName,
-      language,
     );
 
     throwIfIncorrectModuleRegistryCallTypeParameterParserError(
@@ -374,29 +436,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 +475,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{}

package/lib/parsers/flow/parser.js

@@ -38,9 +38,22 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
-const _require = require('../errors'),
+// $FlowFixMe[untyped-import] there's no flowtype flow-parser
+const flowParser = require('flow-parser');
+const _require = require('../parsers-commons'),
+  buildSchema = _require.buildSchema;
+const _require2 = require('./Visitor'),
+  Visitor = _require2.Visitor;
+const _require3 = require('./components'),
+  buildComponentSchema = _require3.buildComponentSchema;
+const _require4 = require('../schema.js'),
+  wrapComponentSchema = _require4.wrapComponentSchema;
+const _require5 = require('./modules'),
+  buildModuleSchema = _require5.buildModuleSchema;
+const fs = require('fs');
+const _require6 = require('../errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require.UnsupportedObjectPropertyTypeAnnotationParserError;
+    _require6.UnsupportedObjectPropertyTypeAnnotationParserError;
 class FlowParser {
   constructor() {
     _defineProperty(
@@ -49,37 +62,19 @@ class FlowParser {
       'TypeParameterInstantiation',
     );
   }
-  getKeyName(propertyOrIndex, hasteModuleName) {
-    var _propertyOrIndex$id$n, _propertyOrIndex$id;
-    switch (propertyOrIndex.type) {
-      case 'ObjectTypeProperty':
-        return propertyOrIndex.key.name;
-      case 'ObjectTypeIndexer':
-        // flow index name is optional
-        return (_propertyOrIndex$id$n =
-          (_propertyOrIndex$id = propertyOrIndex.id) === null ||
-          _propertyOrIndex$id === void 0
-            ? void 0
-            : _propertyOrIndex$id.name) !== null &&
-          _propertyOrIndex$id$n !== void 0
-          ? _propertyOrIndex$id$n
-          : 'key';
-      default:
-        throw new UnsupportedObjectPropertyTypeAnnotationParserError(
-          hasteModuleName,
-          propertyOrIndex,
-          propertyOrIndex.type,
-          this.language(),
-        );
-    }
-  }
-  getMaybeEnumMemberType(maybeEnumDeclaration) {
-    return maybeEnumDeclaration.body.type
-      .replace('EnumNumberBody', 'NumberTypeAnnotation')
-      .replace('EnumStringBody', 'StringTypeAnnotation');
+  isProperty(property) {
+    return property.type === 'ObjectTypeProperty';
   }
-  isEnumDeclaration(maybeEnumDeclaration) {
-    return maybeEnumDeclaration.type === 'EnumDeclaration';
+  getKeyName(property, hasteModuleName) {
+    if (!this.isProperty(property)) {
+      throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+        hasteModuleName,
+        property,
+        property.type,
+        this.language(),
+      );
+    }
+    return property.key.name;
   }
   language() {
     return 'Flow';
@@ -103,6 +98,152 @@ class FlowParser {
     };
     return [...new Set(membersTypes.map(remapLiteral))];
   }
+  parseFile(filename) {
+    const contents = fs.readFileSync(filename, 'utf8');
+    return this.parseString(contents, filename);
+  }
+  parseString(contents, filename) {
+    return buildSchema(
+      contents,
+      filename,
+      wrapComponentSchema,
+      buildComponentSchema,
+      buildModuleSchema,
+      Visitor,
+      this,
+    );
+  }
+  parseModuleFixture(filename) {
+    const contents = fs.readFileSync(filename, 'utf8');
+    return this.parseString(contents, 'path/NativeSampleTurboModule.js');
+  }
+  getAst(contents) {
+    return flowParser.parse(contents, {
+      enums: true,
+    });
+  }
+  getFunctionTypeAnnotationParameters(functionTypeAnnotation) {
+    return functionTypeAnnotation.params;
+  }
+  getFunctionNameFromParameter(parameter) {
+    return parameter.name;
+  }
+  getParameterName(parameter) {
+    return parameter.name.name;
+  }
+  getParameterTypeAnnotation(parameter) {
+    return parameter.typeAnnotation;
+  }
+  getFunctionTypeAnnotationReturnType(functionTypeAnnotation) {
+    return functionTypeAnnotation.returnType;
+  }
+  parseEnumMembersType(typeAnnotation) {
+    const enumMembersType =
+      typeAnnotation.type === 'EnumStringBody'
+        ? 'StringTypeAnnotation'
+        : typeAnnotation.type === 'EnumNumberBody'
+        ? 'NumberTypeAnnotation'
+        : null;
+    if (!enumMembersType) {
+      throw new Error(
+        `Unknown enum type annotation type. Got: ${typeAnnotation.type}. Expected: EnumStringBody or EnumNumberBody.`,
+      );
+    }
+    return enumMembersType;
+  }
+  validateEnumMembersSupported(typeAnnotation, enumMembersType) {
+    if (!typeAnnotation.members || typeAnnotation.members.length === 0) {
+      // passing mixed members to flow would result in a flow error
+      // if the tool is launched ignoring that error, the enum would appear like not having enums
+      throw new Error(
+        'Enums should have at least one member and member values can not be mixed- they all must be either blank, number, or string values.',
+      );
+    }
+    typeAnnotation.members.forEach(member => {
+      if (
+        enumMembersType === 'StringTypeAnnotation' &&
+        (!member.init || typeof member.init.value === 'string')
+      ) {
+        return;
+      }
+      if (
+        enumMembersType === 'NumberTypeAnnotation' &&
+        member.init &&
+        typeof member.init.value === 'number'
+      ) {
+        return;
+      }
+      throw new Error(
+        'Enums can not be mixed- they all must be either blank, number, or string values.',
+      );
+    });
+  }
+  parseEnumMembers(typeAnnotation) {
+    return typeAnnotation.members.map(member => {
+      var _member$init$value, _member$init;
+      return {
+        name: member.id.name,
+        value:
+          (_member$init$value =
+            (_member$init = member.init) === null || _member$init === void 0
+              ? void 0
+              : _member$init.value) !== null && _member$init$value !== void 0
+            ? _member$init$value
+            : member.id.name,
+      };
+    });
+  }
+  isModuleInterface(node) {
+    return (
+      node.type === 'InterfaceDeclaration' &&
+      node.extends.length === 1 &&
+      node.extends[0].type === 'InterfaceExtends' &&
+      node.extends[0].id.name === 'TurboModule'
+    );
+  }
+  extractAnnotatedElement(typeAnnotation, types) {
+    return types[typeAnnotation.typeParameters.params[0].id.name];
+  }
+
+  /**
+   * This FlowFixMe is supposed to refer to an InterfaceDeclaration or TypeAlias
+   * declaration type. Unfortunately, we don't have those types, because flow-parser
+   * generates them, and flow-parser is not type-safe. In the future, we should find
+   * a way to get these types from our flow parser library.
+   *
+   * TODO(T71778680): Flow type AST Nodes
+   */
+
+  getTypes(ast) {
+    return ast.body.reduce((types, node) => {
+      if (
+        node.type === 'ExportNamedDeclaration' &&
+        node.exportKind === 'type'
+      ) {
+        if (
+          node.declaration != null &&
+          (node.declaration.type === 'TypeAlias' ||
+            node.declaration.type === 'InterfaceDeclaration')
+        ) {
+          types[node.declaration.id.name] = node.declaration;
+        }
+      } else if (
+        node.type === 'ExportNamedDeclaration' &&
+        node.exportKind === 'value' &&
+        node.declaration &&
+        node.declaration.type === 'EnumDeclaration'
+      ) {
+        types[node.declaration.id.name] = node.declaration;
+      } else if (
+        node.type === 'TypeAlias' ||
+        node.type === 'InterfaceDeclaration' ||
+        node.type === 'EnumDeclaration'
+      ) {
+        types[node.id.name] = node;
+      }
+      return types;
+    }, {});
+  }
 }
 module.exports = {
   FlowParser,