From 59b0077565bc056283dad048a237dbc183000c76 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Thu, 1 Dec 2016 22:31:56 +0100 Subject: [PATCH 01/15] WIP compiles and doesn't crash (much) but tests are failing --- CHANGELOG.md | 3 + clippy_lints/src/attrs.rs | 8 +- clippy_lints/src/bit_mask.rs | 19 ++-- clippy_lints/src/blacklisted_name.rs | 2 +- clippy_lints/src/consts.rs | 33 +++---- clippy_lints/src/copies.rs | 2 +- clippy_lints/src/derive.rs | 6 +- clippy_lints/src/drop_ref.rs | 4 +- clippy_lints/src/enum_glob_use.rs | 24 +---- clippy_lints/src/eta_reduction.rs | 4 +- clippy_lints/src/eval_order_dependence.rs | 50 +++++----- clippy_lints/src/format.rs | 10 +- clippy_lints/src/functions.rs | 11 ++- .../src/if_let_redundant_pattern_matching.rs | 2 +- clippy_lints/src/let_if_seq.rs | 21 ++--- clippy_lints/src/lib.rs | 2 +- clippy_lints/src/lifetimes.rs | 14 +-- clippy_lints/src/loops.rs | 92 ++++++++++--------- clippy_lints/src/map_clone.rs | 6 +- clippy_lints/src/matches.rs | 4 +- clippy_lints/src/mem_forget.rs | 4 +- clippy_lints/src/methods.rs | 8 +- clippy_lints/src/minmax.rs | 4 +- clippy_lints/src/misc.rs | 42 +++++---- clippy_lints/src/mut_reference.rs | 2 +- clippy_lints/src/needless_borrow.rs | 2 +- clippy_lints/src/no_effect.rs | 37 +++++--- clippy_lints/src/ok_if_let.rs | 2 +- .../src/overflow_check_conditional.rs | 12 +-- clippy_lints/src/panic.rs | 5 +- clippy_lints/src/partialeq_ne_impl.rs | 2 +- clippy_lints/src/print.rs | 17 ++-- clippy_lints/src/ptr.rs | 4 +- clippy_lints/src/ranges.rs | 18 ++-- clippy_lints/src/regex.rs | 4 +- clippy_lints/src/serde.rs | 2 +- clippy_lints/src/shadow.rs | 18 ++-- clippy_lints/src/swap.rs | 4 +- clippy_lints/src/transmute.rs | 9 +- clippy_lints/src/types.rs | 28 +++--- clippy_lints/src/unsafe_removed_from_name.rs | 17 ++-- clippy_lints/src/unused_label.rs | 2 +- clippy_lints/src/utils/higher.rs | 23 +---- clippy_lints/src/utils/hir.rs | 69 +++++++++----- clippy_lints/src/utils/inspector.rs | 32 ++++--- clippy_lints/src/utils/internal_lints.rs | 4 +- clippy_lints/src/utils/mod.rs | 46 ++++++++-- 47 files changed, 387 insertions(+), 347 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c08d567ec52f..9f798c31af18 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,9 @@ # Change Log All notable changes to this project will be documented in this file. +## 0.0.104 — 2016-12-01 +* Update to *rustc 1.15.0-nightly (1c448574b 2016-11-28)* + ## 0.0.103 — 2016-11-25 * Update to *rustc 1.15.0-nightly (d5814b03e 2016-11-23)* diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index f03dcbc5a9aa..0d5e5a4cde6b 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -105,7 +105,7 @@ impl LateLintPass for AttrPass { } match item.node { ItemExternCrate(_) | - ItemUse(_) => { + ItemUse(_, _) => { for attr in &item.attrs { if let MetaItemKind::List(ref lint_list) = attr.value.node { match &*attr.name().as_str() { @@ -113,7 +113,7 @@ impl LateLintPass for AttrPass { // whitelist `unused_imports` for lint in lint_list { if is_word(lint, "unused_imports") { - if let ItemUse(_) = item.node { + if let ItemUse(_, _) = item.node { return; } } @@ -193,8 +193,8 @@ fn is_relevant_expr(cx: &LateContext, expr: &Expr) -> bool { ExprRet(Some(ref e)) => is_relevant_expr(cx, e), ExprRet(None) | ExprBreak(_, None) => false, ExprCall(ref path_expr, _) => { - if let ExprPath(..) = path_expr.node { - let fun_id = resolve_node(cx, path_expr.id).expect("function should be resolved").def_id(); + if let ExprPath(ref qpath) = path_expr.node { + let fun_id = resolve_node(cx, qpath, path_expr.id).def_id(); !match_def_path(cx, fun_id, &paths::BEGIN_PANIC) } else { true diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs index b021079fd975..8a4664d62b72 100644 --- a/clippy_lints/src/bit_mask.rs +++ b/clippy_lints/src/bit_mask.rs @@ -1,5 +1,5 @@ use rustc::hir::*; -use rustc::hir::def::{Def, PathResolution}; +use rustc::hir::def::Def; use rustc::lint::*; use rustc_const_eval::lookup_const_by_id; use syntax::ast::LitKind; @@ -245,18 +245,13 @@ fn fetch_int_literal(cx: &LateContext, lit: &Expr) -> Option { None } } - ExprPath(_, _) => { - { - // Important to let the borrow expire before the const lookup to avoid double - // borrowing. - let def_map = cx.tcx.def_map.borrow(); - match def_map.get(&lit.id) { - Some(&PathResolution { base_def: Def::Const(def_id), .. }) => Some(def_id), - _ => None, - } + ExprPath(ref qpath) => { + let def = cx.tcx.tables().qpath_def(qpath, lit.id); + if let Def::Const(def_id) = def { + lookup_const_by_id(cx.tcx, def_id, None).and_then(|(l, _ty)| fetch_int_literal(cx, l)) + } else { + None } - .and_then(|def_id| lookup_const_by_id(cx.tcx, def_id, None)) - .and_then(|(l, _ty)| fetch_int_literal(cx, l)) } _ => None, } diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs index 55d0efd35362..ce7adda092cd 100644 --- a/clippy_lints/src/blacklisted_name.rs +++ b/clippy_lints/src/blacklisted_name.rs @@ -39,7 +39,7 @@ impl LintPass for BlackListedName { impl LateLintPass for BlackListedName { fn check_pat(&mut self, cx: &LateContext, pat: &Pat) { - if let PatKind::Binding(_, ref ident, _) = pat.node { + if let PatKind::Binding(_, _, ref ident, _) = pat.node { if self.blacklist.iter().any(|s| s == &*ident.node.as_str()) { span_lint(cx, BLACKLISTED_NAME, diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs index 89c57bba233b..afbf9666b10a 100644 --- a/clippy_lints/src/consts.rs +++ b/clippy_lints/src/consts.rs @@ -1,7 +1,7 @@ #![allow(cast_possible_truncation)] use rustc::lint::LateContext; -use rustc::hir::def::{Def, PathResolution}; +use rustc::hir::def::Def; use rustc_const_eval::lookup_const_by_id; use rustc_const_math::{ConstInt, ConstUsize, ConstIsize}; use rustc::hir::*; @@ -10,7 +10,7 @@ use std::cmp::PartialOrd; use std::hash::{Hash, Hasher}; use std::mem; use std::rc::Rc; -use syntax::ast::{FloatTy, LitIntType, LitKind, StrStyle, UintTy, IntTy}; +use syntax::ast::{FloatTy, LitIntType, LitKind, StrStyle, UintTy, IntTy, NodeId}; use syntax::ptr::P; #[derive(Debug, Copy, Clone)] @@ -252,7 +252,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { /// simple constant folding: Insert an expression, get a constant or none. fn expr(&mut self, e: &Expr) -> Option { match e.node { - ExprPath(_, _) => self.fetch_path(e), + ExprPath(ref qpath) => self.fetch_path(qpath, e.id), ExprBlock(ref block) => self.block(block), ExprIf(ref cond, ref then, ref otherwise) => self.ifthenelse(cond, then, otherwise), ExprLit(ref lit) => Some(lit_to_constant(&lit.node)), @@ -285,21 +285,22 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { } /// lookup a possibly constant expression from a ExprPath - fn fetch_path(&mut self, e: &Expr) -> Option { + fn fetch_path(&mut self, qpath: &QPath, id: NodeId) -> Option { if let Some(lcx) = self.lcx { - let mut maybe_id = None; - if let Some(&PathResolution { base_def: Def::Const(id), .. }) = lcx.tcx.def_map.borrow().get(&e.id) { - maybe_id = Some(id); - } - // separate if lets to avoid double borrowing the def_map - if let Some(id) = maybe_id { - if let Some((const_expr, _ty)) = lookup_const_by_id(lcx.tcx, id, None) { - let ret = self.expr(const_expr); - if ret.is_some() { - self.needed_resolution = true; + let def = lcx.tcx.tables().qpath_def(qpath, id); + match def { + Def::Const(def_id) | Def::AssociatedConst(def_id) => { + let substs = Some(lcx.tcx.tables().node_id_item_substs(id) + .unwrap_or_else(|| lcx.tcx.intern_substs(&[]))); + if let Some((const_expr, _ty)) = lookup_const_by_id(lcx.tcx, def_id, substs) { + let ret = self.expr(const_expr); + if ret.is_some() { + self.needed_resolution = true; + } + return ret; } - return ret; - } + }, + _ => {}, } } None diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs index b46fda3d2f20..726b8f214fa8 100644 --- a/clippy_lints/src/copies.rs +++ b/clippy_lints/src/copies.rs @@ -254,7 +254,7 @@ fn bindings<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, pat: &Pat) -> HashMap { + PatKind::Binding(_, _, ref ident, ref as_pat) => { if let Entry::Vacant(v) = map.entry(ident.node.as_str()) { v.insert(cx.tcx.tables().pat_ty(pat)); } diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs index 59687aa191be..35ea620c1283 100644 --- a/clippy_lints/src/derive.rs +++ b/clippy_lints/src/derive.rs @@ -5,7 +5,7 @@ use rustc::ty; use rustc::hir::*; use syntax::codemap::Span; use utils::paths; -use utils::{is_automatically_derived, match_path, span_lint_and_then}; +use utils::{is_automatically_derived, span_lint_and_then, match_path_old}; /// **What it does:** Checks for deriving `Hash` but implementing `PartialEq` /// explicitly. @@ -89,7 +89,7 @@ impl LateLintPass for Derive { fn check_hash_peq<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, span: Span, trait_ref: &TraitRef, ty: ty::Ty<'tcx>, hash_is_automatically_derived: bool) { if_let_chain! {[ - match_path(&trait_ref.path, &paths::HASH), + match_path_old(&trait_ref.path, &paths::HASH), let Some(peq_trait_def_id) = cx.tcx.lang_items.eq_trait() ], { let peq_trait_def = cx.tcx.lookup_trait_def(peq_trait_def_id); @@ -131,7 +131,7 @@ fn check_hash_peq<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, span: Span, trait_re /// Implementation of the `EXPL_IMPL_CLONE_ON_COPY` lint. fn check_copy_clone<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, item: &Item, trait_ref: &TraitRef, ty: ty::Ty<'tcx>) { - if match_path(&trait_ref.path, &paths::CLONE_TRAIT) { + if match_path_old(&trait_ref.path, &paths::CLONE_TRAIT) { let parameter_environment = ty::ParameterEnvironment::for_item(cx.tcx, item.id); let subst_ty = ty.subst(cx.tcx, parameter_environment.free_substs); diff --git a/clippy_lints/src/drop_ref.rs b/clippy_lints/src/drop_ref.rs index b369a3ae386e..dc240a0df7d5 100644 --- a/clippy_lints/src/drop_ref.rs +++ b/clippy_lints/src/drop_ref.rs @@ -38,8 +38,8 @@ impl LintPass for Pass { impl LateLintPass for Pass { fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { if let ExprCall(ref path, ref args) = expr.node { - if let ExprPath(None, _) = path.node { - let def_id = cx.tcx.expect_def(path.id).def_id(); + if let ExprPath(ref qpath) = path.node { + let def_id = cx.tcx.tables().qpath_def(qpath, path.id).def_id(); if match_def_path(cx, def_id, &paths::DROP) { if args.len() != 1 { return; diff --git a/clippy_lints/src/enum_glob_use.rs b/clippy_lints/src/enum_glob_use.rs index 4641bb054313..f4f8d6f378b7 100644 --- a/clippy_lints/src/enum_glob_use.rs +++ b/clippy_lints/src/enum_glob_use.rs @@ -2,8 +2,7 @@ use rustc::hir::*; use rustc::hir::def::Def; -use rustc::hir::map::Node::NodeItem; -use rustc::lint::{LateLintPass, LintPass, LateContext, LintArray, LintContext}; +use rustc::lint::{LateLintPass, LintPass, LateContext, LintArray}; use syntax::ast::NodeId; use syntax::codemap::Span; use utils::span_lint; @@ -48,24 +47,9 @@ impl EnumGlobUse { if item.vis == Visibility::Public { return; // re-exports are fine } - if let ItemUse(ref item_use) = item.node { - if let ViewPath_::ViewPathGlob(_) = item_use.node { - if let Some(def) = cx.tcx.def_map.borrow().get(&item.id) { - if let Some(node_id) = cx.tcx.map.as_local_node_id(def.full_def().def_id()) { - if let Some(NodeItem(it)) = cx.tcx.map.find(node_id) { - if let ItemEnum(..) = it.node { - span_lint(cx, ENUM_GLOB_USE, item.span, "don't use glob imports for enum variants"); - } - } - } else { - let child = cx.sess().cstore.item_children(def.full_def().def_id()); - if let Some(child) = child.first() { - if let Def::Variant(..) = child.def { - span_lint(cx, ENUM_GLOB_USE, item.span, "don't use glob imports for enum variants"); - } - } - } - } + if let ItemUse(ref path, UseKind::Glob) = item.node { + if let Def::Enum(_) = path.def { + span_lint(cx, ENUM_GLOB_USE, item.span, "don't use glob imports for enum variants"); } } } diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs index ee0767f57dfd..d915755fbd12 100644 --- a/clippy_lints/src/eta_reduction.rs +++ b/clippy_lints/src/eta_reduction.rs @@ -72,9 +72,9 @@ fn check_closure(cx: &LateContext, expr: &Expr) { _ => (), } for (a1, a2) in decl.inputs.iter().zip(args) { - if let PatKind::Binding(_, ident, _) = a1.pat.node { + if let PatKind::Binding(_, _, ident, _) = a1.pat.node { // XXXManishearth Should I be checking the binding mode here? - if let ExprPath(None, ref p) = a2.node { + if let ExprPath(QPath::Resolved(None, ref p)) = a2.node { if p.segments.len() != 1 { // If it's a proper path, it can't be a local variable return; diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs index d3c06a581791..5998f4151297 100644 --- a/clippy_lints/src/eval_order_dependence.rs +++ b/clippy_lints/src/eval_order_dependence.rs @@ -61,16 +61,18 @@ impl LateLintPass for EvalOrderDependence { // Find a write to a local variable. match expr.node { ExprAssign(ref lhs, _) | ExprAssignOp(_, ref lhs, _) => { - if let ExprPath(None, ref path) = lhs.node { - if path.segments.len() == 1 { - let var = cx.tcx.expect_def(lhs.id).def_id(); - let mut visitor = ReadVisitor { - cx: cx, - var: var, - write_expr: expr, - last_expr: expr, - }; - check_for_unsequenced_reads(&mut visitor); + if let ExprPath(ref qpath) = lhs.node { + if let QPath::Resolved(_, ref path) = *qpath { + if path.segments.len() == 1 { + let var = cx.tcx.tables().qpath_def(qpath, lhs.id).def_id(); + let mut visitor = ReadVisitor { + cx: cx, + var: var, + write_expr: expr, + last_expr: expr, + }; + check_for_unsequenced_reads(&mut visitor); + } } } } @@ -293,19 +295,21 @@ impl<'v, 't> Visitor<'v> for ReadVisitor<'v, 't> { } match expr.node { - ExprPath(None, ref path) => { - if path.segments.len() == 1 && self.cx.tcx.expect_def(expr.id).def_id() == self.var { - if is_in_assignment_position(self.cx, expr) { - // This is a write, not a read. - } else { - span_note_and_lint( - self.cx, - EVAL_ORDER_DEPENDENCE, - expr.span, - "unsequenced read of a variable", - self.write_expr.span, - "whether read occurs before this write depends on evaluation order" - ); + ExprPath(ref qpath) => { + if let QPath::Resolved(None, ref path) = *qpath { + if path.segments.len() == 1 && self.cx.tcx.tables().qpath_def(qpath, expr.id).def_id() == self.var { + if is_in_assignment_position(self.cx, expr) { + // This is a write, not a read. + } else { + span_note_and_lint( + self.cx, + EVAL_ORDER_DEPENDENCE, + expr.span, + "unsequenced read of a variable", + self.write_expr.span, + "whether read occurs before this write depends on evaluation order" + ); + } } } } diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs index 5a2c5f5c852e..92970bc5e01b 100644 --- a/clippy_lints/src/format.rs +++ b/clippy_lints/src/format.rs @@ -45,10 +45,9 @@ impl LateLintPass for Pass { // `format!("{}", foo)` expansion ExprCall(ref fun, ref args) => { if_let_chain!{[ - let ExprPath(..) = fun.node, + let ExprPath(ref qpath) = fun.node, args.len() == 2, - let Some(fun) = resolve_node(cx, fun.id), - match_def_path(cx, fun.def_id(), &paths::FMT_ARGUMENTS_NEWV1), + match_def_path(cx, resolve_node(cx, qpath, fun.id).def_id(), &paths::FMT_ARGUMENTS_NEWV1), // ensure the format string is `"{..}"` with only one argument and no text check_static_str(cx, &args[0]), // ensure the format argument is `{}` ie. Display with no fancy option @@ -129,9 +128,8 @@ fn check_arg_is_display(cx: &LateContext, expr: &Expr) -> bool { exprs.len() == 1, let ExprCall(_, ref args) = exprs[0].node, args.len() == 2, - let ExprPath(None, _) = args[1].node, - let Some(fun) = resolve_node(cx, args[1].id), - match_def_path(cx, fun.def_id(), &paths::DISPLAY_FMT_METHOD), + let ExprPath(ref qpath) = args[1].node, + match_def_path(cx, resolve_node(cx, qpath, args[1].id).def_id(), &paths::DISPLAY_FMT_METHOD), ], { let ty = walk_ptrs_ty(cx.tcx.tables().pat_ty(&pat[0])); diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index c6f17b615b62..82f210f3d507 100644 --- a/clippy_lints/src/functions.rs +++ b/clippy_lints/src/functions.rs @@ -138,9 +138,9 @@ impl Functions { } } -fn raw_ptr_arg(cx: &LateContext, arg: &hir::Arg) -> Option { - if let (&hir::PatKind::Binding(_, _, _), &hir::TyPtr(_)) = (&arg.pat.node, &arg.ty.node) { - cx.tcx.def_map.borrow().get(&arg.pat.id).map(|pr| pr.full_def().def_id()) +fn raw_ptr_arg(_cx: &LateContext, arg: &hir::Arg) -> Option { + if let (&hir::PatKind::Binding(_, def_id, _, _), &hir::TyPtr(_)) = (&arg.pat.node, &arg.ty.node) { + Some(def_id) } else { None } @@ -183,8 +183,9 @@ impl<'a, 'tcx, 'v> hir::intravisit::Visitor<'v> for DerefVisitor<'a, 'tcx> { impl<'a, 'tcx: 'a> DerefVisitor<'a, 'tcx> { fn check_arg(&self, ptr: &hir::Expr) { - if let Some(def) = self.cx.tcx.def_map.borrow().get(&ptr.id) { - if self.ptrs.contains(&def.full_def().def_id()) { + if let hir::ExprPath(ref qpath) = ptr.node { + let def = self.cx.tcx.tables().qpath_def(qpath, ptr.id); + if self.ptrs.contains(&def.def_id()) { span_lint(self.cx, NOT_UNSAFE_PTR_ARG_DEREF, ptr.span, diff --git a/clippy_lints/src/if_let_redundant_pattern_matching.rs b/clippy_lints/src/if_let_redundant_pattern_matching.rs index 25ff7244cf16..878a1b7313b2 100644 --- a/clippy_lints/src/if_let_redundant_pattern_matching.rs +++ b/clippy_lints/src/if_let_redundant_pattern_matching.rs @@ -63,7 +63,7 @@ impl LateLintPass for Pass { } } - PatKind::Path(_, ref path) if match_path(path, &paths::OPTION_NONE) => { + PatKind::Path(ref path) if match_path(path, &paths::OPTION_NONE) => { "is_none()" } diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs index 598f1b3a57ab..e1f20eb1859f 100644 --- a/clippy_lints/src/let_if_seq.rs +++ b/clippy_lints/src/let_if_seq.rs @@ -65,19 +65,18 @@ impl LateLintPass for LetIfSeq { let Some(expr) = it.peek(), let hir::StmtDecl(ref decl, _) = stmt.node, let hir::DeclLocal(ref decl) = decl.node, - let hir::PatKind::Binding(mode, ref name, None) = decl.pat.node, - let Some(def) = cx.tcx.def_map.borrow().get(&decl.pat.id), + let hir::PatKind::Binding(mode, def_id, ref name, None) = decl.pat.node, let hir::StmtExpr(ref if_, _) = expr.node, let hir::ExprIf(ref cond, ref then, ref else_) = if_.node, - !used_in_expr(cx, def.full_def().def_id(), cond), - let Some(value) = check_assign(cx, def.full_def().def_id(), then), - !used_in_expr(cx, def.full_def().def_id(), value), + !used_in_expr(cx, def_id, cond), + let Some(value) = check_assign(cx, def_id, then), + !used_in_expr(cx, def_id, value), ], { let span = codemap::mk_sp(stmt.span.lo, if_.span.hi); let (default_multi_stmts, default) = if let Some(ref else_) = *else_ { if let hir::ExprBlock(ref else_) = else_.node { - if let Some(default) = check_assign(cx, def.full_def().def_id(), else_) { + if let Some(default) = check_assign(cx, def_id, else_) { (else_.stmts.len() > 1, default) } else if let Some(ref default) = decl.init { (true, &**default) @@ -137,9 +136,8 @@ struct UsedVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx, 'v> hir::intravisit::Visitor<'v> for UsedVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &'v hir::Expr) { if_let_chain! {[ - let hir::ExprPath(None, _) = expr.node, - let Some(def) = self.cx.tcx.def_map.borrow().get(&expr.id), - self.id == def.full_def().def_id(), + let hir::ExprPath(ref qpath) = expr.node, + self.id == self.cx.tcx.tables().qpath_def(qpath, expr.id).def_id(), ], { self.used = true; return; @@ -154,9 +152,8 @@ fn check_assign<'e>(cx: &LateContext, decl: hir::def_id::DefId, block: &'e hir:: let Some(expr) = block.stmts.iter().last(), let hir::StmtSemi(ref expr, _) = expr.node, let hir::ExprAssign(ref var, ref value) = expr.node, - let hir::ExprPath(None, _) = var.node, - let Some(def) = cx.tcx.def_map.borrow().get(&var.id), - decl == def.full_def().def_id(), + let hir::ExprPath(ref qpath) = var.node, + decl == cx.tcx.tables().qpath_def(qpath, var.id).def_id(), ], { let mut v = UsedVisitor { cx: cx, diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index a90f121fe79a..7e2b85df572e 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -256,7 +256,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) { reg.register_late_lint_pass(box functions::Functions::new(conf.too_many_arguments_threshold)); reg.register_early_lint_pass(box doc::Doc::new(conf.doc_valid_idents)); reg.register_late_lint_pass(box neg_multiply::NegMultiply); - reg.register_late_lint_pass(box unsafe_removed_from_name::UnsafeNameRemoval); + reg.register_early_lint_pass(box unsafe_removed_from_name::UnsafeNameRemoval); reg.register_late_lint_pass(box mem_forget::MemForget); reg.register_late_lint_pass(box arithmetic::Arithmetic::default()); reg.register_late_lint_pass(box assign_ops::AssignOps); diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index 710604b3a282..236919bfc253 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -239,12 +239,12 @@ impl<'v, 't> RefVisitor<'v, 't> { self.lts } - fn collect_anonymous_lifetimes(&mut self, path: &Path, ty: &Ty) { - let last_path_segment = path.segments.last().map(|s| &s.parameters); - if let Some(&AngleBracketedParameters(ref params)) = last_path_segment { - if params.lifetimes.is_empty() { - if let Some(def) = self.cx.tcx.def_map.borrow().get(&ty.id).map(|r| r.full_def()) { - match def { + fn collect_anonymous_lifetimes(&mut self, qpath: &QPath, ty: &Ty) { + if let QPath::Resolved(_, ref path) = *qpath { + let last_path_segment = path.segments.last().map(|s| &s.parameters); + if let Some(&AngleBracketedParameters(ref params)) = last_path_segment { + if params.lifetimes.is_empty() { + match self.cx.tcx.tables().qpath_def(qpath, ty.id) { Def::TyAlias(def_id) | Def::Struct(def_id) => { let generics = self.cx.tcx.item_generics(def_id); @@ -277,7 +277,7 @@ impl<'v, 't> Visitor<'v> for RefVisitor<'v, 't> { TyRptr(None, _) => { self.record(&None); } - TyPath(_, ref path) => { + TyPath(ref path) => { self.collect_anonymous_lifetimes(path, ty); } _ => (), diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index f5d9b91bb8c6..d752e78cddf8 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -366,26 +366,28 @@ impl LateLintPass for Pass { } if let ExprMatch(ref match_expr, ref arms, MatchSource::WhileLetDesugar) = expr.node { let pat = &arms[0].pats[0].node; - if let (&PatKind::TupleStruct(ref path, ref pat_args, _), + if let (&PatKind::TupleStruct(ref qpath, ref pat_args, _), &ExprMethodCall(method_name, _, ref method_args)) = (pat, &match_expr.node) { let iter_expr = &method_args[0]; - if let Some(lhs_constructor) = path.segments.last() { - if &*method_name.node.as_str() == "next" && - match_trait_method(cx, match_expr, &paths::ITERATOR) && - &*lhs_constructor.name.as_str() == "Some" && - !is_refutable(cx, &pat_args[0]) && - !is_iterator_used_after_while_let(cx, iter_expr) { - let iterator = snippet(cx, method_args[0].span, "_"); - let loop_var = snippet(cx, pat_args[0].span, "_"); - span_lint_and_then(cx, - WHILE_LET_ON_ITERATOR, - expr.span, - "this loop could be written as a `for` loop", - |db| { - db.span_suggestion(expr.span, - "try", - format!("for {} in {} {{ .. }}", loop_var, iterator)); - }); + if let QPath::Resolved(_, ref path) = *qpath { + if let Some(lhs_constructor) = path.segments.last() { + if &*method_name.node.as_str() == "next" && + match_trait_method(cx, match_expr, &paths::ITERATOR) && + &*lhs_constructor.name.as_str() == "Some" && + !is_refutable(cx, &pat_args[0]) && + !is_iterator_used_after_while_let(cx, iter_expr) { + let iterator = snippet(cx, method_args[0].span, "_"); + let loop_var = snippet(cx, pat_args[0].span, "_"); + span_lint_and_then(cx, + WHILE_LET_ON_ITERATOR, + expr.span, + "this loop could be written as a `for` loop", + |db| { + db.span_suggestion(expr.span, + "try", + format!("for {} in {} {{ .. }}", loop_var, iterator)); + }); + } } } } @@ -421,10 +423,10 @@ fn check_for_loop(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, expr: &E fn check_for_loop_range(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, expr: &Expr) { if let Some(higher::Range { start: Some(start), ref end, limits }) = higher::range(arg) { // the var must be a single name - if let PatKind::Binding(_, ref ident, _) = pat.node { + if let PatKind::Binding(_, def_id, ref ident, _) = pat.node { let mut visitor = VarVisitor { cx: cx, - var: cx.tcx.expect_def(pat.id).def_id(), + var: def_id, indexed: HashMap::new(), nonindex: false, }; @@ -510,7 +512,7 @@ fn is_len_call(expr: &Expr, var: &Name) -> bool { let ExprMethodCall(method, _, ref len_args) = expr.node, len_args.len() == 1, &*method.node.as_str() == "len", - let ExprPath(_, ref path) = len_args[0].node, + let ExprPath(QPath::Resolved(_, ref path)) = len_args[0].node, path.segments.len() == 1, &path.segments[0].name == var ], { @@ -732,7 +734,7 @@ fn check_for_loop_over_map_kv(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Ex fn pat_is_wild(pat: &PatKind, body: &Expr) -> bool { match *pat { PatKind::Wild => true, - PatKind::Binding(_, ident, None) if ident.node.as_str().starts_with('_') => { + PatKind::Binding(_, _, ident, None) if ident.node.as_str().starts_with('_') => { let mut visitor = UsedVisitor { var: ident.node, used: false, @@ -751,7 +753,7 @@ struct UsedVisitor { impl<'a> Visitor<'a> for UsedVisitor { fn visit_expr(&mut self, expr: &Expr) { - if let ExprPath(None, ref path) = expr.node { + if let ExprPath(QPath::Resolved(None, ref path)) = expr.node { if path.segments.len() == 1 && path.segments[0].name == self.var { self.used = true; return; @@ -771,20 +773,21 @@ struct VarVisitor<'v, 't: 'v> { impl<'v, 't> Visitor<'v> for VarVisitor<'v, 't> { fn visit_expr(&mut self, expr: &'v Expr) { - if let ExprPath(None, ref path) = expr.node { - if path.segments.len() == 1 && self.cx.tcx.expect_def(expr.id).def_id() == self.var { - // we are referencing our variable! now check if it's as an index - if_let_chain! {[ - let Some(parexpr) = get_parent_expr(self.cx, expr), - let ExprIndex(ref seqexpr, _) = parexpr.node, - let ExprPath(None, ref seqvar) = seqexpr.node, - seqvar.segments.len() == 1 - ], { - let def_map = self.cx.tcx.def_map.borrow(); - if let Some(def) = def_map.get(&seqexpr.id) { - match def.base_def { + if let ExprPath(ref qpath) = expr.node { + if let QPath::Resolved(None, ref path) = *qpath { + if path.segments.len() == 1 && self.cx.tcx.tables().qpath_def(qpath, expr.id).def_id() == self.var { + // we are referencing our variable! now check if it's as an index + if_let_chain! {[ + let Some(parexpr) = get_parent_expr(self.cx, expr), + let ExprIndex(ref seqexpr, _) = parexpr.node, + let ExprPath(ref seqpath) = seqexpr.node, + let QPath::Resolved(None, ref seqvar) = *seqpath, + seqvar.segments.len() == 1 + ], { + let def = self.cx.tcx.tables().qpath_def(seqpath, seqexpr.id); + match def { Def::Local(..) | Def::Upvar(..) => { - let def_id = def.base_def.def_id(); + let def_id = def.def_id(); let node_id = self.cx.tcx.map.as_local_node_id(def_id).unwrap(); let extent = self.cx.tcx.region_maps.var_scope(node_id); @@ -797,11 +800,11 @@ impl<'v, 't> Visitor<'v> for VarVisitor<'v, 't> { } _ => (), } - } - }} - // we are not indexing anything, record that - self.nonindex = true; - return; + }} + // we are not indexing anything, record that + self.nonindex = true; + return; + } } } walk_expr(self, expr); @@ -1002,7 +1005,7 @@ impl<'v, 't> Visitor<'v> for InitializeVisitor<'v, 't> { // Look for declarations of the variable if let DeclLocal(ref local) = decl.node { if local.pat.id == self.var_id { - if let PatKind::Binding(_, ref ident, _) = local.pat.node { + if let PatKind::Binding(_, _, ref ident, _) = local.pat.node { self.name = Some(ident.node); self.state = if let Some(ref init) = local.init { @@ -1071,8 +1074,9 @@ impl<'v, 't> Visitor<'v> for InitializeVisitor<'v, 't> { } fn var_def_id(cx: &LateContext, expr: &Expr) -> Option { - if let Some(path_res) = cx.tcx.def_map.borrow().get(&expr.id) { - if let Def::Local(def_id) = path_res.base_def { + if let ExprPath(ref qpath) = expr.node { + let path_res = cx.tcx.tables().qpath_def(qpath, expr.id); + if let Def::Local(def_id) = path_res { let node_id = cx.tcx.map.as_local_node_id(def_id).expect("That DefId should be valid"); return Some(node_id); } diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs index 07bbc7038264..9d9b0a6e35bb 100644 --- a/clippy_lints/src/map_clone.rs +++ b/clippy_lints/src/map_clone.rs @@ -64,7 +64,7 @@ impl LateLintPass for Pass { } }} } - ExprPath(_, ref path) => { + ExprPath(ref path) => { if match_path(path, &paths::CLONE) { let type_name = get_type_name(cx, expr, &args[0]).unwrap_or("_"); span_help_and_lint(cx, @@ -85,7 +85,7 @@ impl LateLintPass for Pass { fn expr_eq_name(expr: &Expr, id: ast::Name) -> bool { match expr.node { - ExprPath(None, ref path) => { + ExprPath(QPath::Resolved(None, ref path)) => { let arg_segment = [PathSegment { name: id, parameters: PathParameters::none(), @@ -108,7 +108,7 @@ fn get_type_name(cx: &LateContext, expr: &Expr, arg: &Expr) -> Option<&'static s fn get_arg_name(pat: &Pat) -> Option { match pat.node { - PatKind::Binding(_, name, None) => Some(name.node), + PatKind::Binding(_, _, name, None) => Some(name.node), PatKind::Ref(ref subpat, _) => get_arg_name(subpat), _ => None, } diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index 844715835b99..828e7eda0263 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -210,8 +210,8 @@ fn check_single_match_opt_like(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: } path.to_string() } - PatKind::Binding(BindByValue(MutImmutable), ident, None) => ident.node.to_string(), - PatKind::Path(None, ref path) => path.to_string(), + PatKind::Binding(BindByValue(MutImmutable), _, ident, None) => ident.node.to_string(), + PatKind::Path(ref path) => path.to_string(), _ => return, }; diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs index 492962def6ab..288c238474fe 100644 --- a/clippy_lints/src/mem_forget.rs +++ b/clippy_lints/src/mem_forget.rs @@ -30,8 +30,8 @@ impl LintPass for MemForget { impl LateLintPass for MemForget { fn check_expr(&mut self, cx: &LateContext, e: &Expr) { if let ExprCall(ref path_expr, ref args) = e.node { - if let ExprPath(None, _) = path_expr.node { - let def_id = cx.tcx.expect_def(path_expr.id).def_id(); + if let ExprPath(ref qpath) = path_expr.node { + let def_id = cx.tcx.tables().qpath_def(qpath, path_expr.id).def_id(); if match_def_path(cx, def_id, &paths::MEM_FORGET) { let forgot_ty = cx.tcx.tables().expr_ty(&args[0]); diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index 53c6eae91884..1a824e467c49 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -701,7 +701,7 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir: } if name == "unwrap_or" { - if let hir::ExprPath(_, ref path) = fun.node { + if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = fun.node { let path: &str = &path.segments .last() .expect("A path must have at least one segment") @@ -877,7 +877,7 @@ fn lint_cstring_as_ptr(cx: &LateContext, expr: &hir::Expr, new: &hir::Expr, unwr if_let_chain!{[ let hir::ExprCall(ref fun, ref args) = new.node, args.len() == 1, - let hir::ExprPath(None, ref path) = fun.node, + let hir::ExprPath(ref path) = fun.node, match_path(path, &paths::CSTRING_NEW), ], { span_lint_and_then(cx, TEMPORARY_CSTRING_AS_PTR, expr.span, @@ -1188,7 +1188,7 @@ fn lint_chars_next(cx: &LateContext, expr: &hir::Expr, chain: &hir::Expr, other: let Some(args) = method_chain_args(chain, &["chars", "next"]), let hir::ExprCall(ref fun, ref arg_char) = other.node, arg_char.len() == 1, - let hir::ExprPath(None, ref path) = fun.node, + let hir::ExprPath(hir::QPath::Resolved(None, ref path)) = fun.node, path.segments.len() == 1 && &*path.segments[0].name.as_str() == "Some" ], { let self_ty = walk_ptrs_ty(cx.tcx.tables().expr_ty_adjusted(&args[0][0])); @@ -1408,7 +1408,7 @@ impl OutType { } fn is_bool(ty: &hir::Ty) -> bool { - if let hir::TyPath(None, ref p) = ty.node { + if let hir::TyPath(ref p) = ty.node { match_path(p, &["bool"]) } else { false diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs index 771408a9be63..2b453f1c8806 100644 --- a/clippy_lints/src/minmax.rs +++ b/clippy_lints/src/minmax.rs @@ -61,8 +61,8 @@ enum MinMax { fn min_max<'a>(cx: &LateContext, expr: &'a Expr) -> Option<(MinMax, Constant, &'a Expr)> { if let ExprCall(ref path, ref args) = expr.node { - if let ExprPath(None, _) = path.node { - let def_id = cx.tcx.expect_def(path.id).def_id(); + if let ExprPath(ref qpath) = path.node { + let def_id = cx.tcx.tables().qpath_def(qpath, path.id).def_id(); if match_def_path(cx, def_id, &paths::CMP_MIN) { fetch_const(args, MinMax::Min) diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index 6ad633489200..854a8d144d68 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -173,7 +173,7 @@ impl LateLintPass for Pass { return; } for arg in &decl.inputs { - if let PatKind::Binding(BindByRef(_), _, _) = arg.pat.node { + if let PatKind::Binding(BindByRef(_), _, _, _) = arg.pat.node { span_lint(cx, TOPLEVEL_REF_ARG, arg.pat.span, @@ -186,7 +186,7 @@ impl LateLintPass for Pass { if_let_chain! {[ let StmtDecl(ref d, _) = s.node, let DeclLocal(ref l) = d.node, - let PatKind::Binding(BindByRef(mt), i, None) = l.pat.node, + let PatKind::Binding(BindByRef(mt), _, i, None) = l.pat.node, let Some(ref init) = l.init ], { let init = Sugg::hir(cx, init, ".."); @@ -220,10 +220,10 @@ impl LateLintPass for Pass { if let ExprBinary(ref cmp, ref left, ref right) = expr.node { let op = cmp.node; if op.is_comparison() { - if let ExprPath(_, ref path) = left.node { + if let ExprPath(QPath::Resolved(_, ref path)) = left.node { check_nan(cx, path, expr.span); } - if let ExprPath(_, ref path) = right.node { + if let ExprPath(QPath::Resolved(_, ref path)) = right.node { check_nan(cx, path, expr.span); } check_to_owned(cx, left, right, true, cmp.span); @@ -262,19 +262,23 @@ impl LateLintPass for Pass { return; } let binding = match expr.node { - ExprPath(_, ref path) => { - let binding = path.segments - .last() - .expect("path should always have at least one segment") - .name - .as_str(); - if binding.starts_with('_') && - !binding.starts_with("__") && - &*binding != "_result" && // FIXME: #944 - is_used(cx, expr) && - // don't lint if the declaration is in a macro - non_macro_local(cx, &cx.tcx.expect_def(expr.id)) { - Some(binding) + ExprPath(ref qpath) => { + if let QPath::Resolved(_, ref path) = *qpath { + let binding = path.segments + .last() + .expect("path should always have at least one segment") + .name + .as_str(); + if binding.starts_with('_') && + !binding.starts_with("__") && + &*binding != "_result" && // FIXME: #944 + is_used(cx, expr) && + // don't lint if the declaration is in a macro + non_macro_local(cx, &cx.tcx.tables().qpath_def(qpath, expr.id)) { + Some(binding) + } else { + None + } } else { None } @@ -299,7 +303,7 @@ impl LateLintPass for Pass { } fn check_pat(&mut self, cx: &LateContext, pat: &Pat) { - if let PatKind::Binding(_, ref ident, Some(ref right)) = pat.node { + if let PatKind::Binding(_, _, ref ident, Some(ref right)) = pat.node { if right.node == PatKind::Wild { span_lint(cx, REDUNDANT_PATTERN, @@ -366,7 +370,7 @@ fn check_to_owned(cx: &LateContext, expr: &Expr, other: &Expr, left: bool, op: S } } ExprCall(ref path, ref v) if v.len() == 1 => { - if let ExprPath(None, ref path) = path.node { + if let ExprPath(ref path) = path.node { if match_path(path, &["String", "from_str"]) || match_path(path, &["String", "from"]) { (cx.tcx.tables().expr_ty(&v[0]), snippet(cx, v[0].span, "..")) } else { diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs index b2cdb2cb49b4..eadf0d8ce89c 100644 --- a/clippy_lints/src/mut_reference.rs +++ b/clippy_lints/src/mut_reference.rs @@ -42,7 +42,7 @@ impl LateLintPass for UnnecessaryMutPassed { .expect("A function with an unknown type is called. \ If this happened, the compiler would have \ aborted the compilation long ago"); - if let ExprPath(_, ref path) = fn_expr.node { + if let ExprPath(ref path) = fn_expr.node { check_arguments(cx, arguments, function_type, &path.to_string()); } } diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs index b2199c226e96..459b4faec5dd 100644 --- a/clippy_lints/src/needless_borrow.rs +++ b/clippy_lints/src/needless_borrow.rs @@ -57,7 +57,7 @@ impl LateLintPass for NeedlessBorrow { if in_macro(cx, pat.span) { return; } - if let PatKind::Binding(BindingMode::BindByRef(MutImmutable), _, _) = pat.node { + if let PatKind::Binding(BindingMode::BindByRef(MutImmutable), _, _, _) = pat.node { if let ty::TyRef(_, ref tam) = cx.tcx.tables().pat_ty(pat).sty { if tam.mutbl == MutImmutable { if let ty::TyRef(..) = tam.ty.sty { diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs index 973daa696b64..825aafb4be55 100644 --- a/clippy_lints/src/no_effect.rs +++ b/clippy_lints/src/no_effect.rs @@ -1,5 +1,5 @@ use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use rustc::hir::def::{Def, PathResolution}; +use rustc::hir::def::Def; use rustc::hir::{Expr, Expr_, Stmt, StmtSemi, BlockCheckMode, UnsafeSource}; use utils::{in_macro, span_lint, snippet_opt, span_lint_and_then}; use std::ops::Deref; @@ -68,13 +68,17 @@ fn has_no_effect(cx: &LateContext, expr: &Expr) -> bool { } } Expr_::ExprCall(ref callee, ref args) => { - let def = cx.tcx.def_map.borrow().get(&callee.id).map(|d| d.full_def()); - match def { - Some(Def::Struct(..)) | - Some(Def::Variant(..)) | - Some(Def::StructCtor(..)) | - Some(Def::VariantCtor(..)) => args.iter().all(|arg| has_no_effect(cx, arg)), - _ => false, + if let Expr_::ExprPath(ref qpath) = callee.node { + let def = cx.tcx.tables().qpath_def(qpath, callee.id); + match def { + Def::Struct(..) | + Def::Variant(..) | + Def::StructCtor(..) | + Def::VariantCtor(..) => args.iter().all(|arg| has_no_effect(cx, arg)), + _ => false, + } + } else { + false } } Expr_::ExprBlock(ref block) => { @@ -146,12 +150,17 @@ fn reduce_expression<'a>(cx: &LateContext, expr: &'a Expr) -> Option { - match cx.tcx.def_map.borrow().get(&callee.id).map(PathResolution::full_def) { - Some(Def::Struct(..)) | - Some(Def::Variant(..)) | - Some(Def::StructCtor(..)) | - Some(Def::VariantCtor(..)) => Some(args.iter().collect()), - _ => None, + if let Expr_::ExprPath(ref qpath) = callee.node { + let def = cx.tcx.tables().qpath_def(qpath, callee.id); + match def { + Def::Struct(..) | + Def::Variant(..) | + Def::StructCtor(..) | + Def::VariantCtor(..) => Some(args.iter().collect()), + _ => None, + } + } else { + None } } Expr_::ExprBlock(ref block) => { diff --git a/clippy_lints/src/ok_if_let.rs b/clippy_lints/src/ok_if_let.rs index 1fdfe43b6845..b7e7c70e41a5 100644 --- a/clippy_lints/src/ok_if_let.rs +++ b/clippy_lints/src/ok_if_let.rs @@ -46,7 +46,7 @@ impl LateLintPass for Pass { let ExprMatch(ref op, ref body, ref source) = expr.node, //test if expr is a match let MatchSource::IfLetDesugar { .. } = *source, //test if it is an If Let let ExprMethodCall(_, _, ref result_types) = op.node, //check is expr.ok() has type Result.ok() - let PatKind::TupleStruct(ref x, ref y, _) = body[0].pats[0].node, //get operation + let PatKind::TupleStruct(QPath::Resolved(_, ref x), ref y, _) = body[0].pats[0].node, //get operation method_chain_args(op, &["ok"]).is_some() //test to see if using ok() methoduse std::marker::Sized; ], { diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs index 98c2b986d202..06a1937e1927 100644 --- a/clippy_lints/src/overflow_check_conditional.rs +++ b/clippy_lints/src/overflow_check_conditional.rs @@ -35,9 +35,9 @@ impl LateLintPass for OverflowCheckConditional { if_let_chain! {[ let Expr_::ExprBinary(ref op, ref first, ref second) = expr.node, let Expr_::ExprBinary(ref op2, ref ident1, ref ident2) = first.node, - let Expr_::ExprPath(_,ref path1) = ident1.node, - let Expr_::ExprPath(_, ref path2) = ident2.node, - let Expr_::ExprPath(_, ref path3) = second.node, + let Expr_::ExprPath(QPath::Resolved(_, ref path1)) = ident1.node, + let Expr_::ExprPath(QPath::Resolved(_, ref path2)) = ident2.node, + let Expr_::ExprPath(QPath::Resolved(_, ref path3)) = second.node, &path1.segments[0] == &path3.segments[0] || &path2.segments[0] == &path3.segments[0], cx.tcx.tables().expr_ty(ident1).is_integral(), cx.tcx.tables().expr_ty(ident2).is_integral() @@ -57,9 +57,9 @@ impl LateLintPass for OverflowCheckConditional { if_let_chain! {[ let Expr_::ExprBinary(ref op, ref first, ref second) = expr.node, let Expr_::ExprBinary(ref op2, ref ident1, ref ident2) = second.node, - let Expr_::ExprPath(_,ref path1) = ident1.node, - let Expr_::ExprPath(_, ref path2) = ident2.node, - let Expr_::ExprPath(_, ref path3) = first.node, + let Expr_::ExprPath(QPath::Resolved(_, ref path1)) = ident1.node, + let Expr_::ExprPath(QPath::Resolved(_, ref path2)) = ident2.node, + let Expr_::ExprPath(QPath::Resolved(_, ref path3)) = first.node, &path1.segments[0] == &path3.segments[0] || &path2.segments[0] == &path3.segments[0], cx.tcx.tables().expr_ty(ident1).is_integral(), cx.tcx.tables().expr_ty(ident2).is_integral() diff --git a/clippy_lints/src/panic.rs b/clippy_lints/src/panic.rs index 97ad9173ef15..1d89c5ce507d 100644 --- a/clippy_lints/src/panic.rs +++ b/clippy_lints/src/panic.rs @@ -39,9 +39,8 @@ impl LateLintPass for Pass { let Some(ref ex) = block.expr, let ExprCall(ref fun, ref params) = ex.node, params.len() == 2, - let ExprPath(None, _) = fun.node, - let Some(fun) = resolve_node(cx, fun.id), - match_def_path(cx, fun.def_id(), &paths::BEGIN_PANIC), + let ExprPath(ref qpath) = fun.node, + match_def_path(cx, resolve_node(cx, qpath, fun.id).def_id(), &paths::BEGIN_PANIC), let ExprLit(ref lit) = params[0].node, is_direct_expn_of(cx, params[0].span, "panic").is_some(), let LitKind::Str(ref string, _) = lit.node, diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs index fdee5c256e19..8f25650bf585 100644 --- a/clippy_lints/src/partialeq_ne_impl.rs +++ b/clippy_lints/src/partialeq_ne_impl.rs @@ -40,7 +40,7 @@ impl LateLintPass for Pass { if_let_chain! {[ let ItemImpl(_, _, _, Some(ref trait_ref), _, ref impl_items) = item.node, !is_automatically_derived(&*item.attrs), - cx.tcx.expect_def(trait_ref.ref_id).def_id() == cx.tcx.lang_items.eq_trait().unwrap(), + trait_ref.path.def.def_id() == cx.tcx.lang_items.eq_trait().unwrap(), ], { for impl_item in impl_items { if &*impl_item.name.as_str() == "ne" { diff --git a/clippy_lints/src/print.rs b/clippy_lints/src/print.rs index 46d38a67a863..719d18bffebd 100644 --- a/clippy_lints/src/print.rs +++ b/clippy_lints/src/print.rs @@ -2,7 +2,7 @@ use rustc::hir::*; use rustc::hir::map::Node::{NodeItem, NodeImplItem}; use rustc::lint::*; use utils::paths; -use utils::{is_expn_of, match_path, match_def_path, resolve_node, span_lint}; +use utils::{is_expn_of, match_def_path, resolve_node, span_lint, match_path_old}; use format::get_argument_fmtstr_parts; /// **What it does:** This lint warns when you using `print!()` with a format string that @@ -69,9 +69,9 @@ impl LateLintPass for Pass { fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { if_let_chain! {[ let ExprCall(ref fun, ref args) = expr.node, - let ExprPath(..) = fun.node, - let Some(fun) = resolve_node(cx, fun.id), + let ExprPath(ref qpath) = fun.node, ], { + let fun = resolve_node(cx, qpath, fun.id); let fun_id = fun.def_id(); // Search for `std::io::_print(..)` which is unique in a @@ -93,9 +93,8 @@ impl LateLintPass for Pass { // ensure we're calling Arguments::new_v1 args.len() == 1, let ExprCall(ref args_fun, ref args_args) = args[0].node, - let ExprPath(..) = args_fun.node, - let Some(def) = resolve_node(cx, args_fun.id), - match_def_path(cx, def.def_id(), &paths::FMT_ARGUMENTS_NEWV1), + let ExprPath(ref qpath) = args_fun.node, + match_def_path(cx, resolve_node(cx, qpath, args_fun.id).def_id(), &paths::FMT_ARGUMENTS_NEWV1), args_args.len() == 2, let ExprAddrOf(_, ref match_expr) = args_args[1].node, let ExprMatch(ref args, _, _) = match_expr.node, @@ -121,8 +120,8 @@ impl LateLintPass for Pass { // Search for something like // `::std::fmt::ArgumentV1::new(__arg0, ::std::fmt::Debug::fmt)` else if args.len() == 2 && match_def_path(cx, fun_id, &paths::FMT_ARGUMENTV1_NEW) { - if let ExprPath(None, _) = args[1].node { - let def_id = resolve_node(cx, args[1].id).unwrap().def_id(); + if let ExprPath(ref qpath) = args[1].node { + let def_id = cx.tcx.tables().qpath_def(qpath, args[1].id).def_id(); if match_def_path(cx, def_id, &paths::DEBUG_FMT_METHOD) && !is_in_debug_impl(cx, expr) && is_expn_of(cx, expr.span, "panic").is_none() { span_lint(cx, USE_DEBUG, args[0].span, "use of `Debug`-based formatting"); @@ -141,7 +140,7 @@ fn is_in_debug_impl(cx: &LateContext, expr: &Expr) -> bool { // `Debug` impl if let Some(NodeItem(item)) = map.find(map.get_parent(item.id)) { if let ItemImpl(_, _, _, Some(ref tr), _, _) = item.node { - return match_path(&tr.path, &["Debug"]); + return match_path_old(&tr.path, &["Debug"]); } } } diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index 2863b14b1121..f210ec4dbc05 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -77,7 +77,7 @@ impl LateLintPass for PointerPass { check_fn(cx, &sig.decl, item.id); } } - + fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { if let ExprBinary(ref op, ref l, ref r) = expr.node { if (op.node == BiEq || op.node == BiNe) && (is_null_path(l) || is_null_path(r)) { @@ -116,7 +116,7 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, fn_id: NodeId) { fn is_null_path(expr: &Expr) -> bool { if let ExprCall(ref pathexp, ref args) = expr.node { if args.is_empty() { - if let ExprPath(_, ref path) = pathexp.node { + if let ExprPath(ref path) = pathexp.node { return match_path(path, &paths::PTR_NULL) || match_path(path, &paths::PTR_NULL_MUT) } } diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs index ab02a62ad292..791843ee567b 100644 --- a/clippy_lints/src/ranges.rs +++ b/clippy_lints/src/ranges.rs @@ -73,15 +73,19 @@ impl LateLintPass for StepByZero { let ExprMethodCall(Spanned { node: ref len_name, .. }, _, ref len_args) = end.node, &*len_name.as_str() == "len" && len_args.len() == 1, // .iter() and .len() called on same Path - let ExprPath(_, Path { segments: ref iter_path, .. }) = iter_args[0].node, - let ExprPath(_, Path { segments: ref len_path, .. }) = len_args[0].node, + let ExprPath(QPath::Resolved(_, ref iter_path)) = iter_args[0].node, + let ExprPath(QPath::Resolved(_, ref len_path)) = len_args[0].node, iter_path == len_path ], { - span_lint(cx, - RANGE_ZIP_WITH_LEN, - expr.span, - &format!("It is more idiomatic to use {}.iter().enumerate()", - snippet(cx, iter_args[0].span, "_"))); + let Path { segments: ref iter_path, .. } = **iter_path; + let Path { segments: ref len_path, .. } = **len_path; + if iter_path == len_path { + span_lint(cx, + RANGE_ZIP_WITH_LEN, + expr.span, + &format!("It is more idiomatic to use {}.iter().enumerate()", + snippet(cx, iter_args[0].span, "_"))); + } }} } } diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs index ec3013d36a1b..11eaac0bbb91 100644 --- a/clippy_lints/src/regex.rs +++ b/clippy_lints/src/regex.rs @@ -115,10 +115,10 @@ impl LateLintPass for Pass { fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { if_let_chain!{[ let ExprCall(ref fun, ref args) = expr.node, + let ExprPath(ref qpath) = fun.node, args.len() == 1, - let Some(def) = cx.tcx.def_map.borrow().get(&fun.id), ], { - let def_id = def.full_def().def_id(); + let def_id = cx.tcx.tables().qpath_def(qpath, fun.id).def_id(); if match_def_path(cx, def_id, &paths::REGEX_NEW) || match_def_path(cx, def_id, &paths::REGEX_BUILDER_NEW) { check_regex(cx, &args[0], true); diff --git a/clippy_lints/src/serde.rs b/clippy_lints/src/serde.rs index 6cf10d883d31..c5a232275552 100644 --- a/clippy_lints/src/serde.rs +++ b/clippy_lints/src/serde.rs @@ -29,7 +29,7 @@ impl LintPass for Serde { impl LateLintPass for Serde { fn check_item(&mut self, cx: &LateContext, item: &Item) { if let ItemImpl(_, _, _, Some(ref trait_ref), _, ref items) = item.node { - let did = cx.tcx.expect_def(trait_ref.ref_id).def_id(); + let did = trait_ref.path.def.def_id(); if let Some(visit_did) = get_trait_def_id(cx, &paths::SERDE_DE_VISITOR) { if did == visit_did { let mut seen_str = None; diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs index d23b1c9993fe..c994d47d7599 100644 --- a/clippy_lints/src/shadow.rs +++ b/clippy_lints/src/shadow.rs @@ -1,8 +1,8 @@ use reexport::*; use rustc::lint::*; -use rustc::hir::def::Def; use rustc::hir::*; use rustc::hir::intravisit::{Visitor, FnKind}; +use rustc::ty; use std::ops::Deref; use syntax::codemap::Span; use utils::{higher, in_external_macro, snippet, span_lint_and_then}; @@ -92,7 +92,7 @@ impl LateLintPass for Pass { fn check_fn(cx: &LateContext, decl: &FnDecl, expr: &Expr) { let mut bindings = Vec::new(); for arg in &decl.inputs { - if let PatKind::Binding(_, ident, _) = arg.pat.node { + if let PatKind::Binding(_, _, ident, _) = arg.pat.node { bindings.push((ident.node, ident.span)) } } @@ -135,10 +135,10 @@ fn check_decl(cx: &LateContext, decl: &Decl, bindings: &mut Vec<(Name, Span)>) { } } -fn is_binding(cx: &LateContext, pat: &Pat) -> bool { - match cx.tcx.def_map.borrow().get(&pat.id).map(|d| d.full_def()) { - Some(Def::Variant(..)) | - Some(Def::Struct(..)) => false, +fn is_binding(cx: &LateContext, pat_id: NodeId) -> bool { + let var_ty = cx.tcx.tables().node_id_to_type(pat_id); + match var_ty.sty { + ty::TyAdt(..) => false, _ => true, } } @@ -146,9 +146,9 @@ fn is_binding(cx: &LateContext, pat: &Pat) -> bool { fn check_pat(cx: &LateContext, pat: &Pat, init: &Option<&Expr>, span: Span, bindings: &mut Vec<(Name, Span)>) { // TODO: match more stuff / destructuring match pat.node { - PatKind::Binding(_, ref ident, ref inner) => { + PatKind::Binding(_, _, ref ident, ref inner) => { let name = ident.node; - if is_binding(cx, pat) { + if is_binding(cx, pat.id) { let mut new_binding = true; for tup in bindings.iter_mut() { if tup.0 == name { @@ -344,7 +344,7 @@ fn is_self_shadow(name: Name, expr: &Expr) -> bool { block.stmts.is_empty() && block.expr.as_ref().map_or(false, |e| is_self_shadow(name, e)) } ExprUnary(op, ref inner) => (UnDeref == op) && is_self_shadow(name, inner), - ExprPath(_, ref path) => path_eq_name(name, path), + ExprPath(QPath::Resolved(_, ref path)) => path_eq_name(name, path), _ => false, } } diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs index 278df3bad352..bef66dd402e0 100644 --- a/clippy_lints/src/swap.rs +++ b/clippy_lints/src/swap.rs @@ -65,7 +65,7 @@ fn check_manual_swap(cx: &LateContext, block: &Block) { let StmtDecl(ref tmp, _) = w[0].node, let DeclLocal(ref tmp) = tmp.node, let Some(ref tmp_init) = tmp.init, - let PatKind::Binding(_, ref tmp_name, None) = tmp.pat.node, + let PatKind::Binding(_, _, ref tmp_name, None) = tmp.pat.node, // foo() = bar(); let StmtSemi(ref first, _) = w[1].node, @@ -74,7 +74,7 @@ fn check_manual_swap(cx: &LateContext, block: &Block) { // bar() = t; let StmtSemi(ref second, _) = w[2].node, let ExprAssign(ref lhs2, ref rhs2) = second.node, - let ExprPath(None, ref rhs2) = rhs2.node, + let ExprPath(QPath::Resolved(None, ref rhs2)) = rhs2.node, rhs2.segments.len() == 1, tmp_name.node.as_str() == rhs2.segments[0].name.as_str(), diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index a7e16a56f386..3a8680b1cf77 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -87,8 +87,8 @@ impl LintPass for Transmute { impl LateLintPass for Transmute { fn check_expr(&mut self, cx: &LateContext, e: &Expr) { if let ExprCall(ref path_expr, ref args) = e.node { - if let ExprPath(None, ref path) = path_expr.node { - let def_id = cx.tcx.expect_def(path_expr.id).def_id(); + if let ExprPath(ref qpath) = path_expr.node { + let def_id = cx.tcx.tables().qpath_def(qpath, path_expr.id).def_id(); if match_def_path(cx, def_id, &paths::TRANSMUTE) { let from_ty = cx.tcx.tables().expr_ty(&args[0]); @@ -173,7 +173,7 @@ impl LateLintPass for Transmute { let arg = if from_pty.ty == to_rty.ty { arg } else { - arg.as_ty(&format!("{} {}", cast, get_type_snippet(cx, path, to_rty.ty))) + arg.as_ty(&format!("{} {}", cast, get_type_snippet(cx, qpath, to_rty.ty))) }; db.span_suggestion(e.span, "try", sugg::make_unop(deref, arg).to_string()); @@ -190,8 +190,9 @@ impl LateLintPass for Transmute { /// Get the snippet of `Bar` in `…::transmute`. If that snippet is not available , use /// the type's `ToString` implementation. In weird cases it could lead to types with invalid `'_` /// lifetime, but it should be rare. -fn get_type_snippet(cx: &LateContext, path: &Path, to_rty: ty::Ty) -> String { +fn get_type_snippet(cx: &LateContext, path: &QPath, to_rty: ty::Ty) -> String { if_let_chain!{[ + let QPath::Resolved(_, ref path) = *path, let Some(seg) = path.segments.last(), let PathParameters::AngleBracketedParameters(ref ang) = seg.parameters, let Some(to_ty) = ang.types.get(1), diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index de8fbdcc5d7a..008a1fbc6ce4 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -7,7 +7,7 @@ use std::cmp::Ordering; use syntax::ast::{IntTy, UintTy, FloatTy}; use syntax::codemap::Span; use utils::{comparisons, higher, in_external_macro, in_macro, match_def_path, snippet, - span_help_and_lint, span_lint}; + span_help_and_lint, span_lint, opt_def_id}; use utils::paths; /// Handles all the linting of funky types @@ -74,17 +74,19 @@ impl LateLintPass for TypePass { if in_macro(cx, ast_ty.span) { return; } - if let Some(did) = cx.tcx.def_map.borrow().get(&ast_ty.id) { - if let def::Def::Struct(..) = did.full_def() { - if Some(did.full_def().def_id()) == cx.tcx.lang_items.owned_box() { + if let TyPath(ref qpath) = ast_ty.node { + let def = cx.tcx.tables().qpath_def(qpath, ast_ty.id); + if let Some(def_id) = opt_def_id(def) { + if def_id == cx.tcx.lang_items.owned_box().unwrap() { if_let_chain! {[ - let TyPath(_, ref path) = ast_ty.node, + let QPath::Resolved(_, ref path) = *qpath, let Some(ref last) = path.segments.last(), let PathParameters::AngleBracketedParameters(ref ag) = last.parameters, let Some(ref vec) = ag.types.get(0), - let Some(did) = cx.tcx.def_map.borrow().get(&vec.id), - let def::Def::Struct(..) = did.full_def(), - match_def_path(cx, did.full_def().def_id(), &paths::VEC), + let TyPath(ref qpath) = vec.node, + let def::Def::Struct(..) = cx.tcx.tables().qpath_def(qpath, vec.id), + let Some(did) = opt_def_id(cx.tcx.tables().qpath_def(qpath, vec.id)), + match_def_path(cx, did, &paths::VEC), ], { span_help_and_lint(cx, BOX_VEC, @@ -92,12 +94,12 @@ impl LateLintPass for TypePass { "you seem to be trying to use `Box>`. Consider using just `Vec`", "`Vec` is already on the heap, `Box>` makes an extra allocation."); }} - } else if match_def_path(cx, did.full_def().def_id(), &paths::LINKED_LIST) { + } else if match_def_path(cx, def_id, &paths::LINKED_LIST) { span_help_and_lint(cx, - LINKEDLIST, - ast_ty.span, - "I see you're using a LinkedList! Perhaps you meant some other data structure?", - "a VecDeque might work"); + LINKEDLIST, + ast_ty.span, + "I see you're using a LinkedList! Perhaps you meant some other data structure?", + "a VecDeque might work"); } } } diff --git a/clippy_lints/src/unsafe_removed_from_name.rs b/clippy_lints/src/unsafe_removed_from_name.rs index 7cd108dd02d9..341848a868cd 100644 --- a/clippy_lints/src/unsafe_removed_from_name.rs +++ b/clippy_lints/src/unsafe_removed_from_name.rs @@ -1,6 +1,5 @@ -use rustc::hir::*; use rustc::lint::*; -use syntax::ast::Name; +use syntax::ast::*; use syntax::codemap::Span; use syntax::symbol::InternedString; use utils::span_lint; @@ -34,16 +33,16 @@ impl LintPass for UnsafeNameRemoval { } } -impl LateLintPass for UnsafeNameRemoval { - fn check_item(&mut self, cx: &LateContext, item: &Item) { - if let ItemUse(ref item_use) = item.node { +impl EarlyLintPass for UnsafeNameRemoval { + fn check_item(&mut self, cx: &EarlyContext, item: &Item) { + if let ItemKind::Use(ref item_use) = item.node { match item_use.node { ViewPath_::ViewPathSimple(ref name, ref path) => { unsafe_to_safe_check( path.segments .last() .expect("use paths cannot be empty") - .name, + .identifier, *name, cx, &item.span ); @@ -62,9 +61,9 @@ impl LateLintPass for UnsafeNameRemoval { } } -fn unsafe_to_safe_check(old_name: Name, new_name: Name, cx: &LateContext, span: &Span) { - let old_str = old_name.as_str(); - let new_str = new_name.as_str(); +fn unsafe_to_safe_check(old_name: Ident, new_name: Ident, cx: &EarlyContext, span: &Span) { + let old_str = old_name.name.as_str(); + let new_str = new_name.name.as_str(); if contains_unsafe(&old_str) && !contains_unsafe(&new_str) { span_lint(cx, UNSAFE_REMOVED_FROM_NAME, diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs index e76b9b697084..73c87f36bba8 100644 --- a/clippy_lints/src/unused_label.rs +++ b/clippy_lints/src/unused_label.rs @@ -66,7 +66,7 @@ impl<'v> Visitor<'v> for UnusedLabelVisitor { match expr.node { hir::ExprBreak(Some(label), _) | hir::ExprAgain(Some(label)) => { - self.labels.remove(&label.node.as_str()); + self.labels.remove(&label.name.as_str()); } hir::ExprLoop(_, Some(label), _) | hir::ExprWhile(_, _, Some(label)) => { diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs index 26b45009a825..a2e8bc891b4c 100644 --- a/clippy_lints/src/utils/higher.rs +++ b/clippy_lints/src/utils/higher.rs @@ -44,19 +44,6 @@ pub struct Range<'a> { /// Higher a `hir` range to something similar to `ast::ExprKind::Range`. pub fn range(expr: &hir::Expr) -> Option { - /// Skip unstable blocks. To be removed when ranges get stable. - fn unwrap_unstable(expr: &hir::Expr) -> &hir::Expr { - if let hir::ExprBlock(ref block) = expr.node { - if block.rules == hir::BlockCheckMode::PushUnstableBlock || block.rules == hir::BlockCheckMode::PopUnstableBlock { - if let Some(ref expr) = block.expr { - return expr; - } - } - } - - expr - } - /// Find the field named `name` in the field. Always return `Some` for convenience. fn get_field<'a>(name: &str, fields: &'a [hir::Field]) -> Option<&'a hir::Expr> { let expr = &fields.iter() @@ -64,14 +51,14 @@ pub fn range(expr: &hir::Expr) -> Option { .unwrap_or_else(|| panic!("missing {} field for range", name)) .expr; - Some(unwrap_unstable(expr)) + Some(expr) } // The range syntax is expanded to literal paths starting with `core` or `std` depending on // `#[no_std]`. Testing both instead of resolving the paths. - match unwrap_unstable(expr).node { - hir::ExprPath(None, ref path) => { + match expr.node { + hir::ExprPath(ref path) => { if match_path(path, &paths::RANGE_FULL_STD) || match_path(path, &paths::RANGE_FULL) { Some(Range { start: None, @@ -168,10 +155,10 @@ pub enum VecArgs<'a> { pub fn vec_macro<'e>(cx: &LateContext, expr: &'e hir::Expr) -> Option> { if_let_chain!{[ let hir::ExprCall(ref fun, ref args) = expr.node, - let hir::ExprPath(_, ref path) = fun.node, - let Some(fun_def) = resolve_node(cx, fun.id), + let hir::ExprPath(ref path) = fun.node, is_expn_of(cx, fun.span, "vec").is_some(), ], { + let fun_def = resolve_node(cx, path, fun.id); return if match_def_path(cx, fun_def.def_id(), &paths::VEC_FROM_ELEM) && args.len() == 2 { // `vec![elem; size]` case Some(VecArgs::Repeat(&args[0], &args[1])) diff --git a/clippy_lints/src/utils/hir.rs b/clippy_lints/src/utils/hir.rs index 1199f87ae3c5..5c1f4014bee8 100644 --- a/clippy_lints/src/utils/hir.rs +++ b/clippy_lints/src/utils/hir.rs @@ -69,7 +69,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { match (&left.node, &right.node) { (&ExprAddrOf(l_mut, ref le), &ExprAddrOf(r_mut, ref re)) => l_mut == r_mut && self.eq_expr(le, re), - (&ExprAgain(li), &ExprAgain(ri)) => both(&li, &ri, |l, r| l.node.as_str() == r.node.as_str()), + (&ExprAgain(li), &ExprAgain(ri)) => both(&li, &ri, |l, r| l.name.as_str() == r.name.as_str()), (&ExprAssign(ref ll, ref lr), &ExprAssign(ref rl, ref rr)) => self.eq_expr(ll, rl) && self.eq_expr(lr, rr), (&ExprAssignOp(ref lo, ref ll, ref lr), &ExprAssignOp(ref ro, ref rl, ref rr)) => { lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) @@ -82,7 +82,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { }) } (&ExprBreak(li, ref le), &ExprBreak(ri, ref re)) => - both(&li, &ri, |l, r| l.node.as_str() == r.node.as_str()) + both(&li, &ri, |l, r| l.name.as_str() == r.name.as_str()) && both(le, re, |l, r| self.eq_expr(l, r)), (&ExprBox(ref l), &ExprBox(ref r)) => self.eq_expr(l, r), (&ExprCall(ref l_fun, ref l_args), &ExprCall(ref r_fun, ref r_args)) => { @@ -118,11 +118,9 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { } (&ExprRepeat(ref le, ref ll), &ExprRepeat(ref re, ref rl)) => self.eq_expr(le, re) && self.eq_expr(ll, rl), (&ExprRet(ref l), &ExprRet(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)), - (&ExprPath(ref l_qself, ref l_subpath), &ExprPath(ref r_qself, ref r_subpath)) => { - both(l_qself, r_qself, |l, r| self.eq_qself(l, r)) && self.eq_path(l_subpath, r_subpath) - } + (&ExprPath(ref l), &ExprPath(ref r)) => self.eq_qpath(l, r), (&ExprStruct(ref l_path, ref lf, ref lo), &ExprStruct(ref r_path, ref rf, ref ro)) => { - self.eq_path(l_path, r_path) && both(lo, ro, |l, r| self.eq_expr(l, r)) && + self.eq_qpath(l_path, r_path) && both(lo, ro, |l, r| self.eq_expr(l, r)) && over(lf, rf, |l, r| self.eq_field(l, r)) } (&ExprTup(ref l_tup), &ExprTup(ref r_tup)) => self.eq_exprs(l_tup, r_tup), @@ -153,14 +151,12 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { match (&left.node, &right.node) { (&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r), (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => { - self.eq_path(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs - } - (&PatKind::Binding(ref lb, ref li, ref lp), &PatKind::Binding(ref rb, ref ri, ref rp)) => { - lb == rb && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r)) + self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs } - (&PatKind::Path(ref ql, ref l), &PatKind::Path(ref qr, ref r)) => { - both(ql, qr, |ql, qr| self.eq_qself(ql, qr)) && self.eq_path(l, r) + (&PatKind::Binding(ref lb, ref ld, ref li, ref lp), &PatKind::Binding(ref rb, ref rd, ref ri, ref rp)) => { + lb == rb && ld == rd && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r)) } + (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r), (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r), (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => { ls == rs && over(l, r, |l, r| self.eq_pat(l, r)) @@ -178,6 +174,18 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { } } + fn eq_qpath(&self, left: &QPath, right: &QPath) -> bool { + match (left, right) { + (&QPath::Resolved(ref lty, ref lpath), &QPath::Resolved(ref rty, ref rpath)) => { + both(lty, rty, |l, r| self.eq_ty(l, r)) && self.eq_path(lpath, rpath) + }, + (&QPath::TypeRelative(ref lty, ref lseg), &QPath::TypeRelative(ref rty, ref rseg)) => { + self.eq_ty(lty, rty) && self.eq_path_segment(lseg, rseg) + }, + _ => false, + } + } + fn eq_path(&self, left: &Path, right: &Path) -> bool { left.global == right.global && over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r)) @@ -208,10 +216,6 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { self.eq_path_parameters(&left.parameters, &right.parameters) } - fn eq_qself(&self, left: &QSelf, right: &QSelf) -> bool { - left.ty.node == right.ty.node && left.position == right.position - } - fn eq_ty(&self, left: &Ty, right: &Ty) -> bool { match (&left.node, &right.node) { (&TySlice(ref l_vec), &TySlice(ref r_vec)) => self.eq_ty(l_vec, r_vec), @@ -222,9 +226,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { (&TyRptr(_, ref l_rmut), &TyRptr(_, ref r_rmut)) => { l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty) } - (&TyPath(ref lq, ref l_path), &TyPath(ref rq, ref r_path)) => { - both(lq, rq, |l, r| self.eq_qself(l, r)) && self.eq_path(l_path, r_path) - } + (&TyPath(ref l), &TyPath(ref r)) => self.eq_qpath(l, r), (&TyTup(ref l), &TyTup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)), (&TyInfer, &TyInfer) => true, _ => false, @@ -318,7 +320,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { let c: fn(_) -> _ = ExprAgain; c.hash(&mut self.s); if let Some(i) = i { - self.hash_name(&i.node); + self.hash_name(&i.name); } } ExprAssign(ref l, ref r) => { @@ -350,7 +352,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { let c: fn(_, _) -> _ = ExprBreak; c.hash(&mut self.s); if let Some(i) = i { - self.hash_name(&i.node); + self.hash_name(&i.name); } if let Some(ref j) = *j { self.hash_expr(&*j); @@ -452,16 +454,16 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { self.hash_expr(e); } } - ExprPath(ref _qself, ref subpath) => { - let c: fn(_, _) -> _ = ExprPath; + ExprPath(ref qpath) => { + let c: fn(_) -> _ = ExprPath; c.hash(&mut self.s); - self.hash_path(subpath); + self.hash_qpath(qpath); } ExprStruct(ref path, ref fields, ref expr) => { let c: fn(_, _, _) -> _ = ExprStruct; c.hash(&mut self.s); - self.hash_path(path); + self.hash_qpath(path); for f in fields { self.hash_name(&f.name.node); @@ -526,6 +528,23 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { n.as_str().hash(&mut self.s); } + pub fn hash_qpath(&mut self, p: &QPath) { + match *p { + QPath::Resolved(ref _ty, ref path) => { + let c: fn(_, _) -> _ = QPath::Resolved; + c.hash(&mut self.s); + // self.hash_ty(ty); FIXME + self.hash_path(path); + }, + QPath::TypeRelative(ref _ty, ref seg) => { + let c: fn(_, _) -> _ = QPath::TypeRelative; + c.hash(&mut self.s); + // self.hash_ty(ty); FIXME + self.hash_name(&seg.name); + }, + } + } + pub fn hash_path(&mut self, p: &Path) { p.global.hash(&mut self.s); for p in &p.segments { diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs index 70f47abb54f3..b297aec7c072 100644 --- a/clippy_lints/src/utils/inspector.rs +++ b/clippy_lints/src/utils/inspector.rs @@ -275,11 +275,14 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) { println!("{}index expr:", ind); print_expr(cx, idx, indent + 1); }, - hir::ExprPath(ref sel, ref path) => { - println!("{}Path, {}", ind, ty); - println!("{}self: {:?}", ind, sel); + hir::ExprPath(hir::QPath::Resolved(ref ty, ref path)) => { + println!("{}Resolved Path, {:?}", ind, ty); println!("{}path: {:?}", ind, path); }, + hir::ExprPath(hir::QPath::TypeRelative(ref ty, ref seg)) => { + println!("{}Relative Path, {:?}", ind, ty); + println!("{}seg: {:?}", ind, seg); + } hir::ExprAddrOf(ref muta, ref e) => { println!("{}AddrOf, {}", ind, ty); println!("mutability: {:?}", muta); @@ -354,7 +357,7 @@ fn print_item(cx: &LateContext, item: &hir::Item) { println!("weird extern crate without a crate id"); } } - hir::ItemUse(ref path) => println!("{:?}", path.node), + hir::ItemUse(ref path, ref kind) => println!("{:?}, {:?}", path, kind), hir::ItemStatic(..) => println!("static item of type {:#?}", cx.tcx.item_type(did)), hir::ItemConst(..) => println!("const item of type {:#?}", cx.tcx.item_type(did)), hir::ItemFn(..) => { @@ -383,13 +386,11 @@ fn print_item(cx: &LateContext, item: &hir::Item) { println!("trait has no default impl"); } }, - hir::ItemDefaultImpl(_, ref trait_ref) => { - let trait_did = cx.tcx.expect_def(trait_ref.ref_id).def_id(); - println!("default impl for `{}`", cx.tcx.item_path_str(trait_did)); + hir::ItemDefaultImpl(_, ref _trait_ref) => { + println!("default impl"); }, - hir::ItemImpl(_, _, _, Some(ref trait_ref), _, _) => { - let trait_did = cx.tcx.expect_def(trait_ref.ref_id).def_id(); - println!("impl of trait `{}`", cx.tcx.item_path_str(trait_did)); + hir::ItemImpl(_, _, _, Some(ref _trait_ref), _, _) => { + println!("trait impl"); }, hir::ItemImpl(_, _, _, None, _, _) => { println!("impl"); @@ -402,7 +403,7 @@ fn print_pat(cx: &LateContext, pat: &hir::Pat, indent: usize) { println!("{}+", ind); match pat.node { hir::PatKind::Wild => println!("{}Wild", ind), - hir::PatKind::Binding(ref mode, ref name, ref inner) => { + hir::PatKind::Binding(ref mode, _, ref name, ref inner) => { println!("{}Binding", ind); println!("{}mode: {:?}", ind, mode); println!("{}name: {}", ind, name.node); @@ -434,11 +435,14 @@ fn print_pat(cx: &LateContext, pat: &hir::Pat, indent: usize) { print_pat(cx, field, indent + 1); } }, - hir::PatKind::Path(ref sel, ref path) => { - println!("{}Path", ind); - println!("{}self: {:?}", ind, sel); + hir::PatKind::Path(hir::QPath::Resolved(ref ty, ref path)) => { + println!("{}Resolved Path, {:?}", ind, ty); println!("{}path: {:?}", ind, path); }, + hir::PatKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => { + println!("{}Relative Path, {:?}", ind, ty); + println!("{}seg: {:?}", ind, seg); + }, hir::PatKind::Tuple(ref pats, opt_dots_position) => { println!("{}Tuple", ind); if let Some(dot_position) = opt_dots_position { diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs index 93d1ce8629b0..a510adefb717 100644 --- a/clippy_lints/src/utils/internal_lints.rs +++ b/clippy_lints/src/utils/internal_lints.rs @@ -140,7 +140,7 @@ impl LateLintPass for LintWithoutLintPass { fn is_lint_ref_type(ty: &Ty) -> bool { if let TyRptr(Some(_), MutTy { ty: ref inner, mutbl: MutImmutable }) = ty.node { - if let TyPath(None, ref path) = inner.node { + if let TyPath(ref path) = inner.node { return match_path(path, &paths::LINT); } } @@ -149,7 +149,7 @@ fn is_lint_ref_type(ty: &Ty) -> bool { fn is_lint_array_type(ty: &Ty) -> bool { - if let TyPath(None, ref path) = ty.node { + if let TyPath(ref path) = ty.node { match_path(path, &paths::LINT_ARRAY) } else { false diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index 47d693e03b2d..68d91301b2ca 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -1,6 +1,7 @@ use reexport::*; use rustc::hir::*; use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX}; +use rustc::hir::def::Def; use rustc::hir::map::Node; use rustc::lint::{LintContext, LateContext, Level, Lint}; use rustc::session::Session; @@ -202,7 +203,15 @@ pub fn match_trait_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool /// ``` /// match_path(path, &["std", "rt", "begin_unwind"]) /// ``` -pub fn match_path(path: &Path, segments: &[&str]) -> bool { +pub fn match_path(path: &QPath, segments: &[&str]) -> bool { + if let QPath::Resolved(_, ref path) = *path { + match_path_old(path, segments) + } else { + false + } +} + +pub fn match_path_old(path: &Path, segments: &[&str]) -> bool { path.segments.iter().rev().zip(segments.iter().rev()).all(|(a, b)| a.name == *b) } @@ -283,8 +292,8 @@ pub fn implements_trait<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, } /// Resolve the definition of a node from its `NodeId`. -pub fn resolve_node(cx: &LateContext, id: NodeId) -> Option { - cx.tcx.def_map.borrow().get(&id).map(|d| d.full_def()) +pub fn resolve_node(cx: &LateContext, qpath: &QPath, id: NodeId) -> def::Def { + cx.tcx.tables().qpath_def(qpath, id) } /// Match an `Expr` against a chain of methods, and return the matched `Expr`s. @@ -736,8 +745,8 @@ pub fn is_copy<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: ty::Ty<'tcx>, env: Node /// Return whether a pattern is refutable. pub fn is_refutable(cx: &LateContext, pat: &Pat) -> bool { - fn is_enum_variant(cx: &LateContext, did: NodeId) -> bool { - matches!(cx.tcx.def_map.borrow().get(&did).map(|d| d.full_def()), Some(def::Def::Variant(..)) | Some(def::Def::VariantCtor(..))) + fn is_enum_variant(cx: &LateContext, qpath: &QPath, did: NodeId) -> bool { + matches!(cx.tcx.tables().qpath_def(qpath, did), def::Def::Variant(..) | def::Def::VariantCtor(..)) } fn are_refutable<'a, I: Iterator>(cx: &LateContext, mut i: I) -> bool { @@ -748,17 +757,17 @@ pub fn is_refutable(cx: &LateContext, pat: &Pat) -> bool { PatKind::Binding(..) | PatKind::Wild => false, PatKind::Box(ref pat) | PatKind::Ref(ref pat, _) => is_refutable(cx, pat), PatKind::Lit(..) | PatKind::Range(..) => true, - PatKind::Path(..) => is_enum_variant(cx, pat.id), + PatKind::Path(ref qpath) => is_enum_variant(cx, qpath, pat.id), PatKind::Tuple(ref pats, _) => are_refutable(cx, pats.iter().map(|pat| &**pat)), - PatKind::Struct(_, ref fields, _) => { - if is_enum_variant(cx, pat.id) { + PatKind::Struct(ref qpath, ref fields, _) => { + if is_enum_variant(cx, qpath, pat.id) { true } else { are_refutable(cx, fields.iter().map(|field| &*field.node.pat)) } } - PatKind::TupleStruct(_, ref pats, _) => { - if is_enum_variant(cx, pat.id) { + PatKind::TupleStruct(ref qpath, ref pats, _) => { + if is_enum_variant(cx, qpath, pat.id) { true } else { are_refutable(cx, pats.iter().map(|pat| &**pat)) @@ -793,3 +802,20 @@ pub fn remove_blocks(expr: &Expr) -> &Expr { expr } } + +pub fn opt_def_id(def: Def) -> Option { + match def { + Def::Fn(id) | Def::Mod(id) | Def::Static(id, _) | + Def::Variant(id) | Def::VariantCtor(id, ..) | Def::Enum(id) | Def::TyAlias(id) | + Def::AssociatedTy(id) | Def::TyParam(id) | Def::Struct(id) | Def::StructCtor(id, ..) | + Def::Union(id) | Def::Trait(id) | Def::Method(id) | Def::Const(id) | + Def::AssociatedConst(id) | Def::Local(id) | Def::Upvar(id, ..) | Def::Macro(id) => { + Some(id) + } + + Def::Label(..) | + Def::PrimTy(..) | + Def::SelfTy(..) | + Def::Err => None, + } +} From 16aab716886b9d00ca6e58d502faefdc55477cc6 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Fri, 2 Dec 2016 17:38:31 +0100 Subject: [PATCH 02/15] `enum glob use` and `copies` left --- clippy_lints/src/enum_glob_use.rs | 2 ++ clippy_lints/src/lifetimes.rs | 34 +++++++++++------------ clippy_lints/src/loops.rs | 39 +++++++++++++-------------- clippy_lints/src/methods.rs | 20 +++++++------- clippy_lints/src/misc.rs | 26 +++++++----------- clippy_lints/src/ranges.rs | 16 +++++------ clippy_lints/src/transmute.rs | 5 ++-- clippy_lints/src/types.rs | 5 ++-- clippy_lints/src/utils/higher.rs | 2 +- clippy_lints/src/utils/hir.rs | 23 ++++------------ clippy_lints/src/utils/mod.rs | 45 +++++++++++++++++++++++++++---- clippy_lints/src/utils/paths.rs | 3 ++- tests/compile-fail/copies.rs | 1 + tests/compile-fail/dlist.rs | 2 +- tests/compile-test.rs | 1 + 15 files changed, 116 insertions(+), 108 deletions(-) diff --git a/clippy_lints/src/enum_glob_use.rs b/clippy_lints/src/enum_glob_use.rs index f4f8d6f378b7..7992c4966b2a 100644 --- a/clippy_lints/src/enum_glob_use.rs +++ b/clippy_lints/src/enum_glob_use.rs @@ -48,6 +48,8 @@ impl EnumGlobUse { return; // re-exports are fine } if let ItemUse(ref path, UseKind::Glob) = item.node { + // FIXME: ask jseyfried why the qpath.def for `use std::cmp::Ordering::*;` + // extracted through `ItemUse(ref qpath, UseKind::Glob)` is a `Mod` and not an `Enum` if let Def::Enum(_) = path.def { span_lint(cx, ENUM_GLOB_USE, item.span, "don't use glob imports for enum variants"); } diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index 236919bfc253..6d100317fd88 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -5,7 +5,7 @@ use rustc::hir::*; use rustc::hir::intravisit::{Visitor, walk_ty, walk_ty_param_bound, walk_fn_decl, walk_generics}; use std::collections::{HashSet, HashMap}; use syntax::codemap::Span; -use utils::{in_external_macro, span_lint}; +use utils::{in_external_macro, span_lint, last_path_segment}; /// **What it does:** Checks for lifetime annotations which can be removed by /// relying on lifetime elision. @@ -240,26 +240,24 @@ impl<'v, 't> RefVisitor<'v, 't> { } fn collect_anonymous_lifetimes(&mut self, qpath: &QPath, ty: &Ty) { - if let QPath::Resolved(_, ref path) = *qpath { - let last_path_segment = path.segments.last().map(|s| &s.parameters); - if let Some(&AngleBracketedParameters(ref params)) = last_path_segment { - if params.lifetimes.is_empty() { - match self.cx.tcx.tables().qpath_def(qpath, ty.id) { - Def::TyAlias(def_id) | - Def::Struct(def_id) => { - let generics = self.cx.tcx.item_generics(def_id); - for _ in generics.regions.as_slice() { - self.record(&None); - } + let last_path_segment = &last_path_segment(qpath).parameters; + if let &AngleBracketedParameters(ref params) = last_path_segment { + if params.lifetimes.is_empty() { + match self.cx.tcx.tables().qpath_def(qpath, ty.id) { + Def::TyAlias(def_id) | + Def::Struct(def_id) => { + let generics = self.cx.tcx.item_generics(def_id); + for _ in generics.regions.as_slice() { + self.record(&None); } - Def::Trait(def_id) => { - let trait_def = self.cx.tcx.trait_defs.borrow()[&def_id]; - for _ in &trait_def.generics.regions { - self.record(&None); - } + } + Def::Trait(def_id) => { + let trait_def = self.cx.tcx.trait_defs.borrow()[&def_id]; + for _ in &trait_def.generics.regions { + self.record(&None); } - _ => (), } + _ => (), } } } diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index d752e78cddf8..0d862b76d9bb 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -16,7 +16,7 @@ use utils::sugg; use utils::{snippet, span_lint, get_parent_expr, match_trait_method, match_type, multispan_sugg, in_external_macro, is_refutable, span_help_and_lint, is_integer_literal, - get_enclosing_block, span_lint_and_then, higher, walk_ptrs_ty}; + get_enclosing_block, span_lint_and_then, higher, walk_ptrs_ty, last_path_segment}; use utils::paths; /// **What it does:** Checks for looping over the range of `0..len` of some @@ -369,26 +369,23 @@ impl LateLintPass for Pass { if let (&PatKind::TupleStruct(ref qpath, ref pat_args, _), &ExprMethodCall(method_name, _, ref method_args)) = (pat, &match_expr.node) { let iter_expr = &method_args[0]; - if let QPath::Resolved(_, ref path) = *qpath { - if let Some(lhs_constructor) = path.segments.last() { - if &*method_name.node.as_str() == "next" && - match_trait_method(cx, match_expr, &paths::ITERATOR) && - &*lhs_constructor.name.as_str() == "Some" && - !is_refutable(cx, &pat_args[0]) && - !is_iterator_used_after_while_let(cx, iter_expr) { - let iterator = snippet(cx, method_args[0].span, "_"); - let loop_var = snippet(cx, pat_args[0].span, "_"); - span_lint_and_then(cx, - WHILE_LET_ON_ITERATOR, - expr.span, - "this loop could be written as a `for` loop", - |db| { - db.span_suggestion(expr.span, - "try", - format!("for {} in {} {{ .. }}", loop_var, iterator)); - }); - } - } + let lhs_constructor = last_path_segment(qpath); + if &*method_name.node.as_str() == "next" && + match_trait_method(cx, match_expr, &paths::ITERATOR) && + &*lhs_constructor.name.as_str() == "Some" && + !is_refutable(cx, &pat_args[0]) && + !is_iterator_used_after_while_let(cx, iter_expr) { + let iterator = snippet(cx, method_args[0].span, "_"); + let loop_var = snippet(cx, pat_args[0].span, "_"); + span_lint_and_then(cx, + WHILE_LET_ON_ITERATOR, + expr.span, + "this loop could be written as a `for` loop", + |db| { + db.span_suggestion(expr.span, + "try", + format!("for {} in {} {{ .. }}", loop_var, iterator)); + }); } } } diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index 1a824e467c49..edcdc74013b0 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -3,6 +3,7 @@ use rustc::lint::*; use rustc::middle::const_val::ConstVal; use rustc::middle::const_qualif::ConstQualif; use rustc::ty; +use rustc::hir::def::Def; use rustc_const_eval::EvalHint::ExprTypeChecked; use rustc_const_eval::eval_const_expr_partial; use std::borrow::Cow; @@ -10,7 +11,8 @@ use std::fmt; use syntax::codemap::Span; use utils::{get_trait_def_id, implements_trait, in_external_macro, in_macro, is_copy, match_path, match_trait_method, match_type, method_chain_args, return_ty, same_tys, snippet, - span_lint, span_lint_and_then, span_note_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth}; + span_lint, span_lint_and_then, span_note_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth, + last_path_segment, single_segment_path, match_def_path}; use utils::paths; use utils::sugg; @@ -701,12 +703,8 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, name: &str, args: &[hir: } if name == "unwrap_or" { - if let hir::ExprPath(hir::QPath::Resolved(_, ref path)) = fun.node { - let path: &str = &path.segments - .last() - .expect("A path must have at least one segment") - .name - .as_str(); + if let hir::ExprPath(ref qpath) = fun.node { + let path: &str = &*last_path_segment(qpath).name.as_str(); if ["default", "new"].contains(&path) { let arg_ty = cx.tcx.tables().expr_ty(arg); @@ -878,7 +876,8 @@ fn lint_cstring_as_ptr(cx: &LateContext, expr: &hir::Expr, new: &hir::Expr, unwr let hir::ExprCall(ref fun, ref args) = new.node, args.len() == 1, let hir::ExprPath(ref path) = fun.node, - match_path(path, &paths::CSTRING_NEW), + let Def::Method(did) = cx.tcx.tables().qpath_def(path, fun.id), + match_def_path(cx, did, &paths::CSTRING_NEW) ], { span_lint_and_then(cx, TEMPORARY_CSTRING_AS_PTR, expr.span, "you are getting the inner pointer of a temporary `CString`", @@ -1188,8 +1187,9 @@ fn lint_chars_next(cx: &LateContext, expr: &hir::Expr, chain: &hir::Expr, other: let Some(args) = method_chain_args(chain, &["chars", "next"]), let hir::ExprCall(ref fun, ref arg_char) = other.node, arg_char.len() == 1, - let hir::ExprPath(hir::QPath::Resolved(None, ref path)) = fun.node, - path.segments.len() == 1 && &*path.segments[0].name.as_str() == "Some" + let hir::ExprPath(ref qpath) = fun.node, + let Some(segment) = single_segment_path(qpath), + &*segment.name.as_str() == "Some" ], { let self_ty = walk_ptrs_ty(cx.tcx.tables().expr_ty_adjusted(&args[0][0])); diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index 854a8d144d68..5752e95d0acc 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -10,7 +10,7 @@ use rustc_const_math::ConstFloat; use syntax::codemap::{Span, Spanned, ExpnFormat}; use utils::{ get_item_name, get_parent_expr, implements_trait, in_macro, is_integer_literal, match_path, - snippet, span_lint, span_lint_and_then, walk_ptrs_ty + snippet, span_lint, span_lint_and_then, walk_ptrs_ty, last_path_segment }; use utils::sugg::Sugg; @@ -263,22 +263,14 @@ impl LateLintPass for Pass { } let binding = match expr.node { ExprPath(ref qpath) => { - if let QPath::Resolved(_, ref path) = *qpath { - let binding = path.segments - .last() - .expect("path should always have at least one segment") - .name - .as_str(); - if binding.starts_with('_') && - !binding.starts_with("__") && - &*binding != "_result" && // FIXME: #944 - is_used(cx, expr) && - // don't lint if the declaration is in a macro - non_macro_local(cx, &cx.tcx.tables().qpath_def(qpath, expr.id)) { - Some(binding) - } else { - None - } + let binding = last_path_segment(qpath).name.as_str(); + if binding.starts_with('_') && + !binding.starts_with("__") && + &*binding != "_result" && // FIXME: #944 + is_used(cx, expr) && + // don't lint if the declaration is in a macro + non_macro_local(cx, &cx.tcx.tables().qpath_def(qpath, expr.id)) { + Some(binding) } else { None } diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs index 791843ee567b..b3d03f5dc18f 100644 --- a/clippy_lints/src/ranges.rs +++ b/clippy_lints/src/ranges.rs @@ -75,17 +75,13 @@ impl LateLintPass for StepByZero { // .iter() and .len() called on same Path let ExprPath(QPath::Resolved(_, ref iter_path)) = iter_args[0].node, let ExprPath(QPath::Resolved(_, ref len_path)) = len_args[0].node, - iter_path == len_path + iter_path.segments == len_path.segments ], { - let Path { segments: ref iter_path, .. } = **iter_path; - let Path { segments: ref len_path, .. } = **len_path; - if iter_path == len_path { - span_lint(cx, - RANGE_ZIP_WITH_LEN, - expr.span, - &format!("It is more idiomatic to use {}.iter().enumerate()", - snippet(cx, iter_args[0].span, "_"))); - } + span_lint(cx, + RANGE_ZIP_WITH_LEN, + expr.span, + &format!("It is more idiomatic to use {}.iter().enumerate()", + snippet(cx, iter_args[0].span, "_"))); }} } } diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index 3a8680b1cf77..2263390840c1 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -2,7 +2,7 @@ use rustc::lint::*; use rustc::ty::TypeVariants::{TyRawPtr, TyRef}; use rustc::ty; use rustc::hir::*; -use utils::{match_def_path, paths, span_lint, span_lint_and_then, snippet}; +use utils::{match_def_path, paths, span_lint, span_lint_and_then, snippet, last_path_segment}; use utils::sugg; /// **What it does:** Checks for transmutes that can't ever be correct on any @@ -191,9 +191,8 @@ impl LateLintPass for Transmute { /// the type's `ToString` implementation. In weird cases it could lead to types with invalid `'_` /// lifetime, but it should be rare. fn get_type_snippet(cx: &LateContext, path: &QPath, to_rty: ty::Ty) -> String { + let seg = last_path_segment(path); if_let_chain!{[ - let QPath::Resolved(_, ref path) = *path, - let Some(seg) = path.segments.last(), let PathParameters::AngleBracketedParameters(ref ang) = seg.parameters, let Some(to_ty) = ang.types.get(1), let TyRptr(_, ref to_ty) = to_ty.node, diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index 008a1fbc6ce4..15e5f3f58db7 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -7,7 +7,7 @@ use std::cmp::Ordering; use syntax::ast::{IntTy, UintTy, FloatTy}; use syntax::codemap::Span; use utils::{comparisons, higher, in_external_macro, in_macro, match_def_path, snippet, - span_help_and_lint, span_lint, opt_def_id}; + span_help_and_lint, span_lint, opt_def_id, last_path_segment}; use utils::paths; /// Handles all the linting of funky types @@ -78,9 +78,8 @@ impl LateLintPass for TypePass { let def = cx.tcx.tables().qpath_def(qpath, ast_ty.id); if let Some(def_id) = opt_def_id(def) { if def_id == cx.tcx.lang_items.owned_box().unwrap() { + let last = last_path_segment(qpath); if_let_chain! {[ - let QPath::Resolved(_, ref path) = *qpath, - let Some(ref last) = path.segments.last(), let PathParameters::AngleBracketedParameters(ref ag) = last.parameters, let Some(ref vec) = ag.types.get(0), let TyPath(ref qpath) = vec.node, diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs index a2e8bc891b4c..6ae4743a368c 100644 --- a/clippy_lints/src/utils/higher.rs +++ b/clippy_lints/src/utils/higher.rs @@ -163,7 +163,7 @@ pub fn vec_macro<'e>(cx: &LateContext, expr: &'e hir::Expr) -> Option SpanlessHash<'a, 'tcx> { ExprPath(ref qpath) => { let c: fn(_) -> _ = ExprPath; c.hash(&mut self.s); - self.hash_qpath(qpath); + self.hash_qpath(qpath, e.id); } ExprStruct(ref path, ref fields, ref expr) => { let c: fn(_, _, _) -> _ = ExprStruct; c.hash(&mut self.s); - self.hash_qpath(path); + self.hash_qpath(path, e.id); for f in fields { self.hash_name(&f.name.node); @@ -528,21 +528,8 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { n.as_str().hash(&mut self.s); } - pub fn hash_qpath(&mut self, p: &QPath) { - match *p { - QPath::Resolved(ref _ty, ref path) => { - let c: fn(_, _) -> _ = QPath::Resolved; - c.hash(&mut self.s); - // self.hash_ty(ty); FIXME - self.hash_path(path); - }, - QPath::TypeRelative(ref _ty, ref seg) => { - let c: fn(_, _) -> _ = QPath::TypeRelative; - c.hash(&mut self.s); - // self.hash_ty(ty); FIXME - self.hash_name(&seg.name); - }, - } + pub fn hash_qpath(&mut self, p: &QPath, id: NodeId) { + self.cx.tcx.tables().qpath_def(p, id).hash(&mut self.s); } pub fn hash_path(&mut self, p: &Path) { diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index 68d91301b2ca..cb25759b4ae0 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -95,7 +95,16 @@ pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool { } /// Returns true if this `expn_info` was expanded by any macro. pub fn in_macro(cx: &T, span: Span) -> bool { - cx.sess().codemap().with_expn_info(span.expn_id, |info| info.is_some()) + cx.sess().codemap().with_expn_info(span.expn_id, |info| match info { + Some(info) => { + match info.callee.format { + // don't treat range expressions desugared to structs as "in_macro" + ExpnFormat::CompilerDesugaring(name) => name != "...", + _ => true, + } + }, + None => false, + }) } /// Returns true if the macro that expanded the crate was outside of the current crate or was a @@ -150,6 +159,9 @@ pub fn match_def_path(cx: &LateContext, def_id: DefId, path: &[&str]) -> bool { let mut apb = AbsolutePathBuffer { names: vec![] }; cx.tcx.push_item_path(&mut apb, def_id); + if path == paths::VEC_FROM_ELEM { + println!("{:#?} == {:#?}", apb.names, path); + } apb.names.len() == path.len() && apb.names.iter().zip(path.iter()).all(|(a, &b)| &**a == b) @@ -197,6 +209,23 @@ pub fn match_trait_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool } } +pub fn last_path_segment(path: &QPath) -> &PathSegment { + match *path { + QPath::Resolved(_, ref path) => path.segments + .last() + .expect("A path must have at least one segment"), + QPath::TypeRelative(_, ref seg) => &seg, + } +} + +pub fn single_segment_path(path: &QPath) -> Option<&PathSegment> { + match *path { + QPath::Resolved(_, ref path) if path.segments.len() == 1 => Some(&path.segments[0]), + QPath::Resolved(..) => None, + QPath::TypeRelative(_, ref seg) => Some(&seg), + } +} + /// Match a `Path` against a slice of segment string literals. /// /// # Examples @@ -204,10 +233,16 @@ pub fn match_trait_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool /// match_path(path, &["std", "rt", "begin_unwind"]) /// ``` pub fn match_path(path: &QPath, segments: &[&str]) -> bool { - if let QPath::Resolved(_, ref path) = *path { - match_path_old(path, segments) - } else { - false + match *path { + QPath::Resolved(_, ref path) => match_path_old(path, segments), + QPath::TypeRelative(ref ty, ref segment) => match ty.node { + TyPath(ref inner_path) => { + segments.len() > 0 && + match_path(inner_path, &segments[..(segments.len() - 1)]) && + segment.name == segments[segments.len() - 1] + }, + _ => false, + }, } } diff --git a/clippy_lints/src/utils/paths.rs b/clippy_lints/src/utils/paths.rs index eefc2e5193a0..402985613aeb 100644 --- a/clippy_lints/src/utils/paths.rs +++ b/clippy_lints/src/utils/paths.rs @@ -12,7 +12,7 @@ pub const CLONE_TRAIT: [&'static str; 3] = ["core", "clone", "Clone"]; pub const CMP_MAX: [&'static str; 3] = ["core", "cmp", "max"]; pub const CMP_MIN: [&'static str; 3] = ["core", "cmp", "min"]; pub const COW: [&'static str; 3] = ["collections", "borrow", "Cow"]; -pub const CSTRING_NEW: [&'static str; 4] = ["std", "ffi", "CString", "new"]; +pub const CSTRING_NEW: [&'static str; 5] = ["std", "ffi", "c_str", "CString", "new"]; pub const DEBUG_FMT_METHOD: [&'static str; 4] = ["core", "fmt", "Debug", "fmt"]; pub const DEFAULT_TRAIT: [&'static str; 3] = ["core", "default", "Default"]; pub const DISPLAY_FMT_METHOD: [&'static str; 4] = ["core", "fmt", "Display", "fmt"]; @@ -64,6 +64,7 @@ pub const RESULT: [&'static str; 3] = ["core", "result", "Result"]; pub const RESULT_ERR: [&'static str; 4] = ["core", "result", "Result", "Err"]; pub const RESULT_OK: [&'static str; 4] = ["core", "result", "Result", "Ok"]; pub const SERDE_DE_VISITOR: [&'static str; 3] = ["serde", "de", "Visitor"]; +pub const SLICE_INTO_VEC: [&'static str; 4] = ["collections", "slice", "", "into_vec"]; pub const STRING: [&'static str; 3] = ["collections", "string", "String"]; pub const TRANSMUTE: [&'static str; 4] = ["core", "intrinsics", "", "transmute"]; pub const VEC: [&'static str; 3] = ["collections", "vec", "Vec"]; diff --git a/tests/compile-fail/copies.rs b/tests/compile-fail/copies.rs index 3e65d1aeec47..005129f1b5da 100644 --- a/tests/compile-fail/copies.rs +++ b/tests/compile-fail/copies.rs @@ -9,6 +9,7 @@ #![allow(blacklisted_name)] #![allow(collapsible_if)] #![allow(zero_divided_by_zero, eq_op)] +#![allow(path_statements)] fn bar(_: T) {} fn foo() -> bool { unimplemented!() } diff --git a/tests/compile-fail/dlist.rs b/tests/compile-fail/dlist.rs index e79196191212..525c166e62af 100644 --- a/tests/compile-fail/dlist.rs +++ b/tests/compile-fail/dlist.rs @@ -10,5 +10,5 @@ pub fn test(_: LinkedList) { //~ ERROR I see you're using a LinkedList! } fn main(){ - test(LinkedList::new()); + test(LinkedList::new()); //~ ERROR I see you're using a LinkedList! } diff --git a/tests/compile-test.rs b/tests/compile-test.rs index deadd499192d..50701ce0ec99 100644 --- a/tests/compile-test.rs +++ b/tests/compile-test.rs @@ -21,6 +21,7 @@ fn run_mode(dir: &'static str, mode: &'static str) { fn prepare_env() { set_var("CLIPPY_DISABLE_WIKI_LINKS", "true"); + set_var("RUST_BACKTRACE", "0"); // these are riddicously slow right now } #[test] From cf1fa94be1e98dba2ce1755e1c86acef50daf599 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Fri, 2 Dec 2016 19:19:52 +0100 Subject: [PATCH 03/15] down to for-loops not comparing as equal --- clippy_lints/src/utils/hir.rs | 95 ++++++++++++++--------------------- tests/compile-fail/copies.rs | 6 ++- 2 files changed, 41 insertions(+), 60 deletions(-) diff --git a/clippy_lints/src/utils/hir.rs b/clippy_lints/src/utils/hir.rs index be2b59d5ffc0..ac6c0cb98e26 100644 --- a/clippy_lints/src/utils/hir.rs +++ b/clippy_lints/src/utils/hir.rs @@ -1,6 +1,7 @@ use consts::constant; use rustc::lint::*; use rustc::hir::*; +use rustc::hir::def::Def; use std::hash::{Hash, Hasher}; use std::collections::hash_map::DefaultHasher; use syntax::ast::{Name, NodeId}; @@ -103,8 +104,8 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { (&ExprLoop(ref lb, ref ll, ref lls), &ExprLoop(ref rb, ref rl, ref rls)) => { self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str()) && lls == rls } - (&ExprMatch(ref le, ref la, ref ls), &ExprMatch(ref re, ref ra, ref rs)) => { - ls == rs && self.eq_expr(le, re) && + (&ExprMatch(ref le, ref la, _), &ExprMatch(ref re, ref ra, _)) => { + self.eq_expr(le, re) && over(la, ra, |l, r| { self.eq_expr(&l.body, &r.body) && both(&l.guard, &r.guard, |l, r| self.eq_expr(l, r)) && over(&l.pats, &r.pats, |l, r| self.eq_pat(l, r)) @@ -118,9 +119,10 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { } (&ExprRepeat(ref le, ref ll), &ExprRepeat(ref re, ref rl)) => self.eq_expr(le, re) && self.eq_expr(ll, rl), (&ExprRet(ref l), &ExprRet(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)), - (&ExprPath(ref l), &ExprPath(ref r)) => self.eq_qpath(l, r), + (&ExprPath(ref l), &ExprPath(ref r)) => self.eq_qpath(l, left.id, r, right.id), (&ExprStruct(ref l_path, ref lf, ref lo), &ExprStruct(ref r_path, ref rf, ref ro)) => { - self.eq_qpath(l_path, r_path) && both(lo, ro, |l, r| self.eq_expr(l, r)) && + self.eq_qpath(l_path, left.id, r_path, right.id) && + both(lo, ro, |l, r| self.eq_expr(l, r)) && over(lf, rf, |l, r| self.eq_field(l, r)) } (&ExprTup(ref l_tup), &ExprTup(ref r_tup)) => self.eq_exprs(l_tup, r_tup), @@ -142,21 +144,17 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { left.name.node == right.name.node && self.eq_expr(&left.expr, &right.expr) } - fn eq_lifetime(&self, left: &Lifetime, right: &Lifetime) -> bool { - left.name == right.name - } - /// Check whether two patterns are the same. pub fn eq_pat(&self, left: &Pat, right: &Pat) -> bool { match (&left.node, &right.node) { (&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r), (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => { - self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs + self.eq_qpath(lp, left.id, rp, right.id) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs } - (&PatKind::Binding(ref lb, ref ld, ref li, ref lp), &PatKind::Binding(ref rb, ref rd, ref ri, ref rp)) => { - lb == rb && ld == rd && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r)) + (&PatKind::Binding(ref lb, _, ref li, ref lp), &PatKind::Binding(ref rb, _, ref ri, ref rp)) => { + lb == rb && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r)) } - (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r), + (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, left.id, r, right.id), (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r), (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => { ls == rs && over(l, r, |l, r| self.eq_pat(l, r)) @@ -174,48 +172,23 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { } } - fn eq_qpath(&self, left: &QPath, right: &QPath) -> bool { - match (left, right) { - (&QPath::Resolved(ref lty, ref lpath), &QPath::Resolved(ref rty, ref rpath)) => { - both(lty, rty, |l, r| self.eq_ty(l, r)) && self.eq_path(lpath, rpath) - }, - (&QPath::TypeRelative(ref lty, ref lseg), &QPath::TypeRelative(ref rty, ref rseg)) => { - self.eq_ty(lty, rty) && self.eq_path_segment(lseg, rseg) - }, - _ => false, - } - } - - fn eq_path(&self, left: &Path, right: &Path) -> bool { - left.global == right.global && - over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r)) - } + fn eq_qpath(&self, left: &QPath, lid: NodeId, right: &QPath, rid: NodeId) -> bool { + let l = self.cx.tcx.tables().qpath_def(left, lid); + let r = self.cx.tcx.tables().qpath_def(right, rid); - fn eq_path_parameters(&self, left: &PathParameters, right: &PathParameters) -> bool { - match (left, right) { - (&AngleBracketedParameters(ref left), &AngleBracketedParameters(ref right)) => { - over(&left.lifetimes, &right.lifetimes, |l, r| self.eq_lifetime(l, r)) && - over(&left.types, &right.types, |l, r| self.eq_ty(l, r)) && - over(&left.bindings, &right.bindings, |l, r| self.eq_type_binding(l, r)) - } - (&ParenthesizedParameters(ref left), &ParenthesizedParameters(ref right)) => { - over(&left.inputs, &right.inputs, |l, r| self.eq_ty(l, r)) && - both(&left.output, &right.output, |l, r| self.eq_ty(l, r)) - } - (&AngleBracketedParameters(_), &ParenthesizedParameters(_)) | - (&ParenthesizedParameters(_), &AngleBracketedParameters(_)) => { - false + if let (Def::Local(_), Def::Local(_)) = (l, r) { + if let (&QPath::Resolved(None, ref l), &QPath::Resolved(None, ref r)) = (left, right) { + assert_eq!(l.segments.len(), 1); + assert_eq!(r.segments.len(), 1); + l.segments[0].name == r.segments[0].name + } else { + unreachable!(); } + } else { + l == r } } - fn eq_path_segment(&self, left: &PathSegment, right: &PathSegment) -> bool { - // The == of idents doesn't work with different contexts, - // we have to be explicit about hygiene - left.name.as_str() == right.name.as_str() && - self.eq_path_parameters(&left.parameters, &right.parameters) - } - fn eq_ty(&self, left: &Ty, right: &Ty) -> bool { match (&left.node, &right.node) { (&TySlice(ref l_vec), &TySlice(ref r_vec)) => self.eq_ty(l_vec, r_vec), @@ -226,16 +199,12 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { (&TyRptr(_, ref l_rmut), &TyRptr(_, ref r_rmut)) => { l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty) } - (&TyPath(ref l), &TyPath(ref r)) => self.eq_qpath(l, r), + (&TyPath(ref l), &TyPath(ref r)) => self.eq_qpath(l, left.id, r, right.id), (&TyTup(ref l), &TyTup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)), (&TyInfer, &TyInfer) => true, _ => false, } } - - fn eq_type_binding(&self, left: &TypeBinding, right: &TypeBinding) -> bool { - left.name == right.name && self.eq_ty(&left.ty, &right.ty) - } } fn swap_binop<'a>(binop: BinOp_, lhs: &'a Expr, rhs: &'a Expr) -> Option<(BinOp_, &'a Expr, &'a Expr)> { @@ -420,7 +389,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { } j.hash(&mut self.s); } - ExprMatch(ref e, ref arms, ref s) => { + ExprMatch(ref e, ref arms, _) => { let c: fn(_, _, _) -> _ = ExprMatch; c.hash(&mut self.s); self.hash_expr(e); @@ -432,8 +401,6 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { } self.hash_expr(&arm.body); } - - s.hash(&mut self.s); } ExprMethodCall(ref name, ref _tys, ref args) => { let c: fn(_, _, _) -> _ = ExprMethodCall; @@ -529,7 +496,19 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { } pub fn hash_qpath(&mut self, p: &QPath, id: NodeId) { - self.cx.tcx.tables().qpath_def(p, id).hash(&mut self.s); + let def = self.cx.tcx.tables().qpath_def(p, id); + if let Def::Local(_) = def { + true.hash(&mut self.s); + if let QPath::Resolved(None, ref seq) = *p { + assert_eq!(seq.segments.len(), 1); + self.hash_name(&seq.segments[0].name); + } else { + unreachable!(); + } + } else { + false.hash(&mut self.s); + def.hash(&mut self.s); + } } pub fn hash_path(&mut self, p: &Path) { diff --git a/tests/compile-fail/copies.rs b/tests/compile-fail/copies.rs index 005129f1b5da..ed343c3ba7a8 100644 --- a/tests/compile-fail/copies.rs +++ b/tests/compile-fail/copies.rs @@ -224,16 +224,18 @@ fn if_same_then_else() -> Result<&'static str, ()> { } if true { + //~^NOTE same as this if let Some(42) = None {} } - else { + else { //~ERROR this `if` has identical blocks if let Option::Some(42) = None {} } if true { + //~^NOTE same as this if let Some(42) = None:: {} } - else { + else { //~ERROR this `if` has identical blocks if let Some(42) = None {} } From ff2487b30edb17e3f63a603e35c1ee76370ff01f Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Fri, 2 Dec 2016 19:23:30 +0100 Subject: [PATCH 04/15] permit more equalities --- clippy_lints/src/utils/hir.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/clippy_lints/src/utils/hir.rs b/clippy_lints/src/utils/hir.rs index ac6c0cb98e26..487a3034b3ad 100644 --- a/clippy_lints/src/utils/hir.rs +++ b/clippy_lints/src/utils/hir.rs @@ -101,8 +101,8 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { self.eq_expr(lc, rc) && self.eq_block(lt, rt) && both(le, re, |l, r| self.eq_expr(l, r)) } (&ExprLit(ref l), &ExprLit(ref r)) => l.node == r.node, - (&ExprLoop(ref lb, ref ll, ref lls), &ExprLoop(ref rb, ref rl, ref rls)) => { - self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str()) && lls == rls + (&ExprLoop(ref lb, ref ll, _), &ExprLoop(ref rb, ref rl, _)) => { + self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str()) } (&ExprMatch(ref le, ref la, _), &ExprMatch(ref re, ref ra, _)) => { self.eq_expr(le, re) && @@ -380,14 +380,13 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { c.hash(&mut self.s); l.hash(&mut self.s); } - ExprLoop(ref b, ref i, ref j) => { + ExprLoop(ref b, ref i, _) => { let c: fn(_, _, _) -> _ = ExprLoop; c.hash(&mut self.s); self.hash_block(b); if let Some(i) = *i { self.hash_name(&i.node); } - j.hash(&mut self.s); } ExprMatch(ref e, ref arms, _) => { let c: fn(_, _, _) -> _ = ExprMatch; From 8e1f6dce408deb92affe2099324a5cc7740b6567 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Fri, 2 Dec 2016 19:30:00 +0100 Subject: [PATCH 05/15] enum detection by style convention --- clippy_lints/src/enum_glob_use.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/clippy_lints/src/enum_glob_use.rs b/clippy_lints/src/enum_glob_use.rs index 7992c4966b2a..a47426b03ef5 100644 --- a/clippy_lints/src/enum_glob_use.rs +++ b/clippy_lints/src/enum_glob_use.rs @@ -1,7 +1,6 @@ //! lint on `use`ing all variants of an enum use rustc::hir::*; -use rustc::hir::def::Def; use rustc::lint::{LateLintPass, LintPass, LateContext, LintArray}; use syntax::ast::NodeId; use syntax::codemap::Span; @@ -50,7 +49,8 @@ impl EnumGlobUse { if let ItemUse(ref path, UseKind::Glob) = item.node { // FIXME: ask jseyfried why the qpath.def for `use std::cmp::Ordering::*;` // extracted through `ItemUse(ref qpath, UseKind::Glob)` is a `Mod` and not an `Enum` - if let Def::Enum(_) = path.def { + //if let Def::Enum(_) = path.def { + if path.segments.last().and_then(|seg| seg.name.as_str().chars().next()).map_or(false, char::is_uppercase) { span_lint(cx, ENUM_GLOB_USE, item.span, "don't use glob imports for enum variants"); } } From 42fb11f887c574530e52a055cd3b735ff06c102f Mon Sep 17 00:00:00 2001 From: mcarton Date: Fri, 2 Dec 2016 20:33:37 +0100 Subject: [PATCH 06/15] Don't set RUST_BACKTRACE for tests It is slow but it can be useful and can be set/unset explicitly before running tests if needed. There is no backtrace by default anyway. --- tests/compile-test.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/compile-test.rs b/tests/compile-test.rs index 50701ce0ec99..deadd499192d 100644 --- a/tests/compile-test.rs +++ b/tests/compile-test.rs @@ -21,7 +21,6 @@ fn run_mode(dir: &'static str, mode: &'static str) { fn prepare_env() { set_var("CLIPPY_DISABLE_WIKI_LINKS", "true"); - set_var("RUST_BACKTRACE", "0"); // these are riddicously slow right now } #[test] From fe15880beb3359bcf6d4d5bd8f527a553e2e86bf Mon Sep 17 00:00:00 2001 From: mcarton Date: Fri, 2 Dec 2016 20:54:05 +0100 Subject: [PATCH 07/15] Revert "down to for-loops not comparing as equal" This reverts commit cf1fa94be1e98dba2ce1755e1c86acef50daf599. --- clippy_lints/src/utils/hir.rs | 95 +++++++++++++++++++++-------------- tests/compile-fail/copies.rs | 6 +-- 2 files changed, 60 insertions(+), 41 deletions(-) diff --git a/clippy_lints/src/utils/hir.rs b/clippy_lints/src/utils/hir.rs index 487a3034b3ad..f6903b107904 100644 --- a/clippy_lints/src/utils/hir.rs +++ b/clippy_lints/src/utils/hir.rs @@ -1,7 +1,6 @@ use consts::constant; use rustc::lint::*; use rustc::hir::*; -use rustc::hir::def::Def; use std::hash::{Hash, Hasher}; use std::collections::hash_map::DefaultHasher; use syntax::ast::{Name, NodeId}; @@ -104,8 +103,8 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { (&ExprLoop(ref lb, ref ll, _), &ExprLoop(ref rb, ref rl, _)) => { self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str()) } - (&ExprMatch(ref le, ref la, _), &ExprMatch(ref re, ref ra, _)) => { - self.eq_expr(le, re) && + (&ExprMatch(ref le, ref la, ref ls), &ExprMatch(ref re, ref ra, ref rs)) => { + ls == rs && self.eq_expr(le, re) && over(la, ra, |l, r| { self.eq_expr(&l.body, &r.body) && both(&l.guard, &r.guard, |l, r| self.eq_expr(l, r)) && over(&l.pats, &r.pats, |l, r| self.eq_pat(l, r)) @@ -119,10 +118,9 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { } (&ExprRepeat(ref le, ref ll), &ExprRepeat(ref re, ref rl)) => self.eq_expr(le, re) && self.eq_expr(ll, rl), (&ExprRet(ref l), &ExprRet(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)), - (&ExprPath(ref l), &ExprPath(ref r)) => self.eq_qpath(l, left.id, r, right.id), + (&ExprPath(ref l), &ExprPath(ref r)) => self.eq_qpath(l, r), (&ExprStruct(ref l_path, ref lf, ref lo), &ExprStruct(ref r_path, ref rf, ref ro)) => { - self.eq_qpath(l_path, left.id, r_path, right.id) && - both(lo, ro, |l, r| self.eq_expr(l, r)) && + self.eq_qpath(l_path, r_path) && both(lo, ro, |l, r| self.eq_expr(l, r)) && over(lf, rf, |l, r| self.eq_field(l, r)) } (&ExprTup(ref l_tup), &ExprTup(ref r_tup)) => self.eq_exprs(l_tup, r_tup), @@ -144,17 +142,21 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { left.name.node == right.name.node && self.eq_expr(&left.expr, &right.expr) } + fn eq_lifetime(&self, left: &Lifetime, right: &Lifetime) -> bool { + left.name == right.name + } + /// Check whether two patterns are the same. pub fn eq_pat(&self, left: &Pat, right: &Pat) -> bool { match (&left.node, &right.node) { (&PatKind::Box(ref l), &PatKind::Box(ref r)) => self.eq_pat(l, r), (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => { - self.eq_qpath(lp, left.id, rp, right.id) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs + self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs } - (&PatKind::Binding(ref lb, _, ref li, ref lp), &PatKind::Binding(ref rb, _, ref ri, ref rp)) => { - lb == rb && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r)) + (&PatKind::Binding(ref lb, ref ld, ref li, ref lp), &PatKind::Binding(ref rb, ref rd, ref ri, ref rp)) => { + lb == rb && ld == rd && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r)) } - (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, left.id, r, right.id), + (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r), (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r), (&PatKind::Tuple(ref l, ls), &PatKind::Tuple(ref r, rs)) => { ls == rs && over(l, r, |l, r| self.eq_pat(l, r)) @@ -172,23 +174,48 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { } } - fn eq_qpath(&self, left: &QPath, lid: NodeId, right: &QPath, rid: NodeId) -> bool { - let l = self.cx.tcx.tables().qpath_def(left, lid); - let r = self.cx.tcx.tables().qpath_def(right, rid); + fn eq_qpath(&self, left: &QPath, right: &QPath) -> bool { + match (left, right) { + (&QPath::Resolved(ref lty, ref lpath), &QPath::Resolved(ref rty, ref rpath)) => { + both(lty, rty, |l, r| self.eq_ty(l, r)) && self.eq_path(lpath, rpath) + }, + (&QPath::TypeRelative(ref lty, ref lseg), &QPath::TypeRelative(ref rty, ref rseg)) => { + self.eq_ty(lty, rty) && self.eq_path_segment(lseg, rseg) + }, + _ => false, + } + } + + fn eq_path(&self, left: &Path, right: &Path) -> bool { + left.global == right.global && + over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r)) + } - if let (Def::Local(_), Def::Local(_)) = (l, r) { - if let (&QPath::Resolved(None, ref l), &QPath::Resolved(None, ref r)) = (left, right) { - assert_eq!(l.segments.len(), 1); - assert_eq!(r.segments.len(), 1); - l.segments[0].name == r.segments[0].name - } else { - unreachable!(); + fn eq_path_parameters(&self, left: &PathParameters, right: &PathParameters) -> bool { + match (left, right) { + (&AngleBracketedParameters(ref left), &AngleBracketedParameters(ref right)) => { + over(&left.lifetimes, &right.lifetimes, |l, r| self.eq_lifetime(l, r)) && + over(&left.types, &right.types, |l, r| self.eq_ty(l, r)) && + over(&left.bindings, &right.bindings, |l, r| self.eq_type_binding(l, r)) + } + (&ParenthesizedParameters(ref left), &ParenthesizedParameters(ref right)) => { + over(&left.inputs, &right.inputs, |l, r| self.eq_ty(l, r)) && + both(&left.output, &right.output, |l, r| self.eq_ty(l, r)) + } + (&AngleBracketedParameters(_), &ParenthesizedParameters(_)) | + (&ParenthesizedParameters(_), &AngleBracketedParameters(_)) => { + false } - } else { - l == r } } + fn eq_path_segment(&self, left: &PathSegment, right: &PathSegment) -> bool { + // The == of idents doesn't work with different contexts, + // we have to be explicit about hygiene + left.name.as_str() == right.name.as_str() && + self.eq_path_parameters(&left.parameters, &right.parameters) + } + fn eq_ty(&self, left: &Ty, right: &Ty) -> bool { match (&left.node, &right.node) { (&TySlice(ref l_vec), &TySlice(ref r_vec)) => self.eq_ty(l_vec, r_vec), @@ -199,12 +226,16 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { (&TyRptr(_, ref l_rmut), &TyRptr(_, ref r_rmut)) => { l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty) } - (&TyPath(ref l), &TyPath(ref r)) => self.eq_qpath(l, left.id, r, right.id), + (&TyPath(ref l), &TyPath(ref r)) => self.eq_qpath(l, r), (&TyTup(ref l), &TyTup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)), (&TyInfer, &TyInfer) => true, _ => false, } } + + fn eq_type_binding(&self, left: &TypeBinding, right: &TypeBinding) -> bool { + left.name == right.name && self.eq_ty(&left.ty, &right.ty) + } } fn swap_binop<'a>(binop: BinOp_, lhs: &'a Expr, rhs: &'a Expr) -> Option<(BinOp_, &'a Expr, &'a Expr)> { @@ -388,7 +419,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { self.hash_name(&i.node); } } - ExprMatch(ref e, ref arms, _) => { + ExprMatch(ref e, ref arms, ref s) => { let c: fn(_, _, _) -> _ = ExprMatch; c.hash(&mut self.s); self.hash_expr(e); @@ -400,6 +431,8 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { } self.hash_expr(&arm.body); } + + s.hash(&mut self.s); } ExprMethodCall(ref name, ref _tys, ref args) => { let c: fn(_, _, _) -> _ = ExprMethodCall; @@ -495,19 +528,7 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { } pub fn hash_qpath(&mut self, p: &QPath, id: NodeId) { - let def = self.cx.tcx.tables().qpath_def(p, id); - if let Def::Local(_) = def { - true.hash(&mut self.s); - if let QPath::Resolved(None, ref seq) = *p { - assert_eq!(seq.segments.len(), 1); - self.hash_name(&seq.segments[0].name); - } else { - unreachable!(); - } - } else { - false.hash(&mut self.s); - def.hash(&mut self.s); - } + self.cx.tcx.tables().qpath_def(p, id).hash(&mut self.s); } pub fn hash_path(&mut self, p: &Path) { diff --git a/tests/compile-fail/copies.rs b/tests/compile-fail/copies.rs index ed343c3ba7a8..005129f1b5da 100644 --- a/tests/compile-fail/copies.rs +++ b/tests/compile-fail/copies.rs @@ -224,18 +224,16 @@ fn if_same_then_else() -> Result<&'static str, ()> { } if true { - //~^NOTE same as this if let Some(42) = None {} } - else { //~ERROR this `if` has identical blocks + else { if let Option::Some(42) = None {} } if true { - //~^NOTE same as this if let Some(42) = None:: {} } - else { //~ERROR this `if` has identical blocks + else { if let Some(42) = None {} } From 65ff2df7e7f7522a40bc48545d2bf8e7ce4926be Mon Sep 17 00:00:00 2001 From: mcarton Date: Fri, 2 Dec 2016 22:23:24 +0100 Subject: [PATCH 08/15] Fix copy lints --- clippy_lints/src/utils/hir.rs | 29 +++++++++++++++++++---------- tests/compile-fail/copies.rs | 31 +++++++++++++++++++------------ 2 files changed, 38 insertions(+), 22 deletions(-) diff --git a/clippy_lints/src/utils/hir.rs b/clippy_lints/src/utils/hir.rs index f6903b107904..8ac25c233f97 100644 --- a/clippy_lints/src/utils/hir.rs +++ b/clippy_lints/src/utils/hir.rs @@ -3,7 +3,7 @@ use rustc::lint::*; use rustc::hir::*; use std::hash::{Hash, Hasher}; use std::collections::hash_map::DefaultHasher; -use syntax::ast::{Name, NodeId}; +use syntax::ast::Name; use syntax::ptr::P; use utils::differing_macro_contexts; @@ -100,13 +100,14 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { self.eq_expr(lc, rc) && self.eq_block(lt, rt) && both(le, re, |l, r| self.eq_expr(l, r)) } (&ExprLit(ref l), &ExprLit(ref r)) => l.node == r.node, - (&ExprLoop(ref lb, ref ll, _), &ExprLoop(ref rb, ref rl, _)) => { - self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str()) + (&ExprLoop(ref lb, ref ll, ref lls), &ExprLoop(ref rb, ref rl, ref rls)) => { + lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.node.as_str() == r.node.as_str()) } (&ExprMatch(ref le, ref la, ref ls), &ExprMatch(ref re, ref ra, ref rs)) => { ls == rs && self.eq_expr(le, re) && over(la, ra, |l, r| { - self.eq_expr(&l.body, &r.body) && both(&l.guard, &r.guard, |l, r| self.eq_expr(l, r)) && + self.eq_expr(&l.body, &r.body) && + both(&l.guard, &r.guard, |l, r| self.eq_expr(l, r)) && over(&l.pats, &r.pats, |l, r| self.eq_pat(l, r)) }) } @@ -153,8 +154,8 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { (&PatKind::TupleStruct(ref lp, ref la, ls), &PatKind::TupleStruct(ref rp, ref ra, rs)) => { self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs } - (&PatKind::Binding(ref lb, ref ld, ref li, ref lp), &PatKind::Binding(ref rb, ref rd, ref ri, ref rp)) => { - lb == rb && ld == rd && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r)) + (&PatKind::Binding(ref lb, _, ref li, ref lp), &PatKind::Binding(ref rb, _, ref ri, ref rp)) => { + lb == rb && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r)) } (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r), (&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r), @@ -456,13 +457,13 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { ExprPath(ref qpath) => { let c: fn(_) -> _ = ExprPath; c.hash(&mut self.s); - self.hash_qpath(qpath, e.id); + self.hash_qpath(qpath); } ExprStruct(ref path, ref fields, ref expr) => { let c: fn(_, _, _) -> _ = ExprStruct; c.hash(&mut self.s); - self.hash_qpath(path, e.id); + self.hash_qpath(path); for f in fields { self.hash_name(&f.name.node); @@ -527,8 +528,16 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { n.as_str().hash(&mut self.s); } - pub fn hash_qpath(&mut self, p: &QPath, id: NodeId) { - self.cx.tcx.tables().qpath_def(p, id).hash(&mut self.s); + pub fn hash_qpath(&mut self, p: &QPath) { + match *p { + QPath::Resolved(_, ref path) => { + self.hash_path(path); + } + QPath::TypeRelative(_, ref path) => { + self.hash_name(&path.name); + } + } + //self.cx.tcx.tables().qpath_def(p, id).hash(&mut self.s); } pub fn hash_path(&mut self, p: &Path) { diff --git a/tests/compile-fail/copies.rs b/tests/compile-fail/copies.rs index 005129f1b5da..470284525458 100644 --- a/tests/compile-fail/copies.rs +++ b/tests/compile-fail/copies.rs @@ -122,22 +122,22 @@ fn if_same_then_else() -> Result<&'static str, ()> { if true { //~^NOTE same as this for _ in &[42] { - let foo: &Option<_> = &Some::(42); - if true { - break; - } else { - continue; - } + // let foo: &Option<_> = &Some::(42); + // if true { + // break; + // } else { + // continue; + // } } } else { //~ERROR this `if` has identical blocks for _ in &[42] { - let foo: &Option<_> = &Some::(42); - if true { - break; - } else { - continue; - } + // let foo: &Option<_> = &Some::(42); + // if true { + // break; + // } else { + // continue; + // } } } @@ -237,6 +237,13 @@ fn if_same_then_else() -> Result<&'static str, ()> { if let Some(42) = None {} } + if true { + if let Some(42) = None:: {} + } + else { + if let Some(42) = None:: {} + } + if true { if let Some(a) = Some(42) {} } From 1ba8ed96cfebb9936f5ff2d6af962159ab08c8e2 Mon Sep 17 00:00:00 2001 From: mcarton Date: Fri, 2 Dec 2016 22:33:16 +0100 Subject: [PATCH 09/15] Fix dogfood --- clippy_lints/src/lifetimes.rs | 2 +- clippy_lints/src/types.rs | 2 +- clippy_lints/src/utils/mod.rs | 7 ++----- 3 files changed, 4 insertions(+), 7 deletions(-) diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index 6d100317fd88..57e25b444842 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -241,7 +241,7 @@ impl<'v, 't> RefVisitor<'v, 't> { fn collect_anonymous_lifetimes(&mut self, qpath: &QPath, ty: &Ty) { let last_path_segment = &last_path_segment(qpath).parameters; - if let &AngleBracketedParameters(ref params) = last_path_segment { + if let AngleBracketedParameters(ref params) = *last_path_segment { if params.lifetimes.is_empty() { match self.cx.tcx.tables().qpath_def(qpath, ty.id) { Def::TyAlias(def_id) | diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index 15e5f3f58db7..294ca88b70f3 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -77,7 +77,7 @@ impl LateLintPass for TypePass { if let TyPath(ref qpath) = ast_ty.node { let def = cx.tcx.tables().qpath_def(qpath, ast_ty.id); if let Some(def_id) = opt_def_id(def) { - if def_id == cx.tcx.lang_items.owned_box().unwrap() { + if Some(def_id) == cx.tcx.lang_items.owned_box() { let last = last_path_segment(qpath); if_let_chain! {[ let PathParameters::AngleBracketedParameters(ref ag) = last.parameters, diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index cb25759b4ae0..05bd059d58ab 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -159,9 +159,6 @@ pub fn match_def_path(cx: &LateContext, def_id: DefId, path: &[&str]) -> bool { let mut apb = AbsolutePathBuffer { names: vec![] }; cx.tcx.push_item_path(&mut apb, def_id); - if path == paths::VEC_FROM_ELEM { - println!("{:#?} == {:#?}", apb.names, path); - } apb.names.len() == path.len() && apb.names.iter().zip(path.iter()).all(|(a, &b)| &**a == b) @@ -214,7 +211,7 @@ pub fn last_path_segment(path: &QPath) -> &PathSegment { QPath::Resolved(_, ref path) => path.segments .last() .expect("A path must have at least one segment"), - QPath::TypeRelative(_, ref seg) => &seg, + QPath::TypeRelative(_, ref seg) => seg, } } @@ -222,7 +219,7 @@ pub fn single_segment_path(path: &QPath) -> Option<&PathSegment> { match *path { QPath::Resolved(_, ref path) if path.segments.len() == 1 => Some(&path.segments[0]), QPath::Resolved(..) => None, - QPath::TypeRelative(_, ref seg) => Some(&seg), + QPath::TypeRelative(_, ref seg) => Some(seg), } } From 2e63a5648a5a45d9c2ad1d5f2aea66b304ccea76 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Sun, 4 Dec 2016 19:31:46 +0100 Subject: [PATCH 10/15] uncomment code that was commented out for testing --- tests/compile-fail/copies.rs | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/tests/compile-fail/copies.rs b/tests/compile-fail/copies.rs index 470284525458..9b1e1ec801ec 100644 --- a/tests/compile-fail/copies.rs +++ b/tests/compile-fail/copies.rs @@ -122,22 +122,22 @@ fn if_same_then_else() -> Result<&'static str, ()> { if true { //~^NOTE same as this for _ in &[42] { - // let foo: &Option<_> = &Some::(42); - // if true { - // break; - // } else { - // continue; - // } + let foo: &Option<_> = &Some::(42); + if true { + break; + } else { + continue; + } } } else { //~ERROR this `if` has identical blocks for _ in &[42] { - // let foo: &Option<_> = &Some::(42); - // if true { - // break; - // } else { - // continue; - // } + let foo: &Option<_> = &Some::(42); + if true { + break; + } else { + continue; + } } } From c6e2967b9c6bd43dde81f8c3574ca604040cc4f1 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 6 Dec 2016 11:32:21 +0100 Subject: [PATCH 11/15] rustup to rustc 1.15.0-dev (3b248a184 2016-12-05) --- clippy_lints/src/approx_const.rs | 2 +- clippy_lints/src/arithmetic.rs | 4 +- clippy_lints/src/array_indexing.rs | 2 +- clippy_lints/src/assign_ops.rs | 2 +- clippy_lints/src/attrs.rs | 16 +-- clippy_lints/src/bit_mask.rs | 2 +- clippy_lints/src/blacklisted_name.rs | 2 +- clippy_lints/src/block_in_if_condition.rs | 21 ++-- clippy_lints/src/booleans.rs | 29 +++-- clippy_lints/src/copies.rs | 2 +- clippy_lints/src/cyclomatic_complexity.rs | 41 ++++--- clippy_lints/src/derive.rs | 2 +- clippy_lints/src/drop_ref.rs | 2 +- clippy_lints/src/entry.rs | 11 +- clippy_lints/src/enum_clike.rs | 2 +- clippy_lints/src/enum_glob_use.rs | 2 +- clippy_lints/src/eq_op.rs | 2 +- clippy_lints/src/escape.rs | 10 +- clippy_lints/src/eta_reduction.rs | 5 +- clippy_lints/src/eval_order_dependence.rs | 54 +++++---- clippy_lints/src/format.rs | 2 +- clippy_lints/src/functions.rs | 33 ++++-- clippy_lints/src/identity_op.rs | 2 +- .../src/if_let_redundant_pattern_matching.rs | 2 +- clippy_lints/src/len_zero.rs | 6 +- clippy_lints/src/let_if_seq.rs | 21 +++- clippy_lints/src/lib.rs | 1 + clippy_lints/src/lifetimes.rs | 66 +++++++---- clippy_lints/src/loops.rs | 108 ++++++++++++------ clippy_lints/src/map_clone.rs | 6 +- clippy_lints/src/matches.rs | 2 +- clippy_lints/src/mem_forget.rs | 2 +- clippy_lints/src/methods.rs | 4 +- clippy_lints/src/minmax.rs | 2 +- clippy_lints/src/misc.rs | 12 +- clippy_lints/src/missing_doc.rs | 16 +-- clippy_lints/src/mut_mut.rs | 13 ++- clippy_lints/src/mut_reference.rs | 2 +- clippy_lints/src/mutex_atomic.rs | 2 +- clippy_lints/src/needless_bool.rs | 4 +- clippy_lints/src/needless_borrow.rs | 4 +- clippy_lints/src/needless_update.rs | 2 +- clippy_lints/src/neg_multiply.rs | 2 +- clippy_lints/src/new_without_default.rs | 10 +- clippy_lints/src/no_effect.rs | 2 +- clippy_lints/src/non_expressive_names.rs | 20 ++-- clippy_lints/src/ok_if_let.rs | 2 +- clippy_lints/src/open_options.rs | 2 +- .../src/overflow_check_conditional.rs | 2 +- clippy_lints/src/panic.rs | 2 +- clippy_lints/src/partialeq_ne_impl.rs | 2 +- clippy_lints/src/print.rs | 2 +- clippy_lints/src/ptr.rs | 8 +- clippy_lints/src/ranges.rs | 2 +- clippy_lints/src/regex.rs | 8 +- clippy_lints/src/serde.rs | 2 +- clippy_lints/src/shadow.rs | 79 ++++++++----- clippy_lints/src/strings.rs | 4 +- clippy_lints/src/swap.rs | 2 +- clippy_lints/src/temporary_assignment.rs | 2 +- clippy_lints/src/transmute.rs | 2 +- clippy_lints/src/types.rs | 43 ++++--- clippy_lints/src/unicode.rs | 2 +- clippy_lints/src/unused_label.rs | 36 +++--- clippy_lints/src/utils/hir.rs | 4 +- clippy_lints/src/utils/inspector.rs | 18 +-- clippy_lints/src/utils/internal_lints.rs | 20 ++-- clippy_lints/src/utils/mod.rs | 39 ++++--- clippy_lints/src/utils/sugg.rs | 6 +- clippy_lints/src/vec.rs | 2 +- clippy_lints/src/zero_div_zero.rs | 2 +- 71 files changed, 517 insertions(+), 335 deletions(-) diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs index c57122eeef91..9a6678f176a1 100644 --- a/clippy_lints/src/approx_const.rs +++ b/clippy_lints/src/approx_const.rs @@ -60,7 +60,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprLit(ref lit) = e.node { check_lit(cx, lit, e); } diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs index 7c1042e52374..0ae64e0e7872 100644 --- a/clippy_lints/src/arithmetic.rs +++ b/clippy_lints/src/arithmetic.rs @@ -48,7 +48,7 @@ impl LintPass for Arithmetic { } impl LateLintPass for Arithmetic { - fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { if self.span.is_some() { return; } @@ -82,7 +82,7 @@ impl LateLintPass for Arithmetic { } } - fn check_expr_post(&mut self, _: &LateContext, expr: &hir::Expr) { + fn check_expr_post<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { if Some(expr.span) == self.span { self.span = None; } diff --git a/clippy_lints/src/array_indexing.rs b/clippy_lints/src/array_indexing.rs index eb84f459e985..1f68c32cd24f 100644 --- a/clippy_lints/src/array_indexing.rs +++ b/clippy_lints/src/array_indexing.rs @@ -56,7 +56,7 @@ impl LintPass for ArrayIndexing { } impl LateLintPass for ArrayIndexing { - fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { if let hir::ExprIndex(ref array, ref index) = e.node { // Array with known size can be checked statically let ty = cx.tcx.tables().expr_ty(array); diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs index 9e702fe3b4e3..84b61b1cba42 100644 --- a/clippy_lints/src/assign_ops.rs +++ b/clippy_lints/src/assign_ops.rs @@ -67,7 +67,7 @@ impl LintPass for AssignOps { } impl LateLintPass for AssignOps { - fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { match expr.node { hir::ExprAssignOp(op, ref lhs, ref rhs) => { span_lint_and_then(cx, ASSIGN_OPS, expr.span, "assign operation detected", |db| { diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index 0d5e5a4cde6b..5ddbeb570468 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -82,7 +82,7 @@ impl LintPass for AttrPass { } impl LateLintPass for AttrPass { - fn check_attribute(&mut self, cx: &LateContext, attr: &Attribute) { + fn check_attribute<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, attr: &'tcx Attribute) { if let MetaItemKind::List(ref items) = attr.value.node { if items.is_empty() || attr.name() != "deprecated" { return; @@ -99,7 +99,7 @@ impl LateLintPass for AttrPass { } } - fn check_item(&mut self, cx: &LateContext, item: &Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if is_relevant_item(cx, item) { check_attrs(cx, item.span, &item.name, &item.attrs) } @@ -138,13 +138,13 @@ impl LateLintPass for AttrPass { } } - fn check_impl_item(&mut self, cx: &LateContext, item: &ImplItem) { + fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { if is_relevant_impl(cx, item) { check_attrs(cx, item.span, &item.name, &item.attrs) } } - fn check_trait_item(&mut self, cx: &LateContext, item: &TraitItem) { + fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { if is_relevant_trait(cx, item) { check_attrs(cx, item.span, &item.name, &item.attrs) } @@ -152,8 +152,8 @@ impl LateLintPass for AttrPass { } fn is_relevant_item(cx: &LateContext, item: &Item) -> bool { - if let ItemFn(_, _, _, _, _, ref expr) = item.node { - is_relevant_expr(cx, expr) + if let ItemFn(_, _, _, _, _, eid) = item.node { + is_relevant_expr(cx, cx.tcx.map.expr(eid)) } else { false } @@ -161,7 +161,7 @@ fn is_relevant_item(cx: &LateContext, item: &Item) -> bool { fn is_relevant_impl(cx: &LateContext, item: &ImplItem) -> bool { match item.node { - ImplItemKind::Method(_, ref expr) => is_relevant_expr(cx, expr), + ImplItemKind::Method(_, eid) => is_relevant_expr(cx, cx.tcx.map.expr(eid)), _ => false, } } @@ -169,7 +169,7 @@ fn is_relevant_impl(cx: &LateContext, item: &ImplItem) -> bool { fn is_relevant_trait(cx: &LateContext, item: &TraitItem) -> bool { match item.node { MethodTraitItem(_, None) => true, - MethodTraitItem(_, Some(ref expr)) => is_relevant_expr(cx, expr), + MethodTraitItem(_, Some(eid)) => is_relevant_expr(cx, cx.tcx.map.expr(eid)), _ => false, } } diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs index 8a4664d62b72..fb305f8907d5 100644 --- a/clippy_lints/src/bit_mask.rs +++ b/clippy_lints/src/bit_mask.rs @@ -80,7 +80,7 @@ impl LintPass for BitMask { } impl LateLintPass for BitMask { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprBinary(ref cmp, ref left, ref right) = e.node { if cmp.node.is_comparison() { if let Some(cmp_opt) = fetch_int_literal(cx, right) { diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs index ce7adda092cd..542bf0a4f285 100644 --- a/clippy_lints/src/blacklisted_name.rs +++ b/clippy_lints/src/blacklisted_name.rs @@ -38,7 +38,7 @@ impl LintPass for BlackListedName { } impl LateLintPass for BlackListedName { - fn check_pat(&mut self, cx: &LateContext, pat: &Pat) { + fn check_pat<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) { if let PatKind::Binding(_, _, ref ident, _) = pat.node { if self.blacklist.iter().any(|s| s == &*ident.node.as_str()) { span_lint(cx, diff --git a/clippy_lints/src/block_in_if_condition.rs b/clippy_lints/src/block_in_if_condition.rs index 704729c4e36e..1ac96bf6bcaf 100644 --- a/clippy_lints/src/block_in_if_condition.rs +++ b/clippy_lints/src/block_in_if_condition.rs @@ -1,6 +1,6 @@ use rustc::lint::{LateLintPass, LateContext, LintArray, LintPass}; use rustc::hir::*; -use rustc::hir::intravisit::{Visitor, walk_expr}; +use rustc::hir::intravisit::{Visitor, walk_expr, NestedVisitorMap}; use utils::*; /// **What it does:** Checks for `if` conditions that use blocks to contain an @@ -49,13 +49,15 @@ impl LintPass for BlockInIfCondition { } } -struct ExVisitor<'v> { - found_block: Option<&'v Expr>, +struct ExVisitor<'a, 'tcx: 'a> { + found_block: Option<&'tcx Expr>, + cx: &'a LateContext<'a, 'tcx>, } -impl<'v> Visitor<'v> for ExVisitor<'v> { - fn visit_expr(&mut self, expr: &'v Expr) { - if let ExprClosure(_, _, ref expr, _) = expr.node { +impl<'a, 'tcx: 'a> Visitor<'tcx> for ExVisitor<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx Expr) { + if let ExprClosure(_, _, eid, _) = expr.node { + let expr = self.cx.tcx.map.expr(eid); if matches!(expr.node, ExprBlock(_)) { self.found_block = Some(expr); return; @@ -63,6 +65,9 @@ impl<'v> Visitor<'v> for ExVisitor<'v> { } walk_expr(self, expr); } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } const BRACED_EXPR_MESSAGE: &'static str = "omit braces around single expression condition"; @@ -70,7 +75,7 @@ const COMPLEX_BLOCK_MESSAGE: &'static str = "in an 'if' condition, avoid complex instead, move the block or closure higher and bind it with a 'let'"; impl LateLintPass for BlockInIfCondition { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprIf(ref check, ref then, _) = expr.node { if let ExprBlock(ref block) = check.node { if block.rules == DefaultBlock { @@ -105,7 +110,7 @@ impl LateLintPass for BlockInIfCondition { } } } else { - let mut visitor = ExVisitor { found_block: None }; + let mut visitor = ExVisitor { found_block: None, cx: cx }; walk_expr(&mut visitor, check); if let Some(block) = visitor.found_block { span_lint(cx, BLOCK_IN_IF_CONDITION_STMT, block.span, COMPLEX_BLOCK_MESSAGE); diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs index 21ac913253b2..64c575046a21 100644 --- a/clippy_lints/src/booleans.rs +++ b/clippy_lints/src/booleans.rs @@ -54,12 +54,14 @@ impl LintPass for NonminimalBool { } impl LateLintPass for NonminimalBool { - fn check_item(&mut self, cx: &LateContext, item: &Item) { - NonminimalBoolVisitor(cx).visit_item(item) + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { + NonminimalBoolVisitor { cx: cx }.visit_item(item) } } -struct NonminimalBoolVisitor<'a, 'tcx: 'a>(&'a LateContext<'a, 'tcx>); +struct NonminimalBoolVisitor<'a, 'tcx: 'a> { + cx: &'a LateContext<'a, 'tcx>, +} use quine_mc_cluskey::Bool; struct Hir2Qmm<'a, 'tcx: 'a, 'v> { @@ -308,7 +310,7 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> { fn bool_expr(&self, e: &Expr) { let mut h2q = Hir2Qmm { terminals: Vec::new(), - cx: self.0, + cx: self.cx, }; if let Ok(expr) = h2q.run(e) { @@ -343,7 +345,7 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> { continue 'simplified; } if stats.terminals[i] != 0 && simplified_stats.terminals[i] == 0 { - span_lint_and_then(self.0, + span_lint_and_then(self.cx, LOGIC_BUG, e.span, "this boolean expression contains a logic bug", @@ -353,7 +355,7 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> { outer expression"); db.span_suggestion(e.span, "it would look like the following", - suggest(self.0, suggestion, &h2q.terminals)); + suggest(self.cx, suggestion, &h2q.terminals)); }); // don't also lint `NONMINIMAL_BOOL` return; @@ -370,13 +372,13 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> { } } if !improvements.is_empty() { - span_lint_and_then(self.0, + span_lint_and_then(self.cx, NONMINIMAL_BOOL, e.span, "this boolean expression can be simplified", |db| { for suggestion in &improvements { - db.span_suggestion(e.span, "try", suggest(self.0, suggestion, &h2q.terminals)); + db.span_suggestion(e.span, "try", suggest(self.cx, suggestion, &h2q.terminals)); } }); } @@ -384,15 +386,15 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> { } } -impl<'a, 'v, 'tcx> Visitor<'v> for NonminimalBoolVisitor<'a, 'tcx> { - fn visit_expr(&mut self, e: &'v Expr) { - if in_macro(self.0, e.span) { +impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> { + fn visit_expr(&mut self, e: &'tcx Expr) { + if in_macro(self.cx, e.span) { return; } match e.node { ExprBinary(binop, _, _) if binop.node == BiOr || binop.node == BiAnd => self.bool_expr(e), ExprUnary(UnNot, ref inner) => { - if self.0.tcx.tables.borrow().node_types[&inner.id].is_bool() { + if self.cx.tcx.tables.borrow().node_types[&inner.id].is_bool() { self.bool_expr(e); } else { walk_expr(self, e); @@ -401,4 +403,7 @@ impl<'a, 'v, 'tcx> Visitor<'v> for NonminimalBoolVisitor<'a, 'tcx> { _ => walk_expr(self, e), } } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs index 726b8f214fa8..1931b5d1e3f6 100644 --- a/clippy_lints/src/copies.rs +++ b/clippy_lints/src/copies.rs @@ -110,7 +110,7 @@ impl LintPass for CopyAndPaste { } impl LateLintPass for CopyAndPaste { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if !in_macro(cx, expr.span) { // skip ifs directly in else, it will be checked in the parent if if let Some(&Expr { node: ExprIf(_, _, Some(ref else_expr)), .. }) = get_parent_expr(cx, expr) { diff --git a/clippy_lints/src/cyclomatic_complexity.rs b/clippy_lints/src/cyclomatic_complexity.rs index f7758e3af231..67066d32cc3e 100644 --- a/clippy_lints/src/cyclomatic_complexity.rs +++ b/clippy_lints/src/cyclomatic_complexity.rs @@ -4,7 +4,7 @@ use rustc::cfg::CFG; use rustc::lint::*; use rustc::ty; use rustc::hir::*; -use rustc::hir::intravisit::{Visitor, walk_expr}; +use rustc::hir::intravisit::{Visitor, walk_expr, NestedVisitorMap}; use syntax::ast::Attribute; use syntax::attr; use syntax::codemap::Span; @@ -42,7 +42,7 @@ impl LintPass for CyclomaticComplexity { } impl CyclomaticComplexity { - fn check<'a, 'tcx>(&mut self, cx: &'a LateContext<'a, 'tcx>, expr: &Expr, span: Span) { + fn check<'a, 'tcx: 'a>(&mut self, cx: &'a LateContext<'a, 'tcx>, expr: &'tcx Expr, span: Span) { if in_macro(cx, span) { return; } @@ -60,7 +60,7 @@ impl CyclomaticComplexity { divergence: 0, short_circuits: 0, returns: 0, - tcx: &cx.tcx, + cx: cx, }; helper.visit_expr(expr); let CCHelper { match_arms, divergence, short_circuits, returns, .. } = helper; @@ -91,44 +91,44 @@ impl CyclomaticComplexity { } impl LateLintPass for CyclomaticComplexity { - fn check_item(&mut self, cx: &LateContext, item: &Item) { - if let ItemFn(_, _, _, _, _, ref expr) = item.node { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { + if let ItemFn(_, _, _, _, _, eid) = item.node { if !attr::contains_name(&item.attrs, "test") { - self.check(cx, expr, item.span); + self.check(cx, cx.tcx.map.expr(eid), item.span); } } } - fn check_impl_item(&mut self, cx: &LateContext, item: &ImplItem) { - if let ImplItemKind::Method(_, ref expr) = item.node { - self.check(cx, expr, item.span); + fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { + if let ImplItemKind::Method(_, eid) = item.node { + self.check(cx, cx.tcx.map.expr(eid), item.span); } } - fn check_trait_item(&mut self, cx: &LateContext, item: &TraitItem) { - if let MethodTraitItem(_, Some(ref expr)) = item.node { - self.check(cx, expr, item.span); + fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { + if let MethodTraitItem(_, Some(eid)) = item.node { + self.check(cx, cx.tcx.map.expr(eid), item.span); } } - fn enter_lint_attrs(&mut self, cx: &LateContext, attrs: &[Attribute]) { + fn enter_lint_attrs<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, attrs: &'tcx [Attribute]) { self.limit.push_attrs(cx.sess(), attrs, "cyclomatic_complexity"); } - fn exit_lint_attrs(&mut self, cx: &LateContext, attrs: &[Attribute]) { + fn exit_lint_attrs<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, attrs: &'tcx [Attribute]) { self.limit.pop_attrs(cx.sess(), attrs, "cyclomatic_complexity"); } } -struct CCHelper<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> { +struct CCHelper<'a, 'tcx: 'a> { match_arms: u64, divergence: u64, returns: u64, short_circuits: u64, // && and || - tcx: &'a ty::TyCtxt<'a, 'gcx, 'tcx>, + cx: &'a LateContext<'a, 'tcx>, } -impl<'a, 'b, 'tcx, 'gcx> Visitor<'a> for CCHelper<'b, 'gcx, 'tcx> { - fn visit_expr(&mut self, e: &'a Expr) { +impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> { + fn visit_expr(&mut self, e: &'tcx Expr) { match e.node { ExprMatch(_, ref arms, _) => { walk_expr(self, e); @@ -139,7 +139,7 @@ impl<'a, 'b, 'tcx, 'gcx> Visitor<'a> for CCHelper<'b, 'gcx, 'tcx> { } ExprCall(ref callee, _) => { walk_expr(self, e); - let ty = self.tcx.tables().node_id_to_type(callee.id); + let ty = self.cx.tcx.tables().node_id_to_type(callee.id); match ty.sty { ty::TyFnDef(_, _, ty) | ty::TyFnPtr(ty) if ty.sig.skip_binder().output.sty == ty::TyNever => { @@ -160,6 +160,9 @@ impl<'a, 'b, 'tcx, 'gcx> Visitor<'a> for CCHelper<'b, 'gcx, 'tcx> { _ => walk_expr(self, e), } } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::None + } } #[cfg(feature="debugging")] diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs index 35ea620c1283..4e9f7d9c6645 100644 --- a/clippy_lints/src/derive.rs +++ b/clippy_lints/src/derive.rs @@ -71,7 +71,7 @@ impl LintPass for Derive { } impl LateLintPass for Derive { - fn check_item(&mut self, cx: &LateContext, item: &Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemImpl(_, _, _, Some(ref trait_ref), _, _) = item.node { let ty = cx.tcx.item_type(cx.tcx.map.local_def_id(item.id)); let is_automatically_derived = is_automatically_derived(&*item.attrs); diff --git a/clippy_lints/src/drop_ref.rs b/clippy_lints/src/drop_ref.rs index dc240a0df7d5..c16d879ec2f5 100644 --- a/clippy_lints/src/drop_ref.rs +++ b/clippy_lints/src/drop_ref.rs @@ -36,7 +36,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprCall(ref path, ref args) = expr.node { if let ExprPath(ref qpath) = path.node { let def_id = cx.tcx.tables().qpath_def(qpath, path.id).def_id(); diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs index b251b02632fa..133d2dc68f92 100644 --- a/clippy_lints/src/entry.rs +++ b/clippy_lints/src/entry.rs @@ -1,5 +1,5 @@ use rustc::hir::*; -use rustc::hir::intravisit::{Visitor, walk_expr, walk_block}; +use rustc::hir::intravisit::{Visitor, walk_expr, walk_block, NestedVisitorMap}; use rustc::lint::*; use syntax::codemap::Span; use utils::SpanlessEq; @@ -40,7 +40,7 @@ impl LintPass for HashMapLint { } impl LateLintPass for HashMapLint { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprIf(ref check, ref then_block, ref else_block) = expr.node { if let ExprUnary(UnOp::UnNot, ref check) = check.node { if let Some((ty, map, key)) = check_cond(cx, check) { @@ -111,8 +111,8 @@ struct InsertVisitor<'a, 'tcx: 'a, 'b> { sole_expr: bool, } -impl<'a, 'tcx, 'v, 'b> Visitor<'v> for InsertVisitor<'a, 'tcx, 'b> { - fn visit_expr(&mut self, expr: &'v Expr) { +impl<'a, 'tcx, 'b> Visitor<'tcx> for InsertVisitor<'a, 'tcx, 'b> { + fn visit_expr(&mut self, expr: &'tcx Expr) { if_let_chain! {[ let ExprMethodCall(ref name, _, ref params) = expr.node, params.len() == 3, @@ -144,4 +144,7 @@ impl<'a, 'tcx, 'v, 'b> Visitor<'v> for InsertVisitor<'a, 'tcx, 'b> { walk_expr(self, expr); } } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs index 9188c421ccd4..28fd9833e25c 100644 --- a/clippy_lints/src/enum_clike.rs +++ b/clippy_lints/src/enum_clike.rs @@ -38,7 +38,7 @@ impl LintPass for UnportableVariant { impl LateLintPass for UnportableVariant { #[allow(cast_possible_truncation, cast_sign_loss)] - fn check_item(&mut self, cx: &LateContext, item: &Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemEnum(ref def, _) = item.node { for var in &def.variants { let variant = &var.node; diff --git a/clippy_lints/src/enum_glob_use.rs b/clippy_lints/src/enum_glob_use.rs index a47426b03ef5..1db8607bd257 100644 --- a/clippy_lints/src/enum_glob_use.rs +++ b/clippy_lints/src/enum_glob_use.rs @@ -33,7 +33,7 @@ impl LintPass for EnumGlobUse { } impl LateLintPass for EnumGlobUse { - fn check_mod(&mut self, cx: &LateContext, m: &Mod, _: Span, _: NodeId) { + fn check_mod<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, m: &'tcx Mod, _: Span, _: NodeId) { // only check top level `use` statements for item in &m.item_ids { self.lint_item(cx, cx.krate.item(item.id)); diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs index 7591e3dc076c..8cfeabba9fcb 100644 --- a/clippy_lints/src/eq_op.rs +++ b/clippy_lints/src/eq_op.rs @@ -33,7 +33,7 @@ impl LintPass for EqOp { } impl LateLintPass for EqOp { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprBinary(ref op, ref left, ref right) = e.node { if is_valid_operator(op) && SpanlessEq::new(cx).ignore_fn().eq_expr(left, right) { span_lint(cx, diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs index 703e37e77b01..df01e0481a80 100644 --- a/clippy_lints/src/escape.rs +++ b/clippy_lints/src/escape.rs @@ -61,7 +61,15 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_fn(&mut self, cx: &LateContext, _: visit::FnKind, decl: &FnDecl, body: &Expr, _: Span, id: NodeId) { + fn check_fn<'a, 'tcx: 'a>( + &mut self, + cx: &LateContext<'a, 'tcx>, + _: visit::FnKind<'tcx>, + decl: &'tcx FnDecl, + body: &'tcx Expr, + _: Span, + id: NodeId, + ) { let param_env = ty::ParameterEnvironment::for_item(cx.tcx, id); let infcx = cx.tcx.borrowck_fake_infer_ctxt(param_env); diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs index d915755fbd12..c8d468f7fa90 100644 --- a/clippy_lints/src/eta_reduction.rs +++ b/clippy_lints/src/eta_reduction.rs @@ -34,7 +34,7 @@ impl LintPass for EtaPass { } impl LateLintPass for EtaPass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { match expr.node { ExprCall(_, ref args) | ExprMethodCall(_, _, ref args) => { @@ -48,7 +48,8 @@ impl LateLintPass for EtaPass { } fn check_closure(cx: &LateContext, expr: &Expr) { - if let ExprClosure(_, ref decl, ref ex, _) = expr.node { + if let ExprClosure(_, ref decl, eid, _) = expr.node { + let ex = cx.tcx.map.expr(eid); if let ExprCall(ref caller, ref args) = ex.node { if args.len() != decl.inputs.len() { // Not the same number of arguments, there diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs index 5998f4151297..3a991b0f28b2 100644 --- a/clippy_lints/src/eval_order_dependence.rs +++ b/clippy_lints/src/eval_order_dependence.rs @@ -1,5 +1,5 @@ use rustc::hir::def_id::DefId; -use rustc::hir::intravisit::{Visitor, walk_expr}; +use rustc::hir::intravisit::{Visitor, walk_expr, NestedVisitorMap}; use rustc::hir::*; use rustc::ty; use rustc::lint::*; @@ -57,7 +57,7 @@ impl LintPass for EvalOrderDependence { } impl LateLintPass for EvalOrderDependence { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { // Find a write to a local variable. match expr.node { ExprAssign(ref lhs, _) | ExprAssignOp(_, ref lhs, _) => { @@ -79,13 +79,13 @@ impl LateLintPass for EvalOrderDependence { _ => {} } } - fn check_stmt(&mut self, cx: &LateContext, stmt: &Stmt) { + fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { match stmt.node { - StmtExpr(ref e, _) | StmtSemi(ref e, _) => DivergenceVisitor(cx).maybe_walk_expr(e), + StmtExpr(ref e, _) | StmtSemi(ref e, _) => DivergenceVisitor { cx: cx }.maybe_walk_expr(e), StmtDecl(ref d, _) => { if let DeclLocal(ref local) = d.node { if let Local { init: Some(ref e), .. } = **local { - DivergenceVisitor(cx).visit_expr(e); + DivergenceVisitor { cx: cx }.visit_expr(e); } } }, @@ -93,10 +93,12 @@ impl LateLintPass for EvalOrderDependence { } } -struct DivergenceVisitor<'a, 'tcx: 'a>(&'a LateContext<'a, 'tcx>); +struct DivergenceVisitor<'a, 'tcx: 'a> { + cx: &'a LateContext<'a, 'tcx>, +} impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> { - fn maybe_walk_expr(&mut self, e: &Expr) { + fn maybe_walk_expr(&mut self, e: &'tcx Expr) { match e.node { ExprClosure(..) => {}, ExprMatch(ref e, ref arms, _) => { @@ -114,7 +116,7 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> { } fn report_diverging_sub_expr(&mut self, e: &Expr) { span_lint( - self.0, + self.cx, DIVERGING_SUB_EXPRESSION, e.span, "sub-expression diverges", @@ -122,25 +124,25 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> { } } -impl<'a, 'tcx, 'v> Visitor<'v> for DivergenceVisitor<'a, 'tcx> { - fn visit_expr(&mut self, e: &'v Expr) { +impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> { + fn visit_expr(&mut self, e: &'tcx Expr) { match e.node { ExprAgain(_) | ExprBreak(_, _) | ExprRet(_) => self.report_diverging_sub_expr(e), - ExprCall(ref func, _) => match self.0.tcx.tables().expr_ty(func).sty { + ExprCall(ref func, _) => match self.cx.tcx.tables().expr_ty(func).sty { ty::TyFnDef(_, _, fn_ty) | - ty::TyFnPtr(fn_ty) => if let ty::TyNever = self.0.tcx.erase_late_bound_regions(&fn_ty.sig).output.sty { + ty::TyFnPtr(fn_ty) => if let ty::TyNever = self.cx.tcx.erase_late_bound_regions(&fn_ty.sig).output.sty { self.report_diverging_sub_expr(e); }, _ => {}, }, ExprMethodCall(..) => { let method_call = ty::MethodCall::expr(e.id); - let borrowed_table = self.0.tcx.tables.borrow(); + let borrowed_table = self.cx.tcx.tables.borrow(); let method_type = borrowed_table.method_map.get(&method_call).expect("This should never happen."); let result_ty = method_type.ty.fn_ret(); - if let ty::TyNever = self.0.tcx.erase_late_bound_regions(&result_ty).sty { + if let ty::TyNever = self.cx.tcx.erase_late_bound_regions(&result_ty).sty { self.report_diverging_sub_expr(e); } }, @@ -150,9 +152,12 @@ impl<'a, 'tcx, 'v> Visitor<'v> for DivergenceVisitor<'a, 'tcx> { } self.maybe_walk_expr(e); } - fn visit_block(&mut self, _: &'v Block) { + fn visit_block(&mut self, _: &'tcx Block) { // don't continue over blocks, LateLintPass already does that } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } /// Walks up the AST from the the given write expression (`vis.write_expr`) @@ -209,7 +214,7 @@ enum StopEarly { Stop, } -fn check_expr<'v, 't>(vis: & mut ReadVisitor<'v, 't>, expr: &'v Expr) -> StopEarly { +fn check_expr<'a, 'tcx: 'a>(vis: & mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> StopEarly { if expr.id == vis.last_expr.id { return StopEarly::KeepGoing; } @@ -258,7 +263,7 @@ fn check_expr<'v, 't>(vis: & mut ReadVisitor<'v, 't>, expr: &'v Expr) -> StopEar StopEarly::KeepGoing } -fn check_stmt<'v, 't>(vis: &mut ReadVisitor<'v, 't>, stmt: &'v Stmt) -> StopEarly { +fn check_stmt<'a, 'tcx: 'a>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt) -> StopEarly { match stmt.node { StmtExpr(ref expr, _) | StmtSemi(ref expr, _) => check_expr(vis, expr), @@ -276,20 +281,20 @@ fn check_stmt<'v, 't>(vis: &mut ReadVisitor<'v, 't>, stmt: &'v Stmt) -> StopEarl } /// A visitor that looks for reads from a variable. -struct ReadVisitor<'v, 't: 'v> { - cx: &'v LateContext<'v, 't>, +struct ReadVisitor<'a, 'tcx: 'a> { + cx: &'a LateContext<'a, 'tcx>, /// The id of the variable we're looking for. var: DefId, /// The expressions where the write to the variable occurred (for reporting /// in the lint). - write_expr: &'v Expr, + write_expr: &'tcx Expr, /// The last (highest in the AST) expression we've checked, so we know not /// to recheck it. - last_expr: &'v Expr, + last_expr: &'tcx Expr, } -impl<'v, 't> Visitor<'v> for ReadVisitor<'v, 't> { - fn visit_expr(&mut self, expr: &'v Expr) { +impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx Expr) { if expr.id == self.last_expr.id { return; } @@ -336,6 +341,9 @@ impl<'v, 't> Visitor<'v> for ReadVisitor<'v, 't> { walk_expr(self, expr); } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } /// Returns true if `expr` is the LHS of an assignment, like `expr = ...`. diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs index 92970bc5e01b..236888fe191e 100644 --- a/clippy_lints/src/format.rs +++ b/clippy_lints/src/format.rs @@ -39,7 +39,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let Some(span) = is_expn_of(cx, expr.span, "format") { match expr.node { // `format!("{}", foo)` expansion diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index 82f210f3d507..0d9a668e8b62 100644 --- a/clippy_lints/src/functions.rs +++ b/clippy_lints/src/functions.rs @@ -69,7 +69,15 @@ impl LintPass for Functions { } impl LateLintPass for Functions { - fn check_fn(&mut self, cx: &LateContext, kind: intravisit::FnKind, decl: &hir::FnDecl, expr: &hir::Expr, span: Span, nodeid: ast::NodeId) { + fn check_fn<'a, 'tcx: 'a>( + &mut self, + cx: &LateContext<'a, 'tcx>, + kind: intravisit::FnKind<'tcx>, + decl: &'tcx hir::FnDecl, + expr: &'tcx hir::Expr, + span: Span, + nodeid: ast::NodeId, + ) { use rustc::hir::map::Node::*; let is_impl = if let Some(NodeItem(item)) = cx.tcx.map.find(cx.tcx.map.get_parent_node(nodeid)) { @@ -97,14 +105,15 @@ impl LateLintPass for Functions { self.check_raw_ptr(cx, unsafety, decl, expr, nodeid); } - fn check_trait_item(&mut self, cx: &LateContext, item: &hir::TraitItem) { - if let hir::MethodTraitItem(ref sig, ref expr) = item.node { + fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) { + if let hir::MethodTraitItem(ref sig, eid) = item.node { // don't lint extern functions decls, it's not their fault if sig.abi == Abi::Rust { self.check_arg_number(cx, &sig.decl, item.span); } - if let Some(ref expr) = *expr { + if let Some(eid) = eid { + let expr = cx.tcx.map.expr(eid); self.check_raw_ptr(cx, sig.unsafety, &sig.decl, expr, item.id); } } @@ -122,7 +131,14 @@ impl Functions { } } - fn check_raw_ptr(&self, cx: &LateContext, unsafety: hir::Unsafety, decl: &hir::FnDecl, expr: &hir::Expr, nodeid: ast::NodeId) { + fn check_raw_ptr<'a, 'tcx: 'a>( + &self, + cx: &LateContext<'a, 'tcx>, + unsafety: hir::Unsafety, + decl: &'tcx hir::FnDecl, + expr: &'tcx hir::Expr, + nodeid: ast::NodeId, + ) { if unsafety == hir::Unsafety::Normal && cx.access_levels.is_exported(nodeid) { let raw_ptrs = decl.inputs.iter().filter_map(|arg| raw_ptr_arg(cx, arg)).collect::>(); @@ -151,8 +167,8 @@ struct DerefVisitor<'a, 'tcx: 'a> { ptrs: HashSet, } -impl<'a, 'tcx, 'v> hir::intravisit::Visitor<'v> for DerefVisitor<'a, 'tcx> { - fn visit_expr(&mut self, expr: &'v hir::Expr) { +impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx hir::Expr) { match expr.node { hir::ExprCall(ref f, ref args) => { let ty = self.cx.tcx.tables().expr_ty(f); @@ -179,6 +195,9 @@ impl<'a, 'tcx, 'v> hir::intravisit::Visitor<'v> for DerefVisitor<'a, 'tcx> { hir::intravisit::walk_expr(self, expr); } + fn nested_visit_map<'this>(&'this mut self) -> intravisit::NestedVisitorMap<'this, 'tcx> { + intravisit::NestedVisitorMap::All(&self.cx.tcx.map) + } } impl<'a, 'tcx: 'a> DerefVisitor<'a, 'tcx> { diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs index 92901aa7855b..f360c59372bc 100644 --- a/clippy_lints/src/identity_op.rs +++ b/clippy_lints/src/identity_op.rs @@ -32,7 +32,7 @@ impl LintPass for IdentityOp { } impl LateLintPass for IdentityOp { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if in_macro(cx, e.span) { return; } diff --git a/clippy_lints/src/if_let_redundant_pattern_matching.rs b/clippy_lints/src/if_let_redundant_pattern_matching.rs index 878a1b7313b2..bc834886db96 100644 --- a/clippy_lints/src/if_let_redundant_pattern_matching.rs +++ b/clippy_lints/src/if_let_redundant_pattern_matching.rs @@ -43,7 +43,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprMatch(ref op, ref arms, MatchSource::IfLetDesugar{..}) = expr.node { diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs index be93699bae65..98db74cff3a2 100644 --- a/clippy_lints/src/len_zero.rs +++ b/clippy_lints/src/len_zero.rs @@ -60,7 +60,7 @@ impl LintPass for LenZero { } impl LateLintPass for LenZero { - fn check_item(&mut self, cx: &LateContext, item: &Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if in_macro(cx, item.span) { return; } @@ -72,7 +72,7 @@ impl LateLintPass for LenZero { } } - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if in_macro(cx, expr.span) { return; } @@ -208,7 +208,7 @@ fn has_is_empty(cx: &LateContext, expr: &Expr) -> bool { let ty = &walk_ptrs_ty(cx.tcx.tables().expr_ty(expr)); match ty.sty { - ty::TyTrait(_) => { + ty::TyDynamic(..) => { cx.tcx .associated_items(ty.ty_to_def_id().expect("trait impl not found")) .any(|item| is_is_empty(cx, &item)) diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs index e1f20eb1859f..1605505a6ae3 100644 --- a/clippy_lints/src/let_if_seq.rs +++ b/clippy_lints/src/let_if_seq.rs @@ -58,7 +58,7 @@ impl LintPass for LetIfSeq { } impl LateLintPass for LetIfSeq { - fn check_block(&mut self, cx: &LateContext, block: &hir::Block) { + fn check_block<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx hir::Block) { let mut it = block.stmts.iter().peekable(); while let Some(stmt) = it.next() { if_let_chain! {[ @@ -133,8 +133,8 @@ struct UsedVisitor<'a, 'tcx: 'a> { used: bool, } -impl<'a, 'tcx, 'v> hir::intravisit::Visitor<'v> for UsedVisitor<'a, 'tcx> { - fn visit_expr(&mut self, expr: &'v hir::Expr) { +impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for UsedVisitor<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx hir::Expr) { if_let_chain! {[ let hir::ExprPath(ref qpath) = expr.node, self.id == self.cx.tcx.tables().qpath_def(qpath, expr.id).def_id(), @@ -144,9 +144,16 @@ impl<'a, 'tcx, 'v> hir::intravisit::Visitor<'v> for UsedVisitor<'a, 'tcx> { }} hir::intravisit::walk_expr(self, expr); } + fn nested_visit_map<'this>(&'this mut self) -> hir::intravisit::NestedVisitorMap<'this, 'tcx> { + hir::intravisit::NestedVisitorMap::All(&self.cx.tcx.map) + } } -fn check_assign<'e>(cx: &LateContext, decl: hir::def_id::DefId, block: &'e hir::Block) -> Option<&'e hir::Expr> { +fn check_assign<'a, 'tcx: 'a>( + cx: &LateContext<'a, 'tcx>, + decl: hir::def_id::DefId, + block: &'tcx hir::Block, +) -> Option<&'tcx hir::Expr> { if_let_chain! {[ block.expr.is_none(), let Some(expr) = block.stmts.iter().last(), @@ -175,7 +182,11 @@ fn check_assign<'e>(cx: &LateContext, decl: hir::def_id::DefId, block: &'e hir:: None } -fn used_in_expr(cx: &LateContext, id: hir::def_id::DefId, expr: &hir::Expr) -> bool { +fn used_in_expr<'a, 'tcx: 'a>( + cx: &LateContext<'a, 'tcx>, + id: hir::def_id::DefId, + expr: &'tcx hir::Expr, +) -> bool { let mut v = UsedVisitor { cx: cx, id: id, diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index 7e2b85df572e..b28c78f29d1c 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -9,6 +9,7 @@ #![feature(repeat_str)] #![allow(indexing_slicing, shadow_reuse, unknown_lints, missing_docs_in_private_items)] +#![allow(needless_lifetimes)] #[macro_use] extern crate syntax; diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index 57e25b444842..22e7384675fb 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -2,7 +2,7 @@ use reexport::*; use rustc::lint::*; use rustc::hir::def::Def; use rustc::hir::*; -use rustc::hir::intravisit::{Visitor, walk_ty, walk_ty_param_bound, walk_fn_decl, walk_generics}; +use rustc::hir::intravisit::{Visitor, walk_ty, walk_ty_param_bound, walk_fn_decl, walk_generics, NestedVisitorMap}; use std::collections::{HashSet, HashMap}; use syntax::codemap::Span; use utils::{in_external_macro, span_lint, last_path_segment}; @@ -57,19 +57,19 @@ impl LintPass for LifetimePass { } impl LateLintPass for LifetimePass { - fn check_item(&mut self, cx: &LateContext, item: &Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemFn(ref decl, _, _, _, ref generics, _) = item.node { check_fn_inner(cx, decl, generics, item.span); } } - fn check_impl_item(&mut self, cx: &LateContext, item: &ImplItem) { + fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { if let ImplItemKind::Method(ref sig, _) = item.node { check_fn_inner(cx, &sig.decl, &sig.generics, item.span); } } - fn check_trait_item(&mut self, cx: &LateContext, item: &TraitItem) { + fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { if let MethodTraitItem(ref sig, _) = item.node { check_fn_inner(cx, &sig.decl, &sig.generics, item.span); } @@ -98,7 +98,12 @@ fn bound_lifetimes(bound: &TyParamBound) -> HirVec<&Lifetime> { } } -fn check_fn_inner(cx: &LateContext, decl: &FnDecl, generics: &Generics, span: Span) { +fn check_fn_inner<'a, 'tcx: 'a>( + cx: &LateContext<'a, 'tcx>, + decl: &'tcx FnDecl, + generics: &'tcx Generics, + span: Span, +) { if in_external_macro(cx, span) || has_where_lifetimes(cx, &generics.where_clause) { return; } @@ -116,9 +121,16 @@ fn check_fn_inner(cx: &LateContext, decl: &FnDecl, generics: &Generics, span: Sp report_extra_lifetimes(cx, decl, generics); } -fn could_use_elision<'a, T: Iterator>(cx: &LateContext, func: &FnDecl, - named_lts: &[LifetimeDef], bounds_lts: T) - -> bool { +fn could_use_elision< + 'a, + 'tcx: 'a, + T: Iterator +>( + cx: &LateContext<'a, 'tcx>, + func: &'tcx FnDecl, + named_lts: &'tcx [LifetimeDef], + bounds_lts: T, +) -> bool { // There are two scenarios where elision works: // * no output references, all input references have different LT // * output references, exactly one input reference with same LT @@ -210,8 +222,8 @@ fn unique_lifetimes(lts: &[RefLt]) -> usize { } /// A visitor usable for `rustc_front::visit::walk_ty()`. -struct RefVisitor<'v, 't: 'v> { - cx: &'v LateContext<'v, 't>, +struct RefVisitor<'a, 'tcx: 'a> { + cx: &'a LateContext<'a, 'tcx>, lts: Vec, } @@ -253,7 +265,7 @@ impl<'v, 't> RefVisitor<'v, 't> { } Def::Trait(def_id) => { let trait_def = self.cx.tcx.trait_defs.borrow()[&def_id]; - for _ in &trait_def.generics.regions { + for _ in &self.cx.tcx.item_generics(trait_def.def_id).regions { self.record(&None); } } @@ -264,13 +276,13 @@ impl<'v, 't> RefVisitor<'v, 't> { } } -impl<'v, 't> Visitor<'v> for RefVisitor<'v, 't> { +impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> { // for lifetimes as parameters of generics - fn visit_lifetime(&mut self, lifetime: &'v Lifetime) { + fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) { self.record(&Some(*lifetime)); } - fn visit_ty(&mut self, ty: &'v Ty) { + fn visit_ty(&mut self, ty: &'tcx Ty) { match ty.node { TyRptr(None, _) => { self.record(&None); @@ -282,11 +294,14 @@ impl<'v, 't> Visitor<'v> for RefVisitor<'v, 't> { } walk_ty(self, ty); } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::None + } } /// Are any lifetimes mentioned in the `where` clause? If yes, we don't try to /// reason about elision. -fn has_where_lifetimes(cx: &LateContext, where_clause: &WhereClause) -> bool { +fn has_where_lifetimes<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, where_clause: &'tcx WhereClause) -> bool { for predicate in &where_clause.predicates { match *predicate { WherePredicate::RegionPredicate(..) => return true, @@ -323,34 +338,39 @@ fn has_where_lifetimes(cx: &LateContext, where_clause: &WhereClause) -> bool { false } -struct LifetimeChecker(HashMap); +struct LifetimeChecker { + map: HashMap, +} -impl<'v> Visitor<'v> for LifetimeChecker { +impl<'tcx> Visitor<'tcx> for LifetimeChecker { // for lifetimes as parameters of generics - fn visit_lifetime(&mut self, lifetime: &'v Lifetime) { - self.0.remove(&lifetime.name); + fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) { + self.map.remove(&lifetime.name); } - fn visit_lifetime_def(&mut self, _: &'v LifetimeDef) { + fn visit_lifetime_def(&mut self, _: &'tcx LifetimeDef) { // don't actually visit `<'a>` or `<'a: 'b>` // we've already visited the `'a` declarations and // don't want to spuriously remove them // `'b` in `'a: 'b` is useless unless used elsewhere in // a non-lifetime bound } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::None + } } -fn report_extra_lifetimes(cx: &LateContext, func: &FnDecl, generics: &Generics) { +fn report_extra_lifetimes<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, func: &'tcx FnDecl, generics: &'tcx Generics) { let hs = generics.lifetimes .iter() .map(|lt| (lt.lifetime.name, lt.lifetime.span)) .collect(); - let mut checker = LifetimeChecker(hs); + let mut checker = LifetimeChecker { map: hs }; walk_generics(&mut checker, generics); walk_fn_decl(&mut checker, func); - for &v in checker.0.values() { + for &v in checker.map.values() { span_lint(cx, UNUSED_LIFETIMES, v, "this lifetime isn't used in the function definition"); } } diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index 0d862b76d9bb..233c62890096 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -2,7 +2,7 @@ use reexport::*; use rustc::hir::*; use rustc::hir::def::Def; use rustc::hir::def_id::DefId; -use rustc::hir::intravisit::{Visitor, walk_expr, walk_block, walk_decl}; +use rustc::hir::intravisit::{Visitor, walk_expr, walk_block, walk_decl, NestedVisitorMap}; use rustc::hir::map::Node::NodeBlock; use rustc::lint::*; use rustc::middle::const_val::ConstVal; @@ -308,7 +308,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let Some((pat, arg, body)) = higher::for_loop(expr) { check_for_loop(cx, pat, arg, body, expr); } @@ -391,7 +391,7 @@ impl LateLintPass for Pass { } } - fn check_stmt(&mut self, cx: &LateContext, stmt: &Stmt) { + fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { if let StmtSemi(ref expr, _) = stmt.node { if let ExprMethodCall(ref method, _, ref args) = expr.node { if args.len() == 1 && &*method.node.as_str() == "collect" && @@ -407,7 +407,13 @@ impl LateLintPass for Pass { } } -fn check_for_loop(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, expr: &Expr) { +fn check_for_loop<'a, 'tcx: 'a>( + cx: &LateContext<'a, 'tcx>, + pat: &'tcx Pat, + arg: &'tcx Expr, + body: &'tcx Expr, + expr: &'tcx Expr, +) { check_for_loop_range(cx, pat, arg, body, expr); check_for_loop_reverse_range(cx, arg, expr); check_for_loop_arg(cx, pat, arg, expr); @@ -417,7 +423,13 @@ fn check_for_loop(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, expr: &E /// Check for looping over a range and then indexing a sequence with it. /// The iteratee must be a range literal. -fn check_for_loop_range(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, expr: &Expr) { +fn check_for_loop_range<'a, 'tcx: 'a>( + cx: &LateContext<'a, 'tcx>, + pat: &'tcx Pat, + arg: &'tcx Expr, + body: &'tcx Expr, + expr: &'tcx Expr, +) { if let Some(higher::Range { start: Some(start), ref end, limits }) = higher::range(arg) { // the var must be a single name if let PatKind::Binding(_, def_id, ref ident, _) = pat.node { @@ -646,7 +658,12 @@ fn check_arg_type(cx: &LateContext, pat: &Pat, arg: &Expr) { } } -fn check_for_loop_explicit_counter(cx: &LateContext, arg: &Expr, body: &Expr, expr: &Expr) { +fn check_for_loop_explicit_counter<'a, 'tcx: 'a>( + cx: &LateContext<'a, 'tcx>, + arg: &'tcx Expr, + body: &'tcx Expr, + expr: &'tcx Expr, +) { // Look for variables that are incremented once per loop iteration. let mut visitor = IncrementVisitor { cx: cx, @@ -691,14 +708,20 @@ fn check_for_loop_explicit_counter(cx: &LateContext, arg: &Expr, body: &Expr, ex } /// Check for the `FOR_KV_MAP` lint. -fn check_for_loop_over_map_kv(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, expr: &Expr) { +fn check_for_loop_over_map_kv<'a, 'tcx: 'a>( + cx: &LateContext<'a, 'tcx>, + pat: &'tcx Pat, + arg: &'tcx Expr, + body: &'tcx Expr, + expr: &'tcx Expr, +) { let pat_span = pat.span; if let PatKind::Tuple(ref pat, _) = pat.node { if pat.len() == 2 { let (new_pat_span, kind) = match (&pat[0].node, &pat[1].node) { - (key, _) if pat_is_wild(key, body) => (pat[1].span, "value"), - (_, value) if pat_is_wild(value, body) => (pat[0].span, "key"), + (key, _) if pat_is_wild(cx, key, body) => (pat[1].span, "value"), + (_, value) if pat_is_wild(cx, value, body) => (pat[0].span, "key"), _ => return, }; @@ -728,13 +751,18 @@ fn check_for_loop_over_map_kv(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Ex } /// Return true if the pattern is a `PatWild` or an ident prefixed with `'_'`. -fn pat_is_wild(pat: &PatKind, body: &Expr) -> bool { +fn pat_is_wild<'a, 'tcx: 'a>( + cx: &LateContext<'a, 'tcx>, + pat: &'tcx PatKind, + body: &'tcx Expr, +) -> bool { match *pat { PatKind::Wild => true, PatKind::Binding(_, _, ident, None) if ident.node.as_str().starts_with('_') => { let mut visitor = UsedVisitor { var: ident.node, used: false, + cx: cx, }; walk_expr(&mut visitor, body); !visitor.used @@ -743,13 +771,14 @@ fn pat_is_wild(pat: &PatKind, body: &Expr) -> bool { } } -struct UsedVisitor { +struct UsedVisitor<'a, 'tcx: 'a> { var: ast::Name, // var to look for used: bool, // has the var been used otherwise? + cx: &'a LateContext<'a, 'tcx>, } -impl<'a> Visitor<'a> for UsedVisitor { - fn visit_expr(&mut self, expr: &Expr) { +impl<'a, 'tcx: 'a> Visitor<'tcx> for UsedVisitor<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx Expr) { if let ExprPath(QPath::Resolved(None, ref path)) = expr.node { if path.segments.len() == 1 && path.segments[0].name == self.var { self.used = true; @@ -759,17 +788,20 @@ impl<'a> Visitor<'a> for UsedVisitor { walk_expr(self, expr); } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } -struct VarVisitor<'v, 't: 'v> { - cx: &'v LateContext<'v, 't>, // context reference +struct VarVisitor<'a, 'tcx: 'a> { + cx: &'a LateContext<'a, 'tcx>, // context reference var: DefId, // var name to look for as index indexed: HashMap>, // indexed variables, the extent is None for global nonindex: bool, // has the var been used otherwise? } -impl<'v, 't> Visitor<'v> for VarVisitor<'v, 't> { - fn visit_expr(&mut self, expr: &'v Expr) { +impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx Expr) { if let ExprPath(ref qpath) = expr.node { if let QPath::Resolved(None, ref path) = *qpath { if path.segments.len() == 1 && self.cx.tcx.tables().qpath_def(qpath, expr.id).def_id() == self.var { @@ -806,9 +838,12 @@ impl<'v, 't> Visitor<'v> for VarVisitor<'v, 't> { } walk_expr(self, expr); } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } -fn is_iterator_used_after_while_let(cx: &LateContext, iter_expr: &Expr) -> bool { +fn is_iterator_used_after_while_let<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, iter_expr: &'tcx Expr) -> bool { let def_id = match var_def_id(cx, iter_expr) { Some(id) => id, None => return false, @@ -826,16 +861,16 @@ fn is_iterator_used_after_while_let(cx: &LateContext, iter_expr: &Expr) -> bool visitor.var_used_after_while_let } -struct VarUsedAfterLoopVisitor<'v, 't: 'v> { - cx: &'v LateContext<'v, 't>, +struct VarUsedAfterLoopVisitor<'a, 'tcx: 'a> { + cx: &'a LateContext<'a, 'tcx>, def_id: NodeId, iter_expr_id: NodeId, past_while_let: bool, var_used_after_while_let: bool, } -impl<'v, 't> Visitor<'v> for VarUsedAfterLoopVisitor<'v, 't> { - fn visit_expr(&mut self, expr: &'v Expr) { +impl<'a, 'tcx> Visitor<'tcx> for VarUsedAfterLoopVisitor<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx Expr) { if self.past_while_let { if Some(self.def_id) == var_def_id(self.cx, expr) { self.var_used_after_while_let = true; @@ -845,6 +880,9 @@ impl<'v, 't> Visitor<'v> for VarUsedAfterLoopVisitor<'v, 't> { } walk_expr(self, expr); } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } @@ -935,15 +973,15 @@ enum VarState { } /// Scan a for loop for variables that are incremented exactly once. -struct IncrementVisitor<'v, 't: 'v> { - cx: &'v LateContext<'v, 't>, // context reference +struct IncrementVisitor<'a, 'tcx: 'a> { + cx: &'a LateContext<'a, 'tcx>, // context reference states: HashMap, // incremented variables depth: u32, // depth of conditional expressions done: bool, } -impl<'v, 't> Visitor<'v> for IncrementVisitor<'v, 't> { - fn visit_expr(&mut self, expr: &'v Expr) { +impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx Expr) { if self.done { return; } @@ -984,12 +1022,15 @@ impl<'v, 't> Visitor<'v> for IncrementVisitor<'v, 't> { } walk_expr(self, expr); } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } /// Check whether a variable is initialized to zero at the start of a loop. -struct InitializeVisitor<'v, 't: 'v> { - cx: &'v LateContext<'v, 't>, // context reference - end_expr: &'v Expr, // the for loop. Stop scanning here. +struct InitializeVisitor<'a, 'tcx: 'a> { + cx: &'a LateContext<'a, 'tcx>, // context reference + end_expr: &'tcx Expr, // the for loop. Stop scanning here. var_id: NodeId, state: VarState, name: Option, @@ -997,8 +1038,8 @@ struct InitializeVisitor<'v, 't: 'v> { past_loop: bool, } -impl<'v, 't> Visitor<'v> for InitializeVisitor<'v, 't> { - fn visit_decl(&mut self, decl: &'v Decl) { +impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> { + fn visit_decl(&mut self, decl: &'tcx Decl) { // Look for declarations of the variable if let DeclLocal(ref local) = decl.node { if local.pat.id == self.var_id { @@ -1020,7 +1061,7 @@ impl<'v, 't> Visitor<'v> for InitializeVisitor<'v, 't> { walk_decl(self, decl); } - fn visit_expr(&mut self, expr: &'v Expr) { + fn visit_expr(&mut self, expr: &'tcx Expr) { if self.state == VarState::DontWarn { return; } @@ -1068,6 +1109,9 @@ impl<'v, 't> Visitor<'v> for InitializeVisitor<'v, 't> { } walk_expr(self, expr); } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } fn var_def_id(cx: &LateContext, expr: &Expr) -> Option { diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs index 9d9b0a6e35bb..416f9dcf93eb 100644 --- a/clippy_lints/src/map_clone.rs +++ b/clippy_lints/src/map_clone.rs @@ -25,13 +25,13 @@ declare_lint! { pub struct Pass; impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { // call to .map() if let ExprMethodCall(name, _, ref args) = expr.node { if &*name.node.as_str() == "map" && args.len() == 2 { match args[1].node { - ExprClosure(_, ref decl, ref closure_expr, _) => { - let closure_expr = remove_blocks(closure_expr); + ExprClosure(_, ref decl, closure_eid, _) => { + let closure_expr = remove_blocks(cx.tcx.map.expr(closure_eid)); if_let_chain! {[ // nothing special in the argument, besides reference bindings // (e.g. .map(|&x| x) ) diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index 828e7eda0263..0820a8137329 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -130,7 +130,7 @@ impl LintPass for MatchPass { } impl LateLintPass for MatchPass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if in_external_macro(cx, expr.span) { return; } diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs index 288c238474fe..e3299958ae68 100644 --- a/clippy_lints/src/mem_forget.rs +++ b/clippy_lints/src/mem_forget.rs @@ -28,7 +28,7 @@ impl LintPass for MemForget { } impl LateLintPass for MemForget { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprCall(ref path_expr, ref args) = e.node { if let ExprPath(ref qpath) = path_expr.node { let def_id = cx.tcx.tables().qpath_def(qpath, path_expr.id).def_id(); diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index edcdc74013b0..dd99f5a358ba 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -553,7 +553,7 @@ impl LateLintPass for Pass { #[allow(unused_attributes)] // ^ required because `cyclomatic_complexity` attribute shows up as unused #[cyclomatic_complexity = "30"] - fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { if in_macro(cx, expr.span) { return; } @@ -629,7 +629,7 @@ impl LateLintPass for Pass { } } - fn check_impl_item(&mut self, cx: &LateContext, implitem: &hir::ImplItem) { + fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, implitem: &'tcx hir::ImplItem) { if in_external_macro(cx, implitem.span) { return; } diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs index 2b453f1c8806..f1f353cb762c 100644 --- a/clippy_lints/src/minmax.rs +++ b/clippy_lints/src/minmax.rs @@ -34,7 +34,7 @@ impl LintPass for MinMaxPass { } impl LateLintPass for MinMaxPass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let Some((outer_max, outer_c, oe)) = min_max(cx, expr) { if let Some((inner_max, inner_c, _)) = min_max(cx, oe) { if outer_max == inner_max { diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index 5752e95d0acc..679bad666b9f 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -167,7 +167,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_fn(&mut self, cx: &LateContext, k: FnKind, decl: &FnDecl, _: &Expr, _: Span, _: NodeId) { + fn check_fn<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, k: FnKind<'tcx>, decl: &'tcx FnDecl, _: &'tcx Expr, _: Span, _: NodeId) { if let FnKind::Closure(_) = k { // Does not apply to closures return; @@ -182,7 +182,7 @@ impl LateLintPass for Pass { } } - fn check_stmt(&mut self, cx: &LateContext, s: &Stmt) { + fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx Stmt) { if_let_chain! {[ let StmtDecl(ref d, _) = s.node, let DeclLocal(ref l) = d.node, @@ -216,7 +216,7 @@ impl LateLintPass for Pass { }} } - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprBinary(ref cmp, ref left, ref right) = expr.node { let op = cmp.node; if op.is_comparison() { @@ -294,7 +294,7 @@ impl LateLintPass for Pass { } } - fn check_pat(&mut self, cx: &LateContext, pat: &Pat) { + fn check_pat<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) { if let PatKind::Binding(_, _, ref ident, Some(ref right)) = pat.node { if right.node == PatKind::Wild { span_lint(cx, @@ -440,9 +440,7 @@ fn in_attributes_expansion(cx: &LateContext, expr: &Expr) -> bool { fn non_macro_local(cx: &LateContext, def: &def::Def) -> bool { match *def { def::Def::Local(id) | def::Def::Upvar(id, _, _) => { - let id = cx.tcx.map.as_local_node_id(id).expect("That DefId should be valid"); - - if let Some(span) = cx.tcx.map.opt_span(id) { + if let Some(span) = cx.tcx.map.span_if_local(id) { !in_macro(cx, span) } else { true diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs index 7ca00500475f..e40638616b6e 100644 --- a/clippy_lints/src/missing_doc.rs +++ b/clippy_lints/src/missing_doc.rs @@ -95,7 +95,7 @@ impl LintPass for MissingDoc { } impl LateLintPass for MissingDoc { - fn enter_lint_attrs(&mut self, _: &LateContext, attrs: &[ast::Attribute]) { + fn enter_lint_attrs<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, attrs: &'tcx [ast::Attribute]) { let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| { attr.check_name("doc") && match attr.meta_item_list() { None => false, @@ -105,15 +105,15 @@ impl LateLintPass for MissingDoc { self.doc_hidden_stack.push(doc_hidden); } - fn exit_lint_attrs(&mut self, _: &LateContext, _: &[ast::Attribute]) { + fn exit_lint_attrs<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx [ast::Attribute]) { self.doc_hidden_stack.pop().expect("empty doc_hidden_stack"); } - fn check_crate(&mut self, cx: &LateContext, krate: &hir::Crate) { + fn check_crate<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, krate: &'tcx hir::Crate) { self.check_missing_docs_attrs(cx, &krate.attrs, krate.span, "crate"); } - fn check_item(&mut self, cx: &LateContext, it: &hir::Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { let desc = match it.node { hir::ItemConst(..) => "a constant", hir::ItemEnum(..) => "an enum", @@ -134,7 +134,7 @@ impl LateLintPass for MissingDoc { self.check_missing_docs_attrs(cx, &it.attrs, it.span, desc); } - fn check_trait_item(&mut self, cx: &LateContext, trait_item: &hir::TraitItem) { + fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, trait_item: &'tcx hir::TraitItem) { let desc = match trait_item.node { hir::ConstTraitItem(..) => "an associated constant", hir::MethodTraitItem(..) => "a trait method", @@ -144,7 +144,7 @@ impl LateLintPass for MissingDoc { self.check_missing_docs_attrs(cx, &trait_item.attrs, trait_item.span, desc); } - fn check_impl_item(&mut self, cx: &LateContext, impl_item: &hir::ImplItem) { + fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx hir::ImplItem) { // If the method is an impl for a trait, don't doc. let def_id = cx.tcx.map.local_def_id(impl_item.id); match cx.tcx.associated_item(def_id).container { @@ -164,13 +164,13 @@ impl LateLintPass for MissingDoc { self.check_missing_docs_attrs(cx, &impl_item.attrs, impl_item.span, desc); } - fn check_struct_field(&mut self, cx: &LateContext, sf: &hir::StructField) { + fn check_struct_field<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, sf: &'tcx hir::StructField) { if !sf.is_positional() { self.check_missing_docs_attrs(cx, &sf.attrs, sf.span, "a struct field"); } } - fn check_variant(&mut self, cx: &LateContext, v: &hir::Variant, _: &hir::Generics) { + fn check_variant<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, v: &'tcx hir::Variant, _: &hir::Generics) { self.check_missing_docs_attrs(cx, &v.node.attrs, v.span, "a variant"); } } diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs index fe430a539a0f..303c53186024 100644 --- a/clippy_lints/src/mut_mut.rs +++ b/clippy_lints/src/mut_mut.rs @@ -32,11 +32,11 @@ impl LintPass for MutMut { } impl LateLintPass for MutMut { - fn check_block(&mut self, cx: &LateContext, block: &hir::Block) { + fn check_block<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx hir::Block) { intravisit::walk_block(&mut MutVisitor { cx: cx }, block); } - fn check_ty(&mut self, cx: &LateContext, ty: &hir::Ty) { + fn check_ty<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, ty: &'tcx hir::Ty) { use rustc::hir::intravisit::Visitor; MutVisitor { cx: cx }.visit_ty(ty); @@ -47,8 +47,8 @@ pub struct MutVisitor<'a, 'tcx: 'a> { cx: &'a LateContext<'a, 'tcx>, } -impl<'a, 'tcx, 'v> intravisit::Visitor<'v> for MutVisitor<'a, 'tcx> { - fn visit_expr(&mut self, expr: &'v hir::Expr) { +impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx hir::Expr) { if in_external_macro(self.cx, expr.span) { return; } @@ -74,7 +74,7 @@ impl<'a, 'tcx, 'v> intravisit::Visitor<'v> for MutVisitor<'a, 'tcx> { } } - fn visit_ty(&mut self, ty: &hir::Ty) { + fn visit_ty(&mut self, ty: &'tcx hir::Ty) { if let hir::TyRptr(_, hir::MutTy { ty: ref pty, mutbl: hir::MutMutable }) = ty.node { if let hir::TyRptr(_, hir::MutTy { mutbl: hir::MutMutable, .. }) = pty.node { span_lint(self.cx, MUT_MUT, ty.span, "generally you want to avoid `&mut &mut _` if possible"); @@ -84,4 +84,7 @@ impl<'a, 'tcx, 'v> intravisit::Visitor<'v> for MutVisitor<'a, 'tcx> { intravisit::walk_ty(self, ty); } + fn nested_visit_map<'this>(&'this mut self) -> intravisit::NestedVisitorMap<'this, 'tcx> { + intravisit::NestedVisitorMap::All(&self.cx.tcx.map) + } } diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs index eadf0d8ce89c..08d39b7c43d6 100644 --- a/clippy_lints/src/mut_reference.rs +++ b/clippy_lints/src/mut_reference.rs @@ -33,7 +33,7 @@ impl LintPass for UnnecessaryMutPassed { } impl LateLintPass for UnnecessaryMutPassed { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { let borrowed_table = cx.tcx.tables.borrow(); match e.node { ExprCall(ref fn_expr, ref arguments) => { diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs index bdf0ad2af98b..71fcda814a3b 100644 --- a/clippy_lints/src/mutex_atomic.rs +++ b/clippy_lints/src/mutex_atomic.rs @@ -55,7 +55,7 @@ impl LintPass for MutexAtomic { pub struct MutexAtomic; impl LateLintPass for MutexAtomic { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { let ty = cx.tcx.tables().expr_ty(expr); if let ty::TyAdt(_, subst) = ty.sty { if match_type(cx, ty, &paths::MUTEX) { diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs index 64f0af90aa81..bfa51f0ba703 100644 --- a/clippy_lints/src/needless_bool.rs +++ b/clippy_lints/src/needless_bool.rs @@ -57,7 +57,7 @@ impl LintPass for NeedlessBool { } impl LateLintPass for NeedlessBool { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { use self::Expression::*; if let ExprIf(ref pred, ref then_block, Some(ref else_expr)) = e.node { let reduce = |ret, not| { @@ -117,7 +117,7 @@ impl LintPass for BoolComparison { } impl LateLintPass for BoolComparison { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { use self::Expression::*; if let ExprBinary(Spanned { node: BiEq, .. }, ref left_side, ref right_side) = e.node { match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) { diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs index 459b4faec5dd..0f03ff774d2b 100644 --- a/clippy_lints/src/needless_borrow.rs +++ b/clippy_lints/src/needless_borrow.rs @@ -35,7 +35,7 @@ impl LintPass for NeedlessBorrow { } impl LateLintPass for NeedlessBorrow { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if in_macro(cx, e.span) { return; } @@ -53,7 +53,7 @@ impl LateLintPass for NeedlessBorrow { } } } - fn check_pat(&mut self, cx: &LateContext, pat: &Pat) { + fn check_pat<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) { if in_macro(cx, pat.span) { return; } diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs index cdd266ec2e87..82cd502081f7 100644 --- a/clippy_lints/src/needless_update.rs +++ b/clippy_lints/src/needless_update.rs @@ -31,7 +31,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprStruct(_, ref fields, Some(ref base)) = expr.node { let ty = cx.tcx.tables().expr_ty(expr); if let TyAdt(def, _) = ty.sty { diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs index 5ca6172b6bcc..6b0c8001ed22 100644 --- a/clippy_lints/src/neg_multiply.rs +++ b/clippy_lints/src/neg_multiply.rs @@ -32,7 +32,7 @@ impl LintPass for NegMultiply { #[allow(match_same_arms)] impl LateLintPass for NegMultiply { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprBinary(Spanned { node: BiMul, .. }, ref l, ref r) = e.node { match (&l.node, &r.node) { (&ExprUnary(..), &ExprUnary(..)) => (), diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs index 92d78e875dc1..836a5393a9d7 100644 --- a/clippy_lints/src/new_without_default.rs +++ b/clippy_lints/src/new_without_default.rs @@ -90,7 +90,15 @@ impl LintPass for NewWithoutDefault { } impl LateLintPass for NewWithoutDefault { - fn check_fn(&mut self, cx: &LateContext, kind: FnKind, decl: &hir::FnDecl, _: &hir::Expr, span: Span, id: ast::NodeId) { + fn check_fn<'a, 'tcx: 'a>( + &mut self, + cx: &LateContext<'a, 'tcx>, + kind: FnKind<'tcx>, + decl: &'tcx hir::FnDecl, + _: &'tcx hir::Expr, + span: Span, + id: ast::NodeId, + ) { if in_external_macro(cx, span) { return; } diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs index 825aafb4be55..0a5c21114fb5 100644 --- a/clippy_lints/src/no_effect.rs +++ b/clippy_lints/src/no_effect.rs @@ -103,7 +103,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_stmt(&mut self, cx: &LateContext, stmt: &Stmt) { + fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { if let StmtSemi(ref expr, _) = stmt.node { if has_no_effect(cx, expr) { span_lint(cx, NO_EFFECT, stmt.span, "statement with no effect"); diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs index b5b901ccf847..6ccdb6ee1459 100644 --- a/clippy_lints/src/non_expressive_names.rs +++ b/clippy_lints/src/non_expressive_names.rs @@ -59,9 +59,9 @@ struct ExistingName { whitelist: &'static [&'static str], } -struct SimilarNamesLocalVisitor<'a, 'b: 'a> { +struct SimilarNamesLocalVisitor<'a, 'tcx: 'a> { names: Vec, - cx: &'a EarlyContext<'b>, + cx: &'a EarlyContext<'tcx>, lint: &'a NonExpressiveNames, single_char_names: Vec, } @@ -76,10 +76,10 @@ const WHITELIST: &'static [&'static [&'static str]] = &[ &["set", "get"], ]; -struct SimilarNamesNameVisitor<'a, 'b: 'a, 'c: 'b>(&'a mut SimilarNamesLocalVisitor<'b, 'c>); +struct SimilarNamesNameVisitor<'a: 'b, 'tcx: 'a, 'b>(&'b mut SimilarNamesLocalVisitor<'a, 'tcx>); -impl<'a, 'b, 'c> Visitor for SimilarNamesNameVisitor<'a, 'b, 'c> { - fn visit_pat(&mut self, pat: &Pat) { +impl<'a, 'tcx: 'a, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> { + fn visit_pat(&mut self, pat: &'tcx Pat) { match pat.node { PatKind::Ident(_, id, _) => self.check_name(id.span, id.node.name), PatKind::Struct(_, ref fields, _) => { @@ -120,7 +120,7 @@ fn whitelisted(interned_name: &str, list: &[&str]) -> bool { false } -impl<'a, 'b, 'c> SimilarNamesNameVisitor<'a, 'b, 'c> { +impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> { fn check_short_name(&mut self, c: char, span: Span) { // make sure we ignore shadowing if self.0.single_char_names.contains(&c) { @@ -236,18 +236,18 @@ impl<'a, 'b> SimilarNamesLocalVisitor<'a, 'b> { } } -impl<'a, 'b> Visitor for SimilarNamesLocalVisitor<'a, 'b> { - fn visit_local(&mut self, local: &Local) { +impl<'a, 'tcx> Visitor<'tcx> for SimilarNamesLocalVisitor<'a, 'tcx> { + fn visit_local(&mut self, local: &'tcx Local) { if let Some(ref init) = local.init { self.apply(|this| walk_expr(this, &**init)); } // add the pattern after the expression because the bindings aren't available yet in the init expression SimilarNamesNameVisitor(self).visit_pat(&*local.pat); } - fn visit_block(&mut self, blk: &Block) { + fn visit_block(&mut self, blk: &'tcx Block) { self.apply(|this| walk_block(this, blk)); } - fn visit_arm(&mut self, arm: &Arm) { + fn visit_arm(&mut self, arm: &'tcx Arm) { self.apply(|this| { // just go through the first pattern, as either all patterns bind the same bindings or rustc would have errored much earlier SimilarNamesNameVisitor(this).visit_pat(&arm.pats[0]); diff --git a/clippy_lints/src/ok_if_let.rs b/clippy_lints/src/ok_if_let.rs index b7e7c70e41a5..77244acb3081 100644 --- a/clippy_lints/src/ok_if_let.rs +++ b/clippy_lints/src/ok_if_let.rs @@ -41,7 +41,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_let_chain! {[ //begin checking variables let ExprMatch(ref op, ref body, ref source) = expr.node, //test if expr is a match let MatchSource::IfLetDesugar { .. } = *source, //test if it is an If Let diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs index ca30c14e191a..538d09d082ee 100644 --- a/clippy_lints/src/open_options.rs +++ b/clippy_lints/src/open_options.rs @@ -33,7 +33,7 @@ impl LintPass for NonSensical { } impl LateLintPass for NonSensical { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprMethodCall(ref name, _, ref arguments) = e.node { let (obj_ty, _) = walk_ptrs_ty_depth(cx.tcx.tables().expr_ty(&arguments[0])); if &*name.node.as_str() == "open" && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) { diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs index 06a1937e1927..583b9315fee8 100644 --- a/clippy_lints/src/overflow_check_conditional.rs +++ b/clippy_lints/src/overflow_check_conditional.rs @@ -31,7 +31,7 @@ impl LintPass for OverflowCheckConditional { impl LateLintPass for OverflowCheckConditional { // a + b < a, a > a + b, a < a - b, a - b > a - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_let_chain! {[ let Expr_::ExprBinary(ref op, ref first, ref second) = expr.node, let Expr_::ExprBinary(ref op2, ref ident1, ref ident2) = first.node, diff --git a/clippy_lints/src/panic.rs b/clippy_lints/src/panic.rs index 1d89c5ce507d..893a17a63fc7 100644 --- a/clippy_lints/src/panic.rs +++ b/clippy_lints/src/panic.rs @@ -33,7 +33,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_let_chain! {[ let ExprBlock(ref block) = expr.node, let Some(ref ex) = block.expr, diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs index 8f25650bf585..4982055ef3a2 100644 --- a/clippy_lints/src/partialeq_ne_impl.rs +++ b/clippy_lints/src/partialeq_ne_impl.rs @@ -36,7 +36,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_item(&mut self, cx: &LateContext, item: &Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if_let_chain! {[ let ItemImpl(_, _, _, Some(ref trait_ref), _, ref impl_items) = item.node, !is_automatically_derived(&*item.attrs), diff --git a/clippy_lints/src/print.rs b/clippy_lints/src/print.rs index 719d18bffebd..be70f6a7648f 100644 --- a/clippy_lints/src/print.rs +++ b/clippy_lints/src/print.rs @@ -66,7 +66,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_let_chain! {[ let ExprCall(ref fun, ref args) = expr.node, let ExprPath(ref qpath) = fun.node, diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index f210ec4dbc05..a6be3fae45fc 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -55,13 +55,13 @@ impl LintPass for PointerPass { } impl LateLintPass for PointerPass { - fn check_item(&mut self, cx: &LateContext, item: &Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemFn(ref decl, _, _, _, _, _) = item.node { check_fn(cx, decl, item.id); } } - fn check_impl_item(&mut self, cx: &LateContext, item: &ImplItem) { + fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { if let ImplItemKind::Method(ref sig, _) = item.node { if let Some(NodeItem(it)) = cx.tcx.map.find(cx.tcx.map.get_parent(item.id)) { if let ItemImpl(_, _, _, Some(_), _, _) = it.node { @@ -72,13 +72,13 @@ impl LateLintPass for PointerPass { } } - fn check_trait_item(&mut self, cx: &LateContext, item: &TraitItem) { + fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { if let MethodTraitItem(ref sig, _) = item.node { check_fn(cx, &sig.decl, item.id); } } - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprBinary(ref op, ref l, ref r) = expr.node { if (op.node == BiEq || op.node == BiNe) && (is_null_path(l) || is_null_path(r)) { span_lint(cx, diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs index b3d03f5dc18f..6936fc199934 100644 --- a/clippy_lints/src/ranges.rs +++ b/clippy_lints/src/ranges.rs @@ -47,7 +47,7 @@ impl LintPass for StepByZero { } impl LateLintPass for StepByZero { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprMethodCall(Spanned { node: ref name, .. }, _, ref args) = expr.node { let name = &*name.as_str(); diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs index 11eaac0bbb91..d04b03fcf57e 100644 --- a/clippy_lints/src/regex.rs +++ b/clippy_lints/src/regex.rs @@ -83,11 +83,11 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_crate(&mut self, _: &LateContext, _: &Crate) { + fn check_crate<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx Crate) { self.spans.clear(); } - fn check_block(&mut self, cx: &LateContext, block: &Block) { + fn check_block<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block) { if_let_chain!{[ self.last.is_none(), let Some(ref expr) = block.expr, @@ -106,13 +106,13 @@ impl LateLintPass for Pass { }} } - fn check_block_post(&mut self, _: &LateContext, block: &Block) { + fn check_block_post<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, block: &'tcx Block) { if self.last.map_or(false, |id| block.id == id) { self.last = None; } } - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_let_chain!{[ let ExprCall(ref fun, ref args) = expr.node, let ExprPath(ref qpath) = fun.node, diff --git a/clippy_lints/src/serde.rs b/clippy_lints/src/serde.rs index c5a232275552..97a0e0052b58 100644 --- a/clippy_lints/src/serde.rs +++ b/clippy_lints/src/serde.rs @@ -27,7 +27,7 @@ impl LintPass for Serde { } impl LateLintPass for Serde { - fn check_item(&mut self, cx: &LateContext, item: &Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemImpl(_, _, _, Some(ref trait_ref), _, ref items) = item.node { let did = trait_ref.path.def.def_id(); if let Some(visit_did) = get_trait_def_id(cx, &paths::SERDE_DE_VISITOR) { diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs index c994d47d7599..9ec4ceba7e67 100644 --- a/clippy_lints/src/shadow.rs +++ b/clippy_lints/src/shadow.rs @@ -1,9 +1,8 @@ use reexport::*; use rustc::lint::*; use rustc::hir::*; -use rustc::hir::intravisit::{Visitor, FnKind}; +use rustc::hir::intravisit::{Visitor, FnKind, NestedVisitorMap}; use rustc::ty; -use std::ops::Deref; use syntax::codemap::Span; use utils::{higher, in_external_macro, snippet, span_lint_and_then}; @@ -81,7 +80,15 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_fn(&mut self, cx: &LateContext, _: FnKind, decl: &FnDecl, expr: &Expr, _: Span, _: NodeId) { + fn check_fn<'a, 'tcx: 'a>( + &mut self, + cx: &LateContext<'a, 'tcx>, + _: FnKind<'tcx>, + decl: &'tcx FnDecl, + expr: &'tcx Expr, + _: Span, + _: NodeId, + ) { if in_external_macro(cx, expr.span) { return; } @@ -89,7 +96,7 @@ impl LateLintPass for Pass { } } -fn check_fn(cx: &LateContext, decl: &FnDecl, expr: &Expr) { +fn check_fn<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl, expr: &'tcx Expr) { let mut bindings = Vec::new(); for arg in &decl.inputs { if let PatKind::Binding(_, _, ident, _) = arg.pat.node { @@ -99,7 +106,7 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, expr: &Expr) { check_expr(cx, expr, &mut bindings); } -fn check_block(cx: &LateContext, block: &Block, bindings: &mut Vec<(Name, Span)>) { +fn check_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, block: &'tcx Block, bindings: &mut Vec<(Name, Span)>) { let len = bindings.len(); for stmt in &block.stmts { match stmt.node { @@ -114,7 +121,7 @@ fn check_block(cx: &LateContext, block: &Block, bindings: &mut Vec<(Name, Span)> bindings.truncate(len); } -fn check_decl(cx: &LateContext, decl: &Decl, bindings: &mut Vec<(Name, Span)>) { +fn check_decl<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, decl: &'tcx Decl, bindings: &mut Vec<(Name, Span)>) { if in_external_macro(cx, decl.span) { return; } @@ -128,9 +135,9 @@ fn check_decl(cx: &LateContext, decl: &Decl, bindings: &mut Vec<(Name, Span)>) { } if let Some(ref o) = *init { check_expr(cx, o, bindings); - check_pat(cx, pat, &Some(o), span, bindings); + check_pat(cx, pat, Some(o), span, bindings); } else { - check_pat(cx, pat, &None, span, bindings); + check_pat(cx, pat, None, span, bindings); } } } @@ -143,7 +150,13 @@ fn is_binding(cx: &LateContext, pat_id: NodeId) -> bool { } } -fn check_pat(cx: &LateContext, pat: &Pat, init: &Option<&Expr>, span: Span, bindings: &mut Vec<(Name, Span)>) { +fn check_pat<'a, 'tcx: 'a>( + cx: &LateContext<'a, 'tcx>, + pat: &'tcx Pat, + init: Option<&'tcx Expr>, + span: Span, + bindings: &mut Vec<(Name, Span)>, +) { // TODO: match more stuff / destructuring match pat.node { PatKind::Binding(_, _, ref ident, ref inner) => { @@ -167,14 +180,14 @@ fn check_pat(cx: &LateContext, pat: &Pat, init: &Option<&Expr>, span: Span, bind } } PatKind::Struct(_, ref pfields, _) => { - if let Some(init_struct) = *init { + if let Some(init_struct) = init { if let ExprStruct(_, ref efields, _) = init_struct.node { for field in pfields { let name = field.node.name; let efield = efields.iter() .find(|f| f.name.node == name) .map(|f| &*f.expr); - check_pat(cx, &field.node.pat, &efield, span, bindings); + check_pat(cx, &field.node.pat, efield, span, bindings); } } else { for field in pfields { @@ -183,15 +196,15 @@ fn check_pat(cx: &LateContext, pat: &Pat, init: &Option<&Expr>, span: Span, bind } } else { for field in pfields { - check_pat(cx, &field.node.pat, &None, span, bindings); + check_pat(cx, &field.node.pat, None, span, bindings); } } } PatKind::Tuple(ref inner, _) => { - if let Some(init_tup) = *init { + if let Some(init_tup) = init { if let ExprTup(ref tup) = init_tup.node { for (i, p) in inner.iter().enumerate() { - check_pat(cx, p, &Some(&tup[i]), p.span, bindings); + check_pat(cx, p, Some(&tup[i]), p.span, bindings); } } else { for p in inner { @@ -200,14 +213,14 @@ fn check_pat(cx: &LateContext, pat: &Pat, init: &Option<&Expr>, span: Span, bind } } else { for p in inner { - check_pat(cx, p, &None, span, bindings); + check_pat(cx, p, None, span, bindings); } } } PatKind::Box(ref inner) => { - if let Some(initp) = *init { + if let Some(initp) = init { if let ExprBox(ref inner_init) = initp.node { - check_pat(cx, inner, &Some(&**inner_init), span, bindings); + check_pat(cx, inner, Some(&**inner_init), span, bindings); } else { check_pat(cx, inner, init, span, bindings); } @@ -221,10 +234,15 @@ fn check_pat(cx: &LateContext, pat: &Pat, init: &Option<&Expr>, span: Span, bind } } -fn lint_shadow(cx: &LateContext, name: Name, span: Span, pattern_span: Span, init: &Option, prev_span: Span) - where T: Deref -{ - if let Some(ref expr) = *init { +fn lint_shadow<'a, 'tcx: 'a>( + cx: &LateContext<'a, 'tcx>, + name: Name, + span: Span, + pattern_span: Span, + init: Option<&'tcx Expr>, + prev_span: Span, +) { + if let Some(expr) = init { if is_self_shadow(name, expr) { span_lint_and_then(cx, SHADOW_SAME, @@ -234,7 +252,7 @@ fn lint_shadow(cx: &LateContext, name: Name, span: Span, pattern_span: Span, snippet(cx, expr.span, "..")), |db| { db.span_note(prev_span, "previous binding is here"); }, ); - } else if contains_self(name, expr) { + } else if contains_self(cx, name, expr) { span_lint_and_then(cx, SHADOW_REUSE, pattern_span, @@ -267,7 +285,7 @@ fn lint_shadow(cx: &LateContext, name: Name, span: Span, pattern_span: Span, } } -fn check_expr(cx: &LateContext, expr: &Expr, bindings: &mut Vec<(Name, Span)>) { +fn check_expr<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindings: &mut Vec<(Name, Span)>) { if in_external_macro(cx, expr.span) { return; } @@ -302,7 +320,7 @@ fn check_expr(cx: &LateContext, expr: &Expr, bindings: &mut Vec<(Name, Span)>) { let len = bindings.len(); for arm in arms { for pat in &arm.pats { - check_pat(cx, pat, &Some(&**init), pat.span, bindings); + check_pat(cx, pat, Some(&**init), pat.span, bindings); // This is ugly, but needed to get the right type if let Some(ref guard) = arm.guard { check_expr(cx, guard, bindings); @@ -316,7 +334,7 @@ fn check_expr(cx: &LateContext, expr: &Expr, bindings: &mut Vec<(Name, Span)>) { } } -fn check_ty(cx: &LateContext, ty: &Ty, bindings: &mut Vec<(Name, Span)>) { +fn check_ty<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, ty: &'tcx Ty, bindings: &mut Vec<(Name, Span)>) { match ty.node { TyObjectSum(ref sty, _) | TySlice(ref sty) => check_ty(cx, sty, bindings), @@ -353,23 +371,28 @@ fn path_eq_name(name: Name, path: &Path) -> bool { !path.global && path.segments.len() == 1 && path.segments[0].name.as_str() == name.as_str() } -struct ContainsSelf { +struct ContainsSelf<'a, 'tcx: 'a> { name: Name, result: bool, + cx: &'a LateContext<'a, 'tcx>, } -impl<'v> Visitor<'v> for ContainsSelf { +impl<'a, 'tcx: 'a> Visitor<'tcx> for ContainsSelf<'a, 'tcx> { fn visit_name(&mut self, _: Span, name: Name) { if self.name == name { self.result = true; } } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } -fn contains_self(name: Name, expr: &Expr) -> bool { +fn contains_self<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, name: Name, expr: &'tcx Expr) -> bool { let mut cs = ContainsSelf { name: name, result: false, + cx: cx, }; cs.visit_expr(expr); cs.result diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs index e971d6ee13fc..985ef912dc1c 100644 --- a/clippy_lints/src/strings.rs +++ b/clippy_lints/src/strings.rs @@ -80,7 +80,7 @@ impl LintPass for StringAdd { } impl LateLintPass for StringAdd { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprBinary(Spanned { node: BiAdd, .. }, ref left, _) = e.node { if is_string(cx, left) { if let Allow = cx.current_level(STRING_ADD_ASSIGN) { @@ -137,7 +137,7 @@ impl LintPass for StringLitAsBytes { } impl LateLintPass for StringLitAsBytes { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { use std::ascii::AsciiExt; use syntax::ast::LitKind; use utils::{snippet, in_macro}; diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs index bef66dd402e0..f251db2b1870 100644 --- a/clippy_lints/src/swap.rs +++ b/clippy_lints/src/swap.rs @@ -51,7 +51,7 @@ impl LintPass for Swap { } impl LateLintPass for Swap { - fn check_block(&mut self, cx: &LateContext, block: &Block) { + fn check_block<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block) { check_manual_swap(cx, block); check_suspicious_swap(cx, block); } diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs index 5b5802695bb8..c6246fec9b0f 100644 --- a/clippy_lints/src/temporary_assignment.rs +++ b/clippy_lints/src/temporary_assignment.rs @@ -38,7 +38,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprAssign(ref target, _) = expr.node { match target.node { ExprField(ref base, _) | diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index 2263390840c1..2d09c725fb0d 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -85,7 +85,7 @@ impl LintPass for Transmute { } impl LateLintPass for Transmute { - fn check_expr(&mut self, cx: &LateContext, e: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprCall(ref path_expr, ref args) = e.node { if let ExprPath(ref qpath) = path_expr.node { let def_id = cx.tcx.tables().qpath_def(qpath, path_expr.id).def_id(); diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index 294ca88b70f3..66c14e70e6a5 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -1,6 +1,6 @@ use reexport::*; use rustc::hir::*; -use rustc::hir::intravisit::{FnKind, Visitor, walk_ty}; +use rustc::hir::intravisit::{FnKind, Visitor, walk_ty, NestedVisitorMap}; use rustc::lint::*; use rustc::ty; use std::cmp::Ordering; @@ -70,7 +70,7 @@ impl LintPass for TypePass { } impl LateLintPass for TypePass { - fn check_ty(&mut self, cx: &LateContext, ast_ty: &Ty) { + fn check_ty<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, ast_ty: &'tcx Ty) { if in_macro(cx, ast_ty.span) { return; } @@ -154,7 +154,7 @@ impl LintPass for LetPass { } impl LateLintPass for LetPass { - fn check_decl(&mut self, cx: &LateContext, decl: &Decl) { + fn check_decl<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, decl: &'tcx Decl) { check_let_unit(cx, decl) } } @@ -191,7 +191,7 @@ impl LintPass for UnitCmp { } impl LateLintPass for UnitCmp { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if in_macro(cx, expr.span) { return; } @@ -448,7 +448,7 @@ impl LintPass for CastPass { } impl LateLintPass for CastPass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprCast(ref ex, _) = expr.node { let (cast_from, cast_to) = (cx.tcx.tables().expr_ty(ex), cx.tcx.tables().expr_ty(expr)); if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx, expr.span) { @@ -536,16 +536,16 @@ impl LintPass for TypeComplexityPass { } impl LateLintPass for TypeComplexityPass { - fn check_fn(&mut self, cx: &LateContext, _: FnKind, decl: &FnDecl, _: &Expr, _: Span, _: NodeId) { + fn check_fn<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, _: FnKind<'tcx>, decl: &'tcx FnDecl, _: &'tcx Expr, _: Span, _: NodeId) { self.check_fndecl(cx, decl); } - fn check_struct_field(&mut self, cx: &LateContext, field: &StructField) { + fn check_struct_field<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx StructField) { // enum variants are also struct fields now self.check_type(cx, &field.ty); } - fn check_item(&mut self, cx: &LateContext, item: &Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { match item.node { ItemStatic(ref ty, _, _) | ItemConst(ref ty, _) => self.check_type(cx, ty), @@ -554,7 +554,7 @@ impl LateLintPass for TypeComplexityPass { } } - fn check_trait_item(&mut self, cx: &LateContext, item: &TraitItem) { + fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { match item.node { ConstTraitItem(ref ty, _) | TypeTraitItem(_, Some(ref ty)) => self.check_type(cx, ty), @@ -564,7 +564,7 @@ impl LateLintPass for TypeComplexityPass { } } - fn check_impl_item(&mut self, cx: &LateContext, item: &ImplItem) { + fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { match item.node { ImplItemKind::Const(ref ty, _) | ImplItemKind::Type(ref ty) => self.check_type(cx, ty), @@ -573,7 +573,7 @@ impl LateLintPass for TypeComplexityPass { } } - fn check_local(&mut self, cx: &LateContext, local: &Local) { + fn check_local<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, local: &'tcx Local) { if let Some(ref ty) = local.ty { self.check_type(cx, ty); } @@ -581,7 +581,7 @@ impl LateLintPass for TypeComplexityPass { } impl TypeComplexityPass { - fn check_fndecl(&self, cx: &LateContext, decl: &FnDecl) { + fn check_fndecl<'a, 'tcx: 'a>(&self, cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl) { for arg in &decl.inputs { self.check_type(cx, &arg.ty); } @@ -590,7 +590,7 @@ impl TypeComplexityPass { } } - fn check_type(&self, cx: &LateContext, ty: &Ty) { + fn check_type<'a, 'tcx: 'a>(&self, cx: &LateContext<'a, 'tcx>, ty: &'tcx Ty) { if in_macro(cx, ty.span) { return; } @@ -598,6 +598,7 @@ impl TypeComplexityPass { let mut visitor = TypeComplexityVisitor { score: 0, nest: 1, + cx: cx, }; visitor.visit_ty(ty); visitor.score @@ -613,15 +614,16 @@ impl TypeComplexityPass { } /// Walks a type and assigns a complexity score to it. -struct TypeComplexityVisitor { +struct TypeComplexityVisitor<'a, 'tcx: 'a> { /// total complexity score of the type score: u64, /// current nesting level nest: u64, + cx: &'a LateContext<'a, 'tcx>, } -impl<'v> Visitor<'v> for TypeComplexityVisitor { - fn visit_ty(&mut self, ty: &'v Ty) { +impl<'a, 'tcx: 'a> Visitor<'tcx> for TypeComplexityVisitor<'a, 'tcx> { + fn visit_ty(&mut self, ty: &'tcx Ty) { let (add_score, sub_nest) = match ty.node { // _, &x and *x have only small overhead; don't mess with nesting level TyInfer | TyPtr(..) | TyRptr(..) => (1, 0), @@ -646,6 +648,9 @@ impl<'v> Visitor<'v> for TypeComplexityVisitor { walk_ty(self, ty); self.nest -= sub_nest; } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } /// **What it does:** Checks for expressions where a character literal is cast @@ -678,7 +683,7 @@ impl LintPass for CharLitAsU8 { } impl LateLintPass for CharLitAsU8 { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { use syntax::ast::{LitKind, UintTy}; if let ExprCast(ref e, _) = expr.node { @@ -842,7 +847,7 @@ fn detect_extreme_expr<'a>(cx: &LateContext, expr: &'a Expr) -> Option(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { use types::ExtremeType::*; use types::AbsurdComparisonResult::*; @@ -1067,7 +1072,7 @@ fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons: } impl LateLintPass for InvalidUpcastComparisons { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprBinary(ref cmp, ref lhs, ref rhs) = expr.node { let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs); diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs index afe519893a9f..ba82bc470dca 100644 --- a/clippy_lints/src/unicode.rs +++ b/clippy_lints/src/unicode.rs @@ -69,7 +69,7 @@ impl LintPass for Unicode { } impl LateLintPass for Unicode { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprLit(ref lit) = expr.node { if let LitKind::Str(_, _) = lit.node { check_str(cx, lit.span) diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs index 73c87f36bba8..8119c4d727ab 100644 --- a/clippy_lints/src/unused_label.rs +++ b/clippy_lints/src/unused_label.rs @@ -1,6 +1,6 @@ use rustc::lint::*; use rustc::hir; -use rustc::hir::intravisit::{FnKind, Visitor, walk_expr, walk_fn}; +use rustc::hir::intravisit::{FnKind, Visitor, walk_expr, walk_fn, NestedVisitorMap}; use std::collections::HashMap; use syntax::ast; use syntax::codemap::Span; @@ -29,15 +29,9 @@ declare_lint! { pub struct UnusedLabel; -#[derive(Default)] -struct UnusedLabelVisitor { +struct UnusedLabelVisitor<'a, 'tcx: 'a> { labels: HashMap, -} - -impl UnusedLabelVisitor { - pub fn new() -> UnusedLabelVisitor { - ::std::default::Default::default() - } + cx: &'a LateContext<'a, 'tcx>, } impl LintPass for UnusedLabel { @@ -47,13 +41,24 @@ impl LintPass for UnusedLabel { } impl LateLintPass for UnusedLabel { - fn check_fn(&mut self, cx: &LateContext, kind: FnKind, decl: &hir::FnDecl, body: &hir::Expr, span: Span, fn_id: ast::NodeId) { + fn check_fn<'a, 'tcx: 'a>( + &mut self, + cx: &LateContext<'a, 'tcx>, + kind: FnKind<'tcx>, + decl: &'tcx hir::FnDecl, + body: &'tcx hir::Expr, + span: Span, + fn_id: ast::NodeId, + ) { if in_macro(cx, span) { return; } - let mut v = UnusedLabelVisitor::new(); - walk_fn(&mut v, kind, decl, body, span, fn_id); + let mut v = UnusedLabelVisitor { + cx: cx, + labels: HashMap::new(), + }; + walk_fn(&mut v, kind, decl, body.expr_id(), span, fn_id); for (label, span) in v.labels { span_lint(cx, UNUSED_LABEL, span, &format!("unused label `{}`", label)); @@ -61,8 +66,8 @@ impl LateLintPass for UnusedLabel { } } -impl<'v> Visitor<'v> for UnusedLabelVisitor { - fn visit_expr(&mut self, expr: &hir::Expr) { +impl<'a, 'tcx: 'a> Visitor<'tcx> for UnusedLabelVisitor<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx hir::Expr) { match expr.node { hir::ExprBreak(Some(label), _) | hir::ExprAgain(Some(label)) => { @@ -77,4 +82,7 @@ impl<'v> Visitor<'v> for UnusedLabelVisitor { walk_expr(self, expr); } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } diff --git a/clippy_lints/src/utils/hir.rs b/clippy_lints/src/utils/hir.rs index 8ac25c233f97..e01feb3fcae2 100644 --- a/clippy_lints/src/utils/hir.rs +++ b/clippy_lints/src/utils/hir.rs @@ -376,11 +376,11 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { self.hash_expr(e); // TODO: _ty } - ExprClosure(cap, _, ref e, _) => { + ExprClosure(cap, _, eid, _) => { let c: fn(_, _, _, _) -> _ = ExprClosure; c.hash(&mut self.s); cap.hash(&mut self.s); - self.hash_expr(e); + self.hash_expr(self.cx.tcx.map.expr(eid)); } ExprField(ref e, ref f) => { let c: fn(_, _) -> _ = ExprField; diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs index b297aec7c072..ef98247b7e83 100644 --- a/clippy_lints/src/utils/inspector.rs +++ b/clippy_lints/src/utils/inspector.rs @@ -37,14 +37,14 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_item(&mut self, cx: &LateContext, item: &hir::Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) { if !has_attr(&item.attrs) { return; } print_item(cx, item); } - fn check_impl_item(&mut self, cx: &LateContext, item: &hir::ImplItem) { + fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ImplItem) { if !has_attr(&item.attrs) { return; } @@ -68,33 +68,33 @@ impl LateLintPass for Pass { } } /* - fn check_trait_item(&mut self, cx: &LateContext, item: &hir::TraitItem) { + fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) { if !has_attr(&item.attrs) { return; } } - fn check_variant(&mut self, cx: &LateContext, var: &hir::Variant, _: &hir::Generics) { + fn check_variant<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, _: &hir::Generics) { if !has_attr(&var.node.attrs) { return; } } - fn check_struct_field(&mut self, cx: &LateContext, field: &hir::StructField) { + fn check_struct_field<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx hir::StructField) { if !has_attr(&field.attrs) { return; } } */ - fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { if !has_attr(&expr.attrs) { return; } print_expr(cx, expr, 0); } - fn check_arm(&mut self, cx: &LateContext, arm: &hir::Arm) { + fn check_arm<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, arm: &'tcx hir::Arm) { if !has_attr(&arm.attrs) { return; } @@ -109,7 +109,7 @@ impl LateLintPass for Pass { print_expr(cx, &arm.body, 1); } - fn check_stmt(&mut self, cx: &LateContext, stmt: &hir::Stmt) { + fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx hir::Stmt) { if !has_attr(stmt.node.attrs()) { return; } @@ -120,7 +120,7 @@ impl LateLintPass for Pass { } /* - fn check_foreign_item(&mut self, cx: &LateContext, item: &hir::ForeignItem) { + fn check_foreign_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ForeignItem) { if !has_attr(&item.attrs) { return; } diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs index a510adefb717..c2e55862b3db 100644 --- a/clippy_lints/src/utils/internal_lints.rs +++ b/clippy_lints/src/utils/internal_lints.rs @@ -1,6 +1,6 @@ use rustc::lint::*; use rustc::hir::*; -use rustc::hir::intravisit::{Visitor, walk_expr}; +use rustc::hir::intravisit::{Visitor, walk_expr, NestedVisitorMap}; use utils::{paths, match_path, span_lint}; use syntax::symbol::InternedString; use syntax::ast::{Name, NodeId, ItemKind, Crate as AstCrate}; @@ -105,18 +105,18 @@ impl LintPass for LintWithoutLintPass { impl LateLintPass for LintWithoutLintPass { - fn check_item(&mut self, _: &LateContext, item: &Item) { + fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemStatic(ref ty, MutImmutable, ref expr) = item.node { if is_lint_ref_type(ty) { self.declared_lints.insert(item.name, item.span); } else if is_lint_array_type(ty) && item.vis == Visibility::Inherited && item.name == "ARRAY" { - let mut collector = LintCollector { output: &mut self.registered_lints }; + let mut collector = LintCollector { output: &mut self.registered_lints, cx: cx }; collector.visit_expr(expr); } } } - fn check_crate_post(&mut self, cx: &LateContext, _: &Crate) { + fn check_crate_post<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, _: &'tcx Crate) { for (lint_name, &lint_span) in &self.declared_lints { // When using the `declare_lint!` macro, the original `lint_span`'s // file points to "". @@ -156,18 +156,22 @@ fn is_lint_array_type(ty: &Ty) -> bool { } } -struct LintCollector<'a> { +struct LintCollector<'a, 'tcx: 'a> { output: &'a mut HashSet, + cx: &'a LateContext<'a, 'tcx>, } -impl<'v, 'a: 'v> Visitor<'v> for LintCollector<'a> { - fn visit_expr(&mut self, expr: &'v Expr) { +impl<'a, 'tcx: 'a> Visitor<'tcx> for LintCollector<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx Expr) { walk_expr(self, expr); } - fn visit_path(&mut self, path: &'v Path, _: NodeId) { + fn visit_path(&mut self, path: &'tcx Path, _: NodeId) { if path.segments.len() == 1 { self.output.insert(path.segments[0].name); } } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.map) + } } diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index 05bd059d58ab..dc64e56b2e68 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -94,7 +94,7 @@ pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool { rhs.expn_id != lhs.expn_id } /// Returns true if this `expn_info` was expanded by any macro. -pub fn in_macro(cx: &T, span: Span) -> bool { +pub fn in_macro<'a, T: LintContext<'a>>(cx: &T, span: Span) -> bool { cx.sess().codemap().with_expn_info(span.expn_id, |info| match info { Some(info) => { match info.callee.format { @@ -109,10 +109,10 @@ pub fn in_macro(cx: &T, span: Span) -> bool { /// Returns true if the macro that expanded the crate was outside of the current crate or was a /// compiler plugin. -pub fn in_external_macro(cx: &T, span: Span) -> bool { +pub fn in_external_macro<'a, T: LintContext<'a>>(cx: &T, span: Span) -> bool { /// Invokes `in_macro` with the expansion info of the given span slightly heavy, try to use /// this after other checks have already happened. - fn in_macro_ext(cx: &T, opt_info: Option<&ExpnInfo>) -> bool { + fn in_macro_ext<'a, T: LintContext<'a>>(cx: &T, opt_info: Option<&ExpnInfo>) -> bool { // no ExpnInfo = no macro opt_info.map_or(false, |info| { if let ExpnFormat::MacroAttribute(..) = info.callee.format { @@ -371,12 +371,12 @@ pub fn get_item_name(cx: &LateContext, expr: &Expr) -> Option { /// ``` /// snippet(cx, expr.span, "..") /// ``` -pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> { +pub fn snippet<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> { cx.sess().codemap().span_to_snippet(span).map(From::from).unwrap_or_else(|_| Cow::Borrowed(default)) } /// Convert a span to a code snippet. Returns `None` if not available. -pub fn snippet_opt(cx: &T, span: Span) -> Option { +pub fn snippet_opt<'a, T: LintContext<'a>>(cx: &T, span: Span) -> Option { cx.sess().codemap().span_to_snippet(span).ok() } @@ -388,14 +388,14 @@ pub fn snippet_opt(cx: &T, span: Span) -> Option { /// ``` /// snippet(cx, expr.span, "..") /// ``` -pub fn snippet_block<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> { +pub fn snippet_block<'a, 'b, T: LintContext<'b>>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> { let snip = snippet(cx, span, default); trim_multiline(snip, true) } /// Like `snippet_block`, but add braces if the expr is not an `ExprBlock`. /// Also takes an `Option` which can be put inside the braces. -pub fn expr_block<'a, T: LintContext>(cx: &T, expr: &Expr, option: Option, default: &'a str) -> Cow<'a, str> { +pub fn expr_block<'a, 'b, T: LintContext<'b>>(cx: &T, expr: &Expr, option: Option, default: &'a str) -> Cow<'a, str> { let code = snippet_block(cx, expr.span, default); let string = option.unwrap_or_default(); if let ExprBlock(_) = expr.node { @@ -464,15 +464,15 @@ pub fn get_parent_expr<'c>(cx: &'c LateContext, e: &Expr) -> Option<&'c Expr> { }) } -pub fn get_enclosing_block<'c>(cx: &'c LateContext, node: NodeId) -> Option<&'c Block> { +pub fn get_enclosing_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, node: NodeId) -> Option<&'tcx Block> { let map = &cx.tcx.map; let enclosing_node = map.get_enclosing_scope(node) .and_then(|enclosing_id| map.find(enclosing_id)); if let Some(node) = enclosing_node { match node { Node::NodeBlock(block) => Some(block), - Node::NodeItem(&Item { node: ItemFn(_, _, _, _, _, ref expr), .. }) => { - match expr.node { + Node::NodeItem(&Item { node: ItemFn(_, _, _, _, _, eid), .. }) => { + match cx.tcx.map.expr(eid).node { ExprBlock(ref block) => Some(block), _ => None, } @@ -501,15 +501,14 @@ impl<'a> DiagnosticWrapper<'a> { } } -pub fn span_lint(cx: &T, lint: &'static Lint, sp: Span, msg: &str) { +pub fn span_lint<'a, T: LintContext<'a>>(cx: &T, lint: &'static Lint, sp: Span, msg: &str) { let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, sp, msg)); if cx.current_level(lint) != Level::Allow { db.wiki_link(lint); } } -// FIXME: needless lifetime doesn't trigger here -pub fn span_help_and_lint<'a, T: LintContext>(cx: &'a T, lint: &'static Lint, span: Span, msg: &str, help: &str) { +pub fn span_help_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>(cx: &'a T, lint: &'static Lint, span: Span, msg: &str, help: &str) { let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, span, msg)); if cx.current_level(lint) != Level::Allow { db.0.help(help); @@ -517,8 +516,14 @@ pub fn span_help_and_lint<'a, T: LintContext>(cx: &'a T, lint: &'static Lint, sp } } -pub fn span_note_and_lint<'a, T: LintContext>(cx: &'a T, lint: &'static Lint, span: Span, msg: &str, note_span: Span, - note: &str) { +pub fn span_note_and_lint<'a, 'tcx: 'a, T: LintContext<'tcx>>( + cx: &'a T, + lint: &'static Lint, + span: Span, + msg: &str, + note_span: Span, + note: &str, +) { let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, span, msg)); if cx.current_level(lint) != Level::Allow { if note_span == span { @@ -530,8 +535,8 @@ pub fn span_note_and_lint<'a, T: LintContext>(cx: &'a T, lint: &'static Lint, sp } } -pub fn span_lint_and_then<'a, T: LintContext, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F) - where F: FnOnce(&mut DiagnosticBuilder<'a>) +pub fn span_lint_and_then<'a, 'tcx: 'a, T: LintContext<'tcx>, F>(cx: &'a T, lint: &'static Lint, sp: Span, msg: &str, f: F) + where F: for<'b> FnOnce(&mut DiagnosticBuilder<'b>) { let mut db = DiagnosticWrapper(cx.struct_span_lint(lint, sp, msg)); if cx.current_level(lint) != Level::Allow { diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs index 1dc2629d2077..347834a062a7 100644 --- a/clippy_lints/src/utils/sugg.rs +++ b/clippy_lints/src/utils/sugg.rs @@ -384,7 +384,7 @@ fn astbinop2assignop(op: ast::BinOp) -> AssocOp { } /// Return the indentation before `span` if there are nothing but `[ \t]` before it on its line. -fn indentation(cx: &T, span: Span) -> Option { +fn indentation<'a, T: LintContext<'a>>(cx: &T, span: Span) -> Option { let lo = cx.sess().codemap().lookup_char_pos(span.lo); if let Some(line) = lo.file.get_line(lo.line - 1 /* line numbers in `Loc` are 1-based */) { if let Some((pos, _)) = line.char_indices().find(|&(_, c)| c != ' ' && c != '\t') { @@ -403,7 +403,7 @@ fn indentation(cx: &T, span: Span) -> Option { } /// Convenience extension trait for `DiagnosticBuilder`. -pub trait DiagnosticBuilderExt { +pub trait DiagnosticBuilderExt<'a, T: LintContext<'a>> { /// Suggests to add an attribute to an item. /// /// Correctly handles indentation of the attribute and item. @@ -430,7 +430,7 @@ pub trait DiagnosticBuilderExt { fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str); } -impl<'a, 'b, T: LintContext> DiagnosticBuilderExt for rustc_errors::DiagnosticBuilder<'b> { +impl<'a, 'b, 'c, T: LintContext<'c>> DiagnosticBuilderExt<'c, T> for rustc_errors::DiagnosticBuilder<'b> { fn suggest_item_with_attr(&mut self, cx: &T, item: Span, msg: &str, attr: &D) { if let Some(indent) = indentation(cx, item) { let span = Span { diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs index f847c397da86..bed98559e6f0 100644 --- a/clippy_lints/src/vec.rs +++ b/clippy_lints/src/vec.rs @@ -33,7 +33,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { // search for `&vec![_]` expressions where the adjusted type is `&[_]` if_let_chain!{[ let ty::TypeVariants::TyRef(_, ref ty) = cx.tcx.tables().expr_ty_adjusted(expr).sty, diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs index 64ec3e5eec70..b0cc96f3d64b 100644 --- a/clippy_lints/src/zero_div_zero.rs +++ b/clippy_lints/src/zero_div_zero.rs @@ -28,7 +28,7 @@ impl LintPass for Pass { } impl LateLintPass for Pass { - fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { + fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { // check for instances of 0.0/0.0 if_let_chain! {[ let ExprBinary(ref op, ref left, ref right) = expr.node, From 4a05fbba3e1c4557b5cafbfdf62f6da86347f748 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Tue, 6 Dec 2016 11:33:50 +0100 Subject: [PATCH 12/15] remove wrong rustc version so we don't accidentally forget to update --- CHANGELOG.md | 1 - 1 file changed, 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9f798c31af18..042ed6929d1f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,7 +2,6 @@ All notable changes to this project will be documented in this file. ## 0.0.104 — 2016-12-01 -* Update to *rustc 1.15.0-nightly (1c448574b 2016-11-28)* ## 0.0.103 — 2016-11-25 * Update to *rustc 1.15.0-nightly (d5814b03e 2016-11-23)* From 778ce4dfd359eb8071ad76aa6447b23ce7a0c752 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 7 Dec 2016 13:13:40 +0100 Subject: [PATCH 13/15] update to the rust-PR that unblocks clippy --- clippy_lints/src/approx_const.rs | 4 +- clippy_lints/src/arithmetic.rs | 6 +-- clippy_lints/src/array_indexing.rs | 4 +- clippy_lints/src/assign_ops.rs | 4 +- clippy_lints/src/attrs.rs | 10 ++-- clippy_lints/src/bit_mask.rs | 4 +- clippy_lints/src/blacklisted_name.rs | 4 +- clippy_lints/src/block_in_if_condition.rs | 4 +- clippy_lints/src/booleans.rs | 4 +- clippy_lints/src/copies.rs | 4 +- clippy_lints/src/cyclomatic_complexity.rs | 12 ++--- clippy_lints/src/derive.rs | 6 +-- clippy_lints/src/drop_ref.rs | 4 +- clippy_lints/src/entry.rs | 4 +- clippy_lints/src/enum_clike.rs | 4 +- clippy_lints/src/enum_glob_use.rs | 4 +- clippy_lints/src/eq_op.rs | 4 +- clippy_lints/src/escape.rs | 4 +- clippy_lints/src/eta_reduction.rs | 4 +- clippy_lints/src/eval_order_dependence.rs | 10 ++-- clippy_lints/src/format.rs | 4 +- clippy_lints/src/functions.rs | 10 ++-- clippy_lints/src/identity_op.rs | 4 +- .../src/if_let_redundant_pattern_matching.rs | 4 +- clippy_lints/src/len_zero.rs | 6 +-- clippy_lints/src/let_if_seq.rs | 6 +-- clippy_lints/src/lifetimes.rs | 10 ++-- clippy_lints/src/loops.rs | 14 +++--- clippy_lints/src/map_clone.rs | 4 +- clippy_lints/src/matches.rs | 4 +- clippy_lints/src/mem_forget.rs | 4 +- clippy_lints/src/methods.rs | 6 +-- clippy_lints/src/minmax.rs | 4 +- clippy_lints/src/misc.rs | 10 ++-- clippy_lints/src/missing_doc.rs | 18 +++---- clippy_lints/src/mut_mut.rs | 6 +-- clippy_lints/src/mut_reference.rs | 4 +- clippy_lints/src/mutex_atomic.rs | 4 +- clippy_lints/src/needless_bool.rs | 8 ++-- clippy_lints/src/needless_borrow.rs | 6 +-- clippy_lints/src/needless_update.rs | 4 +- clippy_lints/src/neg_multiply.rs | 4 +- clippy_lints/src/new_without_default.rs | 4 +- clippy_lints/src/no_effect.rs | 4 +- clippy_lints/src/ok_if_let.rs | 4 +- clippy_lints/src/open_options.rs | 4 +- .../src/overflow_check_conditional.rs | 4 +- clippy_lints/src/panic.rs | 4 +- clippy_lints/src/partialeq_ne_impl.rs | 4 +- clippy_lints/src/print.rs | 4 +- clippy_lints/src/ptr.rs | 10 ++-- clippy_lints/src/ranges.rs | 4 +- clippy_lints/src/regex.rs | 10 ++-- clippy_lints/src/serde.rs | 4 +- clippy_lints/src/shadow.rs | 16 +++---- clippy_lints/src/strings.rs | 8 ++-- clippy_lints/src/swap.rs | 4 +- clippy_lints/src/temporary_assignment.rs | 4 +- clippy_lints/src/transmute.rs | 4 +- clippy_lints/src/types.rs | 48 +++++++++---------- clippy_lints/src/unicode.rs | 4 +- clippy_lints/src/unused_label.rs | 4 +- clippy_lints/src/utils/inspector.rs | 20 ++++---- clippy_lints/src/utils/internal_lints.rs | 6 +-- clippy_lints/src/vec.rs | 4 +- clippy_lints/src/zero_div_zero.rs | 4 +- 66 files changed, 217 insertions(+), 217 deletions(-) diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs index 9a6678f176a1..3ccb5f6ef2a0 100644 --- a/clippy_lints/src/approx_const.rs +++ b/clippy_lints/src/approx_const.rs @@ -59,8 +59,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprLit(ref lit) = e.node { check_lit(cx, lit, e); } diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs index 0ae64e0e7872..5020295e20c9 100644 --- a/clippy_lints/src/arithmetic.rs +++ b/clippy_lints/src/arithmetic.rs @@ -47,8 +47,8 @@ impl LintPass for Arithmetic { } } -impl LateLintPass for Arithmetic { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { if self.span.is_some() { return; } @@ -82,7 +82,7 @@ impl LateLintPass for Arithmetic { } } - fn check_expr_post<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { + fn check_expr_post(&mut self, _: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { if Some(expr.span) == self.span { self.span = None; } diff --git a/clippy_lints/src/array_indexing.rs b/clippy_lints/src/array_indexing.rs index 1f68c32cd24f..399f93d08c7c 100644 --- a/clippy_lints/src/array_indexing.rs +++ b/clippy_lints/src/array_indexing.rs @@ -55,8 +55,8 @@ impl LintPass for ArrayIndexing { } } -impl LateLintPass for ArrayIndexing { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ArrayIndexing { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx hir::Expr) { if let hir::ExprIndex(ref array, ref index) = e.node { // Array with known size can be checked statically let ty = cx.tcx.tables().expr_ty(array); diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs index 84b61b1cba42..ef6898cef885 100644 --- a/clippy_lints/src/assign_ops.rs +++ b/clippy_lints/src/assign_ops.rs @@ -66,8 +66,8 @@ impl LintPass for AssignOps { } } -impl LateLintPass for AssignOps { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { match expr.node { hir::ExprAssignOp(op, ref lhs, ref rhs) => { span_lint_and_then(cx, ASSIGN_OPS, expr.span, "assign operation detected", |db| { diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index 5ddbeb570468..a37b08363957 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -81,8 +81,8 @@ impl LintPass for AttrPass { } } -impl LateLintPass for AttrPass { - fn check_attribute<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, attr: &'tcx Attribute) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass { + fn check_attribute(&mut self, cx: &LateContext<'a, 'tcx>, attr: &'tcx Attribute) { if let MetaItemKind::List(ref items) = attr.value.node { if items.is_empty() || attr.name() != "deprecated" { return; @@ -99,7 +99,7 @@ impl LateLintPass for AttrPass { } } - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if is_relevant_item(cx, item) { check_attrs(cx, item.span, &item.name, &item.attrs) } @@ -138,13 +138,13 @@ impl LateLintPass for AttrPass { } } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { if is_relevant_impl(cx, item) { check_attrs(cx, item.span, &item.name, &item.attrs) } } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { if is_relevant_trait(cx, item) { check_attrs(cx, item.span, &item.name, &item.attrs) } diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs index fb305f8907d5..0e569bc76f7b 100644 --- a/clippy_lints/src/bit_mask.rs +++ b/clippy_lints/src/bit_mask.rs @@ -79,8 +79,8 @@ impl LintPass for BitMask { } } -impl LateLintPass for BitMask { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BitMask { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprBinary(ref cmp, ref left, ref right) = e.node { if cmp.node.is_comparison() { if let Some(cmp_opt) = fetch_int_literal(cx, right) { diff --git a/clippy_lints/src/blacklisted_name.rs b/clippy_lints/src/blacklisted_name.rs index 542bf0a4f285..2f9a50fe3dac 100644 --- a/clippy_lints/src/blacklisted_name.rs +++ b/clippy_lints/src/blacklisted_name.rs @@ -37,8 +37,8 @@ impl LintPass for BlackListedName { } } -impl LateLintPass for BlackListedName { - fn check_pat<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlackListedName { + fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) { if let PatKind::Binding(_, _, ref ident, _) = pat.node { if self.blacklist.iter().any(|s| s == &*ident.node.as_str()) { span_lint(cx, diff --git a/clippy_lints/src/block_in_if_condition.rs b/clippy_lints/src/block_in_if_condition.rs index 1ac96bf6bcaf..de004afa1a6c 100644 --- a/clippy_lints/src/block_in_if_condition.rs +++ b/clippy_lints/src/block_in_if_condition.rs @@ -74,8 +74,8 @@ const BRACED_EXPR_MESSAGE: &'static str = "omit braces around single expression const COMPLEX_BLOCK_MESSAGE: &'static str = "in an 'if' condition, avoid complex blocks or closures with blocks; \ instead, move the block or closure higher and bind it with a 'let'"; -impl LateLintPass for BlockInIfCondition { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprIf(ref check, ref then, _) = expr.node { if let ExprBlock(ref block) = check.node { if block.rules == DefaultBlock { diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs index 64c575046a21..bd5657483112 100644 --- a/clippy_lints/src/booleans.rs +++ b/clippy_lints/src/booleans.rs @@ -53,8 +53,8 @@ impl LintPass for NonminimalBool { } } -impl LateLintPass for NonminimalBool { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonminimalBool { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { NonminimalBoolVisitor { cx: cx }.visit_item(item) } } diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs index 1931b5d1e3f6..9fa38ad02b3e 100644 --- a/clippy_lints/src/copies.rs +++ b/clippy_lints/src/copies.rs @@ -109,8 +109,8 @@ impl LintPass for CopyAndPaste { } } -impl LateLintPass for CopyAndPaste { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyAndPaste { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if !in_macro(cx, expr.span) { // skip ifs directly in else, it will be checked in the parent if if let Some(&Expr { node: ExprIf(_, _, Some(ref else_expr)), .. }) = get_parent_expr(cx, expr) { diff --git a/clippy_lints/src/cyclomatic_complexity.rs b/clippy_lints/src/cyclomatic_complexity.rs index 67066d32cc3e..164633b7c644 100644 --- a/clippy_lints/src/cyclomatic_complexity.rs +++ b/clippy_lints/src/cyclomatic_complexity.rs @@ -90,8 +90,8 @@ impl CyclomaticComplexity { } } -impl LateLintPass for CyclomaticComplexity { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CyclomaticComplexity { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemFn(_, _, _, _, _, eid) = item.node { if !attr::contains_name(&item.attrs, "test") { self.check(cx, cx.tcx.map.expr(eid), item.span); @@ -99,22 +99,22 @@ impl LateLintPass for CyclomaticComplexity { } } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { if let ImplItemKind::Method(_, eid) = item.node { self.check(cx, cx.tcx.map.expr(eid), item.span); } } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { if let MethodTraitItem(_, Some(eid)) = item.node { self.check(cx, cx.tcx.map.expr(eid), item.span); } } - fn enter_lint_attrs<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, attrs: &'tcx [Attribute]) { + fn enter_lint_attrs(&mut self, cx: &LateContext<'a, 'tcx>, attrs: &'tcx [Attribute]) { self.limit.push_attrs(cx.sess(), attrs, "cyclomatic_complexity"); } - fn exit_lint_attrs<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, attrs: &'tcx [Attribute]) { + fn exit_lint_attrs(&mut self, cx: &LateContext<'a, 'tcx>, attrs: &'tcx [Attribute]) { self.limit.pop_attrs(cx.sess(), attrs, "cyclomatic_complexity"); } } diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs index 4e9f7d9c6645..449227c97679 100644 --- a/clippy_lints/src/derive.rs +++ b/clippy_lints/src/derive.rs @@ -70,8 +70,8 @@ impl LintPass for Derive { } } -impl LateLintPass for Derive { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Derive { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemImpl(_, _, _, Some(ref trait_ref), _, _) = item.node { let ty = cx.tcx.item_type(cx.tcx.map.local_def_id(item.id)); let is_automatically_derived = is_automatically_derived(&*item.attrs); @@ -86,7 +86,7 @@ impl LateLintPass for Derive { } /// Implementation of the `DERIVE_HASH_XOR_EQ` lint. -fn check_hash_peq<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, span: Span, trait_ref: &TraitRef, ty: ty::Ty<'tcx>, +fn check_hash_peq<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, span: Span, trait_ref: &TraitRef, ty: ty::Ty<'tcx>, hash_is_automatically_derived: bool) { if_let_chain! {[ match_path_old(&trait_ref.path, &paths::HASH), diff --git a/clippy_lints/src/drop_ref.rs b/clippy_lints/src/drop_ref.rs index c16d879ec2f5..106e43e1b6f5 100644 --- a/clippy_lints/src/drop_ref.rs +++ b/clippy_lints/src/drop_ref.rs @@ -35,8 +35,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprCall(ref path, ref args) = expr.node { if let ExprPath(ref qpath) = path.node { let def_id = cx.tcx.tables().qpath_def(qpath, path.id).def_id(); diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs index 133d2dc68f92..00a41c2e986c 100644 --- a/clippy_lints/src/entry.rs +++ b/clippy_lints/src/entry.rs @@ -39,8 +39,8 @@ impl LintPass for HashMapLint { } } -impl LateLintPass for HashMapLint { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for HashMapLint { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprIf(ref check, ref then_block, ref else_block) = expr.node { if let ExprUnary(UnOp::UnNot, ref check) = check.node { if let Some((ty, map, key)) = check_cond(cx, check) { diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs index 28fd9833e25c..f4181da3c2b7 100644 --- a/clippy_lints/src/enum_clike.rs +++ b/clippy_lints/src/enum_clike.rs @@ -36,9 +36,9 @@ impl LintPass for UnportableVariant { } } -impl LateLintPass for UnportableVariant { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnportableVariant { #[allow(cast_possible_truncation, cast_sign_loss)] - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemEnum(ref def, _) = item.node { for var in &def.variants { let variant = &var.node; diff --git a/clippy_lints/src/enum_glob_use.rs b/clippy_lints/src/enum_glob_use.rs index 1db8607bd257..4dafcf365a6c 100644 --- a/clippy_lints/src/enum_glob_use.rs +++ b/clippy_lints/src/enum_glob_use.rs @@ -32,8 +32,8 @@ impl LintPass for EnumGlobUse { } } -impl LateLintPass for EnumGlobUse { - fn check_mod<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, m: &'tcx Mod, _: Span, _: NodeId) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EnumGlobUse { + fn check_mod(&mut self, cx: &LateContext<'a, 'tcx>, m: &'tcx Mod, _: Span, _: NodeId) { // only check top level `use` statements for item in &m.item_ids { self.lint_item(cx, cx.krate.item(item.id)); diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs index 8cfeabba9fcb..c43dfe6e27ca 100644 --- a/clippy_lints/src/eq_op.rs +++ b/clippy_lints/src/eq_op.rs @@ -32,8 +32,8 @@ impl LintPass for EqOp { } } -impl LateLintPass for EqOp { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprBinary(ref op, ref left, ref right) = e.node { if is_valid_operator(op) && SpanlessEq::new(cx).ignore_fn().eq_expr(left, right) { span_lint(cx, diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs index df01e0481a80..0ca1f143b164 100644 --- a/clippy_lints/src/escape.rs +++ b/clippy_lints/src/escape.rs @@ -60,8 +60,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_fn<'a, 'tcx: 'a>( +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_fn( &mut self, cx: &LateContext<'a, 'tcx>, _: visit::FnKind<'tcx>, diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs index c8d468f7fa90..56308ed390d8 100644 --- a/clippy_lints/src/eta_reduction.rs +++ b/clippy_lints/src/eta_reduction.rs @@ -33,8 +33,8 @@ impl LintPass for EtaPass { } } -impl LateLintPass for EtaPass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EtaPass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { match expr.node { ExprCall(_, ref args) | ExprMethodCall(_, _, ref args) => { diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs index 3a991b0f28b2..9e9a900fe7ab 100644 --- a/clippy_lints/src/eval_order_dependence.rs +++ b/clippy_lints/src/eval_order_dependence.rs @@ -56,8 +56,8 @@ impl LintPass for EvalOrderDependence { } } -impl LateLintPass for EvalOrderDependence { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { // Find a write to a local variable. match expr.node { ExprAssign(ref lhs, _) | ExprAssignOp(_, ref lhs, _) => { @@ -79,7 +79,7 @@ impl LateLintPass for EvalOrderDependence { _ => {} } } - fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { + fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { match stmt.node { StmtExpr(ref e, _) | StmtSemi(ref e, _) => DivergenceVisitor { cx: cx }.maybe_walk_expr(e), StmtDecl(ref d, _) => { @@ -214,7 +214,7 @@ enum StopEarly { Stop, } -fn check_expr<'a, 'tcx: 'a>(vis: & mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> StopEarly { +fn check_expr<'a, 'tcx>(vis: & mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> StopEarly { if expr.id == vis.last_expr.id { return StopEarly::KeepGoing; } @@ -263,7 +263,7 @@ fn check_expr<'a, 'tcx: 'a>(vis: & mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) StopEarly::KeepGoing } -fn check_stmt<'a, 'tcx: 'a>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt) -> StopEarly { +fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt) -> StopEarly { match stmt.node { StmtExpr(ref expr, _) | StmtSemi(ref expr, _) => check_expr(vis, expr), diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs index 236888fe191e..0cf4762364ba 100644 --- a/clippy_lints/src/format.rs +++ b/clippy_lints/src/format.rs @@ -38,8 +38,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let Some(span) = is_expn_of(cx, expr.span, "format") { match expr.node { // `format!("{}", foo)` expansion diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index 0d9a668e8b62..52461d08ee8d 100644 --- a/clippy_lints/src/functions.rs +++ b/clippy_lints/src/functions.rs @@ -68,8 +68,8 @@ impl LintPass for Functions { } } -impl LateLintPass for Functions { - fn check_fn<'a, 'tcx: 'a>( +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions { + fn check_fn( &mut self, cx: &LateContext<'a, 'tcx>, kind: intravisit::FnKind<'tcx>, @@ -105,7 +105,7 @@ impl LateLintPass for Functions { self.check_raw_ptr(cx, unsafety, decl, expr, nodeid); } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) { if let hir::MethodTraitItem(ref sig, eid) = item.node { // don't lint extern functions decls, it's not their fault if sig.abi == Abi::Rust { @@ -120,7 +120,7 @@ impl LateLintPass for Functions { } } -impl Functions { +impl<'a, 'tcx> Functions { fn check_arg_number(&self, cx: &LateContext, decl: &hir::FnDecl, span: Span) { let args = decl.inputs.len() as u64; if args > self.threshold { @@ -131,7 +131,7 @@ impl Functions { } } - fn check_raw_ptr<'a, 'tcx: 'a>( + fn check_raw_ptr( &self, cx: &LateContext<'a, 'tcx>, unsafety: hir::Unsafety, diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs index f360c59372bc..547aa23f0de8 100644 --- a/clippy_lints/src/identity_op.rs +++ b/clippy_lints/src/identity_op.rs @@ -31,8 +31,8 @@ impl LintPass for IdentityOp { } } -impl LateLintPass for IdentityOp { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityOp { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if in_macro(cx, e.span) { return; } diff --git a/clippy_lints/src/if_let_redundant_pattern_matching.rs b/clippy_lints/src/if_let_redundant_pattern_matching.rs index bc834886db96..399b58956bd6 100644 --- a/clippy_lints/src/if_let_redundant_pattern_matching.rs +++ b/clippy_lints/src/if_let_redundant_pattern_matching.rs @@ -42,8 +42,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprMatch(ref op, ref arms, MatchSource::IfLetDesugar{..}) = expr.node { diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs index 98db74cff3a2..fd58f86d42f6 100644 --- a/clippy_lints/src/len_zero.rs +++ b/clippy_lints/src/len_zero.rs @@ -59,8 +59,8 @@ impl LintPass for LenZero { } } -impl LateLintPass for LenZero { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LenZero { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if in_macro(cx, item.span) { return; } @@ -72,7 +72,7 @@ impl LateLintPass for LenZero { } } - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if in_macro(cx, expr.span) { return; } diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs index 1605505a6ae3..474a86cdb788 100644 --- a/clippy_lints/src/let_if_seq.rs +++ b/clippy_lints/src/let_if_seq.rs @@ -57,8 +57,8 @@ impl LintPass for LetIfSeq { } } -impl LateLintPass for LetIfSeq { - fn check_block<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx hir::Block) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq { + fn check_block(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx hir::Block) { let mut it = block.stmts.iter().peekable(); while let Some(stmt) = it.next() { if_let_chain! {[ @@ -149,7 +149,7 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for UsedVisitor<'a, 'tcx> { } } -fn check_assign<'a, 'tcx: 'a>( +fn check_assign<'a, 'tcx>( cx: &LateContext<'a, 'tcx>, decl: hir::def_id::DefId, block: &'tcx hir::Block, diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index 22e7384675fb..60132ad9161c 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -56,20 +56,20 @@ impl LintPass for LifetimePass { } } -impl LateLintPass for LifetimePass { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LifetimePass { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemFn(ref decl, _, _, _, ref generics, _) = item.node { check_fn_inner(cx, decl, generics, item.span); } } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { if let ImplItemKind::Method(ref sig, _) = item.node { check_fn_inner(cx, &sig.decl, &sig.generics, item.span); } } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { if let MethodTraitItem(ref sig, _) = item.node { check_fn_inner(cx, &sig.decl, &sig.generics, item.span); } @@ -98,7 +98,7 @@ fn bound_lifetimes(bound: &TyParamBound) -> HirVec<&Lifetime> { } } -fn check_fn_inner<'a, 'tcx: 'a>( +fn check_fn_inner<'a, 'tcx>( cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl, generics: &'tcx Generics, diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index 233c62890096..77f2df03a6a4 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -307,8 +307,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let Some((pat, arg, body)) = higher::for_loop(expr) { check_for_loop(cx, pat, arg, body, expr); } @@ -391,7 +391,7 @@ impl LateLintPass for Pass { } } - fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { + fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { if let StmtSemi(ref expr, _) = stmt.node { if let ExprMethodCall(ref method, _, ref args) = expr.node { if args.len() == 1 && &*method.node.as_str() == "collect" && @@ -407,7 +407,7 @@ impl LateLintPass for Pass { } } -fn check_for_loop<'a, 'tcx: 'a>( +fn check_for_loop<'a, 'tcx>( cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, arg: &'tcx Expr, @@ -423,7 +423,7 @@ fn check_for_loop<'a, 'tcx: 'a>( /// Check for looping over a range and then indexing a sequence with it. /// The iteratee must be a range literal. -fn check_for_loop_range<'a, 'tcx: 'a>( +fn check_for_loop_range<'a, 'tcx>( cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, arg: &'tcx Expr, @@ -658,7 +658,7 @@ fn check_arg_type(cx: &LateContext, pat: &Pat, arg: &Expr) { } } -fn check_for_loop_explicit_counter<'a, 'tcx: 'a>( +fn check_for_loop_explicit_counter<'a, 'tcx>( cx: &LateContext<'a, 'tcx>, arg: &'tcx Expr, body: &'tcx Expr, @@ -708,7 +708,7 @@ fn check_for_loop_explicit_counter<'a, 'tcx: 'a>( } /// Check for the `FOR_KV_MAP` lint. -fn check_for_loop_over_map_kv<'a, 'tcx: 'a>( +fn check_for_loop_over_map_kv<'a, 'tcx>( cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, arg: &'tcx Expr, diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs index 416f9dcf93eb..4539c3c8c105 100644 --- a/clippy_lints/src/map_clone.rs +++ b/clippy_lints/src/map_clone.rs @@ -24,8 +24,8 @@ declare_lint! { #[derive(Copy, Clone)] pub struct Pass; -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { // call to .map() if let ExprMethodCall(name, _, ref args) = expr.node { if &*name.node.as_str() == "map" && args.len() == 2 { diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index 0820a8137329..1d59afd9eace 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -129,8 +129,8 @@ impl LintPass for MatchPass { } } -impl LateLintPass for MatchPass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MatchPass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if in_external_macro(cx, expr.span) { return; } diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs index e3299958ae68..55654a7de43b 100644 --- a/clippy_lints/src/mem_forget.rs +++ b/clippy_lints/src/mem_forget.rs @@ -27,8 +27,8 @@ impl LintPass for MemForget { } } -impl LateLintPass for MemForget { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MemForget { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprCall(ref path_expr, ref args) = e.node { if let ExprPath(ref qpath) = path_expr.node { let def_id = cx.tcx.tables().qpath_def(qpath, path_expr.id).def_id(); diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index dd99f5a358ba..cb8fd62961d8 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -549,11 +549,11 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { #[allow(unused_attributes)] // ^ required because `cyclomatic_complexity` attribute shows up as unused #[cyclomatic_complexity = "30"] - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { if in_macro(cx, expr.span) { return; } @@ -629,7 +629,7 @@ impl LateLintPass for Pass { } } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, implitem: &'tcx hir::ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, implitem: &'tcx hir::ImplItem) { if in_external_macro(cx, implitem.span) { return; } diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs index f1f353cb762c..ccfc01a00030 100644 --- a/clippy_lints/src/minmax.rs +++ b/clippy_lints/src/minmax.rs @@ -33,8 +33,8 @@ impl LintPass for MinMaxPass { } } -impl LateLintPass for MinMaxPass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MinMaxPass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let Some((outer_max, outer_c, oe)) = min_max(cx, expr) { if let Some((inner_max, inner_c, _)) = min_max(cx, oe) { if outer_max == inner_max { diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index 679bad666b9f..0680f6b41a16 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -166,8 +166,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_fn<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, k: FnKind<'tcx>, decl: &'tcx FnDecl, _: &'tcx Expr, _: Span, _: NodeId) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, k: FnKind<'tcx>, decl: &'tcx FnDecl, _: &'tcx Expr, _: Span, _: NodeId) { if let FnKind::Closure(_) = k { // Does not apply to closures return; @@ -182,7 +182,7 @@ impl LateLintPass for Pass { } } - fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx Stmt) { + fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx Stmt) { if_let_chain! {[ let StmtDecl(ref d, _) = s.node, let DeclLocal(ref l) = d.node, @@ -216,7 +216,7 @@ impl LateLintPass for Pass { }} } - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprBinary(ref cmp, ref left, ref right) = expr.node { let op = cmp.node; if op.is_comparison() { @@ -294,7 +294,7 @@ impl LateLintPass for Pass { } } - fn check_pat<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) { + fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) { if let PatKind::Binding(_, _, ref ident, Some(ref right)) = pat.node { if right.node == PatKind::Wild { span_lint(cx, diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs index e40638616b6e..2f3bdeb053c8 100644 --- a/clippy_lints/src/missing_doc.rs +++ b/clippy_lints/src/missing_doc.rs @@ -94,8 +94,8 @@ impl LintPass for MissingDoc { } } -impl LateLintPass for MissingDoc { - fn enter_lint_attrs<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, attrs: &'tcx [ast::Attribute]) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { + fn enter_lint_attrs(&mut self, _: &LateContext<'a, 'tcx>, attrs: &'tcx [ast::Attribute]) { let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| { attr.check_name("doc") && match attr.meta_item_list() { None => false, @@ -105,15 +105,15 @@ impl LateLintPass for MissingDoc { self.doc_hidden_stack.push(doc_hidden); } - fn exit_lint_attrs<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx [ast::Attribute]) { + fn exit_lint_attrs(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx [ast::Attribute]) { self.doc_hidden_stack.pop().expect("empty doc_hidden_stack"); } - fn check_crate<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, krate: &'tcx hir::Crate) { + fn check_crate(&mut self, cx: &LateContext<'a, 'tcx>, krate: &'tcx hir::Crate) { self.check_missing_docs_attrs(cx, &krate.attrs, krate.span, "crate"); } - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) { let desc = match it.node { hir::ItemConst(..) => "a constant", hir::ItemEnum(..) => "an enum", @@ -134,7 +134,7 @@ impl LateLintPass for MissingDoc { self.check_missing_docs_attrs(cx, &it.attrs, it.span, desc); } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, trait_item: &'tcx hir::TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, trait_item: &'tcx hir::TraitItem) { let desc = match trait_item.node { hir::ConstTraitItem(..) => "an associated constant", hir::MethodTraitItem(..) => "a trait method", @@ -144,7 +144,7 @@ impl LateLintPass for MissingDoc { self.check_missing_docs_attrs(cx, &trait_item.attrs, trait_item.span, desc); } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx hir::ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx hir::ImplItem) { // If the method is an impl for a trait, don't doc. let def_id = cx.tcx.map.local_def_id(impl_item.id); match cx.tcx.associated_item(def_id).container { @@ -164,13 +164,13 @@ impl LateLintPass for MissingDoc { self.check_missing_docs_attrs(cx, &impl_item.attrs, impl_item.span, desc); } - fn check_struct_field<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, sf: &'tcx hir::StructField) { + fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, sf: &'tcx hir::StructField) { if !sf.is_positional() { self.check_missing_docs_attrs(cx, &sf.attrs, sf.span, "a struct field"); } } - fn check_variant<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, v: &'tcx hir::Variant, _: &hir::Generics) { + fn check_variant(&mut self, cx: &LateContext<'a, 'tcx>, v: &'tcx hir::Variant, _: &hir::Generics) { self.check_missing_docs_attrs(cx, &v.node.attrs, v.span, "a variant"); } } diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs index 303c53186024..40bb77871dbc 100644 --- a/clippy_lints/src/mut_mut.rs +++ b/clippy_lints/src/mut_mut.rs @@ -31,12 +31,12 @@ impl LintPass for MutMut { } } -impl LateLintPass for MutMut { - fn check_block<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx hir::Block) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MutMut { + fn check_block(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx hir::Block) { intravisit::walk_block(&mut MutVisitor { cx: cx }, block); } - fn check_ty<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, ty: &'tcx hir::Ty) { + fn check_ty(&mut self, cx: &LateContext<'a, 'tcx>, ty: &'tcx hir::Ty) { use rustc::hir::intravisit::Visitor; MutVisitor { cx: cx }.visit_ty(ty); diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs index 08d39b7c43d6..c189ecba6de7 100644 --- a/clippy_lints/src/mut_reference.rs +++ b/clippy_lints/src/mut_reference.rs @@ -32,8 +32,8 @@ impl LintPass for UnnecessaryMutPassed { } } -impl LateLintPass for UnnecessaryMutPassed { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnecessaryMutPassed { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { let borrowed_table = cx.tcx.tables.borrow(); match e.node { ExprCall(ref fn_expr, ref arguments) => { diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs index 71fcda814a3b..8d927110b9d2 100644 --- a/clippy_lints/src/mutex_atomic.rs +++ b/clippy_lints/src/mutex_atomic.rs @@ -54,8 +54,8 @@ impl LintPass for MutexAtomic { pub struct MutexAtomic; -impl LateLintPass for MutexAtomic { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MutexAtomic { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { let ty = cx.tcx.tables().expr_ty(expr); if let ty::TyAdt(_, subst) = ty.sty { if match_type(cx, ty, &paths::MUTEX) { diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs index bfa51f0ba703..3b08ebdbc8e0 100644 --- a/clippy_lints/src/needless_bool.rs +++ b/clippy_lints/src/needless_bool.rs @@ -56,8 +56,8 @@ impl LintPass for NeedlessBool { } } -impl LateLintPass for NeedlessBool { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { use self::Expression::*; if let ExprIf(ref pred, ref then_block, Some(ref else_expr)) = e.node { let reduce = |ret, not| { @@ -116,8 +116,8 @@ impl LintPass for BoolComparison { } } -impl LateLintPass for BoolComparison { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoolComparison { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { use self::Expression::*; if let ExprBinary(Spanned { node: BiEq, .. }, ref left_side, ref right_side) = e.node { match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) { diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs index 0f03ff774d2b..935e0da8c3ed 100644 --- a/clippy_lints/src/needless_borrow.rs +++ b/clippy_lints/src/needless_borrow.rs @@ -34,8 +34,8 @@ impl LintPass for NeedlessBorrow { } } -impl LateLintPass for NeedlessBorrow { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrow { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if in_macro(cx, e.span) { return; } @@ -53,7 +53,7 @@ impl LateLintPass for NeedlessBorrow { } } } - fn check_pat<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) { + fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) { if in_macro(cx, pat.span) { return; } diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs index 82cd502081f7..de6277aa0ee5 100644 --- a/clippy_lints/src/needless_update.rs +++ b/clippy_lints/src/needless_update.rs @@ -30,8 +30,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprStruct(_, ref fields, Some(ref base)) = expr.node { let ty = cx.tcx.tables().expr_ty(expr); if let TyAdt(def, _) = ty.sty { diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs index 6b0c8001ed22..05a6a92c9e9d 100644 --- a/clippy_lints/src/neg_multiply.rs +++ b/clippy_lints/src/neg_multiply.rs @@ -31,8 +31,8 @@ impl LintPass for NegMultiply { } #[allow(match_same_arms)] -impl LateLintPass for NegMultiply { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NegMultiply { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprBinary(Spanned { node: BiMul, .. }, ref l, ref r) = e.node { match (&l.node, &r.node) { (&ExprUnary(..), &ExprUnary(..)) => (), diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs index 836a5393a9d7..f4a7ebee590f 100644 --- a/clippy_lints/src/new_without_default.rs +++ b/clippy_lints/src/new_without_default.rs @@ -89,8 +89,8 @@ impl LintPass for NewWithoutDefault { } } -impl LateLintPass for NewWithoutDefault { - fn check_fn<'a, 'tcx: 'a>( +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NewWithoutDefault { + fn check_fn( &mut self, cx: &LateContext<'a, 'tcx>, kind: FnKind<'tcx>, diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs index 0a5c21114fb5..4a4b73b697f8 100644 --- a/clippy_lints/src/no_effect.rs +++ b/clippy_lints/src/no_effect.rs @@ -102,8 +102,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { if let StmtSemi(ref expr, _) = stmt.node { if has_no_effect(cx, expr) { span_lint(cx, NO_EFFECT, stmt.span, "statement with no effect"); diff --git a/clippy_lints/src/ok_if_let.rs b/clippy_lints/src/ok_if_let.rs index 77244acb3081..6ac49c1f575d 100644 --- a/clippy_lints/src/ok_if_let.rs +++ b/clippy_lints/src/ok_if_let.rs @@ -40,8 +40,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_let_chain! {[ //begin checking variables let ExprMatch(ref op, ref body, ref source) = expr.node, //test if expr is a match let MatchSource::IfLetDesugar { .. } = *source, //test if it is an If Let diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs index 538d09d082ee..f102bdcab33d 100644 --- a/clippy_lints/src/open_options.rs +++ b/clippy_lints/src/open_options.rs @@ -32,8 +32,8 @@ impl LintPass for NonSensical { } } -impl LateLintPass for NonSensical { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSensical { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprMethodCall(ref name, _, ref arguments) = e.node { let (obj_ty, _) = walk_ptrs_ty_depth(cx.tcx.tables().expr_ty(&arguments[0])); if &*name.node.as_str() == "open" && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) { diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs index 583b9315fee8..a09ff3bebf68 100644 --- a/clippy_lints/src/overflow_check_conditional.rs +++ b/clippy_lints/src/overflow_check_conditional.rs @@ -29,9 +29,9 @@ impl LintPass for OverflowCheckConditional { } } -impl LateLintPass for OverflowCheckConditional { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OverflowCheckConditional { // a + b < a, a > a + b, a < a - b, a - b > a - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_let_chain! {[ let Expr_::ExprBinary(ref op, ref first, ref second) = expr.node, let Expr_::ExprBinary(ref op2, ref ident1, ref ident2) = first.node, diff --git a/clippy_lints/src/panic.rs b/clippy_lints/src/panic.rs index 893a17a63fc7..3b4fbb3ab1b6 100644 --- a/clippy_lints/src/panic.rs +++ b/clippy_lints/src/panic.rs @@ -32,8 +32,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_let_chain! {[ let ExprBlock(ref block) = expr.node, let Some(ref ex) = block.expr, diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs index 4982055ef3a2..2677b40f757a 100644 --- a/clippy_lints/src/partialeq_ne_impl.rs +++ b/clippy_lints/src/partialeq_ne_impl.rs @@ -35,8 +35,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if_let_chain! {[ let ItemImpl(_, _, _, Some(ref trait_ref), _, ref impl_items) = item.node, !is_automatically_derived(&*item.attrs), diff --git a/clippy_lints/src/print.rs b/clippy_lints/src/print.rs index be70f6a7648f..daa55c9675fc 100644 --- a/clippy_lints/src/print.rs +++ b/clippy_lints/src/print.rs @@ -65,8 +65,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_let_chain! {[ let ExprCall(ref fun, ref args) = expr.node, let ExprPath(ref qpath) = fun.node, diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index a6be3fae45fc..f1fdc78aca4a 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -54,14 +54,14 @@ impl LintPass for PointerPass { } } -impl LateLintPass for PointerPass { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PointerPass { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemFn(ref decl, _, _, _, _, _) = item.node { check_fn(cx, decl, item.id); } } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { if let ImplItemKind::Method(ref sig, _) = item.node { if let Some(NodeItem(it)) = cx.tcx.map.find(cx.tcx.map.get_parent(item.id)) { if let ItemImpl(_, _, _, Some(_), _, _) = it.node { @@ -72,13 +72,13 @@ impl LateLintPass for PointerPass { } } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { if let MethodTraitItem(ref sig, _) = item.node { check_fn(cx, &sig.decl, item.id); } } - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprBinary(ref op, ref l, ref r) = expr.node { if (op.node == BiEq || op.node == BiNe) && (is_null_path(l) || is_null_path(r)) { span_lint(cx, diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs index 6936fc199934..78f097002039 100644 --- a/clippy_lints/src/ranges.rs +++ b/clippy_lints/src/ranges.rs @@ -46,8 +46,8 @@ impl LintPass for StepByZero { } } -impl LateLintPass for StepByZero { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StepByZero { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprMethodCall(Spanned { node: ref name, .. }, _, ref args) = expr.node { let name = &*name.as_str(); diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs index d04b03fcf57e..6e6b6156d6e6 100644 --- a/clippy_lints/src/regex.rs +++ b/clippy_lints/src/regex.rs @@ -82,12 +82,12 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_crate<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx Crate) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_crate(&mut self, _: &LateContext<'a, 'tcx>, _: &'tcx Crate) { self.spans.clear(); } - fn check_block<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block) { + fn check_block(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block) { if_let_chain!{[ self.last.is_none(), let Some(ref expr) = block.expr, @@ -106,13 +106,13 @@ impl LateLintPass for Pass { }} } - fn check_block_post<'a, 'tcx: 'a>(&mut self, _: &LateContext<'a, 'tcx>, block: &'tcx Block) { + fn check_block_post(&mut self, _: &LateContext<'a, 'tcx>, block: &'tcx Block) { if self.last.map_or(false, |id| block.id == id) { self.last = None; } } - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_let_chain!{[ let ExprCall(ref fun, ref args) = expr.node, let ExprPath(ref qpath) = fun.node, diff --git a/clippy_lints/src/serde.rs b/clippy_lints/src/serde.rs index 97a0e0052b58..ec4bce557061 100644 --- a/clippy_lints/src/serde.rs +++ b/clippy_lints/src/serde.rs @@ -26,8 +26,8 @@ impl LintPass for Serde { } } -impl LateLintPass for Serde { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Serde { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemImpl(_, _, _, Some(ref trait_ref), _, ref items) = item.node { let did = trait_ref.path.def.def_id(); if let Some(visit_did) = get_trait_def_id(cx, &paths::SERDE_DE_VISITOR) { diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs index 9ec4ceba7e67..2d32a8792741 100644 --- a/clippy_lints/src/shadow.rs +++ b/clippy_lints/src/shadow.rs @@ -79,8 +79,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_fn<'a, 'tcx: 'a>( +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_fn( &mut self, cx: &LateContext<'a, 'tcx>, _: FnKind<'tcx>, @@ -96,7 +96,7 @@ impl LateLintPass for Pass { } } -fn check_fn<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl, expr: &'tcx Expr) { +fn check_fn<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl, expr: &'tcx Expr) { let mut bindings = Vec::new(); for arg in &decl.inputs { if let PatKind::Binding(_, _, ident, _) = arg.pat.node { @@ -106,7 +106,7 @@ fn check_fn<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl, expr: check_expr(cx, expr, &mut bindings); } -fn check_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, block: &'tcx Block, bindings: &mut Vec<(Name, Span)>) { +fn check_block<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, block: &'tcx Block, bindings: &mut Vec<(Name, Span)>) { let len = bindings.len(); for stmt in &block.stmts { match stmt.node { @@ -121,7 +121,7 @@ fn check_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, block: &'tcx Block, bin bindings.truncate(len); } -fn check_decl<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, decl: &'tcx Decl, bindings: &mut Vec<(Name, Span)>) { +fn check_decl<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, decl: &'tcx Decl, bindings: &mut Vec<(Name, Span)>) { if in_external_macro(cx, decl.span) { return; } @@ -150,7 +150,7 @@ fn is_binding(cx: &LateContext, pat_id: NodeId) -> bool { } } -fn check_pat<'a, 'tcx: 'a>( +fn check_pat<'a, 'tcx>( cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat, init: Option<&'tcx Expr>, @@ -285,7 +285,7 @@ fn lint_shadow<'a, 'tcx: 'a>( } } -fn check_expr<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindings: &mut Vec<(Name, Span)>) { +fn check_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindings: &mut Vec<(Name, Span)>) { if in_external_macro(cx, expr.span) { return; } @@ -334,7 +334,7 @@ fn check_expr<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindin } } -fn check_ty<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, ty: &'tcx Ty, bindings: &mut Vec<(Name, Span)>) { +fn check_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: &'tcx Ty, bindings: &mut Vec<(Name, Span)>) { match ty.node { TyObjectSum(ref sty, _) | TySlice(ref sty) => check_ty(cx, sty, bindings), diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs index 985ef912dc1c..01f2f66c2fde 100644 --- a/clippy_lints/src/strings.rs +++ b/clippy_lints/src/strings.rs @@ -79,8 +79,8 @@ impl LintPass for StringAdd { } } -impl LateLintPass for StringAdd { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StringAdd { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprBinary(Spanned { node: BiAdd, .. }, ref left, _) = e.node { if is_string(cx, left) { if let Allow = cx.current_level(STRING_ADD_ASSIGN) { @@ -136,8 +136,8 @@ impl LintPass for StringLitAsBytes { } } -impl LateLintPass for StringLitAsBytes { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StringLitAsBytes { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { use std::ascii::AsciiExt; use syntax::ast::LitKind; use utils::{snippet, in_macro}; diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs index f251db2b1870..7393ee3890e5 100644 --- a/clippy_lints/src/swap.rs +++ b/clippy_lints/src/swap.rs @@ -50,8 +50,8 @@ impl LintPass for Swap { } } -impl LateLintPass for Swap { - fn check_block<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Swap { + fn check_block(&mut self, cx: &LateContext<'a, 'tcx>, block: &'tcx Block) { check_manual_swap(cx, block); check_suspicious_swap(cx, block); } diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs index c6246fec9b0f..2f6e6d97fbf7 100644 --- a/clippy_lints/src/temporary_assignment.rs +++ b/clippy_lints/src/temporary_assignment.rs @@ -37,8 +37,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprAssign(ref target, _) = expr.node { match target.node { ExprField(ref base, _) | diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index 2d09c725fb0d..b6731db93839 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -84,8 +84,8 @@ impl LintPass for Transmute { } } -impl LateLintPass for Transmute { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { if let ExprCall(ref path_expr, ref args) = e.node { if let ExprPath(ref qpath) = path_expr.node { let def_id = cx.tcx.tables().qpath_def(qpath, path_expr.id).def_id(); diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index 66c14e70e6a5..d2bc850e2078 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -69,8 +69,8 @@ impl LintPass for TypePass { } } -impl LateLintPass for TypePass { - fn check_ty<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, ast_ty: &'tcx Ty) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypePass { + fn check_ty(&mut self, cx: &LateContext<'a, 'tcx>, ast_ty: &'tcx Ty) { if in_macro(cx, ast_ty.span) { return; } @@ -153,8 +153,8 @@ impl LintPass for LetPass { } } -impl LateLintPass for LetPass { - fn check_decl<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, decl: &'tcx Decl) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetPass { + fn check_decl(&mut self, cx: &LateContext<'a, 'tcx>, decl: &'tcx Decl) { check_let_unit(cx, decl) } } @@ -190,8 +190,8 @@ impl LintPass for UnitCmp { } } -impl LateLintPass for UnitCmp { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitCmp { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if in_macro(cx, expr.span) { return; } @@ -447,8 +447,8 @@ impl LintPass for CastPass { } } -impl LateLintPass for CastPass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CastPass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprCast(ref ex, _) = expr.node { let (cast_from, cast_to) = (cx.tcx.tables().expr_ty(ex), cx.tcx.tables().expr_ty(expr)); if cast_from.is_numeric() && cast_to.is_numeric() && !in_external_macro(cx, expr.span) { @@ -535,17 +535,17 @@ impl LintPass for TypeComplexityPass { } } -impl LateLintPass for TypeComplexityPass { - fn check_fn<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, _: FnKind<'tcx>, decl: &'tcx FnDecl, _: &'tcx Expr, _: Span, _: NodeId) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeComplexityPass { + fn check_fn(&mut self, cx: &LateContext<'a, 'tcx>, _: FnKind<'tcx>, decl: &'tcx FnDecl, _: &'tcx Expr, _: Span, _: NodeId) { self.check_fndecl(cx, decl); } - fn check_struct_field<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx StructField) { + fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx StructField) { // enum variants are also struct fields now self.check_type(cx, &field.ty); } - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { match item.node { ItemStatic(ref ty, _, _) | ItemConst(ref ty, _) => self.check_type(cx, ty), @@ -554,7 +554,7 @@ impl LateLintPass for TypeComplexityPass { } } - fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) { match item.node { ConstTraitItem(ref ty, _) | TypeTraitItem(_, Some(ref ty)) => self.check_type(cx, ty), @@ -564,7 +564,7 @@ impl LateLintPass for TypeComplexityPass { } } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { match item.node { ImplItemKind::Const(ref ty, _) | ImplItemKind::Type(ref ty) => self.check_type(cx, ty), @@ -573,15 +573,15 @@ impl LateLintPass for TypeComplexityPass { } } - fn check_local<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, local: &'tcx Local) { + fn check_local(&mut self, cx: &LateContext<'a, 'tcx>, local: &'tcx Local) { if let Some(ref ty) = local.ty { self.check_type(cx, ty); } } } -impl TypeComplexityPass { - fn check_fndecl<'a, 'tcx: 'a>(&self, cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl) { +impl<'a, 'tcx> TypeComplexityPass { + fn check_fndecl(&self, cx: &LateContext<'a, 'tcx>, decl: &'tcx FnDecl) { for arg in &decl.inputs { self.check_type(cx, &arg.ty); } @@ -590,7 +590,7 @@ impl TypeComplexityPass { } } - fn check_type<'a, 'tcx: 'a>(&self, cx: &LateContext<'a, 'tcx>, ty: &'tcx Ty) { + fn check_type(&self, cx: &LateContext<'a, 'tcx>, ty: &'tcx Ty) { if in_macro(cx, ty.span) { return; } @@ -682,8 +682,8 @@ impl LintPass for CharLitAsU8 { } } -impl LateLintPass for CharLitAsU8 { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CharLitAsU8 { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { use syntax::ast::{LitKind, UintTy}; if let ExprCast(ref e, _) = expr.node { @@ -846,8 +846,8 @@ fn detect_extreme_expr<'a>(cx: &LateContext, expr: &'a Expr) -> Option(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AbsurdExtremeComparisons { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { use types::ExtremeType::*; use types::AbsurdComparisonResult::*; @@ -1071,8 +1071,8 @@ fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons: } } -impl LateLintPass for InvalidUpcastComparisons { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidUpcastComparisons { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprBinary(ref cmp, ref lhs, ref rhs) = expr.node { let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs); diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs index ba82bc470dca..1d5ab7db3461 100644 --- a/clippy_lints/src/unicode.rs +++ b/clippy_lints/src/unicode.rs @@ -68,8 +68,8 @@ impl LintPass for Unicode { } } -impl LateLintPass for Unicode { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Unicode { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if let ExprLit(ref lit) = expr.node { if let LitKind::Str(_, _) = lit.node { check_str(cx, lit.span) diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs index 8119c4d727ab..4f1e01af6e9f 100644 --- a/clippy_lints/src/unused_label.rs +++ b/clippy_lints/src/unused_label.rs @@ -40,8 +40,8 @@ impl LintPass for UnusedLabel { } } -impl LateLintPass for UnusedLabel { - fn check_fn<'a, 'tcx: 'a>( +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedLabel { + fn check_fn( &mut self, cx: &LateContext<'a, 'tcx>, kind: FnKind<'tcx>, diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs index ef98247b7e83..b2900c5691c7 100644 --- a/clippy_lints/src/utils/inspector.rs +++ b/clippy_lints/src/utils/inspector.rs @@ -36,15 +36,15 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) { if !has_attr(&item.attrs) { return; } print_item(cx, item); } - fn check_impl_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ImplItem) { if !has_attr(&item.attrs) { return; } @@ -68,33 +68,33 @@ impl LateLintPass for Pass { } } /* - fn check_trait_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::TraitItem) { if !has_attr(&item.attrs) { return; } } - fn check_variant<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, _: &hir::Generics) { + fn check_variant(&mut self, cx: &LateContext<'a, 'tcx>, var: &'tcx hir::Variant, _: &hir::Generics) { if !has_attr(&var.node.attrs) { return; } } - fn check_struct_field<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx hir::StructField) { + fn check_struct_field(&mut self, cx: &LateContext<'a, 'tcx>, field: &'tcx hir::StructField) { if !has_attr(&field.attrs) { return; } } */ - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { if !has_attr(&expr.attrs) { return; } print_expr(cx, expr, 0); } - fn check_arm<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, arm: &'tcx hir::Arm) { + fn check_arm(&mut self, cx: &LateContext<'a, 'tcx>, arm: &'tcx hir::Arm) { if !has_attr(&arm.attrs) { return; } @@ -109,7 +109,7 @@ impl LateLintPass for Pass { print_expr(cx, &arm.body, 1); } - fn check_stmt<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx hir::Stmt) { + fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx hir::Stmt) { if !has_attr(stmt.node.attrs()) { return; } @@ -120,7 +120,7 @@ impl LateLintPass for Pass { } /* - fn check_foreign_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ForeignItem) { + fn check_foreign_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::ForeignItem) { if !has_attr(&item.attrs) { return; } diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs index c2e55862b3db..91961f906919 100644 --- a/clippy_lints/src/utils/internal_lints.rs +++ b/clippy_lints/src/utils/internal_lints.rs @@ -104,8 +104,8 @@ impl LintPass for LintWithoutLintPass { } -impl LateLintPass for LintWithoutLintPass { - fn check_item<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LintWithoutLintPass { + fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if let ItemStatic(ref ty, MutImmutable, ref expr) = item.node { if is_lint_ref_type(ty) { self.declared_lints.insert(item.name, item.span); @@ -116,7 +116,7 @@ impl LateLintPass for LintWithoutLintPass { } } - fn check_crate_post<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, _: &'tcx Crate) { + fn check_crate_post(&mut self, cx: &LateContext<'a, 'tcx>, _: &'tcx Crate) { for (lint_name, &lint_span) in &self.declared_lints { // When using the `declare_lint!` macro, the original `lint_span`'s // file points to "". diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs index bed98559e6f0..1cfb57496f7a 100644 --- a/clippy_lints/src/vec.rs +++ b/clippy_lints/src/vec.rs @@ -32,8 +32,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { // search for `&vec![_]` expressions where the adjusted type is `&[_]` if_let_chain!{[ let ty::TypeVariants::TyRef(_, ref ty) = cx.tcx.tables().expr_ty_adjusted(expr).sty, diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs index b0cc96f3d64b..daf0721af05a 100644 --- a/clippy_lints/src/zero_div_zero.rs +++ b/clippy_lints/src/zero_div_zero.rs @@ -27,8 +27,8 @@ impl LintPass for Pass { } } -impl LateLintPass for Pass { - fn check_expr<'a, 'tcx: 'a>(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { +impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { + fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { // check for instances of 0.0/0.0 if_let_chain! {[ let ExprBinary(ref op, ref left, ref right) = expr.node, From 3de6f9db202c612aad15397fb5b3320497dc2f25 Mon Sep 17 00:00:00 2001 From: Arnavion Date: Sat, 10 Dec 2016 23:57:19 -0800 Subject: [PATCH 14/15] Use inputs/output getters for rustc::ty::FnSig instead of the now non-existent fields. --- clippy_lints/src/cyclomatic_complexity.rs | 2 +- clippy_lints/src/eta_reduction.rs | 2 +- clippy_lints/src/eval_order_dependence.rs | 2 +- clippy_lints/src/len_zero.rs | 2 +- clippy_lints/src/mut_reference.rs | 2 +- clippy_lints/src/ptr.rs | 2 +- clippy_lints/src/utils/mod.rs | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/clippy_lints/src/cyclomatic_complexity.rs b/clippy_lints/src/cyclomatic_complexity.rs index 164633b7c644..fc9e25c7707e 100644 --- a/clippy_lints/src/cyclomatic_complexity.rs +++ b/clippy_lints/src/cyclomatic_complexity.rs @@ -142,7 +142,7 @@ impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> { let ty = self.cx.tcx.tables().node_id_to_type(callee.id); match ty.sty { ty::TyFnDef(_, _, ty) | - ty::TyFnPtr(ty) if ty.sig.skip_binder().output.sty == ty::TyNever => { + ty::TyFnPtr(ty) if ty.sig.skip_binder().output().sty == ty::TyNever => { self.divergence += 1; } _ => (), diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs index 56308ed390d8..2bf91f8d1bce 100644 --- a/clippy_lints/src/eta_reduction.rs +++ b/clippy_lints/src/eta_reduction.rs @@ -66,7 +66,7 @@ fn check_closure(cx: &LateContext, expr: &Expr) { ty::TyFnDef(_, _, fn_ty) | ty::TyFnPtr(fn_ty) => { if fn_ty.unsafety == Unsafety::Unsafe || - fn_ty.sig.skip_binder().output.sty == ty::TyNever { + fn_ty.sig.skip_binder().output().sty == ty::TyNever { return; } } diff --git a/clippy_lints/src/eval_order_dependence.rs b/clippy_lints/src/eval_order_dependence.rs index 9e9a900fe7ab..88e1180067a7 100644 --- a/clippy_lints/src/eval_order_dependence.rs +++ b/clippy_lints/src/eval_order_dependence.rs @@ -132,7 +132,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> { ExprRet(_) => self.report_diverging_sub_expr(e), ExprCall(ref func, _) => match self.cx.tcx.tables().expr_ty(func).sty { ty::TyFnDef(_, _, fn_ty) | - ty::TyFnPtr(fn_ty) => if let ty::TyNever = self.cx.tcx.erase_late_bound_regions(&fn_ty.sig).output.sty { + ty::TyFnPtr(fn_ty) => if let ty::TyNever = self.cx.tcx.erase_late_bound_regions(&fn_ty.sig).output().sty { self.report_diverging_sub_expr(e); }, _ => {}, diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs index fd58f86d42f6..0242fb523ee5 100644 --- a/clippy_lints/src/len_zero.rs +++ b/clippy_lints/src/len_zero.rs @@ -188,7 +188,7 @@ fn has_is_empty(cx: &LateContext, expr: &Expr) -> bool { if let ty::AssociatedKind::Method = item.kind { if &*item.name.as_str() == "is_empty" { let ty = cx.tcx.item_type(item.def_id).fn_sig().skip_binder(); - ty.inputs.len() == 1 + ty.inputs().len() == 1 } else { false } diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs index c189ecba6de7..d2cd0a329143 100644 --- a/clippy_lints/src/mut_reference.rs +++ b/clippy_lints/src/mut_reference.rs @@ -60,7 +60,7 @@ fn check_arguments(cx: &LateContext, arguments: &[Expr], type_definition: &TyS, match type_definition.sty { TypeVariants::TyFnDef(_, _, fn_type) | TypeVariants::TyFnPtr(fn_type) => { - let parameters = &fn_type.sig.skip_binder().inputs; + let parameters = fn_type.sig.skip_binder().inputs(); for (argument, parameter) in arguments.iter().zip(parameters.iter()) { match parameter.sty { TypeVariants::TyRef(_, TypeAndMut { mutbl: MutImmutable, .. }) | diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index f1fdc78aca4a..1461189946c1 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -94,7 +94,7 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, fn_id: NodeId) { let fn_def_id = cx.tcx.map.local_def_id(fn_id); let fn_ty = cx.tcx.item_type(fn_def_id).fn_sig().skip_binder(); - for (arg, ty) in decl.inputs.iter().zip(&fn_ty.inputs) { + for (arg, ty) in decl.inputs.iter().zip(fn_ty.inputs()) { if let ty::TyRef(_, ty::TypeAndMut { ty, mutbl: MutImmutable }) = ty.sty { if match_type(cx, ty, &paths::VEC) { span_lint(cx, diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index dc64e56b2e68..d8afb96298d4 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -751,7 +751,7 @@ pub fn return_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, fn_item: NodeId) -> ty::T let fn_def_id = cx.tcx.map.local_def_id(fn_item); let fn_sig = cx.tcx.item_type(fn_def_id).fn_sig(); let fn_sig = cx.tcx.liberate_late_bound_regions(parameter_env.free_id_outlive, fn_sig); - fn_sig.output + fn_sig.output() } /// Check if two types are the same. From 4fcefe2a9e38d3fa8e57c58d78328e23de54757f Mon Sep 17 00:00:00 2001 From: mcarton Date: Sat, 17 Dec 2016 01:27:35 +0100 Subject: [PATCH 15/15] Bump to 0.0.104 --- CHANGELOG.md | 3 ++- Cargo.toml | 4 ++-- clippy_lints/Cargo.toml | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 042ed6929d1f..952532a3d7cf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,7 +1,8 @@ # Change Log All notable changes to this project will be documented in this file. -## 0.0.104 — 2016-12-01 +## 0.0.104 — 2016-12-15 +* Update to *rustc 1.15.0-nightly (8f02c429a 2016-12-15)* ## 0.0.103 — 2016-11-25 * Update to *rustc 1.15.0-nightly (d5814b03e 2016-11-23)* diff --git a/Cargo.toml b/Cargo.toml index a21fd9e12274..5167218ff4a8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "clippy" -version = "0.0.103" +version = "0.0.104" authors = [ "Manish Goregaokar ", "Andre Bogus ", @@ -25,7 +25,7 @@ test = false [dependencies] # begin automatic update -clippy_lints = { version = "0.0.103", path = "clippy_lints" } +clippy_lints = { version = "0.0.104", path = "clippy_lints" } # end automatic update [dev-dependencies] diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml index 872c4152ae73..faf86875f40d 100644 --- a/clippy_lints/Cargo.toml +++ b/clippy_lints/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "clippy_lints" # begin automatic update -version = "0.0.103" +version = "0.0.104" # end automatic update authors = [ "Manish Goregaokar ",