Rustup to rust-lang/rust#64874

flip1995 · flip1995 · commit f3cdee441b1d · 2019-10-04T14:24:47.000+02:00
Episode 1 - The simple cases
diff --git a/clippy_lints/src/escape.rs b/clippy_lints/src/escape.rs
@@ -85,7 +85,6 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxedLocal {
             cx.param_env,
             region_scope_tree,
             cx.tables,
-            None,
         )
         .consume_body(body);
 
@@ -114,15 +113,14 @@ fn is_argument(map: &hir::map::Map<'_>, id: HirId) -> bool {
 }
 
 impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
-    fn consume(&mut self, _: HirId, _: Span, cmt: &cmt_<'tcx>, mode: ConsumeMode) {
+    fn consume(&mut self, cmt: &cmt_<'tcx>, mode: ConsumeMode) {
         if let Categorization::Local(lid) = cmt.cat {
-            if let Move(DirectRefMove) | Move(CaptureMove) = mode {
+            if let ConsumeMode::Move = 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) {
         let map = &self.cx.tcx.hir();
         if is_argument(map, consume_pat.hir_id) {
@@ -137,7 +135,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
             }
             return;
         }
-        if let Categorization::Rvalue(..) = cmt.cat {
+        if let Categorization::Rvalue = cmt.cat {
             if let Some(Node::Stmt(st)) = map.find(map.get_parent_node(cmt.hir_id)) {
                 if let StmtKind::Local(ref loc) = st.kind {
                     if let Some(ref ex) = loc.init {
@@ -163,12 +161,10 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
             }
         }
     }
+
     fn borrow(
         &mut self,
-        _: HirId,
-        _: Span,
-        cmt: &cmt_<'tcx>,
-        _: ty::Region<'_>,
+        _: &cmt_<'tcx>,
         _: ty::BorrowKind,
         loan_cause: LoanCause,
     ) {
@@ -192,8 +188,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
             }
         }
     }
-    fn decl_without_init(&mut self, _: HirId, _: Span) {}
-    fn mutate(&mut self, _: HirId, _: Span, _: &cmt_<'tcx>, _: MutateMode) {}
+    fn mutate(&mut self, _: &cmt_<'tcx>) {}
 }
 
 impl<'a, 'tcx> EscapeDelegate<'a, 'tcx> {
diff --git a/clippy_lints/src/loops.rs b/clippy_lints/src/loops.rs
@@ -1547,37 +1547,31 @@ struct MutatePairDelegate {
 }
 
 impl<'tcx> Delegate<'tcx> for MutatePairDelegate {
-    fn consume(&mut self, _: HirId, _: Span, _: &cmt_<'tcx>, _: ConsumeMode) {}
+    fn consume(&mut self, _: &cmt_<'tcx>, _: ConsumeMode) {}
 
-    fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {}
-
-    fn consume_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: ConsumeMode) {}
-
-    fn borrow(&mut self, _: HirId, sp: Span, cmt: &cmt_<'tcx>, _: ty::Region<'_>, bk: ty::BorrowKind, _: LoanCause) {
+    fn borrow(&mut self, cmt: &cmt_<'tcx>, bk: ty::BorrowKind) {
         if let ty::BorrowKind::MutBorrow = bk {
             if let Categorization::Local(id) = cmt.cat {
                 if Some(id) == self.hir_id_low {
-                    self.span_low = Some(sp)
+                    self.span_low = Some(cmt.span)
                 }
                 if Some(id) == self.hir_id_high {
-                    self.span_high = Some(sp)
+                    self.span_high = Some(cmt.span)
                 }
             }
         }
     }
 
-    fn mutate(&mut self, _: HirId, sp: Span, cmt: &cmt_<'tcx>, _: MutateMode) {
+    fn mutate(&mut self, cmt: &cmt_<'tcx>) {
         if let Categorization::Local(id) = cmt.cat {
             if Some(id) == self.hir_id_low {
-                self.span_low = Some(sp)
+                self.span_low = Some(cmt.span)
             }
             if Some(id) == self.hir_id_high {
-                self.span_high = Some(sp)
+                self.span_high = Some(cmt.span)
             }
         }
     }
-
-    fn decl_without_init(&mut self, _: HirId, _: Span) {}
 }
 
 impl<'tcx> MutatePairDelegate {
@@ -1655,7 +1649,6 @@ fn check_for_mutation(
         cx.param_env,
         region_scope_tree,
         cx.tables,
-        None,
     )
     .walk_expr(body);
     delegate.mutation_span()
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
@@ -143,7 +143,6 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {
                 cx.param_env,
                 region_scope_tree,
                 cx.tables,
-                None,
             )
             .consume_body(body);
             ctx
@@ -400,9 +399,9 @@ impl<'a, 'tcx> MovedVariablesCtxt<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> euv::Delegate<'tcx> for MovedVariablesCtxt<'a, 'tcx> {
-    fn consume(&mut self, consume_id: HirId, 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 consume(&mut self, cmt: &mc::cmt_<'tcx>, mode: euv::ConsumeMode) {
+        if let euv::ConsumeMode::Move = mode {
+            self.move_common(cmt.hir_id, cmt.span, cmt);
         }
     }
 
@@ -422,18 +421,12 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for MovedVariablesCtxt<'a, 'tcx> {
 
     fn borrow(
         &mut self,
-        _: HirId,
-        _: Span,
         _: &mc::cmt_<'tcx>,
-        _: ty::Region<'_>,
         _: ty::BorrowKind,
-        _: euv::LoanCause,
     ) {
     }
 
-    fn mutate(&mut self, _: HirId, _: Span, _: &mc::cmt_<'tcx>, _: euv::MutateMode) {}
-
-    fn decl_without_init(&mut self, _: HirId, _: Span) {}
+    fn mutate(&mut self, _: &mc::cmt_<'tcx>) {}
 }
 
 fn unwrap_downcast_or_interior<'a, 'tcx>(mut cmt: &'a mc::cmt_<'tcx>) -> mc::cmt_<'tcx> {
diff --git a/clippy_lints/src/utils/usage.rs b/clippy_lints/src/utils/usage.rs
@@ -6,7 +6,6 @@ use rustc::middle::mem_categorization::cmt_;
 use rustc::middle::mem_categorization::Categorization;
 use rustc::ty;
 use rustc_data_structures::fx::FxHashSet;
-use syntax::source_map::Span;
 
 /// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
 pub fn mutated_variables<'a, 'tcx>(expr: &'tcx Expr, cx: &'a LateContext<'a, 'tcx>) -> Option<FxHashSet<HirId>> {
@@ -23,7 +22,6 @@ pub fn mutated_variables<'a, 'tcx>(expr: &'tcx Expr, cx: &'a LateContext<'a, 'tc
         cx.param_env,
         region_scope_tree,
         cx.tables,
-        None,
     )
     .walk_expr(expr);
 
@@ -66,21 +64,15 @@ impl<'tcx> MutVarsDelegate {
 }
 
 impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
-    fn consume(&mut self, _: HirId, _: Span, _: &cmt_<'tcx>, _: ConsumeMode) {}
+    fn consume(&mut self, _: &cmt_<'tcx>, _: ConsumeMode) {}
 
-    fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {}
-
-    fn consume_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: ConsumeMode) {}
-
-    fn borrow(&mut self, _: HirId, _: Span, cmt: &cmt_<'tcx>, _: ty::Region<'_>, bk: ty::BorrowKind, _: LoanCause) {
+    fn borrow(&mut self, cmt: &cmt_<'tcx>, bk: ty::BorrowKind) {
         if let ty::BorrowKind::MutBorrow = bk {
             self.update(&cmt.cat)
         }
     }
 
-    fn mutate(&mut self, _: HirId, _: Span, cmt: &cmt_<'tcx>, _: MutateMode) {
+    fn mutate(&mut self, cmt: &cmt_<'tcx>) {
         self.update(&cmt.cat)
     }
-
-    fn decl_without_init(&mut self, _: HirId, _: Span) {}
 }

Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,6 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxedLocal {`
`85`	`85`	`cx.param_env,`
`86`	`86`	`region_scope_tree,`
`87`	`87`	`cx.tables,`
`88`		`- None,`
`89`	`88`	`)`
`90`	`89`	`.consume_body(body);`
`91`	`90`
`@@ -114,15 +113,14 @@ fn is_argument(map: &hir::map::Map<'_>, id: HirId) -> bool {`
`114`	`113`	`}`
`115`	`114`
`116`	`115`	`impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {`
`117`		`- fn consume(&mut self, _: HirId, _: Span, cmt: &cmt_<'tcx>, mode: ConsumeMode) {`
	`116`	`+ fn consume(&mut self, cmt: &cmt_<'tcx>, mode: ConsumeMode) {`
`118`	`117`	`if let Categorization::Local(lid) = cmt.cat {`
`119`		`- if let Move(DirectRefMove) \| Move(CaptureMove) = mode {`
	`118`	`+ if let ConsumeMode::Move = mode {`
`120`	`119`	`// moved out or in. clearly can't be localized`
`121`	`120`	`self.set.remove(&lid);`
`122`	`121`	`}`
`123`	`122`	`}`
`124`	`123`	`}`
`125`		`- fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {}`
`126`	`124`	`fn consume_pat(&mut self, consume_pat: &Pat, cmt: &cmt_<'tcx>, _: ConsumeMode) {`
`127`	`125`	`let map = &self.cx.tcx.hir();`
`128`	`126`	`if is_argument(map, consume_pat.hir_id) {`
`@@ -137,7 +135,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {`
`137`	`135`	`}`
`138`	`136`	`return;`
`139`	`137`	`}`
`140`		`- if let Categorization::Rvalue(..) = cmt.cat {`
	`138`	`+ if let Categorization::Rvalue = cmt.cat {`
`141`	`139`	`if let Some(Node::Stmt(st)) = map.find(map.get_parent_node(cmt.hir_id)) {`
`142`	`140`	`if let StmtKind::Local(ref loc) = st.kind {`
`143`	`141`	`if let Some(ref ex) = loc.init {`
`@@ -163,12 +161,10 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {`
`163`	`161`	`}`
`164`	`162`	`}`
`165`	`163`	`}`
	`164`	`+`
`166`	`165`	`fn borrow(`
`167`	`166`	`&mut self,`
`168`		`- _: HirId,`
`169`		`- _: Span,`
`170`		`- cmt: &cmt_<'tcx>,`
`171`		`- _: ty::Region<'_>,`
	`167`	`+ _: &cmt_<'tcx>,`
`172`	`168`	`_: ty::BorrowKind,`
`173`	`169`	`loan_cause: LoanCause,`
`174`	`170`	`) {`
`@@ -192,8 +188,7 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {`
`192`	`188`	`}`
`193`	`189`	`}`
`194`	`190`	`}`
`195`		`- fn decl_without_init(&mut self, _: HirId, _: Span) {}`
`196`		`- fn mutate(&mut self, _: HirId, _: Span, _: &cmt_<'tcx>, _: MutateMode) {}`
	`191`	`+ fn mutate(&mut self, _: &cmt_<'tcx>) {}`
`197`	`192`	`}`
`198`	`193`
`199`	`194`	`impl<'a, 'tcx> EscapeDelegate<'a, 'tcx> {`
Original file line number	Diff line number	Diff line change
`@@ -1547,37 +1547,31 @@ struct MutatePairDelegate {`
`1547`	`1547`	`}`
`1548`	`1548`
`1549`	`1549`	`impl<'tcx> Delegate<'tcx> for MutatePairDelegate {`
`1550`		`- fn consume(&mut self, _: HirId, _: Span, _: &cmt_<'tcx>, _: ConsumeMode) {}`
	`1550`	`+ fn consume(&mut self, _: &cmt_<'tcx>, _: ConsumeMode) {}`
`1551`	`1551`
`1552`		`- fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {}`
`1553`		`-`
`1554`		`- fn consume_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: ConsumeMode) {}`
`1555`		`-`
`1556`		`- fn borrow(&mut self, _: HirId, sp: Span, cmt: &cmt_<'tcx>, _: ty::Region<'_>, bk: ty::BorrowKind, _: LoanCause) {`
	`1552`	`+ fn borrow(&mut self, cmt: &cmt_<'tcx>, bk: ty::BorrowKind) {`
`1557`	`1553`	`if let ty::BorrowKind::MutBorrow = bk {`
`1558`	`1554`	`if let Categorization::Local(id) = cmt.cat {`
`1559`	`1555`	`if Some(id) == self.hir_id_low {`
`1560`		`- self.span_low = Some(sp)`
	`1556`	`+ self.span_low = Some(cmt.span)`
`1561`	`1557`	`}`
`1562`	`1558`	`if Some(id) == self.hir_id_high {`
`1563`		`- self.span_high = Some(sp)`
	`1559`	`+ self.span_high = Some(cmt.span)`
`1564`	`1560`	`}`
`1565`	`1561`	`}`
`1566`	`1562`	`}`
`1567`	`1563`	`}`
`1568`	`1564`
`1569`		`- fn mutate(&mut self, _: HirId, sp: Span, cmt: &cmt_<'tcx>, _: MutateMode) {`
	`1565`	`+ fn mutate(&mut self, cmt: &cmt_<'tcx>) {`
`1570`	`1566`	`if let Categorization::Local(id) = cmt.cat {`
`1571`	`1567`	`if Some(id) == self.hir_id_low {`
`1572`		`- self.span_low = Some(sp)`
	`1568`	`+ self.span_low = Some(cmt.span)`
`1573`	`1569`	`}`
`1574`	`1570`	`if Some(id) == self.hir_id_high {`
`1575`		`- self.span_high = Some(sp)`
	`1571`	`+ self.span_high = Some(cmt.span)`
`1576`	`1572`	`}`
`1577`	`1573`	`}`
`1578`	`1574`	`}`
`1579`		`-`
`1580`		`- fn decl_without_init(&mut self, _: HirId, _: Span) {}`
`1581`	`1575`	`}`
`1582`	`1576`
`1583`	`1577`	`impl<'tcx> MutatePairDelegate {`
`@@ -1655,7 +1649,6 @@ fn check_for_mutation(`
`1655`	`1649`	`cx.param_env,`
`1656`	`1650`	`region_scope_tree,`
`1657`	`1651`	`cx.tables,`
`1658`		`- None,`
`1659`	`1652`	`)`
`1660`	`1653`	`.walk_expr(body);`
`1661`	`1654`	`delegate.mutation_span()`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,6 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {`
`143`	`143`	`cx.param_env,`
`144`	`144`	`region_scope_tree,`
`145`	`145`	`cx.tables,`
`146`		`- None,`
`147`	`146`	`)`
`148`	`147`	`.consume_body(body);`
`149`	`148`	`ctx`
`@@ -400,9 +399,9 @@ impl<'a, 'tcx> MovedVariablesCtxt<'a, 'tcx> {`
`400`	`399`	`}`
`401`	`400`
`402`	`401`	`impl<'a, 'tcx> euv::Delegate<'tcx> for MovedVariablesCtxt<'a, 'tcx> {`
`403`		`- fn consume(&mut self, consume_id: HirId, consume_span: Span, cmt: &mc::cmt_<'tcx>, mode: euv::ConsumeMode) {`
`404`		`- if let euv::ConsumeMode::Move(_) = mode {`
`405`		`- self.move_common(consume_id, consume_span, cmt);`
	`402`	`+ fn consume(&mut self, cmt: &mc::cmt_<'tcx>, mode: euv::ConsumeMode) {`
	`403`	`+ if let euv::ConsumeMode::Move = mode {`
	`404`	`+ self.move_common(cmt.hir_id, cmt.span, cmt);`
`406`	`405`	`}`
`407`	`406`	`}`
`408`	`407`
`@@ -422,18 +421,12 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for MovedVariablesCtxt<'a, 'tcx> {`
`422`	`421`
`423`	`422`	`fn borrow(`
`424`	`423`	`&mut self,`
`425`		`- _: HirId,`
`426`		`- _: Span,`
`427`	`424`	`_: &mc::cmt_<'tcx>,`
`428`		`- _: ty::Region<'_>,`
`429`	`425`	`_: ty::BorrowKind,`
`430`		`- _: euv::LoanCause,`
`431`	`426`	`) {`
`432`	`427`	`}`
`433`	`428`
`434`		`- fn mutate(&mut self, _: HirId, _: Span, _: &mc::cmt_<'tcx>, _: euv::MutateMode) {}`
`435`		`-`
`436`		`- fn decl_without_init(&mut self, _: HirId, _: Span) {}`
	`429`	`+ fn mutate(&mut self, _: &mc::cmt_<'tcx>) {}`
`437`	`430`	`}`
`438`	`431`
`439`	`432`	`fn unwrap_downcast_or_interior<'a, 'tcx>(mut cmt: &'a mc::cmt_<'tcx>) -> mc::cmt_<'tcx> {`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ use rustc::middle::mem_categorization::cmt_;`
`6`	`6`	`use rustc::middle::mem_categorization::Categorization;`
`7`	`7`	`use rustc::ty;`
`8`	`8`	`use rustc_data_structures::fx::FxHashSet;`
`9`		`-use syntax::source_map::Span;`
`10`	`9`
`11`	`10`	/// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
`12`	`11`	`pub fn mutated_variables<'a, 'tcx>(expr: &'tcx Expr, cx: &'a LateContext<'a, 'tcx>) -> Option<FxHashSet<HirId>> {`
`@@ -23,7 +22,6 @@ pub fn mutated_variables<'a, 'tcx>(expr: &'tcx Expr, cx: &'a LateContext<'a, 'tc`
`23`	`22`	`cx.param_env,`
`24`	`23`	`region_scope_tree,`
`25`	`24`	`cx.tables,`
`26`		`- None,`
`27`	`25`	`)`
`28`	`26`	`.walk_expr(expr);`
`29`	`27`
`@@ -66,21 +64,15 @@ impl<'tcx> MutVarsDelegate {`
`66`	`64`	`}`
`67`	`65`
`68`	`66`	`impl<'tcx> Delegate<'tcx> for MutVarsDelegate {`
`69`		`- fn consume(&mut self, _: HirId, _: Span, _: &cmt_<'tcx>, _: ConsumeMode) {}`
	`67`	`+ fn consume(&mut self, _: &cmt_<'tcx>, _: ConsumeMode) {}`
`70`	`68`
`71`		`- fn matched_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: MatchMode) {}`
`72`		`-`
`73`		`- fn consume_pat(&mut self, _: &Pat, _: &cmt_<'tcx>, _: ConsumeMode) {}`
`74`		`-`
`75`		`- fn borrow(&mut self, _: HirId, _: Span, cmt: &cmt_<'tcx>, _: ty::Region<'_>, bk: ty::BorrowKind, _: LoanCause) {`
	`69`	`+ fn borrow(&mut self, cmt: &cmt_<'tcx>, bk: ty::BorrowKind) {`
`76`	`70`	`if let ty::BorrowKind::MutBorrow = bk {`
`77`	`71`	`self.update(&cmt.cat)`
`78`	`72`	`}`
`79`	`73`	`}`
`80`	`74`
`81`		`- fn mutate(&mut self, _: HirId, _: Span, cmt: &cmt_<'tcx>, _: MutateMode) {`
	`75`	`+ fn mutate(&mut self, cmt: &cmt_<'tcx>) {`
`82`	`76`	`self.update(&cmt.cat)`
`83`	`77`	`}`
`84`		`-`
`85`		`- fn decl_without_init(&mut self, _: HirId, _: Span) {}`
`86`	`78`	`}`