@react-native/codegen 0.72.1 → 0.72.3

package/lib/parsers/parsers-commons.js.flow

@@ -15,7 +15,6 @@ import type {
   NamedShape,
   NativeModuleAliasMap,
   NativeModuleBaseTypeAnnotation,
-  NativeModuleEnumDeclaration,
   NativeModuleSchema,
   NativeModuleTypeAnnotation,
   NativeModuleFunctionTypeAnnotation,
@@ -27,6 +26,13 @@ import type {
 import type {Parser} from './parser';
 import type {ParserType} from './errors';
 import type {ParserErrorCapturer, TypeDeclarationMap} from './utils';
+import type {ComponentSchemaBuilderConfig} from './schema.js';
+
+const {
+  getConfigType,
+  extractNativeModuleName,
+  createParserErrorCapturer,
+} = require('./utils');
 
 const {
   throwIfPropertyValueTypeIsUnsupported,
@@ -38,13 +44,11 @@ const {
 const {
   MissingTypeParameterGenericParserError,
   MoreThanOneTypeParameterGenericParserError,
-  UnsupportedEnumDeclarationParserError,
-  UnsupportedGenericParserError,
-  UnsupportedObjectPropertyTypeAnnotationParserError,
   UnnamedFunctionParamParserError,
 } = require('./errors');
 
 const invariant = require('invariant');
+import type {NativeModuleEnumMap} from '../CodegenSchema';
 
 function wrapModuleSchema(
   nativeModuleSchema: NativeModuleSchema,
@@ -116,15 +120,9 @@ function assertGenericTypeAnnotationHasExactlyOneTypeParameter(
 function isObjectProperty(property: $FlowFixMe, language: ParserType): boolean {
   switch (language) {
     case 'Flow':
-      return (
-        property.type === 'ObjectTypeProperty' ||
-        property.type === 'ObjectTypeIndexer'
-      );
+      return property.type === 'ObjectTypeProperty';
     case 'TypeScript':
-      return (
-        property.type === 'TSPropertySignature' ||
-        property.type === 'TSIndexSignature'
-      );
+      return property.type === 'TSPropertySignature';
     default:
       return false;
   }
@@ -135,6 +133,7 @@ function parseObjectProperty(
   hasteModuleName: string,
   types: TypeDeclarationMap,
   aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
   tryParse: ParserErrorCapturer,
   cxxOnly: boolean,
   nullable: boolean,
@@ -143,35 +142,13 @@ function parseObjectProperty(
 ): NamedShape<Nullable<NativeModuleBaseTypeAnnotation>> {
   const language = parser.language();
 
-  if (!isObjectProperty(property, language)) {
-    throw new UnsupportedObjectPropertyTypeAnnotationParserError(
-      hasteModuleName,
-      property,
-      property.type,
-      language,
-    );
-  }
-
-  const {optional = false} = property;
   const name = parser.getKeyName(property, hasteModuleName);
+  const {optional = false} = property;
   const languageTypeAnnotation =
     language === 'TypeScript'
       ? property.typeAnnotation.typeAnnotation
       : property.value;
 
-  if (
-    property.type === 'ObjectTypeIndexer' ||
-    property.type === 'TSIndexSignature'
-  ) {
-    return {
-      name,
-      optional,
-      typeAnnotation: wrapNullable(nullable, {
-        type: 'GenericObjectTypeAnnotation',
-      }), //TODO: use `emitObject` for typeAnnotation
-    };
-  }
-
   const [propertyTypeAnnotation, isPropertyNullable] =
     unwrapNullable<$FlowFixMe>(
       translateTypeAnnotation(
@@ -179,8 +156,10 @@ function parseObjectProperty(
         languageTypeAnnotation,
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
+        parser,
       ),
     );
 
@@ -194,7 +173,6 @@ function parseObjectProperty(
       languageTypeAnnotation,
       property.key,
       propertyTypeAnnotation.type,
-      language,
     );
   }
 
@@ -205,118 +183,43 @@ function parseObjectProperty(
   };
 }
 
-function translateDefault(
-  hasteModuleName: string,
-  typeAnnotation: $FlowFixMe,
-  types: TypeDeclarationMap,
-  nullable: boolean,
-  parser: Parser,
-): Nullable<NativeModuleEnumDeclaration> {
-  const maybeEnumDeclaration =
-    types[parser.nameForGenericTypeAnnotation(typeAnnotation)];
-
-  if (maybeEnumDeclaration && parser.isEnumDeclaration(maybeEnumDeclaration)) {
-    const memberType = parser.getMaybeEnumMemberType(maybeEnumDeclaration);
-
-    if (
-      memberType === 'NumberTypeAnnotation' ||
-      memberType === 'StringTypeAnnotation'
-    ) {
-      return wrapNullable(nullable, {
-        type: 'EnumDeclaration',
-        memberType: memberType,
-      });
-    } else {
-      throw new UnsupportedEnumDeclarationParserError(
-        hasteModuleName,
-        typeAnnotation,
-        memberType,
-        parser.language(),
-      );
-    }
-  }
-
-  throw new UnsupportedGenericParserError(
-    hasteModuleName,
-    typeAnnotation,
-    parser,
-  );
-}
-
-function getTypeAnnotationParameters(
-  typeAnnotation: $FlowFixMe,
-  language: ParserType,
-): $ReadOnlyArray<$FlowFixMe> {
-  return language === 'Flow'
-    ? typeAnnotation.params
-    : typeAnnotation.parameters;
-}
-
-function getFunctionNameFromParameter(
-  param: NamedShape<Nullable<NativeModuleParamTypeAnnotation>>,
-  language: ParserType,
-): $FlowFixMe {
-  return language === 'Flow' ? param.name : param.typeAnnotation;
-}
-
-function getParameterName(param: $FlowFixMe, language: ParserType): string {
-  return language === 'Flow' ? param.name.name : param.name;
-}
-
-function getParameterTypeAnnotation(
-  param: $FlowFixMe,
-  language: ParserType,
-): $FlowFixMe {
-  return language === 'Flow'
-    ? param.typeAnnotation
-    : param.typeAnnotation.typeAnnotation;
-}
-
-function getTypeAnnotationReturnType(
-  typeAnnotation: $FlowFixMe,
-  language: ParserType,
-): $FlowFixMe {
-  return language === 'Flow'
-    ? typeAnnotation.returnType
-    : typeAnnotation.typeAnnotation.typeAnnotation;
-}
-
 function translateFunctionTypeAnnotation(
   hasteModuleName: string,
   // TODO(T108222691): Use flow-types for @babel/parser
   // TODO(T71778680): This is a FunctionTypeAnnotation. Type this.
-  typeAnnotation: $FlowFixMe,
+  functionTypeAnnotation: $FlowFixMe,
   types: TypeDeclarationMap,
   aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
   tryParse: ParserErrorCapturer,
   cxxOnly: boolean,
   translateTypeAnnotation: $FlowFixMe,
-  language: ParserType,
+  parser: Parser,
 ): NativeModuleFunctionTypeAnnotation {
   type Param = NamedShape<Nullable<NativeModuleParamTypeAnnotation>>;
   const params: Array<Param> = [];
 
-  for (const param of getTypeAnnotationParameters(typeAnnotation, language)) {
+  for (const param of parser.getFunctionTypeAnnotationParameters(
+    functionTypeAnnotation,
+  )) {
     const parsedParam = tryParse(() => {
-      if (getFunctionNameFromParameter(param, language) == null) {
-        throw new UnnamedFunctionParamParserError(
-          param,
-          hasteModuleName,
-          language,
-        );
+      if (parser.getFunctionNameFromParameter(param) == null) {
+        throw new UnnamedFunctionParamParserError(param, hasteModuleName);
       }
 
-      const paramName = getParameterName(param, language);
+      const paramName = parser.getParameterName(param);
 
       const [paramTypeAnnotation, isParamTypeAnnotationNullable] =
         unwrapNullable<$FlowFixMe>(
           translateTypeAnnotation(
             hasteModuleName,
-            getParameterTypeAnnotation(param, language),
+            parser.getParameterTypeAnnotation(param),
             types,
             aliasMap,
+            enumMap,
             tryParse,
             cxxOnly,
+            parser,
           ),
         );
 
@@ -351,19 +254,20 @@ function translateFunctionTypeAnnotation(
     unwrapNullable<$FlowFixMe>(
       translateTypeAnnotation(
         hasteModuleName,
-        getTypeAnnotationReturnType(typeAnnotation, language),
+        parser.getFunctionTypeAnnotationReturnType(functionTypeAnnotation),
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
+        parser,
       ),
     );
 
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError(
     hasteModuleName,
-    typeAnnotation,
+    functionTypeAnnotation,
     'FunctionTypeAnnotation',
-    language,
     cxxOnly,
     returnTypeAnnotation.type,
   );
@@ -388,17 +292,18 @@ function buildPropertySchema(
   property: $FlowFixMe,
   types: TypeDeclarationMap,
   aliasMap: {...NativeModuleAliasMap},
+  enumMap: {...NativeModuleEnumMap},
   tryParse: ParserErrorCapturer,
   cxxOnly: boolean,
-  language: ParserType,
   resolveTypeAnnotation: $FlowFixMe,
   translateTypeAnnotation: $FlowFixMe,
+  parser: Parser,
 ): NativeModulePropertyShape {
   let nullable: boolean = false;
   let {key, value} = property;
   const methodName: string = key.name;
 
-  if (language === 'TypeScript') {
+  if (parser.language() === 'TypeScript') {
     value =
       property.type === 'TSMethodSignature'
         ? property
@@ -412,7 +317,7 @@ function buildPropertySchema(
     property.value,
     key.name,
     value.type,
-    language,
+    parser.language(),
   );
 
   return {
@@ -425,15 +330,114 @@ function buildPropertySchema(
         value,
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
         translateTypeAnnotation,
-        language,
+        parser,
       ),
     ),
   };
 }
 
+function buildSchemaFromConfigType(
+  configType: 'module' | 'component' | 'none',
+  filename: ?string,
+  ast: $FlowFixMe,
+  wrapComponentSchema: (config: ComponentSchemaBuilderConfig) => SchemaType,
+  buildComponentSchema: (
+    ast: $FlowFixMe,
+    parser: Parser,
+  ) => ComponentSchemaBuilderConfig,
+  buildModuleSchema: (
+    hasteModuleName: string,
+    ast: $FlowFixMe,
+    tryParse: ParserErrorCapturer,
+    parser: Parser,
+  ) => NativeModuleSchema,
+  parser: Parser,
+): SchemaType {
+  switch (configType) {
+    case 'component': {
+      return wrapComponentSchema(buildComponentSchema(ast, parser));
+    }
+    case 'module': {
+      if (filename === undefined || filename === null) {
+        throw new Error('Filepath expected while parasing a module');
+      }
+      const nativeModuleName = extractNativeModuleName(filename);
+
+      const [parsingErrors, tryParse] = createParserErrorCapturer();
+
+      const schema = tryParse(() =>
+        buildModuleSchema(nativeModuleName, ast, tryParse, parser),
+      );
+
+      if (parsingErrors.length > 0) {
+        /**
+         * TODO(T77968131): We have two options:
+         *  - Throw the first error, but indicate there are more then one errors.
+         *  - Display all errors, nicely formatted.
+         *
+         * For the time being, we're just throw the first error.
+         **/
+
+        throw parsingErrors[0];
+      }
+
+      invariant(
+        schema != null,
+        'When there are no parsing errors, the schema should not be null',
+      );
+
+      return wrapModuleSchema(schema, nativeModuleName);
+    }
+    default:
+      return {modules: {}};
+  }
+}
+
+function buildSchema(
+  contents: string,
+  filename: ?string,
+  wrapComponentSchema: (config: ComponentSchemaBuilderConfig) => SchemaType,
+  buildComponentSchema: (
+    ast: $FlowFixMe,
+    parser: Parser,
+  ) => ComponentSchemaBuilderConfig,
+  buildModuleSchema: (
+    hasteModuleName: string,
+    ast: $FlowFixMe,
+    tryParse: ParserErrorCapturer,
+    parser: Parser,
+  ) => NativeModuleSchema,
+  Visitor: ({isComponent: boolean, isModule: boolean}) => {
+    [type: string]: (node: $FlowFixMe) => void,
+  },
+  parser: Parser,
+): SchemaType {
+  // Early return for non-Spec JavaScript files
+  if (
+    !contents.includes('codegenNativeComponent') &&
+    !contents.includes('TurboModule')
+  ) {
+    return {modules: {}};
+  }
+
+  const ast = parser.getAst(contents);
+  const configType = getConfigType(ast, Visitor);
+
+  return buildSchemaFromConfigType(
+    configType,
+    filename,
+    ast,
+    wrapComponentSchema,
+    buildComponentSchema,
+    buildModuleSchema,
+    parser,
+  );
+}
+
 module.exports = {
   wrapModuleSchema,
   unwrapNullable,
@@ -441,7 +445,8 @@ module.exports = {
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   isObjectProperty,
   parseObjectProperty,
-  translateDefault,
   translateFunctionTypeAnnotation,
   buildPropertySchema,
+  buildSchemaFromConfigType,
+  buildSchema,
 };

package/lib/parsers/parsers-primitives.js

@@ -80,7 +80,10 @@ function _arrayWithHoles(arr) {
 }
 const _require = require('./errors'),
   UnsupportedUnionTypeAnnotationParserError =
-    _require.UnsupportedUnionTypeAnnotationParserError;
+    _require.UnsupportedUnionTypeAnnotationParserError,
+  UnsupportedTypeAnnotationParserError =
+    _require.UnsupportedTypeAnnotationParserError,
+  ParserError = _require.ParserError;
 const _require2 = require('./error-utils'),
   throwIfArrayElementTypeAnnotationIsUnsupported =
     _require2.throwIfArrayElementTypeAnnotationIsUnsupported;
@@ -134,20 +137,22 @@ function emitFunction(
   typeAnnotation,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
   translateTypeAnnotation,
-  language,
+  parser,
 ) {
   const translateFunctionTypeAnnotationValue = translateFunctionTypeAnnotation(
     hasteModuleName,
     typeAnnotation,
     types,
     aliasMap,
+    enumMap,
     tryParse,
     cxxOnly,
     translateTypeAnnotation,
-    language,
+    parser,
   );
   return wrapNullable(nullable, translateFunctionTypeAnnotationValue);
 }
@@ -162,19 +167,19 @@ function emitString(nullable) {
   });
 }
 function typeAliasResolution(
-  typeAliasResolutionStatus,
+  typeResolution,
   objectTypeAnnotation,
   aliasMap,
   nullable,
 ) {
-  if (!typeAliasResolutionStatus.successful) {
+  if (!typeResolution.successful) {
     return wrapNullable(nullable, objectTypeAnnotation);
   }
 
   /**
    * All aliases RHS are required.
    */
-  aliasMap[typeAliasResolutionStatus.aliasName] = objectTypeAnnotation;
+  aliasMap[typeResolution.name] = objectTypeAnnotation;
 
   /**
    * Nullability of type aliases is transitive.
@@ -207,7 +212,51 @@ function typeAliasResolution(
    */
   return wrapNullable(nullable, {
     type: 'TypeAliasTypeAnnotation',
-    name: typeAliasResolutionStatus.aliasName,
+    name: typeResolution.name,
+  });
+}
+function typeEnumResolution(
+  typeAnnotation,
+  typeResolution,
+  nullable,
+  hasteModuleName,
+  language,
+  enumMap,
+  parser,
+) {
+  if (!typeResolution.successful || typeResolution.type !== 'enum') {
+    throw new UnsupportedTypeAnnotationParserError(
+      hasteModuleName,
+      typeAnnotation,
+      language,
+    );
+  }
+  const enumName = typeResolution.name;
+  const enumMemberType = parser.parseEnumMembersType(typeAnnotation);
+  try {
+    parser.validateEnumMembersSupported(typeAnnotation, enumMemberType);
+  } catch (e) {
+    if (e instanceof Error) {
+      throw new ParserError(
+        hasteModuleName,
+        typeAnnotation,
+        `Failed parsing the enum ${enumName} in ${hasteModuleName} with the error: ${e.message}`,
+      );
+    } else {
+      throw e;
+    }
+  }
+  const enumMembers = parser.parseEnumMembers(typeAnnotation);
+  enumMap[enumName] = {
+    name: enumName,
+    type: 'EnumDeclarationWithMembers',
+    memberType: enumMemberType,
+    members: enumMembers,
+  };
+  return wrapNullable(nullable, {
+    name: enumName,
+    type: 'EnumDeclaration',
+    memberType: enumMemberType,
   });
 }
 function emitPromise(
@@ -217,6 +266,7 @@ function emitPromise(
   nullable,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
   translateTypeAnnotation,
@@ -243,8 +293,10 @@ function emitPromise(
           typeAnnotation.typeParameters.params[0],
           types,
           aliasMap,
+          enumMap,
           tryParse,
           cxxOnly,
+          parser,
         ),
       });
     } catch {
@@ -254,11 +306,17 @@ function emitPromise(
     }
   }
 }
-function emitObject(nullable) {
+function emitGenericObject(nullable) {
   return wrapNullable(nullable, {
     type: 'GenericObjectTypeAnnotation',
   });
 }
+function emitObject(nullable, properties) {
+  return wrapNullable(nullable, {
+    type: 'ObjectTypeAnnotation',
+    properties,
+  });
+}
 function emitFloat(nullable) {
   return wrapNullable(nullable, {
     type: 'FloatTypeAnnotation',
@@ -275,7 +333,6 @@ function emitUnion(nullable, hasteModuleName, typeAnnotation, parser) {
       hasteModuleName,
       typeAnnotation,
       unionTypes,
-      parser.language(),
     );
   }
   return wrapNullable(nullable, {
@@ -287,12 +344,13 @@ function translateArrayTypeAnnotation(
   hasteModuleName,
   types,
   aliasMap,
+  enumMap,
   cxxOnly,
   arrayType,
   elementType,
   nullable,
-  language,
   translateTypeAnnotation,
+  parser,
 ) {
   try {
     /**
@@ -306,6 +364,7 @@ function translateArrayTypeAnnotation(
           elementType,
           types,
           aliasMap,
+          enumMap,
           /**
            * TODO(T72031674): Ensure that all ParsingErrors that are thrown
            * while parsing the array element don't get captured and collected.
@@ -316,6 +375,7 @@ function translateArrayTypeAnnotation(
            */
           nullGuard,
           cxxOnly,
+          parser,
         ),
       ),
       _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
@@ -326,7 +386,6 @@ function translateArrayTypeAnnotation(
       elementType,
       arrayType,
       _elementType.type,
-      language,
     );
     return wrapNullable(nullable, {
       type: 'ArrayTypeAnnotation',
@@ -345,6 +404,7 @@ function emitArrayType(
   parser,
   types,
   aliasMap,
+  enumMap,
   cxxOnly,
   nullable,
   translateTypeAnnotation,
@@ -358,12 +418,13 @@ function emitArrayType(
     hasteModuleName,
     types,
     aliasMap,
+    enumMap,
     cxxOnly,
     typeAnnotation.type,
     typeAnnotation.typeParameters.params[0],
     nullable,
-    parser.language(),
     translateTypeAnnotation,
+    parser,
   );
 }
 module.exports = {
@@ -374,6 +435,7 @@ module.exports = {
   emitFunction,
   emitInt32,
   emitNumber,
+  emitGenericObject,
   emitObject,
   emitPromise,
   emitRootTag,
@@ -383,5 +445,6 @@ module.exports = {
   emitMixed,
   emitUnion,
   typeAliasResolution,
+  typeEnumResolution,
   translateArrayTypeAnnotation,
 };