From 6b1d383e3300fc0f41fa898bf98fae80a1ea345e Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Mon, 16 Jul 2018 15:09:04 +0200 Subject: [PATCH] Update the clippy submodule --- CONTRIBUTING.md | 6 +- clippy_lints/src/approx_const.rs | 2 +- clippy_lints/src/arithmetic.rs | 30 +-- clippy_lints/src/assign_ops.rs | 60 ++--- clippy_lints/src/attrs.rs | 18 +- clippy_lints/src/bit_mask.rs | 60 ++--- clippy_lints/src/block_in_if_condition.rs | 8 +- clippy_lints/src/booleans.rs | 52 ++-- clippy_lints/src/bytecount.rs | 18 +- clippy_lints/src/consts.rs | 140 +++++------ clippy_lints/src/copies.rs | 12 +- clippy_lints/src/cyclomatic_complexity.rs | 12 +- clippy_lints/src/default_trait_access.rs | 4 +- clippy_lints/src/derive.rs | 2 +- clippy_lints/src/double_comparison.rs | 14 +- clippy_lints/src/drop_forget_ref.rs | 4 +- clippy_lints/src/duration_subsec.rs | 4 +- clippy_lints/src/empty_enum.rs | 2 +- clippy_lints/src/entry.rs | 12 +- clippy_lints/src/enum_clike.rs | 2 +- clippy_lints/src/enum_glob_use.rs | 2 +- clippy_lints/src/eq_op.rs | 38 +-- clippy_lints/src/erasing_op.rs | 6 +- clippy_lints/src/escape.rs | 6 +- clippy_lints/src/eta_reduction.rs | 8 +- clippy_lints/src/eval_order_dependence.rs | 52 ++-- clippy_lints/src/excessive_precision.rs | 2 +- clippy_lints/src/explicit_write.rs | 8 +- clippy_lints/src/fallible_impl_from.rs | 6 +- clippy_lints/src/format.rs | 34 +-- clippy_lints/src/functions.rs | 12 +- clippy_lints/src/identity_conversion.rs | 10 +- clippy_lints/src/identity_op.rs | 12 +- .../src/if_let_redundant_pattern_matching.rs | 2 +- clippy_lints/src/indexing_slicing.rs | 2 +- .../src/infallible_destructuring_match.rs | 2 +- clippy_lints/src/infinite_iter.rs | 18 +- clippy_lints/src/inherent_impl.rs | 2 +- clippy_lints/src/invalid_ref.rs | 4 +- clippy_lints/src/large_enum_variant.rs | 2 +- clippy_lints/src/len_zero.rs | 20 +- clippy_lints/src/let_if_seq.rs | 20 +- clippy_lints/src/lifetimes.rs | 10 +- clippy_lints/src/loops.rs | 180 +++++++------- clippy_lints/src/map_clone.rs | 12 +- clippy_lints/src/map_unit_fn.rs | 24 +- clippy_lints/src/matches.rs | 22 +- clippy_lints/src/mem_forget.rs | 6 +- clippy_lints/src/methods.rs | 80 +++--- clippy_lints/src/minmax.rs | 4 +- clippy_lints/src/misc.rs | 40 +-- clippy_lints/src/missing_doc.rs | 32 +-- clippy_lints/src/missing_inline.rs | 32 +-- clippy_lints/src/mut_mut.rs | 8 +- clippy_lints/src/mut_reference.rs | 6 +- clippy_lints/src/needless_bool.rs | 18 +- clippy_lints/src/needless_borrow.rs | 4 +- clippy_lints/src/needless_pass_by_value.rs | 12 +- clippy_lints/src/needless_update.rs | 4 +- clippy_lints/src/neg_cmp_op_on_partial_ord.rs | 14 +- clippy_lints/src/neg_multiply.rs | 10 +- clippy_lints/src/new_without_default.rs | 2 +- clippy_lints/src/no_effect.rs | 58 ++--- clippy_lints/src/non_copy_const.rs | 14 +- clippy_lints/src/ok_if_let.rs | 4 +- clippy_lints/src/open_options.rs | 8 +- .../src/overflow_check_conditional.rs | 36 +-- clippy_lints/src/panic_unimplemented.rs | 8 +- clippy_lints/src/partialeq_ne_impl.rs | 2 +- clippy_lints/src/ptr.rs | 20 +- clippy_lints/src/question_mark.rs | 14 +- clippy_lints/src/ranges.rs | 14 +- clippy_lints/src/redundant_field_names.rs | 2 +- clippy_lints/src/regex.rs | 10 +- clippy_lints/src/replace_consts.rs | 2 +- clippy_lints/src/serde_api.rs | 2 +- clippy_lints/src/shadow.rs | 46 ++-- clippy_lints/src/strings.rs | 14 +- clippy_lints/src/suspicious_trait_impl.rs | 47 ++-- clippy_lints/src/swap.rs | 26 +- clippy_lints/src/temporary_assignment.rs | 8 +- clippy_lints/src/transmute.rs | 6 +- .../src/trivially_copy_pass_by_ref.rs | 6 +- clippy_lints/src/types.rs | 72 +++--- clippy_lints/src/unicode.rs | 2 +- clippy_lints/src/unused_io_amount.rs | 12 +- clippy_lints/src/unused_label.rs | 4 +- clippy_lints/src/unwrap.rs | 16 +- clippy_lints/src/use_self.rs | 4 +- clippy_lints/src/utils/author.rs | 110 ++++----- clippy_lints/src/utils/comparisons.rs | 16 +- clippy_lints/src/utils/higher.rs | 70 +++--- clippy_lints/src/utils/hir_utils.rs | 230 +++++++++--------- clippy_lints/src/utils/inspector.rs | 102 ++++---- clippy_lints/src/utils/internal_lints.rs | 9 +- clippy_lints/src/utils/mod.rs | 26 +- clippy_lints/src/utils/ptr.rs | 2 +- clippy_lints/src/utils/sugg.rs | 90 +++---- clippy_lints/src/vec.rs | 2 +- clippy_lints/src/write.rs | 68 +++--- clippy_lints/src/zero_div_zero.rs | 4 +- tests/ui/author.stdout | 10 +- tests/ui/author/call.stdout | 12 +- tests/ui/author/for_loop.stdout | 58 ++--- tests/ui/author/matches.stout | 26 +- tests/ui/deprecated.stderr | 10 +- tests/ui/suspicious_arithmetic_impl.rs | 6 +- tests/ui/trailing_zeros.stdout | 14 +- 108 files changed, 1306 insertions(+), 1266 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d29aa80160ca..293418416a27 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -93,9 +93,9 @@ a `.stdout` file with the generated code: // ./tests/ui/my_lint.stdout if_chain! { - if let Expr_::ExprArray(ref elements) = stmt.node; + if let ExprKind::Array(ref elements) = stmt.node; if elements.len() == 1; - if let Expr_::ExprLit(ref lit) = elements[0].node; + if let ExprKind::Lit(ref lit) = elements[0].node; if let LitKind::Int(7, _) = lit.node; then { // report your lint here @@ -179,7 +179,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) { ``` The [`rustc_plugin::PluginRegistry`][plugin_registry] provides two methods to register lints: [register_early_lint_pass][reg_early_lint_pass] and [register_late_lint_pass][reg_late_lint_pass]. -Both take an object that implements an [`EarlyLintPass`][early_lint_pass] or [`LateLintPass`][late_lint_pass] respectively. This is done in every single lint. +Both take an object that implements an [`EarlyLintPass`][early_lint_pass] or [`LateLintPass`][late_lint_pass] respectively. This is done in every single lint. It's worth noting that the majority of `clippy_lints/src/lib.rs` is autogenerated by `util/update_lints.py` and you don't have to add anything by hand. When you are writing your own lint, you can use that script to save you some time. ```rust diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs index d3741d788012..13e1dbe3c0a7 100644 --- a/clippy_lints/src/approx_const.rs +++ b/clippy_lints/src/approx_const.rs @@ -63,7 +63,7 @@ impl LintPass for Pass { 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 { + if let ExprKind::Lit(ref lit) = e.node { check_lit(cx, lit, e); } } diff --git a/clippy_lints/src/arithmetic.rs b/clippy_lints/src/arithmetic.rs index a9ccc336a199..0ab7a3388637 100644 --- a/clippy_lints/src/arithmetic.rs +++ b/clippy_lints/src/arithmetic.rs @@ -55,21 +55,21 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic { return; } match expr.node { - hir::ExprBinary(ref op, ref l, ref r) => { + hir::ExprKind::Binary(ref op, ref l, ref r) => { match op.node { - hir::BiAnd - | hir::BiOr - | hir::BiBitAnd - | hir::BiBitOr - | hir::BiBitXor - | hir::BiShl - | hir::BiShr - | hir::BiEq - | hir::BiLt - | hir::BiLe - | hir::BiNe - | hir::BiGe - | hir::BiGt => return, + hir::BinOpKind::And + | hir::BinOpKind::Or + | hir::BinOpKind::BitAnd + | hir::BinOpKind::BitOr + | hir::BinOpKind::BitXor + | hir::BinOpKind::Shl + | hir::BinOpKind::Shr + | hir::BinOpKind::Eq + | hir::BinOpKind::Lt + | hir::BinOpKind::Le + | hir::BinOpKind::Ne + | hir::BinOpKind::Ge + | hir::BinOpKind::Gt => return, _ => (), } let (l_ty, r_ty) = (cx.tables.expr_ty(l), cx.tables.expr_ty(r)); @@ -81,7 +81,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Arithmetic { self.span = Some(expr.span); } }, - hir::ExprUnary(hir::UnOp::UnNeg, ref arg) => { + hir::ExprKind::Unary(hir::UnOp::UnNeg, ref arg) => { let ty = cx.tables.expr_ty(arg); if ty.is_integral() { span_lint(cx, INTEGER_ARITHMETIC, expr.span, "integer arithmetic detected"); diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs index ba405610c902..272b6c5a84dc 100644 --- a/clippy_lints/src/assign_ops.rs +++ b/clippy_lints/src/assign_ops.rs @@ -76,7 +76,7 @@ impl LintPass for AssignOps { 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) => { + hir::ExprKind::AssignOp(op, ref lhs, ref rhs) => { span_lint_and_then(cx, ASSIGN_OPS, expr.span, "assign operation detected", |db| { let lhs = &sugg::Sugg::hir(cx, lhs, ".."); let rhs = &sugg::Sugg::hir(cx, rhs, ".."); @@ -87,7 +87,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { format!("{} = {}", lhs, sugg::make_binop(higher::binop(op.node), lhs, rhs)), ); }); - if let hir::ExprBinary(binop, ref l, ref r) = rhs.node { + if let hir::ExprKind::Binary(binop, ref l, ref r) = rhs.node { if op.node == binop.node { let lint = |assignee: &hir::Expr, rhs_other: &hir::Expr| { span_lint_and_then( @@ -131,8 +131,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { } } }, - hir::ExprAssign(ref assignee, ref e) => { - if let hir::ExprBinary(op, ref l, ref r) = e.node { + hir::ExprKind::Assign(ref assignee, ref e) => { + if let hir::ExprKind::Binary(op, ref l, ref r) = e.node { #[allow(cyclomatic_complexity)] let lint = |assignee: &hir::Expr, rhs: &hir::Expr| { let ty = cx.tables.expr_ty(assignee); @@ -142,9 +142,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { $cx:expr, $ty:expr, $rty:expr, - $($trait_name:ident:$full_trait_name:ident),+) => { + $($trait_name:ident),+) => { match $op { - $(hir::$full_trait_name => { + $(hir::BinOpKind::$trait_name => { let [krate, module] = crate::utils::paths::OPS_MODULE; let path = [krate, module, concat!(stringify!($trait_name), "Assign")]; let trait_id = if let Some(trait_id) = get_trait_def_id($cx, &path) { @@ -159,7 +159,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { if_chain! { if parent_impl != ast::CRATE_NODE_ID; if let hir::map::Node::NodeItem(item) = cx.tcx.hir.get(parent_impl); - if let hir::Item_::ItemImpl(_, _, _, _, Some(ref trait_ref), _, _) = + if let hir::ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) = item.node; if trait_ref.path.def.def_id() == trait_id; then { return; } @@ -175,18 +175,18 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { cx, ty, rty.into(), - Add: BiAdd, - Sub: BiSub, - Mul: BiMul, - Div: BiDiv, - Rem: BiRem, - And: BiAnd, - Or: BiOr, - BitAnd: BiBitAnd, - BitOr: BiBitOr, - BitXor: BiBitXor, - Shr: BiShr, - Shl: BiShl + Add, + Sub, + Mul, + Div, + Rem, + And, + Or, + BitAnd, + BitOr, + BitXor, + Shr, + Shl ) { span_lint_and_then( cx, @@ -224,13 +224,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { // a = b commutative_op a if SpanlessEq::new(cx).ignore_fn().eq_expr(assignee, r) { match op.node { - hir::BiAdd - | hir::BiMul - | hir::BiAnd - | hir::BiOr - | hir::BiBitXor - | hir::BiBitAnd - | hir::BiBitOr => { + hir::BinOpKind::Add + | hir::BinOpKind::Mul + | hir::BinOpKind::And + | hir::BinOpKind::Or + | hir::BinOpKind::BitXor + | hir::BinOpKind::BitAnd + | hir::BinOpKind::BitOr => { lint(assignee, l); }, _ => {}, @@ -244,11 +244,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps { } } -fn is_commutative(op: hir::BinOp_) -> bool { - use rustc::hir::BinOp_::*; +fn is_commutative(op: hir::BinOpKind) -> bool { + use rustc::hir::BinOpKind::*; match op { - BiAdd | BiMul | BiAnd | BiOr | BiBitXor | BiBitAnd | BiBitOr | BiEq | BiNe => true, - BiSub | BiDiv | BiRem | BiShl | BiShr | BiLt | BiLe | BiGe | BiGt => false, + Add | Mul | And | Or | BitXor | BitAnd | BitOr | Eq | Ne => true, + Sub | Div | Rem | Shl | Shr | Lt | Le | Ge | Gt => false, } } diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index b9d8976b28b4..5d5e2f964b09 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -154,7 +154,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass { check_attrs(cx, item.span, item.name, &item.attrs) } match item.node { - ItemExternCrate(_) | ItemUse(_, _) => { + ItemKind::ExternCrate(_) | ItemKind::Use(_, _) => { for attr in &item.attrs { if let Some(ref lint_list) = attr.meta_item_list() { match &*attr.name().as_str() { @@ -162,7 +162,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass { // whitelist `unused_imports` and `deprecated` for lint in lint_list { if is_word(lint, "unused_imports") || is_word(lint, "deprecated") { - if let ItemUse(_, _) = item.node { + if let ItemKind::Use(_, _) = item.node { return; } } @@ -207,7 +207,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AttrPass { } fn is_relevant_item(tcx: TyCtxt, item: &Item) -> bool { - if let ItemFn(_, _, _, eid) = item.node { + if let ItemKind::Fn(_, _, _, eid) = item.node { is_relevant_expr(tcx, tcx.body_tables(eid), &tcx.hir.body(eid).value) } else { true @@ -234,8 +234,8 @@ fn is_relevant_trait(tcx: TyCtxt, item: &TraitItem) -> bool { fn is_relevant_block(tcx: TyCtxt, tables: &ty::TypeckTables, block: &Block) -> bool { if let Some(stmt) = block.stmts.first() { match stmt.node { - StmtDecl(_, _) => true, - StmtExpr(ref expr, _) | StmtSemi(ref expr, _) => is_relevant_expr(tcx, tables, expr), + StmtKind::Decl(_, _) => true, + StmtKind::Expr(ref expr, _) | StmtKind::Semi(ref expr, _) => is_relevant_expr(tcx, tables, expr), } } else { block.expr.as_ref().map_or(false, |e| is_relevant_expr(tcx, tables, e)) @@ -244,10 +244,10 @@ fn is_relevant_block(tcx: TyCtxt, tables: &ty::TypeckTables, block: &Block) -> b fn is_relevant_expr(tcx: TyCtxt, tables: &ty::TypeckTables, expr: &Expr) -> bool { match expr.node { - ExprBlock(ref block, _) => is_relevant_block(tcx, tables, block), - ExprRet(Some(ref e)) => is_relevant_expr(tcx, tables, e), - ExprRet(None) | ExprBreak(_, None) => false, - ExprCall(ref path_expr, _) => if let ExprPath(ref qpath) = path_expr.node { + ExprKind::Block(ref block, _) => is_relevant_block(tcx, tables, block), + ExprKind::Ret(Some(ref e)) => is_relevant_expr(tcx, tables, e), + ExprKind::Ret(None) | ExprKind::Break(_, None) => false, + ExprKind::Call(ref path_expr, _) => if let ExprKind::Path(ref qpath) = path_expr.node { if let Some(fun_id) = opt_def_id(tables.qpath_def(qpath, path_expr.hir_id)) { !match_def_path(tcx, fun_id, &paths::BEGIN_PANIC) } else { diff --git a/clippy_lints/src/bit_mask.rs b/clippy_lints/src/bit_mask.rs index 9f548b9e3208..25d5e4d4db1d 100644 --- a/clippy_lints/src/bit_mask.rs +++ b/clippy_lints/src/bit_mask.rs @@ -109,7 +109,7 @@ impl LintPass for BitMask { 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 let ExprKind::Binary(ref cmp, ref left, ref right) = e.node { if cmp.node.is_comparison() { if let Some(cmp_opt) = fetch_int_literal(cx, right) { check_compare(cx, left, cmp.node, cmp_opt, e.span) @@ -119,13 +119,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BitMask { } } if_chain! { - if let Expr_::ExprBinary(ref op, ref left, ref right) = e.node; - if BinOp_::BiEq == op.node; - if let Expr_::ExprBinary(ref op1, ref left1, ref right1) = left.node; - if BinOp_::BiBitAnd == op1.node; - if let Expr_::ExprLit(ref lit) = right1.node; + if let ExprKind::Binary(ref op, ref left, ref right) = e.node; + if BinOpKind::Eq == op.node; + if let ExprKind::Binary(ref op1, ref left1, ref right1) = left.node; + if BinOpKind::BitAnd == op1.node; + if let ExprKind::Lit(ref lit) = right1.node; if let LitKind::Int(n, _) = lit.node; - if let Expr_::ExprLit(ref lit1) = right.node; + if let ExprKind::Lit(ref lit1) = right.node; if let LitKind::Int(0, _) = lit1.node; if n.leading_zeros() == n.count_zeros(); if n > u128::from(self.verbose_bit_mask_threshold); @@ -143,22 +143,22 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BitMask { } } -fn invert_cmp(cmp: BinOp_) -> BinOp_ { +fn invert_cmp(cmp: BinOpKind) -> BinOpKind { match cmp { - BiEq => BiEq, - BiNe => BiNe, - BiLt => BiGt, - BiGt => BiLt, - BiLe => BiGe, - BiGe => BiLe, - _ => BiOr, // Dummy + BinOpKind::Eq => BinOpKind::Eq, + BinOpKind::Ne => BinOpKind::Ne, + BinOpKind::Lt => BinOpKind::Gt, + BinOpKind::Gt => BinOpKind::Lt, + BinOpKind::Le => BinOpKind::Ge, + BinOpKind::Ge => BinOpKind::Le, + _ => BinOpKind::Or, // Dummy } } -fn check_compare(cx: &LateContext, bit_op: &Expr, cmp_op: BinOp_, cmp_value: u128, span: Span) { - if let ExprBinary(ref op, ref left, ref right) = bit_op.node { - if op.node != BiBitAnd && op.node != BiBitOr { +fn check_compare(cx: &LateContext, bit_op: &Expr, cmp_op: BinOpKind, cmp_value: u128, span: Span) { + if let ExprKind::Binary(ref op, ref left, ref right) = bit_op.node { + if op.node != BinOpKind::BitAnd && op.node != BinOpKind::BitOr { return; } fetch_int_literal(cx, right) @@ -167,10 +167,10 @@ fn check_compare(cx: &LateContext, bit_op: &Expr, cmp_op: BinOp_, cmp_value: u12 } } -fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: u128, cmp_value: u128, span: Span) { +fn check_bit_mask(cx: &LateContext, bit_op: BinOpKind, cmp_op: BinOpKind, mask_value: u128, cmp_value: u128, span: Span) { match cmp_op { - BiEq | BiNe => match bit_op { - BiBitAnd => if mask_value & cmp_value != cmp_value { + BinOpKind::Eq | BinOpKind::Ne => match bit_op { + BinOpKind::BitAnd => if mask_value & cmp_value != cmp_value { if cmp_value != 0 { span_lint( cx, @@ -186,7 +186,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: } else if mask_value == 0 { span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero"); }, - BiBitOr => if mask_value | cmp_value != cmp_value { + BinOpKind::BitOr => if mask_value | cmp_value != cmp_value { span_lint( cx, BAD_BIT_MASK, @@ -200,8 +200,8 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: }, _ => (), }, - BiLt | BiGe => match bit_op { - BiBitAnd => if mask_value < cmp_value { + BinOpKind::Lt | BinOpKind::Ge => match bit_op { + BinOpKind::BitAnd => if mask_value < cmp_value { span_lint( cx, BAD_BIT_MASK, @@ -215,7 +215,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: } else if mask_value == 0 { span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero"); }, - BiBitOr => if mask_value >= cmp_value { + BinOpKind::BitOr => if mask_value >= cmp_value { span_lint( cx, BAD_BIT_MASK, @@ -229,11 +229,11 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: } else { check_ineffective_lt(cx, span, mask_value, cmp_value, "|"); }, - BiBitXor => check_ineffective_lt(cx, span, mask_value, cmp_value, "^"), + BinOpKind::BitXor => check_ineffective_lt(cx, span, mask_value, cmp_value, "^"), _ => (), }, - BiLe | BiGt => match bit_op { - BiBitAnd => if mask_value <= cmp_value { + BinOpKind::Le | BinOpKind::Gt => match bit_op { + BinOpKind::BitAnd => if mask_value <= cmp_value { span_lint( cx, BAD_BIT_MASK, @@ -247,7 +247,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: } else if mask_value == 0 { span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero"); }, - BiBitOr => if mask_value > cmp_value { + BinOpKind::BitOr => if mask_value > cmp_value { span_lint( cx, BAD_BIT_MASK, @@ -261,7 +261,7 @@ fn check_bit_mask(cx: &LateContext, bit_op: BinOp_, cmp_op: BinOp_, mask_value: } else { check_ineffective_gt(cx, span, mask_value, cmp_value, "|"); }, - BiBitXor => check_ineffective_gt(cx, span, mask_value, cmp_value, "^"), + BinOpKind::BitXor => check_ineffective_gt(cx, span, mask_value, cmp_value, "^"), _ => (), }, _ => (), diff --git a/clippy_lints/src/block_in_if_condition.rs b/clippy_lints/src/block_in_if_condition.rs index 5f4843411863..94e17290b6a6 100644 --- a/clippy_lints/src/block_in_if_condition.rs +++ b/clippy_lints/src/block_in_if_condition.rs @@ -56,10 +56,10 @@ struct ExVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx: 'a> Visitor<'tcx> for ExVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &'tcx Expr) { - if let ExprClosure(_, _, eid, _, _) = expr.node { + if let ExprKind::Closure(_, _, eid, _, _) = expr.node { let body = self.cx.tcx.hir.body(eid); let ex = &body.value; - if matches!(ex.node, ExprBlock(_, _)) { + if matches!(ex.node, ExprKind::Block(_, _)) { self.found_block = Some(ex); return; } @@ -77,8 +77,8 @@ const COMPLEX_BLOCK_MESSAGE: &str = "in an 'if' condition, avoid complex blocks 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 let ExprKind::If(ref check, ref then, _) = expr.node { + if let ExprKind::Block(ref block, _) = check.node { if block.rules == DefaultBlock { if block.stmts.is_empty() { if let Some(ref ex) = block.expr { diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs index b541bfc6b2fd..e23978ebc1d4 100644 --- a/clippy_lints/src/booleans.rs +++ b/clippy_lints/src/booleans.rs @@ -84,9 +84,9 @@ struct Hir2Qmm<'a, 'tcx: 'a, 'v> { } impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> { - fn extract(&mut self, op: BinOp_, a: &[&'v Expr], mut v: Vec) -> Result, String> { + fn extract(&mut self, op: BinOpKind, a: &[&'v Expr], mut v: Vec) -> Result, String> { for a in a { - if let ExprBinary(binop, ref lhs, ref rhs) = a.node { + if let ExprKind::Binary(binop, ref lhs, ref rhs) = a.node { if binop.node == op { v = self.extract(op, &[lhs, rhs], v)?; continue; @@ -101,13 +101,13 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> { // prevent folding of `cfg!` macros and the like if !in_macro(e.span) { match e.node { - ExprUnary(UnNot, ref inner) => return Ok(Bool::Not(box self.run(inner)?)), - ExprBinary(binop, ref lhs, ref rhs) => match binop.node { - BiOr => return Ok(Bool::Or(self.extract(BiOr, &[lhs, rhs], Vec::new())?)), - BiAnd => return Ok(Bool::And(self.extract(BiAnd, &[lhs, rhs], Vec::new())?)), + ExprKind::Unary(UnNot, ref inner) => return Ok(Bool::Not(box self.run(inner)?)), + ExprKind::Binary(binop, ref lhs, ref rhs) => match binop.node { + BinOpKind::Or => return Ok(Bool::Or(self.extract(BinOpKind::Or, &[lhs, rhs], Vec::new())?)), + BinOpKind::And => return Ok(Bool::And(self.extract(BinOpKind::And, &[lhs, rhs], Vec::new())?)), _ => (), }, - ExprLit(ref lit) => match lit.node { + ExprKind::Lit(ref lit) => match lit.node { LitKind::Bool(true) => return Ok(Bool::True), LitKind::Bool(false) => return Ok(Bool::False), _ => (), @@ -121,8 +121,8 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> { return Ok(Bool::Term(n as u8)); } let negated = match e.node { - ExprBinary(binop, ref lhs, ref rhs) => { - + ExprKind::Binary(binop, ref lhs, ref rhs) => { + if !implements_ord(self.cx, lhs) { continue; } @@ -133,16 +133,16 @@ impl<'a, 'tcx, 'v> Hir2Qmm<'a, 'tcx, 'v> { hir_id: DUMMY_HIR_ID, span: DUMMY_SP, attrs: ThinVec::new(), - node: ExprBinary(dummy_spanned(op), lhs.clone(), rhs.clone()), + node: ExprKind::Binary(dummy_spanned(op), lhs.clone(), rhs.clone()), } }; match binop.node { - BiEq => mk_expr(BiNe), - BiNe => mk_expr(BiEq), - BiGt => mk_expr(BiLe), - BiGe => mk_expr(BiLt), - BiLt => mk_expr(BiGe), - BiLe => mk_expr(BiGt), + BinOpKind::Eq => mk_expr(BinOpKind::Ne), + BinOpKind::Ne => mk_expr(BinOpKind::Eq), + BinOpKind::Gt => mk_expr(BinOpKind::Le), + BinOpKind::Ge => mk_expr(BinOpKind::Lt), + BinOpKind::Lt => mk_expr(BinOpKind::Ge), + BinOpKind::Le => mk_expr(BinOpKind::Gt), _ => continue, } }, @@ -178,23 +178,23 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> { fn simplify_not(&self, expr: &Expr) -> Option { match expr.node { - ExprBinary(binop, ref lhs, ref rhs) => { + ExprKind::Binary(binop, ref lhs, ref rhs) => { if !implements_ord(self.cx, lhs) { return None; } match binop.node { - BiEq => Some(" != "), - BiNe => Some(" == "), - BiLt => Some(" >= "), - BiGt => Some(" <= "), - BiLe => Some(" > "), - BiGe => Some(" < "), + BinOpKind::Eq => Some(" != "), + BinOpKind::Ne => Some(" == "), + BinOpKind::Lt => Some(" >= "), + BinOpKind::Gt => Some(" <= "), + BinOpKind::Le => Some(" > "), + BinOpKind::Ge => Some(" < "), _ => None, }.and_then(|op| Some(format!("{}{}{}", self.snip(lhs)?, op, self.snip(rhs)?))) }, - ExprMethodCall(ref path, _, ref args) if args.len() == 1 => { + ExprKind::MethodCall(ref path, _, ref args) if args.len() == 1 => { let type_of_receiver = self.cx.tables.expr_ty(&args[0]); if !match_type(self.cx, type_of_receiver, &paths::OPTION) && !match_type(self.cx, type_of_receiver, &paths::RESULT) { @@ -441,8 +441,8 @@ impl<'a, 'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'a, 'tcx> { return; } match e.node { - ExprBinary(binop, _, _) if binop.node == BiOr || binop.node == BiAnd => self.bool_expr(e), - ExprUnary(UnNot, ref inner) => if self.cx.tables.node_types()[inner.hir_id].is_bool() { + ExprKind::Binary(binop, _, _) if binop.node == BinOpKind::Or || binop.node == BinOpKind::And => self.bool_expr(e), + ExprKind::Unary(UnNot, ref inner) => if self.cx.tables.node_types()[inner.hir_id].is_bool() { self.bool_expr(e); } else { walk_expr(self, e); diff --git a/clippy_lints/src/bytecount.rs b/clippy_lints/src/bytecount.rs index 6f2ea320f932..aaa924e95b1e 100644 --- a/clippy_lints/src/bytecount.rs +++ b/clippy_lints/src/bytecount.rs @@ -38,20 +38,20 @@ impl LintPass for ByteCount { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount { fn check_expr(&mut self, cx: &LateContext, expr: &Expr) { if_chain! { - if let ExprMethodCall(ref count, _, ref count_args) = expr.node; + if let ExprKind::MethodCall(ref count, _, ref count_args) = expr.node; if count.ident.name == "count"; if count_args.len() == 1; - if let ExprMethodCall(ref filter, _, ref filter_args) = count_args[0].node; + if let ExprKind::MethodCall(ref filter, _, ref filter_args) = count_args[0].node; if filter.ident.name == "filter"; if filter_args.len() == 2; - if let ExprClosure(_, _, body_id, _, _) = filter_args[1].node; + if let ExprKind::Closure(_, _, body_id, _, _) = filter_args[1].node; then { let body = cx.tcx.hir.body(body_id); if_chain! { if body.arguments.len() == 1; if let Some(argname) = get_pat_name(&body.arguments[0].pat); - if let ExprBinary(ref op, ref l, ref r) = body.value.node; - if op.node == BiEq; + if let ExprKind::Binary(ref op, ref l, ref r) = body.value.node; + if op.node == BinOpKind::Eq; if match_type(cx, walk_ptrs_ty(cx.tables.expr_ty(&filter_args[0])), &paths::SLICE_ITER); @@ -66,7 +66,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ByteCount { if ty::TyUint(UintTy::U8) != walk_ptrs_ty(cx.tables.expr_ty(needle)).sty { return; } - let haystack = if let ExprMethodCall(ref path, _, ref args) = + let haystack = if let ExprKind::MethodCall(ref path, _, ref args) = filter_args[0].node { let p = path.ident.name; if (p == "iter" || p == "iter_mut") && args.len() == 1 { @@ -98,13 +98,13 @@ fn check_arg(name: Name, arg: Name, needle: &Expr) -> bool { fn get_path_name(expr: &Expr) -> Option { match expr.node { - ExprBox(ref e) | ExprAddrOf(_, ref e) | ExprUnary(UnOp::UnDeref, ref e) => get_path_name(e), - ExprBlock(ref b, _) => if b.stmts.is_empty() { + ExprKind::Box(ref e) | ExprKind::AddrOf(_, ref e) | ExprKind::Unary(UnOp::UnDeref, ref e) => get_path_name(e), + ExprKind::Block(ref b, _) => if b.stmts.is_empty() { b.expr.as_ref().and_then(|p| get_path_name(p)) } else { None }, - ExprPath(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name), + ExprKind::Path(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name), _ => None, } } diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs index 6fc6637900df..d7323337f247 100644 --- a/clippy_lints/src/consts.rs +++ b/clippy_lints/src/consts.rs @@ -211,25 +211,25 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { /// simple constant folding: Insert an expression, get a constant or none. pub fn expr(&mut self, e: &Expr) -> Option { match e.node { - ExprPath(ref qpath) => self.fetch_path(qpath, e.hir_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, self.tables.expr_ty(e))), - ExprArray(ref vec) => self.multi(vec).map(Constant::Vec), - ExprTup(ref tup) => self.multi(tup).map(Constant::Tuple), - ExprRepeat(ref value, _) => { + ExprKind::Path(ref qpath) => self.fetch_path(qpath, e.hir_id), + ExprKind::Block(ref block, _) => self.block(block), + ExprKind::If(ref cond, ref then, ref otherwise) => self.ifthenelse(cond, then, otherwise), + ExprKind::Lit(ref lit) => Some(lit_to_constant(&lit.node, self.tables.expr_ty(e))), + ExprKind::Array(ref vec) => self.multi(vec).map(Constant::Vec), + ExprKind::Tup(ref tup) => self.multi(tup).map(Constant::Tuple), + ExprKind::Repeat(ref value, _) => { let n = match self.tables.expr_ty(e).sty { ty::TyArray(_, n) => n.assert_usize(self.tcx).expect("array length"), _ => span_bug!(e.span, "typeck error"), }; self.expr(value).map(|v| Constant::Repeat(Box::new(v), n as u64)) }, - ExprUnary(op, ref operand) => self.expr(operand).and_then(|o| match op { + ExprKind::Unary(op, ref operand) => self.expr(operand).and_then(|o| match op { UnNot => self.constant_not(&o, self.tables.expr_ty(e)), UnNeg => self.constant_negate(&o, self.tables.expr_ty(e)), UnDeref => Some(o), }), - ExprBinary(op, ref left, ref right) => self.binop(op, left, right), + ExprKind::Binary(op, ref left, ref right) => self.binop(op, left, right), // TODO: add other expressions _ => None, } @@ -279,7 +279,7 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { .collect::>() } - /// lookup a possibly constant expression from a ExprPath + /// lookup a possibly constant expression from a ExprKind::Path fn fetch_path(&mut self, qpath: &QPath, id: HirId) -> Option { let def = self.tables.qpath_def(qpath, id); match def { @@ -340,43 +340,43 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { let r = sext(self.tcx, r, ity); let zext = |n: i128| Constant::Int(unsext(self.tcx, n, ity)); match op.node { - BiAdd => l.checked_add(r).map(zext), - BiSub => l.checked_sub(r).map(zext), - BiMul => l.checked_mul(r).map(zext), - BiDiv if r != 0 => l.checked_div(r).map(zext), - BiRem if r != 0 => l.checked_rem(r).map(zext), - BiShr => l.checked_shr(r as u128 as u32).map(zext), - BiShl => l.checked_shl(r as u128 as u32).map(zext), - BiBitXor => Some(zext(l ^ r)), - BiBitOr => Some(zext(l | r)), - BiBitAnd => Some(zext(l & r)), - BiEq => Some(Constant::Bool(l == r)), - BiNe => Some(Constant::Bool(l != r)), - BiLt => Some(Constant::Bool(l < r)), - BiLe => Some(Constant::Bool(l <= r)), - BiGe => Some(Constant::Bool(l >= r)), - BiGt => Some(Constant::Bool(l > r)), + BinOpKind::Add => l.checked_add(r).map(zext), + BinOpKind::Sub => l.checked_sub(r).map(zext), + BinOpKind::Mul => l.checked_mul(r).map(zext), + BinOpKind::Div if r != 0 => l.checked_div(r).map(zext), + BinOpKind::Rem if r != 0 => l.checked_rem(r).map(zext), + BinOpKind::Shr => l.checked_shr(r as u128 as u32).map(zext), + BinOpKind::Shl => l.checked_shl(r as u128 as u32).map(zext), + BinOpKind::BitXor => Some(zext(l ^ r)), + BinOpKind::BitOr => Some(zext(l | r)), + BinOpKind::BitAnd => Some(zext(l & r)), + BinOpKind::Eq => Some(Constant::Bool(l == r)), + BinOpKind::Ne => Some(Constant::Bool(l != r)), + BinOpKind::Lt => Some(Constant::Bool(l < r)), + BinOpKind::Le => Some(Constant::Bool(l <= r)), + BinOpKind::Ge => Some(Constant::Bool(l >= r)), + BinOpKind::Gt => Some(Constant::Bool(l > r)), _ => None, } } ty::TyUint(_) => { match op.node { - BiAdd => l.checked_add(r).map(Constant::Int), - BiSub => l.checked_sub(r).map(Constant::Int), - BiMul => l.checked_mul(r).map(Constant::Int), - BiDiv => l.checked_div(r).map(Constant::Int), - BiRem => l.checked_rem(r).map(Constant::Int), - BiShr => l.checked_shr(r as u32).map(Constant::Int), - BiShl => l.checked_shl(r as u32).map(Constant::Int), - BiBitXor => Some(Constant::Int(l ^ r)), - BiBitOr => Some(Constant::Int(l | r)), - BiBitAnd => Some(Constant::Int(l & r)), - BiEq => Some(Constant::Bool(l == r)), - BiNe => Some(Constant::Bool(l != r)), - BiLt => Some(Constant::Bool(l < r)), - BiLe => Some(Constant::Bool(l <= r)), - BiGe => Some(Constant::Bool(l >= r)), - BiGt => Some(Constant::Bool(l > r)), + BinOpKind::Add => l.checked_add(r).map(Constant::Int), + BinOpKind::Sub => l.checked_sub(r).map(Constant::Int), + BinOpKind::Mul => l.checked_mul(r).map(Constant::Int), + BinOpKind::Div => l.checked_div(r).map(Constant::Int), + BinOpKind::Rem => l.checked_rem(r).map(Constant::Int), + BinOpKind::Shr => l.checked_shr(r as u32).map(Constant::Int), + BinOpKind::Shl => l.checked_shl(r as u32).map(Constant::Int), + BinOpKind::BitXor => Some(Constant::Int(l ^ r)), + BinOpKind::BitOr => Some(Constant::Int(l | r)), + BinOpKind::BitAnd => Some(Constant::Int(l & r)), + BinOpKind::Eq => Some(Constant::Bool(l == r)), + BinOpKind::Ne => Some(Constant::Bool(l != r)), + BinOpKind::Lt => Some(Constant::Bool(l < r)), + BinOpKind::Le => Some(Constant::Bool(l <= r)), + BinOpKind::Ge => Some(Constant::Bool(l >= r)), + BinOpKind::Gt => Some(Constant::Bool(l > r)), _ => None, } }, @@ -384,40 +384,40 @@ impl<'c, 'cc> ConstEvalLateContext<'c, 'cc> { } }, (Constant::F32(l), Some(Constant::F32(r))) => match op.node { - BiAdd => Some(Constant::F32(l + r)), - BiSub => Some(Constant::F32(l - r)), - BiMul => Some(Constant::F32(l * r)), - BiDiv => Some(Constant::F32(l / r)), - BiRem => Some(Constant::F32(l % r)), - BiEq => Some(Constant::Bool(l == r)), - BiNe => Some(Constant::Bool(l != r)), - BiLt => Some(Constant::Bool(l < r)), - BiLe => Some(Constant::Bool(l <= r)), - BiGe => Some(Constant::Bool(l >= r)), - BiGt => Some(Constant::Bool(l > r)), + BinOpKind::Add => Some(Constant::F32(l + r)), + BinOpKind::Sub => Some(Constant::F32(l - r)), + BinOpKind::Mul => Some(Constant::F32(l * r)), + BinOpKind::Div => Some(Constant::F32(l / r)), + BinOpKind::Rem => Some(Constant::F32(l % r)), + BinOpKind::Eq => Some(Constant::Bool(l == r)), + BinOpKind::Ne => Some(Constant::Bool(l != r)), + BinOpKind::Lt => Some(Constant::Bool(l < r)), + BinOpKind::Le => Some(Constant::Bool(l <= r)), + BinOpKind::Ge => Some(Constant::Bool(l >= r)), + BinOpKind::Gt => Some(Constant::Bool(l > r)), _ => None, }, (Constant::F64(l), Some(Constant::F64(r))) => match op.node { - BiAdd => Some(Constant::F64(l + r)), - BiSub => Some(Constant::F64(l - r)), - BiMul => Some(Constant::F64(l * r)), - BiDiv => Some(Constant::F64(l / r)), - BiRem => Some(Constant::F64(l % r)), - BiEq => Some(Constant::Bool(l == r)), - BiNe => Some(Constant::Bool(l != r)), - BiLt => Some(Constant::Bool(l < r)), - BiLe => Some(Constant::Bool(l <= r)), - BiGe => Some(Constant::Bool(l >= r)), - BiGt => Some(Constant::Bool(l > r)), + BinOpKind::Add => Some(Constant::F64(l + r)), + BinOpKind::Sub => Some(Constant::F64(l - r)), + BinOpKind::Mul => Some(Constant::F64(l * r)), + BinOpKind::Div => Some(Constant::F64(l / r)), + BinOpKind::Rem => Some(Constant::F64(l % r)), + BinOpKind::Eq => Some(Constant::Bool(l == r)), + BinOpKind::Ne => Some(Constant::Bool(l != r)), + BinOpKind::Lt => Some(Constant::Bool(l < r)), + BinOpKind::Le => Some(Constant::Bool(l <= r)), + BinOpKind::Ge => Some(Constant::Bool(l >= r)), + BinOpKind::Gt => Some(Constant::Bool(l > r)), _ => None, }, (l, r) => match (op.node, l, r) { - (BiAnd, Constant::Bool(false), _) => Some(Constant::Bool(false)), - (BiOr, Constant::Bool(true), _) => Some(Constant::Bool(true)), - (BiAnd, Constant::Bool(true), Some(r)) | (BiOr, Constant::Bool(false), Some(r)) => Some(r), - (BiBitXor, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l ^ r)), - (BiBitAnd, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l & r)), - (BiBitOr, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l | r)), + (BinOpKind::And, Constant::Bool(false), _) => Some(Constant::Bool(false)), + (BinOpKind::Or, Constant::Bool(true), _) => Some(Constant::Bool(true)), + (BinOpKind::And, Constant::Bool(true), Some(r)) | (BinOpKind::Or, Constant::Bool(false), Some(r)) => Some(r), + (BinOpKind::BitXor, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l ^ r)), + (BinOpKind::BitAnd, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l & r)), + (BinOpKind::BitOr, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l | r)), _ => None, }, } diff --git a/clippy_lints/src/copies.rs b/clippy_lints/src/copies.rs index 430ff59cd4d3..9e9a641ce27e 100644 --- a/clippy_lints/src/copies.rs +++ b/clippy_lints/src/copies.rs @@ -115,7 +115,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for CopyAndPaste { if !in_macro(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)), + node: ExprKind::If(_, _, Some(ref else_expr)), .. }) = get_parent_expr(cx, expr) { @@ -172,7 +172,7 @@ fn lint_same_cond(cx: &LateContext, conds: &[&Expr]) { /// Implementation of `MATCH_SAME_ARMS`. fn lint_match_arms(cx: &LateContext, expr: &Expr) { - if let ExprMatch(_, ref arms, MatchSource::Normal) = expr.node { + if let ExprKind::Match(_, ref arms, MatchSource::Normal) = expr.node { let hash = |&(_, arm): &(usize, &Arm)| -> u64 { let mut h = SpanlessHash::new(cx, cx.tables); h.hash_expr(&arm.body); @@ -236,12 +236,12 @@ fn if_sequence(mut expr: &Expr) -> (SmallVector<&Expr>, SmallVector<&Block>) { let mut conds = SmallVector::new(); let mut blocks: SmallVector<&Block> = SmallVector::new(); - while let ExprIf(ref cond, ref then_expr, ref else_expr) = expr.node { + while let ExprKind::If(ref cond, ref then_expr, ref else_expr) = expr.node { conds.push(&**cond); - if let ExprBlock(ref block, _) = then_expr.node { + if let ExprKind::Block(ref block, _) = then_expr.node { blocks.push(block); } else { - panic!("ExprIf node is not an ExprBlock"); + panic!("ExprKind::If node is not an ExprKind::Block"); } if let Some(ref else_expr) = *else_expr { @@ -253,7 +253,7 @@ fn if_sequence(mut expr: &Expr) -> (SmallVector<&Expr>, SmallVector<&Block>) { // final `else {..}` if !blocks.is_empty() { - if let ExprBlock(ref block, _) = expr.node { + if let ExprKind::Block(ref block, _) = expr.node { blocks.push(&**block); } } diff --git a/clippy_lints/src/cyclomatic_complexity.rs b/clippy_lints/src/cyclomatic_complexity.rs index ea5f5cf9b589..b1b667d046ca 100644 --- a/clippy_lints/src/cyclomatic_complexity.rs +++ b/clippy_lints/src/cyclomatic_complexity.rs @@ -147,14 +147,14 @@ struct CCHelper<'a, 'tcx: 'a> { impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> { fn visit_expr(&mut self, e: &'tcx Expr) { match e.node { - ExprMatch(_, ref arms, _) => { + ExprKind::Match(_, ref arms, _) => { walk_expr(self, e); let arms_n: u64 = arms.iter().map(|arm| arm.pats.len() as u64).sum(); if arms_n > 1 { self.match_arms += arms_n - 2; } }, - ExprCall(ref callee, _) => { + ExprKind::Call(ref callee, _) => { walk_expr(self, e); let ty = self.cx.tables.node_id_to_type(callee.hir_id); match ty.sty { @@ -167,15 +167,15 @@ impl<'a, 'tcx> Visitor<'tcx> for CCHelper<'a, 'tcx> { _ => (), } }, - ExprClosure(.., _) => (), - ExprBinary(op, _, _) => { + ExprKind::Closure(.., _) => (), + ExprKind::Binary(op, _, _) => { walk_expr(self, e); match op.node { - BiAnd | BiOr => self.short_circuits += 1, + BinOpKind::And | BinOpKind::Or => self.short_circuits += 1, _ => (), } }, - ExprRet(_) => self.returns += 1, + ExprKind::Ret(_) => self.returns += 1, _ => walk_expr(self, e), } } diff --git a/clippy_lints/src/default_trait_access.rs b/clippy_lints/src/default_trait_access.rs index 30dcafc2daf1..900dabc96505 100644 --- a/clippy_lints/src/default_trait_access.rs +++ b/clippy_lints/src/default_trait_access.rs @@ -38,9 +38,9 @@ impl LintPass for DefaultTraitAccess { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DefaultTraitAccess { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_chain! { - if let ExprCall(ref path, ..) = expr.node; + if let ExprKind::Call(ref path, ..) = expr.node; if !any_parent_is_automatically_derived(cx.tcx, expr.id); - if let ExprPath(ref qpath) = path.node; + if let ExprKind::Path(ref qpath) = path.node; if let Some(def_id) = opt_def_id(cx.tables.qpath_def(qpath, path.hir_id)); if match_def_path(cx.tcx, def_id, &paths::DEFAULT_TRAIT_METHOD); then { diff --git a/clippy_lints/src/derive.rs b/clippy_lints/src/derive.rs index 364c019c486c..0d0eb27fb7db 100644 --- a/clippy_lints/src/derive.rs +++ b/clippy_lints/src/derive.rs @@ -70,7 +70,7 @@ impl LintPass for Derive { 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 { + if let ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) = item.node { let ty = cx.tcx.type_of(cx.tcx.hir.local_def_id(item.id)); let is_automatically_derived = is_automatically_derived(&*item.attrs); diff --git a/clippy_lints/src/double_comparison.rs b/clippy_lints/src/double_comparison.rs index ba398c820647..e2ea5723a98e 100644 --- a/clippy_lints/src/double_comparison.rs +++ b/clippy_lints/src/double_comparison.rs @@ -41,13 +41,13 @@ impl<'a, 'tcx> DoubleComparisonPass { fn check_binop( &self, cx: &LateContext<'a, 'tcx>, - op: BinOp_, + op: BinOpKind, lhs: &'tcx Expr, rhs: &'tcx Expr, span: Span, ) { let (lkind, llhs, lrhs, rkind, rlhs, rrhs) = match (lhs.node.clone(), rhs.node.clone()) { - (ExprBinary(lb, llhs, lrhs), ExprBinary(rb, rlhs, rrhs)) => { + (ExprKind::Binary(lb, llhs, lrhs), ExprKind::Binary(rb, rlhs, rrhs)) => { (lb.node, llhs, lrhs, rb.node, rlhs, rrhs) } _ => return, @@ -67,10 +67,10 @@ impl<'a, 'tcx> DoubleComparisonPass { }} } match (op, lkind, rkind) { - (BiOr, BiEq, BiLt) | (BiOr, BiLt, BiEq) => lint_double_comparison!(<=), - (BiOr, BiEq, BiGt) | (BiOr, BiGt, BiEq) => lint_double_comparison!(>=), - (BiOr, BiLt, BiGt) | (BiOr, BiGt, BiLt) => lint_double_comparison!(!=), - (BiAnd, BiLe, BiGe) | (BiAnd, BiGe, BiLe) => lint_double_comparison!(==), + (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Lt) | (BinOpKind::Or, BinOpKind::Lt, BinOpKind::Eq) => lint_double_comparison!(<=), + (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Gt) | (BinOpKind::Or, BinOpKind::Gt, BinOpKind::Eq) => lint_double_comparison!(>=), + (BinOpKind::Or, BinOpKind::Lt, BinOpKind::Gt) | (BinOpKind::Or, BinOpKind::Gt, BinOpKind::Lt) => lint_double_comparison!(!=), + (BinOpKind::And, BinOpKind::Le, BinOpKind::Ge) | (BinOpKind::And, BinOpKind::Ge, BinOpKind::Le) => lint_double_comparison!(==), _ => (), }; } @@ -78,7 +78,7 @@ impl<'a, 'tcx> DoubleComparisonPass { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DoubleComparisonPass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { - if let ExprBinary(ref kind, ref lhs, ref rhs) = expr.node { + if let ExprKind::Binary(ref kind, ref lhs, ref rhs) = expr.node { self.check_binop(cx, kind.node, lhs, rhs, expr.span); } } diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs index eb271a899c47..b0625e10d761 100644 --- a/clippy_lints/src/drop_forget_ref.rs +++ b/clippy_lints/src/drop_forget_ref.rs @@ -116,8 +116,8 @@ impl LintPass for Pass { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_chain! { - if let ExprCall(ref path, ref args) = expr.node; - if let ExprPath(ref qpath) = path.node; + if let ExprKind::Call(ref path, ref args) = expr.node; + if let ExprKind::Path(ref qpath) = path.node; if args.len() == 1; if let Some(def_id) = opt_def_id(cx.tables.qpath_def(qpath, path.hir_id)); then { diff --git a/clippy_lints/src/duration_subsec.rs b/clippy_lints/src/duration_subsec.rs index 16b94d24b16a..d374973e35b4 100644 --- a/clippy_lints/src/duration_subsec.rs +++ b/clippy_lints/src/duration_subsec.rs @@ -38,8 +38,8 @@ impl LintPass for DurationSubsec { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for DurationSubsec { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_chain! { - if let ExprBinary(Spanned { node: BiDiv, .. }, ref left, ref right) = expr.node; - if let ExprMethodCall(ref method_path, _ , ref args) = left.node; + if let ExprKind::Binary(Spanned { node: BinOpKind::Div, .. }, ref left, ref right) = expr.node; + if let ExprKind::MethodCall(ref method_path, _ , ref args) = left.node; if match_type(cx, walk_ptrs_ty(cx.tables.expr_ty(&args[0])), &paths::DURATION); if let Some((Constant::Int(divisor), _)) = constant(cx, cx.tables, right); then { diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs index 3265338ce12c..1ca32cf2263e 100644 --- a/clippy_lints/src/empty_enum.rs +++ b/clippy_lints/src/empty_enum.rs @@ -34,7 +34,7 @@ impl LintPass for EmptyEnum { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EmptyEnum { fn check_item(&mut self, cx: &LateContext, item: &Item) { let did = cx.tcx.hir.local_def_id(item.id); - if let ItemEnum(..) = item.node { + if let ItemKind::Enum(..) = item.node { let ty = cx.tcx.type_of(did); let adt = ty.ty_adt_def() .expect("already checked whether this is an enum"); diff --git a/clippy_lints/src/entry.rs b/clippy_lints/src/entry.rs index 13c75f39bb89..f29c2d1bb6d0 100644 --- a/clippy_lints/src/entry.rs +++ b/clippy_lints/src/entry.rs @@ -41,13 +41,13 @@ impl LintPass for HashMapLint { 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 ExprKind::If(ref check, ref then_block, ref else_block) = expr.node { + if let ExprKind::Unary(UnOp::UnNot, ref check) = check.node { if let Some((ty, map, key)) = check_cond(cx, check) { // in case of `if !m.contains_key(&k) { m.insert(k, v); }` // we can give a better error message let sole_expr = { - else_block.is_none() && if let ExprBlock(ref then_block, _) = then_block.node { + else_block.is_none() && if let ExprKind::Block(ref then_block, _) = then_block.node { (then_block.expr.is_some() as usize) + then_block.stmts.len() == 1 } else { true @@ -88,10 +88,10 @@ fn check_cond<'a, 'tcx, 'b>( check: &'b Expr, ) -> Option<(&'static str, &'b Expr, &'b Expr)> { if_chain! { - if let ExprMethodCall(ref path, _, ref params) = check.node; + if let ExprKind::MethodCall(ref path, _, ref params) = check.node; if params.len() >= 2; if path.ident.name == "contains_key"; - if let ExprAddrOf(_, ref key) = params[1].node; + if let ExprKind::AddrOf(_, ref key) = params[1].node; then { let map = ¶ms[0]; let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(map)); @@ -123,7 +123,7 @@ struct InsertVisitor<'a, 'tcx: 'a, 'b> { impl<'a, 'tcx, 'b> Visitor<'tcx> for InsertVisitor<'a, 'tcx, 'b> { fn visit_expr(&mut self, expr: &'tcx Expr) { if_chain! { - if let ExprMethodCall(ref path, _, ref params) = expr.node; + if let ExprKind::MethodCall(ref path, _, ref params) = expr.node; if params.len() == 3; if path.ident.name == "insert"; if get_item_name(self.cx, self.map) == get_item_name(self.cx, ¶ms[0]); diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs index f191150f3e79..6584bc6ffa95 100644 --- a/clippy_lints/src/enum_clike.rs +++ b/clippy_lints/src/enum_clike.rs @@ -47,7 +47,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnportableVariant { if cx.tcx.data_layout.pointer_size.bits() != 64 { return; } - if let ItemEnum(ref def, _) = item.node { + if let ItemKind::Enum(ref def, _) = item.node { for var in &def.variants { let variant = &var.node; if let Some(ref anon_const) = variant.disr_expr { diff --git a/clippy_lints/src/enum_glob_use.rs b/clippy_lints/src/enum_glob_use.rs index e90dc6f693a3..042a96a21c85 100644 --- a/clippy_lints/src/enum_glob_use.rs +++ b/clippy_lints/src/enum_glob_use.rs @@ -47,7 +47,7 @@ impl EnumGlobUse { if item.vis.node.is_pub() { return; // re-exports are fine } - if let ItemUse(ref path, UseKind::Glob) = item.node { + if let ItemKind::Use(ref path, UseKind::Glob) = item.node { if let Def::Enum(_) = path.def { span_lint( cx, diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs index 19761fbe8649..f58b499d8065 100644 --- a/clippy_lints/src/eq_op.rs +++ b/clippy_lints/src/eq_op.rs @@ -52,7 +52,7 @@ impl LintPass for EqOp { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { - if let ExprBinary(op, ref left, ref right) = e.node { + if let ExprKind::Binary(op, ref left, ref right) = e.node { if in_macro(e.span) { return; } @@ -66,28 +66,28 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp { return; } let (trait_id, requires_ref) = match op.node { - BiAdd => (cx.tcx.lang_items().add_trait(), false), - BiSub => (cx.tcx.lang_items().sub_trait(), false), - BiMul => (cx.tcx.lang_items().mul_trait(), false), - BiDiv => (cx.tcx.lang_items().div_trait(), false), - BiRem => (cx.tcx.lang_items().rem_trait(), false), + BinOpKind::Add => (cx.tcx.lang_items().add_trait(), false), + BinOpKind::Sub => (cx.tcx.lang_items().sub_trait(), false), + BinOpKind::Mul => (cx.tcx.lang_items().mul_trait(), false), + BinOpKind::Div => (cx.tcx.lang_items().div_trait(), false), + BinOpKind::Rem => (cx.tcx.lang_items().rem_trait(), false), // don't lint short circuiting ops - BiAnd | BiOr => return, - BiBitXor => (cx.tcx.lang_items().bitxor_trait(), false), - BiBitAnd => (cx.tcx.lang_items().bitand_trait(), false), - BiBitOr => (cx.tcx.lang_items().bitor_trait(), false), - BiShl => (cx.tcx.lang_items().shl_trait(), false), - BiShr => (cx.tcx.lang_items().shr_trait(), false), - BiNe | BiEq => (cx.tcx.lang_items().eq_trait(), true), - BiLt | BiLe | BiGe | BiGt => (cx.tcx.lang_items().ord_trait(), true), + BinOpKind::And | BinOpKind::Or => return, + BinOpKind::BitXor => (cx.tcx.lang_items().bitxor_trait(), false), + BinOpKind::BitAnd => (cx.tcx.lang_items().bitand_trait(), false), + BinOpKind::BitOr => (cx.tcx.lang_items().bitor_trait(), false), + BinOpKind::Shl => (cx.tcx.lang_items().shl_trait(), false), + BinOpKind::Shr => (cx.tcx.lang_items().shr_trait(), false), + BinOpKind::Ne | BinOpKind::Eq => (cx.tcx.lang_items().eq_trait(), true), + BinOpKind::Lt | BinOpKind::Le | BinOpKind::Ge | BinOpKind::Gt => (cx.tcx.lang_items().ord_trait(), true), }; if let Some(trait_id) = trait_id { #[allow(match_same_arms)] match (&left.node, &right.node) { // do not suggest to dereference literals - (&ExprLit(..), _) | (_, &ExprLit(..)) => {}, + (&ExprKind::Lit(..), _) | (_, &ExprKind::Lit(..)) => {}, // &foo == &bar - (&ExprAddrOf(_, ref l), &ExprAddrOf(_, ref r)) => { + (&ExprKind::AddrOf(_, ref l), &ExprKind::AddrOf(_, ref r)) => { let lty = cx.tables.expr_ty(l); let rty = cx.tables.expr_ty(r); let lcpy = is_copy(cx, lty); @@ -128,7 +128,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp { } }, // &foo == bar - (&ExprAddrOf(_, ref l), _) => { + (&ExprKind::AddrOf(_, ref l), _) => { let lty = cx.tables.expr_ty(l); let lcpy = is_copy(cx, lty); if (requires_ref || lcpy) && implements_trait(cx, lty, trait_id, &[cx.tables.expr_ty(right).into()]) { @@ -139,7 +139,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp { } }, // foo == &bar - (_, &ExprAddrOf(_, ref r)) => { + (_, &ExprKind::AddrOf(_, ref r)) => { let rty = cx.tables.expr_ty(r); let rcpy = is_copy(cx, rty); if (requires_ref || rcpy) && implements_trait(cx, cx.tables.expr_ty(left), trait_id, &[rty.into()]) { @@ -159,7 +159,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp { fn is_valid_operator(op: BinOp) -> bool { match op.node { - BiSub | BiDiv | BiEq | BiLt | BiLe | BiGt | BiGe | BiNe | BiAnd | BiOr | BiBitXor | BiBitAnd | BiBitOr => true, + BinOpKind::Sub | BinOpKind::Div | BinOpKind::Eq | BinOpKind::Lt | BinOpKind::Le | BinOpKind::Gt | BinOpKind::Ge | BinOpKind::Ne | BinOpKind::And | BinOpKind::Or | BinOpKind::BitXor | BinOpKind::BitAnd | BinOpKind::BitOr => true, _ => false, } } diff --git a/clippy_lints/src/erasing_op.rs b/clippy_lints/src/erasing_op.rs index faf297fd5b25..acede5d1a132 100644 --- a/clippy_lints/src/erasing_op.rs +++ b/clippy_lints/src/erasing_op.rs @@ -36,13 +36,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ErasingOp { if in_macro(e.span) { return; } - if let ExprBinary(ref cmp, ref left, ref right) = e.node { + if let ExprKind::Binary(ref cmp, ref left, ref right) = e.node { match cmp.node { - BiMul | BiBitAnd => { + BinOpKind::Mul | BinOpKind::BitAnd => { check(cx, left, e.span); check(cx, right, e.span); }, - BiDiv => check(cx, left, e.span), + BinOpKind::Div => check(cx, left, e.span), _ => (), } } diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs index c718e1f417c9..a03dc7b62690 100644 --- a/clippy_lints/src/escape.rs +++ b/clippy_lints/src/escape.rs @@ -110,10 +110,10 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> { if let Categorization::Rvalue(..) = cmt.cat { let id = map.hir_to_node_id(cmt.hir_id); if let Some(NodeStmt(st)) = map.find(map.get_parent_node(id)) { - if let StmtDecl(ref decl, _) = st.node { - if let DeclLocal(ref loc) = decl.node { + if let StmtKind::Decl(ref decl, _) = st.node { + if let DeclKind::Local(ref loc) = decl.node { if let Some(ref ex) = loc.init { - if let ExprBox(..) = ex.node { + if let ExprKind::Box(..) = ex.node { if is_non_trait_box(cmt.ty) && !self.is_large_box(cmt.ty) { // let x = box (...) self.set.insert(consume_pat.id); diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs index e924ba6bdbb7..87f0e64caafa 100644 --- a/clippy_lints/src/eta_reduction.rs +++ b/clippy_lints/src/eta_reduction.rs @@ -37,7 +37,7 @@ impl LintPass for EtaPass { 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) => for arg in args { + ExprKind::Call(_, ref args) | ExprKind::MethodCall(_, _, ref args) => for arg in args { check_closure(cx, arg) }, _ => (), @@ -46,10 +46,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EtaPass { } fn check_closure(cx: &LateContext, expr: &Expr) { - if let ExprClosure(_, ref decl, eid, _, _) = expr.node { + if let ExprKind::Closure(_, ref decl, eid, _, _) = expr.node { let body = cx.tcx.hir.body(eid); let ex = &body.value; - if let ExprCall(ref caller, ref args) = ex.node { + if let ExprKind::Call(ref caller, ref args) = ex.node { if args.len() != decl.inputs.len() { // Not the same number of arguments, there // is no way the closure is the same as the function @@ -73,7 +73,7 @@ fn check_closure(cx: &LateContext, expr: &Expr) { for (a1, a2) in iter_input_pats(decl, body).zip(args) { if let PatKind::Binding(_, _, ident, _) = a1.pat.node { // XXXManishearth Should I be checking the binding mode here? - if let ExprPath(QPath::Resolved(None, ref p)) = a2.node { + if let ExprKind::Path(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 d773289263ef..58436bd897bb 100644 --- a/clippy_lints/src/eval_order_dependence.rs +++ b/clippy_lints/src/eval_order_dependence.rs @@ -62,7 +62,7 @@ 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, _) => if let ExprPath(ref qpath) = lhs.node { + ExprKind::Assign(ref lhs, _) | ExprKind::AssignOp(_, ref lhs, _) => if let ExprKind::Path(ref qpath) = lhs.node { if let QPath::Resolved(_, ref path) = *qpath { if path.segments.len() == 1 { if let def::Def::Local(var) = cx.tables.qpath_def(qpath, lhs.hir_id) { @@ -82,8 +82,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence { } fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) { match stmt.node { - StmtExpr(ref e, _) | StmtSemi(ref e, _) => DivergenceVisitor { cx }.maybe_walk_expr(e), - StmtDecl(ref d, _) => if let DeclLocal(ref local) = d.node { + StmtKind::Expr(ref e, _) | StmtKind::Semi(ref e, _) => DivergenceVisitor { cx }.maybe_walk_expr(e), + StmtKind::Decl(ref d, _) => if let DeclKind::Local(ref local) = d.node { if let Local { init: Some(ref e), .. } = **local @@ -102,8 +102,8 @@ struct DivergenceVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> { fn maybe_walk_expr(&mut self, e: &'tcx Expr) { match e.node { - ExprClosure(.., _) => {}, - ExprMatch(ref e, ref arms, _) => { + ExprKind::Closure(.., _) => {}, + ExprKind::Match(ref e, ref arms, _) => { self.visit_expr(e); for arm in arms { if let Some(ref guard) = arm.guard { @@ -124,8 +124,8 @@ impl<'a, 'tcx> DivergenceVisitor<'a, 'tcx> { impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> { fn visit_expr(&mut self, e: &'tcx Expr) { match e.node { - ExprContinue(_) | ExprBreak(_, _) | ExprRet(_) => self.report_diverging_sub_expr(e), - ExprCall(ref func, _) => { + ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => self.report_diverging_sub_expr(e), + ExprKind::Call(ref func, _) => { let typ = self.cx.tables.expr_ty(func); match typ.sty { ty::TyFnDef(..) | ty::TyFnPtr(_) => { @@ -137,7 +137,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> { _ => {}, } }, - ExprMethodCall(..) => { + ExprKind::MethodCall(..) => { let borrowed_table = self.cx.tables; if borrowed_table.expr_ty(e).is_never() { self.report_diverging_sub_expr(e); @@ -218,25 +218,25 @@ fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> St } match expr.node { - ExprArray(_) | - ExprTup(_) | - ExprMethodCall(..) | - ExprCall(_, _) | - ExprAssign(_, _) | - ExprIndex(_, _) | - ExprRepeat(_, _) | - ExprStruct(_, _, _) => { + ExprKind::Array(_) | + ExprKind::Tup(_) | + ExprKind::MethodCall(..) | + ExprKind::Call(_, _) | + ExprKind::Assign(_, _) | + ExprKind::Index(_, _) | + ExprKind::Repeat(_, _) | + ExprKind::Struct(_, _, _) => { walk_expr(vis, expr); }, - ExprBinary(op, _, _) | ExprAssignOp(op, _, _) => { - if op.node == BiAnd || op.node == BiOr { + ExprKind::Binary(op, _, _) | ExprKind::AssignOp(op, _, _) => { + if op.node == BinOpKind::And || op.node == BinOpKind::Or { // x && y and x || y always evaluate x first, so these are // strictly sequenced. } else { walk_expr(vis, expr); } }, - ExprClosure(_, _, _, _, _) => { + ExprKind::Closure(_, _, _, _, _) => { // Either // // * `var` is defined in the closure body, in which case we've @@ -262,12 +262,12 @@ fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> St 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), - StmtDecl(ref decl, _) => { + StmtKind::Expr(ref expr, _) | StmtKind::Semi(ref expr, _) => check_expr(vis, expr), + StmtKind::Decl(ref decl, _) => { // If the declaration is of a local variable, check its initializer // expression if it has one. Otherwise, keep going. let local = match decl.node { - DeclLocal(ref local) => Some(local), + DeclKind::Local(ref local) => Some(local), _ => None, }; local @@ -297,7 +297,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> { } match expr.node { - ExprPath(ref qpath) => { + ExprKind::Path(ref qpath) => { if_chain! { if let QPath::Resolved(None, ref path) = *qpath; if path.segments.len() == 1; @@ -320,7 +320,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> { // We're about to descend a closure. Since we don't know when (or // if) the closure will be evaluated, any reads in it might not // occur here (or ever). Like above, bail to avoid false positives. - ExprClosure(_, _, _, _, _) | + ExprKind::Closure(_, _, _, _, _) | // We want to avoid a false positive when a variable name occurs // only to have its address taken, so we stop here. Technically, @@ -332,7 +332,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> { // ``` // // TODO: fix this - ExprAddrOf(_, _) => { + ExprKind::AddrOf(_, _) => { return; } _ => {} @@ -348,7 +348,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> { /// Returns true if `expr` is the LHS of an assignment, like `expr = ...`. fn is_in_assignment_position(cx: &LateContext, expr: &Expr) -> bool { if let Some(parent) = get_parent_expr(cx, expr) { - if let ExprAssign(ref lhs, _) = parent.node { + if let ExprKind::Assign(ref lhs, _) = parent.node { return lhs.id == expr.id; } } diff --git a/clippy_lints/src/excessive_precision.rs b/clippy_lints/src/excessive_precision.rs index aa648003c0cc..24bbf6692059 100644 --- a/clippy_lints/src/excessive_precision.rs +++ b/clippy_lints/src/excessive_precision.rs @@ -45,7 +45,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ExcessivePrecision { if_chain! { let ty = cx.tables.expr_ty(expr); if let TypeVariants::TyFloat(fty) = ty.sty; - if let hir::ExprLit(ref lit) = expr.node; + if let hir::ExprKind::Lit(ref lit) = expr.node; if let LitKind::Float(sym, _) | LitKind::FloatUnsuffixed(sym) = lit.node; if let Some(sugg) = self.check(sym, fty); then { diff --git a/clippy_lints/src/explicit_write.rs b/clippy_lints/src/explicit_write.rs index 7c741100bde3..019d21f81e0e 100644 --- a/clippy_lints/src/explicit_write.rs +++ b/clippy_lints/src/explicit_write.rs @@ -35,17 +35,17 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_chain! { // match call to unwrap - if let ExprMethodCall(ref unwrap_fun, _, ref unwrap_args) = expr.node; + if let ExprKind::MethodCall(ref unwrap_fun, _, ref unwrap_args) = expr.node; if unwrap_fun.ident.name == "unwrap"; // match call to write_fmt if unwrap_args.len() > 0; - if let ExprMethodCall(ref write_fun, _, ref write_args) = + if let ExprKind::MethodCall(ref write_fun, _, ref write_args) = unwrap_args[0].node; if write_fun.ident.name == "write_fmt"; // match calls to std::io::stdout() / std::io::stderr () if write_args.len() > 0; - if let ExprCall(ref dest_fun, _) = write_args[0].node; - if let ExprPath(ref qpath) = dest_fun.node; + if let ExprKind::Call(ref dest_fun, _) = write_args[0].node; + if let ExprKind::Path(ref qpath) = dest_fun.node; if let Some(dest_fun_id) = opt_def_id(resolve_node(cx, qpath, dest_fun.hir_id)); if let Some(dest_name) = if match_def_path(cx.tcx, dest_fun_id, &["std", "io", "stdio", "stdout"]) { diff --git a/clippy_lints/src/fallible_impl_from.rs b/clippy_lints/src/fallible_impl_from.rs index 64cdc05b44de..1ea000d3611b 100644 --- a/clippy_lints/src/fallible_impl_from.rs +++ b/clippy_lints/src/fallible_impl_from.rs @@ -39,7 +39,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for FallibleImplFrom { // check for `impl From for ..` let impl_def_id = cx.tcx.hir.local_def_id(item.id); if_chain! { - if let hir::ItemImpl(.., ref impl_items) = item.node; + if let hir::ItemKind::Impl(.., ref impl_items) = item.node; if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_def_id); if match_def_path(cx.tcx, impl_trait_ref.def_id, &FROM_TRAIT); then { @@ -63,8 +63,8 @@ fn lint_impl_body<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, impl_span: Span, impl_it fn visit_expr(&mut self, expr: &'tcx Expr) { // check for `begin_panic` if_chain! { - if let ExprCall(ref func_expr, _) = expr.node; - if let ExprPath(QPath::Resolved(_, ref path)) = func_expr.node; + if let ExprKind::Call(ref func_expr, _) = expr.node; + if let ExprKind::Path(QPath::Resolved(_, ref path)) = func_expr.node; if let Some(path_def_id) = opt_def_id(path.def); if match_def_path(self.tcx, path_def_id, &BEGIN_PANIC) || match_def_path(self.tcx, path_def_id, &BEGIN_PANIC_FMT); diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs index 890fe51819aa..e88f03868939 100644 --- a/clippy_lints/src/format.rs +++ b/clippy_lints/src/format.rs @@ -46,9 +46,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { match expr.node { // `format!("{}", foo)` expansion - ExprCall(ref fun, ref args) => { + ExprKind::Call(ref fun, ref args) => { if_chain! { - if let ExprPath(ref qpath) = fun.node; + if let ExprKind::Path(ref qpath) = fun.node; if args.len() == 3; if let Some(fun_def_id) = opt_def_id(resolve_node(cx, qpath, fun.hir_id)); if match_def_path(cx.tcx, fun_def_id, &paths::FMT_ARGUMENTS_NEWV1FORMATTED); @@ -64,7 +64,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } }, // `format!("foo")` expansion contains `match () { () => [], }` - ExprMatch(ref matchee, _, _) => if let ExprTup(ref tup) = matchee.node { + ExprKind::Match(ref matchee, _, _) => if let ExprKind::Tup(ref tup) = matchee.node { if tup.is_empty() { let sugg = format!("{}.to_string()", snippet(cx, expr.span, "").into_owned()); span_lint_and_then(cx, USELESS_FORMAT, span, "useless use of `format!`", |db| { @@ -81,10 +81,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { /// Checks if the expressions matches `&[""]` fn check_single_piece(expr: &Expr) -> bool { if_chain! { - if let ExprAddrOf(_, ref expr) = expr.node; // &[""] - if let ExprArray(ref exprs) = expr.node; // [""] + if let ExprKind::AddrOf(_, ref expr) = expr.node; // &[""] + if let ExprKind::Array(ref exprs) = expr.node; // [""] if exprs.len() == 1; - if let ExprLit(ref lit) = exprs[0].node; + if let ExprKind::Lit(ref lit) = exprs[0].node; if let LitKind::Str(ref lit, _) = lit.node; then { return lit.as_str().is_empty(); @@ -105,23 +105,23 @@ fn check_single_piece(expr: &Expr) -> bool { /// then returns the span of first element of the matched tuple fn get_single_string_arg(cx: &LateContext, expr: &Expr) -> Option { if_chain! { - if let ExprAddrOf(_, ref expr) = expr.node; - if let ExprMatch(ref match_expr, ref arms, _) = expr.node; + if let ExprKind::AddrOf(_, ref expr) = expr.node; + if let ExprKind::Match(ref match_expr, ref arms, _) = expr.node; if arms.len() == 1; if arms[0].pats.len() == 1; if let PatKind::Tuple(ref pat, None) = arms[0].pats[0].node; if pat.len() == 1; - if let ExprArray(ref exprs) = arms[0].body.node; + if let ExprKind::Array(ref exprs) = arms[0].body.node; if exprs.len() == 1; - if let ExprCall(_, ref args) = exprs[0].node; + if let ExprKind::Call(_, ref args) = exprs[0].node; if args.len() == 2; - if let ExprPath(ref qpath) = args[1].node; + if let ExprKind::Path(ref qpath) = args[1].node; if let Some(fun_def_id) = opt_def_id(resolve_node(cx, qpath, args[1].hir_id)); if match_def_path(cx.tcx, fun_def_id, &paths::DISPLAY_FMT_METHOD); then { let ty = walk_ptrs_ty(cx.tables.pat_ty(&pat[0])); if ty.sty == ty::TyStr || match_type(cx, ty, &paths::STRING) { - if let ExprTup(ref values) = match_expr.node { + if let ExprKind::Tup(ref values) = match_expr.node { return Some(values[0].span); } } @@ -143,14 +143,14 @@ fn get_single_string_arg(cx: &LateContext, expr: &Expr) -> Option { /// ``` fn check_unformatted(expr: &Expr) -> bool { if_chain! { - if let ExprAddrOf(_, ref expr) = expr.node; - if let ExprArray(ref exprs) = expr.node; + if let ExprKind::AddrOf(_, ref expr) = expr.node; + if let ExprKind::Array(ref exprs) = expr.node; if exprs.len() == 1; - if let ExprStruct(_, ref fields, _) = exprs[0].node; + if let ExprKind::Struct(_, ref fields, _) = exprs[0].node; if let Some(format_field) = fields.iter().find(|f| f.ident.name == "format"); - if let ExprStruct(_, ref fields, _) = format_field.expr.node; + if let ExprKind::Struct(_, ref fields, _) = format_field.expr.node; if let Some(align_field) = fields.iter().find(|f| f.ident.name == "width"); - if let ExprPath(ref qpath) = align_field.expr.node; + if let ExprKind::Path(ref qpath) = align_field.expr.node; if last_path_segment(qpath).ident.name == "Implied"; then { return true; diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index 554c983d7c51..164380923159 100644 --- a/clippy_lints/src/functions.rs +++ b/clippy_lints/src/functions.rs @@ -86,7 +86,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Functions { use rustc::hir::map::Node::*; let is_impl = if let Some(NodeItem(item)) = cx.tcx.hir.find(cx.tcx.hir.get_parent_node(nodeid)) { - matches!(item.node, hir::ItemImpl(_, _, _, _, Some(_), _, _)) + matches!(item.node, hir::ItemKind::Impl(_, _, _, _, Some(_), _, _)) } else { false }; @@ -168,7 +168,7 @@ impl<'a, 'tcx> Functions { } fn raw_ptr_arg(arg: &hir::Arg, ty: &hir::Ty) -> Option { - if let (&hir::PatKind::Binding(_, id, _, _), &hir::TyPtr(_)) = (&arg.pat.node, &ty.node) { + if let (&hir::PatKind::Binding(_, id, _, _), &hir::TyKind::Ptr(_)) = (&arg.pat.node, &ty.node) { Some(id) } else { None @@ -184,7 +184,7 @@ struct DerefVisitor<'a, 'tcx: 'a> { 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) => { + hir::ExprKind::Call(ref f, ref args) => { let ty = self.tables.expr_ty(f); if type_is_unsafe_function(self.cx, ty) { @@ -193,7 +193,7 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> { } } }, - hir::ExprMethodCall(_, _, ref args) => { + hir::ExprKind::MethodCall(_, _, ref args) => { let def_id = self.tables.type_dependent_defs()[expr.hir_id].def_id(); let base_type = self.cx.tcx.type_of(def_id); @@ -203,7 +203,7 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> { } } }, - hir::ExprUnary(hir::UnDeref, ref ptr) => self.check_arg(ptr), + hir::ExprKind::Unary(hir::UnDeref, ref ptr) => self.check_arg(ptr), _ => (), } @@ -216,7 +216,7 @@ impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> { impl<'a, 'tcx: 'a> DerefVisitor<'a, 'tcx> { fn check_arg(&self, ptr: &hir::Expr) { - if let hir::ExprPath(ref qpath) = ptr.node { + if let hir::ExprKind::Path(ref qpath) = ptr.node { if let Def::Local(id) = self.cx.tables.qpath_def(qpath, ptr.hir_id) { if self.ptrs.contains(&id) { span_lint( diff --git a/clippy_lints/src/identity_conversion.rs b/clippy_lints/src/identity_conversion.rs index 2effb8bd8dbc..32ae8bcb29f8 100644 --- a/clippy_lints/src/identity_conversion.rs +++ b/clippy_lints/src/identity_conversion.rs @@ -43,19 +43,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityConversion { } match e.node { - ExprMatch(_, ref arms, MatchSource::TryDesugar) => { + ExprKind::Match(_, ref arms, MatchSource::TryDesugar) => { let e = match arms[0].body.node { - ExprRet(Some(ref e)) | ExprBreak(_, Some(ref e)) => e, + ExprKind::Ret(Some(ref e)) | ExprKind::Break(_, Some(ref e)) => e, _ => return, }; - if let ExprCall(_, ref args) = e.node { + if let ExprKind::Call(_, ref args) = e.node { self.try_desugar_arm.push(args[0].id); } else { return; } }, - ExprMethodCall(ref name, .., ref args) => { + ExprKind::MethodCall(ref name, .., ref args) => { if match_trait_method(cx, e, &paths::INTO[..]) && &*name.ident.as_str() == "into" { let a = cx.tables.expr_ty(e); let b = cx.tables.expr_ty(&args[0]); @@ -68,7 +68,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityConversion { } }, - ExprCall(ref path, ref args) => if let ExprPath(ref qpath) = path.node { + ExprKind::Call(ref path, ref args) => if let ExprKind::Path(ref qpath) = path.node { if let Some(def_id) = opt_def_id(resolve_node(cx, qpath, path.hir_id)) { if match_def_path(cx.tcx, def_id, &paths::FROM_FROM[..]) { let a = cx.tables.expr_ty(e); diff --git a/clippy_lints/src/identity_op.rs b/clippy_lints/src/identity_op.rs index e983e5746a11..92e07401818e 100644 --- a/clippy_lints/src/identity_op.rs +++ b/clippy_lints/src/identity_op.rs @@ -36,19 +36,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IdentityOp { if in_macro(e.span) { return; } - if let ExprBinary(ref cmp, ref left, ref right) = e.node { + if let ExprKind::Binary(ref cmp, ref left, ref right) = e.node { match cmp.node { - BiAdd | BiBitOr | BiBitXor => { + BinOpKind::Add | BinOpKind::BitOr | BinOpKind::BitXor => { check(cx, left, 0, e.span, right.span); check(cx, right, 0, e.span, left.span); }, - BiShl | BiShr | BiSub => check(cx, right, 0, e.span, left.span), - BiMul => { + BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Sub => check(cx, right, 0, e.span, left.span), + BinOpKind::Mul => { check(cx, left, 1, e.span, right.span); check(cx, right, 1, e.span, left.span); }, - BiDiv => check(cx, right, 1, e.span, left.span), - BiBitAnd => { + BinOpKind::Div => check(cx, right, 1, e.span, left.span), + BinOpKind::BitAnd => { check(cx, left, -1, e.span, right.span); check(cx, right, -1, e.span, left.span); }, diff --git a/clippy_lints/src/if_let_redundant_pattern_matching.rs b/clippy_lints/src/if_let_redundant_pattern_matching.rs index 78b21478d886..17dcf571fbf0 100644 --- a/clippy_lints/src/if_let_redundant_pattern_matching.rs +++ b/clippy_lints/src/if_let_redundant_pattern_matching.rs @@ -45,7 +45,7 @@ impl LintPass for Pass { 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 { + if let ExprKind::Match(ref op, ref arms, MatchSource::IfLetDesugar { .. }) = expr.node { if arms[0].pats.len() == 1 { let good_method = match arms[0].pats[0].node { PatKind::TupleStruct(ref path, ref pats, _) if pats.len() == 1 => { diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs index 7dd72a5383cd..8176408e7208 100644 --- a/clippy_lints/src/indexing_slicing.rs +++ b/clippy_lints/src/indexing_slicing.rs @@ -94,7 +94,7 @@ impl LintPass for IndexingSlicing { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for IndexingSlicing { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { - if let ExprIndex(ref array, ref index) = &expr.node { + if let ExprKind::Index(ref array, ref index) = &expr.node { let ty = cx.tables.expr_ty(array); if let Some(range) = higher::range(cx, index) { // Ranged indexes, i.e. &x[n..m], &x[n..], &x[..n] and &x[..] diff --git a/clippy_lints/src/infallible_destructuring_match.rs b/clippy_lints/src/infallible_destructuring_match.rs index a2b3846b986f..9abd9754d679 100644 --- a/clippy_lints/src/infallible_destructuring_match.rs +++ b/clippy_lints/src/infallible_destructuring_match.rs @@ -50,7 +50,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_local(&mut self, cx: &LateContext<'a, 'tcx>, local: &'tcx Local) { if_chain! { if let Some(ref expr) = local.init; - if let Expr_::ExprMatch(ref target, ref arms, MatchSource::Normal) = expr.node; + if let ExprKind::Match(ref target, ref arms, MatchSource::Normal) = expr.node; if arms.len() == 1 && arms[0].pats.len() == 1 && arms[0].guard.is_none(); if let PatKind::TupleStruct(QPath::Resolved(None, ref variant_name), ref args, _) = arms[0].pats[0].node; if args.len() == 1; diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs index 8f6d499329f3..a979486945a7 100644 --- a/clippy_lints/src/infinite_iter.rs +++ b/clippy_lints/src/infinite_iter.rs @@ -141,7 +141,7 @@ static HEURISTICS: &[(&str, usize, Heuristic, Finiteness)] = &[ fn is_infinite(cx: &LateContext, expr: &Expr) -> Finiteness { match expr.node { - ExprMethodCall(ref method, _, ref args) => { + ExprKind::MethodCall(ref method, _, ref args) => { for &(name, len, heuristic, cap) in HEURISTICS.iter() { if method.ident.name == name && args.len() == len { return (match heuristic { @@ -153,21 +153,21 @@ fn is_infinite(cx: &LateContext, expr: &Expr) -> Finiteness { } } if method.ident.name == "flat_map" && args.len() == 2 { - if let ExprClosure(_, _, body_id, _, _) = args[1].node { + if let ExprKind::Closure(_, _, body_id, _, _) = args[1].node { let body = cx.tcx.hir.body(body_id); return is_infinite(cx, &body.value); } } Finite }, - ExprBlock(ref block, _) => block.expr.as_ref().map_or(Finite, |e| is_infinite(cx, e)), - ExprBox(ref e) | ExprAddrOf(_, ref e) => is_infinite(cx, e), - ExprCall(ref path, _) => if let ExprPath(ref qpath) = path.node { + ExprKind::Block(ref block, _) => block.expr.as_ref().map_or(Finite, |e| is_infinite(cx, e)), + ExprKind::Box(ref e) | ExprKind::AddrOf(_, ref e) => is_infinite(cx, e), + ExprKind::Call(ref path, _) => if let ExprKind::Path(ref qpath) = path.node { match_qpath(qpath, &paths::REPEAT).into() } else { Finite }, - ExprStruct(..) => higher::range(cx, expr) + ExprKind::Struct(..) => higher::range(cx, expr) .map_or(false, |r| r.end.is_none()) .into(), _ => Finite, @@ -205,7 +205,7 @@ static COMPLETING_METHODS: &[(&str, usize)] = &[ fn complete_infinite_iter(cx: &LateContext, expr: &Expr) -> Finiteness { match expr.node { - ExprMethodCall(ref method, _, ref args) => { + ExprKind::MethodCall(ref method, _, ref args) => { for &(name, len) in COMPLETING_METHODS.iter() { if method.ident.name == name && args.len() == len { return is_infinite(cx, &args[0]); @@ -224,11 +224,11 @@ fn complete_infinite_iter(cx: &LateContext, expr: &Expr) -> Finiteness { } } }, - ExprBinary(op, ref l, ref r) => if op.node.is_comparison() { + ExprKind::Binary(op, ref l, ref r) => if op.node.is_comparison() { return is_infinite(cx, l) .and(is_infinite(cx, r)) .and(MaybeInfinite); - }, // TODO: ExprLoop + Match + }, // TODO: ExprKind::Loop + Match _ => (), } Finite diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs index 637ea917a8f0..9fb9a162cde6 100644 --- a/clippy_lints/src/inherent_impl.rs +++ b/clippy_lints/src/inherent_impl.rs @@ -56,7 +56,7 @@ impl LintPass for Pass { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_item(&mut self, _: &LateContext<'a, 'tcx>, item: &'tcx Item) { - if let Item_::ItemImpl(_, _, _, ref generics, None, _, _) = item.node { + if let ItemKind::Impl(_, _, _, ref generics, None, _, _) = item.node { // Remember for each inherent implementation encoutered its span and generics self.impls .insert(item.hir_id.owner_def_id(), (item.span, generics.clone())); diff --git a/clippy_lints/src/invalid_ref.rs b/clippy_lints/src/invalid_ref.rs index 0ebdda9ec886..255efa741659 100644 --- a/clippy_lints/src/invalid_ref.rs +++ b/clippy_lints/src/invalid_ref.rs @@ -35,8 +35,8 @@ impl LintPass for InvalidRef { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidRef { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_chain! { - if let ExprCall(ref path, ref args) = expr.node; - if let ExprPath(ref qpath) = path.node; + if let ExprKind::Call(ref path, ref args) = expr.node; + if let ExprKind::Path(ref qpath) = path.node; if args.len() == 0; if let ty::TyRef(..) = cx.tables.expr_ty(expr).sty; if let Some(def_id) = opt_def_id(cx.tables.qpath_def(qpath, path.hir_id)); diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs index ca136f06aec8..926e3a3033f8 100644 --- a/clippy_lints/src/large_enum_variant.rs +++ b/clippy_lints/src/large_enum_variant.rs @@ -49,7 +49,7 @@ impl LintPass for LargeEnumVariant { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LargeEnumVariant { fn check_item(&mut self, cx: &LateContext, item: &Item) { let did = cx.tcx.hir.local_def_id(item.id); - if let ItemEnum(ref def, _) = item.node { + if let ItemKind::Enum(ref def, _) = item.node { let ty = cx.tcx.type_of(did); let adt = ty.ty_adt_def() .expect("already checked whether this is an enum"); diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs index c1ec7a16296c..bd02eb5c81f1 100644 --- a/clippy_lints/src/len_zero.rs +++ b/clippy_lints/src/len_zero.rs @@ -68,8 +68,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LenZero { } match item.node { - ItemTrait(_, _, _, _, ref trait_items) => check_trait_items(cx, item, trait_items), - ItemImpl(_, _, _, _, None, _, ref impl_items) => check_impl_items(cx, item, impl_items), + ItemKind::Trait(_, _, _, _, ref trait_items) => check_trait_items(cx, item, trait_items), + ItemKind::Impl(_, _, _, _, None, _, ref impl_items) => check_impl_items(cx, item, impl_items), _ => (), } } @@ -79,26 +79,26 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LenZero { return; } - if let ExprBinary(Spanned { node: cmp, .. }, ref left, ref right) = expr.node { + if let ExprKind::Binary(Spanned { node: cmp, .. }, ref left, ref right) = expr.node { match cmp { - BiEq => { + BinOpKind::Eq => { check_cmp(cx, expr.span, left, right, "", 0); // len == 0 check_cmp(cx, expr.span, right, left, "", 0); // 0 == len }, - BiNe => { + BinOpKind::Ne => { check_cmp(cx, expr.span, left, right, "!", 0); // len != 0 check_cmp(cx, expr.span, right, left, "!", 0); // 0 != len }, - BiGt => { + BinOpKind::Gt => { check_cmp(cx, expr.span, left, right, "!", 0); // len > 0 check_cmp(cx, expr.span, right, left, "", 1); // 1 > len }, - BiLt => { + BinOpKind::Lt => { check_cmp(cx, expr.span, left, right, "", 1); // len < 1 check_cmp(cx, expr.span, right, left, "!", 0); // 0 < len }, - BiGe => check_cmp(cx, expr.span, left, right, "!", 1), // len <= 1 - BiLe => check_cmp(cx, expr.span, right, left, "!", 1), // 1 >= len + BinOpKind::Ge => check_cmp(cx, expr.span, left, right, "!", 1), // len <= 1 + BinOpKind::Le => check_cmp(cx, expr.span, right, left, "!", 1), // 1 >= len _ => (), } } @@ -194,7 +194,7 @@ fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItemRef]) { } fn check_cmp(cx: &LateContext, span: Span, method: &Expr, lit: &Expr, op: &str, compare_to: u32) { - if let (&ExprMethodCall(ref method_path, _, ref args), &ExprLit(ref lit)) = (&method.node, &lit.node) { + if let (&ExprKind::MethodCall(ref method_path, _, ref args), &ExprKind::Lit(ref lit)) = (&method.node, &lit.node) { // check if we are in an is_empty() method if let Some(name) = get_item_name(cx, method) { if name == "is_empty" { diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs index 4e0d3de799e5..a72e09f9fdf0 100644 --- a/clippy_lints/src/let_if_seq.rs +++ b/clippy_lints/src/let_if_seq.rs @@ -65,20 +65,20 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq { while let Some(stmt) = it.next() { if_chain! { if let Some(expr) = it.peek(); - if let hir::StmtDecl(ref decl, _) = stmt.node; - if let hir::DeclLocal(ref decl) = decl.node; + if let hir::StmtKind::Decl(ref decl, _) = stmt.node; + if let hir::DeclKind::Local(ref decl) = decl.node; if let hir::PatKind::Binding(mode, canonical_id, ident, None) = decl.pat.node; - if let hir::StmtExpr(ref if_, _) = expr.node; - if let hir::ExprIf(ref cond, ref then, ref else_) = if_.node; + if let hir::StmtKind::Expr(ref if_, _) = expr.node; + if let hir::ExprKind::If(ref cond, ref then, ref else_) = if_.node; if !used_in_expr(cx, canonical_id, cond); - if let hir::ExprBlock(ref then, _) = then.node; + if let hir::ExprKind::Block(ref then, _) = then.node; if let Some(value) = check_assign(cx, canonical_id, &*then); if !used_in_expr(cx, canonical_id, value); then { let span = stmt.span.to(if_.span); let (default_multi_stmts, default) = if let Some(ref else_) = *else_ { - if let hir::ExprBlock(ref else_, _) = else_.node { + if let hir::ExprKind::Block(ref else_, _) = else_.node { if let Some(default) = check_assign(cx, canonical_id, else_) { (else_.stmts.len() > 1, default) } else if let Some(ref default) = decl.init { @@ -140,7 +140,7 @@ struct UsedVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx> hir::intravisit::Visitor<'tcx> for UsedVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &'tcx hir::Expr) { if_chain! { - if let hir::ExprPath(ref qpath) = expr.node; + if let hir::ExprKind::Path(ref qpath) = expr.node; if let Def::Local(local_id) = self.cx.tables.qpath_def(qpath, expr.hir_id); if self.id == local_id; then { @@ -163,9 +163,9 @@ fn check_assign<'a, 'tcx>( if_chain! { if block.expr.is_none(); if let Some(expr) = block.stmts.iter().last(); - if let hir::StmtSemi(ref expr, _) = expr.node; - if let hir::ExprAssign(ref var, ref value) = expr.node; - if let hir::ExprPath(ref qpath) = var.node; + if let hir::StmtKind::Semi(ref expr, _) = expr.node; + if let hir::ExprKind::Assign(ref var, ref value) = expr.node; + if let hir::ExprKind::Path(ref qpath) = var.node; if let Def::Local(local_id) = cx.tables.qpath_def(qpath, var.hir_id); if decl == local_id; then { diff --git a/clippy_lints/src/lifetimes.rs b/clippy_lints/src/lifetimes.rs index c6bf264ff38f..1b371a8141ef 100644 --- a/clippy_lints/src/lifetimes.rs +++ b/clippy_lints/src/lifetimes.rs @@ -59,7 +59,7 @@ impl LintPass for LifetimePass { 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, id) = item.node { + if let ItemKind::Fn(ref decl, _, ref generics, id) = item.node { check_fn_inner(cx, decl, Some(id), generics, item.span); } } @@ -338,14 +338,14 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> { fn visit_ty(&mut self, ty: &'tcx Ty) { match ty.node { - TyRptr(ref lt, _) if lt.is_elided() => { + TyKind::Rptr(ref lt, _) if lt.is_elided() => { self.record(&None); }, - TyPath(ref path) => { + TyKind::Path(ref path) => { if let QPath::Resolved(_, ref path) = *path { if let Def::Existential(def_id) = path.def { let node_id = self.cx.tcx.hir.as_local_node_id(def_id).unwrap(); - if let ItemExistential(ref exist_ty) = self.cx.tcx.hir.expect_item(node_id).node { + if let ItemKind::Existential(ref exist_ty) = self.cx.tcx.hir.expect_item(node_id).node { for bound in &exist_ty.bounds { if let GenericBound::Outlives(_) = *bound { self.record(&None); @@ -360,7 +360,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> { } self.collect_anonymous_lifetimes(path, ty); } - TyTraitObject(ref bounds, ref lt) => { + TyKind::TraitObject(ref bounds, ref lt) => { if !lt.is_elided() { self.abort = true; } diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index 963a8da49cb8..e7da7bde30f2 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -411,7 +411,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { // check for never_loop match expr.node { - ExprWhile(_, ref block, _) | ExprLoop(ref block, _, _) => { + ExprKind::While(_, ref block, _) | ExprKind::Loop(ref block, _, _) => { match never_loop_block(block, expr.id) { NeverLoopResult::AlwaysBreak => span_lint(cx, NEVER_LOOP, expr.span, "this loop never actually loops"), @@ -424,7 +424,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { // check for `loop { if let {} else break }` that could be `while let` // (also matches an explicit "match" instead of "if let") // (even if the "match" or "if let" is used for declaration) - if let ExprLoop(ref block, _, LoopSource::Loop) = expr.node { + if let ExprKind::Loop(ref block, _, LoopSource::Loop) = expr.node { // also check for empty `loop {}` statements if block.stmts.is_empty() && block.expr.is_none() { span_lint( @@ -440,7 +440,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { let inner_stmt_expr = extract_expr_from_first_stmt(block); // or extract the first expression (if any) from the block if let Some(inner) = inner_stmt_expr.or_else(|| extract_first_expr(block)) { - if let ExprMatch(ref matchexpr, ref arms, ref source) = inner.node { + if let ExprKind::Match(ref matchexpr, ref arms, ref source) = inner.node { // ensure "if let" compatible match structure match *source { MatchSource::Normal | MatchSource::IfLetDesugar { .. } => { @@ -476,11 +476,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } } } - if let ExprMatch(ref match_expr, ref arms, MatchSource::WhileLetDesugar) = expr.node { + if let ExprKind::Match(ref match_expr, ref arms, MatchSource::WhileLetDesugar) = expr.node { let pat = &arms[0].pats[0].node; if let ( &PatKind::TupleStruct(ref qpath, ref pat_args, _), - &ExprMethodCall(ref method_path, _, ref method_args), + &ExprKind::MethodCall(ref method_path, _, ref method_args), ) = (pat, &match_expr.node) { let iter_expr = &method_args[0]; @@ -505,14 +505,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } // check for while loops which conditions never change - if let ExprWhile(ref cond, _, _) = expr.node { + if let ExprKind::While(ref cond, _, _) = expr.node { check_infinite_loop(cx, cond, expr); } } 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 let StmtKind::Semi(ref expr, _) = stmt.node { + if let ExprKind::MethodCall(ref method, _, ref args) = expr.node { if args.len() == 1 && method.ident.name == "collect" && match_trait_method(cx, expr, &paths::ITERATOR) { span_lint( cx, @@ -584,53 +584,53 @@ fn never_loop_block(block: &Block, main_loop_id: NodeId) -> NeverLoopResult { fn stmt_to_expr(stmt: &Stmt) -> Option<&Expr> { match stmt.node { - StmtSemi(ref e, ..) | StmtExpr(ref e, ..) => Some(e), - StmtDecl(ref d, ..) => decl_to_expr(d), + StmtKind::Semi(ref e, ..) | StmtKind::Expr(ref e, ..) => Some(e), + StmtKind::Decl(ref d, ..) => decl_to_expr(d), } } fn decl_to_expr(decl: &Decl) -> Option<&Expr> { match decl.node { - DeclLocal(ref local) => local.init.as_ref().map(|p| &**p), + DeclKind::Local(ref local) => local.init.as_ref().map(|p| &**p), _ => None, } } fn never_loop_expr(expr: &Expr, main_loop_id: NodeId) -> NeverLoopResult { match expr.node { - ExprBox(ref e) | - ExprUnary(_, ref e) | - ExprCast(ref e, _) | - ExprType(ref e, _) | - ExprField(ref e, _) | - ExprAddrOf(_, ref e) | - ExprStruct(_, _, Some(ref e)) | - ExprRepeat(ref e, _) => never_loop_expr(e, main_loop_id), - ExprArray(ref es) | ExprMethodCall(_, _, ref es) | ExprTup(ref es) => { + ExprKind::Box(ref e) | + ExprKind::Unary(_, ref e) | + ExprKind::Cast(ref e, _) | + ExprKind::Type(ref e, _) | + ExprKind::Field(ref e, _) | + ExprKind::AddrOf(_, ref e) | + ExprKind::Struct(_, _, Some(ref e)) | + ExprKind::Repeat(ref e, _) => never_loop_expr(e, main_loop_id), + ExprKind::Array(ref es) | ExprKind::MethodCall(_, _, ref es) | ExprKind::Tup(ref es) => { never_loop_expr_all(&mut es.iter(), main_loop_id) }, - ExprCall(ref e, ref es) => never_loop_expr_all(&mut once(&**e).chain(es.iter()), main_loop_id), - ExprBinary(_, ref e1, ref e2) | - ExprAssign(ref e1, ref e2) | - ExprAssignOp(_, ref e1, ref e2) | - ExprIndex(ref e1, ref e2) => never_loop_expr_all(&mut [&**e1, &**e2].iter().cloned(), main_loop_id), - ExprIf(ref e, ref e2, ref e3) => { + ExprKind::Call(ref e, ref es) => never_loop_expr_all(&mut once(&**e).chain(es.iter()), main_loop_id), + ExprKind::Binary(_, ref e1, ref e2) | + ExprKind::Assign(ref e1, ref e2) | + ExprKind::AssignOp(_, ref e1, ref e2) | + ExprKind::Index(ref e1, ref e2) => never_loop_expr_all(&mut [&**e1, &**e2].iter().cloned(), main_loop_id), + ExprKind::If(ref e, ref e2, ref e3) => { let e1 = never_loop_expr(e, main_loop_id); let e2 = never_loop_expr(e2, main_loop_id); let e3 = e3.as_ref().map_or(NeverLoopResult::Otherwise, |e| never_loop_expr(e, main_loop_id)); combine_seq(e1, combine_branches(e2, e3)) }, - ExprLoop(ref b, _, _) => { + ExprKind::Loop(ref b, _, _) => { // Break can come from the inner loop so remove them. absorb_break(&never_loop_block(b, main_loop_id)) }, - ExprWhile(ref e, ref b, _) => { + ExprKind::While(ref e, ref b, _) => { let e = never_loop_expr(e, main_loop_id); let result = never_loop_block(b, main_loop_id); // Break can come from the inner loop so remove them. combine_seq(e, absorb_break(&result)) }, - ExprMatch(ref e, ref arms, _) => { + ExprKind::Match(ref e, ref arms, _) => { let e = never_loop_expr(e, main_loop_id); if arms.is_empty() { e @@ -639,8 +639,8 @@ fn never_loop_expr(expr: &Expr, main_loop_id: NodeId) -> NeverLoopResult { combine_seq(e, arms) } }, - ExprBlock(ref b, _) => never_loop_block(b, main_loop_id), - ExprContinue(d) => { + ExprKind::Block(ref b, _) => never_loop_block(b, main_loop_id), + ExprKind::Continue(d) => { let id = d.target_id .expect("target id can only be missing in the presence of compilation errors"); if id == main_loop_id { @@ -649,22 +649,22 @@ fn never_loop_expr(expr: &Expr, main_loop_id: NodeId) -> NeverLoopResult { NeverLoopResult::AlwaysBreak } }, - ExprBreak(_, _) => { + ExprKind::Break(_, _) => { NeverLoopResult::AlwaysBreak }, - ExprRet(ref e) => { + ExprKind::Ret(ref e) => { if let Some(ref e) = *e { combine_seq(never_loop_expr(e, main_loop_id), NeverLoopResult::AlwaysBreak) } else { NeverLoopResult::AlwaysBreak } }, - ExprStruct(_, _, None) | - ExprYield(_) | - ExprClosure(_, _, _, _, _) | - ExprInlineAsm(_, _, _) | - ExprPath(_) | - ExprLit(_) => NeverLoopResult::Otherwise, + ExprKind::Struct(_, _, None) | + ExprKind::Yield(_) | + ExprKind::Closure(_, _, _, _, _) | + ExprKind::InlineAsm(_, _, _) | + ExprKind::Path(_) | + ExprKind::Lit(_) => NeverLoopResult::Otherwise, } } @@ -701,7 +701,7 @@ fn check_for_loop<'a, 'tcx>( fn same_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr, var: ast::NodeId) -> bool { if_chain! { - if let ExprPath(ref qpath) = expr.node; + if let ExprKind::Path(ref qpath) = expr.node; if let QPath::Resolved(None, ref path) = *qpath; if path.segments.len() == 1; if let Def::Local(local_id) = cx.tables.qpath_def(qpath, expr.hir_id); @@ -754,24 +754,24 @@ fn is_slice_like<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty) -> bool { fn get_fixed_offset_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr, var: ast::NodeId) -> Option { fn extract_offset<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, e: &Expr, var: ast::NodeId) -> Option { match e.node { - ExprLit(ref l) => match l.node { + ExprKind::Lit(ref l) => match l.node { ast::LitKind::Int(x, _ty) => Some(x.to_string()), _ => None, }, - ExprPath(..) if !same_var(cx, e, var) => Some(snippet_opt(cx, e.span).unwrap_or_else(|| "??".into())), + ExprKind::Path(..) if !same_var(cx, e, var) => Some(snippet_opt(cx, e.span).unwrap_or_else(|| "??".into())), _ => None, } } - if let ExprIndex(ref seqexpr, ref idx) = expr.node { + if let ExprKind::Index(ref seqexpr, ref idx) = expr.node { let ty = cx.tables.expr_ty(seqexpr); if !is_slice_like(cx, ty) { return None; } let offset = match idx.node { - ExprBinary(op, ref lhs, ref rhs) => match op.node { - BinOp_::BiAdd => { + ExprKind::Binary(op, ref lhs, ref rhs) => match op.node { + BinOpKind::Add => { let offset_opt = if same_var(cx, lhs, var) { extract_offset(cx, rhs, var) } else if same_var(cx, rhs, var) { @@ -782,10 +782,10 @@ fn get_fixed_offset_var<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &Expr, var: offset_opt.map(Offset::positive) }, - BinOp_::BiSub if same_var(cx, lhs, var) => extract_offset(cx, rhs, var).map(Offset::negative), + BinOpKind::Sub if same_var(cx, lhs, var) => extract_offset(cx, rhs, var).map(Offset::negative), _ => None, }, - ExprPath(..) => if same_var(cx, idx, var) { + ExprKind::Path(..) => if same_var(cx, idx, var) { Some(Offset::positive("0".into())) } else { None @@ -810,7 +810,7 @@ fn fetch_cloned_fixed_offset_var<'a, 'tcx>( var: ast::NodeId, ) -> Option { if_chain! { - if let ExprMethodCall(ref method, _, ref args) = expr.node; + if let ExprKind::MethodCall(ref method, _, ref args) = expr.node; if method.ident.name == "clone"; if args.len() == 1; if let Some(arg) = args.get(0); @@ -832,7 +832,7 @@ fn get_indexed_assignments<'a, 'tcx>( e: &Expr, var: ast::NodeId, ) -> Option<(FixedOffsetVar, FixedOffsetVar)> { - if let Expr_::ExprAssign(ref lhs, ref rhs) = e.node { + if let ExprKind::Assign(ref lhs, ref rhs) = e.node { match (get_fixed_offset_var(cx, lhs, var), fetch_cloned_fixed_offset_var(cx, rhs, var)) { (Some(offset_left), Some(offset_right)) => { // Source and destination must be different @@ -849,7 +849,7 @@ fn get_indexed_assignments<'a, 'tcx>( } } - if let Expr_::ExprBlock(ref b, _) = body.node { + if let ExprKind::Block(ref b, _) = body.node { let Block { ref stmts, ref expr, @@ -859,8 +859,8 @@ fn get_indexed_assignments<'a, 'tcx>( stmts .iter() .map(|stmt| match stmt.node { - Stmt_::StmtDecl(..) => None, - Stmt_::StmtExpr(ref e, _node_id) | Stmt_::StmtSemi(ref e, _node_id) => Some(get_assignment(cx, e, var)), + StmtKind::Decl(..) => None, + StmtKind::Expr(ref e, _node_id) | StmtKind::Semi(ref e, _node_id) => Some(get_assignment(cx, e, var)), }) .chain( expr.as_ref() @@ -906,7 +906,7 @@ fn detect_manual_memcpy<'a, 'tcx>( let print_limit = |end: &Option<&Expr>, offset: Offset, var_name: &str| if let Some(end) = *end { if_chain! { - if let ExprMethodCall(ref method, _, ref len_args) = end.node; + if let ExprKind::MethodCall(ref method, _, ref len_args) = end.node; if method.ident.name == "len"; if len_args.len() == 1; if let Some(arg) = len_args.get(0); @@ -1098,10 +1098,10 @@ fn check_for_loop_range<'a, 'tcx>( fn is_len_call(expr: &Expr, var: Name) -> bool { if_chain! { - if let ExprMethodCall(ref method, _, ref len_args) = expr.node; + if let ExprKind::MethodCall(ref method, _, ref len_args) = expr.node; if len_args.len() == 1; if method.ident.name == "len"; - if let ExprPath(QPath::Resolved(_, ref path)) = len_args[0].node; + if let ExprKind::Path(QPath::Resolved(_, ref path)) = len_args[0].node; if path.segments.len() == 1; if path.segments[0].ident.name == var; then { @@ -1203,7 +1203,7 @@ fn lint_iter_method(cx: &LateContext, args: &[Expr], arg: &Expr, method_name: &s fn check_for_loop_arg(cx: &LateContext, pat: &Pat, arg: &Expr, expr: &Expr) { let mut next_loop_linted = false; // whether or not ITER_NEXT_LOOP lint was used - if let ExprMethodCall(ref method, _, ref args) = arg.node { + if let ExprKind::MethodCall(ref method, _, ref args) = arg.node { // just the receiver, no arguments if args.len() == 1 { let method_name = &*method.ident.as_str(); @@ -1377,7 +1377,7 @@ fn check_for_loop_over_map_kv<'a, 'tcx>( MutMutable => "_mut", }; let arg = match arg.node { - ExprAddrOf(_, ref expr) => &**expr, + ExprKind::AddrOf(_, ref expr) => &**expr, _ => arg, }; @@ -1483,7 +1483,7 @@ fn mut_warn_with_span(cx: &LateContext, span: Option) { fn check_for_mutability(cx: &LateContext, bound: &Expr) -> Option { if_chain! { - if let ExprPath(ref qpath) = bound.node; + if let ExprKind::Path(ref qpath) = bound.node; if let QPath::Resolved(None, _) = *qpath; then { let def = cx.tables.qpath_def(qpath, bound.hir_id); @@ -1598,7 +1598,7 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> { fn check(&mut self, idx: &'tcx Expr, seqexpr: &'tcx Expr, expr: &'tcx Expr) -> bool { if_chain! { // the indexed container is referenced by a name - if let ExprPath(ref seqpath) = seqexpr.node; + if let ExprKind::Path(ref seqpath) = seqexpr.node; if let QPath::Resolved(None, ref seqvar) = *seqpath; if seqvar.segments.len() == 1; then { @@ -1655,7 +1655,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &'tcx Expr) { if_chain! { // a range index op - if let ExprMethodCall(ref meth, _, ref args) = expr.node; + if let ExprKind::MethodCall(ref meth, _, ref args) = expr.node; if (meth.ident.name == "index" && match_trait_method(self.cx, expr, &paths::INDEX)) || (meth.ident.name == "index_mut" && match_trait_method(self.cx, expr, &paths::INDEX_MUT)); if !self.check(&args[1], &args[0], expr); @@ -1664,14 +1664,14 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> { if_chain! { // an index op - if let ExprIndex(ref seqexpr, ref idx) = expr.node; + if let ExprKind::Index(ref seqexpr, ref idx) = expr.node; if !self.check(idx, seqexpr, expr); then { return } } if_chain! { // directly using a variable - if let ExprPath(ref qpath) = expr.node; + if let ExprKind::Path(ref qpath) = expr.node; if let QPath::Resolved(None, ref path) = *qpath; if path.segments.len() == 1; if let Def::Local(local_id) = self.cx.tables.qpath_def(qpath, expr.hir_id); @@ -1687,20 +1687,20 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> { } let old = self.prefer_mutable; match expr.node { - ExprAssignOp(_, ref lhs, ref rhs) | - ExprAssign(ref lhs, ref rhs) => { + ExprKind::AssignOp(_, ref lhs, ref rhs) | + ExprKind::Assign(ref lhs, ref rhs) => { self.prefer_mutable = true; self.visit_expr(lhs); self.prefer_mutable = false; self.visit_expr(rhs); }, - ExprAddrOf(mutbl, ref expr) => { + ExprKind::AddrOf(mutbl, ref expr) => { if mutbl == MutMutable { self.prefer_mutable = true; } self.visit_expr(expr); }, - ExprCall(ref f, ref args) => { + ExprKind::Call(ref f, ref args) => { self.visit_expr(f); for expr in args { let ty = self.cx.tables.expr_ty_adjusted(expr); @@ -1713,7 +1713,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> { self.visit_expr(expr); } }, - ExprMethodCall(_, _, ref args) => { + ExprKind::MethodCall(_, _, ref args) => { let def_id = self.cx.tables.type_dependent_defs()[expr.hir_id].def_id(); for (ty, expr) in self.cx.tcx.fn_sig(def_id).inputs().skip_binder().iter().zip(args) { self.prefer_mutable = false; @@ -1809,8 +1809,8 @@ fn extract_expr_from_first_stmt(block: &Block) -> Option<&Expr> { if block.stmts.is_empty() { return None; } - if let StmtDecl(ref decl, _) = block.stmts[0].node { - if let DeclLocal(ref local) = decl.node { + if let StmtKind::Decl(ref decl, _) = block.stmts[0].node { + if let DeclKind::Local(ref local) = decl.node { if let Some(ref expr) = local.init { Some(expr) } else { @@ -1829,8 +1829,8 @@ fn extract_first_expr(block: &Block) -> Option<&Expr> { match block.expr { Some(ref expr) if block.stmts.is_empty() => Some(expr), None if !block.stmts.is_empty() => match block.stmts[0].node { - StmtExpr(ref expr, _) | StmtSemi(ref expr, _) => Some(expr), - StmtDecl(..) => None, + StmtKind::Expr(ref expr, _) | StmtKind::Semi(ref expr, _) => Some(expr), + StmtKind::Decl(..) => None, }, _ => None, } @@ -1841,8 +1841,8 @@ fn extract_first_expr(block: &Block) -> Option<&Expr> { /// passed expression. The expression may be within a block. fn is_simple_break_expr(expr: &Expr) -> bool { match expr.node { - ExprBreak(dest, ref passed_expr) if dest.label.is_none() && passed_expr.is_none() => true, - ExprBlock(ref b, _) => match extract_first_expr(b) { + ExprKind::Break(dest, ref passed_expr) if dest.label.is_none() && passed_expr.is_none() => true, + ExprKind::Block(ref b, _) => match extract_first_expr(b) { Some(subexpr) => is_simple_break_expr(subexpr), None => false, }, @@ -1882,9 +1882,9 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> { let state = self.states.entry(def_id).or_insert(VarState::Initial); match parent.node { - ExprAssignOp(op, ref lhs, ref rhs) => { + ExprKind::AssignOp(op, ref lhs, ref rhs) => { if lhs.id == expr.id { - if op.node == BiAdd && is_integer_literal(rhs, 1) { + if op.node == BinOpKind::Add && is_integer_literal(rhs, 1) { *state = match *state { VarState::Initial if self.depth == 0 => VarState::IncrOnce, _ => VarState::DontWarn, @@ -1895,8 +1895,8 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> { } } }, - ExprAssign(ref lhs, _) if lhs.id == expr.id => *state = VarState::DontWarn, - ExprAddrOf(mutability, _) if mutability == MutMutable => *state = VarState::DontWarn, + ExprKind::Assign(ref lhs, _) if lhs.id == expr.id => *state = VarState::DontWarn, + ExprKind::AddrOf(mutability, _) if mutability == MutMutable => *state = VarState::DontWarn, _ => (), } } @@ -1931,7 +1931,7 @@ struct InitializeVisitor<'a, 'tcx: 'a> { 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 let DeclKind::Local(ref local) = decl.node { if local.pat.id == self.var_id { if let PatKind::Binding(_, _, ident, _) = local.pat.node { self.name = Some(ident.name); @@ -1969,17 +1969,17 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> { if var_def_id(self.cx, expr) == Some(self.var_id) { if let Some(parent) = get_parent_expr(self.cx, expr) { match parent.node { - ExprAssignOp(_, ref lhs, _) if lhs.id == expr.id => { + ExprKind::AssignOp(_, ref lhs, _) if lhs.id == expr.id => { self.state = VarState::DontWarn; }, - ExprAssign(ref lhs, ref rhs) if lhs.id == expr.id => { + ExprKind::Assign(ref lhs, ref rhs) if lhs.id == expr.id => { self.state = if is_integer_literal(rhs, 0) && self.depth == 0 { VarState::Warn } else { VarState::DontWarn } }, - ExprAddrOf(mutability, _) if mutability == MutMutable => self.state = VarState::DontWarn, + ExprKind::AddrOf(mutability, _) if mutability == MutMutable => self.state = VarState::DontWarn, _ => (), } } @@ -2005,7 +2005,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> { } fn var_def_id(cx: &LateContext, expr: &Expr) -> Option { - if let ExprPath(ref qpath) = expr.node { + if let ExprKind::Path(ref qpath) = expr.node { let path_res = cx.tables.qpath_def(qpath, expr.hir_id); if let Def::Local(node_id) = path_res { return Some(node_id); @@ -2016,14 +2016,14 @@ fn var_def_id(cx: &LateContext, expr: &Expr) -> Option { fn is_loop(expr: &Expr) -> bool { match expr.node { - ExprLoop(..) | ExprWhile(..) => true, + ExprKind::Loop(..) | ExprKind::While(..) => true, _ => false, } } fn is_conditional(expr: &Expr) -> bool { match expr.node { - ExprIf(..) | ExprMatch(..) => true, + ExprKind::If(..) | ExprKind::Match(..) => true, _ => false, } } @@ -2053,7 +2053,7 @@ fn is_loop_nested(cx: &LateContext, loop_expr: &Expr, iter_expr: &Expr) -> bool } match cx.tcx.hir.find(parent) { Some(NodeExpr(expr)) => match expr.node { - ExprLoop(..) | ExprWhile(..) => { + ExprKind::Loop(..) | ExprKind::While(..) => { return true; }, _ => (), @@ -2111,7 +2111,7 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor { return; } match expr.node { - ExprAssign(ref path, _) | ExprAssignOp(_, ref path, _) => if match_var(path, self.iterator) { + ExprKind::Assign(ref path, _) | ExprKind::AssignOp(_, ref path, _) => if match_var(path, self.iterator) { self.nesting = RuledOut; }, _ => walk_expr(self, expr), @@ -2137,7 +2137,7 @@ impl<'tcx> Visitor<'tcx> for LoopNestVisitor { } fn path_name(e: &Expr) -> Option { - if let ExprPath(QPath::Resolved(_, ref path)) = e.node { + if let ExprKind::Path(QPath::Resolved(_, ref path)) = e.node { let segments = &path.segments; if segments.len() == 1 { return Some(segments[0].ident.name); @@ -2193,7 +2193,7 @@ struct VarCollectorVisitor<'a, 'tcx: 'a> { impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> { fn insert_def_id(&mut self, ex: &'tcx Expr) { if_chain! { - if let ExprPath(ref qpath) = ex.node; + if let ExprKind::Path(ref qpath) = ex.node; if let QPath::Resolved(None, _) = *qpath; let def = self.cx.tables.qpath_def(qpath, ex.hir_id); then { @@ -2214,9 +2214,9 @@ impl<'a, 'tcx> VarCollectorVisitor<'a, 'tcx> { impl<'a, 'tcx> Visitor<'tcx> for VarCollectorVisitor<'a, 'tcx> { fn visit_expr(&mut self, ex: &'tcx Expr) { match ex.node { - ExprPath(_) => self.insert_def_id(ex), + ExprKind::Path(_) => self.insert_def_id(ex), // If there is any fuction/method call… we just stop analysis - ExprCall(..) | ExprMethodCall(..) => self.skip = true, + ExprKind::Call(..) | ExprKind::MethodCall(..) => self.skip = true, _ => walk_expr(self, ex), } diff --git a/clippy_lints/src/map_clone.rs b/clippy_lints/src/map_clone.rs index 0d58732f24d1..01ce702c17cf 100644 --- a/clippy_lints/src/map_clone.rs +++ b/clippy_lints/src/map_clone.rs @@ -30,10 +30,10 @@ pub struct Pass; 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(ref method, _, ref args) = expr.node { + if let ExprKind::MethodCall(ref method, _, ref args) = expr.node { if method.ident.name == "map" && args.len() == 2 { match args[1].node { - ExprClosure(_, ref decl, closure_eid, _, _) => { + ExprKind::Closure(_, ref decl, closure_eid, _, _) => { let body = cx.tcx.hir.body(closure_eid); let closure_expr = remove_blocks(&body.value); if_chain! { @@ -62,7 +62,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } } // explicit clone() calls ( .map(|x| x.clone()) ) - else if let ExprMethodCall(ref clone_call, _, ref clone_args) = closure_expr.node { + else if let ExprKind::MethodCall(ref clone_call, _, ref clone_args) = closure_expr.node { if clone_call.ident.name == "clone" && clone_args.len() == 1 && match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT) && @@ -77,7 +77,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } } }, - ExprPath(ref path) => if match_qpath(path, &paths::CLONE) { + ExprKind::Path(ref path) => if match_qpath(path, &paths::CLONE) { let type_name = get_type_name(cx, expr, &args[0]).unwrap_or("_"); span_help_and_lint( cx, @@ -100,7 +100,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn expr_eq_name(cx: &LateContext, expr: &Expr, id: ast::Ident) -> bool { match expr.node { - ExprPath(QPath::Resolved(None, ref path)) => { + ExprKind::Path(QPath::Resolved(None, ref path)) => { let arg_segment = [ PathSegment { ident: id, @@ -126,7 +126,7 @@ fn get_type_name(cx: &LateContext, expr: &Expr, arg: &Expr) -> Option<&'static s fn only_derefs(cx: &LateContext, expr: &Expr, id: ast::Ident) -> bool { match expr.node { - ExprUnary(UnDeref, ref subexpr) if !is_adjusted(cx, subexpr) => only_derefs(cx, subexpr, id), + ExprKind::Unary(UnDeref, ref subexpr) if !is_adjusted(cx, subexpr) => only_derefs(cx, subexpr, id), _ => expr_eq_name(cx, expr, id), } } diff --git a/clippy_lints/src/map_unit_fn.rs b/clippy_lints/src/map_unit_fn.rs index a1f4b70a4dcf..8df573e4c725 100644 --- a/clippy_lints/src/map_unit_fn.rs +++ b/clippy_lints/src/map_unit_fn.rs @@ -1,7 +1,7 @@ use rustc::hir; use rustc::lint::*; use rustc::ty; -use rustc_errors::{Applicability}; +use rustc_errors::Applicability; use syntax::codemap::Span; use crate::utils::{in_macro, iter_input_pats, match_type, method_chain_args, snippet, span_lint_and_then}; use crate::utils::paths; @@ -115,12 +115,12 @@ fn reduce_unit_expression<'a>(cx: &LateContext, expr: &'a hir::Expr) -> Option { + hir::ExprKind::Call(_, _) | + hir::ExprKind::MethodCall(_, _, _) => { // Calls can't be reduced any more Some(expr.span) }, - hir::ExprBlock(ref block, _) => { + hir::ExprKind::Block(ref block, _) => { match (&block.stmts[..], block.expr.as_ref()) { (&[], Some(inner_expr)) => { // If block only contains an expression, @@ -131,9 +131,9 @@ fn reduce_unit_expression<'a>(cx: &LateContext, expr: &'a hir::Expr) -> Option Some(d.span), - hir::StmtExpr(ref e, _) => Some(e.span), - hir::StmtSemi(_, _) => Some(inner_stmt.span), + hir::StmtKind::Decl(ref d, _) => Some(d.span), + hir::StmtKind::Expr(ref e, _) => Some(e.span), + hir::StmtKind::Semi(_, _) => Some(inner_stmt.span), } }, _ => { @@ -151,7 +151,7 @@ fn reduce_unit_expression<'a>(cx: &LateContext, expr: &'a hir::Expr) -> Option(cx: &LateContext<'a, 'tcx>, expr: &'a hir::Expr) -> Option<(&'tcx hir::Arg, &'a hir::Expr)> { - if let hir::ExprClosure(_, ref decl, inner_expr_id, _, _) = expr.node { + if let hir::ExprKind::Closure(_, ref decl, inner_expr_id, _, _) = expr.node { let body = cx.tcx.hir.body(inner_expr_id); let body_expr = &body.value; @@ -175,8 +175,8 @@ fn unit_closure<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'a hir::Expr) -> Op /// Anything else will return `_`. fn let_binding_name(cx: &LateContext, var_arg: &hir::Expr) -> String { match &var_arg.node { - hir::ExprField(_, _) => snippet(cx, var_arg.span, "_").replace(".", "_"), - hir::ExprPath(_) => format!("_{}", snippet(cx, var_arg.span, "")), + hir::ExprKind::Field(_, _) => snippet(cx, var_arg.span, "_").replace(".", "_"), + hir::ExprKind::Path(_) => format!("_{}", snippet(cx, var_arg.span, "")), _ => "_".to_string() } } @@ -247,8 +247,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { return; } - if let hir::StmtSemi(ref expr, _) = stmt.node { - if let hir::ExprMethodCall(_, _, _) = expr.node { + if let hir::StmtKind::Semi(ref expr, _) = stmt.node { + if let hir::ExprKind::MethodCall(_, _, _) = expr.node { if let Some(arglists) = method_chain_args(expr, &["map"]) { lint_map_unit_fn(cx, stmt, expr, arglists[0]); } diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index a14c6a0d8b90..c82d156462d4 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -184,14 +184,14 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MatchPass { if in_external_macro(cx, expr.span) { return; } - if let ExprMatch(ref ex, ref arms, MatchSource::Normal) = expr.node { + if let ExprKind::Match(ref ex, ref arms, MatchSource::Normal) = expr.node { check_single_match(cx, ex, arms, expr); check_match_bool(cx, ex, arms, expr); check_overlapping_arms(cx, ex, arms); check_wild_err_arm(cx, ex, arms); check_match_as_ref(cx, ex, arms, expr); } - if let ExprMatch(ref ex, ref arms, _) = expr.node { + if let ExprKind::Match(ref ex, ref arms, _) = expr.node { check_match_ref_pats(cx, ex, arms, expr); } } @@ -205,7 +205,7 @@ fn check_single_match(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: &Expr) { let els = remove_blocks(&arms[1].body); let els = if is_unit_expr(els) { None - } else if let ExprBlock(_, _) = els.node { + } else if let ExprKind::Block(_, _) = els.node { // matches with blocks that contain statements are prettier as `if let + else` Some(els) } else { @@ -294,7 +294,7 @@ fn check_match_bool(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: &Expr) { if arms.len() == 2 && arms[0].pats.len() == 1 { // no guards let exprs = if let PatKind::Lit(ref arm_bool) = arms[0].pats[0].node { - if let ExprLit(ref lit) = arm_bool.node { + if let ExprKind::Lit(ref lit) = arm_bool.node { match lit.node { LitKind::Bool(true) => Some((&*arms[0].body, &*arms[1].body)), LitKind::Bool(false) => Some((&*arms[1].body, &*arms[0].body)), @@ -372,7 +372,7 @@ fn check_wild_err_arm(cx: &LateContext, ex: &Expr, arms: &[Arm]) { if_chain! { if path_str == "Err"; if inner.iter().any(is_wild); - if let ExprBlock(ref block, _) = arm.body.node; + if let ExprKind::Block(ref block, _) = arm.body.node; if is_panic_block(block); then { // `Err(_)` arm with `panic!` found @@ -406,7 +406,7 @@ fn is_panic_block(block: &Block) -> bool { fn check_match_ref_pats(cx: &LateContext, ex: &Expr, arms: &[Arm], expr: &Expr) { if has_only_ref_pats(arms) { let mut suggs = Vec::new(); - let (title, msg) = if let ExprAddrOf(Mutability::MutImmutable, ref inner) = ex.node { + let (title, msg) = if let ExprKind::AddrOf(Mutability::MutImmutable, ref inner) = ex.node { suggs.push((ex.span, Sugg::hir(cx, inner, "..").to_string())); ( "you don't need to add `&` to both the expression and the patterns", @@ -540,8 +540,8 @@ fn type_ranges(ranges: &[SpannedRange]) -> TypedRanges { fn is_unit_expr(expr: &Expr) -> bool { match expr.node { - ExprTup(ref v) if v.is_empty() => true, - ExprBlock(ref b, _) if b.stmts.is_empty() && b.expr.is_none() => true, + ExprKind::Tup(ref v) if v.is_empty() => true, + ExprKind::Block(ref b, _) if b.stmts.is_empty() && b.expr.is_none() => true, _ => false, } } @@ -561,10 +561,10 @@ fn is_ref_some_arm(arm: &Arm) -> Option { if pats.len() == 1 && match_qpath(path, &paths::OPTION_SOME); if let PatKind::Binding(rb, _, ident, _) = pats[0].node; if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut; - if let ExprCall(ref e, ref args) = remove_blocks(&arm.body).node; - if let ExprPath(ref some_path) = e.node; + if let ExprKind::Call(ref e, ref args) = remove_blocks(&arm.body).node; + if let ExprKind::Path(ref some_path) = e.node; if match_qpath(some_path, &paths::OPTION_SOME) && args.len() == 1; - if let ExprPath(ref qpath) = args[0].node; + if let ExprKind::Path(ref qpath) = args[0].node; if let &QPath::Resolved(_, ref path2) = qpath; if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name; then { diff --git a/clippy_lints/src/mem_forget.rs b/clippy_lints/src/mem_forget.rs index 816c1bb6fbf0..11cf8a9a791a 100644 --- a/clippy_lints/src/mem_forget.rs +++ b/clippy_lints/src/mem_forget.rs @@ -1,5 +1,5 @@ use rustc::lint::*; -use rustc::hir::{Expr, ExprCall, ExprPath}; +use rustc::hir::{Expr, ExprKind}; use crate::utils::{match_def_path, opt_def_id, paths, span_lint}; /// **What it does:** Checks for usage of `std::mem::forget(t)` where `t` is @@ -30,8 +30,8 @@ impl LintPass for MemForget { 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 { + if let ExprKind::Call(ref path_expr, ref args) = e.node { + if let ExprKind::Path(ref qpath) = path_expr.node { if let Some(def_id) = opt_def_id(cx.tables.qpath_def(qpath, path_expr.hir_id)) { if match_def_path(cx.tcx, def_id, &paths::MEM_FORGET) { let forgot_ty = cx.tables.expr_ty(&args[0]); diff --git a/clippy_lints/src/methods.rs b/clippy_lints/src/methods.rs index ca739558e627..26a0b66094fe 100644 --- a/clippy_lints/src/methods.rs +++ b/clippy_lints/src/methods.rs @@ -718,7 +718,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } match expr.node { - hir::ExprMethodCall(ref method_call, ref method_span, ref args) => { + hir::ExprKind::MethodCall(ref method_call, ref method_span, ref args) => { // Chain calls // GET_UNWRAP needs to be checked before general `UNWRAP` lints if let Some(arglists) = method_chain_args(expr, &["get", "unwrap"]) { @@ -789,12 +789,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { _ => (), } }, - hir::ExprBinary(op, ref lhs, ref rhs) if op.node == hir::BiEq || op.node == hir::BiNe => { + hir::ExprKind::Binary(op, ref lhs, ref rhs) if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne => { let mut info = BinaryExprInfo { expr, chain: lhs, other: rhs, - eq: op.node == hir::BiEq, + eq: op.node == hir::BinOpKind::Eq, }; lint_binary_expr_with_method_call(cx, &mut info); }, @@ -813,7 +813,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { if let hir::ImplItemKind::Method(ref sig, id) = implitem.node; if let Some(first_arg_ty) = sig.decl.inputs.get(0); if let Some(first_arg) = iter_input_pats(&sig.decl, cx.tcx.hir.body(id)).next(); - if let hir::ItemImpl(_, _, _, _, None, ref self_ty, _) = item.node; + if let hir::ItemKind::Impl(_, _, _, _, None, ref self_ty, _) = item.node; then { if cx.access_levels.is_exported(implitem.id) { // check missing trait implementations @@ -889,7 +889,7 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, method_span: Span, name: } if name == "unwrap_or" { - if let hir::ExprPath(ref qpath) = fun.node { + if let hir::ExprKind::Path(ref qpath) = fun.node { let path = &*last_path_segment(qpath).ident.as_str(); if ["default", "new"].contains(&path) { @@ -982,13 +982,13 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, method_span: Span, name: if args.len() == 2 { match args[1].node { - hir::ExprCall(ref fun, ref or_args) => { + hir::ExprKind::Call(ref fun, ref or_args) => { let or_has_args = !or_args.is_empty(); if !check_unwrap_or_default(cx, name, fun, &args[0], &args[1], or_has_args, expr.span) { check_general_case(cx, name, method_span, fun.span, &args[0], &args[1], or_has_args, expr.span); } }, - hir::ExprMethodCall(_, span, ref or_args) => { + hir::ExprKind::MethodCall(_, span, ref or_args) => { check_general_case(cx, name, method_span, span, &args[0], &args[1], !or_args.is_empty(), expr.span) }, _ => {}, @@ -999,10 +999,10 @@ fn lint_or_fun_call(cx: &LateContext, expr: &hir::Expr, method_span: Span, name: /// Checks for the `EXPECT_FUN_CALL` lint. fn lint_expect_fun_call(cx: &LateContext, expr: &hir::Expr, method_span: Span, name: &str, args: &[hir::Expr]) { fn extract_format_args(arg: &hir::Expr) -> Option<&hir::HirVec> { - if let hir::ExprAddrOf(_, ref addr_of) = arg.node { - if let hir::ExprCall(ref inner_fun, ref inner_args) = addr_of.node { + if let hir::ExprKind::AddrOf(_, ref addr_of) = arg.node { + if let hir::ExprKind::Call(ref inner_fun, ref inner_args) = addr_of.node { if is_expn_of(inner_fun.span, "format").is_some() && inner_args.len() == 1 { - if let hir::ExprCall(_, ref format_args) = inner_args[0].node { + if let hir::ExprKind::Call(_, ref format_args) = inner_args[0].node { return Some(format_args); } } @@ -1013,9 +1013,9 @@ fn lint_expect_fun_call(cx: &LateContext, expr: &hir::Expr, method_span: Span, n } fn generate_format_arg_snippet(cx: &LateContext, a: &hir::Expr) -> String { - if let hir::ExprAddrOf(_, ref format_arg) = a.node { - if let hir::ExprMatch(ref format_arg_expr, _, _) = format_arg.node { - if let hir::ExprTup(ref format_arg_expr_tup) = format_arg_expr.node { + if let hir::ExprKind::AddrOf(_, ref format_arg) = a.node { + if let hir::ExprKind::Match(ref format_arg_expr, _, _) = format_arg.node { + if let hir::ExprKind::Tup(ref format_arg_expr_tup) = format_arg_expr.node { return snippet(cx, format_arg_expr_tup[0].span, "..").into_owned(); } } @@ -1090,7 +1090,7 @@ fn lint_expect_fun_call(cx: &LateContext, expr: &hir::Expr, method_span: Span, n if args.len() == 2 { match args[1].node { - hir::ExprLit(_) => {}, + hir::ExprKind::Lit(_) => {}, _ => check_general_case(cx, name, method_span, &args[0], &args[1], expr.span), } } @@ -1133,14 +1133,14 @@ fn lint_clone_on_copy(cx: &LateContext, expr: &hir::Expr, arg: &hir::Expr, arg_t match cx.tcx.hir.get(parent) { hir::map::NodeExpr(parent) => match parent.node { // &*x is a nop, &x.clone() is not - hir::ExprAddrOf(..) | + hir::ExprKind::AddrOf(..) | // (*x).func() is useless, x.clone().func() can work in case func borrows mutably - hir::ExprMethodCall(..) => return, + hir::ExprKind::MethodCall(..) => return, _ => {}, } hir::map::NodeStmt(stmt) => { - if let hir::StmtDecl(ref decl, _) = stmt.node { - if let hir::DeclLocal(ref loc) = decl.node { + if let hir::StmtKind::Decl(ref decl, _) = stmt.node { + if let hir::DeclKind::Local(ref loc) = decl.node { if let hir::PatKind::Ref(..) = loc.pat.node { // let ref y = *x borrows x, let ref y = x.clone() does not return; @@ -1229,9 +1229,9 @@ fn lint_extend(cx: &LateContext, expr: &hir::Expr, args: &[hir::Expr]) { fn lint_cstring_as_ptr(cx: &LateContext, expr: &hir::Expr, new: &hir::Expr, unwrap: &hir::Expr) { if_chain! { - if let hir::ExprCall(ref fun, ref args) = new.node; + if let hir::ExprKind::Call(ref fun, ref args) = new.node; if args.len() == 1; - if let hir::ExprPath(ref path) = fun.node; + if let hir::ExprKind::Path(ref path) = fun.node; if let Def::Method(did) = cx.tables.qpath_def(path, fun.hir_id); if match_def_path(cx.tcx, did, &paths::CSTRING_NEW); then { @@ -1274,18 +1274,18 @@ fn lint_unnecessary_fold(cx: &LateContext, expr: &hir::Expr, fold_args: &[hir::E fn check_fold_with_op( cx: &LateContext, fold_args: &[hir::Expr], - op: hir::BinOp_, + op: hir::BinOpKind, replacement_method_name: &str, replacement_has_args: bool) { if_chain! { // Extract the body of the closure passed to fold - if let hir::ExprClosure(_, _, body_id, _, _) = fold_args[2].node; + if let hir::ExprKind::Closure(_, _, body_id, _, _) = fold_args[2].node; let closure_body = cx.tcx.hir.body(body_id); let closure_expr = remove_blocks(&closure_body.value); // Check if the closure body is of the form `acc some_expr(x)` - if let hir::ExprBinary(ref bin_op, ref left_expr, ref right_expr) = closure_expr.node; + if let hir::ExprKind::Binary(ref bin_op, ref left_expr, ref right_expr) = closure_expr.node; if bin_op.node == op; // Extract the names of the two arguments to the closure @@ -1329,19 +1329,19 @@ fn lint_unnecessary_fold(cx: &LateContext, expr: &hir::Expr, fold_args: &[hir::E // Check if the first argument to .fold is a suitable literal match fold_args[1].node { - hir::ExprLit(ref lit) => { + hir::ExprKind::Lit(ref lit) => { match lit.node { ast::LitKind::Bool(false) => check_fold_with_op( - cx, fold_args, hir::BinOp_::BiOr, "any", true + cx, fold_args, hir::BinOpKind::Or, "any", true ), ast::LitKind::Bool(true) => check_fold_with_op( - cx, fold_args, hir::BinOp_::BiAnd, "all", true + cx, fold_args, hir::BinOpKind::And, "all", true ), ast::LitKind::Int(0, _) => check_fold_with_op( - cx, fold_args, hir::BinOp_::BiAdd, "sum", false + cx, fold_args, hir::BinOpKind::Add, "sum", false ), ast::LitKind::Int(1, _) => check_fold_with_op( - cx, fold_args, hir::BinOp_::BiMul, "product", false + cx, fold_args, hir::BinOpKind::Mul, "product", false ), _ => return } @@ -1437,7 +1437,7 @@ fn derefs_to_slice(cx: &LateContext, expr: &hir::Expr, ty: Ty) -> Option( fn lint_map_or_none<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr, map_or_args: &'tcx [hir::Expr]) { if match_type(cx, cx.tables.expr_ty(&map_or_args[0]), &paths::OPTION) { // check if the first non-self argument to map_or() is None - let map_or_arg_is_none = if let hir::Expr_::ExprPath(ref qpath) = map_or_args[1].node { + let map_or_arg_is_none = if let hir::ExprKind::Path(ref qpath) = map_or_args[1].node { match_qpath(qpath, &paths::OPTION_NONE) } else { false @@ -1790,9 +1790,9 @@ fn lint_chars_cmp<'a, 'tcx>( ) -> bool { if_chain! { if let Some(args) = method_chain_args(info.chain, chain_methods); - if let hir::ExprCall(ref fun, ref arg_char) = info.other.node; + if let hir::ExprKind::Call(ref fun, ref arg_char) = info.other.node; if arg_char.len() == 1; - if let hir::ExprPath(ref qpath) = fun.node; + if let hir::ExprKind::Path(ref qpath) = fun.node; if let Some(segment) = single_segment_path(qpath); if segment.ident.name == "Some"; then { @@ -1844,7 +1844,7 @@ fn lint_chars_cmp_with_unwrap<'a, 'tcx>( ) -> bool { if_chain! { if let Some(args) = method_chain_args(info.chain, chain_methods); - if let hir::ExprLit(ref lit) = info.other.node; + if let hir::ExprKind::Lit(ref lit) = info.other.node; if let ast::LitKind::Char(c) = lit.node; then { span_lint_and_sugg( @@ -2057,7 +2057,7 @@ impl SelfKind { return true; } match ty.node { - hir::TyRptr(_, ref mt_ty) => { + hir::TyKind::Rptr(_, ref mt_ty) => { let mutability_match = if self == SelfKind::Ref { mt_ty.mutbl == hir::MutImmutable } else { @@ -2128,8 +2128,8 @@ fn is_as_ref_or_mut_trait(ty: &hir::Ty, self_ty: &hir::Ty, generics: &hir::Gener fn is_ty(ty: &hir::Ty, self_ty: &hir::Ty) -> bool { match (&ty.node, &self_ty.node) { ( - &hir::TyPath(hir::QPath::Resolved(_, ref ty_path)), - &hir::TyPath(hir::QPath::Resolved(_, ref self_ty_path)), + &hir::TyKind::Path(hir::QPath::Resolved(_, ref ty_path)), + &hir::TyKind::Path(hir::QPath::Resolved(_, ref self_ty_path)), ) => ty_path .segments .iter() @@ -2140,7 +2140,7 @@ fn is_ty(ty: &hir::Ty, self_ty: &hir::Ty) -> bool { } fn single_segment_ty(ty: &hir::Ty) -> Option<&hir::PathSegment> { - if let hir::TyPath(ref path) = ty.node { + if let hir::TyKind::Path(ref path) = ty.node { single_segment_path(path) } else { None @@ -2175,20 +2175,20 @@ enum OutType { impl OutType { fn matches(self, cx: &LateContext, ty: &hir::FunctionRetTy) -> bool { - let is_unit = |ty: &hir::Ty| SpanlessEq::new(cx).eq_ty_kind(&ty.node, &hir::TyTup(vec![].into())); + let is_unit = |ty: &hir::Ty| SpanlessEq::new(cx).eq_ty_kind(&ty.node, &hir::TyKind::Tup(vec![].into())); match (self, ty) { (OutType::Unit, &hir::DefaultReturn(_)) => true, (OutType::Unit, &hir::Return(ref ty)) if is_unit(ty) => true, (OutType::Bool, &hir::Return(ref ty)) if is_bool(ty) => true, (OutType::Any, &hir::Return(ref ty)) if !is_unit(ty) => true, - (OutType::Ref, &hir::Return(ref ty)) => matches!(ty.node, hir::TyRptr(_, _)), + (OutType::Ref, &hir::Return(ref ty)) => matches!(ty.node, hir::TyKind::Rptr(_, _)), _ => false, } } } fn is_bool(ty: &hir::Ty) -> bool { - if let hir::TyPath(ref p) = ty.node { + if let hir::TyKind::Path(ref p) = ty.node { match_qpath(p, &["bool"]) } else { false diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs index 4be2b9f52271..fa2c9fda731e 100644 --- a/clippy_lints/src/minmax.rs +++ b/clippy_lints/src/minmax.rs @@ -66,8 +66,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(ref qpath) = path.node { + if let ExprKind::Call(ref path, ref args) = expr.node { + if let ExprKind::Path(ref qpath) = path.node { opt_def_id(cx.tables.qpath_def(qpath, path.hir_id)).and_then(|def_id| { if match_def_path(cx.tcx, def_id, &paths::CMP_MIN) { fetch_const(cx, args, MinMax::Min) diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index 4fc65b2f89af..c5440420fc1e 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -269,8 +269,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx Stmt) { if_chain! { - if let StmtDecl(ref d, _) = s.node; - if let DeclLocal(ref l) = d.node; + if let StmtKind::Decl(ref d, _) = s.node; + if let DeclKind::Local(ref l) = d.node; if let PatKind::Binding(an, _, i, None) = l.pat.node; if let Some(ref init) = l.init; then { @@ -303,9 +303,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } }; if_chain! { - if let StmtSemi(ref expr, _) = s.node; - if let Expr_::ExprBinary(ref binop, ref a, ref b) = expr.node; - if binop.node == BiAnd || binop.node == BiOr; + if let StmtKind::Semi(ref expr, _) = s.node; + if let ExprKind::Binary(ref binop, ref a, ref b) = expr.node; + if binop.node == BinOpKind::And || binop.node == BinOpKind::Or; if let Some(sugg) = Sugg::hir_opt(cx, a); then { span_lint_and_then(cx, @@ -313,7 +313,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { s.span, "boolean short circuit operator in statement may be clearer using an explicit test", |db| { - let sugg = if binop.node == BiOr { !sugg } else { sugg }; + let sugg = if binop.node == BinOpKind::Or { !sugg } else { sugg }; db.span_suggestion(s.span, "replace it with", format!("if {} {{ {}; }}", sugg, &snippet(cx, b.span, ".."))); }); @@ -323,23 +323,23 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { match expr.node { - ExprCast(ref e, ref ty) => { + ExprKind::Cast(ref e, ref ty) => { check_cast(cx, expr.span, e, ty); return; }, - ExprBinary(ref cmp, ref left, ref right) => { + ExprKind::Binary(ref cmp, ref left, ref right) => { let op = cmp.node; if op.is_comparison() { - if let ExprPath(QPath::Resolved(_, ref path)) = left.node { + if let ExprKind::Path(QPath::Resolved(_, ref path)) = left.node { check_nan(cx, path, expr); } - if let ExprPath(QPath::Resolved(_, ref path)) = right.node { + if let ExprKind::Path(QPath::Resolved(_, ref path)) = right.node { check_nan(cx, path, expr); } check_to_owned(cx, left, right); check_to_owned(cx, right, left); } - if (op == BiEq || op == BiNe) && (is_float(cx, left) || is_float(cx, right)) { + if (op == BinOpKind::Eq || op == BinOpKind::Ne) && (is_float(cx, left) || is_float(cx, right)) { if is_allowed(cx, left) || is_allowed(cx, right) { return; } @@ -367,7 +367,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { ); db.span_note(expr.span, "std::f32::EPSILON and std::f64::EPSILON are available."); }); - } else if op == BiRem && is_integer_literal(right, 1) { + } else if op == BinOpKind::Rem && is_integer_literal(right, 1) { span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0"); } }, @@ -378,7 +378,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { return; } let binding = match expr.node { - ExprPath(ref qpath) => { + ExprKind::Path(ref qpath) => { let binding = last_path_segment(qpath).ident.as_str(); if binding.starts_with('_') && !binding.starts_with("__") && @@ -392,7 +392,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { None } }, - ExprField(_, ident) => { + ExprKind::Field(_, ident) => { let name = ident.as_str(); if name.starts_with('_') && !name.starts_with("__") { Some(name) @@ -467,14 +467,14 @@ fn is_float(cx: &LateContext, expr: &Expr) -> bool { fn check_to_owned(cx: &LateContext, expr: &Expr, other: &Expr) { let (arg_ty, snip) = match expr.node { - ExprMethodCall(.., ref args) if args.len() == 1 => { + ExprKind::MethodCall(.., ref args) if args.len() == 1 => { if match_trait_method(cx, expr, &paths::TO_STRING) || match_trait_method(cx, expr, &paths::TO_OWNED) { (cx.tables.expr_ty_adjusted(&args[0]), snippet(cx, args[0].span, "..")) } else { return; } }, - ExprCall(ref path, ref v) if v.len() == 1 => if let ExprPath(ref path) = path.node { + ExprKind::Call(ref path, ref v) if v.len() == 1 => if let ExprKind::Path(ref path) = path.node { if match_qpath(path, &["String", "from_str"]) || match_qpath(path, &["String", "from"]) { (cx.tables.expr_ty_adjusted(&v[0]), snippet(cx, v[0].span, "..")) } else { @@ -520,7 +520,7 @@ fn check_to_owned(cx: &LateContext, expr: &Expr, other: &Expr) { let parent_impl = cx.tcx.hir.get_parent(parent_fn); if parent_impl != CRATE_NODE_ID { if let map::NodeItem(item) = cx.tcx.hir.get(parent_impl) { - if let ItemImpl(.., Some(ref trait_ref), _, _) = item.node { + if let ItemKind::Impl(.., Some(ref trait_ref), _, _) = item.node { if trait_ref.path.def.def_id() == partial_eq_trait_id { // we are implementing PartialEq, don't suggest not doing `to_owned`, otherwise // we go into @@ -542,7 +542,7 @@ fn check_to_owned(cx: &LateContext, expr: &Expr, other: &Expr) { fn is_used(cx: &LateContext, expr: &Expr) -> bool { if let Some(parent) = get_parent_expr(cx, expr) { match parent.node { - ExprAssign(_, ref rhs) | ExprAssignOp(_, _, ref rhs) => SpanlessEq::new(cx).eq_expr(rhs, expr), + ExprKind::Assign(_, ref rhs) | ExprKind::AssignOp(_, _, ref rhs) => SpanlessEq::new(cx).eq_expr(rhs, expr), _ => is_used(cx, parent), } } else { @@ -571,8 +571,8 @@ fn non_macro_local(cx: &LateContext, def: &def::Def) -> bool { fn check_cast(cx: &LateContext, span: Span, e: &Expr, ty: &Ty) { if_chain! { - if let TyPtr(MutTy { mutbl, .. }) = ty.node; - if let ExprLit(ref lit) = e.node; + if let TyKind::Ptr(MutTy { mutbl, .. }) = ty.node; + if let ExprKind::Lit(ref lit) = e.node; if let LitKind::Int(value, ..) = lit.node; if value == 0; if !in_constant(cx, e.id); diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs index ebb3869f48c5..eb4dfe8ba1c2 100644 --- a/clippy_lints/src/missing_doc.rs +++ b/clippy_lints/src/missing_doc.rs @@ -122,9 +122,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { 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", - hir::ItemFn(..) => { + hir::ItemKind::Const(..) => "a constant", + hir::ItemKind::Enum(..) => "an enum", + hir::ItemKind::Fn(..) => { // ignore main() if it.name == "main" { let def_id = cx.tcx.hir.local_def_id(it.id); @@ -135,19 +135,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { } "a function" }, - hir::ItemMod(..) => "a module", - hir::ItemStatic(..) => "a static", - hir::ItemStruct(..) => "a struct", - hir::ItemTrait(..) => "a trait", - hir::ItemTraitAlias(..) => "a trait alias", - hir::ItemGlobalAsm(..) => "an assembly blob", - hir::ItemTy(..) => "a type alias", - hir::ItemUnion(..) => "a union", - hir::ItemExistential(..) => "an existential type", - hir::ItemExternCrate(..) | - hir::ItemForeignMod(..) | - hir::ItemImpl(..) | - hir::ItemUse(..) => return, + hir::ItemKind::Mod(..) => "a module", + hir::ItemKind::Static(..) => "a static", + hir::ItemKind::Struct(..) => "a struct", + hir::ItemKind::Trait(..) => "a trait", + hir::ItemKind::TraitAlias(..) => "a trait alias", + hir::ItemKind::GlobalAsm(..) => "an assembly blob", + hir::ItemKind::Ty(..) => "a type alias", + hir::ItemKind::Union(..) => "a union", + hir::ItemKind::Existential(..) => "an existential type", + hir::ItemKind::ExternCrate(..) | + hir::ItemKind::ForeignMod(..) | + hir::ItemKind::Impl(..) | + hir::ItemKind::Use(..) => return, }; self.check_missing_docs_attrs(cx, &it.attrs, it.span, desc); diff --git a/clippy_lints/src/missing_inline.rs b/clippy_lints/src/missing_inline.rs index 6987eaa71d99..0ca1c53d696e 100644 --- a/clippy_lints/src/missing_inline.rs +++ b/clippy_lints/src/missing_inline.rs @@ -108,11 +108,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingInline { return; } match it.node { - hir::ItemFn(..) => { + hir::ItemKind::Fn(..) => { let desc = "a function"; check_missing_inline_attrs(cx, &it.attrs, it.span, desc); }, - hir::ItemTrait(ref _is_auto, ref _unsafe, ref _generics, + hir::ItemKind::Trait(ref _is_auto, ref _unsafe, ref _generics, ref _bounds, ref trait_items) => { // note: we need to check if the trait is exported so we can't use // `LateLintPass::check_trait_item` here. @@ -134,20 +134,20 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingInline { } } } - hir::ItemConst(..) | - hir::ItemEnum(..) | - hir::ItemMod(..) | - hir::ItemStatic(..) | - hir::ItemStruct(..) | - hir::ItemTraitAlias(..) | - hir::ItemGlobalAsm(..) | - hir::ItemTy(..) | - hir::ItemUnion(..) | - hir::ItemExistential(..) | - hir::ItemExternCrate(..) | - hir::ItemForeignMod(..) | - hir::ItemImpl(..) | - hir::ItemUse(..) => {}, + hir::ItemKind::Const(..) | + hir::ItemKind::Enum(..) | + hir::ItemKind::Mod(..) | + hir::ItemKind::Static(..) | + hir::ItemKind::Struct(..) | + hir::ItemKind::TraitAlias(..) | + hir::ItemKind::GlobalAsm(..) | + hir::ItemKind::Ty(..) | + hir::ItemKind::Union(..) | + hir::ItemKind::Existential(..) | + hir::ItemKind::ExternCrate(..) | + hir::ItemKind::ForeignMod(..) | + hir::ItemKind::Impl(..) | + hir::ItemKind::Use(..) => {}, }; } diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs index 26837313a063..ef08e60c4efe 100644 --- a/clippy_lints/src/mut_mut.rs +++ b/clippy_lints/src/mut_mut.rs @@ -62,8 +62,8 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> { // Let's ignore the generated code. intravisit::walk_expr(self, arg); intravisit::walk_expr(self, body); - } else if let hir::ExprAddrOf(hir::MutMutable, ref e) = expr.node { - if let hir::ExprAddrOf(hir::MutMutable, _) = e.node { + } else if let hir::ExprKind::AddrOf(hir::MutMutable, ref e) = expr.node { + if let hir::ExprKind::AddrOf(hir::MutMutable, _) = e.node { span_lint( self.cx, MUT_MUT, @@ -87,7 +87,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> { } fn visit_ty(&mut self, ty: &'tcx hir::Ty) { - if let hir::TyRptr( + if let hir::TyKind::Rptr( _, hir::MutTy { ty: ref pty, @@ -95,7 +95,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> { }, ) = ty.node { - if let hir::TyRptr( + if let hir::TyKind::Rptr( _, hir::MutTy { mutbl: hir::MutMutable, diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs index 4e9c5c815cce..b4d6652a65a4 100644 --- a/clippy_lints/src/mut_reference.rs +++ b/clippy_lints/src/mut_reference.rs @@ -36,7 +36,7 @@ impl LintPass for UnnecessaryMutPassed { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnecessaryMutPassed { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { match e.node { - ExprCall(ref fn_expr, ref arguments) => if let ExprPath(ref path) = fn_expr.node { + ExprKind::Call(ref fn_expr, ref arguments) => if let ExprKind::Path(ref path) = fn_expr.node { check_arguments( cx, arguments, @@ -44,7 +44,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnecessaryMutPassed { &print::to_string(print::NO_ANN, |s| s.print_qpath(path, false)), ); }, - ExprMethodCall(ref path, _, ref arguments) => { + ExprKind::MethodCall(ref path, _, ref arguments) => { let def_id = cx.tables.type_dependent_defs()[e.hir_id].def_id(); let substs = cx.tables.node_substs(e.hir_id); let method_type = cx.tcx.type_of(def_id).subst(cx.tcx, substs); @@ -69,7 +69,7 @@ fn check_arguments<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arguments: &[Expr], typ ty::TyRawPtr(ty::TypeAndMut { mutbl: MutImmutable, .. - }) => if let ExprAddrOf(MutMutable, _) = argument.node { + }) => if let ExprKind::AddrOf(MutMutable, _) = argument.node { span_lint( cx, UNNECESSARY_MUT_PASSED, diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs index 885cb4b72cb2..2fd5ff9a2464 100644 --- a/clippy_lints/src/needless_bool.rs +++ b/clippy_lints/src/needless_bool.rs @@ -60,7 +60,7 @@ impl LintPass for NeedlessBool { 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 { + if let ExprKind::If(ref pred, ref then_block, Some(ref else_expr)) = e.node { let reduce = |ret, not| { let snip = Sugg::hir(cx, pred, ""); let snip = if not { !snip } else { snip }; @@ -80,7 +80,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool { hint, ); }; - if let ExprBlock(ref then_block, _) = then_block.node { + if let ExprKind::Block(ref then_block, _) = then_block.node { match (fetch_bool_block(then_block), fetch_bool_expr(else_expr)) { (RetBool(true), RetBool(true)) | (Bool(true), Bool(true)) => { span_lint( @@ -105,7 +105,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBool { _ => (), } } else { - panic!("IfExpr 'then' node is not an ExprBlock"); + panic!("IfExpr 'then' node is not an ExprKind::Block"); } } } @@ -123,7 +123,7 @@ impl LintPass for BoolComparison { 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 { + if let ExprKind::Binary(Spanned { node: BinOpKind::Eq, .. }, ref left_side, ref right_side) = e.node { match (fetch_bool_expr(left_side), fetch_bool_expr(right_side)) { (Bool(true), Other) => { let hint = snippet(cx, right_side.span, "..").into_owned(); @@ -184,8 +184,8 @@ enum Expression { fn fetch_bool_block(block: &Block) -> Expression { match (&*block.stmts, block.expr.as_ref()) { (&[], Some(e)) => fetch_bool_expr(&**e), - (&[ref e], None) => if let StmtSemi(ref e, _) = e.node { - if let ExprRet(_) = e.node { + (&[ref e], None) => if let StmtKind::Semi(ref e, _) = e.node { + if let ExprKind::Ret(_) = e.node { fetch_bool_expr(&**e) } else { Expression::Other @@ -199,13 +199,13 @@ fn fetch_bool_block(block: &Block) -> Expression { fn fetch_bool_expr(expr: &Expr) -> Expression { match expr.node { - ExprBlock(ref block, _) => fetch_bool_block(block), - ExprLit(ref lit_ptr) => if let LitKind::Bool(value) = lit_ptr.node { + ExprKind::Block(ref block, _) => fetch_bool_block(block), + ExprKind::Lit(ref lit_ptr) => if let LitKind::Bool(value) = lit_ptr.node { Expression::Bool(value) } else { Expression::Other }, - ExprRet(Some(ref expr)) => match fetch_bool_expr(expr) { + ExprKind::Ret(Some(ref expr)) => match fetch_bool_expr(expr) { Expression::Bool(value) => Expression::RetBool(value), _ => Expression::Other, }, diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs index 84d5292d8c51..90e41bc6f68a 100644 --- a/clippy_lints/src/needless_borrow.rs +++ b/clippy_lints/src/needless_borrow.rs @@ -3,7 +3,7 @@ //! This lint is **warn** by default use rustc::lint::*; -use rustc::hir::{BindingAnnotation, Expr, ExprAddrOf, MutImmutable, Pat, PatKind}; +use rustc::hir::{BindingAnnotation, Expr, ExprKind, MutImmutable, Pat, PatKind}; use rustc::ty; use rustc::ty::adjustment::{Adjust, Adjustment}; use crate::utils::{in_macro, snippet_opt, span_lint_and_then}; @@ -40,7 +40,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrow { if in_macro(e.span) { return; } - if let ExprAddrOf(MutImmutable, ref inner) = e.node { + if let ExprKind::AddrOf(MutImmutable, ref inner) = e.node { if let ty::TyRef(..) = cx.tables.expr_ty(inner).sty { for adj3 in cx.tables.expr_adjustments(e).windows(3) { if let [Adjustment { diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs index bdef092b5332..fa0586c1548a 100644 --- a/clippy_lints/src/needless_pass_by_value.rs +++ b/clippy_lints/src/needless_pass_by_value.rs @@ -88,8 +88,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue { // Exclude non-inherent impls if let Some(NodeItem(item)) = cx.tcx.hir.find(cx.tcx.hir.get_parent_node(node_id)) { - if matches!(item.node, ItemImpl(_, _, _, _, Some(_), _, _) | - ItemTrait(..)) + if matches!(item.node, ItemKind::Impl(_, _, _, _, Some(_), _, _) | + ItemKind::Trait(..)) { return; } @@ -215,7 +215,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue { if match_type(cx, ty, &paths::VEC); if let Some(clone_spans) = get_spans(cx, Some(body.id()), idx, &[("clone", ".to_owned()")]); - if let TyPath(QPath::Resolved(_, ref path)) = input.node; + if let TyKind::Path(QPath::Resolved(_, ref path)) = input.node; if let Some(elem_ty) = path.segments.iter() .find(|seg| seg.ident.name == "Vec") .and_then(|ps| ps.args.as_ref()) @@ -339,7 +339,7 @@ impl<'a, 'tcx> MovedVariablesCtxt<'a, 'tcx> { match node { map::Node::NodeExpr(e) => { // `match` and `if let` - if let ExprMatch(ref c, ..) = e.node { + if let ExprKind::Match(ref c, ..) = e.node { self.spans_need_deref .entry(vid) .or_insert_with(HashSet::new) @@ -350,8 +350,8 @@ impl<'a, 'tcx> MovedVariablesCtxt<'a, 'tcx> { map::Node::NodeStmt(s) => { // `let = x;` if_chain! { - if let StmtDecl(ref decl, _) = s.node; - if let DeclLocal(ref local) = decl.node; + if let StmtKind::Decl(ref decl, _) = s.node; + if let DeclKind::Local(ref local) = decl.node; then { self.spans_need_deref .entry(vid) diff --git a/clippy_lints/src/needless_update.rs b/clippy_lints/src/needless_update.rs index 87b92a53dd02..9c670c1a5b3e 100644 --- a/clippy_lints/src/needless_update.rs +++ b/clippy_lints/src/needless_update.rs @@ -1,6 +1,6 @@ use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; use rustc::ty; -use rustc::hir::{Expr, ExprStruct}; +use rustc::hir::{Expr, ExprKind}; use crate::utils::span_lint; /// **What it does:** Checks for needlessly including a base struct on update @@ -32,7 +32,7 @@ impl LintPass for Pass { 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 { + if let ExprKind::Struct(_, ref fields, Some(ref base)) = expr.node { let ty = cx.tables.expr_ty(expr); if let ty::TyAdt(def, _) = ty.sty { if fields.len() == def.non_enum_variant().fields.len() { diff --git a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs index 013bab69d798..e0374b80dd81 100644 --- a/clippy_lints/src/neg_cmp_op_on_partial_ord.rs +++ b/clippy_lints/src/neg_cmp_op_on_partial_ord.rs @@ -18,20 +18,20 @@ use crate::utils::{self, paths, span_lint, in_external_macro}; /// /// ```rust /// use core::cmp::Ordering; -/// +/// /// // Bad /// let a = 1.0; /// let b = std::f64::NAN; -/// +/// /// let _not_less_or_equal = !(a <= b); /// /// // Good /// let a = 1.0; /// let b = std::f64::NAN; -/// +/// /// let _not_less_or_equal = match a.partial_cmp(&b) { /// None | Some(Ordering::Greater) => true, -/// _ => false, +/// _ => false, /// }; /// ``` declare_clippy_lint! { @@ -54,9 +54,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NoNegCompOpForPartialOrd { if_chain! { if !in_external_macro(cx, expr.span); - if let Expr_::ExprUnary(UnOp::UnNot, ref inner) = expr.node; - if let Expr_::ExprBinary(ref op, ref left, _) = inner.node; - if let BinOp_::BiLe | BinOp_::BiGe | BinOp_::BiLt | BinOp_::BiGt = op.node; + if let ExprKind::Unary(UnOp::UnNot, ref inner) = expr.node; + if let ExprKind::Binary(ref op, ref left, _) = inner.node; + if let BinOpKind::Le | BinOpKind::Ge | BinOpKind::Lt | BinOpKind::Gt = op.node; then { diff --git a/clippy_lints/src/neg_multiply.rs b/clippy_lints/src/neg_multiply.rs index efcc1695eb6a..e30ac8695dc8 100644 --- a/clippy_lints/src/neg_multiply.rs +++ b/clippy_lints/src/neg_multiply.rs @@ -33,11 +33,11 @@ impl LintPass for NegMultiply { #[allow(match_same_arms)] 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 { + if let ExprKind::Binary(Spanned { node: BinOpKind::Mul, .. }, ref l, ref r) = e.node { match (&l.node, &r.node) { - (&ExprUnary(..), &ExprUnary(..)) => (), - (&ExprUnary(UnNeg, ref lit), _) => check_mul(cx, e.span, lit, r), - (_, &ExprUnary(UnNeg, ref lit)) => check_mul(cx, e.span, lit, l), + (&ExprKind::Unary(..), &ExprKind::Unary(..)) => (), + (&ExprKind::Unary(UnNeg, ref lit), _) => check_mul(cx, e.span, lit, r), + (_, &ExprKind::Unary(UnNeg, ref lit)) => check_mul(cx, e.span, lit, l), _ => (), } } @@ -46,7 +46,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NegMultiply { fn check_mul(cx: &LateContext, span: Span, lit: &Expr, exp: &Expr) { if_chain! { - if let ExprLit(ref l) = lit.node; + if let ExprKind::Lit(ref l) = lit.node; if let Constant::Int(val) = consts::lit_to_constant(&l.node, cx.tables.expr_ty(lit)); if val == 1; if cx.tables.expr_ty(exp).is_integral(); diff --git a/clippy_lints/src/new_without_default.rs b/clippy_lints/src/new_without_default.rs index 3f7cbaa6ca16..6be340a99f4a 100644 --- a/clippy_lints/src/new_without_default.rs +++ b/clippy_lints/src/new_without_default.rs @@ -89,7 +89,7 @@ impl LintPass for NewWithoutDefault { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NewWithoutDefault { fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) { - if let hir::ItemImpl(_, _, _, _, None, _, ref items) = item.node { + if let hir::ItemKind::Impl(_, _, _, _, None, _, ref items) = item.node { for assoc_item in items { if let hir::AssociatedItemKind::Method { has_self: false } = assoc_item.kind { let impl_item = cx.tcx.hir.impl_item(assoc_item.id); diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs index 8d351f874213..5180ff348778 100644 --- a/clippy_lints/src/no_effect.rs +++ b/clippy_lints/src/no_effect.rs @@ -1,6 +1,6 @@ use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; use rustc::hir::def::Def; -use rustc::hir::{BiAnd, BiOr, BlockCheckMode, Expr, Expr_, Stmt, StmtSemi, UnsafeSource}; +use rustc::hir::{BinOpKind, BlockCheckMode, Expr, ExprKind, Stmt, StmtKind, UnsafeSource}; use crate::utils::{has_drop, in_macro, snippet_opt, span_lint, span_lint_and_sugg}; use std::ops::Deref; @@ -45,26 +45,26 @@ fn has_no_effect(cx: &LateContext, expr: &Expr) -> bool { return false; } match expr.node { - Expr_::ExprLit(..) | Expr_::ExprClosure(.., _) => true, - Expr_::ExprPath(..) => !has_drop(cx, expr), - Expr_::ExprIndex(ref a, ref b) | Expr_::ExprBinary(_, ref a, ref b) => { + ExprKind::Lit(..) | ExprKind::Closure(.., _) => true, + ExprKind::Path(..) => !has_drop(cx, expr), + ExprKind::Index(ref a, ref b) | ExprKind::Binary(_, ref a, ref b) => { has_no_effect(cx, a) && has_no_effect(cx, b) }, - Expr_::ExprArray(ref v) | Expr_::ExprTup(ref v) => v.iter().all(|val| has_no_effect(cx, val)), - Expr_::ExprRepeat(ref inner, _) | - Expr_::ExprCast(ref inner, _) | - Expr_::ExprType(ref inner, _) | - Expr_::ExprUnary(_, ref inner) | - Expr_::ExprField(ref inner, _) | - Expr_::ExprAddrOf(_, ref inner) | - Expr_::ExprBox(ref inner) => has_no_effect(cx, inner), - Expr_::ExprStruct(_, ref fields, ref base) => { + ExprKind::Array(ref v) | ExprKind::Tup(ref v) => v.iter().all(|val| has_no_effect(cx, val)), + ExprKind::Repeat(ref inner, _) | + ExprKind::Cast(ref inner, _) | + ExprKind::Type(ref inner, _) | + ExprKind::Unary(_, ref inner) | + ExprKind::Field(ref inner, _) | + ExprKind::AddrOf(_, ref inner) | + ExprKind::Box(ref inner) => has_no_effect(cx, inner), + ExprKind::Struct(_, ref fields, ref base) => { !has_drop(cx, expr) && fields.iter().all(|field| has_no_effect(cx, &field.expr)) && match *base { Some(ref base) => has_no_effect(cx, base), None => true, } }, - Expr_::ExprCall(ref callee, ref args) => if let Expr_::ExprPath(ref qpath) = callee.node { + ExprKind::Call(ref callee, ref args) => if let ExprKind::Path(ref qpath) = callee.node { let def = cx.tables.qpath_def(qpath, callee.hir_id); match def { Def::Struct(..) | Def::Variant(..) | Def::StructCtor(..) | Def::VariantCtor(..) => { @@ -75,7 +75,7 @@ fn has_no_effect(cx: &LateContext, expr: &Expr) -> bool { } else { false }, - Expr_::ExprBlock(ref block, _) => { + ExprKind::Block(ref block, _) => { block.stmts.is_empty() && if let Some(ref expr) = block.expr { has_no_effect(cx, expr) } else { @@ -97,7 +97,7 @@ impl LintPass for Pass { 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 let StmtKind::Semi(ref expr, _) = stmt.node { if has_no_effect(cx, expr) { span_lint(cx, NO_EFFECT, stmt.span, "statement with no effect"); } else if let Some(reduced) = reduce_expression(cx, expr) { @@ -132,19 +132,19 @@ fn reduce_expression<'a>(cx: &LateContext, expr: &'a Expr) -> Option Some(vec![&**a, &**b]), - Expr_::ExprBinary(ref binop, ref a, ref b) if binop.node != BiAnd && binop.node != BiOr => { + ExprKind::Index(ref a, ref b) => Some(vec![&**a, &**b]), + ExprKind::Binary(ref binop, ref a, ref b) if binop.node != BinOpKind::And && binop.node != BinOpKind::Or => { Some(vec![&**a, &**b]) }, - Expr_::ExprArray(ref v) | Expr_::ExprTup(ref v) => Some(v.iter().collect()), - Expr_::ExprRepeat(ref inner, _) | - Expr_::ExprCast(ref inner, _) | - Expr_::ExprType(ref inner, _) | - Expr_::ExprUnary(_, ref inner) | - Expr_::ExprField(ref inner, _) | - Expr_::ExprAddrOf(_, ref inner) | - Expr_::ExprBox(ref inner) => reduce_expression(cx, inner).or_else(|| Some(vec![inner])), - Expr_::ExprStruct(_, ref fields, ref base) => if has_drop(cx, expr) { + ExprKind::Array(ref v) | ExprKind::Tup(ref v) => Some(v.iter().collect()), + ExprKind::Repeat(ref inner, _) | + ExprKind::Cast(ref inner, _) | + ExprKind::Type(ref inner, _) | + ExprKind::Unary(_, ref inner) | + ExprKind::Field(ref inner, _) | + ExprKind::AddrOf(_, ref inner) | + ExprKind::Box(ref inner) => reduce_expression(cx, inner).or_else(|| Some(vec![inner])), + ExprKind::Struct(_, ref fields, ref base) => if has_drop(cx, expr) { None } else { Some( @@ -156,7 +156,7 @@ fn reduce_expression<'a>(cx: &LateContext, expr: &'a Expr) -> Option if let Expr_::ExprPath(ref qpath) = callee.node { + ExprKind::Call(ref callee, ref args) => if let ExprKind::Path(ref qpath) = callee.node { let def = cx.tables.qpath_def(qpath, callee.hir_id); match def { Def::Struct(..) | Def::Variant(..) | Def::StructCtor(..) | Def::VariantCtor(..) @@ -169,7 +169,7 @@ fn reduce_expression<'a>(cx: &LateContext, expr: &'a Expr) -> Option { + ExprKind::Block(ref block, _) => { if block.stmts.is_empty() { block.expr.as_ref().and_then(|e| { match block.rules { diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs index 47c84fec6ae1..981451947bfe 100644 --- a/clippy_lints/src/non_copy_const.rs +++ b/clippy_lints/src/non_copy_const.rs @@ -164,7 +164,7 @@ impl LintPass for NonCopyConst { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonCopyConst { fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx Item) { - if let ItemConst(hir_ty, ..) = &it.node { + if let ItemKind::Const(hir_ty, ..) = &it.node { let ty = hir_ty_to_ty(cx.tcx, hir_ty); verify_ty_bound(cx, ty, Source::Item { item: it.span }); } @@ -182,7 +182,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonCopyConst { let item_node_id = cx.tcx.hir.get_parent_node(impl_item.id); let item = cx.tcx.hir.expect_item(item_node_id); // ensure the impl is an inherent impl. - if let ItemImpl(_, _, _, _, None, _, _) = item.node { + if let ItemKind::Impl(_, _, _, _, None, _, _) = item.node { let ty = hir_ty_to_ty(cx.tcx, hir_ty); verify_ty_bound(cx, ty, Source::Assoc { ty: hir_ty.span, item: impl_item.span }); } @@ -190,7 +190,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonCopyConst { } fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { - if let ExprPath(qpath) = &expr.node { + if let ExprKind::Path(qpath) = &expr.node { // Only lint if we use the const item inside a function. if in_constant(cx, expr.id) { return; @@ -213,22 +213,22 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonCopyConst { } if let Some(map::NodeExpr(parent_expr)) = cx.tcx.hir.find(parent_id) { match &parent_expr.node { - ExprAddrOf(..) => { + ExprKind::AddrOf(..) => { // `&e` => `e` must be referenced needs_check_adjustment = false; } - ExprField(..) => { + ExprKind::Field(..) => { dereferenced_expr = parent_expr; needs_check_adjustment = true; } - ExprIndex(e, _) if ptr::eq(&**e, cur_expr) => { + ExprKind::Index(e, _) if ptr::eq(&**e, cur_expr) => { // `e[i]` => desugared to `*Index::index(&e, i)`, // meaning `e` must be referenced. // no need to go further up since a method call is involved now. needs_check_adjustment = false; break; } - ExprUnary(UnDeref, _) => { + ExprKind::Unary(UnDeref, _) => { // `*e` => desugared to `*Deref::deref(&e)`, // meaning `e` must be referenced. // no need to go further up since a method call is involved now. diff --git a/clippy_lints/src/ok_if_let.rs b/clippy_lints/src/ok_if_let.rs index a2573b91f961..0a1399075e06 100644 --- a/clippy_lints/src/ok_if_let.rs +++ b/clippy_lints/src/ok_if_let.rs @@ -44,9 +44,9 @@ impl LintPass for Pass { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_chain! { //begin checking variables - if let ExprMatch(ref op, ref body, ref source) = expr.node; //test if expr is a match + if let ExprKind::Match(ref op, ref body, ref source) = expr.node; //test if expr is a match if let MatchSource::IfLetDesugar { .. } = *source; //test if it is an If Let - if let ExprMethodCall(_, _, ref result_types) = op.node; //check is expr.ok() has type Result.ok() + if let ExprKind::MethodCall(_, _, ref result_types) = op.node; //check is expr.ok() has type Result.ok() if let PatKind::TupleStruct(QPath::Resolved(_, ref x), ref y, _) = body[0].pats[0].node; //get operation if method_chain_args(op, &["ok"]).is_some(); //test to see if using ok() methoduse std::marker::Sized; diff --git a/clippy_lints/src/open_options.rs b/clippy_lints/src/open_options.rs index fbece8226597..b4559969ac24 100644 --- a/clippy_lints/src/open_options.rs +++ b/clippy_lints/src/open_options.rs @@ -1,4 +1,4 @@ -use rustc::hir::{Expr, ExprLit, ExprMethodCall}; +use rustc::hir::{Expr, ExprKind}; use rustc::lint::*; use syntax::ast::LitKind; use syntax::codemap::{Span, Spanned}; @@ -33,7 +33,7 @@ impl LintPass for NonSensical { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSensical { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) { - if let ExprMethodCall(ref path, _, ref arguments) = e.node { + if let ExprKind::MethodCall(ref path, _, ref arguments) = e.node { let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&arguments[0])); if path.ident.name == "open" && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) { let mut options = Vec::new(); @@ -61,13 +61,13 @@ enum OpenOption { } fn get_open_options(cx: &LateContext, argument: &Expr, options: &mut Vec<(OpenOption, Argument)>) { - if let ExprMethodCall(ref path, _, ref arguments) = argument.node { + if let ExprKind::MethodCall(ref path, _, ref arguments) = argument.node { let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&arguments[0])); // Only proceed if this is a call on some object of type std::fs::OpenOptions if match_type(cx, obj_ty, &paths::OPEN_OPTIONS) && arguments.len() >= 2 { let argument_option = match arguments[1].node { - ExprLit(ref span) => { + ExprKind::Lit(ref span) => { if let Spanned { node: LitKind::Bool(lit), .. diff --git a/clippy_lints/src/overflow_check_conditional.rs b/clippy_lints/src/overflow_check_conditional.rs index c5b0c9779566..8783055b31ee 100644 --- a/clippy_lints/src/overflow_check_conditional.rs +++ b/clippy_lints/src/overflow_check_conditional.rs @@ -33,23 +33,23 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OverflowCheckConditional { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { let eq = |l, r| SpanlessEq::new(cx).eq_path_segment(l, r); if_chain! { - if let Expr_::ExprBinary(ref op, ref first, ref second) = expr.node; - if let Expr_::ExprBinary(ref op2, ref ident1, ref ident2) = first.node; - if let Expr_::ExprPath(QPath::Resolved(_, ref path1)) = ident1.node; - if let Expr_::ExprPath(QPath::Resolved(_, ref path2)) = ident2.node; - if let Expr_::ExprPath(QPath::Resolved(_, ref path3)) = second.node; + if let ExprKind::Binary(ref op, ref first, ref second) = expr.node; + if let ExprKind::Binary(ref op2, ref ident1, ref ident2) = first.node; + if let ExprKind::Path(QPath::Resolved(_, ref path1)) = ident1.node; + if let ExprKind::Path(QPath::Resolved(_, ref path2)) = ident2.node; + if let ExprKind::Path(QPath::Resolved(_, ref path3)) = second.node; if eq(&path1.segments[0], &path3.segments[0]) || eq(&path2.segments[0], &path3.segments[0]); if cx.tables.expr_ty(ident1).is_integral(); if cx.tables.expr_ty(ident2).is_integral(); then { - if let BinOp_::BiLt = op.node { - if let BinOp_::BiAdd = op2.node { + if let BinOpKind::Lt = op.node { + if let BinOpKind::Add = op2.node { span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C overflow conditions that will fail in Rust."); } } - if let BinOp_::BiGt = op.node { - if let BinOp_::BiSub = op2.node { + if let BinOpKind::Gt = op.node { + if let BinOpKind::Sub = op2.node { span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C underflow conditions that will fail in Rust."); } @@ -58,23 +58,23 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OverflowCheckConditional { } if_chain! { - if let Expr_::ExprBinary(ref op, ref first, ref second) = expr.node; - if let Expr_::ExprBinary(ref op2, ref ident1, ref ident2) = second.node; - if let Expr_::ExprPath(QPath::Resolved(_, ref path1)) = ident1.node; - if let Expr_::ExprPath(QPath::Resolved(_, ref path2)) = ident2.node; - if let Expr_::ExprPath(QPath::Resolved(_, ref path3)) = first.node; + if let ExprKind::Binary(ref op, ref first, ref second) = expr.node; + if let ExprKind::Binary(ref op2, ref ident1, ref ident2) = second.node; + if let ExprKind::Path(QPath::Resolved(_, ref path1)) = ident1.node; + if let ExprKind::Path(QPath::Resolved(_, ref path2)) = ident2.node; + if let ExprKind::Path(QPath::Resolved(_, ref path3)) = first.node; if eq(&path1.segments[0], &path3.segments[0]) || eq(&path2.segments[0], &path3.segments[0]); if cx.tables.expr_ty(ident1).is_integral(); if cx.tables.expr_ty(ident2).is_integral(); then { - if let BinOp_::BiGt = op.node { - if let BinOp_::BiAdd = op2.node { + if let BinOpKind::Gt = op.node { + if let BinOpKind::Add = op2.node { span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C overflow conditions that will fail in Rust."); } } - if let BinOp_::BiLt = op.node { - if let BinOp_::BiSub = op2.node { + if let BinOpKind::Lt = op.node { + if let BinOpKind::Sub = op2.node { span_lint(cx, OVERFLOW_CHECK_CONDITIONAL, expr.span, "You are trying to use classic C underflow conditions that will fail in Rust."); } diff --git a/clippy_lints/src/panic_unimplemented.rs b/clippy_lints/src/panic_unimplemented.rs index f00a15dd4012..24cf6544f6a0 100644 --- a/clippy_lints/src/panic_unimplemented.rs +++ b/clippy_lints/src/panic_unimplemented.rs @@ -52,10 +52,10 @@ impl LintPass for Pass { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_chain! { - if let ExprBlock(ref block, _) = expr.node; + if let ExprKind::Block(ref block, _) = expr.node; if let Some(ref ex) = block.expr; - if let ExprCall(ref fun, ref params) = ex.node; - if let ExprPath(ref qpath) = fun.node; + if let ExprKind::Call(ref fun, ref params) = ex.node; + if let ExprKind::Path(ref qpath) = fun.node; if let Some(fun_def_id) = opt_def_id(resolve_node(cx, qpath, fun.hir_id)); if match_def_path(cx.tcx, fun_def_id, &paths::BEGIN_PANIC); if params.len() == 2; @@ -86,7 +86,7 @@ fn get_outer_span(expr: &Expr) -> Span { fn match_panic(params: &P<[Expr]>, expr: &Expr, cx: &LateContext) { if_chain! { - if let ExprLit(ref lit) = params[0].node; + if let ExprKind::Lit(ref lit) = params[0].node; if is_direct_expn_of(expr.span, "panic").is_some(); if let LitKind::Str(ref string, _) = lit.node; let string = string.as_str().replace("{{", "").replace("}}", ""); diff --git a/clippy_lints/src/partialeq_ne_impl.rs b/clippy_lints/src/partialeq_ne_impl.rs index 1d9260e2aa79..2d283b96f867 100644 --- a/clippy_lints/src/partialeq_ne_impl.rs +++ b/clippy_lints/src/partialeq_ne_impl.rs @@ -38,7 +38,7 @@ impl LintPass for Pass { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { if_chain! { - if let ItemImpl(_, _, _, _, Some(ref trait_ref), _, ref impl_items) = item.node; + if let ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, ref impl_items) = item.node; if !is_automatically_derived(&*item.attrs); if let Some(eq_trait) = cx.tcx.lang_items().eq_trait(); if trait_ref.path.def.def_id() == eq_trait; diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index 68cecc8de678..22804764d8aa 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -103,7 +103,7 @@ impl LintPass for PointerPass { 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, _, _, body_id) = item.node { + if let ItemKind::Fn(ref decl, _, _, body_id) = item.node { check_fn(cx, decl, item.id, Some(body_id)); } } @@ -111,7 +111,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PointerPass { fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) { if let ImplItemKind::Method(ref sig, body_id) = item.node { if let Some(NodeItem(it)) = cx.tcx.hir.find(cx.tcx.hir.get_parent(item.id)) { - if let ItemImpl(_, _, _, _, Some(_), _, _) = it.node { + if let ItemKind::Impl(_, _, _, _, Some(_), _, _) = it.node { return; // ignore trait impls } } @@ -131,8 +131,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PointerPass { } 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)) { + if let ExprKind::Binary(ref op, ref l, ref r) = expr.node { + if (op.node == BinOpKind::Eq || op.node == BinOpKind::Ne) && (is_null_path(l) || is_null_path(r)) { span_lint( cx, CMP_NULL, @@ -159,7 +159,7 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, fn_id: NodeId, opt_body_id: Option< if match_type(cx, ty, &paths::VEC) { let mut ty_snippet = None; if_chain! { - if let TyPath(QPath::Resolved(_, ref path)) = walk_ptrs_hir_ty(arg).node; + if let TyKind::Path(QPath::Resolved(_, ref path)) = walk_ptrs_hir_ty(arg).node; if let Some(&PathSegment{args: Some(ref parameters), ..}) = path.segments.last(); then { let types: Vec<_> = parameters.args.iter().filter_map(|arg| match arg { @@ -219,8 +219,8 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, fn_id: NodeId, opt_body_id: Option< } } else if match_type(cx, ty, &paths::COW) { if_chain! { - if let TyRptr(_, MutTy { ref ty, ..} ) = arg.node; - if let TyPath(ref path) = ty.node; + if let TyKind::Rptr(_, MutTy { ref ty, ..} ) = arg.node; + if let TyKind::Path(ref path) = ty.node; if let QPath::Resolved(None, ref pp) = *path; if let [ref bx] = *pp.segments; if let Some(ref params) = bx.args; @@ -273,7 +273,7 @@ fn check_fn(cx: &LateContext, decl: &FnDecl, fn_id: NodeId, opt_body_id: Option< } fn get_rptr_lm(ty: &Ty) -> Option<(&Lifetime, Mutability, Span)> { - if let Ty_::TyRptr(ref lt, ref m) = ty.node { + if let TyKind::Rptr(ref lt, ref m) = ty.node { Some((lt, m.mutbl, ty.span)) } else { None @@ -281,9 +281,9 @@ fn get_rptr_lm(ty: &Ty) -> Option<(&Lifetime, Mutability, Span)> { } fn is_null_path(expr: &Expr) -> bool { - if let ExprCall(ref pathexp, ref args) = expr.node { + if let ExprKind::Call(ref pathexp, ref args) = expr.node { if args.is_empty() { - if let ExprPath(ref path) = pathexp.node { + if let ExprKind::Path(ref path) = pathexp.node { return match_qpath(path, &paths::PTR_NULL) || match_qpath(path, &paths::PTR_NULL_MUT); } } diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs index d12f6ddd15a4..b8e7a2646c48 100644 --- a/clippy_lints/src/question_mark.rs +++ b/clippy_lints/src/question_mark.rs @@ -52,8 +52,8 @@ impl QuestionMarkPass { /// If it matches, it will suggest to use the question mark operator instead fn check_is_none_and_early_return_none(cx: &LateContext, expr: &Expr) { if_chain! { - if let ExprIf(ref if_expr, ref body, _) = expr.node; - if let ExprMethodCall(ref segment, _, ref args) = if_expr.node; + if let ExprKind::If(ref if_expr, ref body, _) = expr.node; + if let ExprKind::MethodCall(ref segment, _, ref args) = if_expr.node; if segment.ident.name == "is_none"; if Self::expression_returns_none(cx, body); if let Some(subject) = args.get(0); @@ -87,17 +87,17 @@ impl QuestionMarkPass { fn expression_returns_none(cx: &LateContext, expression: &Expr) -> bool { match expression.node { - ExprBlock(ref block, _) => { + ExprKind::Block(ref block, _) => { if let Some(return_expression) = Self::return_expression(block) { return Self::expression_returns_none(cx, &return_expression); } false }, - ExprRet(Some(ref expr)) => { + ExprKind::Ret(Some(ref expr)) => { Self::expression_returns_none(cx, expr) }, - ExprPath(ref qp) => { + ExprKind::Path(ref qp) => { if let Def::VariantCtor(def_id, _) = cx.tables.qpath_def(qp, expression.hir_id) { return match_def_path(cx.tcx, def_id, &OPTION_NONE); } @@ -113,8 +113,8 @@ impl QuestionMarkPass { if_chain! { if block.stmts.len() == 1; if let Some(expr) = block.stmts.iter().last(); - if let StmtSemi(ref expr, _) = expr.node; - if let ExprRet(ref ret_expr) = expr.node; + if let StmtKind::Semi(ref expr, _) = expr.node; + if let ExprKind::Ret(ref ret_expr) = expr.node; if let &Some(ref ret_expr) = ret_expr; then { diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs index c0fac47b34e8..2fb3bf5182cd 100644 --- a/clippy_lints/src/ranges.rs +++ b/clippy_lints/src/ranges.rs @@ -88,7 +88,7 @@ impl LintPass for Pass { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { - if let ExprMethodCall(ref path, _, ref args) = expr.node { + if let ExprKind::MethodCall(ref path, _, ref args) = expr.node { let name = path.ident.as_str(); // Range with step_by(0). @@ -107,17 +107,17 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { let zip_arg = &args[1]; if_chain! { // .iter() call - if let ExprMethodCall(ref iter_path, _, ref iter_args ) = *iter; + if let ExprKind::MethodCall(ref iter_path, _, ref iter_args ) = *iter; if iter_path.ident.name == "iter"; // range expression in .zip() call: 0..x.len() if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::range(cx, zip_arg); if is_integer_literal(start, 0); // .len() call - if let ExprMethodCall(ref len_path, _, ref len_args) = end.node; + if let ExprKind::MethodCall(ref len_path, _, ref len_args) = end.node; if len_path.ident.name == "len" && len_args.len() == 1; // .iter() and .len() called on same Path - if let ExprPath(QPath::Resolved(_, ref iter_path)) = iter_args[0].node; - if let ExprPath(QPath::Resolved(_, ref len_path)) = len_args[0].node; + if let ExprKind::Path(QPath::Resolved(_, ref iter_path)) = iter_args[0].node; + if let ExprKind::Path(QPath::Resolved(_, ref len_path)) = len_args[0].node; if SpanlessEq::new(cx).eq_path_segments(&iter_path.segments, &len_path.segments); then { span_lint(cx, @@ -184,7 +184,7 @@ fn has_step_by(cx: &LateContext, expr: &Expr) -> bool { fn y_plus_one(expr: &Expr) -> Option<&Expr> { match expr.node { - ExprBinary(Spanned { node: BiAdd, .. }, ref lhs, ref rhs) => if is_integer_literal(lhs, 1) { + ExprKind::Binary(Spanned { node: BinOpKind::Add, .. }, ref lhs, ref rhs) => if is_integer_literal(lhs, 1) { Some(rhs) } else if is_integer_literal(rhs, 1) { Some(lhs) @@ -197,7 +197,7 @@ fn y_plus_one(expr: &Expr) -> Option<&Expr> { fn y_minus_one(expr: &Expr) -> Option<&Expr> { match expr.node { - ExprBinary(Spanned { node: BiSub, .. }, ref lhs, ref rhs) if is_integer_literal(rhs, 1) => Some(lhs), + ExprKind::Binary(Spanned { node: BinOpKind::Sub, .. }, ref lhs, ref rhs) if is_integer_literal(rhs, 1) => Some(lhs), _ => None, } } diff --git a/clippy_lints/src/redundant_field_names.rs b/clippy_lints/src/redundant_field_names.rs index e63e978e26b7..d179bffd59ad 100644 --- a/clippy_lints/src/redundant_field_names.rs +++ b/clippy_lints/src/redundant_field_names.rs @@ -43,7 +43,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RedundantFieldNames { return; } - if let ExprStruct(_, ref fields, _) = expr.node { + if let ExprKind::Struct(_, ref fields, _) = expr.node { for field in fields { let name = field.ident.name; diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs index 6395125578c7..fbead26a03b0 100644 --- a/clippy_lints/src/regex.rs +++ b/clippy_lints/src/regex.rs @@ -108,8 +108,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { if_chain! { - if let ExprCall(ref fun, ref args) = expr.node; - if let ExprPath(ref qpath) = fun.node; + if let ExprKind::Call(ref fun, ref args) = expr.node; + if let ExprKind::Path(ref qpath) = fun.node; if args.len() == 1; if let Some(def_id) = opt_def_id(cx.tables.qpath_def(qpath, fun.hir_id)); then { @@ -176,8 +176,8 @@ fn is_trivial_regex(s: ®ex_syntax::hir::Hir) -> Option<&'static str> { fn check_set<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, utf8: bool) { if_chain! { - if let ExprAddrOf(_, ref expr) = expr.node; - if let ExprArray(ref exprs) = expr.node; + if let ExprKind::AddrOf(_, ref expr) = expr.node; + if let ExprKind::Array(ref exprs) = expr.node; then { for expr in exprs { check_regex(cx, expr, utf8); @@ -192,7 +192,7 @@ fn check_regex<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, utf8: boo .allow_invalid_utf8(!utf8) .build(); - if let ExprLit(ref lit) = expr.node { + if let ExprKind::Lit(ref lit) = expr.node { if let LitKind::Str(ref r, style) = lit.node { let r = &r.as_str(); let offset = if let StrStyle::Raw(n) = style { 2 + n } else { 1 }; diff --git a/clippy_lints/src/replace_consts.rs b/clippy_lints/src/replace_consts.rs index d6d9125a49ca..f149e3248772 100644 --- a/clippy_lints/src/replace_consts.rs +++ b/clippy_lints/src/replace_consts.rs @@ -37,7 +37,7 @@ impl LintPass for ReplaceConsts { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ReplaceConsts { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { if_chain! { - if let hir::ExprPath(ref qp) = expr.node; + if let hir::ExprKind::Path(ref qp) = expr.node; if let Def::Const(def_id) = cx.tables.qpath_def(qp, expr.hir_id); then { for &(const_path, repl_snip) in REPLACEMENTS { diff --git a/clippy_lints/src/serde_api.rs b/clippy_lints/src/serde_api.rs index a4bdd89a0378..55c51307e04d 100644 --- a/clippy_lints/src/serde_api.rs +++ b/clippy_lints/src/serde_api.rs @@ -29,7 +29,7 @@ impl LintPass for Serde { 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 { + if let ItemKind::Impl(_, _, _, _, 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) { if did == visit_did { diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs index d37023e4f8c8..cc08e1ee816f 100644 --- a/clippy_lints/src/shadow.rs +++ b/clippy_lints/src/shadow.rs @@ -110,8 +110,8 @@ fn check_block<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, block: &'tcx Block, binding let len = bindings.len(); for stmt in &block.stmts { match stmt.node { - StmtDecl(ref decl, _) => check_decl(cx, decl, bindings), - StmtExpr(ref e, _) | StmtSemi(ref e, _) => check_expr(cx, e, bindings), + StmtKind::Decl(ref decl, _) => check_decl(cx, decl, bindings), + StmtKind::Expr(ref e, _) | StmtKind::Semi(ref e, _) => check_expr(cx, e, bindings), } } if let Some(ref o) = block.expr { @@ -127,7 +127,7 @@ fn check_decl<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, decl: &'tcx Decl, bindings: if higher::is_from_for_desugar(decl) { return; } - if let DeclLocal(ref local) = decl.node { + if let DeclKind::Local(ref local) = decl.node { let Local { ref pat, ref ty, @@ -185,7 +185,7 @@ fn check_pat<'a, 'tcx>( } }, PatKind::Struct(_, ref pfields, _) => if let Some(init_struct) = init { - if let ExprStruct(_, ref efields, _) = init_struct.node { + if let ExprKind::Struct(_, ref efields, _) = init_struct.node { for field in pfields { let name = field.node.ident.name; let efield = efields @@ -205,7 +205,7 @@ fn check_pat<'a, 'tcx>( } }, PatKind::Tuple(ref inner, _) => if let Some(init_tup) = init { - if let ExprTup(ref tup) = init_tup.node { + if let ExprKind::Tup(ref tup) = init_tup.node { for (i, p) in inner.iter().enumerate() { check_pat(cx, p, Some(&tup[i]), p.span, bindings); } @@ -220,7 +220,7 @@ fn check_pat<'a, 'tcx>( } }, PatKind::Box(ref inner) => if let Some(initp) = init { - if let ExprBox(ref inner_init) = initp.node { + if let ExprKind::Box(ref inner_init) = initp.node { check_pat(cx, inner, Some(&**inner_init), span, bindings); } else { check_pat(cx, inner, init, span, bindings); @@ -306,27 +306,27 @@ fn check_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindings: return; } match expr.node { - ExprUnary(_, ref e) | ExprField(ref e, _) | ExprAddrOf(_, ref e) | ExprBox(ref e) => { + ExprKind::Unary(_, ref e) | ExprKind::Field(ref e, _) | ExprKind::AddrOf(_, ref e) | ExprKind::Box(ref e) => { check_expr(cx, e, bindings) }, - ExprBlock(ref block, _) | ExprLoop(ref block, _, _) => check_block(cx, block, bindings), - // ExprCall - // ExprMethodCall - ExprArray(ref v) | ExprTup(ref v) => for e in v { + ExprKind::Block(ref block, _) | ExprKind::Loop(ref block, _, _) => check_block(cx, block, bindings), + // ExprKind::Call + // ExprKind::MethodCall + ExprKind::Array(ref v) | ExprKind::Tup(ref v) => for e in v { check_expr(cx, e, bindings) }, - ExprIf(ref cond, ref then, ref otherwise) => { + ExprKind::If(ref cond, ref then, ref otherwise) => { check_expr(cx, cond, bindings); check_expr(cx, &**then, bindings); if let Some(ref o) = *otherwise { check_expr(cx, o, bindings); } }, - ExprWhile(ref cond, ref block, _) => { + ExprKind::While(ref cond, ref block, _) => { check_expr(cx, cond, bindings); check_block(cx, block, bindings); }, - ExprMatch(ref init, ref arms, _) => { + ExprKind::Match(ref init, ref arms, _) => { check_expr(cx, init, bindings); let len = bindings.len(); for arm in arms { @@ -347,32 +347,32 @@ fn check_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindings: fn check_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: &'tcx Ty, bindings: &mut Vec<(Name, Span)>) { match ty.node { - TySlice(ref sty) => check_ty(cx, sty, bindings), - TyArray(ref fty, ref anon_const) => { + TyKind::Slice(ref sty) => check_ty(cx, sty, bindings), + TyKind::Array(ref fty, ref anon_const) => { check_ty(cx, fty, bindings); check_expr(cx, &cx.tcx.hir.body(anon_const.body).value, bindings); }, - TyPtr(MutTy { ty: ref mty, .. }) | TyRptr(_, MutTy { ty: ref mty, .. }) => check_ty(cx, mty, bindings), - TyTup(ref tup) => for t in tup { + TyKind::Ptr(MutTy { ty: ref mty, .. }) | TyKind::Rptr(_, MutTy { ty: ref mty, .. }) => check_ty(cx, mty, bindings), + TyKind::Tup(ref tup) => for t in tup { check_ty(cx, t, bindings) }, - TyTypeof(ref anon_const) => check_expr(cx, &cx.tcx.hir.body(anon_const.body).value, bindings), + TyKind::Typeof(ref anon_const) => check_expr(cx, &cx.tcx.hir.body(anon_const.body).value, bindings), _ => (), } } fn is_self_shadow(name: Name, expr: &Expr) -> bool { match expr.node { - ExprBox(ref inner) | ExprAddrOf(_, ref inner) => is_self_shadow(name, inner), - ExprBlock(ref block, _) => { + ExprKind::Box(ref inner) | ExprKind::AddrOf(_, ref inner) => is_self_shadow(name, inner), + ExprKind::Block(ref block, _) => { 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(QPath::Resolved(_, ref path)) => path_eq_name(name, path), + ExprKind::Unary(op, ref inner) => (UnDeref == op) && is_self_shadow(name, inner), + ExprKind::Path(QPath::Resolved(_, ref path)) => path_eq_name(name, path), _ => false, } } diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs index 62cd5de68f06..40f5c66ce158 100644 --- a/clippy_lints/src/strings.rs +++ b/clippy_lints/src/strings.rs @@ -82,12 +82,12 @@ impl LintPass for StringAdd { 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 let ExprKind::Binary(Spanned { node: BinOpKind::Add, .. }, ref left, _) = e.node { if is_string(cx, left) { if !is_allowed(cx, STRING_ADD_ASSIGN, e.id) { let parent = get_parent_expr(cx, e); if let Some(p) = parent { - if let ExprAssign(ref target, _) = p.node { + if let ExprKind::Assign(ref target, _) = p.node { // avoid duplicate matches if SpanlessEq::new(cx).eq_expr(target, left) { return; @@ -102,7 +102,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StringAdd { "you added something to a string. Consider using `String::push_str()` instead", ); } - } else if let ExprAssign(ref target, ref src) = e.node { + } else if let ExprKind::Assign(ref target, ref src) = e.node { if is_string(cx, target) && is_add(cx, src, target) { span_lint( cx, @@ -122,8 +122,8 @@ fn is_string(cx: &LateContext, e: &Expr) -> bool { fn is_add(cx: &LateContext, src: &Expr, target: &Expr) -> bool { match src.node { - ExprBinary(Spanned { node: BiAdd, .. }, ref left, _) => SpanlessEq::new(cx).eq_expr(target, left), - ExprBlock(ref block, _) => { + ExprKind::Binary(Spanned { node: BinOpKind::Add, .. }, ref left, _) => SpanlessEq::new(cx).eq_expr(target, left), + ExprKind::Block(ref block, _) => { block.stmts.is_empty() && block .expr @@ -148,9 +148,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for StringLitAsBytes { use syntax::ast::LitKind; use crate::utils::{in_macro, snippet}; - if let ExprMethodCall(ref path, _, ref args) = e.node { + if let ExprKind::MethodCall(ref path, _, ref args) = e.node { if path.ident.name == "as_bytes" { - if let ExprLit(ref lit) = args[0].node { + if let ExprKind::Lit(ref lit) = args[0].node { if let LitKind::Str(ref lit_content, _) = lit.node { if lit_content.as_str().chars().all(|c| c.is_ascii()) && !in_macro(args[0].span) { span_lint_and_sugg( diff --git a/clippy_lints/src/suspicious_trait_impl.rs b/clippy_lints/src/suspicious_trait_impl.rs index e3ccfec46857..10db53cc782d 100644 --- a/clippy_lints/src/suspicious_trait_impl.rs +++ b/clippy_lints/src/suspicious_trait_impl.rs @@ -59,10 +59,15 @@ impl LintPass for SuspiciousImpl { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for SuspiciousImpl { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) { - use rustc::hir::BinOp_::*; - if let hir::ExprBinary(binop, _, _) = expr.node { + if let hir::ExprKind::Binary(binop, _, _) = expr.node { match binop.node { - BiEq | BiLt | BiLe | BiNe | BiGe | BiGt => return, + | hir::BinOpKind::Eq + | hir::BinOpKind::Lt + | hir::BinOpKind::Le + | hir::BinOpKind::Ne + | hir::BinOpKind::Ge + | hir::BinOpKind::Gt + => return, _ => {}, } // Check if the binary expression is part of another bi/unary expression @@ -71,9 +76,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for SuspiciousImpl { while parent_expr != ast::CRATE_NODE_ID { if let hir::map::Node::NodeExpr(e) = cx.tcx.hir.get(parent_expr) { match e.node { - hir::ExprBinary(..) - | hir::ExprUnary(hir::UnOp::UnNot, _) - | hir::ExprUnary(hir::UnOp::UnNeg, _) => return, + hir::ExprKind::Binary(..) + | hir::ExprKind::Unary(hir::UnOp::UnNot, _) + | hir::ExprKind::Unary(hir::UnOp::UnNeg, _) => return, _ => {}, } } @@ -94,7 +99,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for SuspiciousImpl { expr, binop.node, &["Add", "Sub", "Mul", "Div"], - &[BiAdd, BiSub, BiMul, BiDiv], + &[ + hir::BinOpKind::Add, + hir::BinOpKind::Sub, + hir::BinOpKind::Mul, + hir::BinOpKind::Div, + ], ) { span_lint( cx, @@ -124,7 +134,16 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for SuspiciousImpl { "ShrAssign", ], &[ - BiAdd, BiSub, BiMul, BiDiv, BiBitAnd, BiBitOr, BiBitXor, BiRem, BiShl, BiShr + hir::BinOpKind::Add, + hir::BinOpKind::Sub, + hir::BinOpKind::Mul, + hir::BinOpKind::Div, + hir::BinOpKind::BitAnd, + hir::BinOpKind::BitOr, + hir::BinOpKind::BitXor, + hir::BinOpKind::Rem, + hir::BinOpKind::Shl, + hir::BinOpKind::Shr, ], ) { span_lint( @@ -144,9 +163,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for SuspiciousImpl { fn check_binop<'a>( cx: &LateContext, expr: &hir::Expr, - binop: hir::BinOp_, + binop: hir::BinOpKind, traits: &[&'a str], - expected_ops: &[hir::BinOp_], + expected_ops: &[hir::BinOpKind], ) -> Option<&'a str> { let mut trait_ids = vec![]; let [krate, module] = crate::utils::paths::OPS_MODULE; @@ -167,7 +186,7 @@ fn check_binop<'a>( if_chain! { if parent_impl != ast::CRATE_NODE_ID; if let hir::map::Node::NodeItem(item) = cx.tcx.hir.get(parent_impl); - if let hir::Item_::ItemImpl(_, _, _, _, Some(ref trait_ref), _, _) = item.node; + if let hir::ItemKind::Impl(_, _, _, _, Some(ref trait_ref), _, _) = item.node; if let Some(idx) = trait_ids.iter().position(|&tid| tid == trait_ref.path.def.def_id()); if binop != expected_ops[idx]; then{ @@ -185,9 +204,9 @@ struct BinaryExprVisitor { impl<'a, 'tcx: 'a> Visitor<'tcx> for BinaryExprVisitor { fn visit_expr(&mut self, expr: &'tcx hir::Expr) { match expr.node { - hir::ExprBinary(..) - | hir::ExprUnary(hir::UnOp::UnNot, _) - | hir::ExprUnary(hir::UnOp::UnNeg, _) => { + hir::ExprKind::Binary(..) + | hir::ExprKind::Unary(hir::UnOp::UnNot, _) + | hir::ExprKind::Unary(hir::UnOp::UnNeg, _) => { self.in_binary_expr = true }, _ => {}, diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs index 1037a1bc632e..dfcc9c39348f 100644 --- a/clippy_lints/src/swap.rs +++ b/clippy_lints/src/swap.rs @@ -61,19 +61,19 @@ fn check_manual_swap(cx: &LateContext, block: &Block) { for w in block.stmts.windows(3) { if_chain! { // let t = foo(); - if let StmtDecl(ref tmp, _) = w[0].node; - if let DeclLocal(ref tmp) = tmp.node; + if let StmtKind::Decl(ref tmp, _) = w[0].node; + if let DeclKind::Local(ref tmp) = tmp.node; if let Some(ref tmp_init) = tmp.init; if let PatKind::Binding(_, _, ident, None) = tmp.pat.node; // foo() = bar(); - if let StmtSemi(ref first, _) = w[1].node; - if let ExprAssign(ref lhs1, ref rhs1) = first.node; + if let StmtKind::Semi(ref first, _) = w[1].node; + if let ExprKind::Assign(ref lhs1, ref rhs1) = first.node; // bar() = t; - if let StmtSemi(ref second, _) = w[2].node; - if let ExprAssign(ref lhs2, ref rhs2) = second.node; - if let ExprPath(QPath::Resolved(None, ref rhs2)) = rhs2.node; + if let StmtKind::Semi(ref second, _) = w[2].node; + if let ExprKind::Assign(ref lhs2, ref rhs2) = second.node; + if let ExprKind::Path(QPath::Resolved(None, ref rhs2)) = rhs2.node; if rhs2.segments.len() == 1; if ident.as_str() == rhs2.segments[0].ident.as_str(); @@ -85,8 +85,8 @@ fn check_manual_swap(cx: &LateContext, block: &Block) { lhs1: &'a Expr, lhs2: &'a Expr, ) -> Option<(&'a Expr, &'a Expr, &'a Expr)> { - if let ExprIndex(ref lhs1, ref idx1) = lhs1.node { - if let ExprIndex(ref lhs2, ref idx2) = lhs2.node { + if let ExprKind::Index(ref lhs1, ref idx1) = lhs1.node { + if let ExprKind::Index(ref lhs2, ref idx2) = lhs2.node { if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, lhs2) { let ty = walk_ptrs_ty(cx.tables.expr_ty(lhs1)); @@ -145,11 +145,11 @@ fn check_manual_swap(cx: &LateContext, block: &Block) { fn check_suspicious_swap(cx: &LateContext, block: &Block) { for w in block.stmts.windows(2) { if_chain! { - if let StmtSemi(ref first, _) = w[0].node; - if let StmtSemi(ref second, _) = w[1].node; + if let StmtKind::Semi(ref first, _) = w[0].node; + if let StmtKind::Semi(ref second, _) = w[1].node; if !differing_macro_contexts(first.span, second.span); - if let ExprAssign(ref lhs0, ref rhs0) = first.node; - if let ExprAssign(ref lhs1, ref rhs1) = second.node; + if let ExprKind::Assign(ref lhs0, ref rhs0) = first.node; + if let ExprKind::Assign(ref lhs1, ref rhs1) = second.node; if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs0, rhs1); if SpanlessEq::new(cx).ignore_fn().eq_expr(lhs1, rhs0); then { diff --git a/clippy_lints/src/temporary_assignment.rs b/clippy_lints/src/temporary_assignment.rs index cd13ab0d51ff..008ab56bda84 100644 --- a/clippy_lints/src/temporary_assignment.rs +++ b/clippy_lints/src/temporary_assignment.rs @@ -1,5 +1,5 @@ use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; -use rustc::hir::{Expr, ExprAssign, ExprField, ExprStruct, ExprTup}; +use rustc::hir::{Expr, ExprKind}; use crate::utils::is_adjusted; use crate::utils::span_lint; @@ -23,7 +23,7 @@ declare_clippy_lint! { fn is_temporary(expr: &Expr) -> bool { match expr.node { - ExprStruct(..) | ExprTup(..) => true, + ExprKind::Struct(..) | ExprKind::Tup(..) => true, _ => false, } } @@ -39,8 +39,8 @@ impl LintPass for Pass { 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 { - if let ExprField(ref base, _) = target.node { + if let ExprKind::Assign(ref target, _) = expr.node { + if let ExprKind::Field(ref base, _) = target.node { if is_temporary(base) && !is_adjusted(cx, base) { span_lint(cx, TEMPORARY_ASSIGNMENT, expr.span, "assignment to temporary"); } diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index c2e981979a18..9914ab0e8db3 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -215,8 +215,8 @@ impl LintPass for Transmute { 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 { + if let ExprKind::Call(ref path_expr, ref args) = e.node { + if let ExprKind::Path(ref qpath) = path_expr.node { if let Some(def_id) = opt_def_id(cx.tables.qpath_def(qpath, path_expr.hir_id)) { if match_def_path(cx.tcx, def_id, &paths::TRANSMUTE) { let from_ty = cx.tables.expr_ty(&args[0]); @@ -461,7 +461,7 @@ fn get_type_snippet(cx: &LateContext, path: &QPath, to_ref_ty: Ty) -> String { GenericArg::Type(ty) => Some(ty), GenericArg::Lifetime(_) => None, }).nth(1); - if let TyRptr(_, ref to_ty) = to_ty.node; + if let TyKind::Rptr(_, ref to_ty) = to_ty.node; then { return snippet(cx, to_ty.ty.span, &to_ref_ty.to_string()).to_string(); } diff --git a/clippy_lints/src/trivially_copy_pass_by_ref.rs b/clippy_lints/src/trivially_copy_pass_by_ref.rs index 8d0ddbec9882..18c85cd05ab4 100644 --- a/clippy_lints/src/trivially_copy_pass_by_ref.rs +++ b/clippy_lints/src/trivially_copy_pass_by_ref.rs @@ -100,8 +100,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TriviallyCopyPassByRef { // Exclude non-inherent impls if let Some(NodeItem(item)) = cx.tcx.hir.find(cx.tcx.hir.get_parent_node(node_id)) { - if matches!(item.node, ItemImpl(_, _, _, _, Some(_), _, _) | - ItemTrait(..)) + if matches!(item.node, ItemKind::Impl(_, _, _, _, Some(_), _, _) | + ItemKind::Trait(..)) { return; } @@ -123,7 +123,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TriviallyCopyPassByRef { if is_copy(cx, ty); if let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes()); if size <= self.limit; - if let Ty_::TyRptr(_, MutTy { ty: ref decl_ty, .. }) = input.node; + if let TyKind::Rptr(_, MutTy { ty: ref decl_ty, .. }) = input.node; then { let value_type = if is_self(arg) { "self".into() diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index 61d496c1f0d3..ae4f579a6f22 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -139,7 +139,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypePass { fn check_fn(&mut self, cx: &LateContext, _: FnKind, decl: &FnDecl, _: &Body, _: Span, id: NodeId) { // skip trait implementations, see #605 if let Some(map::NodeItem(item)) = cx.tcx.hir.find(cx.tcx.hir.get_parent(id)) { - if let ItemImpl(_, _, _, _, Some(..), _, _) = item.node { + if let ItemKind::Impl(_, _, _, _, Some(..), _, _) = item.node { return; } } @@ -186,7 +186,7 @@ fn match_type_parameter(cx: &LateContext, qpath: &QPath, path: &[&str]) -> bool GenericArg::Type(ty) => Some(ty), GenericArg::Lifetime(_) => None, }); - if let TyPath(ref qpath) = ty.node; + if let TyKind::Path(ref qpath) = ty.node; if let Some(did) = opt_def_id(cx.tables.qpath_def(qpath, cx.tcx.hir.node_to_hir_id(ty.id))); if match_def_path(cx.tcx, did, path); then { @@ -206,7 +206,7 @@ fn check_ty(cx: &LateContext, ast_ty: &hir::Ty, is_local: bool) { return; } match ast_ty.node { - TyPath(ref qpath) if !is_local => { + TyKind::Path(ref qpath) if !is_local => { let hir_id = cx.tcx.hir.node_to_hir_id(ast_ty.id); let def = cx.tables.qpath_def(qpath, hir_id); if let Some(def_id) = opt_def_id(def) { @@ -282,10 +282,10 @@ fn check_ty(cx: &LateContext, ast_ty: &hir::Ty, is_local: bool) { }, } }, - TyRptr(ref lt, ref mut_ty) => check_ty_rptr(cx, ast_ty, is_local, lt, mut_ty), + TyKind::Rptr(ref lt, ref mut_ty) => check_ty_rptr(cx, ast_ty, is_local, lt, mut_ty), // recurse - TySlice(ref ty) | TyArray(ref ty, _) | TyPtr(MutTy { ref ty, .. }) => check_ty(cx, ty, is_local), - TyTup(ref tys) => for ty in tys { + TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => check_ty(cx, ty, is_local), + TyKind::Tup(ref tys) => for ty in tys { check_ty(cx, ty, is_local); }, _ => {}, @@ -294,7 +294,7 @@ fn check_ty(cx: &LateContext, ast_ty: &hir::Ty, is_local: bool) { fn check_ty_rptr(cx: &LateContext, ast_ty: &hir::Ty, is_local: bool, lt: &Lifetime, mut_ty: &MutTy) { match mut_ty.ty.node { - TyPath(ref qpath) => { + TyKind::Path(ref qpath) => { let hir_id = cx.tcx.hir.node_to_hir_id(mut_ty.ty.id); let def = cx.tables.qpath_def(qpath, hir_id); if_chain! { @@ -343,7 +343,7 @@ fn check_ty_rptr(cx: &LateContext, ast_ty: &hir::Ty, is_local: bool, lt: &Lifeti // Returns true if given type is `Any` trait. fn is_any_trait(t: &hir::Ty) -> bool { if_chain! { - if let TyTraitObject(ref traits, _) = t.node; + if let TyKind::TraitObject(ref traits, _) = t.node; if traits.len() >= 1; // Only Send/Sync can be used as additional traits, so it is enough to // check only the first trait. @@ -377,7 +377,7 @@ declare_clippy_lint! { } fn check_let_unit(cx: &LateContext, decl: &Decl) { - if let DeclLocal(ref local) = decl.node { + if let DeclKind::Local(ref local) = decl.node { if is_unit(cx.tables.pat_ty(&local.pat)) { if in_external_macro(cx, decl.span) || in_macro(local.pat.span) { return; @@ -446,11 +446,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitCmp { if in_macro(expr.span) { return; } - if let ExprBinary(ref cmp, ref left, _) = expr.node { + if let ExprKind::Binary(ref cmp, ref left, _) = expr.node { let op = cmp.node; if op.is_comparison() && is_unit(cx.tables.expr_ty(left)) { let result = match op { - BiEq | BiLe | BiGe => "true", + BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true", _ => "false", }; span_lint( @@ -501,7 +501,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg { return; } match expr.node { - ExprCall(_, ref args) | ExprMethodCall(_, _, ref args) => { + ExprKind::Call(_, ref args) | ExprKind::MethodCall(_, _, ref args) => { for arg in args { if is_unit(cx.tables.expr_ty(arg)) && !is_unit_literal(arg) { let map = &cx.tcx.hir; @@ -539,7 +539,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnitArg { fn is_questionmark_desugar_marked_call(expr: &Expr) -> bool { use syntax_pos::hygiene::CompilerDesugaringKind; - if let ExprCall(ref callee, _) = expr.node { + if let ExprKind::Call(ref callee, _) = expr.node { callee.span.is_compiler_desugaring(CompilerDesugaringKind::QuestionMark) } else { false @@ -555,7 +555,7 @@ fn is_unit(ty: Ty) -> bool { fn is_unit_literal(expr: &Expr) -> bool { match expr.node { - ExprTup(ref slice) if slice.is_empty() => true, + ExprKind::Tup(ref slice) if slice.is_empty() => true, _ => false, } } @@ -812,7 +812,7 @@ fn span_precision_loss_lint(cx: &LateContext, expr: &Expr, cast_from: Ty, cast_t } fn should_strip_parens(op: &Expr, snip: &str) -> bool { - if let ExprBinary(_, _, _) = op.node { + if let ExprKind::Binary(_, _, _) = op.node { if snip.starts_with('(') && snip.ends_with(')') { return true; } @@ -951,9 +951,9 @@ impl LintPass for CastPass { 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 { + if let ExprKind::Cast(ref ex, _) = expr.node { let (cast_from, cast_to) = (cx.tables.expr_ty(ex), cx.tables.expr_ty(expr)); - if let ExprLit(ref lit) = ex.node { + if let ExprKind::Lit(ref lit) = ex.node { use syntax::ast::{LitIntType, LitKind}; match lit.node { LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::FloatUnsuffixed(_) => {}, @@ -1141,7 +1141,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeComplexityPass { 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), + ItemKind::Static(ref ty, _, _) | ItemKind::Const(ref ty, _) => self.check_type(cx, ty), // functions, enums, structs, impls and traits are covered _ => (), } @@ -1214,15 +1214,15 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor { fn visit_ty(&mut self, ty: &'tcx hir::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), + TyKind::Infer | TyKind::Ptr(..) | TyKind::Rptr(..) => (1, 0), // the "normal" components of a type: named types, arrays/tuples - TyPath(..) | TySlice(..) | TyTup(..) | TyArray(..) => (10 * self.nest, 1), + TyKind::Path(..) | TyKind::Slice(..) | TyKind::Tup(..) | TyKind::Array(..) => (10 * self.nest, 1), // function types bring a lot of overhead - TyBareFn(..) => (50 * self.nest, 1), + TyKind::BareFn(..) => (50 * self.nest, 1), - TyTraitObject(ref param_bounds, _) => { + TyKind::TraitObject(ref param_bounds, _) => { let has_lifetime_parameters = param_bounds .iter() .any(|bound| bound.bound_generic_params.iter().any(|gen| match gen.kind { @@ -1289,8 +1289,8 @@ 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 { - if let ExprLit(ref l) = e.node { + if let ExprKind::Cast(ref e, _) = expr.node { + if let ExprKind::Lit(ref l) = e.node { if let LitKind::Char(_) = l.node { if ty::TyUint(UintTy::U8) == cx.tables.expr_ty(expr).sty && !in_macro(expr.span) { let msg = "casting character literal to u8. `char`s \ @@ -1362,7 +1362,7 @@ fn is_cast_between_fixed_and_target<'a, 'tcx>( expr: &'tcx Expr ) -> bool { - if let ExprCast(ref cast_exp, _) = expr.node { + if let ExprKind::Cast(ref cast_exp, _) = expr.node { let precast_ty = cx.tables.expr_ty(cast_exp); let cast_ty = cx.tables.expr_ty(expr); @@ -1374,7 +1374,7 @@ fn is_cast_between_fixed_and_target<'a, 'tcx>( fn detect_absurd_comparison<'a, 'tcx>( cx: &LateContext<'a, 'tcx>, - op: BinOp_, + op: BinOpKind, lhs: &'tcx Expr, rhs: &'tcx Expr, ) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> { @@ -1453,7 +1453,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AbsurdExtremeComparisons { use crate::types::ExtremeType::*; use crate::types::AbsurdComparisonResult::*; - if let ExprBinary(ref cmp, ref lhs, ref rhs) = expr.node { + if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.node { if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) { if !in_macro(expr.span) { let msg = "this comparison involving the minimum or maximum element for this \ @@ -1564,7 +1564,7 @@ fn numeric_cast_precast_bounds<'a>(cx: &LateContext, expr: &'a Expr) -> Option<( use syntax::ast::{IntTy, UintTy}; use std::*; - if let ExprCast(ref cast_exp, _) = expr.node { + if let ExprKind::Cast(ref cast_exp, _) = expr.node { let pre_cast_ty = cx.tables.expr_ty(cast_exp); let cast_ty = cx.tables.expr_ty(expr); // if it's a cast from i32 to u32 wrapping will invalidate all these checks @@ -1627,7 +1627,7 @@ fn node_as_const_fullint<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) } fn err_upcast_comparison(cx: &LateContext, span: Span, expr: &Expr, always: bool) { - if let ExprCast(ref cast_val, _) = expr.node { + if let ExprKind::Cast(ref cast_val, _) = expr.node { span_lint( cx, INVALID_UPCAST_COMPARISONS, @@ -1693,7 +1693,7 @@ fn upcast_comparison_bounds_err<'a, 'tcx>( 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 { + if let ExprKind::Binary(ref cmp, ref lhs, ref rhs) = expr.node { let normalized = comparisons::normalize_comparison(cmp.node, lhs, rhs); let (rel, normalized_lhs, normalized_rhs) = if let Some(val) = normalized { val @@ -1797,7 +1797,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImplicitHasher { } match item.node { - ItemImpl(_, _, _, ref generics, _, ref ty, ref items) => { + ItemKind::Impl(_, _, _, ref generics, _, ref ty, ref items) => { let mut vis = ImplicitHasherTypeVisitor::new(cx); vis.visit_ty(ty); @@ -1829,7 +1829,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImplicitHasher { ); } }, - ItemFn(ref decl, .., ref generics, body_id) => { + ItemKind::Fn(ref decl, .., ref generics, body_id) => { let body = cx.tcx.hir.body(body_id); for ty in &decl.inputs { @@ -1878,7 +1878,7 @@ enum ImplicitHasherType<'tcx> { impl<'tcx> ImplicitHasherType<'tcx> { /// Checks that `ty` is a target type without a BuildHasher. fn new<'a>(cx: &LateContext<'a, 'tcx>, hir_ty: &hir::Ty) -> Option { - if let TyPath(QPath::Resolved(None, ref path)) = hir_ty.node { + if let TyKind::Path(QPath::Resolved(None, ref path)) = hir_ty.node { let params: Vec<_> = path.segments.last().as_ref()?.args.as_ref()? .args.iter().filter_map(|arg| match arg { GenericArg::Type(ty) => Some(ty), @@ -1984,9 +1984,9 @@ impl<'a, 'b, 'tcx: 'a + 'b> Visitor<'tcx> for ImplicitHasherConstructorVisitor<' fn visit_expr(&mut self, e: &'tcx Expr) { if_chain! { - if let ExprCall(ref fun, ref args) = e.node; - if let ExprPath(QPath::TypeRelative(ref ty, ref method)) = fun.node; - if let TyPath(QPath::Resolved(None, ref ty_path)) = ty.node; + if let ExprKind::Call(ref fun, ref args) = e.node; + if let ExprKind::Path(QPath::TypeRelative(ref ty, ref method)) = fun.node; + if let TyKind::Path(QPath::Resolved(None, ref ty_path)) = ty.node; then { if !same_tys(self.cx, self.target.ty(), self.body.expr_ty(e)) { return; diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs index 0cb192e89b29..ddd9db9eda3a 100644 --- a/clippy_lints/src/unicode.rs +++ b/clippy_lints/src/unicode.rs @@ -71,7 +71,7 @@ impl LintPass for Unicode { 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 ExprKind::Lit(ref lit) = expr.node { if let LitKind::Str(_, _) = lit.node { check_str(cx, lit.span, expr.id) } diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs index 316415d73ad2..649a10333710 100644 --- a/clippy_lints/src/unused_io_amount.rs +++ b/clippy_lints/src/unused_io_amount.rs @@ -40,14 +40,14 @@ impl LintPass for UnusedIoAmount { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedIoAmount { fn check_stmt(&mut self, cx: &LateContext, s: &hir::Stmt) { let expr = match s.node { - hir::StmtSemi(ref expr, _) | hir::StmtExpr(ref expr, _) => &**expr, + hir::StmtKind::Semi(ref expr, _) | hir::StmtKind::Expr(ref expr, _) => &**expr, _ => return, }; match expr.node { - hir::ExprMatch(ref res, _, _) if is_try(expr).is_some() => { - if let hir::ExprCall(ref func, ref args) = res.node { - if let hir::ExprPath(ref path) = func.node { + hir::ExprKind::Match(ref res, _, _) if is_try(expr).is_some() => { + if let hir::ExprKind::Call(ref func, ref args) = res.node { + if let hir::ExprKind::Path(ref path) = func.node { if match_qpath(path, &paths::TRY_INTO_RESULT) && args.len() == 1 { check_method_call(cx, &args[0], expr); } @@ -57,7 +57,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedIoAmount { } }, - hir::ExprMethodCall(ref path, _, ref args) => match &*path.ident.as_str() { + hir::ExprKind::MethodCall(ref path, _, ref args) => match &*path.ident.as_str() { "expect" | "unwrap" | "unwrap_or" | "unwrap_or_else" => { check_method_call(cx, &args[0], expr); }, @@ -70,7 +70,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedIoAmount { } fn check_method_call(cx: &LateContext, call: &hir::Expr, expr: &hir::Expr) { - if let hir::ExprMethodCall(ref path, _, _) = call.node { + if let hir::ExprKind::MethodCall(ref path, _, _) = call.node { let symbol = &*path.ident.as_str(); if match_trait_method(cx, call, &paths::IO_READ) && symbol == "read" { span_lint( diff --git a/clippy_lints/src/unused_label.rs b/clippy_lints/src/unused_label.rs index 5c5550ed30fb..0ae956b9443e 100644 --- a/clippy_lints/src/unused_label.rs +++ b/clippy_lints/src/unused_label.rs @@ -69,10 +69,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedLabel { impl<'a, 'tcx: 'a> Visitor<'tcx> for UnusedLabelVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &'tcx hir::Expr) { match expr.node { - hir::ExprBreak(destination, _) | hir::ExprContinue(destination) => if let Some(label) = destination.label { + hir::ExprKind::Break(destination, _) | hir::ExprKind::Continue(destination) => if let Some(label) = destination.label { self.labels.remove(&label.ident.as_str()); }, - hir::ExprLoop(_, Some(label), _) | hir::ExprWhile(_, _, Some(label)) => { + hir::ExprKind::Loop(_, Some(label), _) | hir::ExprKind::While(_, _, Some(label)) => { self.labels.insert(label.ident.as_str(), expr.span); }, _ => (), diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs index b8e34cc66e16..fcc3c2f68c1c 100644 --- a/clippy_lints/src/unwrap.rs +++ b/clippy_lints/src/unwrap.rs @@ -78,21 +78,21 @@ fn collect_unwrap_info<'a, 'tcx: 'a>( expr: &'tcx Expr, invert: bool, ) -> Vec> { - if let Expr_::ExprBinary(op, left, right) = &expr.node { + if let ExprKind::Binary(op, left, right) = &expr.node { match (invert, op.node) { - (false, BinOp_::BiAnd) | (false, BinOp_::BiBitAnd) | (true, BinOp_::BiOr) | (true, BinOp_::BiBitOr) => { + (false, BinOpKind::And) | (false, BinOpKind::BitAnd) | (true, BinOpKind::Or) | (true, BinOpKind::BitOr) => { let mut unwrap_info = collect_unwrap_info(cx, left, invert); unwrap_info.append(&mut collect_unwrap_info(cx, right, invert)); return unwrap_info; }, _ => (), } - } else if let Expr_::ExprUnary(UnNot, expr) = &expr.node { + } else if let ExprKind::Unary(UnNot, expr) = &expr.node { return collect_unwrap_info(cx, expr, !invert); } else { if_chain! { - if let Expr_::ExprMethodCall(method_name, _, args) = &expr.node; - if let Expr_::ExprPath(QPath::Resolved(None, path)) = &args[0].node; + if let ExprKind::MethodCall(method_name, _, args) = &expr.node; + if let ExprKind::Path(QPath::Resolved(None, path)) = &args[0].node; let ty = cx.tables.expr_ty(&args[0]); if match_type(cx, ty, &paths::OPTION) || match_type(cx, ty, &paths::RESULT); let name = method_name.ident.as_str(); @@ -131,7 +131,7 @@ impl<'a, 'tcx: 'a> UnwrappableVariablesVisitor<'a, 'tcx> { impl<'a, 'tcx: 'a> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &'tcx Expr) { - if let Expr_::ExprIf(cond, then, els) = &expr.node { + if let ExprKind::If(cond, then, els) = &expr.node { walk_expr(self, cond); self.visit_branch(cond, then, false); if let Some(els) = els { @@ -140,8 +140,8 @@ impl<'a, 'tcx: 'a> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> { } else { // find `unwrap[_err]()` calls: if_chain! { - if let Expr_::ExprMethodCall(ref method_name, _, ref args) = expr.node; - if let Expr_::ExprPath(QPath::Resolved(None, ref path)) = args[0].node; + if let ExprKind::MethodCall(ref method_name, _, ref args) = expr.node; + if let ExprKind::Path(QPath::Resolved(None, ref path)) = args[0].node; if ["unwrap", "unwrap_err"].contains(&&*method_name.ident.as_str()); let call_to_unwrap = method_name.ident.name == "unwrap"; if let Some(unwrappable) = self.unwrappables.iter() diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs index 10b69852ba53..230d5fdca2c6 100644 --- a/clippy_lints/src/use_self.rs +++ b/clippy_lints/src/use_self.rs @@ -55,8 +55,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UseSelf { return; } if_chain! { - if let ItemImpl(.., ref item_type, ref refs) = item.node; - if let Ty_::TyPath(QPath::Resolved(_, ref item_path)) = item_type.node; + if let ItemKind::Impl(.., ref item_type, ref refs) = item.node; + if let TyKind::Path(QPath::Resolved(_, ref item_path)) = item_type.node; then { let parameters = &item_path.segments.last().expect(SEGMENTS_MSG).args; let should_check = if let Some(ref params) = *parameters { diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs index 520c30b03c0f..9a848c8a805d 100644 --- a/clippy_lints/src/utils/author.rs +++ b/clippy_lints/src/utils/author.rs @@ -5,7 +5,7 @@ use rustc::lint::*; use rustc::hir; -use rustc::hir::{Expr, Expr_, QPath, Ty_, Pat, PatKind, BindingAnnotation, StmtSemi, StmtExpr, StmtDecl, Decl_, Stmt}; +use rustc::hir::{Expr, ExprKind, QPath, TyKind, Pat, PatKind, BindingAnnotation, StmtKind, DeclKind, Stmt}; use rustc::hir::intravisit::{NestedVisitorMap, Visitor}; use syntax::ast::{Attribute, LitKind, DUMMY_NODE_ID}; use std::collections::HashMap; @@ -32,10 +32,10 @@ use crate::utils::get_attr; /// ```rust /// // ./tests/ui/new_lint.stdout /// if_chain!{ -/// if let Expr_::ExprIf(ref cond, ref then, None) = item.node, -/// if let Expr_::ExprBinary(BinOp::Eq, ref left, ref right) = cond.node, -/// if let Expr_::ExprPath(ref path) = left.node, -/// if let Expr_::ExprLit(ref lit) = right.node, +/// if let ExprKind::If(ref cond, ref then, None) = item.node, +/// if let ExprKind::Binary(BinOp::Eq, ref left, ref right) = cond.node, +/// if let ExprKind::Path(ref path) = left.node, +/// if let ExprKind::Lit(ref lit) = right.node, /// if let LitKind::Int(42, _) = lit.node, /// then { /// // report your lint here @@ -192,16 +192,16 @@ struct PrintVisitor { impl<'tcx> Visitor<'tcx> for PrintVisitor { fn visit_expr(&mut self, expr: &Expr) { - print!(" if let Expr_::Expr"); + print!(" if let ExprKind::"); let current = format!("{}.node", self.current); match expr.node { - Expr_::ExprBox(ref inner) => { + ExprKind::Box(ref inner) => { let inner_pat = self.next("inner"); println!("Box(ref {}) = {};", inner_pat, current); self.current = inner_pat; self.visit_expr(inner); }, - Expr_::ExprArray(ref elements) => { + ExprKind::Array(ref elements) => { let elements_pat = self.next("elements"); println!("Array(ref {}) = {};", elements_pat, current); println!(" if {}.len() == {};", elements_pat, elements.len()); @@ -210,7 +210,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { self.visit_expr(element); } }, - Expr_::ExprCall(ref func, ref args) => { + ExprKind::Call(ref func, ref args) => { let func_pat = self.next("func"); let args_pat = self.next("args"); println!("Call(ref {}, ref {}) = {};", func_pat, args_pat, current); @@ -222,11 +222,11 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { self.visit_expr(arg); } }, - Expr_::ExprMethodCall(ref _method_name, ref _generics, ref _args) => { + ExprKind::MethodCall(ref _method_name, ref _generics, ref _args) => { println!("MethodCall(ref method_name, ref generics, ref args) = {};", current); - println!(" // unimplemented: `ExprMethodCall` is not further destructured at the moment"); + println!(" // unimplemented: `ExprKind::MethodCall` is not further destructured at the moment"); }, - Expr_::ExprTup(ref elements) => { + ExprKind::Tup(ref elements) => { let elements_pat = self.next("elements"); println!("Tup(ref {}) = {};", elements_pat, current); println!(" if {}.len() == {};", elements_pat, elements.len()); @@ -235,24 +235,24 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { self.visit_expr(element); } }, - Expr_::ExprBinary(ref op, ref left, ref right) => { + ExprKind::Binary(ref op, ref left, ref right) => { let op_pat = self.next("op"); let left_pat = self.next("left"); let right_pat = self.next("right"); println!("Binary(ref {}, ref {}, ref {}) = {};", op_pat, left_pat, right_pat, current); - println!(" if BinOp_::{:?} == {}.node;", op.node, op_pat); + println!(" if BinOpKind::{:?} == {}.node;", op.node, op_pat); self.current = left_pat; self.visit_expr(left); self.current = right_pat; self.visit_expr(right); }, - Expr_::ExprUnary(ref op, ref inner) => { + ExprKind::Unary(ref op, ref inner) => { let inner_pat = self.next("inner"); println!("Unary(UnOp::{:?}, ref {}) = {};", op, inner_pat, current); self.current = inner_pat; self.visit_expr(inner); }, - Expr_::ExprLit(ref lit) => { + ExprKind::Lit(ref lit) => { let lit_pat = self.next("lit"); println!("Lit(ref {}) = {};", lit_pat, current); match lit.node { @@ -277,27 +277,27 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { }, } }, - Expr_::ExprCast(ref expr, ref ty) => { + ExprKind::Cast(ref expr, ref ty) => { let cast_pat = self.next("expr"); let cast_ty = self.next("cast_ty"); let qp_label = self.next("qp"); println!("Cast(ref {}, ref {}) = {};", cast_pat, cast_ty, current); - if let Ty_::TyPath(ref qp) = ty.node { - println!(" if let Ty_::TyPath(ref {}) = {}.node;", qp_label, cast_ty); + if let TyKind::Path(ref qp) = ty.node { + println!(" if let TyKind::Path(ref {}) = {}.node;", qp_label, cast_ty); self.current = qp_label; self.print_qpath(qp); } self.current = cast_pat; self.visit_expr(expr); }, - Expr_::ExprType(ref expr, ref _ty) => { + ExprKind::Type(ref expr, ref _ty) => { let cast_pat = self.next("expr"); println!("Type(ref {}, _) = {};", cast_pat, current); self.current = cast_pat; self.visit_expr(expr); }, - Expr_::ExprIf(ref cond, ref then, ref opt_else) => { + ExprKind::If(ref cond, ref then, ref opt_else) => { let cond_pat = self.next("cond"); let then_pat = self.next("then"); if let Some(ref else_) = *opt_else { @@ -313,7 +313,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { self.current = then_pat; self.visit_expr(then); }, - Expr_::ExprWhile(ref cond, ref body, _) => { + ExprKind::While(ref cond, ref body, _) => { let cond_pat = self.next("cond"); let body_pat = self.next("body"); let label_pat = self.next("label"); @@ -323,7 +323,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { self.current = body_pat; self.visit_block(body); }, - Expr_::ExprLoop(ref body, _, desugaring) => { + ExprKind::Loop(ref body, _, desugaring) => { let body_pat = self.next("body"); let des = loop_desugaring_name(desugaring); let label_pat = self.next("label"); @@ -331,7 +331,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { self.current = body_pat; self.visit_block(body); }, - Expr_::ExprMatch(ref expr, ref arms, desugaring) => { + ExprKind::Match(ref expr, ref arms, desugaring) => { let des = desugaring_name(desugaring); let expr_pat = self.next("expr"); let arms_pat = self.next("arms"); @@ -355,23 +355,23 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { } } }, - Expr_::ExprClosure(ref _capture_clause, ref _func, _, _, _) => { + ExprKind::Closure(ref _capture_clause, ref _func, _, _, _) => { println!("Closure(ref capture_clause, ref func, _, _, _) = {};", current); - println!(" // unimplemented: `ExprClosure` is not further destructured at the moment"); + println!(" // unimplemented: `ExprKind::Closure` is not further destructured at the moment"); }, - Expr_::ExprYield(ref sub) => { + ExprKind::Yield(ref sub) => { let sub_pat = self.next("sub"); println!("Yield(ref sub) = {};", current); self.current = sub_pat; self.visit_expr(sub); }, - Expr_::ExprBlock(ref block, _) => { + ExprKind::Block(ref block, _) => { let block_pat = self.next("block"); println!("Block(ref {}) = {};", block_pat, current); self.current = block_pat; self.visit_block(block); }, - Expr_::ExprAssign(ref target, ref value) => { + ExprKind::Assign(ref target, ref value) => { let target_pat = self.next("target"); let value_pat = self.next("value"); println!("Assign(ref {}, ref {}) = {};", target_pat, value_pat, current); @@ -380,18 +380,18 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { self.current = value_pat; self.visit_expr(value); }, - Expr_::ExprAssignOp(ref op, ref target, ref value) => { + ExprKind::AssignOp(ref op, ref target, ref value) => { let op_pat = self.next("op"); let target_pat = self.next("target"); let value_pat = self.next("value"); println!("AssignOp(ref {}, ref {}, ref {}) = {};", op_pat, target_pat, value_pat, current); - println!(" if BinOp_::{:?} == {}.node;", op.node, op_pat); + println!(" if BinOpKind::{:?} == {}.node;", op.node, op_pat); self.current = target_pat; self.visit_expr(target); self.current = value_pat; self.visit_expr(value); }, - Expr_::ExprField(ref object, ref field_ident) => { + ExprKind::Field(ref object, ref field_ident) => { let obj_pat = self.next("object"); let field_name_pat = self.next("field_name"); println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current); @@ -399,7 +399,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { self.current = obj_pat; self.visit_expr(object); }, - Expr_::ExprIndex(ref object, ref index) => { + ExprKind::Index(ref object, ref index) => { let object_pat = self.next("object"); let index_pat = self.next("index"); println!("Index(ref {}, ref {}) = {};", object_pat, index_pat, current); @@ -408,19 +408,19 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { self.current = index_pat; self.visit_expr(index); }, - Expr_::ExprPath(ref path) => { + ExprKind::Path(ref path) => { let path_pat = self.next("path"); println!("Path(ref {}) = {};", path_pat, current); self.current = path_pat; self.print_qpath(path); }, - Expr_::ExprAddrOf(mutability, ref inner) => { + ExprKind::AddrOf(mutability, ref inner) => { let inner_pat = self.next("inner"); println!("AddrOf({:?}, ref {}) = {};", mutability, inner_pat, current); self.current = inner_pat; self.visit_expr(inner); }, - Expr_::ExprBreak(ref _destination, ref opt_value) => { + ExprKind::Break(ref _destination, ref opt_value) => { let destination_pat = self.next("destination"); if let Some(ref value) = *opt_value { let value_pat = self.next("value"); @@ -432,12 +432,12 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { } // FIXME: implement label printing }, - Expr_::ExprContinue(ref _destination) => { + ExprKind::Continue(ref _destination) => { let destination_pat = self.next("destination"); println!("Again(ref {}) = {};", destination_pat, current); // FIXME: implement label printing }, - Expr_::ExprRet(ref opt_value) => if let Some(ref value) = *opt_value { + ExprKind::Ret(ref opt_value) => if let Some(ref value) = *opt_value { let value_pat = self.next("value"); println!("Ret(Some(ref {})) = {};", value_pat, current); self.current = value_pat; @@ -445,11 +445,11 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { } else { println!("Ret(None) = {};", current); }, - Expr_::ExprInlineAsm(_, ref _input, ref _output) => { + ExprKind::InlineAsm(_, ref _input, ref _output) => { println!("InlineAsm(_, ref input, ref output) = {};", current); - println!(" // unimplemented: `ExprInlineAsm` is not further destructured at the moment"); + println!(" // unimplemented: `ExprKind::InlineAsm` is not further destructured at the moment"); }, - Expr_::ExprStruct(ref path, ref fields, ref opt_base) => { + ExprKind::Struct(ref path, ref fields, ref opt_base) => { let path_pat = self.next("path"); let fields_pat = self.next("fields"); if let Some(ref base) = *opt_base { @@ -472,7 +472,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { println!(" // unimplemented: field checks"); }, // FIXME: compute length (needs type info) - Expr_::ExprRepeat(ref value, _) => { + ExprKind::Repeat(ref value, _) => { let value_pat = self.next("value"); println!("Repeat(ref {}, _) = {};", value_pat, current); println!("// unimplemented: repeat count check"); @@ -588,20 +588,20 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { } fn visit_stmt(&mut self, s: &Stmt) { - print!(" if let Stmt_::"); + print!(" if let StmtKind::"); let current = format!("{}.node", self.current); match s.node { // Could be an item or a local (let) binding: - StmtDecl(ref decl, _) => { + StmtKind::Decl(ref decl, _) => { let decl_pat = self.next("decl"); - println!("StmtDecl(ref {}, _) = {}", decl_pat, current); - print!(" if let Decl_::"); + println!("Decl(ref {}, _) = {}", decl_pat, current); + print!(" if let DeclKind::"); let current = format!("{}.node", decl_pat); match decl.node { // A local (let) binding: - Decl_::DeclLocal(ref local) => { + DeclKind::Local(ref local) => { let local_pat = self.next("local"); - println!("DeclLocal(ref {}) = {};", local_pat, current); + println!("Local(ref {}) = {};", local_pat, current); if let Some(ref init) = local.init { let init_pat = self.next("init"); println!(" if let Some(ref {}) = {}.init", init_pat, local_pat); @@ -612,24 +612,24 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { self.visit_pat(&local.pat); }, // An item binding: - Decl_::DeclItem(_) => { - println!("DeclItem(item_id) = {};", current); + DeclKind::Item(_) => { + println!("Item(item_id) = {};", current); }, } } // Expr without trailing semi-colon (must have unit type): - StmtExpr(ref e, _) => { + StmtKind::Expr(ref e, _) => { let e_pat = self.next("e"); - println!("StmtExpr(ref {}, _) = {}", e_pat, current); + println!("Expr(ref {}, _) = {}", e_pat, current); self.current = e_pat; self.visit_expr(e); }, // Expr with trailing semi-colon (may have any type): - StmtSemi(ref e, _) => { + StmtKind::Semi(ref e, _) => { let e_pat = self.next("e"); - println!("StmtSemi(ref {}, _) = {}", e_pat, current); + println!("Semi(ref {}, _) = {}", e_pat, current); self.current = e_pat; self.visit_expr(e); }, @@ -674,7 +674,7 @@ fn print_path(path: &QPath, first: &mut bool) { print!("{:?}", segment.ident.as_str()); }, QPath::TypeRelative(ref ty, ref segment) => match ty.node { - hir::Ty_::TyPath(ref inner_path) => { + hir::TyKind::Path(ref inner_path) => { print_path(inner_path, first); if *first { *first = false; diff --git a/clippy_lints/src/utils/comparisons.rs b/clippy_lints/src/utils/comparisons.rs index 5cb9b50a79d2..35f41d400ad8 100644 --- a/clippy_lints/src/utils/comparisons.rs +++ b/clippy_lints/src/utils/comparisons.rs @@ -2,7 +2,7 @@ #![deny(missing_docs_in_private_items)] -use rustc::hir::{BinOp_, Expr}; +use rustc::hir::{BinOpKind, Expr}; #[derive(PartialEq, Eq, Debug, Copy, Clone)] /// Represent a normalized comparison operator. @@ -19,14 +19,14 @@ pub enum Rel { /// Put the expression in the form `lhs < rhs`, `lhs <= rhs`, `lhs == rhs` or /// `lhs != rhs`. -pub fn normalize_comparison<'a>(op: BinOp_, lhs: &'a Expr, rhs: &'a Expr) -> Option<(Rel, &'a Expr, &'a Expr)> { +pub fn normalize_comparison<'a>(op: BinOpKind, lhs: &'a Expr, rhs: &'a Expr) -> Option<(Rel, &'a Expr, &'a Expr)> { match op { - BinOp_::BiLt => Some((Rel::Lt, lhs, rhs)), - BinOp_::BiLe => Some((Rel::Le, lhs, rhs)), - BinOp_::BiGt => Some((Rel::Lt, rhs, lhs)), - BinOp_::BiGe => Some((Rel::Le, rhs, lhs)), - BinOp_::BiEq => Some((Rel::Eq, rhs, lhs)), - BinOp_::BiNe => Some((Rel::Ne, rhs, lhs)), + BinOpKind::Lt => Some((Rel::Lt, lhs, rhs)), + BinOpKind::Le => Some((Rel::Le, lhs, rhs)), + BinOpKind::Gt => Some((Rel::Lt, rhs, lhs)), + BinOpKind::Ge => Some((Rel::Le, rhs, lhs)), + BinOpKind::Eq => Some((Rel::Eq, rhs, lhs)), + BinOpKind::Ne => Some((Rel::Ne, rhs, lhs)), _ => None, } } diff --git a/clippy_lints/src/utils/higher.rs b/clippy_lints/src/utils/higher.rs index 69f1792012a1..3f0243a91c07 100644 --- a/clippy_lints/src/utils/higher.rs +++ b/clippy_lints/src/utils/higher.rs @@ -9,26 +9,26 @@ use syntax::ast; use crate::utils::{is_expn_of, match_def_path, match_qpath, opt_def_id, paths, resolve_node}; /// Convert a hir binary operator to the corresponding `ast` type. -pub fn binop(op: hir::BinOp_) -> ast::BinOpKind { +pub fn binop(op: hir::BinOpKind) -> ast::BinOpKind { match op { - hir::BiEq => ast::BinOpKind::Eq, - hir::BiGe => ast::BinOpKind::Ge, - hir::BiGt => ast::BinOpKind::Gt, - hir::BiLe => ast::BinOpKind::Le, - hir::BiLt => ast::BinOpKind::Lt, - hir::BiNe => ast::BinOpKind::Ne, - hir::BiOr => ast::BinOpKind::Or, - hir::BiAdd => ast::BinOpKind::Add, - hir::BiAnd => ast::BinOpKind::And, - hir::BiBitAnd => ast::BinOpKind::BitAnd, - hir::BiBitOr => ast::BinOpKind::BitOr, - hir::BiBitXor => ast::BinOpKind::BitXor, - hir::BiDiv => ast::BinOpKind::Div, - hir::BiMul => ast::BinOpKind::Mul, - hir::BiRem => ast::BinOpKind::Rem, - hir::BiShl => ast::BinOpKind::Shl, - hir::BiShr => ast::BinOpKind::Shr, - hir::BiSub => ast::BinOpKind::Sub, + hir::BinOpKind::Eq => ast::BinOpKind::Eq, + hir::BinOpKind::Ge => ast::BinOpKind::Ge, + hir::BinOpKind::Gt => ast::BinOpKind::Gt, + hir::BinOpKind::Le => ast::BinOpKind::Le, + hir::BinOpKind::Lt => ast::BinOpKind::Lt, + hir::BinOpKind::Ne => ast::BinOpKind::Ne, + hir::BinOpKind::Or => ast::BinOpKind::Or, + hir::BinOpKind::Add => ast::BinOpKind::Add, + hir::BinOpKind::And => ast::BinOpKind::And, + hir::BinOpKind::BitAnd => ast::BinOpKind::BitAnd, + hir::BinOpKind::BitOr => ast::BinOpKind::BitOr, + hir::BinOpKind::BitXor => ast::BinOpKind::BitXor, + hir::BinOpKind::Div => ast::BinOpKind::Div, + hir::BinOpKind::Mul => ast::BinOpKind::Mul, + hir::BinOpKind::Rem => ast::BinOpKind::Rem, + hir::BinOpKind::Shl => ast::BinOpKind::Shl, + hir::BinOpKind::Shr => ast::BinOpKind::Shr, + hir::BinOpKind::Sub => ast::BinOpKind::Sub, } } @@ -87,7 +87,7 @@ pub fn range<'a, 'b, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'b hir::Expr) -> O // `#[no_std]`. Testing both instead of resolving the paths. match expr.node { - hir::ExprPath(ref path) => { + hir::ExprKind::Path(ref path) => { if match_qpath(path, &paths::RANGE_FULL_STD) || match_qpath(path, &paths::RANGE_FULL) { Some(Range { start: None, @@ -98,7 +98,7 @@ pub fn range<'a, 'b, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'b hir::Expr) -> O None } }, - hir::ExprCall(ref path, ref args) => if let hir::ExprPath(ref path) = path.node { + hir::ExprKind::Call(ref path, ref args) => if let hir::ExprKind::Path(ref path) = path.node { if match_qpath(path, &paths::RANGE_INCLUSIVE_STD_NEW) || match_qpath(path, &paths::RANGE_INCLUSIVE_NEW) { Some(Range { start: Some(&args[0]), @@ -111,7 +111,7 @@ pub fn range<'a, 'b, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'b hir::Expr) -> O } else { None }, - hir::ExprStruct(ref path, ref fields, None) => if match_qpath(path, &paths::RANGE_FROM_STD) + hir::ExprKind::Struct(ref path, ref fields, None) => if match_qpath(path, &paths::RANGE_FROM_STD) || match_qpath(path, &paths::RANGE_FROM) { Some(Range { @@ -154,9 +154,9 @@ pub fn is_from_for_desugar(decl: &hir::Decl) -> bool { // } // ``` if_chain! { - if let hir::DeclLocal(ref loc) = decl.node; + if let hir::DeclKind::Local(ref loc) = decl.node; if let Some(ref expr) = loc.init; - if let hir::ExprMatch(_, _, hir::MatchSource::ForLoopDesugar) = expr.node; + if let hir::ExprKind::Match(_, _, hir::MatchSource::ForLoopDesugar) = expr.node; then { return true; } @@ -171,7 +171,7 @@ pub fn is_from_for_desugar(decl: &hir::Decl) -> bool { // } // ``` if_chain! { - if let hir::DeclLocal(ref loc) = decl.node; + if let hir::DeclKind::Local(ref loc) = decl.node; if let hir::LocalSource::ForLoopDesugar = loc.source; then { return true; @@ -185,15 +185,15 @@ pub fn is_from_for_desugar(decl: &hir::Decl) -> bool { /// `for pat in arg { body }` becomes `(pat, arg, body)`. pub fn for_loop(expr: &hir::Expr) -> Option<(&hir::Pat, &hir::Expr, &hir::Expr)> { if_chain! { - if let hir::ExprMatch(ref iterexpr, ref arms, hir::MatchSource::ForLoopDesugar) = expr.node; - if let hir::ExprCall(_, ref iterargs) = iterexpr.node; + if let hir::ExprKind::Match(ref iterexpr, ref arms, hir::MatchSource::ForLoopDesugar) = expr.node; + if let hir::ExprKind::Call(_, ref iterargs) = iterexpr.node; if iterargs.len() == 1 && arms.len() == 1 && arms[0].guard.is_none(); - if let hir::ExprLoop(ref block, _, _) = arms[0].body.node; + if let hir::ExprKind::Loop(ref block, _, _) = arms[0].body.node; if block.expr.is_none(); if let [ _, _, ref let_stmt, ref body ] = *block.stmts; - if let hir::StmtDecl(ref decl, _) = let_stmt.node; - if let hir::DeclLocal(ref decl) = decl.node; - if let hir::StmtExpr(ref expr, _) = body.node; + if let hir::StmtKind::Decl(ref decl, _) = let_stmt.node; + if let hir::DeclKind::Local(ref decl) = decl.node; + if let hir::StmtKind::Expr(ref expr, _) = body.node; then { return Some((&*decl.pat, &iterargs[0], expr)); } @@ -213,8 +213,8 @@ pub enum VecArgs<'a> { /// from `vec!`. pub fn vec_macro<'e>(cx: &LateContext, expr: &'e hir::Expr) -> Option> { if_chain! { - if let hir::ExprCall(ref fun, ref args) = expr.node; - if let hir::ExprPath(ref path) = fun.node; + if let hir::ExprKind::Call(ref fun, ref args) = expr.node; + if let hir::ExprKind::Path(ref path) = fun.node; if is_expn_of(fun.span, "vec").is_some(); if let Some(fun_def_id) = opt_def_id(resolve_node(cx, path, fun.hir_id)); then { @@ -225,8 +225,8 @@ pub fn vec_macro<'e>(cx: &LateContext, expr: &'e hir::Expr) -> Option SpanlessEq<'a, 'tcx> { /// Check whether two statements are the same. pub fn eq_stmt(&mut self, left: &Stmt, right: &Stmt) -> bool { match (&left.node, &right.node) { - (&StmtDecl(ref l, _), &StmtDecl(ref r, _)) => { - if let (&DeclLocal(ref l), &DeclLocal(ref r)) = (&l.node, &r.node) { + (&StmtKind::Decl(ref l, _), &StmtKind::Decl(ref r, _)) => { + if let (&DeclKind::Local(ref l), &DeclKind::Local(ref r)) = (&l.node, &r.node) { both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) && both(&l.init, &r.init, |l, r| self.eq_expr(l, r)) } else { false } }, - (&StmtExpr(ref l, _), &StmtExpr(ref r, _)) | (&StmtSemi(ref l, _), &StmtSemi(ref r, _)) => { + (&StmtKind::Expr(ref l, _), &StmtKind::Expr(ref r, _)) | (&StmtKind::Semi(ref l, _), &StmtKind::Semi(ref r, _)) => { self.eq_expr(l, r) }, _ => false, @@ -75,52 +75,52 @@ 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), - (&ExprContinue(li), &ExprContinue(ri)) => { + (&ExprKind::AddrOf(l_mut, ref le), &ExprKind::AddrOf(r_mut, ref re)) => l_mut == r_mut && self.eq_expr(le, re), + (&ExprKind::Continue(li), &ExprKind::Continue(ri)) => { both(&li.label, &ri.label, |l, r| l.ident.as_str() == r.ident.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)) => { + (&ExprKind::Assign(ref ll, ref lr), &ExprKind::Assign(ref rl, ref rr)) => self.eq_expr(ll, rl) && self.eq_expr(lr, rr), + (&ExprKind::AssignOp(ref lo, ref ll, ref lr), &ExprKind::AssignOp(ref ro, ref rl, ref rr)) => { lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) }, - (&ExprBlock(ref l, _), &ExprBlock(ref r, _)) => self.eq_block(l, r), - (&ExprBinary(l_op, ref ll, ref lr), &ExprBinary(r_op, ref rl, ref rr)) => { + (&ExprKind::Block(ref l, _), &ExprKind::Block(ref r, _)) => self.eq_block(l, r), + (&ExprKind::Binary(l_op, ref ll, ref lr), &ExprKind::Binary(r_op, ref rl, ref rr)) => { l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) || swap_binop(l_op.node, ll, lr).map_or(false, |(l_op, ll, lr)| { l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr) }) }, - (&ExprBreak(li, ref le), &ExprBreak(ri, ref re)) => { + (&ExprKind::Break(li, ref le), &ExprKind::Break(ri, ref re)) => { both(&li.label, &ri.label, |l, r| l.ident.as_str() == r.ident.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)) => { + (&ExprKind::Box(ref l), &ExprKind::Box(ref r)) => self.eq_expr(l, r), + (&ExprKind::Call(ref l_fun, ref l_args), &ExprKind::Call(ref r_fun, ref r_args)) => { !self.ignore_fn && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args) }, - (&ExprCast(ref lx, ref lt), &ExprCast(ref rx, ref rt)) | - (&ExprType(ref lx, ref lt), &ExprType(ref rx, ref rt)) => self.eq_expr(lx, rx) && self.eq_ty(lt, rt), - (&ExprField(ref l_f_exp, ref l_f_ident), &ExprField(ref r_f_exp, ref r_f_ident)) => { + (&ExprKind::Cast(ref lx, ref lt), &ExprKind::Cast(ref rx, ref rt)) | + (&ExprKind::Type(ref lx, ref lt), &ExprKind::Type(ref rx, ref rt)) => self.eq_expr(lx, rx) && self.eq_ty(lt, rt), + (&ExprKind::Field(ref l_f_exp, ref l_f_ident), &ExprKind::Field(ref r_f_exp, ref r_f_ident)) => { l_f_ident.name == r_f_ident.name && self.eq_expr(l_f_exp, r_f_exp) }, - (&ExprIndex(ref la, ref li), &ExprIndex(ref ra, ref ri)) => self.eq_expr(la, ra) && self.eq_expr(li, ri), - (&ExprIf(ref lc, ref lt, ref le), &ExprIf(ref rc, ref rt, ref re)) => { + (&ExprKind::Index(ref la, ref li), &ExprKind::Index(ref ra, ref ri)) => self.eq_expr(la, ra) && self.eq_expr(li, ri), + (&ExprKind::If(ref lc, ref lt, ref le), &ExprKind::If(ref rc, ref rt, ref re)) => { self.eq_expr(lc, rc) && self.eq_expr(&**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)) => { + (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node, + (&ExprKind::Loop(ref lb, ref ll, ref lls), &ExprKind::Loop(ref rb, ref rl, ref rls)) => { lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.as_str() == r.ident.as_str()) }, - (&ExprMatch(ref le, ref la, ref ls), &ExprMatch(ref re, ref ra, ref rs)) => { + (&ExprKind::Match(ref le, ref la, ref ls), &ExprKind::Match(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)) }) }, - (&ExprMethodCall(ref l_path, _, ref l_args), &ExprMethodCall(ref r_path, _, ref r_args)) => { + (&ExprKind::MethodCall(ref l_path, _, ref l_args), &ExprKind::MethodCall(ref r_path, _, ref r_args)) => { !self.ignore_fn && self.eq_path_segment(l_path, r_path) && self.eq_exprs(l_args, r_args) }, - (&ExprRepeat(ref le, ref ll_id), &ExprRepeat(ref re, ref rl_id)) => { + (&ExprKind::Repeat(ref le, ref ll_id), &ExprKind::Repeat(ref re, ref rl_id)) => { let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(ll_id.body)); let ll = celcx.expr(&self.cx.tcx.hir.body(ll_id.body).value); let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(rl_id.body)); @@ -128,16 +128,16 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { self.eq_expr(le, re) && 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), - (&ExprStruct(ref l_path, ref lf, ref lo), &ExprStruct(ref r_path, ref rf, ref ro)) => { + (&ExprKind::Ret(ref l), &ExprKind::Ret(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)), + (&ExprKind::Path(ref l), &ExprKind::Path(ref r)) => self.eq_qpath(l, r), + (&ExprKind::Struct(ref l_path, ref lf, ref lo), &ExprKind::Struct(ref r_path, ref rf, ref ro)) => { 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), - (&ExprUnary(l_op, ref le), &ExprUnary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re), - (&ExprArray(ref l), &ExprArray(ref r)) => self.eq_exprs(l, r), - (&ExprWhile(ref lc, ref lb, ref ll), &ExprWhile(ref rc, ref rb, ref rl)) => { + (&ExprKind::Tup(ref l_tup), &ExprKind::Tup(ref r_tup)) => self.eq_exprs(l_tup, r_tup), + (&ExprKind::Unary(l_op, ref le), &ExprKind::Unary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re), + (&ExprKind::Array(ref l), &ExprKind::Array(ref r)) => self.eq_exprs(l, r), + (&ExprKind::While(ref lc, ref lb, ref ll), &ExprKind::While(ref rc, ref rb, ref rl)) => { self.eq_expr(lc, rc) && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.as_str() == r.ident.as_str()) }, _ => false, @@ -246,10 +246,10 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { self.eq_ty_kind(&left.node, &right.node) } - pub fn eq_ty_kind(&mut self, left: &Ty_, right: &Ty_) -> bool { + pub fn eq_ty_kind(&mut self, left: &TyKind, right: &TyKind) -> bool { match (left, right) { - (&TySlice(ref l_vec), &TySlice(ref r_vec)) => self.eq_ty(l_vec, r_vec), - (&TyArray(ref lt, ref ll_id), &TyArray(ref rt, ref rl_id)) => { + (&TyKind::Slice(ref l_vec), &TyKind::Slice(ref r_vec)) => self.eq_ty(l_vec, r_vec), + (&TyKind::Array(ref lt, ref ll_id), &TyKind::Array(ref rt, ref rl_id)) => { let full_table = self.tables; let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(ll_id.body)); @@ -264,13 +264,13 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { self.tables = full_table; eq_ty && ll == rl }, - (&TyPtr(ref l_mut), &TyPtr(ref r_mut)) => l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty), - (&TyRptr(_, ref l_rmut), &TyRptr(_, ref r_rmut)) => { + (&TyKind::Ptr(ref l_mut), &TyKind::Ptr(ref r_mut)) => l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty), + (&TyKind::Rptr(_, ref l_rmut), &TyKind::Rptr(_, 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), - (&TyTup(ref l), &TyTup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)), - (&TyInfer, &TyInfer) => true, + (&TyKind::Path(ref l), &TyKind::Path(ref r)) => self.eq_qpath(l, r), + (&TyKind::Tup(ref l), &TyKind::Tup(ref r)) => over(l, r, |l, r| self.eq_ty(l, r)), + (&TyKind::Infer, &TyKind::Infer) => true, _ => false, } } @@ -280,14 +280,26 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> { } } -fn swap_binop<'a>(binop: BinOp_, lhs: &'a Expr, rhs: &'a Expr) -> Option<(BinOp_, &'a Expr, &'a Expr)> { +fn swap_binop<'a>(binop: BinOpKind, lhs: &'a Expr, rhs: &'a Expr) -> Option<(BinOpKind, &'a Expr, &'a Expr)> { match binop { - BiAdd | BiMul | BiBitXor | BiBitAnd | BiEq | BiNe | BiBitOr => Some((binop, rhs, lhs)), - BiLt => Some((BiGt, rhs, lhs)), - BiLe => Some((BiGe, rhs, lhs)), - BiGe => Some((BiLe, rhs, lhs)), - BiGt => Some((BiLt, rhs, lhs)), - BiShl | BiShr | BiRem | BiSub | BiDiv | BiAnd | BiOr => None, + BinOpKind::Add | + BinOpKind::Mul | + BinOpKind::Eq | + BinOpKind::Ne | + BinOpKind::BitAnd | + BinOpKind::BitXor | + BinOpKind::BitOr => Some((binop, rhs, lhs)), + BinOpKind::Lt => Some((BinOpKind::Gt, rhs, lhs)), + BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)), + BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)), + BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)), + BinOpKind::Shl | + BinOpKind::Shr | + BinOpKind::Rem | + BinOpKind::Sub | + BinOpKind::Div | + BinOpKind::And | + BinOpKind::Or => None, } } @@ -359,51 +371,51 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { } match e.node { - ExprAddrOf(m, ref e) => { - let c: fn(_, _) -> _ = ExprAddrOf; + ExprKind::AddrOf(m, ref e) => { + let c: fn(_, _) -> _ = ExprKind::AddrOf; c.hash(&mut self.s); m.hash(&mut self.s); self.hash_expr(e); }, - ExprContinue(i) => { - let c: fn(_) -> _ = ExprContinue; + ExprKind::Continue(i) => { + let c: fn(_) -> _ = ExprKind::Continue; c.hash(&mut self.s); if let Some(i) = i.label { self.hash_name(i.ident.name); } }, - ExprYield(ref e) => { - let c: fn(_) -> _ = ExprYield; + ExprKind::Yield(ref e) => { + let c: fn(_) -> _ = ExprKind::Yield; c.hash(&mut self.s); self.hash_expr(e); }, - ExprAssign(ref l, ref r) => { - let c: fn(_, _) -> _ = ExprAssign; + ExprKind::Assign(ref l, ref r) => { + let c: fn(_, _) -> _ = ExprKind::Assign; c.hash(&mut self.s); self.hash_expr(l); self.hash_expr(r); }, - ExprAssignOp(ref o, ref l, ref r) => { - let c: fn(_, _, _) -> _ = ExprAssignOp; + ExprKind::AssignOp(ref o, ref l, ref r) => { + let c: fn(_, _, _) -> _ = ExprKind::AssignOp; c.hash(&mut self.s); o.hash(&mut self.s); self.hash_expr(l); self.hash_expr(r); }, - ExprBlock(ref b, _) => { - let c: fn(_, _) -> _ = ExprBlock; + ExprKind::Block(ref b, _) => { + let c: fn(_, _) -> _ = ExprKind::Block; c.hash(&mut self.s); self.hash_block(b); }, - ExprBinary(op, ref l, ref r) => { - let c: fn(_, _, _) -> _ = ExprBinary; + ExprKind::Binary(op, ref l, ref r) => { + let c: fn(_, _, _) -> _ = ExprKind::Binary; c.hash(&mut self.s); op.node.hash(&mut self.s); self.hash_expr(l); self.hash_expr(r); }, - ExprBreak(i, ref j) => { - let c: fn(_, _) -> _ = ExprBreak; + ExprKind::Break(i, ref j) => { + let c: fn(_, _) -> _ = ExprKind::Break; c.hash(&mut self.s); if let Some(i) = i.label { self.hash_name(i.ident.name); @@ -412,25 +424,25 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { self.hash_expr(&*j); } }, - ExprBox(ref e) => { - let c: fn(_) -> _ = ExprBox; + ExprKind::Box(ref e) => { + let c: fn(_) -> _ = ExprKind::Box; c.hash(&mut self.s); self.hash_expr(e); }, - ExprCall(ref fun, ref args) => { - let c: fn(_, _) -> _ = ExprCall; + ExprKind::Call(ref fun, ref args) => { + let c: fn(_, _) -> _ = ExprKind::Call; c.hash(&mut self.s); self.hash_expr(fun); self.hash_exprs(args); }, - ExprCast(ref e, ref _ty) => { - let c: fn(_, _) -> _ = ExprCast; + ExprKind::Cast(ref e, ref _ty) => { + let c: fn(_, _) -> _ = ExprKind::Cast; c.hash(&mut self.s); self.hash_expr(e); // TODO: _ty }, - ExprClosure(cap, _, eid, _, _) => { - let c: fn(_, _, _, _, _) -> _ = ExprClosure; + ExprKind::Closure(cap, _, eid, _, _) => { + let c: fn(_, _, _, _, _) -> _ = ExprKind::Closure; c.hash(&mut self.s); match cap { CaptureClause::CaptureByValue => 0, @@ -438,24 +450,24 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { }.hash(&mut self.s); self.hash_expr(&self.cx.tcx.hir.body(eid).value); }, - ExprField(ref e, ref f) => { - let c: fn(_, _) -> _ = ExprField; + ExprKind::Field(ref e, ref f) => { + let c: fn(_, _) -> _ = ExprKind::Field; c.hash(&mut self.s); self.hash_expr(e); self.hash_name(f.name); }, - ExprIndex(ref a, ref i) => { - let c: fn(_, _) -> _ = ExprIndex; + ExprKind::Index(ref a, ref i) => { + let c: fn(_, _) -> _ = ExprKind::Index; c.hash(&mut self.s); self.hash_expr(a); self.hash_expr(i); }, - ExprInlineAsm(..) => { - let c: fn(_, _, _) -> _ = ExprInlineAsm; + ExprKind::InlineAsm(..) => { + let c: fn(_, _, _) -> _ = ExprKind::InlineAsm; c.hash(&mut self.s); }, - ExprIf(ref cond, ref t, ref e) => { - let c: fn(_, _, _) -> _ = ExprIf; + ExprKind::If(ref cond, ref t, ref e) => { + let c: fn(_, _, _) -> _ = ExprKind::If; c.hash(&mut self.s); self.hash_expr(cond); self.hash_expr(&**t); @@ -463,21 +475,21 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { self.hash_expr(e); } }, - ExprLit(ref l) => { - let c: fn(_) -> _ = ExprLit; + ExprKind::Lit(ref l) => { + let c: fn(_) -> _ = ExprKind::Lit; c.hash(&mut self.s); l.hash(&mut self.s); }, - ExprLoop(ref b, ref i, _) => { - let c: fn(_, _, _) -> _ = ExprLoop; + ExprKind::Loop(ref b, ref i, _) => { + let c: fn(_, _, _) -> _ = ExprKind::Loop; c.hash(&mut self.s); self.hash_block(b); if let Some(i) = *i { self.hash_name(i.ident.name); } }, - ExprMatch(ref e, ref arms, ref s) => { - let c: fn(_, _, _) -> _ = ExprMatch; + ExprKind::Match(ref e, ref arms, ref s) => { + let c: fn(_, _, _) -> _ = ExprKind::Match; c.hash(&mut self.s); self.hash_expr(e); @@ -491,14 +503,14 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { s.hash(&mut self.s); }, - ExprMethodCall(ref path, ref _tys, ref args) => { - let c: fn(_, _, _) -> _ = ExprMethodCall; + ExprKind::MethodCall(ref path, ref _tys, ref args) => { + let c: fn(_, _, _) -> _ = ExprKind::MethodCall; c.hash(&mut self.s); self.hash_name(path.ident.name); self.hash_exprs(args); }, - ExprRepeat(ref e, ref l_id) => { - let c: fn(_, _) -> _ = ExprRepeat; + ExprKind::Repeat(ref e, ref l_id) => { + let c: fn(_, _) -> _ = ExprKind::Repeat; c.hash(&mut self.s); self.hash_expr(e); let full_table = self.tables; @@ -506,20 +518,20 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { self.hash_expr(&self.cx.tcx.hir.body(l_id.body).value); self.tables = full_table; }, - ExprRet(ref e) => { - let c: fn(_) -> _ = ExprRet; + ExprKind::Ret(ref e) => { + let c: fn(_) -> _ = ExprKind::Ret; c.hash(&mut self.s); if let Some(ref e) = *e { self.hash_expr(e); } }, - ExprPath(ref qpath) => { - let c: fn(_) -> _ = ExprPath; + ExprKind::Path(ref qpath) => { + let c: fn(_) -> _ = ExprKind::Path; c.hash(&mut self.s); self.hash_qpath(qpath); }, - ExprStruct(ref path, ref fields, ref expr) => { - let c: fn(_, _, _) -> _ = ExprStruct; + ExprKind::Struct(ref path, ref fields, ref expr) => { + let c: fn(_, _, _) -> _ = ExprKind::Struct; c.hash(&mut self.s); self.hash_qpath(path); @@ -533,32 +545,32 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { self.hash_expr(e); } }, - ExprTup(ref tup) => { - let c: fn(_) -> _ = ExprTup; + ExprKind::Tup(ref tup) => { + let c: fn(_) -> _ = ExprKind::Tup; c.hash(&mut self.s); self.hash_exprs(tup); }, - ExprType(ref e, ref _ty) => { - let c: fn(_, _) -> _ = ExprType; + ExprKind::Type(ref e, ref _ty) => { + let c: fn(_, _) -> _ = ExprKind::Type; c.hash(&mut self.s); self.hash_expr(e); // TODO: _ty }, - ExprUnary(lop, ref le) => { - let c: fn(_, _) -> _ = ExprUnary; + ExprKind::Unary(lop, ref le) => { + let c: fn(_, _) -> _ = ExprKind::Unary; c.hash(&mut self.s); lop.hash(&mut self.s); self.hash_expr(le); }, - ExprArray(ref v) => { - let c: fn(_) -> _ = ExprArray; + ExprKind::Array(ref v) => { + let c: fn(_) -> _ = ExprKind::Array; c.hash(&mut self.s); self.hash_exprs(v); }, - ExprWhile(ref cond, ref b, l) => { - let c: fn(_, _, _) -> _ = ExprWhile; + ExprKind::While(ref cond, ref b, l) => { + let c: fn(_, _, _) -> _ = ExprKind::While; c.hash(&mut self.s); self.hash_expr(cond); @@ -601,23 +613,23 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> { pub fn hash_stmt(&mut self, b: &Stmt) { match b.node { - StmtDecl(ref decl, _) => { - let c: fn(_, _) -> _ = StmtDecl; + StmtKind::Decl(ref decl, _) => { + let c: fn(_, _) -> _ = StmtKind::Decl; c.hash(&mut self.s); - if let DeclLocal(ref local) = decl.node { + if let DeclKind::Local(ref local) = decl.node { if let Some(ref init) = local.init { self.hash_expr(init); } } }, - StmtExpr(ref expr, _) => { - let c: fn(_, _) -> _ = StmtExpr; + StmtKind::Expr(ref expr, _) => { + let c: fn(_, _) -> _ = StmtKind::Expr; c.hash(&mut self.s); self.hash_expr(expr); }, - StmtSemi(ref expr, _) => { - let c: fn(_, _) -> _ = StmtSemi; + StmtKind::Semi(ref expr, _) => { + let c: fn(_, _) -> _ = StmtKind::Semi; c.hash(&mut self.s); self.hash_expr(expr); }, diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs index ccc4c9df6e7f..b2b99da3c59a 100644 --- a/clippy_lints/src/utils/inspector.rs +++ b/clippy_lints/src/utils/inspector.rs @@ -122,8 +122,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { return; } match stmt.node { - hir::StmtDecl(ref decl, _) => print_decl(cx, decl), - hir::StmtExpr(ref e, _) | hir::StmtSemi(ref e, _) => print_expr(cx, e, 0), + hir::StmtKind::Decl(ref decl, _) => print_decl(cx, decl), + hir::StmtKind::Expr(ref e, _) | hir::StmtKind::Semi(ref e, _) => print_expr(cx, e, 0), } } // fn check_foreign_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx @@ -141,7 +141,7 @@ fn has_attr(attrs: &[Attribute]) -> bool { fn print_decl(cx: &LateContext, decl: &hir::Decl) { match decl.node { - hir::DeclLocal(ref local) => { + hir::DeclKind::Local(ref local) => { println!("local variable of type {}", cx.tables.node_id_to_type(local.hir_id)); println!("pattern:"); print_pat(cx, &local.pat, 0); @@ -150,7 +150,7 @@ fn print_decl(cx: &LateContext, decl: &hir::Decl) { print_expr(cx, e, 0); } }, - hir::DeclItem(_) => println!("item decl"), + hir::DeclKind::Item(_) => println!("item decl"), } } @@ -160,17 +160,17 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) { println!("{}ty: {}", ind, cx.tables.expr_ty(expr)); println!("{}adjustments: {:?}", ind, cx.tables.adjustments().get(expr.hir_id)); match expr.node { - hir::ExprBox(ref e) => { + hir::ExprKind::Box(ref e) => { println!("{}Box", ind); print_expr(cx, e, indent + 1); }, - hir::ExprArray(ref v) => { + hir::ExprKind::Array(ref v) => { println!("{}Array", ind); for e in v { print_expr(cx, e, indent + 1); } }, - hir::ExprCall(ref func, ref args) => { + hir::ExprKind::Call(ref func, ref args) => { println!("{}Call", ind); println!("{}function:", ind); print_expr(cx, func, indent + 1); @@ -179,20 +179,20 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) { print_expr(cx, arg, indent + 1); } }, - hir::ExprMethodCall(ref path, _, ref args) => { + hir::ExprKind::MethodCall(ref path, _, ref args) => { println!("{}MethodCall", ind); println!("{}method name: {}", ind, path.ident.name); for arg in args { print_expr(cx, arg, indent + 1); } }, - hir::ExprTup(ref v) => { + hir::ExprKind::Tup(ref v) => { println!("{}Tup", ind); for e in v { print_expr(cx, e, indent + 1); } }, - hir::ExprBinary(op, ref lhs, ref rhs) => { + hir::ExprKind::Binary(op, ref lhs, ref rhs) => { println!("{}Binary", ind); println!("{}op: {:?}", ind, op.node); println!("{}lhs:", ind); @@ -200,26 +200,26 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) { println!("{}rhs:", ind); print_expr(cx, rhs, indent + 1); }, - hir::ExprUnary(op, ref inner) => { + hir::ExprKind::Unary(op, ref inner) => { println!("{}Unary", ind); println!("{}op: {:?}", ind, op); print_expr(cx, inner, indent + 1); }, - hir::ExprLit(ref lit) => { + hir::ExprKind::Lit(ref lit) => { println!("{}Lit", ind); println!("{}{:?}", ind, lit); }, - hir::ExprCast(ref e, ref target) => { + hir::ExprKind::Cast(ref e, ref target) => { println!("{}Cast", ind); print_expr(cx, e, indent + 1); println!("{}target type: {:?}", ind, target); }, - hir::ExprType(ref e, ref target) => { + hir::ExprKind::Type(ref e, ref target) => { println!("{}Type", ind); print_expr(cx, e, indent + 1); println!("{}target type: {:?}", ind, target); }, - hir::ExprIf(ref e, _, ref els) => { + hir::ExprKind::If(ref e, _, ref els) => { println!("{}If", ind); println!("{}condition:", ind); print_expr(cx, e, indent + 1); @@ -228,39 +228,39 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) { print_expr(cx, els, indent + 1); } }, - hir::ExprWhile(ref cond, _, _) => { + hir::ExprKind::While(ref cond, _, _) => { println!("{}While", ind); println!("{}condition:", ind); print_expr(cx, cond, indent + 1); }, - hir::ExprLoop(..) => { + hir::ExprKind::Loop(..) => { println!("{}Loop", ind); }, - hir::ExprMatch(ref cond, _, ref source) => { + hir::ExprKind::Match(ref cond, _, ref source) => { println!("{}Match", ind); println!("{}condition:", ind); print_expr(cx, cond, indent + 1); println!("{}source: {:?}", ind, source); }, - hir::ExprClosure(ref clause, _, _, _, _) => { + hir::ExprKind::Closure(ref clause, _, _, _, _) => { println!("{}Closure", ind); println!("{}clause: {:?}", ind, clause); }, - hir::ExprYield(ref sub) => { + hir::ExprKind::Yield(ref sub) => { println!("{}Yield", ind); print_expr(cx, sub, indent + 1); }, - hir::ExprBlock(_, _) => { + hir::ExprKind::Block(_, _) => { println!("{}Block", ind); }, - hir::ExprAssign(ref lhs, ref rhs) => { + hir::ExprKind::Assign(ref lhs, ref rhs) => { println!("{}Assign", ind); println!("{}lhs:", ind); print_expr(cx, lhs, indent + 1); println!("{}rhs:", ind); print_expr(cx, rhs, indent + 1); }, - hir::ExprAssignOp(ref binop, ref lhs, ref rhs) => { + hir::ExprKind::AssignOp(ref binop, ref lhs, ref rhs) => { println!("{}AssignOp", ind); println!("{}op: {:?}", ind, binop.node); println!("{}lhs:", ind); @@ -268,46 +268,46 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) { println!("{}rhs:", ind); print_expr(cx, rhs, indent + 1); }, - hir::ExprField(ref e, ident) => { + hir::ExprKind::Field(ref e, ident) => { println!("{}Field", ind); println!("{}field name: {}", ind, ident.name); println!("{}struct expr:", ind); print_expr(cx, e, indent + 1); }, - hir::ExprIndex(ref arr, ref idx) => { + hir::ExprKind::Index(ref arr, ref idx) => { println!("{}Index", ind); println!("{}array expr:", ind); print_expr(cx, arr, indent + 1); println!("{}index expr:", ind); print_expr(cx, idx, indent + 1); }, - hir::ExprPath(hir::QPath::Resolved(ref ty, ref path)) => { + hir::ExprKind::Path(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)) => { + hir::ExprKind::Path(hir::QPath::TypeRelative(ref ty, ref seg)) => { println!("{}Relative Path, {:?}", ind, ty); println!("{}seg: {:?}", ind, seg); }, - hir::ExprAddrOf(ref muta, ref e) => { + hir::ExprKind::AddrOf(ref muta, ref e) => { println!("{}AddrOf", ind); println!("mutability: {:?}", muta); print_expr(cx, e, indent + 1); }, - hir::ExprBreak(_, ref e) => { + hir::ExprKind::Break(_, ref e) => { println!("{}Break", ind); if let Some(ref e) = *e { print_expr(cx, e, indent + 1); } }, - hir::ExprContinue(_) => println!("{}Again", ind), - hir::ExprRet(ref e) => { + hir::ExprKind::Continue(_) => println!("{}Again", ind), + hir::ExprKind::Ret(ref e) => { println!("{}Ret", ind); if let Some(ref e) = *e { print_expr(cx, e, indent + 1); } }, - hir::ExprInlineAsm(_, ref input, ref output) => { + hir::ExprKind::InlineAsm(_, ref input, ref output) => { println!("{}InlineAsm", ind); println!("{}inputs:", ind); for e in input { @@ -318,7 +318,7 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) { print_expr(cx, e, indent + 1); } }, - hir::ExprStruct(ref path, ref fields, ref base) => { + hir::ExprKind::Struct(ref path, ref fields, ref base) => { println!("{}Struct", ind); println!("{}path: {:?}", ind, path); for field in fields { @@ -330,7 +330,7 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) { print_expr(cx, base, indent + 1); } }, - hir::ExprRepeat(ref val, ref anon_const) => { + hir::ExprKind::Repeat(ref val, ref anon_const) => { println!("{}Repeat", ind); println!("{}value:", ind); print_expr(cx, val, indent + 1); @@ -353,7 +353,7 @@ fn print_item(cx: &LateContext, item: &hir::Item) { hir::VisibilityKind::Inherited => println!("visibility inherited from outer item"), } match item.node { - hir::ItemExternCrate(ref _renamed_from) => { + hir::ItemKind::ExternCrate(ref _renamed_from) => { let def_id = cx.tcx.hir.local_def_id(item.id); if let Some(crate_id) = cx.tcx.extern_mod_stmt_cnum(def_id) { let source = cx.tcx.used_crate_source(crate_id); @@ -367,32 +367,32 @@ fn print_item(cx: &LateContext, item: &hir::Item) { println!("weird extern crate without a crate id"); } }, - hir::ItemUse(ref path, ref kind) => println!("{:?}, {:?}", path, kind), - hir::ItemStatic(..) => println!("static item of type {:#?}", cx.tcx.type_of(did)), - hir::ItemConst(..) => println!("const item of type {:#?}", cx.tcx.type_of(did)), - hir::ItemFn(..) => { + hir::ItemKind::Use(ref path, ref kind) => println!("{:?}, {:?}", path, kind), + hir::ItemKind::Static(..) => println!("static item of type {:#?}", cx.tcx.type_of(did)), + hir::ItemKind::Const(..) => println!("const item of type {:#?}", cx.tcx.type_of(did)), + hir::ItemKind::Fn(..) => { let item_ty = cx.tcx.type_of(did); println!("function of type {:#?}", item_ty); }, - hir::ItemMod(..) => println!("module"), - hir::ItemForeignMod(ref fm) => println!("foreign module with abi: {}", fm.abi), - hir::ItemGlobalAsm(ref asm) => println!("global asm: {:?}", asm), - hir::ItemTy(..) => { + hir::ItemKind::Mod(..) => println!("module"), + hir::ItemKind::ForeignMod(ref fm) => println!("foreign module with abi: {}", fm.abi), + hir::ItemKind::GlobalAsm(ref asm) => println!("global asm: {:?}", asm), + hir::ItemKind::Ty(..) => { println!("type alias for {:?}", cx.tcx.type_of(did)); }, - hir::ItemExistential(..) => { + hir::ItemKind::Existential(..) => { println!("existential type with real type {:?}", cx.tcx.type_of(did)); }, - hir::ItemEnum(..) => { + hir::ItemKind::Enum(..) => { println!("enum definition of type {:?}", cx.tcx.type_of(did)); }, - hir::ItemStruct(..) => { + hir::ItemKind::Struct(..) => { println!("struct definition of type {:?}", cx.tcx.type_of(did)); }, - hir::ItemUnion(..) => { + hir::ItemKind::Union(..) => { println!("union definition of type {:?}", cx.tcx.type_of(did)); }, - hir::ItemTrait(..) => { + hir::ItemKind::Trait(..) => { println!("trait decl"); if cx.tcx.trait_is_auto(did) { println!("trait is auto"); @@ -400,13 +400,13 @@ fn print_item(cx: &LateContext, item: &hir::Item) { println!("trait is not auto"); } }, - hir::ItemTraitAlias(..) => { + hir::ItemKind::TraitAlias(..) => { println!("trait alias"); } - hir::ItemImpl(_, _, _, _, Some(ref _trait_ref), _, _) => { + hir::ItemKind::Impl(_, _, _, _, Some(ref _trait_ref), _, _) => { println!("trait impl"); }, - hir::ItemImpl(_, _, _, _, None, _, _) => { + hir::ItemKind::Impl(_, _, _, _, None, _, _) => { println!("impl"); }, } diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs index ef26b77ea1a4..a348df83a9d1 100644 --- a/clippy_lints/src/utils/internal_lints.rs +++ b/clippy_lints/src/utils/internal_lints.rs @@ -1,5 +1,6 @@ use rustc::lint::*; use rustc::hir::*; +use rustc::hir; use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; use crate::utils::{match_qpath, paths, span_lint}; use syntax::symbol::LocalInternedString; @@ -117,7 +118,7 @@ impl LintPass for LintWithoutLintPass { 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, body_id) = item.node { + if let hir::ItemKind::Static(ref ty, MutImmutable, body_id) = item.node { if is_lint_ref_type(ty) { self.declared_lints.insert(item.name, item.span); } else if is_lint_array_type(ty) && item.name == "ARRAY" { @@ -162,7 +163,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LintWithoutLintPass { fn is_lint_ref_type(ty: &Ty) -> bool { - if let TyRptr( + if let TyKind::Rptr( _, MutTy { ty: ref inner, @@ -170,7 +171,7 @@ fn is_lint_ref_type(ty: &Ty) -> bool { }, ) = ty.node { - if let TyPath(ref path) = inner.node { + if let TyKind::Path(ref path) = inner.node { return match_qpath(path, &paths::LINT); } } @@ -179,7 +180,7 @@ fn is_lint_ref_type(ty: &Ty) -> bool { fn is_lint_array_type(ty: &Ty) -> bool { - if let TyPath(ref path) = ty.node { + if let TyKind::Path(ref path) = ty.node { match_qpath(path, &paths::LINT_ARRAY) } else { false diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs index 6765d9afb66d..c38a925efedf 100644 --- a/clippy_lints/src/utils/mod.rs +++ b/clippy_lints/src/utils/mod.rs @@ -174,7 +174,7 @@ pub fn match_trait_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool /// Check if an expression references a variable of the given name. pub fn match_var(expr: &Expr, var: Name) -> bool { - if let ExprPath(QPath::Resolved(None, ref path)) = expr.node { + if let ExprKind::Path(QPath::Resolved(None, ref path)) = expr.node { if path.segments.len() == 1 && path.segments[0].ident.name == var { return true; } @@ -210,7 +210,7 @@ pub fn match_qpath(path: &QPath, segments: &[&str]) -> bool { match *path { QPath::Resolved(_, ref path) => match_path(path, segments), QPath::TypeRelative(ref ty, ref segment) => match ty.node { - TyPath(ref inner_path) => { + TyKind::Path(ref inner_path) => { !segments.is_empty() && match_qpath(inner_path, &segments[..(segments.len() - 1)]) && segment.ident.name == segments[segments.len() - 1] }, @@ -330,7 +330,7 @@ pub fn method_chain_args<'a>(expr: &'a Expr, methods: &[&str]) -> Option first - if let ExprMethodCall(ref path, _, ref args) = current.node { + if let ExprKind::MethodCall(ref path, _, ref args) = current.node { if path.ident.name == *method_name { if args.iter().any(|e| in_macro(e.span)) { return None; @@ -435,7 +435,7 @@ pub fn last_line_of_span<'a, T: LintContext<'a>>(cx: &T, span: Span) -> Span { Span::new(*line_start, span.hi(), span.ctxt()) } -/// Like `snippet_block`, but add braces if the expr is not an `ExprBlock`. +/// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`. /// Also takes an `Option` which can be put inside the braces. pub fn expr_block<'a, 'b, T: LintContext<'b>>( cx: &T, @@ -445,7 +445,7 @@ pub fn expr_block<'a, 'b, T: LintContext<'b>>( ) -> Cow<'a, str> { let code = snippet_block(cx, expr.span, default); let string = option.unwrap_or_default(); - if let ExprBlock(_, _) = expr.node { + if let ExprKind::Block(_, _) = expr.node { Cow::Owned(format!("{}{}", code, string)) } else if string.is_empty() { Cow::Owned(format!("{{ {} }}", code)) @@ -524,13 +524,13 @@ pub fn get_enclosing_block<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, node: NodeI match node { Node::NodeBlock(block) => Some(block), Node::NodeItem(&Item { - node: ItemFn(_, _, _, eid), + node: ItemKind::Fn(_, _, _, eid), .. }) | Node::NodeImplItem(&ImplItem { node: ImplItemKind::Method(_, eid), .. }) => match cx.tcx.hir.body(eid).value.node { - ExprBlock(ref block, _) => Some(block), + ExprKind::Block(ref block, _) => Some(block), _ => None, }, _ => None, @@ -667,7 +667,7 @@ where /// Return the base type for HIR references and pointers. pub fn walk_ptrs_hir_ty(ty: &hir::Ty) -> &hir::Ty { match ty.node { - TyPtr(ref mut_ty) | TyRptr(_, ref mut_ty) => walk_ptrs_hir_ty(&mut_ty.ty), + TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(&mut_ty.ty), _ => ty, } } @@ -695,7 +695,7 @@ pub fn walk_ptrs_ty_depth(ty: Ty) -> (Ty, usize) { /// Check whether the given expression is a constant literal of the given value. pub fn is_integer_literal(expr: &Expr, value: u128) -> bool { // FIXME: use constant folding - if let ExprLit(ref spanned) = expr.node { + if let ExprKind::Lit(ref spanned) = expr.node { if let LitKind::Int(v, _) = spanned.node { return v == value; } @@ -945,7 +945,7 @@ pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool { /// Ie. `x`, `{ x }` and `{{{{ x }}}}` all give `x`. `{ x; y }` and `{}` return /// themselves. pub fn remove_blocks(expr: &Expr) -> &Expr { - if let ExprBlock(ref block, _) = expr.node { + if let ExprKind::Block(ref block, _) = expr.node { if block.stmts.is_empty() { if let Some(ref expr) = block.expr { remove_blocks(expr) @@ -998,7 +998,7 @@ pub fn is_self(slf: &Arg) -> bool { pub fn is_self_ty(slf: &hir::Ty) -> bool { if_chain! { - if let TyPath(ref qp) = slf.node; + if let TyKind::Path(ref qp) = slf.node; if let QPath::Resolved(None, ref path) = *qp; if let Def::SelfTy(..) = path.def; then { @@ -1020,7 +1020,7 @@ pub fn is_try(expr: &Expr) -> Option<&Expr> { if let PatKind::TupleStruct(ref path, ref pat, None) = arm.pats[0].node; if match_qpath(path, &paths::RESULT_OK[1..]); if let PatKind::Binding(_, defid, _, None) = pat[0].node; - if let ExprPath(QPath::Resolved(None, ref path)) = arm.body.node; + if let ExprKind::Path(QPath::Resolved(None, ref path)) = arm.body.node; if let Def::Local(lid) = path.def; if lid == defid; then { @@ -1038,7 +1038,7 @@ pub fn is_try(expr: &Expr) -> Option<&Expr> { } } - if let ExprMatch(_, ref arms, ref source) = expr.node { + if let ExprKind::Match(_, ref arms, ref source) = expr.node { // desugared from a `?` operator if let MatchSource::TryDesugar = *source { return Some(expr); diff --git a/clippy_lints/src/utils/ptr.rs b/clippy_lints/src/utils/ptr.rs index 09ec90ac63fc..4275345d395e 100644 --- a/clippy_lints/src/utils/ptr.rs +++ b/clippy_lints/src/utils/ptr.rs @@ -54,7 +54,7 @@ impl<'a, 'tcx: 'a> Visitor<'tcx> for PtrCloneVisitor<'a, 'tcx> { if self.abort { return; } - if let ExprMethodCall(ref seg, _, ref args) = expr.node { + if let ExprKind::MethodCall(ref seg, _, ref args) = expr.node { if args.len() == 1 && match_var(&args[0], self.name) { if seg.ident.name == "capacity" { self.abort = true; diff --git a/clippy_lints/src/utils/sugg.rs b/clippy_lints/src/utils/sugg.rs index eb2197a5891e..ff9424289c5c 100644 --- a/clippy_lints/src/utils/sugg.rs +++ b/clippy_lints/src/utils/sugg.rs @@ -46,35 +46,35 @@ impl<'a> Sugg<'a> { snippet_opt(cx, expr.span).map(|snippet| { let snippet = Cow::Owned(snippet); match expr.node { - hir::ExprAddrOf(..) | - hir::ExprBox(..) | - hir::ExprClosure(.., _) | - hir::ExprIf(..) | - hir::ExprUnary(..) | - hir::ExprMatch(..) => Sugg::MaybeParen(snippet), - hir::ExprContinue(..) | - hir::ExprYield(..) | - hir::ExprArray(..) | - hir::ExprBlock(..) | - hir::ExprBreak(..) | - hir::ExprCall(..) | - hir::ExprField(..) | - hir::ExprIndex(..) | - hir::ExprInlineAsm(..) | - hir::ExprLit(..) | - hir::ExprLoop(..) | - hir::ExprMethodCall(..) | - hir::ExprPath(..) | - hir::ExprRepeat(..) | - hir::ExprRet(..) | - hir::ExprStruct(..) | - hir::ExprTup(..) | - hir::ExprWhile(..) => Sugg::NonParen(snippet), - hir::ExprAssign(..) => Sugg::BinOp(AssocOp::Assign, snippet), - hir::ExprAssignOp(op, ..) => Sugg::BinOp(hirbinop2assignop(op), snippet), - hir::ExprBinary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(higher::binop(op.node)), snippet), - hir::ExprCast(..) => Sugg::BinOp(AssocOp::As, snippet), - hir::ExprType(..) => Sugg::BinOp(AssocOp::Colon, snippet), + hir::ExprKind::AddrOf(..) | + hir::ExprKind::Box(..) | + hir::ExprKind::Closure(.., _) | + hir::ExprKind::If(..) | + hir::ExprKind::Unary(..) | + hir::ExprKind::Match(..) => Sugg::MaybeParen(snippet), + hir::ExprKind::Continue(..) | + hir::ExprKind::Yield(..) | + hir::ExprKind::Array(..) | + hir::ExprKind::Block(..) | + hir::ExprKind::Break(..) | + hir::ExprKind::Call(..) | + hir::ExprKind::Field(..) | + hir::ExprKind::Index(..) | + hir::ExprKind::InlineAsm(..) | + hir::ExprKind::Lit(..) | + hir::ExprKind::Loop(..) | + hir::ExprKind::MethodCall(..) | + hir::ExprKind::Path(..) | + hir::ExprKind::Repeat(..) | + hir::ExprKind::Ret(..) | + hir::ExprKind::Struct(..) | + hir::ExprKind::Tup(..) | + hir::ExprKind::While(..) => Sugg::NonParen(snippet), + hir::ExprKind::Assign(..) => Sugg::BinOp(AssocOp::Assign, snippet), + hir::ExprKind::AssignOp(op, ..) => Sugg::BinOp(hirbinop2assignop(op), snippet), + hir::ExprKind::Binary(op, ..) => Sugg::BinOp(AssocOp::from_ast_binop(higher::binop(op.node)), snippet), + hir::ExprKind::Cast(..) => Sugg::BinOp(AssocOp::As, snippet), + hir::ExprKind::Type(..) => Sugg::BinOp(AssocOp::Colon, snippet), } }) } @@ -382,21 +382,29 @@ fn associativity(op: &AssocOp) -> Associativity { /// Convert a `hir::BinOp` to the corresponding assigning binary operator. fn hirbinop2assignop(op: hir::BinOp) -> AssocOp { - use rustc::hir::BinOp_::*; use syntax::parse::token::BinOpToken::*; AssocOp::AssignOp(match op.node { - BiAdd => Plus, - BiBitAnd => And, - BiBitOr => Or, - BiBitXor => Caret, - BiDiv => Slash, - BiMul => Star, - BiRem => Percent, - BiShl => Shl, - BiShr => Shr, - BiSub => Minus, - BiAnd | BiEq | BiGe | BiGt | BiLe | BiLt | BiNe | BiOr => panic!("This operator does not exist"), + hir::BinOpKind::Add => Plus, + hir::BinOpKind::BitAnd => And, + hir::BinOpKind::BitOr => Or, + hir::BinOpKind::BitXor => Caret, + hir::BinOpKind::Div => Slash, + hir::BinOpKind::Mul => Star, + hir::BinOpKind::Rem => Percent, + hir::BinOpKind::Shl => Shl, + hir::BinOpKind::Shr => Shr, + hir::BinOpKind::Sub => Minus, + + | hir::BinOpKind::And + | hir::BinOpKind::Eq + | hir::BinOpKind::Ge + | hir::BinOpKind::Gt + | hir::BinOpKind::Le + | hir::BinOpKind::Lt + | hir::BinOpKind::Ne + | hir::BinOpKind::Or + => panic!("This operator does not exist"), }) } diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs index 0d8997f4f36e..39ab77c3afa1 100644 --- a/clippy_lints/src/vec.rs +++ b/clippy_lints/src/vec.rs @@ -37,7 +37,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { if_chain! { if let ty::TyRef(_, ty, _) = cx.tables.expr_ty_adjusted(expr).sty; if let ty::TySlice(..) = ty.sty; - if let ExprAddrOf(_, ref addressee) = expr.node; + if let ExprKind::AddrOf(_, ref addressee) = expr.node; if let Some(vec_args) = higher::vec_macro(cx, addressee); then { check_vec_macro(cx, &vec_args, expr.span); diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs index 86c95dbcc564..556d128bca79 100644 --- a/clippy_lints/src/write.rs +++ b/clippy_lints/src/write.rs @@ -175,9 +175,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) { match expr.node { // print!() - ExprCall(ref fun, ref args) => { + ExprKind::Call(ref fun, ref args) => { if_chain! { - if let ExprPath(ref qpath) = fun.node; + if let ExprKind::Path(ref qpath) = fun.node; if let Some(fun_id) = opt_def_id(resolve_node(cx, qpath, fun.hir_id)); then { check_print_variants(cx, expr, fun_id, args); @@ -185,7 +185,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass { } }, // write!() - ExprMethodCall(ref fun, _, ref args) => { + ExprKind::MethodCall(ref fun, _, ref args) => { if fun.ident.name == "write_fmt" { check_write_variants(cx, expr, args); } @@ -206,8 +206,8 @@ fn check_write_variants<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, if_chain! { // ensure we're calling Arguments::new_v1 or Arguments::new_v1_formatted if write_args.len() == 2; - if let ExprCall(ref args_fun, ref args_args) = write_args[1].node; - if let ExprPath(ref qpath) = args_fun.node; + if let ExprKind::Call(ref args_fun, ref args_args) = write_args[1].node; + if let ExprKind::Path(ref qpath) = args_fun.node; if let Some(const_def_id) = opt_def_id(resolve_node(cx, qpath, args_fun.hir_id)); if match_def_path(cx.tcx, const_def_id, &paths::FMT_ARGUMENTS_NEWV1) || match_def_path(cx.tcx, const_def_id, &paths::FMT_ARGUMENTS_NEWV1FORMATTED); @@ -219,9 +219,9 @@ fn check_write_variants<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, if_chain! { if args_args.len() >= 2; - if let ExprAddrOf(_, ref match_expr) = args_args[1].node; - if let ExprMatch(ref args, _, _) = match_expr.node; - if let ExprTup(ref args) = args.node; + if let ExprKind::AddrOf(_, ref match_expr) = args_args[1].node; + if let ExprKind::Match(ref args, _, _) = match_expr.node; + if let ExprKind::Tup(ref args) = args.node; if let Some((fmtstr, fmtlen)) = get_argument_fmtstr_parts(&args_args[0]); then { match name { @@ -269,7 +269,7 @@ fn check_print_variants<'a, 'tcx>( if_chain! { // ensure we're calling Arguments::new_v1 if args.len() == 1; - if let ExprCall(ref args_fun, ref args_args) = args[0].node; + if let ExprKind::Call(ref args_fun, ref args_args) = args[0].node; then { // Check for literals in the print!/println! args check_fmt_args_for_literal(cx, args_args, |span| { @@ -277,13 +277,13 @@ fn check_print_variants<'a, 'tcx>( }); if_chain! { - if let ExprPath(ref qpath) = args_fun.node; + if let ExprKind::Path(ref qpath) = args_fun.node; if let Some(const_def_id) = opt_def_id(resolve_node(cx, qpath, args_fun.hir_id)); if match_def_path(cx.tcx, const_def_id, &paths::FMT_ARGUMENTS_NEWV1); if args_args.len() == 2; - if let ExprAddrOf(_, ref match_expr) = args_args[1].node; - if let ExprMatch(ref args, _, _) = match_expr.node; - if let ExprTup(ref args) = args.node; + if let ExprKind::AddrOf(_, ref match_expr) = args_args[1].node; + if let ExprKind::Match(ref args, _, _) = match_expr.node; + if let ExprKind::Tup(ref args) = args.node; if let Some((fmtstr, fmtlen)) = get_argument_fmtstr_parts(&args_args[0]); then { match name { @@ -315,7 +315,7 @@ fn check_print_variants<'a, 'tcx>( // Search for something like // `::std::fmt::ArgumentV1::new(__arg0, ::std::fmt::Debug::fmt)` else if args.len() == 2 && match_def_path(cx.tcx, fun_id, &paths::FMT_ARGUMENTV1_NEW) { - if let ExprPath(ref qpath) = args[1].node { + if let ExprKind::Path(ref qpath) = args[1].node { if let Some(def_id) = opt_def_id(cx.tables.qpath_def(qpath, args[1].hir_id)) { if match_def_path(cx.tcx, def_id, &paths::DEBUG_FMT_METHOD) && !is_in_debug_impl(cx, expr) && is_expn_of(expr.span, "panic").is_none() @@ -341,25 +341,25 @@ where if args.len() >= 2; // the match statement - if let ExprAddrOf(_, ref match_expr) = args[1].node; - if let ExprMatch(ref matchee, ref arms, _) = match_expr.node; - if let ExprTup(ref tup) = matchee.node; + if let ExprKind::AddrOf(_, ref match_expr) = args[1].node; + if let ExprKind::Match(ref matchee, ref arms, _) = match_expr.node; + if let ExprKind::Tup(ref tup) = matchee.node; if arms.len() == 1; - if let ExprArray(ref arm_body_exprs) = arms[0].body.node; + if let ExprKind::Array(ref arm_body_exprs) = arms[0].body.node; then { // it doesn't matter how many args there are in the `write!`/`writeln!`, // if there's one literal, we should warn the user for (idx, tup_arg) in tup.iter().enumerate() { if_chain! { - // first, make sure we're dealing with a literal (i.e., an ExprLit) - if let ExprAddrOf(_, ref tup_val) = tup_arg.node; - if let ExprLit(_) = tup_val.node; + // first, make sure we're dealing with a literal (i.e., an ExprKind::Lit) + if let ExprKind::AddrOf(_, ref tup_val) = tup_arg.node; + if let ExprKind::Lit(_) = tup_val.node; // next, check the corresponding match arm body to ensure // this is DISPLAY_FMT_METHOD - if let ExprCall(_, ref body_args) = arm_body_exprs[idx].node; + if let ExprKind::Call(_, ref body_args) = arm_body_exprs[idx].node; if body_args.len() == 2; - if let ExprPath(ref body_qpath) = body_args[1].node; + if let ExprKind::Path(ref body_qpath) = body_args[1].node; if let Some(fun_def_id) = opt_def_id(resolve_node(cx, body_qpath, body_args[1].hir_id)); if match_def_path(cx.tcx, fun_def_id, &paths::DISPLAY_FMT_METHOD); then { @@ -371,10 +371,10 @@ where // and is just "{}" if_chain! { if args.len() == 3; - if let ExprAddrOf(_, ref format_expr) = args[2].node; - if let ExprArray(ref format_exprs) = format_expr.node; + if let ExprKind::AddrOf(_, ref format_expr) = args[2].node; + if let ExprKind::Array(ref format_exprs) = format_expr.node; if format_exprs.len() >= 1; - if let ExprStruct(_, ref fields, _) = format_exprs[idx].node; + if let ExprKind::Struct(_, ref fields, _) = format_exprs[idx].node; if let Some(format_field) = fields.iter().find(|f| f.ident.name == "format"); if check_unformatted(&format_field.expr); then { @@ -429,10 +429,10 @@ fn has_empty_arg<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, span: Span, fmtstr: Local /// Returns the slice of format string parts in an `Arguments::new_v1` call. fn get_argument_fmtstr_parts(expr: &Expr) -> Option<(LocalInternedString, usize)> { if_chain! { - if let ExprAddrOf(_, ref expr) = expr.node; // &["…", "…", …] - if let ExprArray(ref exprs) = expr.node; + if let ExprKind::AddrOf(_, ref expr) = expr.node; // &["…", "…", …] + if let ExprKind::Array(ref exprs) = expr.node; if let Some(expr) = exprs.last(); - if let ExprLit(ref lit) = expr.node; + if let ExprKind::Lit(ref lit) = expr.node; if let LitKind::Str(ref lit, _) = lit.node; then { return Some((lit.as_str(), exprs.len())); @@ -448,7 +448,7 @@ fn is_in_debug_impl(cx: &LateContext, expr: &Expr) -> bool { if let Some(NodeImplItem(item)) = map.find(map.get_parent(expr.id)) { // `Debug` impl if let Some(NodeItem(item)) = map.find(map.get_parent(item.id)) { - if let ItemImpl(_, _, _, _, Some(ref tr), _, _) = item.node { + if let ItemKind::Impl(_, _, _, _, Some(ref tr), _, _) = item.node { return match_path(&tr.path, &["Debug"]); } } @@ -468,15 +468,15 @@ fn is_in_debug_impl(cx: &LateContext, expr: &Expr) -> bool { /// ``` pub fn check_unformatted(format_field: &Expr) -> bool { if_chain! { - if let ExprStruct(_, ref fields, _) = format_field.node; + if let ExprKind::Struct(_, ref fields, _) = format_field.node; if let Some(width_field) = fields.iter().find(|f| f.ident.name == "width"); - if let ExprPath(ref qpath) = width_field.expr.node; + if let ExprKind::Path(ref qpath) = width_field.expr.node; if last_path_segment(qpath).ident.name == "Implied"; if let Some(align_field) = fields.iter().find(|f| f.ident.name == "align"); - if let ExprPath(ref qpath) = align_field.expr.node; + if let ExprKind::Path(ref qpath) = align_field.expr.node; if last_path_segment(qpath).ident.name == "Unknown"; if let Some(precision_field) = fields.iter().find(|f| f.ident.name == "precision"); - if let ExprPath(ref qpath_precision) = precision_field.expr.node; + if let ExprKind::Path(ref qpath_precision) = precision_field.expr.node; if last_path_segment(qpath_precision).ident.name == "Implied"; then { return true; diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs index aaba01848450..5232d5714f13 100644 --- a/clippy_lints/src/zero_div_zero.rs +++ b/clippy_lints/src/zero_div_zero.rs @@ -32,8 +32,8 @@ 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_chain! { - if let ExprBinary(ref op, ref left, ref right) = expr.node; - if let BinOp_::BiDiv = op.node; + if let ExprKind::Binary(ref op, ref left, ref right) = expr.node; + if let BinOpKind::Div = op.node; // TODO - constant_simple does not fold many operations involving floats. // That's probably fine for this lint - it's pretty unlikely that someone would // do something like 0.0/(2.0 - 2.0), but it would be nice to warn on that case too. diff --git a/tests/ui/author.stdout b/tests/ui/author.stdout index a55b48985ad9..b06fb1d21e35 100644 --- a/tests/ui/author.stdout +++ b/tests/ui/author.stdout @@ -1,11 +1,11 @@ if_chain! { - if let Stmt_::StmtDecl(ref decl, _) = stmt.node - if let Decl_::DeclLocal(ref local) = decl.node; + if let StmtKind::Decl(ref decl, _) = stmt.node + if let DeclKind::Local(ref local) = decl.node; if let Some(ref init) = local.init - if let Expr_::ExprCast(ref expr, ref cast_ty) = init.node; - if let Ty_::TyPath(ref qp) = cast_ty.node; + if let ExprKind::Cast(ref expr, ref cast_ty) = init.node; + if let TyKind::Path(ref qp) = cast_ty.node; if match_qpath(qp, &["char"]); - if let Expr_::ExprLit(ref lit) = expr.node; + if let ExprKind::Lit(ref lit) = expr.node; if let LitKind::Int(69, _) = lit.node; if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local.pat.node; if name.node.as_str() == "x"; diff --git a/tests/ui/author/call.stdout b/tests/ui/author/call.stdout index 3e06bf9ace8b..1c25708fb484 100644 --- a/tests/ui/author/call.stdout +++ b/tests/ui/author/call.stdout @@ -1,14 +1,14 @@ if_chain! { - if let Stmt_::StmtDecl(ref decl, _) = stmt.node - if let Decl_::DeclLocal(ref local) = decl.node; + if let StmtKind::Decl(ref decl, _) = stmt.node + if let DeclKind::Local(ref local) = decl.node; if let Some(ref init) = local.init - if let Expr_::ExprCall(ref func, ref args) = init.node; - if let Expr_::ExprPath(ref path) = func.node; + if let ExprKind::Call(ref func, ref args) = init.node; + if let ExprKind::Path(ref path) = func.node; if match_qpath(path, &["{{root}}", "std", "cmp", "min"]); if args.len() == 2; - if let Expr_::ExprLit(ref lit) = args[0].node; + if let ExprKind::Lit(ref lit) = args[0].node; if let LitKind::Int(3, _) = lit.node; - if let Expr_::ExprLit(ref lit1) = args[1].node; + if let ExprKind::Lit(ref lit1) = args[1].node; if let LitKind::Int(4, _) = lit1.node; if let PatKind::Wild = local.pat.node; then { diff --git a/tests/ui/author/for_loop.stdout b/tests/ui/author/for_loop.stdout index 69bc6d7a0252..b99e8e0ade5e 100644 --- a/tests/ui/author/for_loop.stdout +++ b/tests/ui/author/for_loop.stdout @@ -1,60 +1,60 @@ if_chain! { - if let Expr_::ExprBlock(ref block) = expr.node; - if let Stmt_::StmtDecl(ref decl, _) = block.node - if let Decl_::DeclLocal(ref local) = decl.node; + if let ExprKind::Block(ref block) = expr.node; + if let StmtKind::Decl(ref decl, _) = block.node + if let DeclKind::Local(ref local) = decl.node; if let Some(ref init) = local.init - if let Expr_::ExprMatch(ref expr, ref arms, MatchSource::ForLoopDesugar) = init.node; - if let Expr_::ExprCall(ref func, ref args) = expr.node; - if let Expr_::ExprPath(ref path) = func.node; + if let ExprKind::Match(ref expr, ref arms, MatchSource::ForLoopDesugar) = init.node; + if let ExprKind::Call(ref func, ref args) = expr.node; + if let ExprKind::Path(ref path) = func.node; if match_qpath(path, &["{{root}}", "std", "iter", "IntoIterator", "into_iter"]); if args.len() == 1; - if let Expr_::ExprStruct(ref path1, ref fields, None) = args[0].node; + if let ExprKind::Struct(ref path1, ref fields, None) = args[0].node; if match_qpath(path1, &["{{root}}", "std", "ops", "Range"]); if fields.len() == 2; // unimplemented: field checks if arms.len() == 1; - if let Expr_::ExprLoop(ref body, ref label, LoopSource::ForLoop) = arms[0].body.node; - if let Stmt_::StmtDecl(ref decl1, _) = body.node - if let Decl_::DeclLocal(ref local1) = decl1.node; + if let ExprKind::Loop(ref body, ref label, LoopSource::ForLoop) = arms[0].body.node; + if let StmtKind::Decl(ref decl1, _) = body.node + if let DeclKind::Local(ref local1) = decl1.node; if let PatKind::Binding(BindingAnnotation::Mutable, _, name, None) = local1.pat.node; if name.node.as_str() == "__next"; - if let Stmt_::StmtExpr(ref e, _) = local1.pat.node - if let Expr_::ExprMatch(ref expr1, ref arms1, MatchSource::ForLoopDesugar) = e.node; - if let Expr_::ExprCall(ref func1, ref args1) = expr1.node; - if let Expr_::ExprPath(ref path2) = func1.node; + if let StmtKind::Expr(ref e, _) = local1.pat.node + if let ExprKind::Match(ref expr1, ref arms1, MatchSource::ForLoopDesugar) = e.node; + if let ExprKind::Call(ref func1, ref args1) = expr1.node; + if let ExprKind::Path(ref path2) = func1.node; if match_qpath(path2, &["{{root}}", "std", "iter", "Iterator", "next"]); if args1.len() == 1; - if let Expr_::ExprAddrOf(MutMutable, ref inner) = args1[0].node; - if let Expr_::ExprPath(ref path3) = inner.node; + if let ExprKind::AddrOf(MutMutable, ref inner) = args1[0].node; + if let ExprKind::Path(ref path3) = inner.node; if match_qpath(path3, &["iter"]); if arms1.len() == 2; - if let Expr_::ExprAssign(ref target, ref value) = arms1[0].body.node; - if let Expr_::ExprPath(ref path4) = target.node; + if let ExprKind::Assign(ref target, ref value) = arms1[0].body.node; + if let ExprKind::Path(ref path4) = target.node; if match_qpath(path4, &["__next"]); - if let Expr_::ExprPath(ref path5) = value.node; + if let ExprKind::Path(ref path5) = value.node; if match_qpath(path5, &["val"]); if arms1[0].pats.len() == 1; if let PatKind::TupleStruct(ref path6, ref fields1, None) = arms1[0].pats[0].node; if match_qpath(path6, &["{{root}}", "std", "option", "Option", "Some"]); if fields1.len() == 1; // unimplemented: field checks - if let Expr_::ExprBreak(ref destination, None) = arms1[1].body.node; + if let ExprKind::Break(ref destination, None) = arms1[1].body.node; if arms1[1].pats.len() == 1; if let PatKind::Path(ref path7) = arms1[1].pats[0].node; if match_qpath(path7, &["{{root}}", "std", "option", "Option", "None"]); - if let Stmt_::StmtDecl(ref decl2, _) = path7.node - if let Decl_::DeclLocal(ref local2) = decl2.node; + if let StmtKind::Decl(ref decl2, _) = path7.node + if let DeclKind::Local(ref local2) = decl2.node; if let Some(ref init1) = local2.init - if let Expr_::ExprPath(ref path8) = init1.node; + if let ExprKind::Path(ref path8) = init1.node; if match_qpath(path8, &["__next"]); if let PatKind::Binding(BindingAnnotation::Unannotated, _, name1, None) = local2.pat.node; if name1.node.as_str() == "y"; - if let Stmt_::StmtExpr(ref e1, _) = local2.pat.node - if let Expr_::ExprBlock(ref block1) = e1.node; - if let Stmt_::StmtDecl(ref decl3, _) = block1.node - if let Decl_::DeclLocal(ref local3) = decl3.node; + if let StmtKind::Expr(ref e1, _) = local2.pat.node + if let ExprKind::Block(ref block1) = e1.node; + if let StmtKind::Decl(ref decl3, _) = block1.node + if let DeclKind::Local(ref local3) = decl3.node; if let Some(ref init2) = local3.init - if let Expr_::ExprPath(ref path9) = init2.node; + if let ExprKind::Path(ref path9) = init2.node; if match_qpath(path9, &["y"]); if let PatKind::Binding(BindingAnnotation::Unannotated, _, name2, None) = local3.pat.node; if name2.node.as_str() == "z"; @@ -63,7 +63,7 @@ if_chain! { if name3.node.as_str() == "iter"; if let PatKind::Binding(BindingAnnotation::Unannotated, _, name4, None) = local.pat.node; if name4.node.as_str() == "_result"; - if let Expr_::ExprPath(ref path10) = local.pat.node; + if let ExprKind::Path(ref path10) = local.pat.node; if match_qpath(path10, &["_result"]); then { // report your lint here diff --git a/tests/ui/author/matches.stout b/tests/ui/author/matches.stout index db7de5a2ca5c..94b25aefabed 100644 --- a/tests/ui/author/matches.stout +++ b/tests/ui/author/matches.stout @@ -1,32 +1,32 @@ if_chain! { - if let Stmt_::StmtDecl(ref decl, _) = stmt.node - if let Decl_::DeclLocal(ref local) = decl.node; + if let StmtKind::Decl(ref decl, _) = stmt.node + if let DeclKind::Local(ref local) = decl.node; if let Some(ref init) = local.init - if let Expr_::ExprMatch(ref expr, ref arms, MatchSource::Normal) = init.node; - if let Expr_::ExprLit(ref lit) = expr.node; + if let ExprKind::Match(ref expr, ref arms, MatchSource::Normal) = init.node; + if let ExprKind::Lit(ref lit) = expr.node; if let LitKind::Int(42, _) = lit.node; if arms.len() == 3; - if let Expr_::ExprLit(ref lit1) = arms[0].body.node; + if let ExprKind::Lit(ref lit1) = arms[0].body.node; if let LitKind::Int(5, _) = lit1.node; if arms[0].pats.len() == 1; if let PatKind::Lit(ref lit_expr) = arms[0].pats[0].node - if let Expr_::ExprLit(ref lit2) = lit_expr.node; + if let ExprKind::Lit(ref lit2) = lit_expr.node; if let LitKind::Int(16, _) = lit2.node; - if let Expr_::ExprBlock(ref block) = arms[1].body.node; - if let Stmt_::StmtDecl(ref decl1, _) = block.node - if let Decl_::DeclLocal(ref local1) = decl1.node; + if let ExprKind::Block(ref block) = arms[1].body.node; + if let StmtKind::Decl(ref decl1, _) = block.node + if let DeclKind::Local(ref local1) = decl1.node; if let Some(ref init1) = local1.init - if let Expr_::ExprLit(ref lit3) = init1.node; + if let ExprKind::Lit(ref lit3) = init1.node; if let LitKind::Int(3, _) = lit3.node; if let PatKind::Binding(BindingAnnotation::Unannotated, _, name, None) = local1.pat.node; if name.node.as_str() == "x"; - if let Expr_::ExprPath(ref path) = local1.pat.node; + if let ExprKind::Path(ref path) = local1.pat.node; if match_qpath(path, &["x"]); if arms[1].pats.len() == 1; if let PatKind::Lit(ref lit_expr1) = arms[1].pats[0].node - if let Expr_::ExprLit(ref lit4) = lit_expr1.node; + if let ExprKind::Lit(ref lit4) = lit_expr1.node; if let LitKind::Int(17, _) = lit4.node; - if let Expr_::ExprLit(ref lit5) = arms[2].body.node; + if let ExprKind::Lit(ref lit5) = arms[2].body.node; if let LitKind::Int(1, _) = lit5.node; if arms[2].pats.len() == 1; if let PatKind::Wild = arms[2].pats[0].node; diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr index aa62ccbd0e52..6bbc0aebf9c9 100644 --- a/tests/ui/deprecated.stderr +++ b/tests/ui/deprecated.stderr @@ -1,4 +1,4 @@ -error: lint str_to_string has been removed: using `str::to_string` is common even today and specialization will likely happen soon +error: lint `str_to_string` has been removed: `using `str::to_string` is common even today and specialization will likely happen soon` --> $DIR/deprecated.rs:4:8 | 4 | #[warn(str_to_string)] @@ -6,25 +6,25 @@ error: lint str_to_string has been removed: using `str::to_string` is common eve | = note: `-D renamed-and-removed-lints` implied by `-D warnings` -error: lint string_to_string has been removed: using `string::to_string` is common even today and specialization will likely happen soon +error: lint `string_to_string` has been removed: `using `string::to_string` is common even today and specialization will likely happen soon` --> $DIR/deprecated.rs:6:8 | 6 | #[warn(string_to_string)] | ^^^^^^^^^^^^^^^^ -error: lint unstable_as_slice has been removed: `Vec::as_slice` has been stabilized in 1.7 +error: lint `unstable_as_slice` has been removed: ``Vec::as_slice` has been stabilized in 1.7` --> $DIR/deprecated.rs:8:8 | 8 | #[warn(unstable_as_slice)] | ^^^^^^^^^^^^^^^^^ -error: lint unstable_as_mut_slice has been removed: `Vec::as_mut_slice` has been stabilized in 1.7 +error: lint `unstable_as_mut_slice` has been removed: ``Vec::as_mut_slice` has been stabilized in 1.7` --> $DIR/deprecated.rs:10:8 | 10 | #[warn(unstable_as_mut_slice)] | ^^^^^^^^^^^^^^^^^^^^^ -error: lint misaligned_transmute has been removed: this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr +error: lint `misaligned_transmute` has been removed: `this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr` --> $DIR/deprecated.rs:12:8 | 12 | #[warn(misaligned_transmute)] diff --git a/tests/ui/suspicious_arithmetic_impl.rs b/tests/ui/suspicious_arithmetic_impl.rs index d5982efe12fb..9f6fce2495a3 100644 --- a/tests/ui/suspicious_arithmetic_impl.rs +++ b/tests/ui/suspicious_arithmetic_impl.rs @@ -25,7 +25,7 @@ impl Mul for Foo { type Output = Foo; fn mul(self, other: Foo) -> Foo { - Foo(self.0 * other.0 % 42) // OK: BiRem part of BiExpr as parent node + Foo(self.0 * other.0 % 42) // OK: BinOpKind::Rem part of BiExpr as parent node } } @@ -33,7 +33,7 @@ impl Sub for Foo { type Output = Foo; fn sub(self, other: Self) -> Self { - Foo(self.0 * other.0 - 42) // OK: BiMul part of BiExpr as child node + Foo(self.0 * other.0 - 42) // OK: BinOpKind::Mul part of BiExpr as child node } } @@ -41,7 +41,7 @@ impl Div for Foo { type Output = Foo; fn div(self, other: Self) -> Self { - Foo(do_nothing(self.0 + other.0) / 42) // OK: BiAdd part of BiExpr as child node + Foo(do_nothing(self.0 + other.0) / 42) // OK: BinOpKind::Add part of BiExpr as child node } } diff --git a/tests/ui/trailing_zeros.stdout b/tests/ui/trailing_zeros.stdout index 145c102ed95b..b311604c0c87 100644 --- a/tests/ui/trailing_zeros.stdout +++ b/tests/ui/trailing_zeros.stdout @@ -1,13 +1,13 @@ if_chain! { - if let Expr_::ExprBinary(ref op, ref left, ref right) = expr.node; - if BinOp_::BiEq == op.node; - if let Expr_::ExprBinary(ref op1, ref left1, ref right1) = left.node; - if BinOp_::BiBitAnd == op1.node; - if let Expr_::ExprPath(ref path) = left1.node; + if let ExprKind::Binary(ref op, ref left, ref right) = expr.node; + if BinOpKind::Eq == op.node; + if let ExprKind::Binary(ref op1, ref left1, ref right1) = left.node; + if BinOpKind::BitAnd == op1.node; + if let ExprKind::Path(ref path) = left1.node; if match_qpath(path, &["x"]); - if let Expr_::ExprLit(ref lit) = right1.node; + if let ExprKind::Lit(ref lit) = right1.node; if let LitKind::Int(15, _) = lit.node; - if let Expr_::ExprLit(ref lit1) = right.node; + if let ExprKind::Lit(ref lit1) = right.node; if let LitKind::Int(0, _) = lit1.node; then { // report your lint here