WPS330: fix false positive when alternating operators (#3614)

Author: j2cry

CHANGELOG.md

@@ -22,6 +22,7 @@ Semantic versioning in our case means:
 ### Bugfixes
 
 - Fixes false positive `WPS366` allowing the use of a single constant in `or`, #3610
+- Fixes the false positive `WPS330` when alternating unary operators, #3594
 
 ## 1.6.0
 

tests/test_visitors/test_ast/test_operators/test_useless_operators_before_numbers.py

@@ -50,21 +50,23 @@ def function_name(param1, param2={0}):
         '---5',
         '~~5',
         '~~~5',
+        '~~-5',
+        '~---5',
         '(not not 5)',
         '(not not None)',
         '(not not not True)',
         '(not not False)',
     ],
 )
-def test_plus_sign_before_numbers(
+def test_useless_unary_operator(
     assert_errors,
     parse_ast_tree,
     code,
     number,
     default_options,
     mode,
 ):
-    """Testing that there is no useless plus sign before a number."""
+    """Testing that one of the unary operators before a number is useless."""
     tree = parse_ast_tree(mode(code.format(number)))
 
     visitor = UselessOperatorsVisitor(default_options, tree=tree)
@@ -84,19 +86,21 @@ def test_plus_sign_before_numbers(
         '5',
         '-5',
         '~5',
+        '~-~5',
+        '-~-5',
         '(not 5)',
         '(not True)',
     ],
 )
-def test_plus_sign_before_numbers_valid(
+def test_useful_unary_operator(
     assert_errors,
     parse_ast_tree,
     code,
     number,
     default_options,
     mode,
 ):
-    """Testing that there is no useless plus sign before a number."""
+    """Testing that there is no useless unary operator before a number."""
     tree = parse_ast_tree(mode(code.format(number)))
 
     visitor = UselessOperatorsVisitor(default_options, tree=tree)

wemake_python_styleguide/logic/tree/operators.py

@@ -35,18 +35,24 @@ def get_parent_ignoring_unary(node: ast.AST) -> ast.AST | None:
         node = parent
 
 
-def count_unary_operator(
+def count_consecutive_unary_operator(
     node: ast.AST,
     operator: type[ast.unaryop],
-    amount: int = 0,
+    counter: int = 0,
+    max_counter: int = 0,
 ) -> int:
-    """Returns amount of unary operators matching input."""
+    """Counts the maximum number of consecutive identical unary operators."""
     parent = get_parent(node)
-    if parent is None or not isinstance(parent, ast.UnaryOp):
-        return amount
+    if not isinstance(parent, ast.UnaryOp):
+        return max(counter, max_counter)
+
     if isinstance(parent.op, operator):
-        return count_unary_operator(parent, operator, amount + 1)
-    return count_unary_operator(parent, operator, amount)
+        return count_consecutive_unary_operator(
+            parent, operator, counter + 1, max_counter
+        )
+    if counter > max_counter:
+        return count_consecutive_unary_operator(parent, operator, 0, counter)
+    return count_consecutive_unary_operator(parent, operator, 0, max_counter)
 
 
 def get_reduced_unary_operators(

wemake_python_styleguide/visitors/ast/operators.py

@@ -7,7 +7,7 @@
 from wemake_python_styleguide.logic import walk
 from wemake_python_styleguide.logic.nodes import get_parent
 from wemake_python_styleguide.logic.tree.operators import (
-    count_unary_operator,
+    count_consecutive_unary_operator,
     get_reduced_unary_operators,
     unwrap_unary_node,
 )
@@ -105,7 +105,7 @@ def visit_AugAssign(self, node: ast.AugAssign) -> None:
 
     def _check_operator_count(self, node: ast.Constant) -> None:
         for node_type, limit in self._unary_limits.items():
-            if count_unary_operator(node, node_type) > limit:
+            if count_consecutive_unary_operator(node, node_type) > limit:
                 self.add_violation(
                     consistency.UselessOperatorsViolation(
                         node,