fold a typeof-bearing symbolic op nested in a subscript

Author: KotlinIsland

crates/by_transforms/src/transforms/callable.rs

@@ -37,6 +37,11 @@ use crate::type_info::TypeInfo;
 pub(crate) struct CallableSyntax<'src> {
     source: &'src str,
     types: Option<&'src (dyn TypeInfo + 'src)>,
+    /// ranges already folded by `symbolic_type_op` (e.g. `1 + typeof d` →
+    /// `Literal[3]`). a claimed sub-expression is opaque here: descending into
+    /// it would re-render its `typeof`/operator surface and the wider edit
+    /// would clobber the fold, so `rewrite` leaves it for the fold's own edit
+    claimed_ranges: &'src [TextRange],
     pub(crate) edits: Vec<Fix>,
     pub(crate) needs_import: bool,
     pub(crate) needs_protocol_import: bool,
@@ -64,6 +69,7 @@ impl<'src> CallableSyntax<'src> {
         Self {
             source,
             types: None,
+            claimed_ranges: &[],
             edits: Vec::new(),
             needs_import: false,
             needs_protocol_import: false,
@@ -81,6 +87,11 @@ impl<'src> CallableSyntax<'src> {
         self
     }
 
+    pub(crate) fn with_claimed_ranges(mut self, claimed: &'src [TextRange]) -> Self {
+        self.claimed_ranges = claimed;
+        self
+    }
+
     pub(crate) fn class_defs(&self) -> &str {
         &self.protocol_class_defs
     }
@@ -228,6 +239,12 @@ impl<'src> CallableSyntax<'src> {
     }
 
     pub(crate) fn rewrite(&mut self, expr: &Expr) -> Option<String> {
+        // a symbolic-fold-claimed sub-expression is opaque: the fold emits its
+        // own edit over this exact range, so re-rendering here (and clobbering
+        // it with a wider edit) must not happen
+        if self.claimed_ranges.contains(&expr.range()) {
+            return None;
+        }
         match expr {
             Expr::CallableType(ct) if self.is_non_denotable(ct) => {
                 self.needs_protocol_import = true;
@@ -517,7 +534,12 @@ impl<'ast> ruff_python_ast::visitor::Visitor<'ast> for ValueCallableWalker<'_, '
 
 impl TypeAwarePass for CallableSyntaxPass<'_> {
     fn run(&self, stmts: &[Stmt], types: &dyn TypeInfo, ctx: &mut PassContext) {
-        let mut inner = CallableSyntax::new(self.source).with_types(types);
+        // owned copy so `inner`'s borrow doesn't pin `ctx` against the mutable
+        // `required_imports` / `edits` uses below
+        let claimed = ctx.claimed_type_op_ranges.clone();
+        let mut inner = CallableSyntax::new(self.source)
+            .with_types(types)
+            .with_claimed_ranges(&claimed);
         crate::transforms::type_expr_walker::walk_type_positions_skipping(
             stmts,
             Some(types),

crates/by_transforms/src/transforms/symbolic_type_op.rs

@@ -415,6 +415,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn typeof_operand_nested_in_subscript() {
+        // the fold consumes the `typeof` operand even inside a subscript slice,
+        // so no `TypeOf` survives and the whole operation collapses to its type
+        check(
+            "let d = 2\nx: list[1 + typeof d]\n",
+            indoc! {"
+                from typing import Final, Literal
+                d: Final = 2
+                x: list[Literal[3]]
+            "},
+        );
+    }
+
     #[test]
     fn chained_addition() {
         check(

crates/ty_python_semantic/resources/mdtest/basedpython_symbolic_type_ops.md

@@ -43,6 +43,18 @@ def f(e: 1 + typeof d) -> None:
     reveal_type(e)  # revealed: 3
 ```
 
+## a `typeof` operand folds inside a subscript too
+
+the fold reaches operations nested in a generic subscript — the whole operation collapses to its
+type and the `typeof` is consumed, so no `TypeOf` leaks into the slice
+
+```by
+let d = 2
+
+def f(xs: list[1 + typeof d]) -> None:
+    reveal_type(xs[0])  # revealed: 3
+```
+
 ## the user's full example
 
 ```by