Auto merge of #146534 - yotamofek:pr/successors-iter, r=<try>

[PERF] Change layout of `SwitchTargets`

Author: rust-bors[bot]

compiler/rustc_borrowck/src/polonius/legacy/loan_kills.rs

@@ -67,14 +67,12 @@ impl<'a, 'tcx> Visitor<'tcx> for LoanKillsGenerator<'a, 'tcx> {
             self.location_table.mid_index(location),
         ));
 
-        let successor_blocks = terminator.successors();
-        self.facts.cfg_edge.reserve(successor_blocks.size_hint().0);
-        for successor_block in successor_blocks {
-            self.facts.cfg_edge.push((
+        self.facts.cfg_edge.extend(terminator.successors().map(|successor_block| {
+            (
                 self.location_table.mid_index(location),
                 self.location_table.start_index(successor_block.start_location()),
-            ));
-        }
+            )
+        }));
 
         // A `Call` terminator's return value can be a local which has borrows,
         // so we need to record those as `killed` as well.

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -2016,7 +2016,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             }
             TerminatorKind::SwitchInt { ref targets, .. } => {
                 for target in targets.all_targets() {
-                    self.assert_iscleanup(block_data, *target, is_cleanup);
+                    self.assert_iscleanup(block_data, target, is_cleanup);
                 }
             }
             TerminatorKind::UnwindResume => {

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1,5 +1,6 @@
 use std::cmp;
 
+use itertools::Itertools as _;
 use rustc_abi::{Align, BackendRepr, ExternAbi, HasDataLayout, Reg, Size, WrappingRange};
 use rustc_ast as ast;
 use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece};

compiler/rustc_middle/src/lib.rs

@@ -48,13 +48,15 @@
 #![feature(gen_blocks)]
 #![feature(if_let_guard)]
 #![feature(intra_doc_pointers)]
+#![feature(iter_advance_by)]
 #![feature(min_specialization)]
 #![feature(negative_impls)]
 #![feature(never_type)]
 #![feature(ptr_alignment_type)]
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
 #![feature(sized_hierarchy)]
+#![feature(trusted_len)]
 #![feature(try_blocks)]
 #![feature(try_trait_v2)]
 #![feature(try_trait_v2_residual)]

compiler/rustc_middle/src/mir/pretty.rs

@@ -1004,9 +1004,8 @@ impl<'tcx> TerminatorKind<'tcx> {
             | CoroutineDrop => vec![],
             Goto { .. } => vec!["".into()],
             SwitchInt { ref targets, .. } => targets
-                .values
-                .iter()
-                .map(|&u| Cow::Owned(u.to_string()))
+                .all_values()
+                .map(|u| Cow::Owned(u.to_string()))
                 .chain(iter::once("otherwise".into()))
                 .collect(),
             Call { target: Some(_), unwind: UnwindAction::Cleanup(_), .. } => {

compiler/rustc_middle/src/mir/syntax.rs

@@ -1004,31 +1004,8 @@ pub enum BackwardIncompatibleDropReason {
 
 #[derive(Debug, Clone, TyEncodable, TyDecodable, Hash, HashStable, PartialEq)]
 pub struct SwitchTargets {
-    /// Possible values. For each value, the location to branch to is found in
-    /// the corresponding element in the `targets` vector.
-    pub(super) values: SmallVec<[Pu128; 1]>,
-
-    /// Possible branch targets. The last element of this vector is used for
-    /// the "otherwise" branch, so `targets.len() == values.len() + 1` always
-    /// holds.
-    //
-    // Note: This invariant is non-obvious and easy to violate. This would be a
-    // more rigorous representation:
-    //
-    //   normal: SmallVec<[(Pu128, BasicBlock); 1]>,
-    //   otherwise: BasicBlock,
-    //
-    // But it's important to have the targets in a sliceable type, because
-    // target slices show up elsewhere. E.g. `TerminatorKind::InlineAsm` has a
-    // boxed slice, and `TerminatorKind::FalseEdge` has a single target that
-    // can be converted to a slice with `slice::from_ref`.
-    //
-    // Why does this matter? In functions like `TerminatorKind::successors` we
-    // return `impl Iterator` and a non-slice-of-targets representation here
-    // causes problems because multiple different concrete iterator types would
-    // be involved and we would need a boxed trait object, which requires an
-    // allocation, which is expensive if done frequently.
-    pub(super) targets: SmallVec<[BasicBlock; 2]>,
+    pub(super) normal: SmallVec<[(Pu128, BasicBlock); 1]>,
+    pub(super) otherwise: BasicBlock,
 }
 
 /// Action to be taken when a stack unwind happens.