From e9a3e54910837b8cb4dce1bb476330dd3b1fd1d6 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Mon, 11 Nov 2019 09:24:12 -0800 Subject: [PATCH] MutImmutable -> Immutable, MutMutable -> Mutable, CaptureClause -> CaptureBy --- clippy_lints/src/functions.rs | 4 ++-- clippy_lints/src/loops.rs | 22 ++++++++++--------- clippy_lints/src/matches.rs | 2 +- clippy_lints/src/mem_replace.rs | 4 ++-- clippy_lints/src/methods/mod.rs | 12 +++++----- clippy_lints/src/misc.rs | 4 ++-- clippy_lints/src/mut_mut.rs | 11 +++++----- clippy_lints/src/mut_reference.rs | 7 +++--- clippy_lints/src/mutable_debug_assertion.rs | 4 ++-- clippy_lints/src/needless_borrow.rs | 8 +++---- clippy_lints/src/needless_borrowed_ref.rs | 4 ++-- clippy_lints/src/ptr.rs | 6 ++--- clippy_lints/src/transmute.rs | 6 ++--- .../src/trivially_copy_pass_by_ref.rs | 2 +- clippy_lints/src/types.rs | 6 ++--- clippy_lints/src/utils/author.rs | 2 +- clippy_lints/src/utils/hir_utils.rs | 4 ++-- clippy_lints/src/utils/internal_lints.rs | 4 ++-- tests/ui/author/for_loop.stdout | 2 +- 19 files changed, 59 insertions(+), 55 deletions(-) diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs index 8c3306f6d121d..f958a40aac6a5 100644 --- a/clippy_lints/src/functions.rs +++ b/clippy_lints/src/functions.rs @@ -548,7 +548,7 @@ fn is_mutable_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>, span: Span, Tuple(ref substs) => substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys)), Array(ty, _) | Slice(ty) => is_mutable_ty(cx, ty, span, tys), RawPtr(ty::TypeAndMut { ty, mutbl }) | Ref(_, ty, mutbl) => { - mutbl == hir::Mutability::MutMutable || is_mutable_ty(cx, ty, span, tys) + mutbl == hir::Mutability::Mutable || is_mutable_ty(cx, ty, span, tys) }, // calling something constitutes a side effect, so return true on all callables // also never calls need not be used, so return true for them, too @@ -653,7 +653,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> { tys.clear(); } }, - Assign(ref target, _) | AssignOp(_, ref target, _) | AddrOf(hir::Mutability::MutMutable, ref target) => { + Assign(ref target, _) | AssignOp(_, ref target, _) | AddrOf(hir::Mutability::Mutable, ref target) => { self.mutates_static |= is_mutated_static(self.cx, target) }, _ => {}, diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs index 805e609cea6e3..fcdef51c1d4d2 100644 --- a/clippy_lints/src/loops.rs +++ b/clippy_lints/src/loops.rs @@ -1506,8 +1506,8 @@ fn make_iterator_snippet(cx: &LateContext<'_, '_>, arg: &Expr, applic_ref: &mut match &arg.kind { ExprKind::AddrOf(mutability, arg_inner) if has_iter_method(cx, cx.tables.expr_ty(&arg_inner)).is_some() => { let meth_name = match mutability { - MutMutable => "iter_mut", - MutImmutable => "iter", + Mutability::Mutable => "iter_mut", + Mutability::Immutable => "iter", }; format!( "{}.{}()", @@ -1539,14 +1539,14 @@ fn check_for_loop_over_map_kv<'a, 'tcx>( let (new_pat_span, kind, ty, mutbl) = match cx.tables.expr_ty(arg).kind { ty::Ref(_, ty, mutbl) => match (&pat[0].kind, &pat[1].kind) { (key, _) if pat_is_wild(key, body) => (pat[1].span, "value", ty, mutbl), - (_, value) if pat_is_wild(value, body) => (pat[0].span, "key", ty, MutImmutable), + (_, value) if pat_is_wild(value, body) => (pat[0].span, "key", ty, Mutability::Immutable), _ => return, }, _ => return, }; let mutbl = match mutbl { - MutImmutable => "", - MutMutable => "_mut", + Mutability::Immutable => "", + Mutability::Mutable => "_mut", }; let arg = match arg.kind { ExprKind::AddrOf(_, ref expr) => &**expr, @@ -1874,7 +1874,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> { self.visit_expr(rhs); }, ExprKind::AddrOf(mutbl, ref expr) => { - if mutbl == MutMutable { + if mutbl == Mutability::Mutable { self.prefer_mutable = true; } self.visit_expr(expr); @@ -1885,7 +1885,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> { let ty = self.cx.tables.expr_ty_adjusted(expr); self.prefer_mutable = false; if let ty::Ref(_, _, mutbl) = ty.kind { - if mutbl == MutMutable { + if mutbl == Mutability::Mutable { self.prefer_mutable = true; } } @@ -1897,7 +1897,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> { for (ty, expr) in self.cx.tcx.fn_sig(def_id).inputs().skip_binder().iter().zip(args) { self.prefer_mutable = false; if let ty::Ref(_, _, mutbl) = ty.kind { - if mutbl == MutMutable { + if mutbl == Mutability::Mutable { self.prefer_mutable = true; } } @@ -2090,7 +2090,7 @@ impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> { } }, ExprKind::Assign(ref lhs, _) if lhs.hir_id == expr.hir_id => *state = VarState::DontWarn, - ExprKind::AddrOf(mutability, _) if mutability == MutMutable => *state = VarState::DontWarn, + ExprKind::AddrOf(mutability, _) if mutability == Mutability::Mutable => *state = VarState::DontWarn, _ => (), } } @@ -2172,7 +2172,9 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> { VarState::DontWarn } }, - ExprKind::AddrOf(mutability, _) if mutability == MutMutable => self.state = VarState::DontWarn, + ExprKind::AddrOf(mutability, _) if mutability == Mutability::Mutable => { + self.state = VarState::DontWarn + }, _ => (), } } diff --git a/clippy_lints/src/matches.rs b/clippy_lints/src/matches.rs index 569b189180c68..05c7e6d62200a 100644 --- a/clippy_lints/src/matches.rs +++ b/clippy_lints/src/matches.rs @@ -570,7 +570,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 ExprKind::AddrOf(Mutability::MutImmutable, ref inner) = ex.kind { + let (title, msg) = if let ExprKind::AddrOf(Mutability::Immutable, ref inner) = ex.kind { let span = ex.span.source_callsite(); suggs.push((span, Sugg::hir_with_macro_callsite(cx, inner, "..").to_string())); ( diff --git a/clippy_lints/src/mem_replace.rs b/clippy_lints/src/mem_replace.rs index 23bc4412717eb..115a47f30619a 100644 --- a/clippy_lints/src/mem_replace.rs +++ b/clippy_lints/src/mem_replace.rs @@ -2,7 +2,7 @@ use crate::utils::{ match_def_path, match_qpath, paths, snippet_with_applicability, span_help_and_lint, span_lint_and_sugg, }; use if_chain::if_chain; -use rustc::hir::{Expr, ExprKind, MutMutable, QPath}; +use rustc::hir::{Expr, ExprKind, Mutability, QPath}; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; use rustc::{declare_lint_pass, declare_tool_lint}; use rustc_errors::Applicability; @@ -90,7 +90,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MemReplace { // argument's type. All that's left is to get // replacee's path. let replaced_path = match func_args[0].kind { - ExprKind::AddrOf(MutMutable, ref replaced) => { + ExprKind::AddrOf(Mutability::Mutable, ref replaced) => { if let ExprKind::Path(QPath::Resolved(None, ref replaced_path)) = replaced.kind { replaced_path } else { diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs index c71324ea47254..9fcffc770050e 100644 --- a/clippy_lints/src/methods/mod.rs +++ b/clippy_lints/src/methods/mod.rs @@ -2764,8 +2764,8 @@ fn ty_has_iter_method(cx: &LateContext<'_, '_>, self_ref_ty: Ty<'_>) -> Option<( _ => unreachable!(), }; let method_name = match mutbl { - hir::MutImmutable => "iter", - hir::MutMutable => "iter_mut", + hir::Mutability::Immutable => "iter", + hir::Mutability::Mutable => "iter_mut", }; (ty_name, method_name) }) @@ -2955,8 +2955,8 @@ impl SelfKind { } let trait_path = match mutability { - hir::Mutability::MutImmutable => &paths::ASREF_TRAIT, - hir::Mutability::MutMutable => &paths::ASMUT_TRAIT, + hir::Mutability::Immutable => &paths::ASREF_TRAIT, + hir::Mutability::Mutable => &paths::ASMUT_TRAIT, }; let trait_def_id = match get_trait_def_id(cx, trait_path) { @@ -2969,9 +2969,9 @@ impl SelfKind { match self { Self::Value => matches_value(parent_ty, ty), Self::Ref => { - matches_ref(cx, hir::Mutability::MutImmutable, parent_ty, ty) || ty == parent_ty && is_copy(cx, ty) + matches_ref(cx, hir::Mutability::Immutable, parent_ty, ty) || ty == parent_ty && is_copy(cx, ty) }, - Self::RefMut => matches_ref(cx, hir::Mutability::MutMutable, parent_ty, ty), + Self::RefMut => matches_ref(cx, hir::Mutability::Mutable, parent_ty, ty), Self::No => ty != parent_ty, } } diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs index e7197b671c9e8..24c167c42a167 100644 --- a/clippy_lints/src/misc.rs +++ b/clippy_lints/src/misc.rs @@ -627,8 +627,8 @@ fn check_cast(cx: &LateContext<'_, '_>, span: Span, e: &Expr, ty: &Ty) { if !in_constant(cx, e.hir_id); then { let (msg, sugg_fn) = match mut_ty.mutbl { - Mutability::MutMutable => ("`0 as *mut _` detected", "std::ptr::null_mut"), - Mutability::MutImmutable => ("`0 as *const _` detected", "std::ptr::null"), + Mutability::Mutable => ("`0 as *mut _` detected", "std::ptr::null_mut"), + Mutability::Immutable => ("`0 as *const _` detected", "std::ptr::null"), }; let (sugg, appl) = if let TyKind::Infer = mut_ty.ty.kind { diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs index 37f9197549d18..60ab5d60b0b89 100644 --- a/clippy_lints/src/mut_mut.rs +++ b/clippy_lints/src/mut_mut.rs @@ -57,15 +57,15 @@ 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::ExprKind::AddrOf(hir::MutMutable, ref e) = expr.kind { - if let hir::ExprKind::AddrOf(hir::MutMutable, _) = e.kind { + } else if let hir::ExprKind::AddrOf(hir::Mutability::Mutable, ref e) = expr.kind { + if let hir::ExprKind::AddrOf(hir::Mutability::Mutable, _) = e.kind { span_lint( self.cx, MUT_MUT, expr.span, "generally you want to avoid `&mut &mut _` if possible", ); - } else if let ty::Ref(_, _, hir::MutMutable) = self.cx.tables.expr_ty(e).kind { + } else if let ty::Ref(_, _, hir::Mutability::Mutable) = self.cx.tables.expr_ty(e).kind { span_lint( self.cx, MUT_MUT, @@ -81,14 +81,15 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for MutVisitor<'a, 'tcx> { _, hir::MutTy { ty: ref pty, - mutbl: hir::MutMutable, + mutbl: hir::Mutability::Mutable, }, ) = ty.kind { if let hir::TyKind::Rptr( _, hir::MutTy { - mutbl: hir::MutMutable, .. + mutbl: hir::Mutability::Mutable, + .. }, ) = pty.kind { diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs index 798699eeea665..8caa486ffdc56 100644 --- a/clippy_lints/src/mut_reference.rs +++ b/clippy_lints/src/mut_reference.rs @@ -55,11 +55,12 @@ fn check_arguments<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arguments: &[Expr], typ let parameters = type_definition.fn_sig(cx.tcx).skip_binder().inputs(); for (argument, parameter) in arguments.iter().zip(parameters.iter()) { match parameter.kind { - ty::Ref(_, _, MutImmutable) + ty::Ref(_, _, Mutability::Immutable) | ty::RawPtr(ty::TypeAndMut { - mutbl: MutImmutable, .. + mutbl: Mutability::Immutable, + .. }) => { - if let ExprKind::AddrOf(MutMutable, _) = argument.kind { + if let ExprKind::AddrOf(Mutability::Mutable, _) = argument.kind { span_lint( cx, UNNECESSARY_MUT_PASSED, diff --git a/clippy_lints/src/mutable_debug_assertion.rs b/clippy_lints/src/mutable_debug_assertion.rs index 1184db0587b9d..6d955331add27 100644 --- a/clippy_lints/src/mutable_debug_assertion.rs +++ b/clippy_lints/src/mutable_debug_assertion.rs @@ -128,7 +128,7 @@ impl<'a, 'tcx> MutArgVisitor<'a, 'tcx> { impl<'a, 'tcx> Visitor<'tcx> for MutArgVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &'tcx Expr) { match expr.kind { - ExprKind::AddrOf(Mutability::MutMutable, _) => { + ExprKind::AddrOf(Mutability::Mutable, _) => { self.found = true; return; }, @@ -136,7 +136,7 @@ impl<'a, 'tcx> Visitor<'tcx> for MutArgVisitor<'a, 'tcx> { if let Some(adj) = self.cx.tables.adjustments().get(expr.hir_id) { if adj .iter() - .any(|a| matches!(a.target.kind, ty::Ref(_, _, Mutability::MutMutable))) + .any(|a| matches!(a.target.kind, ty::Ref(_, _, Mutability::Mutable))) { self.found = true; return; diff --git a/clippy_lints/src/needless_borrow.rs b/clippy_lints/src/needless_borrow.rs index 8093a06ab6fec..c2b1b896cf4db 100644 --- a/clippy_lints/src/needless_borrow.rs +++ b/clippy_lints/src/needless_borrow.rs @@ -4,7 +4,7 @@ use crate::utils::{snippet_opt, span_lint_and_then}; use if_chain::if_chain; -use rustc::hir::{BindingAnnotation, Expr, ExprKind, HirId, Item, MutImmutable, Pat, PatKind}; +use rustc::hir::{BindingAnnotation, Expr, ExprKind, HirId, Item, Mutability, Pat, PatKind}; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; use rustc::ty; use rustc::ty::adjustment::{Adjust, Adjustment}; @@ -41,7 +41,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrow { if e.span.from_expansion() || self.derived_item.is_some() { return; } - if let ExprKind::AddrOf(MutImmutable, ref inner) = e.kind { + if let ExprKind::AddrOf(Mutability::Immutable, ref inner) = e.kind { if let ty::Ref(..) = cx.tables.expr_ty(inner).kind { for adj3 in cx.tables.expr_adjustments(e).windows(3) { if let [Adjustment { @@ -82,10 +82,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrow { if_chain! { if let PatKind::Binding(BindingAnnotation::Ref, .., name, _) = pat.kind; if let ty::Ref(_, tam, mutbl) = cx.tables.pat_ty(pat).kind; - if mutbl == MutImmutable; + if mutbl == Mutability::Immutable; if let ty::Ref(_, _, mutbl) = tam.kind; // only lint immutable refs, because borrowed `&mut T` cannot be moved out - if mutbl == MutImmutable; + if mutbl == Mutability::Immutable; then { span_lint_and_then( cx, diff --git a/clippy_lints/src/needless_borrowed_ref.rs b/clippy_lints/src/needless_borrowed_ref.rs index 2c4c5461ae1f5..aab1940683c52 100644 --- a/clippy_lints/src/needless_borrowed_ref.rs +++ b/clippy_lints/src/needless_borrowed_ref.rs @@ -4,7 +4,7 @@ use crate::utils::{snippet_with_applicability, span_lint_and_then}; use if_chain::if_chain; -use rustc::hir::{BindingAnnotation, MutImmutable, Node, Pat, PatKind}; +use rustc::hir::{BindingAnnotation, Mutability, Node, Pat, PatKind}; use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass}; use rustc::{declare_lint_pass, declare_tool_lint}; use rustc_errors::Applicability; @@ -61,7 +61,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessBorrowedRef { if_chain! { // Only lint immutable refs, because `&mut ref T` may be useful. - if let PatKind::Ref(ref sub_pat, MutImmutable) = pat.kind; + if let PatKind::Ref(ref sub_pat, Mutability::Immutable) = pat.kind; // Check sub_pat got a `ref` keyword (excluding `ref mut`). if let PatKind::Binding(BindingAnnotation::Ref, .., spanned_name, _) = sub_pat.kind; diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs index 55662a1ad8319..7c9e8d2946bfb 100644 --- a/clippy_lints/src/ptr.rs +++ b/clippy_lints/src/ptr.rs @@ -150,7 +150,7 @@ fn check_fn(cx: &LateContext<'_, '_>, decl: &FnDecl, fn_id: HirId, opt_body_id: let fn_ty = sig.skip_binder(); for (idx, (arg, ty)) in decl.inputs.iter().zip(fn_ty.inputs()).enumerate() { - if let ty::Ref(_, ty, MutImmutable) = ty.kind { + if let ty::Ref(_, ty, Mutability::Immutable) = ty.kind { if is_type_diagnostic_item(cx, ty, Symbol::intern("vec_type")) { let mut ty_snippet = None; if_chain! { @@ -254,7 +254,7 @@ fn check_fn(cx: &LateContext<'_, '_>, decl: &FnDecl, fn_id: HirId, opt_body_id: } if let FunctionRetTy::Return(ref ty) = decl.output { - if let Some((out, MutMutable, _)) = get_rptr_lm(ty) { + if let Some((out, Mutability::Mutable, _)) = get_rptr_lm(ty) { let mut immutables = vec![]; for (_, ref mutbl, ref argspan) in decl .inputs @@ -262,7 +262,7 @@ fn check_fn(cx: &LateContext<'_, '_>, decl: &FnDecl, fn_id: HirId, opt_body_id: .filter_map(|ty| get_rptr_lm(ty)) .filter(|&(lt, _, _)| lt.name == out.name) { - if *mutbl == MutMutable { + if *mutbl == Mutability::Mutable { return; } immutables.push(*argspan); diff --git a/clippy_lints/src/transmute.rs b/clippy_lints/src/transmute.rs index 788d02ecb0aa7..f12fd6bb0d681 100644 --- a/clippy_lints/src/transmute.rs +++ b/clippy_lints/src/transmute.rs @@ -361,7 +361,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute { ), |db| { let arg = sugg::Sugg::hir(cx, &args[0], ".."); - let (deref, cast) = if mutbl == Mutability::MutMutable { + let (deref, cast) = if mutbl == Mutability::Mutable { ("&mut *", "*mut") } else { ("&*", "*const") @@ -409,7 +409,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute { if let ty::Uint(ast::UintTy::U8) = slice_ty.kind; if from_mutbl == to_mutbl; then { - let postfix = if from_mutbl == Mutability::MutMutable { + let postfix = if from_mutbl == Mutability::Mutable { "_mut" } else { "" @@ -449,7 +449,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute { let sugg_paren = arg .as_ty(cx.tcx.mk_ptr(ty_from_and_mut)) .as_ty(cx.tcx.mk_ptr(ty_to_and_mut)); - let sugg = if to_mutbl == Mutability::MutMutable { + let sugg = if to_mutbl == Mutability::Mutable { sugg_paren.mut_addr_deref() } else { sugg_paren.addr_deref() diff --git a/clippy_lints/src/trivially_copy_pass_by_ref.rs b/clippy_lints/src/trivially_copy_pass_by_ref.rs index 649b50e90def5..616568f36eebe 100644 --- a/clippy_lints/src/trivially_copy_pass_by_ref.rs +++ b/clippy_lints/src/trivially_copy_pass_by_ref.rs @@ -97,7 +97,7 @@ impl<'a, 'tcx> TriviallyCopyPassByRef { } if_chain! { - if let ty::Ref(input_lt, ty, Mutability::MutImmutable) = ty.kind; + if let ty::Ref(input_lt, ty, Mutability::Immutable) = ty.kind; if !output_lts.contains(&input_lt); if is_copy(cx, ty); if let Some(size) = cx.layout_of(ty).ok().map(|l| l.size.bytes()); diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index c303445f7d174..6a105a87e6232 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -393,7 +393,7 @@ fn check_ty_rptr(cx: &LateContext<'_, '_>, hir_ty: &hir::Ty, is_local: bool, lt: } else { format!("{} ", lt.name.ident().as_str()) }; - let mutopt = if mut_ty.mutbl == Mutability::MutMutable { + let mutopt = if mut_ty.mutbl == Mutability::Mutable { "mut " } else { "" @@ -2377,9 +2377,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for RefToMut { if_chain! { if let ExprKind::Unary(UnOp::UnDeref, e) = &expr.kind; if let ExprKind::Cast(e, t) = &e.kind; - if let TyKind::Ptr(MutTy { mutbl: Mutability::MutMutable, .. }) = t.kind; + if let TyKind::Ptr(MutTy { mutbl: Mutability::Mutable, .. }) = t.kind; if let ExprKind::Cast(e, t) = &e.kind; - if let TyKind::Ptr(MutTy { mutbl: Mutability::MutImmutable, .. }) = t.kind; + if let TyKind::Ptr(MutTy { mutbl: Mutability::Immutable, .. }) = t.kind; if let ty::Ref(..) = cx.tables.node_type(e.hir_id).kind; then { span_lint( diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs index f3fc0487b2654..71cf6c03e5ca4 100644 --- a/clippy_lints/src/utils/author.rs +++ b/clippy_lints/src/utils/author.rs @@ -427,7 +427,7 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor { }, ExprKind::AddrOf(mutability, ref inner) => { let inner_pat = self.next("inner"); - println!("AddrOf({:?}, ref {}) = {};", mutability, inner_pat, current); + println!("AddrOf(Mutability::{:?}, ref {}) = {};", mutability, inner_pat, current); self.current = inner_pat; self.visit_expr(inner); }, diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs index 5602e76322d7a..c17f301d8705f 100644 --- a/clippy_lints/src/utils/hir_utils.rs +++ b/clippy_lints/src/utils/hir_utils.rs @@ -447,8 +447,8 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { }, ExprKind::Closure(cap, _, eid, _, _) => { match cap { - CaptureClause::CaptureByValue => 0, - CaptureClause::CaptureByRef => 1, + CaptureBy::Value => 0, + CaptureBy::Ref => 1, } .hash(&mut self.s); // closures inherit TypeckTables diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs index 1d1a3da6bc417..5bf105582216b 100644 --- a/clippy_lints/src/utils/internal_lints.rs +++ b/clippy_lints/src/utils/internal_lints.rs @@ -145,7 +145,7 @@ impl_lint_pass!(LintWithoutLintPass => [LINT_WITHOUT_LINT_PASS]); impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LintWithoutLintPass { fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) { - if let hir::ItemKind::Static(ref ty, MutImmutable, _) = item.kind { + if let hir::ItemKind::Static(ref ty, Mutability::Immutable, _) = item.kind { if is_lint_ref_type(cx, ty) { self.declared_lints.insert(item.ident.name, item.span); } @@ -198,7 +198,7 @@ fn is_lint_ref_type<'tcx>(cx: &LateContext<'_, 'tcx>, ty: &Ty) -> bool { _, MutTy { ty: ref inner, - mutbl: MutImmutable, + mutbl: Mutability::Immutable, }, ) = ty.kind { diff --git a/tests/ui/author/for_loop.stdout b/tests/ui/author/for_loop.stdout index 0ad5834cd90e7..e61d3bb8ce154 100644 --- a/tests/ui/author/for_loop.stdout +++ b/tests/ui/author/for_loop.stdout @@ -22,7 +22,7 @@ if_chain! { if let ExprKind::Path(ref path2) = func1.kind; if match_qpath(path2, &["{{root}}", "std", "iter", "Iterator", "next"]); if args1.len() == 1; - if let ExprKind::AddrOf(MutMutable, ref inner) = args1[0].kind; + if let ExprKind::AddrOf(Mutability::Mutable, ref inner) = args1[0].kind; if let ExprKind::Path(ref path3) = inner.kind; if match_qpath(path3, &["iter"]); if arms1.len() == 2;