@@ -2414,10 +2414,22 @@ impl<'warnings> Compiler<'warnings> {
 
                 if let FBlockDatum::FinallyBody(ref body) = info.fb_datum {
                     // This is an extra copy of the finally body, emitted for the
-                    // path that leaves the try block early. The try statement
-                    // emits its own copies afterwards, so rewind the symbol table
-                    // cursors and leave the nested scopes for those copies.
+                    // path that leaves the try block early. Nested scopes are
+                    // handed out by position, and the cursors are still inside
+                    // the try block's own run of scopes here, so seek them to the
+                    // ones this body opened before compiling it. The try
+                    // statement emits its own copies from the same place
+                    // afterwards, so put the cursors back when the copy is done.
                     let symbol_table_cursors = self.current_symbol_table_cursors();
+                    if let Some(first) = body.first() {
+                        let line = self
+                            .source_file
+                            .to_source_code()
+                            .line_index(first.range().start())
+                            .get()
+                            .to_u32();
+                        self.seek_symbol_table_cursors_to_line(line);
+                    }
                     self.compile_statements(body)?;
                     self.set_symbol_table_cursors(symbol_table_cursors);
                 }
@@ -10354,6 +10366,43 @@ impl<'warnings> Compiler<'warnings> {
         table.next_inlined_comprehension_block = cursors.inlined_comprehension_block;
     }
 
+    /// Advance the nested-scope cursors to the first scope that begins on or
+    /// after `line_number`.
+    ///
+    /// A statement list can be compiled more than once — `finally` bodies are
+    /// re-emitted on every path that leaves the try block early — and each copy
+    /// has to be handed the same scopes as the last. Positioning by line works
+    /// because `finally` is the last clause of its statement: every scope the
+    /// preceding clauses opened begins on an earlier line than the body being
+    /// re-compiled, and every scope that body opens begins on its own line or
+    /// later.
+    fn seek_symbol_table_cursors_to_line(&mut self, line_number: u32) {
+        fn seek(tables: &[SymbolTable], cursor: &mut usize, line_number: u32) {
+            while tables
+                .get(*cursor)
+                .is_some_and(|table| table.line_number < line_number)
+            {
+                *cursor += 1;
+            }
+        }
+
+        let table = self
+            .symbol_table_stack
+            .last_mut()
+            .expect("no current symbol table");
+        seek(&table.sub_tables, &mut table.next_sub_table, line_number);
+        seek(
+            &table.hidden_annotation_blocks,
+            &mut table.next_hidden_annotation_block,
+            line_number,
+        );
+        seek(
+            &table.inlined_comprehension_blocks,
+            &mut table.next_inlined_comprehension_block,
+            line_number,
+        );
+    }
+
     fn lookup_comprehension_symbol_table_after_skipped_nested_scopes_in_expr(
         &mut self,
         expression: &ast::Expr,
 
@@ -367,3 +367,104 @@ def gen():
 
 
 assert generator_return_from_try() == [["z"]]
+
+
+# the copy of the finally body is emitted where the try block is left, so its
+# nested scopes must be looked up past the ones the rest of the try block opens
+def scopes_after_the_early_exit():
+    log = []
+
+    def run(data, leave_early):
+        try:
+            if leave_early:
+                return "early"
+            return list(s * 2 for s in data)
+        finally:
+            log.append(sorted(k for k in data))
+
+    assert run([1, 2], True) == "early"
+    assert run([3, 1], False) == [6, 2]
+    return log
+
+
+assert scopes_after_the_early_exit() == [[1, 2], [1, 3]]
+
+
+# a nested function in the try block is a scope too: taking its symbol table
+# for the generator expression below built one without the `.0` argument
+def named_scope_after_the_early_exit():
+    log = []
+
+    def run(data, leave_early):
+        try:
+            if leave_early:
+                return "early"
+
+            def inner():
+                return [x + 1 for x in data]
+
+            return inner()
+        finally:
+            log.append(sorted(k for k in data))
+
+    assert run([2, 1], True) == "early"
+    assert run([2, 1], False) == [3, 2]
+    return log
+
+
+assert named_scope_after_the_early_exit() == [[1, 2], [1, 2]]
+
+
+# scopes that share a name resolve by position, so `inner` must not be found
+# where the try block declares it
+def same_name_scope_after_the_early_exit():
+    log = []
+
+    def run(value, leave_early):
+        try:
+            if leave_early:
+                return "early"
+
+            def inner():
+                return value
+
+            return inner()
+        finally:
+
+            def inner():
+                return log
+
+            assert inner() is log
+            log.append((lambda x: x + value)(1))
+
+    assert run(10, True) == "early"
+    assert run(20, False) == 20
+    return log
+
+
+assert same_name_scope_after_the_early_exit() == [11, 21]
+
+
+# breaking and continuing out of a loop copy the finally body the same way
+def loop_exit_with_scopes_after_it():
+    seen = []
+    for i in range(4):
+        try:
+            if i == 1:
+                continue
+            if i == 3:
+                break
+            seen.append(sorted(t for t in [i]))
+        finally:
+            seen.append(sorted(k for k in [i, i + 1]))
+    return seen
+
+
+assert loop_exit_with_scopes_after_it() == [
+    [0],
+    [0, 1],
+    [1, 2],
+    [2],
+    [2, 3],
+    [3, 4],
+], loop_exit_with_scopes_after_it()