Squiz/NonExecutableCode: bug fix - PHP 8.0 inline throw expressions

PHP 8.0 introduced the ability to use `throw` as an expression instead of as a statement.
Ref: https://wiki.php.net/rfc/throw_expression

When used as an expression, the `throw` does not necessarily affect the code after it.

See: https://3v4l.org/AmMf2

Fixed now.

Includes unit tests.

Fixes 3592

Author: jrfnl

src/Standards/Squiz/Sniffs/PHP/NonExecutableCodeSniff.php

@@ -22,9 +22,15 @@ class NonExecutableCodeSniff implements Sniff
      * This is in contrast to terminating statements, which cannot be used inline
      * and would result in a parse error (which is not the concern of this sniff).
      *
+     * `throw` can be used as an expression since PHP 8.0.
+     * {@link https://wiki.php.net/rfc/throw_expression}
+     *
      * @var array
      */
-    private $expressionTokens = [T_EXIT => T_EXIT];
+    private $expressionTokens = [
+        T_EXIT  => T_EXIT,
+        T_THROW => T_THROW,
+    ];
 
 
     /**
@@ -65,7 +71,10 @@ public function process(File $phpcsFile, $stackPtr)
         if (isset($this->expressionTokens[$tokens[$stackPtr]['code']]) === true) {
             // If this token is preceded by a logical operator, it only relates to one line
             // and should be ignored. For example: fopen() or die().
-            if (isset(Tokens::$booleanOperators[$tokens[$prev]['code']]) === true) {
+            // Note: There is one exception: throw expressions can not be used with xor.
+            if (isset(Tokens::$booleanOperators[$tokens[$prev]['code']]) === true
+                && ($tokens[$stackPtr]['code'] === T_THROW && $tokens[$prev]['code'] === T_LOGICAL_XOR) === false
+            ) {
                 return;
             }
 

src/Standards/Squiz/Tests/PHP/NonExecutableCodeUnitTest.1.inc

@@ -348,5 +348,53 @@ function exitExpressionsInArrowFunction() {
     echo 'still executable';
 }
 
+// PHP 8.0+: throw expressions which don't stop execution.
+function nonStoppingThrowExpressions() {
+    $callable = fn() => throw new Exception();
+
+    $value = $myValue ? 'something' : throw new Exception();
+    $value = $myValue ?: throw new Exception();
+    $value = $myValue ? throw new Exception() : 'something';
+
+    $value = $nullableValue ?? throw new Exception();
+    $value ??= throw new Exception();
+
+    $condition && throw new Exception();
+    $condition || throw new Exception();
+    $condition and throw new Exception();
+    $condition or throw new Exception();
+
+    echo 'still executable as throw, in all of the above cases, is used as part of an expression';
+
+    throw new Exception();
+    echo 'non-executable';
+}
+
+// PHP 8.0+: throw expressions which do stop execution.
+function executionStoppingThrowExpressionsA() {
+    $condition xor throw new Exception();
+    echo 'non-executable';
+}
+
+function executionStoppingThrowExpressionsB() {
+    throw $userIsAuthorized ? new ForbiddenException() : new UnauthorizedException();
+    echo 'non-executable';
+}
+
+function executionStoppingThrowExpressionsC() {
+    throw $condition1 && $condition2 ? new Exception1() : new Exception2();
+    echo 'non-executable';
+}
+
+function executionStoppingThrowExpressionsD() {
+    throw $exception ??= new Exception();
+    echo 'non-executable';
+}
+
+function executionStoppingThrowExpressionsE() {
+    throw $maybeNullException ?? new Exception();
+    echo 'non-executable';
+}
+
 // Intentional syntax error.
 return array_map(

src/Standards/Squiz/Tests/PHP/NonExecutableCodeUnitTest.php

@@ -76,6 +76,12 @@ public function getWarningList($testFile='')
                 254 => 2,
                 303 => 1,
                 308 => 1,
+                370 => 1,
+                376 => 1,
+                381 => 1,
+                386 => 1,
+                391 => 1,
+                396 => 1,
             ];
             break;
         case 'NonExecutableCodeUnitTest.2.inc':