diff --git a/crates/ruff_linter/src/rules/ruff/rules/fallible_context_manager.rs b/crates/ruff_linter/src/rules/ruff/rules/fallible_context_manager.rs
index 9024b8f738..0a46de3048 100644
--- a/crates/ruff_linter/src/rules/ruff/rules/fallible_context_manager.rs
+++ b/crates/ruff_linter/src/rules/ruff/rules/fallible_context_manager.rs
@@ -66,7 +66,7 @@ pub(crate) fn fallible_context_manager(checker: &Checker, function_def: &StmtFun
     }
 
     let mut visitor = YieldFinallyVisitor::new(checker);
-    visitor.visit_body_with_terminal(&function_def.body, true);
+    visitor.visit_body_with_terminal(&function_def.body);
 }
 
 fn has_contextmanager_decorator(checker: &Checker, function_def: &StmtFunctionDef) -> bool {
@@ -94,12 +94,6 @@ fn has_contextmanager_decorator(checker: &Checker, function_def: &StmtFunctionDe
 struct YieldFinallyVisitor<'a, 'b> {
     /// The checker used to emit diagnostics.
     checker: &'a Checker<'b>,
-    /// Whether the visitor is currently inside a `try` block that has
-    /// `finally` or `except` handlers.
-    in_protected_try: bool,
-    /// Whether the visitor is at the last statement in a `with` block body,
-    /// where the `with` statement's `__exit__` provides exception handling.
-    in_with_last_statement: bool,
     /// Whether the visitor is at a terminal position: the last statement in
     /// the function body, or a `yield` immediately before a `return`.
     in_terminal_position: bool,
@@ -110,9 +104,7 @@ impl<'a, 'b> YieldFinallyVisitor<'a, 'b> {
     fn new(checker: &'a Checker<'b>) -> Self {
         Self {
             checker,
-            in_protected_try: false,
-            in_with_last_statement: false,
-            in_terminal_position: false,
+            in_terminal_position: true,
         }
     }
 }
@@ -122,79 +114,10 @@ impl Visitor<'_> for YieldFinallyVisitor<'_, '_> {
         match stmt {
             Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {}
 
-            Stmt::Try(ast::StmtTry {
-                body,
-                handlers,
-                orelse,
-                finalbody,
-                ..
-            }) if !finalbody.is_empty() || !handlers.is_empty() => {
-                let prev = self.in_protected_try;
-                self.in_protected_try = true;
-                self.visit_body(body);
-                for handler in handlers {
-                    self.visit_except_handler(handler);
-                }
-                self.visit_body(orelse);
-                self.in_protected_try = prev;
-                self.visit_body(finalbody);
-            }
-
             Stmt::With(ast::StmtWith { body, .. }) => {
                 self.visit_with_body(body);
             }
 
-            Stmt::If(ast::StmtIf {
-                test,
-                body,
-                elif_else_clauses,
-                ..
-            }) => {
-                self.visit_expr(test);
-                let terminal = self.in_terminal_position;
-                self.visit_body_with_terminal(body, terminal);
-                for clause in elif_else_clauses {
-                    if let Some(test) = &clause.test {
-                        self.visit_expr(test);
-                    }
-                    self.visit_body_with_terminal(&clause.body, terminal);
-                }
-            }
-
-            Stmt::For(ast::StmtFor {
-                target,
-                iter,
-                body,
-                orelse,
-                ..
-            }) => {
-                self.visit_expr(iter);
-                self.visit_expr(target);
-                let terminal = self.in_terminal_position;
-                self.visit_body_with_terminal(body, terminal);
-                self.visit_body_with_terminal(orelse, terminal);
-            }
-
-            Stmt::While(ast::StmtWhile {
-                test, body, orelse, ..
-            }) => {
-                self.visit_expr(test);
-                let terminal = self.in_terminal_position;
-                self.visit_body_with_terminal(body, terminal);
-                self.visit_body_with_terminal(orelse, terminal);
-            }
-
-            Stmt::Match(ast::StmtMatch { subject, cases, .. }) => {
-                self.visit_expr(subject);
-                let terminal = self.in_terminal_position;
-                for case in cases {
-                    if let Some(guard) = &case.guard {
-                        self.visit_expr(guard);
-                    }
-                    self.visit_body_with_terminal(&case.body, terminal);
-                }
-            }
-
             _ => walk_stmt(self, stmt),
         }
     }
@@ -202,10 +125,7 @@ impl Visitor<'_> for YieldFinallyVisitor<'_, '_> {
     fn visit_expr(&mut self, expr: &Expr) {
         match expr {
             Expr::Yield(_) | Expr::YieldFrom(_) => {
-                if !self.in_protected_try
-                    && !self.in_with_last_statement
-                    && !self.in_terminal_position
-                {
+                if !self.in_terminal_position {
                     self.checker
                         .report_diagnostic(FallibleContextManager, expr.range());
                 }
@@ -221,7 +141,7 @@ impl YieldFinallyVisitor<'_, '_> {
     ///
     /// A statement is considered terminal if it is the last in the body (when `terminal` is true)
     /// or if it is a yield statement immediately followed by a `return`.
-    fn visit_body_with_terminal(&mut self, body: &[Stmt], terminal: bool) {
+    fn visit_body_with_terminal(&mut self, body: &[Stmt]) {
         for (i, stmt) in body.iter().enumerate() {
             let is_last = i == body.len() - 1;
             let is_yield_before_return = Self::is_yield_statement(stmt)
@@ -230,7 +150,7 @@ impl YieldFinallyVisitor<'_, '_> {
                     .is_some_and(|next| matches!(next, Stmt::Return(_)));
 
             let prev = self.in_terminal_position;
-            self.in_terminal_position = (is_last && terminal) || is_yield_before_return;
+            self.in_terminal_position &= is_last || is_yield_before_return;
             self.visit_stmt(stmt);
             self.in_terminal_position = prev;
         }
@@ -241,27 +161,26 @@ impl YieldFinallyVisitor<'_, '_> {
     /// The last statement in a `with` block inherits terminal status from the parent context
     /// and is additionally marked as a "with last statement" if it is a yield.
     fn visit_with_body(&mut self, body: &[Stmt]) {
-        if body.is_empty() {
+        let [rest @ .., last] = body else {
             return;
-        }
+        };
 
         let parent_terminal = self.in_terminal_position;
 
         // Non-last statements: delegate terminal tracking to visit_body_with_terminal
-        if body.len() > 1 {
-            self.visit_body_with_terminal(&body[..body.len() - 1], false);
-        }
+        self.in_terminal_position = false;
+        self.visit_body_with_terminal(rest);
+        self.in_terminal_position = parent_terminal;
 
         // Last statement: inherit terminal from parent, set with-last-statement if yield
-        let last = &body[body.len() - 1];
         let prev_terminal = self.in_terminal_position;
         self.in_terminal_position = parent_terminal;
 
         if Self::is_yield_statement(last) {
-            let prev_with = self.in_with_last_statement;
-            self.in_with_last_statement = true;
+            let prev_with = self.in_terminal_position;
+            self.in_terminal_position = true;
             self.visit_stmt(last);
-            self.in_with_last_statement = prev_with;
+            self.in_terminal_position = prev_with;
         } else {
             self.visit_stmt(last);
         }