@prettier/plugin-php 0.20.0 → 0.21.0

package/src/printer.js

@@ -1,39 +1,25 @@
-"use strict";
-
-const {
-  breakParent,
-  join,
-  line,
-  lineSuffix,
-  group,
-  conditionalGroup,
-  indent,
-  dedent,
-  ifBreak,
-  hardline,
-  softline,
-  literalline,
-  align,
-  dedentToRoot,
-} = require("prettier").doc.builders;
-const { willBreak } = require("prettier").doc.utils;
-const { isNextLineEmptyAfterIndex, hasNewline, hasNewlineInRange } =
-  require("prettier").util;
-const comments = require("./comments");
-const pathNeedsParens = require("./needs-parens");
-
-const {
+import { util as prettierUtil, doc } from "prettier";
+import {
+  printAllComments,
+  hasTrailingComment,
+  hasLeadingComment,
+  printDanglingComments,
+  printComments,
+  isBlockComment,
+  hasLeadingOwnLineComment,
+} from "./comments.js";
+import pathNeedsParens from "./needs-parens.js";
+import { locStart, locEnd } from "./loc.js";
+
+import {
   getLast,
   getPenultimate,
-  isLastStatement,
   lineShouldEndWithSemicolon,
   printNumber,
   shouldFlatten,
   maybeStripLeadingSlashFromUse,
   fileShouldEndWithHardline,
   hasDanglingComments,
-  hasLeadingComment,
-  hasTrailingComment,
   docShouldHaveTrailingNewline,
   isLookupNode,
   isFirstChildrenInlineNode,
@@ -49,12 +35,34 @@ const {
   isDocNode,
   getAncestorNode,
   isReferenceLikeNode,
-  getNextNode,
   normalizeMagicMethodName,
+} from "./util.js";
+
+const {
+  breakParent,
+  join,
+  line,
+  lineSuffix,
+  group,
+  conditionalGroup,
+  indent,
+  dedent,
+  ifBreak,
+  hardline,
+  softline,
+  literalline,
+  align,
+  dedentToRoot,
+} = doc.builders;
+const { willBreak } = doc.utils;
+const {
+  isNextLineEmptyAfterIndex,
+  hasNewline,
+  hasNewlineInRange,
   getNextNonSpaceNonCommentCharacterIndex,
   isNextLineEmpty,
   isPreviousLineEmpty,
-} = require("./util");
+} = prettierUtil;
 
 function isMinVersion(actualVersion, requiredVersion) {
   return parseFloat(actualVersion) >= parseFloat(requiredVersion);
@@ -80,11 +88,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 +129,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");
@@ -193,8 +199,7 @@ function printMemberChain(path, options, print) {
     const { originalText } = options;
     const nextCharIndex = getNextNonSpaceNonCommentCharacterIndex(
       originalText,
-      node,
-      options
+      locEnd(node)
     );
     const nextChar = originalText.charAt(nextCharIndex);
 
@@ -208,11 +213,11 @@ function printMemberChain(path, options, print) {
       );
     }
 
-    return isNextLineEmpty(originalText, node, options);
+    return isNextLineEmpty(originalText, locEnd(node));
   }
 
   function traverse(path) {
-    const node = path.getValue();
+    const { node } = path;
 
     if (
       node.kind === "call" &&
@@ -221,7 +226,7 @@ function printMemberChain(path, options, print) {
       printedNodes.unshift({
         node,
         printed: [
-          comments.printAllComments(
+          printAllComments(
             path,
             () => printArgumentsList(path, options, print),
             options
@@ -247,11 +252,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 +263,7 @@ function printMemberChain(path, options, print) {
     }
   }
 
-  const node = path.getValue();
+  const { node } = path;
 
   printedNodes.unshift({
     node,
@@ -365,7 +366,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 +427,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 +479,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 +575,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 +588,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) {
+    } else if (isNextLineEmpty(options.originalText, locEnd(arg))) {
+      if (isFirst) {
         hasEmptyLineFollowingFirstArg = true;
       }
 
@@ -613,7 +607,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 +643,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 +655,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 +742,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 +781,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 +804,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 +815,7 @@ function printBinaryExpression(
 }
 
 function printLookupNodes(path, options, print) {
-  const node = path.getValue();
+  const { node } = path;
 
   switch (node.kind) {
     case "propertylookup":
@@ -835,9 +826,9 @@ function printLookupNodes(path, options, print) {
       return printStaticLookup(path, options, print);
     case "offsetlookup":
       return printOffsetLookup(path, options, print);
-    /* istanbul ignore next */
+    /* c8 ignore next 2 */
     default:
-      return `Have not implemented lookup kind ${node.kind} yet.`;
+      throw new Error(`Have not implemented lookup kind ${node.kind} yet.`);
   }
 }
 
@@ -855,24 +846,21 @@ function getEncapsedQuotes(node, { opening = true } = {}) {
     return quotes[node.type];
   }
 
-  /* istanbul ignore next */
-  return `Unimplemented encapsed type ${node.type}`;
+  /* c8 ignore next */
+  throw new Error(`Unimplemented encapsed type ${node.type}`);
 }
 
 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, locEnd(node))) {
       separatorParts.push(softline);
     }
   }, "items");
@@ -925,22 +913,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) &&
+      !isLastNode &&
       !isInlineNode &&
       (nextNode && nextNode.kind === "case"
         ? !isFirstChildrenInlineNode(path)
@@ -950,13 +942,11 @@ function printLines(path, options, print, childrenAttribute = "children") {
       printedPath,
       canPrintBlankLine ? hardline : "",
       canPrintBlankLine &&
-      isNextLineEmpty(options.originalText, childNode, options)
+      isNextLineEmpty(options.originalText, locEnd(childNode))
         ? hardline
         : "",
     ];
 
-    const isFirstNode = index === 0;
-    const isLastNode = children.length - 1 === index;
     const isBlockNestedNode =
       node.kind === "block" &&
       parentNode &&
@@ -981,7 +971,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 +1009,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 +1017,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 +1026,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 +1053,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 =
@@ -1082,8 +1071,8 @@ function printLines(path, options, print, childrenAttribute = "children") {
         ? [
             hasNewlineInRange(
               options.originalText.trimEnd(),
-              options.locEnd(lastNode),
-              options.locEnd(node)
+              locEnd(lastNode),
+              locEnd(node)
             )
               ? !(
                   lastNode.kind === "inline" &&
@@ -1093,7 +1082,7 @@ function printLines(path, options, print, childrenAttribute = "children") {
                 ? hardline
                 : ""
               : " ",
-            isNextLineEmpty(options.originalText, lastNode, options)
+            isNextLineEmpty(options.originalText, locEnd(lastNode))
               ? hardline
               : "",
           ]
@@ -1111,17 +1100,15 @@ function printLines(path, options, print, childrenAttribute = "children") {
 }
 
 function printStatements(path, options, print, childrenAttribute) {
-  return path.map((childPath) => {
+  return path.map(({ node, isLast }) => {
     const parts = [];
 
-    parts.push(print(childPath));
+    parts.push(print());
 
-    if (!isLastStatement(childPath)) {
+    if (!isLast) {
       parts.push(hardline);
 
-      if (
-        isNextLineEmpty(options.originalText, childPath.getValue(), options)
-      ) {
+      if (isNextLineEmpty(options.originalText, locEnd(node))) {
         parts.push(hardline);
       }
     }
@@ -1138,28 +1125,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 +1162,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 +1199,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 +1310,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 +1319,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 +1364,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 +1425,7 @@ function printBodyControlStructure(
   print,
   bodyProperty = "body"
 ) {
-  const node = path.getValue();
+  const { node } = path;
 
   if (!node[bodyProperty]) {
     return ";";
@@ -1523,9 +1504,7 @@ function printAssignmentRight(
 ) {
   const ref = hasRef ? "&" : "";
 
-  if (
-    comments.hasLeadingOwnLineComment(options.originalText, rightNode, options)
-  ) {
+  if (hasLeadingOwnLineComment(options.originalText, rightNode)) {
     return indent([hardline, ref, printedRight]);
   }
 
@@ -1561,37 +1540,37 @@ function needsHardlineAfterDanglingComment(node) {
     node.comments.filter((comment) => !comment.leading && !comment.trailing)
   );
 
-  return lastDanglingComment && !comments.isBlockComment(lastDanglingComment);
+  return lastDanglingComment && !isBlockComment(lastDanglingComment);
 }
 
 function stringHasNewLines(node) {
   return node.raw.includes("\n");
 }
 
-function isStringOnItsOwnLine(node, text, options) {
+function isStringOnItsOwnLine(node, text) {
   return (
     (node.kind === "string" ||
       (node.kind === "encapsed" &&
         (node.type === "string" || node.type === "shell"))) &&
     stringHasNewLines(node) &&
-    !hasNewline(text, options.locStart(node), { backwards: true })
+    !hasNewline(text, locStart(node), { backwards: true })
   );
 }
 
 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 +1583,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,19 +1599,17 @@ 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;",
         ];
       }
 
-      const nextNode = getNextNode(path, node);
-
       return [
         "declare(",
         printDeclareArguments(path),
         ")",
-        nextNode && nextNode.kind === "inline" ? "" : ";",
+        path.next?.kind === "inline" ? "" : ";",
       ];
     }
     case "declaredirective":
@@ -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
@@ -1658,11 +1632,7 @@ function printNode(path, options, print) {
                   ? ""
                   : [
                       hardline,
-                      isNextLineEmptyAfterNamespace(
-                        options.originalText,
-                        node,
-                        options.locStart
-                      )
+                      isNextLineEmptyAfterNamespace(options.originalText, node)
                         ? hardline
                         : "",
                     ],
@@ -1679,10 +1649,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 +1664,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 +1707,7 @@ function printNode(path, options, print) {
                     hardline,
                   ]
                 : hasDanglingComments(node)
-                ? [
-                    line,
-                    comments.printDanglingComments(path, options, true),
-                    line,
-                  ]
+                ? [line, printDanglingComments(path, options, true), line]
                 : "",
               "}",
             ]
@@ -1794,7 +1757,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 +1794,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 +1845,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;
@@ -1893,10 +1853,10 @@ function printNode(path, options, print) {
 
         if (hasDanglingComments(node)) {
           parts.push(
-            isNextLineEmpty(options.originalText, node.body, options)
+            isNextLineEmpty(options.originalText, locEnd(node.body))
               ? hardline
               : "",
-            comments.printDanglingComments(path, options, true),
+            printDanglingComments(path, options, true),
             commentOnOwnLine ? hardline : " "
           );
         }
@@ -1938,7 +1898,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 +1937,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
@@ -2075,7 +2035,7 @@ function printNode(path, options, print) {
       // Multiline strings as single arguments
       if (
         node.arguments.length === 1 &&
-        isStringOnItsOwnLine(node.arguments[0], options.originalText, options)
+        isStringOnItsOwnLine(node.arguments[0], options.originalText)
       ) {
         return [
           print("what"),
@@ -2100,7 +2060,7 @@ function printNode(path, options, print) {
       if (
         !isAnonymousClassNode &&
         node.arguments.length === 1 &&
-        isStringOnItsOwnLine(node.arguments[0], options.originalText, options)
+        isStringOnItsOwnLine(node.arguments[0], options.originalText)
       ) {
         return [
           "new ",
@@ -2120,7 +2080,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 +2115,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++;
@@ -2192,10 +2152,10 @@ function printNode(path, options, print) {
         node.useDie ? "die" : "exit",
         "(",
         node.expression
-          ? isStringOnItsOwnLine(node.expression, options.originalText, options)
+          ? isStringOnItsOwnLine(node.expression, options.originalText)
             ? print("expression")
             : [indent([softline, print("expression")]), softline]
-          : comments.printDanglingComments(path, options),
+          : printDanglingComments(path, options),
         ")",
       ]);
     case "global":
@@ -2225,11 +2185,7 @@ function printNode(path, options, print) {
       return [
         hasDanglingComments(node)
           ? [
-              comments.printDanglingComments(
-                path,
-                options,
-                /* sameIndent */ true
-              ),
+              printDanglingComments(path, options, /* sameIndent */ true),
               hardline,
             ]
           : "",
@@ -2239,15 +2195,13 @@ function printNode(path, options, print) {
     case "eval":
       return group([
         "eval(",
-        isStringOnItsOwnLine(node.source, options.originalText, options)
+        isStringOnItsOwnLine(node.source, options.originalText)
           ? 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;
 
@@ -2288,7 +2242,7 @@ function printNode(path, options, print) {
       if (hasDanglingComments(node)) {
         parts.push(
           " ",
-          comments.printDanglingComments(path, options, /* sameIndent */ true)
+          printDanglingComments(path, options, /* sameIndent */ true)
         );
       }
 
@@ -2308,8 +2262,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 +2283,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 +2314,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 +2362,7 @@ function printNode(path, options, print) {
 
         return group([
           open,
-          comments.printDanglingComments(path, options),
+          printDanglingComments(path, options),
           softline,
           close,
         ]);
@@ -2433,15 +2384,15 @@ function printNode(path, options, print) {
 
       const [firstProperty] = node.items
         .filter((node) => node.kind !== "noop")
-        .sort((a, b) => options.locStart(a) - options.locStart(b));
+        .sort((a, b) => locStart(a) - locStart(b));
       const isAssociative = !!(firstProperty && firstProperty.key);
       const shouldBreak =
         isAssociative &&
         firstProperty &&
         hasNewlineInRange(
           options.originalText,
-          options.locStart(node),
-          options.locStart(firstProperty)
+          locStart(node),
+          locStart(firstProperty)
         );
 
       return group(
@@ -2459,7 +2410,7 @@ function printNode(path, options, print) {
                 ]
               : ""
           ),
-          comments.printDanglingComments(path, options, true),
+          printDanglingComments(path, options, true),
           softline,
           close,
         ],
@@ -2528,8 +2479,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 +2562,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 +2611,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 +2663,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;
@@ -2799,9 +2750,9 @@ function printNode(path, options, print) {
               : "",
           ];
         }
-        // istanbul ignore next
+        /* c8 ignore next 2 */
         default:
-          return `Have not implemented kind ${node.type} yet.`;
+          throw new Error(`Have not implemented kind ${node.type} yet.`);
       }
     case "inline":
       return join(
@@ -2839,7 +2790,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 +2799,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,15 +2820,14 @@ 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 &&
-          isPreviousLineEmpty(options.originalText, armNode, options)
+          !path.isFirst &&
+          isPreviousLineEmpty(options.originalText, locStart(armNode))
             ? hardline
             : "";
 
@@ -2894,11 +2843,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(print("cond")), softline]),
+        group([indent([softline, print("cond")]), softline]),
         ") {",
         group(indent([...arms])),
         " ",
@@ -2908,9 +2857,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")];
 
@@ -2934,11 +2881,11 @@ function printNode(path, options, print) {
     case "variadicplaceholder":
       return "...";
 
+    /* c8 ignore next 3 */
     case "error":
     default:
-      // istanbul ignore next
-      return `Have not implemented kind ${node.kind} yet.`;
+      throw new Error(`Have not implemented kind '${node.kind}' yet.`);
   }
 }
 
-module.exports = genericPrint;
+export default genericPrint;