+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::ty::same_type_and_consts;
+use clippy_utils::{meets_msrv, msrvs};
use if_chain::if_chain;
+use rustc_data_structures::fx::FxHashSet;
use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::intravisit::{walk_item, walk_path, walk_ty, NestedVisitorMap, Visitor};
use rustc_hir::{
- def, FnDecl, FnRetTy, FnSig, GenericArg, HirId, ImplItem, ImplItemKind, Item, ItemKind, Path, PathSegment, QPath,
+ self as hir,
+ def::{CtorOf, DefKind, Res},
+ def_id::LocalDefId,
+ intravisit::{walk_inf, walk_ty, Visitor},
+ Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Pat, PatKind, Path, QPath,
TyKind,
};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::hir::map::Map;
-use rustc_middle::lint::in_external_macro;
-use rustc_middle::ty;
-use rustc_middle::ty::{DefIdTree, Ty};
+use rustc_lint::{LateContext, LateLintPass};
use rustc_semver::RustcVersion;
use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::symbol::kw;
+use rustc_span::Span;
use rustc_typeck::hir_ty_to_ty;
-use crate::utils::{differing_macro_contexts, meets_msrv, span_lint_and_sugg};
-
declare_clippy_lint! {
- /// **What it does:** Checks for unnecessary repetition of structure name when a
+ /// ### What it does
+ /// Checks for unnecessary repetition of structure name when a
/// replacement with `Self` is applicable.
///
- /// **Why is this bad?** Unnecessary repetition. Mixed use of `Self` and struct
+ /// ### Why is this bad?
+ /// Unnecessary repetition. Mixed use of `Self` and struct
/// name
/// feels inconsistent.
///
- /// **Known problems:**
- /// - False positive when using associated types ([#2843](https://github.com/rust-lang/rust-clippy/issues/2843))
- /// - False positives in some situations when using generics ([#3410](https://github.com/rust-lang/rust-clippy/issues/3410))
+ /// ### Known problems
+ /// - Unaddressed false negative in fn bodies of trait implementations
+ /// - False positive with associated types in traits (#4140)
///
- /// **Example:**
+ /// ### Example
/// ```rust
- /// struct Foo {}
+ /// struct Foo;
/// impl Foo {
/// fn new() -> Foo {
/// Foo {}
/// ```
/// could be
/// ```rust
- /// struct Foo {}
+ /// struct Foo;
/// impl Foo {
/// fn new() -> Self {
/// Self {}
/// }
/// }
/// ```
+ #[clippy::version = "pre 1.29.0"]
pub USE_SELF,
nursery,
"unnecessary structure name repetition whereas `Self` is applicable"
}
-impl_lint_pass!(UseSelf => [USE_SELF]);
-
-const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
-
-fn span_use_self_lint(cx: &LateContext<'_>, path: &Path<'_>, last_segment: Option<&PathSegment<'_>>) {
- let last_segment = last_segment.unwrap_or_else(|| path.segments.last().expect(SEGMENTS_MSG));
-
- // Path segments only include actual path, no methods or fields.
- let last_path_span = last_segment.ident.span;
+#[derive(Default)]
+pub struct UseSelf {
+ msrv: Option<RustcVersion>,
+ stack: Vec<StackItem>,
+}
- if differing_macro_contexts(path.span, last_path_span) {
- return;
+impl UseSelf {
+ #[must_use]
+ pub fn new(msrv: Option<RustcVersion>) -> Self {
+ Self {
+ msrv,
+ ..Self::default()
+ }
}
-
- // Only take path up to the end of last_path_span.
- let span = path.span.with_hi(last_path_span.hi());
-
- span_lint_and_sugg(
- cx,
- USE_SELF,
- span,
- "unnecessary structure name repetition",
- "use the applicable keyword",
- "Self".to_owned(),
- Applicability::MachineApplicable,
- );
}
-// FIXME: always use this (more correct) visitor, not just in method signatures.
-struct SemanticUseSelfVisitor<'a, 'tcx> {
- cx: &'a LateContext<'tcx>,
- self_ty: Ty<'tcx>,
+#[derive(Debug)]
+enum StackItem {
+ Check {
+ impl_id: LocalDefId,
+ in_body: u32,
+ types_to_skip: FxHashSet<HirId>,
+ },
+ NoCheck,
}
-impl<'a, 'tcx> Visitor<'tcx> for SemanticUseSelfVisitor<'a, 'tcx> {
- type Map = Map<'tcx>;
+impl_lint_pass!(UseSelf => [USE_SELF]);
- fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'_>) {
- if let TyKind::Path(QPath::Resolved(_, path)) = &hir_ty.kind {
- match path.res {
- def::Res::SelfTy(..) => {},
- _ => {
- if hir_ty_to_ty(self.cx.tcx, hir_ty) == self.self_ty {
- span_use_self_lint(self.cx, path, None);
- }
- },
- }
- }
+const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
- walk_ty(self, hir_ty)
+impl<'tcx> LateLintPass<'tcx> for UseSelf {
+ fn check_item(&mut self, _cx: &LateContext<'_>, item: &Item<'_>) {
+ if matches!(item.kind, ItemKind::OpaqueTy(_)) {
+ // skip over `ItemKind::OpaqueTy` in order to lint `foo() -> impl <..>`
+ return;
+ }
+ // We push the self types of `impl`s on a stack here. Only the top type on the stack is
+ // relevant for linting, since this is the self type of the `impl` we're currently in. To
+ // avoid linting on nested items, we push `StackItem::NoCheck` on the stack to signal, that
+ // we're in an `impl` or nested item, that we don't want to lint
+ let stack_item = if_chain! {
+ if let ItemKind::Impl(Impl { self_ty, .. }) = item.kind;
+ if let TyKind::Path(QPath::Resolved(_, item_path)) = self_ty.kind;
+ let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
+ if parameters.as_ref().map_or(true, |params| {
+ !params.parenthesized && !params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
+ });
+ then {
+ StackItem::Check {
+ impl_id: item.def_id,
+ in_body: 0,
+ types_to_skip: std::iter::once(self_ty.hir_id).collect(),
+ }
+ } else {
+ StackItem::NoCheck
+ }
+ };
+ self.stack.push(stack_item);
}
- fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
- NestedVisitorMap::None
+ fn check_item_post(&mut self, _: &LateContext<'_>, item: &Item<'_>) {
+ if !matches!(item.kind, ItemKind::OpaqueTy(_)) {
+ self.stack.pop();
+ }
}
-}
-
-fn check_trait_method_impl_decl<'tcx>(
- cx: &LateContext<'tcx>,
- impl_item: &ImplItem<'_>,
- impl_decl: &'tcx FnDecl<'_>,
- impl_trait_ref: ty::TraitRef<'tcx>,
-) {
- let trait_method = cx
- .tcx
- .associated_items(impl_trait_ref.def_id)
- .find_by_name_and_kind(cx.tcx, impl_item.ident, ty::AssocKind::Fn, impl_trait_ref.def_id)
- .expect("impl method matches a trait method");
-
- let trait_method_sig = cx.tcx.fn_sig(trait_method.def_id);
- let trait_method_sig = cx.tcx.erase_late_bound_regions(trait_method_sig);
- let output_hir_ty = if let FnRetTy::Return(ty) = &impl_decl.output {
- Some(&**ty)
- } else {
- None
- };
-
- // `impl_hir_ty` (of type `hir::Ty`) represents the type written in the signature.
- // `trait_ty` (of type `ty::Ty`) is the semantic type for the signature in the trait.
- // We use `impl_hir_ty` to see if the type was written as `Self`,
- // `hir_ty_to_ty(...)` to check semantic types of paths, and
- // `trait_ty` to determine which parts of the signature in the trait, mention
- // the type being implemented verbatim (as opposed to `Self`).
- for (impl_hir_ty, trait_ty) in impl_decl
- .inputs
- .iter()
- .chain(output_hir_ty)
- .zip(trait_method_sig.inputs_and_output)
- {
- // Check if the input/output type in the trait method specifies the implemented
- // type verbatim, and only suggest `Self` if that isn't the case.
- // This avoids suggestions to e.g. replace `Vec<u8>` with `Vec<Self>`,
- // in an `impl Trait for u8`, when the trait always uses `Vec<u8>`.
- // See also https://github.com/rust-lang/rust-clippy/issues/2894.
- let self_ty = impl_trait_ref.self_ty();
- if !trait_ty.walk().any(|inner| inner == self_ty.into()) {
- let mut visitor = SemanticUseSelfVisitor { cx, self_ty };
-
- visitor.visit_ty(&impl_hir_ty);
+ fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
+ // We want to skip types in trait `impl`s that aren't declared as `Self` in the trait
+ // declaration. The collection of those types is all this method implementation does.
+ if_chain! {
+ if let ImplItemKind::Fn(FnSig { decl, .. }, ..) = impl_item.kind;
+ if let Some(&mut StackItem::Check {
+ impl_id,
+ ref mut types_to_skip,
+ ..
+ }) = self.stack.last_mut();
+ if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_id);
+ then {
+ // `self_ty` is the semantic self type of `impl <trait> for <type>`. This cannot be
+ // `Self`.
+ let self_ty = impl_trait_ref.self_ty();
+
+ // `trait_method_sig` is the signature of the function, how it is declared in the
+ // trait, not in the impl of the trait.
+ let trait_method = cx
+ .tcx
+ .associated_item(impl_item.def_id)
+ .trait_item_def_id
+ .expect("impl method matches a trait method");
+ let trait_method_sig = cx.tcx.fn_sig(trait_method);
+ let trait_method_sig = cx.tcx.erase_late_bound_regions(trait_method_sig);
+
+ // `impl_inputs_outputs` is an iterator over the types (`hir::Ty`) declared in the
+ // implementation of the trait.
+ let output_hir_ty = if let FnRetTy::Return(ty) = &decl.output {
+ Some(&**ty)
+ } else {
+ None
+ };
+ let impl_inputs_outputs = decl.inputs.iter().chain(output_hir_ty);
+
+ // `impl_hir_ty` (of type `hir::Ty`) represents the type written in the signature.
+ //
+ // `trait_sem_ty` (of type `ty::Ty`) is the semantic type for the signature in the
+ // trait declaration. This is used to check if `Self` was used in the trait
+ // declaration.
+ //
+ // If `any`where in the `trait_sem_ty` the `self_ty` was used verbatim (as opposed
+ // to `Self`), we want to skip linting that type and all subtypes of it. This
+ // avoids suggestions to e.g. replace `Vec<u8>` with `Vec<Self>`, in an `impl Trait
+ // for u8`, when the trait always uses `Vec<u8>`.
+ //
+ // See also https://github.com/rust-lang/rust-clippy/issues/2894.
+ for (impl_hir_ty, trait_sem_ty) in impl_inputs_outputs.zip(trait_method_sig.inputs_and_output) {
+ if trait_sem_ty.walk().any(|inner| inner == self_ty.into()) {
+ let mut visitor = SkipTyCollector::default();
+ visitor.visit_ty(impl_hir_ty);
+ types_to_skip.extend(visitor.types_to_skip);
+ }
+ }
+ }
}
}
-}
-
-const USE_SELF_MSRV: RustcVersion = RustcVersion::new(1, 37, 0);
-
-pub struct UseSelf {
- msrv: Option<RustcVersion>,
-}
-impl UseSelf {
- #[must_use]
- pub fn new(msrv: Option<RustcVersion>) -> Self {
- Self { msrv }
+ fn check_body(&mut self, _: &LateContext<'_>, _: &hir::Body<'_>) {
+ // `hir_ty_to_ty` cannot be called in `Body`s or it will panic (sometimes). But in bodies
+ // we can use `cx.typeck_results.node_type(..)` to get the `ty::Ty` from a `hir::Ty`.
+ // However the `node_type()` method can *only* be called in bodies.
+ if let Some(&mut StackItem::Check { ref mut in_body, .. }) = self.stack.last_mut() {
+ *in_body = in_body.saturating_add(1);
+ }
}
-}
-impl<'tcx> LateLintPass<'tcx> for UseSelf {
- fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
- if !meets_msrv(self.msrv.as_ref(), &USE_SELF_MSRV) {
- return;
+ fn check_body_post(&mut self, _: &LateContext<'_>, _: &hir::Body<'_>) {
+ if let Some(&mut StackItem::Check { ref mut in_body, .. }) = self.stack.last_mut() {
+ *in_body = in_body.saturating_sub(1);
}
+ }
- if in_external_macro(cx.sess(), item.span) {
- return;
- }
+ fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
if_chain! {
- if let ItemKind::Impl(impl_) = &item.kind;
- if let TyKind::Path(QPath::Resolved(_, ref item_path)) = impl_.self_ty.kind;
+ if !hir_ty.span.from_expansion();
+ if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+ if let Some(&StackItem::Check {
+ impl_id,
+ in_body,
+ ref types_to_skip,
+ }) = self.stack.last();
+ if let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind;
+ if !matches!(path.res, Res::SelfTy { .. } | Res::Def(DefKind::TyParam, _));
+ if !types_to_skip.contains(&hir_ty.hir_id);
+ let ty = if in_body > 0 {
+ cx.typeck_results().node_type(hir_ty.hir_id)
+ } else {
+ hir_ty_to_ty(cx.tcx, hir_ty)
+ };
+ if same_type_and_consts(ty, cx.tcx.type_of(impl_id));
+ let hir = cx.tcx.hir();
+ // prevents false positive on `#[derive(serde::Deserialize)]`
+ if !hir.span(hir.get_parent_node(hir_ty.hir_id)).in_derive_expansion();
then {
- let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
- let should_check = parameters.as_ref().map_or(
- true,
- |params| !params.parenthesized
- &&!params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
- );
-
- if should_check {
- let visitor = &mut UseSelfVisitor {
- item_path,
- cx,
- };
- let impl_trait_ref = cx.tcx.impl_trait_ref(item.def_id);
-
- if let Some(impl_trait_ref) = impl_trait_ref {
- for impl_item_ref in impl_.items {
- let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
- if let ImplItemKind::Fn(FnSig{ decl: impl_decl, .. }, impl_body_id)
- = &impl_item.kind {
- check_trait_method_impl_decl(cx, impl_item, impl_decl, impl_trait_ref);
+ span_lint(cx, hir_ty.span);
+ }
+ }
+ }
- let body = cx.tcx.hir().body(*impl_body_id);
- visitor.visit_body(body);
- } else {
- visitor.visit_impl_item(impl_item);
- }
- }
- } else {
- for impl_item_ref in impl_.items {
- let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
- visitor.visit_impl_item(impl_item);
+ fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+ if_chain! {
+ if !expr.span.from_expansion();
+ if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+ if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
+ if cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id);
+ then {} else { return; }
+ }
+ match expr.kind {
+ ExprKind::Struct(QPath::Resolved(_, path), ..) => match path.res {
+ Res::SelfTy { .. } => (),
+ Res::Def(DefKind::Variant, _) => lint_path_to_variant(cx, path),
+ _ => span_lint(cx, path.span),
+ },
+ // tuple struct instantiation (`Foo(arg)` or `Enum::Foo(arg)`)
+ ExprKind::Call(fun, _) => {
+ if let ExprKind::Path(QPath::Resolved(_, path)) = fun.kind {
+ if let Res::Def(DefKind::Ctor(ctor_of, _), ..) = path.res {
+ match ctor_of {
+ CtorOf::Variant => lint_path_to_variant(cx, path),
+ CtorOf::Struct => span_lint(cx, path.span),
}
}
}
+ },
+ // unit enum variants (`Enum::A`)
+ ExprKind::Path(QPath::Resolved(_, path)) => lint_path_to_variant(cx, path),
+ _ => (),
+ }
+ }
+
+ fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
+ if_chain! {
+ if !pat.span.from_expansion();
+ if meets_msrv(self.msrv, msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+ if let Some(&StackItem::Check { impl_id, .. }) = self.stack.last();
+ if let PatKind::Path(QPath::Resolved(_, path)) = pat.kind;
+ if !matches!(path.res, Res::SelfTy { .. } | Res::Def(DefKind::TyParam, _));
+ if cx.typeck_results().pat_ty(pat) == cx.tcx.type_of(impl_id);
+ if let [first, ..] = path.segments;
+ if let Some(hir_id) = first.hir_id;
+ then {
+ span_lint(cx, cx.tcx.hir().span(hir_id));
}
}
}
+
extract_msrv_attr!(LateContext);
}
-struct UseSelfVisitor<'a, 'tcx> {
- item_path: &'a Path<'a>,
- cx: &'a LateContext<'tcx>,
+#[derive(Default)]
+struct SkipTyCollector {
+ types_to_skip: Vec<HirId>,
}
-impl<'a, 'tcx> Visitor<'tcx> for UseSelfVisitor<'a, 'tcx> {
- type Map = Map<'tcx>;
-
- fn visit_path(&mut self, path: &'tcx Path<'_>, _id: HirId) {
- if !path.segments.iter().any(|p| p.ident.span.is_dummy()) {
- if path.segments.len() >= 2 {
- let last_but_one = &path.segments[path.segments.len() - 2];
- if last_but_one.ident.name != kw::SelfUpper {
- let enum_def_id = match path.res {
- Res::Def(DefKind::Variant, variant_def_id) => self.cx.tcx.parent(variant_def_id),
- Res::Def(DefKind::Ctor(def::CtorOf::Variant, _), ctor_def_id) => {
- let variant_def_id = self.cx.tcx.parent(ctor_def_id);
- variant_def_id.and_then(|def_id| self.cx.tcx.parent(def_id))
- },
- _ => None,
- };
+impl<'tcx> Visitor<'tcx> for SkipTyCollector {
+ fn visit_infer(&mut self, inf: &hir::InferArg) {
+ self.types_to_skip.push(inf.hir_id);
- if self.item_path.res.opt_def_id() == enum_def_id {
- span_use_self_lint(self.cx, path, Some(last_but_one));
- }
- }
- }
-
- if path.segments.last().expect(SEGMENTS_MSG).ident.name != kw::SelfUpper {
- if self.item_path.res == path.res {
- span_use_self_lint(self.cx, path, None);
- } else if let Res::Def(DefKind::Ctor(def::CtorOf::Struct, _), ctor_def_id) = path.res {
- if self.item_path.res.opt_def_id() == self.cx.tcx.parent(ctor_def_id) {
- span_use_self_lint(self.cx, path, None);
- }
- }
- }
- }
-
- walk_path(self, path);
+ walk_inf(self, inf);
}
+ fn visit_ty(&mut self, hir_ty: &hir::Ty<'_>) {
+ self.types_to_skip.push(hir_ty.hir_id);
- fn visit_item(&mut self, item: &'tcx Item<'_>) {
- match item.kind {
- ItemKind::Use(..)
- | ItemKind::Static(..)
- | ItemKind::Enum(..)
- | ItemKind::Struct(..)
- | ItemKind::Union(..)
- | ItemKind::Impl { .. }
- | ItemKind::Fn(..) => {
- // Don't check statements that shadow `Self` or where `Self` can't be used
- },
- _ => walk_item(self, item),
- }
+ walk_ty(self, hir_ty);
}
+}
+
+fn span_lint(cx: &LateContext<'_>, span: Span) {
+ span_lint_and_sugg(
+ cx,
+ USE_SELF,
+ span,
+ "unnecessary structure name repetition",
+ "use the applicable keyword",
+ "Self".to_owned(),
+ Applicability::MachineApplicable,
+ );
+}
- fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
- NestedVisitorMap::All(self.cx.tcx.hir())
+fn lint_path_to_variant(cx: &LateContext<'_>, path: &Path<'_>) {
+ if let [.., self_seg, _variant] = path.segments {
+ let span = path
+ .span
+ .with_hi(self_seg.args().span_ext().unwrap_or(self_seg.ident.span).hi());
+ span_lint(cx, span);
}
}