Merge remote-tracking branch 'upstream/main' into jit-isinstance

Author: tomasr8

Doc/deprecations/pending-removal-in-3.14.rst

@@ -78,7 +78,7 @@ Pending removal in Python 3.14
   :meth:`~pathlib.PurePath.relative_to`: passing additional arguments is
   deprecated.
 
-* :mod:`pkgutil`: :func:`!pkgutil.find_loader` and :func:!pkgutil.get_loader`
+* :mod:`pkgutil`: :func:`!pkgutil.find_loader` and :func:`!pkgutil.get_loader`
   now raise :exc:`DeprecationWarning`;
   use :func:`importlib.util.find_spec` instead.
   (Contributed by Nikita Sobolev in :gh:`97850`.)

Doc/using/windows.rst

@@ -95,6 +95,9 @@ as ``python3.14.exe``) to be available. The directory will be
 administrator. Click Start and search for "Edit environment variables for your
 account" for the system settings page to add the path.
 
+Each Python runtime you install will have its own directory for scripts. These
+also need to be added to :envvar:`PATH` if you want to use them.
+
 The Python install manager will be automatically updated to new releases. This
 does not affect any installs of Python runtimes. Uninstalling the Python install
 manager does not uninstall any Python runtimes.
@@ -713,6 +716,16 @@ default).
    your ``pythonw.exe`` and ``pyw.exe`` aliases are consistent with your
    others.
    "
+   "``pip`` gives me a ""command not found"" error when I type it in my
+   terminal.","Have you activated a virtual environment? Run the
+   ``.venv\Scripts\activate`` script in your terminal to activate.
+   "
+   "","The package may be available but missing the generated executable.
+   We recommend using the ``python -m pip`` command instead, or alternatively
+   the ``python -m pip install --force pip`` command will recreate the
+   executables and show you the path to add to :envvar:`PATH`. These scripts are
+   separated for each runtime, and so you may need to add multiple paths.
+   "
 
 
 .. _windows-embeddable:

Include/internal/pycore_opcode_metadata.h

@@ -102,6 +102,8 @@ def gen_colors(buffer: str) -> Iterator[ColorSpan]:
         for color in gen_colors_from_token_stream(gen, line_lengths):
             yield color
             last_emitted = color
+    except SyntaxError:
+        return
     except tokenize.TokenError as te:
         yield from recover_unterminated_string(
             te, line_lengths, last_emitted, buffer

Include/internal/pycore_uop_metadata.h

@@ -1942,6 +1942,23 @@ def testfunc(n):
         self.assertNotIn("_COMPARE_OP_INT", uops)
         self.assertNotIn("_GUARD_IS_TRUE_POP", uops)
 
+    def test_call_isinstance_guards_removed(self):
+        def testfunc(n):
+            x = 0
+            for _ in range(n):
+                y = isinstance(42, int)
+                if y:
+                    x += 1
+            return x
+
+        res, ex = self._run_with_optimizer(testfunc, TIER2_THRESHOLD)
+        self.assertEqual(res, TIER2_THRESHOLD)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertIn("_CALL_ISINSTANCE", uops)
+        self.assertNotIn("_GUARD_THIRD_NULL", uops)
+        self.assertNotIn("_GUARD_CALLABLE_ISINSTANCE", uops)
+
     def test_call_isinstance_is_true(self):
         def testfunc(n):
             x = 0

Lib/_pyrepl/utils.py

@@ -0,0 +1,109 @@
+import threading
+from unittest import TestCase
+from test.support import threading_helper
+from random import randint
+from io import BytesIO
+from sys import getsizeof
+
+
+class TestBytesIO(TestCase):
+    # Test pretty much everything that can break under free-threading.
+    # Non-deterministic, but at least one of these things will fail if
+    # BytesIO object is not free-thread safe.
+
+    def check(self, funcs, *args):
+        barrier = threading.Barrier(len(funcs))
+        threads = []
+
+        for func in funcs:
+            thread = threading.Thread(target=func, args=(barrier, *args))
+
+            threads.append(thread)
+
+        with threading_helper.start_threads(threads):
+            pass
+
+    @threading_helper.requires_working_threading()
+    @threading_helper.reap_threads
+    def test_free_threading(self):
+        """Test for segfaults and aborts."""
+
+        def write(barrier, b, *ignore):
+            barrier.wait()
+            try: b.write(b'0' * randint(100, 1000))
+            except ValueError: pass  # ignore write fail to closed file
+
+        def writelines(barrier, b, *ignore):
+            barrier.wait()
+            b.write(b'0\n' * randint(100, 1000))
+
+        def truncate(barrier, b, *ignore):
+            barrier.wait()
+            try: b.truncate(0)
+            except: BufferError  # ignore exported buffer
+
+        def read(barrier, b, *ignore):
+            barrier.wait()
+            b.read()
+
+        def read1(barrier, b, *ignore):
+            barrier.wait()
+            b.read1()
+
+        def readline(barrier, b, *ignore):
+            barrier.wait()
+            b.readline()
+
+        def readlines(barrier, b, *ignore):
+            barrier.wait()
+            b.readlines()
+
+        def readinto(barrier, b, into, *ignore):
+            barrier.wait()
+            b.readinto(into)
+
+        def close(barrier, b, *ignore):
+            barrier.wait()
+            b.close()
+
+        def getvalue(barrier, b, *ignore):
+            barrier.wait()
+            b.getvalue()
+
+        def getbuffer(barrier, b, *ignore):
+            barrier.wait()
+            b.getbuffer()
+
+        def iter(barrier, b, *ignore):
+            barrier.wait()
+            list(b)
+
+        def getstate(barrier, b, *ignore):
+            barrier.wait()
+            b.__getstate__()
+
+        def setstate(barrier, b, st, *ignore):
+            barrier.wait()
+            b.__setstate__(st)
+
+        def sizeof(barrier, b, *ignore):
+            barrier.wait()
+            getsizeof(b)
+
+        self.check([write] * 10, BytesIO())
+        self.check([writelines] * 10, BytesIO())
+        self.check([write] * 10 + [truncate] * 10, BytesIO())
+        self.check([truncate] + [read] * 10, BytesIO(b'0\n'*204800))
+        self.check([truncate] + [read1] * 10, BytesIO(b'0\n'*204800))
+        self.check([truncate] + [readline] * 10, BytesIO(b'0\n'*20480))
+        self.check([truncate] + [readlines] * 10, BytesIO(b'0\n'*20480))
+        self.check([truncate] + [readinto] * 10, BytesIO(b'0\n'*204800), bytearray(b'0\n'*204800))
+        self.check([close] + [write] * 10, BytesIO())
+        self.check([truncate] + [getvalue] * 10, BytesIO(b'0\n'*204800))
+        self.check([truncate] + [getbuffer] * 10, BytesIO(b'0\n'*204800))
+        self.check([truncate] + [iter] * 10, BytesIO(b'0\n'*20480))
+        self.check([truncate] + [getstate] * 10, BytesIO(b'0\n'*204800))
+        self.check([truncate] + [setstate] * 10, BytesIO(b'0\n'*204800), (b'123', 0, None))
+        self.check([truncate] + [sizeof] * 10, BytesIO(b'0\n'*204800))
+
+        # no tests for seek or tell because they don't break anything