MIR drive-by cleanups

compiler/rustc_middle/src/mir/syntax.rs

@@ -749,6 +749,29 @@ pub enum TerminatorKind<'tcx> {
     },
 }
 
+impl TerminatorKind<'_> {
+    /// Returns a simple string representation of a `TerminatorKind` variant, independent of any
+    /// values it might hold (e.g. `TerminatorKind::Call` always returns `"Call"`).
+    pub const fn name(&self) -> &'static str {
+        match self {
+            TerminatorKind::Goto { .. } => "Goto",
+            TerminatorKind::SwitchInt { .. } => "SwitchInt",
+            TerminatorKind::Resume => "Resume",
+            TerminatorKind::Terminate => "Terminate",
+            TerminatorKind::Return => "Return",
+            TerminatorKind::Unreachable => "Unreachable",
+            TerminatorKind::Drop { .. } => "Drop",
+            TerminatorKind::Call { .. } => "Call",
+            TerminatorKind::Assert { .. } => "Assert",
+            TerminatorKind::Yield { .. } => "Yield",
+            TerminatorKind::GeneratorDrop => "GeneratorDrop",
+            TerminatorKind::FalseEdge { .. } => "FalseEdge",
+            TerminatorKind::FalseUnwind { .. } => "FalseUnwind",
+            TerminatorKind::InlineAsm { .. } => "InlineAsm",
+        }
+    }
+}
+
 /// Action to be taken when a stack unwind happens.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)]
 #[derive(TypeFoldable, TypeVisitable)]

compiler/rustc_mir_build/src/build/scope.rs

@@ -644,24 +644,27 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
         };
 
-        if let Some(destination) = destination {
-            if let Some(value) = value {
+        match (destination, value) {
+            (Some(destination), Some(value)) => {
                 debug!("stmt_expr Break val block_context.push(SubExpr)");
                 self.block_context.push(BlockFrame::SubExpr);
                 unpack!(block = self.expr_into_dest(destination, block, value));
                 self.block_context.pop();
-            } else {
+            }
+            (Some(destination), None) => {
                 self.cfg.push_assign_unit(block, source_info, destination, self.tcx)
             }
-        } else {
-            assert!(value.is_none(), "`return` and `break` should have a destination");
-            if self.tcx.sess.instrument_coverage() {
+            (None, Some(_)) => {
+                panic!("`return`, `become` and `break` with value and must have a destination")
+            }
+            (None, None) if self.tcx.sess.instrument_coverage() => {
                 // Unlike `break` and `return`, which push an `Assign` statement to MIR, from which
                 // a Coverage code region can be generated, `continue` needs no `Assign`; but
                 // without one, the `InstrumentCoverage` MIR pass cannot generate a code region for
                 // `continue`. Coverage will be missing unless we add a dummy `Assign` to MIR.
                 self.add_dummy_assignment(span, block, source_info);
             }
+            (None, None) => {}
         }
 
         let region_scope = self.scopes.breakable_scopes[break_index].region_scope;
@@ -671,12 +674,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         } else {
             self.scopes.breakable_scopes[break_index].continue_drops.as_mut().unwrap()
         };
-        let mut drop_idx = ROOT_NODE;
-        for scope in &self.scopes.scopes[scope_index + 1..] {
-            for drop in &scope.drops {
-                drop_idx = drops.add_drop(*drop, drop_idx);
-            }
-        }
+
+        let drop_idx = self.scopes.scopes[scope_index + 1..]
+            .iter()
+            .flat_map(|scope| &scope.drops)
+            .fold(ROOT_NODE, |drop_idx, &drop| drops.add_drop(drop, drop_idx));
+
         drops.add_entry(block, drop_idx);
 
         // `build_drop_trees` doesn't have access to our source_info, so we

compiler/rustc_mir_build/src/thir/cx/expr.rs

@@ -130,6 +130,7 @@ impl<'tcx> Cx<'tcx> {
                 ExprKind::Pointer { cast: PointerCast::Unsize, source: self.thir.exprs.push(expr) }
             }
             Adjust::Pointer(cast) => ExprKind::Pointer { cast, source: self.thir.exprs.push(expr) },
+            Adjust::NeverToAny if adjustment.target.is_never() => return expr,
             Adjust::NeverToAny => ExprKind::NeverToAny { source: self.thir.exprs.push(expr) },
             Adjust::Deref(None) => {
                 adjust_span(&mut expr);

compiler/rustc_mir_transform/src/coverage/debug.rs

@@ -118,7 +118,7 @@ use rustc_middle::mir::spanview::{self, SpanViewable};
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_middle::mir::coverage::*;
-use rustc_middle::mir::{self, BasicBlock, TerminatorKind};
+use rustc_middle::mir::{self, BasicBlock};
 use rustc_middle::ty::TyCtxt;
 use rustc_span::Span;
 
@@ -796,36 +796,15 @@ fn bcb_to_string_sections<'tcx>(
     }
     let non_term_blocks = bcb_data.basic_blocks[0..len - 1]
         .iter()
-        .map(|&bb| format!("{:?}: {}", bb, term_type(&mir_body[bb].terminator().kind)))
+        .map(|&bb| format!("{:?}: {}", bb, mir_body[bb].terminator().kind.name()))
         .collect::<Vec<_>>();
     if non_term_blocks.len() > 0 {
         sections.push(non_term_blocks.join("\n"));
     }
     sections.push(format!(
         "{:?}: {}",
         bcb_data.basic_blocks.last().unwrap(),
-        term_type(&bcb_data.terminator(mir_body).kind)
+        bcb_data.terminator(mir_body).kind.name(),
     ));
     sections
 }
-
-/// Returns a simple string representation of a `TerminatorKind` variant, independent of any
-/// values it might hold.
-pub(super) fn term_type(kind: &TerminatorKind<'_>) -> &'static str {
-    match kind {
-        TerminatorKind::Goto { .. } => "Goto",
-        TerminatorKind::SwitchInt { .. } => "SwitchInt",
-        TerminatorKind::Resume => "Resume",
-        TerminatorKind::Terminate => "Terminate",
-        TerminatorKind::Return => "Return",
-        TerminatorKind::Unreachable => "Unreachable",
-        TerminatorKind::Drop { .. } => "Drop",
-        TerminatorKind::Call { .. } => "Call",
-        TerminatorKind::Assert { .. } => "Assert",
-        TerminatorKind::Yield { .. } => "Yield",
-        TerminatorKind::GeneratorDrop => "GeneratorDrop",
-        TerminatorKind::FalseEdge { .. } => "FalseEdge",
-        TerminatorKind::FalseUnwind { .. } => "FalseUnwind",
-        TerminatorKind::InlineAsm { .. } => "InlineAsm",
-    }
-}

compiler/rustc_mir_transform/src/coverage/spans.rs

@@ -1,4 +1,3 @@
-use super::debug::term_type;
 use super::graph::{BasicCoverageBlock, BasicCoverageBlockData, CoverageGraph, START_BCB};
 
 use itertools::Itertools;
@@ -40,7 +39,7 @@ impl CoverageStatement {
                     "{}: @{}.{}: {:?}",
                     source_range_no_file(tcx, span),
                     bb.index(),
-                    term_type(&term.kind),
+                    term.kind.name(),
                     term.kind
                 )
             }

compiler/rustc_mir_transform/src/coverage/tests.rs

@@ -25,7 +25,6 @@
 //! to: `rustc_span::create_default_session_globals_then(|| { test_here(); })`.
 
 use super::counters;
-use super::debug;
 use super::graph;
 use super::spans;
 
@@ -188,12 +187,12 @@ fn debug_basic_blocks(mir_body: &Body<'_>) -> String {
                     | TerminatorKind::Goto { target }
                     | TerminatorKind::InlineAsm { destination: Some(target), .. }
                     | TerminatorKind::Yield { resume: target, .. } => {
-                        format!("{}{:?}:{} -> {:?}", sp, bb, debug::term_type(kind), target)
+                        format!("{}{:?}:{} -> {:?}", sp, bb, kind.name(), target)
                     }
                     TerminatorKind::SwitchInt { targets, .. } => {
-                        format!("{}{:?}:{} -> {:?}", sp, bb, debug::term_type(kind), targets)
+                        format!("{}{:?}:{} -> {:?}", sp, bb, kind.name(), targets)
                     }
-                    _ => format!("{}{:?}:{}", sp, bb, debug::term_type(kind)),
+                    _ => format!("{}{:?}:{}", sp, bb, kind.name()),
                 }
             })
             .collect::<Vec<_>>()
@@ -215,7 +214,7 @@ fn print_mir_graphviz(name: &str, mir_body: &Body<'_>) {
                         "    {:?} [label=\"{:?}: {}\"];\n{}",
                         bb,
                         bb,
-                        debug::term_type(&data.terminator().kind),
+                        data.terminator().kind.name(),
                         mir_body
                             .basic_blocks
                             .successors(bb)
@@ -244,7 +243,7 @@ fn print_coverage_graphviz(
                         "    {:?} [label=\"{:?}: {}\"];\n{}",
                         bcb,
                         bcb,
-                        debug::term_type(&bcb_data.terminator(mir_body).kind),
+                        bcb_data.terminator(mir_body).kind.name(),
                         basic_coverage_blocks
                             .successors(bcb)
                             .map(|successor| { format!("    {:?} -> {:?};", bcb, successor) })

src/tools/miri/tests/fail/never_say_never.rs

@@ -6,10 +6,8 @@
 
 fn main() {
     let y = &5;
-    let x: ! = unsafe {
-        *(y as *const _ as *const !) //~ ERROR: entering unreachable code
-    };
-    f(x)
+    let x: ! = unsafe { *(y as *const _ as *const !) };
+    f(x) //~ ERROR: entering unreachable code
 }
 
 fn f(x: !) -> ! {

src/tools/miri/tests/fail/never_say_never.stderr

@@ -1,8 +1,8 @@
 error: Undefined Behavior: entering unreachable code
   --> $DIR/never_say_never.rs:LL:CC
    |
-LL |         *(y as *const _ as *const !)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ entering unreachable code
+LL |     f(x)
+   |     ^^^^ entering unreachable code
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information

tests/mir-opt/const_prop/transmute.unreachable_box.ConstProp.32bit.diff

@@ -3,24 +3,20 @@
 
   fn unreachable_box() -> ! {
       let mut _0: !;                       // return place in scope 0 at $DIR/transmute.rs:+0:36: +0:37
-      let mut _1: !;                       // in scope 0 at $DIR/transmute.rs:+0:38: +3:2
-      let _2: std::boxed::Box<Never>;      // in scope 0 at $DIR/transmute.rs:+1:9: +1:10
-      let mut _3: !;                       // in scope 0 at $DIR/transmute.rs:+2:5: +2:16
+      let _1: std::boxed::Box<Never>;      // in scope 0 at $DIR/transmute.rs:+1:9: +1:10
       scope 1 {
-          debug x => _2;                   // in scope 1 at $DIR/transmute.rs:+1:9: +1:10
+          debug x => _1;                   // in scope 1 at $DIR/transmute.rs:+1:9: +1:10
       }
       scope 2 {
       }
 
       bb0: {
-          StorageLive(_1);                 // scope 0 at $DIR/transmute.rs:+0:38: +3:2
-          StorageLive(_2);                 // scope 0 at $DIR/transmute.rs:+1:9: +1:10
--         _2 = const 1_usize as std::boxed::Box<Never> (Transmute); // scope 2 at $DIR/transmute.rs:+1:34: +1:52
-+         _2 = const Box::<Never>(Unique::<Never> {{ pointer: NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData::<Never> }}, std::alloc::Global); // scope 2 at $DIR/transmute.rs:+1:34: +1:52
+          StorageLive(_1);                 // scope 0 at $DIR/transmute.rs:+1:9: +1:10
+-         _1 = const 1_usize as std::boxed::Box<Never> (Transmute); // scope 2 at $DIR/transmute.rs:+1:34: +1:52
++         _1 = const Box::<Never>(Unique::<Never> {{ pointer: NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData::<Never> }}, std::alloc::Global); // scope 2 at $DIR/transmute.rs:+1:34: +1:52
 +                                          // mir::Constant
 +                                          // + span: no-location
 +                                          // + literal: Const { ty: Box<Never>, val: Value(Scalar(0x00000001)) }
-          StorageLive(_3);                 // scope 1 at $DIR/transmute.rs:+2:5: +2:16
           unreachable;                     // scope 1 at $DIR/transmute.rs:+2:11: +2:13
       }
   }

tests/mir-opt/const_prop/transmute.unreachable_box.ConstProp.64bit.diff

@@ -3,24 +3,20 @@
 
   fn unreachable_box() -> ! {
       let mut _0: !;                       // return place in scope 0 at $DIR/transmute.rs:+0:36: +0:37
-      let mut _1: !;                       // in scope 0 at $DIR/transmute.rs:+0:38: +3:2
-      let _2: std::boxed::Box<Never>;      // in scope 0 at $DIR/transmute.rs:+1:9: +1:10
-      let mut _3: !;                       // in scope 0 at $DIR/transmute.rs:+2:5: +2:16
+      let _1: std::boxed::Box<Never>;      // in scope 0 at $DIR/transmute.rs:+1:9: +1:10
       scope 1 {
-          debug x => _2;                   // in scope 1 at $DIR/transmute.rs:+1:9: +1:10
+          debug x => _1;                   // in scope 1 at $DIR/transmute.rs:+1:9: +1:10
       }
       scope 2 {
       }
 
       bb0: {
-          StorageLive(_1);                 // scope 0 at $DIR/transmute.rs:+0:38: +3:2
-          StorageLive(_2);                 // scope 0 at $DIR/transmute.rs:+1:9: +1:10
--         _2 = const 1_usize as std::boxed::Box<Never> (Transmute); // scope 2 at $DIR/transmute.rs:+1:34: +1:52
-+         _2 = const Box::<Never>(Unique::<Never> {{ pointer: NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData::<Never> }}, std::alloc::Global); // scope 2 at $DIR/transmute.rs:+1:34: +1:52
+          StorageLive(_1);                 // scope 0 at $DIR/transmute.rs:+1:9: +1:10
+-         _1 = const 1_usize as std::boxed::Box<Never> (Transmute); // scope 2 at $DIR/transmute.rs:+1:34: +1:52
++         _1 = const Box::<Never>(Unique::<Never> {{ pointer: NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData::<Never> }}, std::alloc::Global); // scope 2 at $DIR/transmute.rs:+1:34: +1:52
 +                                          // mir::Constant
 +                                          // + span: no-location
 +                                          // + literal: Const { ty: Box<Never>, val: Value(Scalar(0x0000000000000001)) }
-          StorageLive(_3);                 // scope 1 at $DIR/transmute.rs:+2:5: +2:16
           unreachable;                     // scope 1 at $DIR/transmute.rs:+2:11: +2:13
       }
   }

tests/mir-opt/const_prop/transmute.unreachable_direct.ConstProp.32bit.diff

@@ -3,22 +3,19 @@
 
   fn unreachable_direct() -> ! {
       let mut _0: !;                       // return place in scope 0 at $DIR/transmute.rs:+0:39: +0:40
-      let mut _1: !;                       // in scope 0 at $DIR/transmute.rs:+0:41: +3:2
-      let _2: Never;                       // in scope 0 at $DIR/transmute.rs:+1:9: +1:10
-      let mut _3: ();                      // in scope 0 at $DIR/transmute.rs:+1:39: +1:41
-      let mut _4: !;                       // in scope 0 at $DIR/transmute.rs:+2:5: +2:15
+      let _1: Never;                       // in scope 0 at $DIR/transmute.rs:+1:9: +1:10
+      let mut _2: ();                      // in scope 0 at $DIR/transmute.rs:+1:39: +1:41
       scope 1 {
-          debug x => _2;                   // in scope 1 at $DIR/transmute.rs:+1:9: +1:10
+          debug x => _1;                   // in scope 1 at $DIR/transmute.rs:+1:9: +1:10
       }
       scope 2 {
       }
 
       bb0: {
-          StorageLive(_1);                 // scope 0 at $DIR/transmute.rs:+0:41: +3:2
-          StorageLive(_2);                 // scope 0 at $DIR/transmute.rs:+1:9: +1:10
-          StorageLive(_3);                 // scope 2 at $DIR/transmute.rs:+1:39: +1:41
-          _3 = ();                         // scope 2 at $DIR/transmute.rs:+1:39: +1:41
-          _2 = move _3 as Never (Transmute); // scope 2 at $DIR/transmute.rs:+1:29: +1:42
+          StorageLive(_1);                 // scope 0 at $DIR/transmute.rs:+1:9: +1:10
+          StorageLive(_2);                 // scope 2 at $DIR/transmute.rs:+1:39: +1:41
+          _2 = ();                         // scope 2 at $DIR/transmute.rs:+1:39: +1:41
+          _1 = move _2 as Never (Transmute); // scope 2 at $DIR/transmute.rs:+1:29: +1:42
           unreachable;                     // scope 2 at $DIR/transmute.rs:+1:29: +1:42
       }
   }

tests/mir-opt/const_prop/transmute.unreachable_direct.ConstProp.64bit.diff

@@ -3,22 +3,19 @@
 
   fn unreachable_direct() -> ! {
       let mut _0: !;                       // return place in scope 0 at $DIR/transmute.rs:+0:39: +0:40
-      let mut _1: !;                       // in scope 0 at $DIR/transmute.rs:+0:41: +3:2
-      let _2: Never;                       // in scope 0 at $DIR/transmute.rs:+1:9: +1:10
-      let mut _3: ();                      // in scope 0 at $DIR/transmute.rs:+1:39: +1:41
-      let mut _4: !;                       // in scope 0 at $DIR/transmute.rs:+2:5: +2:15
+      let _1: Never;                       // in scope 0 at $DIR/transmute.rs:+1:9: +1:10
+      let mut _2: ();                      // in scope 0 at $DIR/transmute.rs:+1:39: +1:41
       scope 1 {
-          debug x => _2;                   // in scope 1 at $DIR/transmute.rs:+1:9: +1:10
+          debug x => _1;                   // in scope 1 at $DIR/transmute.rs:+1:9: +1:10
       }
       scope 2 {
       }
 
       bb0: {
-          StorageLive(_1);                 // scope 0 at $DIR/transmute.rs:+0:41: +3:2
-          StorageLive(_2);                 // scope 0 at $DIR/transmute.rs:+1:9: +1:10
-          StorageLive(_3);                 // scope 2 at $DIR/transmute.rs:+1:39: +1:41
-          _3 = ();                         // scope 2 at $DIR/transmute.rs:+1:39: +1:41
-          _2 = move _3 as Never (Transmute); // scope 2 at $DIR/transmute.rs:+1:29: +1:42
+          StorageLive(_1);                 // scope 0 at $DIR/transmute.rs:+1:9: +1:10
+          StorageLive(_2);                 // scope 2 at $DIR/transmute.rs:+1:39: +1:41
+          _2 = ();                         // scope 2 at $DIR/transmute.rs:+1:39: +1:41
+          _1 = move _2 as Never (Transmute); // scope 2 at $DIR/transmute.rs:+1:29: +1:42
           unreachable;                     // scope 2 at $DIR/transmute.rs:+1:29: +1:42
       }
   }

tests/mir-opt/const_prop/transmute.unreachable_mut.ConstProp.32bit.diff

@@ -3,28 +3,24 @@
 
   fn unreachable_mut() -> ! {
       let mut _0: !;                       // return place in scope 0 at $DIR/transmute.rs:+0:36: +0:37
-      let mut _1: !;                       // in scope 0 at $DIR/transmute.rs:+0:38: +3:2
-      let _2: &mut Never;                  // in scope 0 at $DIR/transmute.rs:+1:9: +1:10
-      let mut _3: &mut Never;              // in scope 0 at $DIR/transmute.rs:+1:34: +1:52
-      let mut _4: !;                       // in scope 0 at $DIR/transmute.rs:+2:5: +2:16
+      let _1: &mut Never;                  // in scope 0 at $DIR/transmute.rs:+1:9: +1:10
+      let mut _2: &mut Never;              // in scope 0 at $DIR/transmute.rs:+1:34: +1:52
       scope 1 {
-          debug x => _2;                   // in scope 1 at $DIR/transmute.rs:+1:9: +1:10
+          debug x => _1;                   // in scope 1 at $DIR/transmute.rs:+1:9: +1:10
       }
       scope 2 {
       }
 
       bb0: {
-          StorageLive(_1);                 // scope 0 at $DIR/transmute.rs:+0:38: +3:2
-          StorageLive(_2);                 // scope 0 at $DIR/transmute.rs:+1:9: +1:10
-          StorageLive(_3);                 // scope 0 at $DIR/transmute.rs:+1:34: +1:52
--         _3 = const 1_usize as &mut Never (Transmute); // scope 2 at $DIR/transmute.rs:+1:34: +1:52
-+         _3 = const {0x1 as &mut Never};  // scope 2 at $DIR/transmute.rs:+1:34: +1:52
+          StorageLive(_1);                 // scope 0 at $DIR/transmute.rs:+1:9: +1:10
+          StorageLive(_2);                 // scope 0 at $DIR/transmute.rs:+1:34: +1:52
+-         _2 = const 1_usize as &mut Never (Transmute); // scope 2 at $DIR/transmute.rs:+1:34: +1:52
++         _2 = const {0x1 as &mut Never};  // scope 2 at $DIR/transmute.rs:+1:34: +1:52
 +                                          // mir::Constant
 +                                          // + span: no-location
 +                                          // + literal: Const { ty: &mut Never, val: Value(Scalar(0x00000001)) }
-          _2 = &mut (*_3);                 // scope 0 at $DIR/transmute.rs:+1:34: +1:52
-          StorageDead(_3);                 // scope 0 at $DIR/transmute.rs:+1:54: +1:55
-          StorageLive(_4);                 // scope 1 at $DIR/transmute.rs:+2:5: +2:16
+          _1 = &mut (*_2);                 // scope 0 at $DIR/transmute.rs:+1:34: +1:52
+          StorageDead(_2);                 // scope 0 at $DIR/transmute.rs:+1:54: +1:55
           unreachable;                     // scope 1 at $DIR/transmute.rs:+2:11: +2:13
       }
   }