youknowone · Sep 30, 2026 · Sep 21, 2026 · Sep 26, 2026 · Sep 26, 2026 · Sep 29, 2026
diff --git a/crates/compiler/src/lib.rs b/crates/compiler/src/lib.rs
@@ -6796,6 +6796,17 @@ pub fn leading_byte_order_mark_error(source_file: &SourceFile) -> Option<Compile
     })
 }
 
+/// Source-level errors raised before parsing, as CPython's tokenizer does.
+///
+/// Checking after the parse would build the tree first, and one nested that
+/// deep exhausts the native stack when it is dropped.
+pub fn pre_parse_source_error(source_file: &SourceFile) -> Result<(), CompileError> {
+    match too_many_nested_parentheses_error(source_file.source_text()) {
+        Some(error) => Err(CompileError::from_source_error(source_file, error)),
+        None => Ok(()),
+    }
+}
+
 fn post_parse_source_error(
     source_file: &SourceFile,
     tokens: &Tokens,
@@ -6804,9 +6815,6 @@ fn post_parse_source_error(
     if let Some(error) = leading_byte_order_mark_error(source_file) {
         return Some(error);
     }
-    if let Some(error) = too_many_nested_parentheses_error(source_file.source_text()) {
-        return Some(CompileError::from_source_error(source_file, error));
-    }
     if let Some(error) = too_many_nested_interpolated_strings(source_file.source_text()) {
         return Some(CompileError::from_source_error(source_file, error));
     }
@@ -6837,6 +6845,82 @@ fn is_compound_stmt(stmt: &ast::Stmt) -> bool {
     )
 }
 
+/// Rejects an AST nested deeper than `limit`.
+///
+/// The parser grows its own stack, so it returns trees deeper than the passes
+/// after it can walk, and each of those recurses without a limit of its own.
+/// The symbol table applies the same limit, but `compile(..., PyCF_ONLY_AST)`
+/// returns before reaching it.
+pub fn too_deeply_nested_error(
+    ast: &ast::Mod,
+    source_file: &SourceFile,
+    limit: usize,
+) -> Result<(), CompileError> {
+    use ast::visitor::Visitor;
+
+    struct DepthChecker {
+        depth: usize,
+        limit: usize,
+        too_deep: Option<ruff_text_size::TextRange>,
+    }
+
+    impl DepthChecker {
+        fn descend(&mut self, range: ruff_text_size::TextRange, walk: impl FnOnce(&mut Self)) {
+            if self.too_deep.is_some() {
+                return;
+            }
+            if self.depth >= self.limit {
+                self.too_deep = Some(range);
+                return;
+            }
+            self.depth += 1;
+            walk(self);
+            self.depth -= 1;
+        }
+    }
+
+    impl<'a> Visitor<'a> for DepthChecker {
+        fn visit_stmt(&mut self, stmt: &'a ast::Stmt) {
+            self.descend(stmt.range(), |checker| {
+                ast::visitor::walk_stmt(checker, stmt);
+            });
+        }
+
+        fn visit_expr(&mut self, expr: &'a ast::Expr) {
+            self.descend(expr.range(), |checker| {
+                ast::visitor::walk_expr(checker, expr);
+            });
+        }
+
+        fn visit_pattern(&mut self, pattern: &'a ast::Pattern) {
+            self.descend(pattern.range(), |checker| {
+                ast::visitor::walk_pattern(checker, pattern);
+            });
+        }
+    }
+
+    let mut checker = DepthChecker {
+        depth: 0,
+        limit,
+        too_deep: None,
+    };
+    match ast {
+        ast::Mod::Module(module) => checker.visit_body(&module.body),
+        ast::Mod::Expression(expression) => checker.visit_expr(&expression.body),
+    }
+
+    let Some(range) = checker.too_deep else {
+        return Ok(());
+    };
+    let (location, end_location) = source_locations(source_file, range.start(), range.end());
+    Err(CompileError::Codegen(codegen::error::CodegenError {
+        location: Some(location),
+        end_location: Some(end_location),
+        error: codegen::error::CodegenErrorType::RecursionError,
+        source_path: source_file.name().to_owned(),
+    }))
+}
+
 /// Syntax the reference grammar has no rule for, but that this parser accepts.
 ///
 /// A bare generator expression is one: `f(x for x in y)` is the `primary
@@ -7192,6 +7276,7 @@ fn _compile_with_syntax_warning_handler<'a>(
         opts.future_features
             .contains(core::bytecode::CodeFlags::FUTURE_BARRY_AS_BDFL),
     );
+    pre_parse_source_error(&source_file)?;
     let parsed = parser::parse(barry_source.source(), parser_options);
     if let Some(error) = barry_source.diagnostic(parsed.as_ref().err(), &source_file) {
         return Err(error);
@@ -7213,6 +7298,7 @@ fn _compile_with_syntax_warning_handler<'a>(
         return Err(error);
     }
     let ast = parsed.into_syntax();
+    too_deeply_nested_error(&ast, &source_file, opts.recursion_limit)?;
     if let Some(error) = unsupported_grammar_error(&ast, &source_file) {
         return Err(error);
     }
@@ -7493,6 +7579,7 @@ pub fn _compile_symtable(
         prepare_barry_as_flufl_source(source_file.source_text(), parser_options.clone(), false);
     let res = match mode {
         Mode::Exec | Mode::Single | Mode::BlockExpr => {
+            pre_parse_source_error(&source_file)?;
             let parsed = ruff_python_parser::parse(barry_source.source(), parser_options);
             if let Some(error) = barry_source.diagnostic(parsed.as_ref().err(), &source_file) {
                 return Err(error);
@@ -7505,6 +7592,7 @@ pub fn _compile_symtable(
                 return Err(error);
             }
             let ast = ast.into_syntax();
+            too_deeply_nested_error(&ast, &source_file, CompileOpts::default().recursion_limit)?;
             if let Some(error) = unsupported_grammar_error(&ast, &source_file) {
                 return Err(error);
             }
@@ -7519,6 +7607,7 @@ pub fn _compile_symtable(
             symboltable::SymbolTable::scan_program(&ast, source_file.clone())
         }
         Mode::Eval => {
+            pre_parse_source_error(&source_file)?;
             let parsed = ruff_python_parser::parse(barry_source.source(), parser_options);
             if let Some(error) = barry_source.diagnostic(parsed.as_ref().err(), &source_file) {
                 return Err(error);
@@ -7531,6 +7620,7 @@ pub fn _compile_symtable(
                 return Err(error);
             }
             let ast = ast.into_syntax();
+            too_deeply_nested_error(&ast, &source_file, CompileOpts::default().recursion_limit)?;
             if let Some(error) = unsupported_grammar_error(&ast, &source_file) {
                 return Err(error);
             }

diff --git a/crates/vm/src/stdlib/_ast.rs b/crates/vm/src/stdlib/_ast.rs
@@ -1813,6 +1813,7 @@ pub(crate) fn parse(
         options.clone(),
         explicit_future_features.contains(crate::bytecode::CodeFlags::FUTURE_BARRY_AS_BDFL),
     );
+    rustpython_compiler::pre_parse_source_error(&source_file)?;
     let parsed = parser::parse_unchecked(barry_source.source(), options);
     let type_comment_source =
         type_comments.then(|| TypeCommentSource::new(source, parsed.tokens()));
@@ -1881,6 +1882,11 @@ pub(crate) fn parse(
         return Err(error);
     }
     let mut top = parsed.into_syntax();
+    rustpython_compiler::too_deeply_nested_error(
+        &top,
+        &source_file,
+        rustpython_compiler::CompileOpts::default().recursion_limit,
+    )?;
     if let Some(error) = rustpython_compiler::unsupported_grammar_error(&top, &source_file) {
         return Err(error);
     }

diff --git a/crates/vm/src/vm/compile.rs b/crates/vm/src/vm/compile.rs
@@ -1381,6 +1381,10 @@ mod escape_warnings {
         filename: &'a str,
         vm: &'a VirtualMachine,
         error: Option<CompileWarningError>,
+        /// This pass runs before the compile that rejects an over-nested
+        /// tree, so it has to stop itself.
+        depth: usize,
+        depth_limit: usize,
     }
 
     impl<'a> EscapeWarningVisitor<'a> {
@@ -1525,7 +1529,13 @@ mod escape_warnings {
                         }
                     }
                 }
-                _ => ast::visitor::walk_expr(self, expr),
+                _ => {
+                    if self.depth < self.depth_limit {
+                        self.depth += 1;
+                        ast::visitor::walk_expr(self, expr);
+                        self.depth -= 1;
+                    }
+                }
             }
         }
     }
@@ -1548,6 +1558,12 @@ mod escape_warnings {
             source: &str,
             filename: &str,
         ) -> Result<(), CompileWarningError> {
+            // The compile that follows rejects this source; parsing it here
+            // would build a tree that exhausts the stack when dropped.
+            let source_file = compiler::core::SourceFileBuilder::new(filename, source).finish();
+            if compiler::pre_parse_source_error(&source_file).is_err() {
+                return Ok(());
+            }
             let Ok(parsed) =
                 ruff_python_parser::parse(source, ruff_python_parser::Mode::Module.into())
             else {
@@ -1559,6 +1575,8 @@ mod escape_warnings {
                 filename,
                 vm: self,
                 error: None,
+                depth: 0,
+                depth_limit: compiler::CompileOpts::default().recursion_limit,
             };
             match &ast {
                 ast::Mod::Module(module) => {

diff --git a/extra_tests/snippets/syntax_deep_nesting.py b/extra_tests/snippets/syntax_deep_nesting.py
@@ -0,0 +1,51 @@
+import ast
+
+from testutils import assert_raises
+
+# Deeply nested source used to exhaust the native stack, killing the process
+# with a signal no `except` here could catch. What is asserted below is mostly
+# that this file finishes at all: reaching the end means each case raised a
+# Python exception instead of taking the interpreter down.
+#
+# Two limits keep that from happening, and each has to apply before a tree that
+# deep is built. The parser grows its own stack when it runs low on one, and a
+# tree it returns costs stack both to walk and to drop, so checking afterwards
+# is already too late.
+
+
+def nested_binop(depth):
+    return "x" + "+1" * depth
+
+
+def nested_brackets(depth):
+    return "[" * depth + "1" + "]" * depth
+
+
+# Brackets are counted in the source text before it is parsed, the way CPython
+# counts them in its tokenizer, so no tree is built for these at all.
+assert_raises(SyntaxError, compile, nested_brackets(200000), "<test>", "exec")
+assert_raises(SyntaxError, ast.parse, nested_brackets(200000))
+assert_raises(SyntaxError, compile, nested_brackets(5000), "<test>", "exec")
+assert_raises(SyntaxError, ast.parse, nested_brackets(5000))
+
+# Nesting that reaches the parser is bounded by the compiler's recursion limit,
+# applied to the tree it returns. CPython bounds the same walks by how much
+# stack is left rather than by a count, so it accepts depths rejected here;
+# either outcome is fine, crashing is not.
+try:
+    compile(nested_binop(20000), "<test>", "exec")
+except RecursionError:
+    pass
+
+# `compile(..., PyCF_ONLY_AST)`, which `ast.parse` uses, returns before the
+# symbol table runs, so it used to reach the limit of no pass at all.
+try:
+    ast.parse(nested_binop(5000))
+except RecursionError:
+    pass
+
+# Nesting within both limits still compiles and runs.
+assert compile(nested_binop(100), "<test>", "exec")
+assert compile(nested_brackets(100), "<test>", "exec")
+assert ast.parse(nested_binop(100))
+assert eval(compile(nested_binop(100), "<test>", "eval"), {"x": 0}) == 100