@prettier/plugin-php 0.20.1 → 0.21.0

package/src/printer.js

@@ -1,23 +1,4 @@
 import { util as prettierUtil, doc } from "prettier";
-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 } =
-  prettierUtil;
 import {
   printAllComments,
   hasTrailingComment,
@@ -28,11 +9,11 @@ import {
   hasLeadingOwnLineComment,
 } from "./comments.js";
 import pathNeedsParens from "./needs-parens.js";
+import { locStart, locEnd } from "./loc.js";
 
 import {
   getLast,
   getPenultimate,
-  isLastStatement,
   lineShouldEndWithSemicolon,
   printNumber,
   shouldFlatten,
@@ -54,12 +35,34 @@ import {
   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,
-} from "./util.js";
+} = prettierUtil;
 
 function isMinVersion(actualVersion, requiredVersion) {
   return parseFloat(actualVersion) >= parseFloat(requiredVersion);
@@ -196,8 +199,7 @@ function printMemberChain(path, options, print) {
     const { originalText } = options;
     const nextCharIndex = getNextNonSpaceNonCommentCharacterIndex(
       originalText,
-      node,
-      options
+      locEnd(node)
     );
     const nextChar = originalText.charAt(nextCharIndex);
 
@@ -211,7 +213,7 @@ function printMemberChain(path, options, print) {
       );
     }
 
-    return isNextLineEmpty(originalText, node, options);
+    return isNextLineEmpty(originalText, locEnd(node));
   }
 
   function traverse(path) {
@@ -591,7 +593,7 @@ function printArgumentsList(path, options, print, argumentsKey = "arguments") {
 
     if (isLast) {
       // do nothing
-    } else if (isNextLineEmpty(options.originalText, arg, options)) {
+    } else if (isNextLineEmpty(options.originalText, locEnd(arg))) {
       if (isFirst) {
         hasEmptyLineFollowingFirstArg = true;
       }
@@ -824,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.`);
   }
 }
 
@@ -844,8 +846,8 @@ 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) {
@@ -858,7 +860,7 @@ function printArrayItems(path, options, print) {
 
     separatorParts = [",", line];
 
-    if (node && isNextLineEmpty(options.originalText, node, options)) {
+    if (node && isNextLineEmpty(options.originalText, locEnd(node))) {
       separatorParts.push(softline);
     }
   }, "items");
@@ -930,7 +932,7 @@ function printLines(path, options, print, childrenAttribute = "children") {
     const isInlineNode = childNode.kind === "inline";
     const printedPath = print();
     const canPrintBlankLine =
-      !isLastStatement(path) &&
+      !isLastNode &&
       !isInlineNode &&
       (nextNode && nextNode.kind === "case"
         ? !isFirstChildrenInlineNode(path)
@@ -940,7 +942,7 @@ function printLines(path, options, print, childrenAttribute = "children") {
       printedPath,
       canPrintBlankLine ? hardline : "",
       canPrintBlankLine &&
-      isNextLineEmpty(options.originalText, childNode, options)
+      isNextLineEmpty(options.originalText, locEnd(childNode))
         ? hardline
         : "",
     ];
@@ -1069,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" &&
@@ -1080,7 +1082,7 @@ function printLines(path, options, print, childrenAttribute = "children") {
                 ? hardline
                 : ""
               : " ",
-            isNextLineEmpty(options.originalText, lastNode, options)
+            isNextLineEmpty(options.originalText, locEnd(lastNode))
               ? hardline
               : "",
           ]
@@ -1098,15 +1100,15 @@ function printLines(path, options, print, childrenAttribute = "children") {
 }
 
 function printStatements(path, options, print, childrenAttribute) {
-  return path.map(() => {
+  return path.map(({ node, isLast }) => {
     const parts = [];
 
     parts.push(print());
 
-    if (!isLastStatement(path)) {
+    if (!isLast) {
       parts.push(hardline);
 
-      if (isNextLineEmpty(options.originalText, path.node, options)) {
+      if (isNextLineEmpty(options.originalText, locEnd(node))) {
         parts.push(hardline);
       }
     }
@@ -1502,7 +1504,7 @@ function printAssignmentRight(
 ) {
   const ref = hasRef ? "&" : "";
 
-  if (hasLeadingOwnLineComment(options.originalText, rightNode, options)) {
+  if (hasLeadingOwnLineComment(options.originalText, rightNode)) {
     return indent([hardline, ref, printedRight]);
   }
 
@@ -1545,13 +1547,13 @@ 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 })
   );
 }
 
@@ -1603,13 +1605,11 @@ function printNode(path, options, print) {
         ];
       }
 
-      const nextNode = getNextNode(path, node);
-
       return [
         "declare(",
         printDeclareArguments(path),
         ")",
-        nextNode && nextNode.kind === "inline" ? "" : ";",
+        path.next?.kind === "inline" ? "" : ";",
       ];
     }
     case "declaredirective":
@@ -1632,11 +1632,7 @@ function printNode(path, options, print) {
                   ? ""
                   : [
                       hardline,
-                      isNextLineEmptyAfterNamespace(
-                        options.originalText,
-                        node,
-                        options.locStart
-                      )
+                      isNextLineEmptyAfterNamespace(options.originalText, node)
                         ? hardline
                         : "",
                     ],
@@ -1857,7 +1853,7 @@ function printNode(path, options, print) {
 
         if (hasDanglingComments(node)) {
           parts.push(
-            isNextLineEmpty(options.originalText, node.body, options)
+            isNextLineEmpty(options.originalText, locEnd(node.body))
               ? hardline
               : "",
             printDanglingComments(path, options, true),
@@ -2039,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"),
@@ -2064,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 ",
@@ -2156,7 +2152,7 @@ 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]
           : printDanglingComments(path, options),
@@ -2199,7 +2195,7 @@ 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],
         ")",
@@ -2388,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(
@@ -2754,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(
@@ -2831,7 +2827,7 @@ function printNode(path, options, print) {
         const body = print("body");
         const maybeEmptyLineBetweenArms =
           !path.isFirst &&
-          isPreviousLineEmpty(options.originalText, armNode, options)
+          isPreviousLineEmpty(options.originalText, locStart(armNode))
             ? hardline
             : "";
 
@@ -2851,7 +2847,7 @@ function printNode(path, options, print) {
       }, "arms");
       return group([
         "match (",
-        group([softline, indent(print("cond")), softline]),
+        group([indent([softline, print("cond")]), softline]),
         ") {",
         group(indent([...arms])),
         " ",
@@ -2885,10 +2881,10 @@ 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.`);
   }
 }
 

package/src/util.js

@@ -1,38 +1,7 @@
-import { util as prettierUtil, version as prettierVersion } from "prettier";
-
-const {
-  hasNewline,
-  skipEverythingButNewLine,
-  skipNewline,
-  isNextLineEmpty: _isNextLineEmpty,
-  isPreviousLineEmpty: _isPreviousLineEmpty,
-  getNextNonSpaceNonCommentCharacterIndex:
-    _getNextNonSpaceNonCommentCharacterIndex,
-} = prettierUtil;
-
-function lookupIfPrettier2(options, prop) {
-  return parseInt(prettierVersion[0]) > 1 ? options[prop] : options;
-}
-
-function isPreviousLineEmpty(text, node, options) {
-  return _isPreviousLineEmpty(
-    text,
-    node,
-    lookupIfPrettier2(options, "locStart")
-  );
-}
+import { util as prettierUtil } from "prettier";
+import { locStart } from "./loc.js";
 
-function isNextLineEmpty(text, node, options) {
-  return _isNextLineEmpty(text, node, lookupIfPrettier2(options, "locEnd"));
-}
-
-function getNextNonSpaceNonCommentCharacterIndex(text, node, options) {
-  return _getNextNonSpaceNonCommentCharacterIndex(
-    text,
-    node,
-    lookupIfPrettier2(options, "locEnd")
-  );
-}
+const { hasNewline, skipEverythingButNewLine, skipNewline } = prettierUtil;
 
 function printNumber(rawNumber) {
   return (
@@ -52,49 +21,47 @@ function printNumber(rawNumber) {
 }
 
 // http://php.net/manual/en/language.operators.precedence.php
-const PRECEDENCE = {};
-[
-  ["or"],
-  ["xor"],
-  ["and"],
+const PRECEDENCE = new Map(
   [
-    "=",
-    "+=",
-    "-=",
-    "*=",
-    "**=",
-    "/=",
-    ".=",
-    "%=",
-    "&=",
-    "|=",
-    "^=",
-    "<<=",
-    ">>=",
-  ],
-  ["??"],
-  ["||"],
-  ["&&"],
-  ["|"],
-  ["^"],
-  ["&"],
-  ["==", "===", "!=", "!==", "<>", "<=>"],
-  ["<", ">", "<=", ">="],
-  [">>", "<<"],
-  ["+", "-", "."],
-  ["*", "/", "%"],
-  ["!"],
-  ["instanceof"],
-  ["++", "--", "~"],
-  ["**"],
-].forEach((tier, i) => {
-  tier.forEach((op) => {
-    PRECEDENCE[op] = i;
-  });
-});
-
-function getPrecedence(op) {
-  return PRECEDENCE[op];
+    ["or"],
+    ["xor"],
+    ["and"],
+    [
+      "=",
+      "+=",
+      "-=",
+      "*=",
+      "**=",
+      "/=",
+      ".=",
+      "%=",
+      "&=",
+      "|=",
+      "^=",
+      "<<=",
+      ">>=",
+    ],
+    ["??"],
+    ["||"],
+    ["&&"],
+    ["|"],
+    ["^"],
+    ["&"],
+    ["==", "===", "!=", "!==", "<>", "<=>"],
+    ["<", ">", "<=", ">="],
+    [">>", "<<"],
+    ["+", "-", "."],
+    ["*", "/", "%"],
+    ["!"],
+    ["instanceof"],
+    ["++", "--", "~"],
+    ["**"],
+  ].flatMap((operators, index) =>
+    operators.map((operator) => [operator, index])
+  )
+);
+function getPrecedence(operator) {
+  return PRECEDENCE.get(operator);
 }
 
 const equalityOperators = ["==", "!=", "===", "!==", "<>", "<=>"];
@@ -187,14 +154,6 @@ function getNodeListProperty(node) {
   return Array.isArray(body) ? body : null;
 }
 
-function getParentNodeListProperty(path) {
-  const { parent } = path;
-  if (!parent) {
-    return null;
-  }
-  return getNodeListProperty(parent);
-}
-
 function getLast(arr) {
   if (arr.length > 0) {
     return arr[arr.length - 1];
@@ -209,15 +168,6 @@ function getPenultimate(arr) {
   return null;
 }
 
-function isLastStatement(path) {
-  const body = getParentNodeListProperty(path);
-  if (!body) {
-    return true;
-  }
-  const { node } = path;
-  return body[body.length - 1] === node;
-}
-
 function isFirstChildrenInlineNode(path) {
   const { node } = path;
 
@@ -532,23 +482,6 @@ function getAlignment(text) {
   return lastLine.length - lastLine.trimLeft().length + 1;
 }
 
-function getNextNode(path, node) {
-  const { parent } = path;
-  const children = getNodeListProperty(parent);
-
-  if (!children) {
-    return null;
-  }
-
-  const index = children.indexOf(node);
-
-  if (index === -1) {
-    return null;
-  }
-
-  return parent.children[index + 1];
-}
-
 function isProgramLikeNode(node) {
   return ["program", "declare", "namespace"].includes(node.kind);
 }
@@ -605,7 +538,7 @@ function hasEmptyBody(path, name = "body") {
   );
 }
 
-function isNextLineEmptyAfterNamespace(text, node, locStart) {
+function isNextLineEmptyAfterNamespace(text, node) {
   let idx = locStart(node);
   idx = skipEverythingButNewLine(text, idx);
   idx = skipNewline(text, idx);
@@ -665,17 +598,15 @@ const magicMethods = [
   "__clone",
   "__debugInfo",
 ];
-const MagicMethodsMap = magicMethods.reduce((map, obj) => {
-  map[obj.toLowerCase()] = obj;
-
-  return map;
-}, {});
+const magicMethodsMap = new Map(
+  magicMethods.map((name) => [name.toLowerCase(), name])
+);
 
 function normalizeMagicMethodName(name) {
   const loweredName = name.toLowerCase();
 
-  if (MagicMethodsMap[loweredName]) {
-    return MagicMethodsMap[loweredName];
+  if (magicMethodsMap.has(loweredName)) {
+    return magicMethodsMap.get(loweredName);
   }
 
   return name;
@@ -687,11 +618,8 @@ export {
   isBitwiseOperator,
   shouldFlatten,
   nodeHasStatement,
-  getNodeListProperty,
-  getParentNodeListProperty,
   getLast,
   getPenultimate,
-  isLastStatement,
   getBodyFirstChild,
   lineShouldEndWithSemicolon,
   fileShouldEndWithHardline,
@@ -712,9 +640,5 @@ export {
   shouldPrintHardlineBeforeTrailingComma,
   isDocNode,
   getAncestorNode,
-  getNextNode,
   normalizeMagicMethodName,
-  isPreviousLineEmpty,
-  isNextLineEmpty,
-  getNextNonSpaceNonCommentCharacterIndex,
 };