apply suggestions and fix bitset subtraction

compiler/rustc_codegen_ssa/src/mir/statement.rs

@@ -92,8 +92,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             | mir::StatementKind::AscribeUserType(..)
             | mir::StatementKind::ConstEvalCounter
             | mir::StatementKind::PlaceMention(..)
-            | mir::StatementKind::Nop
-            | mir::StatementKind::BackwardIncompatibleDropHint { .. } => {}
+            | mir::StatementKind::BackwardIncompatibleDropHint { .. }
+            | mir::StatementKind::Nop => {}
         }
     }
 }

compiler/rustc_hir_analysis/src/check/region.rs

@@ -178,9 +178,10 @@ fn resolve_block<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, blk: &'tcx h
                     (lint::Level::Allow, _)
                 )
             {
-                // Note: we are unconditionally adding this information so that we can run
-                // migration for Edition lower than 2024.
-                // For future scope changes, we need to extend the mapping with edition information.
+                // If this temporary scope will be changing once the codebase adopts Rust 2024,
+                // and we are linting about possible semantic changes that would result,
+                // then record this node-id in the field `backwards_incompatible_scope`
+                // for future reference.
                 visitor
                     .scope_tree
                     .backwards_incompatible_scope

compiler/rustc_index/src/bit_set.rs

@@ -680,12 +680,14 @@ impl<T: Idx> BitRelations<ChunkedBitSet<T>> for ChunkedBitSet<T> {
         for (mut self_chunk, other_chunk) in self.chunks.iter_mut().zip(other.chunks.iter()) {
             match (&mut self_chunk, &other_chunk) {
                 (Zeros(..), _) | (_, Zeros(..)) => {}
-                (Ones(self_chunk_domain_size), Ones(other_chunk_domain_size)) => {
+                (
+                    Ones(self_chunk_domain_size) | Mixed(self_chunk_domain_size, _, _),
+                    Ones(other_chunk_domain_size),
+                ) => {
                     debug_assert_eq!(self_chunk_domain_size, other_chunk_domain_size);
                     changed = true;
                     *self_chunk = Zeros(*self_chunk_domain_size);
                 }
-                (_, Ones(_)) => {}
                 (
                     Ones(self_chunk_domain_size),
                     Mixed(other_chunk_domain_size, other_chunk_count, other_chunk_words),

compiler/rustc_middle/src/arena.rs

@@ -114,7 +114,6 @@ macro_rules! arena_types {
             [decode] specialization_graph: rustc_middle::traits::specialization_graph::Graph,
             [] crate_inherent_impls: rustc_middle::ty::CrateInherentImpls,
             [] hir_owner_nodes: rustc_hir::OwnerNodes<'tcx>,
-            [] hir_id_set: rustc_hir::HirIdSet,
         ]);
     )
 }

compiler/rustc_middle/src/mir/syntax.rs

@@ -441,7 +441,11 @@ pub enum StatementKind<'tcx> {
     /// No-op. Useful for deleting instructions without affecting statement indices.
     Nop,
 
-    /// Marker statement for backward-incompatible drops in incoming future editions
+    /// Marker statement for backward-incompatible drops in incoming future editions.
+    /// This is semantically equivalent to `Nop`, so codegen and MIRI should interpret this
+    /// statement as such.
+    /// The only use case of this statement is for linting in MIR to detect temporary lifetime
+    /// changes.
     BackwardIncompatibleDropHint {
         /// Place to drop
         place: Box<Place<'tcx>>,

compiler/rustc_middle/src/thir.rs

@@ -259,7 +259,8 @@ pub struct TempLifetime {
     /// Lifetime for temporaries as expected.
     /// This should be `None` in a constant context.
     pub temp_lifetime: Option<region::Scope>,
-    /// Backward-incompatible lifetime for future editions
+    /// If `Some(lt)`, indicates that the lifetime of this temporary will change to `lt` in a future edition.
+    /// If `None`, then no changes are expected, or lints are disabled.
     pub backwards_incompatible: Option<region::Scope>,
 }
 

compiler/rustc_middle/src/ty/rvalue_scopes.rs

@@ -53,6 +53,10 @@ impl RvalueScopes {
                 | ScopeData::Arguments
                 | ScopeData::IfThen
                 | ScopeData::Remainder(_) => {
+                    // If we haven't already passed through a backwards-incompatible node,
+                    // then check if we are passing through one now and record it if so.
+                    // This is for now only working for cases where a temporary lifetime is
+                    // *shortened*.
                     if backwards_incompatible.is_none() {
                         backwards_incompatible = region_scope_tree
                             .backwards_incompatible_scope

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -264,7 +264,6 @@ TrivialTypeTraversalImpls! {
 // interners).
 TrivialTypeTraversalAndLiftImpls! {
     ::rustc_hir::def_id::DefId,
-    ::rustc_hir::hir_id::ItemLocalId,
     ::rustc_hir::Safety,
     ::rustc_target::spec::abi::Abi,
     crate::ty::ClosureKind,

compiler/rustc_mir_dataflow/src/value_analysis.rs

@@ -93,8 +93,8 @@ pub trait ValueAnalysis<'tcx> {
             | StatementKind::FakeRead(..)
             | StatementKind::PlaceMention(..)
             | StatementKind::Coverage(..)
-            | StatementKind::AscribeUserType(..)
-            | StatementKind::BackwardIncompatibleDropHint { .. } => (),
+            | StatementKind::BackwardIncompatibleDropHint { .. }
+            | StatementKind::AscribeUserType(..) => {}
         }
     }