Skip to content

Commit

Permalink
rework use_self impl based on ty::Ty comparison rust-lang#3410
Browse files Browse the repository at this point in the history
  • Loading branch information
Tim Nielens committed Apr 24, 2020
1 parent 02c9435 commit 2e3a7e3
Show file tree
Hide file tree
Showing 6 changed files with 210 additions and 194 deletions.
242 changes: 101 additions & 141 deletions clippy_lints/src/use_self.rs
View file
Original file line number Diff line number Diff line change
@@ -1,19 +1,18 @@
use if_chain::if_chain;
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::intravisit::{walk_expr, walk_impl_item, walk_ty, NestedVisitorMap, Visitor};
use rustc_hir::{
def, FnDecl, FnRetTy, FnSig, GenericArg, HirId, ImplItem, ImplItemKind, Item, ItemKind, Path, PathSegment, QPath,
TyKind,
def, Expr, ExprKind, FnDecl, FnRetTy, FnSig, GenericArg, ImplItem, ImplItemKind, Item, ItemKind, Path, PathSegment,
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_middle::ty::Ty;
use rustc_session::{declare_lint_pass, declare_tool_lint};
use rustc_span::symbol::kw;
use rustc_span::Span;
use rustc_typeck::hir_ty_to_ty;

use crate::utils::{differing_macro_contexts, span_lint_and_sugg};
Expand Down Expand Up @@ -81,15 +80,87 @@ fn span_use_self_lint(cx: &LateContext<'_, '_>, path: &Path<'_>, last_segment: O
);
}

// FIXME: always use this (more correct) visitor, not just in method signatures.
struct SemanticUseSelfVisitor<'a, 'tcx> {
struct ImplVisitor<'a, 'tcx> {
cx: &'a LateContext<'a, 'tcx>,
item: &'tcx Item<'tcx>,
self_ty: Ty<'tcx>,
}

impl<'a, 'tcx> Visitor<'tcx> for SemanticUseSelfVisitor<'a, 'tcx> {
impl<'a, 'tcx> ImplVisitor<'a, 'tcx> {
fn check_trait_method_impl_decl(
&mut self,
impl_item: &ImplItem<'tcx>,
impl_decl: &'tcx FnDecl<'tcx>,
impl_trait_ref: ty::TraitRef<'tcx>,
) {
let tcx = self.cx.tcx;
let trait_method = tcx
.associated_items(impl_trait_ref.def_id)
.find_by_name_and_kind(tcx, impl_item.ident, ty::AssocKind::Fn, impl_trait_ref.def_id)
.expect("impl method matches a trait method");

let trait_method_sig = tcx.fn_sig(trait_method.def_id);
let trait_method_sig = 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()) {
self.visit_ty(&impl_hir_ty);
}
}
}
}

impl<'a, 'tcx> Visitor<'tcx> for ImplVisitor<'a, 'tcx> {
type Map = Map<'tcx>;

fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
if let ExprKind::Struct(QPath::Resolved(_, path), ..) = expr.kind {
if self
.cx
.tcx
.typeck_tables_of(expr.hir_id.owner.to_def_id())
.node_type(expr.hir_id)
== self.self_ty
{
match path.res {
def::Res::SelfTy(..) => {},
_ => {
span_use_self_lint(self.cx, path, None);
},
}
span_use_self_lint(self.cx, path, None);
}
}
walk_expr(self, expr)
}

fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
}

fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'_>) {
if let TyKind::Path(QPath::Resolved(_, path)) = &hir_ty.kind {
match path.res {
Expand All @@ -105,54 +176,20 @@ impl<'a, 'tcx> Visitor<'tcx> for SemanticUseSelfVisitor<'a, 'tcx> {
walk_ty(self, hir_ty)
}

fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
NestedVisitorMap::None
}
}

fn check_trait_method_impl_decl<'a, 'tcx>(
cx: &'a LateContext<'a, '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 visit_impl_item(&mut self, ii: &'tcx ImplItem<'tcx>) {
let tcx = self.cx.tcx;
let impl_def_id = tcx.hir().local_def_id(self.item.hir_id);
let impl_trait_ref = tcx.impl_trait_ref(impl_def_id);
if_chain! {
if let Some(impl_trait_ref) = impl_trait_ref;
if let ImplItemKind::Fn(FnSig { decl: impl_decl, .. }, impl_body_id) = &ii.kind;
then {
self.check_trait_method_impl_decl(ii, impl_decl, impl_trait_ref);
let body = tcx.hir().body(*impl_body_id);
self.visit_body(body);
} else {
walk_impl_item(self, ii)
}
}
}
}
Expand All @@ -177,96 +214,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UseSelf {
};

if should_check {
let visitor = &mut UseSelfVisitor {
item_path,
let self_ty= hir_ty_to_ty(cx.tcx, item_type);
let visitor = &mut ImplVisitor {
cx,
item,
self_ty,
};
let impl_def_id = cx.tcx.hir().local_def_id(item.hir_id);
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)
= &impl_item.kind {
check_trait_method_impl_decl(cx, impl_item, impl_decl, impl_trait_ref);

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 refs {
let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
visitor.visit_impl_item(impl_item);
}
for impl_item_ref in refs {
let impl_item = cx.tcx.hir().impl_item(impl_item_ref.id);
visitor.visit_impl_item(impl_item);
}
}
}
}
}
}

struct UseSelfVisitor<'a, 'tcx> {
item_path: &'a Path<'a>,
cx: &'a LateContext<'a, 'tcx>,
}

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,
};

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);
}

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),
}
}

fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
NestedVisitorMap::All(self.cx.tcx.hir())
}
}
50 changes: 42 additions & 8 deletions tests/ui/use_self.fixed
View file
Original file line number Diff line number Diff line change
Expand Up @@ -86,7 +86,7 @@ mod existential {
struct Foo;

impl Foo {
fn bad(foos: &[Self]) -> impl Iterator<Item = &Self> {
fn bad(foos: &[Self]) -> impl Iterator<Item = &Foo> {
foos.iter()
}

Expand All @@ -101,7 +101,7 @@ mod tuple_structs {

impl TS {
pub fn ts() -> Self {
Self(0)
TS(0)
}
}
}
Expand Down Expand Up @@ -163,9 +163,9 @@ mod nesting {
}

fn method2() {
let _ = Self::B(42);
let _ = Self::C { field: true };
let _ = Self::A;
let _ = Enum::B(42);
let _ = Self { field: true };
let _ = Enum::A;
}
}
}
Expand All @@ -176,11 +176,26 @@ mod issue3410 {
struct B;

trait Trait<T> {
fn a(v: T);
fn a(v: T) -> Self;
}

impl Trait<Vec<A>> for Vec<B> {
fn a(_: Vec<A>) {}
fn a(_: Vec<A>) -> Self {
unimplemented!()
}
}

impl<T> Trait<Vec<A>> for Vec<T>
where
T: Trait<B>,
{
fn a(v: Vec<A>) -> Self {
// fix false positive, should not trigger here
<Vec<B>>::a(v)
.into_iter()
.map(Trait::a)
.collect()
}
}
}

Expand Down Expand Up @@ -232,7 +247,7 @@ mod paths_created_by_lowering {
const A: usize = 0;
const B: usize = 1;

async fn g() -> Self {
async fn g() -> S {
Self {}
}

Expand All @@ -251,3 +266,22 @@ mod paths_created_by_lowering {
}
}
}

// reused from #1997
mod generics {
struct Foo<T> {
value: T,
}

impl<T> Foo<T> {
// `Self` is applicable here
fn foo(value: T) -> Self<T> {
Self { value }
}

// `Cannot` use `Self` as a return type as the generic types are different
fn bar(value: i32) -> Foo<i32> {
Foo { value }
}
}
}
Loading

0 comments on commit 2e3a7e3

Please sign in to comment.