@react-native/codegen 0.72.1

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

@@ -0,0 +1,420 @@
+/**
+ * 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 {
+  NamedShape,
+  NativeModuleAliasMap,
+  NativeModuleBaseTypeAnnotation,
+  NativeModuleTypeAnnotation,
+  NativeModulePropertyShape,
+  NativeModuleSchema,
+  Nullable,
+} from '../../../CodegenSchema';
+import type {ParserErrorCapturer, TypeDeclarationMap} from '../../utils';
+
+const {visit, isModuleRegistryCall, verifyPlatforms} = require('../../utils');
+const {resolveTypeAnnotation, getTypes} = require('../utils');
+const {
+  unwrapNullable,
+  wrapNullable,
+  assertGenericTypeAnnotationHasExactlyOneTypeParameter,
+  parseObjectProperty,
+  translateDefault,
+  buildPropertySchema,
+} = require('../../parsers-commons');
+const {
+  emitArrayType,
+  emitBoolean,
+  emitDouble,
+  emitFloat,
+  emitFunction,
+  emitNumber,
+  emitInt32,
+  emitObject,
+  emitPromise,
+  emitRootTag,
+  emitVoid,
+  emitString,
+  emitStringish,
+  emitMixed,
+  emitUnion,
+  typeAliasResolution,
+  translateArrayTypeAnnotation,
+} = require('../../parsers-primitives');
+
+const {
+  UnsupportedTypeAnnotationParserError,
+  IncorrectModuleRegistryCallArgumentTypeParserError,
+} = require('../../errors');
+
+const {
+  throwIfModuleInterfaceNotFound,
+  throwIfModuleInterfaceIsMisnamed,
+  throwIfUnusedModuleInterfaceParserError,
+  throwIfWrongNumberOfCallExpressionArgs,
+  throwIfMoreThanOneModuleRegistryCalls,
+  throwIfIncorrectModuleRegistryCallTypeParameterParserError,
+  throwIfUntypedModule,
+  throwIfMoreThanOneModuleInterfaceParserError,
+} = require('../../error-utils');
+
+const {FlowParser} = require('../parser');
+
+const language = 'Flow';
+const parser = new FlowParser();
+
+function translateTypeAnnotation(
+  hasteModuleName: string,
+  /**
+   * TODO(T71778680): Flow-type this node.
+   */
+  flowTypeAnnotation: $FlowFixMe,
+  types: TypeDeclarationMap,
+  aliasMap: {...NativeModuleAliasMap},
+  tryParse: ParserErrorCapturer,
+  cxxOnly: boolean,
+): Nullable<NativeModuleTypeAnnotation> {
+  const {nullable, typeAnnotation, typeAliasResolutionStatus} =
+    resolveTypeAnnotation(flowTypeAnnotation, types);
+
+  switch (typeAnnotation.type) {
+    case 'GenericTypeAnnotation': {
+      switch (typeAnnotation.id.name) {
+        case 'RootTag': {
+          return emitRootTag(nullable);
+        }
+        case 'Promise': {
+          return emitPromise(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+            nullable,
+            types,
+            aliasMap,
+            tryParse,
+            cxxOnly,
+            translateTypeAnnotation,
+          );
+        }
+        case 'Array':
+        case '$ReadOnlyArray': {
+          return emitArrayType(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+            types,
+            aliasMap,
+            cxxOnly,
+            nullable,
+            translateTypeAnnotation,
+          );
+        }
+        case '$ReadOnly': {
+          assertGenericTypeAnnotationHasExactlyOneTypeParameter(
+            hasteModuleName,
+            typeAnnotation,
+            parser,
+          );
+
+          const [paramType, isParamNullable] = unwrapNullable(
+            translateTypeAnnotation(
+              hasteModuleName,
+              typeAnnotation.typeParameters.params[0],
+              types,
+              aliasMap,
+              tryParse,
+              cxxOnly,
+            ),
+          );
+
+          return wrapNullable(nullable || isParamNullable, paramType);
+        }
+        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 emitObject(nullable);
+        }
+        default: {
+          return translateDefault(
+            hasteModuleName,
+            typeAnnotation,
+            types,
+            nullable,
+            parser,
+          );
+        }
+      }
+    }
+    case 'ObjectTypeAnnotation': {
+      const objectTypeAnnotation = {
+        type: 'ObjectTypeAnnotation',
+        // $FlowFixMe[missing-type-arg]
+        properties: ([
+          ...typeAnnotation.properties,
+          ...typeAnnotation.indexers,
+        ]: Array<$FlowFixMe>)
+          .map<?NamedShape<Nullable<NativeModuleBaseTypeAnnotation>>>(
+            property => {
+              return tryParse(() => {
+                return parseObjectProperty(
+                  property,
+                  hasteModuleName,
+                  types,
+                  aliasMap,
+                  tryParse,
+                  cxxOnly,
+                  nullable,
+                  translateTypeAnnotation,
+                  parser,
+                );
+              });
+            },
+          )
+          .filter(Boolean),
+      };
+
+      return typeAliasResolution(
+        typeAliasResolutionStatus,
+        objectTypeAnnotation,
+        aliasMap,
+        nullable,
+      );
+    }
+    case 'BooleanTypeAnnotation': {
+      return emitBoolean(nullable);
+    }
+    case 'NumberTypeAnnotation': {
+      return emitNumber(nullable);
+    }
+    case 'VoidTypeAnnotation': {
+      return emitVoid(nullable);
+    }
+    case 'StringTypeAnnotation': {
+      return emitString(nullable);
+    }
+    case 'FunctionTypeAnnotation': {
+      return emitFunction(
+        nullable,
+        hasteModuleName,
+        typeAnnotation,
+        types,
+        aliasMap,
+        tryParse,
+        cxxOnly,
+        translateTypeAnnotation,
+        language,
+      );
+    }
+    case 'UnionTypeAnnotation': {
+      return emitUnion(nullable, hasteModuleName, typeAnnotation, parser);
+    }
+    case 'StringLiteralTypeAnnotation': {
+      // 'a' is a special case for 'a' | 'b' but the type name is different
+      return wrapNullable(nullable, {
+        type: 'UnionTypeAnnotation',
+        memberType: 'StringTypeAnnotation',
+      });
+    }
+    case 'MixedTypeAnnotation': {
+      if (cxxOnly) {
+        return emitMixed(nullable);
+      }
+      // Fallthrough
+    }
+    default: {
+      throw new UnsupportedTypeAnnotationParserError(
+        hasteModuleName,
+        typeAnnotation,
+        language,
+      );
+    }
+  }
+}
+
+function isModuleInterface(node: $FlowFixMe) {
+  return (
+    node.type === 'InterfaceDeclaration' &&
+    node.extends.length === 1 &&
+    node.extends[0].type === 'InterfaceExtends' &&
+    node.extends[0].id.name === 'TurboModule'
+  );
+}
+
+function buildModuleSchema(
+  hasteModuleName: string,
+  /**
+   * TODO(T71778680): Flow-type this node.
+   */
+  ast: $FlowFixMe,
+  tryParse: ParserErrorCapturer,
+): 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,
+      language,
+    );
+
+    throwIfMoreThanOneModuleRegistryCalls(
+      hasteModuleName,
+      callExpressions,
+      callExpressions.length,
+      language,
+    );
+
+    const [callExpression] = callExpressions;
+    const {typeArguments} = callExpression;
+    const methodName = callExpression.callee.property.name;
+
+    throwIfWrongNumberOfCallExpressionArgs(
+      hasteModuleName,
+      callExpression,
+      methodName,
+      callExpression.arguments.length,
+      language,
+    );
+
+    if (callExpression.arguments[0].type !== 'Literal') {
+      const {type} = callExpression.arguments[0];
+      throw new IncorrectModuleRegistryCallArgumentTypeParserError(
+        hasteModuleName,
+        callExpression.arguments[0],
+        methodName,
+        type,
+        language,
+      );
+    }
+
+    const $moduleName = callExpression.arguments[0].value;
+
+    throwIfUntypedModule(
+      typeArguments,
+      hasteModuleName,
+      callExpression,
+      methodName,
+      $moduleName,
+      language,
+    );
+
+    throwIfIncorrectModuleRegistryCallTypeParameterParserError(
+      hasteModuleName,
+      typeArguments,
+      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.properties: $ReadOnlyArray<$FlowFixMe>)
+    .filter(property => property.type === 'ObjectTypeProperty')
+    .map<?{
+      aliasMap: NativeModuleAliasMap,
+      propertyShape: NativeModulePropertyShape,
+    }>(property => {
+      const aliasMap: {...NativeModuleAliasMap} = {};
+      return tryParse(() => ({
+        aliasMap: aliasMap,
+        propertyShape: buildPropertySchema(
+          hasteModuleName,
+          property,
+          types,
+          aliasMap,
+          tryParse,
+          cxxOnly,
+          language,
+          resolveTypeAnnotation,
+          translateTypeAnnotation,
+        ),
+      }));
+    })
+    .filter(Boolean)
+    .reduce(
+      (moduleSchema: NativeModuleSchema, {aliasMap, propertyShape}) => ({
+        type: 'NativeModule',
+        aliases: {...moduleSchema.aliases, ...aliasMap},
+        spec: {
+          properties: [...moduleSchema.spec.properties, propertyShape],
+        },
+        moduleName: moduleSchema.moduleName,
+        excludedPlatforms: moduleSchema.excludedPlatforms,
+      }),
+      {
+        type: 'NativeModule',
+        aliases: {},
+        spec: {properties: []},
+        moduleName,
+        excludedPlatforms:
+          excludedPlatforms.length !== 0 ? [...excludedPlatforms] : undefined,
+      },
+    );
+}
+
+module.exports = {
+  buildModuleSchema,
+  flowTranslateTypeAnnotation: translateTypeAnnotation,
+};

package/lib/parsers/flow/parser.js

@@ -0,0 +1,109 @@
+/**
+ * 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';
+
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, 'string');
+  return typeof key === 'symbol' ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== 'object' || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || 'default');
+    if (typeof res !== 'object') return res;
+    throw new TypeError('@@toPrimitive must return a primitive value.');
+  }
+  return (hint === 'string' ? String : Number)(input);
+}
+const _require = require('../errors'),
+  UnsupportedObjectPropertyTypeAnnotationParserError =
+    _require.UnsupportedObjectPropertyTypeAnnotationParserError;
+class FlowParser {
+  constructor() {
+    _defineProperty(
+      this,
+      'typeParameterInstantiation',
+      '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');
+  }
+  isEnumDeclaration(maybeEnumDeclaration) {
+    return maybeEnumDeclaration.type === 'EnumDeclaration';
+  }
+  language() {
+    return 'Flow';
+  }
+  nameForGenericTypeAnnotation(typeAnnotation) {
+    return typeAnnotation.id.name;
+  }
+  checkIfInvalidModule(typeArguments) {
+    return (
+      typeArguments.type !== 'TypeParameterInstantiation' ||
+      typeArguments.params.length !== 1 ||
+      typeArguments.params[0].type !== 'GenericTypeAnnotation' ||
+      typeArguments.params[0].id.name !== 'Spec'
+    );
+  }
+  remapUnionTypeAnnotationMemberNames(membersTypes) {
+    const remapLiteral = item => {
+      return item.type
+        .replace('NumberLiteralTypeAnnotation', 'NumberTypeAnnotation')
+        .replace('StringLiteralTypeAnnotation', 'StringTypeAnnotation');
+    };
+    return [...new Set(membersTypes.map(remapLiteral))];
+  }
+}
+module.exports = {
+  FlowParser,
+};

package/lib/parsers/flow/parser.js.flow

@@ -0,0 +1,83 @@
+/**
+ * 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 {UnionTypeAnnotationMemberType} from '../../CodegenSchema.js';
+import type {ParserType} from '../errors';
+import type {Parser} from '../parser';
+
+const {
+  UnsupportedObjectPropertyTypeAnnotationParserError,
+} = require('../errors');
+
+class FlowParser 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');
+  }
+
+  isEnumDeclaration(maybeEnumDeclaration: $FlowFixMe): boolean {
+    return maybeEnumDeclaration.type === 'EnumDeclaration';
+  }
+
+  language(): ParserType {
+    return 'Flow';
+  }
+
+  nameForGenericTypeAnnotation(typeAnnotation: $FlowFixMe): string {
+    return typeAnnotation.id.name;
+  }
+
+  checkIfInvalidModule(typeArguments: $FlowFixMe): boolean {
+    return (
+      typeArguments.type !== 'TypeParameterInstantiation' ||
+      typeArguments.params.length !== 1 ||
+      typeArguments.params[0].type !== 'GenericTypeAnnotation' ||
+      typeArguments.params[0].id.name !== 'Spec'
+    );
+  }
+
+  remapUnionTypeAnnotationMemberNames(
+    membersTypes: $FlowFixMe[],
+  ): UnionTypeAnnotationMemberType[] {
+    const remapLiteral = (item: $FlowFixMe) => {
+      return item.type
+        .replace('NumberLiteralTypeAnnotation', 'NumberTypeAnnotation')
+        .replace('StringLiteralTypeAnnotation', 'StringTypeAnnotation');
+    };
+
+    return [...new Set(membersTypes.map(remapLiteral))];
+  }
+}
+
+module.exports = {
+  FlowParser,
+};

package/lib/parsers/flow/utils.js

@@ -0,0 +1,108 @@
+/**
+ * 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';
+
+/**
+ * This FlowFixMe is supposed to refer to an InterfaceDeclaration or TypeAlias
+ * declaration type. Unfortunately, we don't have those types, because flow-parser
+ * generates them, and flow-parser is not type-safe. In the future, we should find
+ * a way to get these types from our flow parser library.
+ *
+ * TODO(T71778680): Flow type AST Nodes
+ */
+
+function getTypes(ast) {
+  return ast.body.reduce((types, node) => {
+    if (node.type === 'ExportNamedDeclaration' && node.exportKind === 'type') {
+      if (
+        node.declaration != null &&
+        (node.declaration.type === 'TypeAlias' ||
+          node.declaration.type === 'InterfaceDeclaration')
+      ) {
+        types[node.declaration.id.name] = node.declaration;
+      }
+    } else if (
+      node.type === 'ExportNamedDeclaration' &&
+      node.exportKind === 'value' &&
+      node.declaration &&
+      node.declaration.type === 'EnumDeclaration'
+    ) {
+      types[node.declaration.id.name] = node.declaration;
+    } else if (
+      node.type === 'TypeAlias' ||
+      node.type === 'InterfaceDeclaration' ||
+      node.type === 'EnumDeclaration'
+    ) {
+      types[node.id.name] = node;
+    }
+    return types;
+  }, {});
+}
+
+// $FlowFixMe[unclear-type] there's no flowtype for ASTs
+
+const invariant = require('invariant');
+function resolveTypeAnnotation(
+  // TODO(T71778680): This is an Flow TypeAnnotation. Flow-type this
+  typeAnnotation,
+  types,
+) {
+  invariant(
+    typeAnnotation != null,
+    'resolveTypeAnnotation(): typeAnnotation cannot be null',
+  );
+  let node = typeAnnotation;
+  let nullable = false;
+  let typeAliasResolutionStatus = {
+    successful: false,
+  };
+  for (;;) {
+    if (node.type === 'NullableTypeAnnotation') {
+      nullable = true;
+      node = node.typeAnnotation;
+    } else if (node.type === 'GenericTypeAnnotation') {
+      typeAliasResolutionStatus = {
+        successful: true,
+        aliasName: node.id.name,
+      };
+      const resolvedTypeAnnotation = types[node.id.name];
+      if (
+        resolvedTypeAnnotation == null ||
+        resolvedTypeAnnotation.type === 'EnumDeclaration'
+      ) {
+        break;
+      }
+      invariant(
+        resolvedTypeAnnotation.type === 'TypeAlias',
+        `GenericTypeAnnotation '${node.id.name}' must resolve to a TypeAlias. Instead, it resolved to a '${resolvedTypeAnnotation.type}'`,
+      );
+      node = resolvedTypeAnnotation.right;
+    } else {
+      break;
+    }
+  }
+  return {
+    nullable: nullable,
+    typeAnnotation: node,
+    typeAliasResolutionStatus,
+  };
+}
+function getValueFromTypes(value, types) {
+  if (value.type === 'GenericTypeAnnotation' && types[value.id.name]) {
+    return getValueFromTypes(types[value.id.name].right, types);
+  }
+  return value;
+}
+module.exports = {
+  getValueFromTypes,
+  resolveTypeAnnotation,
+  getTypes,
+};