@prettier/plugin-php 0.24.0 → 0.26.0

package/README.md

@@ -198,7 +198,7 @@ supported PHP version.
 You set the `phpVersion` to `composer` and this will only use the `composer.json` file to determine the php
 version, prettier will crash if the PHP cannot be determined.
 
-You can also set the `phpVersion` to a specific version, such as `7.4`, `8.0`, `8.1`, `8.2`, or `8.3`.
+You can also set the `phpVersion` to a specific version, such as `7.4`, `8.0`, `8.1`, `8.2`, `8.3` or `8.4`.
 
 **Please Note:** If the phpVersion is not set correctly for your environment, this plugin will produce code that could
 be incompatible with your PHP runtime. For example, if you are using PHP 7.4, but the plugin is set to PHP 8.3, it will

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-php",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "Prettier PHP Plugin",
   "repository": "prettier/prettier-php",
   "author": "Lucas Azzola <@azz>",
@@ -26,33 +26,33 @@
     "index.d.ts"
   ],
   "dependencies": {
-    "linguist-languages": "^8.0.0",
-    "php-parser": "^3.2.5"
+    "linguist-languages": "^9.4.0",
+    "php-parser": "^3.7.0"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.27.2",
-    "@rollup/plugin-alias": "^5.1.0",
-    "@rollup/plugin-babel": "^6.0.3",
-    "@rollup/plugin-commonjs": "^25.0.7",
+    "@rollup/plugin-alias": "^6.0.0",
+    "@rollup/plugin-babel": "^7.0.0",
+    "@rollup/plugin-commonjs": "^29.0.2",
     "@rollup/plugin-inject": "^5.0.5",
     "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.1",
-    "@rollup/plugin-replace": "^5.0.5",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-terser": "^0.4.3",
     "c8": "^10.1.3",
-    "cross-env": "^7.0.2",
+    "cross-env": "^10.1.0",
     "eslint": "8.57.0",
-    "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-import": "2.29.1",
-    "eslint-plugin-jest": "27.6.3",
-    "eslint-plugin-prettier": "5.1.3",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-import": "2.32.0",
+    "eslint-plugin-jest": "29.15.4",
+    "eslint-plugin-prettier": "5.5.5",
     "eslint-plugin-prettier-doc": "^1.1.0",
-    "jest": "30.0.3",
-    "jest-environment-jsdom": "30.0.2",
+    "jest": "30.3.0",
+    "jest-environment-jsdom": "30.3.0",
     "jest-light-runner": "^0.7.9",
     "jest-snapshot-serializer-raw": "^2.0.0",
     "prettier": "^3.6.1",
-    "rollup": "^3.28.1",
+    "rollup": "^4.60.0",
     "strip-ansi": "^7.1.0"
   },
   "peerDependencies": {

package/src/clean.mjs

@@ -101,6 +101,17 @@ function clean(node, newObj) {
     newObj.name.name = normalizeMagicMethodName(newObj.name.name);
   }
 
+  // #[A, B] -> #[A] #[B]: the printer gives an attribute whose arguments
+  // break a block of its own (PER-CS 12.3), which is the same declaration.
+  if (Array.isArray(node.attrGroups) && node.attrGroups.length > 1) {
+    newObj.attrGroups = [
+      {
+        ...newObj.attrGroups[0],
+        attrs: newObj.attrGroups.flatMap((attrGroup) => attrGroup.attrs),
+      },
+    ];
+  }
+
   if (node.kind === "noop") {
     return null;
   }

package/src/comments.mjs

@@ -62,6 +62,7 @@ function handleOwnLineComment(comment, text, options) {
       options
     ) ||
     handleTryComments(enclosingNode, followingNode, comment) ||
+    handleClassMemberStatementComments(enclosingNode, followingNode, comment) ||
     handleClassComments(enclosingNode, followingNode, comment) ||
     handleFunctionParameter(
       text,
@@ -201,6 +202,7 @@ function handleRemainingComment(comment, text, options) {
     handleGoto(enclosingNode, comment) ||
     handleHalt(precedingNode, enclosingNode, followingNode, comment) ||
     handleBreakAndContinueStatementComments(enclosingNode, comment) ||
+    handleClassMemberStatementComments(enclosingNode, followingNode, comment) ||
     handleInlineComments(
       enclosingNode,
       precedingNode,
@@ -433,6 +435,32 @@ function handleTraitUseComments(enclosingNode, followingNode, comment) {
   return false;
 }
 
+function handleClassMemberStatementComments(
+  enclosingNode,
+  followingNode,
+  comment
+) {
+  if (
+    enclosingNode &&
+    enclosingNode.kind === "propertystatement" &&
+    enclosingNode.properties?.includes(followingNode)
+  ) {
+    addLeadingComment(enclosingNode, comment);
+    return true;
+  }
+
+  if (
+    enclosingNode &&
+    enclosingNode.kind === "classconstant" &&
+    enclosingNode.constants?.includes(followingNode)
+  ) {
+    addLeadingComment(enclosingNode, comment);
+    return true;
+  }
+
+  return false;
+}
+
 function handleClassComments(enclosingNode, followingNode, comment) {
   if (
     enclosingNode &&
@@ -564,8 +592,8 @@ function handleFunctionParameter(
     return false;
   }
   if (
-    precedingNode.kind === "typereference" &&
-    followingNode.kind === "identifier"
+    precedingNode?.kind === "typereference" &&
+    followingNode?.kind === "identifier"
   ) {
     addTrailingComment(precedingNode, comment);
     return true;
@@ -907,6 +935,29 @@ function getCommentChildNodes(node) {
     node.what.__parent_new_arguments = [...node.arguments];
     return [node.what];
   }
+
+  if (node.attrGroups && node.attrGroups.length > 0) {
+    if (node.kind === "method" || node.kind === "function") {
+      // Keep every child (in source order): dropping `body` makes comments
+      // inside the body resolve against the return type, dropping `name`
+      // makes a comment after the attribute look like it precedes the body.
+      return [
+        ...node.attrGroups,
+        ...(node.name && typeof node.name === "object" ? [node.name] : []),
+        ...node.arguments,
+        ...(node.type ? [node.type] : []),
+        ...(node.body ? [node.body] : []),
+      ];
+    }
+
+    if (node.kind === "classconstant") {
+      return [...node.attrGroups, ...node.constants];
+    }
+
+    if (node.kind === "enumcase") {
+      return node.attrGroups;
+    }
+  }
 }
 
 function canAttachComment(node) {

package/src/needs-parens.mjs

@@ -142,7 +142,8 @@ function needsParens(path, options) {
           return false;
       }
     }
-    case "yield": {
+    case "yield":
+    case "yieldfrom": {
       switch (parent.kind) {
         case "propertylookup":
         case "nullsafepropertylookup":
@@ -154,8 +155,11 @@ function needsParens(path, options) {
         case "retif":
           return key === "test";
 
+        case "assign":
+          return node.kind === "yield" && !!(node.key || node.value);
+
         default:
-          return !!(node.key || node.value);
+          return node.kind === "yieldfrom" || !!(node.key || node.value);
       }
     }
     case "assign": {
@@ -166,7 +170,7 @@ function needsParens(path, options) {
         return false;
       } else if (parent.kind === "assign") {
         return false;
-      } else if (parent.kind === "static") {
+      } else if (parent.kind === "staticvariable") {
         return false;
       } else if (
         ["if", "do", "while", "foreach", "switch"].includes(parent.kind)
@@ -188,7 +192,12 @@ function needsParens(path, options) {
         case "bin":
         case "retif":
           if (key === "test" && !parent.trueExpr) {
-            return false;
+            // A full ternary in the test position of a shorthand ternary
+            // (`?:`) needs parens: `1 ? 2 : 3 ?: 4` is a syntax error in
+            // PHP 8. Shorthand ternaries chain left-associatively, so they
+            // don't need parens here.
+            // https://github.com/prettier/plugin-php/issues/2115
+            return !!node.trueExpr;
           }
 
           return true;
@@ -215,7 +224,7 @@ function needsParens(path, options) {
         default:
           return false;
       }
-    case "silence":
+    case "silent":
     case "cast":
       // TODO: bug https://github.com/glayzzle/php-parser/issues/172
       return node.parenthesizedExpression;

package/src/options.mjs

@@ -7,7 +7,7 @@ const CATEGORY_PHP = "PHP";
 const SUPPORTED_PHP_VERSIONS = [
   5.0, 5.1, 5.2, 5.3, 5.4, 5.5, 5.6,
   7.0, 7.1, 7.2, 7.3, 7.4,
-  8.0, 8.1, 8.2, 8.3, 8.4,
+  8.0, 8.1, 8.2, 8.3, 8.4, 8.5,
 ];
 
 export const LATEST_SUPPORTED_PHP_VERSION = Math.max(...SUPPORTED_PHP_VERSIONS);

package/src/printer.mjs

@@ -50,6 +50,7 @@ const {
   dedent,
   ifBreak,
   hardline,
+  hardlineWithoutBreakParent,
   softline,
   literalline,
   align,
@@ -741,6 +742,32 @@ function shouldInlineLogicalExpression(node) {
 // precedence level and the AST is structured based on precedence
 // level, things are naturally broken up correctly, i.e. `&&` is
 // broken before `+`.
+function printPipeChain(path, print, trailingSemicolon = false) {
+  const elements = [];
+
+  function collect() {
+    const { node } = path;
+    if (node.kind === "bin" && node.type === "|>") {
+      elements.push(path.call(print, "left"));
+      path.call(collect, "right");
+    } else {
+      elements.push(print());
+    }
+  }
+
+  collect();
+
+  const [first, ...rest] = elements;
+  const semicolon = trailingSemicolon
+    ? ifBreak([hardlineWithoutBreakParent, ";"], ";")
+    : "";
+  return group([
+    first,
+    indent(rest.flatMap((el) => [line, "|> ", el])),
+    semicolon,
+  ]);
+}
+
 function printBinaryExpression(
   path,
   print,
@@ -1172,31 +1199,16 @@ function printAttrs(path, options, print, { inline = false } = {}) {
   if (!path.node.attrGroups) {
     return [];
   }
-  path.each(() => {
-    const attrGroup = ["#["];
+  path.each((attrGroupPath) => {
     if (!inline && allAttrs.length > 0) {
       allAttrs.push(hardline);
     }
-    attrGroup.push(softline);
-    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(path, options, print, "args"));
-      }
-      attrGroup.push(group(attrStmt));
-    }, "attrs");
     allAttrs.push(
-      group([
-        indent(attrGroup),
-        ifBreak(shouldPrintComma(options, 8.0) ? "," : ""),
-        softline,
-        "]",
-        inline ? ifBreak(softline, " ") : "",
-      ])
+      printAllComments(
+        attrGroupPath,
+        () => printAttrGroup(attrGroupPath, options, print, { inline }),
+        options
+      )
     );
   }, "attrGroups");
   if (allAttrs.length === 0) {
@@ -1205,6 +1217,40 @@ function printAttrs(path, options, print, { inline = false } = {}) {
   return [...allAttrs, inline ? "" : hardline];
 }
 
+// PER-CS 12.3: an attribute whose argument list is split over several lines
+// must be the only one in its `#[...]` block, and its arguments follow the
+// multiline function call rules (`#[Name(` ... `)]`). So a block is printed on
+// one line while it fits; otherwise each attribute gets a block of its own and
+// only the argument lists break.
+function printAttrGroup(path, options, print, { inline = false } = {}) {
+  const printedAttrs = path.map(({ node: attrNode }) => {
+    const attrStmt = [attrNode.name];
+    if (attrNode.args.length > 0) {
+      attrStmt.push(printArgumentsList(path, options, print, "args"));
+    }
+    return group(attrStmt);
+  }, "attrs");
+  const separator = inline ? ifBreak(softline, " ") : "";
+
+  if (printedAttrs.length === 1) {
+    return group(["#[", printedAttrs[0], "]", separator]);
+  }
+
+  const printedOneBlock = ["#[", join(", ", printedAttrs), "]", separator];
+  const printedOneBlockEach = group(
+    [
+      join(
+        inline ? line : hardline,
+        printedAttrs.map((attr) => ["#[", attr, "]"])
+      ),
+      inline ? line : "",
+    ],
+    { shouldBreak: true }
+  );
+
+  return conditionalGroup([printedOneBlock, printedOneBlockEach]);
+}
+
 function printClass(path, options, print) {
   const { node } = path;
   const isAnonymousClass = node.kind === "class" && node.isAnonymous;
@@ -1219,7 +1265,7 @@ function printClass(path, options, print) {
     declaration.push("abstract ");
   }
 
-  if (node.isReadonly) {
+  if (node.isReadonly && !isAnonymousClass) {
     declaration.push("readonly ");
   }
 
@@ -1431,6 +1477,38 @@ function printFunction(path, options, print) {
   ];
 }
 
+// PHP 8.4 property hooks (`{ get => ...; set(...) { ... } }`) on a property or a
+// promoted constructor parameter. PER-CS puts the opening brace on the
+// declaration line and one hook per line, preserving single blank lines.
+function printPropertyHooks(path, options, print) {
+  const { node } = path;
+
+  if (!node.hooks || node.hooks.length === 0) {
+    return "";
+  }
+
+  // Interface / abstract declarations (`{ get; set; }`) stay on the property's line.
+  if (node.hooks.every((hook) => !hook.body)) {
+    return [" { ", join(" ", path.map(print, "hooks")), " }"];
+  }
+
+  const printedHooks = path.map(({ node: hook, isLast }) => {
+    const parts = [print()];
+
+    if (!isLast) {
+      parts.push(hardline);
+
+      if (isNextLineEmpty(options.originalText, locEnd(hook))) {
+        parts.push(hardline);
+      }
+    }
+
+    return parts;
+  }, "hooks");
+
+  return [" {", indent([hardline, ...printedHooks]), hardline, "}"];
+}
+
 function printBodyControlStructure(
   path,
   options,
@@ -1524,6 +1602,7 @@ function printAssignmentRight(
 
   const canBreak =
     (pureRightNode.kind === "bin" &&
+      pureRightNode.type !== "|>" &&
       !shouldInlineLogicalExpression(pureRightNode)) ||
     (pureRightNode.kind === "retif" &&
       ((!pureRightNode.trueExpr &&
@@ -1738,14 +1817,13 @@ function printNode(path, options, print) {
         node.parenthesizedExpression ? ")" : "",
       ];
     case "parameter": {
-      let promoted = "";
-      if (node.flags === 1) {
-        promoted = "public ";
-      } else if (node.flags === 2) {
-        promoted = "protected ";
-      } else if (node.flags === 4) {
-        promoted = "private ";
-      }
+      const visibilities = { 1: "public", 2: "protected", 4: "private" };
+      // promoted constructor property: `public`, and/or the asymmetric set
+      // visibility `private(set)` (PHP 8.4)
+      const promoted = [
+        node.flags ? [visibilities[node.flags], " "] : "",
+        node.flagsSet ? [visibilities[node.flagsSet], "(set) "] : "",
+      ];
       const name = [
         ...printAttrs(path, options, print, { inline: true }),
         promoted,
@@ -1757,6 +1835,7 @@ function printNode(path, options, print) {
         "$",
         print("name"),
       ];
+      const hooks = printPropertyHooks(path, options, print);
 
       if (node.value) {
         return group([
@@ -1774,10 +1853,11 @@ function printNode(path, options, print) {
             false,
             options
           ),
+          hooks,
         ]);
       }
 
-      return name;
+      return [name, hooks];
     }
     case "variadic":
       return ["...", print("what")];
@@ -1799,7 +1879,41 @@ function printNode(path, options, print) {
               ),
             ]
           : "",
+        printPropertyHooks(path, options, print),
       ]);
+    case "propertyhook": {
+      const declaration = [
+        ...printAttrs(path, options, print, { inline: true }),
+        node.isFinal ? "final " : "",
+        node.byref ? "&" : "",
+        node.name,
+        node.parameter ? ["(", print("parameter"), ")"] : "",
+      ];
+
+      // `get;` / `set;` in an interface or abstract class
+      if (!node.body) {
+        return [...declaration, ";"];
+      }
+
+      // `get => expr;`
+      if (node.body.kind !== "block") {
+        return group([
+          ...declaration,
+          " =>",
+          printAssignmentRight(node, node.body, print("body"), false, options),
+          ";",
+        ]);
+      }
+
+      // `get { ... }` - like a closure, the brace stays on the hook's line
+      return [
+        ...declaration,
+        " {",
+        indent([hasEmptyBody(path) ? "" : hardline, print("body")]),
+        hasEmptyBody(path) ? "" : hardline,
+        "}",
+      ];
+    }
     case "propertystatement": {
       const attrs = [];
       path.each(() => {
@@ -1822,10 +1936,18 @@ function printNode(path, options, print) {
 
       return group([
         ...attrs,
+        node.isAbstract ? "abstract " : "",
+        node.isFinal ? "final " : "",
         hasVisibility
           ? [node.visibility === null ? "var" : node.visibility, ""]
           : "",
-        node.isStatic ? [hasVisibility ? " " : "", "static"] : "",
+        // asymmetric visibility: `public private(set)`
+        node.visibilitySet
+          ? [hasVisibility ? " " : "", node.visibilitySet, "(set)"]
+          : "",
+        node.isStatic
+          ? [hasVisibility || node.visibilitySet ? " " : "", "static"]
+          : "",
         firstProperty ? [" ", firstProperty] : "",
         indent(
           printed.slice(1).map((p) => [",", hasValue ? hardline : line, p])
@@ -2094,7 +2216,7 @@ function printNode(path, options, print) {
             () => printAttrs(path, options, print, { inline: true }),
             "what"
           ),
-          "class",
+          node.what.isReadonly ? "readonly class" : "class",
           node.arguments.length > 0
             ? [" ", printArgumentsList(path, options, print)]
             : "",
@@ -2114,11 +2236,64 @@ function printNode(path, options, print) {
 
       return parts;
     }
-    case "clone":
+    case "clone": {
+      if (!node.properties) {
+        return [
+          "clone ",
+          node.what.comments ? indent(print("what")) : print("what"),
+        ];
+      }
+
+      // PHP 8.5 clone with: `clone($obj, ['prop' => $value])`, laid out like
+      // a call with two arguments (see printArgumentsList). No trailing comma:
+      // php-parser does not accept one after the properties expression.
+      const printedWhat = print("what");
+      const printedProperties = print("properties");
+      const printedArguments = [printedWhat, ",", line, printedProperties];
+      const allArgsBrokenOut = () =>
+        group(["clone(", indent([line, ...printedArguments]), line, ")"], {
+          shouldBreak: true,
+        });
+
+      if (!shouldGroupLastArg([node.what, node.properties])) {
+        return group(
+          ["clone(", indent([softline, ...printedArguments]), softline, ")"],
+          {
+            shouldBreak: willBreak(printedWhat) || willBreak(printedProperties),
+          }
+        );
+      }
+
+      const somePrintedArgumentsWillBreak =
+        willBreak(printedWhat) || willBreak(printedProperties);
+      const simpleConcat = [
+        "clone(",
+        printedWhat,
+        ", ",
+        printedProperties,
+        ")",
+      ];
+
       return [
-        "clone ",
-        node.what.comments ? indent(print("what")) : print("what"),
+        somePrintedArgumentsWillBreak ? breakParent : "",
+        conditionalGroup(
+          [
+            somePrintedArgumentsWillBreak
+              ? ifBreak(allArgsBrokenOut(), simpleConcat)
+              : simpleConcat,
+            [
+              "clone(",
+              printedWhat,
+              ", ",
+              group(printedProperties, { shouldBreak: true }),
+              ")",
+            ],
+            allArgsBrokenOut(),
+          ],
+          { shouldBreak: willBreak(printedWhat) }
+        ),
       ];
+    }
     case "propertylookup":
     case "nullsafepropertylookup":
     case "staticlookup":
@@ -2278,6 +2453,10 @@ function printNode(path, options, print) {
           parent.curly) ||
         (parentParent &&
           parent.kind === "offsetlookup" &&
+          // Only the base variable of the lookup follows the `${` printed
+          // by the encapsedpart; a variable in the offset position is a
+          // nested variable and keeps its own `$`.
+          parent.what === node &&
           parentParent.kind === "encapsedpart" &&
           parentParent.syntax === "simple" &&
           parentParent.curly)
@@ -2487,6 +2666,16 @@ function printNode(path, options, print) {
       );
     }
     case "bin": {
+      if (node.type === "|>") {
+        const { parent, grandparent } = path;
+        const isStatementLevel =
+          parent.kind === "expressionstatement" ||
+          (parent.kind === "assign" &&
+            grandparent &&
+            grandparent.kind === "expressionstatement");
+        return printPipeChain(path, print, isStatementLevel);
+      }
+
       const { parent, grandparent: parentParent } = path;
       const isInsideParenthesis =
         node !== parent.body &&
@@ -2871,6 +3060,7 @@ function printNode(path, options, print) {
 
     case "enumcase":
       return group([
+        ...printAttrs(path, options, print),
         "case ",
         print("name"),
         node.value

package/src/util.mjs

@@ -41,6 +41,7 @@ const PRECEDENCE = new Map(
       "<<=",
       ">>=",
     ],
+    ["|>"],
     ["??"],
     ["||"],
     ["&&"],
@@ -70,7 +71,7 @@ const bitshiftOperators = [">>", "<<"];
 
 function isBitwiseOperator(operator) {
   return (
-    !!bitshiftOperators[operator] ||
+    bitshiftOperators.includes(operator) ||
     operator === "|" ||
     operator === "^" ||
     operator === "&"
@@ -353,12 +354,30 @@ function lineShouldEndWithSemicolon(path) {
   if (node.kind === "method" && node.isAbstract) {
     return true;
   }
+  // a hooked property ends with its closing brace, not a semicolon
+  if (
+    node.kind === "propertystatement" &&
+    node.properties.some((property) => property.hooks?.length > 0)
+  ) {
+    return false;
+  }
   if (node.kind === "method") {
     const { parent } = path;
     if (parent && parent.kind === "interface") {
       return true;
     }
   }
+  if (node.kind === "expressionstatement") {
+    const expr = node.expression;
+    const isPipeChain =
+      (expr.kind === "bin" && expr.type === "|>") ||
+      (expr.kind === "assign" &&
+        expr.right.kind === "bin" &&
+        expr.right.type === "|>");
+    if (isPipeChain) {
+      return false;
+    }
+  }
   return [
     "expressionstatement",
     "do",
@@ -678,7 +697,7 @@ function isSimpleCallArgument(node, depth = 2) {
 
   if (isCallLikeExpression(node)) {
     const parts = getChainParts(node);
-    parts.unshift();
+    parts.shift();
 
     return (
       parts.length <= depth &&