hermes-transform 0.8.0 → 0.10.0

package/dist/transform/TransformContext.js.flow

@@ -18,8 +18,9 @@ import type {
   Statement,
   TypeAnnotationType,
 } from 'hermes-estree';
-import type {DetachedNode} from '../detachedNode';
+import type {DetachedNode, MaybeDetachedNode} from '../detachedNode';
 import type {TransformCloneSignatures} from '../generated/TransformCloneSignatures';
+import type {TransformModifySignatures} from '../generated/TransformModifySignatures';
 import type {TransformReplaceSignatures} from '../generated/TransformReplaceSignatures';
 import type {TraversalContext} from '../traverse/traverse';
 import type {AddCommentsMutation} from './mutations/AddComments';
@@ -29,9 +30,12 @@ import type {RemoveCommentMutation} from './mutations/RemoveComment';
 import type {RemoveNodeMutation} from './mutations/RemoveNode';
 import type {RemoveStatementMutation} from './mutations/RemoveStatement';
 import type {ReplaceNodeMutation} from './mutations/ReplaceNode';
-import type {ReplaceStatementWithManyMutation} from './mutations/ReplaceStatementWithMany';
+import type {
+  ReplaceStatementWithManyMutation,
+  ReplaceStatementWithManyMutationNodes,
+} from './mutations/ReplaceStatementWithMany';
 
-import {deepCloneNode, shallowCloneNode} from '../detachedNode';
+import {asDetachedNode, deepCloneNode, shallowCloneNode} from '../detachedNode';
 import {
   CommentPlacement,
   getCommentsForNode,
@@ -103,6 +107,8 @@ type TransformCloneAPIs = $ReadOnly<{
   shallowCloneArray: {
     <T: ESNode>(node: $ReadOnlyArray<T>): $ReadOnlyArray<DetachedNode<T>>,
     <T: ESNode>(node: ?$ReadOnlyArray<T>): ?$ReadOnlyArray<DetachedNode<T>>,
+    <T: ESNode>(node: $ReadOnlyArray<?T>): $ReadOnlyArray<DetachedNode<?T>>,
+    <T: ESNode>(node: ?$ReadOnlyArray<?T>): ?$ReadOnlyArray<DetachedNode<?T>>,
   },
 
   /**
@@ -148,14 +154,14 @@ type TransformCommentAPIs = $ReadOnly<{
    */
   cloneCommentsTo: (
     target: ESNode,
-    destination: ESNode | DetachedNode<ESNode>,
+    destination: MaybeDetachedNode<ESNode>,
   ) => void,
 
   /**
    * Add comments on the line before a specified node.
    */
   addLeadingComments: (
-    node: ESNode | DetachedNode<ESNode>,
+    node: MaybeDetachedNode<ESNode>,
     comments: SingleOrArray<Comment>,
   ) => void,
 
@@ -163,7 +169,7 @@ type TransformCommentAPIs = $ReadOnly<{
    * Add comments inline before a specified node.
    */
   addLeadingInlineComments: (
-    node: ESNode | DetachedNode<ESNode>,
+    node: MaybeDetachedNode<ESNode>,
     comments: SingleOrArray<Comment>,
   ) => void,
 
@@ -171,7 +177,7 @@ type TransformCommentAPIs = $ReadOnly<{
    * Add comments on the line after a specified node.
    */
   addTrailingComments: (
-    node: ESNode | DetachedNode<ESNode>,
+    node: MaybeDetachedNode<ESNode>,
     comments: SingleOrArray<Comment>,
   ) => void,
 
@@ -179,7 +185,7 @@ type TransformCommentAPIs = $ReadOnly<{
    * Add comments inline after a specified node.
    */
   addTrailingInlineComments: (
-    node: ESNode | DetachedNode<ESNode>,
+    node: MaybeDetachedNode<ESNode>,
     comments: SingleOrArray<Comment>,
   ) => void,
 
@@ -197,7 +203,7 @@ type TransformInsertAPIs = $ReadOnly<{
   insertAfterStatement: (
     target: InsertStatementMutation['target'],
     nodeToInsert: SingleOrArray<
-      DetachedNode<InsertStatementMutation['target']>,
+      MaybeDetachedNode<InsertStatementMutation['target']>,
     >,
   ) => void,
 
@@ -208,11 +214,19 @@ type TransformInsertAPIs = $ReadOnly<{
   insertBeforeStatement: (
     target: InsertStatementMutation['target'],
     nodeToInsert: SingleOrArray<
-      DetachedNode<InsertStatementMutation['target']>,
+      MaybeDetachedNode<InsertStatementMutation['target']>,
     >,
   ) => void,
 }>;
 
+type TransformModifyAPIs = $ReadOnly<{
+  /**
+   * Modifies a given node in place.
+   * This is equivalent to doing a replace with a shallow clone with overrides.
+   */
+  modifyNodeInPlace: TransformModifySignatures,
+}>;
+
 type TransformRemoveAPIs = $ReadOnly<{
   /**
    * Removes a given node from the AST.
@@ -236,37 +250,37 @@ type TransformReplaceAPIs = $ReadOnly<{
     // Expressions may be replaced with other expressions
     (
       target: Expression,
-      nodeToReplaceWith: DetachedNode<Expression>,
+      nodeToReplaceWith: MaybeDetachedNode<Expression>,
       options?: ReplaceNodeOptions,
     ): void,
     // Module declarations may be replaced with statements or other module declarations
     (
       target: ModuleDeclaration,
-      nodeToReplaceWith: DetachedNode<ModuleDeclaration | Statement>,
+      nodeToReplaceWith: MaybeDetachedNode<ModuleDeclaration | Statement>,
       options?: ReplaceNodeOptions,
     ): void,
     // Statement maybe be replaced with statements or module declarations
     (
       target: Statement,
-      nodeToReplaceWith: DetachedNode<ModuleDeclaration | Statement>,
+      nodeToReplaceWith: MaybeDetachedNode<ModuleDeclaration | Statement>,
       options?: ReplaceNodeOptions,
     ): void,
     // Types maybe be replaced with other types
     (
       target: TypeAnnotationType,
-      nodeToReplaceWith: DetachedNode<TypeAnnotationType>,
+      nodeToReplaceWith: MaybeDetachedNode<TypeAnnotationType>,
       options?: ReplaceNodeOptions,
     ): void,
     // Class members may be replaced with other class members
     (
       target: ClassMember,
-      nodeToReplaceWith: DetachedNode<ClassMember>,
+      nodeToReplaceWith: MaybeDetachedNode<ClassMember>,
       options?: ReplaceNodeOptions,
     ): void,
     // Function params amy be replace with other function params
     (
       target: FunctionParameter,
-      nodeToReplaceWith: DetachedNode<FunctionParameter>,
+      nodeToReplaceWith: MaybeDetachedNode<FunctionParameter>,
       options?: ReplaceNodeOptions,
     ): void,
   } & TransformReplaceSignatures, // allow like-for-like replacements as well
@@ -277,7 +291,9 @@ type TransformReplaceAPIs = $ReadOnly<{
    */
   replaceStatementWithMany: (
     target: ReplaceStatementWithManyMutation['target'],
-    nodesToReplaceWith: ReplaceStatementWithManyMutation['nodesToReplaceWith'],
+    nodesToReplaceWith: $ReadOnlyArray<
+      MaybeDetachedNode<ReplaceStatementWithManyMutationNodes>,
+    >,
     options?: {
       /**
        * Moves the comments from the target node to the first node in the array.
@@ -296,6 +312,7 @@ export type TransformContextAdditions = $ReadOnly<{
   ...TransformCommentAPIs,
   ...TransformCloneAPIs,
   ...TransformInsertAPIs,
+  ...TransformModifyAPIs,
   ...TransformRemoveAPIs,
   ...TransformReplaceAPIs,
 }>;
@@ -321,14 +338,15 @@ export function getTransformContext(): TransformContextAdditions {
         return null;
       }
 
-      return shallowCloneNode(node);
+      return shallowCloneNode(node, {});
     }: TransformCloneAPIs['shallowCloneNode']),
 
-    // $FlowExpectedError[incompatible-exact]
     shallowCloneNodeWithOverrides: ((
       node: ?ESNode,
-      newProps?: $ReadOnly<{...}>,
-    ): ?DetachedNode<ESNode> => {
+      newProps?: $ReadOnly<{...}> = {},
+    ): // $FlowExpectedError[incompatible-cast]
+    // $FlowExpectedError[prop-missing]
+    ?DetachedNode<ESNode> => {
       if (node == null) {
         return null;
       }
@@ -337,14 +355,20 @@ export function getTransformContext(): TransformContextAdditions {
     }: TransformCloneAPIs['shallowCloneNodeWithOverrides']),
 
     shallowCloneArray: (<T: ESNode>(
-      nodes: ?$ReadOnlyArray<T>,
+      nodes: ?$ReadOnlyArray<?T>,
     ): // $FlowExpectedError[incompatible-cast]
-    ?$ReadOnlyArray<DetachedNode<ESNode>> => {
+    ?$ReadOnlyArray<DetachedNode<?ESNode>> => {
       if (nodes == null) {
         return null;
       }
 
-      return nodes.map(node => shallowCloneNode<T>(node));
+      return nodes.map((node): DetachedNode<?ESNode> => {
+        if (node == null) {
+          // $FlowExpectedError[incompatible-return]
+          return node;
+        }
+        return shallowCloneNode<T>(node, {});
+      });
     }: TransformCloneAPIs['shallowCloneArray']),
 
     deepCloneNode: ((
@@ -355,14 +379,15 @@ export function getTransformContext(): TransformContextAdditions {
         return null;
       }
 
-      return deepCloneNode(node);
+      return deepCloneNode(node, {});
     }: TransformCloneAPIs['deepCloneNode']),
 
-    // $FlowExpectedError[incompatible-exact]
     deepCloneNodeWithOverrides: ((
       node: ?ESNode,
-      newProps?: $ReadOnly<{...}>,
-    ): ?DetachedNode<ESNode> => {
+      newProps?: $ReadOnly<{...}> = {},
+    ): // $FlowExpectedError[incompatible-cast]
+    // $FlowExpectedError[prop-missing]
+    ?DetachedNode<ESNode> => {
       if (node == null) {
         return null;
       }
@@ -444,13 +469,25 @@ export function getTransformContext(): TransformContextAdditions {
   const insertAPIs: TransformInsertAPIs = {
     insertAfterStatement: ((target, nodesToInsert): void => {
       pushMutation(
-        createInsertStatementMutation('after', target, toArray(nodesToInsert)),
+        createInsertStatementMutation(
+          'after',
+          target,
+          toArray(nodesToInsert).map(n =>
+            asDetachedNode(n, {useDeepClone: true}),
+          ),
+        ),
       );
     }: TransformInsertAPIs['insertBeforeStatement']),
 
     insertBeforeStatement: ((target, nodesToInsert): void => {
       pushMutation(
-        createInsertStatementMutation('before', target, toArray(nodesToInsert)),
+        createInsertStatementMutation(
+          'before',
+          target,
+          toArray(nodesToInsert).map(n =>
+            asDetachedNode(n, {useDeepClone: true}),
+          ),
+        ),
       );
     }: TransformInsertAPIs['insertBeforeStatement']),
   };
@@ -466,11 +503,15 @@ export function getTransformContext(): TransformContextAdditions {
   const replaceAPIs: TransformReplaceAPIs = {
     replaceNode: ((
       target: ESNode,
-      nodeToReplaceWith: DetachedNode<ESNode>,
+      nodeToReplaceWith: MaybeDetachedNode<ESNode>,
       options?: ReplaceNodeOptions,
     ): void => {
       pushMutation(
-        createReplaceNodeMutation(target, nodeToReplaceWith, options),
+        createReplaceNodeMutation(
+          target,
+          asDetachedNode(nodeToReplaceWith),
+          options,
+        ),
       );
     }: TransformReplaceAPIs['replaceNode']),
 
@@ -482,12 +523,27 @@ export function getTransformContext(): TransformContextAdditions {
       pushMutation(
         createReplaceStatementWithManyMutation(
           target,
-          nodesToReplaceWith,
+          nodesToReplaceWith.map(n => asDetachedNode(n)),
           options,
         ),
       );
     }: TransformReplaceAPIs['replaceStatementWithMany']),
   };
+  const modifyAPIs: TransformModifyAPIs = {
+    modifyNodeInPlace: ((
+      node: ?ESNode,
+      newProps?: $ReadOnly<{...}> = {},
+      options?: ReplaceNodeOptions,
+    ): void => {
+      if (node == null) {
+        return;
+      }
+
+      const cloned = shallowCloneNode(node, newProps, {preserveLocation: true});
+      // $FlowExpectedError[incompatible-call]
+      replaceAPIs.replaceNode(node, cloned, options);
+    }: TransformModifyAPIs['modifyNodeInPlace']),
+  };
 
   return {
     mutations,
@@ -500,6 +556,7 @@ export function getTransformContext(): TransformContextAdditions {
     ...cloneAPIs,
     ...commentAPIs,
     ...insertAPIs,
+    ...modifyAPIs,
     ...removeAPIs,
     ...replaceAPIs,
   };

package/dist/transform/comments/comments.js

@@ -10,7 +10,10 @@ exports.appendCommentToSource = appendCommentToSource;
 exports.attachComments = attachComments;
 exports.cloneComment = cloneComment;
 exports.cloneCommentWithMarkers = cloneCommentWithMarkers;
+exports.cloneJSDocCommentsToNewNode = cloneJSDocCommentsToNewNode;
 exports.getCommentsForNode = getCommentsForNode;
+exports.getLeadingCommentsForNode = getLeadingCommentsForNode;
+exports.getTrailingCommentsForNode = getTrailingCommentsForNode;
 exports.isLeadingComment = isLeadingComment;
 exports.isTrailingComment = isTrailingComment;
 exports.moveCommentsToNewNode = moveCommentsToNewNode;
@@ -24,6 +27,8 @@ var _printerEstree = _interopRequireDefault(require("./prettier/language-js/prin
 
 var _util = require("./prettier/common/util");
 
+var _hermesEstree = require("hermes-estree");
+
 var _os = require("os");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -57,18 +62,34 @@ function moveCommentsToNewNode(oldNode, newNode) {
   setCommentsOnNode(oldNode, []);
 }
 
+function cloneJSDocCommentsToNewNode(oldNode, newNode) {
+  const comments = getCommentsForNode(oldNode).filter(comment => {
+    return (0, _hermesEstree.isBlockComment)(comment) && // JSDoc comments always start with an extra asterisk
+    comment.value.startsWith('*');
+  });
+  setCommentsOnNode(newNode, comments.map(cloneCommentWithMarkers));
+}
+
 function setCommentsOnNode(node, comments) {
   // $FlowExpectedError - this property is secretly added by prettier.
   node.comments = comments;
 }
 
-function addCommentsToNode(node, comments) {
+function addCommentsToNode(node, comments, side = 'trailing') {
   var _node$comments;
 
-  // $FlowExpectedError - this property is secretly added by prettier.
-  node.comments = (_node$comments = node.comments) != null ? _node$comments : []; // $FlowExpectedError
-
-  node.comments.push(...comments);
+  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
+  // $FlowExpectedError[cannot-write]
+  // $FlowExpectedError[incompatible-use]
+  node.comments = (_node$comments = node.comments) != null ? _node$comments : [];
+
+  if (side === 'leading') {
+    // $FlowExpectedError[incompatible-cast]
+    node.comments.unshift(...comments);
+  } else {
+    // $FlowExpectedError[incompatible-cast]
+    node.comments.push(...comments);
+  }
 }
 
 function getCommentsForNode(node) {
@@ -88,6 +109,14 @@ function isTrailingComment(comment) {
   return comment.trailing === true;
 }
 
+function getLeadingCommentsForNode(node) {
+  return getCommentsForNode(node).filter(isLeadingComment);
+}
+
+function getTrailingCommentsForNode(node) {
+  return getCommentsForNode(node).filter(isTrailingComment);
+}
+
 function addComment(node, comment, placement) {
   switch (placement) {
     case CommentPlacement.LEADING_OWN_LINE:

package/dist/transform/comments/comments.js.flow

@@ -9,7 +9,7 @@
  */
 
 import type {Comment, ESNode, Program} from 'hermes-estree';
-import type {DetachedNode} from '../../detachedNode';
+import type {DetachedNode, MaybeDetachedNode} from '../../detachedNode';
 
 // $FlowExpectedError[untyped-import]
 import {attach as untypedAttach} from './prettier/main/comments';
@@ -23,6 +23,7 @@ import {
   // $FlowExpectedError[untyped-import]
   addTrailingComment as untypedAddTrailingComment,
 } from './prettier/common/util';
+import {isBlockComment} from 'hermes-estree';
 import {EOL} from 'os';
 
 export type Options = $ReadOnly<{}>;
@@ -54,6 +55,20 @@ export function moveCommentsToNewNode(
   setCommentsOnNode(oldNode, []);
 }
 
+export function cloneJSDocCommentsToNewNode(
+  oldNode: ESNode,
+  newNode: MaybeDetachedNode<ESNode>,
+): void {
+  const comments = getCommentsForNode(oldNode).filter(comment => {
+    return (
+      isBlockComment(comment) &&
+      // JSDoc comments always start with an extra asterisk
+      comment.value.startsWith('*')
+    );
+  });
+  setCommentsOnNode(newNode, comments.map(cloneCommentWithMarkers));
+}
+
 export function setCommentsOnNode(
   node: ESNode | DetachedNode<ESNode>,
   comments: $ReadOnlyArray<Comment>,
@@ -65,11 +80,19 @@ export function setCommentsOnNode(
 export function addCommentsToNode(
   node: ESNode | DetachedNode<ESNode>,
   comments: $ReadOnlyArray<Comment>,
+  side?: 'leading' | 'trailing' = 'trailing',
 ): void {
-  // $FlowExpectedError - this property is secretly added by prettier.
+  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
+  // $FlowExpectedError[cannot-write]
+  // $FlowExpectedError[incompatible-use]
   node.comments = node.comments ?? [];
-  // $FlowExpectedError
-  (node.comments: Array<Comment>).push(...comments);
+  if (side === 'leading') {
+    // $FlowExpectedError[incompatible-cast]
+    (node.comments: Array<Comment>).unshift(...comments);
+  } else {
+    // $FlowExpectedError[incompatible-cast]
+    (node.comments: Array<Comment>).push(...comments);
+  }
 }
 
 export function getCommentsForNode(
@@ -88,6 +111,18 @@ export function isTrailingComment(comment: Comment): boolean {
   return comment.trailing === true;
 }
 
+export function getLeadingCommentsForNode(
+  node: ESNode | DetachedNode<ESNode>,
+): $ReadOnlyArray<Comment> {
+  return getCommentsForNode(node).filter(isLeadingComment);
+}
+
+export function getTrailingCommentsForNode(
+  node: ESNode | DetachedNode<ESNode>,
+): $ReadOnlyArray<Comment> {
+  return getCommentsForNode(node).filter(isTrailingComment);
+}
+
 export function addComment(
   node: ESNode | DetachedNode<ESNode>,
   comment: Comment,

package/dist/transform/comments/prettier/main/comments.js

@@ -50,7 +50,7 @@ function getSortedChildNodes(node, options, resultArray) {
     return childNodesCache.get(node);
   }
 
-  const childNodes = printer.getCommentChildNodes && printer.getCommentChildNodes(node, options) || typeof node === 'object' && Object.entries(node).filter(([key]) => key !== 'enclosingNode' && key !== 'precedingNode' && key !== 'followingNode' && key !== 'tokens' && key !== 'comments').map(([, value]) => value);
+  const childNodes = printer.getCommentChildNodes && printer.getCommentChildNodes(node, options) || typeof node === 'object' && Object.entries(node).filter(([key]) => key !== 'enclosingNode' && key !== 'precedingNode' && key !== 'followingNode' && key !== 'tokens' && key !== 'comments' && key !== 'parent').map(([, value]) => value);
 
   if (!childNodes) {
     return;

package/dist/transform/comments/prettier/main/comments.js.flow

@@ -57,7 +57,8 @@ function getSortedChildNodes(node, options, resultArray) {
             key !== 'precedingNode' &&
             key !== 'followingNode' &&
             key !== 'tokens' &&
-            key !== 'comments',
+            key !== 'comments' &&
+            key !== 'parent',
         )
         .map(([, value]) => value));
 

package/dist/transform/mutations/InsertStatement.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.createInsertStatementMutation = createInsertStatementMutation;
 exports.performInsertStatementMutation = performInsertStatementMutation;
 
-var _arrayUtils = require("./utils/arrayUtils");
+var _hermesParser = require("hermes-parser");
 
 var _getStatementParent = require("./utils/getStatementParent");
 
@@ -58,13 +58,13 @@ function performInsertStatementMutation(mutationContext, mutation) {
     switch (mutation.side) {
       case 'before':
         {
-          parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(parent[insertionParent.key], insertionParent.targetIndex, mutation.nodesToInsert);
+          parent[insertionParent.key] = _hermesParser.astArrayMutationHelpers.insertInArray(parent[insertionParent.key], insertionParent.targetIndex, mutation.nodesToInsert);
           break;
         }
 
       case 'after':
         {
-          parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(parent[insertionParent.key], insertionParent.targetIndex + 1, mutation.nodesToInsert);
+          parent[insertionParent.key] = _hermesParser.astArrayMutationHelpers.insertInArray(parent[insertionParent.key], insertionParent.targetIndex + 1, mutation.nodesToInsert);
           break;
         }
     }
@@ -86,5 +86,6 @@ function performInsertStatementMutation(mutationContext, mutation) {
     parent: insertionParent.parent
   });
   insertionParent.parent[insertionParent.key] = blockStatement;
+  statementToWrap.parent = blockStatement;
   return insertionParent.parent;
 }

package/dist/transform/mutations/InsertStatement.js.flow

@@ -12,7 +12,7 @@ import type {ESNode, ModuleDeclaration, Statement} from 'hermes-estree';
 import type {MutationContext} from '../MutationContext';
 import type {DetachedNode} from '../../detachedNode';
 
-import {insertInArray} from './utils/arrayUtils';
+import {astArrayMutationHelpers} from 'hermes-parser';
 import {getStatementParent} from './utils/getStatementParent';
 import {isValidModuleDeclarationParent} from './utils/isValidModuleDeclarationParent';
 import {InvalidInsertionError} from '../Errors';
@@ -73,7 +73,7 @@ export function performInsertStatementMutation(
     } = insertionParent.parent;
     switch (mutation.side) {
       case 'before': {
-        parent[insertionParent.key] = insertInArray(
+        parent[insertionParent.key] = astArrayMutationHelpers.insertInArray(
           parent[insertionParent.key],
           insertionParent.targetIndex,
           mutation.nodesToInsert,
@@ -82,7 +82,7 @@ export function performInsertStatementMutation(
       }
 
       case 'after': {
-        parent[insertionParent.key] = insertInArray(
+        parent[insertionParent.key] = astArrayMutationHelpers.insertInArray(
           parent[insertionParent.key],
           insertionParent.targetIndex + 1,
           mutation.nodesToInsert,
@@ -113,6 +113,7 @@ export function performInsertStatementMutation(
 
   (insertionParent.parent: interface {[string]: mixed})[insertionParent.key] =
     blockStatement;
+  statementToWrap.parent = blockStatement;
 
   return insertionParent.parent;
 }

package/dist/transform/mutations/RemoveComment.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.createRemoveCommentMutation = createRemoveCommentMutation;
 exports.performRemoveCommentMutations = performRemoveCommentMutations;
 
-var _SimpleTraverser = require("../../traverse/SimpleTraverser");
+var _hermesParser = require("hermes-parser");
 
 var _comments = require("../comments/comments");
 
@@ -33,7 +33,7 @@ function performRemoveCommentMutations(ast, mutations) {
 
   const commentsToRemove = new Set(mutations.map(m => m.comment));
 
-  _SimpleTraverser.SimpleTraverser.traverse(ast, {
+  _hermesParser.SimpleTraverser.traverse(ast, {
     enter(node) {
       if (node === ast) {
         return;
@@ -56,7 +56,7 @@ function performRemoveCommentMutations(ast, mutations) {
 
       if (commentsToRemove.size === 0) {
         // no more comments to process - so we can exit traversal
-        throw _SimpleTraverser.SimpleTraverserBreak;
+        throw _hermesParser.SimpleTraverserBreak;
       }
     },
 

package/dist/transform/mutations/RemoveComment.js.flow

@@ -9,10 +9,8 @@
  */
 
 import type {Comment, Program} from 'hermes-estree';
-import {
-  SimpleTraverser,
-  SimpleTraverserBreak,
-} from '../../traverse/SimpleTraverser';
+
+import {SimpleTraverser, SimpleTraverserBreak} from 'hermes-parser';
 import {getCommentsForNode, setCommentsOnNode} from '../comments/comments';
 
 export type RemoveCommentMutation = $ReadOnly<{
@@ -70,7 +68,7 @@ function intersectSets<T>(
   first: $ReadOnlySet<T>,
   other: $ReadOnlySet<T>,
 ): Set<T> {
-  const ret = new Set();
+  const ret = new Set<T>();
   for (const value of first) {
     if (other.has(value)) {
       ret.add(value);

package/dist/transform/mutations/RemoveNode.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.createRemoveNodeMutation = createRemoveNodeMutation;
 exports.performRemoveNodeMutation = performRemoveNodeMutation;
 
-var _arrayUtils = require("./utils/arrayUtils");
+var _hermesParser = require("hermes-parser");
 
 var _Errors = require("../Errors");
 
@@ -187,6 +187,6 @@ function performRemoveNodeMutation(mutationContext, mutation) {
   mutationContext.markDeletion(mutation.node);
   mutationContext.markMutation(removalParent.parent, removalParent.key);
   const parent = removalParent.parent;
-  parent[removalParent.key] = (0, _arrayUtils.removeFromArray)(parent[removalParent.key], removalParent.targetIndex);
+  parent[removalParent.key] = _hermesParser.astArrayMutationHelpers.removeFromArray(parent[removalParent.key], removalParent.targetIndex);
   return removalParent.parent;
 }

package/dist/transform/mutations/RemoveNode.js.flow

@@ -30,7 +30,7 @@ import type {
 import type {MutationContext} from '../MutationContext';
 import type {DetachedNode} from '../../detachedNode';
 
-import {removeFromArray} from './utils/arrayUtils';
+import {astArrayMutationHelpers} from 'hermes-parser';
 import {InvalidRemovalError} from '../Errors';
 
 export type RemoveNodeMutation = $ReadOnly<{
@@ -281,7 +281,7 @@ export function performRemoveNodeMutation(
   const parent: interface {
     [string]: $ReadOnlyArray<DetachedNode<RemoveNodeMutation['node']>>,
   } = removalParent.parent;
-  parent[removalParent.key] = removeFromArray(
+  parent[removalParent.key] = astArrayMutationHelpers.removeFromArray(
     parent[removalParent.key],
     removalParent.targetIndex,
   );

package/dist/transform/mutations/RemoveStatement.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.createRemoveStatementMutation = createRemoveStatementMutation;
 exports.performRemoveStatementMutation = performRemoveStatementMutation;
 
-var _arrayUtils = require("./utils/arrayUtils");
+var _hermesParser = require("hermes-parser");
 
 var _getStatementParent = require("./utils/getStatementParent");
 
@@ -39,7 +39,7 @@ function performRemoveStatementMutation(mutationContext, mutation) {
 
   if (removalParent.type === 'array') {
     const parent = removalParent.parent;
-    parent[removalParent.key] = (0, _arrayUtils.removeFromArray)(parent[removalParent.key], removalParent.targetIndex);
+    parent[removalParent.key] = _hermesParser.astArrayMutationHelpers.removeFromArray(parent[removalParent.key], removalParent.targetIndex);
   } else {
     // The parent has a 1:1 relationship on this key, so we can't just
     // remove the node. Instead we replace it with an empty block statement.