WPS345: forbid symmetric bitwise operations (#3593)

Author: j2cry

CHANGELOG.md

@@ -27,6 +27,7 @@ Semantic versioning in our case means:
 - Fixes false positive `WPS457` for ``while True`` loop with ``await`` expressions, #3753
 - Fixes the false positive `WPS617` by assigning a function that receives a lambda expression as a parameter.
 - Fixes false positive `WPS430` for whitelisted nested functions, #3589
+- Fixes `WPS345` to forbid symmetric bitwise operations, #3593
 
 
 ## 1.5.0

tests/test_visitors/test_ast/test_operators/test_useless_math.py

@@ -2,6 +2,7 @@
 
 from wemake_python_styleguide.violations.consistency import (
     MeaninglessNumberOperationViolation,
+    UselessOperatorsViolation,
 )
 from wemake_python_styleguide.visitors.ast.operators import (
     UselessOperatorsVisitor,
@@ -105,6 +106,67 @@ def test_useful_math(
     assert_errors(visitor, [])
 
 
+@pytest.mark.parametrize(
+    'expression',
+    [
+        '6 & 6',
+        '1 & True',
+        '(not -3) | (not -3)',
+        '-~8 ^ -~8',
+        '+7 & +++7',
+        '-~-7 | -~-7',
+        '(not not --7) ^ 7',
+    ],
+)
+def test_meaningless_symmetric_bitwise_math(
+    assert_errors,
+    parse_ast_tree,
+    expression,
+    default_options,
+):
+    """Testing that symmetric bitwise operations are forbidden."""
+    tree = parse_ast_tree(expression)
+
+    visitor = UselessOperatorsVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(
+        visitor,
+        [MeaninglessNumberOperationViolation],
+        ignored_types=UselessOperatorsViolation,
+    )
+
+
+@pytest.mark.parametrize(
+    'expression',
+    [
+        '5 & 6',
+        '(not -2) | 3',
+        '-~7 ^ -~8',
+        'value | 2',
+        '-value & -3',
+        'value ^ -1',
+        '+6 & +++7',
+        '-~-4 | -~-7',
+        '(not not --8) ^ 7',
+        'value | ~~4',
+    ],
+)
+def test_useful_asymmetric_bitwise_math(
+    assert_errors,
+    parse_ast_tree,
+    expression,
+    default_options,
+):
+    """Testing that asymmetric bitwise operations are allowed."""
+    tree = parse_ast_tree(expression)
+
+    visitor = UselessOperatorsVisitor(default_options, tree=tree)
+    visitor.run()
+
+    assert_errors(visitor, [], ignored_types=UselessOperatorsViolation)
+
+
 @pytest.mark.parametrize(
     'expression',
     [

wemake_python_styleguide/logic/tree/operators.py

@@ -47,3 +47,25 @@ def count_unary_operator(
     if isinstance(parent.op, operator):
         return count_unary_operator(parent, operator, amount + 1)
     return count_unary_operator(parent, operator, amount)
+
+
+def get_reduced_unary_operators(
+    node: ast.AST,
+    opchain: list[type[ast.unaryop]] | None = None,
+) -> list[type[ast.unaryop]]:
+    """Returns a sequence of significant unary operators."""
+    if opchain is None:
+        opchain = []
+
+    parent = get_parent(node)
+    if not isinstance(parent, ast.UnaryOp):
+        return opchain
+
+    if not isinstance(parent.op, ast.UAdd):
+        lastop = opchain[-1] if opchain else None
+        if lastop and isinstance(parent.op, lastop):
+            opchain.pop()
+        else:
+            opchain.append(type(parent.op))
+
+    return get_reduced_unary_operators(parent, opchain)

wemake_python_styleguide/visitors/ast/operators.py

@@ -7,6 +7,7 @@
 from wemake_python_styleguide.logic.nodes import get_parent
 from wemake_python_styleguide.logic.tree.operators import (
     count_unary_operator,
+    get_reduced_unary_operators,
     unwrap_unary_node,
 )
 from wemake_python_styleguide.types import AnyNodes
@@ -31,7 +32,7 @@
         'visit_NameConstant',
     ),
 )
-class UselessOperatorsVisitor(base.BaseNodeVisitor):
+class UselessOperatorsVisitor(base.BaseNodeVisitor):  # noqa: WPS214
     """Checks operators used in the code."""
 
     _unary_limits: ClassVar[_OperatorLimits] = {
@@ -85,6 +86,7 @@ def visit_BinOp(self, node: ast.BinOp) -> None:
         """Visits binary operators."""
         self._check_zero_division(node.op, node.right)
         self._check_useless_math_operator(node.op, node.left, node.right)
+        self._check_useless_symmetric_operator(node.op, node.left, node.right)
         self.generic_visit(node)
 
     def visit_AugAssign(self, node: ast.AugAssign) -> None:
@@ -137,6 +139,32 @@ def _check_useless_math_operator(
                     consistency.MeaninglessNumberOperationViolation(number),
                 )
 
+    def _check_useless_symmetric_operator(
+        self,
+        op: ast.operator,
+        left: ast.AST,
+        right: ast.AST,
+    ) -> None:
+        real_left = unwrap_unary_node(left)
+        real_right = unwrap_unary_node(right)
+        if not (
+            isinstance(real_left, ast.Constant)
+            and isinstance(real_right, ast.Constant)
+        ):
+            return
+
+        left_unary_ops = get_reduced_unary_operators(real_left)
+        right_unary_ops = get_reduced_unary_operators(real_right)
+        if isinstance(op, (ast.BitAnd, ast.BitOr, ast.BitXor)):
+            is_identical_constants = (
+                real_left.value == real_right.value
+                and left_unary_ops == right_unary_ops
+            )
+            if is_identical_constants:
+                self.add_violation(
+                    consistency.MeaninglessNumberOperationViolation(right)
+                )
+
     def _get_non_negative_nodes(
         self,
         left: ast.AST | None,