Newtype for FakeRead semi-traversable tuple

Author: eggyal

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -14,9 +14,9 @@ use rustc_middle::hir::nested_filter::OnlyBodies;
 use rustc_middle::mir::tcx::PlaceTy;
 use rustc_middle::mir::{
     self, AggregateKind, BindingForm, BorrowKind, CallSource, ClearCrossCrate, ConstraintCategory,
-    FakeReadCause, LocalDecl, LocalInfo, LocalKind, Location, MutBorrowKind, Operand, Place,
-    PlaceRef, ProjectionElem, Rvalue, Statement, StatementKind, Terminator, TerminatorKind,
-    VarBindingForm,
+    FakeReadCause, FakeReadCauseAndPlace, LocalDecl, LocalInfo, LocalKind, Location, MutBorrowKind,
+    Operand, Place, PlaceRef, ProjectionElem, Rvalue, Statement, StatementKind, Terminator,
+    TerminatorKind, VarBindingForm,
 };
 use rustc_middle::ty::{self, suggest_constraining_type_params, PredicateKind, Ty};
 use rustc_middle::util::CallKind;
@@ -3010,9 +3010,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         impl<'tcx> Visitor<'tcx> for FakeReadCauseFinder<'tcx> {
             fn visit_statement(&mut self, statement: &Statement<'tcx>, _: Location) {
                 match statement {
-                    Statement { kind: StatementKind::FakeRead(box (cause, place)), .. }
-                        if *place == self.place =>
-                    {
+                    Statement {
+                        kind: StatementKind::FakeRead(box FakeReadCauseAndPlace(cause, place)),
+                        ..
+                    } if *place == self.place => {
                         self.cause = Some(*cause);
                     }
                     _ => (),

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -6,8 +6,8 @@ use rustc_hir::intravisit::Visitor;
 use rustc_index::IndexSlice;
 use rustc_infer::infer::NllRegionVariableOrigin;
 use rustc_middle::mir::{
-    Body, CallSource, CastKind, ConstraintCategory, FakeReadCause, Local, LocalInfo, Location,
-    Operand, Place, Rvalue, Statement, StatementKind, TerminatorKind,
+    Body, CallSource, CastKind, ConstraintCategory, FakeReadCause, FakeReadCauseAndPlace, Local,
+    LocalInfo, Location, Operand, Place, Rvalue, Statement, StatementKind, TerminatorKind,
 };
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::{self, RegionVid, TyCtxt};
@@ -477,7 +477,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 let block = &self.body.basic_blocks[location.block];
 
                 let kind = if let Some(&Statement {
-                    kind: StatementKind::FakeRead(box (FakeReadCause::ForLet(_), place)),
+                    kind:
+                        StatementKind::FakeRead(box FakeReadCauseAndPlace(
+                            FakeReadCause::ForLet(_),
+                            place,
+                        )),
                     ..
                 }) = block.statements.get(location.statement_index)
                 {

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -13,9 +13,9 @@ use rustc_index::IndexSlice;
 use rustc_infer::infer::LateBoundRegionConversionTime;
 use rustc_middle::mir::tcx::PlaceTy;
 use rustc_middle::mir::{
-    AggregateKind, CallSource, ConstOperand, FakeReadCause, Local, LocalInfo, LocalKind, Location,
-    Operand, Place, PlaceRef, ProjectionElem, Rvalue, Statement, StatementKind, Terminator,
-    TerminatorKind,
+    AggregateKind, CallSource, ConstOperand, FakeReadCause, FakeReadCauseAndPlace, Local,
+    LocalInfo, LocalKind, Location, Operand, Place, PlaceRef, ProjectionElem, Rvalue, Statement,
+    StatementKind, Terminator, TerminatorKind,
 };
 use rustc_middle::ty::print::Print;
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
@@ -797,7 +797,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 
         // StatementKind::FakeRead only contains a def_id if they are introduced as a result
         // of pattern matching within a closure.
-        if let StatementKind::FakeRead(box (cause, place)) = stmt.kind {
+        if let StatementKind::FakeRead(box FakeReadCauseAndPlace(cause, place)) = stmt.kind {
             match cause {
                 FakeReadCause::ForMatchedPlace(Some(closure_def_id))
                 | FakeReadCause::ForLet(Some(closure_def_id)) => {

compiler/rustc_borrowck/src/invalidation.rs

@@ -62,7 +62,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {
 
                 self.mutate_place(location, *lhs, Shallow(None));
             }
-            StatementKind::FakeRead(box (_, _)) => {
+            StatementKind::FakeRead(_) => {
                 // Only relevant for initialized/liveness/safety checks.
             }
             StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(op)) => {

compiler/rustc_borrowck/src/lib.rs

@@ -629,7 +629,7 @@ impl<'cx, 'tcx, R> rustc_mir_dataflow::ResultsVisitor<'cx, 'tcx, R> for MirBorro
 
                 self.mutate_place(location, (*lhs, span), Shallow(None), flow_state);
             }
-            StatementKind::FakeRead(box (_, place)) => {
+            StatementKind::FakeRead(box FakeReadCauseAndPlace(_, place)) => {
                 // Read for match doesn't access any memory and is used to
                 // assert that a place is safe and live. So we don't have to
                 // do any checks here.

compiler/rustc_middle/src/mir/pretty.rs

@@ -680,7 +680,7 @@ impl Debug for Statement<'_> {
         use self::StatementKind::*;
         match self.kind {
             Assign(box (ref place, ref rv)) => write!(fmt, "{place:?} = {rv:?}"),
-            FakeRead(box (ref cause, ref place)) => {
+            FakeRead(box FakeReadCauseAndPlace(ref cause, ref place)) => {
                 write!(fmt, "FakeRead({cause:?}, {place:?})")
             }
             Retag(ref kind, ref place) => write!(

compiler/rustc_middle/src/mir/syntax.rs

@@ -288,7 +288,7 @@ pub enum StatementKind<'tcx> {
     /// When executed at runtime this is a nop.
     ///
     /// Disallowed after drop elaboration.
-    FakeRead(Box<(FakeReadCause, Place<'tcx>)>),
+    FakeRead(Box<FakeReadCauseAndPlace<'tcx>>),
 
     /// Write the discriminant for a variant to the enum Place.
     ///
@@ -459,6 +459,10 @@ pub enum RetagKind {
     Default,
 }
 
+#[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, Hash, HashStable, PartialEq)]
+#[derive(TypeFoldable, TypeVisitable)]
+pub struct FakeReadCauseAndPlace<'tcx>(pub FakeReadCause, pub Place<'tcx>);
+
 /// The `FakeReadCause` describes the type of pattern why a FakeRead statement exists.
 #[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, Hash, HashStable, PartialEq)]
 pub enum FakeReadCause {

compiler/rustc_middle/src/mir/visit.rs

@@ -379,7 +379,7 @@ macro_rules! make_mir_visitor {
                     ) => {
                         self.visit_assign(place, rvalue, location);
                     }
-                    StatementKind::FakeRead(box (_, place)) => {
+                    StatementKind::FakeRead(box FakeReadCauseAndPlace(_, place)) => {
                         self.visit_place(
                             place,
                             PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect),

compiler/rustc_mir_build/src/build/cfg.rs

@@ -85,7 +85,7 @@ impl<'tcx> CFG<'tcx> {
         cause: FakeReadCause,
         place: Place<'tcx>,
     ) {
-        let kind = StatementKind::FakeRead(Box::new((cause, place)));
+        let kind = StatementKind::FakeRead(Box::new(FakeReadCauseAndPlace(cause, place)));
         let stmt = Statement { source_info, kind };
         self.push(block, stmt);
     }

compiler/rustc_mir_dataflow/src/move_paths/builder.rs

@@ -376,7 +376,7 @@ impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> {
                 }
                 self.gather_rvalue(rval);
             }
-            StatementKind::FakeRead(box (_, place)) => {
+            StatementKind::FakeRead(box FakeReadCauseAndPlace(_, place)) => {
                 self.create_move_path(*place);
             }
             StatementKind::StorageLive(_) => {}