Provide different suggestions for constructors.

clippy_lints/src/derive.rs

@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note, span_lint_and_then};
 use clippy_utils::paths;
 use clippy_utils::ty::{implements_trait, is_copy};
-use clippy_utils::{get_trait_def_id, is_automatically_derived, is_diagnostic_item, is_lint_allowed, match_def_path};
+use clippy_utils::{get_trait_def_id, is_automatically_derived, is_lint_allowed, match_def_path};
 use if_chain::if_chain;
 use rustc_hir::intravisit::{walk_expr, walk_fn, walk_item, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::{
@@ -197,7 +197,7 @@ fn check_hash_peq<'tcx>(
  if_chain! {
  if let Some(peq_trait_def_id) = cx.tcx.lang_items().eq_trait();
  if let Some(def_id) = trait_ref.trait_def_id();
- if is_diagnostic_item(cx, def_id, sym::Hash);
+ if cx.tcx.is_diagnostic_item(sym::Hash, def_id);
  then {
  // Look for the PartialEq implementations for `ty`
  cx.tcx.for_each_relevant_impl(peq_trait_def_id, ty, |impl_id| {

clippy_lints/src/drop_forget_ref.rs

@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_note;
-use clippy_utils::is_diagnostic_item;
 use clippy_utils::ty::is_copy;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
@@ -118,49 +117,36 @@ declare_lint_pass!(DropForgetRef => [DROP_REF, FORGET_REF, DROP_COPY, FORGET_COP
 impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
  fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  if_chain! {
- if let ExprKind::Call(path, args) = expr.kind;
+ if let ExprKind::Call(path, [arg]) = expr.kind;
  if let ExprKind::Path(ref qpath) = path.kind;
- if args.len() == 1;
  if let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id();
  then {
- let lint;
- let msg;
- let arg = &args[0];
  let arg_ty = cx.typeck_results().expr_ty(arg);
 
- if let ty::Ref(..) = arg_ty.kind() {
- if is_diagnostic_item(cx, def_id, sym::mem_drop) {
- lint = DROP_REF;
- msg = DROP_REF_SUMMARY.to_string();
- } else if is_diagnostic_item(cx, def_id, sym::mem_forget) {
- lint = FORGET_REF;
- msg = FORGET_REF_SUMMARY.to_string();
- } else {
- return;
+ let (lint, msg) = if let ty::Ref(..) = arg_ty.kind() {
+ match cx.tcx.get_diagnostic_name(def_id) {
+ Some(sym::mem_drop) => (DROP_REF, DROP_REF_SUMMARY),
+ Some(sym::mem_forget) => (FORGET_REF, FORGET_REF_SUMMARY),
+ _ => return,
  }
- span_lint_and_note(cx,
- lint,
- expr.span,
- &msg,
- Some(arg.span),
- &format!("argument has type `{}`", arg_ty));
  } else if is_copy(cx, arg_ty) {
- if is_diagnostic_item(cx, def_id, sym::mem_drop) {
- lint = DROP_COPY;
- msg = DROP_COPY_SUMMARY.to_string();
- } else if is_diagnostic_item(cx, def_id, sym::mem_forget) {
- lint = FORGET_COPY;
- msg = FORGET_COPY_SUMMARY.to_string();
- } else {
- return;
+ match cx.tcx.get_diagnostic_name(def_id) {
+ Some(sym::mem_drop) => (DROP_COPY, DROP_COPY_SUMMARY),
+ Some(sym::mem_forget) => (FORGET_COPY, FORGET_COPY_SUMMARY),
+ _ => return,
  }
- span_lint_and_note(cx,
- lint,
- expr.span,
- &msg,
- Some(arg.span),
- &format!("argument has type {}", arg_ty));
- }
+ } else {
+ return;
+ };
+
+ span_lint_and_note(
+ cx,
+ lint,
+ expr.span,
+ msg,
+ Some(arg.span),
+ &format!("argument has type `{}`", arg_ty)
+ );
  }
  }
  }

clippy_lints/src/infinite_iter.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-use clippy_utils::{get_trait_def_id, higher, is_diagnostic_item, paths};
+use clippy_utils::{get_trait_def_id, higher, paths};
 use rustc_hir::{BorrowKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -171,7 +171,7 @@ fn is_infinite(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
  if let ExprKind::Path(ref qpath) = path.kind {
  cx.qpath_res(qpath, path.hir_id)
  .opt_def_id()
- .map_or(false, |id| is_diagnostic_item(cx, id, sym::iter_repeat))
+ .map_or(false, |id| cx.tcx.is_diagnostic_item(sym::iter_repeat, id))
  .into()
  } else {
  Finite

clippy_lints/src/loops/while_let_on_iterator.rs

@@ -2,21 +2,20 @@ use super::WHILE_LET_ON_ITERATOR;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{get_enclosing_loop_or_closure, is_lang_item, is_refutable, is_trait_method, visitors::is_res_used};
+use clippy_utils::{get_enclosing_loop_or_closure, is_lang_ctor, is_refutable, is_trait_method, visitors::is_res_used};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_expr, ErasedMap, NestedVisitorMap, Visitor};
-use rustc_hir::{def::Res, Expr, ExprKind, HirId, LangItem, Local, PatKind, QPath, UnOp};
+use rustc_hir::{def::Res, Expr, ExprKind, HirId, LangItem, Local, PatKind, UnOp};
 use rustc_lint::LateContext;
 use rustc_span::{symbol::sym, Span, Symbol};
 
 pub(super) fn check(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  let (scrutinee_expr, iter_expr, some_pat, loop_expr) = if_chain! {
  if let Some(higher::WhileLet { if_then, let_pat, let_expr }) = higher::WhileLet::hir(expr);
  // check for `Some(..)` pattern
- if let PatKind::TupleStruct(QPath::Resolved(None, pat_path), some_pat, _) = let_pat.kind;
- if let Res::Def(_, pat_did) = pat_path.res;
- if is_lang_item(cx, pat_did, LangItem::OptionSome);
+ if let PatKind::TupleStruct(ref pat_path, some_pat, _) = let_pat.kind;
+ if is_lang_ctor(cx, pat_path, LangItem::OptionSome);
  // check for call to `Iterator::next`
  if let ExprKind::MethodCall(method_name, _, [iter_expr], _) = let_expr.kind;
  if method_name.ident.name == sym::next;

clippy_lints/src/mem_forget.rs

@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::is_diagnostic_item;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
@@ -33,7 +32,7 @@ impl<'tcx> LateLintPass<'tcx> for MemForget {
  if let ExprKind::Call(path_expr, [ref first_arg, ..]) = e.kind {
  if let ExprKind::Path(ref qpath) = path_expr.kind {
  if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id() {
- if is_diagnostic_item(cx, def_id, sym::mem_forget) {
+ if cx.tcx.is_diagnostic_item(sym::mem_forget, def_id) {
  let forgot_ty = cx.typeck_results().expr_ty(first_arg);
 
  if forgot_ty.ty_adt_def().map_or(false, |def| def.has_dtor(cx.tcx)) {

clippy_lints/src/mem_replace.rs

@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_non_aggregate_primitive_type;
-use clippy_utils::{is_default_equivalent, is_diagnostic_item, is_lang_ctor, meets_msrv, msrvs};
+use clippy_utils::{is_default_equivalent, is_lang_ctor, meets_msrv, msrvs};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::OptionNone;
@@ -249,7 +249,7 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
  if let ExprKind::Call(func, func_args) = expr.kind;
  if let ExprKind::Path(ref func_qpath) = func.kind;
  if let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id();
- if is_diagnostic_item(cx, def_id, sym::mem_replace);
+ if cx.tcx.is_diagnostic_item(sym::mem_replace, def_id);
  if let [dest, src] = func_args;
  then {
  check_replace_option_with_none(cx, src, dest, expr.span);

clippy_lints/src/methods/inefficient_to_string.rs

@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_type_diagnostic_item, walk_ptrs_ty_depth};
-use clippy_utils::{is_diagnostic_item, match_def_path, paths};
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -60,7 +60,7 @@ fn specializes_tostring(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
  }
 
  if let ty::Adt(adt, substs) = ty.kind() {
- is_diagnostic_item(cx, adt.did, sym::Cow) && substs.type_at(1).is_str()
+ cx.tcx.is_diagnostic_item(sym::Cow, adt.did) && substs.type_at(1).is_str()
  } else {
  false
  }

clippy_lints/src/minmax.rs

@@ -1,6 +1,6 @@
 use clippy_utils::consts::{constant_simple, Constant};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_diagnostic_item, is_trait_method};
+use clippy_utils::is_trait_method;
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -74,14 +74,10 @@ fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Cons
  cx.typeck_results()
  .qpath_res(qpath, path.hir_id)
  .opt_def_id()
- .and_then(|def_id| {
- if is_diagnostic_item(cx, def_id, sym::cmp_min) {
- fetch_const(cx, args, MinMax::Min)
- } else if is_diagnostic_item(cx, def_id, sym::cmp_max) {
- fetch_const(cx, args, MinMax::Max)
- } else {
- None
- }
+ .and_then(|def_id| match cx.tcx.get_diagnostic_name(def_id) {
+ Some(sym::cmp_min) => fetch_const(cx, args, MinMax::Min),
+ Some(sym::cmp_max) => fetch_const(cx, args, MinMax::Max),
+ _ => None,
  })
  } else {
  None

clippy_lints/src/redundant_clone.rs

@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::{has_drop, is_copy, is_type_diagnostic_item, walk_ptrs_ty_depth};
-use clippy_utils::{fn_has_unsatisfiable_preds, is_lang_item, match_def_path, paths};
+use clippy_utils::{fn_has_unsatisfiable_preds, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_data_structures::{fx::FxHashMap, transitive_relation::TransitiveRelation};
 use rustc_errors::Applicability;
@@ -135,7 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
  }
 
  if let ty::Adt(def, _) = arg_ty.kind() {
- if is_lang_item(cx, def.did, LangItem::ManuallyDrop) {
+ if cx.tcx.lang_items().require(LangItem::ManuallyDrop).ok() == Some(def.did) {
  continue;
  }
  }

clippy_lints/src/size_of_in_element_count.rs

@@ -2,7 +2,7 @@
 //! expecting a count of T
 
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::{is_diagnostic_item, match_def_path, paths};
+use clippy_utils::{match_def_path, paths};
 use if_chain::if_chain;
 use rustc_hir::BinOpKind;
 use rustc_hir::{Expr, ExprKind};
@@ -45,8 +45,7 @@ fn get_size_of_ty(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: bool)
  if !inverted;
  if let ExprKind::Path(ref count_func_qpath) = count_func.kind;
  if let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id();
- if is_diagnostic_item(cx, def_id, sym::mem_size_of)
- || is_diagnostic_item(cx, def_id, sym::mem_size_of_val);
+ if matches!(cx.tcx.get_diagnostic_name(def_id), Some(sym::mem_size_of | sym::mem_size_of_val));
  then {
  cx.typeck_results().node_substs(count_func.hir_id).types().next()
  } else {

clippy_lints/src/to_string_in_display.rs

@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::{is_diag_trait_item, is_diagnostic_item, path_to_local_id};
+use clippy_utils::{is_diag_trait_item, path_to_local_id};
 use if_chain::if_chain;
 use rustc_hir::{Expr, ExprKind, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -115,7 +115,7 @@ fn is_display_impl(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
  if let ItemKind::Impl(Impl { of_trait: Some(trait_ref), .. }) = &item.kind;
  if let Some(did) = trait_ref.trait_def_id();
  then {
- is_diagnostic_item(cx, did, sym::Display)
+ cx.tcx.is_diagnostic_item(sym::Display, did)
  } else {
  false
  }

clippy_lints/src/types/borrowed_box.rs

@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_diagnostic_item;
 use clippy_utils::source::snippet;
 
 use if_chain::if_chain;
@@ -91,7 +90,7 @@ fn is_any_trait(cx: &LateContext<'_>, t: &hir::Ty<'_>) -> bool {
  if let Some(trait_did) = traits[0].trait_ref.trait_def_id();
  // Only Send/Sync can be used as additional traits, so it is enough to
  // check only the first trait.
- if is_diagnostic_item(cx, trait_did, sym::Any);
+ if cx.tcx.is_diagnostic_item(sym::Any, trait_did);
  then {
  return true;
  }

clippy_lints/src/useless_conversion.rs

@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
 use clippy_utils::source::{snippet, snippet_with_macro_callsite};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, same_type_and_consts};
-use clippy_utils::{get_parent_expr, is_lang_item, is_trait_method, match_def_path, paths};
+use clippy_utils::{get_parent_expr, is_trait_method, match_def_path, paths};
 use if_chain::if_chain;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, HirId, LangItem, MatchSource};
@@ -154,7 +154,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion {
  }
 
  if_chain! {
- if is_lang_item(cx, def_id, LangItem::FromFrom);
+ if cx.tcx.lang_items().require(LangItem::FromFrom).ok() == Some(def_id);
  if same_type_and_consts(a, b);
 
  then {