rustc_mir_transform: Enforce rustc::potential_query_instability lint

Stop allowing `rustc::potential_query_instability` on all of
rustc_mir_transform and instead allow it on a case-by-case basis if it
is safe to do so. In this particular crate, all instances were safe to
allow.

Author: Enselic

compiler/rustc_mir_transform/src/const_prop.rs

@@ -806,6 +806,8 @@ impl<'tcx> Visitor<'tcx> for ConstPropagator<'_, 'tcx> {
         // This loop can get very hot for some bodies: it check each local in each bb.
         // To avoid this quadratic behaviour, we only clear the locals that were modified inside
         // the current block.
+        // The order in which we remove constness does not matter.
+        #[allow(rustc::potential_query_instability)]
         for local in written_only_inside_own_block_locals.drain() {
             debug_assert_eq!(
                 self.ecx.machine.can_const_prop[local],

compiler/rustc_mir_transform/src/const_prop_lint.rs

@@ -670,6 +670,8 @@ impl<'tcx> Visitor<'tcx> for ConstPropagator<'_, 'tcx> {
         // This loop can get very hot for some bodies: it check each local in each bb.
         // To avoid this quadratic behaviour, we only clear the locals that were modified inside
         // the current block.
+        // The order in which we remove constness does not matter.
+        #[allow(rustc::potential_query_instability)]
         for local in written_only_inside_own_block_locals.drain() {
             debug_assert_eq!(
                 self.ecx.machine.can_const_prop[local],

compiler/rustc_mir_transform/src/coverage/counters.rs

@@ -181,6 +181,8 @@ impl CoverageCounters {
     pub(super) fn bcb_edge_counters(
         &self,
     ) -> impl Iterator<Item = (BasicCoverageBlock, BasicCoverageBlock, &BcbCounter)> {
+        // The contract of bcb_edge_counters() makes no guarantees about ordering.
+        #[allow(rustc::potential_query_instability)]
         self.bcb_edge_counters
             .iter()
             .map(|(&(from_bcb, to_bcb), counter_kind)| (from_bcb, to_bcb, counter_kind))

compiler/rustc_mir_transform/src/dest_prop.rs

@@ -214,6 +214,9 @@ impl<'tcx> MirPass<'tcx> for DestinationPropagation {
             // This is the set of merges we will apply this round. It is a subset of the candidates.
             let mut merges = FxHashMap::default();
 
+            // We put iterated entires into `merges` (another map) and
+            // `merged_locals` (a set), so the insertion order does not matter.
+            #[allow(rustc::potential_query_instability)]
             for (src, candidates) in candidates.c.iter() {
                 if merged_locals.contains(*src) {
                     continue;
@@ -736,11 +739,15 @@ fn find_candidates<'alloc, 'tcx>(
     let mut visitor = FindAssignments { body, candidates, borrowed };
     visitor.visit_body(body);
     // Deduplicate candidates
+    // The order in which we dedup does not matter.
+    #[allow(rustc::potential_query_instability)]
     for (_, cands) in candidates.iter_mut() {
         cands.sort();
         cands.dedup();
     }
     // Generate the reverse map
+    // `candidates_reverse` is another map, so the order does not matter.
+    #[allow(rustc::potential_query_instability)]
     for (src, cands) in candidates.iter() {
         for dest in cands.iter().copied() {
             candidates_reverse.entry(dest).or_default().push(*src);

compiler/rustc_mir_transform/src/lib.rs

@@ -1,4 +1,3 @@
-#![allow(rustc::potential_query_instability)]
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
 #![feature(box_patterns)]

compiler/rustc_mir_transform/src/unreachable_prop.rs

@@ -54,6 +54,8 @@ impl MirPass<'_> for UnreachablePropagation {
         patch.apply(body);
 
         // We do want do keep some unreachable blocks, but make them empty.
+        // The order in which we clear bb statements does not matter.
+        #[allow(rustc::potential_query_instability)]
         for bb in unreachable_blocks {
             body.basic_blocks_mut()[bb].statements.clear();
         }