@prettier/plugin-php 0.20.0 → 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;
   }
 
@@ -123,14 +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 ? "{" : "", 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");
@@ -212,7 +215,7 @@ function printMemberChain(path, options, print) {
   }
 
   function traverse(path) {
-    const node = path.getValue();
+    const { node } = path;
 
     if (
       node.kind === "call" &&
@@ -221,7 +224,7 @@ function printMemberChain(path, options, print) {
       printedNodes.unshift({
         node,
         printed: [
-          comments.printAllComments(
+          printAllComments(
             path,
             () => printArgumentsList(path, options, print),
             options
@@ -247,11 +250,7 @@ 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 {
@@ -262,7 +261,7 @@ function printMemberChain(path, options, print) {
     }
   }
 
-  const node = path.getValue();
+  const { node } = path;
 
   printedNodes.unshift({
     node,
@@ -365,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 = [];
@@ -426,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);
 
@@ -479,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");
 
@@ -579,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),
       ")",
     ];
   }
@@ -592,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;
       }
 
@@ -613,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 =
@@ -649,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(() => print([], { expandFirstArg: true })),
+          print([], { expandFirstArg: true }),
           printedArguments.length > 1 ? "," : "",
           hasEmptyLineFollowingFirstArg ? hardline : line,
           hasEmptyLineFollowingFirstArg ? hardline : "",
@@ -662,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(() => print([], { expandLastArg: true })),
+          print([], { expandLastArg: true }),
         ];
       }
-
-      i++;
     }, argumentsKey);
 
     const somePrintedArgumentsWillBreak = printedArguments.some(willBreak);
@@ -751,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
@@ -790,7 +779,7 @@ function printBinaryExpression(
 
     // 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) !==
@@ -813,7 +802,7 @@ 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.
@@ -824,7 +813,7 @@ function printBinaryExpression(
 }
 
 function printLookupNodes(path, options, print) {
-  const node = path.getValue();
+  const { node } = path;
 
   switch (node.kind) {
     case "propertylookup":
@@ -863,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");
@@ -925,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)
@@ -955,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 &&
@@ -981,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)
           : "";
@@ -1019,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,
               "?>",
             ]
@@ -1027,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;
 
@@ -1035,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
@@ -1064,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 =
@@ -1111,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);
       }
     }
@@ -1138,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(
-          () => comments.printDanglingComments(path, 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,
                 ]
@@ -1178,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");
@@ -1215,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];
@@ -1326,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,
     "}",
   ];
@@ -1335,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",
   });
@@ -1380,10 +1362,7 @@ function printFunction(path, options, print) {
       ": ",
       hasDanglingComments(node.type)
         ? [
-            path.call(
-              () => comments.printDanglingComments(path, options, true),
-              "type"
-            ),
+            path.call(() => printDanglingComments(path, options, true), "type"),
             " ",
           ]
         : "",
@@ -1444,7 +1423,7 @@ function printBodyControlStructure(
   print,
   bodyProperty = "body"
 ) {
-  const node = path.getValue();
+  const { node } = path;
 
   if (!node[bodyProperty]) {
     return ";";
@@ -1523,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]);
   }
 
@@ -1561,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) {
@@ -1580,18 +1557,18 @@ function isStringOnItsOwnLine(node, text, options) {
 
 function printComposedTypes(path, print, glue) {
   return group(
-    path.map((uPath, i) => (i === 0 ? [print()] : [glue, 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,
@@ -1604,14 +1581,11 @@ function printNode(path, options, print) {
     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)) {
@@ -1623,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 +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
@@ -1679,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
           ? [
@@ -1697,7 +1668,7 @@ 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 ", print("alias")] : "",
       ];
@@ -1740,11 +1711,7 @@ function printNode(path, options, print) {
                     hardline,
                   ]
                 : hasDanglingComments(node)
-                ? [
-                    line,
-                    comments.printDanglingComments(path, options, true),
-                    line,
-                  ]
+                ? [line, printDanglingComments(path, options, true), line]
                 : "",
               "}",
             ]
@@ -1794,7 +1761,7 @@ 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,
@@ -1831,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);
 
@@ -1885,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;
@@ -1896,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 : " "
           );
         }
@@ -1938,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
@@ -1977,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
@@ -2120,7 +2084,7 @@ 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(
             () => printAttrs(path, options, print, { inline: true }),
@@ -2155,11 +2119,11 @@ function printNode(path, options, print) {
     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++;
@@ -2195,7 +2159,7 @@ function printNode(path, options, print) {
           ? isStringOnItsOwnLine(node.expression, options.originalText, options)
             ? print("expression")
             : [indent([softline, print("expression")]), softline]
-          : comments.printDanglingComments(path, options),
+          : printDanglingComments(path, options),
         ")",
       ]);
     case "global":
@@ -2225,11 +2189,7 @@ function printNode(path, options, print) {
       return [
         hasDanglingComments(node)
           ? [
-              comments.printDanglingComments(
-                path,
-                options,
-                /* sameIndent */ true
-              ),
+              printDanglingComments(path, options, /* sameIndent */ true),
               hardline,
             ]
           : "",
@@ -2245,9 +2205,7 @@ function printNode(path, options, print) {
         ")",
       ]);
     case "echo": {
-      const printedArguments = path.map((childPath) => {
-        return print(childPath);
-      }, "expressions");
+      const printedArguments = path.map(print, "expressions");
 
       let firstVariable;
 
@@ -2288,7 +2246,7 @@ function printNode(path, options, print) {
       if (hasDanglingComments(node)) {
         parts.push(
           " ",
-          comments.printDanglingComments(path, options, /* sameIndent */ true)
+          printDanglingComments(path, options, /* sameIndent */ true)
         );
       }
 
@@ -2308,8 +2266,7 @@ function printNode(path, options, print) {
         ")",
       ]);
     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" &&
@@ -2330,7 +2287,7 @@ function printNode(path, options, print) {
     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;
 
@@ -2361,9 +2318,7 @@ function printNode(path, options, print) {
         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);
 
@@ -2411,7 +2366,7 @@ function printNode(path, options, print) {
 
         return group([
           open,
-          comments.printDanglingComments(path, options),
+          printDanglingComments(path, options),
           softline,
           close,
         ]);
@@ -2459,7 +2414,7 @@ function printNode(path, options, print) {
                 ]
               : ""
           ),
-          comments.printDanglingComments(path, options, true),
+          printDanglingComments(path, options, true),
           softline,
           close,
         ],
@@ -2528,8 +2483,7 @@ function printNode(path, options, print) {
       );
     }
     case "bin": {
-      const parent = path.getParentNode();
-      const parentParent = path.getParentNode(1);
+      const { parent, grandparent: parentParent } = path;
       const isInsideParenthesis =
         node !== parent.body &&
         (parent.kind === "if" ||
@@ -2612,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;
@@ -2660,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 = [
@@ -2712,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;
@@ -2839,7 +2794,7 @@ 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);
@@ -2848,19 +2803,18 @@ function printNode(path, options, print) {
       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
               ),
@@ -2870,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 = print("body");
         const maybeEmptyLineBetweenArms =
-          armIdx > 0 &&
+          !path.isFirst &&
           isPreviousLineEmpty(options.originalText, armNode, options)
             ? hardline
             : "";
@@ -2894,7 +2847,7 @@ function printNode(path, options, print) {
             maybeTrailingComma,
             ...maybeTrailingComment,
           ]),
-        ].slice(armIdx > 0 ? 0 : 1);
+        ].slice(!path.isFirst ? 0 : 1);
       }, "arms");
       return group([
         "match (",
@@ -2908,9 +2861,7 @@ 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, ": ", print("value")];
 
@@ -2941,4 +2892,4 @@ function printNode(path, options, print) {
   }
 }
 
-module.exports = genericPrint;
+export default genericPrint;