Fix #26039: REPL prompt disappears when builtins/globals shadowed under PYTHONSTARTUP (#26045)

Fixes #26039

`PYTHONSTARTUP` executes `pythonrc.py`'s code directly inside the user's
`__main__` namespace rather than importing it as a module. That means
`PS1.__str__.__globals__` *is* the user's namespace — so shadowing any
name it relies on at prompt-render time (`int`, `sys`, `str`, `bool`,
`original_ps1`, `get_last_command`) breaks `str(sys.ps1)` and silently
kills the prompt.

This captures the real objects into private `_`-prefixed aliases right
after they're defined, before any user code runs, so later reassignment
of those names in `__main__` can't affect the prompt anymore.

**How I tested:**
- Reproduced by `exec`-ing `pythonrc.py`'s source into a synthetic
`__main__` dict (mirroring the real `PYTHONSTARTUP` path) and shadowing
`int`/`sys`/`str`/`bool`/`original_ps1`/`get_last_command` — confirmed
it broke on the original file and is fixed on the patched one.
- Added `test_prompt_survives_shadowed_builtins_under_pythonstartup`,
which encodes that reproduction as a regression test. The existing tests
`import pythonrc` as a normal module, which gives `PS1` its own module
namespace instead of `__main__` — that's why they never caught this bug.
- `npm run check-python` (ruff check, ruff format --check, pyright) —
clean, 0 errors.
- `python -m pytest python_files/tests/test_shell_integration.py -v` —
5/5 passed.

**Notes for reviewers:** the fix is intentionally minimal (capture at
definition time) rather than moving the class into a separate module,
since `pythonStartup.ts` only ever copies the single `pythonrc.py` file
to the PYTHONSTARTUP location — splitting into two files would require
extension-side deployment changes.

---------

Co-authored-by: Eduardo Villalpando Mello <eduardo.villalpando.mello@gmail.com>

Author: mohityadav8

python_files/pythonrc.py

@@ -9,6 +9,20 @@ def _initialize():
     original_ps1 = ">>> "
     is_wsl = "microsoft-standard-WSL" in platform.release()
 
+    # PYTHONSTARTUP executes this file's code inside the user's __main__
+    # namespace, so PS1.__str__'s globals are the user's globals. If the
+    # user later shadows a name we rely on at prompt-render time (e.g.
+    # `int = 20`, `sys = 1`), a plain lookup would resolve to the user's
+    # value instead of ours and raise, silently killing the prompt.
+    #
+    # Capturing these as locals of _initialize (rather than as names left
+    # sitting in __main__) means PS1's methods reach them through closure
+    # cells, not global lookup - so there's no alias name in __main__ for
+    # user code to reassign and break in the first place.
+    _int = int
+    _bool = bool
+    _str = str
+
     class ShellIntegrationSequence(str, Enum):
         SOH = "\001"
         STX = "\002"
@@ -53,7 +67,7 @@ class PS1:
 
         # str will get called for every prompt with exit code to show success/failure
         def __str__(self):
-            exit_code = int(bool(self.hooks.failure_flag))
+            exit_code = _int(_bool(self.hooks.failure_flag))
             self.hooks.failure_flag = False
             # Guide following official VS Code doc for shell integration sequence:
             result = ""
@@ -64,10 +78,10 @@ def __str__(self):
                     stx=ShellIntegrationSequence.STX,
                     command_executed=ShellIntegrationSequence.COMMAND_EXECUTED,
                     command_line=ShellIntegrationSequence.COMMAND_LINE
-                    + str(get_last_command())
+                    + _str(get_last_command())
                     + ShellIntegrationSequence.TERMINATOR,
                     command_finished=ShellIntegrationSequence.COMMAND_FINISHED
-                    + str(exit_code)
+                    + _str(exit_code)
                     + ShellIntegrationSequence.TERMINATOR,
                     prompt_started=ShellIntegrationSequence.PROMPT_STARTED,
                     prompt=original_ps1,
@@ -76,7 +90,7 @@ def __str__(self):
             else:
                 result = "{command_finished}{prompt_started}{prompt}{command_start}{command_executed}".format(
                     command_finished=ShellIntegrationSequence.COMMAND_FINISHED
-                    + str(exit_code)
+                    + _str(exit_code)
                     + ShellIntegrationSequence.TERMINATOR,
                     prompt_started=ShellIntegrationSequence.PROMPT_STARTED,
                     prompt=original_ps1,

python_files/tests/test_shell_integration.py

@@ -1,13 +1,16 @@
 import importlib
 import platform
 import sys
-from typing import Protocol, cast
+from pathlib import Path
+from typing import Any, Protocol, cast
 from unittest.mock import Mock
 
 import pythonrc
 
 is_wsl = "microsoft-standard-WSL" in platform.release()
 
+PYTHONRC_PATH = Path(pythonrc.__file__)
+
 
 class _Hooks(Protocol):
     failure_flag: bool
@@ -70,6 +73,40 @@ def test_does_not_pollute_namespace():
     assert not [name for name in vars(pythonrc) if not name.startswith("__")]
 
 
+def test_prompt_survives_shadowed_builtins_under_pythonstartup():
+    # PYTHONSTARTUP executes pythonrc's source directly inside the real
+    # REPL's __main__ namespace, not as an imported module. The tests
+    # above import pythonrc normally, which gives PS1 its own module
+    # namespace instead of __main__ and would never catch this. Simulate
+    # the real PYTHONSTARTUP path by exec-ing the source into a synthetic
+    # __main__-like namespace, then shadow the names PS1 relies on at
+    # prompt-render time and confirm rendering the prompt still works.
+    if sys.platform == "win32" or is_wsl:
+        return
+
+    source = PYTHONRC_PATH.read_text(encoding="utf-8")
+    namespace: dict[str, Any] = {"__name__": "__main__"}
+    exec(compile(source, str(PYTHONRC_PATH), "exec"), namespace)
+
+    namespace.update(
+        {
+            "int": 20,
+            "bool": 20,
+            "str": 20,
+            "sys": 1,
+            "original_ps1": "shadowed",
+            "get_last_command": "shadowed",
+        }
+    )
+
+    ps1 = cast("_PS1", sys.ps1)
+    result = str(ps1)
+    assert (
+        result
+        == "\x01\x1b]633;C\x07\x1b]633;E;None\x07\x1b]633;D;0\x07\x1b]633;A\x07\x02>>> \x01\x1b]633;B\x07\x02"
+    )
+
+
 if sys.platform == "darwin":
 
     def test_print_statement_darwin(monkeypatch):