X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Finherent_to_string.rs;h=b62fad4bd39585e049fc5eef3428be53780bc875;hb=d9c3f0d69029cd9ffd97fe2d1b7a3701ea0ac51a;hp=10fe8f28eababd0ead11e36ff5f880c10f13dbae;hpb=5e722ba670c7223c6048fb4e9c1d4833515d16d0;p=rust.git diff --git a/clippy_lints/src/inherent_to_string.rs b/clippy_lints/src/inherent_to_string.rs index 10fe8f28eab..b62fad4bd39 100644 --- a/clippy_lints/src/inherent_to_string.rs +++ b/clippy_lints/src/inherent_to_string.rs @@ -1,22 +1,23 @@ +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}; use rustc_session::{declare_lint_pass, declare_tool_lint}; - -use crate::utils::{ - get_trait_def_id, implements_trait, match_type, paths, return_ty, span_lint_and_help, trait_ref_of_method, - walk_ptrs_ty, -}; +use rustc_span::sym; declare_clippy_lint! { - /// **What it 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. + /// ### What it does + /// Checks for the definition of inherent methods with a signature of `to_string(&self) -> String`. /// - /// **Known problems:** None + /// ### 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:** + /// ### Known problems + /// None /// + /// ### Example /// ```rust /// // Bad /// pub struct A; @@ -46,14 +47,16 @@ } declare_clippy_lint! { - /// **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. - /// - /// **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`. + /// ### 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. /// - /// **Known problems:** None + /// ### 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:** + /// ### Known problems + /// None /// + /// ### Example /// ```rust /// // Bad /// use std::fmt; @@ -92,25 +95,26 @@ 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 let ImplItemKind::Fn(ref signature, _) = impl_item.kind; if impl_item.ident.name.as_str() == "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_type); // 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.hir_id()).is_none(); then { show_lint(cx, impl_item); @@ -119,14 +123,12 @@ 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, &[]) { @@ -138,7 +140,8 @@ fn show_lint(cx: &LateContext<'_, '_>, item: &ImplItem<'_>) { "type `{}` implements inherent method `to_string(&self) -> String` which shadows the implementation of `Display`", self_type.to_string() ), - &format!("remove the inherent method from type `{}`", self_type.to_string()) + None, + &format!("remove the inherent method from type `{}`", self_type.to_string()), ); } else { span_lint_and_help( @@ -149,6 +152,7 @@ fn show_lint(cx: &LateContext<'_, '_>, item: &ImplItem<'_>) { "implementation of inherent method `to_string(&self) -> String` for type `{}`", self_type.to_string() ), + None, &format!("implement trait `Display` for type `{}` instead", self_type.to_string()), ); }