flow-parser 0.318.0 → 0.320.0

package/oxidized/transform/astArrayMutationHelpers.js.flow

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+function assertArrayBounds<T>(array: ReadonlyArray<T>, index: number): void {
+  if (index < 0 || index >= array.length) {
+    throw new Error(
+      `Invalid Mutation: Tried to mutate an elements array with an out of bounds index. Index: ${index}, Array Size: ${array.length}`,
+    );
+  }
+}
+
+export function arrayIsEqual(
+  a1: ReadonlyArray<unknown>,
+  a2: ReadonlyArray<unknown>,
+): boolean {
+  if (a1 === a2) {
+    return true;
+  }
+
+  if (a1.length !== a2.length) {
+    return false;
+  }
+
+  for (let i = 0; i < a1.length; i++) {
+    if (a1[i] !== a2[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function insertInArray<T>(
+  array: ReadonlyArray<T>,
+  index: number,
+  elements: ReadonlyArray<T>,
+): Array<T> {
+  if (index === array.length) {
+    // Support the insert at end of array case.
+    return array.concat(elements);
+  }
+  assertArrayBounds(array, index);
+  return array.slice(0, index).concat(elements).concat(array.slice(index));
+}
+
+export function removeFromArray<T>(
+  array: ReadonlyArray<T>,
+  index: number,
+): Array<T> {
+  assertArrayBounds(array, index);
+  return [...array.slice(0, index), ...array.slice(index + 1)];
+}
+
+export function replaceInArray<T>(
+  array: ReadonlyArray<T>,
+  index: number,
+  elements: ReadonlyArray<T>,
+): Array<T> {
+  assertArrayBounds(array, index);
+  return array
+    .slice(0, index)
+    .concat(elements)
+    .concat(array.slice(index + 1));
+}

package/oxidized/transform/astNodeMutationHelpers.js

@@ -0,0 +1,142 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deepCloneNode = deepCloneNode;
+exports.nodeWith = nodeWith;
+exports.removeNodeOnParent = removeNodeOnParent;
+exports.replaceNodeOnParent = replaceNodeOnParent;
+exports.setParentPointersInDirectChildren = setParentPointersInDirectChildren;
+exports.shallowCloneNode = shallowCloneNode;
+exports.updateAllParentPointers = updateAllParentPointers;
+
+var _astArrayMutationHelpers = require("./astArrayMutationHelpers");
+
+var _getVisitorKeys = require("../traverse/getVisitorKeys");
+
+var _SimpleTraverser = require("../traverse/SimpleTraverser");
+
+function getParentKey(target, parent, visitorKeys) {
+  if (parent == null) {
+    throw new Error(`Expected parent node to be set on "${target.type}"`);
+  }
+
+  for (const key of (0, _getVisitorKeys.getVisitorKeys)(parent, visitorKeys)) {
+    if ((0, _getVisitorKeys.isNode)(parent[key])) {
+      if (parent[key] === target) {
+        return {
+          type: 'single',
+          node: parent,
+          key
+        };
+      }
+    } else if (Array.isArray(parent[key])) {
+      for (let i = 0; i < parent[key].length; i += 1) {
+        const current = parent[key][i];
+
+        if (current === target) {
+          return {
+            type: 'array',
+            node: parent,
+            key,
+            targetIndex: i
+          };
+        }
+      }
+    }
+  }
+
+  throw new Error(`Expected to find the ${target.type} as a direct child of the ${parent.type}.`);
+}
+
+function replaceNodeOnParent(originalNode, originalNodeParent, nodeToReplaceWith, visitorKeys) {
+  const replacementParent = getParentKey(originalNode, originalNodeParent, visitorKeys);
+  const parent = replacementParent.node;
+
+  if (replacementParent.type === 'array') {
+    parent[replacementParent.key] = (0, _astArrayMutationHelpers.replaceInArray)(parent[replacementParent.key], replacementParent.targetIndex, Array.isArray(nodeToReplaceWith) ? nodeToReplaceWith : [nodeToReplaceWith]);
+  } else {
+    if (Array.isArray(nodeToReplaceWith)) {
+      throw new Error(`Cannot insert array into non-array parent type: ${parent.type}`);
+    }
+
+    parent[replacementParent.key] = nodeToReplaceWith;
+  }
+}
+
+function removeNodeOnParent(originalNode, originalNodeParent, visitorKeys) {
+  const replacementParent = getParentKey(originalNode, originalNodeParent, visitorKeys);
+  const parent = replacementParent.node;
+
+  if (replacementParent.type === 'array') {
+    parent[replacementParent.key] = (0, _astArrayMutationHelpers.removeFromArray)(parent[replacementParent.key], replacementParent.targetIndex);
+  } else {
+    parent[replacementParent.key] = null;
+  }
+}
+
+function setParentPointersInDirectChildren(node, visitorKeys) {
+  for (const key of (0, _getVisitorKeys.getVisitorKeys)(node, visitorKeys)) {
+    if ((0, _getVisitorKeys.isNode)(node[key])) {
+      node[key].parent = node;
+    } else if (Array.isArray(node[key])) {
+      for (const child of node[key]) {
+        child.parent = node;
+      }
+    }
+  }
+}
+
+function updateAllParentPointers(node, visitorKeys) {
+  _SimpleTraverser.SimpleTraverser.traverse(node, {
+    enter(node, parent) {
+      node.parent = parent;
+    },
+
+    leave() {},
+
+    visitorKeys
+  });
+}
+
+function nodeWith(node, overrideProps, visitorKeys) {
+  const willBeUnchanged = Object.entries(overrideProps).every(([key, value]) => {
+    const node_ = node;
+
+    if (Array.isArray(value)) {
+      return Array.isArray(node_[key]) ? (0, _astArrayMutationHelpers.arrayIsEqual)(node_[key], value) : false;
+    }
+
+    return node_[key] === value;
+  });
+
+  if (willBeUnchanged) {
+    return node;
+  }
+
+  const newNode = { ...node,
+    ...overrideProps
+  };
+  setParentPointersInDirectChildren(newNode, visitorKeys);
+  return newNode;
+}
+
+function shallowCloneNode(node, visitorKeys) {
+  const newNode = { ...node
+  };
+  setParentPointersInDirectChildren(newNode, visitorKeys);
+  return newNode;
+}
+
+function deepCloneNode(node, visitorKeys) {
+  const clone = JSON.parse(JSON.stringify(node, (key, value) => {
+    if (key === 'parent') {
+      return undefined;
+    }
+
+    return value;
+  }));
+  updateAllParentPointers(clone, visitorKeys);
+  return clone;
+}

package/oxidized/transform/astNodeMutationHelpers.js.flow

@@ -0,0 +1,252 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {ESNode} from 'flow-estree';
+import type {VisitorKeysType} from '../traverse/getVisitorKeys';
+
+import {
+  arrayIsEqual,
+  removeFromArray,
+  replaceInArray,
+} from './astArrayMutationHelpers';
+import {getVisitorKeys, isNode} from '../traverse/getVisitorKeys';
+import {SimpleTraverser} from '../traverse/SimpleTraverser';
+
+function getParentKey(
+  target: ESNode,
+  parent: ESNode,
+  visitorKeys?: ?VisitorKeysType,
+): Readonly<
+  | {
+      type: 'single',
+      node: ESNode,
+      key: string,
+    }
+  | {
+      type: 'array',
+      node: ESNode,
+      key: string,
+      targetIndex: number,
+    },
+> {
+  if (parent == null) {
+    throw new Error(`Expected parent node to be set on "${target.type}"`);
+  }
+  for (const key of getVisitorKeys(parent, visitorKeys)) {
+    if (
+      isNode(
+        // $FlowExpectedError[prop-missing]
+        parent[key],
+      )
+    ) {
+      // $FlowFixMe[invalid-compare]
+      if (parent[key] === target) {
+        return {type: 'single', node: parent, key};
+      }
+    } else if (
+      Array.isArray(
+        // $FlowExpectedError[prop-missing]
+        parent[key],
+      )
+    ) {
+      for (let i = 0; i < parent[key].length; i += 1) {
+        // $FlowExpectedError[invalid-tuple-index]
+        const current = parent[key][i];
+        // $FlowFixMe[invalid-compare]
+        if (current === target) {
+          return {type: 'array', node: parent, key, targetIndex: i};
+        }
+      }
+    }
+  }
+
+  // this shouldn't happen ever
+  throw new Error(
+    `Expected to find the ${target.type} as a direct child of the ${parent.type}.`,
+  );
+}
+
+/**
+ * Replace a node with a new node within an AST (via the parent pointer).
+ */
+export function replaceNodeOnParent(
+  originalNode: ESNode,
+  originalNodeParent: ESNode,
+  nodeToReplaceWith: ESNode | ReadonlyArray<ESNode>,
+  visitorKeys?: ?VisitorKeysType,
+): void {
+  const replacementParent = getParentKey(
+    originalNode,
+    originalNodeParent,
+    visitorKeys,
+  );
+  const parent = replacementParent.node;
+  if (replacementParent.type === 'array') {
+    // $FlowExpectedError[prop-missing]
+    parent[replacementParent.key] = replaceInArray(
+      // $FlowExpectedError[prop-missing]
+      parent[replacementParent.key],
+      replacementParent.targetIndex,
+      Array.isArray(nodeToReplaceWith)
+        ? nodeToReplaceWith
+        : [nodeToReplaceWith],
+    );
+  } else {
+    if (Array.isArray(nodeToReplaceWith)) {
+      throw new Error(
+        `Cannot insert array into non-array parent type: ${parent.type}`,
+      );
+    }
+    // $FlowExpectedError[prop-missing]
+    parent[replacementParent.key] = nodeToReplaceWith;
+  }
+}
+
+/**
+ * Remove a node from the AST its connected to (via the parent pointer).
+ */
+export function removeNodeOnParent(
+  originalNode: ESNode,
+  originalNodeParent: ESNode,
+  visitorKeys?: ?VisitorKeysType,
+): void {
+  const replacementParent = getParentKey(
+    originalNode,
+    originalNodeParent,
+    visitorKeys,
+  );
+  const parent = replacementParent.node;
+  if (replacementParent.type === 'array') {
+    // $FlowExpectedError[prop-missing]
+    parent[replacementParent.key] = removeFromArray(
+      // $FlowExpectedError[prop-missing]
+      parent[replacementParent.key],
+      replacementParent.targetIndex,
+    );
+  } else {
+    // $FlowExpectedError[prop-missing]
+    parent[replacementParent.key] = null;
+  }
+}
+
+/**
+ * Corrects the parent pointers in direct children of the given node.
+ */
+export function setParentPointersInDirectChildren(
+  node: ESNode,
+  visitorKeys?: ?VisitorKeysType,
+): void {
+  for (const key: $FlowFixMe of getVisitorKeys(node, visitorKeys)) {
+    if (isNode(node[key])) {
+      // $FlowExpectedError[cannot-write]
+      node[key].parent = node;
+    } else if (Array.isArray(node[key])) {
+      for (const child of node[key]) {
+        child.parent = node;
+      }
+    }
+  }
+}
+
+/**
+ * Traverses the entire subtree to ensure the parent pointers are set correctly.
+ */
+export function updateAllParentPointers(
+  node: ESNode,
+  visitorKeys?: ?VisitorKeysType,
+) {
+  SimpleTraverser.traverse(node, {
+    enter(node, parent) {
+      // $FlowExpectedError[cannot-write]
+      node.parent = parent;
+    },
+    leave() {},
+    visitorKeys,
+  });
+}
+
+/**
+ * Clone node and add new props.
+ *
+ * This will only create a new object if the overrides actually result in a change.
+ */
+export function nodeWith<T: ESNode>(
+  node: T,
+  overrideProps: Partial<T>,
+  visitorKeys?: ?VisitorKeysType,
+): T {
+  // Check if this will actually result in a change, maintaining referential equality is important.
+  const willBeUnchanged = Object.entries(overrideProps).every(
+    ([key, value]) => {
+      const node_: $FlowFixMe = node;
+      if (Array.isArray(value)) {
+        return Array.isArray(node_[key])
+          ? arrayIsEqual(node_[key], value)
+          : false;
+      }
+      return node_[key] === value;
+    },
+  );
+  if (willBeUnchanged) {
+    return node;
+  }
+
+  // Create new node.
+  // $FlowExpectedError[cannot-spread-interface]
+  const newNode: T = {
+    ...node,
+    ...overrideProps,
+  };
+
+  // Ensure parent pointers are correctly set within this nodes children.
+  setParentPointersInDirectChildren(newNode, visitorKeys);
+
+  return newNode;
+}
+
+/**
+ * Shallow clones node, providing a new reference for an existing node.
+ */
+export function shallowCloneNode<T: ESNode>(
+  node: T,
+  visitorKeys?: ?VisitorKeysType,
+): T {
+  // $FlowExpectedError[cannot-spread-interface]
+  const newNode: T = {...node};
+
+  // Ensure parent pointers are correctly set within this nodes children.
+  setParentPointersInDirectChildren(newNode, visitorKeys);
+
+  return newNode;
+}
+
+/**
+ * Deeply clones node and its entire tree.
+ */
+export function deepCloneNode<T: ESNode>(
+  node: T,
+  visitorKeys?: ?VisitorKeysType,
+): T {
+  const clone: T = JSON.parse(
+    JSON.stringify(node, (key, value) => {
+      // null out parent pointers
+      if (key === 'parent') {
+        return undefined;
+      }
+      return value;
+    }),
+  );
+
+  updateAllParentPointers(clone, visitorKeys);
+
+  return clone;
+}

package/oxidized/transform/print/comments/comments.js

@@ -0,0 +1,245 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CommentPlacement = void 0;
+exports.addComment = addComment;
+exports.appendCommentToSource = appendCommentToSource;
+exports.attachComments = attachComments;
+exports.cloneComment = cloneComment;
+exports.cloneCommentWithMarkers = cloneCommentWithMarkers;
+exports.cloneCommentsToNewNode = cloneCommentsToNewNode;
+exports.cloneJSDocCommentsToNewNode = cloneJSDocCommentsToNewNode;
+exports.getCommentsForNode = getCommentsForNode;
+exports.getLeadingCommentsForNode = getLeadingCommentsForNode;
+exports.getTrailingCommentsForNode = getTrailingCommentsForNode;
+exports.isAttachedComment = isAttachedComment;
+exports.isLeadingComment = isLeadingComment;
+exports.isTrailingComment = isTrailingComment;
+exports.makeCommentOwnLine = makeCommentOwnLine;
+exports.moveCommentsToNewNode = moveCommentsToNewNode;
+exports.mutateESTreeASTCommentsForPrettier = mutateESTreeASTCommentsForPrettier;
+exports.setCommentsOnNode = setCommentsOnNode;
+
+var _comments = require("./prettier/main/comments");
+
+var _loc = require("./prettier/language-js/loc");
+
+var _printerEstree = _interopRequireDefault(require("./prettier/language-js/printer-estree"));
+
+var _util = require("./prettier/common/util");
+
+var _flowEstree = require("flow-estree");
+
+var _os = require("os");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const CommentPlacement = require("flow-enums-runtime").Mirrored(["LEADING_OWN_LINE", "LEADING_INLINE", "TRAILING_OWN_LINE", "TRAILING_INLINE"]);
+
+exports.CommentPlacement = CommentPlacement;
+
+function attachComments(comments, ast, text) {
+  (0, _comments.attach)(comments, ast, text, {
+    locStart: _loc.locStart,
+    locEnd: _loc.locEnd,
+    printer: _printerEstree.default
+  });
+}
+
+function mutateESTreeASTCommentsForPrettier(program, text) {
+  let code = text;
+  delete program.comments;
+
+  if (program.docblock != null && program.docblock.comment != null) {
+    const docblockComment = program.docblock.comment;
+    const isDocblockCommentNew = !isAttachedComment(docblockComment);
+
+    if (isDocblockCommentNew) {
+      docblockComment.printed = false;
+      docblockComment.leading = true;
+      docblockComment.trailing = false;
+    }
+
+    if (program.body.length > 0) {
+      const firstStatement = program.body[0];
+      const leadingComments = getLeadingCommentsForNode(firstStatement);
+
+      if (!leadingComments.includes(docblockComment)) {
+        setCommentsOnNode(firstStatement, [docblockComment, ...getCommentsForNode(firstStatement)]);
+
+        if (isDocblockCommentNew) {
+          code = makeCommentOwnLine(code, docblockComment);
+        }
+      }
+    } else {
+      setCommentsOnNode(program, [docblockComment]);
+    }
+  }
+
+  delete program.docblock;
+  return code;
+}
+
+function moveCommentsToNewNode(oldNode, newNode) {
+  setCommentsOnNode(newNode, getCommentsForNode(oldNode));
+  setCommentsOnNode(oldNode, []);
+}
+
+function cloneCommentsToNewNode(oldNode, newNode) {
+  setCommentsOnNode(newNode, getCommentsForNode(oldNode).map(comment => cloneCommentWithMarkers(comment)));
+}
+
+function cloneJSDocCommentsToNewNode(oldNode, newNode) {
+  const comments = getCommentsForNode(oldNode).filter(comment => {
+    return (0, _flowEstree.isBlockComment)(comment) && comment.value.startsWith('*');
+  });
+  setCommentsOnNode(newNode, [...getCommentsForNode(newNode), ...comments.map(cloneCommentWithMarkers)]);
+}
+
+function setCommentsOnNode(node, comments) {
+  node.comments = comments;
+}
+
+function getCommentsForNode(node) {
+  var _node$comments;
+
+  return (_node$comments = node.comments) != null ? _node$comments : [];
+}
+
+function isAttachedComment(comment) {
+  return comment.printed === false;
+}
+
+function isLeadingComment(comment) {
+  return comment.leading === true;
+}
+
+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:
+    case CommentPlacement.LEADING_INLINE:
+      {
+        (0, _util.addLeadingComment)(node, comment);
+        break;
+      }
+
+    case CommentPlacement.TRAILING_OWN_LINE:
+    case CommentPlacement.TRAILING_INLINE:
+      {
+        (0, _util.addTrailingComment)(node, comment);
+        break;
+      }
+  }
+}
+
+function cloneComment(comment) {
+  return {
+    type: comment.type,
+    value: comment.value,
+    loc: comment.loc,
+    range: comment.range
+  };
+}
+
+function cloneCommentWithMarkers(comment) {
+  return {
+    type: comment.type,
+    value: comment.value,
+    loc: comment.loc,
+    range: comment.range,
+    leading: isLeadingComment(comment),
+    trailing: isTrailingComment(comment)
+  };
+}
+
+function getFirstNewlineIndex(code) {
+  return code.search(/\r\n|\n|\r/);
+}
+
+function getFirstNonWhitespaceIndex(code) {
+  return code.search(/\S/);
+}
+
+function makeCommentOwnLine(code, comment) {
+  let newCode = code;
+  let firstNewline = getFirstNewlineIndex(code);
+
+  if (firstNewline === -1) {
+    newCode += _os.EOL;
+    firstNewline = newCode.length;
+  }
+
+  comment.range = [firstNewline + 1, firstNewline];
+  return newCode;
+}
+
+function appendCommentToSource(code, comment, placement) {
+  let newCode = code;
+
+  switch (comment.type) {
+    case 'Block':
+      {
+        switch (placement) {
+          case CommentPlacement.LEADING_OWN_LINE:
+          case CommentPlacement.TRAILING_OWN_LINE:
+            {
+              newCode = makeCommentOwnLine(code, comment);
+              break;
+            }
+
+          case CommentPlacement.LEADING_INLINE:
+          case CommentPlacement.TRAILING_INLINE:
+            {
+              let firstNonWhitespace = getFirstNonWhitespaceIndex(code);
+
+              if (firstNonWhitespace === -1) {
+                newCode += '$FORCE_INLINE_ON_EMPTY_FILE_TOKEN$;';
+                firstNonWhitespace = newCode.length;
+                break;
+              }
+
+              comment.range = [firstNonWhitespace + 1, firstNonWhitespace];
+              break;
+            }
+        }
+
+        break;
+      }
+
+    case 'Line':
+      {
+        const commentText = `//${comment.value}`;
+        const lastChar = newCode[newCode.length - 1];
+
+        if (lastChar !== '\n' && lastChar !== '\r') {
+          newCode += _os.EOL;
+        }
+
+        if (placement === CommentPlacement.TRAILING_INLINE) {
+          newCode += '$FORCE_END_OF_LINE_COMMENT_TOKEN$;';
+        }
+
+        const start = newCode.length;
+        newCode += commentText;
+        const end = newCode.length;
+        comment.range = [start, end];
+        break;
+      }
+  }
+
+  return newCode;
+}