2
0
Fork 0
mirror of https://github.com/rust-lang/rust-clippy synced 2024-12-22 02:53:20 +00:00
rust-clippy/clippy_lints/src/use_self.rs

270 lines
9.6 KiB
Rust
Raw Normal View History

use if_chain::if_chain;
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};
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;
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! {
/// **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 {}
/// }
/// }
/// ```
pub USE_SELF,
nursery,
"unnecessary structure name repetition whereas `Self` is applicable"
}
2019-04-08 20:43:55 +00:00
declare_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));
2019-01-31 01:15:29 +00:00
// Path segments only include actual path, no methods or fields.
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.
let span = path.span.with_hi(last_path_span.hi());
2018-07-18 05:57:50 +00:00
span_lint_and_sugg(
cx,
USE_SELF,
span,
2018-07-18 05:57:50 +00:00
"unnecessary structure name repetition",
"use the applicable keyword",
"Self".to_owned(),
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> {
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
}
}
2020-04-07 19:53:02 +00:00
walk_ty(self, hir_ty)
2018-07-14 10:18:50 +00:00
}
fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
2018-07-14 10:18:50 +00:00
NestedVisitorMap::None
}
}
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)
.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);
2020-10-24 00:21:27 +00:00
let trait_method_sig = cx.tcx.erase_late_bound_regions(trait_method_sig);
2018-07-14 10:18:50 +00:00
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
}
}
impl<'tcx> LateLintPass<'tcx> for UseSelf {
fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
if in_external_macro(cx.sess(), item.span) {
return;
}
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;
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(_)))
);
2018-07-14 10:18:50 +00:00
if should_check {
let visitor = &mut UseSelfVisitor {
item_path,
cx,
};
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 {
let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
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);
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 {
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-08-25 07:30:21 +00:00
}
}
}
}
}
struct UseSelfVisitor<'a, 'tcx> {
2019-12-30 04:02:10 +00:00
item_path: &'a Path<'a>,
cx: &'a LateContext<'tcx>,
}
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-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-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 {
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
}
}
}
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 { .. }
| 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),
}
}
fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
NestedVisitorMap::All(self.cx.tcx.hir())
}
}