@react-native/codegen 0.72.3 → 0.73.0

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

@@ -15,9 +15,7 @@ import type {
   NativeModuleAliasMap,
   NativeModuleEnumMap,
   NativeModuleBaseTypeAnnotation,
-  NativeModulePropertyShape,
   NativeModuleTypeAnnotation,
-  NativeModuleSchema,
   Nullable,
 } from '../../../CodegenSchema';
 
@@ -30,33 +28,20 @@ import type {
 const {flattenIntersectionType} = require('../parseTopLevelType');
 const {flattenProperties} = require('../components/componentsUtils');
 
-const {visit, isModuleRegistryCall, verifyPlatforms} = 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');
 
@@ -65,22 +50,6 @@ const {
   UnsupportedTypeAnnotationParserError,
 } = require('../../errors');
 
-const {
-  throwIfUntypedModule,
-  throwIfUnusedModuleInterfaceParserError,
-  throwIfModuleInterfaceNotFound,
-  throwIfModuleInterfaceIsMisnamed,
-  throwIfWrongNumberOfCallExpressionArgs,
-  throwIfMoreThanOneModuleRegistryCalls,
-  throwIfMoreThanOneModuleInterfaceParserError,
-  throwIfIncorrectModuleRegistryCallTypeParameterParserError,
-  throwIfIncorrectModuleRegistryCallArgument,
-  throwIfPartialNotAnnotatingTypeParameter,
-  throwIfPartialWithMoreParameter,
-} = require('../../error-utils');
-
-const language = 'TypeScript';
-
 function translateObjectTypeAnnotation(
   hasteModuleName: string,
   /**
@@ -139,6 +108,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,
   /**
@@ -196,97 +233,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': {
-          throwIfPartialWithMoreParameter(typeAnnotation);
-
-          const annotatedElement = parser.extractAnnotatedElement(
-            typeAnnotation,
-            types,
-          );
-
-          throwIfPartialNotAnnotatingTypeParameter(
-            typeAnnotation,
-            types,
-            parser,
-          );
-
-          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,23 +344,10 @@ function translateTypeAnnotation(
         typeResolutionStatus,
         nullable,
         hasteModuleName,
-        language,
         enumMap,
         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,
@@ -420,185 +365,31 @@ 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,
-        language,
+        aliasMap,
+        enumMap,
+        tryParse,
+        cxxOnly,
+        nullable,
+        parser,
       );
-    }
-  }
-}
-
-function buildModuleSchema(
-  hasteModuleName: string,
-  /**
-   * TODO(T108222691): Use flow-types for @babel/parser
-   */
-  ast: $FlowFixMe,
-  tryParse: ParserErrorCapturer,
-  parser: Parser,
-): NativeModuleSchema {
-  const types = parser.getTypes(ast);
-  const moduleSpecs = (Object.values(types): $ReadOnlyArray<$FlowFixMe>).filter(
-    t => parser.isModuleInterface(t),
-  );
-
-  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,
-    );
-
-    throwIfIncorrectModuleRegistryCallArgument(
-      hasteModuleName,
-      callExpression.arguments[0],
-      methodName,
-    );
-
-    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(
+      if (!commonType) {
+        throw new UnsupportedTypeAnnotationParserError(
           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,
-      },
-    );
+          typeAnnotation,
+          parser.language(),
+        );
+      }
+      return commonType;
+    }
+  }
 }
 
 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('../schema.js'),
-  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(
@@ -80,7 +86,13 @@ class TypeScriptParser {
     return 'TypeScript';
   }
   nameForGenericTypeAnnotation(typeAnnotation) {
-    return typeAnnotation.typeName.name;
+    var _typeAnnotation$typeN;
+    return typeAnnotation === null || typeAnnotation === void 0
+      ? void 0
+      : (_typeAnnotation$typeN = typeAnnotation.typeName) === null ||
+        _typeAnnotation$typeN === void 0
+      ? void 0
+      : _typeAnnotation$typeN.name;
   }
   checkIfInvalidModule(typeArguments) {
     return (
@@ -113,6 +125,8 @@ class TypeScriptParser {
       buildModuleSchema,
       Visitor,
       this,
+      resolveTypeAnnotation,
+      typeScriptTranslateTypeAnnotation,
     );
   }
   parseModuleFixture(filename) {
@@ -216,6 +230,9 @@ class TypeScriptParser {
       node.extends[0].expression.name === 'TurboModule'
     );
   }
+  isGenericTypeAnnotation(type) {
+    return type === 'TSTypeReference';
+  }
   extractAnnotatedElement(typeAnnotation, types) {
     return types[typeAnnotation.typeParameters.params[0].typeName.name];
   }
@@ -249,6 +266,73 @@ class TypeScriptParser {
       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;
+  }
+  bodyProperties(typeAlias) {
+    return typeAlias.body.body;
+  }
+  convertKeywordToTypeAnnotation(keyword) {
+    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 = {
   TypeScriptParser,