@react-native/codegen 0.72.2 → 0.72.4

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

@@ -15,9 +15,7 @@ import type {
   NativeModuleAliasMap,
   NativeModuleEnumMap,
   NativeModuleBaseTypeAnnotation,
-  NativeModulePropertyShape,
   NativeModuleTypeAnnotation,
-  NativeModuleSchema,
   Nullable,
 } from '../../../CodegenSchema';
 
@@ -30,55 +28,33 @@ import type {
 const {flattenIntersectionType} = require('../parseTopLevelType');
 const {flattenProperties} = require('../components/componentsUtils');
 
-const {visit, isModuleRegistryCall, verifyPlatforms} = require('../../utils');
-const {resolveTypeAnnotation, getTypes} = require('../utils');
+const {resolveTypeAnnotation} = require('../utils');
 
-const {
-  parseObjectProperty,
-  buildPropertySchema,
-} = require('../../parsers-commons');
-const {typeEnumResolution} = require('../../parsers-primitives');
+const {parseObjectProperty} = require('../../parsers-commons');
 
 const {
   emitArrayType,
   emitBoolean,
-  emitDouble,
-  emitFloat,
   emitFunction,
   emitNumber,
-  emitInt32,
   emitGenericObject,
-  emitObject,
   emitPromise,
   emitRootTag,
   emitVoid,
   emitString,
-  emitStringish,
   emitMixed,
   emitUnion,
+  emitCommonTypes,
   typeAliasResolution,
+  typeEnumResolution,
   translateArrayTypeAnnotation,
 } = require('../../parsers-primitives');
 
 const {
   UnsupportedGenericParserError,
   UnsupportedTypeAnnotationParserError,
-  IncorrectModuleRegistryCallArgumentTypeParserError,
 } = require('../../errors');
 
-const {
-  throwIfUntypedModule,
-  throwIfUnusedModuleInterfaceParserError,
-  throwIfModuleInterfaceNotFound,
-  throwIfModuleInterfaceIsMisnamed,
-  throwIfWrongNumberOfCallExpressionArgs,
-  throwIfMoreThanOneModuleRegistryCalls,
-  throwIfMoreThanOneModuleInterfaceParserError,
-  throwIfIncorrectModuleRegistryCallTypeParameterParserError,
-} = require('../../error-utils');
-
-const language = 'TypeScript';
-
 function translateObjectTypeAnnotation(
   hasteModuleName: string,
   /**
@@ -137,6 +113,74 @@ function translateObjectTypeAnnotation(
   );
 }
 
+function translateTypeReferenceAnnotation(
+  typeName: string,
+  nullable: boolean,
+  typeAnnotation: $FlowFixMe,
+  hasteModuleName: string,
+  types: TypeDeclarationMap,
+  aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
+  tryParse: ParserErrorCapturer,
+  cxxOnly: boolean,
+  parser: Parser,
+): Nullable<NativeModuleTypeAnnotation> {
+  switch (typeName) {
+    case 'RootTag': {
+      return emitRootTag(nullable);
+    }
+    case 'Promise': {
+      return emitPromise(
+        hasteModuleName,
+        typeAnnotation,
+        parser,
+        nullable,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+      );
+    }
+    case 'Array':
+    case 'ReadonlyArray': {
+      return emitArrayType(
+        hasteModuleName,
+        typeAnnotation,
+        parser,
+        types,
+        aliasMap,
+        enumMap,
+        cxxOnly,
+        nullable,
+        translateTypeAnnotation,
+      );
+    }
+    default: {
+      const commonType = emitCommonTypes(
+        hasteModuleName,
+        types,
+        typeAnnotation,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
+      );
+
+      if (!commonType) {
+        throw new UnsupportedGenericParserError(
+          hasteModuleName,
+          typeAnnotation,
+          parser,
+        );
+      }
+      return commonType;
+    }
+  }
+}
 function translateTypeAnnotation(
   hasteModuleName: string,
   /**
@@ -194,99 +238,18 @@ function translateTypeAnnotation(
       }
     }
     case 'TSTypeReference': {
-      switch (typeAnnotation.typeName.name) {
-        case 'RootTag': {
-          return emitRootTag(nullable);
-        }
-        case 'Promise': {
-          return emitPromise(
-            hasteModuleName,
-            typeAnnotation,
-            parser,
-            nullable,
-            types,
-            aliasMap,
-            enumMap,
-            tryParse,
-            cxxOnly,
-            translateTypeAnnotation,
-          );
-        }
-        case 'Array':
-        case 'ReadonlyArray': {
-          return emitArrayType(
-            hasteModuleName,
-            typeAnnotation,
-            parser,
-            types,
-            aliasMap,
-            enumMap,
-            cxxOnly,
-            nullable,
-            translateTypeAnnotation,
-          );
-        }
-        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': {
-          if (typeAnnotation.typeParameters.params.length !== 1) {
-            throw new Error(
-              'Partials only support annotating exactly one parameter.',
-            );
-          }
-
-          const annotatedElement =
-            types[typeAnnotation.typeParameters.params[0].typeName.name];
-
-          if (!annotatedElement) {
-            throw new Error(
-              'Partials only support annotating a type parameter.',
-            );
-          }
-
-          const properties = annotatedElement.typeAnnotation.members.map(
-            member => {
-              return {
-                name: member.key.name,
-                optional: true,
-                typeAnnotation: translateTypeAnnotation(
-                  hasteModuleName,
-                  member.typeAnnotation.typeAnnotation,
-                  types,
-                  aliasMap,
-                  enumMap,
-                  tryParse,
-                  cxxOnly,
-                  parser,
-                ),
-              };
-            },
-          );
-
-          return emitObject(nullable, properties);
-        }
-        default: {
-          throw new UnsupportedGenericParserError(
-            hasteModuleName,
-            typeAnnotation,
-            parser,
-          );
-        }
-      }
+      return translateTypeReferenceAnnotation(
+        typeAnnotation.typeName.name,
+        nullable,
+        typeAnnotation,
+        hasteModuleName,
+        types,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        parser,
+      );
     }
     case 'TSInterfaceDeclaration': {
       const baseTypes = (typeAnnotation.extends ?? []).map(
@@ -386,7 +349,6 @@ function translateTypeAnnotation(
         typeResolutionStatus,
         nullable,
         hasteModuleName,
-        language,
         enumMap,
         parser,
       );
@@ -430,188 +392,12 @@ function translateTypeAnnotation(
       throw new UnsupportedTypeAnnotationParserError(
         hasteModuleName,
         typeAnnotation,
-        language,
+        parser.language(),
       );
     }
   }
 }
 
-function isModuleInterface(node: $FlowFixMe) {
-  return (
-    node.type === 'TSInterfaceDeclaration' &&
-    node.extends?.length === 1 &&
-    node.extends[0].type === 'TSExpressionWithTypeArguments' &&
-    node.extends[0].expression.name === 'TurboModule'
-  );
-}
-
-function buildModuleSchema(
-  hasteModuleName: string,
-  /**
-   * TODO(T108222691): Use flow-types for @babel/parser
-   */
-  ast: $FlowFixMe,
-  tryParse: ParserErrorCapturer,
-  parser: Parser,
-): NativeModuleSchema {
-  const types = getTypes(ast);
-  const moduleSpecs = (Object.values(types): $ReadOnlyArray<$FlowFixMe>).filter(
-    isModuleInterface,
-  );
-
-  throwIfModuleInterfaceNotFound(
-    moduleSpecs.length,
-    hasteModuleName,
-    ast,
-    language,
-  );
-
-  throwIfMoreThanOneModuleInterfaceParserError(
-    hasteModuleName,
-    moduleSpecs,
-    language,
-  );
-
-  const [moduleSpec] = moduleSpecs;
-
-  throwIfModuleInterfaceIsMisnamed(hasteModuleName, moduleSpec.id, language);
-
-  // Parse Module Name
-  const moduleName = ((): string => {
-    const callExpressions = [];
-    visit(ast, {
-      CallExpression(node) {
-        if (isModuleRegistryCall(node)) {
-          callExpressions.push(node);
-        }
-      },
-    });
-
-    throwIfUnusedModuleInterfaceParserError(
-      hasteModuleName,
-      moduleSpec,
-      callExpressions,
-    );
-
-    throwIfMoreThanOneModuleRegistryCalls(
-      hasteModuleName,
-      callExpressions,
-      callExpressions.length,
-    );
-
-    const [callExpression] = callExpressions;
-    const {typeParameters} = callExpression;
-    const methodName = callExpression.callee.property.name;
-
-    throwIfWrongNumberOfCallExpressionArgs(
-      hasteModuleName,
-      callExpression,
-      methodName,
-      callExpression.arguments.length,
-    );
-
-    if (callExpression.arguments[0].type !== 'StringLiteral') {
-      const {type} = callExpression.arguments[0];
-      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
-        hasteModuleName,
-        callExpression.arguments[0],
-        methodName,
-        type,
-      );
-    }
-
-    const $moduleName = callExpression.arguments[0].value;
-
-    throwIfUntypedModule(
-      typeParameters,
-      hasteModuleName,
-      callExpression,
-      methodName,
-      $moduleName,
-    );
-
-    throwIfIncorrectModuleRegistryCallTypeParameterParserError(
-      hasteModuleName,
-      typeParameters,
-      methodName,
-      $moduleName,
-      parser,
-    );
-
-    return $moduleName;
-  })();
-
-  // Some module names use platform suffix to indicate platform-exclusive modules.
-  // Eventually this should be made explicit in the Flow type itself.
-  // Also check the hasteModuleName for platform suffix.
-  // Note: this shape is consistent with ComponentSchema.
-  const {cxxOnly, excludedPlatforms} = verifyPlatforms(
-    hasteModuleName,
-    moduleName,
-  );
-
-  // $FlowFixMe[missing-type-arg]
-  return (moduleSpec.body.body: $ReadOnlyArray<$FlowFixMe>)
-    .filter(
-      property =>
-        property.type === 'TSMethodSignature' ||
-        property.type === 'TSPropertySignature',
-    )
-    .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,
-          resolveTypeAnnotation,
-          translateTypeAnnotation,
-          parser,
-        ),
-      }));
-    })
-    .filter(Boolean)
-    .reduce(
-      (
-        moduleSchema: NativeModuleSchema,
-        {aliasMap, enumMap, propertyShape},
-      ) => {
-        return {
-          type: 'NativeModule',
-          aliasMap: {...moduleSchema.aliasMap, ...aliasMap},
-          enumMap: {...moduleSchema.enumMap, ...enumMap},
-          spec: {
-            properties: [...moduleSchema.spec.properties, propertyShape],
-          },
-          moduleName: moduleSchema.moduleName,
-          excludedPlatforms: moduleSchema.excludedPlatforms,
-        };
-      },
-      {
-        type: 'NativeModule',
-        aliasMap: {},
-        enumMap: {},
-        spec: {properties: []},
-        moduleName: moduleName,
-        excludedPlatforms:
-          excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
-      },
-    );
-}
-
 module.exports = {
-  buildModuleSchema,
   typeScriptTranslateTypeAnnotation: translateTypeAnnotation,
 };

package/lib/parsers/typescript/parser.js

@@ -38,22 +38,28 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
+const _require = require('./modules'),
+  typeScriptTranslateTypeAnnotation =
+    _require.typeScriptTranslateTypeAnnotation;
+
 // $FlowFixMe[untyped-import] Use flow-types for @babel/parser
 const babelParser = require('@babel/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('./components/schema'),
-  wrapComponentSchema = _require4.wrapComponentSchema;
-const _require5 = require('./modules'),
-  buildModuleSchema = _require5.buildModuleSchema;
+const _require2 = require('../parsers-commons'),
+  buildSchema = _require2.buildSchema;
+const _require3 = require('../parsers-primitives'),
+  Visitor = _require3.Visitor;
+const _require4 = require('./components'),
+  buildComponentSchema = _require4.buildComponentSchema;
+const _require5 = require('../schema.js'),
+  wrapComponentSchema = _require5.wrapComponentSchema;
+const _require6 = require('../parsers-commons.js'),
+  buildModuleSchema = _require6.buildModuleSchema;
+const _require7 = require('./utils'),
+  resolveTypeAnnotation = _require7.resolveTypeAnnotation;
 const fs = require('fs');
-const _require6 = require('../errors'),
+const _require8 = require('../errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require6.UnsupportedObjectPropertyTypeAnnotationParserError;
+    _require8.UnsupportedObjectPropertyTypeAnnotationParserError;
 class TypeScriptParser {
   constructor() {
     _defineProperty(
@@ -113,6 +119,8 @@ class TypeScriptParser {
       buildModuleSchema,
       Visitor,
       this,
+      resolveTypeAnnotation,
+      typeScriptTranslateTypeAnnotation,
     );
   }
   parseModuleFixture(filename) {
@@ -205,6 +213,99 @@ class TypeScriptParser {
       };
     });
   }
+  isModuleInterface(node) {
+    var _node$extends;
+    return (
+      node.type === 'TSInterfaceDeclaration' &&
+      ((_node$extends = node.extends) === null || _node$extends === void 0
+        ? void 0
+        : _node$extends.length) === 1 &&
+      node.extends[0].type === 'TSExpressionWithTypeArguments' &&
+      node.extends[0].expression.name === 'TurboModule'
+    );
+  }
+  extractAnnotatedElement(typeAnnotation, types) {
+    return types[typeAnnotation.typeParameters.params[0].typeName.name];
+  }
+
+  /**
+   * TODO(T108222691): Use flow-types for @babel/parser
+   */
+  getTypes(ast) {
+    return ast.body.reduce((types, node) => {
+      switch (node.type) {
+        case 'ExportNamedDeclaration': {
+          if (node.declaration) {
+            switch (node.declaration.type) {
+              case 'TSTypeAliasDeclaration':
+              case 'TSInterfaceDeclaration':
+              case 'TSEnumDeclaration': {
+                types[node.declaration.id.name] = node.declaration;
+                break;
+              }
+            }
+          }
+          break;
+        }
+        case 'TSTypeAliasDeclaration':
+        case 'TSInterfaceDeclaration':
+        case 'TSEnumDeclaration': {
+          types[node.id.name] = node;
+          break;
+        }
+      }
+      return types;
+    }, {});
+  }
+  callExpressionTypeParameters(callExpression) {
+    return callExpression.typeParameters || null;
+  }
+  computePartialProperties(
+    properties,
+    hasteModuleName,
+    types,
+    aliasMap,
+    enumMap,
+    tryParse,
+    cxxOnly,
+  ) {
+    return properties.map(prop => {
+      return {
+        name: prop.key.name,
+        optional: true,
+        typeAnnotation: typeScriptTranslateTypeAnnotation(
+          hasteModuleName,
+          prop.typeAnnotation.typeAnnotation,
+          types,
+          aliasMap,
+          enumMap,
+          tryParse,
+          cxxOnly,
+          this,
+        ),
+      };
+    });
+  }
+  functionTypeAnnotation(propertyValueType) {
+    return (
+      propertyValueType === 'TSFunctionType' ||
+      propertyValueType === 'TSMethodSignature'
+    );
+  }
+  getTypeArgumentParamsFromDeclaration(declaration) {
+    return declaration.typeParameters.params;
+  }
+
+  // This FlowFixMe is supposed to refer to typeArgumentParams and funcArgumentParams of generated AST.
+  getNativeComponentType(typeArgumentParams, funcArgumentParams) {
+    return {
+      propsTypeName: typeArgumentParams[0].typeName.name,
+      componentName: funcArgumentParams[0].value,
+    };
+  }
+  getAnnotatedElementProperties(annotatedElement) {
+    return annotatedElement.typeAnnotation.members;
+  }
 }
 module.exports = {
   TypeScriptParser,