remove visit_terminator_kind from MIR visitor

RalfJung · RalfJung · commit 0bcefd9b5e68 · 2020-06-16T09:43:31.000+02:00
diff --git a/src/librustc_codegen_ssa/mir/analyze.rs b/src/librustc_codegen_ssa/mir/analyze.rs
@@ -234,8 +234,8 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>
         self.visit_rvalue(rvalue, location);
     }
 
-    fn visit_terminator_kind(&mut self, kind: &mir::TerminatorKind<'tcx>, location: Location) {
-        let check = match *kind {
+    fn visit_terminator(&mut self, terminator: &mir::Terminator<'tcx>, location: Location) {
+        let check = match terminator.kind {
             mir::TerminatorKind::Call { func: mir::Operand::Constant(ref c), ref args, .. } => {
                 match c.literal.ty.kind {
                     ty::FnDef(did, _) => Some((did, args)),
@@ -259,7 +259,7 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>
             }
         }
 
-        self.super_terminator_kind(kind, location);
+        self.super_terminator(terminator, location);
     }
 
     fn visit_place(&mut self, place: &mir::Place<'tcx>, context: PlaceContext, location: Location) {
diff --git a/src/librustc_middle/mir/visit.rs b/src/librustc_middle/mir/visit.rs
@@ -108,12 +108,6 @@ macro_rules! make_mir_visitor {
                 self.super_terminator(terminator, location);
             }
 
-            fn visit_terminator_kind(&mut self,
-                                     kind: & $($mutability)? TerminatorKind<'tcx>,
-                                     location: Location) {
-                self.super_terminator_kind(kind, location);
-            }
-
             fn visit_assert_message(&mut self,
                                     msg: & $($mutability)? AssertMessage<'tcx>,
                                     location: Location) {
@@ -413,16 +407,10 @@ macro_rules! make_mir_visitor {
 
             fn super_terminator(&mut self,
                                 terminator: &$($mutability)? Terminator<'tcx>,
-                                location: Location) {
+                                source_location: Location) {
                 let Terminator { source_info, kind } = terminator;
 
                 self.visit_source_info(source_info);
-                self.visit_terminator_kind(kind, location);
-            }
-
-            fn super_terminator_kind(&mut self,
-                                     kind: & $($mutability)? TerminatorKind<'tcx>,
-                                     source_location: Location) {
                 match kind {
                     TerminatorKind::Goto { .. } |
                     TerminatorKind::Resume |
diff --git a/src/librustc_mir/borrow_check/invalidation.rs b/src/librustc_mir/borrow_check/invalidation.rs
@@ -2,7 +2,7 @@ use rustc_data_structures::graph::dominators::Dominators;
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::{BasicBlock, Body, Location, Place, Rvalue};
 use rustc_middle::mir::{BorrowKind, Mutability, Operand};
-use rustc_middle::mir::{InlineAsmOperand, TerminatorKind};
+use rustc_middle::mir::{InlineAsmOperand, Terminator, TerminatorKind};
 use rustc_middle::mir::{Statement, StatementKind};
 use rustc_middle::ty::TyCtxt;
 
@@ -112,10 +112,10 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {
         self.super_statement(statement, location);
     }
 
-    fn visit_terminator_kind(&mut self, kind: &TerminatorKind<'tcx>, location: Location) {
+    fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location) {
         self.check_activations(location);
 
-        match kind {
+        match &terminator.kind {
             TerminatorKind::SwitchInt { ref discr, switch_ty: _, values: _, targets: _ } => {
                 self.consume_operand(location, discr);
             }
@@ -222,7 +222,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {
             }
         }
 
-        self.super_terminator_kind(kind, location);
+        self.super_terminator(terminator, location);
     }
 }
 
diff --git a/src/librustc_mir/borrow_check/used_muts.rs b/src/librustc_mir/borrow_check/used_muts.rs
@@ -1,5 +1,7 @@
 use rustc_middle::mir::visit::{PlaceContext, Visitor};
-use rustc_middle::mir::{Local, Location, Place, Statement, StatementKind, TerminatorKind};
+use rustc_middle::mir::{
+    Local, Location, Place, Statement, StatementKind, Terminator, TerminatorKind,
+};
 
 use rustc_data_structures::fx::FxHashSet;
 
@@ -62,9 +64,9 @@ impl GatherUsedMutsVisitor<'_, '_, '_> {
 }
 
 impl<'visit, 'cx, 'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'visit, 'cx, 'tcx> {
-    fn visit_terminator_kind(&mut self, kind: &TerminatorKind<'tcx>, _location: Location) {
-        debug!("visit_terminator_kind: kind={:?}", kind);
-        match &kind {
+    fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, _location: Location) {
+        debug!("visit_terminator: terminator={:?}", terminator);
+        match &terminator.kind {
             TerminatorKind::Call { destination: Some((into, _)), .. } => {
                 self.remove_never_initialized_mut_locals(*into);
             }
@@ -73,6 +75,8 @@ impl<'visit, 'cx, 'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'visit, 'cx, 'tc
             }
             _ => {}
         }
+
+        // FIXME: no super_terminator?
     }
 
     fn visit_statement(&mut self, statement: &Statement<'tcx>, _location: Location) {
@@ -84,6 +88,8 @@ impl<'visit, 'cx, 'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'visit, 'cx, 'tc
             );
             self.remove_never_initialized_mut_locals(*into);
         }
+
+        // FIXME: no super_statement?
     }
 
     fn visit_local(&mut self, local: &Local, place_context: PlaceContext, location: Location) {
@@ -101,5 +107,7 @@ impl<'visit, 'cx, 'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'visit, 'cx, 'tc
                 }
             }
         }
+
+        // FIXME: no super_local?
     }
 }
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
@@ -616,11 +616,11 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
         self.super_const(constant);
     }
 
-    fn visit_terminator_kind(&mut self, kind: &mir::TerminatorKind<'tcx>, location: Location) {
-        debug!("visiting terminator {:?} @ {:?}", kind, location);
+    fn visit_terminator(&mut self, terminator: &mir::Terminator<'tcx>, location: Location) {
+        debug!("visiting terminator {:?} @ {:?}", terminator, location);
 
         let tcx = self.tcx;
-        match *kind {
+        match terminator.kind {
             mir::TerminatorKind::Call { ref func, .. } => {
                 let callee_ty = func.ty(self.body, tcx);
                 let callee_ty = self.monomorphize(callee_ty);
@@ -663,7 +663,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
             | mir::TerminatorKind::FalseUnwind { .. } => bug!(),
         }
 
-        self.super_terminator_kind(kind, location);
+        self.super_terminator(terminator, location);
     }
 
     fn visit_local(
diff --git a/src/librustc_mir/transform/check_consts/resolver.rs b/src/librustc_mir/transform/check_consts/resolver.rs
@@ -121,11 +121,12 @@ where
         self.super_assign(place, rvalue, location);
     }
 
-    fn visit_terminator_kind(&mut self, kind: &mir::TerminatorKind<'tcx>, location: Location) {
+    fn visit_terminator(&mut self, terminator: &mir::Terminator<'tcx>, location: Location) {
         // The effect of assignment to the return place in `TerminatorKind::Call` is not applied
         // here; that occurs in `apply_call_return_effect`.
 
-        if let mir::TerminatorKind::DropAndReplace { value, location: dest, .. } = kind {
+        if let mir::TerminatorKind::DropAndReplace { value, location: dest, .. } = &terminator.kind
+        {
             let qualif = qualifs::in_operand::<Q, _>(
                 self.ccx,
                 &mut |l| self.qualifs_per_local.contains(l),
@@ -139,7 +140,7 @@ where
 
         // We need to assign qualifs to the dropped location before visiting the operand that
         // replaces it since qualifs can be cleared on move.
-        self.super_terminator_kind(kind, location);
+        self.super_terminator(terminator, location);
     }
 }
 
diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs
@@ -93,13 +93,13 @@ impl<'tcx> MutVisitor<'tcx> for RenameLocalVisitor<'tcx> {
         }
     }
 
-    fn visit_terminator_kind(&mut self, kind: &mut TerminatorKind<'tcx>, location: Location) {
-        match kind {
+    fn visit_terminator(&mut self, terminator: &mut Terminator<'tcx>, location: Location) {
+        match terminator.kind {
             TerminatorKind::Return => {
                 // Do not replace the implicit `_0` access here, as that's not possible. The
                 // transform already handles `return` correctly.
             }
-            _ => self.super_terminator_kind(kind, location),
+            _ => self.super_terminator(terminator, location),
         }
     }
 }
diff --git a/src/librustc_mir/transform/inline.rs b/src/librustc_mir/transform/inline.rs
@@ -731,14 +731,14 @@ impl<'a, 'tcx> MutVisitor<'tcx> for Integrator<'a, 'tcx> {
         }
     }
 
-    fn visit_terminator_kind(&mut self, kind: &mut TerminatorKind<'tcx>, loc: Location) {
+    fn visit_terminator(&mut self, terminator: &mut Terminator<'tcx>, loc: Location) {
         // Don't try to modify the implicit `_0` access on return (`return` terminators are
         // replaced down below anyways).
-        if !matches!(kind, TerminatorKind::Return) {
-            self.super_terminator_kind(kind, loc);
+        if !matches!(terminator.kind, TerminatorKind::Return) {
+            self.super_terminator(terminator, loc);
         }
 
-        match *kind {
+        match terminator.kind {
             TerminatorKind::GeneratorDrop | TerminatorKind::Yield { .. } => bug!(),
             TerminatorKind::Goto { ref mut target } => {
                 *target = self.update_target(*target);
@@ -782,11 +782,11 @@ impl<'a, 'tcx> MutVisitor<'tcx> for Integrator<'a, 'tcx> {
                 }
             }
             TerminatorKind::Return => {
-                *kind = TerminatorKind::Goto { target: self.return_block };
+                terminator.kind = TerminatorKind::Goto { target: self.return_block };
             }
             TerminatorKind::Resume => {
                 if let Some(tgt) = self.cleanup_block {
-                    *kind = TerminatorKind::Goto { target: tgt }
+                    terminator.kind = TerminatorKind::Goto { target: tgt }
                 }
             }
             TerminatorKind::Abort => {}
diff --git a/src/librustc_mir/transform/no_landing_pads.rs b/src/librustc_mir/transform/no_landing_pads.rs
@@ -34,10 +34,10 @@ impl<'tcx> MutVisitor<'tcx> for NoLandingPads<'tcx> {
         self.tcx
     }
 
-    fn visit_terminator_kind(&mut self, kind: &mut TerminatorKind<'tcx>, location: Location) {
-        if let Some(unwind) = kind.unwind_mut() {
+    fn visit_terminator(&mut self, terminator: &mut Terminator<'tcx>, location: Location) {
+        if let Some(unwind) = terminator.kind.unwind_mut() {
             unwind.take();
         }
-        self.super_terminator_kind(kind, location);
+        self.super_terminator(terminator, location);
     }
 }
diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs
@@ -216,10 +216,10 @@ impl<'tcx> Visitor<'tcx> for Collector<'_, 'tcx> {
         }
     }
 
-    fn visit_terminator_kind(&mut self, kind: &TerminatorKind<'tcx>, location: Location) {
-        self.super_terminator_kind(kind, location);
+    fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location) {
+        self.super_terminator(terminator, location);
 
-        match *kind {
+        match terminator.kind {
             TerminatorKind::Call { ref func, .. } => {
                 if let ty::FnDef(def_id, _) = func.ty(self.ccx.body, self.ccx.tcx).kind {
                     let fn_sig = self.ccx.tcx.fn_sig(def_id);

Original file line number	Diff line number	Diff line change
`@@ -234,8 +234,8 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>`
`234`	`234`	`self.visit_rvalue(rvalue, location);`
`235`	`235`	`}`
`236`	`236`
`237`		`- fn visit_terminator_kind(&mut self, kind: &mir::TerminatorKind<'tcx>, location: Location) {`
`238`		`- let check = match *kind {`
	`237`	`+ fn visit_terminator(&mut self, terminator: &mir::Terminator<'tcx>, location: Location) {`
	`238`	`+ let check = match terminator.kind {`
`239`	`239`	`mir::TerminatorKind::Call { func: mir::Operand::Constant(ref c), ref args, .. } => {`
`240`	`240`	`match c.literal.ty.kind {`
`241`	`241`	`ty::FnDef(did, _) => Some((did, args)),`
`@@ -259,7 +259,7 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>`
`259`	`259`	`}`
`260`	`260`	`}`
`261`	`261`
`262`		`- self.super_terminator_kind(kind, location);`
	`262`	`+ self.super_terminator(terminator, location);`
`263`	`263`	`}`
`264`	`264`
`265`	`265`	`fn visit_place(&mut self, place: &mir::Place<'tcx>, context: PlaceContext, location: Location) {`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ use rustc_data_structures::graph::dominators::Dominators;`
`2`	`2`	`use rustc_middle::mir::visit::Visitor;`
`3`	`3`	`use rustc_middle::mir::{BasicBlock, Body, Location, Place, Rvalue};`
`4`	`4`	`use rustc_middle::mir::{BorrowKind, Mutability, Operand};`
`5`		`-use rustc_middle::mir::{InlineAsmOperand, TerminatorKind};`
	`5`	`+use rustc_middle::mir::{InlineAsmOperand, Terminator, TerminatorKind};`
`6`	`6`	`use rustc_middle::mir::{Statement, StatementKind};`
`7`	`7`	`use rustc_middle::ty::TyCtxt;`
`8`	`8`
`@@ -112,10 +112,10 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {`
`112`	`112`	`self.super_statement(statement, location);`
`113`	`113`	`}`
`114`	`114`
`115`		`- fn visit_terminator_kind(&mut self, kind: &TerminatorKind<'tcx>, location: Location) {`
	`115`	`+ fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location) {`
`116`	`116`	`self.check_activations(location);`
`117`	`117`
`118`		`- match kind {`
	`118`	`+ match &terminator.kind {`
`119`	`119`	`TerminatorKind::SwitchInt { ref discr, switch_ty: _, values: _, targets: _ } => {`
`120`	`120`	`self.consume_operand(location, discr);`
`121`	`121`	`}`
`@@ -222,7 +222,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {`
`222`	`222`	`}`
`223`	`223`	`}`
`224`	`224`
`225`		`- self.super_terminator_kind(kind, location);`
	`225`	`+ self.super_terminator(terminator, location);`
`226`	`226`	`}`
`227`	`227`	`}`
`228`	`228`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,7 @@`
`1`	`1`	`use rustc_middle::mir::visit::{PlaceContext, Visitor};`
`2`		`-use rustc_middle::mir::{Local, Location, Place, Statement, StatementKind, TerminatorKind};`
	`2`	`+use rustc_middle::mir::{`
	`3`	`+ Local, Location, Place, Statement, StatementKind, Terminator, TerminatorKind,`
	`4`	`+};`
`3`	`5`
`4`	`6`	`use rustc_data_structures::fx::FxHashSet;`
`5`	`7`
`@@ -62,9 +64,9 @@ impl GatherUsedMutsVisitor<'_, '_, '_> {`
`62`	`64`	`}`
`63`	`65`
`64`	`66`	`impl<'visit, 'cx, 'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'visit, 'cx, 'tcx> {`
`65`		`- fn visit_terminator_kind(&mut self, kind: &TerminatorKind<'tcx>, _location: Location) {`
`66`		`- debug!("visit_terminator_kind: kind={:?}", kind);`
`67`		`- match &kind {`
	`67`	`+ fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, _location: Location) {`
	`68`	`+ debug!("visit_terminator: terminator={:?}", terminator);`
	`69`	`+ match &terminator.kind {`
`68`	`70`	`TerminatorKind::Call { destination: Some((into, _)), .. } => {`
`69`	`71`	`self.remove_never_initialized_mut_locals(*into);`
`70`	`72`	`}`
`@@ -73,6 +75,8 @@ impl<'visit, 'cx, 'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'visit, 'cx, 'tc`
`73`	`75`	`}`
`74`	`76`	`_ => {}`
`75`	`77`	`}`
	`78`	`+`
	`79`	`+ // FIXME: no super_terminator?`
`76`	`80`	`}`
`77`	`81`
`78`	`82`	`fn visit_statement(&mut self, statement: &Statement<'tcx>, _location: Location) {`
`@@ -84,6 +88,8 @@ impl<'visit, 'cx, 'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'visit, 'cx, 'tc`
`84`	`88`	`);`
`85`	`89`	`self.remove_never_initialized_mut_locals(*into);`
`86`	`90`	`}`
	`91`	`+`
	`92`	`+ // FIXME: no super_statement?`
`87`	`93`	`}`
`88`	`94`
`89`	`95`	`fn visit_local(&mut self, local: &Local, place_context: PlaceContext, location: Location) {`
`@@ -101,5 +107,7 @@ impl<'visit, 'cx, 'tcx> Visitor<'tcx> for GatherUsedMutsVisitor<'visit, 'cx, 'tc`
`101`	`107`	`}`
`102`	`108`	`}`
`103`	`109`	`}`
	`110`	`+`
	`111`	`+ // FIXME: no super_local?`
`104`	`112`	`}`
`105`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -616,11 +616,11 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {`
`616`	`616`	`self.super_const(constant);`
`617`	`617`	`}`
`618`	`618`
`619`		`- fn visit_terminator_kind(&mut self, kind: &mir::TerminatorKind<'tcx>, location: Location) {`
`620`		`- debug!("visiting terminator {:?} @ {:?}", kind, location);`
	`619`	`+ fn visit_terminator(&mut self, terminator: &mir::Terminator<'tcx>, location: Location) {`
	`620`	`+ debug!("visiting terminator {:?} @ {:?}", terminator, location);`
`621`	`621`
`622`	`622`	`let tcx = self.tcx;`
`623`		`- match *kind {`
	`623`	`+ match terminator.kind {`
`624`	`624`	`mir::TerminatorKind::Call { ref func, .. } => {`
`625`	`625`	`let callee_ty = func.ty(self.body, tcx);`
`626`	`626`	`let callee_ty = self.monomorphize(callee_ty);`
`@@ -663,7 +663,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {`
`663`	`663`	`\| mir::TerminatorKind::FalseUnwind { .. } => bug!(),`
`664`	`664`	`}`
`665`	`665`
`666`		`- self.super_terminator_kind(kind, location);`
	`666`	`+ self.super_terminator(terminator, location);`
`667`	`667`	`}`
`668`	`668`
`669`	`669`	`fn visit_local(`
Original file line number	Diff line number	Diff line change
`@@ -121,11 +121,12 @@ where`
`121`	`121`	`self.super_assign(place, rvalue, location);`
`122`	`122`	`}`
`123`	`123`
`124`		`- fn visit_terminator_kind(&mut self, kind: &mir::TerminatorKind<'tcx>, location: Location) {`
	`124`	`+ fn visit_terminator(&mut self, terminator: &mir::Terminator<'tcx>, location: Location) {`
`125`	`125`	// The effect of assignment to the return place in `TerminatorKind::Call` is not applied
`126`	`126`	// here; that occurs in `apply_call_return_effect`.
`127`	`127`
`128`		`- if let mir::TerminatorKind::DropAndReplace { value, location: dest, .. } = kind {`
	`128`	`+ if let mir::TerminatorKind::DropAndReplace { value, location: dest, .. } = &terminator.kind`
	`129`	`+ {`
`129`	`130`	`let qualif = qualifs::in_operand::<Q, _>(`
`130`	`131`	`self.ccx,`
`131`	`132`	`&mut \|l\| self.qualifs_per_local.contains(l),`
`@@ -139,7 +140,7 @@ where`
`139`	`140`
`140`	`141`	`// We need to assign qualifs to the dropped location before visiting the operand that`
`141`	`142`	`// replaces it since qualifs can be cleared on move.`
`142`		`- self.super_terminator_kind(kind, location);`
	`143`	`+ self.super_terminator(terminator, location);`
`143`	`144`	`}`
`144`	`145`	`}`
`145`	`146`
Original file line number	Diff line number	Diff line change
`@@ -93,13 +93,13 @@ impl<'tcx> MutVisitor<'tcx> for RenameLocalVisitor<'tcx> {`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
`96`		`- fn visit_terminator_kind(&mut self, kind: &mut TerminatorKind<'tcx>, location: Location) {`
`97`		`- match kind {`
	`96`	`+ fn visit_terminator(&mut self, terminator: &mut Terminator<'tcx>, location: Location) {`
	`97`	`+ match terminator.kind {`
`98`	`98`	`TerminatorKind::Return => {`
`99`	`99`	// Do not replace the implicit `_0` access here, as that's not possible. The
`100`	`100`	// transform already handles `return` correctly.
`101`	`101`	`}`
`102`		`- _ => self.super_terminator_kind(kind, location),`
	`102`	`+ _ => self.super_terminator(terminator, location),`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`	`}`
Original file line number	Diff line number	Diff line change
`@@ -731,14 +731,14 @@ impl<'a, 'tcx> MutVisitor<'tcx> for Integrator<'a, 'tcx> {`
`731`	`731`	`}`
`732`	`732`	`}`
`733`	`733`
`734`		`- fn visit_terminator_kind(&mut self, kind: &mut TerminatorKind<'tcx>, loc: Location) {`
	`734`	`+ fn visit_terminator(&mut self, terminator: &mut Terminator<'tcx>, loc: Location) {`
`735`	`735`	// Don't try to modify the implicit `_0` access on return (`return` terminators are
`736`	`736`	`// replaced down below anyways).`
`737`		`- if !matches!(kind, TerminatorKind::Return) {`
`738`		`- self.super_terminator_kind(kind, loc);`
	`737`	`+ if !matches!(terminator.kind, TerminatorKind::Return) {`
	`738`	`+ self.super_terminator(terminator, loc);`
`739`	`739`	`}`
`740`	`740`
`741`		`- match *kind {`
	`741`	`+ match terminator.kind {`
`742`	`742`	`TerminatorKind::GeneratorDrop \| TerminatorKind::Yield { .. } => bug!(),`
`743`	`743`	`TerminatorKind::Goto { ref mut target } => {`
`744`	`744`	`target = self.update_target(target);`
`@@ -782,11 +782,11 @@ impl<'a, 'tcx> MutVisitor<'tcx> for Integrator<'a, 'tcx> {`
`782`	`782`	`}`
`783`	`783`	`}`
`784`	`784`	`TerminatorKind::Return => {`
`785`		`- *kind = TerminatorKind::Goto { target: self.return_block };`
	`785`	`+ terminator.kind = TerminatorKind::Goto { target: self.return_block };`
`786`	`786`	`}`
`787`	`787`	`TerminatorKind::Resume => {`
`788`	`788`	`if let Some(tgt) = self.cleanup_block {`
`789`		`- *kind = TerminatorKind::Goto { target: tgt }`
	`789`	`+ terminator.kind = TerminatorKind::Goto { target: tgt }`
`790`	`790`	`}`
`791`	`791`	`}`
`792`	`792`	`TerminatorKind::Abort => {}`
Original file line number	Diff line number	Diff line change
`@@ -34,10 +34,10 @@ impl<'tcx> MutVisitor<'tcx> for NoLandingPads<'tcx> {`
`34`	`34`	`self.tcx`
`35`	`35`	`}`
`36`	`36`
`37`		`- fn visit_terminator_kind(&mut self, kind: &mut TerminatorKind<'tcx>, location: Location) {`
`38`		`- if let Some(unwind) = kind.unwind_mut() {`
	`37`	`+ fn visit_terminator(&mut self, terminator: &mut Terminator<'tcx>, location: Location) {`
	`38`	`+ if let Some(unwind) = terminator.kind.unwind_mut() {`
`39`	`39`	`unwind.take();`
`40`	`40`	`}`
`41`		`- self.super_terminator_kind(kind, location);`
	`41`	`+ self.super_terminator(terminator, location);`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -216,10 +216,10 @@ impl<'tcx> Visitor<'tcx> for Collector<'_, 'tcx> {`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`
`219`		`- fn visit_terminator_kind(&mut self, kind: &TerminatorKind<'tcx>, location: Location) {`
`220`		`- self.super_terminator_kind(kind, location);`
	`219`	`+ fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location) {`
	`220`	`+ self.super_terminator(terminator, location);`
`221`	`221`
`222`		`- match *kind {`
	`222`	`+ match terminator.kind {`
`223`	`223`	`TerminatorKind::Call { ref func, .. } => {`
`224`	`224`	`if let ty::FnDef(def_id, _) = func.ty(self.ccx.body, self.ccx.tcx).kind {`
`225`	`225`	`let fn_sig = self.ccx.tcx.fn_sig(def_id);`