fix(upstream): drop_in_place -> drop_glue

Author: nbdd0121

src/binary_analysis/reconstruct.rs

@@ -135,7 +135,7 @@ pub fn recover_fn_call_span<'tcx>(
                     ty::EarlyBinder::bind(ty),
                 );
 
-                let instance = Instance::resolve_drop_in_place(tcx, ty);
+                let instance = Instance::resolve_drop_glue(tcx, ty);
                 if tcx.symbol_name(instance).name != callee {
                     continue;
                 }

src/diagnostic/use_stack.rs

@@ -93,7 +93,7 @@ impl<'tcx> AnalysisCtxt<'tcx> {
     ) {
         for site in use_stack.iter().rev() {
             let def_id = site.instance.value.def_id();
-            if self.is_lang_item(def_id, LangItem::DropInPlace) {
+            if self.is_lang_item(def_id, LangItem::DropGlue) {
                 let ty = site.instance.value.args[0];
                 diag.note(format!("which is called from drop glue of `{ty}`"));
                 continue;

src/monomorphize_collector.rs

@@ -485,8 +485,8 @@ fn check_recursion_limit<'tcx>(
     let recursion_depth = recursion_depths.get(&def_id).cloned().unwrap_or(0);
     debug!(" => recursion depth={}", recursion_depth);
 
-    let adjusted_recursion_depth = if Some(def_id) == tcx.lang_items().drop_in_place_fn() {
-        // HACK: drop_in_place creates tight monomorphization loops. Give
+    let adjusted_recursion_depth = if tcx.is_lang_item(def_id, LangItem::DropGlue) {
+        // HACK: `drop_glue` creates tight monomorphization loops. Give
         // it more margin.
         recursion_depth / 4
     } else {
@@ -779,7 +779,7 @@ fn visit_drop_use<'tcx>(
     source: Span,
     output: &mut MonoItems<'tcx>,
 ) {
-    let instance = Instance::resolve_drop_in_place(tcx, ty);
+    let instance = Instance::resolve_drop_glue(tcx, ty);
     visit_instance_use(tcx, instance, is_direct_call, source, output);
 }
 
@@ -1313,7 +1313,7 @@ impl<'v> RootCollector<'_, 'v> {
                         });
 
                     // This type is impossible to instantiate, so we should not try to
-                    // generate a `drop_in_place` instance for it.
+                    // generate a `drop_glue` instance for it.
                     if self.tcx.instantiate_and_check_impossible_predicates((
                         id.owner_id.to_def_id(),
                         id_args,

src/preempt_count/adjustment.rs

@@ -418,10 +418,10 @@ memoize!(
             _ => return Err(Error::TooGeneric),
         }
 
-        // Do not call `resolve_drop_in_place` because we need typing_env.
-        let drop_in_place = cx.require_lang_item(LangItem::DropInPlace, DUMMY_SP);
+        // Do not call `resolve_drop_glue` because we need typing_env.
+        let drop_glue = cx.require_lang_item(LangItem::DropGlue, DUMMY_SP);
         let args = cx.mk_args(&[ty.into()]);
-        let instance = ty::Instance::try_resolve(cx.tcx, typing_env, drop_in_place, args)
+        let instance = ty::Instance::try_resolve(cx.tcx, typing_env, drop_glue, args)
             .unwrap()
             .unwrap();
         let poly_instance = typing_env.as_query_input(instance);
@@ -540,10 +540,10 @@ memoize!(
             return Ok(());
         }
 
-        // Do not call `resolve_drop_in_place` because we need typing_env.
-        let drop_in_place = cx.require_lang_item(LangItem::DropInPlace, DUMMY_SP);
+        // Do not call `resolve_drop_glue` because we need typing_env.
+        let drop_glue = cx.require_lang_item(LangItem::DropGlue, DUMMY_SP);
         let args = cx.mk_args(&[ty.into()]);
-        let instance = ty::Instance::try_resolve(cx.tcx, typing_env, drop_in_place, args)
+        let instance = ty::Instance::try_resolve(cx.tcx, typing_env, drop_glue, args)
             .unwrap()
             .unwrap();
 

src/preempt_count/check.rs

@@ -726,10 +726,10 @@ memoize!(
             _ => return Err(Error::TooGeneric),
         }
 
-        // Do not call `resolve_drop_in_place` because we need typing_env.
-        let drop_in_place = cx.require_lang_item(LangItem::DropInPlace, DUMMY_SP);
+        // Do not call `resolve_drop_glue` because we need typing_env.
+        let drop_glue = cx.require_lang_item(LangItem::DropGlue, DUMMY_SP);
         let args = cx.mk_args(&[ty.into()]);
-        let instance = ty::Instance::try_resolve(cx.tcx, typing_env, drop_in_place, args)
+        let instance = ty::Instance::try_resolve(cx.tcx, typing_env, drop_glue, args)
             .unwrap()
             .unwrap();
         let poly_instance = typing_env.as_query_input(instance);

src/preempt_count/expectation.rs

@@ -471,10 +471,10 @@ impl<'tcx> AnalysisCtxt<'tcx> {
         );
         let span = MultiSpan::new();
 
-        // Do not call `resolve_drop_in_place` because we need typing_env.
-        let drop_in_place = self.require_lang_item(LangItem::DropInPlace, DUMMY_SP);
+        // Do not call `resolve_drop_glue` because we need typing_env.
+        let drop_glue = self.require_lang_item(LangItem::DropGlue, DUMMY_SP);
         let args = self.mk_args(&[ty.into()]);
-        let instance = ty::Instance::try_resolve(self.tcx, typing_env, drop_in_place, args)
+        let instance = ty::Instance::try_resolve(self.tcx, typing_env, drop_glue, args)
             .unwrap()
             .unwrap();
 
@@ -757,10 +757,10 @@ memoize!(
             _ => return Err(Error::TooGeneric),
         }
 
-        // Do not call `resolve_drop_in_place` because we need typing_env.
-        let drop_in_place = cx.require_lang_item(LangItem::DropInPlace, DUMMY_SP);
+        // Do not call `resolve_drop_glue` because we need typing_env.
+        let drop_glue = cx.require_lang_item(LangItem::DropGlue, DUMMY_SP);
         let args = cx.mk_args(&[ty.into()]);
-        let instance = ty::Instance::try_resolve(cx.tcx, typing_env, drop_in_place, args)
+        let instance = ty::Instance::try_resolve(cx.tcx, typing_env, drop_glue, args)
             .unwrap()
             .unwrap();
         let poly_instance = typing_env.as_query_input(instance);
@@ -884,10 +884,10 @@ memoize!(
             return Ok(());
         }
 
-        // Do not call `resolve_drop_in_place` because we need typing_env.
-        let drop_in_place = cx.require_lang_item(LangItem::DropInPlace, DUMMY_SP);
+        // Do not call `resolve_drop_glue` because we need typing_env.
+        let drop_glue = cx.require_lang_item(LangItem::DropGlue, DUMMY_SP);
         let args = cx.mk_args(&[ty.into()]);
-        let instance = ty::Instance::try_resolve(cx.tcx, typing_env, drop_in_place, args)
+        let instance = ty::Instance::try_resolve(cx.tcx, typing_env, drop_glue, args)
             .unwrap()
             .unwrap();