From dc207339137a766d7f45590a97cfa0f2a0314e2f Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Sun, 14 Jul 2024 13:50:27 -0400 Subject: [PATCH 1/3] Stop using the gen keyword in the compiler --- compiler/rustc_borrowck/src/dataflow.rs | 2 +- compiler/rustc_hir/src/hir.rs | 18 +++++------ .../rustc_hir_typeck/src/fn_ctxt/checks.rs | 2 +- compiler/rustc_middle/src/mir/visit.rs | 6 ++-- .../rustc_mir_dataflow/src/framework/mod.rs | 30 +++++++++---------- .../src/impls/borrowed_locals.rs | 8 ++--- .../src/impls/initialized.rs | 18 +++++------ .../rustc_mir_dataflow/src/impls/liveness.rs | 4 +-- .../src/impls/storage_liveness.rs | 12 ++++---- src/bootstrap/src/core/builder.rs | 3 ++ 10 files changed, 53 insertions(+), 50 deletions(-) diff --git a/compiler/rustc_borrowck/src/dataflow.rs b/compiler/rustc_borrowck/src/dataflow.rs index 00a30dc2240a6..59b3c6916cbdd 100644 --- 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 index 4561f9d9b49df..3bd7b300758c4 100644 --- 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 index ab0f356ce91f1..9c58809123931 100644 --- 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| ¶m.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 index 0d3c419748b7a..0031ded244062 100644 --- 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 index 09cdb055a3e8b..6eaed0f775337 100644 --- a/compiler/rustc_mir_dataflow/src/framework/mod.rs +++ b/compiler/rustc_mir_dataflow/src/framework/mod.rs @@ -402,7 +402,7 @@ where /// building up a `GenKillSet` and then throwing it away. pub trait GenKill { /// 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); @@ -410,7 +410,7 @@ pub trait GenKill { /// Calls `gen` for each element in `elems`. fn gen_all(&mut self, elems: impl IntoIterator) { for elem in elems { - self.gen(elem); + self.gen_(elem); } } @@ -424,12 +424,12 @@ pub trait GenKill { /// 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 { - gen: HybridBitSet, + gen_: HybridBitSet, kill: HybridBitSet, } @@ -437,31 +437,31 @@ impl GenKillSet { /// 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) { - state.union(&self.gen); + state.union(&self.gen_); state.subtract(&self.kill); } } impl GenKill for GenKillSet { - 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 GenKill for BitSet { - fn gen(&mut self, elem: T) { + fn gen_(&mut self, elem: T) { self.insert(elem); } @@ -471,7 +471,7 @@ impl GenKill for BitSet { } impl GenKill for ChunkedBitSet { - fn gen(&mut self, elem: T) { + fn gen_(&mut self, elem: T) { self.insert(elem); } @@ -481,11 +481,11 @@ impl GenKill for ChunkedBitSet { } impl> GenKill for MaybeReachable { - 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> GenKill for MaybeReachable { } impl GenKill for lattice::Dual> { - 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 index 574da949b0ed3..885fdd0d58bea 100644 --- 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 { impl GenKill 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 index ffcf630b653cd..a9bceeccdce2f 100644 --- 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 index 334fa9976f037..48bdb1316012f 100644 --- 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, 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 index f850a71027739..682cec12f1fbd 100644 --- 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 index aeb3474360801..398a5f73d7b74 100644 --- 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 { From f08c43afc7b801f2ab0109764df9cc959ebc8b79 Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Sun, 14 Jul 2024 14:22:11 -0400 Subject: [PATCH 2/3] Suppress some fallout from gen in synstructure --- compiler/rustc_macros/src/diagnostics/diagnostic.rs | 4 ++++ compiler/rustc_macros/src/diagnostics/subdiagnostic.rs | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/compiler/rustc_macros/src/diagnostics/diagnostic.rs b/compiler/rustc_macros/src/diagnostics/diagnostic.rs index a3abbdcf18ca5..2743660ab8917 100644 --- a/compiler/rustc_macros/src/diagnostics/diagnostic.rs +++ b/compiler/rustc_macros/src/diagnostics/diagnostic.rs @@ -71,6 +71,8 @@ impl<'a> DiagnosticDerive<'a> { }); // A lifetime of `'a` causes conflicts, but `_sess` is fine. + // FIXME(edition_2024): Fix the `keyword_idents_2024` lint to not trigger here? + #[allow(keyword_idents_2024)] let mut imp = structure.gen_impl(quote! { gen impl<'_sess, G> rustc_errors::Diagnostic<'_sess, G> for @Self where G: rustc_errors::EmissionGuarantee @@ -148,6 +150,8 @@ impl<'a> LintDiagnosticDerive<'a> { } }); + // FIXME(edition_2024): Fix the `keyword_idents_2024` lint to not trigger here? + #[allow(keyword_idents_2024)] let mut imp = structure.gen_impl(quote! { gen impl<'__a> rustc_errors::LintDiagnostic<'__a, ()> for @Self { #[track_caller] diff --git a/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs b/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs index 69014f39925ab..7f090f5ebc163 100644 --- a/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs +++ b/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs @@ -86,6 +86,9 @@ impl SubdiagnosticDerive { let diag = &self.diag; let f = &self.f; + + // FIXME(edition_2024): Fix the `keyword_idents_2024` lint to not trigger here? + #[allow(keyword_idents_2024)] let ret = structure.gen_impl(quote! { gen impl rustc_errors::Subdiagnostic for @Self { fn add_to_diag_with<__G, __F>( @@ -100,6 +103,7 @@ impl SubdiagnosticDerive { } } }); + ret } } From 80393ea7a8a789d26643b3038410d85a9315c117 Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Sun, 14 Jul 2024 14:52:36 -0400 Subject: [PATCH 3/3] Fix trivial gen ident usage in tools --- src/bootstrap/src/core/builder.rs | 2 +- src/librustdoc/clean/mod.rs | 4 ++-- src/librustdoc/html/render/search_index.rs | 6 +++--- .../clippy/clippy_lints/src/misc_early/mod.rs | 4 ++-- .../clippy/clippy_lints/src/trait_bounds.rs | 20 +++++++++---------- .../clippy_lints/src/types/type_complexity.rs | 2 +- 6 files changed, 19 insertions(+), 19 deletions(-) diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs index 398a5f73d7b74..f033905e9f62c 100644 --- a/src/bootstrap/src/core/builder.rs +++ b/src/bootstrap/src/core/builder.rs @@ -1998,7 +1998,7 @@ 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 + // FIXME(edition_2024): Change this to `-Wrust_2024_idioms` when all // of the individual lints are satisfied. rustflags.arg("-Wkeyword_idents_2024"); } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 98ce268a77466..a0e28d2f55c70 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1052,12 +1052,12 @@ fn clean_fn_decl_legacy_const_generics(func: &mut Function, attrs: &[ast::Attrib for (pos, literal) in meta_item_list.iter().filter_map(|meta| meta.lit()).enumerate() { match literal.kind { ast::LitKind::Int(a, _) => { - let gen = func.generics.params.remove(0); + let param = func.generics.params.remove(0); if let GenericParamDef { name, kind: GenericParamDefKind::Const { ty, .. }, .. - } = gen + } = param { func.decl .inputs diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs index bc8bdffc33145..66d3f0fd8ce82 100644 --- a/src/librustdoc/html/render/search_index.rs +++ b/src/librustdoc/html/render/search_index.rs @@ -1051,7 +1051,7 @@ fn simplify_fn_type<'tcx, 'a>( let mut ty_generics = Vec::new(); let mut ty_constraints = Vec::new(); if let Some(arg_generics) = arg.generic_args() { - for ty in arg_generics.into_iter().filter_map(|gen| match gen { + for ty in arg_generics.into_iter().filter_map(|param| match param { clean::GenericArg::Type(ty) => Some(ty), _ => None, }) { @@ -1172,8 +1172,8 @@ fn simplify_fn_constraint<'tcx, 'a>( ) { let mut ty_constraints = Vec::new(); let ty_constrained_assoc = RenderTypeId::AssociatedType(constraint.assoc.name); - for gen in &constraint.assoc.args { - match gen { + for param in &constraint.assoc.args { + match param { clean::GenericArg::Type(arg) => simplify_fn_type( self_, generics, diff --git a/src/tools/clippy/clippy_lints/src/misc_early/mod.rs b/src/tools/clippy/clippy_lints/src/misc_early/mod.rs index fedcfd11fdccc..4cba13a05c246 100644 --- a/src/tools/clippy/clippy_lints/src/misc_early/mod.rs +++ b/src/tools/clippy/clippy_lints/src/misc_early/mod.rs @@ -364,8 +364,8 @@ declare_lint_pass!(MiscEarlyLints => [ ]); impl EarlyLintPass for MiscEarlyLints { - fn check_generics(&mut self, cx: &EarlyContext<'_>, gen: &Generics) { - for param in &gen.params { + fn check_generics(&mut self, cx: &EarlyContext<'_>, generics: &Generics) { + for param in &generics.params { builtin_type_shadow::check(cx, param); } } diff --git a/src/tools/clippy/clippy_lints/src/trait_bounds.rs b/src/tools/clippy/clippy_lints/src/trait_bounds.rs index c05cd9ed59345..07390d6f43029 100644 --- a/src/tools/clippy/clippy_lints/src/trait_bounds.rs +++ b/src/tools/clippy/clippy_lints/src/trait_bounds.rs @@ -102,9 +102,9 @@ impl TraitBounds { impl_lint_pass!(TraitBounds => [TYPE_REPETITION_IN_BOUNDS, TRAIT_DUPLICATION_IN_BOUNDS]); impl<'tcx> LateLintPass<'tcx> for TraitBounds { - fn check_generics(&mut self, cx: &LateContext<'tcx>, gen: &'tcx Generics<'_>) { - self.check_type_repetition(cx, gen); - check_trait_bound_duplication(cx, gen); + fn check_generics(&mut self, cx: &LateContext<'tcx>, generics: &'tcx Generics<'_>) { + self.check_type_repetition(cx, generics); + check_trait_bound_duplication(cx, generics); } fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) { @@ -238,7 +238,7 @@ impl TraitBounds { } #[allow(clippy::mutable_key_type)] - fn check_type_repetition<'tcx>(&self, cx: &LateContext<'tcx>, gen: &'tcx Generics<'_>) { + fn check_type_repetition<'tcx>(&self, cx: &LateContext<'tcx>, generics: &'tcx Generics<'_>) { struct SpanlessTy<'cx, 'tcx> { ty: &'tcx Ty<'tcx>, cx: &'cx LateContext<'tcx>, @@ -258,12 +258,12 @@ impl TraitBounds { } impl Eq for SpanlessTy<'_, '_> {} - if gen.span.from_expansion() { + if generics.span.from_expansion() { return; } let mut map: UnhashMap, Vec<&GenericBound<'_>>> = UnhashMap::default(); let mut applicability = Applicability::MaybeIncorrect; - for bound in gen.predicates { + for bound in generics.predicates { if let WherePredicate::BoundPredicate(ref p) = bound && p.origin != PredicateOrigin::ImplTrait && p.bounds.len() as u64 <= self.max_trait_bounds @@ -301,8 +301,8 @@ impl TraitBounds { } } -fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) { - if gen.span.from_expansion() { +fn check_trait_bound_duplication(cx: &LateContext<'_>, generics: &'_ Generics<'_>) { + if generics.span.from_expansion() { return; } @@ -313,7 +313,7 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) { // | // collects each of these where clauses into a set keyed by generic name and comparable trait // eg. (T, Clone) - let where_predicates = gen + let where_predicates = generics .predicates .iter() .filter_map(|pred| { @@ -342,7 +342,7 @@ fn check_trait_bound_duplication(cx: &LateContext<'_>, gen: &'_ Generics<'_>) { // | // compare trait bounds keyed by generic name and comparable trait to collected where // predicates eg. (T, Clone) - for predicate in gen.predicates.iter().filter(|pred| !pred.in_where_clause()) { + for predicate in generics.predicates.iter().filter(|pred| !pred.in_where_clause()) { if let WherePredicate::BoundPredicate(bound_predicate) = predicate && bound_predicate.origin != PredicateOrigin::ImplTrait && !bound_predicate.span.from_expansion() diff --git a/src/tools/clippy/clippy_lints/src/types/type_complexity.rs b/src/tools/clippy/clippy_lints/src/types/type_complexity.rs index 0aa50c99c1690..b6e765d7c3937 100644 --- a/src/tools/clippy/clippy_lints/src/types/type_complexity.rs +++ b/src/tools/clippy/clippy_lints/src/types/type_complexity.rs @@ -57,7 +57,7 @@ impl<'tcx> Visitor<'tcx> for TypeComplexityVisitor { bound .bound_generic_params .iter() - .any(|gen| matches!(gen.kind, GenericParamKind::Lifetime { .. })) + .any(|param| matches!(param.kind, GenericParamKind::Lifetime { .. })) }); if has_lifetime_parameters { // complex trait bounds like A<'a, 'b>