diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions.rs
index 8c3306f6d12..f958a40aac6 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 805e609cea6..fcdef51c1d4 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 569b189180c..05c7e6d6220 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 23bc4412717..115a47f3061 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 c71324ea472..9fcffc77005 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 e7197b671c9..24c167c42a1 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 37f9197549d..60ab5d60b0b 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 798699eeea6..8caa486ffdc 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 1184db0587b..6d955331add 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 8093a06ab6f..c2b1b896cf4 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 2c4c5461ae1..aab1940683c 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 55662a1ad83..7c9e8d2946b 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 788d02ecb0a..f12fd6bb0d6 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 649b50e90de..616568f36ee 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 c303445f7d1..6a105a87e62 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 f3fc0487b26..71cf6c03e5c 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 5602e76322d..c17f301d870 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 1d1a3da6bc4..5bf10558221 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 0ad5834cd90..e61d3bb8ce1 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;