Add simplifiable match rule (wemake-services#3526)

Co-authored-by: sobolevn <[email protected]>

Author: ZhdanovAM72

CHANGELOG.md

@@ -17,6 +17,13 @@ Semantic versioning in our case means:
   change the client facing API, change code conventions significantly, etc.
 
 
+## 1.5.0
+
+### Features
+
+- Adds `WPS365`: match statement can be simplified to `if`, #3520
+
+
 ## 1.4.0
 
 ### Features

docs/pages/usage/setup.rst

@@ -29,7 +29,7 @@ Required configuration
 ----------------------
 
 You must either provide ``--select=WPS`` to all your ``flake8`` calls,
-or add ``select = WPS`` into your ``flake8`` configration file.
+or add ``select = WPS`` into your ``flake8`` configuration file.
 
 Running
 -------

tests/fixtures/noqa/noqa.py

@@ -616,6 +616,12 @@ def many_raises_function(parameter):  # noqa: WPS238
     case 8:
         my_print('eighth')
 
+match subject:  # noqa: WPS365
+    case 1:
+        ...
+    case _:
+        ...
+
 
 my_print("""
 text

tests/test_checker/test_noqa.py

@@ -166,6 +166,7 @@
         'WPS362': 2,
         'WPS363': 1,
         'WPS364': 1,
+        'WPS365': 1,
         'WPS400': 0,  # defined in ignored violations.
         'WPS401': 0,  # logically unacceptable.
         'WPS402': 0,  # defined in ignored violations.

tests/test_visitors/test_ast/test_conditions/test_simplified_match_conditions.py

@@ -0,0 +1,189 @@
+import pytest
+
+from wemake_python_styleguide.violations.consistency import (
+    SimplifiableMatchViolation,
+)
+from wemake_python_styleguide.visitors.ast.conditions import (
+    SimplifiableMatchVisitor,
+)
+
+# Wrong:
+simplifiable_match_match = """
+match subject:
+    case {0}{1}:
+        pass
+    case _:
+        pass
+"""
+
+simplifiable_union_match_match = """
+match subject:
+    case {0} | {1}{2}:
+        pass
+    case _:
+        pass
+"""
+
+simplifiable_guard_match = """
+match subject:
+    case x if x > 0:
+        pass
+    case _:
+        pass
+"""
+
+# Correct:
+complex_match = """
+match subject:
+    case State.FIRST:
+        pass
+    case State.SECOND:
+        pass
+    case _:
+        pass
+"""
+
+no_wildcard_match = """
+match subject:
+    case State.FIRST:
+        pass
+    case State.SECOND:
+        pass
+"""
+
+guard_match = """
+match subject:
+    case [x] if x > 0:
+        pass
+    case _:
+        pass
+"""
+
+class_with_args_match = """
+match subject:
+    case SomeClass(x):
+        pass
+    case _:
+        pass
+"""
+
+class_with_kwargs_match = """
+match subject:
+    case SomeClass(name=x):
+        pass
+    case _:
+        pass
+"""
+
+sequences_match = """
+match subject:
+    case [x, *rest]:
+        pass
+    case _:
+        pass
+"""
+
+mappings_match = """
+match subject:
+    case {"key": x}:
+        pass
+    case _:
+        pass
+"""
+
+
+@pytest.mark.parametrize(
+    'code',
+    [
+        '1',
+        'True',
+        'None',
+        '"string"',
+        'ns.CONST',
+        'State.REJECTED',
+    ],
+)
+@pytest.mark.parametrize(
+    'as_binding',
+    ['', ' as x'],
+)
+def test_simplifiable_single_match(
+    code,
+    as_binding,
+    assert_errors,
+    parse_ast_tree,
+    default_options,
+):
+    """Test that simple single-case match raises a violation."""
+    tree = parse_ast_tree(simplifiable_match_match.format(code, as_binding))
+    visitor = SimplifiableMatchVisitor(default_options, tree=tree)
+    visitor.run()
+    assert_errors(visitor, [SimplifiableMatchViolation])
+
+
+def test_simplifiable_guarded_match(
+    assert_errors,
+    parse_ast_tree,
+    default_options,
+):
+    """Test that guarded irrefutable match is simplified."""
+    tree = parse_ast_tree(simplifiable_guard_match)
+    visitor = SimplifiableMatchVisitor(default_options, tree=tree)
+    visitor.run()
+    assert_errors(visitor, [SimplifiableMatchViolation])
+
+
+@pytest.mark.parametrize(
+    ('left', 'right'),
+    [
+        ('1', '2'),
+        ('True', 'False'),
+        ('"a"', '"b"'),
+        ('State.OK', 'State.ERROR'),
+        ('"first" | "second"', '"third"'),
+    ],
+)
+@pytest.mark.parametrize(
+    'as_binding',
+    ['', ' as x'],
+)
+def test_simplifiable_union_match(
+    left,
+    right,
+    as_binding,
+    assert_errors,
+    parse_ast_tree,
+    default_options,
+):
+    """Test that union pattern raises violation."""
+    tree = parse_ast_tree(
+        simplifiable_union_match_match.format(left, right, as_binding)
+    )
+    visitor = SimplifiableMatchVisitor(default_options, tree=tree)
+    visitor.run()
+    assert_errors(visitor, [SimplifiableMatchViolation])
+
+
+@pytest.mark.parametrize(
+    'template',
+    [
+        complex_match,
+        no_wildcard_match,
+        guard_match,
+        class_with_args_match,
+        class_with_kwargs_match,
+        sequences_match,
+        mappings_match,
+    ],
+)
+def test_not_simplifiable_match_templates(
+    template,
+    assert_errors,
+    parse_ast_tree,
+    default_options,
+):
+    """Test that complex or non-simplifiable matches do not raise violations."""
+    tree = parse_ast_tree(template)
+    visitor = SimplifiableMatchVisitor(default_options, tree=tree)
+    visitor.run()
+    assert_errors(visitor, [])

wemake_python_styleguide/logic/tree/pattern_matching.py

@@ -45,3 +45,60 @@ def is_constant_subject(condition: ast.AST | list[ast.expr]) -> bool:
             and is_constant_subject(node.values)
         )
     return False
+
+
+def is_wildcard_pattern(case: ast.match_case) -> bool:
+    """Returns True only for `case _:`."""
+    pattern = case.pattern
+    return (
+        isinstance(pattern, ast.MatchAs)
+        and pattern.pattern is None
+        and pattern.name is None
+    )
+
+
+def is_simple_pattern(pattern: ast.pattern) -> bool:
+    """Returns True if the pattern is simple enough to replace with `==`."""
+    return _is_simple_value_or_singleton(pattern) or _is_simple_composite(
+        pattern
+    )
+
+
+def _is_simple_composite(pattern: ast.pattern) -> bool:
+    """Returns True/False for MatchOr and MatchAs, None otherwise."""
+    if isinstance(pattern, ast.MatchOr):
+        return all(is_simple_pattern(sub) for sub in pattern.patterns)
+    if isinstance(pattern, ast.MatchAs):
+        inner = pattern.pattern
+        return inner is not None and is_simple_pattern(inner)
+    return False
+
+
+def _is_simple_value_or_singleton(pattern: ast.pattern) -> bool:
+    """
+    Checks if a pattern is a simple literal or singleton.
+
+    Supports:
+    - Single values: ``1``, ``"text"``, ``ns.CONST``.
+    - Singleton values: ``True``, ``False``, ``None``.
+    """
+    if isinstance(pattern, ast.MatchSingleton):
+        return True
+    if isinstance(pattern, ast.MatchValue):
+        return isinstance(
+            pattern.value, (ast.Constant, ast.Name, ast.Attribute)
+        )
+    return False
+
+
+def is_irrefutable_binding(pattern: ast.pattern) -> bool:
+    """
+    Returns True for patterns like ``case x:`` or ``case data:``.
+
+    These always match and just bind the subject to a name.
+    """
+    return (
+        isinstance(pattern, ast.MatchAs)
+        and pattern.pattern is None
+        and pattern.name is not None
+    )

wemake_python_styleguide/presets/types/tree.py

@@ -70,6 +70,7 @@
     conditions.BooleanConditionVisitor,
     conditions.MatchVisitor,
     conditions.ChainedIsVisitor,
+    conditions.SimplifiableMatchVisitor,
     iterables.IterableUnpackingVisitor,
     blocks.AfterBlockVariablesVisitor,
     subscripts.SubscriptVisitor,

wemake_python_styleguide/violations/consistency.py

@@ -2415,3 +2415,48 @@ class NotInWithUnaryOpViolation(ASTViolation):
 
     error_template = 'Found legacy `not ... in`, use `... not in` instead'
     code = 364
+
+
+@final
+class SimplifiableMatchViolation(ASTViolation):
+    """
+    Some ``match`` statements can be simplified to ``if`` statements.
+
+    Reasoning:
+        Using ``match`` for simple two-case conditions
+        (including wildcard ``_``)
+        is unnecessarily verbose and less performant than a plain ``if/else``.
+        Simple conditions should prefer readability and simplicity.
+
+    Solution:
+        Replace violating ``match ... case _`` statements with ``if ... else``.
+
+    When is this violation is raised?
+        - When there are exactly two ``case`` statements
+        - When the first case uses a literal pattern
+        - When the second case is a wildcard: ``case _:``
+
+
+    Example::
+
+        # Correct:
+        if state == EventType.REJECT:
+            user = 'rejected'
+        else:
+            user = 'active'
+
+        # Wrong:
+        match state:
+            case EventType.REJECT:
+                user = 'rejected'
+            case _:
+                user = 'active'
+
+    .. versionadded:: 1.5.0
+
+    """
+
+    error_template = (
+        'Found simplifiable `match` statement that can be just `if`'
+    )
+    code = 365

wemake_python_styleguide/visitors/ast/conditions.py

@@ -9,10 +9,12 @@
     compares,
     ifs,
     operators,
+    pattern_matching,
 )
 from wemake_python_styleguide.types import AnyIf, AnyNodes
 from wemake_python_styleguide.violations import (
     best_practices,
+    consistency,
     refactoring,
 )
 from wemake_python_styleguide.visitors.base import BaseNodeVisitor
@@ -188,3 +190,26 @@ def visit_Compare(self, node: ast.Compare) -> None:
             self.add_violation(refactoring.ChainedIsViolation(node))
 
         self.generic_visit(node)
+
+
+@final
+class SimplifiableMatchVisitor(BaseNodeVisitor):
+    """Checks for match statements that can be simplified to if/else."""
+
+    def visit_Match(self, node: ast.Match) -> None:
+        """Checks match statements."""
+        self._check_simplifiable_match(node)
+        self.generic_visit(node)
+
+    def _check_simplifiable_match(self, node: ast.Match) -> None:
+        cases = node.cases
+        if len(cases) == 2:
+            first, second = cases
+
+            if not pattern_matching.is_wildcard_pattern(second):
+                return
+
+            if pattern_matching.is_irrefutable_binding(
+                first.pattern
+            ) or pattern_matching.is_simple_pattern(first.pattern):
+                self.add_violation(consistency.SimplifiableMatchViolation(node))