Fixes compilation for rust nightly 2018-05-05

Michael Wright · Michael Wright · commit 1477f348582e · 2018-05-06T14:05:41.000+02:00
Closes #2725
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
@@ -3,7 +3,7 @@ use rustc::hir::intravisit as visit;
 use rustc::hir::map::Node::{NodeExpr, NodeStmt};
 use rustc::lint::*;
 use rustc::middle::expr_use_visitor::*;
-use rustc::middle::mem_categorization::{cmt, Categorization};
+use rustc::middle::mem_categorization::{cmt_, Categorization};
 use rustc::ty::{self, Ty};
 use rustc::ty::layout::LayoutOf;
 use rustc::util::nodemap::NodeSet;
@@ -86,16 +86,16 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
 }
 
 impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
-    fn consume(&mut self, _: NodeId, _: Span, cmt: cmt<'tcx>, mode: ConsumeMode) {
+    fn consume(&mut self, _: NodeId, _: Span, cmt: &cmt_<'tcx>, mode: ConsumeMode) {
         if let Categorization::Local(lid) = cmt.cat {
             if let Move(DirectRefMove) = mode {
                 // moved out or in. clearly can't be localized
                 self.set.remove(&lid);
             }
         }
     }
-    fn matched_pat(&mut self, _: &Pat, _: cmt<'tcx>, _: MatchMode) {}
-    fn consume_pat(&mut self, consume_pat: &Pat, cmt: cmt<'tcx>, _: ConsumeMode) {
+    fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {}
+    fn consume_pat(&mut self, consume_pat: &Pat, cmt: &cmt_<'tcx>, _: ConsumeMode) {
         let map = &self.cx.tcx.hir;
         if map.is_argument(consume_pat.id) {
             // Skip closure arguments
@@ -135,7 +135,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
             }
         }
     }
-    fn borrow(&mut self, _: NodeId, _: Span, cmt: cmt<'tcx>, _: ty::Region, _: ty::BorrowKind, loan_cause: LoanCause) {
+    fn borrow(&mut self, _: NodeId, _: Span, cmt: &cmt_<'tcx>, _: ty::Region, _: ty::BorrowKind, loan_cause: LoanCause) {
         if let Categorization::Local(lid) = cmt.cat {
             match loan_cause {
                 // x.foo()
@@ -157,7 +157,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
         }
     }
     fn decl_without_init(&mut self, _: NodeId, _: Span) {}
-    fn mutate(&mut self, _: NodeId, _: Span, _: cmt<'tcx>, _: MutateMode) {}
+    fn mutate(&mut self, _: NodeId, _: Span, _: &cmt_<'tcx>, _: MutateMode) {}
 }
 
 impl<'a, 'tcx> EscapeDelegate<'a, 'tcx> {
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
@@ -10,7 +10,7 @@ use rustc::middle::region;
 // use rustc::middle::region::CodeExtent;
 use rustc::middle::expr_use_visitor::*;
 use rustc::middle::mem_categorization::Categorization;
-use rustc::middle::mem_categorization::cmt;
+use rustc::middle::mem_categorization::cmt_;
 use rustc::ty::{self, Ty};
 use rustc::ty::subst::Subst;
 use std::collections::{HashMap, HashSet};
@@ -1412,13 +1412,13 @@ struct MutatePairDelegate {
 }
 
 impl<'tcx> Delegate<'tcx> for MutatePairDelegate {
-    fn consume(&mut self, _: NodeId, _: Span, _: cmt<'tcx>, _: ConsumeMode) {}
+    fn consume(&mut self, _: NodeId, _: Span, _: &cmt_<'tcx>, _: ConsumeMode) {}
 
-    fn matched_pat(&mut self, _: &Pat, _: cmt<'tcx>, _: MatchMode) {}
+    fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {}
 
-    fn consume_pat(&mut self, _: &Pat, _: cmt<'tcx>, _: ConsumeMode) {}
+    fn consume_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: ConsumeMode) {}
 
-    fn borrow(&mut self, _: NodeId, sp: Span, cmt: cmt<'tcx>, _: ty::Region, bk: ty::BorrowKind, _: LoanCause) {
+    fn borrow(&mut self, _: NodeId, sp: Span, cmt: &cmt_<'tcx>, _: ty::Region, bk: ty::BorrowKind, _: LoanCause) {
         if let ty::BorrowKind::MutBorrow = bk {
             if let Categorization::Local(id) = cmt.cat {
                 if Some(id) == self.node_id_low {
@@ -1431,7 +1431,7 @@ impl<'tcx> Delegate<'tcx> for MutatePairDelegate {
         }
     }
 
-    fn mutate(&mut self, _: NodeId, sp: Span, cmt: cmt<'tcx>, _: MutateMode) {
+    fn mutate(&mut self, _: NodeId, sp: Span, cmt: &cmt_<'tcx>, _: MutateMode) {
         if let Categorization::Local(id) = cmt.cat {
             if Some(id) == self.node_id_low {
                 self.span_low = Some(sp)
@@ -2255,19 +2255,19 @@ impl<'tcx> MutVarsDelegate {
 
 
 impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
-    fn consume(&mut self, _: NodeId, _: Span, _: cmt<'tcx>, _: ConsumeMode) {}
+    fn consume(&mut self, _: NodeId, _: Span, _: &cmt_<'tcx>, _: ConsumeMode) {}
 
-    fn matched_pat(&mut self, _: &Pat, _: cmt<'tcx>, _: MatchMode) {}
+    fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {}
 
-    fn consume_pat(&mut self, _: &Pat, _: cmt<'tcx>, _: ConsumeMode) {}
+    fn consume_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: ConsumeMode) {}
 
-    fn borrow(&mut self, _: NodeId, _: Span, cmt: cmt<'tcx>, _: ty::Region, bk: ty::BorrowKind, _: LoanCause) {
+    fn borrow(&mut self, _: NodeId, _: Span, cmt: &cmt_<'tcx>, _: ty::Region, bk: ty::BorrowKind, _: LoanCause) {
         if let ty::BorrowKind::MutBorrow = bk {
             self.update(&cmt.cat)
         }
     }
 
-    fn mutate(&mut self, _: NodeId, _: Span, cmt: cmt<'tcx>, _: MutateMode) {
+    fn mutate(&mut self, _: NodeId, _: Span, cmt: &cmt_<'tcx>, _: MutateMode) {
         self.update(&cmt.cat)
     }
 
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
@@ -308,15 +308,15 @@ impl<'a, 'tcx> MovedVariablesCtxt<'a, 'tcx> {
         }
     }
 
-    fn move_common(&mut self, _consume_id: NodeId, _span: Span, cmt: mc::cmt<'tcx>) {
+    fn move_common(&mut self, _consume_id: NodeId, _span: Span, cmt: &mc::cmt_<'tcx>) {
         let cmt = unwrap_downcast_or_interior(cmt);
 
         if let mc::Categorization::Local(vid) = cmt.cat {
             self.moved_vars.insert(vid);
         }
     }
 
-    fn non_moving_pat(&mut self, matched_pat: &Pat, cmt: mc::cmt<'tcx>) {
+    fn non_moving_pat(&mut self, matched_pat: &Pat, cmt: &mc::cmt_<'tcx>) {
         let cmt = unwrap_downcast_or_interior(cmt);
 
         if let mc::Categorization::Local(vid) = cmt.cat {
@@ -367,41 +367,41 @@ impl<'a, 'tcx> MovedVariablesCtxt<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> euv::Delegate<'tcx> for MovedVariablesCtxt<'a, 'tcx> {
-    fn consume(&mut self, consume_id: NodeId, consume_span: Span, cmt: mc::cmt<'tcx>, mode: euv::ConsumeMode) {
+    fn consume(&mut self, consume_id: NodeId, consume_span: Span, cmt: &mc::cmt_<'tcx>, mode: euv::ConsumeMode) {
         if let euv::ConsumeMode::Move(_) = mode {
             self.move_common(consume_id, consume_span, cmt);
         }
     }
 
-    fn matched_pat(&mut self, matched_pat: &Pat, cmt: mc::cmt<'tcx>, mode: euv::MatchMode) {
+    fn matched_pat(&mut self, matched_pat: &Pat, cmt: &mc::cmt_<'tcx>, mode: euv::MatchMode) {
         if let euv::MatchMode::MovingMatch = mode {
             self.move_common(matched_pat.id, matched_pat.span, cmt);
         } else {
             self.non_moving_pat(matched_pat, cmt);
         }
     }
 
-    fn consume_pat(&mut self, consume_pat: &Pat, cmt: mc::cmt<'tcx>, mode: euv::ConsumeMode) {
+    fn consume_pat(&mut self, consume_pat: &Pat, cmt: &mc::cmt_<'tcx>, mode: euv::ConsumeMode) {
         if let euv::ConsumeMode::Move(_) = mode {
             self.move_common(consume_pat.id, consume_pat.span, cmt);
         }
     }
 
-    fn borrow(&mut self, _: NodeId, _: Span, _: mc::cmt<'tcx>, _: ty::Region, _: ty::BorrowKind, _: euv::LoanCause) {}
+    fn borrow(&mut self, _: NodeId, _: Span, _: &mc::cmt_<'tcx>, _: ty::Region, _: ty::BorrowKind, _: euv::LoanCause) {}
 
-    fn mutate(&mut self, _: NodeId, _: Span, _: mc::cmt<'tcx>, _: euv::MutateMode) {}
+    fn mutate(&mut self, _: NodeId, _: Span, _: &mc::cmt_<'tcx>, _: euv::MutateMode) {}
 
     fn decl_without_init(&mut self, _: NodeId, _: Span) {}
 }
 
 
-fn unwrap_downcast_or_interior(mut cmt: mc::cmt) -> mc::cmt {
+fn unwrap_downcast_or_interior<'a, 'tcx>(mut cmt: &'a mc::cmt_<'tcx>) -> mc::cmt_<'tcx> {
     loop {
-        match cmt.cat.clone() {
-            mc::Categorization::Downcast(c, _) | mc::Categorization::Interior(c, _) => {
+        match cmt.cat {
+            mc::Categorization::Downcast(ref c, _) | mc::Categorization::Interior(ref c, _) => {
                 cmt = c;
             },
-            _ => return cmt,
+            _ => return (*cmt).clone(),
         }
-    }
+    };
 }

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ use rustc::hir::intravisit as visit;`
`3`	`3`	`use rustc::hir::map::Node::{NodeExpr, NodeStmt};`
`4`	`4`	`use rustc::lint::*;`
`5`	`5`	`use rustc::middle::expr_use_visitor::*;`
`6`		`-use rustc::middle::mem_categorization::{cmt, Categorization};`
	`6`	`+use rustc::middle::mem_categorization::{cmt_, Categorization};`
`7`	`7`	`use rustc::ty::{self, Ty};`
`8`	`8`	`use rustc::ty::layout::LayoutOf;`
`9`	`9`	`use rustc::util::nodemap::NodeSet;`
`@@ -86,16 +86,16 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {`
`89`		`- fn consume(&mut self, _: NodeId, _: Span, cmt: cmt<'tcx>, mode: ConsumeMode) {`
	`89`	`+ fn consume(&mut self, _: NodeId, _: Span, cmt: &cmt_<'tcx>, mode: ConsumeMode) {`
`90`	`90`	`if let Categorization::Local(lid) = cmt.cat {`
`91`	`91`	`if let Move(DirectRefMove) = mode {`
`92`	`92`	`// moved out or in. clearly can't be localized`
`93`	`93`	`self.set.remove(&lid);`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`}`
`97`		`- fn matched_pat(&mut self, _: &Pat, _: cmt<'tcx>, _: MatchMode) {}`
`98`		`- fn consume_pat(&mut self, consume_pat: &Pat, cmt: cmt<'tcx>, _: ConsumeMode) {`
	`97`	`+ fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {}`
	`98`	`+ fn consume_pat(&mut self, consume_pat: &Pat, cmt: &cmt_<'tcx>, _: ConsumeMode) {`
`99`	`99`	`let map = &self.cx.tcx.hir;`
`100`	`100`	`if map.is_argument(consume_pat.id) {`
`101`	`101`	`// Skip closure arguments`
`@@ -135,7 +135,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`	`}`
`138`		`- fn borrow(&mut self, _: NodeId, _: Span, cmt: cmt<'tcx>, _: ty::Region, _: ty::BorrowKind, loan_cause: LoanCause) {`
	`138`	`+ fn borrow(&mut self, _: NodeId, _: Span, cmt: &cmt_<'tcx>, _: ty::Region, _: ty::BorrowKind, loan_cause: LoanCause) {`
`139`	`139`	`if let Categorization::Local(lid) = cmt.cat {`
`140`	`140`	`match loan_cause {`
`141`	`141`	`// x.foo()`
`@@ -157,7 +157,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {`
`157`	`157`	`}`
`158`	`158`	`}`
`159`	`159`	`fn decl_without_init(&mut self, _: NodeId, _: Span) {}`
`160`		`- fn mutate(&mut self, _: NodeId, _: Span, _: cmt<'tcx>, _: MutateMode) {}`
	`160`	`+ fn mutate(&mut self, _: NodeId, _: Span, _: &cmt_<'tcx>, _: MutateMode) {}`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`impl<'a, 'tcx> EscapeDelegate<'a, 'tcx> {`
Original file line number	Diff line number	Diff line change
`@@ -308,15 +308,15 @@ impl<'a, 'tcx> MovedVariablesCtxt<'a, 'tcx> {`
`308`	`308`	`}`
`309`	`309`	`}`
`310`	`310`
`311`		`- fn move_common(&mut self, _consume_id: NodeId, _span: Span, cmt: mc::cmt<'tcx>) {`
	`311`	`+ fn move_common(&mut self, _consume_id: NodeId, _span: Span, cmt: &mc::cmt_<'tcx>) {`
`312`	`312`	`let cmt = unwrap_downcast_or_interior(cmt);`
`313`	`313`
`314`	`314`	`if let mc::Categorization::Local(vid) = cmt.cat {`
`315`	`315`	`self.moved_vars.insert(vid);`
`316`	`316`	`}`
`317`	`317`	`}`
`318`	`318`
`319`		`- fn non_moving_pat(&mut self, matched_pat: &Pat, cmt: mc::cmt<'tcx>) {`
	`319`	`+ fn non_moving_pat(&mut self, matched_pat: &Pat, cmt: &mc::cmt_<'tcx>) {`
`320`	`320`	`let cmt = unwrap_downcast_or_interior(cmt);`
`321`	`321`
`322`	`322`	`if let mc::Categorization::Local(vid) = cmt.cat {`
`@@ -367,41 +367,41 @@ impl<'a, 'tcx> MovedVariablesCtxt<'a, 'tcx> {`
`367`	`367`	`}`
`368`	`368`
`369`	`369`	`impl<'a, 'tcx> euv::Delegate<'tcx> for MovedVariablesCtxt<'a, 'tcx> {`
`370`		`- fn consume(&mut self, consume_id: NodeId, consume_span: Span, cmt: mc::cmt<'tcx>, mode: euv::ConsumeMode) {`
	`370`	`+ fn consume(&mut self, consume_id: NodeId, consume_span: Span, cmt: &mc::cmt_<'tcx>, mode: euv::ConsumeMode) {`
`371`	`371`	`if let euv::ConsumeMode::Move(_) = mode {`
`372`	`372`	`self.move_common(consume_id, consume_span, cmt);`
`373`	`373`	`}`
`374`	`374`	`}`
`375`	`375`
`376`		`- fn matched_pat(&mut self, matched_pat: &Pat, cmt: mc::cmt<'tcx>, mode: euv::MatchMode) {`
	`376`	`+ fn matched_pat(&mut self, matched_pat: &Pat, cmt: &mc::cmt_<'tcx>, mode: euv::MatchMode) {`
`377`	`377`	`if let euv::MatchMode::MovingMatch = mode {`
`378`	`378`	`self.move_common(matched_pat.id, matched_pat.span, cmt);`
`379`	`379`	`} else {`
`380`	`380`	`self.non_moving_pat(matched_pat, cmt);`
`381`	`381`	`}`
`382`	`382`	`}`
`383`	`383`
`384`		`- fn consume_pat(&mut self, consume_pat: &Pat, cmt: mc::cmt<'tcx>, mode: euv::ConsumeMode) {`
	`384`	`+ fn consume_pat(&mut self, consume_pat: &Pat, cmt: &mc::cmt_<'tcx>, mode: euv::ConsumeMode) {`
`385`	`385`	`if let euv::ConsumeMode::Move(_) = mode {`
`386`	`386`	`self.move_common(consume_pat.id, consume_pat.span, cmt);`
`387`	`387`	`}`
`388`	`388`	`}`
`389`	`389`
`390`		`- fn borrow(&mut self, _: NodeId, _: Span, _: mc::cmt<'tcx>, _: ty::Region, _: ty::BorrowKind, _: euv::LoanCause) {}`
	`390`	`+ fn borrow(&mut self, _: NodeId, _: Span, _: &mc::cmt_<'tcx>, _: ty::Region, _: ty::BorrowKind, _: euv::LoanCause) {}`
`391`	`391`
`392`		`- fn mutate(&mut self, _: NodeId, _: Span, _: mc::cmt<'tcx>, _: euv::MutateMode) {}`
	`392`	`+ fn mutate(&mut self, _: NodeId, _: Span, _: &mc::cmt_<'tcx>, _: euv::MutateMode) {}`
`393`	`393`
`394`	`394`	`fn decl_without_init(&mut self, _: NodeId, _: Span) {}`
`395`	`395`	`}`
`396`	`396`
`397`	`397`
`398`		`-fn unwrap_downcast_or_interior(mut cmt: mc::cmt) -> mc::cmt {`
	`398`	`+fn unwrap_downcast_or_interior<'a, 'tcx>(mut cmt: &'a mc::cmt_<'tcx>) -> mc::cmt_<'tcx> {`
`399`	`399`	`loop {`
`400`		`- match cmt.cat.clone() {`
`401`		`- mc::Categorization::Downcast(c, _) \| mc::Categorization::Interior(c, _) => {`
	`400`	`+ match cmt.cat {`
	`401`	`+ mc::Categorization::Downcast(ref c, _) \| mc::Categorization::Interior(ref c, _) => {`
`402`	`402`	`cmt = c;`
`403`	`403`	`},`
`404`		`- _ => return cmt,`
	`404`	`+ _ => return (*cmt).clone(),`
`405`	`405`	`}`
`406`		`- }`
	`406`	`+ };`
`407`	`407`	`}`