hermes-transform 0.8.0 → 0.10.0

package/dist/transform/mutations/RemoveStatement.js.flow

@@ -12,7 +12,7 @@ import type {ESNode, ModuleDeclaration, Statement} from 'hermes-estree';
 import type {MutationContext} from '../MutationContext';
 import type {DetachedNode} from '../../detachedNode';
 
-import {removeFromArray} from './utils/arrayUtils';
+import {astArrayMutationHelpers} from 'hermes-parser';
 import {getStatementParent} from './utils/getStatementParent';
 import * as t from '../../generated/node-types';
 
@@ -43,7 +43,7 @@ export function performRemoveStatementMutation(
     const parent: interface {
       [string]: $ReadOnlyArray<DetachedNode<Statement | ModuleDeclaration>>,
     } = removalParent.parent;
-    parent[removalParent.key] = removeFromArray(
+    parent[removalParent.key] = astArrayMutationHelpers.removeFromArray(
       parent[removalParent.key],
       removalParent.targetIndex,
     );

package/dist/transform/mutations/ReplaceNode.js

@@ -6,13 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.createReplaceNodeMutation = createReplaceNodeMutation;
 exports.performReplaceNodeMutation = performReplaceNodeMutation;
 
-var _arrayUtils = require("./utils/arrayUtils");
+var _hermesParser = require("hermes-parser");
 
 var _comments = require("../comments/comments");
 
 var _Errors = require("../Errors");
 
-var _getVisitorKeys = require("../../getVisitorKeys");
+var _detachedNode = require("../../detachedNode");
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -44,7 +44,7 @@ function performReplaceNodeMutation(mutationContext, mutation) {
 
   if (replacementParent.type === 'array') {
     const parent = replacementParent.parent;
-    parent[replacementParent.key] = (0, _arrayUtils.replaceInArray)(parent[replacementParent.key], replacementParent.targetIndex, [mutation.nodeToReplaceWith]);
+    parent[replacementParent.key] = _hermesParser.astArrayMutationHelpers.replaceInArray(parent[replacementParent.key], replacementParent.targetIndex, [mutation.nodeToReplaceWith]);
   } else {
     replacementParent.parent[replacementParent.key] = mutation.nodeToReplaceWith;
   }
@@ -59,8 +59,8 @@ function performReplaceNodeMutation(mutationContext, mutation) {
 function getParentKey(target) {
   const parent = target.parent;
 
-  for (const key of (0, _getVisitorKeys.getVisitorKeys)(parent)) {
-    if ((0, _getVisitorKeys.isNode)( // $FlowExpectedError[prop-missing]
+  for (const key of (0, _hermesParser.getVisitorKeys)(parent)) {
+    if ((0, _hermesParser.isNode)( // $FlowExpectedError[prop-missing]
     parent[key])) {
       if (parent[key] === target) {
         return {
@@ -71,7 +71,10 @@ function getParentKey(target) {
       }
     } else if (Array.isArray(parent[key])) {
       for (let i = 0; i < parent[key].length; i += 1) {
-        if (parent[key][i] === target) {
+        const current = parent[key][i];
+        const originalNode = (0, _detachedNode.getOriginalNode)(current);
+
+        if (current === target || originalNode === target) {
           return {
             type: 'array',
             parent,
@@ -84,5 +87,5 @@ function getParentKey(target) {
   } // this shouldn't happen ever
 
 
-  throw new _Errors.InvalidReplacementError(`Expected to find the ${target.type} as a direct child of the ${target.type}.`);
+  throw new _Errors.InvalidReplacementError(`Expected to find the ${target.type} as a direct child of the ${parent.type}.`);
 }

package/dist/transform/mutations/ReplaceNode.js.flow

@@ -12,10 +12,10 @@ import type {ESNode} from 'hermes-estree';
 import type {MutationContext} from '../MutationContext';
 import type {DetachedNode} from '../../detachedNode';
 
-import {replaceInArray} from './utils/arrayUtils';
+import {getVisitorKeys, isNode, astArrayMutationHelpers} from 'hermes-parser';
 import {moveCommentsToNewNode} from '../comments/comments';
 import {InvalidReplacementError} from '../Errors';
-import {getVisitorKeys, isNode} from '../../getVisitorKeys';
+import {getOriginalNode} from '../../detachedNode';
 
 export type ReplaceNodeMutation = $ReadOnly<{
   type: 'replaceNode',
@@ -55,7 +55,7 @@ export function performReplaceNodeMutation(
     const parent: interface {
       [string]: $ReadOnlyArray<DetachedNode<ESNode>>,
     } = replacementParent.parent;
-    parent[replacementParent.key] = replaceInArray(
+    parent[replacementParent.key] = astArrayMutationHelpers.replaceInArray(
       parent[replacementParent.key],
       replacementParent.targetIndex,
       [mutation.nodeToReplaceWith],
@@ -99,7 +99,9 @@ function getParentKey(target: ESNode): $ReadOnly<
       }
     } else if (Array.isArray(parent[key])) {
       for (let i = 0; i < parent[key].length; i += 1) {
-        if (parent[key][i] === target) {
+        const current = parent[key][i];
+        const originalNode = getOriginalNode(current);
+        if (current === target || originalNode === target) {
           return {type: 'array', parent, key, targetIndex: i};
         }
       }
@@ -108,6 +110,6 @@ function getParentKey(target: ESNode): $ReadOnly<
 
   // this shouldn't happen ever
   throw new InvalidReplacementError(
-    `Expected to find the ${target.type} as a direct child of the ${target.type}.`,
+    `Expected to find the ${target.type} as a direct child of the ${parent.type}.`,
   );
 }

package/dist/transform/mutations/ReplaceStatementWithMany.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.createReplaceStatementWithManyMutation = createReplaceStatementWithManyMutation;
 exports.performReplaceStatementWithManyMutation = performReplaceStatementWithManyMutation;
 
-var _arrayUtils = require("./utils/arrayUtils");
+var _hermesParser = require("hermes-parser");
 
 var _getStatementParent = require("./utils/getStatementParent");
 
@@ -63,7 +63,7 @@ function performReplaceStatementWithManyMutation(mutationContext, mutation) {
 
   if (replacementParent.type === 'array') {
     const parent = replacementParent.parent;
-    parent[replacementParent.key] = (0, _arrayUtils.replaceInArray)(parent[replacementParent.key], replacementParent.targetIndex, mutation.nodesToReplaceWith);
+    parent[replacementParent.key] = _hermesParser.astArrayMutationHelpers.replaceInArray(parent[replacementParent.key], replacementParent.targetIndex, mutation.nodesToReplaceWith);
     return replacementParent.parent;
   }
 

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

@@ -12,18 +12,21 @@ import type {ESNode, ModuleDeclaration, Statement} from 'hermes-estree';
 import type {MutationContext} from '../MutationContext';
 import type {DetachedNode} from '../../detachedNode';
 
-import {replaceInArray} from './utils/arrayUtils';
+import {astArrayMutationHelpers} from 'hermes-parser';
 import {getStatementParent} from './utils/getStatementParent';
 import {isValidModuleDeclarationParent} from './utils/isValidModuleDeclarationParent';
 import {moveCommentsToNewNode} from '../comments/comments';
 import {InvalidReplacementError} from '../Errors';
 import * as t from '../../generated/node-types';
 
+export type ReplaceStatementWithManyMutationNodes =
+  | ModuleDeclaration
+  | Statement;
 export type ReplaceStatementWithManyMutation = $ReadOnly<{
   type: 'replaceStatementWithMany',
-  target: ModuleDeclaration | Statement,
+  target: ReplaceStatementWithManyMutationNodes,
   nodesToReplaceWith: $ReadOnlyArray<
-    DetachedNode<ModuleDeclaration | Statement>,
+    DetachedNode<ReplaceStatementWithManyMutationNodes>,
   >,
   keepComments: boolean,
 }>;
@@ -75,7 +78,7 @@ export function performReplaceStatementWithManyMutation(
     const parent: interface {
       [string]: $ReadOnlyArray<DetachedNode<Statement | ModuleDeclaration>>,
     } = replacementParent.parent;
-    parent[replacementParent.key] = replaceInArray(
+    parent[replacementParent.key] = astArrayMutationHelpers.replaceInArray(
       parent[replacementParent.key],
       replacementParent.targetIndex,
       mutation.nodesToReplaceWith,

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

@@ -97,8 +97,9 @@ function getStatementParent(target) {
       case 'ForInStatement':
       case 'ForOfStatement':
         {
-          assertValidStatementLocation( // $FlowExpectedError[prop-missing] - flow does not track properties from parent interface
-          parent, 'left', 'right');
+          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,

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

@@ -9,6 +9,8 @@
  */
 
 import type {
+  ForInStatement,
+  ForOfStatement,
   ModuleDeclaration,
   Statement,
   StatementParentArray,
@@ -92,10 +94,11 @@ export function getStatementParent(
 
       case 'ForInStatement':
       case 'ForOfStatement': {
-        assertValidStatementLocation(
-          // $FlowExpectedError[prop-missing] - flow does not track properties from parent interface
+        assertValidStatementLocation<ForInStatement | ForOfStatement>(
           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'};

package/dist/transform/parse.js

@@ -0,0 +1,55 @@
+/**
+ * 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");
+
+function parse(code) {
+  const {
+    ast,
+    scopeManager
+  } = (0, _hermesEslint.parseForESLint)(code, {
+    sourceType: 'module'
+  }); // 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/transform/parse.js.flow

@@ -0,0 +1,55 @@
+/**
+ * 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 {Program} from 'hermes-estree';
+import type {ScopeManager} from 'hermes-eslint';
+
+import {attachComments} from './comments/comments';
+import {parseForESLint} from 'hermes-eslint';
+
+export type ParseResult = {
+  ast: Program,
+  scopeManager: ScopeManager,
+  code: string,
+};
+
+export function parse(code: string): ParseResult {
+  const {ast, scopeManager} = parseForESLint(code, {
+    sourceType: 'module',
+  });
+
+  // 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
+  attachComments(comments, ast, code);
+
+  return {ast, scopeManager, code};
+}

package/dist/transform/print.js

@@ -0,0 +1,160 @@
+/**
+ * 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; }
+
+function print(ast, originalCode, prettierOptions = {}, visitorKeys) {
+  // $FlowExpectedError[incompatible-type] This is now safe to access.
+  const program = ast; // The docblock comment is never attached to any AST nodes, since its technically
+  // attached to the program. However this is specific to our AST and in order for
+  // prettier to correctly print it we need to attach it to the first node in the
+  // program body.
+
+  if (program.docblock != null && program.body.length > 0) {
+    const firstNode = program.body[0];
+    const docblockComment = program.docblock.comment;
+    const leadingComments = (0, _comments.getLeadingCommentsForNode)(firstNode);
+
+    if (!leadingComments.includes(docblockComment)) {
+      (0, _comments.addCommentsToNode)(firstNode, [docblockComment], 'leading');
+    }
+  } // Fix up the AST to match what prettier expects.
+
+
+  mutateASTForPrettier(program, visitorKeys); // we need to delete the comments prop or else prettier will do
+  // its own attachment pass after the mutation and duplicate the
+  // comments on each node, borking the output
+  // $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;
+    }
+
+  });
+}
+
+function mutateASTForPrettier(rootNode, visitorKeys) {
+  _hermesParser.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); // 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 _hermesParser.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) {
+  switch (node.type) {
+    case 'CallExpression':
+      // $FlowExpectedError[cannot-spread-interface]
+      return { ...node,
+        type: 'OptionalCallExpression',
+        callee: transformChainExpression(node.callee)
+      };
+
+    case 'MemberExpression':
+      // $FlowExpectedError[cannot-spread-interface]
+      return { ...node,
+        type: 'OptionalMemberExpression',
+        object: transformChainExpression(node.object)
+      };
+    // No default
+  }
+
+  return node;
+}

package/dist/transform/print.js.flow

@@ -0,0 +1,176 @@
+/**
+ * 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 '../detachedNode';
+import type {Program, ESNode} from 'hermes-estree';
+
+import {SimpleTraverser} from 'hermes-parser';
+import * as prettier from 'prettier';
+import {
+  addCommentsToNode,
+  getLeadingCommentsForNode,
+} from './comments/comments';
+import type {VisitorKeysType} from 'hermes-parser';
+
+export function print(
+  ast: MaybeDetachedNode<Program>,
+  originalCode: string,
+  prettierOptions: {...} = {},
+  visitorKeys?: ?VisitorKeysType,
+): string {
+  // $FlowExpectedError[incompatible-type] This is now safe to access.
+  const program: Program = ast;
+
+  // The docblock comment is never attached to any AST nodes, since its technically
+  // attached to the program. However this is specific to our AST and in order for
+  // prettier to correctly print it we need to attach it to the first node in the
+  // program body.
+  if (program.docblock != null && program.body.length > 0) {
+    const firstNode = program.body[0];
+    const docblockComment = program.docblock.comment;
+    const leadingComments = getLeadingCommentsForNode(firstNode);
+    if (!leadingComments.includes(docblockComment)) {
+      addCommentsToNode(firstNode, [docblockComment], 'leading');
+    }
+  }
+
+  // Fix up the AST to match what prettier expects.
+  mutateASTForPrettier(program, visitorKeys);
+
+  // we need to delete the comments prop or else prettier will do
+  // its own attachment pass after the mutation and duplicate the
+  // comments on each node, borking the output
+  // $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;
+      },
+    },
+  );
+}
+
+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);
+
+        // 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),
+      };
+
+    case 'MemberExpression':
+      // $FlowExpectedError[cannot-spread-interface]
+      return {
+        ...node,
+        type: 'OptionalMemberExpression',
+        object: transformChainExpression(node.object),
+      };
+    // No default
+  }
+
+  return node;
+}