hermes-transform 0.28.0 → 0.29.0

package/dist/src/traverse/NodeEventGenerator.js

@@ -0,0 +1,353 @@
+/**
+ * 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.NodeEventGenerator = void 0;
+
+var _hermesParser = require("hermes-parser");
+
+var esquery = _interopRequireWildcard(require("./esquery"));
+
+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); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const ESQUERY_OPTIONS = Object.freeze({
+  visitorKeys: _hermesParser.FlowVisitorKeys,
+  fallback: node => {
+    throw new Error(`No visitor keys found for node type "${node.type}".`);
+  }
+});
+/**
+ * Computes the union of one or more arrays
+ * @param arrays One or more arrays to union
+ * @returns The union of the input arrays
+ */
+
+function union(...arrays) {
+  return [...new Set(arrays.flat())];
+}
+/**
+ * Computes the intersection of one or more arrays
+ * @param arrays One or more arrays to intersect
+ * @returns The intersection of the input arrays
+ */
+
+
+function intersection(...arrays) {
+  if (arrays.length === 0) {
+    return [];
+  }
+
+  let result = [...new Set(arrays[0])];
+
+  for (const array of arrays.slice(1)) {
+    result = result.filter(x => array.includes(x));
+  }
+
+  return result;
+}
+/**
+ * Gets the possible types of a selector
+ * @param parsedSelector An object (from esquery) describing the matching behavior of the selector
+ * @returns The node types that could possibly trigger this selector, or `null` if all node types could trigger it
+ */
+
+
+function getPossibleTypes(parsedSelector) {
+  switch (parsedSelector.type) {
+    case 'identifier':
+      if (!(parsedSelector.value in _hermesParser.FlowVisitorKeys)) {
+        throw new Error(`Unexpected selector ${parsedSelector.value}`);
+      } // $FlowExpectedError[incompatible-return]
+
+
+      return [parsedSelector.value];
+
+    case 'matches':
+      {
+        const typesForComponents = parsedSelector.selectors.map(getPossibleTypes);
+        const typesForComponentsNonNull = typesForComponents.filter(Boolean);
+
+        if (typesForComponents.length === typesForComponentsNonNull.length) {
+          return union(...typesForComponentsNonNull);
+        }
+
+        return null;
+      }
+
+    case 'compound':
+      {
+        const typesForComponents = parsedSelector.selectors.map(getPossibleTypes).filter(Boolean); // If all of the components could match any type, then the compound could also match any type.
+
+        if (!typesForComponents.length) {
+          return null;
+        }
+        /*
+         * If at least one of the components could only match a particular type, the compound could only match
+         * the intersection of those types.
+         */
+
+
+        return intersection(...typesForComponents);
+      }
+
+    case 'child':
+    case 'descendant':
+    case 'sibling':
+    case 'adjacent':
+      return getPossibleTypes(parsedSelector.right);
+
+    case 'class':
+      if (parsedSelector.name === 'function') {
+        return ['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'];
+      }
+
+      return null;
+
+    default:
+      return null;
+  }
+}
+/**
+ * Counts the number of class, pseudo-class, and attribute queries in this selector
+ * @param parsedSelector An object (from esquery) describing the selector's matching behavior
+ * @returns The number of class, pseudo-class, and attribute queries in this selector
+ */
+
+
+function countClassAttributes(parsedSelector) {
+  switch (parsedSelector.type) {
+    case 'child':
+    case 'descendant':
+    case 'sibling':
+    case 'adjacent':
+      return countClassAttributes(parsedSelector.left) + countClassAttributes(parsedSelector.right);
+
+    case 'compound':
+    case 'not':
+    case 'matches':
+      return parsedSelector.selectors.reduce((sum, childSelector) => sum + countClassAttributes(childSelector), 0);
+
+    case 'attribute':
+    case 'field':
+    case 'nth-child':
+    case 'nth-last-child':
+      return 1;
+
+    default:
+      return 0;
+  }
+}
+/**
+ * Counts the number of identifier queries in this selector
+ * @param parsedSelector An object (from esquery) describing the selector's matching behavior
+ * @returns The number of identifier queries
+ */
+
+
+function countIdentifiers(parsedSelector) {
+  switch (parsedSelector.type) {
+    case 'child':
+    case 'descendant':
+    case 'sibling':
+    case 'adjacent':
+      return countIdentifiers(parsedSelector.left) + countIdentifiers(parsedSelector.right);
+
+    case 'compound':
+    case 'not':
+    case 'matches':
+      return parsedSelector.selectors.reduce((sum, childSelector) => sum + countIdentifiers(childSelector), 0);
+
+    case 'identifier':
+      return 1;
+
+    default:
+      return 0;
+  }
+}
+/**
+ * Compares the specificity of two selector objects, with CSS-like rules.
+ * @param selectorA An AST selector descriptor
+ * @param selectorB Another AST selector descriptor
+ * @returns
+ * a value less than 0 if selectorA is less specific than selectorB
+ * a value greater than 0 if selectorA is more specific than selectorB
+ * a value less than 0 if selectorA and selectorB have the same specificity, and selectorA <= selectorB alphabetically
+ * a value greater than 0 if selectorA and selectorB have the same specificity, and selectorA > selectorB alphabetically
+ */
+
+
+function compareSpecificity(selectorA, selectorB) {
+  return selectorA.attributeCount - selectorB.attributeCount || selectorA.identifierCount - selectorB.identifierCount || (selectorA.rawSelector <= selectorB.rawSelector ? -1 : 1);
+}
+/**
+ * Parses a raw selector string, and throws a useful error if parsing fails.
+ * @param rawSelector A raw AST selector
+ * @returns An object (from esquery) describing the matching behavior of this selector
+ * @throws An error if the selector is invalid
+ */
+
+
+function tryParseSelector(rawSelector) {
+  try {
+    return esquery.parse(rawSelector.replace(/:exit$/u, ''));
+  } catch (err) {
+    if (err.location && err.location.start && typeof err.location.start.offset === 'number') {
+      throw new SyntaxError(`Syntax error in selector "${rawSelector}" at position ${err.location.start.offset}: ${err.message}`);
+    }
+
+    throw err;
+  }
+}
+
+const selectorCache = new Map();
+/**
+ * Parses a raw selector string, and returns the parsed selector along with specificity and type information.
+ * @param rawSelector A raw AST selector
+ * @returns A selector descriptor
+ */
+
+function parseSelector(rawSelector) {
+  const cachedSelector = selectorCache.get(rawSelector);
+
+  if (cachedSelector) {
+    return cachedSelector;
+  }
+
+  const parsedSelector = tryParseSelector(rawSelector);
+  const result = {
+    rawSelector,
+    isExit: rawSelector.endsWith(':exit'),
+    parsedSelector,
+    listenerTypes: getPossibleTypes(parsedSelector),
+    attributeCount: countClassAttributes(parsedSelector),
+    identifierCount: countIdentifiers(parsedSelector)
+  };
+  selectorCache.set(rawSelector, result);
+  return result;
+}
+/**
+ * The event generator for AST nodes.
+ */
+
+
+class NodeEventGenerator {
+  /**
+   * @param emitter
+   * An SafeEmitter which is the destination of events. This emitter must already
+   * have registered listeners for all of the events that it needs to listen for.
+   * (See lib/linter/safe-emitter.js for more details on `SafeEmitter`.)
+   */
+  constructor(emitter) {
+    this.emitter = void 0;
+    this._currentAncestry = [];
+    this._enterSelectorsByNodeType = new Map();
+    this._exitSelectorsByNodeType = new Map();
+    this._anyTypeEnterSelectors = [];
+    this._anyTypeExitSelectors = [];
+    this.emitter = emitter;
+    emitter.eventNames().forEach(rawSelector => {
+      const selector = parseSelector(rawSelector);
+
+      if (selector.listenerTypes) {
+        const typeMap = selector.isExit ? this._exitSelectorsByNodeType : this._enterSelectorsByNodeType;
+        selector.listenerTypes.forEach(nodeType => {
+          const selectors = typeMap.get(nodeType);
+
+          if (!selectors) {
+            typeMap.set(nodeType, [selector]);
+          } else {
+            selectors.push(selector);
+          }
+        });
+      } else {
+        const selectors = selector.isExit ? this._anyTypeExitSelectors : this._anyTypeEnterSelectors;
+        selectors.push(selector);
+      }
+    });
+
+    this._anyTypeEnterSelectors.sort(compareSpecificity);
+
+    this._anyTypeExitSelectors.sort(compareSpecificity);
+
+    this._enterSelectorsByNodeType.forEach(selectorList => selectorList.sort(compareSpecificity));
+
+    this._exitSelectorsByNodeType.forEach(selectorList => selectorList.sort(compareSpecificity));
+  }
+  /**
+   * Checks a selector against a node, and emits it if it matches
+   * @param node The node to check
+   * @param selector An AST selector descriptor
+   * @private
+   */
+
+
+  _applySelector(node, selector) {
+    if (esquery.matches(node, selector.parsedSelector, this._currentAncestry, ESQUERY_OPTIONS)) {
+      this.emitter.emit(selector.rawSelector, node);
+    }
+  }
+  /**
+   * Applies all appropriate selectors to a node, in specificity order
+   * @param node The node to check
+   * @param isExit `false` if the node is currently being entered, `true` if it's currently being exited
+   * @private
+   */
+
+
+  _applySelectors(node, isExit) {
+    const selectorsByNodeType = (isExit ? this._exitSelectorsByNodeType : this._enterSelectorsByNodeType).get(node.type) || [];
+    const anyTypeSelectors = isExit ? this._anyTypeExitSelectors : this._anyTypeEnterSelectors;
+    /*
+     * selectorsByNodeType and anyTypeSelectors were already sorted by specificity in the constructor.
+     * Iterate through each of them, applying selectors in the right order.
+     */
+
+    let selectorsByTypeIndex = 0;
+    let anyTypeSelectorsIndex = 0;
+
+    while (selectorsByTypeIndex < selectorsByNodeType.length || anyTypeSelectorsIndex < anyTypeSelectors.length) {
+      if (selectorsByTypeIndex >= selectorsByNodeType.length || anyTypeSelectorsIndex < anyTypeSelectors.length && compareSpecificity(anyTypeSelectors[anyTypeSelectorsIndex], selectorsByNodeType[selectorsByTypeIndex]) < 0) {
+        this._applySelector(node, anyTypeSelectors[anyTypeSelectorsIndex++]);
+      } else {
+        this._applySelector(node, selectorsByNodeType[selectorsByTypeIndex++]);
+      }
+    }
+  }
+  /**
+   * Emits an event of entering AST node.
+   * @param node A node which was entered.
+   */
+
+
+  enterNode(node) {
+    this._applySelectors(node, false);
+
+    this._currentAncestry.unshift(node);
+  }
+  /**
+   * Emits an event of leaving AST node.
+   * @param node A node which was left.
+   */
+
+
+  leaveNode(node) {
+    this._currentAncestry.shift();
+
+    this._applySelectors(node, true);
+  }
+
+}
+
+exports.NodeEventGenerator = NodeEventGenerator;

package/dist/src/traverse/SafeEmitter.js

@@ -0,0 +1,52 @@
+/**
+ * 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.SafeEmitter = void 0;
+
+/**
+ * Creates an object which can listen for and emit events.
+ * This is similar to the EventEmitter API in Node's standard library, but it has a few differences.
+ * The goal is to allow multiple modules to attach arbitrary listeners to the same emitter, without
+ * letting the modules know about each other at all.
+ * 1. It has no special keys like `error` and `newListener`, which would allow modules to detect when
+ * another module throws an error or registers a listener.
+ * 2. It calls listener functions without any `this` value. (`EventEmitter` calls listeners with a
+ * `this` value of the emitter instance, which would give listeners access to other listeners.)
+ */
+class SafeEmitter {
+  constructor() {
+    this.listeners = Object.create(null);
+  }
+
+  on(eventName, listener) {
+    if (eventName in this.listeners) {
+      this.listeners[eventName].push(listener);
+    } else {
+      this.listeners[eventName] = [listener];
+    }
+  }
+
+  emit(eventName, node) {
+    if (eventName in this.listeners) {
+      this.listeners[eventName].forEach(listener => listener(node));
+    }
+  }
+
+  eventNames() {
+    return Object.keys(this.listeners);
+  }
+
+}
+
+exports.SafeEmitter = SafeEmitter;

package/dist/src/traverse/esquery.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.
+ *
+ * 
+ * @format
+ */
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.query = exports.parse = exports.matches = exports.match = void 0;
+
+var _esquery = _interopRequireDefault(require("esquery"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// $FlowExpectedError[cannot-resolve-module]
+
+/** Parse a selector and return its AST. */
+const parse = _esquery.default.parse;
+/** From a JS AST and a selector AST, collect all JS AST nodes that match the selector. */
+
+exports.parse = parse;
+const match = _esquery.default.match;
+/** Given a `node` and its ancestors, determine if `node` is matched by `selector`. */
+
+exports.match = match;
+const matches = _esquery.default.matches;
+/** Query the code AST using the selector string. */
+
+exports.matches = matches;
+const query = _esquery.default.query;
+exports.query = query;

package/dist/src/traverse/traverse.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.traverse = traverse;
+exports.traverseWithContext = traverseWithContext;
+
+var _codeFrame = require("@babel/code-frame");
+
+var _NodeEventGenerator = require("./NodeEventGenerator");
+
+var _SafeEmitter = require("./SafeEmitter");
+
+var _hermesParser = require("hermes-parser");
+
+/**
+ * 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
+ */
+
+/**
+ * Traverse the AST with additional context members provided by `additionalContext`.
+ * @param ast the ESTree AST to traverse
+ * @param scopeManager the eslint-scope compatible scope manager instance calculated using the ast
+ * @param additionalContext a callback function which returns additional context members to add to the context provided to the visitor
+ */
+function traverseWithContext(code, ast, scopeManager, additionalContext, visitor) {
+  const emitter = new _SafeEmitter.SafeEmitter();
+  let currentNode = ast;
+  let shouldSkipTraversal = false;
+  let shouldStopTraversal = false;
+
+  const getScope = (givenNode = currentNode) => {
+    // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope.
+    const inner = givenNode.type !== 'Program';
+
+    for (let node = givenNode; node; node = node.parent) {
+      const scope = scopeManager.acquire(node, inner);
+
+      if (scope) {
+        if (scope.type === 'function-expression-name') {
+          return scope.childScopes[0];
+        }
+
+        return scope;
+      }
+    }
+
+    return scopeManager.scopes[0];
+  };
+
+  const traversalContextBase = Object.freeze({
+    buildCodeFrame: (node, message) => {
+      // babel uses 1-indexed columns
+      const locForBabel = {
+        start: {
+          line: node.loc.start.line,
+          column: node.loc.start.column + 1
+        },
+        end: {
+          line: node.loc.end.line,
+          column: node.loc.end.column + 1
+        }
+      };
+      return (0, _codeFrame.codeFrameColumns)(code, locForBabel, {
+        linesAbove: 0,
+        linesBelow: 0,
+        highlightCode: process.env.NODE_ENV !== 'test',
+        message: message
+      });
+    },
+    buildSimpleCodeFrame: (node, message) => {
+      return `[${node.type}:${node.loc.start.line}:${node.loc.start.column}] ${message}`;
+    },
+    getDeclaredVariables: node => scopeManager.getDeclaredVariables(node),
+    getBinding: name => {
+      let currentScope = getScope();
+
+      while (currentScope != null) {
+        for (const variable of currentScope.variables) {
+          if (variable.defs.length && variable.name === name) {
+            return variable;
+          }
+        }
+
+        currentScope = currentScope.upper;
+      }
+
+      return null;
+    },
+    getScope,
+    stopTraversal: () => {
+      shouldStopTraversal = true;
+    },
+    skipTraversal: () => {
+      shouldSkipTraversal = true;
+    }
+  });
+  const traversalContext = Object.freeze({ ...traversalContextBase,
+    ...additionalContext(traversalContextBase)
+  });
+  const selectors = visitor(traversalContext); // add all the selectors from the visitor as listeners
+
+  Object.keys(selectors).forEach(selector => {
+    // flow doesn't want us to be general here - but it's safe
+    const listener = selectors[selector];
+
+    if (listener) {
+      emitter.on(selector, listener);
+    }
+  });
+  const eventGenerator = new _NodeEventGenerator.NodeEventGenerator(emitter);
+
+  function checkTraversalFlags() {
+    if (shouldStopTraversal) {
+      // No need to reset the flag since we won't enter any more nodes.
+      throw _hermesParser.SimpleTraverser.Break;
+    }
+
+    if (shouldSkipTraversal) {
+      shouldSkipTraversal = false;
+      throw _hermesParser.SimpleTraverser.Skip;
+    }
+  }
+
+  _hermesParser.SimpleTraverser.traverse(ast, {
+    enter(node) {
+      currentNode = node;
+      eventGenerator.enterNode(node);
+      checkTraversalFlags();
+    },
+
+    leave(node) {
+      currentNode = node;
+      eventGenerator.leaveNode(node);
+      checkTraversalFlags();
+    }
+
+  });
+}
+
+function traverse(code, ast, scopeManager, visitor) {
+  traverseWithContext(code, ast, scopeManager, () => {}, visitor);
+}

package/dist/transform/comments/prettier/language-js/comments.js

@@ -59,7 +59,7 @@ const {
 
 
 function handleOwnLineComment(context) {
-  return [handleIgnoreComments, handleLastFunctionArgComments, handleMemberExpressionComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleImportSpecifierComments, handleForComments, handleUnionTypeComments, handleOnlyComments, handleImportDeclarationComments, handleAssignmentPatternComments, handleMethodNameComments, handleLabeledStatementComments].some(fn => fn(context));
+  return [handleIgnoreComments, handleLastFunctionArgComments, handleMemberExpressionComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleImportSpecifierComments, handleForComments, handleUnionTypeComments, handleMatchOrPatternComments, handleOnlyComments, handleImportDeclarationComments, handleAssignmentPatternComments, handleMethodNameComments, handleLabeledStatementComments].some(fn => fn(context));
 }
 /**
  * @param {CommentContext} context
@@ -553,6 +553,34 @@ function handleUnionTypeComments({
   return false;
 }
 
+function handleMatchOrPatternComments({
+  comment,
+  precedingNode,
+  enclosingNode,
+  followingNode
+}) {
+  if (enclosingNode && enclosingNode.type === 'MatchOrPattern') {
+    if (isPrettierIgnoreComment(comment)) {
+      followingNode.prettierIgnore = true;
+      comment.unignore = true;
+    }
+
+    if (precedingNode) {
+      addTrailingComment(precedingNode, comment);
+      return true;
+    }
+
+    return false;
+  }
+
+  if (followingNode && followingNode.type === 'MatchOrPattern' && isPrettierIgnoreComment(comment)) {
+    followingNode.types[0].prettierIgnore = true;
+    comment.unignore = true;
+  }
+
+  return false;
+}
+
 function handlePropertyComments({
   comment,
   enclosingNode

package/dist/transform/mutations/utils/getStatementParent.js.flow

@@ -19,9 +19,7 @@ import type {
 
 import {InvalidStatementError} from '../../Errors';
 
-export function getStatementParent(
-  target: ModuleDeclaration | Statement,
-): $ReadOnly<
+type StatementParent = $ReadOnly<
   | {
       type: 'single',
       parent: StatementParentSingle,
@@ -33,7 +31,11 @@ export function getStatementParent(
       key: string,
       targetIndex: number,
     },
-> {
+>;
+
+export function getStatementParent(
+  target: ModuleDeclaration | Statement,
+): StatementParent {
   function assertValidStatementLocation<T: $ReadOnly<interface {type: string}>>(
     parentWithType: T,
     ...invalidKeys: $ReadOnlyArray<$Keys<T>>
@@ -63,7 +65,7 @@ export function getStatementParent(
   }
 
   const parent = target.parent;
-  const result = (() => {
+  const result: StatementParent = (() => {
     switch (parent.type) {
       case 'IfStatement': {
         assertValidStatementLocation(parent, 'test');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-transform",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Tools built on top of Hermes-ESTree to enable codebase transformation",
   "main": "dist/index.js",
   "license": "MIT",
@@ -12,14 +12,14 @@
     "@babel/code-frame": "^7.16.0",
     "esquery": "^1.4.0",
     "flow-enums-runtime": "^0.0.6",
-    "hermes-eslint": "0.28.0",
-    "hermes-estree": "0.28.0",
-    "hermes-parser": "0.28.0",
+    "hermes-eslint": "0.29.0",
+    "hermes-estree": "0.29.0",
+    "hermes-parser": "0.29.0",
     "string-width": "4.2.3"
   },
   "peerDependencies": {
     "prettier": "^3.0.0 || ^2.7.1",
-    "prettier-plugin-hermes-parser": "0.28.0"
+    "prettier-plugin-hermes-parser": "0.29.0"
   },
   "files": [
     "dist",