@prettier/plugin-php 0.19.7 → 0.20.1

package/src/printer.js

@@ -1,5 +1,4 @@
-"use strict";
-
+import { util as prettierUtil, doc } from "prettier";
 const {
   breakParent,
   join,
@@ -15,14 +14,22 @@ const {
   literalline,
   align,
   dedentToRoot,
-} = require("prettier").doc.builders;
-const { willBreak } = require("prettier").doc.utils;
+} = doc.builders;
+const { willBreak } = doc.utils;
 const { isNextLineEmptyAfterIndex, hasNewline, hasNewlineInRange } =
-  require("prettier").util;
-const comments = require("./comments");
-const pathNeedsParens = require("./needs-parens");
-
-const {
+  prettierUtil;
+import {
+  printAllComments,
+  hasTrailingComment,
+  hasLeadingComment,
+  printDanglingComments,
+  printComments,
+  isBlockComment,
+  hasLeadingOwnLineComment,
+} from "./comments.js";
+import pathNeedsParens from "./needs-parens.js";
+
+import {
   getLast,
   getPenultimate,
   isLastStatement,
@@ -32,8 +39,6 @@ const {
   maybeStripLeadingSlashFromUse,
   fileShouldEndWithHardline,
   hasDanglingComments,
-  hasLeadingComment,
-  hasTrailingComment,
   docShouldHaveTrailingNewline,
   isLookupNode,
   isFirstChildrenInlineNode,
@@ -54,7 +59,7 @@ const {
   getNextNonSpaceNonCommentCharacterIndex,
   isNextLineEmpty,
   isPreviousLineEmpty,
-} = require("./util");
+} from "./util.js";
 
 function isMinVersion(actualVersion, requiredVersion) {
   return parseFloat(actualVersion) >= parseFloat(requiredVersion);
@@ -80,11 +85,9 @@ function shouldPrintHardlineForOpenBrace(options) {
 }
 
 function genericPrint(path, options, print) {
-  const node = path.getValue();
+  const { node } = path;
 
-  if (!node) {
-    return "";
-  } else if (typeof node === "string") {
+  if (typeof node === "string") {
     return node;
   }
 
@@ -115,7 +118,7 @@ function genericPrint(path, options, print) {
 }
 
 function printPropertyLookup(path, options, print, nullsafe = false) {
-  return [nullsafe ? "?" : "", "->", path.call(print, "offset")];
+  return [nullsafe ? "?" : "", "->", print("offset")];
 }
 
 function printNullsafePropertyLookup(path, options, print) {
@@ -123,19 +126,14 @@ function printNullsafePropertyLookup(path, options, print) {
 }
 
 function printStaticLookup(path, options, print) {
-  const node = path.getValue();
+  const { node } = path;
   const needCurly = !["variable", "identifier"].includes(node.offset.kind);
 
-  return [
-    "::",
-    needCurly ? "{" : "",
-    path.call(print, "offset"),
-    needCurly ? "}" : "",
-  ];
+  return ["::", needCurly ? "{" : "", print("offset"), needCurly ? "}" : ""];
 }
 
 function printOffsetLookup(path, options, print) {
-  const node = path.getValue();
+  const { node } = path;
   const shouldInline =
     (node.offset && node.offset.kind === "number") ||
     getAncestorNode(path, "encapsed");
@@ -144,7 +142,7 @@ function printOffsetLookup(path, options, print) {
     "[",
     node.offset
       ? group([
-          indent([shouldInline ? "" : softline, path.call(print, "offset")]),
+          indent([shouldInline ? "" : softline, print("offset")]),
           shouldInline ? "" : softline,
         ])
       : "",
@@ -217,7 +215,7 @@ function printMemberChain(path, options, print) {
   }
 
   function traverse(path) {
-    const node = path.getValue();
+    const { node } = path;
 
     if (
       node.kind === "call" &&
@@ -226,7 +224,7 @@ function printMemberChain(path, options, print) {
       printedNodes.unshift({
         node,
         printed: [
-          comments.printAllComments(
+          printAllComments(
             path,
             () => printArgumentsList(path, options, print),
             options
@@ -252,22 +250,18 @@ function printMemberChain(path, options, print) {
       printedNodes.unshift({
         node,
         needsParens: pathNeedsParens(path, options),
-        printed: comments.printAllComments(
-          path,
-          () => printedMemberish,
-          options
-        ),
+        printed: printAllComments(path, () => printedMemberish, options),
       });
       path.call((what) => traverse(what), "what");
     } else {
       printedNodes.unshift({
         node,
-        printed: path.call(print),
+        printed: print(),
       });
     }
   }
 
-  const node = path.getValue();
+  const { node } = path;
 
   printedNodes.unshift({
     node,
@@ -370,7 +364,7 @@ function printMemberChain(path, options, print) {
 
     if (
       printedNodes[i].node.comments &&
-      comments.hasTrailingComment(printedNodes[i].node)
+      hasTrailingComment(printedNodes[i].node)
     ) {
       groups.push(currentGroup);
       currentGroup = [];
@@ -431,8 +425,7 @@ function printMemberChain(path, options, print) {
     );
   }
 
-  const isExpressionStatement =
-    path.getParentNode().kind === "expressionstatement";
+  const isExpressionStatement = path.parent.kind === "expressionstatement";
   const shouldMerge =
     groups.length >= 2 && !groups[1][0].node.comments && shouldNotWrap(groups);
 
@@ -484,13 +477,9 @@ function printMemberChain(path, options, print) {
   const flatGroups = groups.slice(0, cutoff).flat();
 
   const hasComment =
-    flatGroups
-      .slice(1, -1)
-      .some((node) => comments.hasLeadingComment(node.node)) ||
-    flatGroups
-      .slice(0, -1)
-      .some((node) => comments.hasTrailingComment(node.node)) ||
-    (groups[cutoff] && comments.hasLeadingComment(groups[cutoff][0].node));
+    flatGroups.slice(1, -1).some((node) => hasLeadingComment(node.node)) ||
+    flatGroups.slice(0, -1).some((node) => hasTrailingComment(node.node)) ||
+    (groups[cutoff] && hasLeadingComment(groups[cutoff][0].node));
 
   const hasEncapsedAncestor = getAncestorNode(path, "encapsed");
 
@@ -584,12 +573,12 @@ function shouldGroupFirstArg(args) {
 }
 
 function printArgumentsList(path, options, print, argumentsKey = "arguments") {
-  const args = path.getValue()[argumentsKey];
+  const args = path.node[argumentsKey];
 
   if (args.length === 0) {
     return [
       "(",
-      comments.printDanglingComments(path, options, /* sameIndent */ true),
+      printDanglingComments(path, options, /* sameIndent */ true),
       ")",
     ];
   }
@@ -597,15 +586,13 @@ function printArgumentsList(path, options, print, argumentsKey = "arguments") {
   let anyArgEmptyLine = false;
   let hasEmptyLineFollowingFirstArg = false;
 
-  const lastArgIndex = args.length - 1;
-  const printedArguments = path.map((argPath, index) => {
-    const arg = argPath.getNode();
-    const parts = [print(argPath)];
+  const printedArguments = path.map(({ node: arg, isLast, isFirst }) => {
+    const parts = [print()];
 
-    if (index === lastArgIndex) {
+    if (isLast) {
       // do nothing
     } else if (isNextLineEmpty(options.originalText, arg, options)) {
-      if (index === 0) {
+      if (isFirst) {
         hasEmptyLineFollowingFirstArg = true;
       }
 
@@ -618,7 +605,7 @@ function printArgumentsList(path, options, print, argumentsKey = "arguments") {
     return parts;
   }, argumentsKey);
 
-  const node = path.getValue();
+  const { node } = path;
   const lastArg = getLast(args);
 
   const maybeTrailingComma =
@@ -654,12 +641,11 @@ function printArgumentsList(path, options, print, argumentsKey = "arguments") {
 
     // We want to print the last argument with a special flag
     let printedExpanded;
-    let i = 0;
 
-    path.each((argPath) => {
-      if (shouldGroupFirst && i === 0) {
+    path.each(({ isLast, isFirst }) => {
+      if (shouldGroupFirst && isFirst) {
         printedExpanded = [
-          argPath.call((p) => print(p, { expandFirstArg: true })),
+          print([], { expandFirstArg: true }),
           printedArguments.length > 1 ? "," : "",
           hasEmptyLineFollowingFirstArg ? hardline : line,
           hasEmptyLineFollowingFirstArg ? hardline : "",
@@ -667,14 +653,12 @@ function printArgumentsList(path, options, print, argumentsKey = "arguments") {
         ];
       }
 
-      if (shouldGroupLast && i === args.length - 1) {
+      if (shouldGroupLast && isLast) {
         printedExpanded = [
           ...printedArguments.slice(0, -1),
-          argPath.call((p) => print(p, { expandLastArg: true })),
+          print([], { expandLastArg: true }),
         ];
       }
-
-      i++;
     }, argumentsKey);
 
     const somePrintedArgumentsWillBreak = printedArguments.some(willBreak);
@@ -756,7 +740,7 @@ function printBinaryExpression(
   isInsideParenthesis
 ) {
   let parts = [];
-  const node = path.getValue();
+  const { node } = path;
 
   if (node.kind === "bin") {
     // Put all operators with the same precedence level in the same
@@ -772,9 +756,9 @@ function printBinaryExpression(
       // Flatten them out by recursively calling this function.
       parts = parts.concat(
         path.call(
-          (left) =>
+          () =>
             printBinaryExpression(
-              left,
+              path,
               print,
               options,
               /* isNested */ true,
@@ -784,18 +768,18 @@ function printBinaryExpression(
         )
       );
     } else {
-      parts.push(path.call(print, "left"));
+      parts.push(print("left"));
     }
 
     const shouldInline = shouldInlineLogicalExpression(node);
 
     const right = shouldInline
-      ? [node.type, " ", path.call(print, "right")]
-      : [node.type, line, path.call(print, "right")];
+      ? [node.type, " ", print("right")]
+      : [node.type, line, print("right")];
 
     // If there's only a single binary expression, we want to create a group
     // in order to avoid having a small right part like -1 be on its own line.
-    const parent = path.getParentNode();
+    const { parent } = path;
     const shouldGroup =
       !(isInsideParenthesis && ["||", "&&"].includes(node.type)) &&
       getNodeKindIncludingLogical(parent) !==
@@ -818,18 +802,18 @@ function printBinaryExpression(
     // the other ones since we don't call the normal print on bin,
     // only for the left and right parts
     if (isNested && node.comments) {
-      parts = comments.printAllComments(path, () => parts, options);
+      parts = printAllComments(path, () => parts, options);
     }
   } else {
     // Our stopping case. Simply print the node normally.
-    parts.push(path.call(print));
+    parts.push(print());
   }
 
   return parts;
 }
 
 function printLookupNodes(path, options, print) {
-  const node = path.getValue();
+  const { node } = path;
 
   switch (node.kind) {
     case "propertylookup":
@@ -868,16 +852,13 @@ function printArrayItems(path, options, print) {
   const printedElements = [];
   let separatorParts = [];
 
-  path.each((childPath) => {
+  path.each(({ node }) => {
     printedElements.push(separatorParts);
-    printedElements.push(group(print(childPath)));
+    printedElements.push(group(print()));
 
     separatorParts = [",", line];
 
-    if (
-      childPath.getValue() &&
-      isNextLineEmpty(options.originalText, childPath.getValue(), options)
-    ) {
+    if (node && isNextLineEmpty(options.originalText, node, options)) {
       separatorParts.push(softline);
     }
   }, "items");
@@ -930,22 +911,26 @@ function wrapPartsIntoGroups(parts, indexes) {
 }
 
 function printLines(path, options, print, childrenAttribute = "children") {
-  const node = path.getValue();
-  const parentNode = path.getParentNode();
+  const { node, parent: parentNode } = path;
 
   let lastInlineIndex = -1;
 
   const parts = [];
   const groupIndexes = [];
 
-  path.map((childPath, index) => {
-    const childNode = childPath.getValue();
+  path.map(() => {
+    const {
+      node: childNode,
+      next: nextNode,
+      isFirst: isFirstNode,
+      isLast: isLastNode,
+      index,
+    } = path;
+
     const isInlineNode = childNode.kind === "inline";
-    const printedPath = print(childPath);
-    const children = node[childrenAttribute];
-    const nextNode = children[index + 1];
+    const printedPath = print();
     const canPrintBlankLine =
-      !isLastStatement(childPath) &&
+      !isLastStatement(path) &&
       !isInlineNode &&
       (nextNode && nextNode.kind === "case"
         ? !isFirstChildrenInlineNode(path)
@@ -960,8 +945,6 @@ function printLines(path, options, print, childrenAttribute = "children") {
         : "",
     ];
 
-    const isFirstNode = index === 0;
-    const isLastNode = children.length - 1 === index;
     const isBlockNestedNode =
       node.kind === "block" &&
       parentNode &&
@@ -986,7 +969,7 @@ function printLines(path, options, print, childrenAttribute = "children") {
           (isInlineNode ? prevLastInlineIndex : lastInlineIndex) + 1;
         const end = isLastNode && !isInlineNode ? index + 1 : index;
         const prevInlineNode =
-          children[isInlineNode ? prevLastInlineIndex : lastInlineIndex];
+          path.siblings[isInlineNode ? prevLastInlineIndex : lastInlineIndex];
         const alignment = prevInlineNode
           ? getAlignment(prevInlineNode.raw)
           : "";
@@ -1024,7 +1007,7 @@ function printLines(path, options, print, childrenAttribute = "children") {
                 ? "<?php"
                 : "",
               node.kind === "namespace" || !isBlockNestedNode ? hardline : "",
-              comments.printComments(childNode.leadingComments, options),
+              printComments(childNode.leadingComments, options),
               hardline,
               "?>",
             ]
@@ -1032,6 +1015,7 @@ function printLines(path, options, print, childrenAttribute = "children") {
           ? ""
           : [beforeCloseTagInlineNode, "?>"];
 
+      //FIXME getNode is used to get ancestors, but it seems this means to get next sibling?
       const nextV = path.getNode(index + 1);
       const skipLastComment = nextV && nextV.children && nextV.children.length;
 
@@ -1040,9 +1024,7 @@ function printLines(path, options, print, childrenAttribute = "children") {
           ? [
               openTag,
               hardline,
-              skipLastComment
-                ? comments.printComments(childNode.comments, options)
-                : "",
+              skipLastComment ? printComments(childNode.comments, options) : "",
               hardline,
             ]
           : isProgramLikeNode(node) && isLastNode
@@ -1069,7 +1051,7 @@ function printLines(path, options, print, childrenAttribute = "children") {
         between && between[2] && between[2].includes("\n")
           ? [hardline, between[2].split("\n").length > 2 ? hardline : ""]
           : " ",
-        node.comments ? comments.printComments(node.comments, options) : "",
+        node.comments ? printComments(node.comments, options) : "",
       ];
 
       const shortEcho =
@@ -1116,17 +1098,15 @@ function printLines(path, options, print, childrenAttribute = "children") {
 }
 
 function printStatements(path, options, print, childrenAttribute) {
-  return path.map((childPath) => {
+  return path.map(() => {
     const parts = [];
 
-    parts.push(print(childPath));
+    parts.push(print());
 
-    if (!isLastStatement(childPath)) {
+    if (!isLastStatement(path)) {
       parts.push(hardline);
 
-      if (
-        isNextLineEmpty(options.originalText, childPath.getValue(), options)
-      ) {
+      if (isNextLineEmpty(options.originalText, path.node, options)) {
         parts.push(hardline);
       }
     }
@@ -1143,28 +1123,25 @@ function printClassPart(
   beforePart = " ",
   afterPart = " "
 ) {
-  const node = path.getValue();
-  const printedBeforePart = hasDanglingComments(node[part])
+  const value = path.node[part];
+  const printedBeforePart = hasDanglingComments(value)
     ? [
         hardline,
-        path.call(
-          (partPath) => comments.printDanglingComments(partPath, options, true),
-          part
-        ),
+        path.call(() => printDanglingComments(path, options, true), part),
         hardline,
       ]
     : beforePart;
-  const printedPartItems = Array.isArray(node[part])
+  const printedPartItems = Array.isArray(value)
     ? group(
         join(
           ",",
-          path.map((itemPartPath) => {
-            const printedPart = print(itemPartPath);
+          path.map(({ node }) => {
+            const printedPart = print();
             // Check if any of the implements nodes have comments
-            return hasDanglingComments(itemPartPath.getValue())
+            return hasDanglingComments(node)
               ? [
                   hardline,
-                  comments.printDanglingComments(itemPartPath, options, true),
+                  printDanglingComments(path, options, true),
                   hardline,
                   printedPart,
                 ]
@@ -1172,7 +1149,7 @@ function printClassPart(
           }, part)
         )
       )
-    : [afterPart, path.call(print, part)];
+    : [afterPart, print(part)];
 
   return indent([
     printedBeforePart,
@@ -1183,23 +1160,23 @@ function printClassPart(
 
 function printAttrs(path, options, print, { inline = false } = {}) {
   const allAttrs = [];
-  if (!path.getValue().attrGroups) {
+  if (!path.node.attrGroups) {
     return [];
   }
-  path.each((agPath) => {
+  path.each(() => {
     const attrGroup = ["#["];
     if (!inline && allAttrs.length > 0) {
       allAttrs.push(hardline);
     }
     attrGroup.push(softline);
-    agPath.each((attrPath) => {
-      const attrNode = attrPath.getValue();
+    path.each(() => {
+      const attrNode = path.node;
       if (attrGroup.length > 2) {
         attrGroup.push(",", line);
       }
       const attrStmt = [attrNode.name];
       if (attrNode.args.length > 0) {
-        attrStmt.push(printArgumentsList(attrPath, options, print, "args"));
+        attrStmt.push(printArgumentsList(path, options, print, "args"));
       }
       attrGroup.push(group(attrStmt));
     }, "attrs");
@@ -1220,7 +1197,7 @@ function printAttrs(path, options, print, { inline = false } = {}) {
 }
 
 function printClass(path, options, print) {
-  const node = path.getValue();
+  const { node } = path;
   const isAnonymousClass = node.kind === "class" && node.isAnonymous;
   const attrs = printAttrs(path, options, print, { inline: isAnonymousClass });
   const declaration = isAnonymousClass ? [] : [...attrs];
@@ -1241,11 +1218,11 @@ function printClass(path, options, print) {
   declaration.push(isAnonymousClass ? "" : node.kind);
 
   if (node.name) {
-    declaration.push(" ", path.call(print, "name"));
+    declaration.push(" ", print("name"));
   }
 
   if (node.kind === "enum" && node.valueType) {
-    declaration.push(": ", path.call(print, "valueType"));
+    declaration.push(": ", print("valueType"));
   }
 
   // Only `class` can have `extends` and `implements`
@@ -1331,7 +1308,7 @@ function printClass(path, options, print) {
       hasEmptyClassBody ? "" : hardline,
       printStatements(path, options, print, "body"),
     ]),
-    comments.printDanglingComments(path, options, true),
+    printDanglingComments(path, options, true),
     isAnonymousClass && hasEmptyClassBody ? softline : hardline,
     "}",
   ];
@@ -1340,7 +1317,7 @@ function printClass(path, options, print) {
 }
 
 function printFunction(path, options, print) {
-  const node = path.getValue();
+  const { node } = path;
   const declAttrs = printAttrs(path, options, print, {
     inline: node.kind === "closure",
   });
@@ -1369,7 +1346,7 @@ function printFunction(path, options, print) {
   }
 
   if (node.name) {
-    declaration.push(path.call(print, "name"));
+    declaration.push(print("name"));
   }
 
   declaration.push(printArgumentsList(path, options, print));
@@ -1385,16 +1362,12 @@ function printFunction(path, options, print) {
       ": ",
       hasDanglingComments(node.type)
         ? [
-            path.call(
-              (typePath) =>
-                comments.printDanglingComments(typePath, options, true),
-              "type"
-            ),
+            path.call(() => printDanglingComments(path, options, true), "type"),
             " ",
           ]
         : "",
       node.nullable ? "?" : "",
-      path.call(print, "type"),
+      print("type"),
     ]);
   }
 
@@ -1407,7 +1380,7 @@ function printFunction(path, options, print) {
   const isClosure = node.kind === "closure";
   const printedBody = [
     "{",
-    indent([hasEmptyBody(path) ? "" : hardline, path.call(print, "body")]),
+    indent([hasEmptyBody(path) ? "" : hardline, print("body")]),
     isClosure && hasEmptyBody(path) ? "" : hardline,
     "}",
   ];
@@ -1450,13 +1423,13 @@ function printBodyControlStructure(
   print,
   bodyProperty = "body"
 ) {
-  const node = path.getValue();
+  const { node } = path;
 
   if (!node[bodyProperty]) {
     return ";";
   }
 
-  const printedBody = path.call(print, bodyProperty);
+  const printedBody = print(bodyProperty);
 
   return [
     node.shortForm ? ":" : " {",
@@ -1529,9 +1502,7 @@ function printAssignmentRight(
 ) {
   const ref = hasRef ? "&" : "";
 
-  if (
-    comments.hasLeadingOwnLineComment(options.originalText, rightNode, options)
-  ) {
+  if (hasLeadingOwnLineComment(options.originalText, rightNode, options)) {
     return indent([hardline, ref, printedRight]);
   }
 
@@ -1567,7 +1538,7 @@ function needsHardlineAfterDanglingComment(node) {
     node.comments.filter((comment) => !comment.leading && !comment.trailing)
   );
 
-  return lastDanglingComment && !comments.isBlockComment(lastDanglingComment);
+  return lastDanglingComment && !isBlockComment(lastDanglingComment);
 }
 
 function stringHasNewLines(node) {
@@ -1586,21 +1557,18 @@ function isStringOnItsOwnLine(node, text, options) {
 
 function printComposedTypes(path, print, glue) {
   return group(
-    path.map(
-      (uPath, i) => (i === 0 ? [path.call(print)] : [glue, path.call(print)]),
-      "types"
-    )
+    path.map(({ isFirst }) => (isFirst ? [print()] : [glue, print()]), "types")
   );
 }
 
 function printNode(path, options, print) {
-  const node = path.getValue();
+  const { node } = path;
 
   switch (node.kind) {
     case "program": {
       return group([
         printLines(path, options, print),
-        comments.printDanglingComments(
+        printDanglingComments(
           path,
           options,
           /* sameIndent */ true,
@@ -1609,18 +1577,15 @@ function printNode(path, options, print) {
       ]);
     }
     case "expressionstatement":
-      return path.call(print, "expression");
+      return print("expression");
     case "block":
       return [
         printLines(path, options, print),
-        comments.printDanglingComments(path, options, true),
+        printDanglingComments(path, options, true),
       ];
     case "declare": {
       const printDeclareArguments = (path) => {
-        return join(
-          ", ",
-          path.map((directive) => print(directive), "directives")
-        );
+        return join(", ", path.map(print, "directives"));
       };
 
       if (["block", "short"].includes(node.mode)) {
@@ -1632,7 +1597,7 @@ function printNode(path, options, print) {
           node.children.length > 0
             ? indent([hardline, printLines(path, options, print)])
             : "",
-          comments.printDanglingComments(path, options),
+          printDanglingComments(path, options),
           hardline,
           node.mode === "block" ? "}" : "enddeclare;",
         ];
@@ -1648,7 +1613,7 @@ function printNode(path, options, print) {
       ];
     }
     case "declaredirective":
-      return [path.call(print, "key"), "=", path.call(print, "value")];
+      return [print("key"), "=", print("value")];
     case "namespace":
       return [
         "namespace ",
@@ -1657,7 +1622,7 @@ function printNode(path, options, print) {
           : "",
         node.withBrackets ? "{" : ";",
         hasDanglingComments(node)
-          ? [" ", comments.printDanglingComments(path, options, true)]
+          ? [" ", printDanglingComments(path, options, true)]
           : "",
         node.children.length > 0
           ? node.withBrackets
@@ -1688,10 +1653,7 @@ function printNode(path, options, print) {
           node.name
             ? [maybeStripLeadingSlashFromUse(node.name), "\\{", softline]
             : "",
-          join(
-            [",", line],
-            path.map((item) => print(item), "items")
-          ),
+          join([",", line], path.map(print, "items")),
         ]),
         node.name
           ? [
@@ -1706,9 +1668,9 @@ function printNode(path, options, print) {
         node.type ? [node.type, " "] : "",
         maybeStripLeadingSlashFromUse(node.name),
         hasDanglingComments(node)
-          ? [" ", comments.printDanglingComments(path, options, true)]
+          ? [" ", printDanglingComments(path, options, true)]
           : "",
-        node.alias ? [" as ", path.call(print, "alias")] : "",
+        node.alias ? [" as ", print("alias")] : "",
       ];
     case "class":
     case "enum":
@@ -1717,20 +1679,20 @@ function printNode(path, options, print) {
       return printClass(path, options, print);
     case "traitprecedence":
       return [
-        path.call(print, "trait"),
+        print("trait"),
         "::",
-        path.call(print, "method"),
+        print("method"),
         " insteadof ",
         join(", ", path.map(print, "instead")),
       ];
     case "traitalias":
       return [
-        node.trait ? [path.call(print, "trait"), "::"] : "",
-        node.method ? path.call(print, "method") : "",
+        node.trait ? [print("trait"), "::"] : "",
+        node.method ? print("method") : "",
         " as ",
         join(" ", [
           ...(node.visibility ? [node.visibility] : []),
-          ...(node.as ? [path.call(print, "as")] : []),
+          ...(node.as ? [print("as")] : []),
         ]),
       ];
     case "traituse":
@@ -1749,11 +1711,7 @@ function printNode(path, options, print) {
                     hardline,
                   ]
                 : hasDanglingComments(node)
-                ? [
-                    line,
-                    comments.printDanglingComments(path, options, true),
-                    line,
-                  ]
+                ? [line, printDanglingComments(path, options, true), line]
                 : "",
               "}",
             ]
@@ -1770,11 +1728,9 @@ function printNode(path, options, print) {
         node.isStatic ? "static " : "",
         "fn",
         printArgumentsList(path, options, print),
-        node.type
-          ? [": ", node.nullable ? "?" : "", path.call(print, "type")]
-          : "",
+        node.type ? [": ", node.nullable ? "?" : "", print("type")] : "",
         " => ",
-        path.call(print, "body"),
+        print("body"),
         node.parenthesizedExpression ? ")" : "",
       ];
     case "parameter": {
@@ -1791,11 +1747,11 @@ function printNode(path, options, print) {
         promoted,
         node.readonly ? "readonly " : "",
         node.nullable ? "?" : "",
-        node.type ? [path.call(print, "type"), " "] : "",
+        node.type ? [print("type"), " "] : "",
         node.byref ? "&" : "",
         node.variadic ? "..." : "",
         "$",
-        path.call(print, "name"),
+        print("name"),
       ];
 
       if (node.value) {
@@ -1805,12 +1761,12 @@ function printNode(path, options, print) {
           // no node to attach comments that fall in between the parameter name
           // and value, we store them as dangling comments
           hasDanglingComments(node) ? " " : "",
-          comments.printDanglingComments(path, options, true),
+          printDanglingComments(path, options, true),
           " =",
           printAssignmentRight(
             node.name,
             node.value,
-            path.call(print, "value"),
+            print("value"),
             false,
             options
           ),
@@ -1820,22 +1776,20 @@ function printNode(path, options, print) {
       return name;
     }
     case "variadic":
-      return ["...", path.call(print, "what")];
+      return ["...", print("what")];
     case "property":
       return group([
         node.readonly ? "readonly " : "",
-        node.type
-          ? [node.nullable ? "?" : "", path.call(print, "type"), " "]
-          : "",
+        node.type ? [node.nullable ? "?" : "", print("type"), " "] : "",
         "$",
-        path.call(print, "name"),
+        print("name"),
         node.value
           ? [
               " =",
               printAssignmentRight(
                 node.name,
                 node.value,
-                path.call(print, "value"),
+                print("value"),
                 false,
                 options
               ),
@@ -1844,13 +1798,10 @@ function printNode(path, options, print) {
       ]);
     case "propertystatement": {
       const attrs = [];
-      path.map(
-        (propPath) => attrs.push(...printAttrs(propPath, options, print)),
-        "properties"
-      );
-      const printed = path.map((childPath) => {
-        return print(childPath);
+      path.each(() => {
+        attrs.push(...printAttrs(path, options, print));
       }, "properties");
+      const printed = path.map(print, "properties");
 
       const hasValue = node.properties.some((property) => property.value);
 
@@ -1882,7 +1833,7 @@ function printNode(path, options, print) {
       const body = printBodyControlStructure(path, options, print, "body");
       const opening = group([
         "if (",
-        group([indent([softline, path.call(print, "test")]), softline]),
+        group([indent([softline, print("test")]), softline]),
         ")",
         body,
       ]);
@@ -1898,7 +1849,7 @@ function printNode(path, options, print) {
         const commentOnOwnLine =
           (hasTrailingComment(node.body) &&
             node.body.comments.some(
-              (comment) => comment.trailing && !comments.isBlockComment(comment)
+              (comment) => comment.trailing && !isBlockComment(comment)
             )) ||
           needsHardlineAfterDanglingComment(node);
         const elseOnSameLine = !commentOnOwnLine;
@@ -1909,7 +1860,7 @@ function printNode(path, options, print) {
             isNextLineEmpty(options.originalText, node.body, options)
               ? hardline
               : "",
-            comments.printDanglingComments(path, options, true),
+            printDanglingComments(path, options, true),
             commentOnOwnLine ? hardline : " "
           );
         }
@@ -1918,7 +1869,7 @@ function printNode(path, options, print) {
           "else",
           group(
             node.alternate.kind === "if"
-              ? path.call(print, "alternate")
+              ? print("alternate")
               : printBodyControlStructure(path, options, print, "alternate")
           )
         );
@@ -1933,7 +1884,7 @@ function printNode(path, options, print) {
         "do",
         printBodyControlStructure(path, options, print, "body"),
         " while (",
-        group([indent([softline, path.call(print, "test")]), softline]),
+        group([indent([softline, print("test")]), softline]),
         ")",
       ];
     case "while":
@@ -1941,7 +1892,7 @@ function printNode(path, options, print) {
       return group([
         node.kind,
         " (",
-        group([indent([softline, path.call(print, "test")]), softline]),
+        group([indent([softline, print("test")]), softline]),
         ")",
         printBodyControlStructure(path, options, print, "body"),
       ]);
@@ -1951,7 +1902,7 @@ function printNode(path, options, print) {
       // We want to keep dangling comments above the loop to stay consistent.
       // Any comment positioned between the for statement and the parentheses
       // is going to be printed before the statement.
-      const dangling = comments.printDanglingComments(
+      const dangling = printDanglingComments(
         path,
         options,
         /* sameLine */ true
@@ -1990,7 +1941,7 @@ function printNode(path, options, print) {
       // We want to keep dangling comments above the loop to stay consistent.
       // Any comment positioned between the for statement and the parentheses
       // is going to be printed before the statement.
-      const dangling = comments.printDanglingComments(
+      const dangling = printDanglingComments(
         path,
         options,
         /* sameLine */ true
@@ -2004,18 +1955,13 @@ function printNode(path, options, print) {
           group([
             indent([
               softline,
-              path.call(print, "source"),
+              print("source"),
               line,
               "as ",
               group(
                 node.key
-                  ? indent(
-                      join(
-                        [" =>", line],
-                        [path.call(print, "key"), path.call(print, "value")]
-                      )
-                    )
-                  : path.call(print, "value")
+                  ? indent(join([" =>", line], [print("key"), print("value")]))
+                  : print("value")
               ),
             ]),
             softline,
@@ -2053,7 +1999,7 @@ function printNode(path, options, print) {
           ? [
               " (",
               join(" | ", path.map(print, "what")),
-              node.variable ? [" ", path.call(print, "variable")] : "",
+              node.variable ? [" ", print("variable")] : "",
               ")",
             ]
           : "",
@@ -2065,9 +2011,7 @@ function printNode(path, options, print) {
         node.test
           ? [
               "case ",
-              node.test.comments
-                ? indent(path.call(print, "test"))
-                : path.call(print, "test"),
+              node.test.comments ? indent(print("test")) : print("test"),
               ":",
             ]
           : "default:",
@@ -2075,7 +2019,7 @@ function printNode(path, options, print) {
           ? node.body.children && node.body.children.length
             ? indent([
                 isFirstChildrenInlineNode(path) ? "" : hardline,
-                path.call(print, "body"),
+                print("body"),
               ])
             : ""
           : "",
@@ -2084,7 +2028,7 @@ function printNode(path, options, print) {
     case "continue":
       if (node.level) {
         if (node.level.kind === "number" && node.level.value !== "1") {
-          return [`${node.kind} `, path.call(print, "level")];
+          return [`${node.kind} `, print("level")];
         }
 
         return node.kind;
@@ -2098,7 +2042,7 @@ function printNode(path, options, print) {
         isStringOnItsOwnLine(node.arguments[0], options.originalText, options)
       ) {
         return [
-          path.call(print, "what"),
+          print("what"),
           "(",
           join(", ", path.map(print, "arguments")),
           ")",
@@ -2110,10 +2054,7 @@ function printNode(path, options, print) {
         return printMemberChain(path, options, print);
       }
 
-      return [
-        path.call(print, "what"),
-        printArgumentsList(path, options, print),
-      ];
+      return [print("what"), printArgumentsList(path, options, print)];
     }
     case "new": {
       const isAnonymousClassNode =
@@ -2128,7 +2069,7 @@ function printNode(path, options, print) {
         return [
           "new ",
           ...path.call(printAttrs, "what"),
-          path.call(print, "what"),
+          print("what"),
           "(",
           join(", ", path.map(print, "arguments")),
           ")",
@@ -2143,23 +2084,23 @@ function printNode(path, options, print) {
         parts.push(
           node.what.leadingComments &&
             node.what.leadingComments[0].kind === "commentblock"
-            ? [comments.printComments(node.what.leadingComments, options), " "]
+            ? [printComments(node.what.leadingComments, options), " "]
             : "",
           ...path.call(
-            (pa) => printAttrs(pa, options, print, { inline: true }),
+            () => printAttrs(path, options, print, { inline: true }),
             "what"
           ),
           "class",
           node.arguments.length > 0
             ? [" ", printArgumentsList(path, options, print)]
             : "",
-          group(path.call(print, "what"))
+          group(print("what"))
         );
       } else {
         const isExpression = ["call", "offsetlookup"].includes(node.what.kind);
         const printed = [
           isExpression ? "(" : "",
-          path.call(print, "what"),
+          print("what"),
           isExpression ? ")" : "",
           printArgumentsList(path, options, print),
         ];
@@ -2172,19 +2113,17 @@ function printNode(path, options, print) {
     case "clone":
       return [
         "clone ",
-        node.what.comments
-          ? indent(path.call(print, "what"))
-          : path.call(print, "what"),
+        node.what.comments ? indent(print("what")) : print("what"),
       ];
     case "propertylookup":
     case "nullsafepropertylookup":
     case "staticlookup":
     case "offsetlookup": {
-      const parent = path.getParentNode();
+      const { parent } = path;
 
+      // TODO: Use `AstPath.findAncestor` when it's stable
       let firstNonMemberParent;
       let i = 0;
-
       do {
         firstNonMemberParent = path.getParentNode(i);
         i++;
@@ -2206,7 +2145,7 @@ function printNode(path, options, print) {
           !isLookupNode(parent));
 
       return [
-        path.call(print, "what"),
+        print("what"),
         shouldInline
           ? printLookupNodes(path, options, print)
           : group(indent([softline, printLookupNodes(path, options, print)])),
@@ -2218,9 +2157,9 @@ function printNode(path, options, print) {
         "(",
         node.expression
           ? isStringOnItsOwnLine(node.expression, options.originalText, options)
-            ? path.call(print, "expression")
-            : [indent([softline, path.call(print, "expression")]), softline]
-          : comments.printDanglingComments(path, options),
+            ? print("expression")
+            : [indent([softline, print("expression")]), softline]
+          : printDanglingComments(path, options),
         ")",
       ]);
     case "global":
@@ -2233,32 +2172,24 @@ function printNode(path, options, print) {
         node.require ? "require" : "include",
         node.once ? "_once" : "",
         " ",
-        node.target.comments
-          ? indent(path.call(print, "target"))
-          : path.call(print, "target"),
+        node.target.comments ? indent(print("target")) : print("target"),
       ];
     case "label":
-      return [path.call(print, "name"), ":"];
+      return [print("name"), ":"];
     case "goto":
-      return ["goto ", path.call(print, "label")];
+      return ["goto ", print("label")];
     case "throw":
       return [
         "throw ",
-        node.what.comments
-          ? indent(path.call(print, "what"))
-          : path.call(print, "what"),
+        node.what.comments ? indent(print("what")) : print("what"),
       ];
     case "silent":
-      return ["@", path.call(print, "expr")];
+      return ["@", print("expr")];
     case "halt":
       return [
         hasDanglingComments(node)
           ? [
-              comments.printDanglingComments(
-                path,
-                options,
-                /* sameIndent */ true
-              ),
+              printDanglingComments(path, options, /* sameIndent */ true),
               hardline,
             ]
           : "",
@@ -2269,14 +2200,12 @@ function printNode(path, options, print) {
       return group([
         "eval(",
         isStringOnItsOwnLine(node.source, options.originalText, options)
-          ? path.call(print, "source")
-          : [indent([softline, path.call(print, "source")]), softline],
+          ? print("source")
+          : [indent([softline, print("source")]), softline],
         ")",
       ]);
     case "echo": {
-      const printedArguments = path.map((childPath) => {
-        return print(childPath);
-      }, "expressions");
+      const printedArguments = path.map(print, "expressions");
 
       let firstVariable;
 
@@ -2299,8 +2228,8 @@ function printNode(path, options, print) {
       return [
         "print ",
         node.expression.comments
-          ? indent(path.call(print, "expression"))
-          : path.call(print, "expression"),
+          ? indent(print("expression"))
+          : print("expression"),
       ];
     }
     case "return": {
@@ -2309,7 +2238,7 @@ function printNode(path, options, print) {
       parts.push("return");
 
       if (node.expr) {
-        const printedExpr = path.call(print, "expr");
+        const printedExpr = print("expr");
 
         parts.push(" ", node.expr.comments ? indent(printedExpr) : printedExpr);
       }
@@ -2317,7 +2246,7 @@ function printNode(path, options, print) {
       if (hasDanglingComments(node)) {
         parts.push(
           " ",
-          comments.printDanglingComments(path, options, /* sameIndent */ true)
+          printDanglingComments(path, options, /* sameIndent */ true)
         );
       }
 
@@ -2332,13 +2261,12 @@ function printNode(path, options, print) {
     case "empty":
       return group([
         "empty(",
-        indent([softline, path.call(print, "expression")]),
+        indent([softline, print("expression")]),
         softline,
         ")",
       ]);
     case "variable": {
-      const parent = path.getParentNode();
-      const parentParent = path.getParentNode(1);
+      const { parent, grandparent: parentParent } = path;
       const ampersand = parent.kind === "assign" ? "" : node.byref ? "&" : "";
       const dollar =
         (parent.kind === "encapsedpart" &&
@@ -2354,18 +2282,12 @@ function printNode(path, options, print) {
       const openCurly = node.curly ? "{" : "";
       const closeCurly = node.curly ? "}" : "";
 
-      return [
-        ampersand,
-        dollar,
-        openCurly,
-        path.call(print, "name"),
-        closeCurly,
-      ];
+      return [ampersand, dollar, openCurly, print("name"), closeCurly];
     }
     case "constantstatement":
     case "classconstant": {
       const attrs = printAttrs(path, options, print);
-      const printed = path.map((childPath) => print(childPath), "constants");
+      const printed = path.map(print, "constants");
 
       let firstVariable;
 
@@ -2388,17 +2310,15 @@ function printNode(path, options, print) {
     case "constant":
       return printAssignment(
         node.name,
-        path.call(print, "name"),
+        print("name"),
         " =",
         node.value,
-        path.call(print, "value"),
+        print("value"),
         false,
         options
       );
     case "static": {
-      const printed = path.map((childPath) => {
-        return print(childPath);
-      }, "variables");
+      const printed = path.map(print, "variables");
 
       const hasValue = node.variables.some((item) => item.defaultValue);
 
@@ -2422,10 +2342,10 @@ function printNode(path, options, print) {
     case "staticvariable": {
       return printAssignment(
         node.variable,
-        path.call(print, "variable"),
+        print("variable"),
         " =",
         node.defaultValue,
-        path.call(print, "defaultValue"),
+        print("defaultValue"),
         false,
         options
       );
@@ -2446,7 +2366,7 @@ function printNode(path, options, print) {
 
         return group([
           open,
-          comments.printDanglingComments(path, options),
+          printDanglingComments(path, options),
           softline,
           close,
         ]);
@@ -2494,7 +2414,7 @@ function printNode(path, options, print) {
                 ]
               : ""
           ),
-          comments.printDanglingComments(path, options, true),
+          printDanglingComments(path, options, true),
           softline,
           close,
         ],
@@ -2507,19 +2427,19 @@ function printNode(path, options, print) {
       return node.key
         ? printAssignment(
             node.key,
-            path.call(print, "key"),
+            print("key"),
             " =>",
             node.value,
-            path.call(print, "value"),
+            print("value"),
             ref,
             options
           )
-        : [ref, unpack, path.call(print, "value")];
+        : [ref, unpack, print("value")];
     }
     case "yield": {
       const printedKeyAndValue = [
-        node.key ? [path.call(print, "key"), " => "] : "",
-        path.call(print, "value"),
+        node.key ? [print("key"), " => "] : "",
+        print("value"),
       ];
 
       return [
@@ -2533,24 +2453,20 @@ function printNode(path, options, print) {
     case "yieldfrom":
       return [
         "yield from ",
-        node.value.comments
-          ? indent(path.call(print, "value"))
-          : path.call(print, "value"),
+        node.value.comments ? indent(print("value")) : print("value"),
       ];
     case "unary":
-      return [node.type, path.call(print, "what")];
+      return [node.type, print("what")];
     case "pre":
-      return [node.type + node.type, path.call(print, "what")];
+      return [node.type + node.type, print("what")];
     case "post":
-      return [path.call(print, "what"), node.type + node.type];
+      return [print("what"), node.type + node.type];
     case "cast":
       return [
         "(",
         node.type,
         ") ",
-        node.expr.comments
-          ? indent(path.call(print, "expr"))
-          : path.call(print, "expr"),
+        node.expr.comments ? indent(print("expr")) : print("expr"),
       ];
     case "assignref":
     case "assign": {
@@ -2558,17 +2474,16 @@ function printNode(path, options, print) {
 
       return printAssignment(
         node.left,
-        path.call(print, "left"),
+        print("left"),
         [" ", hasRef ? "=" : node.operator],
         node.right,
-        path.call(print, "right"),
+        print("right"),
         hasRef,
         options
       );
     }
     case "bin": {
-      const parent = path.getParentNode();
-      const parentParent = path.getParentNode(1);
+      const { parent, grandparent: parentParent } = path;
       const isInsideParenthesis =
         node !== parent.body &&
         (parent.kind === "if" ||
@@ -2651,8 +2566,9 @@ function printNode(path, options, print) {
     }
     case "retif": {
       const parts = [];
-      const parent = path.getParentNode();
+      const { parent } = path;
 
+      // TODO: Use `AstPath.findAncestor` when it's stable
       // Find the outermost non-retif parent, and the outermost retif parent.
       let currentParent;
       let i = 0;
@@ -2665,8 +2581,8 @@ function printNode(path, options, print) {
 
       const printedFalseExpr =
         node.falseExpr.kind === "bin"
-          ? indent(path.call(print, "falseExpr"))
-          : path.call(print, "falseExpr");
+          ? indent(print("falseExpr"))
+          : print("falseExpr");
       const part = [
         node.trueExpr ? line : " ",
         "?",
@@ -2674,8 +2590,8 @@ function printNode(path, options, print) {
           ? [
               " ",
               node.trueExpr.kind === "bin"
-                ? indent(path.call(print, "trueExpr"))
-                : path.call(print, "trueExpr"),
+                ? indent(print("trueExpr"))
+                : print("trueExpr"),
               line,
             ]
           : "",
@@ -2699,7 +2615,7 @@ function printNode(path, options, print) {
       //   ? $b
       //   : $c
       // )->call()
-      const parentParent = path.getParentNode(1);
+      const parentParent = path.grandparent;
       const pureParent =
         parent.kind === "cast" && parentParent ? parentParent : parent;
       const breakLookupNodes = [
@@ -2709,7 +2625,7 @@ function printNode(path, options, print) {
       ];
       const breakClosingParens = breakLookupNodes.includes(pureParent.kind);
 
-      const printedTest = path.call(print, "test");
+      const printedTest = print("test");
 
       if (!node.trueExpr) {
         const printed = [
@@ -2751,10 +2667,10 @@ function printNode(path, options, print) {
     case "number":
       return printNumber(node.value);
     case "string": {
-      const parent = path.getParentNode();
+      const { parent } = path;
 
       if (parent.kind === "encapsedpart") {
-        const parentParent = path.getParentNode(1);
+        const parentParent = path.grandparent;
         let closingTagIndentation = 0;
         const flexible = isMinVersion(options.phpVersion, "7.3");
         let linebreak = literalline;
@@ -2818,7 +2734,7 @@ function printNode(path, options, print) {
           ? "}"
           : "";
 
-      return [open, path.call(print, "expression"), close];
+      return [open, print("expression"), close];
     }
     case "encapsed":
       switch (node.type) {
@@ -2866,7 +2782,7 @@ function printNode(path, options, print) {
     case "name":
       return [node.resolution === "rn" ? "namespace\\" : "", node.name];
     case "literal":
-      return path.call(print, "value");
+      return print("value");
     case "parentreference":
       return "parent";
     case "selfreference":
@@ -2878,28 +2794,27 @@ function printNode(path, options, print) {
     case "nullkeyword":
       return "null";
     case "identifier": {
-      const parent = path.getParentNode();
+      const { parent } = path;
 
       if (parent.kind === "method") {
         node.name = normalizeMagicMethodName(node.name);
       }
 
-      return path.call(print, "name");
+      return print("name");
     }
     case "match": {
-      const lastArmIndex = node.arms.length - 1;
-      const arms = path.map((armPath, armIdx) => {
-        const armNode = armPath.getValue();
+      const arms = path.map(() => {
+        const armNode = path.node;
 
-        const maybeLeadingComment = comments.hasLeadingComment(armNode)
-          ? [comments.printComments(armNode.leadingComments, options), hardline]
+        const maybeLeadingComment = hasLeadingComment(armNode)
+          ? [printComments(armNode.leadingComments, options), hardline]
           : [];
         const maybeTrailingComma =
-          armIdx < lastArmIndex || options.trailingCommaPHP ? "," : "";
-        const maybeTrailingComment = comments.hasTrailingComment(armNode)
+          !path.isLast || options.trailingCommaPHP ? "," : "";
+        const maybeTrailingComment = hasTrailingComment(armNode)
           ? [
               " ",
-              comments.printComments(
+              printComments(
                 armNode.comments.filter((c) => c.trailing),
                 options
               ),
@@ -2909,14 +2824,13 @@ function printNode(path, options, print) {
         const conds =
           armNode.conds === null
             ? "default"
-            : armPath.map(
-                (condPath, condIdx) =>
-                  [",", line, print(condPath)].slice(condIdx === 0 ? 2 : 0),
+            : path.map(
+                ({ isFirst }) => [",", line, print()].slice(isFirst ? 2 : 0),
                 "conds"
               );
-        const body = armPath.call(print, "body");
+        const body = print("body");
         const maybeEmptyLineBetweenArms =
-          armIdx > 0 &&
+          !path.isFirst &&
           isPreviousLineEmpty(options.originalText, armNode, options)
             ? hardline
             : "";
@@ -2933,11 +2847,11 @@ function printNode(path, options, print) {
             maybeTrailingComma,
             ...maybeTrailingComment,
           ]),
-        ].slice(armIdx > 0 ? 0 : 1);
+        ].slice(!path.isFirst ? 0 : 1);
       }, "arms");
       return group([
         "match (",
-        group([softline, indent(path.call(print, "cond")), softline]),
+        group([softline, indent(print("cond")), softline]),
         ") {",
         group(indent([...arms])),
         " ",
@@ -2947,23 +2861,21 @@ function printNode(path, options, print) {
     }
 
     case "noop":
-      return node.comments
-        ? comments.printComments(path.getValue().comments, options)
-        : "";
+      return node.comments ? printComments(node.comments, options) : "";
     case "namedargument":
-      return [node.name, ": ", path.call(print, "value")];
+      return [node.name, ": ", print("value")];
 
     case "enumcase":
       return group([
         "case ",
-        path.call(print, "name"),
+        print("name"),
         node.value
           ? [
               " =",
               printAssignmentRight(
                 node.name,
                 node.value,
-                path.call(print, "value"),
+                print("value"),
                 false,
                 options
               ),
@@ -2980,4 +2892,4 @@ function printNode(path, options, print) {
   }
 }
 
-module.exports = genericPrint;
+export default genericPrint;