Auto merge of #130691 - scottmcm:elaborate-drops-to-calls, r=<try>

[WIP] Elaborate drops to calls

For now just borrowing CI to check for annoying no_core tests that I broke
r? ghost

Author: bors

compiler/rustc_mir_transform/src/inline/cycle.rs

@@ -1,8 +1,9 @@
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::LangItem;
 use rustc_middle::mir::TerminatorKind;
-use rustc_middle::ty::{self, GenericArgsRef, InstanceKind, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, GenericArg, GenericArgsRef, InstanceKind, TyCtxt, TypeVisitableExt};
 use rustc_session::Limit;
 use rustc_span::sym;
 use tracing::{instrument, trace};
@@ -191,6 +192,18 @@ pub(crate) fn mir_inliner_callees<'tcx>(
             };
             calls.insert(call);
         }
+        // This query is called on *analysis* MIR, which doesn't have drops elaborated,
+        // let alone any of the later runtime MIR optimizations.
+        if let TerminatorKind::Drop { place, .. } = &terminator.kind {
+            let dropped_ty = place.ty(&body.local_decls, tcx).ty;
+            let param_env = tcx.param_env_reveal_all_normalized(instance.def_id());
+            if dropped_ty.needs_drop(tcx, param_env) {
+                let drop_in_place_fn =
+                    tcx.require_lang_item(LangItem::DropInPlace, Some(terminator.source_info.span));
+                let args = tcx.mk_args(&[GenericArg::from(dropped_ty)]);
+                calls.insert((drop_in_place_fn, args));
+            }
+        }
     }
     tcx.arena.alloc_from_iter(calls.iter().copied())
 }

tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff

@@ -9,8 +9,8 @@
       let mut _4: i32;
       let mut _5: !;
       let _6: !;
-+     scope 1 (inlined panic) {
-+         let mut _7: !;
++     scope 1 (inlined calls_panic) {
++         let _7: !;
 +     }
 
       bb0: {
@@ -34,9 +34,9 @@
       bb2: {
           StorageDead(_3);
           StorageLive(_6);
--         _6 = panic() -> unwind unreachable;
+-         _6 = calls_panic() -> unwind unreachable;
 +         StorageLive(_7);
-+         _7 = begin_panic::<&str>(const "explicit panic") -> unwind unreachable;
++         _7 = panic_cold_explicit() -> unwind unreachable;
       }
   }
 

tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff

@@ -9,8 +9,8 @@
       let mut _4: i32;
       let mut _5: !;
       let _6: !;
-+     scope 1 (inlined panic) {
-+         let mut _7: !;
++     scope 1 (inlined calls_panic) {
++         let _7: !;
 +     }
 
       bb0: {
@@ -34,9 +34,9 @@
       bb2: {
           StorageDead(_3);
           StorageLive(_6);
--         _6 = panic() -> unwind continue;
+-         _6 = calls_panic() -> unwind continue;
 +         StorageLive(_7);
-+         _7 = begin_panic::<&str>(const "explicit panic") -> unwind continue;
++         _7 = panic_cold_explicit() -> unwind continue;
       }
   }
 

tests/mir-opt/inline/inline_diverging.rs

@@ -1,7 +1,7 @@
 // Tests inlining of diverging calls.
 //
 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
-//@ compile-flags: -Zinline-mir-hint-threshold=1000 -C debuginfo=full
+//@ compile-flags: -Zinline-mir-hint-threshold=1000 -C debuginfo=full --edition=2021
 #![crate_type = "lib"]
 
 // EMIT_MIR inline_diverging.f.Inline.diff
@@ -17,8 +17,8 @@ pub fn g(i: i32) -> u32 {
         i as u32
     } else {
         // CHECK-LABEL: fn g(
-        // CHECK: (inlined panic)
-        panic();
+        // CHECK: (inlined calls_panic)
+        calls_panic();
     }
 }
 
@@ -38,7 +38,7 @@ pub fn call_twice<R, F: Fn() -> R>(f: F) -> (R, R) {
 }
 
 #[inline(always)]
-fn panic() -> ! {
+fn calls_panic() -> ! {
     panic!();
 }
 

tests/mir-opt/inline/inline_drop.drop_both_arguments.Inline.diff

@@ -0,0 +1,30 @@
+- // MIR for `drop_both_arguments` before Inline
++ // MIR for `drop_both_arguments` after Inline
+  
+  fn drop_both_arguments(_1: CallThingOnDrop, _2: CallThingOnDrop) -> () {
+      debug _a => _1;
+      debug _b => _2;
+      let mut _0: ();
+  
+      bb0: {
+          _0 = const ();
+          drop(_2) -> [return: bb1, unwind: bb3];
+      }
+  
+      bb1: {
+          drop(_1) -> [return: bb2, unwind: bb4];
+      }
+  
+      bb2: {
+          return;
+      }
+  
+      bb3 (cleanup): {
+          drop(_1) -> [return: bb4, unwind terminate(cleanup)];
+      }
+  
+      bb4 (cleanup): {
+          resume;
+      }
+  }
+  

tests/mir-opt/inline/inline_drop.rs

@@ -0,0 +1,24 @@
+// Test for inlining with an indirect destination place.
+//
+//@ test-mir-pass: Inline
+//@ edition: 2021
+//@ needs-unwind
+#![crate_type = "lib"]
+
+#[inline(never)]
+fn thing() {}
+
+struct CallThingOnDrop;
+
+impl Drop for CallThingOnDrop {
+    #[inline]
+    fn drop(&mut self) {
+        thing();
+    }
+}
+
+// EMIT_MIR inline_drop.drop_both_arguments.Inline.diff
+pub fn drop_both_arguments(_a: CallThingOnDrop, _b: CallThingOnDrop) {
+    // CHECK: drop(_2)
+    // CHECK: drop(_1)
+}