Tokenizer/PHP: add more tests with FQN true/false/null

This is already handled correctly in all relevant places, these tests just safeguard that.

Author: jrfnl

tests/Core/Tokenizers/PHP/BackfillFnTokenTest.inc

@@ -107,6 +107,15 @@ fn(array $a) : True => $a;
 /* testNullReturnType */
 fn(array $a) : null => $a;
 
+/* testFQNFalseReturnType */
+fn(array $a) : \FALSE => $a;
+
+/* testFQNTrueReturnType */
+fn(array $a) : \true => $a;
+
+/* testFQNNullReturnType */
+fn(array $a) : \Null => $a;
+
 /* testUnionParamType */
 $arrowWithUnionParam = fn(int|float $param) : SomeClass => new SomeClass($param);
 

tests/Core/Tokenizers/PHP/BackfillFnTokenTest.php

@@ -455,30 +455,39 @@ public function testKeywordReturnTypes($testMarker)
     public static function dataKeywordReturnTypes()
     {
         return [
-            'self'     => [
+            'self'      => [
                 'testMarker'  => '/* testSelfReturnType */',
             ],
-            'parent'   => [
+            'parent'    => [
                 'testMarker'  => '/* testParentReturnType */',
             ],
-            'callable' => [
+            'callable'  => [
                 'testMarker'  => '/* testCallableReturnType */',
             ],
-            'array'    => [
+            'array'     => [
                 'testMarker'  => '/* testArrayReturnType */',
             ],
-            'static'   => [
+            'static'    => [
                 'testMarker'  => '/* testStaticReturnType */',
             ],
-            'false'    => [
+            'false'     => [
                 'testMarker'  => '/* testFalseReturnType */',
             ],
-            'true'     => [
+            'true'      => [
                 'testMarker'  => '/* testTrueReturnType */',
             ],
-            'null'     => [
+            'null'      => [
                 'testMarker'  => '/* testNullReturnType */',
             ],
+            'FQN false' => [
+                'testMarker'  => '/* testFQNFalseReturnType */',
+            ],
+            'FQN true'  => [
+                'testMarker'  => '/* testFQNTrueReturnType */',
+            ],
+            'FQN null'  => [
+                'testMarker'  => '/* testFQNNullReturnType */',
+            ],
         ];
 
     }//end dataKeywordReturnTypes()

tests/Core/Tokenizers/PHP/BitwiseOrTest.inc

@@ -187,6 +187,15 @@ function trueTypeReturn($param): array|true|null {}
 /* testTypeUnionPHP82TrueLast */
 $closure = function ($param): array|true {}
 
+/* testTypeUnionFQNTrue */
+function FQNTrueTypeParam(\True|null $param) {}
+
+/* testTypeUnionFQNFalse */
+function FQNFalseTypeReturn($param): array|\false|null {}
+
+/* testTypeUnionFQNNull */
+$closure = function ($param): array|\NULL {};
+
 /* testLiveCoding */
 // Intentional parse error. This has to be the last test in the file.
 return function( type|

tests/Core/Tokenizers/PHP/BitwiseOrTest.php

@@ -155,6 +155,9 @@ public static function dataTypeUnion()
             'type for function param with true type first'             => ['/* testTypeUnionPHP82TrueFirst */'],
             'return type for function with true type middle'           => ['/* testTypeUnionPHP82TrueMiddle */'],
             'return type for closure with true type last'              => ['/* testTypeUnionPHP82TrueLast */'],
+            'type for function param with FQN true'                    => ['/* testTypeUnionFQNTrue */'],
+            'return type for function with FQN false'                  => ['/* testTypeUnionFQNFalse */'],
+            'return type for closure with FQN null'                    => ['/* testTypeUnionFQNNull */'],
         ];
 
     }//end dataTypeUnion()

tests/Core/Tokenizers/PHP/DNFTypesTest.inc

@@ -225,6 +225,12 @@ abstract class DNFTypes {
     // Illegal type: segments which are strict subsets of others are disallowed, but that's not the concern of the tokenizer.
     public function identifierNamesReturnFQ(
     ) /* testDNFTypeReturnFullyQualified */ : (\Fully\Qualified\NameA&\Fully\Qualified\NameB)|\Fully\Qualified\NameB {}
+
+    public function FQNTrueTypeParam(/* testDNFTypeFQNTrue */ \True|(A&D) $param) {}
+
+    public function FQNFalseTypeReturn($param) /* testDNFTypeFQNFalse */ : (A&D)|\false|null {
+        $closure = function ($param): /* testDNFTypeFQNNull */ (A&D)|\NULL {};
+    }
 }
 
 function globalFunctionWithSpreadAndReference(

tests/Core/Tokenizers/PHP/DNFTypesTest.php

@@ -496,6 +496,15 @@ public static function dataDNFTypeParentheses()
             'OO method return type: fully qualified classes'              => [
                 'testMarker'  => '/* testDNFTypeReturnFullyQualified */',
             ],
+            'OO method param type: fully qualified true'                  => [
+                'testMarker'  => '/* testDNFTypeFQNTrue */',
+            ],
+            'OO method return type: fully qualified false'                => [
+                'testMarker'  => '/* testDNFTypeFQNFalse */',
+            ],
+            'closure return type: fully qualified null'                   => [
+                'testMarker'  => '/* testDNFTypeFQNNull */',
+            ],
             'function param type: with reference'                         => [
                 'testMarker'  => '/* testDNFTypeWithReference */',
             ],

tests/Core/Tokenizers/PHP/TypeIntersectionTest.inc

@@ -162,6 +162,15 @@ function &fn(/* testTypeIntersectionNonArrowFunctionDeclaration */ Foo&Bar $some
 /* testTypeIntersectionWithInvalidTypes */
 function (int&string $var) {};
 
+/* testTypeIntersectionInvalidFQNTrue */
+function FQNTrueTypeParam(\True&MyClass $param) {}
+
+/* testTypeIntersectionInvalidFQNFalse */
+function FQNFalseTypeReturn($param): \SomeOtherClass&\false&MyClass {}
+
+/* testTypeIntersectionInvalidFQNNull */
+$closure = function ($param): MyClass&\NULL {};
+
 /* testLiveCoding */
 // Intentional parse error. This has to be the last test in the file.
 return function( Foo&

tests/Core/Tokenizers/PHP/TypeIntersectionTest.php

@@ -151,6 +151,9 @@ public static function dataTypeIntersection()
             'return type for arrow function'                              => ['/* testTypeIntersectionArrowReturnType */'],
             'type for function parameter, return by ref'                  => ['/* testTypeIntersectionNonArrowFunctionDeclaration */'],
             'type for function parameter with invalid types'              => ['/* testTypeIntersectionWithInvalidTypes */'],
+            'type for method parameter, includes (invalid) FQN true'      => ['/* testTypeIntersectionInvalidFQNTrue */'],
+            'return type for method, includes (invalid) FQN false'        => ['/* testTypeIntersectionInvalidFQNFalse */'],
+            'return type for closure, includes (invalid) FQN null'        => ['/* testTypeIntersectionInvalidFQNNull */'],
         ];
 
     }//end dataTypeIntersection()