Consider irrefutable pattern similar to if .. else for C901

crates/ruff_linter/src/rules/mccabe/rules/function_is_too_complex.rs

@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, ExceptHandler, Stmt};
+use ruff_python_ast::{self as ast, ExceptHandler, Pattern, Stmt};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
@@ -100,6 +100,28 @@ fn get_complexity_number(stmts: &[Stmt]) -> usize {
                     complexity += 1;
                     complexity += get_complexity_number(&case.body);
                 }
+                if let Some(last_case) = cases.last() {
+                    if let Pattern::MatchAs(match_as_pattern) = &last_case.pattern {
+                        if match_as_pattern.pattern.is_none() {
+                            // The complexity of an irrefutable pattern is similar to an `else` block of an `if` statement.
+                            // This is either a wildcard pattern or a named catch-all pattern.
+                            // 
+                            // For example:
+                            // ```python
+                            // match subject:
+                            //     case 1: ...
+                            //     case _: ...
+                            //
+                            // match subject:
+                            //     case 1: ...
+                            //     case foo: ...
+                            // ```
+                            //
+                            // Irrefutable pattern: https://peps.python.org/pep-0634/#irrefutable-case-blocks
+                            complexity -= 1;
+                        }
+                    }
+                }
             }
             Stmt::Try(ast::StmtTry {
                 body,
@@ -431,17 +453,49 @@ def with_lock():
     }
 
     #[test]
-    fn match_case() -> Result<()> {
+    fn simple_match_case() -> Result<()> {
         let source = r"
 def f():
-    match a:
-        case 30:
+    match subject:
+        case 2:
             print('foo')
         case _:
             print('bar')
+";
+        let stmts = parse_suite(source)?;
+        assert_eq!(get_complexity_number(&stmts), 2);
+        Ok(())
+    }
+
+    #[test]
+    fn multiple_match_case() -> Result<()> {
+        let source = r"
+def f():
+    match subject:
+        case 2:
+            print('foo')
+        case 2:
+            print('bar')
+        case _:
+            print('baz')
 ";
         let stmts = parse_suite(source)?;
         assert_eq!(get_complexity_number(&stmts), 3);
         Ok(())
     }
+
+    #[test]
+    fn named_catch_all_match_case() -> Result<()> {
+        let source = r"
+def f():
+    match subject:
+        case 2:
+            print('hello')
+        case x:
+            print(x)
+";
+        let stmts = parse_suite(source)?;
+        assert_eq!(get_complexity_number(&stmts), 2);
+        Ok(())
+    }
 }