refactor(mir-transform): Merge pass policies into one function

Author: jamie-osec

compiler/rustc_mir_transform/src/abort_unwinding_calls.rs

@@ -6,6 +6,8 @@ use rustc_middle::ty::{self, TyCtxt, layout};
 use rustc_span::sym;
 use rustc_target::spec::PanicStrategy;
 
+use crate::PassPolicy;
+
 /// A pass that runs which is targeted at ensuring that codegen guarantees about
 /// unwinding are upheld for compilations of panic=abort programs.
 ///
@@ -138,7 +140,9 @@ impl<'tcx> crate::MirPass<'tcx> for AbortUnwindingCalls {
         super::simplify::remove_dead_blocks(body);
     }
 
-    fn is_required(&self) -> bool {
-        true
+    fn policy(&self, _sess: &rustc_session::Session) -> PassPolicy {
+        // Implements part of MIR semantics, turning effectively implicit aborts into explicit
+        // ones.
+        PassPolicy::Required
     }
 }

compiler/rustc_mir_transform/src/add_call_guards.rs

@@ -21,6 +21,8 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 use tracing::debug;
 
+use crate::PassPolicy;
+
 #[derive(PartialEq)]
 pub(super) enum AddCallGuards {
     AllCallEdges,
@@ -127,8 +129,10 @@ impl<'tcx> crate::MirPass<'tcx> for AddCallGuards {
         basic_blocks.extend(new_blocks);
     }
 
-    fn is_required(&self) -> bool {
-        true
+    fn policy(&self, _sess: &rustc_session::Session) -> PassPolicy {
+        // Breaks critical edges so codegen can place edge-specific actions without affecting
+        // other control-flow edges.
+        PassPolicy::Required
     }
 }
 

compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs

@@ -4,7 +4,7 @@ use rustc_middle::ty::{self, TyCtxt};
 use tracing::debug;
 
 use crate::patch::MirPatch;
-use crate::util;
+use crate::{PassPolicy, util};
 
 /// This pass moves values being dropped that are within a packed
 /// struct to a separate local before dropping them, to ensure that
@@ -70,8 +70,9 @@ impl<'tcx> crate::MirPass<'tcx> for AddMovesForPackedDrops {
         patch.apply(body);
     }
 
-    fn is_required(&self) -> bool {
-        true
+    fn policy(&self, _sess: &rustc_session::Session) -> PassPolicy {
+        // Implements part of MIR semantics by making implicit packed-drop handling explicit.
+        PassPolicy::Required
     }
 }
 

compiler/rustc_mir_transform/src/add_subtyping_projections.rs

@@ -2,6 +2,7 @@ use rustc_middle::mir::visit::MutVisitor;
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 
+use crate::PassPolicy;
 use crate::patch::MirPatch;
 
 pub(super) struct Subtyper;
@@ -65,7 +66,8 @@ impl<'tcx> crate::MirPass<'tcx> for Subtyper {
         checker.patcher.apply(body);
     }
 
-    fn is_required(&self) -> bool {
-        true
+    fn policy(&self, _sess: &rustc_session::Session) -> PassPolicy {
+        // FIXME: Why is this okay? (The pass is also lacking a proper module-level description.)
+        PassPolicy::Required
     }
 }

compiler/rustc_mir_transform/src/check_alignment.rs

@@ -7,13 +7,15 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::{Ty, TyCtxt};
 use rustc_session::Session;
 
+use crate::PassPolicy;
 use crate::check_pointers::{BorrowedFieldProjectionMode, PointerCheck, check_pointers};
 
 pub(super) struct CheckAlignment;
 
 impl<'tcx> crate::MirPass<'tcx> for CheckAlignment {
-    fn is_enabled(&self, sess: &Session) -> bool {
-        sess.ub_checks()
+    fn policy(&self, sess: &Session) -> PassPolicy {
+        // When UB checks are enabled this is part of their semantics, not an optimization.
+        PassPolicy::optional(sess.ub_checks())
     }
 
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
@@ -31,10 +33,6 @@ impl<'tcx> crate::MirPass<'tcx> for CheckAlignment {
             BorrowedFieldProjectionMode::FollowProjections,
         );
     }
-
-    fn is_required(&self) -> bool {
-        true
-    }
 }
 
 /// Inserts the actual alignment check's logic. Returns a

compiler/rustc_mir_transform/src/check_enums.rs

@@ -10,14 +10,17 @@ use rustc_middle::ty::{self, Ty, TyCtxt, TypingEnv};
 use rustc_session::Session;
 use tracing::debug;
 
+use crate::PassPolicy;
+
 /// This pass inserts checks for a valid enum discriminant where they are most
 /// likely to find UB, because checking everywhere like Miri would generate too
 /// much MIR.
 pub(super) struct CheckEnums;
 
 impl<'tcx> crate::MirPass<'tcx> for CheckEnums {
-    fn is_enabled(&self, sess: &Session) -> bool {
-        sess.ub_checks()
+    fn policy(&self, sess: &Session) -> PassPolicy {
+        // When UB checks are enabled this is part of their semantics, not an optimization.
+        PassPolicy::optional(sess.ub_checks())
     }
 
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
@@ -109,10 +112,6 @@ impl<'tcx> crate::MirPass<'tcx> for CheckEnums {
             }
         }
     }
-
-    fn is_required(&self) -> bool {
-        true
-    }
 }
 
 /// Represent the different kind of enum checks we can insert.

compiler/rustc_mir_transform/src/check_null.rs

@@ -5,13 +5,15 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::{Ty, TyCtxt};
 use rustc_session::Session;
 
+use crate::PassPolicy;
 use crate::check_pointers::{BorrowedFieldProjectionMode, PointerCheck, check_pointers};
 
 pub(super) struct CheckNull;
 
 impl<'tcx> crate::MirPass<'tcx> for CheckNull {
-    fn is_enabled(&self, sess: &Session) -> bool {
-        sess.ub_checks()
+    fn policy(&self, sess: &Session) -> PassPolicy {
+        // When UB checks are enabled this is part of their semantics, not an optimization.
+        PassPolicy::optional(sess.ub_checks())
     }
 
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
@@ -23,10 +25,6 @@ impl<'tcx> crate::MirPass<'tcx> for CheckNull {
             BorrowedFieldProjectionMode::NoFollowProjections,
         );
     }
-
-    fn is_required(&self) -> bool {
-        true
-    }
 }
 
 fn insert_null_check<'tcx>(

compiler/rustc_mir_transform/src/cleanup_post_borrowck.rs

@@ -21,6 +21,8 @@ use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::adjustment::PointerCoercion;
 
+use crate::PassPolicy;
+
 pub(super) struct CleanupPostBorrowck;
 
 impl<'tcx> crate::MirPass<'tcx> for CleanupPostBorrowck {
@@ -85,7 +87,8 @@ impl<'tcx> crate::MirPass<'tcx> for CleanupPostBorrowck {
         }
     }
 
-    fn is_required(&self) -> bool {
-        true
+    fn policy(&self, _sess: &rustc_session::Session) -> PassPolicy {
+        // Removes administrative MIR instructions that later passes must never see.
+        PassPolicy::Required
     }
 }

compiler/rustc_mir_transform/src/copy_prop.rs

@@ -6,6 +6,7 @@ use rustc_middle::ty::TyCtxt;
 use rustc_mir_dataflow::{Analysis, ResultsCursor};
 use tracing::{debug, instrument};
 
+use crate::PassPolicy;
 use crate::ssa::{MaybeUninitializedLocals, SsaLocals};
 
 /// Unify locals that copy each other.
@@ -21,8 +22,8 @@ use crate::ssa::{MaybeUninitializedLocals, SsaLocals};
 pub(super) struct CopyProp;
 
 impl<'tcx> crate::MirPass<'tcx> for CopyProp {
-    fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
-        sess.mir_opt_level() >= 1
+    fn policy(&self, sess: &rustc_session::Session) -> PassPolicy {
+        PassPolicy::optimization(sess.mir_opt_level() >= 1)
     }
 
     #[instrument(level = "trace", skip(self, tcx, body))]
@@ -95,10 +96,6 @@ impl<'tcx> crate::MirPass<'tcx> for CopyProp {
 
         crate::simplify::remove_unused_definitions(body);
     }
-
-    fn is_required(&self) -> bool {
-        false
-    }
 }
 
 /// Utility to help performing substitution: for all key-value pairs in `copy_classes`,

compiler/rustc_mir_transform/src/coroutine/mod.rs

@@ -80,7 +80,7 @@ use tracing::{debug, instrument};
 
 use crate::deref_separator::deref_finder;
 use crate::patch::MirPatch;
-use crate::{abort_unwinding_calls, pass_manager as pm, simplify};
+use crate::{PassPolicy, abort_unwinding_calls, pass_manager as pm, simplify};
 
 pub(super) struct StateTransform;
 
@@ -1219,8 +1219,9 @@ impl<'tcx> crate::MirPass<'tcx> for StateTransform {
         create_coroutine_resume_function(tcx, transform, body, can_return, can_unwind);
     }
 
-    fn is_required(&self) -> bool {
-        true
+    fn policy(&self, _sess: &rustc_session::Session) -> PassPolicy {
+        // Implements coroutine semantics by lowering the coroutine body to a state machine.
+        PassPolicy::Required
     }
 }