Mirrors/rust-clippy
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-clippy synced 2024-11-14 17:07:17 +00:00
Code Issues Projects Releases Packages Wiki Activity

Resolve field, struct and function renaming

Browse source 
Addresses the errors produced by (re)moving, merging or renaming
structs, fields and methods by rust-lang/rust#48149 and rust-lang/rust#51580
This commit is contained in:
flip1995 2018-06-24 15:32:40 +02:00
parent 5f5fa084ec
commit d9a80d2f84
No known key found for this signature in database
GPG key ID: 9F184E1164831181
22 changed files with 106 additions and 94 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
clippy_lints/src/attrs.rs
View file

@ -207,7 +207,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass {
} }
fn is_relevant_item(tcx: TyCtxt, item: &Item) -> bool { fn is_relevant_item(tcx: TyCtxt, item: &Item) -> bool {
if let ItemFn(_, _, _, _, _, eid) = item.node { if let ItemFn(_, _, _, eid) = item.node {
is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value) is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value)
} else { } else {
true true

2
clippy_lints/src/eval_order_dependence.rs
View file

@ -124,7 +124,7 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> {
impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> { impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
fn visit_expr(&mut self, e: &'tcx Expr) { fn visit_expr(&mut self, e: &'tcx Expr) {
match e.node { match e.node {
ExprAgain(_) | ExprBreak(_, _) | ExprRet(_) => self.report_diverging_sub_expr(e), ExprContinue(_) | ExprBreak(_, _) | ExprRet(_) => self.report_diverging_sub_expr(e),
ExprCall(ref func, _) => { ExprCall(ref func, _) => {
let typ = self.cx.tables.expr_ty(func); let typ = self.cx.tables.expr_ty(func);
match typ.sty { match typ.sty {

12
clippy_lints/src/functions.rs
View file

@ -92,8 +92,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions {
}; };
let unsafety = match kind { let unsafety = match kind {
hir::intravisit::FnKind::ItemFn(_, _, unsafety, _, _, _, _) => unsafety, hir::intravisit::FnKind::ItemFn(_, _, hir::FnHeader { unsafety, .. }, _, _) => unsafety,
hir::intravisit::FnKind::Method(_, sig, _, _) => sig.unsafety, hir::intravisit::FnKind::Method(_, sig, _, _) => sig.header.unsafety,
hir::intravisit::FnKind::Closure(_) => return, hir::intravisit::FnKind::Closure(_) => return,
}; };
@ -101,8 +101,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions {
if !is_impl { if !is_impl {
// don't lint extern functions decls, it's not their fault either // don't lint extern functions decls, it's not their fault either
match kind { match kind {
hir::intravisit::FnKind::Method(_, &hir::MethodSig { abi: Abi::Rust, .. }, _, _) | hir::intravisit::FnKind::Method(_, &hir::MethodSig { header: hir::FnHeader { abi: Abi::Rust, .. }, .. }, _, _) |
hir::intravisit::FnKind::ItemFn(_, _, _, _, Abi::Rust, _, _) => self.check_arg_number(cx, decl, span), hir::intravisit::FnKind::ItemFn(_, _, hir::FnHeader { abi: Abi::Rust, .. }, _, _) => self.check_arg_number(cx, decl, span),
_ => {}, _ => {},
} }
} }
@ -113,13 +113,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions {
fn check_trait_item(&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::TraitItemKind::Method(ref sig, ref eid) = item.node { if let hir::TraitItemKind::Method(ref sig, ref eid) = item.node {
// don't lint extern functions decls, it's not their fault // don't lint extern functions decls, it's not their fault
if sig.abi == Abi::Rust { if sig.header.abi == Abi::Rust {
self.check_arg_number(cx, &sig.decl, item.span); self.check_arg_number(cx, &sig.decl, item.span);
} }
if let hir::TraitMethod::Provided(eid) = *eid { if let hir::TraitMethod::Provided(eid) = *eid {
let body = cx.tcx.hir.body(eid); let body = cx.tcx.hir.body(eid);
self.check_raw_ptr(cx, sig.unsafety, &sig.decl, body, item.id); self.check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.id);
} }
} }
} }

57
clippy_lints/src/lifetimes.rs
View file

@ -59,7 +59,7 @@ impl LintPass for LifetimePass {
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LifetimePass { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LifetimePass {
fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
if let ItemFn(ref decl, _, _, _, ref generics, id) = item.node { if let ItemFn(ref decl, _, ref generics, id) = item.node {
check_fn_inner(cx, decl, Some(id), generics, item.span); check_fn_inner(cx, decl, Some(id), generics, item.span);
} }
} }
@ -101,32 +101,35 @@ fn check_fn_inner<'a, 'tcx>(
} }
let mut bounds_lts = Vec::new(); let mut bounds_lts = Vec::new();
for typ in generics.ty_params() { generics.params.iter().for_each(|param| match param.kind {
for bound in &typ.bounds { GenericParamKind::Lifetime { .. } => {},
let mut visitor = RefVisitor::new(cx); GenericParamKind::Type { .. } => {
walk_ty_param_bound(&mut visitor, bound); for bound in &param.bounds {
if visitor.lts.iter().any(|lt| matches!(lt, RefLt::Named(_))) { let mut visitor = RefVisitor::new(cx);
return; walk_param_bound(&mut visitor, bound);
} if visitor.lts.iter().any(|lt| matches!(lt, RefLt::Named(_))) {
if let TraitTyParamBound(ref trait_ref, _) = *bound { return;
let params = &trait_ref }
.trait_ref if let GenericBound::Trait(ref trait_ref, _) = *bound {
.path let params = &trait_ref
.segments .trait_ref
.last() .path
.expect("a path must have at least one segment") .segments
.parameters; .last()
if let Some(ref params) = *params { .expect("a path must have at least one segment")
for bound in &params.lifetimes { .args;
if bound.name.name() != "'static" && !bound.is_elided() { if let Some(ref params) = *params {
return; for bound in &params.lifetimes {
if bound.name.name() != "'static" && !bound.is_elided() {
return;
}
bounds_lts.push(bound);
} }
bounds_lts.push(bound);
} }
} }
} }
} },
} });
if could_use_elision(cx, decl, body, &generics.params, bounds_lts) { if could_use_elision(cx, decl, body, &generics.params, bounds_lts) {
span_lint( span_lint(
cx, cx,
@ -295,7 +298,7 @@ impl<'v, 't> RefVisitor<'v, 't> {
} }
fn collect_anonymous_lifetimes(&mut self, qpath: &QPath, ty: &Ty) { fn collect_anonymous_lifetimes(&mut self, qpath: &QPath, ty: &Ty) {
if let Some(ref last_path_segment) = last_path_segment(qpath).parameters { if let Some(ref last_path_segment) = last_path_segment(qpath).args {
if !last_path_segment.parenthesized && last_path_segment.lifetimes.is_empty() { if !last_path_segment.parenthesized && last_path_segment.lifetimes.is_empty() {
let hir_id = self.cx.tcx.hir.node_to_hir_id(ty.id); let hir_id = self.cx.tcx.hir.node_to_hir_id(ty.id);
match self.cx.tables.qpath_def(qpath, hir_id) { match self.cx.tables.qpath_def(qpath, hir_id) {
@ -335,7 +338,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> {
TyImplTraitExistential(exist_ty_id, _, _) => { TyImplTraitExistential(exist_ty_id, _, _) => {
if let ItemExistential(ref exist_ty) = self.cx.tcx.hir.expect_item(exist_ty_id.id).node { if let ItemExistential(ref exist_ty) = self.cx.tcx.hir.expect_item(exist_ty_id.id).node {
for bound in &exist_ty.bounds { for bound in &exist_ty.bounds {
if let RegionTyParamBound(_) = *bound { if let GenericBound::Outlives(_) = *bound {
self.record(&None); self.record(&None);
} }
} }
@ -377,7 +380,7 @@ fn has_where_lifetimes<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, where_clause: &
let allowed_lts = allowed_lts_from(&pred.bound_generic_params); let allowed_lts = allowed_lts_from(&pred.bound_generic_params);
// now walk the bounds // now walk the bounds
for bound in pred.bounds.iter() { for bound in pred.bounds.iter() {
walk_ty_param_bound(&mut visitor, bound); walk_param_bound(&mut visitor, bound);
} }
// and check that all lifetimes are allowed // and check that all lifetimes are allowed
match visitor.into_vec() { match visitor.into_vec() {
@ -418,7 +421,7 @@ impl<'tcx> Visitor<'tcx> for LifetimeChecker {
// don't want to spuriously remove them // don't want to spuriously remove them
// `'b` in `'a: 'b` is useless unless used elsewhere in // `'b` in `'a: 'b` is useless unless used elsewhere in
// a non-lifetime bound // a non-lifetime bound
if param.is_type_param() { if let GenericParamKind::Type { .. } = param.kind {
walk_generic_param(self, param) walk_generic_param(self, param)
} }
} }

2
clippy_lints/src/loops.rs
View file

@ -640,7 +640,7 @@ fn never_loop_expr(expr: &Expr, main_loop_id: NodeId) -> NeverLoopResult {
} }
}, },
ExprBlock(ref b, _) => never_loop_block(b, main_loop_id), ExprBlock(ref b, _) => never_loop_block(b, main_loop_id),
ExprAgain(d) => { ExprContinue(d) => {
let id = d.target_id let id = d.target_id
.expect("target id can only be missing in the presence of compilation errors"); .expect("target id can only be missing in the presence of compilation errors");
if id == main_loop_id { if id == main_loop_id {

2
clippy_lints/src/map_clone.rs
View file

@ -104,7 +104,7 @@ fn expr_eq_name(expr: &Expr, id: ast::Name) -> bool {
let arg_segment = [ let arg_segment = [
PathSegment { PathSegment {
name: id, name: id,
parameters: None, args: None,
infer_types: true, infer_types: true,
}, },
]; ];

47
clippy_lints/src/methods.rs
View file

@ -7,7 +7,7 @@ use std::fmt;
use std::iter; use std::iter;
use syntax::ast; use syntax::ast;
use syntax::codemap::{Span, BytePos}; use syntax::codemap::{Span, BytePos};
use crate::utils::{get_arg_name, get_trait_def_id, implements_trait, in_external_macro, in_macro, is_copy, is_expn_of, is_self, use crate::utils::{get_arg_name, get_trait_def_id, implements_trait, in_external_macro, in_macro, is_copy, is_expn_of, is_self,
is_self_ty, iter_input_pats, last_path_segment, match_def_path, match_path, match_qpath, match_trait_method, is_self_ty, iter_input_pats, last_path_segment, match_def_path, match_path, match_qpath, match_trait_method,
match_type, method_chain_args, match_var, return_ty, remove_blocks, same_tys, single_segment_path, snippet, match_type, method_chain_args, match_var, return_ty, remove_blocks, same_tys, single_segment_path, snippet,
span_lint, span_lint_and_sugg, span_lint_and_then, span_note_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth}; span_lint, span_lint_and_sugg, span_lint_and_then, span_note_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth};
@ -336,7 +336,7 @@ declare_clippy_lint! {
/// ///
/// **Known problems:** If the function has side-effects, not calling it will /// **Known problems:** If the function has side-effects, not calling it will
/// change the semantic of the program, but you shouldn't rely on that anyway. /// change the semantic of the program, but you shouldn't rely on that anyway.
/// ///
/// **Example:** /// **Example:**
/// ```rust /// ```rust
/// foo.expect(&format("Err {}: {}", err_code, err_msg)) /// foo.expect(&format("Err {}: {}", err_code, err_msg))
@ -1020,7 +1020,7 @@ fn lint_expect_fun_call(cx: &LateContext, expr: &hir::Expr, method_span: Span, n
} }
} }
}; };
snippet(cx, a.span, "..").into_owned() snippet(cx, a.span, "..").into_owned()
} }
@ -1077,7 +1077,7 @@ fn lint_expect_fun_call(cx: &LateContext, expr: &hir::Expr, method_span: Span, n
} }
let sugg: Cow<_> = snippet(cx, arg.span, ".."); let sugg: Cow<_> = snippet(cx, arg.span, "..");
span_lint_and_sugg( span_lint_and_sugg(
cx, cx,
EXPECT_FUN_CALL, EXPECT_FUN_CALL,
@ -2091,26 +2091,29 @@ impl SelfKind {
fn is_as_ref_or_mut_trait(ty: &hir::Ty, self_ty: &hir::Ty, generics: &hir::Generics, name: &[&str]) -> bool { fn is_as_ref_or_mut_trait(ty: &hir::Ty, self_ty: &hir::Ty, generics: &hir::Generics, name: &[&str]) -> bool {
single_segment_ty(ty).map_or(false, |seg| { single_segment_ty(ty).map_or(false, |seg| {
generics.ty_params().any(|param| { generics.params.iter().any(|param| match param.kind {
param.name == seg.name && param.bounds.iter().any(|bound| { hir::GenericParamKind::Type { .. } => {
if let hir::TyParamBound::TraitTyParamBound(ref ptr, ..) = *bound { param.name.name() == seg.name && param.bounds.iter().any(|bound| {
let path = &ptr.trait_ref.path; if let hir::GenericBound::Trait(ref ptr, ..) = *bound {
match_path(path, name) && path.segments.last().map_or(false, |s| { let path = &ptr.trait_ref.path;
if let Some(ref params) = s.parameters { match_path(path, name) && path.segments.last().map_or(false, |s| {
if params.parenthesized { if let Some(ref params) = s.args {
false if params.parenthesized {
false
} else {
params.types.len() == 1
&& (is_self_ty(&params.types[0]) || is_ty(&*params.types[0], self_ty))
}
} else { } else {
params.types.len() == 1 false
&& (is_self_ty(&params.types[0]) || is_ty(&*params.types[0], self_ty))
} }
} else { })
false } else {
} false
}) }
} else { })
false },
} _ => false,
})
}) })
}) })
} }

10
clippy_lints/src/misc_early.rs
View file

@ -189,13 +189,13 @@ impl LintPass for MiscEarly {
impl EarlyLintPass for MiscEarly { impl EarlyLintPass for MiscEarly {
fn check_generics(&mut self, cx: &EarlyContext, gen: &Generics) { fn check_generics(&mut self, cx: &EarlyContext, gen: &Generics) {
for param in &gen.params { for param in &gen.params {
if let GenericParam::Type(ref ty) = *param { if let GenericParamKind::Type { .. } = param.kind {
let name = ty.ident.name.as_str(); let name = param.ident.name.as_str();
if constants::BUILTIN_TYPES.contains(&&*name) { if constants::BUILTIN_TYPES.contains(&&*name) {
span_lint( span_lint(
cx, cx,
BUILTIN_TYPE_SHADOW, BUILTIN_TYPE_SHADOW,
ty.ident.span, param.ident.span,
&format!("This generic shadows the built-in type `{}`", name), &format!("This generic shadows the built-in type `{}`", name),
); );
} }
@ -296,7 +296,7 @@ impl EarlyLintPass for MiscEarly {
} }
match expr.node { match expr.node {
ExprKind::Call(ref paren, _) => if let ExprKind::Paren(ref closure) = paren.node { ExprKind::Call(ref paren, _) => if let ExprKind::Paren(ref closure) = paren.node {
if let ExprKind::Closure(_, _, ref decl, ref block, _) = closure.node { if let ExprKind::Closure(_, _, _, ref decl, ref block, _) = closure.node {
span_lint_and_then( span_lint_and_then(
cx, cx,
REDUNDANT_CLOSURE_CALL, REDUNDANT_CLOSURE_CALL,
@ -327,7 +327,7 @@ impl EarlyLintPass for MiscEarly {
if_chain! { if_chain! {
if let StmtKind::Local(ref local) = w[0].node; if let StmtKind::Local(ref local) = w[0].node;
if let Option::Some(ref t) = local.init; if let Option::Some(ref t) = local.init;
if let ExprKind::Closure(_, _, _, _, _) = t.node; if let ExprKind::Closure(..) = t.node;
if let PatKind::Ident(_, ident, _) = local.pat.node; if let PatKind::Ident(_, ident, _) = local.pat.node;
if let StmtKind::Semi(ref second) = w[1].node; if let StmtKind::Semi(ref second) = w[1].node;
if let ExprKind::Assign(_, ref call) = second.node; if let ExprKind::Assign(_, ref call) = second.node;

6
clippy_lints/src/needless_pass_by_value.rs
View file

@ -72,8 +72,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {
} }
match kind { match kind {
FnKind::ItemFn(.., abi, _, attrs) => { FnKind::ItemFn(.., header, _, attrs) => {
if abi != Abi::Rust { if header.abi != Abi::Rust {
return; return;
} }
for a in attrs { for a in attrs {
@ -218,7 +218,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {
if let TyPath(QPath::Resolved(_, ref path)) = input.node; if let TyPath(QPath::Resolved(_, ref path)) = input.node;
if let Some(elem_ty) = path.segments.iter() if let Some(elem_ty) = path.segments.iter()
.find(|seg| seg.name == "Vec") .find(|seg| seg.name == "Vec")
.and_then(|ps| ps.parameters.as_ref()) .and_then(|ps| ps.args.as_ref())
.map(|params| &params.types[0]); .map(|params| &params.types[0]);
then { then {
let slice_ty = format!("&[{}]", snippet(cx, elem_ty.span, "_")); let slice_ty = format!("&[{}]", snippet(cx, elem_ty.span, "_"));

7
clippy_lints/src/new_without_default.rs
View file

@ -99,11 +99,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NewWithoutDefault {
if let hir::ImplItemKind::Method(ref sig, _) = impl_item.node { if let hir::ImplItemKind::Method(ref sig, _) = impl_item.node {
let name = impl_item.name; let name = impl_item.name;
let id = impl_item.id; let id = impl_item.id;
if sig.constness == hir::Constness::Const { if sig.header.constness == hir::Constness::Const {
// can't be implemented by default // can't be implemented by default
return; return;
} }
if impl_item.generics.params.iter().any(|gen| gen.is_type_param()) { if impl_item.generics.params.iter().any(|gen| match gen.kind {
hir::GenericParamKind::Type { .. } => true,
_ => false
}) {
// when the result of `new()` depends on a type parameter we should not require // when the result of `new()` depends on a type parameter we should not require
// an // an
// impl of `Default` // impl of `Default`

2
clippy_lints/src/non_expressive_names.rs
View file

@ -312,7 +312,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SimilarNamesLocalVisitor<'a, 'tcx> {
impl EarlyLintPass for NonExpressiveNames { impl EarlyLintPass for NonExpressiveNames {
fn check_item(&mut self, cx: &EarlyContext, item: &Item) { fn check_item(&mut self, cx: &EarlyContext, item: &Item) {
if let ItemKind::Fn(ref decl, _, _, _, _, ref blk) = item.node { if let ItemKind::Fn(ref decl, _, _, ref blk) = item.node {
do_check(self, cx, &item.attrs, decl, blk); do_check(self, cx, &item.attrs, decl, blk);
} }
} }

6
clippy_lints/src/ptr.rs
View file

@ -103,7 +103,7 @@ impl LintPass for PointerPass {
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PointerPass { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PointerPass {
fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
if let ItemFn(ref decl, _, _, _, _, body_id) = item.node { if let ItemFn(ref decl, _, _, body_id) = item.node {
check_fn(cx, decl, item.id, Some(body_id)); check_fn(cx, decl, item.id, Some(body_id));
} }
} }
@ -160,7 +160,7 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, fn_id: NodeId, opt_body_id: Option<
let mut ty_snippet = None; let mut ty_snippet = None;
if_chain! { if_chain! {
if let TyPath(QPath::Resolved(_, ref path)) = walk_ptrs_hir_ty(arg).node; if let TyPath(QPath::Resolved(_, ref path)) = walk_ptrs_hir_ty(arg).node;
if let Some(&PathSegment{parameters: Some(ref parameters), ..}) = path.segments.last(); if let Some(&PathSegment{args: Some(ref parameters), ..}) = path.segments.last();
if parameters.types.len() == 1; if parameters.types.len() == 1;
then { then {
ty_snippet = snippet_opt(cx, parameters.types[0].span); ty_snippet = snippet_opt(cx, parameters.types[0].span);
@ -218,7 +218,7 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, fn_id: NodeId, opt_body_id: Option<
if let TyPath(ref path) = ty.node; if let TyPath(ref path) = ty.node;
if let QPath::Resolved(None, ref pp) = *path; if let QPath::Resolved(None, ref pp) = *path;
if let [ref bx] = *pp.segments; if let [ref bx] = *pp.segments;
if let Some(ref params) = bx.parameters; if let Some(ref params) = bx.args;
if !params.parenthesized; if !params.parenthesized;
if let [ref inner] = *params.types; if let [ref inner] = *params.types;
then { then {

2
clippy_lints/src/transmute.rs
View file

@ -455,7 +455,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
fn get_type_snippet(cx: &LateContext, path: &QPath, to_ref_ty: Ty) -> String { fn get_type_snippet(cx: &LateContext, path: &QPath, to_ref_ty: Ty) -> String {
let seg = last_path_segment(path); let seg = last_path_segment(path);
if_chain! { if_chain! {
if let Some(ref params) = seg.parameters; if let Some(ref params) = seg.args;
if !params.parenthesized; if !params.parenthesized;
if let Some(to_ty) = params.types.get(1); if let Some(to_ty) = params.types.get(1);
if let TyRptr(_, ref to_ty) = to_ty.node; if let TyRptr(_, ref to_ty) = to_ty.node;

4
clippy_lints/src/trivially_copy_pass_by_ref.rs
View file

@ -84,8 +84,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TriviallyCopyPassByRef {
} }
match kind { match kind {
FnKind::ItemFn(.., abi, _, attrs) => { FnKind::ItemFn(.., header, _, attrs) => {
if abi != Abi::Rust { if header.abi != Abi::Rust {
return; return;
} }
for a in attrs { for a in attrs {

17
clippy_lints/src/types.rs
View file

@ -180,7 +180,7 @@ fn check_fn_decl(cx: &LateContext, decl: &FnDecl) {
fn match_type_parameter(cx: &LateContext, qpath: &QPath, path: &[&str]) -> bool { fn match_type_parameter(cx: &LateContext, qpath: &QPath, path: &[&str]) -> bool {
let last = last_path_segment(qpath); let last = last_path_segment(qpath);
if_chain! { if_chain! {
if let Some(ref params) = last.parameters; if let Some(ref params) = last.args;
if !params.parenthesized; if !params.parenthesized;
if let Some(ty) = params.types.get(0); if let Some(ty) = params.types.get(0);
if let TyPath(ref qpath) = ty.node; if let TyPath(ref qpath) = ty.node;
@ -244,7 +244,7 @@ fn check_ty(cx: &LateContext, ast_ty: &hir::Ty, is_local: bool) {
QPath::Resolved(Some(ref ty), ref p) => { QPath::Resolved(Some(ref ty), ref p) => {
check_ty(cx, ty, is_local); check_ty(cx, ty, is_local);
for ty in p.segments.iter().flat_map(|seg| { for ty in p.segments.iter().flat_map(|seg| {
seg.parameters seg.args
.as_ref() .as_ref()
.map_or_else(|| [].iter(), |params| params.types.iter()) .map_or_else(|| [].iter(), |params| params.types.iter())
}) { }) {
@ -252,7 +252,7 @@ fn check_ty(cx: &LateContext, ast_ty: &hir::Ty, is_local: bool) {
} }
}, },
QPath::Resolved(None, ref p) => for ty in p.segments.iter().flat_map(|seg| { QPath::Resolved(None, ref p) => for ty in p.segments.iter().flat_map(|seg| {
seg.parameters seg.args
.as_ref() .as_ref()
.map_or_else(|| [].iter(), |params| params.types.iter()) .map_or_else(|| [].iter(), |params| params.types.iter())
}) { }) {
@ -260,7 +260,7 @@ fn check_ty(cx: &LateContext, ast_ty: &hir::Ty, is_local: bool) {
}, },
QPath::TypeRelative(ref ty, ref seg) => { QPath::TypeRelative(ref ty, ref seg) => {
check_ty(cx, ty, is_local); check_ty(cx, ty, is_local);
if let Some(ref params) = seg.parameters { if let Some(ref params) = seg.args {
for ty in params.types.iter() { for ty in params.types.iter() {
check_ty(cx, ty, is_local); check_ty(cx, ty, is_local);
} }
@ -288,7 +288,7 @@ fn check_ty_rptr(cx: &LateContext, ast_ty: &hir::Ty, is_local: bool, lt: &Lifeti
if Some(def_id) == cx.tcx.lang_items().owned_box(); if Some(def_id) == cx.tcx.lang_items().owned_box();
if let QPath::Resolved(None, ref path) = *qpath; if let QPath::Resolved(None, ref path) = *qpath;
if let [ref bx] = *path.segments; if let [ref bx] = *path.segments;
if let Some(ref params) = bx.parameters; if let Some(ref params) = bx.args;
if !params.parenthesized; if !params.parenthesized;
if let [ref inner] = *params.types; if let [ref inner] = *params.types;
then { then {
@ -1208,7 +1208,10 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor {
TyTraitObject(ref param_bounds, _) => { TyTraitObject(ref param_bounds, _) => {
let has_lifetime_parameters = param_bounds let has_lifetime_parameters = param_bounds
.iter() .iter()
.any(|bound| bound.bound_generic_params.iter().any(|gen| gen.is_lifetime_param())); .any(|bound| bound.bound_generic_params.iter().any(|gen| match gen.kind {
GenericParamKind::Lifetime { .. } => true,
_ => false,
}));
if has_lifetime_parameters { if has_lifetime_parameters {
// complex trait bounds like A<'a, 'b> // complex trait bounds like A<'a, 'b>
(50 * self.nest, 1) (50 * self.nest, 1)
@ -1859,7 +1862,7 @@ impl<'tcx> ImplicitHasherType<'tcx> {
/// Checks that `ty` is a target type without a BuildHasher. /// Checks that `ty` is a target type without a BuildHasher.
fn new<'a>(cx: &LateContext<'a, 'tcx>, hir_ty: &hir::Ty) -> Option<Self> { fn new<'a>(cx: &LateContext<'a, 'tcx>, hir_ty: &hir::Ty) -> Option<Self> {
if let TyPath(QPath::Resolved(None, ref path)) = hir_ty.node { if let TyPath(QPath::Resolved(None, ref path)) = hir_ty.node {
let params = &path.segments.last().as_ref()?.parameters.as_ref()?.types; let params = &path.segments.last().as_ref()?.args.as_ref()?.types;
let params_len = params.len(); let params_len = params.len();
let ty = hir_ty_to_ty(cx.tcx, hir_ty); let ty = hir_ty_to_ty(cx.tcx, hir_ty);

2
clippy_lints/src/unused_label.rs
View file

@ -69,7 +69,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedLabel {
impl<'a, 'tcx: 'a> Visitor<'tcx> for UnusedLabelVisitor<'a, 'tcx> { impl<'a, 'tcx: 'a> Visitor<'tcx> for UnusedLabelVisitor<'a, 'tcx> {
fn visit_expr(&mut self, expr: &'tcx hir::Expr) { fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
match expr.node { match expr.node {
hir::ExprBreak(destination, _) | hir::ExprAgain(destination) => if let Some(label) = destination.label { hir::ExprBreak(destination, _) | hir::ExprContinue(destination) => if let Some(label) = destination.label {
self.labels.remove(&label.name.as_str()); self.labels.remove(&label.name.as_str());
}, },
hir::ExprLoop(_, Some(label), _) | hir::ExprWhile(_, _, Some(label)) => { hir::ExprLoop(_, Some(label), _) | hir::ExprWhile(_, _, Some(label)) => {

2
clippy_lints/src/use_self.rs
View file

@ -58,7 +58,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UseSelf {
if let ItemImpl(.., ref item_type, ref refs) = item.node; if let ItemImpl(.., ref item_type, ref refs) = item.node;
if let Ty_::TyPath(QPath::Resolved(_, ref item_path)) = item_type.node; if let Ty_::TyPath(QPath::Resolved(_, ref item_path)) = item_type.node;
then { then {
let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).parameters; let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args;
let should_check = if let Some(ref params) = *parameters { let should_check = if let Some(ref params) = *parameters {
!params.parenthesized && params.lifetimes.len() == 0 !params.parenthesized && params.lifetimes.len() == 0
} else { } else {

2
clippy_lints/src/utils/author.rs
View file

@ -432,7 +432,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
} }
// FIXME: implement label printing // FIXME: implement label printing
}, },
Expr_::ExprAgain(ref _destination) => { Expr_::ExprContinue(ref _destination) => {
let destination_pat = self.next("destination"); let destination_pat = self.next("destination");
println!("Again(ref {}) = {};", destination_pat, current); println!("Again(ref {}) = {};", destination_pat, current);
// FIXME: implement label printing // FIXME: implement label printing

10
clippy_lints/src/utils/hir_utils.rs
View file

@ -76,7 +76,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
match (&left.node, &right.node) { match (&left.node, &right.node) {
(&ExprAddrOf(l_mut, ref le), &ExprAddrOf(r_mut, ref re)) => l_mut == r_mut && self.eq_expr(le, re), (&ExprAddrOf(l_mut, ref le), &ExprAddrOf(r_mut, ref re)) => l_mut == r_mut && self.eq_expr(le, re),
(&ExprAgain(li), &ExprAgain(ri)) => { (&ExprContinue(li), &ExprContinue(ri)) => {
both(&li.label, &ri.label, |l, r| l.name.as_str() == r.name.as_str()) both(&li.label, &ri.label, |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), (&ExprAssign(ref ll, ref lr), &ExprAssign(ref rl, ref rr)) => self.eq_expr(ll, rl) && self.eq_expr(lr, rr),
@ -201,7 +201,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
&& over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r)) && over(&left.segments, &right.segments, |l, r| self.eq_path_segment(l, r))
} }
fn eq_path_parameters(&mut self, left: &PathParameters, right: &PathParameters) -> bool { fn eq_path_parameters(&mut self, left: &GenericArgs, right: &GenericArgs) -> bool {
if !(left.parenthesized || right.parenthesized) { if !(left.parenthesized || right.parenthesized) {
over(&left.lifetimes, &right.lifetimes, |l, r| self.eq_lifetime(l, r)) 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.types, &right.types, |l, r| self.eq_ty(l, r))
@ -224,7 +224,7 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
if left.name.as_str() != right.name.as_str() { if left.name.as_str() != right.name.as_str() {
return false; return false;
} }
match (&left.parameters, &right.parameters) { match (&left.args, &right.args) {
(&None, &None) => true, (&None, &None) => true,
(&Some(ref l), &Some(ref r)) => self.eq_path_parameters(l, r), (&Some(ref l), &Some(ref r)) => self.eq_path_parameters(l, r),
_ => false, _ => false,
@ -345,8 +345,8 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
m.hash(&mut self.s); m.hash(&mut self.s);
self.hash_expr(e); self.hash_expr(e);
}, },
ExprAgain(i) => { ExprContinue(i) => {
let c: fn(_) -> _ = ExprAgain; let c: fn(_) -> _ = ExprContinue;
c.hash(&mut self.s); c.hash(&mut self.s);
if let Some(i) = i.label { if let Some(i) = i.label {
self.hash_name(i.name); self.hash_name(i.name);

2
clippy_lints/src/utils/inspector.rs
View file

@ -300,7 +300,7 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
print_expr(cx, e, indent + 1); print_expr(cx, e, indent + 1);
} }
}, },
hir::ExprAgain(_) => println!("{}Again", ind), hir::ExprContinue(_) => println!("{}Again", ind),
hir::ExprRet(ref e) => { hir::ExprRet(ref e) => {
println!("{}Ret", ind); println!("{}Ret", ind);
if let Some(ref e) = *e { if let Some(ref e) = *e {

2
clippy_lints/src/utils/mod.rs
View file

@ -524,7 +524,7 @@ pub fn get_enclosing_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, node: NodeI
match node { match node {
Node::NodeBlock(block) => Some(block), Node::NodeBlock(block) => Some(block),
Node::NodeItem(&Item { Node::NodeItem(&Item {
node: ItemFn(_, _, _, _, _, eid), node: ItemFn(_, _, _, eid),
.. ..
}) | Node::NodeImplItem(&ImplItem { }) | Node::NodeImplItem(&ImplItem {
node: ImplItemKind::Method(_, eid), node: ImplItemKind::Method(_, eid),

2
clippy_lints/src/utils/sugg.rs
View file

@ -52,7 +52,7 @@ impl<'a> Sugg<'a> {
hir::ExprIf(..) | hir::ExprIf(..) |
hir::ExprUnary(..) | hir::ExprUnary(..) |
hir::ExprMatch(..) => Sugg::MaybeParen(snippet), hir::ExprMatch(..) => Sugg::MaybeParen(snippet),
hir::ExprAgain(..) | hir::ExprContinue(..) |
hir::ExprYield(..) | hir::ExprYield(..) |
hir::ExprArray(..) | hir::ExprArray(..) |
hir::ExprBlock(..) | hir::ExprBlock(..) |