hermes-parser 0.9.0 → 0.10.0

package/dist/HermesToBabelAdapter.js

@@ -121,6 +121,12 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
       case 'BigIntLiteral':
         return this.mapBigIntLiteral(node);
 
+      case 'BigIntLiteralTypeAnnotation':
+        return this.mapBigIntLiteralTypeAnnotation(node);
+
+      case 'BigIntTypeAnnotation':
+        return this.mapBigIntTypeAnnotation(node);
+
       default:
         return this.mapNodeDefault(node);
     }
@@ -436,10 +442,36 @@ class HermesToBabelAdapter extends _HermesASTAdapter.default {
   }
 
   mapBigIntLiteral(node) {
-    const bigint = node.bigint.replace(/n$/, '').replace(/_/, '');
-    node.value = typeof BigInt === 'function' ? BigInt(bigint) : null;
+    node.value = this.getBigIntLiteralValue(node.bigint).value;
+    return node;
+  }
+
+  mapBigIntLiteralTypeAnnotation(node) {
+    node.value = this.getBigIntLiteralValue(node.raw).value;
     return node;
   }
+  /**
+   * Babel does not parse the bigint keyword type as the keyword node.
+   * So we need to down-level the AST to a plain GenericTypeAnnotation
+   */
+
+
+  mapBigIntTypeAnnotation(node) {
+    return {
+      type: 'GenericTypeAnnotation',
+      id: {
+        type: 'Identifier',
+        name: 'bigint',
+        loc: node.loc,
+        start: node.start,
+        end: node.end
+      },
+      typeParameters: null,
+      loc: node.loc,
+      start: node.start,
+      end: node.end
+    };
+  }
 
   mapPrivateProperty(nodeUnprocessed) {
     const node = this.mapNodeDefault(nodeUnprocessed);

package/dist/HermesToBabelAdapter.js.flow

@@ -91,6 +91,10 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
         return this.mapUnsupportedTypeAnnotation(node);
       case 'BigIntLiteral':
         return this.mapBigIntLiteral(node);
+      case 'BigIntLiteralTypeAnnotation':
+        return this.mapBigIntLiteralTypeAnnotation(node);
+      case 'BigIntTypeAnnotation':
+        return this.mapBigIntTypeAnnotation(node);
       default:
         return this.mapNodeDefault(node);
     }
@@ -413,10 +417,33 @@ export default class HermesToBabelAdapter extends HermesASTAdapter {
   }
 
   mapBigIntLiteral(node: HermesNode): HermesNode {
-    const bigint = node.bigint.replace(/n$/, '').replace(/_/, '');
-    node.value = typeof BigInt === 'function' ? BigInt(bigint) : null;
+    node.value = this.getBigIntLiteralValue(node.bigint).value;
     return node;
   }
+  mapBigIntLiteralTypeAnnotation(node: HermesNode): HermesNode {
+    node.value = this.getBigIntLiteralValue(node.raw).value;
+    return node;
+  }
+  /**
+   * Babel does not parse the bigint keyword type as the keyword node.
+   * So we need to down-level the AST to a plain GenericTypeAnnotation
+   */
+  mapBigIntTypeAnnotation(node: HermesNode): HermesNode {
+    return {
+      type: 'GenericTypeAnnotation',
+      id: {
+        type: 'Identifier',
+        name: 'bigint',
+        loc: node.loc,
+        start: node.start,
+        end: node.end,
+      },
+      typeParameters: null,
+      loc: node.loc,
+      start: node.start,
+      end: node.end,
+    };
+  }
 
   mapPrivateProperty(nodeUnprocessed: HermesNode): HermesNode {
     const node = this.mapNodeDefault(nodeUnprocessed);

package/dist/HermesToESTreeAdapter.js

@@ -173,14 +173,8 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
 
   mapBigIntLiteral(node) {
     const newNode = this.mapSimpleLiteral(node);
-    const bigint = node.bigint // estree spec is to not have a trailing `n` on this property
-    // https://github.com/estree/estree/blob/db962bb417a97effcfe9892f87fbb93c81a68584/es2020.md#bigintliteral
-    .replace(/n$/, '') // `BigInt` doesn't accept numeric separator and `bigint` property should not include numeric separator
-    .replace(/_/, '');
     return { ...newNode,
-      // coerce the string to a bigint value if supported by the environment
-      value: typeof BigInt === 'function' ? BigInt(bigint) : null,
-      bigint
+      ...this.getBigIntLiteralValue(node.bigint)
     };
   }
 
@@ -214,8 +208,9 @@ class HermesToESTreeAdapter extends _HermesASTAdapter.default {
   }
 
   mapBigIntLiteralTypeAnnotation(node) {
-    node.value = null;
-    return node;
+    return { ...node,
+      ...this.getBigIntLiteralValue(node.raw)
+    };
   }
 
   mapTemplateElement(node) {

package/dist/HermesToESTreeAdapter.js.flow

@@ -150,17 +150,9 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
 
   mapBigIntLiteral(node: HermesNode): HermesNode {
     const newNode = this.mapSimpleLiteral(node);
-    const bigint = node.bigint
-      // estree spec is to not have a trailing `n` on this property
-      // https://github.com/estree/estree/blob/db962bb417a97effcfe9892f87fbb93c81a68584/es2020.md#bigintliteral
-      .replace(/n$/, '')
-      // `BigInt` doesn't accept numeric separator and `bigint` property should not include numeric separator
-      .replace(/_/, '');
     return {
       ...newNode,
-      // coerce the string to a bigint value if supported by the environment
-      value: typeof BigInt === 'function' ? BigInt(bigint) : null,
-      bigint,
+      ...this.getBigIntLiteralValue(node.bigint),
     };
   }
 
@@ -193,8 +185,10 @@ export default class HermesToESTreeAdapter extends HermesASTAdapter {
   }
 
   mapBigIntLiteralTypeAnnotation(node: HermesNode): HermesNode {
-    node.value = null;
-    return node;
+    return {
+      ...node,
+      ...this.getBigIntLiteralValue(node.raw),
+    };
   }
 
   mapTemplateElement(node: HermesNode): HermesNode {

package/dist/generated/visitor-keys.js

@@ -6,6 +6,13 @@
  *
  * 
  * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
  */
 // lint directives to let us do some basic validation of generated files
 
@@ -55,6 +62,7 @@ const HERMES_AST_VISITOR_KEYS = {
   },
   BigIntLiteral: {},
   BigIntLiteralTypeAnnotation: {},
+  BigIntTypeAnnotation: {},
   BinaryExpression: {
     left: 'Node',
     right: 'Node'
@@ -454,7 +462,8 @@ const HERMES_AST_VISITOR_KEYS = {
     key: 'Node',
     value: 'Node',
     variance: 'Node',
-    typeAnnotation: 'Node'
+    typeAnnotation: 'Node',
+    tsModifiers: 'Node'
   },
   QualifiedTypeIdentifier: {
     qualification: 'Node',

package/dist/getModuleDocblock.js

@@ -19,7 +19,8 @@ const DIRECTIVE_REGEX = /^\s*@([a-zA-Z0-9_-]+)( +.+)?$/;
 function parseDocblockString(docblock) {
   const directiveLines = docblock.split('\n') // remove the leading " *" from each line
   .map(line => line.trimStart().replace(/^\* ?/, '').trim()).filter(line => line.startsWith('@'));
-  const directives = {};
+  const directives = // $FlowExpectedError[incompatible-type] - flow types  this return as {...}
+  Object.create(null);
 
   for (const line of directiveLines) {
     var _match$;

package/dist/getModuleDocblock.js.flow

@@ -24,7 +24,9 @@ export function parseDocblockString(docblock: string): DocblockDirectives {
 
   const directives: {
     [string]: Array<string>,
-  } = {};
+  } =
+    // $FlowExpectedError[incompatible-type] - flow types  this return as {...}
+    Object.create(null);
 
   for (const line of directiveLines) {
     const match = DIRECTIVE_REGEX.exec(line);

package/dist/getVisitorKeys.js

@@ -0,0 +1 @@
+"use strict";

package/dist/index.js

@@ -12,6 +12,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  parse: true,
+  astArrayMutationHelpers: true,
+  astNodeMutationHelpers: true
+};
+exports.astNodeMutationHelpers = exports.astArrayMutationHelpers = void 0;
 exports.parse = parse;
 
 var HermesParser = _interopRequireWildcard(require("./HermesParser"));
@@ -20,6 +26,41 @@ var _HermesToBabelAdapter = _interopRequireDefault(require("./HermesToBabelAdapt
 
 var _HermesToESTreeAdapter = _interopRequireDefault(require("./HermesToESTreeAdapter"));
 
+var _SimpleTraverser = require("./traverse/SimpleTraverser");
+
+Object.keys(_SimpleTraverser).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SimpleTraverser[key]) return;
+  exports[key] = _SimpleTraverser[key];
+});
+
+var _SimpleTransform = require("./transform/SimpleTransform");
+
+Object.keys(_SimpleTransform).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SimpleTransform[key]) return;
+  exports[key] = _SimpleTransform[key];
+});
+
+var _getVisitorKeys = require("./traverse/getVisitorKeys");
+
+Object.keys(_getVisitorKeys).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _getVisitorKeys[key]) return;
+  exports[key] = _getVisitorKeys[key];
+});
+
+var _astArrayMutationHelpers = _interopRequireWildcard(require("./transform/astArrayMutationHelpers"));
+
+exports.astArrayMutationHelpers = _astArrayMutationHelpers;
+
+var _astNodeMutationHelpers = _interopRequireWildcard(require("./transform/astNodeMutationHelpers"));
+
+exports.astNodeMutationHelpers = _astNodeMutationHelpers;
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

package/dist/index.js.flow

@@ -83,3 +83,8 @@ export function parse(
 }
 
 export type {ParserOptions} from './ParserOptions';
+export * from './traverse/SimpleTraverser';
+export * from './transform/SimpleTransform';
+export * from './traverse/getVisitorKeys';
+export * as astArrayMutationHelpers from './transform/astArrayMutationHelpers';
+export * as astNodeMutationHelpers from './transform/astNodeMutationHelpers';

package/dist/transform/SimpleTransform.js

@@ -0,0 +1,92 @@
+/**
+ * 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';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SimpleTransform = void 0;
+
+var _SimpleTraverser = require("../traverse/SimpleTraverser");
+
+var _astNodeMutationHelpers = require("./astNodeMutationHelpers");
+
+/**
+ * A simple class to recursively tranform AST trees.
+ */
+class SimpleTransform {
+  /**
+   * Transform the given AST tree.
+   * @param rootNode The root node to traverse.
+   * @param options The option object.
+   * @return The modified rootNode or a new node if the rootNode was transformed directly.
+   */
+  transform(rootNode, options) {
+    let resultRootNode = rootNode;
+
+    _SimpleTraverser.SimpleTraverser.traverse(rootNode, {
+      enter: (node, parent) => {
+        const resultNode = options.transform(node);
+
+        if (resultNode !== node) {
+          const traversedResultNode = resultNode != null ? this.transform(resultNode, options) : null;
+
+          if (parent == null) {
+            if (node !== rootNode) {
+              throw new Error('SimpleTransform infra error: Parent not set on non root node, this should not be possible');
+            }
+
+            resultRootNode = traversedResultNode;
+          } else if (traversedResultNode == null) {
+            (0, _astNodeMutationHelpers.removeNodeOnParent)(node, parent);
+          } else {
+            (0, _astNodeMutationHelpers.replaceNodeOnParent)(node, parent, traversedResultNode);
+          }
+
+          throw _SimpleTraverser.SimpleTraverser.Skip;
+        }
+      },
+
+      leave(_node) {}
+
+    });
+
+    return resultRootNode;
+  }
+  /**
+   * Transform the given AST tree.
+   * @param node The root node to traverse.
+   * @param options The option object.
+   */
+
+
+  static transform(node, options) {
+    return new SimpleTransform().transform(node, options);
+  }
+  /**
+   * Return a new AST node with the given properties overrided if needed.
+   *
+   * This function takes care to only create new nodes when needed. Referential equality of nodes
+   * is important as its used to know if a node should be re-traversed.
+   *
+   * @param node The base AST node.
+   * @param overrideProps New properties to apply to the node.
+   * @return Either the orginal node if the properties matched the existing node or a new node with
+   *         the new properties.
+   */
+
+
+  static nodeWith(node, overrideProps) {
+    return (0, _astNodeMutationHelpers.nodeWith)(node, overrideProps);
+  }
+
+}
+
+exports.SimpleTransform = SimpleTransform;

package/dist/transform/SimpleTransform.js.flow

@@ -0,0 +1,104 @@
+/**
+ * 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-local
+ * @format
+ */
+
+'use strict';
+
+import type {VisitorKeysType} from '../traverse/getVisitorKeys';
+import type {ESNode} from 'hermes-estree';
+
+import {SimpleTraverser} from '../traverse/SimpleTraverser';
+import {
+  nodeWith,
+  removeNodeOnParent,
+  replaceNodeOnParent,
+} from './astNodeMutationHelpers';
+
+/**
+ * Transform callback
+ * @param node The node we are visiting
+ * @returns
+ *   - return input node, signals no changes were made will continue to the next node.
+ *   - return new node, the old node will be replaced in the AST. The new node and its
+ *     children are then traversed.
+ *   - return null, signals the node should be deleted from the AST.
+ */
+export type TransformCallback = (node: ESNode) => ESNode | null;
+
+export type TransformOptions = $ReadOnly<{
+  /** The callback function which is called on entering each node. */
+  transform: TransformCallback,
+
+  /** The set of visitor keys to use for traversal. Defaults to the `hermes-eslint` visitor keys */
+  visitorKeys?: ?VisitorKeysType,
+}>;
+
+/**
+ * A simple class to recursively tranform AST trees.
+ */
+export class SimpleTransform {
+  /**
+   * Transform the given AST tree.
+   * @param rootNode The root node to traverse.
+   * @param options The option object.
+   * @return The modified rootNode or a new node if the rootNode was transformed directly.
+   */
+  transform(rootNode: ESNode, options: TransformOptions): ESNode | null {
+    let resultRootNode: ESNode | null = rootNode;
+    SimpleTraverser.traverse(rootNode, {
+      enter: (node: ESNode, parent: ?ESNode) => {
+        const resultNode = options.transform(node);
+        if (resultNode !== node) {
+          const traversedResultNode =
+            resultNode != null ? this.transform(resultNode, options) : null;
+          if (parent == null) {
+            if (node !== rootNode) {
+              throw new Error(
+                'SimpleTransform infra error: Parent not set on non root node, this should not be possible',
+              );
+            }
+            resultRootNode = traversedResultNode;
+          } else if (traversedResultNode == null) {
+            removeNodeOnParent(node, parent);
+          } else {
+            replaceNodeOnParent(node, parent, traversedResultNode);
+          }
+
+          throw SimpleTraverser.Skip;
+        }
+      },
+      leave(_node: ESNode) {},
+    });
+    return resultRootNode;
+  }
+
+  /**
+   * Transform the given AST tree.
+   * @param node The root node to traverse.
+   * @param options The option object.
+   */
+  static transform(node: ESNode, options: TransformOptions): ESNode | null {
+    return new SimpleTransform().transform(node, options);
+  }
+
+  /**
+   * Return a new AST node with the given properties overrided if needed.
+   *
+   * This function takes care to only create new nodes when needed. Referential equality of nodes
+   * is important as its used to know if a node should be re-traversed.
+   *
+   * @param node The base AST node.
+   * @param overrideProps New properties to apply to the node.
+   * @return Either the orginal node if the properties matched the existing node or a new node with
+   *         the new properties.
+   */
+  static nodeWith<T: ESNode>(node: T, overrideProps: $Partial<T>): T {
+    return nodeWith<T>(node, overrideProps);
+  }
+}

package/dist/transform/astArrayMutationHelpers.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrayIsEqual = arrayIsEqual;
+exports.insertInArray = insertInArray;
+exports.removeFromArray = removeFromArray;
+exports.replaceInArray = replaceInArray;
+
+/**
+ * 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
+ */
+function assertArrayBounds(array, index) {
+  if (index < 0 || index >= array.length) {
+    throw new Error(`Invalid Mutation: Tried to mutate an elements array with an out of bounds index. Index: ${index}, Array Size: ${array.length}`);
+  }
+}
+
+function arrayIsEqual(a1, a2) {
+  if (a1 === a2) {
+    return true;
+  }
+
+  if (a1.length !== a2.length) {
+    return false;
+  }
+
+  for (let i = 0; i < a1.length; i++) {
+    if (a1[i] !== a2[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function insertInArray(array, index, elements) {
+  if (index === array.length) {
+    // Support the insert at end of array case.
+    return array.concat(elements);
+  }
+
+  assertArrayBounds(array, index);
+  return array.slice(0, index).concat(elements).concat(array.slice(index));
+}
+
+function removeFromArray(array, index) {
+  assertArrayBounds(array, index);
+  return [...array.slice(0, index), ...array.slice(index + 1)];
+}
+
+function replaceInArray(array, index, elements) {
+  assertArrayBounds(array, index);
+  return array.slice(0, index).concat(elements).concat(array.slice(index + 1));
+}

package/dist/transform/astArrayMutationHelpers.js.flow

@@ -0,0 +1,71 @@
+/**
+ * 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-local
+ * @format
+ */
+
+function assertArrayBounds<T>(array: $ReadOnlyArray<T>, index: number): void {
+  if (index < 0 || index >= array.length) {
+    throw new Error(
+      `Invalid Mutation: Tried to mutate an elements array with an out of bounds index. Index: ${index}, Array Size: ${array.length}`,
+    );
+  }
+}
+
+export function arrayIsEqual(
+  a1: $ReadOnlyArray<mixed>,
+  a2: $ReadOnlyArray<mixed>,
+): boolean {
+  if (a1 === a2) {
+    return true;
+  }
+
+  if (a1.length !== a2.length) {
+    return false;
+  }
+
+  for (let i = 0; i < a1.length; i++) {
+    if (a1[i] !== a2[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function insertInArray<T>(
+  array: $ReadOnlyArray<T>,
+  index: number,
+  elements: $ReadOnlyArray<T>,
+): Array<T> {
+  if (index === array.length) {
+    // Support the insert at end of array case.
+    return array.concat(elements);
+  }
+  assertArrayBounds(array, index);
+  return array.slice(0, index).concat(elements).concat(array.slice(index));
+}
+
+export function removeFromArray<T>(
+  array: $ReadOnlyArray<T>,
+  index: number,
+): Array<T> {
+  assertArrayBounds(array, index);
+  return [...array.slice(0, index), ...array.slice(index + 1)];
+}
+
+export function replaceInArray<T>(
+  array: $ReadOnlyArray<T>,
+  index: number,
+  elements: $ReadOnlyArray<T>,
+): Array<T> {
+  assertArrayBounds(array, index);
+  return array
+    .slice(0, index)
+    .concat(elements)
+    .concat(array.slice(index + 1));
+}