bugfix on runtime borrows

Author: dingxiangfei2009

compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs

@@ -103,16 +103,18 @@ impl<'a, 'mir, 'tcx> DropsReachable<'a, 'mir, 'tcx> {
             // we will proceed with `succ`
             let dropped_local_there = match self.visited.entry(succ) {
                 hash_map::Entry::Occupied(occupied_entry) => {
-                    if !occupied_entry.get().borrow_mut().union(&*dropped_local_here.borrow()) {
+                    if succ == block
+                        || !occupied_entry.get().borrow_mut().union(&*dropped_local_here.borrow())
+                    {
                         // `succ` has been visited but no new drops observed so far,
                         // so we can bail on `succ` until new drop information arrives
                         continue;
                     }
                     occupied_entry.get().clone()
                 }
-                hash_map::Entry::Vacant(vacant_entry) => {
-                    vacant_entry.insert(dropped_local_here.clone()).clone()
-                }
+                hash_map::Entry::Vacant(vacant_entry) => vacant_entry
+                    .insert(Rc::new(RefCell::new(dropped_local_here.borrow().clone())))
+                    .clone(),
             };
             if let Some(terminator) = &target.terminator
                 && let TerminatorKind::Drop {
@@ -141,6 +143,61 @@ impl<'a, 'mir, 'tcx> DropsReachable<'a, 'mir, 'tcx> {
     }
 }
 
+fn true_significant_drop_ty<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    ty: Ty<'tcx>,
+) -> Option<SmallVec<[Ty<'tcx>; 2]>> {
+    if let ty::Adt(def, args) = ty.kind() {
+        let mut did = def.did();
+        let mut name_rev = vec![];
+        loop {
+            let key = tcx.def_key(did);
+
+            match key.disambiguated_data.data {
+                rustc_hir::definitions::DefPathData::CrateRoot => {
+                    name_rev.push(tcx.crate_name(did.krate))
+                }
+                rustc_hir::definitions::DefPathData::TypeNs(symbol) => name_rev.push(symbol),
+                _ => return None,
+            }
+            if let Some(parent) = key.parent {
+                did = DefId { krate: did.krate, index: parent };
+            } else {
+                break;
+            }
+        }
+        let name_str: Vec<_> = name_rev.iter().rev().map(|x| x.as_str()).collect();
+        debug!(?name_str);
+        match name_str[..] {
+            // These are the types from Rust core ecosystem
+            ["sym" | "proc_macro2", ..] | ["core" | "std", "task", "RawWaker"] => Some(smallvec![]),
+            // These are important types from Rust ecosystem
+            ["tracing", "instrument", "Instrumented"] | ["bytes", "Bytes"] => Some(smallvec![]),
+            ["hashbrown", "raw", "RawTable" | "RawIntoIter"] => {
+                if let [ty, ..] = &***args
+                    && let Some(ty) = ty.as_type()
+                {
+                    Some(smallvec![ty])
+                } else {
+                    None
+                }
+            }
+            ["hashbrown", "raw", "RawDrain"] => {
+                if let [_, ty, ..] = &***args
+                    && let Some(ty) = ty.as_type()
+                {
+                    Some(smallvec![ty])
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    } else {
+        None
+    }
+}
+
 #[instrument(level = "debug", skip(tcx, param_env))]
 fn extract_component_raw<'tcx>(
     tcx: TyCtxt<'tcx>,
@@ -154,7 +211,14 @@ fn extract_component_raw<'tcx>(
     debug!(?ty, "components");
     let mut out_tys = smallvec![];
     for ty in tys {
-        out_tys.push(ty);
+        if let Some(tys) = true_significant_drop_ty(tcx, ty) {
+            // Some types can be further opened up because the drop is simply delegated
+            for ty in tys {
+                out_tys.extend(extract_component_raw(tcx, param_env, ty));
+            }
+        } else {
+            out_tys.push(ty);
+        }
     }
     out_tys
 }