Address review feedback on slice folding, fallthrough, attr-chain

youknowone · youknowone · commit 238d1e780cab · 2026-04-30T19:33:32.000+09:00
- try_fold_constant_slice now delegates to try_fold_constant_expr so
  slice bounds accept the same constants other folding paths do
  (unary-folded values, __debug__, etc.).
- remove_nops resolves fallthrough predecessors through empty blocks
  via next_nonempty_block before checking ends_with_for_cleanup.
- should_deopt_borrowed_attr_chain ReturnIter matcher now accepts
  Instruction::CallKw alongside Instruction::Call, matching the
  Call/CallKw treatment in the surrounding deopt trigger check.
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -10172,33 +10172,6 @@ impl Compiler {
         self.emit_arg(idx, |consti| Instruction::LoadConst { consti })
     }
 
-    fn try_fold_slice_constant_part(
-        &mut self,
-        expr: &ast::Expr,
-    ) -> CompileResult<Option<ConstantData>> {
-        Ok(Some(match expr {
-            ast::Expr::NumberLiteral(num) => match &num.value {
-                ast::Number::Int(int) => ConstantData::Integer {
-                    value: ruff_int_to_bigint(int).map_err(|e| self.error(e))?,
-                },
-                ast::Number::Float(f) => ConstantData::Float { value: *f },
-                ast::Number::Complex { real, imag } => ConstantData::Complex {
-                    value: Complex::new(*real, *imag),
-                },
-            },
-            ast::Expr::StringLiteral(s) => ConstantData::Str {
-                value: self.compile_string_value(s),
-            },
-            ast::Expr::BytesLiteral(b) => ConstantData::Bytes {
-                value: b.value.bytes().collect(),
-            },
-            ast::Expr::BooleanLiteral(b) => ConstantData::Boolean { value: b.value },
-            ast::Expr::NoneLiteral(_) => ConstantData::None,
-            ast::Expr::EllipsisLiteral(_) => ConstantData::Ellipsis,
-            _ => return Ok(None),
-        }))
-    }
-
     fn try_fold_constant_slice(
         &mut self,
         lower: Option<&ast::Expr>,
@@ -10207,7 +10180,7 @@ impl Compiler {
     ) -> CompileResult<Option<ConstantData>> {
         let start = match lower {
             Some(expr) => {
-                let Some(constant) = self.try_fold_slice_constant_part(expr)? else {
+                let Some(constant) = self.try_fold_constant_expr(expr)? else {
                     return Ok(None);
                 };
                 constant
@@ -10216,7 +10189,7 @@ impl Compiler {
         };
         let stop = match upper {
             Some(expr) => {
-                let Some(constant) = self.try_fold_slice_constant_part(expr)? else {
+                let Some(constant) = self.try_fold_constant_expr(expr)? else {
                     return Ok(None);
                 };
                 constant
@@ -10225,7 +10198,7 @@ impl Compiler {
         };
         let step = match step {
             Some(expr) => {
-                let Some(constant) = self.try_fold_slice_constant_part(expr)? else {
+                let Some(constant) = self.try_fold_constant_expr(expr)? else {
                     return Ok(None);
                 };
                 constant
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
@@ -2562,8 +2562,9 @@ impl CodeInfo {
         let jump_targets = compute_target_predecessor_flags(&self.blocks).jump;
         let mut fallthrough_predecessors = vec![None; self.blocks.len()];
         for (pred_idx, block) in self.blocks.iter().enumerate() {
-            if block.next != BlockIdx::NULL {
-                fallthrough_predecessors[block.next.idx()] = Some(pred_idx);
+            let next = next_nonempty_block(&self.blocks, block.next);
+            if next != BlockIdx::NULL {
+                fallthrough_predecessors[next.idx()] = Some(pred_idx);
             }
         }
         let starts_after_for_cleanup: Vec<_> = fallthrough_predecessors
@@ -4407,7 +4408,7 @@ impl CodeInfo {
                 Some(Instruction::GetIter) => Some(DeoptKind::ReturnIter {
                     tail_start_idx: cursor + 1,
                 }),
-                Some(Instruction::Call { .. }) => real_instrs
+                Some(Instruction::Call { .. } | Instruction::CallKw { .. }) => real_instrs
                     .get(cursor + 1)
                     .and_then(|(_, info)| info.instr.real())
                     .and_then(|instr| {
