unify type-expression lowering into a single pass

`&`/`and` (intersection), `or` (union), `not` (negation) and callable types
(`(A) -> B`, Protocol synthesis) now lower through one pass (callable.rs). the
separate intersection/not_type forward passes and their Fragment-template
lowerer are gone — callable's rewrite gains the boolop cases and reuses the
shared chain-flatten helpers, so `&`/`and`/`or`/`not` are defined in one place.

this composes the per-leaf lowerings inside every type-form and context: a
`float` / literal / `dynamic` arm inside an intersection, union arm, callable
arg/return, or generic subscript is now wrapped (`JustFloat` / `Literal[…]` /
`Any`) instead of leaking raw with an orphan import — by routing re-emitted
leaves through the shared `rewrite_type_expr` composer and materialising narrow
edits through `Fragment::Src` passthrough.

it also closes three composed-position gaps found by sandpit triangulation
(`by check` passes, the transpiled python crashed):

- the `< 3.12` generics polyfill (`TypeVar(bound=)`, `TypeAliasType`) spliced its
  payload through a leaf-only rewriter, leaking raw `&`/`not`; it now routes
  through the full lowerer (`callable::lower_type_expr_full`), matching native
- a synthesized `Protocol` class is hoisted to module top; its `__call__`
  annotations are now forward-reference strings, so they never evaluate a name
  defined later (was a runtime `NameError`)
- a `typeof` nested under a structural type-form (`&`/`or`/`not`/`?`/arrow) is
  skipped by the typeof AST fold, whose statement re-render would otherwise
  drop the lowerer's wide edit and leak the operator raw

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: KotlinIsland

crates/by_transforms/src/transforms/ast_driver.rs

@@ -37,11 +37,11 @@ use super::{
     annotation, anon_named_tuple, auto_quote, callable, cast, coalesce, coalesce_chain, compat,
     decl_site_variance, decorator_keyword, dedent_string, dynamic_keyword, empty_declarations,
     float_const, force_unwrap, generic_call, generics, identity_swap, implicit_typing, init_method,
-    intersection, just_float, kw_subscript, literal_types, main_function, modifiers,
-    mutable_defaults, none_chain, not_type, optional_type, overload, postfix_await, propagate,
-    reified_generic, repeated_underscore, sentinel, some_ctor, string_tag, super_keyword,
-    symbolic_type_op, top_star, tuple_index, type_is, typed_dict_literal, typed_lambda,
-    typeof_keyword, unpack, use_site_variance,
+    just_float, kw_subscript, literal_types, main_function, modifiers, mutable_defaults,
+    none_chain, optional_type, overload, postfix_await, propagate, reified_generic,
+    repeated_underscore, sentinel, some_ctor, string_tag, super_keyword, symbolic_type_op,
+    top_star, tuple_index, type_is, typed_dict_literal, typed_lambda, typeof_keyword, unpack,
+    use_site_variance,
 };
 use crate::Config;
 use crate::type_info::TypeInfo;
@@ -376,15 +376,6 @@ pub(crate) fn run_against_source<'a>(
         text_edits: RefCell::new(vec![]),
     };
 
-    let typeof_inner = typeof_keyword::TypeofFold::new();
-    let typeof_pass = VisitorPass {
-        inner: &typeof_inner,
-        changed_cell: typeof_inner.changed_cell(),
-        imports: vec![],
-        hoist: RefCell::new(vec![]),
-        text_edits: RefCell::new(vec![]),
-    };
-
     // resolve symbolic operations in type positions (`1 + 1` → `Literal[2]`)
     // up front, from the original parse where `typeof` operands are still
     // intact for ty to read. the pass replaces each operation node and must run
@@ -396,6 +387,23 @@ pub(crate) fn run_against_source<'a>(
     ctx.claimed_type_op_ranges = symbolic_folds.claimed_ranges();
     let symbolic_pass = symbolic_type_op::SymbolicTypeOp::new(symbolic_folds);
 
+    // a `typeof` nested under a structural type-form (`&` / `or` / `not` / an
+    // arrow) belongs to the type-expression lowerer's wide edit; the fold
+    // skips those so its statement re-render doesn't drop that edit
+    let typeof_skip = typeof_keyword::collect_structural_typeof_ranges(
+        parsed_handle.suite(),
+        &semantic_model,
+        &ctx.claimed_type_op_ranges,
+    );
+    let typeof_inner = typeof_keyword::TypeofFold::new(typeof_skip);
+    let typeof_pass = VisitorPass {
+        inner: &typeof_inner,
+        changed_cell: typeof_inner.changed_cell(),
+        imports: vec![],
+        hoist: RefCell::new(vec![]),
+        text_edits: RefCell::new(vec![]),
+    };
+
     let tuple_index_pass = tuple_index::TupleIndexPass::new();
 
     let sentinel_inner = sentinel::Sentinel::new();
@@ -425,8 +433,6 @@ pub(crate) fn run_against_source<'a>(
         text_edits: RefCell::new(vec![]),
     };
 
-    let not_type_pass = not_type::NotType::new();
-    let intersection_pass = intersection::IntersectionType::new();
     let dynamic_keyword_pass = dynamic_keyword::DynamicKeywordPass::new();
     let type_is_pass = type_is::TypeIs::new();
     let top_star_pass = top_star::TopStar::new();
@@ -525,8 +531,6 @@ pub(crate) fn run_against_source<'a>(
     // type-aware passes: operate on the salsa-owned parsed module (so
     // semantic queries hit the right AST nodes), emit text_edits / imports
     let type_aware: &[&dyn TypeAwarePass] = &[
-        &not_type_pass,
-        &intersection_pass,
         &dynamic_keyword_pass,
         &just_float_pass,
         &float_const_pass,

crates/by_transforms/src/transforms/callable.rs

@@ -43,8 +43,8 @@ impl<'src> DynamicKeyword<'src> {
         }
     }
 
-    /// public so [`crate::transforms::just_float::rewrite_type_expr`] can drive
-    /// a one-off lowering over a single expression without spinning up a pass
+    /// public so [`crate::transforms::just_float::rewrite_type_expr_with_imports`]
+    /// can drive a one-off lowering over a single expression without a pass
     /// (used by `generics.rs` when the PEP-695 polyfill replaces a whole type
     /// alias / bound and would otherwise subsume our minimal edits)
     pub(crate) fn emit_in_type_expr(&mut self, expr: &Expr) {

crates/by_transforms/src/transforms/dynamic_keyword.rs

@@ -37,8 +37,8 @@ impl<'src> FloatConst<'src> {
     }
 
     /// Run the erasure over a single type expression (used by the composed
-    /// `rewrite_type_expr` in `just_float`, where a polyfill replaces the whole
-    /// range and would otherwise subsume our in-place edits)
+    /// `rewrite_type_expr_with_imports` in `just_float`, where a polyfill
+    /// replaces the whole range and would otherwise subsume our in-place edits)
     pub(crate) fn emit_in_type_expr(&mut self, expr: &Expr) {
         walk_one_type_expr(expr, self);
     }

crates/by_transforms/src/transforms/float_const.rs

@@ -9,7 +9,7 @@ use ruff_python_ast::{
 use ruff_text_size::{Ranged, TextRange, TextSize};
 
 use crate::config::Config;
-use crate::transforms::just_float;
+use crate::transforms::callable::lower_type_expr_full;
 use crate::type_info::TypeInfo;
 use ruff_python_ast::PythonVersion;
 
@@ -278,17 +278,16 @@ impl<'src> GenericPolyfill<'src> {
                                     format!("tuple[{inner}]")
                                 }
                             } else {
-                                just_float::rewrite_type_expr(self.source, self.types, bound)
+                                lower_type_expr_full(self.source, self.types, bound)
                                     .unwrap_or_else(|| self.src(bound.range()).to_owned())
                             };
                             extra_args.push(format!("bound={bound_src}"));
                         }
                     }
 
                     if let Some(default) = &tv.default {
-                        let default_src =
-                            just_float::rewrite_type_expr(self.source, self.types, default)
-                                .unwrap_or_else(|| self.src(default.range()).to_owned());
+                        let default_src = lower_type_expr_full(self.source, self.types, default)
+                            .unwrap_or_else(|| self.src(default.range()).to_owned());
                         if self.config.min_version < PythonVersion::PY313 {
                             self.needed_imports.typevar_needs_ext = true;
                         }
@@ -600,7 +599,7 @@ impl<'src> GenericPolyfill<'src> {
         // Pull in the literal-types + just-float rewrite for the RHS — our
         // `alias.range()` edit subsumes anything those emitted on the value
         // alone, so we have to splice the rewrite into our output.
-        let literal_rewrite = just_float::rewrite_type_expr(self.source, self.types, &alias.value);
+        let literal_rewrite = lower_type_expr_full(self.source, self.types, &alias.value);
 
         let (type_params_arg, defs, value_src) = if let Some(tp) = &alias.type_params {
             let (generic_args, type_defs, rename_map) = self.process_type_params(&tp.type_params);
@@ -1440,15 +1439,18 @@ mod tests {
 
     #[test]
     fn tuple_bound_is_not_constraints() {
-        // In basedpython, `T: (int, str)` means bound=(int, str), NOT positional
-        // constraints. Use `T: constraints(int, str)` for that.
+        // In basedpython, `T: (int, str)` is a tuple-type upper bound, NOT
+        // positional constraints. Use `T: constraints(int, str)` for that. the
+        // bound lowers like any other type expression (matching the native
+        // `class Foo[T: tuple[int, str]]` form), since the polyfill routes the
+        // bound through the same type-expression lowerer
         check(
             indoc! {"
                 class Foo[T: (int, str)]: ...
             "},
             indoc! {"
                 from typing import TypeVar, Generic
-                _T = TypeVar(\"_T\", bound=(int, str))
+                _T = TypeVar(\"_T\", bound=tuple[int, str])
                 class Foo(Generic[_T]): ...
             "},
         );
@@ -1531,12 +1533,56 @@ mod tests {
 
     #[test]
     fn by_tuple_is_bound() {
-        // In .by files, T: (int, str) is an upper bound (tuple type), not constraints.
+        // In .by files, T: (int, str) is an upper bound (tuple type), not
+        // constraints — and it lowers to `tuple[int, str]` like the native form
         check(
             "class Foo[T: (int, str)]: ...\n",
             indoc! {"
                 from typing import TypeVar, Generic
-                _T = TypeVar(\"_T\", bound=(int, str))
+                _T = TypeVar(\"_T\", bound=tuple[int, str])
+                class Foo(Generic[_T]): ...
+            "},
+        );
+    }
+
+    #[test]
+    fn intersection_bound_polyfilled() {
+        // an `&` bound lowers to `Intersection[...]` even on the < 3.12 polyfill
+        // path: the `TypeVar(bound=)` payload routes through the full type
+        // lowerer, matching the native `class Foo[T: Intersection[A, B]]`
+        check(
+            "class Foo[T: A & B]: ...\n",
+            indoc! {"
+                from ty_extensions import Intersection
+                from typing import TypeVar, Generic
+                _T = TypeVar(\"_T\", bound=Intersection[A, B])
+                class Foo(Generic[_T]): ...
+            "},
+        );
+    }
+
+    #[test]
+    fn negation_bound_polyfilled() {
+        check(
+            "class Foo[T: not int]: ...\n",
+            indoc! {"
+                from ty_extensions import Not
+                from typing import TypeVar, Generic
+                _T = TypeVar(\"_T\", bound=Not[int])
+                class Foo(Generic[_T]): ...
+            "},
+        );
+    }
+
+    #[test]
+    fn leaf_composes_in_polyfilled_bound() {
+        // per-leaf lowering still composes inside the spliced bound
+        check(
+            "class Foo[T: A & float]: ...\n",
+            indoc! {"
+                from ty_extensions import Intersection, JustFloat
+                from typing import TypeVar, Generic
+                _T = TypeVar(\"_T\", bound=Intersection[A, JustFloat])
                 class Foo(Generic[_T]): ...
             "},
         );