X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Finherent_to_string.rs;h=694f646c707cc2590e99ffd5bf16308e98aba06b;hb=a2c6252cd33d125a670be991dd17a11745bfbe72;hp=b92a99488f9de80ed4f95fb70e431d7d21c01b50;hpb=4bbd10a585616dd9d7027d16d7f8e6b8ece9e325;p=rust.git diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs index b92a99488f9..694f646c707 100644 --- a/clippy_lints/src/inherent_to_string.rs +++ b/clippy_lints/src/inherent_to_string.rs @@ -1,24 +1,21 @@ +use clippy_utils::diagnostics::span_lint_and_help; +use clippy_utils::ty::{implements_trait, is_type_diagnostic_item}; +use clippy_utils::{get_trait_def_id, paths, return_ty, trait_ref_of_method}; use if_chain::if_chain; -use rustc::hir::{ImplItem, ImplItemKind}; -use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use rustc::{declare_lint_pass, declare_tool_lint}; - -use crate::utils::{ - get_trait_def_id, implements_trait, match_type, paths, return_ty, span_help_and_lint, trait_ref_of_method, - walk_ptrs_ty, -}; +use rustc_hir::{ImplItem, ImplItemKind}; +use rustc_lint::{LateContext, LateLintPass}; +use rustc_session::{declare_lint_pass, declare_tool_lint}; +use rustc_span::sym; declare_clippy_lint! { - /// **What id does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`. - /// - /// **Why is this bad?** This method is also implicitly defined if a type implements the `Display` trait. As the functionality of `Display` is much more versatile, it should be preferred. - /// - /// **Known problems:** None + /// ### What it does + /// Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`. /// - /// ** Example:** + /// ### Why is this bad? + /// This method is also implicitly defined if a type implements the `Display` trait. As the functionality of `Display` is much more versatile, it should be preferred. /// + /// ### Example /// ```rust - /// // Bad /// pub struct A; /// /// impl A { @@ -28,8 +25,8 @@ /// } /// ``` /// + /// Use instead: /// ```rust - /// // Good /// use std::fmt; /// /// pub struct A; @@ -40,22 +37,21 @@ /// } /// } /// ``` + #[clippy::version = "1.38.0"] pub INHERENT_TO_STRING, style, "type implements inherent method `to_string()`, but should instead implement the `Display` trait" } declare_clippy_lint! { - /// **What id does:** Checks for the definition of inherent methods with a signature of `to_string(&self) -> String` and if the type implementing this method also implements the `Display` trait. - /// - /// **Why is this bad?** This method is also implicitly defined if a type implements the `Display` trait. The less versatile inherent method will then shadow the implementation introduced by `Display`. - /// - /// **Known problems:** None + /// ### What it does + /// Checks for the definition of inherent methods with a signature of `to_string(&self) -> String` and if the type implementing this method also implements the `Display` trait. /// - /// ** Example:** + /// ### Why is this bad? + /// This method is also implicitly defined if a type implements the `Display` trait. The less versatile inherent method will then shadow the implementation introduced by `Display`. /// + /// ### Example /// ```rust - /// // Bad /// use std::fmt; /// /// pub struct A; @@ -73,8 +69,8 @@ /// } /// ``` /// + /// Use instead: /// ```rust - /// // Good /// use std::fmt; /// /// pub struct A; @@ -85,32 +81,34 @@ /// } /// } /// ``` + #[clippy::version = "1.38.0"] pub INHERENT_TO_STRING_SHADOW_DISPLAY, correctness, - "type implements inherent method `to_string()`, which gets shadowed by the implementation of the `Display` trait " + "type implements inherent method `to_string()`, which gets shadowed by the implementation of the `Display` trait" } declare_lint_pass!(InherentToString => [INHERENT_TO_STRING, INHERENT_TO_STRING_SHADOW_DISPLAY]); -impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InherentToString { - fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx ImplItem) { +impl<'tcx> LateLintPass<'tcx> for InherentToString { + fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) { if impl_item.span.from_expansion() { return; } if_chain! { // Check if item is a method, called to_string and has a parameter 'self' - if let ImplItemKind::Method(ref signature, _) = impl_item.kind; - if impl_item.ident.name.as_str() == "to_string"; + if let ImplItemKind::Fn(ref signature, _) = impl_item.kind; + if impl_item.ident.name == sym::to_string; let decl = &signature.decl; if decl.implicit_self.has_implicit_self(); if decl.inputs.len() == 1; + if impl_item.generics.params.is_empty(); // Check if return type is String - if match_type(cx, return_ty(cx, impl_item.hir_id), &paths::STRING); + if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id()), sym::String); // Filters instances of to_string which are required by a trait - if trait_ref_of_method(cx, impl_item.hir_id).is_none(); + if trait_ref_of_method(cx, impl_item.def_id).is_none(); then { show_lint(cx, impl_item); @@ -119,37 +117,37 @@ fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx ImplI } } -fn show_lint(cx: &LateContext<'_, '_>, item: &ImplItem) { - let display_trait_id = - get_trait_def_id(cx, &["core", "fmt", "Display"]).expect("Failed to get trait ID of `Display`!"); +fn show_lint(cx: &LateContext<'_>, item: &ImplItem<'_>) { + let display_trait_id = get_trait_def_id(cx, &paths::DISPLAY_TRAIT).expect("Failed to get trait ID of `Display`!"); // Get the real type of 'self' - let fn_def_id = cx.tcx.hir().local_def_id(item.hir_id); - let self_type = cx.tcx.fn_sig(fn_def_id).input(0); - let self_type = walk_ptrs_ty(self_type.skip_binder()); + let self_type = cx.tcx.fn_sig(item.def_id).input(0); + let self_type = self_type.skip_binder().peel_refs(); // Emit either a warning or an error if implements_trait(cx, self_type, display_trait_id, &[]) { - span_help_and_lint( + span_lint_and_help( cx, INHERENT_TO_STRING_SHADOW_DISPLAY, item.span, &format!( "type `{}` implements inherent method `to_string(&self) -> String` which shadows the implementation of `Display`", - self_type.to_string() + self_type ), - &format!("remove the inherent method from type `{}`", self_type.to_string()) + None, + &format!("remove the inherent method from type `{}`", self_type), ); } else { - span_help_and_lint( + span_lint_and_help( cx, INHERENT_TO_STRING, item.span, &format!( "implementation of inherent method `to_string(&self) -> String` for type `{}`", - self_type.to_string() + self_type ), - &format!("implement trait `Display` for type `{}` instead", self_type.to_string()), + None, + &format!("implement trait `Display` for type `{}` instead", self_type), ); } }