Make unconditional_recursion warning detect recursive drops

Author: Enselic

compiler/rustc_mir_build/src/lints.rs

@@ -3,8 +3,10 @@ use rustc_data_structures::graph::iterate::{
     NodeStatus, TriColorDepthFirstSearch, TriColorVisitor,
 };
 use rustc_hir::def::DefKind;
-use rustc_middle::mir::{self, BasicBlock, BasicBlocks, Body, Operand, Terminator, TerminatorKind};
-use rustc_middle::ty::{self, Instance, TyCtxt};
+use rustc_middle::mir::{
+    self, BasicBlock, BasicBlocks, Body, Operand, Place, Terminator, TerminatorKind,
+};
+use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
 use rustc_middle::ty::{GenericArg, GenericArgs};
 use rustc_session::lint::builtin::UNCONDITIONAL_RECURSION;
 use rustc_span::Span;
@@ -23,7 +25,26 @@ pub(crate) fn check<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) {
             _ => &[],
         };
 
-        let mut vis = Search { tcx, body, reachable_recursive_calls: vec![], trait_args };
+        // If this body is a drop fn, figure out for what type. That way we can
+        // later detect recursive drops.
+        let mut drop_for = None;
+        if let Some(trait_ref) =
+            tcx.impl_of_method(def_id.to_def_id()).and_then(|def_id| tcx.impl_trait_ref(def_id)) &&
+            let Some(drop_trait) = tcx.lang_items().drop_trait() &&
+            drop_trait == trait_ref.instantiate_identity().def_id
+        {
+            if let ty::Ref(_, dropped_ty, _) = tcx
+                .liberate_late_bound_regions(
+                    def_id.to_def_id(),
+                    tcx.fn_sig(def_id).instantiate_identity().input(0),
+                )
+                .kind()
+            {
+                drop_for = Some(*dropped_ty);
+            }
+        };
+
+        let mut vis = Search { tcx, body, drop_for, reachable_recursive_calls: vec![], trait_args };
         if let Some(NonRecursive) =
             TriColorDepthFirstSearch::new(&body.basic_blocks).run_from_start(&mut vis)
         {
@@ -53,13 +74,18 @@ struct Search<'mir, 'tcx> {
     body: &'mir Body<'tcx>,
     trait_args: &'tcx [GenericArg<'tcx>],
 
+    // If Some, the `body` is the body of a fn drop() implementation, and the
+    // type is the type that Drop is implemented for
+    drop_for: Option<Ty<'tcx>>,
+
     reachable_recursive_calls: Vec<Span>,
 }
 
 impl<'mir, 'tcx> Search<'mir, 'tcx> {
     fn is_recursive_terminator(&self, terminator: &Terminator<'tcx>) -> bool {
         match &terminator.kind {
             TerminatorKind::Call { func, args, .. } => self.is_recursive_call(func, args),
+            TerminatorKind::Drop { place, .. } => self.is_recursive_drop(place),
             _ => false,
         }
     }
@@ -98,6 +124,16 @@ impl<'mir, 'tcx> Search<'mir, 'tcx> {
 
         false
     }
+
+    fn is_recursive_drop(&self, place: &Place<'tcx>) -> bool {
+        match self.drop_for {
+            None => false,
+            Some(drop_for) => {
+                let dropped_ty = place.ty(self.body, self.tcx).ty;
+                dropped_ty == drop_for
+            }
+        }
+    }
 }
 
 impl<'mir, 'tcx> TriColorVisitor<BasicBlocks<'tcx>> for Search<'mir, 'tcx> {

tests/ui/lint/lint-unconditional-recursion.rs

@@ -191,4 +191,12 @@ impl Default for Point {
     }
 }
 
+pub struct RecursiveDrop;
+
+impl Drop for RecursiveDrop {
+    fn drop(&mut self) { //~ ERROR function cannot return without recursing
+        let _ = RecursiveDrop;
+    }
+}
+
 fn main() {}

tests/ui/lint/lint-unconditional-recursion.stderr

@@ -197,5 +197,15 @@ LL |             ..Default::default()
    |
    = help: a `loop` may express intention better if this is on purpose
 
-error: aborting due to 18 previous errors
+error: function cannot return without recursing
+  --> $DIR/lint-unconditional-recursion.rs:197:5
+   |
+LL |     fn drop(&mut self) {
+   |     ^^^^^^^^^^^^^^^^^^ cannot return without recursing
+LL |         let _ = RecursiveDrop;
+   |                              - recursive call site
+   |
+   = help: a `loop` may express intention better if this is on purpose
+
+error: aborting due to 19 previous errors