Don't instantiate so many copies of real_drop_in_place

Author: matthewjasper

src/librustc/ty/instance.rs

@@ -52,7 +52,8 @@ pub enum InstanceDef<'tcx> {
     /// `<[mut closure] as FnOnce>::call_once`
     ClosureOnceShim { call_once: DefId },
 
-    /// `drop_in_place::<T>; None` for empty drop glue.
+    /// `real_drop_in_place::<T>`; `None` for empty drop glue. The `DefId` is
+    /// for `real_drop_in_place`.
     DropGlue(DefId, Option<Ty<'tcx>>),
 
     ///`<T as Clone>::clone` shim.
@@ -108,11 +109,28 @@ impl<'tcx> InstanceDef<'tcx> {
         if self.is_inline(tcx) {
             return true
         }
-        if let ty::InstanceDef::DropGlue(..) = *self {
-            // Drop glue wants to be instantiated at every codegen
+        if let ty::InstanceDef::DropGlue(.., Some(ty)) = *self {
+            // Drop glue generally wants to be instantiated at every codegen
             // unit, but without an #[inline] hint. We should make this
             // available to normal end-users.
-            return true
+            if tcx.sess.opts.incremental.is_none() {
+                return true;
+            }
+            // When compiling with incremental, we can generate a *lot* of
+            // codegen units. Including drop glue into all of them has a
+            // considerable compile time cost.
+            //
+            // We include enums without destructors to allow, say, optimizing
+            // drops of `Option::None` before LTO. We also respect the intent of
+            // `#[inline]` on `Drop::drop` implementations.
+            return ty.ty_adt_def()
+                .map_or(true, |adt_def| {
+                    adt_def.destructor(tcx)
+                        .map_or(
+                            adt_def.is_enum(),
+                            |dtor| tcx.codegen_fn_attrs(dtor.did).requests_inline(),
+                        )
+                })
         }
         tcx.codegen_fn_attrs(self.def_id()).requests_inline()
     }

src/librustc_mir/monomorphize/partitioning.rs

@@ -690,13 +690,20 @@ fn characteristic_def_id_of_mono_item<'tcx>(
 
             if tcx.trait_of_item(def_id).is_some() {
                 let self_ty = instance.substs.type_at(0);
-                // This is an implementation of a trait method.
+                // This is a default implementation of a trait method.
                 return characteristic_def_id_of_type(self_ty).or(Some(def_id));
             }
 
             if let Some(impl_def_id) = tcx.impl_of_method(def_id) {
-                // This is a method within an inherent impl, find out what the
-                // self-type is:
+                if tcx.sess.opts.incremental.is_some()
+                    && tcx.trait_id_of_impl(impl_def_id) == tcx.lang_items().drop_trait()
+                {
+                    // Put `Drop::drop` into the same cgu as `real_drop_in_place`
+                    // since `real_drop_in_place` is the only thing that can
+                    // call it.
+                    return None;
+                }
+                // This is a method within an impl, find out what the self-type is:
                 let impl_self_ty = tcx.subst_and_normalize_erasing_regions(
                     instance.substs,
                     ty::ParamEnv::reveal_all(),