2018-11-20 13:06:29 +00:00
|
|
|
use if_chain::if_chain;
|
2018-12-29 15:04:45 +00:00
|
|
|
use rustc_errors::Applicability;
|
2020-01-06 16:39:50 +00:00
|
|
|
use rustc_hir as hir;
|
|
|
|
use rustc_hir::def::{DefKind, Res};
|
2020-01-09 07:13:22 +00:00
|
|
|
use rustc_hir::intravisit::{walk_item, walk_path, walk_ty, NestedVisitorMap, Visitor};
|
2020-02-21 08:39:38 +00:00
|
|
|
use rustc_hir::{
|
|
|
|
def, FnDecl, FnRetTy, FnSig, GenericArg, HirId, ImplItem, ImplItemKind, Item, ItemKind, Path, PathSegment, QPath,
|
|
|
|
TyKind,
|
|
|
|
};
|
2020-01-12 06:08:41 +00:00
|
|
|
use rustc_lint::{LateContext, LateLintPass, LintContext};
|
2020-03-30 09:02:14 +00:00
|
|
|
use rustc_middle::hir::map::Map;
|
|
|
|
use rustc_middle::lint::in_external_macro;
|
|
|
|
use rustc_middle::ty;
|
|
|
|
use rustc_middle::ty::{DefIdTree, Ty};
|
2020-01-11 11:37:08 +00:00
|
|
|
use rustc_session::{declare_lint_pass, declare_tool_lint};
|
2019-12-31 00:17:56 +00:00
|
|
|
use rustc_span::symbol::kw;
|
2020-04-07 19:53:02 +00:00
|
|
|
use rustc_typeck::hir_ty_to_ty;
|
2017-07-28 11:28:07 +00:00
|
|
|
|
2019-10-15 13:11:29 +00:00
|
|
|
use crate::utils::{differing_macro_contexts, span_lint_and_sugg};
|
2019-01-31 01:15:29 +00:00
|
|
|
|
2018-03-28 13:24:26 +00:00
|
|
|
declare_clippy_lint! {
|
2019-03-05 16:50:33 +00:00
|
|
|
/// **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
|
|
|
|
/// name
|
|
|
|
/// feels inconsistent.
|
|
|
|
///
|
|
|
|
/// **Known problems:**
|
|
|
|
/// - False positive when using associated types (#2843)
|
|
|
|
/// - False positives in some situations when using generics (#3410)
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// struct Foo {}
|
|
|
|
/// impl Foo {
|
|
|
|
/// fn new() -> Foo {
|
|
|
|
/// Foo {}
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
/// could be
|
|
|
|
/// ```rust
|
|
|
|
/// struct Foo {}
|
|
|
|
/// impl Foo {
|
|
|
|
/// fn new() -> Self {
|
|
|
|
/// Self {}
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ```
|
2017-07-28 11:28:07 +00:00
|
|
|
pub USE_SELF,
|
2019-11-29 06:51:49 +00:00
|
|
|
nursery,
|
2020-08-11 14:43:53 +00:00
|
|
|
"unnecessary structure name repetition whereas `Self` is applicable"
|
2017-07-28 11:28:07 +00:00
|
|
|
}
|
|
|
|
|
2019-04-08 20:43:55 +00:00
|
|
|
declare_lint_pass!(UseSelf => [USE_SELF]);
|
2017-07-28 11:28:07 +00:00
|
|
|
|
2017-08-22 17:22:47 +00:00
|
|
|
const SEGMENTS_MSG: &str = "segments should be composed of at least 1 element";
|
|
|
|
|
2020-06-25 20:41:36 +00:00
|
|
|
fn span_use_self_lint(cx: &LateContext<'_>, path: &Path<'_>, last_segment: Option<&PathSegment<'_>>) {
|
2019-07-31 00:24:28 +00:00
|
|
|
let last_segment = last_segment.unwrap_or_else(|| path.segments.last().expect(SEGMENTS_MSG));
|
|
|
|
|
2019-01-31 01:15:29 +00:00
|
|
|
// Path segments only include actual path, no methods or fields.
|
2019-07-31 00:24:28 +00:00
|
|
|
let last_path_span = last_segment.ident.span;
|
2019-10-15 13:11:29 +00:00
|
|
|
|
|
|
|
if differing_macro_contexts(path.span, last_path_span) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-01-31 01:15:29 +00:00
|
|
|
// Only take path up to the end of last_path_span.
|
2019-01-22 13:43:59 +00:00
|
|
|
let span = path.span.with_hi(last_path_span.hi());
|
2019-01-21 12:06:32 +00:00
|
|
|
|
2018-07-18 05:57:50 +00:00
|
|
|
span_lint_and_sugg(
|
|
|
|
cx,
|
|
|
|
USE_SELF,
|
2019-01-20 13:50:26 +00:00
|
|
|
span,
|
2018-07-18 05:57:50 +00:00
|
|
|
"unnecessary structure name repetition",
|
|
|
|
"use the applicable keyword",
|
|
|
|
"Self".to_owned(),
|
2018-11-27 14:13:57 +00:00
|
|
|
Applicability::MachineApplicable,
|
2018-07-18 05:57:50 +00:00
|
|
|
);
|
2018-07-14 10:18:50 +00:00
|
|
|
}
|
|
|
|
|
2020-04-07 19:53:02 +00:00
|
|
|
// FIXME: always use this (more correct) visitor, not just in method signatures.
|
|
|
|
struct SemanticUseSelfVisitor<'a, 'tcx> {
|
2020-06-25 20:41:36 +00:00
|
|
|
cx: &'a LateContext<'tcx>,
|
2020-04-07 19:53:02 +00:00
|
|
|
self_ty: Ty<'tcx>,
|
2018-07-14 10:18:50 +00:00
|
|
|
}
|
|
|
|
|
2020-04-07 19:53:02 +00:00
|
|
|
impl<'a, 'tcx> Visitor<'tcx> for SemanticUseSelfVisitor<'a, 'tcx> {
|
2020-01-09 07:13:22 +00:00
|
|
|
type Map = Map<'tcx>;
|
|
|
|
|
2020-04-07 19:53:02 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
},
|
2018-07-14 10:18:50 +00:00
|
|
|
}
|
|
|
|
}
|
2018-11-10 08:46:21 +00:00
|
|
|
|
2020-04-07 19:53:02 +00:00
|
|
|
walk_ty(self, hir_ty)
|
2018-07-14 10:18:50 +00:00
|
|
|
}
|
|
|
|
|
2020-03-15 22:41:20 +00:00
|
|
|
fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
|
2018-07-14 10:18:50 +00:00
|
|
|
NestedVisitorMap::None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-25 20:41:36 +00:00
|
|
|
fn check_trait_method_impl_decl<'tcx>(
|
|
|
|
cx: &LateContext<'tcx>,
|
2019-12-22 14:42:41 +00:00
|
|
|
impl_item: &ImplItem<'_>,
|
2019-12-30 04:02:10 +00:00
|
|
|
impl_decl: &'tcx FnDecl<'_>,
|
2020-04-07 19:53:02 +00:00
|
|
|
impl_trait_ref: ty::TraitRef<'tcx>,
|
2018-07-14 10:18:50 +00:00
|
|
|
) {
|
|
|
|
let trait_method = cx
|
|
|
|
.tcx
|
|
|
|
.associated_items(impl_trait_ref.def_id)
|
2020-04-14 10:25:45 +00:00
|
|
|
.find_by_name_and_kind(cx.tcx, impl_item.ident, ty::AssocKind::Fn, impl_trait_ref.def_id)
|
2018-07-14 10:18:50 +00:00
|
|
|
.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);
|
|
|
|
|
2020-04-07 19:53:02 +00:00
|
|
|
let output_hir_ty = if let FnRetTy::Return(ty) = &impl_decl.output {
|
2018-07-14 10:18:50 +00:00
|
|
|
Some(&**ty)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
|
2020-04-07 19:53:02 +00:00
|
|
|
// `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);
|
|
|
|
}
|
2018-07-14 10:18:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-25 20:41:36 +00:00
|
|
|
impl<'tcx> LateLintPass<'tcx> for UseSelf {
|
|
|
|
fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
|
2019-01-04 10:31:28 +00:00
|
|
|
if in_external_macro(cx.sess(), item.span) {
|
2017-08-21 10:58:06 +00:00
|
|
|
return;
|
|
|
|
}
|
2017-10-23 19:18:02 +00:00
|
|
|
if_chain! {
|
2020-01-18 05:14:36 +00:00
|
|
|
if let ItemKind::Impl{ self_ty: ref item_type, items: refs, .. } = item.kind;
|
2019-09-27 15:16:06 +00:00
|
|
|
if let TyKind::Path(QPath::Resolved(_, ref item_path)) = item_type.kind;
|
2017-10-23 19:18:02 +00:00
|
|
|
then {
|
2018-06-24 13:32:40 +00:00
|
|
|
let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
|
2020-06-25 18:58:47 +00:00
|
|
|
let should_check = parameters.as_ref().map_or(
|
|
|
|
true,
|
2020-07-05 20:11:19 +00:00
|
|
|
|params| !params.parenthesized
|
|
|
|
&&!params.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)))
|
2020-06-25 18:58:47 +00:00
|
|
|
);
|
2018-07-14 10:18:50 +00:00
|
|
|
|
2017-10-23 19:18:02 +00:00
|
|
|
if should_check {
|
|
|
|
let visitor = &mut UseSelfVisitor {
|
2018-03-15 15:07:15 +00:00
|
|
|
item_path,
|
|
|
|
cx,
|
2017-10-23 19:18:02 +00:00
|
|
|
};
|
2019-07-06 03:52:51 +00:00
|
|
|
let impl_def_id = cx.tcx.hir().local_def_id(item.hir_id);
|
2018-07-14 10:18:50 +00:00
|
|
|
let impl_trait_ref = cx.tcx.impl_trait_ref(impl_def_id);
|
|
|
|
|
|
|
|
if let Some(impl_trait_ref) = impl_trait_ref {
|
|
|
|
for impl_item_ref in refs {
|
2018-12-08 00:56:03 +00:00
|
|
|
let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
|
2020-03-16 15:00:16 +00:00
|
|
|
if let ImplItemKind::Fn(FnSig{ decl: impl_decl, .. }, impl_body_id)
|
2019-09-27 15:16:06 +00:00
|
|
|
= &impl_item.kind {
|
2020-04-07 19:53:02 +00:00
|
|
|
check_trait_method_impl_decl(cx, impl_item, impl_decl, impl_trait_ref);
|
2018-11-10 08:46:21 +00:00
|
|
|
|
2018-12-08 00:56:03 +00:00
|
|
|
let body = cx.tcx.hir().body(*impl_body_id);
|
2018-07-14 10:18:50 +00:00
|
|
|
visitor.visit_body(body);
|
|
|
|
} else {
|
|
|
|
visitor.visit_impl_item(impl_item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for impl_item_ref in refs {
|
2018-12-08 00:56:03 +00:00
|
|
|
let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
|
2018-07-14 10:18:50 +00:00
|
|
|
visitor.visit_impl_item(impl_item);
|
|
|
|
}
|
2017-10-23 19:18:02 +00:00
|
|
|
}
|
2017-08-25 07:30:21 +00:00
|
|
|
}
|
2017-07-28 11:28:07 +00:00
|
|
|
}
|
2017-10-23 19:18:02 +00:00
|
|
|
}
|
2017-07-28 11:28:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-19 18:36:23 +00:00
|
|
|
struct UseSelfVisitor<'a, 'tcx> {
|
2019-12-30 04:02:10 +00:00
|
|
|
item_path: &'a Path<'a>,
|
2020-06-25 20:41:36 +00:00
|
|
|
cx: &'a LateContext<'tcx>,
|
2017-07-28 11:28:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, 'tcx> Visitor<'tcx> for UseSelfVisitor<'a, 'tcx> {
|
2020-01-09 07:13:22 +00:00
|
|
|
type Map = Map<'tcx>;
|
|
|
|
|
2019-12-30 04:02:10 +00:00
|
|
|
fn visit_path(&mut self, path: &'tcx Path<'_>, _id: HirId) {
|
2019-11-07 03:59:13 +00:00
|
|
|
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,
|
|
|
|
};
|
2019-07-31 00:24:28 +00:00
|
|
|
|
2019-11-07 03:59:13 +00:00
|
|
|
if self.item_path.res.opt_def_id() == enum_def_id {
|
|
|
|
span_use_self_lint(self.cx, path, Some(last_but_one));
|
|
|
|
}
|
2019-07-31 00:24:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-07 03:59:13 +00:00
|
|
|
if path.segments.last().expect(SEGMENTS_MSG).ident.name != kw::SelfUpper {
|
|
|
|
if self.item_path.res == path.res {
|
2019-07-31 00:24:28 +00:00
|
|
|
span_use_self_lint(self.cx, path, None);
|
2019-11-07 03:59:13 +00:00
|
|
|
} 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);
|
|
|
|
}
|
2018-12-27 16:27:42 +00:00
|
|
|
}
|
|
|
|
}
|
2017-07-28 11:28:07 +00:00
|
|
|
}
|
2019-07-31 00:24:28 +00:00
|
|
|
|
2017-07-28 11:28:07 +00:00
|
|
|
walk_path(self, path);
|
|
|
|
}
|
|
|
|
|
2019-12-22 14:42:41 +00:00
|
|
|
fn visit_item(&mut self, item: &'tcx Item<'_>) {
|
2019-09-27 15:16:06 +00:00
|
|
|
match item.kind {
|
2019-01-06 14:05:04 +00:00
|
|
|
ItemKind::Use(..)
|
|
|
|
| ItemKind::Static(..)
|
|
|
|
| ItemKind::Enum(..)
|
|
|
|
| ItemKind::Struct(..)
|
2019-01-07 13:11:53 +00:00
|
|
|
| ItemKind::Union(..)
|
2020-01-18 05:14:36 +00:00
|
|
|
| ItemKind::Impl { .. }
|
2019-03-11 14:24:49 +00:00
|
|
|
| ItemKind::Fn(..) => {
|
2019-01-06 14:05:04 +00:00
|
|
|
// Don't check statements that shadow `Self` or where `Self` can't be used
|
|
|
|
},
|
|
|
|
_ => walk_item(self, item),
|
|
|
|
}
|
2018-11-13 04:15:33 +00:00
|
|
|
}
|
|
|
|
|
2020-03-15 22:41:20 +00:00
|
|
|
fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
|
|
|
|
NestedVisitorMap::All(self.cx.tcx.hir())
|
2017-07-28 11:28:07 +00:00
|
|
|
}
|
|
|
|
}
|