Rustup to rust-lang/rust#66671

clippy_lints/src/bytecount.rs

@@ -101,7 +101,7 @@ fn check_arg(name: Name, arg: Name, needle: &Expr) -> bool {
 
 fn get_path_name(expr: &Expr) -> Option<Name> {
     match expr.kind {
-        ExprKind::Box(ref e) | ExprKind::AddrOf(_, ref e) | ExprKind::Unary(UnOp::UnDeref, ref e) => get_path_name(e),
+        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))

clippy_lints/src/entry.rs

@@ -105,7 +105,7 @@ fn check_cond<'a, 'tcx, 'b>(
         if let ExprKind::MethodCall(ref path, _, ref params) = check.kind;
         if params.len() >= 2;
         if path.ident.name == sym!(contains_key);
-        if let ExprKind::AddrOf(_, ref key) = params[1].kind;
+        if let ExprKind::AddrOf(_, _, ref key) = params[1].kind;
         then {
             let map = &params[0];
             let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(map));

clippy_lints/src/eq_op.rs

@@ -86,7 +86,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
                     // do not suggest to dereference literals
                     (&ExprKind::Lit(..), _) | (_, &ExprKind::Lit(..)) => {},
                     // &foo == &bar
-                    (&ExprKind::AddrOf(_, ref l), &ExprKind::AddrOf(_, 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);
@@ -143,7 +143,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
                         }
                     },
                     // &foo == bar
-                    (&ExprKind::AddrOf(_, ref l), _) => {
+                    (&ExprKind::AddrOf(_, _, ref l), _) => {
                         let lty = cx.tables.expr_ty(l);
                         let lcpy = is_copy(cx, lty);
                         if (requires_ref || lcpy)
@@ -161,7 +161,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
                         }
                     },
                     // foo == &bar
-                    (_, &ExprKind::AddrOf(_, ref r)) => {
+                    (_, &ExprKind::AddrOf(_, _, ref r)) => {
                         let rty = cx.tables.expr_ty(r);
                         let rcpy = is_copy(cx, rty);
                         if (requires_ref || rcpy)

clippy_lints/src/eval_order_dependence.rs

@@ -328,7 +328,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
             // ```
             //
             // TODO: fix this
-            ExprKind::AddrOf(_, _) => {
+            ExprKind::AddrOf(_, _, _) => {
                 return;
             }
             _ => {}

clippy_lints/src/explicit_write.rs

@@ -135,7 +135,7 @@ fn write_output_string(write_args: &HirVec<Expr>) -> Option<String> {
         if write_args.len() > 1;
         if let ExprKind::Call(_, ref output_args) = write_args[1].kind;
         if output_args.len() > 0;
-        if let ExprKind::AddrOf(_, ref output_string_expr) = output_args[0].kind;
+        if let ExprKind::AddrOf(_, _, ref output_string_expr) = output_args[0].kind;
         if let ExprKind::Array(ref string_exprs) = output_string_expr.kind;
         // we only want to provide an automatic suggestion for simple (non-format) strings
         if string_exprs.len() == 1;

clippy_lints/src/format.rs

@@ -73,7 +73,7 @@ fn span_useless_format<T: LintContext>(cx: &T, span: Span, help: &str, mut sugg:
 
 fn on_argumentv1_new<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, arms: &'tcx [Arm]) -> Option<String> {
     if_chain! {
-        if let ExprKind::AddrOf(_, ref format_args) = expr.kind;
+        if let ExprKind::AddrOf(_, _, ref format_args) = expr.kind;
         if let ExprKind::Array(ref elems) = arms[0].body.kind;
         if elems.len() == 1;
         if let Some(args) = match_function_call(cx, &elems[0], &paths::FMT_ARGUMENTV1_NEW);
@@ -115,13 +115,13 @@ fn on_new_v1<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) -> Option<S
         if let Some(args) = match_function_call(cx, expr, &paths::FMT_ARGUMENTS_NEW_V1);
         if args.len() == 2;
         // Argument 1 in `new_v1()`
-        if let ExprKind::AddrOf(_, ref arr) = args[0].kind;
+        if let ExprKind::AddrOf(_, _, ref arr) = args[0].kind;
         if let ExprKind::Array(ref pieces) = arr.kind;
         if pieces.len() == 1;
         if let ExprKind::Lit(ref lit) = pieces[0].kind;
         if let LitKind::Str(ref s, _) = lit.node;
         // Argument 2 in `new_v1()`
-        if let ExprKind::AddrOf(_, ref arg1) = args[1].kind;
+        if let ExprKind::AddrOf(_, _, ref arg1) = args[1].kind;
         if let ExprKind::Match(ref matchee, ref arms, MatchSource::Normal) = arg1.kind;
         if arms.len() == 1;
         if let ExprKind::Tup(ref tup) = matchee.kind;
@@ -143,13 +143,13 @@ fn on_new_v1_fmt<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) -> Opti
         if args.len() == 3;
         if check_unformatted(&args[2]);
         // Argument 1 in `new_v1_formatted()`
-        if let ExprKind::AddrOf(_, ref arr) = args[0].kind;
+        if let ExprKind::AddrOf(_, _, ref arr) = args[0].kind;
         if let ExprKind::Array(ref pieces) = arr.kind;
         if pieces.len() == 1;
         if let ExprKind::Lit(ref lit) = pieces[0].kind;
         if let LitKind::Str(..) = lit.node;
         // Argument 2 in `new_v1_formatted()`
-        if let ExprKind::AddrOf(_, ref arg1) = args[1].kind;
+        if let ExprKind::AddrOf(_, _, ref arg1) = args[1].kind;
         if let ExprKind::Match(ref matchee, ref arms, MatchSource::Normal) = arg1.kind;
         if arms.len() == 1;
         if let ExprKind::Tup(ref tup) = matchee.kind;
@@ -173,7 +173,7 @@ fn on_new_v1_fmt<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) -> Opti
 /// ```
 fn check_unformatted(expr: &Expr) -> bool {
     if_chain! {
-        if let ExprKind::AddrOf(_, ref expr) = expr.kind;
+        if let ExprKind::AddrOf(_, _, ref expr) = expr.kind;
         if let ExprKind::Array(ref exprs) = expr.kind;
         if exprs.len() == 1;
         // struct `core::fmt::rt::v1::Argument`

clippy_lints/src/functions.rs

@@ -656,7 +656,7 @@ impl<'a, 'tcx> intravisit::Visitor<'tcx> for StaticMutVisitor<'a, 'tcx> {
                     tys.clear();
                 }
             },
-            Assign(ref target, _) | AssignOp(_, ref target, _) | AddrOf(hir::Mutability::Mutable, ref target) => {
+            Assign(ref target, _) | AssignOp(_, ref target, _) | AddrOf(_, hir::Mutability::Mutable, ref target) => {
                 self.mutates_static |= is_mutated_static(self.cx, target)
             },
             _ => {},

clippy_lints/src/infinite_iter.rs

@@ -163,7 +163,7 @@ fn is_infinite(cx: &LateContext<'_, '_>, expr: &Expr) -> Finiteness {
             Finite
         },
         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::Box(ref e) | ExprKind::AddrOf(_, _, ref e) => is_infinite(cx, e),
         ExprKind::Call(ref path, _) => {
             if let ExprKind::Path(ref qpath) = path.kind {
                 match_qpath(qpath, &paths::REPEAT).into()

clippy_lints/src/loops.rs

@@ -674,7 +674,7 @@ fn never_loop_expr(expr: &Expr, main_loop_id: HirId) -> NeverLoopResult {
         | ExprKind::Cast(ref e, _)
         | ExprKind::Type(ref e, _)
         | ExprKind::Field(ref e, _)
-        | ExprKind::AddrOf(_, ref e)
+        | ExprKind::AddrOf(_, _, ref e)
         | ExprKind::Struct(_, _, Some(ref e))
         | ExprKind::Repeat(ref e, _)
         | ExprKind::DropTemps(ref e) => never_loop_expr(e, main_loop_id),
@@ -1504,7 +1504,7 @@ fn make_iterator_snippet(cx: &LateContext<'_, '_>, arg: &Expr, applic_ref: &mut
         // (&x).into_iter() ==> x.iter()
         // (&mut x).into_iter() ==> x.iter_mut()
         match &arg.kind {
-            ExprKind::AddrOf(mutability, arg_inner) if has_iter_method(cx, cx.tables.expr_ty(&arg_inner)).is_some() => {
+            ExprKind::AddrOf(_, mutability, arg_inner) if has_iter_method(cx, cx.tables.expr_ty(&arg_inner)).is_some() => {
                 let meth_name = match mutability {
                     Mutability::Mutable => "iter_mut",
                     Mutability::Immutable => "iter",
@@ -1549,7 +1549,7 @@ fn check_for_loop_over_map_kv<'a, 'tcx>(
                 Mutability::Mutable => "_mut",
             };
             let arg = match arg.kind {
-                ExprKind::AddrOf(_, ref expr) => &**expr,
+                ExprKind::AddrOf(_, _, ref expr) => &**expr,
                 _ => arg,
             };
 
@@ -1873,7 +1873,7 @@ impl<'a, 'tcx> Visitor<'tcx> for VarVisitor<'a, 'tcx> {
                 self.prefer_mutable = false;
                 self.visit_expr(rhs);
             },
-            ExprKind::AddrOf(mutbl, ref expr) => {
+            ExprKind::AddrOf(_, mutbl, ref expr) => {
                 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 == Mutability::Mutable => *state = VarState::DontWarn,
+                    ExprKind::AddrOf(_, mutability, _) if mutability == Mutability::Mutable => *state = VarState::DontWarn,
                     _ => (),
                 }
             }
@@ -2172,7 +2172,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
                             VarState::DontWarn
                         }
                     },
-                    ExprKind::AddrOf(mutability, _) if mutability == Mutability::Mutable => {
+                    ExprKind::AddrOf(_, mutability, _) if mutability == Mutability::Mutable => {
                         self.state = VarState::DontWarn
                     },
                     _ => (),

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::Immutable, 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()));
             (

clippy_lints/src/mem_discriminant.rs

@@ -57,7 +57,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MemDiscriminant {
                             let mut derefs_needed = ptr_depth;
                             let mut cur_expr = param;
                             while derefs_needed > 0  {
-                                if let ExprKind::AddrOf(_, ref inner_expr) = cur_expr.kind {
+                                if let ExprKind::AddrOf(_, _, ref inner_expr) = cur_expr.kind {
                                     derefs_needed -= 1;
                                     cur_expr = inner_expr;
                                 } else {

clippy_lints/src/mem_replace.rs

@@ -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(Mutability::Mutable, ref replaced) => {
+                            ExprKind::AddrOf(_, Mutability::Mutable, ref replaced) => {
                                 if let ExprKind::Path(QPath::Resolved(None, ref replaced_path)) = replaced.kind {
                                     replaced_path
                                 } else {

clippy_lints/src/methods/mod.rs

@@ -1519,7 +1519,7 @@ fn lint_expect_fun_call(cx: &LateContext<'_, '_>, expr: &hir::Expr, method_span:
         let mut arg_root = arg;
         loop {
             arg_root = match &arg_root.kind {
-                hir::ExprKind::AddrOf(_, expr) => expr,
+                hir::ExprKind::AddrOf(_, _, expr) => expr,
                 hir::ExprKind::MethodCall(method_name, _, call_args) => {
                     if call_args.len() == 1
                         && (method_name.ident.name == sym!(as_str) || method_name.ident.name == sym!(as_ref))
@@ -1561,7 +1561,7 @@ fn lint_expect_fun_call(cx: &LateContext<'_, '_>, expr: &hir::Expr, method_span:
         applicability: &mut Applicability,
     ) -> Vec<String> {
         if_chain! {
-            if let hir::ExprKind::AddrOf(_, ref format_arg) = a.kind;
+            if let hir::ExprKind::AddrOf(_, _, ref format_arg) = a.kind;
             if let hir::ExprKind::Match(ref format_arg_expr, _, _) = format_arg.kind;
             if let hir::ExprKind::Tup(ref format_arg_expr_tup) = format_arg_expr.kind;
 
@@ -1578,7 +1578,7 @@ fn lint_expect_fun_call(cx: &LateContext<'_, '_>, expr: &hir::Expr, method_span:
 
     fn is_call(node: &hir::ExprKind) -> bool {
         match node {
-            hir::ExprKind::AddrOf(_, expr) => {
+            hir::ExprKind::AddrOf(_, _, expr) => {
                 is_call(&expr.kind)
             },
             hir::ExprKind::Call(..)

clippy_lints/src/mut_mut.rs

@@ -57,8 +57,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::ExprKind::AddrOf(hir::Mutability::Mutable, ref e) = expr.kind {
-            if let hir::ExprKind::AddrOf(hir::Mutability::Mutable, _) = 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,

clippy_lints/src/mut_reference.rs

@@ -60,7 +60,7 @@ fn check_arguments<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arguments: &[Expr], typ
                         mutbl: Mutability::Immutable,
                         ..
                     }) => {
-                        if let ExprKind::AddrOf(Mutability::Mutable, _) = argument.kind {
+                        if let ExprKind::AddrOf(_, Mutability::Mutable, _) = argument.kind {
                             span_lint(
                                 cx,
                                 UNNECESSARY_MUT_PASSED,

clippy_lints/src/mutable_debug_assertion.rs

@@ -77,14 +77,14 @@ fn extract_call<'a, 'tcx>(cx: &'a LateContext<'a, 'tcx>, e: &'tcx Expr) -> Optio
                         if let ExprKind::Tup(ref conditions) = headerexpr.kind;
                         if conditions.len() == 2;
                         then {
-                            if let ExprKind::AddrOf(_, ref lhs) = conditions[0].kind {
+                            if let ExprKind::AddrOf(_, _, ref lhs) = conditions[0].kind {
                                 let mut visitor = MutArgVisitor::new(cx);
                                 visitor.visit_expr(lhs);
                                 if let Some(span) = visitor.expr_span() {
                                     return Some(span);
                                 }
                             }
-                            if let ExprKind::AddrOf(_, ref rhs) = conditions[1].kind {
+                            if let ExprKind::AddrOf(_, _, ref rhs) = conditions[1].kind {
                                 let mut visitor = MutArgVisitor::new(cx);
                                 visitor.visit_expr(rhs);
                                 if let Some(span) = visitor.expr_span() {
@@ -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::Mutable, _) => {
+            ExprKind::AddrOf(_, Mutability::Mutable, _) => {
                 self.found = true;
                 return;
             },

clippy_lints/src/needless_borrow.rs

@@ -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(Mutability::Immutable, 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 {

clippy_lints/src/no_effect.rs

@@ -58,7 +58,7 @@ fn has_no_effect(cx: &LateContext<'_, '_>, expr: &Expr) -> bool {
         | ExprKind::Type(ref inner, _)
         | ExprKind::Unary(_, ref inner)
         | ExprKind::Field(ref inner, _)
-        | ExprKind::AddrOf(_, ref inner)
+        | ExprKind::AddrOf(_, _, ref inner)
         | ExprKind::Box(ref inner) => has_no_effect(cx, inner),
         ExprKind::Struct(_, ref fields, ref base) => {
             !has_drop(cx, cx.tables.expr_ty(expr))
@@ -134,7 +134,7 @@ fn reduce_expression<'a>(cx: &LateContext<'_, '_>, expr: &'a Expr) -> Option<Vec
         | ExprKind::Type(ref inner, _)
         | ExprKind::Unary(_, ref inner)
         | ExprKind::Field(ref inner, _)
-        | ExprKind::AddrOf(_, 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, cx.tables.expr_ty(expr)) {

clippy_lints/src/reference.rs

@@ -37,7 +37,7 @@ impl EarlyLintPass for DerefAddrOf {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
         if_chain! {
             if let ExprKind::Unary(UnOp::Deref, ref deref_target) = e.kind;
-            if let ExprKind::AddrOf(_, ref addrof_target) = without_parens(deref_target).kind;
+            if let ExprKind::AddrOf(_, _, ref addrof_target) = without_parens(deref_target).kind;
             if !in_macro(addrof_target.span);
             then {
                 let mut applicability = Applicability::MachineApplicable;
@@ -80,7 +80,7 @@ impl EarlyLintPass for RefInDeref {
         if_chain! {
             if let ExprKind::Field(ref object, _) = e.kind;
             if let ExprKind::Paren(ref parened) = object.kind;
-            if let ExprKind::AddrOf(_, ref inner) = parened.kind;
+            if let ExprKind::AddrOf(_, _, ref inner) = parened.kind;
             then {
                 let mut applicability = Applicability::MachineApplicable;
                 span_lint_and_sugg(

clippy_lints/src/regex.rs

@@ -186,7 +186,7 @@ fn is_trivial_regex(s: &regex_syntax::hir::Hir) -> Option<&'static str> {
 
 fn check_set<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, utf8: bool) {
     if_chain! {
-        if let ExprKind::AddrOf(_, ref expr) = expr.kind;
+        if let ExprKind::AddrOf(_, _, ref expr) = expr.kind;
         if let ExprKind::Array(ref exprs) = expr.kind;
         then {
             for expr in exprs {

clippy_lints/src/shadow.rs

@@ -313,7 +313,7 @@ fn check_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindings:
         return;
     }
     match expr.kind {
-        ExprKind::Unary(_, ref e) | ExprKind::Field(ref e, _) | ExprKind::AddrOf(_, ref e) | ExprKind::Box(ref e) => {
+        ExprKind::Unary(_, ref e) | ExprKind::Field(ref e, _) | ExprKind::AddrOf(_, _, ref e) | ExprKind::Box(ref e) => {
             check_expr(cx, e, bindings)
         },
         ExprKind::Block(ref block, _) | ExprKind::Loop(ref block, _, _) => check_block(cx, block, bindings),
@@ -365,7 +365,7 @@ fn check_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: &'tcx Ty, bindings: &mut V
 
 fn is_self_shadow(name: Name, expr: &Expr) -> bool {
     match expr.kind {
-        ExprKind::Box(ref inner) | ExprKind::AddrOf(_, ref inner) => is_self_shadow(name, inner),
+        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))
         },