gh-89723: Set sys.last_* for SyntaxErrors in the IDLE Shell

The standard interpreter sets sys.last_type, sys.last_value,
sys.last_traceback, and sys.last_exc for an unhandled SyntaxError.  IDLE
did not, because it catches the error in its GUI process while user code
runs in a separate process.  Send the exception to the user process and
set the attributes there.

Author: serhiy-storchaka

Lib/idlelib/idle_test/test_run.py

@@ -2,6 +2,7 @@
 
 from idlelib import run
 import io
+import pickle
 import sys
 from test.support import captured_output, captured_stderr
 import unittest
@@ -521,6 +522,32 @@ def test_exceptions(self):
         self.assertIs(t, TypeError)
         self.assertTrue(isinstance(e.__context__, ZeroDivisionError))
 
+    def test_setup_last_exception(self):
+        # gh-89723: sys.last_* are set for a SyntaxError caught in the GUI.
+        attrs = 'last_type', 'last_value', 'last_traceback', 'last_exc'
+        saved = {a: getattr(sys, a) for a in attrs if hasattr(sys, a)}
+        def restore():
+            for a in attrs:
+                if a in saved:
+                    setattr(sys, a, saved[a])
+                elif hasattr(sys, a):
+                    delattr(sys, a)
+        self.addCleanup(restore)
+
+        try:
+            compile('1 +', '<pyshell#0>', 'exec')
+        except SyntaxError as e:
+            exc = e
+        # The exception reaches the user process pickled, without a traceback.
+        exc = pickle.loads(pickle.dumps(exc))
+        self.assertIsNone(exc.__traceback__)
+
+        self.ex.setup_last_exception(exc)
+        self.assertIs(sys.last_exc, exc)
+        self.assertIs(sys.last_value, exc)
+        self.assertIs(sys.last_type, SyntaxError)
+        self.assertIsNone(sys.last_traceback)
+
 
 if __name__ == '__main__':
     unittest.main(verbosity=2)

Lib/idlelib/pyshell.py

@@ -732,6 +732,17 @@ def showsyntaxerror(self, filename=None, **kwargs):
         tkconsole.colorize_syntax_error(text, pos)
         tkconsole.resetoutput()
         self.write("SyntaxError: %s\n" % msg)
+        # The standard interpreter sets sys.last_* for an unhandled
+        # SyntaxError, but IDLE catches it here in the GUI process, so set
+        # them in the user process instead (gh-89723).
+        if self.rpcclt:
+            self.rpcclt.remotequeue("exec", "setup_last_exception",
+                                    (value,), {})
+        else:
+            value = value.with_traceback(None)
+            sys.last_exc = sys.last_value = value
+            sys.last_type = type
+            sys.last_traceback = None
         tkconsole.showprompt()
 
     def showtraceback(self):

Lib/idlelib/run.py

@@ -677,6 +677,12 @@ def runcode(self, code):
         else:
             flush_stdout()
 
+    def setup_last_exception(self, exc):
+        "Set sys.last_* for an exception caught in the GUI process (gh-89723)."
+        sys.last_exc = sys.last_value = exc
+        sys.last_type = type(exc)
+        sys.last_traceback = exc.__traceback__
+
     def interrupt_the_server(self):
         if interruptible:
             thread.interrupt_main()

Misc/NEWS.d/next/IDLE/2026-07-01-12-00-00.gh-issue-89723.Kd8xY2.rst

@@ -0,0 +1,3 @@
+Set ``sys.last_exc`` and friends in the user process for a ``SyntaxError``
+entered in the Shell, as the standard interpreter does.  Previously they
+were left unset because IDLE catches the error in its GUI process.