1 use clippy_utils::diagnostics::span_lint_hir_and_then;
2 use rustc_data_structures::fx::FxHashMap;
3 use rustc_hir::def::{DefKind, Res};
4 use rustc_hir::{HirId, Impl, ItemKind, Node, Path, QPath, TraitRef, TyKind};
5 use rustc_lint::{LateContext, LateLintPass};
6 use rustc_middle::ty::AssocKind;
7 use rustc_session::{declare_lint_pass, declare_tool_lint};
8 use rustc_span::symbol::Symbol;
10 use std::collections::{BTreeMap, BTreeSet};
12 declare_clippy_lint! {
14 /// It lints if a struct has two methods with the same name:
15 /// one from a trait, another not from trait.
17 /// ### Why is this bad?
36 #[clippy::version = "1.57.0"]
39 "two method with same name"
42 declare_lint_pass!(SameNameMethod => [SAME_NAME_METHOD]);
45 impl_methods: BTreeMap<Symbol, (Span, HirId)>,
46 trait_methods: BTreeMap<Symbol, Vec<Span>>,
49 impl<'tcx> LateLintPass<'tcx> for SameNameMethod {
50 #[expect(clippy::too_many_lines)]
51 fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
52 let mut map = FxHashMap::<Res, ExistingName>::default();
54 for id in cx.tcx.hir().items() {
55 if matches!(cx.tcx.def_kind(id.def_id), DefKind::Impl)
56 && let item = cx.tcx.hir().item(id)
57 && let ItemKind::Impl(Impl {
63 && let TyKind::Path(QPath::Resolved(_, Path { res, .. })) = self_ty.kind
65 if !map.contains_key(res) {
69 impl_methods: BTreeMap::new(),
70 trait_methods: BTreeMap::new(),
74 let existing_name = map.get_mut(res).unwrap();
78 let mut methods_in_trait: BTreeSet<Symbol> = if_chain! {
79 if let Some(Node::TraitRef(TraitRef { path, .. })) =
80 cx.tcx.hir().find(trait_ref.hir_ref_id);
81 if let Res::Def(DefKind::Trait, did) = path.res;
84 // `rustc_middle::ty::assoc::AssocItems::items` is public,
85 // we can iterate its keys instead of `in_definition_order`,
86 // which's more efficient
88 .associated_items(did)
89 .in_definition_order()
90 .filter(|assoc_item| {
91 matches!(assoc_item.kind, AssocKind::Fn)
93 .map(|assoc_item| assoc_item.name)
100 let mut check_trait_method = |method_name: Symbol, trait_method_span: Span| {
101 if let Some((impl_span, hir_id)) = existing_name.impl_methods.get(&method_name) {
102 span_lint_hir_and_then(
107 "method's name is the same as an existing method in a trait",
111 &format!("existing `{}` defined here", method_name),
116 if let Some(v) = existing_name.trait_methods.get_mut(&method_name) {
117 v.push(trait_method_span);
119 existing_name.trait_methods.insert(method_name, vec![trait_method_span]);
123 for impl_item_ref in (*items).iter().filter(|impl_item_ref| {
124 matches!(impl_item_ref.kind, rustc_hir::AssocItemKind::Fn { .. })
126 let method_name = impl_item_ref.ident.name;
127 methods_in_trait.remove(&method_name);
128 check_trait_method(method_name, impl_item_ref.span);
131 for method_name in methods_in_trait {
132 check_trait_method(method_name, item.span);
136 for impl_item_ref in (*items).iter().filter(|impl_item_ref| {
137 matches!(impl_item_ref.kind, rustc_hir::AssocItemKind::Fn { .. })
139 let method_name = impl_item_ref.ident.name;
140 let impl_span = impl_item_ref.span;
141 let hir_id = impl_item_ref.id.hir_id();
142 if let Some(trait_spans) = existing_name.trait_methods.get(&method_name) {
143 span_lint_hir_and_then(
148 "method's name is the same as an existing method in a trait",
150 // TODO should we `span_note` on every trait?
151 // iterate on trait_spans?
154 &format!("existing `{}` defined here", method_name),
159 existing_name.impl_methods.insert(method_name, (impl_span, hir_id));