@react-native/codegen 0.72.1 → 0.72.2

package/lib/parsers/parserMock.js

@@ -38,9 +38,26 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
+// $FlowFixMe[untyped-import] there's no flowtype flow-parser
+const flowParser = require('flow-parser');
 const _require = require('./errors'),
   UnsupportedObjectPropertyTypeAnnotationParserError =
     _require.UnsupportedObjectPropertyTypeAnnotationParserError;
+const schemaMock = {
+  modules: {
+    StringPropNativeComponentView: {
+      type: 'Component',
+      components: {
+        StringPropNativeComponentView: {
+          extendsProps: [],
+          events: [],
+          props: [],
+          commands: [],
+        },
+      },
+    },
+  },
+};
 export class MockedParser {
   constructor() {
     _defineProperty(
@@ -49,37 +66,19 @@ export class MockedParser {
       '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';
@@ -93,4 +92,62 @@ export class MockedParser {
   remapUnionTypeAnnotationMemberNames(membersTypes) {
     return [];
   }
+  parseFile(filename) {
+    return schemaMock;
+  }
+  parseString(contents, filename) {
+    return schemaMock;
+  }
+  parseModuleFixture(filename) {
+    return schemaMock;
+  }
+  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) {
+    return typeAnnotation.type;
+  }
+  validateEnumMembersSupported(typeAnnotation, enumMembersType) {
+    return;
+  }
+  parseEnumMembers(typeAnnotation) {
+    return typeAnnotation.type === 'StringTypeAnnotation'
+      ? [
+          {
+            name: 'Hello',
+            value: 'hello',
+          },
+          {
+            name: 'Goodbye',
+            value: 'goodbye',
+          },
+        ]
+      : [
+          {
+            name: 'On',
+            value: '1',
+          },
+          {
+            name: 'Off',
+            value: '0',
+          },
+        ];
+  }
 }

package/lib/parsers/parserMock.js.flow

@@ -10,42 +10,57 @@
 
 'use strict';
 
-import type {UnionTypeAnnotationMemberType} from '../CodegenSchema.js';
 import type {Parser} from './parser';
 import type {ParserType} from './errors';
+import type {
+  UnionTypeAnnotationMemberType,
+  SchemaType,
+  NamedShape,
+  Nullable,
+  NativeModuleParamTypeAnnotation,
+  NativeModuleEnumMemberType,
+  NativeModuleEnumMembers,
+} from '../CodegenSchema';
 
+// $FlowFixMe[untyped-import] there's no flowtype flow-parser
+const flowParser = require('flow-parser');
 const {
   UnsupportedObjectPropertyTypeAnnotationParserError,
 } = require('./errors');
 
+const schemaMock = {
+  modules: {
+    StringPropNativeComponentView: {
+      type: 'Component',
+      components: {
+        StringPropNativeComponentView: {
+          extendsProps: [],
+          events: [],
+          props: [],
+          commands: [],
+        },
+      },
+    },
+  },
+};
+
 export class MockedParser implements Parser {
   typeParameterInstantiation: string = 'TypeParameterInstantiation';
 
-  getKeyName(propertyOrIndex: $FlowFixMe, hasteModuleName: string): string {
-    switch (propertyOrIndex.type) {
-      case 'ObjectTypeProperty':
-        return propertyOrIndex.key.name;
-      case 'ObjectTypeIndexer':
-        // flow index name is optional
-        return propertyOrIndex.id?.name ?? 'key';
-      default:
-        throw new UnsupportedObjectPropertyTypeAnnotationParserError(
-          hasteModuleName,
-          propertyOrIndex,
-          propertyOrIndex.type,
-          this.language(),
-        );
-    }
-  }
-
-  getMaybeEnumMemberType(maybeEnumDeclaration: $FlowFixMe): string {
-    return maybeEnumDeclaration.body.type
-      .replace('EnumNumberBody', 'NumberTypeAnnotation')
-      .replace('EnumStringBody', 'StringTypeAnnotation');
+  isProperty(property: $FlowFixMe): boolean {
+    return property.type === 'ObjectTypeProperty';
   }
 
-  isEnumDeclaration(maybeEnumDeclaration: $FlowFixMe): boolean {
-    return maybeEnumDeclaration.type === 'EnumDeclaration';
+  getKeyName(property: $FlowFixMe, hasteModuleName: string): string {
+    if (!this.isProperty(property)) {
+      throw new UnsupportedObjectPropertyTypeAnnotationParserError(
+        hasteModuleName,
+        property,
+        property.type,
+        this.language(),
+      );
+    }
+    return property.key.name;
   }
 
   language(): ParserType {
@@ -65,4 +80,83 @@ export class MockedParser implements Parser {
   ): UnionTypeAnnotationMemberType[] {
     return [];
   }
+
+  parseFile(filename: string): SchemaType {
+    return schemaMock;
+  }
+
+  parseString(contents: string, filename: ?string): SchemaType {
+    return schemaMock;
+  }
+
+  parseModuleFixture(filename: string): SchemaType {
+    return schemaMock;
+  }
+
+  getAst(contents: string): $FlowFixMe {
+    return flowParser.parse(contents, {
+      enums: true,
+    });
+  }
+
+  getFunctionTypeAnnotationParameters(
+    functionTypeAnnotation: $FlowFixMe,
+  ): $ReadOnlyArray<$FlowFixMe> {
+    return functionTypeAnnotation.params;
+  }
+
+  getFunctionNameFromParameter(
+    parameter: NamedShape<Nullable<NativeModuleParamTypeAnnotation>>,
+  ): $FlowFixMe {
+    return parameter.name;
+  }
+
+  getParameterName(parameter: $FlowFixMe): string {
+    return parameter.name.name;
+  }
+
+  getParameterTypeAnnotation(parameter: $FlowFixMe): $FlowFixMe {
+    return parameter.typeAnnotation;
+  }
+
+  getFunctionTypeAnnotationReturnType(
+    functionTypeAnnotation: $FlowFixMe,
+  ): $FlowFixMe {
+    return functionTypeAnnotation.returnType;
+  }
+
+  parseEnumMembersType(typeAnnotation: $FlowFixMe): NativeModuleEnumMemberType {
+    return typeAnnotation.type;
+  }
+
+  validateEnumMembersSupported(
+    typeAnnotation: $FlowFixMe,
+    enumMembersType: NativeModuleEnumMemberType,
+  ): void {
+    return;
+  }
+
+  parseEnumMembers(typeAnnotation: $FlowFixMe): NativeModuleEnumMembers {
+    return typeAnnotation.type === 'StringTypeAnnotation'
+      ? [
+          {
+            name: 'Hello',
+            value: 'hello',
+          },
+          {
+            name: 'Goodbye',
+            value: 'goodbye',
+          },
+        ]
+      : [
+          {
+            name: 'On',
+            value: '1',
+          },
+          {
+            name: 'Off',
+            value: '0',
+          },
+        ];
+  }
 }

package/lib/parsers/parsers-commons.js

@@ -78,25 +78,24 @@ function _iterableToArrayLimit(arr, i) {
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
-const _require = require('./error-utils'),
+const _require = require('./utils'),
+  getConfigType = _require.getConfigType,
+  extractNativeModuleName = _require.extractNativeModuleName,
+  createParserErrorCapturer = _require.createParserErrorCapturer;
+const _require2 = require('./error-utils'),
   throwIfPropertyValueTypeIsUnsupported =
-    _require.throwIfPropertyValueTypeIsUnsupported,
+    _require2.throwIfPropertyValueTypeIsUnsupported,
   throwIfUnsupportedFunctionParamTypeAnnotationParserError =
-    _require.throwIfUnsupportedFunctionParamTypeAnnotationParserError,
+    _require2.throwIfUnsupportedFunctionParamTypeAnnotationParserError,
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError =
-    _require.throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
-  throwIfModuleTypeIsUnsupported = _require.throwIfModuleTypeIsUnsupported;
-const _require2 = require('./errors'),
+    _require2.throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
+  throwIfModuleTypeIsUnsupported = _require2.throwIfModuleTypeIsUnsupported;
+const _require3 = require('./errors'),
   MissingTypeParameterGenericParserError =
-    _require2.MissingTypeParameterGenericParserError,
+    _require3.MissingTypeParameterGenericParserError,
   MoreThanOneTypeParameterGenericParserError =
-    _require2.MoreThanOneTypeParameterGenericParserError,
-  UnsupportedEnumDeclarationParserError =
-    _require2.UnsupportedEnumDeclarationParserError,
-  UnsupportedGenericParserError = _require2.UnsupportedGenericParserError,
-  UnsupportedObjectPropertyTypeAnnotationParserError =
-    _require2.UnsupportedObjectPropertyTypeAnnotationParserError,
-  UnnamedFunctionParamParserError = _require2.UnnamedFunctionParamParserError;
+    _require3.MoreThanOneTypeParameterGenericParserError,
+  UnnamedFunctionParamParserError = _require3.UnnamedFunctionParamParserError;
 const invariant = require('invariant');
 function wrapModuleSchema(nativeModuleSchema, hasteModuleName) {
   return {
@@ -151,15 +150,9 @@ function assertGenericTypeAnnotationHasExactlyOneTypeParameter(
 function isObjectProperty(property, language) {
   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;
   }
@@ -169,6 +162,7 @@ function parseObjectProperty(
   hasteModuleName,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
   nullable,
@@ -176,42 +170,23 @@ function parseObjectProperty(
   parser,
 ) {
   const language = parser.language();
-  if (!isObjectProperty(property, language)) {
-    throw new UnsupportedObjectPropertyTypeAnnotationParserError(
-      hasteModuleName,
-      property,
-      property.type,
-      language,
-    );
-  }
+  const name = parser.getKeyName(property, hasteModuleName);
   const _property$optional = property.optional,
     optional = _property$optional === void 0 ? false : _property$optional;
-  const name = parser.getKeyName(property, hasteModuleName);
   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 _unwrapNullable = unwrapNullable(
       translateTypeAnnotation(
         hasteModuleName,
         languageTypeAnnotation,
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
+        parser,
       ),
     ),
     _unwrapNullable2 = _slicedToArray(_unwrapNullable, 2),
@@ -227,7 +202,6 @@ function parseObjectProperty(
       languageTypeAnnotation,
       property.key,
       propertyTypeAnnotation.type,
-      language,
     );
   }
   return {
@@ -236,92 +210,38 @@ function parseObjectProperty(
     typeAnnotation: wrapNullable(isPropertyNullable, propertyTypeAnnotation),
   };
 }
-function translateDefault(
-  hasteModuleName,
-  typeAnnotation,
-  types,
-  nullable,
-  parser,
-) {
-  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, language) {
-  return language === 'Flow'
-    ? typeAnnotation.params
-    : typeAnnotation.parameters;
-}
-function getFunctionNameFromParameter(param, language) {
-  return language === 'Flow' ? param.name : param.typeAnnotation;
-}
-function getParameterName(param, language) {
-  return language === 'Flow' ? param.name.name : param.name;
-}
-function getParameterTypeAnnotation(param, language) {
-  return language === 'Flow'
-    ? param.typeAnnotation
-    : param.typeAnnotation.typeAnnotation;
-}
-function getTypeAnnotationReturnType(typeAnnotation, language) {
-  return language === 'Flow'
-    ? typeAnnotation.returnType
-    : typeAnnotation.typeAnnotation.typeAnnotation;
-}
 function translateFunctionTypeAnnotation(
   hasteModuleName,
   // TODO(T108222691): Use flow-types for @babel/parser
   // TODO(T71778680): This is a FunctionTypeAnnotation. Type this.
-  typeAnnotation,
+  functionTypeAnnotation,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
   translateTypeAnnotation,
-  language,
+  parser,
 ) {
   const params = [];
-  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 _unwrapNullable3 = unwrapNullable(
           translateTypeAnnotation(
             hasteModuleName,
-            getParameterTypeAnnotation(param, language),
+            parser.getParameterTypeAnnotation(param),
             types,
             aliasMap,
+            enumMap,
             tryParse,
             cxxOnly,
+            parser,
           ),
         ),
         _unwrapNullable4 = _slicedToArray(_unwrapNullable3, 2),
@@ -354,11 +274,13 @@ function translateFunctionTypeAnnotation(
   const _unwrapNullable5 = unwrapNullable(
       translateTypeAnnotation(
         hasteModuleName,
-        getTypeAnnotationReturnType(typeAnnotation, language),
+        parser.getFunctionTypeAnnotationReturnType(functionTypeAnnotation),
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
+        parser,
       ),
     ),
     _unwrapNullable6 = _slicedToArray(_unwrapNullable5, 2),
@@ -366,9 +288,8 @@ function translateFunctionTypeAnnotation(
     isReturnTypeAnnotationNullable = _unwrapNullable6[1];
   throwIfUnsupportedFunctionReturnTypeAnnotationParserError(
     hasteModuleName,
-    typeAnnotation,
+    functionTypeAnnotation,
     'FunctionTypeAnnotation',
-    language,
     cxxOnly,
     returnTypeAnnotation.type,
   );
@@ -391,17 +312,18 @@ function buildPropertySchema(
   property,
   types,
   aliasMap,
+  enumMap,
   tryParse,
   cxxOnly,
-  language,
   resolveTypeAnnotation,
   translateTypeAnnotation,
+  parser,
 ) {
   let nullable = false;
   let key = property.key,
     value = property.value;
   const methodName = key.name;
-  if (language === 'TypeScript') {
+  if (parser.language() === 'TypeScript') {
     value =
       property.type === 'TSMethodSignature'
         ? property
@@ -415,7 +337,7 @@ function buildPropertySchema(
     property.value,
     key.name,
     value.type,
-    language,
+    parser.language(),
   );
   return {
     name: methodName,
@@ -427,14 +349,93 @@ function buildPropertySchema(
         value,
         types,
         aliasMap,
+        enumMap,
         tryParse,
         cxxOnly,
         translateTypeAnnotation,
-        language,
+        parser,
       ),
     ),
   };
 }
+function buildSchemaFromConfigType(
+  configType,
+  filename,
+  ast,
+  wrapComponentSchema,
+  buildComponentSchema,
+  buildModuleSchema,
+  parser,
+) {
+  switch (configType) {
+    case 'component': {
+      return wrapComponentSchema(buildComponentSchema(ast));
+    }
+    case 'module': {
+      if (filename === undefined || filename === null) {
+        throw new Error('Filepath expected while parasing a module');
+      }
+      const nativeModuleName = extractNativeModuleName(filename);
+      const _createParserErrorCap = createParserErrorCapturer(),
+        _createParserErrorCap2 = _slicedToArray(_createParserErrorCap, 2),
+        parsingErrors = _createParserErrorCap2[0],
+        tryParse = _createParserErrorCap2[1];
+      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,
+  filename,
+  wrapComponentSchema,
+  buildComponentSchema,
+  buildModuleSchema,
+  Visitor,
+  parser,
+) {
+  // 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,
@@ -442,7 +443,8 @@ module.exports = {
   assertGenericTypeAnnotationHasExactlyOneTypeParameter,
   isObjectProperty,
   parseObjectProperty,
-  translateDefault,
   translateFunctionTypeAnnotation,
   buildPropertySchema,
+  buildSchemaFromConfigType,
+  buildSchema,
 };