Rollup merge of #95649 - ouz-a:mir-opt, r=oli-obk

New mir-opt deref_separator

This adds a new mir-opt that split certain derefs into this form:
`let x = (*a.b).c;` to => `tmp = a.b; let x = (*tmp).c;`

Huge thanks to ``@oli-obk`` for his patient mentoring.

2 files changed, 74 insertions, 0 deletions

diff --git a/compiler/rustc_mir_transform/src/deref_separator.rs b/compiler/rustc_mir_transform/src/deref_separator.rs
new file mode 100644
index 00000000000..79aac163550
--- /dev/null
+++ b/compiler/rustc_mir_transform/src/deref_separator.rs
@@ -0,0 +1,72 @@
+use crate::MirPass;
+use rustc_middle::mir::patch::MirPatch;
+use rustc_middle::mir::*;
+use rustc_middle::ty::TyCtxt;
+pub struct Derefer;
+
+pub fn deref_finder<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+    let mut patch = MirPatch::new(body);
+    let (basic_blocks, local_decl) = body.basic_blocks_and_local_decls_mut();
+    for (block, data) in basic_blocks.iter_enumerated_mut() {
+        for (i, stmt) in data.statements.iter_mut().enumerate() {
+            match stmt.kind {
+                StatementKind::Assign(box (og_place, Rvalue::Ref(region, borrow_knd, place))) => {
+                    for (idx, (p_ref, p_elem)) in place.iter_projections().enumerate() {
+                        if p_elem == ProjectionElem::Deref && !p_ref.projection.is_empty() {
+                            // The type that we are derefing.
+                            let ty = p_ref.ty(local_decl, tcx).ty;
+                            let temp = patch.new_temp(ty, stmt.source_info.span);
+
+                            // Because we are assigning this right before original statement
+                            // we are using index i of statement.
+                            let loc = Location { block: block, statement_index: i };
+                            patch.add_statement(loc, StatementKind::StorageLive(temp));
+
+                            // We are adding current p_ref's projections to our
+                            // temp value.
+                            let deref_place =
+                                Place::from(p_ref.local).project_deeper(p_ref.projection, tcx);
+                            patch.add_assign(
+                                loc,
+                                Place::from(temp),
+                                Rvalue::Use(Operand::Move(deref_place)),
+                            );
+
+                            // We are creating a place by using our temp value's location
+                            // and copying derefed values which we need to create new statement.
+                            let temp_place =
+                                Place::from(temp).project_deeper(&place.projection[idx..], tcx);
+                            let new_stmt = Statement {
+                                source_info: stmt.source_info,
+                                kind: StatementKind::Assign(Box::new((
+                                    og_place,
+                                    Rvalue::Ref(region, borrow_knd, temp_place),
+                                ))),
+                            };
+
+                            // Replace current statement with newly created one.
+                            *stmt = new_stmt;
+
+                            // Since our job with the temp is done it should be gone
+                            let loc = Location { block: block, statement_index: i + 1 };
+                            patch.add_statement(loc, StatementKind::StorageDead(temp));
+
+                            // As all projections are off the base projection, if there are
+                            // multiple derefs in the middle of projection, it might cause
+                            // unsoundness, to not let that happen we break the loop.
+                            break;
+                        }
+                    }
+                }
+                _ => (),
+            }
+        }
+    }
+    patch.apply(body);
+}
+
+impl<'tcx> MirPass<'tcx> for Derefer {
+    fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        deref_finder(tcx, body);
+    }
+}
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 2fca498a125..059ee09dfd7 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -53,6 +53,7 @@ mod const_prop_lint;
 mod coverage;
 mod deaggregator;
 mod deduplicate_blocks;
+mod deref_separator;
 mod dest_prop;
 pub mod dump_mir;
 mod early_otherwise_branch;
@@ -431,6 +432,7 @@ fn run_post_borrowck_cleanup_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tc
         // `Deaggregator` is conceptually part of MIR building, some backends rely on it happening
         // and it can help optimizations.
         &deaggregator::Deaggregator,
+        &deref_separator::Derefer,
         &Lint(const_prop_lint::ConstProp),
     ];