hermes-transform 0.5.0

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

@@ -0,0 +1,513 @@
+/**
+ * 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.
+ *
+ * @format
+ */
+'use strict';
+
+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 _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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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(_e2) { throw _e2; }, 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(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure 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 _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 _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+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); }
+
+var assert = require('assert');
+
+var _require = require('../common/util.js'),
+    hasNewline = _require.hasNewline,
+    addLeadingComment = _require.addLeadingComment,
+    addDanglingComment = _require.addDanglingComment,
+    addTrailingComment = _require.addTrailingComment;
+
+var childNodesCache = new WeakMap();
+
+function getSortedChildNodes(node, options, resultArray) {
+  if (!node) {
+    return;
+  }
+
+  var printer = options.printer,
+      locStart = options.locStart,
+      locEnd = options.locEnd;
+
+  if (resultArray) {
+    if (printer.canAttachComment && printer.canAttachComment(node)) {
+      // This reverse insertion sort almost always takes constant
+      // time because we almost always (maybe always?) append the
+      // nodes in order anyway.
+      var i;
+
+      for (i = resultArray.length - 1; i >= 0; --i) {
+        if (locStart(resultArray[i]) <= locStart(node) && locEnd(resultArray[i]) <= locEnd(node)) {
+          break;
+        }
+      }
+
+      resultArray.splice(i + 1, 0, node);
+      return;
+    }
+  } else if (childNodesCache.has(node)) {
+    return childNodesCache.get(node);
+  }
+
+  var childNodes = printer.getCommentChildNodes && printer.getCommentChildNodes(node, options) || _typeof(node) === 'object' && Object.entries(node).filter(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 1),
+        key = _ref2[0];
+
+    return key !== 'enclosingNode' && key !== 'precedingNode' && key !== 'followingNode' && key !== 'tokens' && key !== 'comments';
+  }).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+        value = _ref4[1];
+
+    return value;
+  });
+
+  if (!childNodes) {
+    return;
+  }
+
+  if (!resultArray) {
+    resultArray = [];
+    childNodesCache.set(node, resultArray);
+  }
+
+  var _iterator = _createForOfIteratorHelper(childNodes),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var childNode = _step.value;
+      getSortedChildNodes(childNode, options, resultArray);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return resultArray;
+} // As efficiently as possible, decorate the comment object with
+// .precedingNode, .enclosingNode, and/or .followingNode properties, at
+// least one of which is guaranteed to be defined.
+
+
+function decorateComment(node, comment, options, enclosingNode) {
+  var locStart = options.locStart,
+      locEnd = options.locEnd;
+  var commentStart = locStart(comment);
+  var commentEnd = locEnd(comment);
+  var childNodes = getSortedChildNodes(node, options);
+  var precedingNode;
+  var followingNode; // Time to dust off the old binary search robes and wizard hat.
+
+  var left = 0;
+  var right = childNodes.length;
+
+  while (left < right) {
+    var middle = left + right >> 1;
+    var child = childNodes[middle];
+    var start = locStart(child);
+    var end = locEnd(child); // The comment is completely contained by this child node.
+
+    if (start <= commentStart && commentEnd <= end) {
+      // Abandon the binary search at this level.
+      return decorateComment(child, comment, options, child);
+    }
+
+    if (end <= commentStart) {
+      // This child node falls completely before the comment.
+      // Because we will never consider this node or any nodes
+      // before it again, this node must be the closest preceding
+      // node we have encountered so far.
+      precedingNode = child;
+      left = middle + 1;
+      continue;
+    }
+
+    if (commentEnd <= start) {
+      // This child node falls completely after the comment.
+      // Because we will never consider this node or any nodes after
+      // it again, this node must be the closest following node we
+      // have encountered so far.
+      followingNode = child;
+      right = middle;
+      continue;
+    }
+    /* istanbul ignore next */
+
+
+    throw new Error('Comment location overlaps with node location');
+  } // We don't want comments inside of different expressions inside of the same
+  // template literal to move to another expression.
+
+
+  if (enclosingNode && enclosingNode.type === 'TemplateLiteral') {
+    var quasis = enclosingNode.quasis;
+    var commentIndex = findExpressionIndexForComment(quasis, comment, options);
+
+    if (precedingNode && findExpressionIndexForComment(quasis, precedingNode, options) !== commentIndex) {
+      precedingNode = null;
+    }
+
+    if (followingNode && findExpressionIndexForComment(quasis, followingNode, options) !== commentIndex) {
+      followingNode = null;
+    }
+  }
+
+  return {
+    enclosingNode: enclosingNode,
+    precedingNode: precedingNode,
+    followingNode: followingNode
+  };
+}
+
+var returnFalse = function returnFalse() {
+  return false;
+};
+
+function attach(comments, ast, text, options) {
+  if (!Array.isArray(comments)) {
+    return;
+  }
+
+  var tiesToBreak = [];
+  var locStart = options.locStart,
+      locEnd = options.locEnd,
+      _options$printer$hand = options.printer.handleComments,
+      handleComments = _options$printer$hand === void 0 ? {} : _options$printer$hand; // TODO: Make this as default behavior
+
+  var avoidAstMutation = handleComments.avoidAstMutation,
+      _handleComments$ownLi = handleComments.ownLine,
+      handleOwnLineComment = _handleComments$ownLi === void 0 ? returnFalse : _handleComments$ownLi,
+      _handleComments$endOf = handleComments.endOfLine,
+      handleEndOfLineComment = _handleComments$endOf === void 0 ? returnFalse : _handleComments$endOf,
+      _handleComments$remai = handleComments.remaining,
+      handleRemainingComment = _handleComments$remai === void 0 ? returnFalse : _handleComments$remai;
+  var decoratedComments = comments.map(function (comment, index) {
+    return _objectSpread(_objectSpread({}, decorateComment(ast, comment, options)), {}, {
+      comment: comment,
+      text: text,
+      options: options,
+      ast: ast,
+      isLastComment: comments.length - 1 === index
+    });
+  });
+
+  var _iterator2 = _createForOfIteratorHelper(decoratedComments.entries()),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = _slicedToArray(_step2.value, 2),
+          index = _step2$value[0],
+          context = _step2$value[1];
+
+      var _comment = context.comment,
+          precedingNode = context.precedingNode,
+          enclosingNode = context.enclosingNode,
+          followingNode = context.followingNode,
+          _text = context.text,
+          _options = context.options,
+          _ast = context.ast,
+          isLastComment = context.isLastComment;
+
+      if (_options.parser === 'json' || _options.parser === 'json5' || _options.parser === '__js_expression' || _options.parser === '__vue_expression') {
+        if (locStart(_comment) - locStart(_ast) <= 0) {
+          addLeadingComment(_ast, _comment);
+          continue;
+        }
+
+        if (locEnd(_comment) - locEnd(_ast) >= 0) {
+          addTrailingComment(_ast, _comment);
+          continue;
+        }
+      }
+
+      var args = void 0;
+
+      if (avoidAstMutation) {
+        args = [context];
+      } else {
+        _comment.enclosingNode = enclosingNode;
+        _comment.precedingNode = precedingNode;
+        _comment.followingNode = followingNode;
+        args = [_comment, _text, _options, _ast, isLastComment];
+      }
+
+      if (isOwnLineComment(_text, _options, decoratedComments, index)) {
+        _comment.placement = 'ownLine'; // If a comment exists on its own line, prefer a leading comment.
+        // We also need to check if it's the first line of the file.
+
+        if (handleOwnLineComment.apply(void 0, _toConsumableArray(args))) {// We're good
+        } else if (followingNode) {
+          // Always a leading comment.
+          addLeadingComment(followingNode, _comment);
+        } else if (precedingNode) {
+          addTrailingComment(precedingNode, _comment);
+        } else if (enclosingNode) {
+          addDanglingComment(enclosingNode, _comment);
+        } else {
+          // There are no nodes, let's attach it to the root of the ast
+
+          /* istanbul ignore next */
+          addDanglingComment(_ast, _comment);
+        }
+      } else if (isEndOfLineComment(_text, _options, decoratedComments, index)) {
+        _comment.placement = 'endOfLine';
+
+        if (handleEndOfLineComment.apply(void 0, _toConsumableArray(args))) {// We're good
+        } else if (precedingNode) {
+          // There is content before this comment on the same line, but
+          // none after it, so prefer a trailing comment of the previous node.
+          addTrailingComment(precedingNode, _comment);
+        } else if (followingNode) {
+          addLeadingComment(followingNode, _comment);
+        } else if (enclosingNode) {
+          addDanglingComment(enclosingNode, _comment);
+        } else {
+          // There are no nodes, let's attach it to the root of the ast
+
+          /* istanbul ignore next */
+          addDanglingComment(_ast, _comment);
+        }
+      } else {
+        _comment.placement = 'remaining';
+
+        if (handleRemainingComment.apply(void 0, _toConsumableArray(args))) {// We're good
+        } else if (precedingNode && followingNode) {
+          // Otherwise, text exists both before and after the comment on
+          // the same line. If there is both a preceding and following
+          // node, use a tie-breaking algorithm to determine if it should
+          // be attached to the next or previous node. In the last case,
+          // simply attach the right node;
+          var tieCount = tiesToBreak.length;
+
+          if (tieCount > 0) {
+            var lastTie = tiesToBreak[tieCount - 1];
+
+            if (lastTie.followingNode !== followingNode) {
+              breakTies(tiesToBreak, _text, _options);
+            }
+          }
+
+          tiesToBreak.push(context);
+        } else if (precedingNode) {
+          addTrailingComment(precedingNode, _comment);
+        } else if (followingNode) {
+          addLeadingComment(followingNode, _comment);
+        } else if (enclosingNode) {
+          addDanglingComment(enclosingNode, _comment);
+        } else {
+          // There are no nodes, let's attach it to the root of the ast
+
+          /* istanbul ignore next */
+          addDanglingComment(_ast, _comment);
+        }
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  breakTies(tiesToBreak, text, options);
+
+  if (!avoidAstMutation) {
+    var _iterator3 = _createForOfIteratorHelper(comments),
+        _step3;
+
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var comment = _step3.value;
+        // These node references were useful for breaking ties, but we
+        // don't need them anymore, and they create cycles in the AST that
+        // may lead to infinite recursion if we don't delete them here.
+        delete comment.precedingNode;
+        delete comment.enclosingNode;
+        delete comment.followingNode;
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  }
+}
+
+var isAllEmptyAndNoLineBreak = function isAllEmptyAndNoLineBreak(text) {
+  return !/[\S\n\u2028\u2029]/.test(text);
+};
+
+function isOwnLineComment(text, options, decoratedComments, commentIndex) {
+  var _decoratedComments$co = decoratedComments[commentIndex],
+      comment = _decoratedComments$co.comment,
+      precedingNode = _decoratedComments$co.precedingNode;
+  var locStart = options.locStart,
+      locEnd = options.locEnd;
+  var start = locStart(comment);
+
+  if (precedingNode) {
+    // Find first comment on the same line
+    for (var index = commentIndex - 1; index >= 0; index--) {
+      var _decoratedComments$in = decoratedComments[index],
+          _comment2 = _decoratedComments$in.comment,
+          currentCommentPrecedingNode = _decoratedComments$in.precedingNode;
+
+      if (currentCommentPrecedingNode !== precedingNode || !isAllEmptyAndNoLineBreak(text.slice(locEnd(_comment2), start))) {
+        break;
+      }
+
+      start = locStart(_comment2);
+    }
+  }
+
+  return hasNewline(text, start, {
+    backwards: true
+  });
+}
+
+function isEndOfLineComment(text, options, decoratedComments, commentIndex) {
+  var _decoratedComments$co2 = decoratedComments[commentIndex],
+      comment = _decoratedComments$co2.comment,
+      followingNode = _decoratedComments$co2.followingNode;
+  var locStart = options.locStart,
+      locEnd = options.locEnd;
+  var end = locEnd(comment);
+
+  if (followingNode) {
+    // Find last comment on the same line
+    for (var index = commentIndex + 1; index < decoratedComments.length; index++) {
+      var _decoratedComments$in2 = decoratedComments[index],
+          _comment3 = _decoratedComments$in2.comment,
+          currentCommentFollowingNode = _decoratedComments$in2.followingNode;
+
+      if (currentCommentFollowingNode !== followingNode || !isAllEmptyAndNoLineBreak(text.slice(end, locStart(_comment3)))) {
+        break;
+      }
+
+      end = locEnd(_comment3);
+    }
+  }
+
+  return hasNewline(text, end);
+}
+
+function breakTies(tiesToBreak, text, options) {
+  var tieCount = tiesToBreak.length;
+
+  if (tieCount === 0) {
+    return;
+  }
+
+  var _tiesToBreak$ = tiesToBreak[0],
+      precedingNode = _tiesToBreak$.precedingNode,
+      followingNode = _tiesToBreak$.followingNode,
+      enclosingNode = _tiesToBreak$.enclosingNode;
+  var gapRegExp = options.printer.getGapRegex && options.printer.getGapRegex(enclosingNode) || /^[\s(]*$/;
+  var gapEndPos = options.locStart(followingNode); // Iterate backwards through tiesToBreak, examining the gaps
+  // between the tied comments. In order to qualify as leading, a
+  // comment must be separated from followingNode by an unbroken series of
+  // gaps (or other comments). Gaps should only contain whitespace or open
+  // parentheses.
+
+  var indexOfFirstLeadingComment;
+
+  for (indexOfFirstLeadingComment = tieCount; indexOfFirstLeadingComment > 0; --indexOfFirstLeadingComment) {
+    var _tiesToBreak = tiesToBreak[indexOfFirstLeadingComment - 1],
+        comment = _tiesToBreak.comment,
+        currentCommentPrecedingNode = _tiesToBreak.precedingNode,
+        currentCommentFollowingNode = _tiesToBreak.followingNode;
+    assert.strictEqual(currentCommentPrecedingNode, precedingNode);
+    assert.strictEqual(currentCommentFollowingNode, followingNode);
+    var gap = text.slice(options.locEnd(comment), gapEndPos);
+
+    if (gapRegExp.test(gap)) {
+      gapEndPos = options.locStart(comment);
+    } else {
+      // The gap string contained something other than whitespace or open
+      // parentheses.
+      break;
+    }
+  }
+
+  var _iterator4 = _createForOfIteratorHelper(tiesToBreak.entries()),
+      _step4;
+
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var _step4$value = _slicedToArray(_step4.value, 2),
+          i = _step4$value[0],
+          _comment4 = _step4$value[1].comment;
+
+      if (i < indexOfFirstLeadingComment) {
+        addTrailingComment(precedingNode, _comment4);
+      } else {
+        addLeadingComment(followingNode, _comment4);
+      }
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+
+  for (var _i2 = 0, _arr2 = [precedingNode, followingNode]; _i2 < _arr2.length; _i2++) {
+    var node = _arr2[_i2];
+
+    if (node.comments && node.comments.length > 1) {
+      node.comments.sort(function (a, b) {
+        return options.locStart(a) - options.locStart(b);
+      });
+    }
+  }
+
+  tiesToBreak.length = 0;
+}
+
+function findExpressionIndexForComment(quasis, comment, options) {
+  var startPos = options.locStart(comment) - 1;
+
+  for (var i = 1; i < quasis.length; ++i) {
+    if (startPos < options.locStart(quasis[i])) {
+      return i - 1;
+    }
+  } // We haven't found it, it probably means that some of the locations are off.
+  // Let's just return the first one.
+
+  /* istanbul ignore next */
+
+
+  return 0;
+}
+
+module.exports = {
+  attach: attach
+};