1 use clippy_utils::diagnostics::span_lint_and_sugg;
2 use clippy_utils::ty::same_type_and_consts;
3 use clippy_utils::{is_from_proc_macro, meets_msrv, msrvs};
4 use if_chain::if_chain;
5 use rustc_data_structures::fx::FxHashSet;
6 use rustc_errors::Applicability;
9 def::{CtorOf, DefKind, Res},
11 intravisit::{walk_inf, walk_ty, Visitor},
12 Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Pat, PatKind, Path, QPath,
15 use rustc_hir_analysis::hir_ty_to_ty;
16 use rustc_lint::{LateContext, LateLintPass};
17 use rustc_semver::RustcVersion;
18 use rustc_session::{declare_tool_lint, impl_lint_pass};
21 declare_clippy_lint! {
23 /// Checks for unnecessary repetition of structure name when a
24 /// replacement with `Self` is applicable.
26 /// ### Why is this bad?
27 /// Unnecessary repetition. Mixed use of `Self` and struct
29 /// feels inconsistent.
31 /// ### Known problems
32 /// - Unaddressed false negative in fn bodies of trait implementations
33 /// - False positive with associated types in traits (#4140)
48 /// fn new() -> Self {
53 #[clippy::version = "pre 1.29.0"]
56 "unnecessary structure name repetition whereas `Self` is applicable"
61 msrv: Option<RustcVersion>,
62 stack: Vec<StackItem>,
67 pub fn new(msrv: Option<RustcVersion>) -> Self {
80 types_to_skip: FxHashSet<HirId>,
85 impl_lint_pass!(UseSelf => [USE_SELF]);
87 const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
89 impl<'tcx> LateLintPass<'tcx> for UseSelf {
90 fn check_item(&mut self, cx: &LateContext<'tcx>, item: &Item<'tcx>) {
91 if matches!(item.kind, ItemKind::OpaqueTy(_)) {
92 // skip over `ItemKind::OpaqueTy` in order to lint `foo() -> impl <..>`
95 // We push the self types of `impl`s on a stack here. Only the top type on the stack is
96 // relevant for linting, since this is the self type of the `impl` we're currently in. To
97 // avoid linting on nested items, we push `StackItem::NoCheck` on the stack to signal, that
98 // we're in an `impl` or nested item, that we don't want to lint
99 let stack_item = if_chain! {
100 if let ItemKind::Impl(Impl { self_ty, .. }) = item.kind;
101 if let TyKind::Path(QPath::Resolved(_, item_path)) = self_ty.kind;
102 let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
103 if parameters.as_ref().map_or(true, |params| {
104 !params.parenthesized && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
106 if !is_from_proc_macro(cx, item); // expensive, should be last check
109 impl_id: item.def_id.def_id,
111 types_to_skip: std::iter::once(self_ty.hir_id).collect(),
117 self.stack.push(stack_item);
120 fn check_item_post(&mut self, _: &LateContext<'_>, item: &Item<'_>) {
121 if !matches!(item.kind, ItemKind::OpaqueTy(_)) {
126 fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
127 // We want to skip types in trait `impl`s that aren't declared as `Self` in the trait
128 // declaration. The collection of those types is all this method implementation does.
130 if let ImplItemKind::Fn(FnSig { decl, .. }, ..) = impl_item.kind;
131 if let Some(&mut StackItem::Check {
133 ref mut types_to_skip,
135 }) = self.stack.last_mut();
136 if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_id);
138 // `self_ty` is the semantic self type of `impl <trait> for <type>`. This cannot be
140 let self_ty = impl_trait_ref.self_ty();
142 // `trait_method_sig` is the signature of the function, how it is declared in the
143 // trait, not in the impl of the trait.
144 let trait_method = cx
146 .associated_item(impl_item.def_id)
148 .expect("impl method matches a trait method");
149 let trait_method_sig = cx.tcx.fn_sig(trait_method);
150 let trait_method_sig = cx.tcx.erase_late_bound_regions(trait_method_sig);
152 // `impl_inputs_outputs` is an iterator over the types (`hir::Ty`) declared in the
153 // implementation of the trait.
154 let output_hir_ty = if let FnRetTy::Return(ty) = &decl.output {
159 let impl_inputs_outputs = decl.inputs.iter().chain(output_hir_ty);
161 // `impl_hir_ty` (of type `hir::Ty`) represents the type written in the signature.
163 // `trait_sem_ty` (of type `ty::Ty`) is the semantic type for the signature in the
164 // trait declaration. This is used to check if `Self` was used in the trait
167 // If `any`where in the `trait_sem_ty` the `self_ty` was used verbatim (as opposed
168 // to `Self`), we want to skip linting that type and all subtypes of it. This
169 // avoids suggestions to e.g. replace `Vec<u8>` with `Vec<Self>`, in an `impl Trait
170 // for u8`, when the trait always uses `Vec<u8>`.
172 // See also https://github.com/rust-lang/rust-clippy/issues/2894.
173 for (impl_hir_ty, trait_sem_ty) in impl_inputs_outputs.zip(trait_method_sig.inputs_and_output) {
174 if trait_sem_ty.walk().any(|inner| inner == self_ty.into()) {
175 let mut visitor = SkipTyCollector::default();
176 visitor.visit_ty(impl_hir_ty);
177 types_to_skip.extend(visitor.types_to_skip);
184 fn check_body(&mut self, _: &LateContext<'_>, _: &hir::Body<'_>) {
185 // `hir_ty_to_ty` cannot be called in `Body`s or it will panic (sometimes). But in bodies
186 // we can use `cx.typeck_results.node_type(..)` to get the `ty::Ty` from a `hir::Ty`.
187 // However the `node_type()` method can *only* be called in bodies.
188 if let Some(&mut StackItem::Check { ref mut in_body, .. }) = self.stack.last_mut() {
189 *in_body = in_body.saturating_add(1);
193 fn check_body_post(&mut self, _: &LateContext<'_>, _: &hir::Body<'_>) {
194 if let Some(&mut StackItem::Check { ref mut in_body, .. }) = self.stack.last_mut() {
195 *in_body = in_body.saturating_sub(1);
199 fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
201 if !hir_ty.span.from_expansion();
202 if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
203 if let Some(&StackItem::Check {
207 }) = self.stack.last();
208 if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
211 Res::SelfTyParam { .. }
212 | Res::SelfTyAlias { .. }
213 | Res::Def(DefKind::TyParam, _)
215 if !types_to_skip.contains(&hir_ty.hir_id);
216 let ty = if in_body > 0 {
217 cx.typeck_results().node_type(hir_ty.hir_id)
219 hir_ty_to_ty(cx.tcx, hir_ty)
221 if same_type_and_consts(ty, cx.tcx.type_of(impl_id));
223 span_lint(cx, hir_ty.span);
228 fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
230 if !expr.span.from_expansion();
231 if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
232 if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
233 if cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id);
234 then {} else { return; }
237 ExprKind::Struct(QPath::Resolved(_, path), ..) => match path.res {
238 Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } => (),
239 Res::Def(DefKind::Variant, _) => lint_path_to_variant(cx, path),
240 _ => span_lint(cx, path.span),
242 // tuple struct instantiation (`Foo(arg)` or `Enum::Foo(arg)`)
243 ExprKind::Call(fun, _) => {
244 if let ExprKind::Path(QPath::Resolved(_, path)) = fun.kind {
245 if let Res::Def(DefKind::Ctor(ctor_of, _), ..) = path.res {
247 CtorOf::Variant => lint_path_to_variant(cx, path),
248 CtorOf::Struct => span_lint(cx, path.span),
253 // unit enum variants (`Enum::A`)
254 ExprKind::Path(QPath::Resolved(_, path)) => lint_path_to_variant(cx, path),
259 fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
261 if !pat.span.from_expansion();
262 if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
263 if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
264 // get the path from the pattern
265 if let PatKind::Path(QPath::Resolved(_, path))
266 | PatKind::TupleStruct(QPath::Resolved(_, path), _, _)
267 | PatKind::Struct(QPath::Resolved(_, path), _, _) = pat.kind;
268 if cx.typeck_results().pat_ty(pat) == cx.tcx.type_of(impl_id);
271 Res::Def(DefKind::Ctor(ctor_of, _), ..) => match ctor_of {
272 CtorOf::Variant => lint_path_to_variant(cx, path),
273 CtorOf::Struct => span_lint(cx, path.span),
275 Res::Def(DefKind::Variant, ..) => lint_path_to_variant(cx, path),
276 Res::Def(DefKind::Struct, ..) => span_lint(cx, path.span),
283 extract_msrv_attr!(LateContext);
287 struct SkipTyCollector {
288 types_to_skip: Vec<HirId>,
291 impl<'tcx> Visitor<'tcx> for SkipTyCollector {
292 fn visit_infer(&mut self, inf: &hir::InferArg) {
293 self.types_to_skip.push(inf.hir_id);
297 fn visit_ty(&mut self, hir_ty: &hir::Ty<'_>) {
298 self.types_to_skip.push(hir_ty.hir_id);
300 walk_ty(self, hir_ty);
304 fn span_lint(cx: &LateContext<'_>, span: Span) {
309 "unnecessary structure name repetition",
310 "use the applicable keyword",
312 Applicability::MachineApplicable,
316 fn lint_path_to_variant(cx: &LateContext<'_>, path: &Path<'_>) {
317 if let [.., self_seg, _variant] = path.segments {
320 .with_hi(self_seg.args().span_ext().unwrap_or(self_seg.ident.span).hi());