Stop using the gen keyword in the compiler

compiler-errors · compiler-errors · commit dc207339137a · 2024-07-14T14:01:01.000-04:00
diff --git a/compiler/rustc_borrowck/src/dataflow.rs b/compiler/rustc_borrowck/src/dataflow.rs
@@ -553,7 +553,7 @@ impl<'tcx> rustc_mir_dataflow::GenKillAnalysis<'tcx> for Borrows<'_, '_, 'tcx> {
                         panic!("could not find BorrowIndex for location {location:?}");
                     });
 
-                    trans.gen(index);
+                    trans.gen_(index);
                 }
 
                 // Make sure there are no remaining borrows for variables
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -3218,10 +3218,10 @@ impl<'hir> Item<'hir> {
             ItemKind::Static(ty, mutbl, body), (ty, *mutbl, *body);
 
         expect_const, (&'hir Ty<'hir>, &'hir Generics<'hir>, BodyId),
-            ItemKind::Const(ty, gen, body), (ty, gen, *body);
+            ItemKind::Const(ty, generics, body), (ty, generics, *body);
 
         expect_fn, (&FnSig<'hir>, &'hir Generics<'hir>, BodyId),
-            ItemKind::Fn(sig, gen, body), (sig, gen, *body);
+            ItemKind::Fn(sig, generics, body), (sig, generics, *body);
 
         expect_macro, (&ast::MacroDef, MacroKind), ItemKind::Macro(def, mk), (def, *mk);
 
@@ -3233,25 +3233,25 @@ impl<'hir> Item<'hir> {
         expect_global_asm, &'hir InlineAsm<'hir>, ItemKind::GlobalAsm(asm), asm;
 
         expect_ty_alias, (&'hir Ty<'hir>, &'hir Generics<'hir>),
-            ItemKind::TyAlias(ty, gen), (ty, gen);
+            ItemKind::TyAlias(ty, generics), (ty, generics);
 
         expect_opaque_ty, &OpaqueTy<'hir>, ItemKind::OpaqueTy(ty), ty;
 
-        expect_enum, (&EnumDef<'hir>, &'hir Generics<'hir>), ItemKind::Enum(def, gen), (def, gen);
+        expect_enum, (&EnumDef<'hir>, &'hir Generics<'hir>), ItemKind::Enum(def, generics), (def, generics);
 
         expect_struct, (&VariantData<'hir>, &'hir Generics<'hir>),
-            ItemKind::Struct(data, gen), (data, gen);
+            ItemKind::Struct(data, generics), (data, generics);
 
         expect_union, (&VariantData<'hir>, &'hir Generics<'hir>),
-            ItemKind::Union(data, gen), (data, gen);
+            ItemKind::Union(data, generics), (data, generics);
 
         expect_trait,
             (IsAuto, Safety, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]),
-            ItemKind::Trait(is_auto, safety, gen, bounds, items),
-            (*is_auto, *safety, gen, bounds, items);
+            ItemKind::Trait(is_auto, safety, generics, bounds, items),
+            (*is_auto, *safety, generics, bounds, items);
 
         expect_trait_alias, (&'hir Generics<'hir>, GenericBounds<'hir>),
-            ItemKind::TraitAlias(gen, bounds), (gen, bounds);
+            ItemKind::TraitAlias(generics, bounds), (generics, bounds);
 
         expect_impl, &'hir Impl<'hir>, ItemKind::Impl(imp), imp;
     }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -2554,7 +2554,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         .and_then(|node| node.generics())
                         .into_iter()
                         .flat_map(|generics| generics.params)
-                        .find(|gen| &gen.def_id.to_def_id() == res_def_id)
+                        .find(|param| &param.def_id.to_def_id() == res_def_id)
                 } else {
                     None
                 }
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
@@ -1016,14 +1016,14 @@ macro_rules! extra_body_methods {
 macro_rules! super_body {
     ($self:ident, $body:ident, $($mutability:ident, $invalidate:tt)?) => {
         let span = $body.span;
-        if let Some(gen) = &$($mutability)? $body.coroutine {
-            if let Some(yield_ty) = $(& $mutability)? gen.yield_ty {
+        if let Some(coroutine) = &$($mutability)? $body.coroutine {
+            if let Some(yield_ty) = $(& $mutability)? coroutine.yield_ty {
                 $self.visit_ty(
                     yield_ty,
                     TyContext::YieldTy(SourceInfo::outermost(span))
                 );
             }
-            if let Some(resume_ty) = $(& $mutability)? gen.resume_ty {
+            if let Some(resume_ty) = $(& $mutability)? coroutine.resume_ty {
                 $self.visit_ty(
                     resume_ty,
                     TyContext::ResumeTy(SourceInfo::outermost(span))
diff --git a/compiler/rustc_mir_dataflow/src/framework/mod.rs b/compiler/rustc_mir_dataflow/src/framework/mod.rs
@@ -402,15 +402,15 @@ where
 /// building up a `GenKillSet` and then throwing it away.
 pub trait GenKill<T> {
     /// Inserts `elem` into the state vector.
-    fn gen(&mut self, elem: T);
+    fn gen_(&mut self, elem: T);
 
     /// Removes `elem` from the state vector.
     fn kill(&mut self, elem: T);
 
     /// Calls `gen` for each element in `elems`.
     fn gen_all(&mut self, elems: impl IntoIterator<Item = T>) {
         for elem in elems {
-            self.gen(elem);
+            self.gen_(elem);
         }
     }
 
@@ -424,44 +424,44 @@ pub trait GenKill<T> {
 
 /// Stores a transfer function for a gen/kill problem.
 ///
-/// Calling `gen`/`kill` on a `GenKillSet` will "build up" a transfer function so that it can be
-/// applied multiple times efficiently. When there are multiple calls to `gen` and/or `kill` for
+/// Calling `gen_`/`kill` on a `GenKillSet` will "build up" a transfer function so that it can be
+/// applied multiple times efficiently. When there are multiple calls to `gen_` and/or `kill` for
 /// the same element, the most recent one takes precedence.
 #[derive(Clone)]
 pub struct GenKillSet<T> {
-    gen: HybridBitSet<T>,
+    gen_: HybridBitSet<T>,
     kill: HybridBitSet<T>,
 }
 
 impl<T: Idx> GenKillSet<T> {
     /// Creates a new transfer function that will leave the dataflow state unchanged.
     pub fn identity(universe: usize) -> Self {
         GenKillSet {
-            gen: HybridBitSet::new_empty(universe),
+            gen_: HybridBitSet::new_empty(universe),
             kill: HybridBitSet::new_empty(universe),
         }
     }
 
     pub fn apply(&self, state: &mut impl BitSetExt<T>) {
-        state.union(&self.gen);
+        state.union(&self.gen_);
         state.subtract(&self.kill);
     }
 }
 
 impl<T: Idx> GenKill<T> for GenKillSet<T> {
-    fn gen(&mut self, elem: T) {
-        self.gen.insert(elem);
+    fn gen_(&mut self, elem: T) {
+        self.gen_.insert(elem);
         self.kill.remove(elem);
     }
 
     fn kill(&mut self, elem: T) {
         self.kill.insert(elem);
-        self.gen.remove(elem);
+        self.gen_.remove(elem);
     }
 }
 
 impl<T: Idx> GenKill<T> for BitSet<T> {
-    fn gen(&mut self, elem: T) {
+    fn gen_(&mut self, elem: T) {
         self.insert(elem);
     }
 
@@ -471,7 +471,7 @@ impl<T: Idx> GenKill<T> for BitSet<T> {
 }
 
 impl<T: Idx> GenKill<T> for ChunkedBitSet<T> {
-    fn gen(&mut self, elem: T) {
+    fn gen_(&mut self, elem: T) {
         self.insert(elem);
     }
 
@@ -481,11 +481,11 @@ impl<T: Idx> GenKill<T> for ChunkedBitSet<T> {
 }
 
 impl<T, S: GenKill<T>> GenKill<T> for MaybeReachable<S> {
-    fn gen(&mut self, elem: T) {
+    fn gen_(&mut self, elem: T) {
         match self {
             // If the state is not reachable, adding an element does nothing.
             MaybeReachable::Unreachable => {}
-            MaybeReachable::Reachable(set) => set.gen(elem),
+            MaybeReachable::Reachable(set) => set.gen_(elem),
         }
     }
 
@@ -499,7 +499,7 @@ impl<T, S: GenKill<T>> GenKill<T> for MaybeReachable<S> {
 }
 
 impl<T: Idx> GenKill<T> for lattice::Dual<BitSet<T>> {
-    fn gen(&mut self, elem: T) {
+    fn gen_(&mut self, elem: T) {
         self.0.insert(elem);
     }
 
diff --git a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
@@ -97,7 +97,7 @@ where
             Rvalue::AddressOf(_, borrowed_place)
             | Rvalue::Ref(_, BorrowKind::Mut { .. } | BorrowKind::Shared, borrowed_place) => {
                 if !borrowed_place.is_indirect() {
-                    self.trans.gen(borrowed_place.local);
+                    self.trans.gen_(borrowed_place.local);
                 }
             }
 
@@ -131,7 +131,7 @@ where
                 //
                 // [#61069]: https://github.com/rust-lang/rust/pull/61069
                 if !dropped_place.is_indirect() {
-                    self.trans.gen(dropped_place.local);
+                    self.trans.gen_(dropped_place.local);
                 }
             }
 
@@ -159,8 +159,8 @@ pub fn borrowed_locals(body: &Body<'_>) -> BitSet<Local> {
 
     impl GenKill<Local> for Borrowed {
         #[inline]
-        fn gen(&mut self, elem: Local) {
-            self.0.gen(elem)
+        fn gen_(&mut self, elem: Local) {
+            self.0.gen_(elem)
         }
         #[inline]
         fn kill(&mut self, _: Local) {
diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
@@ -283,7 +283,7 @@ impl<'a, 'mir, 'tcx> MaybeInitializedPlaces<'a, 'mir, 'tcx> {
     ) {
         match state {
             DropFlagState::Absent => trans.kill(path),
-            DropFlagState::Present => trans.gen(path),
+            DropFlagState::Present => trans.gen_(path),
         }
     }
 }
@@ -295,7 +295,7 @@ impl<'a, 'tcx> MaybeUninitializedPlaces<'a, '_, 'tcx> {
         state: DropFlagState,
     ) {
         match state {
-            DropFlagState::Absent => trans.gen(path),
+            DropFlagState::Absent => trans.gen_(path),
             DropFlagState::Present => trans.kill(path),
         }
     }
@@ -309,7 +309,7 @@ impl<'a, 'tcx> DefinitelyInitializedPlaces<'a, 'tcx> {
     ) {
         match state {
             DropFlagState::Absent => trans.kill(path),
-            DropFlagState::Present => trans.gen(path),
+            DropFlagState::Present => trans.gen_(path),
         }
     }
 }
@@ -331,7 +331,7 @@ impl<'tcx> AnalysisDomain<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> {
             MaybeReachable::Reachable(ChunkedBitSet::new_empty(self.move_data().move_paths.len()));
         drop_flag_effects_for_function_entry(self.body, self.mdpe, |path, s| {
             assert!(s == DropFlagState::Present);
-            state.gen(path);
+            state.gen_(path);
         });
     }
 }
@@ -362,7 +362,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> {
             && let LookupResult::Exact(mpi) = self.move_data().rev_lookup.find(place.as_ref())
         {
             on_all_children_bits(self.move_data(), mpi, |child| {
-                trans.gen(child);
+                trans.gen_(child);
             })
         }
     }
@@ -400,7 +400,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> {
                 self.move_data(),
                 self.move_data().rev_lookup.find(place.as_ref()),
                 |mpi| {
-                    trans.gen(mpi);
+                    trans.gen_(mpi);
                 },
             );
         });
@@ -572,7 +572,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeUninitializedPlaces<'_, '_, 'tcx> {
                 self.move_data(),
                 enum_place,
                 variant,
-                |mpi| trans.gen(mpi),
+                |mpi| trans.gen_(mpi),
             );
         });
     }
@@ -643,7 +643,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for DefinitelyInitializedPlaces<'_, 'tcx> {
                 self.move_data(),
                 self.move_data().rev_lookup.find(place.as_ref()),
                 |mpi| {
-                    trans.gen(mpi);
+                    trans.gen_(mpi);
                 },
             );
         });
@@ -738,7 +738,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for EverInitializedPlaces<'_, '_, 'tcx> {
 
         let call_loc = self.body.terminator_loc(block);
         for init_index in &init_loc_map[call_loc] {
-            trans.gen(*init_index);
+            trans.gen_(*init_index);
         }
     }
 }
diff --git a/compiler/rustc_mir_dataflow/src/impls/liveness.rs b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
@@ -116,7 +116,7 @@ where
                     self.0.kill(place.local);
                 }
             }
-            Some(DefUse::Use) => self.0.gen(place.local),
+            Some(DefUse::Use) => self.0.gen_(place.local),
             None => {}
         }
 
@@ -154,7 +154,7 @@ impl DefUse {
     fn apply(trans: &mut impl GenKill<Local>, place: Place<'_>, context: PlaceContext) {
         match DefUse::for_place(place, context) {
             Some(DefUse::Def) => trans.kill(place.local),
-            Some(DefUse::Use) => trans.gen(place.local),
+            Some(DefUse::Use) => trans.gen_(place.local),
             None => {}
         }
     }
diff --git a/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs b/compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs
@@ -54,7 +54,7 @@ impl<'tcx, 'a> crate::GenKillAnalysis<'tcx> for MaybeStorageLive<'a> {
         _: Location,
     ) {
         match stmt.kind {
-            StatementKind::StorageLive(l) => trans.gen(l),
+            StatementKind::StorageLive(l) => trans.gen_(l),
             StatementKind::StorageDead(l) => trans.kill(l),
             _ => (),
         }
@@ -127,7 +127,7 @@ impl<'tcx, 'a> crate::GenKillAnalysis<'tcx> for MaybeStorageDead<'a> {
     ) {
         match stmt.kind {
             StatementKind::StorageLive(l) => trans.kill(l),
-            StatementKind::StorageDead(l) => trans.gen(l),
+            StatementKind::StorageDead(l) => trans.gen_(l),
             _ => (),
         }
     }
@@ -208,7 +208,7 @@ impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {
             StatementKind::Assign(box (place, _))
             | StatementKind::SetDiscriminant { box place, .. }
             | StatementKind::Deinit(box place) => {
-                trans.gen(place.local);
+                trans.gen_(place.local);
             }
 
             // Nothing to do for these. Match exhaustively so this fails to compile when new
@@ -250,7 +250,7 @@ impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {
 
         match &terminator.kind {
             TerminatorKind::Call { destination, .. } => {
-                trans.gen(destination.local);
+                trans.gen_(destination.local);
             }
 
             // Note that we do *not* gen the `resume_arg` of `Yield` terminators. The reason for
@@ -265,7 +265,7 @@ impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {
                         InlineAsmOperand::Out { place, .. }
                         | InlineAsmOperand::InOut { out_place: place, .. } => {
                             if let Some(place) = place {
-                                trans.gen(place.local);
+                                trans.gen_(place.local);
                             }
                         }
                         InlineAsmOperand::In { .. }
@@ -341,7 +341,7 @@ impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {
         _block: BasicBlock,
         return_places: CallReturnPlaces<'_, 'tcx>,
     ) {
-        return_places.for_each(|place| trans.gen(place.local));
+        return_places.for_each(|place| trans.gen_(place.local));
     }
 }
 
diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs
@@ -1998,6 +1998,9 @@ impl<'a> Builder<'a> {
         if mode == Mode::Rustc {
             rustflags.arg("-Zunstable-options");
             rustflags.arg("-Wrustc::internal");
+            // FIXME(edition_2024): Change this to `-Wrust_2018_idioms` when all
+            // of the individual lints are satisfied.
+            rustflags.arg("-Wkeyword_idents_2024");
         }
 
         if self.config.rust_frame_pointers {

Original file line number	Diff line number	Diff line change
`@@ -553,7 +553,7 @@ impl<'tcx> rustc_mir_dataflow::GenKillAnalysis<'tcx> for Borrows<'_, '_, 'tcx> {`
`553`	`553`	`panic!("could not find BorrowIndex for location {location:?}");`
`554`	`554`	`});`
`555`	`555`
`556`		`- trans.gen(index);`
	`556`	`+ trans.gen_(index);`
`557`	`557`	`}`
`558`	`558`
`559`	`559`	`// Make sure there are no remaining borrows for variables`
Original file line number	Diff line number	Diff line change
`@@ -2554,7 +2554,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`2554`	`2554`	`.and_then(\|node\| node.generics())`
`2555`	`2555`	`.into_iter()`
`2556`	`2556`	`.flat_map(\|generics\| generics.params)`
`2557`		`- .find(\|gen\| &gen.def_id.to_def_id() == res_def_id)`
	`2557`	`+ .find(\|param\| &param.def_id.to_def_id() == res_def_id)`
`2558`	`2558`	`} else {`
`2559`	`2559`	`None`
`2560`	`2560`	`}`
Original file line number	Diff line number	Diff line change
`@@ -402,15 +402,15 @@ where`
`402`	`402`	/// building up a `GenKillSet` and then throwing it away.
`403`	`403`	`pub trait GenKill<T> {`
`404`	`404`	/// Inserts `elem` into the state vector.
`405`		`- fn gen(&mut self, elem: T);`
	`405`	`+ fn gen_(&mut self, elem: T);`
`406`	`406`
`407`	`407`	/// Removes `elem` from the state vector.
`408`	`408`	`fn kill(&mut self, elem: T);`
`409`	`409`
`410`	`410`	/// Calls `gen` for each element in `elems`.
`411`	`411`	`fn gen_all(&mut self, elems: impl IntoIterator<Item = T>) {`
`412`	`412`	`for elem in elems {`
`413`		`- self.gen(elem);`
	`413`	`+ self.gen_(elem);`
`414`	`414`	`}`
`415`	`415`	`}`
`416`	`416`
`@@ -424,44 +424,44 @@ pub trait GenKill<T> {`
`424`	`424`
`425`	`425`	`/// Stores a transfer function for a gen/kill problem.`
`426`	`426`	`///`
`427`		-/// Calling `gen`/`kill` on a `GenKillSet` will "build up" a transfer function so that it can be
`428`		-/// applied multiple times efficiently. When there are multiple calls to `gen` and/or `kill` for
	`427`	+/// Calling `gen_`/`kill` on a `GenKillSet` will "build up" a transfer function so that it can be
	`428`	+/// applied multiple times efficiently. When there are multiple calls to `gen_` and/or `kill` for
`429`	`429`	`/// the same element, the most recent one takes precedence.`
`430`	`430`	`#[derive(Clone)]`
`431`	`431`	`pub struct GenKillSet<T> {`
`432`		`- gen: HybridBitSet<T>,`
	`432`	`+ gen_: HybridBitSet<T>,`
`433`	`433`	`kill: HybridBitSet<T>,`
`434`	`434`	`}`
`435`	`435`
`436`	`436`	`impl<T: Idx> GenKillSet<T> {`
`437`	`437`	`/// Creates a new transfer function that will leave the dataflow state unchanged.`
`438`	`438`	`pub fn identity(universe: usize) -> Self {`
`439`	`439`	`GenKillSet {`
`440`		`- gen: HybridBitSet::new_empty(universe),`
	`440`	`+ gen_: HybridBitSet::new_empty(universe),`
`441`	`441`	`kill: HybridBitSet::new_empty(universe),`
`442`	`442`	`}`
`443`	`443`	`}`
`444`	`444`
`445`	`445`	`pub fn apply(&self, state: &mut impl BitSetExt<T>) {`
`446`		`- state.union(&self.gen);`
	`446`	`+ state.union(&self.gen_);`
`447`	`447`	`state.subtract(&self.kill);`
`448`	`448`	`}`
`449`	`449`	`}`
`450`	`450`
`451`	`451`	`impl<T: Idx> GenKill<T> for GenKillSet<T> {`
`452`		`- fn gen(&mut self, elem: T) {`
`453`		`- self.gen.insert(elem);`
	`452`	`+ fn gen_(&mut self, elem: T) {`
	`453`	`+ self.gen_.insert(elem);`
`454`	`454`	`self.kill.remove(elem);`
`455`	`455`	`}`
`456`	`456`
`457`	`457`	`fn kill(&mut self, elem: T) {`
`458`	`458`	`self.kill.insert(elem);`
`459`		`- self.gen.remove(elem);`
	`459`	`+ self.gen_.remove(elem);`
`460`	`460`	`}`
`461`	`461`	`}`
`462`	`462`
`463`	`463`	`impl<T: Idx> GenKill<T> for BitSet<T> {`
`464`		`- fn gen(&mut self, elem: T) {`
	`464`	`+ fn gen_(&mut self, elem: T) {`
`465`	`465`	`self.insert(elem);`
`466`	`466`	`}`
`467`	`467`
`@@ -471,7 +471,7 @@ impl<T: Idx> GenKill<T> for BitSet<T> {`
`471`	`471`	`}`
`472`	`472`
`473`	`473`	`impl<T: Idx> GenKill<T> for ChunkedBitSet<T> {`
`474`		`- fn gen(&mut self, elem: T) {`
	`474`	`+ fn gen_(&mut self, elem: T) {`
`475`	`475`	`self.insert(elem);`
`476`	`476`	`}`
`477`	`477`
`@@ -481,11 +481,11 @@ impl<T: Idx> GenKill<T> for ChunkedBitSet<T> {`
`481`	`481`	`}`
`482`	`482`
`483`	`483`	`impl<T, S: GenKill<T>> GenKill<T> for MaybeReachable<S> {`
`484`		`- fn gen(&mut self, elem: T) {`
	`484`	`+ fn gen_(&mut self, elem: T) {`
`485`	`485`	`match self {`
`486`	`486`	`// If the state is not reachable, adding an element does nothing.`
`487`	`487`	`MaybeReachable::Unreachable => {}`
`488`		`- MaybeReachable::Reachable(set) => set.gen(elem),`
	`488`	`+ MaybeReachable::Reachable(set) => set.gen_(elem),`
`489`	`489`	`}`
`490`	`490`	`}`
`491`	`491`
`@@ -499,7 +499,7 @@ impl<T, S: GenKill<T>> GenKill<T> for MaybeReachable<S> {`
`499`	`499`	`}`
`500`	`500`
`501`	`501`	`impl<T: Idx> GenKill<T> for lattice::Dual<BitSet<T>> {`
`502`		`- fn gen(&mut self, elem: T) {`
	`502`	`+ fn gen_(&mut self, elem: T) {`
`503`	`503`	`self.0.insert(elem);`
`504`	`504`	`}`
`505`	`505`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ where`
`97`	`97`	`Rvalue::AddressOf(_, borrowed_place)`
`98`	`98`	`\| Rvalue::Ref(_, BorrowKind::Mut { .. } \| BorrowKind::Shared, borrowed_place) => {`
`99`	`99`	`if !borrowed_place.is_indirect() {`
`100`		`- self.trans.gen(borrowed_place.local);`
	`100`	`+ self.trans.gen_(borrowed_place.local);`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`@@ -131,7 +131,7 @@ where`
`131`	`131`	`//`
`132`	`132`	`// [#61069]: https://github.com/rust-lang/rust/pull/61069`
`133`	`133`	`if !dropped_place.is_indirect() {`
`134`		`- self.trans.gen(dropped_place.local);`
	`134`	`+ self.trans.gen_(dropped_place.local);`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`
`@@ -159,8 +159,8 @@ pub fn borrowed_locals(body: &Body<'_>) -> BitSet<Local> {`
`159`	`159`
`160`	`160`	`impl GenKill<Local> for Borrowed {`
`161`	`161`	`#[inline]`
`162`		`- fn gen(&mut self, elem: Local) {`
`163`		`- self.0.gen(elem)`
	`162`	`+ fn gen_(&mut self, elem: Local) {`
	`163`	`+ self.0.gen_(elem)`
`164`	`164`	`}`
`165`	`165`	`#[inline]`
`166`	`166`	`fn kill(&mut self, _: Local) {`
Original file line number	Diff line number	Diff line change
`@@ -283,7 +283,7 @@ impl<'a, 'mir, 'tcx> MaybeInitializedPlaces<'a, 'mir, 'tcx> {`
`283`	`283`	`) {`
`284`	`284`	`match state {`
`285`	`285`	`DropFlagState::Absent => trans.kill(path),`
`286`		`- DropFlagState::Present => trans.gen(path),`
	`286`	`+ DropFlagState::Present => trans.gen_(path),`
`287`	`287`	`}`
`288`	`288`	`}`
`289`	`289`	`}`
`@@ -295,7 +295,7 @@ impl<'a, 'tcx> MaybeUninitializedPlaces<'a, '_, 'tcx> {`
`295`	`295`	`state: DropFlagState,`
`296`	`296`	`) {`
`297`	`297`	`match state {`
`298`		`- DropFlagState::Absent => trans.gen(path),`
	`298`	`+ DropFlagState::Absent => trans.gen_(path),`
`299`	`299`	`DropFlagState::Present => trans.kill(path),`
`300`	`300`	`}`
`301`	`301`	`}`
`@@ -309,7 +309,7 @@ impl<'a, 'tcx> DefinitelyInitializedPlaces<'a, 'tcx> {`
`309`	`309`	`) {`
`310`	`310`	`match state {`
`311`	`311`	`DropFlagState::Absent => trans.kill(path),`
`312`		`- DropFlagState::Present => trans.gen(path),`
	`312`	`+ DropFlagState::Present => trans.gen_(path),`
`313`	`313`	`}`
`314`	`314`	`}`
`315`	`315`	`}`
`@@ -331,7 +331,7 @@ impl<'tcx> AnalysisDomain<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> {`
`331`	`331`	`MaybeReachable::Reachable(ChunkedBitSet::new_empty(self.move_data().move_paths.len()));`
`332`	`332`	`drop_flag_effects_for_function_entry(self.body, self.mdpe, \|path, s\| {`
`333`	`333`	`assert!(s == DropFlagState::Present);`
`334`		`- state.gen(path);`
	`334`	`+ state.gen_(path);`
`335`	`335`	`});`
`336`	`336`	`}`
`337`	`337`	`}`
`@@ -362,7 +362,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> {`
`362`	`362`	`&& let LookupResult::Exact(mpi) = self.move_data().rev_lookup.find(place.as_ref())`
`363`	`363`	`{`
`364`	`364`	`on_all_children_bits(self.move_data(), mpi, \|child\| {`
`365`		`- trans.gen(child);`
	`365`	`+ trans.gen_(child);`
`366`	`366`	`})`
`367`	`367`	`}`
`368`	`368`	`}`
`@@ -400,7 +400,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> {`
`400`	`400`	`self.move_data(),`
`401`	`401`	`self.move_data().rev_lookup.find(place.as_ref()),`
`402`	`402`	`\|mpi\| {`
`403`		`- trans.gen(mpi);`
	`403`	`+ trans.gen_(mpi);`
`404`	`404`	`},`
`405`	`405`	`);`
`406`	`406`	`});`
`@@ -572,7 +572,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeUninitializedPlaces<'_, '_, 'tcx> {`
`572`	`572`	`self.move_data(),`
`573`	`573`	`enum_place,`
`574`	`574`	`variant,`
`575`		`- \|mpi\| trans.gen(mpi),`
	`575`	`+ \|mpi\| trans.gen_(mpi),`
`576`	`576`	`);`
`577`	`577`	`});`
`578`	`578`	`}`
`@@ -643,7 +643,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for DefinitelyInitializedPlaces<'_, 'tcx> {`
`643`	`643`	`self.move_data(),`
`644`	`644`	`self.move_data().rev_lookup.find(place.as_ref()),`
`645`	`645`	`\|mpi\| {`
`646`		`- trans.gen(mpi);`
	`646`	`+ trans.gen_(mpi);`
`647`	`647`	`},`
`648`	`648`	`);`
`649`	`649`	`});`
`@@ -738,7 +738,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for EverInitializedPlaces<'_, '_, 'tcx> {`
`738`	`738`
`739`	`739`	`let call_loc = self.body.terminator_loc(block);`
`740`	`740`	`for init_index in &init_loc_map[call_loc] {`
`741`		`- trans.gen(*init_index);`
	`741`	`+ trans.gen_(*init_index);`
`742`	`742`	`}`
`743`	`743`	`}`
`744`	`744`	`}`
Original file line number	Diff line number	Diff line change
`@@ -116,7 +116,7 @@ where`
`116`	`116`	`self.0.kill(place.local);`
`117`	`117`	`}`
`118`	`118`	`}`
`119`		`- Some(DefUse::Use) => self.0.gen(place.local),`
	`119`	`+ Some(DefUse::Use) => self.0.gen_(place.local),`
`120`	`120`	`None => {}`
`121`	`121`	`}`
`122`	`122`
`@@ -154,7 +154,7 @@ impl DefUse {`
`154`	`154`	`fn apply(trans: &mut impl GenKill<Local>, place: Place<'_>, context: PlaceContext) {`
`155`	`155`	`match DefUse::for_place(place, context) {`
`156`	`156`	`Some(DefUse::Def) => trans.kill(place.local),`
`157`		`- Some(DefUse::Use) => trans.gen(place.local),`
	`157`	`+ Some(DefUse::Use) => trans.gen_(place.local),`
`158`	`158`	`None => {}`
`159`	`159`	`}`
`160`	`160`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ impl<'tcx, 'a> crate::GenKillAnalysis<'tcx> for MaybeStorageLive<'a> {`
`54`	`54`	`_: Location,`
`55`	`55`	`) {`
`56`	`56`	`match stmt.kind {`
`57`		`- StatementKind::StorageLive(l) => trans.gen(l),`
	`57`	`+ StatementKind::StorageLive(l) => trans.gen_(l),`
`58`	`58`	`StatementKind::StorageDead(l) => trans.kill(l),`
`59`	`59`	`_ => (),`
`60`	`60`	`}`
`@@ -127,7 +127,7 @@ impl<'tcx, 'a> crate::GenKillAnalysis<'tcx> for MaybeStorageDead<'a> {`
`127`	`127`	`) {`
`128`	`128`	`match stmt.kind {`
`129`	`129`	`StatementKind::StorageLive(l) => trans.kill(l),`
`130`		`- StatementKind::StorageDead(l) => trans.gen(l),`
	`130`	`+ StatementKind::StorageDead(l) => trans.gen_(l),`
`131`	`131`	`_ => (),`
`132`	`132`	`}`
`133`	`133`	`}`
`@@ -208,7 +208,7 @@ impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {`
`208`	`208`	`StatementKind::Assign(box (place, _))`
`209`	`209`	`\| StatementKind::SetDiscriminant { box place, .. }`
`210`	`210`	`\| StatementKind::Deinit(box place) => {`
`211`		`- trans.gen(place.local);`
	`211`	`+ trans.gen_(place.local);`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`// Nothing to do for these. Match exhaustively so this fails to compile when new`
`@@ -250,7 +250,7 @@ impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {`
`250`	`250`
`251`	`251`	`match &terminator.kind {`
`252`	`252`	`TerminatorKind::Call { destination, .. } => {`
`253`		`- trans.gen(destination.local);`
	`253`	`+ trans.gen_(destination.local);`
`254`	`254`	`}`
`255`	`255`
`256`	`256`	// Note that we do not gen the `resume_arg` of `Yield` terminators. The reason for
`@@ -265,7 +265,7 @@ impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {`
`265`	`265`	`InlineAsmOperand::Out { place, .. }`
`266`	`266`	`\| InlineAsmOperand::InOut { out_place: place, .. } => {`
`267`	`267`	`if let Some(place) = place {`
`268`		`- trans.gen(place.local);`
	`268`	`+ trans.gen_(place.local);`
`269`	`269`	`}`
`270`	`270`	`}`
`271`	`271`	`InlineAsmOperand::In { .. }`
`@@ -341,7 +341,7 @@ impl<'tcx> crate::GenKillAnalysis<'tcx> for MaybeRequiresStorage<'_, 'tcx> {`
`341`	`341`	`_block: BasicBlock,`
`342`	`342`	`return_places: CallReturnPlaces<'_, 'tcx>,`
`343`	`343`	`) {`
`344`		`- return_places.for_each(\|place\| trans.gen(place.local));`
	`344`	`+ return_places.for_each(\|place\| trans.gen_(place.local));`
`345`	`345`	`}`
`346`	`346`	`}`
`347`	`347`
Original file line number	Diff line number	Diff line change
`@@ -1998,6 +1998,9 @@ impl<'a> Builder<'a> {`
`1998`	`1998`	`if mode == Mode::Rustc {`
`1999`	`1999`	`rustflags.arg("-Zunstable-options");`
`2000`	`2000`	`rustflags.arg("-Wrustc::internal");`
	`2001`	+ // FIXME(edition_2024): Change this to `-Wrust_2018_idioms` when all
	`2002`	`+ // of the individual lints are satisfied.`
	`2003`	`+ rustflags.arg("-Wkeyword_idents_2024");`
`2001`	`2004`	`}`
`2002`	`2005`
`2003`	`2006`	`if self.config.rust_frame_pointers {`