Add new utils for defninition identification.

Author: Jarcho

book/src/development/adding_lints.md

@@ -759,8 +759,7 @@ for some users. Adding a configuration is done in the following steps:
 Here are some pointers to things you are likely going to need for every lint:
 
 * [Clippy utils][utils] - Various helper functions. Maybe the function you need
-  is already in here ([`is_type_diagnostic_item`], [`implements_trait`],
-  [`snippet`], etc)
+  is already in here ([`implements_trait`], [`snippet`], etc)
 * [Clippy diagnostics][diagnostics]
 * [Let chains][let-chains]
 * [`from_expansion`][from_expansion] and
@@ -790,7 +789,6 @@ get away with copying things from existing similar lints. If you are stuck,
 don't hesitate to ask on [Zulip] or in the issue/PR.
 
 [utils]: https://doc.rust-lang.org/nightly/nightly-rustc/clippy_utils/index.html
-[`is_type_diagnostic_item`]: https://doc.rust-lang.org/nightly/nightly-rustc/clippy_utils/ty/fn.is_type_diagnostic_item.html
 [`implements_trait`]: https://doc.rust-lang.org/nightly/nightly-rustc/clippy_utils/ty/fn.implements_trait.html
 [`snippet`]: https://doc.rust-lang.org/nightly/nightly-rustc/clippy_utils/source/fn.snippet.html
 [let-chains]: https://github.com/rust-lang/rust/pull/94927

book/src/development/common_tools_writing_lints.md

@@ -85,8 +85,8 @@ to check for. All of these methods only check for the base type, generic
 arguments have to be checked separately.
 
 ```rust
-use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
 use clippy_utils::paths;
+use clippy_utils::res::MaybeDef;
 use rustc_span::symbol::sym;
 use rustc_hir::LangItem;
 
@@ -97,12 +97,12 @@ impl LateLintPass<'_> for MyStructLint {
 
         // 1. Using diagnostic items
         // The last argument is the diagnostic item to check for
-        if is_type_diagnostic_item(cx, ty, sym::Option) {
+        if ty.is_diag_item(cx, sym::Option) {
             // The type is an `Option`
         }
 
         // 2. Using lang items
-        if is_type_lang_item(cx, ty, LangItem::RangeFull) {
+        if ty.is_lang_item(cx, LangItem::RangeFull) {
             // The type is a full range like `.drain(..)`
         }
 
@@ -124,26 +124,28 @@ diagnostic item, lang item or neither.
 
 ```rust
 use clippy_utils::ty::implements_trait;
-use clippy_utils::is_trait_method;
 use rustc_span::symbol::sym;
 
 impl LateLintPass<'_> for MyStructLint {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        // 1. Using diagnostic items with the expression
-        // we use `is_trait_method` function from Clippy's utils
-        if is_trait_method(cx, expr, sym::Iterator) {
-            // method call in `expr` belongs to `Iterator` trait
-        }
 
-        // 2. Using lang items with the expression type
+        // 1. Get the `DefId` of the trait.
+        // via lang items
+        let trait_id = cx.tcx.lang_items().drop_trait();
+        // via diagnostic items
+        let trait_id = cx.tcx.get_diagnostic_item(sym::Eq);
+
+        // 2. Check for the trait implementation via the `implements_trait` util.
         let ty = cx.typeck_results().expr_ty(expr);
-        if cx.tcx.lang_items()
-            // we are looking for the `DefId` of `Drop` trait in lang items
-            .drop_trait()
-            // then we use it with our type `ty` by calling `implements_trait` from Clippy's utils
-            .is_some_and(|id| implements_trait(cx, ty, id, &[])) {
-                // `expr` implements `Drop` trait
-            }
+        if trait_id.is_some_and(|id| implements_trait(cx, ty, id, &[])) {
+            // `ty` implements the trait.
+        }
+
+        // 3. If the trait requires additional generic arguments
+        let trait_id = cx.tcx.lang_items().eq_trait();
+        if trait_id.is_some_and(|id| implements_trait(cx, ty, id, &[ty])) {
+            // `ty` implements `PartialEq<Self>`
+        }
     }
 }
 ```
@@ -159,7 +161,7 @@ paths for Clippy can be found in [paths.rs][paths]
 To check if our type defines a method called `some_method`:
 
 ```rust
-use clippy_utils::ty::is_type_lang_item;
+use clippy_utils::res::MaybeDef;
 use clippy_utils::{sym, return_ty};
 
 impl<'tcx> LateLintPass<'tcx> for MyTypeImpl {
@@ -173,7 +175,7 @@ impl<'tcx> LateLintPass<'tcx> for MyTypeImpl {
             // We can also check it has a parameter `self`
             && signature.decl.implicit_self.has_implicit_self()
             // We can go further and even check if its return type is `String`
-            && is_type_lang_item(cx, return_ty(cx, impl_item.hir_id), LangItem::String)
+            && return_ty(cx, impl_item.hir_id).is_lang_item(cx, LangItem::String)
         {
             // ...
         }

book/src/development/method_checking.md

@@ -16,7 +16,7 @@ the [`ExprKind`] that we can access from `expr.kind`:
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_span::sym;
-use clippy_utils::is_trait_method;
+use clippy_utils::res::{MaybeDef, MaybeTypeckRes};
 
 impl<'tcx> LateLintPass<'tcx> for OurFancyMethodLint {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
@@ -28,7 +28,7 @@ impl<'tcx> LateLintPass<'tcx> for OurFancyMethodLint {
             // (It's necessary if we want to check that method is specifically belonging to a specific trait,
             // for example, a `map` method could belong to user-defined trait instead of to `Iterator`)
             // See the next section for more information.
-            && is_trait_method(cx, self_arg, sym::OurFancyTrait)
+            && cx.ty_based_def(self_arg).opt_parent(cx).is_diag_item(cx, sym::OurFancyTrait)
         {
             println!("`expr` is a method call for `our_fancy_method`");
         }
@@ -56,7 +56,7 @@ Let us take a look at how we might check for the implementation of
 `our_fancy_method` on a type:
 
 ```rust
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::res::MaybeDef;
 use clippy_utils::return_ty;
 use rustc_hir::{ImplItem, ImplItemKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -71,7 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for MyTypeImpl {
             // We can also check it has a parameter `self`
             && signature.decl.implicit_self.has_implicit_self()
             // We can go even further and even check if its return type is `String`
-            && is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym::String)
+            && return_ty(cx, impl_item.hir_id).is_diag_item(cx, sym::String)
         {
             println!("`our_fancy_method` is implemented!");
         }

clippy_utils/src/lib.rs

@@ -66,6 +66,7 @@ pub mod msrvs;
 pub mod numeric_literal;
 pub mod paths;
 pub mod qualify_min_const_fn;
+pub mod res;
 pub mod source;
 pub mod str_utils;
 pub mod sugg;