hermes-transform 0.28.0 → 0.29.0

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

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCloneCommentsToMutation = createCloneCommentsToMutation;
+exports.performCloneCommentsToMutation = performCloneCommentsToMutation;
+
+var _comments = require("../comments/comments");
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+function createCloneCommentsToMutation(target, destination) {
+  return {
+    type: 'cloneCommentsTo',
+    target,
+    destination
+  };
+}
+
+function performCloneCommentsToMutation(_mutationContext, mutation) {
+  (0, _comments.cloneCommentsToNewNode)(mutation.target, mutation.destination);
+  return null;
+}

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

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createInsertStatementMutation = createInsertStatementMutation;
+exports.performInsertStatementMutation = performInsertStatementMutation;
+
+var _hermesParser = require("hermes-parser");
+
+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 (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; }
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+function createInsertStatementMutation(side, target, nodesToInsert) {
+  if (nodesToInsert.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'insertStatement',
+    side,
+    target,
+    nodesToInsert
+  };
+}
+
+function performInsertStatementMutation(mutationContext, mutation) {
+  mutationContext.assertNotDeleted(mutation.target, `Attempted to insert ${mutation.side} a deleted ${mutation.target.type} node. This likely means that you attempted to mutate around the target after it was deleted/replaced.`);
+  const 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 ${insertionParent.parent.type}.`);
+  }
+
+  mutationContext.markMutation(insertionParent.parent, insertionParent.key);
+
+  if (insertionParent.type === 'array') {
+    const parent = insertionParent.parent;
+
+    switch (mutation.side) {
+      case 'before':
+        {
+          parent[insertionParent.key] = _hermesParser.astArrayMutationHelpers.insertInArray(parent[insertionParent.key], insertionParent.targetIndex, mutation.nodesToInsert);
+          break;
+        }
+
+      case 'after':
+        {
+          parent[insertionParent.key] = _hermesParser.astArrayMutationHelpers.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;
+  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[insertionParent.key] = blockStatement;
+  statementToWrap.parent = blockStatement;
+  return insertionParent.parent;
+}

package/dist/src/transform/mutations/ModifyNodeInPlace.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createModifyNodeInPlaceMutation = createModifyNodeInPlaceMutation;
+exports.performModifyNodeInPlaceMutation = performModifyNodeInPlaceMutation;
+
+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
+ */
+function createModifyNodeInPlaceMutation(target, newProps) {
+  return {
+    type: 'modifyNodeInPlace',
+    target,
+    newProps
+  };
+}
+
+function performModifyNodeInPlaceMutation(mutationContext, mutation) {
+  const {
+    target,
+    newProps
+  } = mutation;
+
+  for (const [key, newPropValue] of Object.entries(newProps)) {
+    const prevPropValue = target[key]; // If the value did not change, skip.
+
+    if (prevPropValue === newPropValue) {
+      continue;
+    } // Mark removed nodes as deleted
+
+
+    if ((0, _hermesParser.isNode)(prevPropValue)) {
+      mutationContext.markDeletion(prevPropValue);
+    } else if (Array.isArray(prevPropValue)) {
+      for (const prevPropValueItem of prevPropValue) {
+        if ((0, _hermesParser.isNode)(prevPropValueItem)) {
+          mutationContext.markDeletion(prevPropValueItem);
+        }
+      }
+    } // Mark node property as mutated.
+
+
+    mutationContext.markMutation(target, key); // Assign new property.
+
+    target[key] = newPropValue;
+  }
+
+  return target;
+}

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

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRemoveCommentMutation = createRemoveCommentMutation;
+exports.performRemoveCommentMutations = performRemoveCommentMutations;
+
+var _hermesParser = require("hermes-parser");
+
+var _comments = require("../comments/comments");
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+function createRemoveCommentMutation(comment) {
+  return {
+    type: 'removeComment',
+    comment
+  };
+}
+
+function performRemoveCommentMutations(ast, mutations) {
+  if (mutations.length === 0) {
+    return;
+  }
+
+  const commentsToRemove = new Set(mutations.map(m => m.comment));
+
+  _hermesParser.SimpleTraverser.traverse(ast, {
+    enter(node) {
+      if (node === ast) {
+        return;
+      }
+
+      const nodeCommentsSet = new Set((0, _comments.getCommentsForNode)(node));
+
+      if (nodeCommentsSet.size === 0) {
+        return;
+      }
+
+      const matchedComments = intersectSets(commentsToRemove, nodeCommentsSet);
+
+      for (const comment of matchedComments) {
+        commentsToRemove.delete(comment);
+        nodeCommentsSet.delete(comment);
+      }
+
+      (0, _comments.setCommentsOnNode)(node, Array.from(nodeCommentsSet));
+
+      if (commentsToRemove.size === 0) {
+        // no more comments to process - so we can exit traversal
+        throw _hermesParser.SimpleTraverserBreak;
+      }
+    },
+
+    leave() {}
+
+  });
+}
+
+function intersectSets(first, other) {
+  const ret = new Set();
+
+  for (const value of first) {
+    if (other.has(value)) {
+      ret.add(value);
+    }
+  }
+
+  return ret;
+}

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

@@ -0,0 +1,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRemoveNodeMutation = createRemoveNodeMutation;
+exports.performRemoveNodeMutation = performRemoveNodeMutation;
+
+var _hermesParser = require("hermes-parser");
+
+var _Errors = require("../Errors");
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+function createRemoveNodeMutation(node) {
+  return {
+    type: 'removeNode',
+    node
+  };
+}
+
+const VALID_ENUM_MEMBER_PARENTS = ['EnumBooleanBody', 'EnumNumberBody', 'EnumBigIntBody', 'EnumStringBody', 'EnumSymbolBody'];
+const VALID_FUNCTION_PARAMETER_PARENTS = ['ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression'];
+const VALID_PROPERTY_PARENTS = ['ObjectExpression', 'ObjectPattern'];
+const VALID_COMPONENT_TYPE_PARAMETER_PARENTS = ['DeclareComponent', 'ComponentTypeAnnotation'];
+
+function getRemovalParent(node) {
+  const key = (() => {
+    function getErrorMessage(expectedParents) {
+      return `Tried to remove ${node.type} from parent of type ${node.parent.type}.\nHowever ${node.type} can only be safely removed from parent of type ${expectedParents.join(' | ')}.`;
+    }
+
+    function assertParent(expectedParents_) {
+      const expectedParents = typeof expectedParents_ === 'string' ? [expectedParents_] : expectedParents_;
+
+      if (!expectedParents.includes(node.parent.type)) {
+        return new _Errors.InvalidRemovalError(getErrorMessage(expectedParents));
+      }
+    }
+
+    switch (node.type) {
+      // ClassMember
+      case 'PropertyDefinition':
+      case 'MethodDefinition':
+        assertParent('ClassBody');
+        return 'body';
+
+      case 'EnumBooleanMember':
+      case 'EnumDefaultedMember':
+      case 'EnumNumberMember':
+      case 'EnumStringMember':
+        assertParent(VALID_ENUM_MEMBER_PARENTS);
+        return 'members';
+      // Components
+
+      case 'ComponentParameter':
+        assertParent('ComponentDeclaration');
+        return 'params';
+
+      case 'ComponentTypeParameter':
+        assertParent(VALID_COMPONENT_TYPE_PARAMETER_PARENTS);
+        return 'params';
+      // FunctionParameter
+
+      case 'AssignmentPattern':
+      case 'ArrayPattern':
+      case 'ObjectPattern':
+        assertParent(VALID_FUNCTION_PARAMETER_PARENTS);
+        return 'params';
+
+      case 'FunctionTypeParam':
+        assertParent('FunctionTypeAnnotation');
+        return 'params';
+
+      case 'JSXAttribute':
+        assertParent('JSXOpeningElement');
+        return 'attributes';
+
+      case 'ImportDeclaration':
+        assertParent('Program');
+        return 'body';
+
+      case 'ObjectTypeCallProperty':
+        assertParent('ObjectTypeAnnotation');
+        return 'callProperties';
+
+      case 'ObjectTypeIndexer':
+        assertParent('ObjectTypeAnnotation');
+        return 'indexers';
+
+      case 'ObjectTypeInternalSlot':
+        assertParent('ObjectTypeAnnotation');
+        return 'internalSlots';
+
+      case 'ObjectTypeProperty':
+      case 'ObjectTypeSpreadProperty':
+        assertParent('ObjectTypeAnnotation');
+        return 'properties';
+
+      case 'Property':
+        assertParent(VALID_PROPERTY_PARENTS);
+        return 'properties';
+      // Identifier can be the child of a number of usecases
+
+      case 'Identifier':
+        switch (node.parent.type) {
+          case 'ArrowFunctionExpression':
+          case 'FunctionDeclaration':
+          case 'FunctionExpression':
+            return 'params';
+
+          case 'ArrayExpression':
+          case 'ArrayPattern':
+            return 'elements';
+
+          default:
+            throw new _Errors.InvalidRemovalError(getErrorMessage(['ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression', 'ArrayExpression', 'ArrayPattern']));
+        }
+
+      // RestElement can be the child of a number of usecases
+
+      case 'RestElement':
+        switch (node.parent.type) {
+          case 'ArrowFunctionExpression':
+          case 'FunctionDeclaration':
+          case 'FunctionExpression':
+          case 'ComponentDeclaration':
+            return 'params';
+
+          case 'ArrayPattern':
+            return 'elements';
+
+          case 'ObjectPattern':
+            return 'properties';
+          // $FlowFixMe[incompatible-type]
+
+          case 'OptionalCallExpression':
+          case 'CallExpression':
+          case 'NewExpression':
+            return 'arguments';
+
+          default:
+            throw new _Errors.InvalidRemovalError(getErrorMessage(['ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression', 'ComponentDeclaration', 'ArrayPattern', 'ObjectPattern', 'CallExpression', 'OptionalCallExpression', 'NewExpression']));
+        }
+
+      // SpreadElement can be the child of a number of usecases
+
+      case 'SpreadElement':
+        switch (node.parent.type) {
+          case 'ArrayExpression':
+            return 'elements';
+
+          case 'ObjectExpression':
+            return 'properties';
+          // $FlowFixMe[incompatible-type]
+
+          case 'OptionalCallExpression':
+          case 'CallExpression':
+          case 'NewExpression':
+            return 'arguments';
+
+          default:
+            throw new _Errors.InvalidRemovalError(getErrorMessage(['ArrayExpression', 'ObjectExpression', 'CallExpression', 'OptionalCallExpression', 'NewExpression']));
+        }
+
+      default:
+        throw new _Errors.InvalidRemovalError(`Cannot perform a remove mutation on node of type ${node.type}`);
+    }
+  })();
+
+  const targetIndex = (() => {
+    // $FlowExpectedError[prop-missing]
+    const arr = node.parent[key];
+    const idx = arr.indexOf(node);
+
+    if (idx === -1) {
+      throw new _Errors.InvalidRemovalError(`Could not find target in array of \`${node.parent.type}.${key}\`.`);
+    }
+
+    return idx;
+  })();
+
+  return {
+    type: 'array',
+    parent: node.parent,
+    key,
+    targetIndex
+  };
+}
+
+function performRemoveNodeMutation(mutationContext, mutation) {
+  const removalParent = getRemovalParent(mutation.node);
+  mutationContext.markDeletion(mutation.node);
+  mutationContext.markMutation(removalParent.parent, removalParent.key);
+  const parent = removalParent.parent;
+  parent[removalParent.key] = _hermesParser.astArrayMutationHelpers.removeFromArray(parent[removalParent.key], removalParent.targetIndex);
+  return removalParent.parent;
+}

package/dist/src/transform/mutations/RemoveStatement.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRemoveStatementMutation = createRemoveStatementMutation;
+exports.performRemoveStatementMutation = performRemoveStatementMutation;
+
+var _hermesParser = require("hermes-parser");
+
+var _getStatementParent = require("./utils/getStatementParent");
+
+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 (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; }
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+function createRemoveStatementMutation(node) {
+  return {
+    type: 'removeStatement',
+    node
+  };
+}
+
+function performRemoveStatementMutation(mutationContext, mutation) {
+  const removalParent = (0, _getStatementParent.getStatementParent)(mutation.node);
+  mutationContext.markDeletion(mutation.node);
+  mutationContext.markMutation(removalParent.parent, removalParent.key);
+
+  if (removalParent.type === 'array') {
+    const parent = removalParent.parent;
+    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.
+    // We COULD throw an error here and make the codemodder write a stricter
+    // codemod - but we decided to add this bit of magic to make it easier
+    // to write codemods.
+    // Worst case it creates some dead code that can be easily detected
+    // and cleaned up later.
+    const blockStatement = t.BlockStatement({
+      body: [],
+      parent: removalParent.parent
+    });
+    removalParent.parent[removalParent.key] = blockStatement;
+  }
+
+  return removalParent.parent;
+}

package/dist/src/transform/mutations/ReplaceNode.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createReplaceNodeMutation = createReplaceNodeMutation;
+exports.performReplaceNodeMutation = performReplaceNodeMutation;
+
+var _hermesParser = require("hermes-parser");
+
+var _comments = require("../comments/comments");
+
+var _Errors = require("../Errors");
+
+var _detachedNode = require("../../detachedNode");
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+function createReplaceNodeMutation(target, nodeToReplaceWith, options) {
+  var _options$keepComments;
+
+  return {
+    type: 'replaceNode',
+    target,
+    nodeToReplaceWith,
+    keepComments: (_options$keepComments = options == null ? void 0 : options.keepComments) != null ? _options$keepComments : false
+  };
+}
+
+function performReplaceNodeMutation(mutationContext, mutation) {
+  const replacementParent = getParentKey(mutation.target);
+  mutationContext.markDeletion(mutation.target);
+  mutationContext.markMutation(replacementParent.parent, replacementParent.key); // NOTE: currently this mutation assumes you're doing the right thing.
+  // it does no runtime checks and provides no guarantees about the
+  // correctness of the resulting code.
+  // TODO: maybe add some runtime checks based on codegenned predicates?
+
+  if (replacementParent.type === 'array') {
+    const parent = replacementParent.parent;
+    parent[replacementParent.key] = _hermesParser.astArrayMutationHelpers.replaceInArray(parent[replacementParent.key], replacementParent.targetIndex, [mutation.nodeToReplaceWith]);
+  } else {
+    replacementParent.parent[replacementParent.key] = mutation.nodeToReplaceWith;
+  }
+
+  if (mutation.keepComments) {
+    (0, _comments.moveCommentsToNewNode)(mutation.target, mutation.nodeToReplaceWith);
+  }
+
+  return replacementParent.parent;
+}
+
+function getParentKey(target) {
+  const parent = target.parent;
+
+  for (const key of (0, _hermesParser.getVisitorKeys)(parent)) {
+    const child = parent[key];
+
+    if ((0, _hermesParser.isNode)(child)) {
+      if (child === target) {
+        return {
+          type: 'single',
+          parent,
+          key
+        };
+      }
+    } else if (Array.isArray(child)) {
+      for (let i = 0; i < child.length; i += 1) {
+        const current = child[i];
+        const originalNode = (0, _detachedNode.getOriginalNode)(current);
+
+        if (current === target || originalNode === target) {
+          return {
+            type: 'array',
+            parent,
+            key,
+            targetIndex: i
+          };
+        }
+      }
+    }
+  } // this shouldn't happen ever
+
+
+  throw new _Errors.InvalidReplacementError(`Expected to find the ${target.type} as a direct child of the ${parent.type}.`);
+}