pythongh-133672: Allow LOAD_FAST to be optimized to LOAD_FAST_BORROW

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ljfp

Lib/test/test_peepholer.py

@@ -2598,6 +2598,36 @@ def test_for_iter(self):
             ("LOAD_CONST", 0, 7),
             ("RETURN_VALUE", None, 8),
         ]
+        expected = [
+            ("LOAD_FAST_BORROW", 0, 1),
+            top := self.Label(),
+            ("FOR_ITER", end := self.Label(), 2),
+            ("STORE_FAST", 2, 3),
+            ("JUMP", top, 4),
+            end,
+            ("END_FOR", None, 5),
+            ("POP_TOP", None, 6),
+            ("LOAD_CONST", 0, 7),
+            ("RETURN_VALUE", None, 8),
+        ]
+        self.cfg_optimization_test(insts, expected, consts=[None])
+
+    def test_for_iter_checks_fallthrough(self):
+        insts = [
+            ("LOAD_FAST", 0, 1),
+            ("GET_ITER", 0, 2),
+            top := self.Label(),
+            ("FOR_ITER", end := self.Label(), 3),
+            ("STORE_FAST", 1, 4),
+            ("LOAD_CONST", 0, 5),
+            ("STORE_FAST", 0, 6),
+            ("JUMP", top, 7),
+            end,
+            ("END_FOR", None, 8),
+            ("POP_ITER", None, 9),
+            ("LOAD_CONST", 0, 10),
+            ("RETURN_VALUE", None, 11),
+        ]
         self.cfg_optimization_test(insts, insts, consts=[None])
 
     def test_load_attr(self):
@@ -2675,6 +2705,69 @@ def test_send(self):
         ]
         self.cfg_optimization_test(insts, expected, consts=[None])
 
+    def test_borrow_checks_exception_handler_edges(self):
+        insts = [
+            ("LOAD_FAST", 0, 1),
+            ("JUMP", start := self.Label(), 2),
+            start,
+            ("SETUP_FINALLY", handler := self.Label(), 3),
+            ("LOAD_CONST", 0, 4),
+            ("BINARY_OP", 0, 5),
+            ("POP_BLOCK", None, 6),
+            ("RETURN_VALUE", None, 7),
+            handler,
+            ("STORE_FAST", 1, 8),
+            ("LOAD_CONST", 0, 9),
+            ("STORE_FAST", 0, 10),
+            ("POP_TOP", None, 11),
+            ("LOAD_CONST", 0, 12),
+            ("RETURN_VALUE", None, 13),
+        ]
+        expected = [
+            ("LOAD_FAST", 0, 1),
+            ("NOP", None, 2),
+            ("SETUP_FINALLY", handler := self.Label(), 3),
+            ("LOAD_CONST", 0, 4),
+            ("BINARY_OP", 0, 5),
+            ("NOP", None, 6),
+            ("RETURN_VALUE", None, 7),
+            handler,
+            ("STORE_FAST", 1, 8),
+            ("LOAD_CONST", 0, 9),
+            ("STORE_FAST", 0, 10),
+            ("POP_TOP", None, 11),
+            ("LOAD_CONST", 0, 12),
+            ("RETURN_VALUE", None, 13),
+        ]
+        self.cfg_optimization_test(insts, expected, consts=[None])
+
+    def test_copied_reference_is_not_borrowed(self):
+        insts = [
+            ("LOAD_FAST", 0, 1),
+            ("COPY", 1, 1),
+            ("TO_BOOL", None, 1),
+            ("POP_JUMP_IF_TRUE", target := self.Label(), 1),
+            ("POP_TOP", None, 1),
+            ("LOAD_FAST", 1, 1),
+            target,
+            ("STORE_FAST", 0, 1),
+            ("LOAD_CONST", 0, 2),
+            ("RETURN_VALUE", None, 2),
+        ]
+        expected = [
+            ("LOAD_FAST", 0, 1),
+            ("COPY", 1, 1),
+            ("TO_BOOL", None, 1),
+            ("POP_JUMP_IF_TRUE", target := self.Label(), 1),
+            ("POP_TOP", None, 1),
+            ("LOAD_FAST", 1, 1),
+            target,
+            ("STORE_FAST", 0, 1),
+            ("LOAD_CONST", 0, 2),
+            ("RETURN_VALUE", None, 2),
+        ]
+        self.cfg_optimization_test(insts, expected, consts=[None])
+
     def test_format_simple(self):
         # FORMAT_SIMPLE will leave its operand on the stack if it's a unicode
         # object. We treat it conservatively and assume that it always leaves

Misc/NEWS.d/next/Core_and_Builtins/2025-05-09-00-06-52.gh-issue-133672.y6QwwH.rst

@@ -0,0 +1 @@
+The peephole optimizer now converts LOAD_FAST to LOAD_FAST_BORROW more aggressively. This optimization is applied even if the loaded variable remains live on the stack at the end of a basic block, as long as the borrow is otherwise determined to be safe. This can reduce reference counting overhead in certain code patterns, such as with iterables in loops.