--- /dev/null
+use crate::LateContext;
+use crate::LateLintPass;
+use crate::LintContext;
+use rustc_hir as hir;
+use rustc_span::symbol::sym;
+
+declare_lint! {
+ /// The `drop_bounds` lint checks for generics with `std::ops::Drop` as
+ /// bounds.
+ ///
+ /// ### Example
+ ///
+ /// ```rust
+ /// fn foo<T: Drop>() {}
+ /// ```
+ ///
+ /// {{produces}}
+ ///
+ /// ### Explanation
+ ///
+ /// `Drop` bounds do not really accomplish anything. A type may have
+ /// compiler-generated drop glue without implementing the `Drop` trait
+ /// itself. The `Drop` trait also only has one method, `Drop::drop`, and
+ /// that function is by fiat not callable in user code. So there is really
+ /// no use case for using `Drop` in trait bounds.
+ ///
+ /// The most likely use case of a drop bound is to distinguish between
+ /// types that have destructors and types that don't. Combined with
+ /// specialization, a naive coder would write an implementation that
+ /// assumed a type could be trivially dropped, then write a specialization
+ /// for `T: Drop` that actually calls the destructor. Except that doing so
+ /// is not correct; String, for example, doesn't actually implement Drop,
+ /// but because String contains a Vec, assuming it can be trivially dropped
+ /// will leak memory.
+ pub DROP_BOUNDS,
+ Warn,
+ "bounds of the form `T: Drop` are useless"
+}
+
+declare_lint_pass!(
+ /// Lint for bounds of the form `T: Drop`, which usually
+ /// indicate an attempt to emulate `std::mem::needs_drop`.
+ DropTraitConstraints => [DROP_BOUNDS]
+);
+
+impl<'tcx> LateLintPass<'tcx> for DropTraitConstraints {
+ fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
+ use rustc_middle::ty::PredicateAtom::*;
+
+ let def_id = cx.tcx.hir().local_def_id(item.hir_id);
+ let predicates = cx.tcx.explicit_predicates_of(def_id);
+ for &(predicate, span) in predicates.predicates {
+ let trait_predicate = match predicate.skip_binders() {
+ Trait(trait_predicate, _constness) => trait_predicate,
+ _ => continue,
+ };
+ let def_id = trait_predicate.trait_ref.def_id;
+ if cx.tcx.lang_items().drop_trait() == Some(def_id) {
+ // Explicitly allow `impl Drop`, a drop-guards-as-Voldemort-type pattern.
+ if trait_predicate.trait_ref.self_ty().is_impl_trait() {
+ continue;
+ }
+ cx.struct_span_lint(DROP_BOUNDS, span, |lint| {
+ let needs_drop = match cx.tcx.get_diagnostic_item(sym::needs_drop) {
+ Some(needs_drop) => needs_drop,
+ None => return,
+ };
+ let msg = format!(
+ "bounds on `{}` are useless, consider instead \
+ using `{}` to detect if a type has a destructor",
+ predicate,
+ cx.tcx.def_path_str(needs_drop)
+ );
+ lint.build(&msg).emit()
+ });
+ }
+ }
+ }
+}
--- /dev/null
+error: bounds on `T: Drop` are useless, consider instead using `std::mem::needs_drop` to detect if a type has a destructor
+ --> $DIR/drop-bounds.rs:2:11
+ |
+LL | fn foo<T: Drop>() {}
+ | ^^^^
+ |
+note: the lint level is defined here
+ --> $DIR/drop-bounds.rs:1:9
+ |
+LL | #![deny(drop_bounds)]
+ | ^^^^^^^^^^^
+
+error: bounds on `U: Drop` are useless, consider instead using `std::mem::needs_drop` to detect if a type has a destructor
+ --> $DIR/drop-bounds.rs:5:8
+ |
+LL | U: Drop,
+ | ^^^^
+
+error: bounds on `impl Drop: Drop` are useless, consider instead using `std::mem::needs_drop` to detect if a type has a destructor
+ --> $DIR/drop-bounds.rs:8:17
+ |
+LL | fn baz(_x: impl Drop) {}
+ | ^^^^
+
+error: bounds on `T: Drop` are useless, consider instead using `std::mem::needs_drop` to detect if a type has a destructor
+ --> $DIR/drop-bounds.rs:9:15
+ |
+LL | struct Foo<T: Drop> {
+ | ^^^^
+
+error: bounds on `U: Drop` are useless, consider instead using `std::mem::needs_drop` to detect if a type has a destructor
+ --> $DIR/drop-bounds.rs:12:24
+ |
+LL | struct Bar<U> where U: Drop {
+ | ^^^^
+
+error: bounds on `Self: Drop` are useless, consider instead using `std::mem::needs_drop` to detect if a type has a destructor
+ --> $DIR/drop-bounds.rs:15:12
+ |
+LL | trait Baz: Drop {
+ | ^^^^
+
+error: bounds on `T: Drop` are useless, consider instead using `std::mem::needs_drop` to detect if a type has a destructor
+ --> $DIR/drop-bounds.rs:17:9
+ |
+LL | impl<T: Drop> Baz for T {
+ | ^^^^
+
+error: aborting due to 7 previous errors
+