hermes-transform 0.5.0

package/dist/transform/getTransformedAST.js.flow

@@ -0,0 +1,128 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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 {ESNode, Program} from 'hermes-estree';
+import type {Visitor} from '../traverse/traverse';
+import type {TransformContext} from './TransformContext';
+import type {RemoveCommentMutation} from './mutations/RemoveComment';
+
+import {parseForESLint} from 'hermes-eslint';
+import {updateAllParentPointers} from '../detachedNode';
+import {traverseWithContext} from '../traverse/traverse';
+import {MutationContext} from './MutationContext';
+import {getTransformContext} from './TransformContext';
+import {attachComments} from './comments/comments';
+import {performAddLeadingCommentsMutation} from './mutations/AddLeadingComments';
+import {performAddTrailingCommentsMutation} from './mutations/AddTrailingComments';
+import {performCloneCommentsToMutation} from './mutations/CloneCommentsTo';
+import {performInsertStatementMutation} from './mutations/InsertStatement';
+import {performRemoveCommentMutations} from './mutations/RemoveComment';
+import {performRemoveStatementMutation} from './mutations/RemoveStatement';
+import {performReplaceNodeMutation} from './mutations/ReplaceNode';
+import {performReplaceStatementWithManyMutation} from './mutations/ReplaceStatementWithMany';
+
+export function getTransformedAST(
+  code: string,
+  visitors: Visitor<TransformContext>,
+): {
+  ast: Program,
+  astWasMutated: boolean,
+  mutatedCode: string,
+} {
+  const {ast, scopeManager} = parseForESLint(code, {
+    sourceType: 'module',
+  });
+
+  // attach comments before mutation. this will ensure that as nodes are
+  // cloned / moved around - comments remain in the correct place with respect to the node
+  attachComments(ast.comments, ast, code);
+
+  // traverse the AST and colllect the mutations
+  const transformContext = getTransformContext();
+  traverseWithContext(ast, scopeManager, () => transformContext, visitors);
+
+  // apply the mutations to the AST
+  const mutationContext = new MutationContext(code);
+
+  const removeCommentMutations: Array<RemoveCommentMutation> = [];
+
+  for (const mutation of transformContext.mutations) {
+    const mutationRoot = ((): ESNode | null => {
+      switch (mutation.type) {
+        case 'insertStatement': {
+          return performInsertStatementMutation(mutationContext, mutation);
+        }
+
+        case 'replaceNode': {
+          return performReplaceNodeMutation(mutationContext, mutation);
+        }
+
+        case 'replaceStatementWithMany': {
+          return performReplaceStatementWithManyMutation(
+            mutationContext,
+            mutation,
+          );
+        }
+
+        case 'removeStatement': {
+          return performRemoveStatementMutation(mutationContext, mutation);
+        }
+
+        case 'removeComment': {
+          // these are handled later
+          removeCommentMutations.push(mutation);
+          return null;
+        }
+
+        case 'addLeadingComments': {
+          return performAddLeadingCommentsMutation(mutationContext, mutation);
+        }
+
+        case 'addTrailingComments': {
+          return performAddTrailingCommentsMutation(mutationContext, mutation);
+        }
+
+        case 'cloneCommentsTo': {
+          return performCloneCommentsToMutation(mutationContext, mutation);
+        }
+      }
+    })();
+
+    // ensure the subtree's parent pointers are correct
+    // this is required for two reasons:
+    // 1) The userland transform is just JS - so there's nothing stopping them
+    //    from doing anything dodgy. The flow types have some enforcement, but
+    //    ofc that can just be ignored with a suppression.
+    // 2) Shallow clones are a necessary evil in the transform because they
+    //    allow codemods to do simple changes to just one node without the
+    //    weight that comes with deeply cloning the entire AST.
+    //    However we can't update the parent pointers of the cloned node's
+    //    children until the mutation step or else we would be mutating
+    //    real AST nodes and potentially break the traverse step.
+    //
+    // Being strict here just helps us ensure we keep everything in sync
+    if (mutationRoot) {
+      updateAllParentPointers(mutationRoot);
+    }
+  }
+
+  // remove the comments
+  // this is done at the end because it requires a complete traversal of the AST
+  // so that we can find relevant node's attachment array
+  performRemoveCommentMutations(ast, removeCommentMutations);
+
+  return {
+    ast,
+    astWasMutated: transformContext.astWasMutated,
+    mutatedCode: mutationContext.code,
+  };
+}

package/dist/transform/mutations/AddLeadingComments.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAddLeadingCommentsMutation = createAddLeadingCommentsMutation;
+exports.performAddLeadingCommentsMutation = performAddLeadingCommentsMutation;
+
+var _comments = require("../comments/comments");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function createAddLeadingCommentsMutation(node, comments) {
+  if (comments.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'addLeadingComments',
+    comments: comments,
+    node: node
+  };
+}
+
+function performAddLeadingCommentsMutation(mutationContext, mutation) {
+  var _iterator = _createForOfIteratorHelper(mutation.comments),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var originalComment = _step.value;
+      var comment = (0, _comments.cloneComment)(originalComment);
+      mutationContext.appendCommentToSource(comment);
+      (0, _comments.addLeadingComment)(mutation.node, comment);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return null;
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+import type {Comment, ESNode} from 'hermes-estree';
+import type {DetachedNode} from '../../detachedNode';
+import type {MutationContext} from '../MutationContext';
+
+import {addLeadingComment, cloneComment} from '../comments/comments';
+
+export type AddLeadingCommentsMutation = $ReadOnly<{
+  type: 'addLeadingComments',
+  comments: $ReadOnlyArray<Comment>,
+  node: ESNode | DetachedNode<ESNode>,
+}>;
+
+export function createAddLeadingCommentsMutation(
+  node: AddLeadingCommentsMutation['node'],
+  comments: AddLeadingCommentsMutation['comments'],
+): ?AddLeadingCommentsMutation {
+  if (comments.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'addLeadingComments',
+    comments,
+    node,
+  };
+}
+
+export function performAddLeadingCommentsMutation(
+  mutationContext: MutationContext,
+  mutation: AddLeadingCommentsMutation,
+): null {
+  for (const originalComment of mutation.comments) {
+    const comment = cloneComment(originalComment);
+    mutationContext.appendCommentToSource(comment);
+    addLeadingComment(mutation.node, comment);
+  }
+
+  return null;
+}

package/dist/transform/mutations/AddTrailingComments.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAddTrailingCommentsMutation = createAddTrailingCommentsMutation;
+exports.performAddTrailingCommentsMutation = performAddTrailingCommentsMutation;
+
+var _comments = require("../comments/comments");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function createAddTrailingCommentsMutation(node, comments) {
+  if (comments.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'addTrailingComments',
+    comments: comments,
+    node: node
+  };
+}
+
+function performAddTrailingCommentsMutation(mutationContext, mutation) {
+  var _iterator = _createForOfIteratorHelper(mutation.comments),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var originalComment = _step.value;
+      var comment = (0, _comments.cloneComment)(originalComment);
+      mutationContext.appendCommentToSource(comment);
+      (0, _comments.addTrailingComment)(mutation.node, comment);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return null;
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+import type {Comment, ESNode} from 'hermes-estree';
+import type {DetachedNode} from '../../detachedNode';
+import type {MutationContext} from '../MutationContext';
+
+import {addTrailingComment, cloneComment} from '../comments/comments';
+
+export type AddTrailingCommentsMutation = $ReadOnly<{
+  type: 'addTrailingComments',
+  comments: $ReadOnlyArray<Comment>,
+  node: ESNode | DetachedNode<ESNode>,
+}>;
+
+export function createAddTrailingCommentsMutation(
+  node: AddTrailingCommentsMutation['node'],
+  comments: AddTrailingCommentsMutation['comments'],
+): ?AddTrailingCommentsMutation {
+  if (comments.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'addTrailingComments',
+    comments,
+    node,
+  };
+}
+
+export function performAddTrailingCommentsMutation(
+  mutationContext: MutationContext,
+  mutation: AddTrailingCommentsMutation,
+): null {
+  for (const originalComment of mutation.comments) {
+    const comment = cloneComment(originalComment);
+    mutationContext.appendCommentToSource(comment);
+    addTrailingComment(mutation.node, comment);
+  }
+
+  return null;
+}

package/dist/transform/mutations/CloneCommentsTo.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCloneCommentsToMutation = createCloneCommentsToMutation;
+exports.performCloneCommentsToMutation = performCloneCommentsToMutation;
+
+var _comments = require("../comments/comments");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function createCloneCommentsToMutation(target, destination) {
+  return {
+    type: 'cloneCommentsTo',
+    target: target,
+    destination: destination
+  };
+}
+
+function performCloneCommentsToMutation(mutationContext, mutation) {
+  var newComments = [];
+
+  var _iterator = _createForOfIteratorHelper((0, _comments.getCommentsForNode)(mutation.target)),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var originalComment = _step.value;
+      var comment = (0, _comments.cloneCommentWithMarkers)(originalComment);
+      mutationContext.appendCommentToSource(comment);
+      newComments.push(comment);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  (0, _comments.addCommentsToNode)(mutation.destination, newComments);
+  return null;
+}

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

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+import type {ESNode} from 'hermes-estree';
+import type {DetachedNode} from '../../detachedNode';
+import type {MutationContext} from '../MutationContext';
+
+import {
+  addCommentsToNode,
+  cloneCommentWithMarkers,
+  getCommentsForNode,
+} from '../comments/comments';
+
+export type CloneCommentsToMutation = $ReadOnly<{
+  type: 'cloneCommentsTo',
+  target: ESNode | DetachedNode<ESNode>,
+  destination: ESNode | DetachedNode<ESNode>,
+}>;
+
+export function createCloneCommentsToMutation(
+  target: CloneCommentsToMutation['target'],
+  destination: CloneCommentsToMutation['destination'],
+): CloneCommentsToMutation {
+  return {
+    type: 'cloneCommentsTo',
+    target,
+    destination,
+  };
+}
+
+export function performCloneCommentsToMutation(
+  mutationContext: MutationContext,
+  mutation: CloneCommentsToMutation,
+): null {
+  const newComments = [];
+  for (const originalComment of getCommentsForNode(mutation.target)) {
+    const comment = cloneCommentWithMarkers(originalComment);
+    mutationContext.appendCommentToSource(comment);
+    newComments.push(comment);
+  }
+  addCommentsToNode(mutation.destination, newComments);
+
+  return null;
+}

package/dist/transform/mutations/InsertStatement.js

@@ -0,0 +1,92 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInsertStatementMutation = createInsertStatementMutation;
+exports.performInsertStatementMutation = performInsertStatementMutation;
+
+var _arrayUtils = require("./utils/arrayUtils");
+
+var _getStatementParent = require("./utils/getStatementParent");
+
+var _isValidModuleDeclarationParent = require("./utils/isValidModuleDeclarationParent");
+
+var _Errors = require("../Errors");
+
+var t = _interopRequireWildcard(require("../../generated/node-types"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(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; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function createInsertStatementMutation(side, target, nodesToInsert) {
+  if (nodesToInsert.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'insertStatement',
+    side: side,
+    target: target,
+    nodesToInsert: nodesToInsert
+  };
+}
+
+function performInsertStatementMutation(mutationContext, mutation) {
+  var insertionParent = (0, _getStatementParent.getStatementParent)(mutation.target); // enforce that if we are inserting module declarations - they are being inserted in a valid location
+
+  if (!(0, _isValidModuleDeclarationParent.isValidModuleDeclarationParent)(insertionParent.parent, mutation.nodesToInsert)) {
+    throw new _Errors.InvalidInsertionError("import/export cannot be inserted into a ".concat(insertionParent.parent.type, "."));
+  }
+
+  mutationContext.markMutation(insertionParent.parent, insertionParent.key);
+
+  if (insertionParent.type === 'array') {
+    var _parent = insertionParent.parent;
+
+    switch (mutation.side) {
+      case 'before':
+        {
+          _parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(_parent[insertionParent.key], insertionParent.targetIndex - 1, mutation.nodesToInsert);
+          break;
+        }
+
+      case 'after':
+        {
+          _parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(_parent[insertionParent.key], insertionParent.targetIndex + 1, mutation.nodesToInsert);
+          break;
+        }
+    }
+
+    return insertionParent.parent;
+  }
+
+  var statementsToInsert = // $FlowExpectedError[incompatible-cast] -- this is enforced by isValidModuleDeclarationParent above
+  mutation.nodesToInsert;
+  var parent = insertionParent.parent,
+      key = insertionParent.key; // $FlowExpectedError[prop-missing]
+
+  var statementToWrap = parent[key]; // we need to wrap this key in a BlockStatement so we can insert the new statement
+
+  var blockStatement = t.BlockStatement({
+    body: mutation.side === 'before' ? [].concat(_toConsumableArray(statementsToInsert), [statementToWrap]) : [statementToWrap].concat(_toConsumableArray(statementsToInsert)),
+    parent: insertionParent.parent
+  });
+  insertionParent.parent[insertionParent.key] = blockStatement;
+  return insertionParent.parent;
+}

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

@@ -0,0 +1,113 @@
+/**
+ * Copyright (c) Facebook, Inc. and its 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
+ */
+
+import type {ESNode, ModuleDeclaration, Statement} from 'hermes-estree';
+import type {MutationContext} from '../MutationContext';
+import type {DetachedNode} from '../../detachedNode';
+
+import {insertInArray} from './utils/arrayUtils';
+import {getStatementParent} from './utils/getStatementParent';
+import {isValidModuleDeclarationParent} from './utils/isValidModuleDeclarationParent';
+import {InvalidInsertionError} from '../Errors';
+import * as t from '../../generated/node-types';
+
+export type InsertStatementMutation = $ReadOnly<{
+  type: 'insertStatement',
+  side: 'before' | 'after',
+  target: ModuleDeclaration | Statement,
+  nodesToInsert: $ReadOnlyArray<DetachedNode<Statement | ModuleDeclaration>>,
+}>;
+
+export function createInsertStatementMutation(
+  side: InsertStatementMutation['side'],
+  target: InsertStatementMutation['target'],
+  nodesToInsert: InsertStatementMutation['nodesToInsert'],
+): ?InsertStatementMutation {
+  if (nodesToInsert.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'insertStatement',
+    side,
+    target,
+    nodesToInsert,
+  };
+}
+
+export function performInsertStatementMutation(
+  mutationContext: MutationContext,
+  mutation: InsertStatementMutation,
+): ESNode {
+  const insertionParent = getStatementParent(mutation.target);
+
+  // enforce that if we are inserting module declarations - they are being inserted in a valid location
+  if (
+    !isValidModuleDeclarationParent(
+      insertionParent.parent,
+      mutation.nodesToInsert,
+    )
+  ) {
+    throw new InvalidInsertionError(
+      `import/export cannot be inserted into a ${insertionParent.parent.type}.`,
+    );
+  }
+
+  mutationContext.markMutation(insertionParent.parent, insertionParent.key);
+
+  if (insertionParent.type === 'array') {
+    const parent: interface {
+      [string]: $ReadOnlyArray<DetachedNode<Statement | ModuleDeclaration>>,
+    } = insertionParent.parent;
+    switch (mutation.side) {
+      case 'before': {
+        parent[insertionParent.key] = insertInArray(
+          parent[insertionParent.key],
+          insertionParent.targetIndex - 1,
+          mutation.nodesToInsert,
+        );
+        break;
+      }
+
+      case 'after': {
+        parent[insertionParent.key] = insertInArray(
+          parent[insertionParent.key],
+          insertionParent.targetIndex + 1,
+          mutation.nodesToInsert,
+        );
+        break;
+      }
+    }
+
+    return insertionParent.parent;
+  }
+
+  const statementsToInsert =
+    // $FlowExpectedError[incompatible-cast] -- this is enforced by isValidModuleDeclarationParent above
+    (mutation.nodesToInsert: $ReadOnlyArray<DetachedNode<Statement>>);
+
+  const {parent, key} = insertionParent;
+
+  // $FlowExpectedError[prop-missing]
+  const statementToWrap = parent[key];
+  // we need to wrap this key in a BlockStatement so we can insert the new statement
+  const blockStatement = t.BlockStatement({
+    body:
+      mutation.side === 'before'
+        ? [...statementsToInsert, statementToWrap]
+        : [statementToWrap, ...statementsToInsert],
+    parent: insertionParent.parent,
+  });
+
+  (insertionParent.parent: interface {[string]: mixed})[insertionParent.key] =
+    blockStatement;
+
+  return insertionParent.parent;
+}