@prettier/plugin-php 0.25.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-php",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "Prettier PHP Plugin",
   "repository": "prettier/prettier-php",
   "author": "Lucas Azzola <@azz>",
@@ -26,12 +26,12 @@
     "index.d.ts"
   ],
   "dependencies": {
-    "linguist-languages": "^8.0.0",
-    "php-parser": "^3.4.0"
+    "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-alias": "^6.0.0",
     "@rollup/plugin-babel": "^7.0.0",
     "@rollup/plugin-commonjs": "^29.0.2",
     "@rollup/plugin-inject": "^5.0.5",
@@ -40,11 +40,11 @@
     "@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-config-prettier": "10.1.8",
     "eslint-plugin-import": "2.32.0",
-    "eslint-plugin-jest": "27.6.3",
+    "eslint-plugin-jest": "29.15.4",
     "eslint-plugin-prettier": "5.5.5",
     "eslint-plugin-prettier-doc": "^1.1.0",
     "jest": "30.3.0",

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

@@ -192,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;

package/src/printer.mjs

@@ -1199,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) {
@@ -1232,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;
@@ -1458,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,
@@ -1766,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,
@@ -1785,6 +1835,7 @@ function printNode(path, options, print) {
         "$",
         print("name"),
       ];
+      const hooks = printPropertyHooks(path, options, print);
 
       if (node.value) {
         return group([
@@ -1802,10 +1853,11 @@ function printNode(path, options, print) {
             false,
             options
           ),
+          hooks,
         ]);
       }
 
-      return name;
+      return [name, hooks];
     }
     case "variadic":
       return ["...", print("what")];
@@ -1827,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(() => {
@@ -1850,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])
@@ -2142,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":
@@ -2306,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)
@@ -2909,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

@@ -354,6 +354,13 @@ 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") {