hermes-parser 0.28.1 → 0.29.0

package/dist/src/traverse/SimpleTraverser.js

@@ -0,0 +1,137 @@
+/**
+ * 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.SimpleTraverserSkip = exports.SimpleTraverserBreak = exports.SimpleTraverser = void 0;
+
+var _getVisitorKeys = require("./getVisitorKeys");
+
+/**
+ * Can be thrown within the traversal "enter" function to prevent the traverser
+ * from traversing the node any further, essentially culling the remainder of the
+ * AST branch
+ */
+const SimpleTraverserSkip = new Error();
+/**
+ * Can be thrown at any point during the traversal to immediately stop traversal
+ * entirely.
+ */
+
+exports.SimpleTraverserSkip = SimpleTraverserSkip;
+const SimpleTraverserBreak = new Error();
+/**
+ * A very simple traverser class to traverse AST trees.
+ */
+
+exports.SimpleTraverserBreak = SimpleTraverserBreak;
+
+class SimpleTraverser {
+  /**
+   * Traverse the given AST tree.
+   * @param node The root node to traverse.
+   * @param options The option object.
+   */
+  traverse(node, options) {
+    try {
+      this._traverse(node, null, options);
+    } catch (ex) {
+      if (ex === SimpleTraverserBreak) {
+        return;
+      }
+
+      throw ex;
+    }
+  }
+  /**
+   * Traverse the given AST tree recursively.
+   * @param node The current node.
+   * @param parent The parent node.
+   * @private
+   */
+
+
+  _traverse(node, parent, options) {
+    if (!(0, _getVisitorKeys.isNode)(node)) {
+      return;
+    }
+
+    try {
+      options.enter(node, parent);
+    } catch (ex) {
+      if (ex === SimpleTraverserSkip) {
+        return;
+      }
+
+      this._setErrorContext(ex, node);
+
+      throw ex;
+    }
+
+    const keys = (0, _getVisitorKeys.getVisitorKeys)(node, options.visitorKeys);
+
+    for (const key of keys) {
+      const child = node[key];
+
+      if (Array.isArray(child)) {
+        for (let j = 0; j < child.length; ++j) {
+          this._traverse(child[j], node, options);
+        }
+      } else {
+        this._traverse(child, node, options);
+      }
+    }
+
+    try {
+      options.leave(node, parent);
+    } catch (ex) {
+      if (ex === SimpleTraverserSkip) {
+        return;
+      }
+
+      this._setErrorContext(ex, node);
+
+      throw ex;
+    }
+  }
+  /**
+   * Set useful contextual information onto the error object.
+   * @param ex The error object.
+   * @param node The current node.
+   * @private
+   */
+
+
+  _setErrorContext(ex, node) {
+    // $FlowFixMe[prop-missing]
+    ex.currentNode = {
+      type: node.type,
+      range: node.range,
+      loc: node.loc
+    };
+  }
+  /**
+   * Traverse the given AST tree.
+   * @param node The root node to traverse.
+   * @param options The option object.
+   */
+
+
+  static traverse(node, options) {
+    new SimpleTraverser().traverse(node, options);
+  }
+
+}
+
+exports.SimpleTraverser = SimpleTraverser;
+SimpleTraverser.Break = SimpleTraverserBreak;
+SimpleTraverser.Skip = SimpleTraverserSkip;

package/dist/src/traverse/getVisitorKeys.js

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ *
+ * 
+ * @noformat
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getVisitorKeys = getVisitorKeys;
+exports.isNode = isNode;
+
+var _ESTreeVisitorKeys = _interopRequireDefault(require("../generated/ESTreeVisitorKeys"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function isNode(thing)
+/*: implies thing is {+[string]: mixed} */
+{
+  return typeof thing === 'object' && thing != null && typeof thing.type === 'string';
+}
+
+function getVisitorKeys(node, visitorKeys) {
+  const keys = (visitorKeys != null ? visitorKeys : _ESTreeVisitorKeys.default)[node.type];
+
+  if (keys == null) {
+    throw new Error(`No visitor keys found for node type "${node.type}".`);
+  } // $FlowExpectedError[prop-missing]
+
+
+  return keys;
+}

package/dist/src/utils/Builders.js

@@ -0,0 +1,191 @@
+/**
+ * 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.EMPTY_PARENT = void 0;
+exports.callExpression = callExpression;
+exports.conjunction = conjunction;
+exports.createDefaultPosition = createDefaultPosition;
+exports.disjunction = disjunction;
+exports.etc = etc;
+exports.ident = ident;
+exports.iife = iife;
+exports.nullLiteral = nullLiteral;
+exports.numberLiteral = numberLiteral;
+exports.stringLiteral = stringLiteral;
+exports.throwStatement = throwStatement;
+exports.typeofExpression = typeofExpression;
+exports.variableDeclaration = variableDeclaration;
+// Rely on the mapper to fix up parent relationships.
+const EMPTY_PARENT = null;
+exports.EMPTY_PARENT = EMPTY_PARENT;
+
+function createDefaultPosition() {
+  return {
+    line: 1,
+    column: 0
+  };
+}
+
+function etc({
+  loc,
+  range,
+  parent
+} = {}) {
+  return {
+    loc: {
+      start: (loc == null ? void 0 : loc.start) != null ? loc.start : createDefaultPosition(),
+      end: (loc == null ? void 0 : loc.end) != null ? loc.end : createDefaultPosition()
+    },
+    range: range != null ? range : [0, 0],
+    parent: parent != null ? parent : EMPTY_PARENT
+  };
+}
+
+function ident(name, info) {
+  return {
+    type: 'Identifier',
+    name,
+    optional: false,
+    typeAnnotation: null,
+    ...etc(info)
+  };
+}
+
+function stringLiteral(value, info) {
+  return {
+    type: 'Literal',
+    value,
+    raw: `"${value}"`,
+    literalType: 'string',
+    ...etc(info)
+  };
+}
+
+function numberLiteral(value, info) {
+  return {
+    type: 'Literal',
+    value,
+    raw: String(value),
+    literalType: 'numeric',
+    ...etc(info)
+  };
+}
+
+function nullLiteral(info) {
+  return {
+    type: 'Literal',
+    value: null,
+    raw: 'null',
+    literalType: 'null',
+    ...etc(info)
+  };
+}
+
+function conjunction(tests) {
+  if (tests.length === 0) {
+    throw new Error('Must have at least one test.');
+  }
+
+  return tests.reduce((acc, test) => ({
+    type: 'LogicalExpression',
+    left: acc,
+    right: test,
+    operator: '&&',
+    ...etc()
+  }));
+}
+
+function disjunction(tests) {
+  if (tests.length === 0) {
+    throw new Error('Must have at least one test.');
+  }
+
+  return tests.reduce((acc, test) => ({
+    type: 'LogicalExpression',
+    left: acc,
+    right: test,
+    operator: '||',
+    ...etc()
+  }));
+}
+
+function variableDeclaration(kind, id, init, info) {
+  return {
+    type: 'VariableDeclaration',
+    kind,
+    declarations: [{
+      type: 'VariableDeclarator',
+      init,
+      id,
+      ...etc(),
+      parent: EMPTY_PARENT
+    }],
+    ...etc(info)
+  };
+}
+
+function callExpression(callee, args, info) {
+  return {
+    type: 'CallExpression',
+    callee,
+    arguments: args,
+    typeArguments: null,
+    optional: false,
+    ...etc(info)
+  };
+}
+
+function throwStatement(arg, info) {
+  return {
+    type: 'ThrowStatement',
+    argument: callExpression(ident('Error'), [arg]),
+    ...etc(info)
+  };
+}
+
+function iife(statements, params = [], args = []) {
+  const callee = {
+    type: 'ArrowFunctionExpression',
+    params,
+    expression: false,
+    async: false,
+    predicate: null,
+    returnType: null,
+    typeParameters: null,
+    id: null,
+    body: {
+      type: 'BlockStatement',
+      body: statements,
+      ...etc()
+    },
+    ...etc()
+  };
+  return callExpression(callee, args);
+}
+
+function typeofExpression(arg, kind) {
+  return {
+    type: 'BinaryExpression',
+    left: {
+      type: 'UnaryExpression',
+      operator: 'typeof',
+      argument: arg,
+      prefix: true,
+      ...etc()
+    },
+    right: stringLiteral(kind),
+    operator: '===',
+    ...etc()
+  };
+}

package/dist/src/utils/GenID.js

@@ -0,0 +1,41 @@
+/**
+ * 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.createGenID = createGenID;
+const genPrefix = '$$gen$';
+
+function createGenID(uniqueTransformPrefix) {
+  let genN = 0;
+  const used = new Set();
+  return {
+    genID() {
+      let name;
+
+      do {
+        name = `${genPrefix}${uniqueTransformPrefix}${genN}`;
+        genN++;
+      } while (used.has(name));
+
+      used.add(name);
+      return name;
+    },
+
+    addUsage(name) {
+      if (name.startsWith(genPrefix)) {
+        used.add(name);
+      }
+    }
+
+  };
+}

package/dist/src/utils/createSyntaxError.js

@@ -0,0 +1,25 @@
+/**
+ * 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.createSyntaxError = createSyntaxError;
+
+function createSyntaxError(node, err) {
+  const syntaxError = new SyntaxError(err); // $FlowExpectedError[prop-missing]
+
+  syntaxError.loc = {
+    line: node.loc.start.line,
+    column: node.loc.start.column
+  };
+  return syntaxError;
+}

package/dist/src/utils/mutateESTreeASTForPrettier.js

@@ -0,0 +1,127 @@
+/**
+ * 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.default = mutate;
+
+var _SimpleTransform = require("../transform/SimpleTransform");
+
+// https://github.com/prettier/prettier/blob/d962466a828f8ef51435e3e8840178d90b7ec6cd/src/language-js/parse/postprocess/index.js#L161-L182
+function transformChainExpression(node, comments) {
+  if (comments != null) {
+    var _node$comments;
+
+    // $FlowExpectedError[prop-missing]
+    const joinedComments = comments.concat((_node$comments = node.comments) != null ? _node$comments : []); // $FlowExpectedError[prop-missing]
+    // $FlowFixMe[cannot-write]
+
+    node.comments = joinedComments;
+  }
+
+  switch (node.type) {
+    case 'CallExpression':
+      // $FlowExpectedError[cannot-spread-interface]
+      return { ...node,
+        type: 'OptionalCallExpression',
+        callee: transformChainExpression(node.callee)
+      };
+
+    case 'MemberExpression':
+      // $FlowExpectedError[cannot-spread-interface]
+      return { ...node,
+        type: 'OptionalMemberExpression',
+        object: transformChainExpression(node.object)
+      };
+    // No default
+  }
+
+  return node;
+}
+
+function mutate(rootNode, visitorKeys) {
+  // Since we don't return the result of `transform` we need to be careful not to replace the Program root node.
+  _SimpleTransform.SimpleTransform.transform(rootNode, {
+    transform(node) {
+      // prettier fully expects the parent pointers are NOT set and
+      // certain cases can crash due to prettier infinite-looping
+      // whilst naively traversing the parent property
+      // https://github.com/prettier/prettier/issues/11793
+      // Note: Only needed for prettier V2, this is supported in V3
+      if (node.parent) {
+        // $FlowExpectedError[cannot-write]
+        delete node.parent;
+      } // prettier currently relies on the AST being in the old-school, deprecated AST format for optional chaining
+      // so we have to apply their transform to our AST so it can actually format it.
+      // Note: Only needed for prettier V2, this is supported in V3
+
+
+      if (node.type === 'ChainExpression') {
+        // $FlowFixMe[prop-missing]
+        return transformChainExpression(node.expression, node == null ? void 0 : node.comments);
+      } // Prettier currently relies on comparing the `node` vs `node.value` start positions to know if an
+      // `ObjectTypeProperty` is a method or not (instead of using the `node.method` boolean). To correctly print
+      // the node when its not a method we need the start position to be different from the `node.value`s start
+      // position.
+
+
+      if (node.type === 'ObjectTypeProperty') {
+        if (node.method === false && node.kind === 'init' && node.range[0] === 1 && node.value.range[0] === 1) {
+          // $FlowExpectedError[cannot-write]
+          // $FlowExpectedError[cannot-spread-interface]
+          node.value = { ...node.value,
+            range: [2, node.value.range[1]]
+          };
+        }
+
+        return node;
+      } // Prettier currently relies on comparing the the start positions to know if the import/export specifier should have a
+      // rename (eg `Name` vs `Name as Name`) when the name is exactly the same
+      // So we need to ensure that the range is always the same to avoid the useless code printing
+
+
+      if (node.type === 'ImportSpecifier') {
+        if (node.local.name === node.imported.name) {
+          if (node.local.range == null) {
+            // for our TS-ast printing which has no locs
+            // $FlowExpectedError[cannot-write]
+            node.local.range = [0, 0];
+          } // $FlowExpectedError[cannot-write]
+
+
+          node.imported.range = [...node.local.range];
+        }
+
+        return node;
+      }
+
+      if (node.type === 'ExportSpecifier') {
+        if (node.local.name === node.exported.name) {
+          if (node.local.range == null) {
+            // for our TS-ast printing which has no locs
+            // $FlowExpectedError[cannot-write]
+            node.local.range = [0, 0];
+          } // $FlowExpectedError[cannot-write]
+
+
+          node.exported.range = [...node.local.range];
+        }
+
+        return node;
+      }
+
+      return node;
+    },
+
+    visitorKeys
+  });
+}

package/dist/utils/Builders.js

@@ -24,6 +24,7 @@ exports.nullLiteral = nullLiteral;
 exports.numberLiteral = numberLiteral;
 exports.stringLiteral = stringLiteral;
 exports.throwStatement = throwStatement;
+exports.typeofExpression = typeofExpression;
 exports.variableDeclaration = variableDeclaration;
 // Rely on the mapper to fix up parent relationships.
 const EMPTY_PARENT = null;
@@ -171,4 +172,20 @@ function iife(statements, params = [], args = []) {
     ...etc()
   };
   return callExpression(callee, args);
+}
+
+function typeofExpression(arg, kind) {
+  return {
+    type: 'BinaryExpression',
+    left: {
+      type: 'UnaryExpression',
+      operator: 'typeof',
+      argument: arg,
+      prefix: true,
+      ...etc()
+    },
+    right: stringLiteral(kind),
+    operator: '===',
+    ...etc()
+  };
 }

package/dist/utils/Builders.js.flow

@@ -12,6 +12,7 @@
 
 import type {
   ArrowFunctionExpression,
+  BinaryExpression,
   BindingName,
   CallExpression,
   ESNode,
@@ -196,3 +197,22 @@ export function iife(
   };
   return callExpression(callee, args);
 }
+
+export function typeofExpression(
+  arg: Expression,
+  kind: string,
+): BinaryExpression {
+  return {
+    type: 'BinaryExpression',
+    left: {
+      type: 'UnaryExpression',
+      operator: 'typeof',
+      argument: arg,
+      prefix: true,
+      ...etc(),
+    },
+    right: stringLiteral(kind),
+    operator: '===',
+    ...etc(),
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-parser",
-  "version": "0.28.1",
+  "version": "0.29.0",
   "description": "A JavaScript parser built from the Hermes engine",
   "main": "dist/index.js",
   "license": "MIT",
@@ -9,7 +9,7 @@
     "url": "git@github.com:facebook/hermes.git"
   },
   "dependencies": {
-    "hermes-estree": "0.28.1"
+    "hermes-estree": "0.29.0"
   },
   "devDependencies": {
     "@babel/parser": "7.7.4",