From 3ffd6159f211a9c9fd499a821069923d5953c867 Mon Sep 17 00:00:00 2001
From: Junichi Yamamoto <junichi11@apache.org>
Date: Mon, 16 Oct 2023 11:57:08 +0900
Subject: [PATCH] PHP 8.2 Support: Disjunctive Normal Form Types (Part 8)

- https://github.com/apache/netbeans/issues/4725
- https://wiki.php.net/rfc/dnf_types
- Fix the formatter(Prevent adding `WHITESPACE_BEFORE_METHOD_DEC_PAREN` twice)
```php
// e.g. the following case has "(("
function example((X&Y)|Z $param): void {}
```
- Add a unit test
---
 .../php/editor/indent/FormatVisitor.java      |   5 +-
 .../formatting/php82/dnfTypes_01.php          | 190 ++++++++++++
 .../php82/dnfTypes_01.php.formatted           | 281 ++++++++++++++++++
 .../php/editor/indent/PHPFormatterTest.java   |   5 +
 4 files changed, 480 insertions(+), 1 deletion(-)
 create mode 100644 php/php.editor/test/unit/data/testfiles/formatting/php82/dnfTypes_01.php
 create mode 100644 php/php.editor/test/unit/data/testfiles/formatting/php82/dnfTypes_01.php.formatted

diff --git a/php/php.editor/src/org/netbeans/modules/php/editor/indent/FormatVisitor.java b/php/php.editor/src/org/netbeans/modules/php/editor/indent/FormatVisitor.java
index c03939e031a0..2913ec7a660a 100644
--- a/php/php.editor/src/org/netbeans/modules/php/editor/indent/FormatVisitor.java
+++ b/php/php.editor/src/org/netbeans/modules/php/editor/indent/FormatVisitor.java
@@ -1465,13 +1465,16 @@ public void visit(FunctionDeclaration node) {
         scan(node.getAttributes());
         scan(node.getFunctionName());
 
+        // e.g. function paramHasDNFType((X&Y)|Z $test): void {}
+        boolean addedOpenParen = false;
         // #270903 add indent
         while (ts.moveNext() && (ts.token().id() == PHPTokenId.WHITESPACE
                 || isComment(ts.token())
-                || isOpenParen(ts.token()))) {
+                || (isOpenParen(ts.token()) && !addedOpenParen))) {
             addFormatToken(formatTokens);
             if (isOpenParen(ts.token())) {
                 formatTokens.add(new FormatToken.IndentToken(ts.offset() + ts.token().length(), options.continualIndentSize));
+                addedOpenParen = true;
             }
         }
         ts.movePrevious();
diff --git a/php/php.editor/test/unit/data/testfiles/formatting/php82/dnfTypes_01.php b/php/php.editor/test/unit/data/testfiles/formatting/php82/dnfTypes_01.php
new file mode 100644
index 000000000000..7fa34460fa32
--- /dev/null
+++ b/php/php.editor/test/unit/data/testfiles/formatting/php82/dnfTypes_01.php
@@ -0,0 +1,190 @@
+<?php
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+class ClassX {
+const IMPLICIT_X_CONSTANT = "implicit constant";
+public const PUBLIC_X_CONSTANT = "public constant";
+private const PRIVATE_X_CONSTANT = "private constant";
+protected const PROTECTED_X_CONSTANT = "protected constant";
+    public (ClassY   &   ClassZ)   |   ClassX $publicXField;
+private (ClassX&ClassZ)|(ClassY&ClassZ)|ClassX $privateXField;
+protected ClassX|(ClassY&ClassZ)|    ClassY     $protectedXField;
+public static      (ClassY&ClassZ)|ClassX $publicStaticXField;
+private static (ClassY&ClassZ)|ClassY $privateStaticXField;
+protected static (ClassY&ClassZ)   |      ClassX|ClassY $protectedStaticXField;
+
+public function publicXMethod((ClassY&ClassZ)|ClassX $param1): ClassX|(ClassY&ClassZ) {}
+ private function privateMXethod(ClassZ|(ClassY&ClassZ)|ClassX $param1 = null): (ClassY&ClassZ)|ClassX {}
+       protected function protectedXMethod(  (ClassY & ClassZ)   |(ClassX   &ClassZ) $param1): (ClassY&ClassZ)|(ClassX&ClassZ) {}
+public static function publicStaticXMethod(ClassX | (ClassY & ClassZ) $param1, int $param2): (ClassY&ClassZ)|ClassX {}
+     private static function privateStaticXMethod(int $param1, (ClassX&ClassY)|ClassZ $param2): ClassX|(ClassY&ClassZ){}
+protected static function   protectedStaticXMethod(ClassX|null $param1, (ClassX&ClassZ)|null $param2 = null): (ClassY&ClassZ)|ClassX {}
+}
+
+class ClassY {
+const IMPLICIT_Y_CONSTANT = "implicit constant";
+public const PUBLIC_Y_CONSTANT = "public constant";
+private const PRIVATE_Y_CONSTANT = "private constant";
+            protected const PROTECTED_Y_CONSTANT = "protected constant";
+public (ClassY&ClassZ)|    ClassX $publicYField;
+          private (ClassX&ClassZ)|(ClassY&ClassZ)|ClassX $privateYField;
+protected ClassX|(ClassY&ClassZ)|ClassY $protectedYField;
+public static (ClassY&     ClassZ)|ClassX $publicStaticYField;
+private static (    ClassY&ClassZ)|ClassY $privateStaticYField;
+protected static (ClassY&ClassZ)|ClassX|ClassY $protectedStaticYField;
+
+public function publicYMethod((ClassY&ClassZ)|   ClassX $param1, (ClassY&ClassZ)|ClassX|(ClassX&ClassZ) $param2): ClassX|(ClassY&ClassZ) {}
+private function privateYMethod(ClassX $param1, (ClassY&ClassZ)   |null $param2): (ClassY&ClassZ)|ClassX {}
+protected function protectedYMethod((ClassY&ClassZ)|   ClassX $param1, ClassY|(ClassX&ClassZ&ClassY) $param2): (ClassY&ClassZ)|(ClassX&ClassZ) {}
+public static function publicStaticYMethod(null|(ClassY&ClassZ)|   ClassX $param1): (ClassY&ClassZ)|ClassX {}
+private static function privateStaticYMethod(    (ClassY&ClassZ)|ClassX|ClassY $param): ClassX|(ClassY&ClassZ){}
+protected static function protectedStaticYMethod(      (ClassY&ClassZ)|(ClassX&ClassZ) $param1): (ClassY&ClassZ)|ClassX {}
+}
+
+class ClassZ {
+const IMPLICIT_Z_CONSTANT = "implicit constant";
+public const PUBLIC_Z_CONSTANT = "public constant";
+private const PRIVATE_Z_CONSTANT = "private constant";
+protected const PROTECTED_Z_CONSTANT = "protected constant";
+public (ClassY&ClassZ)|ClassX $publicZField;
+private (ClassX&ClassZ)|(ClassY&ClassZ)|ClassX $privateZField;
+protected ClassX|(ClassY&ClassZ)|ClassY $protectedZField;
+public static (ClassY&ClassZ)|ClassX $publicStaticZField;
+private static (ClassY&ClassZ)|ClassY $privateStaticZField;
+protected static (ClassY&ClassZ)|ClassX|ClassY $protectedStaticZField;
+
+public function publicZMethod(
+        ClassX|(ClassY&ClassZ)|ClassY $param1
+        ): ClassX|(ClassY&ClassZ)|ClassY {}
+private function privateZMethod(): (ClassY&ClassZ)|ClassX {}
+protected function protectedZMethod(ClassX $param = null): (ClassY&ClassZ)|(ClassX&ClassZ) {}
+public static function publicStaticZMethod(ClassX&ClassY $param): (ClassX&ClassZ)|(ClassY&ClassZ)|ClassX {}
+private static function privateStaticZMethod(ClassX|null $param): ClassX|(ClassY&ClassZ){}
+protected static function protectedStaticZMethod(
+        int $param,
+        ClassX|ClassY $param2
+        ): (ClassY&ClassZ)|ClassX {}
+}
+
+trait TestTrait {
+  const IMPLICIT_TRAIT_CONSTANT = "implicit constant";
+  public const PUBLIC_TRAIT_CONSTANT = "public constant";
+  private const PRIVATE_TRAIT_CONSTANT = "private constant";
+  protected const PROTECTED_TRAIT_CONSTANT = "protected constant";
+  public (ClassX&ClassY)|ClassY $publicTraitField;
+  private (ClassX&ClassY)|(ClassY&ClassZ) $privateTraitField;
+  protected ClassY|(ClassX&ClassY) $protectedTraitField;
+  public static ClassY|(ClassX&ClassY)|ClassX $publicStaticTraitField;
+  private static (ClassX&ClassZ)|ClassY $privateStaticTraitField;
+  protected static (ClassX&ClassY&ClassZ)|ClassX $protectedStaticTraitField;
+
+  public function publicTraitMethod(?ClassX $param): (ClassX&ClassY)|ClassZ {}
+  private function privateTraitMethod((ClassX&ClassY)| ClassZ $param):  (ClassX&ClassY)|ClassZ {}
+  protected function protectedTraitMethod(string $param1, (ClassX&ClassY)|(ClassX&ClassZ) $param2): (ClassX&ClassY)|ClassZ {}
+  public static function publicStaticTraitMethod(): (ClassX&ClassY)|(ClassX&ClassY&ClassZ) {}
+  private static function privateStaticTraitMethod(ClassX|(ClassX&ClassY)|ClassZ $param1, ClassX|(ClassX&ClassY)|ClassZ $param2):  ClassX|(ClassX&ClassY)|ClassZ {}
+  protected static function protectedStaticTraitMethod(string|int $param = 1): ClassZ|(ClassX&ClassY) {}
+}
+
+function testFunctionReturnType(): (ClassX&ClassY)|ClassZ {
+}
+
+interface TestInterface {
+
+    public function paramType(ClassX|(ClassY&ClassZ) $test): void;
+    public function returnType(): ClassX|(ClassY&ClassZ);
+
+}
+
+/**
+ * @method ClassX|(ClassX&ClassZ) methodTag() Description
+ * @property (ClassX&ClassY)|ClassY $propertyTag Description
+ */
+class TestClass implements TestInterface {
+use TestTrait;
+/**
+ * @var ClassX|(ClassX&ClassY)
+ */
+public $publicPhpdocField;
+public (ClassX&ClassZ)|(ClassY&ClassZ) $publicFiled;
+private ClassX|(ClassY&ClassZ) $privateFiled;
+protected ClassZ|ClassX|(ClassY&ClassZ) $protectedFiled;
+/**
+ * @var (ClassX&ClassY)|ClassZ
+ */
+public static $publicPhpdocStaticField;
+public static (ClassX&ClassZ)|ClassZ $publicStaticField;
+private static ClassZ|(ClassZ&ClassY) $privateStaticField;
+protected static (ClassX&ClassZ)|ClassZ $protectedStaticField;
+
+public function __construct(
+        public ClassZ|(ClassZ&ClassY) $publicPromotedFiled,
+        private null|(ClassZ&ClassX) $privatePromotedFiled,
+        protected ClassZ|(ClassZ&ClassY)|ClassX $protectedPromotedFiled,
+) {
+}
+
+public function paramType(ClassX|(ClassY&ClassZ) $param1): void {
+}
+
+/**
+ * @return (ClassX&ClassZ)|(ClassX&ClassY) Description
+ */
+public function phpdocReturnType() {
+}
+
+public function returnType(): ClassX|(ClassY&ClassZ) {
+}
+
+public static function publicStaticMethod(): (ClassX&ClassZ)|(ClassX&ClassY) {
+}
+
+}
+
+/** @var (ClassX&ClassY)|null $vardoc1 */
+$vardoc1->publicXField;
+/** @var ClassZ|(ClassX&ClassY)|null $vardoc2 */
+$vardoc2->publicXField;
+/** @var ClassZ|(ClassX&ClassY)|(ClassX&ClassZ) $vardoc3 */
+$vardoc3->publicXField;
+
+/* @var $vardoc4 (ClassX&ClassY)|null */
+$vardoc4->publicXField;
+/* @var $vardoc5 ClassZ|(ClassX&ClassY)|null */
+$vardoc5->publicXField;
+/* @var $vardoc6 ClassZ|(ClassX&ClassY)|(ClassX&ClassZ) */
+$vardoc6->publicXField;
+
+$closure = function((X&Y&Z)|Y $test1, X|(X&Z)|(Y&Z) $test2): void {};
+$closure = function(int $test): (X&Y&Z)|(X&Z) {};
+
+$arrow = fn((X&Y)|(Y&Z) $test) => $test;
+$arrow = fn((X&Y)|(Y&Z) $test): (X&Y)|(Y&Z)|(X&Z) => $test;
+
+$anon = new class($test) {
+ private (ClassX&ClassY)|ClassZ $property;
+
+ public function __construct((ClassX&ClassY)|ClassZ $property)
+        {
+            $this->property = $property;
+    }
+    
+    public function test((ClassX&ClassY)|null $param): (ClassX&ClassY)|(ClassY&ClassZ) {
+    }
+};
diff --git a/php/php.editor/test/unit/data/testfiles/formatting/php82/dnfTypes_01.php.formatted b/php/php.editor/test/unit/data/testfiles/formatting/php82/dnfTypes_01.php.formatted
new file mode 100644
index 000000000000..933d833d0e4c
--- /dev/null
+++ b/php/php.editor/test/unit/data/testfiles/formatting/php82/dnfTypes_01.php.formatted
@@ -0,0 +1,281 @@
+<?php
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+class ClassX {
+
+    const IMPLICIT_X_CONSTANT = "implicit constant";
+    public const PUBLIC_X_CONSTANT = "public constant";
+    private const PRIVATE_X_CONSTANT = "private constant";
+    protected const PROTECTED_X_CONSTANT = "protected constant";
+
+    public (ClassY&ClassZ)|ClassX $publicXField;
+    private (ClassX&ClassZ)|(ClassY&ClassZ)|ClassX $privateXField;
+    protected ClassX|(ClassY&ClassZ)|ClassY $protectedXField;
+    public static (ClassY&ClassZ)|ClassX $publicStaticXField;
+    private static (ClassY&ClassZ)|ClassY $privateStaticXField;
+    protected static (ClassY&ClassZ)|ClassX|ClassY $protectedStaticXField;
+
+    public function publicXMethod((ClassY&ClassZ)|ClassX $param1): ClassX|(ClassY&ClassZ) {
+        
+    }
+
+    private function privateMXethod(ClassZ|(ClassY&ClassZ)|ClassX $param1 = null): (ClassY&ClassZ)|ClassX {
+        
+    }
+
+    protected function protectedXMethod((ClassY&ClassZ)|(ClassX&ClassZ) $param1): (ClassY&ClassZ)|(ClassX&ClassZ) {
+        
+    }
+
+    public static function publicStaticXMethod(ClassX|(ClassY&ClassZ) $param1, int $param2): (ClassY&ClassZ)|ClassX {
+        
+    }
+
+    private static function privateStaticXMethod(int $param1, (ClassX&ClassY)|ClassZ $param2): ClassX|(ClassY&ClassZ) {
+        
+    }
+
+    protected static function protectedStaticXMethod(ClassX|null $param1, (ClassX&ClassZ)|null $param2 = null): (ClassY&ClassZ)|ClassX {
+        
+    }
+}
+
+class ClassY {
+
+    const IMPLICIT_Y_CONSTANT = "implicit constant";
+    public const PUBLIC_Y_CONSTANT = "public constant";
+    private const PRIVATE_Y_CONSTANT = "private constant";
+    protected const PROTECTED_Y_CONSTANT = "protected constant";
+
+    public (ClassY&ClassZ)|ClassX $publicYField;
+    private (ClassX&ClassZ)|(ClassY&ClassZ)|ClassX $privateYField;
+    protected ClassX|(ClassY&ClassZ)|ClassY $protectedYField;
+    public static (ClassY&ClassZ)|ClassX $publicStaticYField;
+    private static ( ClassY&ClassZ)|ClassY $privateStaticYField;
+    protected static (ClassY&ClassZ)|ClassX|ClassY $protectedStaticYField;
+
+    public function publicYMethod((ClassY&ClassZ)|ClassX $param1, (ClassY&ClassZ)|ClassX|(ClassX&ClassZ) $param2): ClassX|(ClassY&ClassZ) {
+        
+    }
+
+    private function privateYMethod(ClassX $param1, (ClassY&ClassZ)|null $param2): (ClassY&ClassZ)|ClassX {
+        
+    }
+
+    protected function protectedYMethod((ClassY&ClassZ)|ClassX $param1, ClassY|(ClassX&ClassZ&ClassY) $param2): (ClassY&ClassZ)|(ClassX&ClassZ) {
+        
+    }
+
+    public static function publicStaticYMethod(null|(ClassY&ClassZ)|ClassX $param1): (ClassY&ClassZ)|ClassX {
+        
+    }
+
+    private static function privateStaticYMethod((ClassY&ClassZ)|ClassX|ClassY $param): ClassX|(ClassY&ClassZ) {
+        
+    }
+
+    protected static function protectedStaticYMethod((ClassY&ClassZ)|(ClassX&ClassZ) $param1): (ClassY&ClassZ)|ClassX {
+        
+    }
+}
+
+class ClassZ {
+
+    const IMPLICIT_Z_CONSTANT = "implicit constant";
+    public const PUBLIC_Z_CONSTANT = "public constant";
+    private const PRIVATE_Z_CONSTANT = "private constant";
+    protected const PROTECTED_Z_CONSTANT = "protected constant";
+
+    public (ClassY&ClassZ)|ClassX $publicZField;
+    private (ClassX&ClassZ)|(ClassY&ClassZ)|ClassX $privateZField;
+    protected ClassX|(ClassY&ClassZ)|ClassY $protectedZField;
+    public static (ClassY&ClassZ)|ClassX $publicStaticZField;
+    private static (ClassY&ClassZ)|ClassY $privateStaticZField;
+    protected static (ClassY&ClassZ)|ClassX|ClassY $protectedStaticZField;
+
+    public function publicZMethod(
+            ClassX|(ClassY&ClassZ)|ClassY $param1
+    ): ClassX|(ClassY&ClassZ)|ClassY {
+        
+    }
+
+    private function privateZMethod(): (ClassY&ClassZ)|ClassX {
+        
+    }
+
+    protected function protectedZMethod(ClassX $param = null): (ClassY&ClassZ)|(ClassX&ClassZ) {
+        
+    }
+
+    public static function publicStaticZMethod(ClassX&ClassY $param): (ClassX&ClassZ)|(ClassY&ClassZ)|ClassX {
+        
+    }
+
+    private static function privateStaticZMethod(ClassX|null $param): ClassX|(ClassY&ClassZ) {
+        
+    }
+
+    protected static function protectedStaticZMethod(
+            int $param,
+            ClassX|ClassY $param2
+    ): (ClassY&ClassZ)|ClassX {
+        
+    }
+}
+
+trait TestTrait {
+
+    const IMPLICIT_TRAIT_CONSTANT = "implicit constant";
+    public const PUBLIC_TRAIT_CONSTANT = "public constant";
+    private const PRIVATE_TRAIT_CONSTANT = "private constant";
+    protected const PROTECTED_TRAIT_CONSTANT = "protected constant";
+
+    public (ClassX&ClassY)|ClassY $publicTraitField;
+    private (ClassX&ClassY)|(ClassY&ClassZ) $privateTraitField;
+    protected ClassY|(ClassX&ClassY) $protectedTraitField;
+    public static ClassY|(ClassX&ClassY)|ClassX $publicStaticTraitField;
+    private static (ClassX&ClassZ)|ClassY $privateStaticTraitField;
+    protected static (ClassX&ClassY&ClassZ)|ClassX $protectedStaticTraitField;
+
+    public function publicTraitMethod(?ClassX $param): (ClassX&ClassY)|ClassZ {
+        
+    }
+
+    private function privateTraitMethod((ClassX&ClassY)|ClassZ $param): (ClassX&ClassY)|ClassZ {
+        
+    }
+
+    protected function protectedTraitMethod(string $param1, (ClassX&ClassY)|(ClassX&ClassZ) $param2): (ClassX&ClassY)|ClassZ {
+        
+    }
+
+    public static function publicStaticTraitMethod(): (ClassX&ClassY)|(ClassX&ClassY&ClassZ) {
+        
+    }
+
+    private static function privateStaticTraitMethod(ClassX|(ClassX&ClassY)|ClassZ $param1, ClassX|(ClassX&ClassY)|ClassZ $param2): ClassX|(ClassX&ClassY)|ClassZ {
+        
+    }
+
+    protected static function protectedStaticTraitMethod(string|int $param = 1): ClassZ|(ClassX&ClassY) {
+        
+    }
+}
+
+function testFunctionReturnType(): (ClassX&ClassY)|ClassZ {
+    
+}
+
+interface TestInterface {
+
+    public function paramType(ClassX|(ClassY&ClassZ) $test): void;
+
+    public function returnType(): ClassX|(ClassY&ClassZ);
+}
+
+/**
+ * @method ClassX|(ClassX&ClassZ) methodTag() Description
+ * @property (ClassX&ClassY)|ClassY $propertyTag Description
+ */
+class TestClass implements TestInterface {
+
+    use TestTrait;
+
+    /**
+     * @var ClassX|(ClassX&ClassY)
+     */
+    public $publicPhpdocField;
+    public (ClassX&ClassZ)|(ClassY&ClassZ) $publicFiled;
+    private ClassX|(ClassY&ClassZ) $privateFiled;
+    protected ClassZ|ClassX|(ClassY&ClassZ) $protectedFiled;
+
+    /**
+     * @var (ClassX&ClassY)|ClassZ
+     */
+    public static $publicPhpdocStaticField;
+    public static (ClassX&ClassZ)|ClassZ $publicStaticField;
+    private static ClassZ|(ClassZ&ClassY) $privateStaticField;
+    protected static (ClassX&ClassZ)|ClassZ $protectedStaticField;
+
+    public function __construct(
+            public ClassZ|(ClassZ&ClassY) $publicPromotedFiled,
+            private null|(ClassZ&ClassX) $privatePromotedFiled,
+            protected ClassZ|(ClassZ&ClassY)|ClassX $protectedPromotedFiled,
+    ) {
+        
+    }
+
+    public function paramType(ClassX|(ClassY&ClassZ) $param1): void {
+        
+    }
+
+    /**
+     * @return (ClassX&ClassZ)|(ClassX&ClassY) Description
+     */
+    public function phpdocReturnType() {
+        
+    }
+
+    public function returnType(): ClassX|(ClassY&ClassZ) {
+        
+    }
+
+    public static function publicStaticMethod(): (ClassX&ClassZ)|(ClassX&ClassY) {
+        
+    }
+}
+
+/** @var (ClassX&ClassY)|null $vardoc1 */
+$vardoc1->publicXField;
+/** @var ClassZ|(ClassX&ClassY)|null $vardoc2 */
+$vardoc2->publicXField;
+/** @var ClassZ|(ClassX&ClassY)|(ClassX&ClassZ) $vardoc3 */
+$vardoc3->publicXField;
+
+/* @var $vardoc4 (ClassX&ClassY)|null */
+$vardoc4->publicXField;
+/* @var $vardoc5 ClassZ|(ClassX&ClassY)|null */
+$vardoc5->publicXField;
+/* @var $vardoc6 ClassZ|(ClassX&ClassY)|(ClassX&ClassZ) */
+$vardoc6->publicXField;
+
+$closure = function ((X&Y&Z)|Y $test1, X|(X&Z)|(Y&Z) $test2): void {
+    
+};
+$closure = function (int $test): (X&Y&Z)|(X&Z) {
+    
+};
+
+$arrow = fn((X&Y)|(Y&Z) $test) => $test;
+$arrow = fn((X&Y)|(Y&Z) $test): (X&Y)|(Y&Z)|(X&Z) => $test;
+
+$anon = new class($test) {
+
+    private (ClassX&ClassY)|ClassZ $property;
+
+    public function __construct((ClassX&ClassY)|ClassZ $property) {
+        $this->property = $property;
+    }
+
+    public function test((ClassX&ClassY)|null $param): (ClassX&ClassY)|(ClassY&ClassZ) {
+        
+    }
+};
diff --git a/php/php.editor/test/unit/src/org/netbeans/modules/php/editor/indent/PHPFormatterTest.java b/php/php.editor/test/unit/src/org/netbeans/modules/php/editor/indent/PHPFormatterTest.java
index 6feeccc9e879..b39411588f18 100644
--- a/php/php.editor/test/unit/src/org/netbeans/modules/php/editor/indent/PHPFormatterTest.java
+++ b/php/php.editor/test/unit/src/org/netbeans/modules/php/editor/indent/PHPFormatterTest.java
@@ -1099,4 +1099,9 @@ public void testReadonlyClasses_01b() throws Exception {
         HashMap<String, Object> options = new HashMap<>(FmtOptions.getDefaults());
         reformatFileContents("testfiles/formatting/php82/readonlyClasses_01b.php", options);
     }
+
+    public void testDNFTypes_01() throws Exception {
+        HashMap<String, Object> options = new HashMap<>(FmtOptions.getDefaults());
+        reformatFileContents("testfiles/formatting/php82/dnfTypes_01.php", options);
+    }
 }