hermes-transform 0.11.0 → 0.12.0

package/dist/transform/print.js.flow

@@ -11,9 +11,9 @@
 'use strict';
 
 import type {MaybeDetachedNode} from '../detachedNode';
-import type {Program, ESNode} from 'hermes-estree';
+import type {Program} from 'hermes-estree';
 
-import {SimpleTraverser} from 'hermes-parser';
+import {mutateESTreeASTForPrettier} from 'hermes-parser';
 import * as prettier from 'prettier';
 import {
   addCommentsToNode,
@@ -21,12 +21,12 @@ import {
 } from './comments/comments';
 import type {VisitorKeysType} from 'hermes-parser';
 
-export function print(
+export async function print(
   ast: MaybeDetachedNode<Program>,
   originalCode: string,
   prettierOptions: {...} = {},
   visitorKeys?: ?VisitorKeysType,
-): string {
+): Promise<string> {
   // $FlowExpectedError[incompatible-type] This is now safe to access.
   const program: Program = ast;
 
@@ -44,7 +44,7 @@ export function print(
   }
 
   // Fix up the AST to match what prettier expects.
-  mutateASTForPrettier(program, visitorKeys);
+  mutateESTreeASTForPrettier(program, visitorKeys);
 
   // we need to delete the comments prop or else prettier will do
   // its own attachment pass after the mutation and duplicate the
@@ -52,125 +52,63 @@ export function print(
   // $FlowExpectedError[cannot-write]
   delete program.comments;
 
-  return prettier.format(
-    originalCode,
-    // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
-    {
-      ...prettierOptions,
-      parser() {
-        return program;
-      },
-    },
-  );
+  switch (getPrettierMajorVersion()) {
+    case '3': {
+      // Lazy require this module as it only exists in prettier v3.
+      const prettierFlowPlugin = require('prettier/plugins/flow');
+      return prettier.format(
+        originalCode,
+        // $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': {
+      return prettier.format(
+        originalCode,
+        // $FlowExpectedError[incompatible-exact] - we don't want to create a dependency on the prettier types
+        {
+          ...prettierOptions,
+          parser() {
+            return program;
+          },
+        },
+      );
+    }
+    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 mutateASTForPrettier(
-  rootNode: ESNode,
-  visitorKeys: ?VisitorKeysType,
-): void {
-  SimpleTraverser.traverse(rootNode, {
-    enter(node) {
-      // prettier fully expects the parent pointers are NOT set and
-      // certain cases can crash due to prettier infinite-looping
-      // whilst naively traversing the parent property
-      // https://github.com/prettier/prettier/issues/11793
-      // $FlowExpectedError[cannot-write]
-      delete node.parent;
-
-      // prettier currently relies on the AST being in the old-school, deprecated AST format for optional chaining
-      // so we have to apply their transform to our AST so it can actually format it.
-      if (node.type === 'ChainExpression') {
-        const newNode = transformChainExpression(node.expression);
-
-        // Clear out existing properties
-        for (const k of Object.keys(node)) {
-          // $FlowExpectedError[prop-missing]
-          delete node[k];
-        }
-
-        // Traverse `newNode` and its children.
-        mutateASTForPrettier(newNode, visitorKeys);
+function getPrettierMajorVersion(): '3' | '2' | 'UNSUPPORTED' {
+  const {version} = prettier;
 
-        // Overwrite `node` to match `newNode` while retaining the reference.
-        // $FlowExpectedError[prop-missing]
-        // $FlowExpectedError[cannot-write]
-        Object.assign(node, newNode);
-
-        // Skip traversing the existing nodes since we are replacing them.
-        throw SimpleTraverser.Skip;
-      }
-
-      // Prettier currently relies on comparing the `node` vs `node.value` start positions to know if an
-      // `ObjectTypeProperty` is a method or not (instead of using the `node.method` boolean). To correctly print
-      // the node when its not a method we need the start position to be different from the `node.value`s start
-      // position.
-      if (node.type === 'ObjectTypeProperty') {
-        if (
-          node.method === false &&
-          node.kind === 'init' &&
-          node.range[0] === 1 &&
-          node.value.range[0] === 1
-        ) {
-          // $FlowExpectedError[cannot-write]
-          // $FlowExpectedError[cannot-spread-interface]
-          node.value = {
-            ...node.value,
-            range: [2, node.value.range[1]],
-          };
-        }
-      }
-
-      // Prettier currently relies on comparing the the start positions to know if the import/export specifier should have a
-      // rename (eg `Name` vs `Name as Name`) when the name is exactly the same
-      // So we need to ensure that the range is always the same to avoid the useless code printing
-      if (node.type === 'ImportSpecifier') {
-        if (node.local.name === node.imported.name) {
-          if (node.local.range == null) {
-            // for our TS-ast printing which has no locs
-            // $FlowExpectedError[cannot-write]
-            node.local.range = [0, 0];
-          }
-          // $FlowExpectedError[cannot-write]
-          node.imported.range = [...node.local.range];
-        }
-      }
-      if (node.type === 'ExportSpecifier') {
-        if (node.local.name === node.exported.name) {
-          if (node.local.range == null) {
-            // for our TS-ast printing which has no locs
-            // $FlowExpectedError[cannot-write]
-            node.local.range = [0, 0];
-          }
-          // $FlowExpectedError[cannot-write]
-          node.exported.range = [...node.local.range];
-        }
-      }
-    },
-    leave() {},
-    visitorKeys,
-  });
-}
-
-// https://github.com/prettier/prettier/blob/d962466a828f8ef51435e3e8840178d90b7ec6cd/src/language-js/parse/postprocess/index.js#L161-L182
-function transformChainExpression(node: ESNode): ESNode {
-  switch (node.type) {
-    case 'CallExpression':
-      // $FlowExpectedError[cannot-spread-interface]
-      return {
-        ...node,
-        type: 'OptionalCallExpression',
-        callee: transformChainExpression(node.callee),
-      };
+  if (version.startsWith('3.')) {
+    return '3';
+  }
 
-    case 'MemberExpression':
-      // $FlowExpectedError[cannot-spread-interface]
-      return {
-        ...node,
-        type: 'OptionalMemberExpression',
-        object: transformChainExpression(node.object),
-      };
-    // No default
+  if (version.startsWith('2.')) {
+    return '2';
   }
 
-  return node;
+  return 'UNSUPPORTED';
 }

package/dist/transform/transform.js

@@ -20,8 +20,8 @@ var _parse = require("./parse");
 
 var _print = require("./print");
 
-function transform(originalCode, visitors, prettierOptions = {}) {
-  const parseResult = (0, _parse.parse)(originalCode);
+async function transform(originalCode, visitors, prettierOptions = {}) {
+  const parseResult = await (0, _parse.parse)(originalCode);
   const {
     ast,
     astWasMutated,

package/dist/transform/transform.js.flow

@@ -19,12 +19,12 @@ import {print} from './print';
 
 export type TransformVisitor = Visitor<TransformContextAdditions>;
 
-export function transform(
+export async function transform(
   originalCode: string,
   visitors: TransformVisitor,
   prettierOptions: {...} = {},
-): string {
-  const parseResult = parse(originalCode);
+): Promise<string> {
+  const parseResult = await parse(originalCode);
 
   const {ast, astWasMutated, mutatedCode} = transformAST(parseResult, visitors);
   if (!astWasMutated) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-transform",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Tools built on top of Hermes-ESTree to enable codebase transformation",
   "main": "dist/index.js",
   "license": "MIT",
@@ -12,12 +12,12 @@
     "@babel/code-frame": "^7.16.0",
     "esquery": "^1.4.0",
     "flow-enums-runtime": "^0.0.6",
-    "hermes-eslint": "0.11.0",
-    "hermes-estree": "0.11.0",
-    "hermes-parser": "0.11.0"
+    "hermes-eslint": "0.12.0",
+    "hermes-estree": "0.12.0",
+    "hermes-parser": "0.12.0"
   },
   "peerDependencies": {
-    "prettier": "^2.7.1"
+    "prettier": "^3.0.0 || ^2.7.1"
   },
   "files": [
     "dist",

package/dist/transform/comments/prettier/common/util.js.flow

@@ -1,349 +0,0 @@
-/**
- * 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';
-
-const stringWidth = require('string-width');
-const getLast = require('../utils/get-last.js');
-
-const notAsciiRegex = /[^\x20-\x7F]/;
-
-/**
- * @typedef {{backwards?: boolean}} SkipOptions
- */
-
-/**
- * @param {string | RegExp} chars
- * @returns {(text: string, index: number | false, opts?: SkipOptions) => number | false}
- */
-function skip(chars) {
-  return (text, index, opts) => {
-    const backwards = opts && opts.backwards;
-
-    // Allow `skip` functions to be threaded together without having
-    // to check for failures (did someone say monads?).
-    /* istanbul ignore next */
-    if (index === false) {
-      return false;
-    }
-
-    const {length} = text;
-    let cursor = index;
-    while (cursor >= 0 && cursor < length) {
-      const c = text.charAt(cursor);
-      if (chars instanceof RegExp) {
-        if (!chars.test(c)) {
-          return cursor;
-        }
-      } else if (!chars.includes(c)) {
-        return cursor;
-      }
-
-      backwards ? cursor-- : cursor++;
-    }
-
-    if (cursor === -1 || cursor === length) {
-      // If we reached the beginning or end of the file, return the
-      // out-of-bounds cursor. It's up to the caller to handle this
-      // correctly. We don't want to indicate `false` though if it
-      // actually skipped valid characters.
-      return cursor;
-    }
-    return false;
-  };
-}
-
-/**
- * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
- */
-const skipWhitespace = skip(/\s/);
-/**
- * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
- */
-const skipSpaces = skip(' \t');
-/**
- * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
- */
-const skipToLineEnd = skip(',; \t');
-/**
- * @type {(text: string, index: number | false, opts?: SkipOptions) => number | false}
- */
-const skipEverythingButNewLine = skip(/[^\n\r]/);
-
-/**
- * @param {string} text
- * @param {number | false} index
- * @returns {number | false}
- */
-function skipInlineComment(text, index) {
-  /* istanbul ignore next */
-  if (index === false) {
-    return false;
-  }
-
-  if (text.charAt(index) === '/' && text.charAt(index + 1) === '*') {
-    for (let i = index + 2; i < text.length; ++i) {
-      if (text.charAt(i) === '*' && text.charAt(i + 1) === '/') {
-        return i + 2;
-      }
-    }
-  }
-  return index;
-}
-
-/**
- * @param {string} text
- * @param {number | false} index
- * @returns {number | false}
- */
-function skipTrailingComment(text, index) {
-  /* istanbul ignore next */
-  if (index === false) {
-    return false;
-  }
-
-  if (text.charAt(index) === '/' && text.charAt(index + 1) === '/') {
-    return skipEverythingButNewLine(text, index);
-  }
-  return index;
-}
-
-// This one doesn't use the above helper function because it wants to
-// test \r\n in order and `skip` doesn't support ordering and we only
-// want to skip one newline. It's simple to implement.
-/**
- * @param {string} text
- * @param {number | false} index
- * @param {SkipOptions=} opts
- * @returns {number | false}
- */
-function skipNewline(text, index, opts) {
-  const backwards = opts && opts.backwards;
-  if (index === false) {
-    return false;
-  }
-
-  const atIndex = text.charAt(index);
-  if (backwards) {
-    // We already replace `\r\n` with `\n` before parsing
-    /* istanbul ignore next */
-    if (text.charAt(index - 1) === '\r' && atIndex === '\n') {
-      return index - 2;
-    }
-    if (
-      atIndex === '\n' ||
-      atIndex === '\r' ||
-      atIndex === '\u2028' ||
-      atIndex === '\u2029'
-    ) {
-      return index - 1;
-    }
-  } else {
-    // We already replace `\r\n` with `\n` before parsing
-    /* istanbul ignore next */
-    if (atIndex === '\r' && text.charAt(index + 1) === '\n') {
-      return index + 2;
-    }
-    if (
-      atIndex === '\n' ||
-      atIndex === '\r' ||
-      atIndex === '\u2028' ||
-      atIndex === '\u2029'
-    ) {
-      return index + 1;
-    }
-  }
-
-  return index;
-}
-
-/**
- * @param {string} text
- * @param {number} index
- * @param {SkipOptions=} opts
- * @returns {boolean}
- */
-function hasNewline(text, index, opts = {}) {
-  const idx = skipSpaces(text, opts.backwards ? index - 1 : index, opts);
-  const idx2 = skipNewline(text, idx, opts);
-  return idx !== idx2;
-}
-
-/**
- * @param {string} text
- * @param {number} start
- * @param {number} end
- * @returns {boolean}
- */
-function hasNewlineInRange(text, start, end) {
-  for (let i = start; i < end; ++i) {
-    if (text.charAt(i) === '\n') {
-      return true;
-    }
-  }
-  return false;
-}
-
-/**
- * @param {string} text
- * @param {number} index
- * @returns {boolean}
- */
-function isNextLineEmptyAfterIndex(text, index) {
-  /** @type {number | false} */
-  let oldIdx = null;
-  /** @type {number | false} */
-  let idx = index;
-  while (idx !== oldIdx) {
-    // We need to skip all the potential trailing inline comments
-    oldIdx = idx;
-    idx = skipToLineEnd(text, idx);
-    idx = skipInlineComment(text, idx);
-    idx = skipSpaces(text, idx);
-  }
-  idx = skipTrailingComment(text, idx);
-  idx = skipNewline(text, idx);
-  return idx !== false && hasNewline(text, idx);
-}
-
-/**
- * @param {string} text
- * @param {number} idx
- * @returns {number | false}
- */
-function getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, idx) {
-  /** @type {number | false} */
-  let oldIdx = null;
-  /** @type {number | false} */
-  let nextIdx = idx;
-  while (nextIdx !== oldIdx) {
-    oldIdx = nextIdx;
-    nextIdx = skipSpaces(text, nextIdx);
-    nextIdx = skipInlineComment(text, nextIdx);
-    nextIdx = skipTrailingComment(text, nextIdx);
-    nextIdx = skipNewline(text, nextIdx);
-  }
-  return nextIdx;
-}
-
-/**
- * @template N
- * @param {string} text
- * @param {N} node
- * @param {(node: N) => number} locEnd
- * @returns {number | false}
- */
-function getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd) {
-  return getNextNonSpaceNonCommentCharacterIndexWithStartIndex(
-    text,
-    locEnd(node),
-  );
-}
-
-/**
- * @template N
- * @param {string} text
- * @param {N} node
- * @param {(node: N) => number} locEnd
- * @returns {string}
- */
-function getNextNonSpaceNonCommentCharacter(text, node, locEnd) {
-  return text.charAt(
-    // @ts-expect-error => TBD: can return false, should we define a fallback?
-    getNextNonSpaceNonCommentCharacterIndex(text, node, locEnd),
-  );
-}
-
-/**
- * @param {string} text
- * @returns {number}
- */
-function getStringWidth(text) {
-  if (!text) {
-    return 0;
-  }
-
-  // shortcut to avoid needless string `RegExp`s, replacements, and allocations within `string-width`
-  if (!notAsciiRegex.test(text)) {
-    return text.length;
-  }
-
-  return stringWidth(text);
-}
-
-function addCommentHelper(node, comment) {
-  const comments = node.comments || (node.comments = []);
-  comments.push(comment);
-  comment.printed = false;
-  comment.nodeDescription = describeNodeForDebugging(node);
-}
-
-function addLeadingComment(node, comment) {
-  comment.leading = true;
-  comment.trailing = false;
-  addCommentHelper(node, comment);
-}
-
-function addDanglingComment(node, comment, marker) {
-  comment.leading = false;
-  comment.trailing = false;
-  if (marker) {
-    comment.marker = marker;
-  }
-  addCommentHelper(node, comment);
-}
-
-function addTrailingComment(node, comment) {
-  comment.leading = false;
-  comment.trailing = true;
-  addCommentHelper(node, comment);
-}
-
-/**
- * @param {any} object
- * @returns {object is Array<any>}
- */
-function isNonEmptyArray(object) {
-  return Array.isArray(object) && object.length > 0;
-}
-
-function describeNodeForDebugging(node) {
-  const nodeType = node.type || node.kind || '(unknown type)';
-  let nodeName = String(
-    node.name ||
-      (node.id && (typeof node.id === 'object' ? node.id.name : node.id)) ||
-      (node.key && (typeof node.key === 'object' ? node.key.name : node.key)) ||
-      (node.value &&
-        (typeof node.value === 'object' ? '' : String(node.value))) ||
-      node.operator ||
-      '',
-  );
-  if (nodeName.length > 20) {
-    nodeName = nodeName.slice(0, 19) + '…';
-  }
-  return nodeType + (nodeName ? ' ' + nodeName : '');
-}
-
-module.exports = {
-  getStringWidth,
-  getLast,
-  getNextNonSpaceNonCommentCharacterIndexWithStartIndex,
-  getNextNonSpaceNonCommentCharacterIndex,
-  getNextNonSpaceNonCommentCharacter,
-  skipWhitespace,
-  skipSpaces,
-  skipNewline,
-  isNextLineEmptyAfterIndex,
-  hasNewline,
-  hasNewlineInRange,
-  addLeadingComment,
-  addDanglingComment,
-  addTrailingComment,
-  isNonEmptyArray,
-};