From 12e3911d81034864314503b9c2d9fba2773c7904 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 20 Feb 2025 18:58:46 +0000
Subject: [PATCH] Greatly simplify lifetime captures in edition 2024
---
compiler/rustc_abi/src/lib.rs | 2 +-
compiler/rustc_ast_lowering/src/lib.rs | 17 ++++++------
.../src/attributes/allow_unstable.rs | 24 ++++++++---------
.../src/diagnostics/conflict_errors.rs | 7 +++--
.../rustc_borrowck/src/member_constraints.rs | 7 ++---
.../src/polonius/loan_liveness.rs | 2 +-
.../rustc_borrowck/src/region_infer/mod.rs | 10 +++----
.../src/region_infer/reverse_sccs.rs | 5 +---
.../rustc_borrowck/src/region_infer/values.rs | 24 +++++++----------
.../src/type_check/free_region_relations.rs | 2 +-
.../src/type_check/liveness/local_use_map.rs | 8 +++---
.../rustc_borrowck/src/universal_regions.rs | 8 +++---
.../rustc_const_eval/src/interpret/intern.rs | 4 +--
.../src/graph/implementation/mod.rs | 8 +++---
.../src/graph/scc/mod.rs | 2 +-
.../src/sorted_map/index_map.rs | 4 +--
compiler/rustc_data_structures/src/sso/map.rs | 2 +-
compiler/rustc_data_structures/src/sso/set.rs | 2 +-
.../rustc_data_structures/src/sync/vec.rs | 4 +--
.../src/transitive_relation.rs | 2 +-
compiler/rustc_expand/src/proc_macro.rs | 2 +-
compiler/rustc_hir/src/definitions.rs | 2 +-
compiler/rustc_hir/src/lang_items.rs | 2 +-
compiler/rustc_hir_analysis/src/collect.rs | 5 ++--
.../src/collect/resolve_bound_vars.rs | 7 ++---
compiler/rustc_index/src/bit_set.rs | 2 +-
compiler/rustc_index/src/interval.rs | 4 +--
compiler/rustc_index/src/slice.rs | 6 ++---
compiler/rustc_index/src/vec.rs | 4 +--
.../src/infer/canonical/query_response.rs | 13 +++++-----
.../rustc_infer/src/infer/free_regions.rs | 2 +-
compiler/rustc_infer/src/infer/mod.rs | 7 ++---
.../rustc_infer/src/infer/outlives/mod.rs | 2 +-
compiler/rustc_lexer/src/lib.rs | 2 +-
compiler/rustc_lint/src/context.rs | 4 +--
compiler/rustc_metadata/src/rmeta/decoder.rs | 26 ++++++++-----------
compiler/rustc_middle/src/hir/map.rs | 13 ++++------
compiler/rustc_middle/src/hir/mod.rs | 16 ++++++------
compiler/rustc_middle/src/hir/place.rs | 2 +-
.../interpret/allocation/provenance_map.rs | 2 +-
compiler/rustc_middle/src/mir/mod.rs | 9 +++----
compiler/rustc_middle/src/mir/pretty.rs | 2 +-
compiler/rustc_middle/src/ty/adt.rs | 3 +--
compiler/rustc_middle/src/ty/closure.rs | 3 +--
compiler/rustc_middle/src/ty/context.rs | 8 +++---
compiler/rustc_middle/src/ty/generic_args.rs | 10 +++----
compiler/rustc_middle/src/ty/mod.rs | 9 +++----
compiler/rustc_middle/src/ty/predicate.rs | 13 ++++------
compiler/rustc_middle/src/ty/sty.rs | 5 ++--
compiler/rustc_middle/src/ty/trait_def.rs | 4 +--
.../rustc_middle/src/ty/typeck_results.rs | 2 +-
.../src/builder/expr/as_place.rs | 6 ++---
compiler/rustc_mir_build/src/thir/cx/mod.rs | 6 ++---
.../rustc_mir_dataflow/src/move_paths/mod.rs | 2 +-
compiler/rustc_mir_dataflow/src/un_derefer.rs | 2 +-
.../rustc_mir_dataflow/src/value_analysis.rs | 6 +----
.../rustc_mir_transform/src/coverage/graph.rs | 3 +--
.../rustc_mir_transform/src/coverage/query.rs | 3 +--
.../rustc_mir_transform/src/coverage/spans.rs | 3 +--
.../rustc_mir_transform/src/jump_threading.rs | 4 +--
compiler/rustc_mir_transform/src/sroa.rs | 2 +-
compiler/rustc_mir_transform/src/ssa.rs | 2 +-
compiler/rustc_monomorphize/src/collector.rs | 2 +-
compiler/rustc_parse/src/parser/mod.rs | 2 +-
compiler/rustc_pattern_analysis/src/lib.rs | 10 +++----
.../rustc_pattern_analysis/src/pat_column.rs | 4 +--
compiler/rustc_pattern_analysis/src/rustc.rs | 26 ++++++++-----------
.../rustc_pattern_analysis/src/usefulness.rs | 25 ++++++++----------
.../tests/common/mod.rs | 13 +++++-----
.../src/dep_graph/serialized.rs | 2 +-
compiler/rustc_session/src/parse.rs | 2 +-
compiler/rustc_session/src/search_paths.rs | 11 ++++----
.../error_reporting/infer/need_type_info.rs | 2 +-
.../src/solve/fulfill.rs | 4 +--
.../src/traits/fulfill.rs | 7 +++--
.../traits/specialize/specialization_graph.rs | 7 ++---
.../src/traits/vtable.rs | 2 +-
compiler/rustc_ty_utils/src/implied_bounds.rs | 4 +--
.../rustc_ty_utils/src/layout/invariant.rs | 2 +-
compiler/rustc_ty_utils/src/needs_drop.rs | 2 +-
.../rustc_type_ir/src/search_graph/mod.rs | 2 +-
compiler/stable_mir/src/mir/body.rs | 2 +-
compiler/stable_mir/src/ty.rs | 2 +-
.../diagnostics/match_check/pat_analysis.rs | 10 +++----
84 files changed, 223 insertions(+), 294 deletions(-)
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index 34228912041d..879e4bf64a85 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -1345,7 +1345,7 @@ impl<FieldIdx: Idx> FieldsShape<FieldIdx> {
/// Gets source indices of the fields by increasing offsets.
#[inline]
- pub fn index_by_increasing_offset(&self) -> impl ExactSizeIterator<Item = usize> + '_ {
+ pub fn index_by_increasing_offset(&self) -> impl ExactSizeIterator<Item = usize> {
let mut inverse_small = [0u8; 64];
let mut inverse_big = IndexVec::new();
let use_small = self.count() <= inverse_small.len();
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 1c777111896d..b865cbedbbb7 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -45,7 +45,6 @@ use std::sync::Arc;
use rustc_ast::node_id::NodeMap;
use rustc_ast::{self as ast, *};
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::sorted_map::SortedMap;
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@@ -1821,11 +1820,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
self.new_named_lifetime_with_res(new_id, ident, res)
}
- fn lower_generic_params_mut<'s>(
- &'s mut self,
- params: &'s [GenericParam],
+ fn lower_generic_params_mut(
+ &mut self,
+ params: &[GenericParam],
source: hir::GenericParamSource,
- ) -> impl Iterator<Item = hir::GenericParam<'hir>> + Captures<'a> + Captures<'s> {
+ ) -> impl Iterator<Item = hir::GenericParam<'hir>> {
params.iter().map(move |param| self.lower_generic_param(param, source))
}
@@ -1986,11 +1985,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
self.arena.alloc_from_iter(self.lower_param_bounds_mut(bounds, itctx))
}
- fn lower_param_bounds_mut<'s>(
- &'s mut self,
- bounds: &'s [GenericBound],
+ fn lower_param_bounds_mut(
+ &mut self,
+ bounds: &[GenericBound],
itctx: ImplTraitContext,
- ) -> impl Iterator<Item = hir::GenericBound<'hir>> + Captures<'s> + Captures<'a> {
+ ) -> impl Iterator<Item = hir::GenericBound<'hir>> {
bounds.iter().map(move |bound| self.lower_param_bound(bound, itctx))
}
diff --git a/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs b/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
index 471168ed4f56..13d246b08a8f 100644
--- a/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
@@ -4,25 +4,25 @@ use rustc_span::{Symbol, sym};
use crate::session_diagnostics;
-pub fn allow_internal_unstable<'a>(
- sess: &'a Session,
- attrs: &'a [impl AttributeExt],
-) -> impl Iterator<Item = Symbol> + 'a {
+pub fn allow_internal_unstable(
+ sess: &Session,
+ attrs: &[impl AttributeExt],
+) -> impl Iterator<Item = Symbol> {
allow_unstable(sess, attrs, sym::allow_internal_unstable)
}
-pub fn rustc_allow_const_fn_unstable<'a>(
- sess: &'a Session,
- attrs: &'a [impl AttributeExt],
-) -> impl Iterator<Item = Symbol> + 'a {
+pub fn rustc_allow_const_fn_unstable(
+ sess: &Session,
+ attrs: &[impl AttributeExt],
+) -> impl Iterator<Item = Symbol> {
allow_unstable(sess, attrs, sym::rustc_allow_const_fn_unstable)
}
-fn allow_unstable<'a>(
- sess: &'a Session,
- attrs: &'a [impl AttributeExt],
+fn allow_unstable(
+ sess: &Session,
+ attrs: &[impl AttributeExt],
symbol: Symbol,
-) -> impl Iterator<Item = Symbol> + 'a {
+) -> impl Iterator<Item = Symbol> {
let attrs = filter_by_name(attrs, symbol);
let list = attrs
.filter_map(move |attr| {
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 94662070db40..f33f2ab58e05 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -8,7 +8,6 @@ use std::ops::ControlFlow;
use either::Either;
use hir::{ClosureKind, Path};
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxIndexSet;
use rustc_errors::codes::*;
use rustc_errors::{Applicability, Diag, MultiSpan, struct_span_code_err};
@@ -3530,10 +3529,10 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
location: Location,
mpi: MovePathIndex,
) -> (Vec<MoveSite>, Vec<Location>) {
- fn predecessor_locations<'a, 'tcx>(
- body: &'a mir::Body<'tcx>,
+ fn predecessor_locations<'tcx>(
+ body: &mir::Body<'tcx>,
location: Location,
- ) -> impl Iterator<Item = Location> + Captures<'tcx> + 'a {
+ ) -> impl Iterator<Item = Location> {
if location.statement_index == 0 {
let predecessors = body.basic_blocks.predecessors()[location.block].to_vec();
Either::Left(predecessors.into_iter().map(move |bb| body.terminator_loc(bb)))
diff --git a/compiler/rustc_borrowck/src/member_constraints.rs b/compiler/rustc_borrowck/src/member_constraints.rs
index a0adf471fd31..bdd0f6fe11e0 100644
--- a/compiler/rustc_borrowck/src/member_constraints.rs
+++ b/compiler/rustc_borrowck/src/member_constraints.rs
@@ -1,7 +1,6 @@
use std::hash::Hash;
use std::ops::Index;
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxIndexMap;
use rustc_index::{IndexSlice, IndexVec};
use rustc_middle::ty::{self, Ty};
@@ -147,9 +146,7 @@ impl<'tcx, R> MemberConstraintSet<'tcx, R>
where
R: Copy + Hash + Eq,
{
- pub(crate) fn all_indices(
- &self,
- ) -> impl Iterator<Item = NllMemberConstraintIndex> + Captures<'tcx> + '_ {
+ pub(crate) fn all_indices(&self) -> impl Iterator<Item = NllMemberConstraintIndex> {
self.constraints.indices()
}
@@ -159,7 +156,7 @@ where
pub(crate) fn indices(
&self,
member_region_vid: R,
- ) -> impl Iterator<Item = NllMemberConstraintIndex> + Captures<'tcx> + '_ {
+ ) -> impl Iterator<Item = NllMemberConstraintIndex> {
let mut next = self.first_constraints.get(&member_region_vid).cloned();
std::iter::from_fn(move || -> Option<NllMemberConstraintIndex> {
if let Some(current) = next {
diff --git a/compiler/rustc_borrowck/src/polonius/loan_liveness.rs b/compiler/rustc_borrowck/src/polonius/loan_liveness.rs
index 768c12a97a64..5cd265e0db92 100644
--- a/compiler/rustc_borrowck/src/polonius/loan_liveness.rs
+++ b/compiler/rustc_borrowck/src/polonius/loan_liveness.rs
@@ -175,7 +175,7 @@ impl LocalizedConstraintGraph {
}
/// Returns the outgoing edges of a given node, not its transitive closure.
- fn outgoing_edges(&self, node: LocalizedNode) -> impl Iterator<Item = LocalizedNode> + use<'_> {
+ fn outgoing_edges(&self, node: LocalizedNode) -> impl Iterator<Item = LocalizedNode> {
// The outgoing edges are:
// - the physical edges present at this node,
// - the materialized logical edges that exist virtually at all points for this node's
diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
index e0e3e028c612..a00fce08c9ba 100644
--- a/compiler/rustc_borrowck/src/region_infer/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -576,9 +576,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
/// Returns an iterator over all the outlives constraints.
- pub(crate) fn outlives_constraints(
- &self,
- ) -> impl Iterator<Item = OutlivesConstraint<'tcx>> + '_ {
+ pub(crate) fn outlives_constraints(&self) -> impl Iterator<Item = OutlivesConstraint<'tcx>> {
self.constraints.outlives().iter().copied()
}
@@ -615,10 +613,10 @@ impl<'tcx> RegionInferenceContext<'tcx> {
self.scc_values.region_value_str(scc)
}
- pub(crate) fn placeholders_contained_in<'a>(
- &'a self,
+ pub(crate) fn placeholders_contained_in(
+ &self,
r: RegionVid,
- ) -> impl Iterator<Item = ty::PlaceholderRegion> + 'a {
+ ) -> impl Iterator<Item = ty::PlaceholderRegion> {
let scc = self.constraint_sccs.scc(r);
self.scc_values.placeholders_contained_in(scc)
}
diff --git a/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs b/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs
index d0cfe572d087..b2ed8a358279 100644
--- a/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs
+++ b/compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs
@@ -20,10 +20,7 @@ pub(crate) struct ReverseSccGraph {
impl ReverseSccGraph {
/// Find all universal regions that are required to outlive the given SCC.
- pub(super) fn upper_bounds<'a>(
- &'a self,
- scc0: ConstraintSccIndex,
- ) -> impl Iterator<Item = RegionVid> + 'a {
+ pub(super) fn upper_bounds(&self, scc0: ConstraintSccIndex) -> impl Iterator<Item = RegionVid> {
let mut duplicates = FxIndexSet::default();
graph::depth_first_search(&self.graph, scc0)
.flat_map(move |scc1| {
diff --git a/compiler/rustc_borrowck/src/region_infer/values.rs b/compiler/rustc_borrowck/src/region_infer/values.rs
index f1bcb353dc61..d9ac5b5cb132 100644
--- a/compiler/rustc_borrowck/src/region_infer/values.rs
+++ b/compiler/rustc_borrowck/src/region_infer/values.rs
@@ -88,7 +88,7 @@ impl LivenessValues {
}
/// Iterate through each region that has a value in this set.
- pub(crate) fn regions(&self) -> impl Iterator<Item = RegionVid> + '_ {
+ pub(crate) fn regions(&self) -> impl Iterator<Item = RegionVid> {
self.points.as_ref().expect("use with_specific_points").rows()
}
@@ -96,7 +96,7 @@ impl LivenessValues {
// We are passing query instability implications to the caller.
#[rustc_lint_query_instability]
#[allow(rustc::potential_query_instability)]
- pub(crate) fn live_regions_unordered(&self) -> impl Iterator<Item = RegionVid> + '_ {
+ pub(crate) fn live_regions_unordered(&self) -> impl Iterator<Item = RegionVid> {
self.live_regions.as_ref().unwrap().iter().copied()
}
@@ -143,7 +143,7 @@ impl LivenessValues {
}
/// Returns an iterator of all the points where `region` is live.
- fn live_points(&self, region: RegionVid) -> impl Iterator<Item = PointIndex> + '_ {
+ fn live_points(&self, region: RegionVid) -> impl Iterator<Item = PointIndex> {
let Some(points) = &self.points else {
unreachable!(
"Should be using LivenessValues::with_specific_points to ask whether live at a location"
@@ -340,7 +340,7 @@ impl<N: Idx> RegionValues<N> {
}
/// Returns the locations contained within a given region `r`.
- pub(crate) fn locations_outlived_by<'a>(&'a self, r: N) -> impl Iterator<Item = Location> + 'a {
+ pub(crate) fn locations_outlived_by(&self, r: N) -> impl Iterator<Item = Location> {
self.points.row(r).into_iter().flat_map(move |set| {
set.iter()
.take_while(move |&p| self.location_map.point_in_range(p))
@@ -349,18 +349,15 @@ impl<N: Idx> RegionValues<N> {
}
/// Returns just the universal regions that are contained in a given region's value.
- pub(crate) fn universal_regions_outlived_by<'a>(
- &'a self,
- r: N,
- ) -> impl Iterator<Item = RegionVid> + 'a {
+ pub(crate) fn universal_regions_outlived_by(&self, r: N) -> impl Iterator<Item = RegionVid> {
self.free_regions.row(r).into_iter().flat_map(|set| set.iter())
}
/// Returns all the elements contained in a given region's value.
- pub(crate) fn placeholders_contained_in<'a>(
- &'a self,
+ pub(crate) fn placeholders_contained_in(
+ &self,
r: N,
- ) -> impl Iterator<Item = ty::PlaceholderRegion> + 'a {
+ ) -> impl Iterator<Item = ty::PlaceholderRegion> {
self.placeholders
.row(r)
.into_iter()
@@ -369,10 +366,7 @@ impl<N: Idx> RegionValues<N> {
}
/// Returns all the elements contained in a given region's value.
- pub(crate) fn elements_contained_in<'a>(
- &'a self,
- r: N,
- ) -> impl Iterator<Item = RegionElement> + 'a {
+ pub(crate) fn elements_contained_in(&self, r: N) -> impl Iterator<Item = RegionElement> {
let points_iter = self.locations_outlived_by(r).map(RegionElement::Location);
let free_regions_iter =
diff --git a/compiler/rustc_borrowck/src/type_check/free_region_relations.rs b/compiler/rustc_borrowck/src/type_check/free_region_relations.rs
index efbae1e15353..eaac633b512d 100644
--- a/compiler/rustc_borrowck/src/type_check/free_region_relations.rs
+++ b/compiler/rustc_borrowck/src/type_check/free_region_relations.rs
@@ -172,7 +172,7 @@ impl UniversalRegionRelations<'_> {
}
/// Returns the _non-transitive_ set of known `outlives` constraints between free regions.
- pub(crate) fn known_outlives(&self) -> impl Iterator<Item = (RegionVid, RegionVid)> + '_ {
+ pub(crate) fn known_outlives(&self) -> impl Iterator<Item = (RegionVid, RegionVid)> {
self.outlives.base_edges()
}
}
diff --git a/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs b/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs
index 6182b68f6f41..9591da83708b 100644
--- a/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs
+++ b/compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs
@@ -54,7 +54,7 @@ rustc_index::newtype_index! {
fn appearances_iter(
first: Option<AppearanceIndex>,
appearances: &Appearances,
-) -> impl Iterator<Item = AppearanceIndex> + '_ {
+) -> impl Iterator<Item = AppearanceIndex> {
AppearancesIter { appearances, current: first }
}
@@ -107,17 +107,17 @@ impl LocalUseMap {
local_use_map
}
- pub(crate) fn defs(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
+ pub(crate) fn defs(&self, local: Local) -> impl Iterator<Item = PointIndex> {
appearances_iter(self.first_def_at[local], &self.appearances)
.map(move |aa| self.appearances[aa].point_index)
}
- pub(crate) fn uses(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
+ pub(crate) fn uses(&self, local: Local) -> impl Iterator<Item = PointIndex> {
appearances_iter(self.first_use_at[local], &self.appearances)
.map(move |aa| self.appearances[aa].point_index)
}
- pub(crate) fn drops(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
+ pub(crate) fn drops(&self, local: Local) -> impl Iterator<Item = PointIndex> {
appearances_iter(self.first_drop_at[local], &self.appearances)
.map(move |aa| self.appearances[aa].point_index)
}
diff --git a/compiler/rustc_borrowck/src/universal_regions.rs b/compiler/rustc_borrowck/src/universal_regions.rs
index c578eb4dc458..b39ead66e95c 100644
--- a/compiler/rustc_borrowck/src/universal_regions.rs
+++ b/compiler/rustc_borrowck/src/universal_regions.rs
@@ -308,7 +308,7 @@ impl<'tcx> UniversalRegions<'tcx> {
/// Returns an iterator over all the RegionVids corresponding to
/// universally quantified free regions.
- pub(crate) fn universal_regions_iter(&self) -> impl Iterator<Item = RegionVid> + use<> {
+ pub(crate) fn universal_regions_iter(&self) -> impl Iterator<Item = RegionVid> + 'static {
(FIRST_GLOBAL_INDEX..self.num_universals).map(RegionVid::from_usize)
}
@@ -332,9 +332,9 @@ impl<'tcx> UniversalRegions<'tcx> {
}
/// Gets an iterator over all the early-bound regions that have names.
- pub(crate) fn named_universal_regions_iter<'s>(
- &'s self,
- ) -> impl Iterator<Item = (ty::Region<'tcx>, ty::RegionVid)> + 's {
+ pub(crate) fn named_universal_regions_iter(
+ &self,
+ ) -> impl Iterator<Item = (ty::Region<'tcx>, ty::RegionVid)> {
self.indices.indices.iter().map(|(&r, &v)| (r, v))
}
diff --git a/compiler/rustc_const_eval/src/interpret/intern.rs b/compiler/rustc_const_eval/src/interpret/intern.rs
index e14cc1dad363..43631330f89b 100644
--- a/compiler/rustc_const_eval/src/interpret/intern.rs
+++ b/compiler/rustc_const_eval/src/interpret/intern.rs
@@ -61,8 +61,8 @@ impl HasStaticRootDefId for const_eval::CompileTimeMachine<'_> {
/// already mutable (as a sanity check).
///
/// Returns an iterator over all relocations referred to by this allocation.
-fn intern_shallow<'rt, 'tcx, T, M: CompileTimeMachine<'tcx, T>>(
- ecx: &'rt mut InterpCx<'tcx, M>,
+fn intern_shallow<'tcx, T, M: CompileTimeMachine<'tcx, T>>(
+ ecx: &mut InterpCx<'tcx, M>,
alloc_id: AllocId,
mutability: Mutability,
) -> Result<impl Iterator<Item = CtfeProvenance> + 'tcx, ()> {
diff --git a/compiler/rustc_data_structures/src/graph/implementation/mod.rs b/compiler/rustc_data_structures/src/graph/implementation/mod.rs
index 7724e9347d82..a80365938b96 100644
--- a/compiler/rustc_data_structures/src/graph/implementation/mod.rs
+++ b/compiler/rustc_data_structures/src/graph/implementation/mod.rs
@@ -193,11 +193,11 @@ impl<N: Debug, E: Debug> Graph<N, E> {
AdjacentEdges { graph: self, direction, next: first_edge }
}
- pub fn successor_nodes(&self, source: NodeIndex) -> impl Iterator<Item = NodeIndex> + '_ {
+ pub fn successor_nodes(&self, source: NodeIndex) -> impl Iterator<Item = NodeIndex> {
self.outgoing_edges(source).targets()
}
- pub fn predecessor_nodes(&self, target: NodeIndex) -> impl Iterator<Item = NodeIndex> + '_ {
+ pub fn predecessor_nodes(&self, target: NodeIndex) -> impl Iterator<Item = NodeIndex> {
self.incoming_edges(target).sources()
}
@@ -255,11 +255,11 @@ pub struct AdjacentEdges<'g, N, E> {
}
impl<'g, N: Debug, E: Debug> AdjacentEdges<'g, N, E> {
- fn targets(self) -> impl Iterator<Item = NodeIndex> + 'g {
+ fn targets(self) -> impl Iterator<Item = NodeIndex> {
self.map(|(_, edge)| edge.target)
}
- fn sources(self) -> impl Iterator<Item = NodeIndex> + 'g {
+ fn sources(self) -> impl Iterator<Item = NodeIndex> {
self.map(|(_, edge)| edge.source)
}
}
diff --git a/compiler/rustc_data_structures/src/graph/scc/mod.rs b/compiler/rustc_data_structures/src/graph/scc/mod.rs
index 2241b538738c..e7c4ea3daae4 100644
--- a/compiler/rustc_data_structures/src/graph/scc/mod.rs
+++ b/compiler/rustc_data_structures/src/graph/scc/mod.rs
@@ -133,7 +133,7 @@ impl<N: Idx, S: Idx + Ord, A: Annotation> Sccs<N, S, A> {
/// meaning that if `S1 -> S2`, we will visit `S2` first and `S1` after.
/// This is convenient when the edges represent dependencies: when you visit
/// `S1`, the value for `S2` will already have been computed.
- pub fn all_sccs(&self) -> impl Iterator<Item = S> + use<N, S, A> {
+ pub fn all_sccs(&self) -> impl Iterator<Item = S> + 'static {
(0..self.scc_data.len()).map(S::new)
}
diff --git a/compiler/rustc_data_structures/src/sorted_map/index_map.rs b/compiler/rustc_data_structures/src/sorted_map/index_map.rs
index e9a5fb519754..1654867739f0 100644
--- a/compiler/rustc_data_structures/src/sorted_map/index_map.rs
+++ b/compiler/rustc_data_structures/src/sorted_map/index_map.rs
@@ -84,7 +84,7 @@ impl<I: Idx, K: Ord, V> SortedIndexMultiMap<I, K, V> {
/// If there are multiple items that are equivalent to `key`, they will be yielded in
/// insertion order.
#[inline]
- pub fn get_by_key(&self, key: K) -> impl Iterator<Item = &V> + '_ {
+ pub fn get_by_key(&self, key: K) -> impl Iterator<Item = &V> {
self.get_by_key_enumerated(key).map(|(_, v)| v)
}
@@ -94,7 +94,7 @@ impl<I: Idx, K: Ord, V> SortedIndexMultiMap<I, K, V> {
/// If there are multiple items that are equivalent to `key`, they will be yielded in
/// insertion order.
#[inline]
- pub fn get_by_key_enumerated(&self, key: K) -> impl Iterator<Item = (I, &V)> + '_ {
+ pub fn get_by_key_enumerated(&self, key: K) -> impl Iterator<Item = (I, &V)> {
let lower_bound = self.idx_sorted_by_item_key.partition_point(|&i| self.items[i].0 < key);
self.idx_sorted_by_item_key[lower_bound..].iter().map_while(move |&i| {
let (k, v) = &self.items[i];
diff --git a/compiler/rustc_data_structures/src/sso/map.rs b/compiler/rustc_data_structures/src/sso/map.rs
index 3200249a2dc4..827c82fa46a1 100644
--- a/compiler/rustc_data_structures/src/sso/map.rs
+++ b/compiler/rustc_data_structures/src/sso/map.rs
@@ -165,7 +165,7 @@ impl<K, V> SsoHashMap<K, V> {
/// Clears the map, returning all key-value pairs as an iterator. Keeps the
/// allocated memory for reuse.
- pub fn drain(&mut self) -> impl Iterator<Item = (K, V)> + '_ {
+ pub fn drain(&mut self) -> impl Iterator<Item = (K, V)> {
match self {
SsoHashMap::Array(array) => Either::Left(array.drain(..)),
SsoHashMap::Map(map) => Either::Right(map.drain()),
diff --git a/compiler/rustc_data_structures/src/sso/set.rs b/compiler/rustc_data_structures/src/sso/set.rs
index a4b40138933d..e3fa1cbf4cc5 100644
--- a/compiler/rustc_data_structures/src/sso/set.rs
+++ b/compiler/rustc_data_structures/src/sso/set.rs
@@ -80,7 +80,7 @@ impl<T> SsoHashSet<T> {
/// Clears the set, returning all elements in an iterator.
#[inline]
- pub fn drain(&mut self) -> impl Iterator<Item = T> + '_ {
+ pub fn drain(&mut self) -> impl Iterator<Item = T> {
self.map.drain().map(entry_to_key)
}
}
diff --git a/compiler/rustc_data_structures/src/sync/vec.rs b/compiler/rustc_data_structures/src/sync/vec.rs
index 21ec5cf6c13b..afbb0cef9f95 100644
--- a/compiler/rustc_data_structures/src/sync/vec.rs
+++ b/compiler/rustc_data_structures/src/sync/vec.rs
@@ -45,14 +45,14 @@ impl<T: Copy> AppendOnlyVec<T> {
self.vec.read().get(i).copied()
}
- pub fn iter_enumerated(&self) -> impl Iterator<Item = (usize, T)> + '_ {
+ pub fn iter_enumerated(&self) -> impl Iterator<Item = (usize, T)> {
(0..)
.map(|i| (i, self.get(i)))
.take_while(|(_, o)| o.is_some())
.filter_map(|(i, o)| Some((i, o?)))
}
- pub fn iter(&self) -> impl Iterator<Item = T> + '_ {
+ pub fn iter(&self) -> impl Iterator<Item = T> {
(0..).map(|i| self.get(i)).take_while(|o| o.is_some()).flatten()
}
}
diff --git a/compiler/rustc_data_structures/src/transitive_relation.rs b/compiler/rustc_data_structures/src/transitive_relation.rs
index e81ebb9a4be2..33ac279f3e0a 100644
--- a/compiler/rustc_data_structures/src/transitive_relation.rs
+++ b/compiler/rustc_data_structures/src/transitive_relation.rs
@@ -363,7 +363,7 @@ impl<T: Eq + Hash + Copy> TransitiveRelation<T> {
/// Lists all the base edges in the graph: the initial _non-transitive_ set of element
/// relations, which will be later used as the basis for the transitive closure computation.
- pub fn base_edges(&self) -> impl Iterator<Item = (T, T)> + '_ {
+ pub fn base_edges(&self) -> impl Iterator<Item = (T, T)> {
self.edges
.iter()
.map(move |edge| (self.elements[edge.source.0], self.elements[edge.target.0]))
diff --git a/compiler/rustc_expand/src/proc_macro.rs b/compiler/rustc_expand/src/proc_macro.rs
index 814d2b04d8d0..a6cdeaee176f 100644
--- a/compiler/rustc_expand/src/proc_macro.rs
+++ b/compiler/rustc_expand/src/proc_macro.rs
@@ -31,7 +31,7 @@ impl<T> pm::bridge::server::MessagePipe<T> for MessagePipe<T> {
}
}
-fn exec_strategy(ecx: &ExtCtxt<'_>) -> impl pm::bridge::server::ExecutionStrategy + use<> {
+fn exec_strategy(ecx: &ExtCtxt<'_>) -> impl pm::bridge::server::ExecutionStrategy + 'static {
pm::bridge::server::MaybeCrossThread::<MessagePipe<_>>::new(
ecx.sess.opts.unstable_opts.proc_macro_execution_strategy
== ProcMacroExecutionStrategy::CrossThread,
diff --git a/compiler/rustc_hir/src/definitions.rs b/compiler/rustc_hir/src/definitions.rs
index 08a0a5225e74..c4c309e77e19 100644
--- a/compiler/rustc_hir/src/definitions.rs
+++ b/compiler/rustc_hir/src/definitions.rs
@@ -93,7 +93,7 @@ impl DefPathTable {
pub fn enumerated_keys_and_path_hashes(
&self,
- ) -> impl Iterator<Item = (DefIndex, &DefKey, DefPathHash)> + ExactSizeIterator + '_ {
+ ) -> impl Iterator<Item = (DefIndex, &DefKey, DefPathHash)> + ExactSizeIterator {
self.index_to_key
.iter_enumerated()
.map(move |(index, key)| (index, key, self.def_path_hash(index)))
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 34c0837b25a5..f5626937ec45 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -60,7 +60,7 @@ impl LanguageItems {
self.reverse_items.get(&def_id).copied()
}
- pub fn iter(&self) -> impl Iterator<Item = (LangItem, DefId)> + '_ {
+ pub fn iter(&self) -> impl Iterator<Item = (LangItem, DefId)> {
self.items
.iter()
.enumerate()
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 5bb77c096dcf..1a89c9dedc52 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -20,7 +20,6 @@ use std::ops::Bound;
use rustc_abi::ExternAbi;
use rustc_ast::Recovered;
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
use rustc_data_structures::unord::UnordMap;
use rustc_errors::{
@@ -1690,10 +1689,10 @@ fn polarity_of_impl(
/// the lifetimes that are declared. For fns or methods, we have to
/// screen out those that do not appear in any where-clauses etc using
/// `resolve_lifetime::early_bound_lifetimes`.
-fn early_bound_lifetimes_from_generics<'a, 'tcx: 'a>(
+fn early_bound_lifetimes_from_generics<'a, 'tcx>(
tcx: TyCtxt<'tcx>,
generics: &'a hir::Generics<'a>,
-) -> impl Iterator<Item = &'a hir::GenericParam<'a>> + Captures<'tcx> {
+) -> impl Iterator<Item = &'a hir::GenericParam<'a>> {
generics.params.iter().filter(move |param| match param.kind {
GenericParamKind::Lifetime { .. } => !tcx.is_late_bound(param.hir_id),
_ => false,
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
index fee3c6088ede..efd65ba3cc40 100644
--- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
+++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -160,7 +160,7 @@ enum Scope<'a> {
impl<'a> Scope<'a> {
// A helper for debugging scopes without printing parent scopes
- fn debug_truncated(&'a self) -> impl fmt::Debug + 'a {
+ fn debug_truncated(&self) -> impl fmt::Debug {
fmt::from_fn(move |f| match self {
Self::Binder { bound_vars, scope_type, hir_id, where_bound_origin, s: _ } => f
.debug_struct("Binder")
@@ -2159,10 +2159,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
/// Walk the generics of the item for a trait bound whose self type
/// corresponds to the expected res, and return the trait def id.
- fn for_each_trait_bound_on_res(
- &self,
- expected_res: Res,
- ) -> impl Iterator<Item = DefId> + use<'tcx, '_> {
+ fn for_each_trait_bound_on_res(&self, expected_res: Res) -> impl Iterator<Item = DefId> {
std::iter::from_coroutine(
#[coroutine]
move || {
diff --git a/compiler/rustc_index/src/bit_set.rs b/compiler/rustc_index/src/bit_set.rs
index d7d90ea16e49..6dc044a6d380 100644
--- a/compiler/rustc_index/src/bit_set.rs
+++ b/compiler/rustc_index/src/bit_set.rs
@@ -1666,7 +1666,7 @@ impl<R: Idx, C: Idx> SparseBitMatrix<R, C> {
/// Iterates through all the columns set to true in a given row of
/// the matrix.
- pub fn iter(&self, row: R) -> impl Iterator<Item = C> + '_ {
+ pub fn iter(&self, row: R) -> impl Iterator<Item = C> {
self.row(row).into_iter().flat_map(|r| r.iter())
}
diff --git a/compiler/rustc_index/src/interval.rs b/compiler/rustc_index/src/interval.rs
index a3d87f59567f..0225c5c4f329 100644
--- a/compiler/rustc_index/src/interval.rs
+++ b/compiler/rustc_index/src/interval.rs
@@ -51,7 +51,7 @@ impl<I: Idx> IntervalSet<I> {
self.map.clear();
}
- pub fn iter(&self) -> impl Iterator<Item = I> + '_
+ pub fn iter(&self) -> impl Iterator<Item = I>
where
I: Step,
{
@@ -59,7 +59,7 @@ impl<I: Idx> IntervalSet<I> {
}
/// Iterates through intervals stored in the set, in order.
- pub fn iter_intervals(&self) -> impl Iterator<Item = std::ops::Range<I>> + '_
+ pub fn iter_intervals(&self) -> impl Iterator<Item = std::ops::Range<I>>
where
I: Step,
{
diff --git a/compiler/rustc_index/src/slice.rs b/compiler/rustc_index/src/slice.rs
index 956d32c9a694..4636f294f13b 100644
--- a/compiler/rustc_index/src/slice.rs
+++ b/compiler/rustc_index/src/slice.rs
@@ -63,9 +63,7 @@ impl<I: Idx, T> IndexSlice<I, T> {
}
#[inline]
- pub fn iter_enumerated(
- &self,
- ) -> impl DoubleEndedIterator<Item = (I, &T)> + ExactSizeIterator + '_ {
+ pub fn iter_enumerated(&self) -> impl DoubleEndedIterator<Item = (I, &T)> + ExactSizeIterator {
self.raw.iter().enumerate().map(|(n, t)| (I::new(n), t))
}
@@ -84,7 +82,7 @@ impl<I: Idx, T> IndexSlice<I, T> {
#[inline]
pub fn iter_enumerated_mut(
&mut self,
- ) -> impl DoubleEndedIterator<Item = (I, &mut T)> + ExactSizeIterator + '_ {
+ ) -> impl DoubleEndedIterator<Item = (I, &mut T)> + ExactSizeIterator {
self.raw.iter_mut().enumerate().map(|(n, t)| (I::new(n), t))
}
diff --git a/compiler/rustc_index/src/vec.rs b/compiler/rustc_index/src/vec.rs
index 1cb8bc861af9..7f3f3ead5f2a 100644
--- a/compiler/rustc_index/src/vec.rs
+++ b/compiler/rustc_index/src/vec.rs
@@ -132,7 +132,7 @@ impl<I: Idx, T> IndexVec<I, T> {
}
#[inline]
- pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> impl Iterator<Item = T> + '_ {
+ pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> impl Iterator<Item = T> {
self.raw.drain(range)
}
@@ -140,7 +140,7 @@ impl<I: Idx, T> IndexVec<I, T> {
pub fn drain_enumerated<R: RangeBounds<usize>>(
&mut self,
range: R,
- ) -> impl Iterator<Item = (I, T)> + '_ {
+ ) -> impl Iterator<Item = (I, T)> {
let begin = match range.start_bound() {
std::ops::Bound::Included(i) => *i,
std::ops::Bound::Excluded(i) => i.checked_add(1).unwrap(),
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
index 23f63af778d0..8a61631c69c0 100644
--- a/compiler/rustc_infer/src/infer/canonical/query_response.rs
+++ b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -10,7 +10,6 @@
use std::fmt::Debug;
use std::iter;
-use rustc_data_structures::captures::Captures;
use rustc_index::{Idx, IndexVec};
use rustc_middle::arena::ArenaAllocatable;
use rustc_middle::mir::ConstraintCategory;
@@ -541,13 +540,13 @@ impl<'tcx> InferCtxt<'tcx> {
/// Converts the region constraints resulting from a query into an
/// iterator of obligations.
- fn query_outlives_constraints_into_obligations<'a>(
- &'a self,
- cause: &'a ObligationCause<'tcx>,
+ fn query_outlives_constraints_into_obligations(
+ &self,
+ cause: &ObligationCause<'tcx>,
param_env: ty::ParamEnv<'tcx>,
- uninstantiated_region_constraints: &'a [QueryOutlivesConstraint<'tcx>],
- result_args: &'a CanonicalVarValues<'tcx>,
- ) -> impl Iterator<Item = PredicateObligation<'tcx>> + 'a + Captures<'tcx> {
+ uninstantiated_region_constraints: &[QueryOutlivesConstraint<'tcx>],
+ result_args: &CanonicalVarValues<'tcx>,
+ ) -> impl Iterator<Item = PredicateObligation<'tcx>> {
uninstantiated_region_constraints.iter().map(move |&constraint| {
let predicate = instantiate_value(self.tcx, result_args, constraint);
self.query_outlives_constraint_to_obligation(predicate, cause.clone(), param_env)
diff --git a/compiler/rustc_infer/src/infer/free_regions.rs b/compiler/rustc_infer/src/infer/free_regions.rs
index 5452ba67497b..8fa5361121c6 100644
--- a/compiler/rustc_infer/src/infer/free_regions.rs
+++ b/compiler/rustc_infer/src/infer/free_regions.rs
@@ -38,7 +38,7 @@ pub struct FreeRegionMap<'tcx> {
}
impl<'tcx> FreeRegionMap<'tcx> {
- pub fn elements(&self) -> impl Iterator<Item = Region<'tcx>> + '_ {
+ pub fn elements(&self) -> impl Iterator<Item = Region<'tcx>> {
self.relation.elements().copied()
}
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index de49c246c155..537e8119adaf 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -15,7 +15,6 @@ use region_constraints::{
};
pub use relate::StructurallyRelateAliases;
pub use relate::combine::PredicateEmittingRelation;
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
use rustc_data_structures::undo_log::{Rollback, UndoLogs};
use rustc_data_structures::unify as ut;
@@ -233,7 +232,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
// while looping through this.
pub fn iter_opaque_types(
&self,
- ) -> impl Iterator<Item = (ty::OpaqueTypeKey<'tcx>, ty::OpaqueHiddenType<'tcx>)> + '_ {
+ ) -> impl Iterator<Item = (ty::OpaqueTypeKey<'tcx>, ty::OpaqueHiddenType<'tcx>)> {
self.opaque_type_storage.opaque_types.iter().map(|(&k, &v)| (k, v))
}
}
@@ -1295,9 +1294,7 @@ impl<'tcx> InferCtxt<'tcx> {
/// The returned function is used in a fast path. If it returns `true` the variable is
/// unchanged, `false` indicates that the status is unknown.
#[inline]
- pub fn is_ty_infer_var_definitely_unchanged<'a>(
- &'a self,
- ) -> (impl Fn(TyOrConstInferVar) -> bool + Captures<'tcx> + 'a) {
+ pub fn is_ty_infer_var_definitely_unchanged(&self) -> impl Fn(TyOrConstInferVar) -> bool {
// This hoists the borrow/release out of the loop body.
let inner = self.inner.try_borrow();
diff --git a/compiler/rustc_infer/src/infer/outlives/mod.rs b/compiler/rustc_infer/src/infer/outlives/mod.rs
index 1afe50e336da..2a4544c1140d 100644
--- a/compiler/rustc_infer/src/infer/outlives/mod.rs
+++ b/compiler/rustc_infer/src/infer/outlives/mod.rs
@@ -20,7 +20,7 @@ pub(crate) mod verify;
#[instrument(level = "debug", skip(param_env), ret)]
pub fn explicit_outlives_bounds<'tcx>(
param_env: ty::ParamEnv<'tcx>,
-) -> impl Iterator<Item = OutlivesBound<'tcx>> + 'tcx {
+) -> impl Iterator<Item = OutlivesBound<'tcx>> {
param_env
.caller_bounds()
.into_iter()
diff --git a/compiler/rustc_lexer/src/lib.rs b/compiler/rustc_lexer/src/lib.rs
index c63ab77decac..bf18845a0830 100644
--- a/compiler/rustc_lexer/src/lib.rs
+++ b/compiler/rustc_lexer/src/lib.rs
@@ -291,7 +291,7 @@ pub fn validate_raw_str(input: &str, prefix_len: u32) -> Result<(), RawStrError>
}
/// Creates an iterator that produces tokens from the input string.
-pub fn tokenize(input: &str) -> impl Iterator<Item = Token> + '_ {
+pub fn tokenize(input: &str) -> impl Iterator<Item = Token> {
let mut cursor = Cursor::new(input);
std::iter::from_fn(move || {
let token = cursor.advance_token();
diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs
index c74158102c7a..74663e6b4bbe 100644
--- a/compiler/rustc_lint/src/context.rs
+++ b/compiler/rustc_lint/src/context.rs
@@ -139,9 +139,7 @@ impl LintStore {
&self.lints
}
- pub fn get_lint_groups<'t>(
- &'t self,
- ) -> impl Iterator<Item = (&'static str, Vec<LintId>, bool)> + 't {
+ pub fn get_lint_groups(&self) -> impl Iterator<Item = (&'static str, Vec<LintId>, bool)> {
self.lint_groups
.iter()
.filter(|(_, LintGroup { depr, .. })| {
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index e8dcda875e67..0604892e34d5 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -8,7 +8,6 @@ use std::{io, iter, mem};
pub(super) use cstore_impl::provide;
use proc_macro::bridge::client::ProcMacro;
use rustc_ast as ast;
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::fx::FxIndexMap;
use rustc_data_structures::owned_slice::OwnedSlice;
@@ -963,14 +962,14 @@ impl CrateRoot {
pub(crate) fn decode_crate_deps<'a>(
&self,
metadata: &'a MetadataBlob,
- ) -> impl ExactSizeIterator<Item = CrateDep> + Captures<'a> {
+ ) -> impl ExactSizeIterator<Item = CrateDep> {
self.crate_deps.decode(metadata)
}
pub(crate) fn decode_target_modifiers<'a>(
&self,
metadata: &'a MetadataBlob,
- ) -> impl ExactSizeIterator<Item = TargetModifier> + Captures<'a> {
+ ) -> impl ExactSizeIterator<Item = TargetModifier> {
self.target_modifiers.decode(metadata)
}
}
@@ -1276,7 +1275,7 @@ impl<'a> CrateMetadataRef<'a> {
self,
id: DefIndex,
sess: &'a Session,
- ) -> impl Iterator<Item = ModChild> + 'a {
+ ) -> impl Iterator<Item = ModChild> {
iter::from_coroutine(
#[coroutine]
move || {
@@ -1326,10 +1325,7 @@ impl<'a> CrateMetadataRef<'a> {
.is_some_and(|ident| ident.name == kw::SelfLower)
}
- fn get_associated_item_or_field_def_ids(
- self,
- id: DefIndex,
- ) -> impl Iterator<Item = DefId> + 'a {
+ fn get_associated_item_or_field_def_ids(self, id: DefIndex) -> impl Iterator<Item = DefId> {
self.root
.tables
.associated_item_or_field_def_ids
@@ -1380,7 +1376,7 @@ impl<'a> CrateMetadataRef<'a> {
self,
id: DefIndex,
sess: &'a Session,
- ) -> impl Iterator<Item = hir::Attribute> + 'a {
+ ) -> impl Iterator<Item = hir::Attribute> {
self.root
.tables
.attributes
@@ -1417,12 +1413,12 @@ impl<'a> CrateMetadataRef<'a> {
}
/// Decodes all traits in the crate (for rustdoc and rustc diagnostics).
- fn get_traits(self) -> impl Iterator<Item = DefId> + 'a {
+ fn get_traits(self) -> impl Iterator<Item = DefId> {
self.root.traits.decode(self).map(move |index| self.local_def_id(index))
}
/// Decodes all trait impls in the crate (for rustdoc).
- fn get_trait_impls(self) -> impl Iterator<Item = DefId> + 'a {
+ fn get_trait_impls(self) -> impl Iterator<Item = DefId> {
self.cdata.trait_impls.values().flat_map(move |impls| {
impls.decode(self).map(move |(impl_index, _)| self.local_def_id(impl_index))
})
@@ -1463,7 +1459,7 @@ impl<'a> CrateMetadataRef<'a> {
}
}
- fn get_native_libraries(self, sess: &'a Session) -> impl Iterator<Item = NativeLib> + 'a {
+ fn get_native_libraries(self, sess: &'a Session) -> impl Iterator<Item = NativeLib> {
self.root.native_libraries.decode((self, sess))
}
@@ -1476,7 +1472,7 @@ impl<'a> CrateMetadataRef<'a> {
.decode((self, sess))
}
- fn get_foreign_modules(self, sess: &'a Session) -> impl Iterator<Item = ForeignModule> + 'a {
+ fn get_foreign_modules(self, sess: &'a Session) -> impl Iterator<Item = ForeignModule> {
self.root.foreign_modules.decode((self, sess))
}
@@ -1816,7 +1812,7 @@ impl<'a> CrateMetadataRef<'a> {
.decode(self)
}
- fn get_doc_link_traits_in_scope(self, index: DefIndex) -> impl Iterator<Item = DefId> + 'a {
+ fn get_doc_link_traits_in_scope(self, index: DefIndex) -> impl Iterator<Item = DefId> {
self.root
.tables
.doc_link_traits_in_scope
@@ -1887,7 +1883,7 @@ impl CrateMetadata {
cdata
}
- pub(crate) fn dependencies(&self) -> impl Iterator<Item = CrateNum> + '_ {
+ pub(crate) fn dependencies(&self) -> impl Iterator<Item = CrateNum> {
self.dependencies.iter().copied()
}
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
index 40dd6aa73fd4..7d632f592aff 100644
--- a/compiler/rustc_middle/src/hir/map.rs
+++ b/compiler/rustc_middle/src/hir/map.rs
@@ -174,15 +174,12 @@ impl<'tcx> TyCtxt<'tcx> {
}
#[inline]
- pub fn hir_free_items(self) -> impl Iterator<Item = ItemId> + 'tcx {
+ pub fn hir_free_items(self) -> impl Iterator<Item = ItemId> {
self.hir_crate_items(()).free_items.iter().copied()
}
#[inline]
- pub fn hir_module_free_items(
- self,
- module: LocalModDefId,
- ) -> impl Iterator<Item = ItemId> + 'tcx {
+ pub fn hir_module_free_items(self, module: LocalModDefId) -> impl Iterator<Item = ItemId> {
self.hir_module_items(module).free_items()
}
@@ -283,7 +280,7 @@ impl<'tcx> TyCtxt<'tcx> {
})
}
- pub fn hir_body_param_names(self, id: BodyId) -> impl Iterator<Item = Ident> + 'tcx {
+ pub fn hir_body_param_names(self, id: BodyId) -> impl Iterator<Item = Ident> {
self.hir_body(id).params.iter().map(|arg| match arg.pat.kind {
PatKind::Binding(_, _, ident, _) => ident,
_ => Ident::empty(),
@@ -337,7 +334,7 @@ impl<'tcx> TyCtxt<'tcx> {
/// crate. If you would prefer to iterate over the bodies
/// themselves, you can do `self.hir().krate().body_ids.iter()`.
#[inline]
- pub fn hir_body_owners(self) -> impl Iterator<Item = LocalDefId> + 'tcx {
+ pub fn hir_body_owners(self) -> impl Iterator<Item = LocalDefId> {
self.hir_crate_items(()).body_owners.iter().copied()
}
@@ -502,7 +499,7 @@ impl<'tcx> TyCtxt<'tcx> {
/// Returns an iterator for the nodes in the ancestor tree of the `current_id`
/// until the crate root is reached. Prefer this over your own loop using `parent_id`.
#[inline]
- pub fn hir_parent_id_iter(self, current_id: HirId) -> impl Iterator<Item = HirId> + 'tcx {
+ pub fn hir_parent_id_iter(self, current_id: HirId) -> impl Iterator<Item = HirId> {
ParentHirIterator::new(self, current_id)
}
diff --git a/compiler/rustc_middle/src/hir/mod.rs b/compiler/rustc_middle/src/hir/mod.rs
index 2a201e230155..6071a58367ed 100644
--- a/compiler/rustc_middle/src/hir/mod.rs
+++ b/compiler/rustc_middle/src/hir/mod.rs
@@ -40,25 +40,25 @@ impl ModuleItems {
/// include foreign items. If you want to e.g. get all functions, use `definitions()` below.
///
/// However, this does include the `impl` blocks themselves.
- pub fn free_items(&self) -> impl Iterator<Item = ItemId> + '_ {
+ pub fn free_items(&self) -> impl Iterator<Item = ItemId> {
self.free_items.iter().copied()
}
- pub fn trait_items(&self) -> impl Iterator<Item = TraitItemId> + '_ {
+ pub fn trait_items(&self) -> impl Iterator<Item = TraitItemId> {
self.trait_items.iter().copied()
}
/// Returns all items that are associated with some `impl` block (both inherent and trait impl
/// blocks).
- pub fn impl_items(&self) -> impl Iterator<Item = ImplItemId> + '_ {
+ pub fn impl_items(&self) -> impl Iterator<Item = ImplItemId> {
self.impl_items.iter().copied()
}
- pub fn foreign_items(&self) -> impl Iterator<Item = ForeignItemId> + '_ {
+ pub fn foreign_items(&self) -> impl Iterator<Item = ForeignItemId> {
self.foreign_items.iter().copied()
}
- pub fn owners(&self) -> impl Iterator<Item = OwnerId> + '_ {
+ pub fn owners(&self) -> impl Iterator<Item = OwnerId> {
self.free_items
.iter()
.map(|id| id.owner_id)
@@ -67,15 +67,15 @@ impl ModuleItems {
.chain(self.foreign_items.iter().map(|id| id.owner_id))
}
- pub fn opaques(&self) -> impl Iterator<Item = LocalDefId> + '_ {
+ pub fn opaques(&self) -> impl Iterator<Item = LocalDefId> {
self.opaques.iter().copied()
}
- pub fn nested_bodies(&self) -> impl Iterator<Item = LocalDefId> + '_ {
+ pub fn nested_bodies(&self) -> impl Iterator<Item = LocalDefId> {
self.nested_bodies.iter().copied()
}
- pub fn definitions(&self) -> impl Iterator<Item = LocalDefId> + '_ {
+ pub fn definitions(&self) -> impl Iterator<Item = LocalDefId> {
self.owners().map(|id| id.def_id)
}
diff --git a/compiler/rustc_middle/src/hir/place.rs b/compiler/rustc_middle/src/hir/place.rs
index 66b701523b71..316ad80eb985 100644
--- a/compiler/rustc_middle/src/hir/place.rs
+++ b/compiler/rustc_middle/src/hir/place.rs
@@ -97,7 +97,7 @@ impl<'tcx> Place<'tcx> {
/// The types are in the reverse order that they are applied. So if
/// `x: &*const u32` and the `Place` is `**x`, then the types returned are
///`*const u32` then `&*const u32`.
- pub fn deref_tys(&self) -> impl Iterator<Item = Ty<'tcx>> + '_ {
+ pub fn deref_tys(&self) -> impl Iterator<Item = Ty<'tcx>> {
self.projections.iter().enumerate().rev().filter_map(move |(index, proj)| {
if ProjectionKind::Deref == proj.kind {
Some(self.ty_before_projection(index))
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
index 78196b053619..2f13f9635785 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
@@ -121,7 +121,7 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
}
/// Yields all the provenances stored in this map.
- pub fn provenances(&self) -> impl Iterator<Item = Prov> + '_ {
+ pub fn provenances(&self) -> impl Iterator<Item = Prov> {
let bytes = self.bytes.iter().flat_map(|b| b.values());
self.ptrs.values().chain(bytes).copied()
}
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 227cb97c76b5..cf90df1b198b 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -12,7 +12,6 @@ use either::Either;
use polonius_engine::Atom;
use rustc_abi::{FieldIdx, VariantIdx};
pub use rustc_ast::Mutability;
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::graph::dominators::Dominators;
use rustc_errors::{DiagArgName, DiagArgValue, DiagMessage, ErrorGuaranteed, IntoDiagArg};
@@ -472,7 +471,7 @@ impl<'tcx> Body<'tcx> {
/// Returns an iterator over all user-declared mutable locals.
#[inline]
- pub fn mut_vars_iter<'a>(&'a self) -> impl Iterator<Item = Local> + Captures<'tcx> + 'a {
+ pub fn mut_vars_iter(&self) -> impl Iterator<Item = Local> {
(self.arg_count + 1..self.local_decls.len()).filter_map(move |index| {
let local = Local::new(index);
let decl = &self.local_decls[local];
@@ -482,9 +481,7 @@ impl<'tcx> Body<'tcx> {
/// Returns an iterator over all user-declared mutable arguments and locals.
#[inline]
- pub fn mut_vars_and_args_iter<'a>(
- &'a self,
- ) -> impl Iterator<Item = Local> + Captures<'tcx> + 'a {
+ pub fn mut_vars_and_args_iter(&self) -> impl Iterator<Item = Local> {
(1..self.local_decls.len()).filter_map(move |index| {
let local = Local::new(index);
let decl = &self.local_decls[local];
@@ -514,7 +511,7 @@ impl<'tcx> Body<'tcx> {
}
#[inline]
- pub fn drain_vars_and_temps<'a>(&'a mut self) -> impl Iterator<Item = LocalDecl<'tcx>> + 'a {
+ pub fn drain_vars_and_temps(&mut self) -> impl Iterator<Item = LocalDecl<'tcx>> {
self.local_decls.drain(self.arg_count + 1..)
}
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 1d61cf48ad26..875f5282bf29 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1523,7 +1523,7 @@ pub fn write_allocations<'tcx>(
) -> io::Result<()> {
fn alloc_ids_from_alloc(
alloc: ConstAllocation<'_>,
- ) -> impl DoubleEndedIterator<Item = AllocId> + '_ {
+ ) -> impl DoubleEndedIterator<Item = AllocId> {
alloc.inner().provenance().ptrs().values().map(|p| p.alloc_id())
}
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
index b529d17540a8..3585f28b4a55 100644
--- a/compiler/rustc_middle/src/ty/adt.rs
+++ b/compiler/rustc_middle/src/ty/adt.rs
@@ -4,7 +4,6 @@ use std::ops::Range;
use std::str;
use rustc_abi::{FIRST_VARIANT, ReprOptions, VariantIdx};
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::intern::Interned;
@@ -540,7 +539,7 @@ impl<'tcx> AdtDef<'tcx> {
pub fn discriminants(
self,
tcx: TyCtxt<'tcx>,
- ) -> impl Iterator<Item = (VariantIdx, Discr<'tcx>)> + Captures<'tcx> {
+ ) -> impl Iterator<Item = (VariantIdx, Discr<'tcx>)> {
assert!(self.is_enum());
let repr_type = self.repr().discr_type();
let initial = repr_type.initial_discriminant(tcx);
diff --git a/compiler/rustc_middle/src/ty/closure.rs b/compiler/rustc_middle/src/ty/closure.rs
index c4d5367e2f03..3605f2402e7f 100644
--- a/compiler/rustc_middle/src/ty/closure.rs
+++ b/compiler/rustc_middle/src/ty/closure.rs
@@ -1,6 +1,5 @@
use std::fmt::Write;
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxIndexMap;
use rustc_hir as hir;
use rustc_hir::HirId;
@@ -415,7 +414,7 @@ pub fn analyze_coroutine_closure_captures<'a, 'tcx: 'a, T>(
parent_captures: impl IntoIterator<Item = &'a CapturedPlace<'tcx>>,
child_captures: impl IntoIterator<Item = &'a CapturedPlace<'tcx>>,
mut for_each: impl FnMut((usize, &'a CapturedPlace<'tcx>), (usize, &'a CapturedPlace<'tcx>)) -> T,
-) -> impl Iterator<Item = T> + Captures<'a> + Captures<'tcx> {
+) -> impl Iterator<Item = T> {
std::iter::from_coroutine(
#[coroutine]
move || {
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 32a9e67f9ad5..d20e8bd42e69 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -1939,7 +1939,7 @@ impl<'tcx> TyCtxt<'tcx> {
Ok(TyCtxtFeed { key: num, tcx: self })
}
- pub fn iter_local_def_id(self) -> impl Iterator<Item = LocalDefId> + 'tcx {
+ pub fn iter_local_def_id(self) -> impl Iterator<Item = LocalDefId> {
// Create a dependency to the red node to be sure we re-execute this when the amount of
// definitions change.
self.dep_graph.read_index(DepNodeIndex::FOREVER_RED_NODE);
@@ -2171,14 +2171,14 @@ impl<'tcx> TyCtxt<'tcx> {
}
/// All traits in the crate graph, including those not visible to the user.
- pub fn all_traits(self) -> impl Iterator<Item = DefId> + 'tcx {
+ pub fn all_traits(self) -> impl Iterator<Item = DefId> {
iter::once(LOCAL_CRATE)
.chain(self.crates(()).iter().copied())
.flat_map(move |cnum| self.traits(cnum).iter().copied())
}
/// All traits that are visible within the crate graph (i.e. excluding private dependencies).
- pub fn visible_traits(self) -> impl Iterator<Item = DefId> + 'tcx {
+ pub fn visible_traits(self) -> impl Iterator<Item = DefId> {
let visible_crates =
self.crates(()).iter().copied().filter(move |cnum| self.is_user_visible_dep(*cnum));
@@ -2363,7 +2363,7 @@ macro_rules! sty_debug_print {
}
impl<'tcx> TyCtxt<'tcx> {
- pub fn debug_stats(self) -> impl fmt::Debug + 'tcx {
+ pub fn debug_stats(self) -> impl fmt::Debug {
fmt::from_fn(move |fmt| {
sty_debug_print!(
fmt,
diff --git a/compiler/rustc_middle/src/ty/generic_args.rs b/compiler/rustc_middle/src/ty/generic_args.rs
index b74ddb817103..ed0b3059d752 100644
--- a/compiler/rustc_middle/src/ty/generic_args.rs
+++ b/compiler/rustc_middle/src/ty/generic_args.rs
@@ -479,25 +479,23 @@ impl<'tcx> GenericArgs<'tcx> {
}
#[inline]
- pub fn types(&'tcx self) -> impl DoubleEndedIterator<Item = Ty<'tcx>> + 'tcx {
+ pub fn types(&self) -> impl DoubleEndedIterator<Item = Ty<'tcx>> {
self.iter().filter_map(|k| k.as_type())
}
#[inline]
- pub fn regions(&'tcx self) -> impl DoubleEndedIterator<Item = ty::Region<'tcx>> + 'tcx {
+ pub fn regions(&self) -> impl DoubleEndedIterator<Item = ty::Region<'tcx>> {
self.iter().filter_map(|k| k.as_region())
}
#[inline]
- pub fn consts(&'tcx self) -> impl DoubleEndedIterator<Item = ty::Const<'tcx>> + 'tcx {
+ pub fn consts(&self) -> impl DoubleEndedIterator<Item = ty::Const<'tcx>> {
self.iter().filter_map(|k| k.as_const())
}
/// Returns generic arguments that are not lifetimes.
#[inline]
- pub fn non_erasable_generics(
- &'tcx self,
- ) -> impl DoubleEndedIterator<Item = GenericArgKind<'tcx>> + 'tcx {
+ pub fn non_erasable_generics(&self) -> impl DoubleEndedIterator<Item = GenericArgKind<'tcx>> {
self.iter().filter_map(|k| match k.unpack() {
ty::GenericArgKind::Lifetime(_) => None,
generic => Some(generic),
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index bd1fb0ca41cf..8ed5a118093f 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1798,14 +1798,11 @@ impl<'tcx> TyCtxt<'tcx> {
}
}
- pub fn get_attrs_by_path<'attr>(
+ pub fn get_attrs_by_path(
self,
did: DefId,
- attr: &'attr [Symbol],
- ) -> impl Iterator<Item = &'tcx hir::Attribute> + 'attr
- where
- 'tcx: 'attr,
- {
+ attr: &[Symbol],
+ ) -> impl Iterator<Item = &'tcx hir::Attribute> {
let filter_fn = move |a: &&hir::Attribute| a.path_matches(attr);
if let Some(did) = did.as_local() {
self.hir().attrs(self.local_def_id_to_hir_id(did)).iter().filter(filter_fn)
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
index 584cac22ae8d..553de83dfcb4 100644
--- a/compiler/rustc_middle/src/ty/predicate.rs
+++ b/compiler/rustc_middle/src/ty/predicate.rs
@@ -1,6 +1,5 @@
use std::cmp::Ordering;
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::intern::Interned;
use rustc_hir::def_id::DefId;
use rustc_macros::{HashStable, extension};
@@ -336,9 +335,9 @@ impl<'tcx> ty::List<ty::PolyExistentialPredicate<'tcx>> {
}
#[inline]
- pub fn projection_bounds<'a>(
- &'a self,
- ) -> impl Iterator<Item = ty::Binder<'tcx, ExistentialProjection<'tcx>>> + 'a {
+ pub fn projection_bounds(
+ &self,
+ ) -> impl Iterator<Item = ty::Binder<'tcx, ExistentialProjection<'tcx>>> {
self.iter().filter_map(|predicate| {
predicate
.map_bound(|pred| match pred {
@@ -350,16 +349,14 @@ impl<'tcx> ty::List<ty::PolyExistentialPredicate<'tcx>> {
}
#[inline]
- pub fn auto_traits<'a>(&'a self) -> impl Iterator<Item = DefId> + Captures<'tcx> + 'a {
+ pub fn auto_traits(&self) -> impl Iterator<Item = DefId> {
self.iter().filter_map(|predicate| match predicate.skip_binder() {
ExistentialPredicate::AutoTrait(did) => Some(did),
_ => None,
})
}
- pub fn without_auto_traits(
- &self,
- ) -> impl Iterator<Item = ty::PolyExistentialPredicate<'tcx>> + '_ {
+ pub fn without_auto_traits(&self) -> impl Iterator<Item = ty::PolyExistentialPredicate<'tcx>> {
self.iter().filter(|predicate| {
!matches!(predicate.as_ref().skip_binder(), ExistentialPredicate::AutoTrait(_))
})
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index dd4da2cf4ac3..d5617adf26b4 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -9,7 +9,6 @@ use std::ops::{ControlFlow, Range};
use hir::def::{CtorKind, DefKind};
use rustc_abi::{ExternAbi, FIRST_VARIANT, FieldIdx, VariantIdx};
-use rustc_data_structures::captures::Captures;
use rustc_errors::{ErrorGuaranteed, MultiSpan};
use rustc_hir as hir;
use rustc_hir::LangItem;
@@ -105,7 +104,7 @@ impl<'tcx> ty::CoroutineArgs<TyCtxt<'tcx>> {
self,
def_id: DefId,
tcx: TyCtxt<'tcx>,
- ) -> impl Iterator<Item = (VariantIdx, Discr<'tcx>)> + Captures<'tcx> {
+ ) -> impl Iterator<Item = (VariantIdx, Discr<'tcx>)> {
self.variant_range(def_id, tcx).map(move |index| {
(index, Discr { val: index.as_usize() as u128, ty: self.discr_ty(tcx) })
})
@@ -139,7 +138,7 @@ impl<'tcx> ty::CoroutineArgs<TyCtxt<'tcx>> {
self,
def_id: DefId,
tcx: TyCtxt<'tcx>,
- ) -> impl Iterator<Item: Iterator<Item = Ty<'tcx>> + Captures<'tcx>> {
+ ) -> impl Iterator<Item: Iterator<Item = Ty<'tcx>>> {
let layout = tcx.coroutine_layout(def_id, self.kind_ty()).unwrap();
layout.variant_fields.iter().map(move |variant| {
variant.iter().map(move |field| {
diff --git a/compiler/rustc_middle/src/ty/trait_def.rs b/compiler/rustc_middle/src/ty/trait_def.rs
index 17e90c15d413..8fa1c569737a 100644
--- a/compiler/rustc_middle/src/ty/trait_def.rs
+++ b/compiler/rustc_middle/src/ty/trait_def.rs
@@ -188,7 +188,7 @@ impl<'tcx> TyCtxt<'tcx> {
self,
trait_def_id: DefId,
self_ty: Ty<'tcx>,
- ) -> impl Iterator<Item = DefId> + 'tcx {
+ ) -> impl Iterator<Item = DefId> {
let impls = self.trait_impls_of(trait_def_id);
if let Some(simp) =
fast_reject::simplify_type(self, self_ty, TreatParams::InstantiateWithInfer)
@@ -204,7 +204,7 @@ impl<'tcx> TyCtxt<'tcx> {
/// Returns an iterator containing all impls for `trait_def_id`.
///
/// `trait_def_id` MUST BE the `DefId` of a trait.
- pub fn all_impls(self, trait_def_id: DefId) -> impl Iterator<Item = DefId> + 'tcx {
+ pub fn all_impls(self, trait_def_id: DefId) -> impl Iterator<Item = DefId> {
let TraitImpls { blanket_impls, non_blanket_impls } = self.trait_impls_of(trait_def_id);
blanket_impls.iter().chain(non_blanket_impls.iter().flat_map(|(_, v)| v)).cloned()
diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs
index b8c73d258437..d4484a16fea4 100644
--- a/compiler/rustc_middle/src/ty/typeck_results.rs
+++ b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -575,7 +575,7 @@ impl<'a, V> LocalTableInContext<'a, V> {
}
pub fn items(
- &'a self,
+ &self,
) -> UnordItems<(hir::ItemLocalId, &'a V), impl Iterator<Item = (hir::ItemLocalId, &'a V)>>
{
self.data.items().map(|(id, value)| (*id, value))
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_place.rs b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
index 308ca442b40c..581f45db6c48 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_place.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
@@ -216,11 +216,11 @@ fn to_upvars_resolved_place_builder<'tcx>(
/// Supports only HIR projection kinds that represent a path that might be
/// captured by a closure or a coroutine, i.e., an `Index` or a `Subslice`
/// projection kinds are unsupported.
-fn strip_prefix<'a, 'tcx>(
+fn strip_prefix<'tcx>(
mut base_ty: Ty<'tcx>,
- projections: &'a [PlaceElem<'tcx>],
+ projections: &[PlaceElem<'tcx>],
prefix_projections: &[HirProjection<'tcx>],
-) -> impl Iterator<Item = PlaceElem<'tcx>> + 'a {
+) -> impl Iterator<Item = PlaceElem<'tcx>> {
let mut iter = projections
.iter()
.copied()
diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs
index 7a9f6e463045..41a642f95b6e 100644
--- a/compiler/rustc_mir_build/src/thir/cx/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/mod.rs
@@ -159,12 +159,12 @@ impl<'tcx> ThirBuildCx<'tcx> {
})
}
- fn explicit_params<'a>(
- &'a mut self,
+ fn explicit_params(
+ &mut self,
owner_id: HirId,
fn_decl: &'tcx hir::FnDecl<'tcx>,
body: &'tcx hir::Body<'tcx>,
- ) -> impl Iterator<Item = Param<'tcx>> + 'a {
+ ) -> impl Iterator<Item = Param<'tcx>> {
let fn_sig = self.typeck_results.liberated_fn_sigs()[owner_id];
body.params.iter().enumerate().map(move |(index, param)| {
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/mod.rs b/compiler/rustc_mir_dataflow/src/move_paths/mod.rs
index 8aea8d2ae3ca..18985ba0da25 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/mod.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/mod.rs
@@ -343,7 +343,7 @@ impl<'tcx> MovePathLookup<'tcx> {
/// `MovePathIndex`es.
pub fn iter_locals_enumerated(
&self,
- ) -> impl DoubleEndedIterator<Item = (Local, MovePathIndex)> + '_ {
+ ) -> impl DoubleEndedIterator<Item = (Local, MovePathIndex)> {
self.locals.iter_enumerated().filter_map(|(l, &idx)| Some((l, idx?)))
}
}
diff --git a/compiler/rustc_mir_dataflow/src/un_derefer.rs b/compiler/rustc_mir_dataflow/src/un_derefer.rs
index bb15b8106a1e..b38dd9d40f52 100644
--- a/compiler/rustc_mir_dataflow/src/un_derefer.rs
+++ b/compiler/rustc_mir_dataflow/src/un_derefer.rs
@@ -28,7 +28,7 @@ impl<'tcx> UnDerefer<'tcx> {
pub(crate) fn iter_projections(
&self,
place: PlaceRef<'tcx>,
- ) -> impl Iterator<Item = (PlaceRef<'tcx>, PlaceElem<'tcx>)> + '_ {
+ ) -> impl Iterator<Item = (PlaceRef<'tcx>, PlaceElem<'tcx>)> {
ProjectionIter::new(self.deref_chain(place.local), place)
}
}
diff --git a/compiler/rustc_mir_dataflow/src/value_analysis.rs b/compiler/rustc_mir_dataflow/src/value_analysis.rs
index 9cba07e15a43..36fb1c2b36d0 100644
--- a/compiler/rustc_mir_dataflow/src/value_analysis.rs
+++ b/compiler/rustc_mir_dataflow/src/value_analysis.rs
@@ -2,7 +2,6 @@ use std::fmt::{Debug, Formatter};
use std::ops::Range;
use rustc_abi::{FieldIdx, VariantIdx};
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::{FxHashMap, FxIndexSet, StdEntry};
use rustc_data_structures::stack::ensure_sufficient_stack;
use rustc_index::IndexVec;
@@ -676,10 +675,7 @@ impl<'tcx> Map<'tcx> {
}
/// Iterate over all direct children.
- fn children(
- &self,
- parent: PlaceIndex,
- ) -> impl Iterator<Item = PlaceIndex> + Captures<'_> + Captures<'tcx> {
+ fn children(&self, parent: PlaceIndex) -> impl Iterator<Item = PlaceIndex> {
Children::new(self, parent)
}
diff --git a/compiler/rustc_mir_transform/src/coverage/graph.rs b/compiler/rustc_mir_transform/src/coverage/graph.rs
index 6d84248ddfbd..09384defea86 100644
--- a/compiler/rustc_mir_transform/src/coverage/graph.rs
+++ b/compiler/rustc_mir_transform/src/coverage/graph.rs
@@ -2,7 +2,6 @@ use std::cmp::Ordering;
use std::ops::{Index, IndexMut};
use std::{mem, slice};
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::graph::dominators::Dominators;
use rustc_data_structures::graph::{self, DirectedGraph, StartNode};
@@ -218,7 +217,7 @@ impl CoverageGraph {
pub(crate) fn reloop_predecessors(
&self,
to_bcb: BasicCoverageBlock,
- ) -> impl Iterator<Item = BasicCoverageBlock> + Captures<'_> {
+ ) -> impl Iterator<Item = BasicCoverageBlock> {
self.predecessors[to_bcb].iter().copied().filter(move |&pred| self.dominates(to_bcb, pred))
}
}
diff --git a/compiler/rustc_mir_transform/src/coverage/query.rs b/compiler/rustc_mir_transform/src/coverage/query.rs
index ef86358b2057..58461be01f17 100644
--- a/compiler/rustc_mir_transform/src/coverage/query.rs
+++ b/compiler/rustc_mir_transform/src/coverage/query.rs
@@ -1,4 +1,3 @@
-use rustc_data_structures::captures::Captures;
use rustc_index::bit_set::DenseBitSet;
use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
use rustc_middle::mir::coverage::{BasicCoverageBlock, CoverageIdsInfo, CoverageKind, MappingKind};
@@ -153,7 +152,7 @@ fn coverage_ids_info<'tcx>(
fn all_coverage_in_mir_body<'a, 'tcx>(
body: &'a Body<'tcx>,
-) -> impl Iterator<Item = &'a CoverageKind> + Captures<'tcx> {
+) -> impl Iterator<Item = &'a CoverageKind> {
body.basic_blocks.iter().flat_map(|bb_data| &bb_data.statements).filter_map(|statement| {
match statement.kind {
StatementKind::Coverage(ref kind) if !is_inlined(body, statement) => Some(kind),
diff --git a/compiler/rustc_mir_transform/src/coverage/spans.rs b/compiler/rustc_mir_transform/src/coverage/spans.rs
index 314a86ea52f0..b9ed6984ddb2 100644
--- a/compiler/rustc_mir_transform/src/coverage/spans.rs
+++ b/compiler/rustc_mir_transform/src/coverage/spans.rs
@@ -1,6 +1,5 @@
use std::collections::VecDeque;
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxHashSet;
use rustc_middle::mir;
use rustc_span::{DesugaringKind, ExpnKind, MacroKind, Span};
@@ -182,7 +181,7 @@ fn divide_spans_into_buckets(input_covspans: Vec<Covspan>, holes: &[Hole]) -> Ve
fn drain_front_while<'a, T>(
queue: &'a mut VecDeque<T>,
mut pred_fn: impl FnMut(&T) -> bool,
-) -> impl Iterator<Item = T> + Captures<'a> {
+) -> impl Iterator<Item = T> {
std::iter::from_fn(move || if pred_fn(queue.front()?) { queue.pop_front() } else { None })
}
diff --git a/compiler/rustc_mir_transform/src/jump_threading.rs b/compiler/rustc_mir_transform/src/jump_threading.rs
index bd310b078975..0a72a9d669fe 100644
--- a/compiler/rustc_mir_transform/src/jump_threading.rs
+++ b/compiler/rustc_mir_transform/src/jump_threading.rs
@@ -172,11 +172,11 @@ impl HasBottom for ConditionSet<'_> {
}
impl<'a> ConditionSet<'a> {
- fn iter(self) -> impl Iterator<Item = Condition> + 'a {
+ fn iter(self) -> impl Iterator<Item = Condition> {
self.0.iter().copied()
}
- fn iter_matches(self, value: ScalarInt) -> impl Iterator<Item = Condition> + 'a {
+ fn iter_matches(self, value: ScalarInt) -> impl Iterator<Item = Condition> {
self.iter().filter(move |c| c.matches(value))
}
diff --git a/compiler/rustc_mir_transform/src/sroa.rs b/compiler/rustc_mir_transform/src/sroa.rs
index 28de99f9193d..7c6ccc89c4f3 100644
--- a/compiler/rustc_mir_transform/src/sroa.rs
+++ b/compiler/rustc_mir_transform/src/sroa.rs
@@ -185,7 +185,7 @@ impl<'tcx> ReplacementMap<'tcx> {
fn place_fragments(
&self,
place: Place<'tcx>,
- ) -> Option<impl Iterator<Item = (FieldIdx, Ty<'tcx>, Local)> + '_> {
+ ) -> Option<impl Iterator<Item = (FieldIdx, Ty<'tcx>, Local)>> {
let local = place.as_local()?;
let fields = self.fragments[local].as_ref()?;
Some(fields.iter_enumerated().filter_map(|(field, &opt_ty_local)| {
diff --git a/compiler/rustc_mir_transform/src/ssa.rs b/compiler/rustc_mir_transform/src/ssa.rs
index 9f769077e77e..3d512fb064ec 100644
--- a/compiler/rustc_mir_transform/src/ssa.rs
+++ b/compiler/rustc_mir_transform/src/ssa.rs
@@ -138,7 +138,7 @@ impl SsaLocals {
pub(super) fn assignments<'a, 'tcx>(
&'a self,
body: &'a Body<'tcx>,
- ) -> impl Iterator<Item = (Local, &'a Rvalue<'tcx>, Location)> + 'a {
+ ) -> impl Iterator<Item = (Local, &'a Rvalue<'tcx>, Location)> {
self.assignment_order.iter().filter_map(|&local| {
if let Set1::One(DefLocation::Assignment(loc)) = self.assignments[local] {
let stmt = body.stmt_at(loc).left()?;
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 1195c25e1308..9b652cddc499 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -323,7 +323,7 @@ impl<'tcx> MonoItems<'tcx> {
self.items.entry(item.node).or_insert(item.span);
}
- fn items(&self) -> impl Iterator<Item = MonoItem<'tcx>> + '_ {
+ fn items(&self) -> impl Iterator<Item = MonoItem<'tcx>> {
self.items.keys().cloned()
}
}
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index bbd73dec2e47..80a33a760059 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -1657,7 +1657,7 @@ impl<'a> Parser<'a> {
// Debug view of the parser's token stream, up to `{lookahead}` tokens.
// Only used when debugging.
#[allow(unused)]
- pub(crate) fn debug_lookahead(&self, lookahead: usize) -> impl fmt::Debug + '_ {
+ pub(crate) fn debug_lookahead(&self, lookahead: usize) -> impl fmt::Debug {
fmt::from_fn(move |f| {
let mut dbg_fmt = f.debug_struct("Parser"); // or at least, one view of
diff --git a/compiler/rustc_pattern_analysis/src/lib.rs b/compiler/rustc_pattern_analysis/src/lib.rs
index fec44d5af55d..a3400ebb7993 100644
--- a/compiler/rustc_pattern_analysis/src/lib.rs
+++ b/compiler/rustc_pattern_analysis/src/lib.rs
@@ -61,11 +61,11 @@ pub trait PatCx: Sized + fmt::Debug {
fn ctor_arity(&self, ctor: &Constructor<Self>, ty: &Self::Ty) -> usize;
/// The types of the fields for this constructor. The result must contain `ctor_arity()` fields.
- fn ctor_sub_tys<'a>(
- &'a self,
- ctor: &'a Constructor<Self>,
- ty: &'a Self::Ty,
- ) -> impl Iterator<Item = (Self::Ty, PrivateUninhabitedField)> + ExactSizeIterator + Captures<'a>;
+ fn ctor_sub_tys(
+ &self,
+ ctor: &Constructor<Self>,
+ ty: &Self::Ty,
+ ) -> impl Iterator<Item = (Self::Ty, PrivateUninhabitedField)> + ExactSizeIterator;
/// The set of all the constructors for `ty`.
///
diff --git a/compiler/rustc_pattern_analysis/src/pat_column.rs b/compiler/rustc_pattern_analysis/src/pat_column.rs
index eb4e095c1c66..814eb8afcfc0 100644
--- a/compiler/rustc_pattern_analysis/src/pat_column.rs
+++ b/compiler/rustc_pattern_analysis/src/pat_column.rs
@@ -1,6 +1,6 @@
use crate::constructor::{Constructor, SplitConstructorSet};
use crate::pat::{DeconstructedPat, PatOrWild};
-use crate::{Captures, MatchArm, PatCx};
+use crate::{MatchArm, PatCx};
/// A column of patterns in a match, where a column is the intuitive notion of "subpatterns that
/// inspect the same subvalue/place".
@@ -41,7 +41,7 @@ impl<'p, Cx: PatCx> PatternColumn<'p, Cx> {
pub fn head_ty(&self) -> Option<&Cx::Ty> {
self.patterns.first().map(|pat| pat.ty())
}
- pub fn iter<'a>(&'a self) -> impl Iterator<Item = &'p DeconstructedPat<Cx>> + Captures<'a> {
+ pub fn iter(&self) -> impl Iterator<Item = &'p DeconstructedPat<Cx>> {
self.patterns.iter().copied()
}
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 0b1e954d64d4..88194c737a6c 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -25,7 +25,7 @@ use crate::lints::lint_nonexhaustive_missing_variants;
use crate::pat_column::PatternColumn;
use crate::rustc::print::EnumInfo;
use crate::usefulness::{PlaceValidity, compute_match_usefulness};
-use crate::{Captures, PatCx, PrivateUninhabitedField, errors};
+use crate::{PatCx, PrivateUninhabitedField, errors};
mod print;
@@ -175,8 +175,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
&self,
ty: RevealedTy<'tcx>,
variant: &'tcx VariantDef,
- ) -> impl Iterator<Item = (&'tcx FieldDef, RevealedTy<'tcx>)> + Captures<'p> + Captures<'_>
- {
+ ) -> impl Iterator<Item = (&'tcx FieldDef, RevealedTy<'tcx>)> {
let ty::Adt(_, args) = ty.kind() else { bug!() };
variant.fields.iter().map(move |field| {
let ty = field.ty(self.tcx, args);
@@ -203,13 +202,11 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
/// Returns the types of the fields for a given constructor. The result must have a length of
/// `ctor.arity()`.
- pub(crate) fn ctor_sub_tys<'a>(
- &'a self,
- ctor: &'a Constructor<'p, 'tcx>,
+ pub(crate) fn ctor_sub_tys(
+ &self,
+ ctor: &Constructor<'p, 'tcx>,
ty: RevealedTy<'tcx>,
- ) -> impl Iterator<Item = (RevealedTy<'tcx>, PrivateUninhabitedField)>
- + ExactSizeIterator
- + Captures<'a> {
+ ) -> impl Iterator<Item = (RevealedTy<'tcx>, PrivateUninhabitedField)> + ExactSizeIterator {
fn reveal_and_alloc<'a, 'tcx>(
cx: &'a RustcPatCtxt<'_, 'tcx>,
iter: impl Iterator<Item = Ty<'tcx>>,
@@ -936,12 +933,11 @@ impl<'p, 'tcx: 'p> PatCx for RustcPatCtxt<'p, 'tcx> {
fn ctor_arity(&self, ctor: &crate::constructor::Constructor<Self>, ty: &Self::Ty) -> usize {
self.ctor_arity(ctor, *ty)
}
- fn ctor_sub_tys<'a>(
- &'a self,
- ctor: &'a crate::constructor::Constructor<Self>,
- ty: &'a Self::Ty,
- ) -> impl Iterator<Item = (Self::Ty, PrivateUninhabitedField)> + ExactSizeIterator + Captures<'a>
- {
+ fn ctor_sub_tys(
+ &self,
+ ctor: &crate::constructor::Constructor<Self>,
+ ty: &Self::Ty,
+ ) -> impl Iterator<Item = (Self::Ty, PrivateUninhabitedField)> + ExactSizeIterator {
self.ctor_sub_tys(ctor, *ty)
}
fn ctors_for_ty(
diff --git a/compiler/rustc_pattern_analysis/src/usefulness.rs b/compiler/rustc_pattern_analysis/src/usefulness.rs
index 1dff76141da5..11ebbea07fa4 100644
--- a/compiler/rustc_pattern_analysis/src/usefulness.rs
+++ b/compiler/rustc_pattern_analysis/src/usefulness.rs
@@ -719,7 +719,7 @@ use tracing::{debug, instrument};
use self::PlaceValidity::*;
use crate::constructor::{Constructor, ConstructorSet, IntRange};
use crate::pat::{DeconstructedPat, PatId, PatOrWild, WitnessPat};
-use crate::{Captures, MatchArm, PatCx, PrivateUninhabitedField};
+use crate::{MatchArm, PatCx, PrivateUninhabitedField};
#[cfg(not(feature = "rustc"))]
pub fn ensure_sufficient_stack<R>(f: impl FnOnce() -> R) -> R {
f()
@@ -902,11 +902,11 @@ struct PlaceInfo<Cx: PatCx> {
impl<Cx: PatCx> PlaceInfo<Cx> {
/// Given a constructor for the current place, we return one `PlaceInfo` for each field of the
/// constructor.
- fn specialize<'a>(
- &'a self,
- cx: &'a Cx,
- ctor: &'a Constructor<Cx>,
- ) -> impl Iterator<Item = Self> + ExactSizeIterator + Captures<'a> {
+ fn specialize(
+ &self,
+ cx: &Cx,
+ ctor: &Constructor<Cx>,
+ ) -> impl Iterator<Item = Self> + ExactSizeIterator {
let ctor_sub_tys = cx.ctor_sub_tys(ctor, &self.ty);
let ctor_sub_validity = self.validity.specialize(ctor);
ctor_sub_tys.map(move |(ty, PrivateUninhabitedField(private_uninhabited))| PlaceInfo {
@@ -1046,13 +1046,13 @@ impl<'p, Cx: PatCx> PatStack<'p, Cx> {
self.pats[0]
}
- fn iter(&self) -> impl Iterator<Item = PatOrWild<'p, Cx>> + Captures<'_> {
+ fn iter(&self) -> impl Iterator<Item = PatOrWild<'p, Cx>> {
self.pats.iter().copied()
}
// Expand the first or-pattern into its subpatterns. Only useful if the pattern is an
// or-pattern. Panics if `self` is empty.
- fn expand_or_pat(&self) -> impl Iterator<Item = PatStack<'p, Cx>> + Captures<'_> {
+ fn expand_or_pat(&self) -> impl Iterator<Item = PatStack<'p, Cx>> {
self.head().expand_or_pat().into_iter().map(move |pat| {
let mut new = self.clone();
new.pats[0] = pat;
@@ -1157,15 +1157,12 @@ impl<'p, Cx: PatCx> MatrixRow<'p, Cx> {
self.pats.head()
}
- fn iter(&self) -> impl Iterator<Item = PatOrWild<'p, Cx>> + Captures<'_> {
+ fn iter(&self) -> impl Iterator<Item = PatOrWild<'p, Cx>> {
self.pats.iter()
}
// Expand the first or-pattern (if any) into its subpatterns. Panics if `self` is empty.
- fn expand_or_pat(
- &self,
- parent_row: usize,
- ) -> impl Iterator<Item = MatrixRow<'p, Cx>> + Captures<'_> {
+ fn expand_or_pat(&self, parent_row: usize) -> impl Iterator<Item = MatrixRow<'p, Cx>> {
let is_or_pat = self.pats.head().is_or_pat();
self.pats.expand_or_pat().map(move |patstack| MatrixRow {
pats: patstack,
@@ -1275,7 +1272,7 @@ impl<'p, Cx: PatCx> Matrix<'p, Cx> {
}
/// Iterate over the first pattern of each row.
- fn heads(&self) -> impl Iterator<Item = PatOrWild<'p, Cx>> + Clone + Captures<'_> {
+ fn heads(&self) -> impl Iterator<Item = PatOrWild<'p, Cx>> + Clone {
self.rows().map(|r| r.head())
}
diff --git a/compiler/rustc_pattern_analysis/tests/common/mod.rs b/compiler/rustc_pattern_analysis/tests/common/mod.rs
index 23560ad64190..365bc2d863f4 100644
--- a/compiler/rustc_pattern_analysis/tests/common/mod.rs
+++ b/compiler/rustc_pattern_analysis/tests/common/mod.rs
@@ -2,7 +2,7 @@ use rustc_pattern_analysis::constructor::{
Constructor, ConstructorSet, IntRange, MaybeInfiniteInt, RangeEnd, VariantVisibility,
};
use rustc_pattern_analysis::usefulness::{PlaceValidity, UsefulnessReport};
-use rustc_pattern_analysis::{Captures, MatchArm, PatCx, PrivateUninhabitedField};
+use rustc_pattern_analysis::{MatchArm, PatCx, PrivateUninhabitedField};
/// Sets up `tracing` for easier debugging. Tries to look like the `rustc` setup.
pub fn init_tracing() {
@@ -156,12 +156,11 @@ impl PatCx for Cx {
ty.sub_tys(ctor).len()
}
- fn ctor_sub_tys<'a>(
- &'a self,
- ctor: &'a Constructor<Self>,
- ty: &'a Self::Ty,
- ) -> impl Iterator<Item = (Self::Ty, PrivateUninhabitedField)> + ExactSizeIterator + Captures<'a>
- {
+ fn ctor_sub_tys(
+ &self,
+ ctor: &Constructor<Self>,
+ ty: &Self::Ty,
+ ) -> impl Iterator<Item = (Self::Ty, PrivateUninhabitedField)> + ExactSizeIterator {
ty.sub_tys(ctor).into_iter().map(|ty| (ty, PrivateUninhabitedField(false)))
}
diff --git a/compiler/rustc_query_system/src/dep_graph/serialized.rs b/compiler/rustc_query_system/src/dep_graph/serialized.rs
index a4fb0a5b0722..bc78878a84a2 100644
--- a/compiler/rustc_query_system/src/dep_graph/serialized.rs
+++ b/compiler/rustc_query_system/src/dep_graph/serialized.rs
@@ -98,7 +98,7 @@ impl SerializedDepGraph {
pub fn edge_targets_from(
&self,
source: SerializedDepNodeIndex,
- ) -> impl Iterator<Item = SerializedDepNodeIndex> + Clone + '_ {
+ ) -> impl Iterator<Item = SerializedDepNodeIndex> + Clone {
let header = self.edge_list_indices[source];
let mut raw = &self.edge_list_data[header.start()..];
// Figure out where the edge list for `source` ends by getting the start index of the next
diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs
index e0405a71f65a..1fe521bd32d5 100644
--- a/compiler/rustc_session/src/parse.rs
+++ b/compiler/rustc_session/src/parse.rs
@@ -329,7 +329,7 @@ impl ParseSess {
self.proc_macro_quoted_spans.push(span)
}
- pub fn proc_macro_quoted_spans(&self) -> impl Iterator<Item = (usize, Span)> + '_ {
+ pub fn proc_macro_quoted_spans(&self) -> impl Iterator<Item = (usize, Span)> {
// This is equivalent to `.iter().copied().enumerate()`, but that isn't possible for
// AppendOnlyVec, so we resort to this scheme.
self.proc_macro_quoted_spans.iter_enumerated()
diff --git a/compiler/rustc_session/src/search_paths.rs b/compiler/rustc_session/src/search_paths.rs
index b750d870cb6f..00e12b45bafb 100644
--- a/compiler/rustc_session/src/search_paths.rs
+++ b/compiler/rustc_session/src/search_paths.rs
@@ -20,12 +20,11 @@ pub struct FilesIndex(Vec<(Arc<str>, SearchPathFile)>);
impl FilesIndex {
/// Look up [SearchPathFile] by (prefix, suffix) pair.
- pub fn query<'this, 'prefix, 'suffix>(
- &'this self,
- prefix: &'prefix str,
- suffix: &'suffix str,
- ) -> Option<impl Iterator<Item = (String, &'this SearchPathFile)> + use<'this, 'prefix, 'suffix>>
- {
+ pub fn query<'s>(
+ &'s self,
+ prefix: &str,
+ suffix: &str,
+ ) -> Option<impl Iterator<Item = (String, &'s SearchPathFile)>> {
let start = self.0.partition_point(|(k, _)| **k < *prefix);
if start == self.0.len() {
return None;
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index 42b8199cb265..bed9734f389c 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -1074,7 +1074,7 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
&self,
path: &'tcx hir::Path<'tcx>,
args: GenericArgsRef<'tcx>,
- ) -> impl Iterator<Item = InsertableGenericArgs<'tcx>> + 'a {
+ ) -> impl Iterator<Item = InsertableGenericArgs<'tcx>> + 'tcx {
let tcx = self.tecx.tcx;
let have_turbofish = path.segments.iter().any(|segment| {
segment.args.is_some_and(|args| args.args.iter().any(|arg| arg.is_ty_or_const()))
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index 51d560d4c43d..704ba6e501d8 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -67,9 +67,7 @@ impl<'tcx> ObligationStorage<'tcx> {
obligations
}
- fn unstalled_for_select(
- &mut self,
- ) -> impl Iterator<Item = PredicateObligation<'tcx>> + use<'tcx> {
+ fn unstalled_for_select(&mut self) -> impl Iterator<Item = PredicateObligation<'tcx>> + 'tcx {
mem::take(&mut self.pending).into_iter()
}
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index f2d2dd2f3ce5..e39f8e673dba 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -1,6 +1,5 @@
use std::marker::PhantomData;
-use rustc_data_structures::captures::Captures;
use rustc_data_structures::obligation_forest::{
Error, ForestObligation, ObligationForest, ObligationProcessor, Outcome, ProcessResult,
};
@@ -900,10 +899,10 @@ impl<'a, 'tcx> FulfillProcessor<'a, 'tcx> {
}
/// Returns the set of inference variables contained in `args`.
-fn args_infer_vars<'a, 'tcx>(
- selcx: &SelectionContext<'a, 'tcx>,
+fn args_infer_vars<'tcx>(
+ selcx: &SelectionContext<'_, 'tcx>,
args: ty::Binder<'tcx, GenericArgsRef<'tcx>>,
-) -> impl Iterator<Item = TyOrConstInferVar> + Captures<'tcx> {
+) -> impl Iterator<Item = TyOrConstInferVar> {
selcx
.infcx
.resolve_vars_if_possible(args)
diff --git a/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs b/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
index f39c611d19fe..19d3561dd595 100644
--- a/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
+++ b/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
@@ -200,15 +200,12 @@ impl<'tcx> Children {
}
}
-fn iter_children(children: &Children) -> impl Iterator<Item = DefId> + '_ {
+fn iter_children(children: &Children) -> impl Iterator<Item = DefId> {
let nonblanket = children.non_blanket_impls.iter().flat_map(|(_, v)| v.iter());
children.blanket_impls.iter().chain(nonblanket).cloned()
}
-fn filtered_children(
- children: &mut Children,
- st: SimplifiedType,
-) -> impl Iterator<Item = DefId> + '_ {
+fn filtered_children(children: &mut Children, st: SimplifiedType) -> impl Iterator<Item = DefId> {
let nonblanket = children.non_blanket_impls.entry(st).or_default().iter();
children.blanket_impls.iter().chain(nonblanket).cloned()
}
diff --git a/compiler/rustc_trait_selection/src/traits/vtable.rs b/compiler/rustc_trait_selection/src/traits/vtable.rs
index 0024316b877c..165174c0bcc1 100644
--- a/compiler/rustc_trait_selection/src/traits/vtable.rs
+++ b/compiler/rustc_trait_selection/src/traits/vtable.rs
@@ -196,7 +196,7 @@ fn own_existential_vtable_entries(tcx: TyCtxt<'_>, trait_def_id: DefId) -> &[Def
fn own_existential_vtable_entries_iter(
tcx: TyCtxt<'_>,
trait_def_id: DefId,
-) -> impl Iterator<Item = DefId> + '_ {
+) -> impl Iterator<Item = DefId> {
let trait_methods = tcx
.associated_items(trait_def_id)
.in_definition_order()
diff --git a/compiler/rustc_ty_utils/src/implied_bounds.rs b/compiler/rustc_ty_utils/src/implied_bounds.rs
index cc7baf8daac5..6205578bf747 100644
--- a/compiler/rustc_ty_utils/src/implied_bounds.rs
+++ b/compiler/rustc_ty_utils/src/implied_bounds.rs
@@ -151,7 +151,7 @@ fn assumed_wf_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx [(Ty<'
}
}
-fn fn_sig_spans(tcx: TyCtxt<'_>, def_id: LocalDefId) -> impl Iterator<Item = Span> + '_ {
+fn fn_sig_spans(tcx: TyCtxt<'_>, def_id: LocalDefId) -> impl Iterator<Item = Span> {
let node = tcx.hir_node_by_def_id(def_id);
if let Some(decl) = node.fn_decl() {
decl.inputs.iter().map(|ty| ty.span).chain(iter::once(decl.output.span()))
@@ -160,7 +160,7 @@ fn fn_sig_spans(tcx: TyCtxt<'_>, def_id: LocalDefId) -> impl Iterator<Item = Spa
}
}
-fn impl_spans(tcx: TyCtxt<'_>, def_id: LocalDefId) -> impl Iterator<Item = Span> + '_ {
+fn impl_spans(tcx: TyCtxt<'_>, def_id: LocalDefId) -> impl Iterator<Item = Span> {
let item = tcx.hir().expect_item(def_id);
if let hir::ItemKind::Impl(impl_) = item.kind {
let trait_args = impl_
diff --git a/compiler/rustc_ty_utils/src/layout/invariant.rs b/compiler/rustc_ty_utils/src/layout/invariant.rs
index 5ea6716c5ca1..525199801c3a 100644
--- a/compiler/rustc_ty_utils/src/layout/invariant.rs
+++ b/compiler/rustc_ty_utils/src/layout/invariant.rs
@@ -33,7 +33,7 @@ pub(super) fn layout_sanity_check<'tcx>(cx: &LayoutCx<'tcx>, layout: &TyAndLayou
fn non_zst_fields<'tcx, 'a>(
cx: &'a LayoutCx<'tcx>,
layout: &'a TyAndLayout<'tcx>,
- ) -> impl Iterator<Item = (Size, TyAndLayout<'tcx>)> + 'a {
+ ) -> impl Iterator<Item = (Size, TyAndLayout<'tcx>)> {
(0..layout.layout.fields().count()).filter_map(|i| {
let field = layout.field(cx, i);
// Also checking `align == 1` here leads to test failures in
diff --git a/compiler/rustc_ty_utils/src/needs_drop.rs b/compiler/rustc_ty_utils/src/needs_drop.rs
index 80de7e20951a..52955ec59a4a 100644
--- a/compiler/rustc_ty_utils/src/needs_drop.rs
+++ b/compiler/rustc_ty_utils/src/needs_drop.rs
@@ -373,7 +373,7 @@ fn drop_tys_helper<'tcx>(
fn adt_consider_insignificant_dtor<'tcx>(
tcx: TyCtxt<'tcx>,
-) -> impl Fn(ty::AdtDef<'tcx>) -> Option<DtorType> + 'tcx {
+) -> impl Fn(ty::AdtDef<'tcx>) -> Option<DtorType> {
move |adt_def: ty::AdtDef<'tcx>| {
let is_marked_insig = tcx.has_attr(adt_def.did(), sym::rustc_insignificant_dtor);
if is_marked_insig {
diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 3cc2dcbaca6d..082cfff72e20 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -285,7 +285,7 @@ impl<X: Cx> NestedGoals<X> {
#[cfg_attr(feature = "nightly", rustc_lint_query_instability)]
#[allow(rustc::potential_query_instability)]
- fn iter(&self) -> impl Iterator<Item = (X::Input, UsageKind)> + '_ {
+ fn iter(&self) -> impl Iterator<Item = (X::Input, UsageKind)> {
self.nested_goals.iter().map(|(i, p)| (*i, *p))
}
diff --git a/compiler/stable_mir/src/mir/body.rs b/compiler/stable_mir/src/mir/body.rs
index bc2e427f50cb..f8b46f50a529 100644
--- a/compiler/stable_mir/src/mir/body.rs
+++ b/compiler/stable_mir/src/mir/body.rs
@@ -864,7 +864,7 @@ impl SwitchTargets {
}
/// The conditional targets which are only taken if the pattern matches the given value.
- pub fn branches(&self) -> impl Iterator<Item = (u128, BasicBlockIdx)> + '_ {
+ pub fn branches(&self) -> impl Iterator<Item = (u128, BasicBlockIdx)> {
self.branches.iter().copied()
}
diff --git a/compiler/stable_mir/src/ty.rs b/compiler/stable_mir/src/ty.rs
index 9ef80edb82a6..b857a735b725 100644
--- a/compiler/stable_mir/src/ty.rs
+++ b/compiler/stable_mir/src/ty.rs
@@ -809,7 +809,7 @@ impl AdtDef {
}
/// Iterate over the variants in this ADT.
- pub fn variants_iter(&self) -> impl Iterator<Item = VariantDef> + '_ {
+ pub fn variants_iter(&self) -> impl Iterator<Item = VariantDef> {
(0..self.num_variants())
.map(|idx| VariantDef { idx: VariantIdx::to_val(idx), adt_def: *self })
}
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
index 3312da470c03..91eb59fb3140 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
@@ -361,11 +361,11 @@ impl PatCx for MatchCheckCtx<'_> {
}
}
- fn ctor_sub_tys<'a>(
- &'a self,
- ctor: &'a rustc_pattern_analysis::constructor::Constructor<Self>,
- ty: &'a Self::Ty,
- ) -> impl ExactSizeIterator<Item = (Self::Ty, PrivateUninhabitedField)> + Captures<'a> {
+ fn ctor_sub_tys(
+ &self,
+ ctor: &rustc_pattern_analysis::constructor::Constructor<Self>,
+ ty: &Self::Ty,
+ ) -> impl ExactSizeIterator<Item = (Self::Ty, PrivateUninhabitedField)> {
let single = |ty| smallvec![(ty, PrivateUninhabitedField(false))];
let tys: SmallVec<[_; 2]> = match ctor {
Struct | Variant(_) | UnionField => match ty.kind(Interner) {