diff --git a/book/src/development/method_checking.md b/book/src/development/method_checking.md
index 604fcf193df..c93af6f21d2 100644
--- a/book/src/development/method_checking.md
+++ b/book/src/development/method_checking.md
@@ -4,56 +4,58 @@ In some scenarios we might want to check for methods when developing
 a lint. There are two kinds of questions that we might be curious about:
 
 - Invocation: Does an expression call a specific method?
-- Definition: Does the type `Ty` of an expression define a method?
+- Definition: Does an `impl` define a method?
 
 ## Checking if an `expr` is calling a specific method
 
 Suppose we have an `expr`, we can check whether it calls a specific
 method, e.g. `our_fancy_method`, by performing a pattern match on
-the [ExprKind] that we can access from `expr.kind`:
+the [`ExprKind`] that we can access from `expr.kind`:
 
 ```rust
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_span::sym;
+use clippy_utils::is_trait_method;
 
 impl<'tcx> LateLintPass<'tcx> for OurFancyMethodLint {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
         // Check our expr is calling a method with pattern matching
-        if let hir::ExprKind::MethodCall(path, _, [_self_arg, ..]) = &expr.kind
+        if let hir::ExprKind::MethodCall(path, _, [self_arg, ..]) = &expr.kind
             // Check if the name of this method is `our_fancy_method`
             && path.ident.name == sym!(our_fancy_method)
             // We can check the type of the self argument whenever necessary.
-			// (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 "Type Checking" chapter of the Clippy book for more information.
+            // (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)
         {
-                println!("`expr` is a method call for `our_fancy_method`");
+            println!("`expr` is a method call for `our_fancy_method`");
         }
     }
 }
 ```
 
-Take a closer look at the `ExprKind` enum variant [MethodCall] for more
+Take a closer look at the `ExprKind` enum variant [`MethodCall`] for more
 information on the pattern matching.
 As mentioned in [Define Lints](define_lints.md#lint-types),
 the `methods` lint type is full of pattern matching with `Methodcall`
 in case the reader wishes to explore more.
 
 Additionally, we use the [`clippy_utils::sym!`][sym] macro to conveniently convert
-an input `our_fancy_method` into a `Symbol` and compare that symbol to the [ident][Ident]'s name in the [PathSegment]
-in the [MethodCall].
+an input `our_fancy_method` into a `Symbol` and compare that symbol to the [`ident`][Ident]'s name in the [`PathSegment`]
+in the [`MethodCall`].
 
-## Checking if a type defines a specific method
+## Checking if a `impl` block implements a method
 
 While sometimes we want to check whether a method is being called or not,
-other times we want to know if our type `Ty` defines a method.
+other times we want to know if our `Ty` defines a method.
 
-To check if our type defines a method called `our_fancy_method`,
-we will utilize the [check_impl_item] method that is available
-in our beloved [LateLintPass] (for more information, refer to the
+To check if our `impl` block defines a method `our_fancy_method`,
+we will utilize the [`check_impl_item`] method that is available
+in our beloved [`LateLintPass`] (for more information, refer to the
 ["Lint Passes"](lint_passes.md) chapter in Clippy book).
-This method provides us with an [ImplItem] struct, which represents
+This method provides us with an [`ImplItem`] struct, which represents
 anything within an `impl` block.
 
 Let us take a look at how we might check for the implementation of
@@ -65,7 +67,6 @@ use clippy_utils::return_ty;
 use rustc_hir::{ImplItem, ImplItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_span::symbol::sym;
-
 impl<'tcx> LateLintPass<'tcx> for MyTypeImpl {
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
         // Check if item is a method/function
@@ -83,11 +84,11 @@ impl<'tcx> LateLintPass<'tcx> for MyTypeImpl {
 }
 ```
 
-[check_impl_item]: https://doc.rust-lang.org/stable/nightly-rustc/rustc_lint/trait.LateLintPass.html#method.check_impl_item
-[ExprKind]: https://doc.rust-lang.org/beta/nightly-rustc/rustc_hir/hir/enum.ExprKind.html
+[`check_impl_item`]: https://doc.rust-lang.org/stable/nightly-rustc/rustc_lint/trait.LateLintPass.html#method.check_impl_item
+[`ExprKind`]: https://doc.rust-lang.org/beta/nightly-rustc/rustc_hir/hir/enum.ExprKind.html
 [Ident]: https://doc.rust-lang.org/beta/nightly-rustc/rustc_span/symbol/struct.Ident.html
-[ImplItem]: https://doc.rust-lang.org/stable/nightly-rustc/rustc_hir/hir/struct.ImplItem.html
-[LateLintPass]: https://doc.rust-lang.org/stable/nightly-rustc/rustc_lint/trait.LateLintPass.html
-[MethodCall]: https://doc.rust-lang.org/beta/nightly-rustc/rustc_hir/hir/enum.ExprKind.html#variant.MethodCall
-[PathSegment]: https://doc.rust-lang.org/beta/nightly-rustc/rustc_hir/hir/struct.PathSegment.html
+[`ImplItem`]: https://doc.rust-lang.org/stable/nightly-rustc/rustc_hir/hir/struct.ImplItem.html
+[`LateLintPass`]: https://doc.rust-lang.org/stable/nightly-rustc/rustc_lint/trait.LateLintPass.html
+[`MethodCall`]: https://doc.rust-lang.org/beta/nightly-rustc/rustc_hir/hir/enum.ExprKind.html#variant.MethodCall
+[`PathSegment`]: https://doc.rust-lang.org/beta/nightly-rustc/rustc_hir/hir/struct.PathSegment.html
 [sym]: https://doc.rust-lang.org/stable/nightly-rustc/clippy_utils/macro.sym.html