Update docs and tests changed by GH-157585

Too complex source now raises SyntaxError, so the tests inject
MemoryError to test that any compile() error is reported.
Compiling a too deeply nested AST object still raises RecursionError.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: serhiy-storchaka

Doc/builtins/functions.rst

@@ -390,6 +390,7 @@ are always available.  They are listed here in alphabetical order.
    that is too complex to parse or compile,
    for example an expression with many thousands of nested operators,
    or that is too large;
+   :exc:`RecursionError` if an AST object *source* is too deeply nested;
    and :exc:`ValueError` if *mode* or *flags* is invalid.
 
    If you want to parse Python code into its AST representation, see

Doc/library/code.rst

@@ -74,9 +74,7 @@ build applications which provide an interactive interpreter prompt.
 
    Returns a code object (the same as ``compile(source, filename, symbol)``) if the
    command is complete and valid; ``None`` if the command is incomplete; raises
-   :exc:`SyntaxError` if the command is complete and contains a syntax error, or
-   raises :exc:`OverflowError` or :exc:`ValueError` if the command contains an
-   invalid literal.
+   :exc:`SyntaxError` if the command is complete and invalid.
 
 
 .. _interpreter-objects:
@@ -91,8 +89,8 @@ Interactive Interpreter Objects
    :func:`compile_command`; the default for *filename* is ``'<input>'``, and for
    *symbol* is ``'single'``.  One of several things can happen:
 
-   * The input is incorrect; :func:`compile_command` raised an exception
-     (usually :exc:`SyntaxError`).  A syntax traceback will be
+   * The input is incorrect; :func:`compile_command` raised
+     :exc:`SyntaxError`.  A syntax traceback will be
      printed by calling the :meth:`showsyntaxerror` method.  :meth:`runsource`
      returns ``False``.
 

Lib/code.py

@@ -44,7 +44,7 @@ def runsource(self, source, filename="<input>", symbol="single"):
         One of several things can happen:
 
         1) The input is incorrect; compile_command() raised an
-        exception (usually SyntaxError).  A syntax traceback will be
+        exception (SyntaxError).  A syntax traceback will be
         printed by calling the showsyntaxerror() method.
 
         2) The input is incomplete, and more input is required;

Lib/test/test_code_module.py

@@ -146,13 +146,15 @@ def test_unicode_error(self):
 
     def test_compile_error(self):
         # Any error raised by compile() must be reported (gh-69919).
-        self.infunc.side_effect = ['-' * 100_000 + '1', EOFError('Finished')]
-        self.console.interact()
+        self.infunc.side_effect = ['1', EOFError('Finished')]
+        with mock.patch.object(self.console, 'compile',
+                               side_effect=MemoryError('spam')):
+            self.console.interact()
         output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
         output = output[output.index('(InteractiveConsole)'):]
         output = output[output.index('\n') + 1:]
-        self.assertRegex(output, r'^(MemoryError|RecursionError): ')
-        self.assertIn(self.sysmod.last_type, (MemoryError, RecursionError))
+        self.assertRegex(output, r'^MemoryError: spam\n')
+        self.assertIs(self.sysmod.last_type, MemoryError)
         self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
 
     def test_sysexcepthook(self):

Lib/test/test_pyrepl/test_interact.py

@@ -135,12 +135,13 @@ def test_runsource_shows_syntax_error_for_failed_compilation(self):
     def test_runsource_compile_error(self):
         # Any error raised by compile() is reported (gh-69919).
         console = InteractiveColoredConsole()
-        source = '-' * 100_000 + '1'
         f = io.StringIO()
-        with contextlib.redirect_stderr(f):
-            result = console.runsource(source)
+        with (contextlib.redirect_stderr(f),
+              patch.object(console.compile, 'compiler',
+                           side_effect=MemoryError('spam'))):
+            result = console.runsource('1')
         self.assertFalse(result)
-        self.assertRegex(f.getvalue(), r'^(MemoryError|RecursionError): ')
+        self.assertRegex(f.getvalue(), r'^MemoryError: spam$')
 
     def test_runsource_survives_null_bytes(self):
         console = InteractiveColoredConsole()
@@ -195,9 +196,10 @@ def test_invalid_syntax_single_line(self):
 
     def test_compile_error_single_line(self):
         namespace = {}
-        code = '-' * 100_000 + '1'  # MemoryError or RecursionError
+        code = "1"
         console = InteractiveColoredConsole(namespace, filename="<stdin>")
-        self.assertFalse(_more_lines(console, code))
+        with patch.object(console, 'compile', side_effect=MemoryError):
+            self.assertFalse(_more_lines(console, code))
 
     def test_empty_line(self):
         namespace = {}