Merge branch 'main' of https://github.com/python/cpython into add-bytecode-specialization-guide

Author: faizanoor3001

Doc/whatsnew/3.14.rst

@@ -785,6 +785,10 @@ pdb
   (if any).
   (Contributed by Tian Gao in :gh:`130493`.)
 
+* ``<tab>`` at the beginning of the line in :mod:`pdb` multi-line input will
+  fill in a 4-space indentation now, instead of inserting a ``\t`` character.
+  (Contributed by Tian Gao in :gh:`130471`.)
+
 
 pickle
 ------

Lib/pdb.py

@@ -652,10 +652,10 @@ def displayhook(self, obj):
             self.message(repr(obj))
 
     @contextmanager
-    def _disable_command_completion(self):
+    def _enable_multiline_completion(self):
         completenames = self.completenames
         try:
-            self.completenames = self.completedefault
+            self.completenames = self.complete_multiline_names
             yield
         finally:
             self.completenames = completenames
@@ -753,7 +753,7 @@ def default(self, line):
             buffer = line
             if (code := codeop.compile_command(line + '\n', '<stdin>', 'single')) is None:
                 # Multi-line mode
-                with self._disable_command_completion():
+                with self._enable_multiline_completion():
                     buffer = line
                     continue_prompt = "...   "
                     while (code := codeop.compile_command(buffer, '<stdin>', 'single')) is None:
@@ -996,6 +996,21 @@ def _complete_expression(self, text, line, begidx, endidx):
             # Complete a simple name.
             return [n for n in ns.keys() if n.startswith(text)]
 
+    def _complete_indentation(self, text, line, begidx, endidx):
+        try:
+            import readline
+        except ImportError:
+            return []
+        # Fill in spaces to form a 4-space indent
+        return [' ' * (4 - readline.get_begidx() % 4)]
+
+    def complete_multiline_names(self, text, line, begidx, endidx):
+        # If text is space-only, the user entered <tab> before any text.
+        # That normally means they want to indent the current line.
+        if not text.strip():
+            return self._complete_indentation(text, line, begidx, endidx)
+        return self.completedefault(text, line, begidx, endidx)
+
     def completedefault(self, text, line, begidx, endidx):
         if text.startswith("$"):
             # Complete convenience variables

Lib/test/test_capi/test_opt.py

@@ -1499,6 +1499,37 @@ def f(n):
         # But all of the appends we care about are still there:
         self.assertEqual(uops.count("_CALL_LIST_APPEND"), len("ABCDEFG"))
 
+    def test_narrow_type_to_constant_int_zero(self):
+        def f(n):
+            trace = []
+            for i in range(n):
+                # zero is always (int) 0, but we can only prove that it's a integer:
+                false = i == TIER2_THRESHOLD # this will always be false, while hopefully still fooling optimizer improvements
+                zero = false + 0 # this should always set the variable zero equal to 0
+                trace.append("A")
+                if not zero:  # Kept.
+                    trace.append("B")
+                    if not zero:  # Removed!
+                        trace.append("C")
+                    trace.append("D")
+                    if zero:  # Removed!
+                        trace.append("X")
+                    trace.append("E")
+                trace.append("F")
+                if zero:  # Removed!
+                    trace.append("X")
+                trace.append("G")
+            return trace
+
+        trace, ex = self._run_with_optimizer(f, TIER2_THRESHOLD)
+        self.assertEqual(trace, list("ABCDEFG") * TIER2_THRESHOLD)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        # Only one guard remains:
+        self.assertEqual(uops.count("_GUARD_IS_FALSE_POP"), 1)
+        self.assertEqual(uops.count("_GUARD_IS_TRUE_POP"), 0)
+        # But all of the appends we care about are still there:
+        self.assertEqual(uops.count("_CALL_LIST_APPEND"), len("ABCDEFG"))
 
 def global_identity(x):
     return x

Lib/test/test_pdb.py

@@ -4342,6 +4342,32 @@ def test_quit(self):
         # The quit prompt should be printed exactly twice
         self.assertEqual(stdout.count("Quit anyway"), 2)
 
+    def test_quit_after_interact(self):
+        """
+        interact command will set sys.ps1 temporarily, we need to make sure
+        that it's restored and pdb does not believe it's in interactive mode
+        after interact is done.
+        """
+        script = """
+            x = 1
+            breakpoint()
+        """
+
+        commands = """
+            interact
+            quit()
+            q
+            y
+        """
+
+        stdout, stderr = self._run_script(script, commands)
+        # Normal exit should not print anything to stderr
+        self.assertEqual(stderr, "")
+        # The quit prompt should be printed exactly once
+        self.assertEqual(stdout.count("Quit anyway"), 1)
+        # BdbQuit should not be printed
+        self.assertNotIn("BdbQuit", stdout)
+
     def test_set_trace_with_skip(self):
         """GH-82897
         Inline set_trace() should break unconditionally. This example is a
@@ -4487,6 +4513,32 @@ def test_multiline_completion(self):
 
         self.assertIn(b'42', output)
 
+    def test_multiline_indent_completion(self):
+        script = textwrap.dedent("""
+            import pdb; pdb.Pdb().set_trace()
+        """)
+
+        # \t should always complete a 4-space indent
+        # This piece of code will raise an IndentationError or a SyntaxError
+        # if the completion is not working as expected
+        input = textwrap.dedent("""\
+            def func():
+            \ta = 1
+             \ta += 1
+              \ta += 1
+               \tif a > 0:
+                    a += 1
+            \t\treturn a
+
+            func()
+            c
+        """).encode()
+
+        output = run_pty(script, input)
+
+        self.assertIn(b'4', output)
+        self.assertNotIn(b'Error', output)
+
 
 def load_tests(loader, tests, pattern):
     from test import test_pdb

Misc/ACKS

@@ -1061,6 +1061,7 @@ Detlef Lannert
 Rémi Lapeyre
 Soren Larsen
 Amos Latteier
+Keenan Lau
 Piers Lauder
 Ben Laurie
 Yoni Lavi

Misc/NEWS.d/next/Core_and_Builtins/2025-03-03-01-21-04.gh-issue-130415.ibOV6B.rst

@@ -0,0 +1 @@
+Improve JIT understanding of integers in boolean context.

Misc/NEWS.d/next/Library/2025-02-22-19-44-00.gh-issue-125377.LFTK0H.rst

@@ -0,0 +1 @@
+``<tab>`` at the beginning of the line in :mod:`pdb` multi-line input will fill in a 4-space indentation now, instead of inserting a ``\t`` character.

Python/optimizer_bytecodes.c

@@ -406,7 +406,7 @@ dummy_func(void) {
     op(_TO_BOOL_INT, (value -- res)) {
         if (!optimize_to_bool(this_instr, ctx, value, &res)) {
             sym_set_type(value, &PyLong_Type);
-            res = sym_new_type(ctx, &PyBool_Type);
+            res = sym_new_truthiness(ctx, value, true);
         }
     }
 

Python/optimizer_cases.c.h

@@ -299,6 +299,9 @@ _Py_uop_sym_set_const(JitOptContext *ctx, JitOptSymbol *sym, PyObject *const_val
             else if (type == &PyBool_Type) {
                 _Py_uop_sym_set_const(ctx, value, Py_False);
             }
+            else if (type == &PyLong_Type) {
+                _Py_uop_sym_set_const(ctx, value, Py_GetConstant(Py_CONSTANT_ZERO));
+            }
             // TODO: More types (GH-130415)!
             make_const(sym, const_val);
             return;