flow-parser 0.317.0 → 0.319.0

package/oxidized/transform/print/comments/prettier/language-js/utils.js

@@ -0,0 +1,89 @@
+'use strict';
+
+function isBlockComment(comment) {
+  return comment.type === 'Block' || comment.type === 'CommentBlock' || comment.type === 'MultiLine';
+}
+
+function isLineComment(comment) {
+  return comment.type === 'Line' || comment.type === 'CommentLine' || comment.type === 'SingleLine' || comment.type === 'HashbangComment' || comment.type === 'HTMLOpen' || comment.type === 'HTMLClose';
+}
+
+function isCallExpression(node) {
+  return node && (node.type === 'CallExpression' || node.type === 'OptionalCallExpression');
+}
+
+function isMemberExpression(node) {
+  return node && (node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression');
+}
+
+const functionParametersCache = new WeakMap();
+
+function getFunctionParameters(node) {
+  if (functionParametersCache.has(node)) {
+    return functionParametersCache.get(node);
+  }
+
+  const parameters = [];
+
+  if (node.this) {
+    parameters.push(node.this);
+  }
+
+  if (Array.isArray(node.parameters)) {
+    parameters.push(...node.parameters);
+  } else if (Array.isArray(node.params)) {
+    parameters.push(...node.params);
+  }
+
+  if (node.rest) {
+    parameters.push(node.rest);
+  }
+
+  functionParametersCache.set(node, parameters);
+  return parameters;
+}
+
+const callArgumentsCache = new WeakMap();
+
+function getCallArguments(node) {
+  if (callArgumentsCache.has(node)) {
+    return callArgumentsCache.get(node);
+  }
+
+  let args = node.arguments;
+
+  if (node.type === 'ImportExpression') {
+    args = [node.source];
+
+    if (node.attributes) {
+      args.push(node.attributes);
+    }
+  }
+
+  callArgumentsCache.set(node, args);
+  return args;
+}
+
+function isPrettierIgnoreComment(comment) {
+  return comment.value.trim() === 'prettier-ignore' && !comment.unignore;
+}
+
+function isCallLikeExpression(node) {
+  return isCallExpression(node) || node.type === 'NewExpression' || node.type === 'ImportExpression';
+}
+
+function isObjectProperty(node) {
+  return node && (node.type === 'ObjectProperty' || node.type === 'Property' && !node.method && node.kind === 'init');
+}
+
+module.exports = {
+  getFunctionParameters,
+  getCallArguments,
+  isBlockComment,
+  isCallLikeExpression,
+  isLineComment,
+  isPrettierIgnoreComment,
+  isCallExpression,
+  isMemberExpression,
+  isObjectProperty
+};

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

@@ -0,0 +1,374 @@
+'use strict';
+
+const assert = require('assert');
+
+const {
+  hasNewline,
+  addLeadingComment,
+  addDanglingComment,
+  addTrailingComment
+} = require('../common/util.js');
+
+const childNodesCache = new WeakMap();
+
+function getSortedChildNodes(node, options, resultArray) {
+  if (!node) {
+    return;
+  }
+
+  const {
+    printer,
+    locStart,
+    locEnd
+  } = options;
+
+  if (resultArray) {
+    if (printer.canAttachComment && printer.canAttachComment(node)) {
+      let 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);
+  }
+
+  const childNodes = printer.getCommentChildNodes && printer.getCommentChildNodes(node, options) || typeof node === 'object' && Object.entries(node).filter(([key]) => key !== 'enclosingNode' && key !== 'precedingNode' && key !== 'followingNode' && key !== 'tokens' && key !== 'comments' && key !== 'parent').map(([, value]) => value);
+
+  if (!childNodes) {
+    return;
+  }
+
+  if (!resultArray) {
+    resultArray = [];
+    childNodesCache.set(node, resultArray);
+  }
+
+  for (const childNode of childNodes) {
+    getSortedChildNodes(childNode, options, resultArray);
+  }
+
+  return resultArray;
+}
+
+function decorateComment(node, comment, options, enclosingNode) {
+  const {
+    locStart,
+    locEnd
+  } = options;
+  const commentStart = locStart(comment);
+  const commentEnd = locEnd(comment);
+  const childNodes = getSortedChildNodes(node, options);
+  let precedingNode;
+  let followingNode;
+  let left = 0;
+  let right = childNodes.length;
+
+  while (left < right) {
+    const middle = left + right >> 1;
+    const child = childNodes[middle];
+    const start = locStart(child);
+    const end = locEnd(child);
+
+    if (start <= commentStart && commentEnd <= end) {
+      return decorateComment(child, comment, options, child);
+    }
+
+    if (end <= commentStart) {
+      precedingNode = child;
+      left = middle + 1;
+      continue;
+    }
+
+    if (commentEnd <= start) {
+      followingNode = child;
+      right = middle;
+      continue;
+    }
+
+    throw new Error('Comment location overlaps with node location');
+  }
+
+  if (enclosingNode && enclosingNode.type === 'TemplateLiteral') {
+    const {
+      quasis
+    } = enclosingNode;
+    const 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,
+    precedingNode,
+    followingNode
+  };
+}
+
+const returnFalse = () => false;
+
+function attach(comments, ast, text, options) {
+  if (!Array.isArray(comments)) {
+    return;
+  }
+
+  const tiesToBreak = [];
+  const {
+    locStart,
+    locEnd,
+    printer: {
+      handleComments = {}
+    }
+  } = options;
+  const {
+    avoidAstMutation,
+    ownLine: handleOwnLineComment = returnFalse,
+    endOfLine: handleEndOfLineComment = returnFalse,
+    remaining: handleRemainingComment = returnFalse
+  } = handleComments;
+  const decoratedComments = comments.map((comment, index) => ({ ...decorateComment(ast, comment, options),
+    comment,
+    text,
+    options,
+    ast,
+    isLastComment: comments.length - 1 === index
+  }));
+
+  for (const [index, context] of decoratedComments.entries()) {
+    const {
+      comment,
+      precedingNode,
+      enclosingNode,
+      followingNode,
+      text,
+      options,
+      ast,
+      isLastComment
+    } = context;
+
+    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;
+      }
+    }
+
+    let args;
+
+    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 (handleOwnLineComment(...args)) {} else if (followingNode) {
+        addLeadingComment(followingNode, comment);
+      } else if (precedingNode) {
+        addTrailingComment(precedingNode, comment);
+      } else if (enclosingNode) {
+        addDanglingComment(enclosingNode, comment);
+      } else {
+        addDanglingComment(ast, comment);
+      }
+    } else if (isEndOfLineComment(text, options, decoratedComments, index)) {
+      comment.placement = 'endOfLine';
+
+      if (handleEndOfLineComment(...args)) {} else if (precedingNode) {
+        addTrailingComment(precedingNode, comment);
+      } else if (followingNode) {
+        addLeadingComment(followingNode, comment);
+      } else if (enclosingNode) {
+        addDanglingComment(enclosingNode, comment);
+      } else {
+        addDanglingComment(ast, comment);
+      }
+    } else {
+      comment.placement = 'remaining';
+
+      if (handleRemainingComment(...args)) {} else if (precedingNode && followingNode) {
+        const tieCount = tiesToBreak.length;
+
+        if (tieCount > 0) {
+          const 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 {
+        addDanglingComment(ast, comment);
+      }
+    }
+  }
+
+  breakTies(tiesToBreak, text, options);
+
+  if (!avoidAstMutation) {
+    for (const comment of comments) {
+      delete comment.precedingNode;
+      delete comment.enclosingNode;
+      delete comment.followingNode;
+    }
+  }
+}
+
+const isAllEmptyAndNoLineBreak = text => !/[\S\n\u2028\u2029]/.test(text);
+
+function isOwnLineComment(text, options, decoratedComments, commentIndex) {
+  const {
+    comment,
+    precedingNode
+  } = decoratedComments[commentIndex];
+  const {
+    locStart,
+    locEnd
+  } = options;
+  let start = locStart(comment);
+
+  if (precedingNode) {
+    for (let index = commentIndex - 1; index >= 0; index--) {
+      const {
+        comment,
+        precedingNode: currentCommentPrecedingNode
+      } = decoratedComments[index];
+
+      if (currentCommentPrecedingNode !== precedingNode || !isAllEmptyAndNoLineBreak(text.slice(locEnd(comment), start))) {
+        break;
+      }
+
+      start = locStart(comment);
+    }
+  }
+
+  return hasNewline(text, start, {
+    backwards: true
+  });
+}
+
+function isEndOfLineComment(text, options, decoratedComments, commentIndex) {
+  const {
+    comment,
+    followingNode
+  } = decoratedComments[commentIndex];
+  const {
+    locStart,
+    locEnd
+  } = options;
+  let end = locEnd(comment);
+
+  if (followingNode) {
+    for (let index = commentIndex + 1; index < decoratedComments.length; index++) {
+      const {
+        comment,
+        followingNode: currentCommentFollowingNode
+      } = decoratedComments[index];
+
+      if (currentCommentFollowingNode !== followingNode || !isAllEmptyAndNoLineBreak(text.slice(end, locStart(comment)))) {
+        break;
+      }
+
+      end = locEnd(comment);
+    }
+  }
+
+  return hasNewline(text, end);
+}
+
+function breakTies(tiesToBreak, text, options) {
+  const tieCount = tiesToBreak.length;
+
+  if (tieCount === 0) {
+    return;
+  }
+
+  const {
+    precedingNode,
+    followingNode,
+    enclosingNode
+  } = tiesToBreak[0];
+  const gapRegExp = options.printer.getGapRegex && options.printer.getGapRegex(enclosingNode) || /^[\s(]*$/;
+  let gapEndPos = options.locStart(followingNode);
+  let indexOfFirstLeadingComment;
+
+  for (indexOfFirstLeadingComment = tieCount; indexOfFirstLeadingComment > 0; --indexOfFirstLeadingComment) {
+    const {
+      comment,
+      precedingNode: currentCommentPrecedingNode,
+      followingNode: currentCommentFollowingNode
+    } = tiesToBreak[indexOfFirstLeadingComment - 1];
+    assert.strictEqual(currentCommentPrecedingNode, precedingNode);
+    assert.strictEqual(currentCommentFollowingNode, followingNode);
+    const gap = text.slice(options.locEnd(comment), gapEndPos);
+
+    if (gapRegExp.test(gap)) {
+      gapEndPos = options.locStart(comment);
+    } else {
+      break;
+    }
+  }
+
+  for (const [i, {
+    comment
+  }] of tiesToBreak.entries()) {
+    if (i < indexOfFirstLeadingComment) {
+      addTrailingComment(precedingNode, comment);
+    } else {
+      addLeadingComment(followingNode, comment);
+    }
+  }
+
+  for (const node of [precedingNode, followingNode]) {
+    if (node.comments && node.comments.length > 1) {
+      node.comments.sort((a, b) => options.locStart(a) - options.locStart(b));
+    }
+  }
+
+  tiesToBreak.length = 0;
+}
+
+function findExpressionIndexForComment(quasis, comment, options) {
+  const startPos = options.locStart(comment) - 1;
+
+  for (let i = 1; i < quasis.length; ++i) {
+    if (startPos < options.locStart(quasis[i])) {
+      return i - 1;
+    }
+  }
+
+  return 0;
+}
+
+module.exports = {
+  attach
+};

package/oxidized/transform/print/comments/prettier/utils/get-last.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const getLast = arr => arr[arr.length - 1];
+
+module.exports = getLast;

package/oxidized/transform/print/detachedNodeTypes.js

@@ -0,0 +1 @@
+'use strict';

package/oxidized/transform/print/detachedNodeTypes.js.flow

@@ -0,0 +1,24 @@
+/**
+ * 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-local
+ * @format
+ */
+
+/*
+ * Minimal type-only stub for `DetachedNode<T>` and `MaybeDetachedNode<T>`.
+ * Upstream hermes-transform's `src/detachedNode.js` defines these as part of
+ * its broader detached-AST authoring surface used by node-builders. The
+ * vendored `print()` only needs the structural types for its public API
+ * signature; everything is type-erased at runtime by Babel's
+ * flow-strip-types pass. By keeping a local stub we avoid pulling in the
+ * full hermes-transform detached-node machinery.
+ */
+
+'use strict';
+
+export type DetachedNode<+T> = T;
+export type MaybeDetachedNode<+T> = T | DetachedNode<T>;

package/oxidized/transform/print/print.js

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.print = print;
+
+var _mutateESTreeASTForPrettier = _interopRequireDefault(require("../../utils/mutateESTreeASTForPrettier"));
+
+var prettier = _interopRequireWildcard(require("prettier"));
+
+var _comments = require("./comments/comments");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+async function print(ast, originalCode, prettierOptions = {}, visitorKeys) {
+  const program = ast;
+
+  if (program.body.length === 0) {
+    var _program$docblock;
+
+    const docblockComment = (_program$docblock = program.docblock) == null ? void 0 : _program$docblock.comment;
+
+    if (docblockComment != null) {
+      return '/*' + docblockComment.value + '*/\n';
+    }
+
+    return '';
+  }
+
+  const codeForPrinting = (0, _comments.mutateESTreeASTCommentsForPrettier)(program, originalCode);
+  (0, _mutateESTreeASTForPrettier.default)(program, visitorKeys);
+  let pluginParserName = 'flow';
+  let pluginParser;
+  let pluginPrinter;
+
+  try {
+    const prettierHermesPlugin = await Promise.resolve().then(() => _interopRequireWildcard(require('prettier-plugin-hermes-parser')));
+    pluginParser = prettierHermesPlugin.parsers.hermes;
+    pluginPrinter = prettierHermesPlugin.printers;
+    pluginParserName = 'hermes';
+  } catch {
+    const prettierFlowPlugin = require('prettier/plugins/flow');
+
+    pluginParser = prettierFlowPlugin.parsers.flow;
+  }
+
+  return prettier.format(codeForPrinting, { ...prettierOptions,
+    parser: pluginParserName,
+    requirePragma: false,
+    plugins: [{
+      parsers: {
+        [pluginParserName]: { ...pluginParser,
+
+          parse() {
+            return program;
+          }
+
+        }
+      },
+      printers: pluginPrinter
+    }]
+  });
+}

package/oxidized/transform/print/print.js.flow

@@ -0,0 +1,87 @@
+/**
+ * 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-local
+ * @format
+ */
+
+'use strict';
+
+import type {MaybeDetachedNode} from './detachedNodeTypes';
+import type {Program} from 'flow-estree';
+
+import mutateESTreeASTForPrettier from '../../utils/mutateESTreeASTForPrettier';
+import * as prettier from 'prettier';
+import {mutateESTreeASTCommentsForPrettier} from './comments/comments';
+import type {VisitorKeysType} from '../../traverse/getVisitorKeys';
+
+export async function print(
+  ast: MaybeDetachedNode<Program>,
+  originalCode: string,
+  prettierOptions: {...} = {},
+  visitorKeys?: ?VisitorKeysType,
+): Promise<string> {
+  // $FlowExpectedError[incompatible-type] This is now safe to access.
+  const program: 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) {
+    // If the program had a docblock comment, we need to create the string manually.
+    const docblockComment = 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 = mutateESTreeASTCommentsForPrettier(
+    program,
+    originalCode,
+  );
+
+  // Fix up the AST to match what prettier expects.
+  mutateESTreeASTForPrettier(program, visitorKeys);
+
+  let pluginParserName = 'flow';
+  let pluginParser;
+  let pluginPrinter;
+  try {
+    // Use prettier-plugin-hermes-parser if we can. It has latest Flow syntax support.
+    // $FlowExpectedError[untyped-import]
+    const prettierHermesPlugin = await import('prettier-plugin-hermes-parser');
+    pluginParser = prettierHermesPlugin.parsers.hermes;
+    pluginPrinter = prettierHermesPlugin.printers;
+    pluginParserName = 'hermes';
+  } catch {
+    const prettierFlowPlugin = require('prettier/plugins/flow');
+    pluginParser = prettierFlowPlugin.parsers.flow;
+  }
+
+  return prettier.format(
+    codeForPrinting,
+    // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
+    {
+      ...prettierOptions,
+      parser: pluginParserName,
+      requirePragma: false,
+      plugins: [
+        {
+          parsers: {
+            [pluginParserName]: {
+              ...pluginParser,
+              parse() {
+                return program;
+              },
+            },
+          },
+          printers: pluginPrinter,
+        },
+      ],
+    },
+  );
+}