Merging upstream version 1.73.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

32 files changed, 342 insertions, 300 deletions

diff --git a/tests/mir-opt/inline/cycle.g.Inline.panic-abort.diff b/tests/mir-opt/inline/cycle.g.Inline.panic-abort.diff
index f3f4d895a..8f2baf4a3 100644
--- a/tests/mir-opt/inline/cycle.g.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/cycle.g.Inline.panic-abort.diff
@@ -5,13 +5,10 @@
       let mut _0: ();
       let _1: ();
 +     let mut _2: fn() {main};
-+     let mut _5: ();
 +     scope 1 (inlined f::<fn() {main}>) {
 +         debug g => _2;
 +         let mut _3: &fn() {main};
 +         let _4: ();
-+         scope 2 (inlined <fn() {main} as Fn<()>>::call - shim(fn() {main})) {
-+         }
 +     }
   
       bb0: {
@@ -22,9 +19,7 @@
 +         StorageLive(_4);
 +         StorageLive(_3);
 +         _3 = &_2;
-+         StorageLive(_5);
-+         _5 = const ();
-+         _4 = move (*_3)() -> [return: bb2, unwind unreachable];
++         _4 = <fn() {main} as Fn<()>>::call(move _3, const ()) -> [return: bb2, unwind unreachable];
       }
   
       bb1: {
@@ -36,7 +31,6 @@
 +     }
 + 
 +     bb2: {
-+         StorageDead(_5);
 +         StorageDead(_3);
 +         drop(_2) -> [return: bb1, unwind unreachable];
       }
diff --git a/tests/mir-opt/inline/cycle.g.Inline.panic-unwind.diff b/tests/mir-opt/inline/cycle.g.Inline.panic-unwind.diff
index 3ce8d9acf..ad801fd28 100644
--- a/tests/mir-opt/inline/cycle.g.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/cycle.g.Inline.panic-unwind.diff
@@ -5,13 +5,10 @@
       let mut _0: ();
       let _1: ();
 +     let mut _2: fn() {main};
-+     let mut _5: ();
 +     scope 1 (inlined f::<fn() {main}>) {
 +         debug g => _2;
 +         let mut _3: &fn() {main};
 +         let _4: ();
-+         scope 2 (inlined <fn() {main} as Fn<()>>::call - shim(fn() {main})) {
-+         }
 +     }
   
       bb0: {
@@ -22,9 +19,7 @@
 +         StorageLive(_4);
 +         StorageLive(_3);
 +         _3 = &_2;
-+         StorageLive(_5);
-+         _5 = const ();
-+         _4 = move (*_3)() -> [return: bb4, unwind: bb2];
++         _4 = <fn() {main} as Fn<()>>::call(move _3, const ()) -> [return: bb2, unwind: bb3];
       }
   
       bb1: {
@@ -35,18 +30,17 @@
           return;
 +     }
 + 
-+     bb2 (cleanup): {
-+         drop(_2) -> [return: bb3, unwind terminate];
++     bb2: {
++         StorageDead(_3);
++         drop(_2) -> [return: bb1, unwind continue];
 +     }
 + 
 +     bb3 (cleanup): {
-+         resume;
++         drop(_2) -> [return: bb4, unwind terminate];
 +     }
 + 
-+     bb4: {
-+         StorageDead(_5);
-+         StorageDead(_3);
-+         drop(_2) -> [return: bb1, unwind continue];
++     bb4 (cleanup): {
++         resume;
       }
   }
   
diff --git a/tests/mir-opt/inline/cycle.main.Inline.panic-abort.diff b/tests/mir-opt/inline/cycle.main.Inline.panic-abort.diff
index eb0076354..fd1f698c6 100644
--- a/tests/mir-opt/inline/cycle.main.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/cycle.main.Inline.panic-abort.diff
@@ -5,21 +5,10 @@
       let mut _0: ();
       let _1: ();
 +     let mut _2: fn() {g};
-+     let mut _5: ();
 +     scope 1 (inlined f::<fn() {g}>) {
 +         debug g => _2;
 +         let mut _3: &fn() {g};
 +         let _4: ();
-+         scope 2 (inlined <fn() {g} as Fn<()>>::call - shim(fn() {g})) {
-+             scope 3 (inlined g) {
-+                 scope 4 (inlined f::<fn() {main}>) {
-+                     debug g => main;
-+                     let _6: ();
-+                     scope 5 (inlined <fn() {main} as Fn<()>>::call - shim(fn() {main})) {
-+                     }
-+                 }
-+             }
-+         }
 +     }
   
       bb0: {
@@ -30,10 +19,7 @@
 +         StorageLive(_4);
 +         StorageLive(_3);
 +         _3 = &_2;
-+         StorageLive(_5);
-+         _5 = const ();
-+         StorageLive(_6);
-+         _6 = main() -> [return: bb2, unwind unreachable];
++         _4 = <fn() {g} as Fn<()>>::call(move _3, const ()) -> [return: bb2, unwind unreachable];
       }
   
       bb1: {
@@ -45,8 +31,6 @@
 +     }
 + 
 +     bb2: {
-+         StorageDead(_6);
-+         StorageDead(_5);
 +         StorageDead(_3);
 +         drop(_2) -> [return: bb1, unwind unreachable];
       }
diff --git a/tests/mir-opt/inline/cycle.main.Inline.panic-unwind.diff b/tests/mir-opt/inline/cycle.main.Inline.panic-unwind.diff
index 198a23226..99dc64115 100644
--- a/tests/mir-opt/inline/cycle.main.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/cycle.main.Inline.panic-unwind.diff
@@ -5,21 +5,10 @@
       let mut _0: ();
       let _1: ();
 +     let mut _2: fn() {g};
-+     let mut _5: ();
 +     scope 1 (inlined f::<fn() {g}>) {
 +         debug g => _2;
 +         let mut _3: &fn() {g};
 +         let _4: ();
-+         scope 2 (inlined <fn() {g} as Fn<()>>::call - shim(fn() {g})) {
-+             scope 3 (inlined g) {
-+                 scope 4 (inlined f::<fn() {main}>) {
-+                     debug g => main;
-+                     let _6: ();
-+                     scope 5 (inlined <fn() {main} as Fn<()>>::call - shim(fn() {main})) {
-+                     }
-+                 }
-+             }
-+         }
 +     }
   
       bb0: {
@@ -30,10 +19,7 @@
 +         StorageLive(_4);
 +         StorageLive(_3);
 +         _3 = &_2;
-+         StorageLive(_5);
-+         _5 = const ();
-+         StorageLive(_6);
-+         _6 = main() -> [return: bb4, unwind: bb2];
++         _4 = <fn() {g} as Fn<()>>::call(move _3, const ()) -> [return: bb2, unwind: bb3];
       }
   
       bb1: {
@@ -44,19 +30,17 @@
           return;
 +     }
 + 
-+     bb2 (cleanup): {
-+         drop(_2) -> [return: bb3, unwind terminate];
++     bb2: {
++         StorageDead(_3);
++         drop(_2) -> [return: bb1, unwind continue];
 +     }
 + 
 +     bb3 (cleanup): {
-+         resume;
++         drop(_2) -> [return: bb4, unwind terminate];
 +     }
 + 
-+     bb4: {
-+         StorageDead(_6);
-+         StorageDead(_5);
-+         StorageDead(_3);
-+         drop(_2) -> [return: bb1, unwind continue];
++     bb4 (cleanup): {
++         resume;
       }
   }
   
diff --git a/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-abort.diff b/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-abort.diff
new file mode 100644
index 000000000..757617e59
--- /dev/null
+++ b/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-abort.diff
@@ -0,0 +1,29 @@
+- // MIR for `call` before Inline
++ // MIR for `call` after Inline
+  
+  fn call(_1: Box<dyn FnMut<I, Output = ()>>, _2: I) -> () {
+      debug mock => _1;
+      debug input => _2;
+      let mut _0: ();
+      let mut _3: &mut std::boxed::Box<dyn std::ops::FnMut<I, Output = ()>>;
+      let mut _4: I;
+  
+      bb0: {
+          StorageLive(_3);
+          _3 = &mut _1;
+          StorageLive(_4);
+          _4 = move _2;
+          _0 = <Box<dyn FnMut<I, Output = ()>> as FnMut<I>>::call_mut(move _3, move _4) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_4);
+          StorageDead(_3);
+          drop(_1) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-unwind.diff b/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-unwind.diff
new file mode 100644
index 000000000..ef85e075e
--- /dev/null
+++ b/tests/mir-opt/inline/dont_ice_on_generic_rust_call.call.Inline.panic-unwind.diff
@@ -0,0 +1,37 @@
+- // MIR for `call` before Inline
++ // MIR for `call` after Inline
+  
+  fn call(_1: Box<dyn FnMut<I, Output = ()>>, _2: I) -> () {
+      debug mock => _1;
+      debug input => _2;
+      let mut _0: ();
+      let mut _3: &mut std::boxed::Box<dyn std::ops::FnMut<I, Output = ()>>;
+      let mut _4: I;
+  
+      bb0: {
+          StorageLive(_3);
+          _3 = &mut _1;
+          StorageLive(_4);
+          _4 = move _2;
+          _0 = <Box<dyn FnMut<I, Output = ()>> as FnMut<I>>::call_mut(move _3, move _4) -> [return: bb1, unwind: bb3];
+      }
+  
+      bb1: {
+          StorageDead(_4);
+          StorageDead(_3);
+          drop(_1) -> [return: bb2, unwind: bb4];
+      }
+  
+      bb2: {
+          return;
+      }
+  
+      bb3 (cleanup): {
+          drop(_1) -> [return: bb4, unwind terminate];
+      }
+  
+      bb4 (cleanup): {
+          resume;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/dont_ice_on_generic_rust_call.rs b/tests/mir-opt/inline/dont_ice_on_generic_rust_call.rs
new file mode 100644
index 000000000..971223c72
--- /dev/null
+++ b/tests/mir-opt/inline/dont_ice_on_generic_rust_call.rs
@@ -0,0 +1,11 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+// compile-flags: -Zmir-enable-passes=+Inline --crate-type=lib
+
+#![feature(fn_traits, tuple_trait, unboxed_closures)]
+
+use std::marker::Tuple;
+
+// EMIT_MIR dont_ice_on_generic_rust_call.call.Inline.diff
+pub fn call<I: Tuple>(mut mock: Box<dyn FnMut<I, Output = ()>>, input: I) {
+    mock.call_mut(input)
+}
diff --git a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff
index 57b0849e1..9d5042caa 100644
--- a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff
@@ -32,7 +32,7 @@
 -         _0 = try_execute_query::<<Q as Query>::C>(move _4) -> [return: bb2, unwind unreachable];
 +         StorageLive(_5);
 +         _5 = _4 as &dyn Cache<V = <Q as Query>::V> (PointerCoercion(Unsize));
-+         _0 = <dyn Cache<V = <Q as Query>::V> as Cache>::store_nocache(_5) -> [return: bb2, unwind unreachable];
++         _0 = <dyn Cache<V = <Q as Query>::V> as Cache>::store_nocache(move _5) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
diff --git a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff
index 706c1d481..9bd3855c5 100644
--- a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff
@@ -32,7 +32,7 @@
 -         _0 = try_execute_query::<<Q as Query>::C>(move _4) -> [return: bb2, unwind continue];
 +         StorageLive(_5);
 +         _5 = _4 as &dyn Cache<V = <Q as Query>::V> (PointerCoercion(Unsize));
-+         _0 = <dyn Cache<V = <Q as Query>::V> as Cache>::store_nocache(_5) -> [return: bb2, unwind continue];
++         _0 = <dyn Cache<V = <Q as Query>::V> as Cache>::store_nocache(move _5) -> [return: bb2, unwind continue];
       }
   
       bb2: {
diff --git a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff
index 9a6d3596f..96e16d023 100644
--- a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff
@@ -17,7 +17,7 @@
           _2 = move _3 as &dyn Cache<V = <C as Cache>::V> (PointerCoercion(Unsize));
           StorageDead(_3);
 -         _0 = mk_cycle::<<C as Cache>::V>(move _2) -> [return: bb1, unwind unreachable];
-+         _0 = <dyn Cache<V = <C as Cache>::V> as Cache>::store_nocache(_2) -> [return: bb1, unwind unreachable];
++         _0 = <dyn Cache<V = <C as Cache>::V> as Cache>::store_nocache(move _2) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff
index 1a08df2b0..06d65abcb 100644
--- a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff
@@ -17,7 +17,7 @@
           _2 = move _3 as &dyn Cache<V = <C as Cache>::V> (PointerCoercion(Unsize));
           StorageDead(_3);
 -         _0 = mk_cycle::<<C as Cache>::V>(move _2) -> [return: bb1, unwind continue];
-+         _0 = <dyn Cache<V = <C as Cache>::V> as Cache>::store_nocache(_2) -> [return: bb1, unwind continue];
++         _0 = <dyn Cache<V = <C as Cache>::V> as Cache>::store_nocache(move _2) -> [return: bb1, unwind continue];
       }
   
       bb1: {
diff --git a/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-abort.diff
new file mode 100644
index 000000000..4fa04b05e
--- /dev/null
+++ b/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-abort.diff
@@ -0,0 +1,32 @@
+- // MIR for `call` before Inline
++ // MIR for `call` after Inline
+  
+  fn call(_1: Box<dyn Fn(i32)>) -> () {
+      debug x => _1;
+      let mut _0: ();
+      let _2: ();
+      let mut _3: &std::boxed::Box<dyn std::ops::Fn(i32)>;
+      let mut _4: (i32,);
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+          _3 = &_1;
+          StorageLive(_4);
+          _4 = (const 1_i32,);
+          _2 = <Box<dyn Fn(i32)> as Fn<(i32,)>>::call(move _3, move _4) -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          _0 = const ();
+          drop(_1) -> [return: bb2, unwind unreachable];
+      }
+  
+      bb2: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-unwind.diff
new file mode 100644
index 000000000..5df730a99
--- /dev/null
+++ b/tests/mir-opt/inline/inline_box_fn.call.Inline.panic-unwind.diff
@@ -0,0 +1,40 @@
+- // MIR for `call` before Inline
++ // MIR for `call` after Inline
+  
+  fn call(_1: Box<dyn Fn(i32)>) -> () {
+      debug x => _1;
+      let mut _0: ();
+      let _2: ();
+      let mut _3: &std::boxed::Box<dyn std::ops::Fn(i32)>;
+      let mut _4: (i32,);
+  
+      bb0: {
+          StorageLive(_2);
+          StorageLive(_3);
+          _3 = &_1;
+          StorageLive(_4);
+          _4 = (const 1_i32,);
+          _2 = <Box<dyn Fn(i32)> as Fn<(i32,)>>::call(move _3, move _4) -> [return: bb1, unwind: bb3];
+      }
+  
+      bb1: {
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          _0 = const ();
+          drop(_1) -> [return: bb2, unwind: bb4];
+      }
+  
+      bb2: {
+          return;
+      }
+  
+      bb3 (cleanup): {
+          drop(_1) -> [return: bb4, unwind terminate];
+      }
+  
+      bb4 (cleanup): {
+          resume;
+      }
+  }
+  
diff --git a/tests/mir-opt/inline/inline_box_fn.rs b/tests/mir-opt/inline/inline_box_fn.rs
new file mode 100644
index 000000000..348f0e77f
--- /dev/null
+++ b/tests/mir-opt/inline/inline_box_fn.rs
@@ -0,0 +1,8 @@
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+// unit-test: Inline
+// compile-flags: --crate-type=lib
+
+// EMIT_MIR inline_box_fn.call.Inline.diff
+fn call(x: Box<dyn Fn(i32)>) {
+    x(1);
+}
diff --git a/tests/mir-opt/inline/inline_cycle.two.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_cycle.two.Inline.panic-abort.diff
index d83c8d585..8a6eec335 100644
--- a/tests/mir-opt/inline/inline_cycle.two.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_cycle.two.Inline.panic-abort.diff
@@ -5,20 +5,9 @@
       let mut _0: ();
       let _1: ();
 +     let mut _2: fn() {f};
-+     let mut _4: ();
 +     scope 1 (inlined call::<fn() {f}>) {
 +         debug f => _2;
 +         let _3: ();
-+         scope 2 (inlined <fn() {f} as FnOnce<()>>::call_once - shim(fn() {f})) {
-+             scope 3 (inlined f) {
-+                 scope 4 (inlined call::<fn() {f}>) {
-+                     debug f => f;
-+                     let _5: ();
-+                     scope 5 (inlined <fn() {f} as FnOnce<()>>::call_once - shim(fn() {f})) {
-+                     }
-+                 }
-+             }
-+         }
 +     }
   
       bb0: {
@@ -27,15 +16,10 @@
 +         StorageLive(_2);
 +         _2 = f;
 +         StorageLive(_3);
-+         StorageLive(_4);
-+         _4 = const ();
-+         StorageLive(_5);
-+         _5 = f() -> [return: bb1, unwind unreachable];
++         _3 = <fn() {f} as FnOnce<()>>::call_once(move _2, const ()) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
-+         StorageDead(_5);
-+         StorageDead(_4);
 +         StorageDead(_3);
 +         StorageDead(_2);
           StorageDead(_1);
diff --git a/tests/mir-opt/inline/inline_cycle.two.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_cycle.two.Inline.panic-unwind.diff
index a08662959..a24649c1e 100644
--- a/tests/mir-opt/inline/inline_cycle.two.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_cycle.two.Inline.panic-unwind.diff
@@ -5,20 +5,9 @@
       let mut _0: ();
       let _1: ();
 +     let mut _2: fn() {f};
-+     let mut _4: ();
 +     scope 1 (inlined call::<fn() {f}>) {
 +         debug f => _2;
 +         let _3: ();
-+         scope 2 (inlined <fn() {f} as FnOnce<()>>::call_once - shim(fn() {f})) {
-+             scope 3 (inlined f) {
-+                 scope 4 (inlined call::<fn() {f}>) {
-+                     debug f => f;
-+                     let _5: ();
-+                     scope 5 (inlined <fn() {f} as FnOnce<()>>::call_once - shim(fn() {f})) {
-+                     }
-+                 }
-+             }
-+         }
 +     }
   
       bb0: {
@@ -27,15 +16,10 @@
 +         StorageLive(_2);
 +         _2 = f;
 +         StorageLive(_3);
-+         StorageLive(_4);
-+         _4 = const ();
-+         StorageLive(_5);
-+         _5 = f() -> [return: bb1, unwind continue];
++         _3 = <fn() {f} as FnOnce<()>>::call_once(move _2, const ()) -> [return: bb1, unwind continue];
       }
   
       bb1: {
-+         StorageDead(_5);
-+         StorageDead(_4);
 +         StorageDead(_3);
 +         StorageDead(_2);
           StorageDead(_1);
diff --git a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff
index 0dcd5fae8..7d5553b2f 100644
--- a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff
@@ -5,7 +5,6 @@
       let mut _0: ();
       let _1: (!, !);
 +     let mut _2: fn() -> ! {sleep};
-+     let mut _7: ();
 +     scope 1 (inlined call_twice::<!, fn() -> ! {sleep}>) {
 +         debug f => _2;
 +         let mut _3: &fn() -> ! {sleep};
@@ -18,10 +17,6 @@
 +                 debug b => _6;
 +             }
 +         }
-+         scope 4 (inlined <fn() -> ! {sleep} as Fn<()>>::call - shim(fn() -> ! {sleep})) {
-+             scope 5 (inlined sleep) {
-+             }
-+         }
 +     }
   
       bb0: {
@@ -33,13 +28,24 @@
 +         StorageLive(_6);
 +         StorageLive(_3);
 +         _3 = &_2;
-+         StorageLive(_7);
-+         _7 = const ();
-+         goto -> bb1;
++         _4 = <fn() -> ! {sleep} as Fn<()>>::call(move _3, const ()) -> [return: bb1, unwind unreachable];
 +     }
 + 
 +     bb1: {
-+         goto -> bb1;
++         StorageDead(_3);
++         StorageLive(_5);
++         _5 = &_2;
++         _6 = <fn() -> ! {sleep} as Fn<()>>::call(move _5, const ()) -> [return: bb2, unwind unreachable];
++     }
++ 
++     bb2: {
++         StorageDead(_5);
++         _1 = (move _4, move _6);
++         drop(_2) -> [return: bb3, unwind unreachable];
++     }
++ 
++     bb3: {
++         unreachable;
       }
   }
   
diff --git a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff
index dfc12db12..073ddeff7 100644
--- a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff
@@ -5,7 +5,6 @@
       let mut _0: ();
       let _1: (!, !);
 +     let mut _2: fn() -> ! {sleep};
-+     let mut _8: ();
 +     scope 1 (inlined call_twice::<!, fn() -> ! {sleep}>) {
 +         debug f => _2;
 +         let mut _3: &fn() -> ! {sleep};
@@ -19,10 +18,6 @@
 +                 debug b => _6;
 +             }
 +         }
-+         scope 4 (inlined <fn() -> ! {sleep} as Fn<()>>::call - shim(fn() -> ! {sleep})) {
-+             scope 5 (inlined sleep) {
-+             }
-+         }
 +     }
   
       bb0: {
@@ -34,13 +29,40 @@
 +         StorageLive(_4);
 +         StorageLive(_3);
 +         _3 = &_2;
-+         StorageLive(_8);
-+         _8 = const ();
-+         goto -> bb1;
++         _4 = <fn() -> ! {sleep} as Fn<()>>::call(move _3, const ()) -> [return: bb1, unwind: bb5];
 +     }
 + 
 +     bb1: {
-+         goto -> bb1;
++         StorageDead(_3);
++         StorageLive(_5);
++         _5 = &_2;
++         _6 = <fn() -> ! {sleep} as Fn<()>>::call(move _5, const ()) -> [return: bb2, unwind: bb4];
++     }
++ 
++     bb2: {
++         StorageDead(_5);
++         StorageLive(_7);
++         _7 = move _4;
++         _1 = (move _7, move _6);
++         StorageDead(_7);
++         StorageDead(_4);
++         drop(_2) -> [return: bb3, unwind continue];
++     }
++ 
++     bb3: {
++         unreachable;
++     }
++ 
++     bb4 (cleanup): {
++         drop(_4) -> [return: bb5, unwind terminate];
++     }
++ 
++     bb5 (cleanup): {
++         drop(_2) -> [return: bb6, unwind terminate];
++     }
++ 
++     bb6 (cleanup): {
++         resume;
       }
   }
   
diff --git a/tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-abort.diff
index 3848196ec..dc0ab255a 100644
--- a/tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-abort.diff
@@ -33,37 +33,36 @@
 +                         debug ptr => _11;
 +                         scope 18 (inlined NonNull::<[u8]>::as_mut_ptr) {
 +                             debug self => _11;
-+                             let mut _16: std::ptr::NonNull<u8>;
++                             let mut _15: std::ptr::NonNull<u8>;
 +                             scope 19 (inlined NonNull::<[u8]>::as_non_null_ptr) {
 +                                 debug self => _11;
-+                                 let mut _17: *mut u8;
-+                                 let mut _18: *mut [u8];
++                                 let mut _16: *mut u8;
++                                 let mut _17: *mut [u8];
 +                                 scope 20 {
 +                                     scope 21 (inlined NonNull::<[u8]>::as_ptr) {
 +                                         debug self => _11;
-+                                         let mut _19: *const [u8];
++                                         let mut _18: *const [u8];
 +                                     }
 +                                     scope 22 (inlined ptr::mut_ptr::<impl *mut [u8]>::as_mut_ptr) {
-+                                         debug self => _18;
++                                         debug self => _17;
 +                                     }
 +                                     scope 23 (inlined NonNull::<u8>::new_unchecked) {
-+                                         debug ptr => _17;
-+                                         let mut _20: *const u8;
-+                                         let mut _21: *mut u8;
++                                         debug ptr => _16;
++                                         let mut _19: *const u8;
 +                                         scope 24 {
 +                                             scope 25 (inlined NonNull::<T>::new_unchecked::runtime::<u8>) {
-+                                                 debug ptr => _21;
++                                                 debug ptr => _16;
 +                                                 scope 26 (inlined ptr::mut_ptr::<impl *mut u8>::is_null) {
-+                                                     debug self => _21;
-+                                                     let mut _22: *mut u8;
++                                                     debug self => _16;
++                                                     let mut _20: *mut u8;
 +                                                     scope 27 {
 +                                                         scope 28 (inlined ptr::mut_ptr::<impl *mut T>::is_null::runtime_impl) {
-+                                                             debug ptr => _22;
++                                                             debug ptr => _20;
 +                                                             scope 29 (inlined ptr::mut_ptr::<impl *mut u8>::addr) {
-+                                                                 debug self => _22;
++                                                                 debug self => _20;
 +                                                                 scope 30 {
 +                                                                     scope 31 (inlined ptr::mut_ptr::<impl *mut u8>::cast::<()>) {
-+                                                                         debug self => _22;
++                                                                         debug self => _20;
 +                                                                     }
 +                                                                 }
 +                                                             }
@@ -76,8 +75,8 @@
 +                                 }
 +                             }
 +                             scope 32 (inlined NonNull::<u8>::as_ptr) {
-+                                 debug self => _16;
-+                                 let mut _23: *const u8;
++                                 debug self => _15;
++                                 let mut _21: *const u8;
 +                             }
 +                         }
 +                     }
@@ -94,14 +93,13 @@
 +                         scope 10 {
 +                             scope 11 (inlined std::ptr::Alignment::new_unchecked) {
 +                                 debug align => _5;
-+                                 let mut _15: usize;
 +                                 scope 12 {
 +                                     scope 14 (inlined std::ptr::Alignment::new_unchecked::runtime) {
-+                                         debug align => _15;
++                                         debug align => _5;
 +                                         scope 15 (inlined core::num::<impl usize>::is_power_of_two) {
-+                                             debug self => _15;
++                                             debug self => _5;
 +                                             scope 16 (inlined core::num::<impl usize>::count_ones) {
-+                                                 debug self => _15;
++                                                 debug self => _5;
 +                                             }
 +                                         }
 +                                     }
@@ -131,14 +129,12 @@
 +         StorageLive(_12);
 +         StorageLive(_13);
 +         StorageLive(_14);
-+         StorageLive(_15);
 +         _14 = _5 as std::ptr::Alignment (Transmute);
-+         StorageDead(_15);
 +         _8 = Layout { size: _4, align: move _14 };
 +         StorageDead(_14);
 +         StorageLive(_9);
 +         _13 = const _;
-+         _9 = std::alloc::Global::alloc_impl(_13, _8, const false) -> [return: bb5, unwind unreachable];
++         _9 = std::alloc::Global::alloc_impl(move _13, _8, const false) -> [return: bb5, unwind unreachable];
       }
   
       bb1: {
@@ -148,7 +144,7 @@
       }
   
       bb2: {
-+         _12 = handle_alloc_error(_8) -> unwind unreachable;
++         _12 = handle_alloc_error(move _8) -> unwind unreachable;
 +     }
 + 
 +     bb3: {
@@ -157,29 +153,27 @@
 + 
 +     bb4: {
 +         _11 = ((_9 as Ok).0: std::ptr::NonNull<[u8]>);
++         StorageLive(_15);
 +         StorageLive(_16);
 +         StorageLive(_17);
 +         StorageLive(_18);
-+         StorageLive(_19);
-+         _19 = (_11.0: *const [u8]);
-+         _18 = move _19 as *mut [u8] (PtrToPtr);
-+         StorageDead(_19);
-+         _17 = _18 as *mut u8 (PtrToPtr);
++         _18 = (_11.0: *const [u8]);
++         _17 = move _18 as *mut [u8] (PtrToPtr);
 +         StorageDead(_18);
++         _16 = _17 as *mut u8 (PtrToPtr);
++         StorageDead(_17);
++         StorageLive(_19);
 +         StorageLive(_20);
-+         StorageLive(_21);
-+         StorageLive(_22);
-+         _20 = _17 as *const u8 (PointerCoercion(MutToConstPointer));
-+         _16 = NonNull::<u8> { pointer: _20 };
-+         StorageDead(_22);
-+         StorageDead(_21);
++         _19 = _16 as *const u8 (PointerCoercion(MutToConstPointer));
++         _15 = NonNull::<u8> { pointer: _19 };
 +         StorageDead(_20);
-+         StorageDead(_17);
-+         StorageLive(_23);
-+         _23 = (_16.0: *const u8);
-+         _6 = move _23 as *mut u8 (PtrToPtr);
-+         StorageDead(_23);
++         StorageDead(_19);
 +         StorageDead(_16);
++         StorageLive(_21);
++         _21 = (_15.0: *const u8);
++         _6 = move _21 as *mut u8 (PtrToPtr);
++         StorageDead(_21);
++         StorageDead(_15);
 +         StorageDead(_9);
 +         StorageDead(_13);
 +         StorageDead(_12);
diff --git a/tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-unwind.diff
index 80b5810aa..54c33aac9 100644
--- a/tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_into_box_place.main.Inline.panic-unwind.diff
@@ -33,37 +33,36 @@
 +                         debug ptr => _11;
 +                         scope 18 (inlined NonNull::<[u8]>::as_mut_ptr) {
 +                             debug self => _11;
-+                             let mut _16: std::ptr::NonNull<u8>;
++                             let mut _15: std::ptr::NonNull<u8>;
 +                             scope 19 (inlined NonNull::<[u8]>::as_non_null_ptr) {
 +                                 debug self => _11;
-+                                 let mut _17: *mut u8;
-+                                 let mut _18: *mut [u8];
++                                 let mut _16: *mut u8;
++                                 let mut _17: *mut [u8];
 +                                 scope 20 {
 +                                     scope 21 (inlined NonNull::<[u8]>::as_ptr) {
 +                                         debug self => _11;
-+                                         let mut _19: *const [u8];
++                                         let mut _18: *const [u8];
 +                                     }
 +                                     scope 22 (inlined ptr::mut_ptr::<impl *mut [u8]>::as_mut_ptr) {
-+                                         debug self => _18;
++                                         debug self => _17;
 +                                     }
 +                                     scope 23 (inlined NonNull::<u8>::new_unchecked) {
-+                                         debug ptr => _17;
-+                                         let mut _20: *const u8;
-+                                         let mut _21: *mut u8;
++                                         debug ptr => _16;
++                                         let mut _19: *const u8;
 +                                         scope 24 {
 +                                             scope 25 (inlined NonNull::<T>::new_unchecked::runtime::<u8>) {
-+                                                 debug ptr => _21;
++                                                 debug ptr => _16;
 +                                                 scope 26 (inlined ptr::mut_ptr::<impl *mut u8>::is_null) {
-+                                                     debug self => _21;
-+                                                     let mut _22: *mut u8;
++                                                     debug self => _16;
++                                                     let mut _20: *mut u8;
 +                                                     scope 27 {
 +                                                         scope 28 (inlined ptr::mut_ptr::<impl *mut T>::is_null::runtime_impl) {
-+                                                             debug ptr => _22;
++                                                             debug ptr => _20;
 +                                                             scope 29 (inlined ptr::mut_ptr::<impl *mut u8>::addr) {
-+                                                                 debug self => _22;
++                                                                 debug self => _20;
 +                                                                 scope 30 {
 +                                                                     scope 31 (inlined ptr::mut_ptr::<impl *mut u8>::cast::<()>) {
-+                                                                         debug self => _22;
++                                                                         debug self => _20;
 +                                                                     }
 +                                                                 }
 +                                                             }
@@ -76,8 +75,8 @@
 +                                 }
 +                             }
 +                             scope 32 (inlined NonNull::<u8>::as_ptr) {
-+                                 debug self => _16;
-+                                 let mut _23: *const u8;
++                                 debug self => _15;
++                                 let mut _21: *const u8;
 +                             }
 +                         }
 +                     }
@@ -94,14 +93,13 @@
 +                         scope 10 {
 +                             scope 11 (inlined std::ptr::Alignment::new_unchecked) {
 +                                 debug align => _5;
-+                                 let mut _15: usize;
 +                                 scope 12 {
 +                                     scope 14 (inlined std::ptr::Alignment::new_unchecked::runtime) {
-+                                         debug align => _15;
++                                         debug align => _5;
 +                                         scope 15 (inlined core::num::<impl usize>::is_power_of_two) {
-+                                             debug self => _15;
++                                             debug self => _5;
 +                                             scope 16 (inlined core::num::<impl usize>::count_ones) {
-+                                                 debug self => _15;
++                                                 debug self => _5;
 +                                             }
 +                                         }
 +                                     }
@@ -131,14 +129,12 @@
 +         StorageLive(_12);
 +         StorageLive(_13);
 +         StorageLive(_14);
-+         StorageLive(_15);
 +         _14 = _5 as std::ptr::Alignment (Transmute);
-+         StorageDead(_15);
 +         _8 = Layout { size: _4, align: move _14 };
 +         StorageDead(_14);
 +         StorageLive(_9);
 +         _13 = const _;
-+         _9 = std::alloc::Global::alloc_impl(_13, _8, const false) -> [return: bb7, unwind: bb3];
++         _9 = std::alloc::Global::alloc_impl(move _13, _8, const false) -> [return: bb7, unwind: bb3];
       }
   
       bb1: {
@@ -165,7 +161,7 @@
 -     bb4 (cleanup): {
 -         resume;
 +     bb4: {
-+         _12 = handle_alloc_error(_8) -> bb3;
++         _12 = handle_alloc_error(move _8) -> bb3;
 +     }
 + 
 +     bb5: {
@@ -174,29 +170,27 @@
 + 
 +     bb6: {
 +         _11 = ((_9 as Ok).0: std::ptr::NonNull<[u8]>);
++         StorageLive(_15);
 +         StorageLive(_16);
 +         StorageLive(_17);
 +         StorageLive(_18);
-+         StorageLive(_19);
-+         _19 = (_11.0: *const [u8]);
-+         _18 = move _19 as *mut [u8] (PtrToPtr);
-+         StorageDead(_19);
-+         _17 = _18 as *mut u8 (PtrToPtr);
++         _18 = (_11.0: *const [u8]);
++         _17 = move _18 as *mut [u8] (PtrToPtr);
 +         StorageDead(_18);
++         _16 = _17 as *mut u8 (PtrToPtr);
++         StorageDead(_17);
++         StorageLive(_19);
 +         StorageLive(_20);
-+         StorageLive(_21);
-+         StorageLive(_22);
-+         _20 = _17 as *const u8 (PointerCoercion(MutToConstPointer));
-+         _16 = NonNull::<u8> { pointer: _20 };
-+         StorageDead(_22);
-+         StorageDead(_21);
++         _19 = _16 as *const u8 (PointerCoercion(MutToConstPointer));
++         _15 = NonNull::<u8> { pointer: _19 };
 +         StorageDead(_20);
-+         StorageDead(_17);
-+         StorageLive(_23);
-+         _23 = (_16.0: *const u8);
-+         _6 = move _23 as *mut u8 (PtrToPtr);
-+         StorageDead(_23);
++         StorageDead(_19);
 +         StorageDead(_16);
++         StorageLive(_21);
++         _21 = (_15.0: *const u8);
++         _6 = move _21 as *mut u8 (PtrToPtr);
++         StorageDead(_21);
++         StorageDead(_15);
 +         StorageDead(_9);
 +         StorageDead(_13);
 +         StorageDead(_12);
diff --git a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir
index 503f15308..f0d1cfe03 100644
--- a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir
+++ b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir
@@ -15,7 +15,7 @@ fn test2(_1: &dyn X) -> bool {
         _3 = &(*_1);
         _2 = move _3 as &dyn X (PointerCoercion(Unsize));
         StorageDead(_3);
-        _0 = <dyn X as X>::y(_2) -> [return: bb1, unwind unreachable];
+        _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
diff --git a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir
index 37bb53e79..f37b08143 100644
--- a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir
@@ -15,7 +15,7 @@ fn test2(_1: &dyn X) -> bool {
         _3 = &(*_1);
         _2 = move _3 as &dyn X (PointerCoercion(Unsize));
         StorageDead(_3);
-        _0 = <dyn X as X>::y(_2) -> [return: bb1, unwind continue];
+        _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind continue];
     }
 
     bb1: {
diff --git a/tests/mir-opt/inline/issue_78442.bar.Inline.panic-abort.diff b/tests/mir-opt/inline/issue_78442.bar.Inline.panic-abort.diff
index b86eb5f35..bee01a5f9 100644
--- a/tests/mir-opt/inline/issue_78442.bar.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/issue_78442.bar.Inline.panic-abort.diff
@@ -8,8 +8,6 @@
       let mut _3: &fn() {foo};
       let _4: fn() {foo};
       let mut _5: ();
-+     scope 1 (inlined <fn() {foo} as Fn<()>>::call - shim(fn() {foo})) {
-+     }
   
       bb0: {
           StorageLive(_2);
@@ -22,26 +20,20 @@
           _3 = &_4;
           StorageLive(_5);
           _5 = ();
--         _2 = <fn() {foo} as Fn<()>>::call(move _3, move _5) -> [return: bb2, unwind unreachable];
-+         _2 = move (*_3)() -> [return: bb3, unwind unreachable];
+          _2 = <fn() {foo} as Fn<()>>::call(move _3, move _5) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
-+         return;
-+     }
-+ 
-+     bb3: {
           StorageDead(_5);
           StorageDead(_3);
           StorageDead(_4);
           StorageDead(_2);
           _0 = const ();
--         drop(_1) -> [return: bb3, unwind unreachable];
--     }
-- 
--     bb3: {
--         return;
-+         drop(_1) -> [return: bb2, unwind unreachable];
+          drop(_1) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          return;
       }
   }
   
diff --git a/tests/mir-opt/inline/issue_78442.bar.Inline.panic-unwind.diff b/tests/mir-opt/inline/issue_78442.bar.Inline.panic-unwind.diff
index c67babba2..b750330df 100644
--- a/tests/mir-opt/inline/issue_78442.bar.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/issue_78442.bar.Inline.panic-unwind.diff
@@ -8,55 +8,40 @@
       let mut _3: &fn() {foo};
       let _4: fn() {foo};
       let mut _5: ();
-+     scope 1 (inlined <fn() {foo} as Fn<()>>::call - shim(fn() {foo})) {
-+     }
   
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
--         _4 = hide_foo() -> [return: bb1, unwind: bb4];
-+         _4 = hide_foo() -> [return: bb1, unwind: bb3];
+          _4 = hide_foo() -> [return: bb1, unwind: bb4];
       }
   
       bb1: {
           _3 = &_4;
           StorageLive(_5);
           _5 = ();
--         _2 = <fn() {foo} as Fn<()>>::call(move _3, move _5) -> [return: bb2, unwind: bb4];
-+         _2 = move (*_3)() -> [return: bb5, unwind: bb3];
+          _2 = <fn() {foo} as Fn<()>>::call(move _3, move _5) -> [return: bb2, unwind: bb4];
       }
   
       bb2: {
--         StorageDead(_5);
--         StorageDead(_3);
--         StorageDead(_4);
--         StorageDead(_2);
--         _0 = const ();
--         drop(_1) -> [return: bb3, unwind: bb5];
-+         return;
+          StorageDead(_5);
+          StorageDead(_3);
+          StorageDead(_4);
+          StorageDead(_2);
+          _0 = const ();
+          drop(_1) -> [return: bb3, unwind: bb5];
       }
   
--     bb3: {
--         return;
-+     bb3 (cleanup): {
-+         drop(_1) -> [return: bb4, unwind terminate];
+      bb3: {
+          return;
       }
   
       bb4 (cleanup): {
--         drop(_1) -> [return: bb5, unwind terminate];
-+         resume;
+          drop(_1) -> [return: bb5, unwind terminate];
       }
   
--     bb5 (cleanup): {
--         resume;
-+     bb5: {
-+         StorageDead(_5);
-+         StorageDead(_3);
-+         StorageDead(_4);
-+         StorageDead(_2);
-+         _0 = const ();
-+         drop(_1) -> [return: bb2, unwind: bb4];
+      bb5 (cleanup): {
+          resume;
       }
   }
   
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff
index 90b32247c..d05221966 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff
@@ -12,7 +12,6 @@
 +         debug rhs => _4;
 +         let mut _5: u16;
 +         let mut _6: bool;
-+         let mut _7: u32;
 +         scope 2 {
 +         }
 +     }
@@ -28,10 +27,7 @@
 -     bb1: {
 +         StorageLive(_5);
 +         StorageLive(_6);
-+         StorageLive(_7);
-+         _7 = const 65535_u32;
-+         _6 = Le(_4, move _7);
-+         StorageDead(_7);
++         _6 = Le(_4, const 65535_u32);
 +         assume(move _6);
 +         StorageDead(_6);
 +         _5 = _4 as u16 (IntToInt);
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff
index cae25759c..67a5ac248 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff
@@ -12,7 +12,6 @@
 +         debug rhs => _4;
 +         let mut _5: u16;
 +         let mut _6: bool;
-+         let mut _7: u32;
 +         scope 2 {
 +         }
 +     }
@@ -28,10 +27,7 @@
 -     bb1: {
 +         StorageLive(_5);
 +         StorageLive(_6);
-+         StorageLive(_7);
-+         _7 = const 65535_u32;
-+         _6 = Le(_4, move _7);
-+         StorageDead(_7);
++         _6 = Le(_4, const 65535_u32);
 +         assume(move _6);
 +         StorageDead(_6);
 +         _5 = _4 as u16 (IntToInt);
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir
index 3f388a69d..f9dff62e0 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir
@@ -7,25 +7,21 @@ fn unchecked_shl_unsigned_smaller(_1: u16, _2: u32) -> u16 {
     scope 1 (inlined core::num::<impl u16>::unchecked_shl) {
         debug self => _1;
         debug rhs => _2;
-        let mut _3: u32;
-        let mut _4: bool;
-        let mut _5: u16;
+        let mut _3: bool;
+        let mut _4: u16;
         scope 2 {
         }
     }
 
     bb0: {
-        StorageLive(_5);
         StorageLive(_4);
         StorageLive(_3);
-        _3 = const 65535_u32;
-        _4 = Le(_2, move _3);
+        _3 = Le(_2, const 65535_u32);
+        assume(move _3);
         StorageDead(_3);
-        assume(move _4);
+        _4 = _2 as u16 (IntToInt);
+        _0 = ShlUnchecked(_1, move _4);
         StorageDead(_4);
-        _5 = _2 as u16 (IntToInt);
-        _0 = ShlUnchecked(_1, move _5);
-        StorageDead(_5);
         return;
     }
 }
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir
index 3f388a69d..f9dff62e0 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir
@@ -7,25 +7,21 @@ fn unchecked_shl_unsigned_smaller(_1: u16, _2: u32) -> u16 {
     scope 1 (inlined core::num::<impl u16>::unchecked_shl) {
         debug self => _1;
         debug rhs => _2;
-        let mut _3: u32;
-        let mut _4: bool;
-        let mut _5: u16;
+        let mut _3: bool;
+        let mut _4: u16;
         scope 2 {
         }
     }
 
     bb0: {
-        StorageLive(_5);
         StorageLive(_4);
         StorageLive(_3);
-        _3 = const 65535_u32;
-        _4 = Le(_2, move _3);
+        _3 = Le(_2, const 65535_u32);
+        assume(move _3);
         StorageDead(_3);
-        assume(move _4);
+        _4 = _2 as u16 (IntToInt);
+        _0 = ShlUnchecked(_1, move _4);
         StorageDead(_4);
-        _5 = _2 as u16 (IntToInt);
-        _0 = ShlUnchecked(_1, move _5);
-        StorageDead(_5);
         return;
     }
 }
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.Inline.panic-abort.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.Inline.panic-abort.diff
index fa7e5d16e..15b36b284 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.Inline.panic-abort.diff
@@ -12,7 +12,6 @@
 +         debug rhs => _4;
 +         let mut _5: i16;
 +         let mut _6: bool;
-+         let mut _7: u32;
 +         scope 2 {
 +         }
 +     }
@@ -28,10 +27,7 @@
 -     bb1: {
 +         StorageLive(_5);
 +         StorageLive(_6);
-+         StorageLive(_7);
-+         _7 = const 32767_u32;
-+         _6 = Le(_4, move _7);
-+         StorageDead(_7);
++         _6 = Le(_4, const 32767_u32);
 +         assume(move _6);
 +         StorageDead(_6);
 +         _5 = _4 as i16 (IntToInt);
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.Inline.panic-unwind.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.Inline.panic-unwind.diff
index fe5331214..8629f92db 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.Inline.panic-unwind.diff
@@ -12,7 +12,6 @@
 +         debug rhs => _4;
 +         let mut _5: i16;
 +         let mut _6: bool;
-+         let mut _7: u32;
 +         scope 2 {
 +         }
 +     }
@@ -28,10 +27,7 @@
 -     bb1: {
 +         StorageLive(_5);
 +         StorageLive(_6);
-+         StorageLive(_7);
-+         _7 = const 32767_u32;
-+         _6 = Le(_4, move _7);
-+         StorageDead(_7);
++         _6 = Le(_4, const 32767_u32);
 +         assume(move _6);
 +         StorageDead(_6);
 +         _5 = _4 as i16 (IntToInt);
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.PreCodegen.after.panic-abort.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.PreCodegen.after.panic-abort.mir
index 64ea25349..65fa0d956 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.PreCodegen.after.panic-abort.mir
@@ -7,25 +7,21 @@ fn unchecked_shr_signed_smaller(_1: i16, _2: u32) -> i16 {
     scope 1 (inlined core::num::<impl i16>::unchecked_shr) {
         debug self => _1;
         debug rhs => _2;
-        let mut _3: u32;
-        let mut _4: bool;
-        let mut _5: i16;
+        let mut _3: bool;
+        let mut _4: i16;
         scope 2 {
         }
     }
 
     bb0: {
-        StorageLive(_5);
         StorageLive(_4);
         StorageLive(_3);
-        _3 = const 32767_u32;
-        _4 = Le(_2, move _3);
+        _3 = Le(_2, const 32767_u32);
+        assume(move _3);
         StorageDead(_3);
-        assume(move _4);
+        _4 = _2 as i16 (IntToInt);
+        _0 = ShrUnchecked(_1, move _4);
         StorageDead(_4);
-        _5 = _2 as i16 (IntToInt);
-        _0 = ShrUnchecked(_1, move _5);
-        StorageDead(_5);
         return;
     }
 }
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.PreCodegen.after.panic-unwind.mir
index 64ea25349..65fa0d956 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_smaller.PreCodegen.after.panic-unwind.mir
@@ -7,25 +7,21 @@ fn unchecked_shr_signed_smaller(_1: i16, _2: u32) -> i16 {
     scope 1 (inlined core::num::<impl i16>::unchecked_shr) {
         debug self => _1;
         debug rhs => _2;
-        let mut _3: u32;
-        let mut _4: bool;
-        let mut _5: i16;
+        let mut _3: bool;
+        let mut _4: i16;
         scope 2 {
         }
     }
 
     bb0: {
-        StorageLive(_5);
         StorageLive(_4);
         StorageLive(_3);
-        _3 = const 32767_u32;
-        _4 = Le(_2, move _3);
+        _3 = Le(_2, const 32767_u32);
+        assume(move _3);
         StorageDead(_3);
-        assume(move _4);
+        _4 = _2 as i16 (IntToInt);
+        _0 = ShrUnchecked(_1, move _4);
         StorageDead(_4);
-        _5 = _2 as i16 (IntToInt);
-        _0 = ShrUnchecked(_1, move _5);
-        StorageDead(_5);
         return;
     }
 }