Add Universal.CodeAnalysis.MixedBooleanOperator

README.md

@@ -229,6 +229,10 @@ Detects `foreach` control structures which use the same variable for both the ke
 
 Note: The fixer will maintain the existing behaviour of the code. This may not be the _intended_ behaviour.
 
+#### `Universal.CodeAnalysis.MixedBooleanOperator` :books:
+
+Forbids mixing `&&` and `||` within a single expression without making precedence clear using parentheses.
+
 #### `Universal.CodeAnalysis.NoEchoSprintf` :wrench: :books:
 
 Detects use of the inefficient `echo [v]sprintf(...);` combi. Use `[v]printf()` instead.

Universal/Docs/CodeAnalysis/MixedBooleanOperatorStandard.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0"?>
+<documentation xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="https://phpcsstandards.github.io/PHPCSDevTools/phpcsdocs.xsd"
+    title="Mixed Boolean Operator"
+    >
+    <standard>
+    <![CDATA[
+    Forbids mixing `&&` and `||` within a single expression without making precedence clear using parentheses.
+    ]]>
+    </standard>
+    <code_comparison>
+        <code title="Valid: Making precedence clear with parentheses.">
+        <![CDATA[
+$one = false;
+$two = false;
+$three = true;
+
+$result = <em>($one && $two) || $three</em>;
+$result2 = <em>$one && ($two || $three)</em>;
+        ]]>
+        </code>
+        <code title="Invalid: Not using parentheses.">
+        <![CDATA[
+$one = false;
+$two = false;
+$three = true;
+
+$result = <em>$one && $two || $three</em>;
+        ]]>
+        </code>
+    </code_comparison>
+</documentation>

Universal/Sniffs/CodeAnalysis/MixedBooleanOperatorSniff.php

@@ -0,0 +1,107 @@
+<?php
+/**
+ * PHPCSExtra, a collection of sniffs and standards for use with PHP_CodeSniffer.
+ *
+ * @package   PHPCSExtra
+ * @copyright 2021 WoltLab GmbH, 2023 PHPCSExtra Contributors
+ * @license   https://opensource.org/licenses/LGPL-3.0 LGPL3
+ * @link      https://github.com/PHPCSStandards/PHPCSExtra
+ */
+
+namespace PHPCSExtra\Universal\Sniffs\CodeAnalysis;
+
+use PHP_CodeSniffer\Files\File;
+use PHP_CodeSniffer\Sniffs\Sniff;
+
+/**
+ * Forbid mixing `&&` and `||` within a single expression without making precedence
+ * clear using parentheses.
+ *
+ * @link https://github.com/squizlabs/PHP_CodeSniffer/pull/3205
+ * @link https://github.com/php-fig/per-coding-style/issues/22
+ *
+ * @since 1.2.0
+ */
+final class MixedBooleanOperatorSniff implements Sniff
+{
+
+    /**
+     * Returns an array of tokens this test wants to listen for.
+     *
+     * @since 1.2.0
+     *
+     * @return array<int|string>
+     */
+    public function register()
+    {
+        return [
+            \T_BOOLEAN_OR,
+            \T_BOOLEAN_AND,
+        ];
+    }
+
+    /**
+     * Processes this test, when one of its tokens is encountered.
+     *
+     * @since 1.2.0
+     *
+     * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
+     * @param int                         $stackPtr  The position of the current token
+     *                                               in the stack passed in $tokens.
+     *
+     * @return void
+     */
+    public function process(File $phpcsFile, $stackPtr)
+    {
+        $tokens = $phpcsFile->getTokens();
+        $token  = $tokens[$stackPtr];
+
+        $start = $phpcsFile->findStartOfStatement($stackPtr);
+
+        if ($token['code'] === T_BOOLEAN_AND) {
+            $search = T_BOOLEAN_OR;
+        } elseif ($token['code'] === T_BOOLEAN_OR) {
+            $search = T_BOOLEAN_AND;
+        } else {
+            throw new \LogicException('Unreachable');
+        }
+
+        while (true) {
+            $previous = $phpcsFile->findPrevious(
+                [
+                    $search,
+                    T_OPEN_PARENTHESIS,
+                    T_OPEN_SQUARE_BRACKET,
+                    T_CLOSE_PARENTHESIS,
+                    T_CLOSE_SQUARE_BRACKET,
+                ],
+                $stackPtr,
+                $start
+            );
+
+            if ($previous === false) {
+                break;
+            }
+
+            if ($tokens[$previous]['code'] === T_OPEN_PARENTHESIS
+                || $tokens[$previous]['code'] === T_OPEN_SQUARE_BRACKET
+            ) {
+                // We halt if we reach the opening parens / bracket of the boolean operator.
+                return;
+            } elseif ($tokens[$previous]['code'] === T_CLOSE_PARENTHESIS) {
+                // We skip the content of nested parens.
+                $stackPtr = ($tokens[$previous]['parenthesis_opener'] - 1);
+            } elseif ($tokens[$previous]['code'] === T_CLOSE_SQUARE_BRACKET) {
+                // We skip the content of nested brackets.
+                $stackPtr = ($tokens[$previous]['bracket_opener'] - 1);
+            } elseif ($tokens[$previous]['code'] === $search) {
+                // We reached a mismatching operator, thus we must report the error.
+                $error = "Mixed '&&' and '||' within an expression without using parentheses.";
+                $phpcsFile->addError($error, $stackPtr, 'MissingParentheses', []);
+                return;
+            } else {
+                throw new \LogicException('Unreachable');
+            }
+        }
+    }
+}

Universal/Tests/CodeAnalysis/MixedBooleanOperatorUnitTest.inc

@@ -0,0 +1,41 @@
+<?php
+
+if (true && true || true);
+if ((true && true) || true);
+if (true && (true || true));
+
+$var = true && true || true;
+$var = (true && true) || true;
+$var = true && (true || true);
+
+$complex = true && (true || true) && true;
+$complex = true && (true || true) || true;
+
+if (
+    true
+    && true
+    || true
+);
+
+if (
+    true
+    && (
+        true
+        || true
+    )
+);
+
+if (true && foo(true || true));
+if (true && foo(true && true || true));
+if (true && $foo[true || true]);
+if (true && $foo[true && true || true]);
+
+if (true && foo(true) || true);
+if (true && $foo[true] || true);
+if (true && foo($foo[true]) || true);
+
+$foo[] = true && true || false;
+
+foo([true && true || false]);
+
+if (true && true || true && true);

Universal/Tests/CodeAnalysis/MixedBooleanOperatorUnitTest.php

@@ -0,0 +1,57 @@
+<?php
+/**
+ * PHPCSExtra, a collection of sniffs and standards for use with PHP_CodeSniffer.
+ *
+ * @package   PHPCSExtra
+ * @copyright 2021 WoltLab GmbH, 2023 PHPCSExtra Contributors
+ * @license   https://opensource.org/licenses/LGPL-3.0 LGPL3
+ * @link      https://github.com/PHPCSStandards/PHPCSExtra
+ */
+
+namespace PHPCSExtra\Universal\Tests\CodeAnalysis;
+
+use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest;
+
+/**
+ * Unit test class for the ForeachUniqueAssignment sniff.
+ *
+ * @covers PHPCSExtra\Universal\Sniffs\CodeAnalysis\MixedBooleanOperatorSniff
+ *
+ * @since 1.2.0
+ */
+final class MixedBooleanOperatorUnitTest extends AbstractSniffUnitTest
+{
+
+    /**
+     * Returns the lines where errors should occur.
+     *
+     * @return array<int, int> Key is the line number, value is the number of expected errors.
+     */
+    public function getErrorList()
+    {
+        return [
+            3  => 1,
+            7  => 1,
+            12 => 1,
+            17 => 1,
+            29 => 1,
+            31 => 1,
+            33 => 1,
+            34 => 1,
+            35 => 1,
+            37 => 1,
+            39 => 1,
+            41 => 2,
+        ];
+    }
+
+    /**
+     * Returns the lines where warnings should occur.
+     *
+     * @return array<int, int> Key is the line number, value is the number of expected warnings.
+     */
+    public function getWarningList()
+    {
+        return [];
+    }
+}