Merge pull request #1714 from PHPCompatibility/php-8.2/detect-dnf-types

PHP 8.2 | Detect DNF types in all type declaration related sniffs

.github/CONTRIBUTING.md

@@ -24,7 +24,7 @@ To start contributing, fork the repository, create a new branch in your fork, ma
 
 Please make sure that your pull request contains unit tests covering what's being addressed by it.
 
-* All code should be compatible with PHPCS >= 3.9.0.
+* All code should be compatible with PHPCS >= 3.10.0.
 * All code should be compatible with PHP 5.4 to PHP nightly.
 * All code should comply with the PHPCompatibility coding standards.
     The [ruleset used by PHPCompatibility](https://github.com/PHPCSStandards/PHPCSDevCS) is largely based on PSR-12 with minor variations and some additional checks for array layout and documentation and such.

.github/workflows/test.yml

@@ -93,7 +93,7 @@ jobs:
 
         include:
           - php: '7.2'
-            phpcs_version: '^3.9.0'
+            phpcs_version: '^3.10.0'
             custom_ini: true
             experimental: false
 

PHPCompatibility/Sniffs/Classes/NewTypedPropertiesSniff.php

@@ -27,6 +27,7 @@
  * - Since PHP 8.1, intersection types are supported for class/interface names.
  * - Since PHP 8.2, `false` and `null` can be used as stand-alone types.
  * - Since PHP 8.2, the `true` sub-type is available.
+ * - Since PHP 8.2, disjunctive normal form types are available.
  *
  * PHP version 7.4+
  *
@@ -37,6 +38,7 @@
  * @link https://wiki.php.net/rfc/pure-intersection-types
  * @link https://wiki.php.net/rfc/null-false-standalone-types
  * @link https://wiki.php.net/rfc/true-type
+ * @link https://wiki.php.net/rfc/dnf_types
  *
  * @since 9.2.0
  */
@@ -239,9 +241,10 @@ protected function checkType(File $phpcsFile, $typeToken, $typeInfo)
                 [$origType]
             );
         } else {
-            $types              = \preg_split('`[|&]`', $type, -1, \PREG_SPLIT_NO_EMPTY);
-            $isUnionType        = (\strpos($type, '|') !== false);
-            $isIntersectionType = (\strpos($type, '&') !== false);
+            $types              = \preg_split('`[|&()]`', $type, -1, \PREG_SPLIT_NO_EMPTY);
+            $isUnionType        = (\strpos($type, '|') !== false && \strpos($type, '(') === false);
+            $isIntersectionType = (\strpos($type, '&') !== false && \strpos($type, '(') === false);
+            $isDNFType          = \strpos($type, '(') !== false;
 
             if (ScannedCode::shouldRunOnOrBelow('7.4') === true && $isUnionType === true) {
                 $phpcsFile->addError(
@@ -261,6 +264,15 @@ protected function checkType(File $phpcsFile, $typeToken, $typeInfo)
                 );
             }
 
+            if (ScannedCode::shouldRunOnOrBelow('8.1') === true && $isDNFType === true) {
+                $phpcsFile->addError(
+                    'Disjunctive Normal Form types are not present in PHP version 8.1 or earlier. Found: %s',
+                    $typeToken,
+                    'DNFTypeFound',
+                    [$origType]
+                );
+            }
+
             foreach ($types as $type) {
                 if (isset($this->newTypes[$type])) {
                     $itemInfo = [

PHPCompatibility/Sniffs/FunctionDeclarations/NewParamTypeDeclarationsSniff.php

@@ -36,6 +36,7 @@
  * - Since PHP 8.1, intersection types are supported for class/interface names.
  * - Since PHP 8.2, `false` and `null` can be used as stand-alone types.
  * - Since PHP 8.2, the `true` sub-type is available.
+ * - Since PHP 8.2, disjunctive normal form types are available.
  *
  * Additionally, this sniff does a cursory check for typical invalid type declarations,
  * such as:
@@ -55,6 +56,7 @@
  * @link https://wiki.php.net/rfc/pure-intersection-types
  * @link https://wiki.php.net/rfc/null-false-standalone-types
  * @link https://wiki.php.net/rfc/true-type
+ * @link https://wiki.php.net/rfc/dnf_types
  *
  * @since 7.0.0
  * @since 7.1.0  Now extends the `AbstractNewFeatureSniff` instead of the base `Sniff` class.
@@ -232,9 +234,10 @@ public function process(File $phpcsFile, $stackPtr)
             // Strip off potential nullable indication.
             $typeHint           = \ltrim($param['type_hint'], '?');
             $typeHint           = \strtolower($typeHint);
-            $types              = \preg_split('`[|&]`', $typeHint, -1, \PREG_SPLIT_NO_EMPTY);
-            $isUnionType        = (\strpos($typeHint, '|') !== false);
-            $isIntersectionType = (\strpos($typeHint, '&') !== false);
+            $types              = \preg_split('`[|&()]`', $typeHint, -1, \PREG_SPLIT_NO_EMPTY);
+            $isUnionType        = (\strpos($typeHint, '|') !== false && \strpos($typeHint, '(') === false);
+            $isIntersectionType = (\strpos($typeHint, '&') !== false && \strpos($typeHint, '(') === false);
+            $isDNFType          = \strpos($typeHint, '(') !== false;
 
             if ($supportsPHP7 === true && $isUnionType === true) {
                 $phpcsFile->addError(
@@ -254,6 +257,15 @@ public function process(File $phpcsFile, $stackPtr)
                 );
             }
 
+            if ($supportsPHP81 === true && $isDNFType === true) {
+                $phpcsFile->addError(
+                    'Disjunctive Normal Form types are not present in PHP version 8.1 or earlier. Found: %s',
+                    $param['token'],
+                    'DNFTypeFound',
+                    [$param['type_hint']]
+                );
+            }
+
             foreach ($types as $type) {
                 if (isset($this->newTypes[$type])) {
                     $itemInfo = [

PHPCompatibility/Sniffs/FunctionDeclarations/NewReturnTypeDeclarationsSniff.php

@@ -30,6 +30,7 @@
  * - Since PHP 8.1, intersection types are supported for class/interface names.
  * - Since PHP 8.2, `false` and `null` can be used as stand-alone types.
  * - Since PHP 8.2, the `true` sub-type is available.
+ * - Since PHP 8.2, disjunctive normal form types are available.
  *
  * PHP version 7.0+
  *
@@ -46,6 +47,7 @@
  * @link https://wiki.php.net/rfc/pure-intersection-types
  * @link https://wiki.php.net/rfc/null-false-standalone-types
  * @link https://wiki.php.net/rfc/true-type
+ * @link https://wiki.php.net/rfc/dnf_types
  *
  * @since 7.0.0
  * @since 7.1.0  Now extends the `AbstractNewFeatureSniff` instead of the base `Sniff` class.
@@ -210,9 +212,10 @@ public function process(File $phpcsFile, $stackPtr)
         $returnType         = \ltrim($properties['return_type'], '?'); // Trim off potential nullability.
         $returnType         = \strtolower($returnType);
         $returnTypeToken    = $properties['return_type_token'];
-        $types              = \preg_split('`[|&]`', $returnType, -1, \PREG_SPLIT_NO_EMPTY);
-        $isUnionType        = (\strpos($returnType, '|') !== false);
-        $isIntersectionType = (\strpos($returnType, '&') !== false);
+        $types              = \preg_split('`[|&()]`', $returnType, -1, \PREG_SPLIT_NO_EMPTY);
+        $isUnionType        = (\strpos($returnType, '|') !== false && \strpos($returnType, '(') === false);
+        $isIntersectionType = (\strpos($returnType, '&') !== false && \strpos($returnType, '(') === false);
+        $isDNFType          = \strpos($returnType, '(') !== false;
 
         if (ScannedCode::shouldRunOnOrBelow('7.4') === true && $isUnionType === true) {
             $phpcsFile->addError(
@@ -232,6 +235,15 @@ public function process(File $phpcsFile, $stackPtr)
             );
         }
 
+        if (ScannedCode::shouldRunOnOrBelow('8.1') === true && $isDNFType === true) {
+            $phpcsFile->addError(
+                'Disjunctive Normal Form types are not present in PHP version 8.1 or earlier. Found: %s',
+                $returnTypeToken,
+                'DNFTypeFound',
+                [$properties['return_type']]
+            );
+        }
+
         foreach ($types as $type) {
             if (isset($this->newTypes[$type]) === true) {
                 $itemInfo = [

PHPCompatibility/Tests/Classes/NewTypedPropertiesUnitTest.inc

@@ -169,3 +169,18 @@ class EdgeCase {
 class ShouldBeDetected {
     public int $property;
 }
+
+// PHP 8.2 DNF types.
+class DNFTypes {
+    public (Foo&Bar)|null $dnf1;
+    public readonly (A&B)|(C&D) $dnf2;
+
+    // Intentional fatal error - &/| reversed, but that's not the concern of the sniff.
+    public B&(D|W) $illegalDnf;
+
+    // Intentional fatal error - segments are not unique, but that's not the concern of the sniff.
+    public (A&B)|(B&A) $duplicateNotAllowed;
+
+    // Intentional fatal error - segments which are strict subsets of others are disallowed, but that's not the concern of the sniff.
+    public (A&self)|A $nonSubsetNotAllowedPlusSelf;
+}

PHPCompatibility/Tests/Classes/NewTypedPropertiesUnitTest.php

@@ -103,6 +103,11 @@ public static function dataNewTypedProperties()
             [161],
             [165],
             [170],
+            [175],
+            [176],
+            [179],
+            [182],
+            [185],
         ];
     }
 
@@ -231,6 +236,7 @@ public static function dataNewTypedPropertyTypes()
             ['false', '7.4', 99, '8.0'],
             ['mixed', '7.4', 116, '8.0', false],
             ['true', '8.1', 147, '8.2'],
+            ['null', '7.4', 175, '8.2'],
         ];
     }
 
@@ -338,6 +344,7 @@ public static function dataInvalidNonUnionNullFalseType()
         return [
             [93, 'null'],
             [96, 'false'],
+            [175, 'null'],
         ];
     }
 
@@ -413,6 +420,44 @@ public static function dataNewIntersectionTypes()
     }
 
 
+    /**
+     * Verify that an error is thrown for DNF types.
+     *
+     * @dataProvider dataNewDNFTypes
+     *
+     * @param string $type The declared type.
+     * @param int    $line The line number where the error is expected.
+     *
+     * @return void
+     */
+    public function testNewDNFTypes($type, $line)
+    {
+        $file = $this->sniffFile(__FILE__, '8.1');
+        $this->assertError($file, $line, "Disjunctive Normal Form types are not present in PHP version 8.1 or earlier. Found: $type");
+
+        $file = $this->sniffFile(__FILE__, '8.2');
+        $this->assertNoViolation($file, $line);
+    }
+
+    /**
+     * Data provider.
+     *
+     * @see testNewDNFTypes()
+     *
+     * @return array
+     */
+    public static function dataNewDNFTypes()
+    {
+        return [
+            ['(Foo&Bar)|null', 175],
+            ['(A&B)|(C&D)', 176],
+            ['B&(D|W)', 179],
+            ['(A&B)|(B&A)', 182],
+            ['(A&self)|A', 185],
+        ];
+    }
+
+
     /*
      * `testNoViolationsInFileOnValidVersion` test omitted as this sniff will also throw warnings/errors
      * about invalid typed properties.

PHPCompatibility/Tests/FunctionDeclarations/NewParamTypeDeclarationsUnitTest.inc

@@ -168,3 +168,19 @@ enum Suit implements Colorful
         A&B $intersection,
     ): mixed {}
 }
+
+// PHP 8.2 DNF types.
+function NOTDnfTypeParamDefault($param = (CONST_A & CONST_B) | CONST_C) {}
+
+function DNFTypes((Foo&Bar)|null $a, int|(\A&\B) $b) {}
+$closure = function($a, (A&B)|(C&D) $b) {};
+
+// Intentional fatal error - &/| reversed, but that's not the concern of the sniff.
+$arrow = fn(B&(D|W)|null $a) => $a;
+
+// Intentional fatal error - segments are not unique, but that's not the concern of the sniff.
+$arrow = fn((A&B)|(B&A) $a) => $a;
+
+// Intentional fatal error - segments which are strict subsets of others are disallowed, but that's not the concern of the sniff.
+// Intentional fatal error - using self type outside a class is invalid.
+$arrow = fn((A&self)|A $a) => $a;