Move remaining lambda rule to deferred pass (#8098)

crates/ruff_linter/src/checkers/ast/analyze/deferred_lambdas.rs

@@ -2,7 +2,7 @@ use ruff_python_ast::Expr;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
-use crate::rules::pylint;
+use crate::rules::{flake8_pie, pylint};
 
 /// Run lint rules over all deferred lambdas in the [`SemanticModel`].
 pub(crate) fn deferred_lambdas(checker: &mut Checker) {
@@ -18,6 +18,9 @@ pub(crate) fn deferred_lambdas(checker: &mut Checker) {
             if checker.enabled(Rule::UnnecessaryLambda) {
                 pylint::rules::unnecessary_lambda(checker, lambda);
             }
+            if checker.enabled(Rule::ReimplementedListBuiltin) {
+                flake8_pie::rules::reimplemented_list_builtin(checker, lambda);
+            }
         }
     }
 }

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -1267,17 +1267,6 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 }
             }
         }
-        Expr::Lambda(
-            lambda @ ast::ExprLambda {
-                parameters: _,
-                body: _,
-                range: _,
-            },
-        ) => {
-            if checker.enabled(Rule::ReimplementedListBuiltin) {
-                flake8_pie::rules::reimplemented_list_builtin(checker, lambda);
-            }
-        }
         Expr::IfExp(ast::ExprIfExp {
             test,
             body,

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -1834,15 +1834,15 @@ impl<'a> Checker<'a> {
             for snapshot in deferred_functions {
                 self.semantic.restore(snapshot);
 
-                if let Stmt::FunctionDef(ast::StmtFunctionDef {
+                let Stmt::FunctionDef(ast::StmtFunctionDef {
                     body, parameters, ..
                 }) = self.semantic.current_statement()
-                {
+                else {
+                    unreachable!("Expected Stmt::FunctionDef")
+                };
+
                 self.visit_parameters(parameters);
                 self.visit_body(body);
-                } else {
-                    unreachable!("Expected Stmt::FunctionDef")
-                }
             }
         }
         self.semantic.restore(snapshot);
@@ -1856,19 +1856,19 @@ impl<'a> Checker<'a> {
             for snapshot in lambdas {
                 self.semantic.restore(snapshot);
 
-                if let Some(Expr::Lambda(ast::ExprLambda {
+                let Some(Expr::Lambda(ast::ExprLambda {
                     parameters,
                     body,
                     range: _,
                 })) = self.semantic.current_expression()
-                {
+                else {
+                    unreachable!("Expected Expr::Lambda");
+                };
+
                 if let Some(parameters) = parameters {
                     self.visit_parameters(parameters);
                 }
                 self.visit_expr(body);
-                } else {
-                    unreachable!("Expected Expr::Lambda");
-                }
 
                 deferred.push(snapshot);
             }