use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::ty::same_type_and_consts;
-use clippy_utils::{in_macro, meets_msrv, msrvs};
+use clippy_utils::{meets_msrv, msrvs};
use if_chain::if_chain;
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::Applicability;
self as hir,
def::{CtorOf, DefKind, Res},
def_id::LocalDefId,
- intravisit::{walk_ty, walk_inf, NestedVisitorMap, Visitor},
- Expr, ExprKind, FnRetTy, FnSig, GenericArg, HirId, Impl, ImplItemKind, Item, ItemKind, Node, Path, PathSegment,
- QPath, TyKind,
+ 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::ty::AssocKind;
+use rustc_lint::{LateContext, LateLintPass};
use rustc_semver::RustcVersion;
use rustc_session::{declare_tool_lint, impl_lint_pass};
use rustc_span::Span;
use rustc_typeck::hir_ty_to_ty;
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:**
+ /// ### Known problems
/// - Unaddressed false negative in fn bodies of trait implementations
- /// - False positive with assotiated types in traits (#4140)
- ///
- /// **Example:**
+ /// - False positive with associated types in traits (#4140)
///
+ /// ### 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"
// trait, not in the impl of the trait.
let trait_method = cx
.tcx
- .associated_items(impl_trait_ref.def_id)
- .find_by_name_and_kind(cx.tcx, impl_item.ident, AssocKind::Fn, impl_trait_ref.def_id)
+ .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.def_id);
+ 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
fn check_ty(&mut self, cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) {
if_chain! {
- if !in_macro(hir_ty.span);
- if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+ 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 !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)
};
if same_type_and_consts(ty, cx.tcx.type_of(impl_id));
let hir = cx.tcx.hir();
- let id = hir.get_parent_node(hir_ty.hir_id);
- if !hir.opt_span(id).map_or(false, in_macro);
+ // prevents false positive on `#[derive(serde::Deserialize)]`
+ if !hir.span(hir.get_parent_node(hir_ty.hir_id)).in_derive_expansion();
then {
span_lint(cx, hir_ty.span);
}
fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
if_chain! {
- if !in_macro(expr.span);
- if meets_msrv(self.msrv.as_ref(), &msrvs::TYPE_ALIAS_ENUM_VARIANTS);
+ 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::SelfTy { .. } => (),
Res::Def(DefKind::Variant, _) => lint_path_to_variant(cx, path),
_ => span_lint(cx, path.span),
},
}
}
+ 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);
}
}
impl<'tcx> Visitor<'tcx> for SkipTyCollector {
- type Map = Map<'tcx>;
-
fn visit_infer(&mut self, inf: &hir::InferArg) {
- self.types_to_skip.push(inf.hir_id);
+ self.types_to_skip.push(inf.hir_id);
- walk_inf(self, inf)
+ walk_inf(self, inf);
}
fn visit_ty(&mut self, hir_ty: &hir::Ty<'_>) {
self.types_to_skip.push(hir_ty.hir_id);
walk_ty(self, hir_ty);
}
-
- fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
- NestedVisitorMap::None
- }
-}
-
-<<<<<<< HEAD
-=======
-struct LintTyCollector<'a, 'tcx> {
- cx: &'a LateContext<'tcx>,
- self_ty: Ty<'tcx>,
- types_to_lint: Vec<HirId>,
- types_to_skip: Vec<HirId>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for LintTyCollector<'a, 'tcx> {
- type Map = Map<'tcx>;
-
- fn visit_ty(&mut self, hir_ty: &'tcx hir::Ty<'_>) {
- if_chain! {
- if let Some(ty) = self.cx.typeck_results().node_type_opt(hir_ty.hir_id);
- if should_lint_ty(hir_ty, ty, self.self_ty);
- then {
- self.types_to_lint.push(hir_ty.hir_id);
- } else {
- self.types_to_skip.push(hir_ty.hir_id);
- }
- }
-
- walk_ty(self, hir_ty);
- }
-
- fn visit_infer(&mut self, inf: &'tcx hir::InferArg) {
- if_chain! {
- if let Some(ty) = self.cx.typeck_results().node_type_opt(inf.hir_id);
- if should_lint_ty(&inf.to_ty(), ty, self.self_ty);
- then {
- self.types_to_lint.push(inf.hir_id);
- } else {
- self.types_to_skip.push(inf.hir_id);
- }
- }
-
- walk_inf(self, inf)
- }
-
- fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
- NestedVisitorMap::None
- }
}
->>>>>>> Add inferred args to typeck
fn span_lint(cx: &LateContext<'_>, span: Span) {
span_lint_and_sugg(
cx,