hermes-transform 0.28.0 → 0.29.0

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

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createReplaceStatementWithManyMutation = createReplaceStatementWithManyMutation;
+exports.performReplaceStatementWithManyMutation = performReplaceStatementWithManyMutation;
+
+var _hermesParser = require("hermes-parser");
+
+var _getStatementParent = require("./utils/getStatementParent");
+
+var _isValidModuleDeclarationParent = require("./utils/isValidModuleDeclarationParent");
+
+var _comments = require("../comments/comments");
+
+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 createReplaceStatementWithManyMutation(target, nodesToReplaceWith, options) {
+  var _options$keepComments;
+
+  if (nodesToReplaceWith.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'replaceStatementWithMany',
+    target,
+    nodesToReplaceWith,
+    keepComments: (_options$keepComments = options == null ? void 0 : options.keepComments) != null ? _options$keepComments : false
+  };
+}
+
+function performReplaceStatementWithManyMutation(mutationContext, mutation) {
+  const replacementParent = (0, _getStatementParent.getStatementParent)(mutation.target); // enforce that if we are replacing with module declarations - they are being inserted in a valid location
+
+  if (!(0, _isValidModuleDeclarationParent.isValidModuleDeclarationParent)(replacementParent.parent, mutation.nodesToReplaceWith)) {
+    throw new _Errors.InvalidReplacementError(`import/export cannot be replaced into a ${replacementParent.parent.type}.`);
+  }
+
+  mutationContext.markDeletion(mutation.target);
+  mutationContext.markMutation(replacementParent.parent, replacementParent.key);
+
+  if (mutation.keepComments) {
+    // attach comments to the very first replacement node
+    (0, _comments.moveCommentsToNewNode)(mutation.target, mutation.nodesToReplaceWith[0]);
+  }
+
+  if (replacementParent.type === 'array') {
+    const parent = replacementParent.parent;
+    parent[replacementParent.key] = _hermesParser.astArrayMutationHelpers.replaceInArray(parent[replacementParent.key], replacementParent.targetIndex, mutation.nodesToReplaceWith);
+    return replacementParent.parent;
+  }
+
+  const statementsToReplaceWith = // $FlowExpectedError[incompatible-cast] -- this is enforced by isValidModuleDeclarationParent above
+  mutation.nodesToReplaceWith; // we need to wrap the nodes in a BlockStatement as before there was only 1 node
+
+  const blockStatement = t.BlockStatement({
+    body: statementsToReplaceWith,
+    parent: replacementParent.parent
+  });
+  replacementParent.parent[replacementParent.key] = blockStatement;
+  return replacementParent.parent;
+}

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

@@ -0,0 +1,143 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStatementParent = getStatementParent;
+
+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 getStatementParent(target) {
+  function assertValidStatementLocation(parentWithType, ...invalidKeys) {
+    for (const key of invalidKeys) {
+      // $FlowExpectedError[prop-missing]
+      const value = parentWithType[key];
+
+      if (value === target || Array.isArray(value) && value.includes(target)) {
+        throw new _Errors.InvalidStatementError(`Attempted to insert a statement into \`${parentWithType.type}.${key}\`.`);
+      }
+    }
+  }
+
+  function getAssertedIndex(key, arr) {
+    const idx = arr.indexOf(target);
+
+    if (idx === -1) {
+      throw new _Errors.InvalidStatementError(`Could not find target in array of \`${parent.type}.${key}\`.`);
+    }
+
+    return idx;
+  }
+
+  const parent = target.parent;
+
+  const result = (() => {
+    switch (parent.type) {
+      case 'IfStatement':
+        {
+          assertValidStatementLocation(parent, 'test');
+          const key = parent.consequent === target ? 'consequent' : 'alternate';
+          return {
+            type: 'single',
+            parent,
+            key
+          };
+        }
+
+      case 'LabeledStatement':
+        {
+          assertValidStatementLocation(parent, 'label');
+          return {
+            type: 'single',
+            parent,
+            key: 'body'
+          };
+        }
+
+      case 'WithStatement':
+        {
+          assertValidStatementLocation(parent, 'object');
+          return {
+            type: 'single',
+            parent,
+            key: 'body'
+          };
+        }
+
+      case 'DoWhileStatement':
+      case 'WhileStatement':
+        {
+          assertValidStatementLocation(parent, 'test');
+          return {
+            type: 'single',
+            parent,
+            key: 'body'
+          };
+        }
+
+      case 'ForStatement':
+        {
+          assertValidStatementLocation(parent, 'init', 'test', 'update');
+          return {
+            type: 'single',
+            parent,
+            key: 'body'
+          };
+        }
+
+      case 'ForInStatement':
+      case 'ForOfStatement':
+        {
+          assertValidStatementLocation(parent, // $FlowExpectedError[prop-missing] - flow does not track properties from parent interface
+          'left', // $FlowExpectedError[prop-missing] - flow does not track properties from parent interface
+          'right');
+          return {
+            type: 'single',
+            parent,
+            key: 'body'
+          };
+        }
+
+      case 'SwitchCase':
+        {
+          assertValidStatementLocation(parent, 'test');
+          return {
+            type: 'array',
+            parent,
+            key: 'consequent',
+            targetIndex: getAssertedIndex('consequent', parent.consequent)
+          };
+        }
+
+      case 'BlockStatement':
+      case 'Program':
+        {
+          return {
+            type: 'array',
+            parent,
+            key: 'body',
+            targetIndex: getAssertedIndex('body', parent.body)
+          };
+        }
+    }
+
+    throw new _Errors.InvalidStatementError(`Expected to find a valid statement parent, but found a parent of type "${parent.type}".`);
+  })();
+
+  if ( // array insertions are already validated by the getAssertedIndex function
+  result.targetIndex == null && // $FlowExpectedError[prop-missing]
+  result.parent[result.key] !== target) {
+    throw new _Errors.InvalidStatementError(`Expected to find the target "${target.type}" on the "${result.parent.type}.${result.key}", but found a different node. ` + 'This likely means that you attempted to mutate around the target after it was deleted/replaced.');
+  }
+
+  return result;
+}

package/dist/src/transform/mutations/utils/isValidModuleDeclarationParent.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidModuleDeclarationParent = isValidModuleDeclarationParent;
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @noformat
+ */
+function isModuleDeclaration(node)
+/*: node is (
+| ImportDeclaration
+| ExportNamedDeclaration
+| ExportDefaultDeclaration
+| ExportAllDeclaration
+) */
+{
+  return node.type === 'ImportDeclaration' || node.type === 'ExportNamedDeclaration' || node.type === 'ExportDefaultDeclaration' || node.type === 'ExportAllDeclaration';
+}
+
+function isValidModuleDeclarationParent(target, nodesToInsertOrReplace) {
+  if (target.type === 'Program' || target.type === 'BlockStatement' && target.parent.type === 'DeclareModule') {
+    return true;
+  }
+
+  for (const node of nodesToInsertOrReplace) {
+    if (!isModuleDeclaration( // $FlowExpectedError[incompatible-cast]
+    node)) {
+      continue;
+    }
+
+    return false;
+  }
+
+  return true;
+}

package/dist/src/transform/parse.js

@@ -0,0 +1,56 @@
+/**
+ * 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.parse = parse;
+
+var _comments = require("./comments/comments");
+
+var _hermesEslint = require("hermes-eslint");
+
+async function parse(code) {
+  const {
+    ast,
+    scopeManager
+  } = (0, _hermesEslint.parseForESLint)(code, {
+    sourceType: 'module',
+    enableExperimentalComponentSyntax: true
+  }); // Don't include the docblock comment in the comment list as we don't want to attach it
+  // as it should be maintained at the top of the file as nodes are moved around.
+
+  let comments = ast.comments;
+
+  if (ast.docblock != null && ast.docblock.comment === comments[0]) {
+    const [first, ...nonDocblockComments] = comments; // Since we will not be attaching this comment automatically we need to add the
+    // properties prettier expects for printing.
+    // $FlowExpectedError[prop-missing]
+
+    first.placement = 'endOfLine'; // $FlowExpectedError[prop-missing]
+
+    first.leading = true; // $FlowExpectedError[prop-missing]
+
+    first.trailing = false; // $FlowExpectedError[prop-missing]
+
+    first.printed = false;
+    comments = nonDocblockComments;
+  } // 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
+
+
+  (0, _comments.attachComments)(comments, ast, code);
+  return {
+    ast,
+    scopeManager,
+    code
+  };
+}

package/dist/src/transform/print.js

@@ -0,0 +1,134 @@
+/**
+ * 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.print = print;
+
+var _hermesParser = require("hermes-parser");
+
+var prettier = _interopRequireWildcard(require("prettier"));
+
+var _comments = require("./comments/comments");
+
+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; }
+
+let cache = 1;
+const cacheBase = Math.random();
+
+async function print(ast, originalCode, prettierOptions = {}, visitorKeys) {
+  // $FlowExpectedError[incompatible-type] This is now safe to access.
+  const program = ast; // If the AST body is empty, we can skip the cost of prettier by returning a static string of the contents.
+
+  if (program.body.length === 0) {
+    var _program$docblock;
+
+    // If the program had a docblock comment, we need to create the string manually.
+    const docblockComment = (_program$docblock = program.docblock) == null ? void 0 : _program$docblock.comment;
+
+    if (docblockComment != null) {
+      return '/*' + docblockComment.value + '*/\n';
+    }
+
+    return '';
+  } // Cleanup the comments from the AST and generate the "orginal" code needed for prettier.
+
+
+  const codeForPrinting = (0, _comments.mutateESTreeASTCommentsForPrettier)(program, originalCode); // Fix up the AST to match what prettier expects.
+
+  (0, _hermesParser.mutateESTreeASTForPrettier)(program, visitorKeys);
+
+  switch (getPrettierMajorVersion()) {
+    case '3':
+      {
+        // Lazy require this module as it only exists in prettier v3.
+        const prettierFlowPlugin = require('prettier/plugins/flow');
+
+        return prettier.format(codeForPrinting, // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
+        { ...prettierOptions,
+          parser: 'flow',
+          requirePragma: false,
+          plugins: [{
+            parsers: {
+              flow: { ...prettierFlowPlugin.parsers.flow,
+
+                parse() {
+                  return program;
+                }
+
+              }
+            }
+          }]
+        });
+      }
+
+    case '2':
+      {
+        var _hermesPlugin$parsers;
+
+        const hermesPlugin = require('prettier-plugin-hermes-parser');
+
+        const hermesParser = (_hermesPlugin$parsers = hermesPlugin.parsers) == null ? void 0 : _hermesPlugin$parsers.hermes;
+
+        if (hermesParser == null) {
+          throw new Error('Hermes parser plugin not found');
+        }
+
+        return prettier.format(codeForPrinting, // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
+        { ...prettierOptions,
+          parser: 'hermes',
+          requirePragma: false,
+          plugins: [// $FlowExpectedError[incompatible-call] Cache value is not expected but needed in this case.
+          {
+            parsers: {
+              hermes: { ...hermesParser,
+                // Prettier caches the plugin, by making this key always unique we ensure the new `parse`
+                // function with the correct AST is always called.
+                cache: `${cacheBase}-${cache++}`,
+
+                // Provide the passed AST to prettier
+                parse() {
+                  return program;
+                }
+
+              }
+            },
+            printers: hermesPlugin.printers
+          }]
+        });
+      }
+
+    case 'UNSUPPORTED':
+    default:
+      {
+        throw new Error(`Unknown or unsupported prettier version of "${prettier.version}". Only major versions 3 or 2 of prettier are supported.`);
+      }
+  }
+}
+
+function getPrettierMajorVersion() {
+  const {
+    version
+  } = prettier;
+
+  if (version.startsWith('3.')) {
+    return '3';
+  }
+
+  if (version.startsWith('2.')) {
+    return '2';
+  }
+
+  return 'UNSUPPORTED';
+}

package/dist/src/transform/transform.js

@@ -0,0 +1,36 @@
+/**
+ * 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.transform = transform;
+
+var _transformAST = require("./transformAST");
+
+var _parse = require("./parse");
+
+var _print = require("./print");
+
+async function transform(originalCode, visitors, prettierOptions = {}) {
+  const parseResult = await (0, _parse.parse)(originalCode);
+  const {
+    ast,
+    astWasMutated,
+    mutatedCode
+  } = (0, _transformAST.transformAST)(parseResult, visitors);
+
+  if (!astWasMutated) {
+    return originalCode;
+  }
+
+  return (0, _print.print)(ast, mutatedCode, prettierOptions);
+}

package/dist/src/transform/transformAST.js

@@ -0,0 +1,134 @@
+/**
+ * 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.transformAST = transformAST;
+
+var _detachedNode = require("../detachedNode");
+
+var _traverse = require("../traverse/traverse");
+
+var _MutationContext = require("./MutationContext");
+
+var _TransformContext = require("./TransformContext");
+
+var _AddComments = require("./mutations/AddComments");
+
+var _CloneCommentsTo = require("./mutations/CloneCommentsTo");
+
+var _InsertStatement = require("./mutations/InsertStatement");
+
+var _RemoveComment = require("./mutations/RemoveComment");
+
+var _RemoveNode = require("./mutations/RemoveNode");
+
+var _RemoveStatement = require("./mutations/RemoveStatement");
+
+var _ReplaceNode = require("./mutations/ReplaceNode");
+
+var _ReplaceStatementWithMany = require("./mutations/ReplaceStatementWithMany");
+
+var _ModifyNodeInPlace = require("./mutations/ModifyNodeInPlace");
+
+function transformAST({
+  ast,
+  scopeManager,
+  code
+}, visitors) {
+  // traverse the AST and collect the mutations
+  const transformContext = (0, _TransformContext.getTransformContext)();
+  (0, _traverse.traverseWithContext)(code, ast, scopeManager, () => transformContext, visitors); // apply the mutations to the AST
+
+  const mutationContext = new _MutationContext.MutationContext(code);
+  const removeCommentMutations = [];
+
+  for (const mutation of transformContext.mutations) {
+    const mutationRoot = (() => {
+      switch (mutation.type) {
+        case 'modifyNodeInPlace':
+          {
+            return (0, _ModifyNodeInPlace.performModifyNodeInPlaceMutation)(mutationContext, mutation);
+          }
+
+        case 'insertStatement':
+          {
+            return (0, _InsertStatement.performInsertStatementMutation)(mutationContext, mutation);
+          }
+
+        case 'replaceNode':
+          {
+            return (0, _ReplaceNode.performReplaceNodeMutation)(mutationContext, mutation);
+          }
+
+        case 'replaceStatementWithMany':
+          {
+            return (0, _ReplaceStatementWithMany.performReplaceStatementWithManyMutation)(mutationContext, mutation);
+          }
+
+        case 'removeNode':
+          {
+            return (0, _RemoveNode.performRemoveNodeMutation)(mutationContext, mutation);
+          }
+
+        case 'removeStatement':
+          {
+            return (0, _RemoveStatement.performRemoveStatementMutation)(mutationContext, mutation);
+          }
+
+        case 'removeComment':
+          {
+            // these are handled later
+            removeCommentMutations.push(mutation);
+            return null;
+          }
+
+        case 'addComments':
+          {
+            return (0, _AddComments.performAddCommentsMutation)(mutationContext, mutation);
+          }
+
+        case 'cloneCommentsTo':
+          {
+            return (0, _CloneCommentsTo.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) {
+      (0, _detachedNode.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
+
+
+  (0, _RemoveComment.performRemoveCommentMutations)(ast, removeCommentMutations);
+  return {
+    ast,
+    astWasMutated: transformContext.astWasMutated,
+    mutatedCode: mutationContext.code
+  };
+}