Remove unused loops in deferred checks

Summary
--

While reviewing #23473, I noticed that the `while` loops in our deferred checks
for `for` loops and lambdas would only be used if we pushed additional deferred
scopes to the `Checker` while running lint rule code. This should actually be
impossible given that the rules only receive a `&Checker` (as shown by the
immutable re-borrow), and none of our tests fail when removing the loops.

I guess it doesn't hurt to have the loops either since they only run once, but
it did serve to confuse me today.

I assume, but didn't fully confirm, that this used to be interleaved with the
visiting phase, at which point additional deferred scopes could have still been
added in the middle of this.

Test Plan
--

Existing tests

Author: ntBre

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

@@ -6,41 +6,41 @@ use crate::rules::{flake8_bugbear, flake8_simplify, perflint, pylint, pyupgrade,
 
 /// Run lint rules over all deferred for-loops in the [`SemanticModel`].
 pub(crate) fn deferred_for_loops(checker: &mut Checker) {
-    while !checker.analyze.for_loops.is_empty() {
-        let for_loops = std::mem::take(&mut checker.analyze.for_loops);
-        for snapshot in for_loops {
-            checker.semantic.restore(snapshot);
+    let for_loops = std::mem::take(&mut checker.analyze.for_loops);
+    for snapshot in for_loops {
+        checker.semantic.restore(snapshot);
 
-            let Stmt::For(stmt_for) = checker.semantic.current_statement() else {
-                unreachable!("Expected Stmt::For");
-            };
-            if checker.is_rule_enabled(Rule::UnusedLoopControlVariable) {
-                flake8_bugbear::rules::unused_loop_control_variable(checker, stmt_for);
-            }
-            if checker.is_rule_enabled(Rule::IncorrectDictIterator) {
-                perflint::rules::incorrect_dict_iterator(checker, stmt_for);
-            }
-            if checker.is_rule_enabled(Rule::YieldInForLoop) {
-                pyupgrade::rules::yield_in_for_loop(checker, stmt_for);
-            }
-            if checker.is_rule_enabled(Rule::UnnecessaryEnumerate) {
-                refurb::rules::unnecessary_enumerate(checker, stmt_for);
-            }
-            if checker.is_rule_enabled(Rule::EnumerateForLoop) {
-                flake8_simplify::rules::enumerate_for_loop(checker, stmt_for);
-            }
-            if checker.is_rule_enabled(Rule::LoopIteratorMutation) {
-                flake8_bugbear::rules::loop_iterator_mutation(checker, stmt_for);
-            }
-            if checker.is_rule_enabled(Rule::DictIndexMissingItems) {
-                pylint::rules::dict_index_missing_items(checker, stmt_for);
-            }
-            if checker.is_rule_enabled(Rule::ManualDictComprehension) {
-                perflint::rules::manual_dict_comprehension(checker, stmt_for);
-            }
-            if checker.is_rule_enabled(Rule::ManualListComprehension) {
-                perflint::rules::manual_list_comprehension(checker, stmt_for);
-            }
+        let checker = &*checker;
+
+        let Stmt::For(stmt_for) = checker.semantic.current_statement() else {
+            unreachable!("Expected Stmt::For");
+        };
+        if checker.is_rule_enabled(Rule::UnusedLoopControlVariable) {
+            flake8_bugbear::rules::unused_loop_control_variable(checker, stmt_for);
+        }
+        if checker.is_rule_enabled(Rule::IncorrectDictIterator) {
+            perflint::rules::incorrect_dict_iterator(checker, stmt_for);
+        }
+        if checker.is_rule_enabled(Rule::YieldInForLoop) {
+            pyupgrade::rules::yield_in_for_loop(checker, stmt_for);
+        }
+        if checker.is_rule_enabled(Rule::UnnecessaryEnumerate) {
+            refurb::rules::unnecessary_enumerate(checker, stmt_for);
+        }
+        if checker.is_rule_enabled(Rule::EnumerateForLoop) {
+            flake8_simplify::rules::enumerate_for_loop(checker, stmt_for);
+        }
+        if checker.is_rule_enabled(Rule::LoopIteratorMutation) {
+            flake8_bugbear::rules::loop_iterator_mutation(checker, stmt_for);
+        }
+        if checker.is_rule_enabled(Rule::DictIndexMissingItems) {
+            pylint::rules::dict_index_missing_items(checker, stmt_for);
+        }
+        if checker.is_rule_enabled(Rule::ManualDictComprehension) {
+            perflint::rules::manual_dict_comprehension(checker, stmt_for);
+        }
+        if checker.is_rule_enabled(Rule::ManualListComprehension) {
+            perflint::rules::manual_list_comprehension(checker, stmt_for);
         }
     }
 }

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

@@ -6,24 +6,24 @@ use crate::rules::{flake8_builtins, flake8_pie, pylint};
 
 /// Run lint rules over all deferred lambdas in the [`SemanticModel`].
 pub(crate) fn deferred_lambdas(checker: &mut Checker) {
-    while !checker.analyze.lambdas.is_empty() {
-        let lambdas = std::mem::take(&mut checker.analyze.lambdas);
-        for snapshot in lambdas {
-            checker.semantic.restore(snapshot);
+    let lambdas = std::mem::take(&mut checker.analyze.lambdas);
+    for snapshot in lambdas {
+        checker.semantic.restore(snapshot);
 
-            let Some(Expr::Lambda(lambda)) = checker.semantic.current_expression() else {
-                unreachable!("Expected Expr::Lambda");
-            };
+        let checker = &*checker;
 
-            if checker.is_rule_enabled(Rule::UnnecessaryLambda) {
-                pylint::rules::unnecessary_lambda(checker, lambda);
-            }
-            if checker.is_rule_enabled(Rule::ReimplementedContainerBuiltin) {
-                flake8_pie::rules::reimplemented_container_builtin(checker, lambda);
-            }
-            if checker.is_rule_enabled(Rule::BuiltinLambdaArgumentShadowing) {
-                flake8_builtins::rules::builtin_lambda_argument_shadowing(checker, lambda);
-            }
+        let Some(Expr::Lambda(lambda)) = checker.semantic.current_expression() else {
+            unreachable!("Expected Expr::Lambda");
+        };
+
+        if checker.is_rule_enabled(Rule::UnnecessaryLambda) {
+            pylint::rules::unnecessary_lambda(checker, lambda);
+        }
+        if checker.is_rule_enabled(Rule::ReimplementedContainerBuiltin) {
+            flake8_pie::rules::reimplemented_container_builtin(checker, lambda);
+        }
+        if checker.is_rule_enabled(Rule::BuiltinLambdaArgumentShadowing) {
+            flake8_builtins::rules::builtin_lambda_argument_shadowing(checker, lambda);
         }
     }
 }