fix three checker/runtime divergences the harness surfaced

Author: KotlinIsland

crates/by_transforms/src/lib.rs

@@ -508,7 +508,12 @@ fn run_lowering_phase(
     _types: &dyn TypeInfo,
 ) -> LoweringResult {
     let mut output = String::new();
-    if config.inject_future_annotations && !config.is_stub && !has_future_annotations(stmts) {
+    // below 3.10 the runtime cannot evaluate pep 604 `X | Y` annotations —
+    // which the optional lowering itself produces — so annotation evaluation
+    // must always be deferred on those targets
+    let needs_lazy_annotations =
+        config.inject_future_annotations || config.min_version < PythonVersion::PY310;
+    if needs_lazy_annotations && !config.is_stub && !has_future_annotations(stmts) {
         output.push_str("from __future__ import annotations\n");
     }
     output.push_str(source);

crates/by_transforms/src/transforms/ast_driver.rs

@@ -416,7 +416,7 @@ pub(crate) fn run_against_source<'a>(
         text_edits: RefCell::new(vec![]),
     };
 
-    let typed_lambda_inner = typed_lambda::TypedLambda::new();
+    let typed_lambda_inner = typed_lambda::TypedLambda::new(source_ref);
     let typed_lambda_pass = VisitorPass {
         inner: &typed_lambda_inner,
         changed_cell: typed_lambda_inner.changed_cell(),

crates/by_transforms/src/transforms/auto_quote.rs

@@ -45,16 +45,16 @@ impl<'src> AutoQuote<'src> {
 
 impl AstPass for AutoQuote<'_> {
     fn run(&self, module: &mut ModModule, ctx: &mut PassContext) {
-        // skip quoting whenever annotations won't be eagerly evaluated:
-        // native deferral on 3.14+, or a future import that defers them all
-        if self.min_version.defers_annotations()
+        // annotation positions need no quoting when they won't be eagerly
+        // evaluated: native deferral on 3.14+ (PEP 649), or a future import
+        // that defers them all. class *bases* and value-position subscripts
+        // (`class A(list[A])`, `list[A]()`) evaluate eagerly regardless, so
+        // their self-references are always quoted
+        let quote_annotations = !(self.min_version.defers_annotations()
             || self.inject_future
-            || has_future_annotations(&module.body)
-        {
-            return;
-        }
+            || has_future_annotations(&module.body));
         let mut edits: Vec<(TextRange, String)> = Vec::new();
-        process_stmts(&module.body, self.source, &mut edits);
+        process_stmts(&module.body, self.source, &mut edits, quote_annotations);
         ctx.text_edits.extend(edits);
     }
 }
@@ -67,51 +67,66 @@ fn has_future_annotations(stmts: &[Stmt]) -> bool {
     })
 }
 
-fn process_stmts(stmts: &[Stmt], source: &str, edits: &mut Vec<(TextRange, String)>) {
+fn process_stmts(
+    stmts: &[Stmt],
+    source: &str,
+    edits: &mut Vec<(TextRange, String)>,
+    quote_annotations: bool,
+) {
     for stmt in stmts {
         if let Stmt::ClassDef(c) = stmt {
-            process_class(c, source, edits);
+            process_class(c, source, edits, quote_annotations);
             // nested classes inside this one's body are recursed into by
             // process_class so the inner ClassDef walks with its own name
         } else {
             // top-level non-class statements may contain nested classes via
             // function bodies — descend
-            walk_for_nested_classes(stmt, source, edits);
+            walk_for_nested_classes(stmt, source, edits, quote_annotations);
         }
     }
 }
 
-fn walk_for_nested_classes(stmt: &Stmt, source: &str, edits: &mut Vec<(TextRange, String)>) {
+fn walk_for_nested_classes(
+    stmt: &Stmt,
+    source: &str,
+    edits: &mut Vec<(TextRange, String)>,
+    quote_annotations: bool,
+) {
     // only walk into structures that may contain nested class defs.
     // function bodies, if/while/try blocks, etc.
     match stmt {
-        Stmt::FunctionDef(f) => process_stmts(&f.body, source, edits),
+        Stmt::FunctionDef(f) => process_stmts(&f.body, source, edits, quote_annotations),
         Stmt::If(i) => {
-            process_stmts(&i.body, source, edits);
+            process_stmts(&i.body, source, edits, quote_annotations);
             for clause in &i.elif_else_clauses {
-                process_stmts(&clause.body, source, edits);
+                process_stmts(&clause.body, source, edits, quote_annotations);
             }
         }
-        Stmt::While(w) => process_stmts(&w.body, source, edits),
+        Stmt::While(w) => process_stmts(&w.body, source, edits, quote_annotations),
         Stmt::For(f) => {
-            process_stmts(&f.body, source, edits);
-            process_stmts(&f.orelse, source, edits);
+            process_stmts(&f.body, source, edits, quote_annotations);
+            process_stmts(&f.orelse, source, edits, quote_annotations);
         }
-        Stmt::With(w) => process_stmts(&w.body, source, edits),
+        Stmt::With(w) => process_stmts(&w.body, source, edits, quote_annotations),
         Stmt::Try(t) => {
-            process_stmts(&t.body, source, edits);
+            process_stmts(&t.body, source, edits, quote_annotations);
             for h in &t.handlers {
                 let ruff_python_ast::ExceptHandler::ExceptHandler(eh) = h;
-                process_stmts(&eh.body, source, edits);
+                process_stmts(&eh.body, source, edits, quote_annotations);
             }
-            process_stmts(&t.orelse, source, edits);
-            process_stmts(&t.finalbody, source, edits);
+            process_stmts(&t.orelse, source, edits, quote_annotations);
+            process_stmts(&t.finalbody, source, edits, quote_annotations);
         }
         _ => {}
     }
 }
 
-fn process_class(class: &StmtClassDef, source: &str, edits: &mut Vec<(TextRange, String)>) {
+fn process_class(
+    class: &StmtClassDef,
+    source: &str,
+    edits: &mut Vec<(TextRange, String)>,
+    quote_annotations: bool,
+) {
     let class_name = class.name.id.as_str();
     let typevar_names: Vec<String> = class
         .type_params
@@ -148,25 +163,30 @@ fn process_class(class: &StmtClassDef, source: &str, edits: &mut Vec<(TextRange,
     // (handled by walker), method bodies need separate descent for
     // `list[A]()` patterns
     for stmt in &class.body {
-        process_class_body_stmt(stmt, &mut visitor);
+        process_class_body_stmt(stmt, &mut visitor, quote_annotations);
     }
 
     // recurse into nested classes inside the body so they get their own
     // class-context walk (the `visitor` borrow of `edits` ends above)
-    process_stmts(&class.body, source, edits);
+    process_stmts(&class.body, source, edits, quote_annotations);
 }
 
-fn process_class_body_stmt(stmt: &Stmt, visitor: &mut Visitor<'_>) {
+fn process_class_body_stmt(stmt: &Stmt, visitor: &mut Visitor<'_>, quote_annotations: bool) {
     match stmt {
         Stmt::Expr(e) => walk_value_subscripts(e.value.as_ref(), visitor),
         Stmt::Assign(a) => walk_value_subscripts(a.value.as_ref(), visitor),
         Stmt::AnnAssign(a) => {
-            walk_one_type_expr(a.annotation.as_ref(), visitor);
+            if quote_annotations {
+                walk_one_type_expr(a.annotation.as_ref(), visitor);
+            }
             if let Some(value) = &a.value {
                 walk_value_subscripts(value.as_ref(), visitor);
             }
         }
         Stmt::FunctionDef(f) => {
+            if !quote_annotations {
+                return;
+            }
             for param in f.parameters.iter_non_variadic_params() {
                 if let Some(ann) = &param.parameter.annotation {
                     walk_one_type_expr(ann, visitor);
@@ -516,6 +536,21 @@ mod tests {
         );
     }
 
+    #[test]
+    fn class_base_still_quoted_when_version_defers_annotations() {
+        // pep 649 defers annotations only — a class *base* evaluates eagerly,
+        // so its self-reference still needs the quote
+        let config = Config {
+            min_version: PythonVersion::from((3, 14)),
+            ..Config::test_default()
+        };
+        let out = transpile_with("class A(list[A]):\n    pass\n", &config);
+        assert!(
+            out.contains("class A(list[\"A\"]):"),
+            "base self-ref must stay quoted on 3.14+, got: {out}"
+        );
+    }
+
     #[test]
     fn not_quoted_when_source_has_future() {
         // a user-written future import already defers every annotation

crates/by_transforms/src/transforms/mutable_defaults.rs

@@ -14,6 +14,8 @@
 //! function, body included, keeps its source bytes, so sibling lowerings
 //! (`??`, `?.`, `int?` annotations, …) anywhere in the function still apply.
 
+use std::fmt::Write as _;
+
 use ruff_python_ast::visitor::{Visitor, walk_stmt};
 use ruff_python_ast::{Expr, Stmt, StmtFunctionDef, UnaryOp};
 use ruff_text_size::{Ranged, TextRange};
@@ -92,30 +94,33 @@ impl MutableDefaults<'_> {
                 // each guard re-establishes it for the following line
                 let base = prefix.to_owned();
                 for (name, default) in &guards {
-                    text.push_str(&format!(
+                    let _ = write!(
+                        text,
                         "if {name} is _MISSING:\n{base}    {name} = {default}\n{base}"
-                    ));
+                    );
                 }
             } else {
                 // single-line body (`def f(x=[]): ...`) — break it onto its own
                 // indented line after the guards
                 let base = format!("{}    ", line_indent(self.source, f.range().start()));
                 for (name, default) in &guards {
-                    text.push_str(&format!(
+                    let _ = write!(
+                        text,
                         "\n{base}if {name} is _MISSING:\n{base}    {name} = {default}"
-                    ));
+                    );
                 }
-                text.push_str(&format!("\n{base}"));
+                let _ = write!(text, "\n{base}");
             }
             self.edits.push((TextRange::empty(insert_at), text));
         } else {
             // docstring-only body: append the guards after it
             let doc_end = f.body[docstring_count - 1].range().end();
             let base = format!("{}    ", line_indent(self.source, f.range().start()));
             for (name, default) in &guards {
-                text.push_str(&format!(
+                let _ = write!(
+                    text,
                     "\n{base}if {name} is _MISSING:\n{base}    {name} = {default}"
-                ));
+                );
             }
             self.edits.push((TextRange::empty(doc_end), text));
         }

crates/by_transforms/src/transforms/optional_type.rs

@@ -196,6 +196,20 @@ class Optional:
         check("x: int?\n", "x: int | None\n");
     }
 
+    #[test]
+    fn py39_target_defers_annotation_evaluation() {
+        // below 3.10 the runtime cannot evaluate the pep 604 union this very
+        // lowering produces, so the future import is mandatory
+        let config = crate::Config {
+            min_version: crate::PythonVersion::PY39,
+            ..crate::Config::test_default()
+        };
+        assert_eq!(
+            crate::transpile("x: int? = None\n", &config).unwrap(),
+            "from __future__ import annotations\nx: int | None = None\n"
+        );
+    }
+
     #[test]
     fn optional_of_negation_composes() {
         // the operand source is preserved, so the `not_type` transform still

crates/by_transforms/src/transforms/typed_lambda.rs

@@ -12,14 +12,17 @@ use std::cell::Cell;
 
 use ruff_python_ast::visitor::transformer::{Transformer, walk_expr};
 use ruff_python_ast::{Expr, Parameters, Stmt};
+use ruff_text_size::{Ranged, TextRange};
 
-pub(crate) struct TypedLambda {
+pub(crate) struct TypedLambda<'src> {
+    source: &'src str,
     changed: Cell<bool>,
 }
 
-impl TypedLambda {
-    pub(crate) fn new() -> Self {
+impl<'src> TypedLambda<'src> {
+    pub(crate) fn new(source: &'src str) -> Self {
         Self {
+            source,
             changed: Cell::new(false),
         }
     }
@@ -54,7 +57,7 @@ impl TypedLambda {
     }
 }
 
-impl Transformer for TypedLambda {
+impl Transformer for TypedLambda<'_> {
     fn visit_stmt(&self, stmt: &mut Stmt) {
         ruff_python_ast::visitor::transformer::walk_stmt(self, stmt);
     }
@@ -73,6 +76,14 @@ impl Transformer for TypedLambda {
             lambda.returns = None;
             any = true;
         }
+        // a parenthesized parameter list (`lambda (x): …`) is based-only
+        // surface even without annotations — re-render to the bare form
+        if let Some(p) = lambda.parameters.as_deref()
+            && p.range() != TextRange::default()
+            && self.source.as_bytes().get(usize::from(p.range().start())) == Some(&b'(')
+        {
+            any = true;
+        }
         if any {
             self.changed.set(true);
         }
@@ -109,6 +120,13 @@ mod tests {
         check("a = lambda () -> int: 42\n", "a = lambda : 42\n");
     }
 
+    #[test]
+    fn parenthesized_untyped_lambda() {
+        // parens around lambda params are based-only surface even with no
+        // annotations — they must not leak into the output
+        check("g = lambda (x): str(x)\n", "g = lambda x: str(x)\n");
+    }
+
     #[test]
     fn untyped_lambda_unchanged() {
         check("a = lambda x, y: x + y\n", "a = lambda x, y: x + y\n");