mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Stop using the gen keyword in the compiler

Browse Source
This commit is contained in:
Michael Goulet 2024-07-14 13:50:27 -04:00
parent 88fa119c77
commit dc20733913
10 changed files with 53 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_borrowck/src/dataflow.rs
View File

@ -553,7 +553,7 @@ fn statement_effect(
panic!("could not find BorrowIndex for location {location:?}"); panic!("could not find BorrowIndex for location {location:?}");
}); });
trans.gen(index); trans.gen_(index);
} }
// Make sure there are no remaining borrows for variables // Make sure there are no remaining borrows for variables

18
compiler/rustc_hir/src/hir.rs
View File

@ -3218,10 +3218,10 @@ pub fn is_struct_or_union(&self) -> bool {
ItemKind::Static(ty, mutbl, body), (ty, *mutbl, *body); ItemKind::Static(ty, mutbl, body), (ty, *mutbl, *body);
expect_const, (&'hir Ty<'hir>, &'hir Generics<'hir>, BodyId), 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), 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); expect_macro, (&ast::MacroDef, MacroKind), ItemKind::Macro(def, mk), (def, *mk);
@ -3233,25 +3233,25 @@ pub fn is_struct_or_union(&self) -> bool {
expect_global_asm, &'hir InlineAsm<'hir>, ItemKind::GlobalAsm(asm), asm; expect_global_asm, &'hir InlineAsm<'hir>, ItemKind::GlobalAsm(asm), asm;
expect_ty_alias, (&'hir Ty<'hir>, &'hir Generics<'hir>), 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_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>), 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>), expect_union, (&VariantData<'hir>, &'hir Generics<'hir>),
ItemKind::Union(data, gen), (data, gen); ItemKind::Union(data, generics), (data, generics);
expect_trait, expect_trait,
(IsAuto, Safety, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]), (IsAuto, Safety, &'hir Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]),
ItemKind::Trait(is_auto, safety, gen, bounds, items), ItemKind::Trait(is_auto, safety, generics, bounds, items),
(*is_auto, *safety, gen, bounds, items); (*is_auto, *safety, generics, bounds, items);
expect_trait_alias, (&'hir Generics<'hir>, GenericBounds<'hir>), 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; expect_impl, &'hir Impl<'hir>, ItemKind::Impl(imp), imp;
} }

2
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View File

@ -2554,7 +2554,7 @@ fn get_hir_params_with_generics(
.and_then(|node| node.generics()) .and_then(|node| node.generics())
.into_iter() .into_iter()
.flat_map(|generics| generics.params) .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 { } else {
None None
} }

6
compiler/rustc_middle/src/mir/visit.rs
View File

@ -1016,14 +1016,14 @@ fn super_body_preserves_cfg(&mut self, body: &mut Body<'tcx>) {
macro_rules! super_body { macro_rules! super_body {
($self:ident, $body:ident, $($mutability:ident, $invalidate:tt)?) => { ($self:ident, $body:ident, $($mutability:ident, $invalidate:tt)?) => {
let span = $body.span; let span = $body.span;
if let Some(gen) = &$($mutability)? $body.coroutine { if let Some(coroutine) = &$($mutability)? $body.coroutine {
if let Some(yield_ty) = $(& $mutability)? gen.yield_ty { if let Some(yield_ty) = $(& $mutability)? coroutine.yield_ty {
$self.visit_ty( $self.visit_ty(
yield_ty, yield_ty,
TyContext::YieldTy(SourceInfo::outermost(span)) 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( $self.visit_ty(
resume_ty, resume_ty,
TyContext::ResumeTy(SourceInfo::outermost(span)) TyContext::ResumeTy(SourceInfo::outermost(span))

30
compiler/rustc_mir_dataflow/src/framework/mod.rs
View File

@ -402,7 +402,7 @@ fn into_engine<'mir>(
/// building up a `GenKillSet` and then throwing it away. /// building up a `GenKillSet` and then throwing it away.
pub trait GenKill<T> { pub trait GenKill<T> {
/// Inserts `elem` into the state vector. /// Inserts `elem` into the state vector.
fn gen(&mut self, elem: T); fn gen_(&mut self, elem: T);
/// Removes `elem` from the state vector. /// Removes `elem` from the state vector.
fn kill(&mut self, elem: T); fn kill(&mut self, elem: T);
@ -410,7 +410,7 @@ pub trait GenKill<T> {
/// Calls `gen` for each element in `elems`. /// Calls `gen` for each element in `elems`.
fn gen_all(&mut self, elems: impl IntoIterator<Item = T>) { fn gen_all(&mut self, elems: impl IntoIterator<Item = T>) {
for elem in elems { for elem in elems {
self.gen(elem); self.gen_(elem);
} }
} }
@ -424,12 +424,12 @@ fn kill_all(&mut self, elems: impl IntoIterator<Item = T>) {
/// Stores a transfer function for a gen/kill problem. /// 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 /// 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 /// applied multiple times efficiently. When there are multiple calls to `gen_` and/or `kill` for
/// the same element, the most recent one takes precedence. /// the same element, the most recent one takes precedence.
#[derive(Clone)] #[derive(Clone)]
pub struct GenKillSet<T> { pub struct GenKillSet<T> {
gen: HybridBitSet<T>, gen_: HybridBitSet<T>,
kill: HybridBitSet<T>, kill: HybridBitSet<T>,
} }
@ -437,31 +437,31 @@ impl<T: Idx> GenKillSet<T> {
/// Creates a new transfer function that will leave the dataflow state unchanged. /// Creates a new transfer function that will leave the dataflow state unchanged.
pub fn identity(universe: usize) -> Self { pub fn identity(universe: usize) -> Self {
GenKillSet { GenKillSet {
gen: HybridBitSet::new_empty(universe), gen_: HybridBitSet::new_empty(universe),
kill: HybridBitSet::new_empty(universe), kill: HybridBitSet::new_empty(universe),
} }
} }
pub fn apply(&self, state: &mut impl BitSetExt<T>) { pub fn apply(&self, state: &mut impl BitSetExt<T>) {
state.union(&self.gen); state.union(&self.gen_);
state.subtract(&self.kill); state.subtract(&self.kill);
} }
} }
impl<T: Idx> GenKill<T> for GenKillSet<T> { impl<T: Idx> GenKill<T> for GenKillSet<T> {
fn gen(&mut self, elem: T) { fn gen_(&mut self, elem: T) {
self.gen.insert(elem); self.gen_.insert(elem);
self.kill.remove(elem); self.kill.remove(elem);
} }
fn kill(&mut self, elem: T) { fn kill(&mut self, elem: T) {
self.kill.insert(elem); self.kill.insert(elem);
self.gen.remove(elem); self.gen_.remove(elem);
} }
} }
impl<T: Idx> GenKill<T> for BitSet<T> { impl<T: Idx> GenKill<T> for BitSet<T> {
fn gen(&mut self, elem: T) { fn gen_(&mut self, elem: T) {
self.insert(elem); self.insert(elem);
} }
@ -471,7 +471,7 @@ fn kill(&mut self, elem: T) {
} }
impl<T: Idx> GenKill<T> for ChunkedBitSet<T> { impl<T: Idx> GenKill<T> for ChunkedBitSet<T> {
fn gen(&mut self, elem: T) { fn gen_(&mut self, elem: T) {
self.insert(elem); self.insert(elem);
} }
@ -481,11 +481,11 @@ fn kill(&mut self, elem: T) {
} }
impl<T, S: GenKill<T>> GenKill<T> for MaybeReachable<S> { impl<T, S: GenKill<T>> GenKill<T> for MaybeReachable<S> {
fn gen(&mut self, elem: T) { fn gen_(&mut self, elem: T) {
match self { match self {
// If the state is not reachable, adding an element does nothing. // If the state is not reachable, adding an element does nothing.
MaybeReachable::Unreachable => {} MaybeReachable::Unreachable => {}
MaybeReachable::Reachable(set) => set.gen(elem), MaybeReachable::Reachable(set) => set.gen_(elem),
} }
} }
@ -499,7 +499,7 @@ fn kill(&mut self, elem: T) {
} }
impl<T: Idx> GenKill<T> for lattice::Dual<BitSet<T>> { 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); self.0.insert(elem);
} }

8
compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
View File

@ -97,7 +97,7 @@ fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
Rvalue::AddressOf(_, borrowed_place) Rvalue::AddressOf(_, borrowed_place)
| Rvalue::Ref(_, BorrowKind::Mut { .. } | BorrowKind::Shared, borrowed_place) => { | Rvalue::Ref(_, BorrowKind::Mut { .. } | BorrowKind::Shared, borrowed_place) => {
if !borrowed_place.is_indirect() { if !borrowed_place.is_indirect() {
self.trans.gen(borrowed_place.local); self.trans.gen_(borrowed_place.local);
} }
} }
@ -131,7 +131,7 @@ fn visit_terminator(&mut self, terminator: &Terminator<'tcx>, location: Location
// //
// [#61069]: https://github.com/rust-lang/rust/pull/61069 // [#61069]: https://github.com/rust-lang/rust/pull/61069
if !dropped_place.is_indirect() { 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 { impl GenKill<Local> for Borrowed {
#[inline] #[inline]
fn gen(&mut self, elem: Local) { fn gen_(&mut self, elem: Local) {
self.0.gen(elem) self.0.gen_(elem)
} }
#[inline] #[inline]
fn kill(&mut self, _: Local) { fn kill(&mut self, _: Local) {

18
compiler/rustc_mir_dataflow/src/impls/initialized.rs
View File

@ -283,7 +283,7 @@ fn update_bits(
) { ) {
match state { match state {
DropFlagState::Absent => trans.kill(path), DropFlagState::Absent => trans.kill(path),
DropFlagState::Present => trans.gen(path), DropFlagState::Present => trans.gen_(path),
} }
} }
} }
@ -295,7 +295,7 @@ fn update_bits(
state: DropFlagState, state: DropFlagState,
) { ) {
match state { match state {
DropFlagState::Absent => trans.gen(path), DropFlagState::Absent => trans.gen_(path),
DropFlagState::Present => trans.kill(path), DropFlagState::Present => trans.kill(path),
} }
} }
@ -309,7 +309,7 @@ fn update_bits(
) { ) {
match state { match state {
DropFlagState::Absent => trans.kill(path), DropFlagState::Absent => trans.kill(path),
DropFlagState::Present => trans.gen(path), DropFlagState::Present => trans.gen_(path),
} }
} }
} }
@ -331,7 +331,7 @@ fn initialize_start_block(&self, _: &mir::Body<'tcx>, state: &mut Self::Domain)
MaybeReachable::Reachable(ChunkedBitSet::new_empty(self.move_data().move_paths.len())); MaybeReachable::Reachable(ChunkedBitSet::new_empty(self.move_data().move_paths.len()));
drop_flag_effects_for_function_entry(self.body, self.mdpe, |path, s| { drop_flag_effects_for_function_entry(self.body, self.mdpe, |path, s| {
assert!(s == DropFlagState::Present); assert!(s == DropFlagState::Present);
state.gen(path); state.gen_(path);
}); });
} }
} }
@ -362,7 +362,7 @@ fn statement_effect(
&& let LookupResult::Exact(mpi) = self.move_data().rev_lookup.find(place.as_ref()) && let LookupResult::Exact(mpi) = self.move_data().rev_lookup.find(place.as_ref())
{ {
on_all_children_bits(self.move_data(), mpi, |child| { on_all_children_bits(self.move_data(), mpi, |child| {
trans.gen(child); trans.gen_(child);
}) })
} }
} }
@ -400,7 +400,7 @@ fn call_return_effect(
self.move_data(), self.move_data(),
self.move_data().rev_lookup.find(place.as_ref()), self.move_data().rev_lookup.find(place.as_ref()),
|mpi| { |mpi| {
trans.gen(mpi); trans.gen_(mpi);
}, },
); );
}); });
@ -572,7 +572,7 @@ fn switch_int_edge_effects<G: GenKill<Self::Idx>>(
self.move_data(), self.move_data(),
enum_place, enum_place,
variant, variant,
|mpi| trans.gen(mpi), |mpi| trans.gen_(mpi),
); );
}); });
} }
@ -643,7 +643,7 @@ fn call_return_effect(
self.move_data(), self.move_data(),
self.move_data().rev_lookup.find(place.as_ref()), self.move_data().rev_lookup.find(place.as_ref()),
|mpi| { |mpi| {
trans.gen(mpi); trans.gen_(mpi);
}, },
); );
}); });
@ -738,7 +738,7 @@ fn call_return_effect(
let call_loc = self.body.terminator_loc(block); let call_loc = self.body.terminator_loc(block);
for init_index in &init_loc_map[call_loc] { for init_index in &init_loc_map[call_loc] {
trans.gen(*init_index); trans.gen_(*init_index);
} }
} }
} }

4
compiler/rustc_mir_dataflow/src/impls/liveness.rs
View File

@ -116,7 +116,7 @@ fn visit_place(&mut self, place: &mir::Place<'tcx>, context: PlaceContext, locat
self.0.kill(place.local); self.0.kill(place.local);
} }
} }
Some(DefUse::Use) => self.0.gen(place.local), Some(DefUse::Use) => self.0.gen_(place.local),
None => {} None => {}
} }
@ -154,7 +154,7 @@ impl DefUse {
fn apply(trans: &mut impl GenKill<Local>, place: Place<'_>, context: PlaceContext) { fn apply(trans: &mut impl GenKill<Local>, place: Place<'_>, context: PlaceContext) {
match DefUse::for_place(place, context) { match DefUse::for_place(place, context) {
Some(DefUse::Def) => trans.kill(place.local), Some(DefUse::Def) => trans.kill(place.local),
Some(DefUse::Use) => trans.gen(place.local), Some(DefUse::Use) => trans.gen_(place.local),
None => {} None => {}
} }
} }

12
compiler/rustc_mir_dataflow/src/impls/storage_liveness.rs
View File

@ -54,7 +54,7 @@ fn statement_effect(
_: Location, _: Location,
) { ) {
match stmt.kind { match stmt.kind {
StatementKind::StorageLive(l) => trans.gen(l), StatementKind::StorageLive(l) => trans.gen_(l),
StatementKind::StorageDead(l) => trans.kill(l), StatementKind::StorageDead(l) => trans.kill(l),
_ => (), _ => (),
} }
@ -127,7 +127,7 @@ fn statement_effect(
) { ) {
match stmt.kind { match stmt.kind {
StatementKind::StorageLive(l) => trans.kill(l), StatementKind::StorageLive(l) => trans.kill(l),
StatementKind::StorageDead(l) => trans.gen(l), StatementKind::StorageDead(l) => trans.gen_(l),
_ => (), _ => (),
} }
} }
@ -208,7 +208,7 @@ fn before_statement_effect(
StatementKind::Assign(box (place, _)) StatementKind::Assign(box (place, _))
| StatementKind::SetDiscriminant { box place, .. } | StatementKind::SetDiscriminant { box place, .. }
| StatementKind::Deinit(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 // Nothing to do for these. Match exhaustively so this fails to compile when new
@ -250,7 +250,7 @@ fn before_terminator_effect(
match &terminator.kind { match &terminator.kind {
TerminatorKind::Call { destination, .. } => { 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 // Note that we do *not* gen the `resume_arg` of `Yield` terminators. The reason for
@ -265,7 +265,7 @@ fn before_terminator_effect(
InlineAsmOperand::Out { place, .. } InlineAsmOperand::Out { place, .. }
| InlineAsmOperand::InOut { out_place: place, .. } => { | InlineAsmOperand::InOut { out_place: place, .. } => {
if let Some(place) = place { if let Some(place) = place {
trans.gen(place.local); trans.gen_(place.local);
} }
} }
InlineAsmOperand::In { .. } InlineAsmOperand::In { .. }
@ -341,7 +341,7 @@ fn call_return_effect(
_block: BasicBlock, _block: BasicBlock,
return_places: CallReturnPlaces<'_, 'tcx>, return_places: CallReturnPlaces<'_, 'tcx>,
) { ) {
return_places.for_each(|place| trans.gen(place.local)); return_places.for_each(|place| trans.gen_(place.local));
} }
} }

3
src/bootstrap/src/core/builder.rs
View File

@ -1998,6 +1998,9 @@ fn cargo(
if mode == Mode::Rustc { if mode == Mode::Rustc {
rustflags.arg("-Zunstable-options"); rustflags.arg("-Zunstable-options");
rustflags.arg("-Wrustc::internal"); 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 { if self.config.rust_frame_pointers {