@react-native/codegen 0.72.1

package/lib/parsers/consistency/compareSnaps.js

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+'use strict';
+
+function compareSnaps(
+  flowFixtures,
+  flowSnaps,
+  flowExtraCases,
+  tsFixtures,
+  tsSnaps,
+  tsExtraCases,
+  ignoredCases,
+) {
+  const flowCases = Object.keys(flowFixtures).sort();
+  const tsCases = Object.keys(tsFixtures).sort();
+  const commonCases = flowCases.filter(name => tsCases.indexOf(name) !== -1);
+  describe('RN Codegen Parsers', () => {
+    it('should not unintentionally contains test case for Flow but not for TypeScript', () => {
+      expect(
+        flowCases.filter(name => commonCases.indexOf(name) === -1),
+      ).toEqual(flowExtraCases);
+    });
+    it('should not unintentionally contains test case for TypeScript but not for Flow', () => {
+      expect(tsCases.filter(name => commonCases.indexOf(name) === -1)).toEqual(
+        tsExtraCases,
+      );
+    });
+    for (const commonCase of commonCases) {
+      const flowSnap =
+        flowSnaps[
+          `RN Codegen Flow Parser can generate fixture ${commonCase} 1`
+        ];
+      const tsSnap =
+        tsSnaps[
+          `RN Codegen TypeScript Parser can generate fixture ${commonCase} 1`
+        ];
+      it(`should be able to find the snapshot for Flow for case ${commonCase}`, () => {
+        expect(typeof flowSnap).toEqual('string');
+      });
+      it(`should be able to find the snapshot for TypeScript for case ${commonCase}`, () => {
+        expect(typeof tsSnap).toEqual('string');
+      });
+      if (ignoredCases.indexOf(commonCase) === -1) {
+        it(`should generate the same snapshot from Flow and TypeScript for fixture ${commonCase}`, () => {
+          expect(flowSnap).toEqual(tsSnap);
+        });
+      } else {
+        it(`should generate the different snapshot from Flow and TypeScript for fixture ${commonCase}`, () => {
+          expect(flowSnap).not.toEqual(tsSnap);
+        });
+      }
+    }
+  });
+}
+function compareTsArraySnaps(tsSnaps, tsExtraCases) {
+  for (const array2Case of tsExtraCases.filter(
+    name => name.indexOf('ARRAY2') !== -1,
+  )) {
+    const arrayCase = array2Case.replace('ARRAY2', 'ARRAY');
+    it(`should generate the same snap from fixture ${arrayCase} and ${array2Case}`, () => {
+      expect(
+        tsSnaps[
+          `RN Codegen TypeScript Parser can generate fixture ${arrayCase}`
+        ],
+      ).toEqual(
+        tsSnaps[
+          `RN Codegen TypeScript Parser can generate fixture ${array2Case}`
+        ],
+      );
+    });
+  }
+}
+module.exports = {
+  compareSnaps,
+  compareTsArraySnaps,
+};

package/lib/parsers/error-utils.js

@@ -0,0 +1,284 @@
+/**
+ * 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.
+ *
+ *
+ * @format
+ */
+
+'use strict';
+
+const _require = require('./errors'),
+  MisnamedModuleInterfaceParserError =
+    _require.MisnamedModuleInterfaceParserError,
+  UnsupportedFunctionReturnTypeAnnotationParserError =
+    _require.UnsupportedFunctionReturnTypeAnnotationParserError,
+  ModuleInterfaceNotFoundParserError =
+    _require.ModuleInterfaceNotFoundParserError,
+  MoreThanOneModuleRegistryCallsParserError =
+    _require.MoreThanOneModuleRegistryCallsParserError,
+  UnusedModuleInterfaceParserError = _require.UnusedModuleInterfaceParserError,
+  IncorrectModuleRegistryCallArityParserError =
+    _require.IncorrectModuleRegistryCallArityParserError,
+  IncorrectModuleRegistryCallTypeParameterParserError =
+    _require.IncorrectModuleRegistryCallTypeParameterParserError,
+  UnsupportedObjectPropertyValueTypeAnnotationParserError =
+    _require.UnsupportedObjectPropertyValueTypeAnnotationParserError,
+  UntypedModuleRegistryCallParserError =
+    _require.UntypedModuleRegistryCallParserError,
+  UnsupportedModulePropertyParserError =
+    _require.UnsupportedModulePropertyParserError,
+  MoreThanOneModuleInterfaceParserError =
+    _require.MoreThanOneModuleInterfaceParserError,
+  UnsupportedFunctionParamTypeAnnotationParserError =
+    _require.UnsupportedFunctionParamTypeAnnotationParserError,
+  UnsupportedArrayElementTypeAnnotationParserError =
+    _require.UnsupportedArrayElementTypeAnnotationParserError;
+function throwIfModuleInterfaceIsMisnamed(
+  nativeModuleName,
+  moduleSpecId,
+  parserType,
+) {
+  if (moduleSpecId.name !== 'Spec') {
+    throw new MisnamedModuleInterfaceParserError(
+      nativeModuleName,
+      moduleSpecId,
+      parserType,
+    );
+  }
+}
+function throwIfModuleInterfaceNotFound(
+  numberOfModuleSpecs,
+  nativeModuleName,
+  ast,
+  parserType,
+) {
+  if (numberOfModuleSpecs === 0) {
+    throw new ModuleInterfaceNotFoundParserError(
+      nativeModuleName,
+      ast,
+      parserType,
+    );
+  }
+}
+function throwIfMoreThanOneModuleRegistryCalls(
+  hasteModuleName,
+  callExpressions,
+  callExpressionsLength,
+  language,
+) {
+  if (callExpressions.length > 1) {
+    throw new MoreThanOneModuleRegistryCallsParserError(
+      hasteModuleName,
+      callExpressions,
+      callExpressionsLength,
+      language,
+    );
+  }
+}
+function throwIfUnusedModuleInterfaceParserError(
+  nativeModuleName,
+  moduleSpec,
+  callExpressions,
+  language,
+) {
+  if (callExpressions.length === 0) {
+    throw new UnusedModuleInterfaceParserError(
+      nativeModuleName,
+      moduleSpec,
+      language,
+    );
+  }
+}
+function throwIfWrongNumberOfCallExpressionArgs(
+  nativeModuleName,
+  flowCallExpression,
+  methodName,
+  numberOfCallExpressionArgs,
+  language,
+) {
+  if (numberOfCallExpressionArgs !== 1) {
+    throw new IncorrectModuleRegistryCallArityParserError(
+      nativeModuleName,
+      flowCallExpression,
+      methodName,
+      numberOfCallExpressionArgs,
+      language,
+    );
+  }
+}
+function throwIfIncorrectModuleRegistryCallTypeParameterParserError(
+  nativeModuleName,
+  typeArguments,
+  methodName,
+  moduleName,
+  parser,
+) {
+  function throwError() {
+    throw new IncorrectModuleRegistryCallTypeParameterParserError(
+      nativeModuleName,
+      typeArguments,
+      methodName,
+      moduleName,
+      parser.language(),
+    );
+  }
+  if (parser.checkIfInvalidModule(typeArguments)) {
+    throwError();
+  }
+}
+function throwIfUnsupportedFunctionReturnTypeAnnotationParserError(
+  nativeModuleName,
+  returnTypeAnnotation,
+  invalidReturnType,
+  language,
+  cxxOnly,
+  returnType,
+) {
+  if (!cxxOnly && returnType === 'FunctionTypeAnnotation') {
+    throw new UnsupportedFunctionReturnTypeAnnotationParserError(
+      nativeModuleName,
+      returnTypeAnnotation.returnType,
+      'FunctionTypeAnnotation',
+      language,
+    );
+  }
+}
+function throwIfUntypedModule(
+  typeArguments,
+  hasteModuleName,
+  callExpression,
+  methodName,
+  moduleName,
+  language,
+) {
+  if (typeArguments == null) {
+    throw new UntypedModuleRegistryCallParserError(
+      hasteModuleName,
+      callExpression,
+      methodName,
+      moduleName,
+      language,
+    );
+  }
+}
+function throwIfModuleTypeIsUnsupported(
+  nativeModuleName,
+  propertyValue,
+  propertyName,
+  propertyValueType,
+  language,
+) {
+  if (language === 'Flow' && propertyValueType !== 'FunctionTypeAnnotation') {
+    throw new UnsupportedModulePropertyParserError(
+      nativeModuleName,
+      propertyValue,
+      propertyName,
+      propertyValueType,
+      language,
+    );
+  } else if (
+    language === 'TypeScript' &&
+    propertyValueType !== 'TSFunctionType' &&
+    propertyValueType !== 'TSMethodSignature'
+  ) {
+    throw new UnsupportedModulePropertyParserError(
+      nativeModuleName,
+      propertyValue,
+      propertyName,
+      propertyValueType,
+      language,
+    );
+  }
+}
+const UnsupportedObjectPropertyTypeToInvalidPropertyValueTypeMap = {
+  FunctionTypeAnnotation: 'FunctionTypeAnnotation',
+  VoidTypeAnnotation: 'void',
+  PromiseTypeAnnotation: 'Promise',
+};
+function throwIfPropertyValueTypeIsUnsupported(
+  moduleName,
+  propertyValue,
+  propertyKey,
+  type,
+  language,
+) {
+  const invalidPropertyValueType =
+    UnsupportedObjectPropertyTypeToInvalidPropertyValueTypeMap[type];
+  throw new UnsupportedObjectPropertyValueTypeAnnotationParserError(
+    moduleName,
+    propertyValue,
+    propertyKey,
+    invalidPropertyValueType,
+    language,
+  );
+}
+function throwIfMoreThanOneModuleInterfaceParserError(
+  nativeModuleName,
+  moduleSpecs,
+  parserType,
+) {
+  if (moduleSpecs.length > 1) {
+    throw new MoreThanOneModuleInterfaceParserError(
+      nativeModuleName,
+      moduleSpecs,
+      moduleSpecs.map(node => node.id.name),
+      parserType,
+    );
+  }
+}
+function throwIfUnsupportedFunctionParamTypeAnnotationParserError(
+  nativeModuleName,
+  languageParamTypeAnnotation,
+  paramName,
+  paramTypeAnnotationType,
+) {
+  throw new UnsupportedFunctionParamTypeAnnotationParserError(
+    nativeModuleName,
+    languageParamTypeAnnotation,
+    paramName,
+    paramTypeAnnotationType,
+  );
+}
+function throwIfArrayElementTypeAnnotationIsUnsupported(
+  hasteModuleName,
+  flowElementType,
+  flowArrayType,
+  type,
+  language,
+) {
+  const TypeMap = {
+    FunctionTypeAnnotation: 'FunctionTypeAnnotation',
+    VoidTypeAnnotation: 'void',
+    PromiseTypeAnnotation: 'Promise',
+    // TODO: Added as a work-around for now until TupleTypeAnnotation are fully supported in both flow and TS
+    // Right now they are partially treated as UnionTypeAnnotation
+    UnionTypeAnnotation: 'UnionTypeAnnotation',
+  };
+  if (type in TypeMap) {
+    throw new UnsupportedArrayElementTypeAnnotationParserError(
+      hasteModuleName,
+      flowElementType,
+      flowArrayType,
+      TypeMap[type],
+      language,
+    );
+  }
+}
+module.exports = {
+  throwIfModuleInterfaceIsMisnamed,
+  throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
+  throwIfModuleInterfaceNotFound,
+  throwIfMoreThanOneModuleRegistryCalls,
+  throwIfPropertyValueTypeIsUnsupported,
+  throwIfUnusedModuleInterfaceParserError,
+  throwIfWrongNumberOfCallExpressionArgs,
+  throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfUntypedModule,
+  throwIfModuleTypeIsUnsupported,
+  throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfUnsupportedFunctionParamTypeAnnotationParserError,
+  throwIfArrayElementTypeAnnotationIsUnsupported,
+};

package/lib/parsers/error-utils.js.flow

@@ -0,0 +1,295 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {NativeModuleTypeAnnotation} from '../CodegenSchema';
+import type {ParserType} from './errors';
+import type {Parser} from './parser';
+
+const {
+  MisnamedModuleInterfaceParserError,
+  UnsupportedFunctionReturnTypeAnnotationParserError,
+  ModuleInterfaceNotFoundParserError,
+  MoreThanOneModuleRegistryCallsParserError,
+  UnusedModuleInterfaceParserError,
+  IncorrectModuleRegistryCallArityParserError,
+  IncorrectModuleRegistryCallTypeParameterParserError,
+  UnsupportedObjectPropertyValueTypeAnnotationParserError,
+  UntypedModuleRegistryCallParserError,
+  UnsupportedModulePropertyParserError,
+  MoreThanOneModuleInterfaceParserError,
+  UnsupportedFunctionParamTypeAnnotationParserError,
+  UnsupportedArrayElementTypeAnnotationParserError,
+} = require('./errors');
+
+function throwIfModuleInterfaceIsMisnamed(
+  nativeModuleName: string,
+  moduleSpecId: $FlowFixMe,
+  parserType: ParserType,
+) {
+  if (moduleSpecId.name !== 'Spec') {
+    throw new MisnamedModuleInterfaceParserError(
+      nativeModuleName,
+      moduleSpecId,
+      parserType,
+    );
+  }
+}
+
+function throwIfModuleInterfaceNotFound(
+  numberOfModuleSpecs: number,
+  nativeModuleName: string,
+  ast: $FlowFixMe,
+  parserType: ParserType,
+) {
+  if (numberOfModuleSpecs === 0) {
+    throw new ModuleInterfaceNotFoundParserError(
+      nativeModuleName,
+      ast,
+      parserType,
+    );
+  }
+}
+
+function throwIfMoreThanOneModuleRegistryCalls(
+  hasteModuleName: string,
+  callExpressions: $FlowFixMe,
+  callExpressionsLength: number,
+  language: ParserType,
+) {
+  if (callExpressions.length > 1) {
+    throw new MoreThanOneModuleRegistryCallsParserError(
+      hasteModuleName,
+      callExpressions,
+      callExpressionsLength,
+      language,
+    );
+  }
+}
+
+function throwIfUnusedModuleInterfaceParserError(
+  nativeModuleName: string,
+  moduleSpec: $FlowFixMe,
+  callExpressions: $FlowFixMe,
+  language: ParserType,
+) {
+  if (callExpressions.length === 0) {
+    throw new UnusedModuleInterfaceParserError(
+      nativeModuleName,
+      moduleSpec,
+      language,
+    );
+  }
+}
+
+function throwIfWrongNumberOfCallExpressionArgs(
+  nativeModuleName: string,
+  flowCallExpression: $FlowFixMe,
+  methodName: string,
+  numberOfCallExpressionArgs: number,
+  language: ParserType,
+) {
+  if (numberOfCallExpressionArgs !== 1) {
+    throw new IncorrectModuleRegistryCallArityParserError(
+      nativeModuleName,
+      flowCallExpression,
+      methodName,
+      numberOfCallExpressionArgs,
+      language,
+    );
+  }
+}
+
+function throwIfIncorrectModuleRegistryCallTypeParameterParserError(
+  nativeModuleName: string,
+  typeArguments: $FlowFixMe,
+  methodName: string,
+  moduleName: string,
+  parser: Parser,
+) {
+  function throwError() {
+    throw new IncorrectModuleRegistryCallTypeParameterParserError(
+      nativeModuleName,
+      typeArguments,
+      methodName,
+      moduleName,
+      parser.language(),
+    );
+  }
+
+  if (parser.checkIfInvalidModule(typeArguments)) {
+    throwError();
+  }
+}
+
+function throwIfUnsupportedFunctionReturnTypeAnnotationParserError(
+  nativeModuleName: string,
+  returnTypeAnnotation: $FlowFixMe,
+  invalidReturnType: string,
+  language: ParserType,
+  cxxOnly: boolean,
+  returnType: string,
+) {
+  if (!cxxOnly && returnType === 'FunctionTypeAnnotation') {
+    throw new UnsupportedFunctionReturnTypeAnnotationParserError(
+      nativeModuleName,
+      returnTypeAnnotation.returnType,
+      'FunctionTypeAnnotation',
+      language,
+    );
+  }
+}
+
+function throwIfUntypedModule(
+  typeArguments: $FlowFixMe,
+  hasteModuleName: string,
+  callExpression: $FlowFixMe,
+  methodName: string,
+  moduleName: string,
+  language: ParserType,
+) {
+  if (typeArguments == null) {
+    throw new UntypedModuleRegistryCallParserError(
+      hasteModuleName,
+      callExpression,
+      methodName,
+      moduleName,
+      language,
+    );
+  }
+}
+
+function throwIfModuleTypeIsUnsupported(
+  nativeModuleName: string,
+  propertyValue: $FlowFixMe,
+  propertyName: string,
+  propertyValueType: string,
+  language: ParserType,
+) {
+  if (language === 'Flow' && propertyValueType !== 'FunctionTypeAnnotation') {
+    throw new UnsupportedModulePropertyParserError(
+      nativeModuleName,
+      propertyValue,
+      propertyName,
+      propertyValueType,
+      language,
+    );
+  } else if (
+    language === 'TypeScript' &&
+    propertyValueType !== 'TSFunctionType' &&
+    propertyValueType !== 'TSMethodSignature'
+  ) {
+    throw new UnsupportedModulePropertyParserError(
+      nativeModuleName,
+      propertyValue,
+      propertyName,
+      propertyValueType,
+      language,
+    );
+  }
+}
+
+const UnsupportedObjectPropertyTypeToInvalidPropertyValueTypeMap = {
+  FunctionTypeAnnotation: 'FunctionTypeAnnotation',
+  VoidTypeAnnotation: 'void',
+  PromiseTypeAnnotation: 'Promise',
+};
+
+function throwIfPropertyValueTypeIsUnsupported(
+  moduleName: string,
+  propertyValue: $FlowFixMe,
+  propertyKey: string,
+  type: string,
+  language: ParserType,
+) {
+  const invalidPropertyValueType =
+    UnsupportedObjectPropertyTypeToInvalidPropertyValueTypeMap[type];
+
+  throw new UnsupportedObjectPropertyValueTypeAnnotationParserError(
+    moduleName,
+    propertyValue,
+    propertyKey,
+    invalidPropertyValueType,
+    language,
+  );
+}
+
+function throwIfMoreThanOneModuleInterfaceParserError(
+  nativeModuleName: string,
+  moduleSpecs: $ReadOnlyArray<$FlowFixMe>,
+  parserType: ParserType,
+) {
+  if (moduleSpecs.length > 1) {
+    throw new MoreThanOneModuleInterfaceParserError(
+      nativeModuleName,
+      moduleSpecs,
+      moduleSpecs.map(node => node.id.name),
+      parserType,
+    );
+  }
+}
+
+function throwIfUnsupportedFunctionParamTypeAnnotationParserError(
+  nativeModuleName: string,
+  languageParamTypeAnnotation: $FlowFixMe,
+  paramName: string,
+  paramTypeAnnotationType: NativeModuleTypeAnnotation['type'],
+) {
+  throw new UnsupportedFunctionParamTypeAnnotationParserError(
+    nativeModuleName,
+    languageParamTypeAnnotation,
+    paramName,
+    paramTypeAnnotationType,
+  );
+}
+
+function throwIfArrayElementTypeAnnotationIsUnsupported(
+  hasteModuleName: string,
+  flowElementType: $FlowFixMe,
+  flowArrayType: 'Array' | '$ReadOnlyArray' | 'ReadonlyArray',
+  type: string,
+  language: ParserType,
+) {
+  const TypeMap = {
+    FunctionTypeAnnotation: 'FunctionTypeAnnotation',
+    VoidTypeAnnotation: 'void',
+    PromiseTypeAnnotation: 'Promise',
+    // TODO: Added as a work-around for now until TupleTypeAnnotation are fully supported in both flow and TS
+    // Right now they are partially treated as UnionTypeAnnotation
+    UnionTypeAnnotation: 'UnionTypeAnnotation',
+  };
+
+  if (type in TypeMap) {
+    throw new UnsupportedArrayElementTypeAnnotationParserError(
+      hasteModuleName,
+      flowElementType,
+      flowArrayType,
+      TypeMap[type],
+      language,
+    );
+  }
+}
+
+module.exports = {
+  throwIfModuleInterfaceIsMisnamed,
+  throwIfUnsupportedFunctionReturnTypeAnnotationParserError,
+  throwIfModuleInterfaceNotFound,
+  throwIfMoreThanOneModuleRegistryCalls,
+  throwIfPropertyValueTypeIsUnsupported,
+  throwIfUnusedModuleInterfaceParserError,
+  throwIfWrongNumberOfCallExpressionArgs,
+  throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfUntypedModule,
+  throwIfModuleTypeIsUnsupported,
+  throwIfMoreThanOneModuleInterfaceParserError,
+  throwIfUnsupportedFunctionParamTypeAnnotationParserError,
+  throwIfArrayElementTypeAnnotationIsUnsupported,
+};