bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rollup merge of #101496 - spastorino:lower_lifetime_binder_api_changes, r=oli-obk

Browse source 
Allow lower_lifetime_binder receive a closure

``@oli-obk`` requested this and other changes as a way of simplifying https://github.com/rust-lang/rust/pull/101345. This is just going to make the diff of https://github.com/rust-lang/rust/pull/101345 smaller.

r? ``@oli-obk`` ``@cjgillot``
This commit is contained in:
Dylan DPC 2022-09-08 20:48:36 +05:30 • committed by GitHub
commit 953a6b3da7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 63 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

59
compiler/rustc_ast_lowering/src/expr.rs
View file

@ -849,21 +849,22 @@ impl<'hir> LoweringContext<'_, 'hir> {
(body_id, generator_option) (body_id, generator_option)
}); });
let bound_generic_params = self.lower_lifetime_binder(closure_id, generic_params); self.lower_lifetime_binder(closure_id, generic_params, |lctx, bound_generic_params| {
// Lower outside new scope to preserve `is_in_loop_condition`. // Lower outside new scope to preserve `is_in_loop_condition`.
let fn_decl = self.lower_fn_decl(decl, None, FnDeclKind::Closure, None); let fn_decl = lctx.lower_fn_decl(decl, None, FnDeclKind::Closure, None);
let c = self.arena.alloc(hir::Closure { let c = lctx.arena.alloc(hir::Closure {
binder: binder_clause, binder: binder_clause,
capture_clause, capture_clause,
bound_generic_params, bound_generic_params,
fn_decl, fn_decl,
body: body_id, body: body_id,
fn_decl_span: self.lower_span(fn_decl_span), fn_decl_span: lctx.lower_span(fn_decl_span),
movability: generator_option, movability: generator_option,
}); });
hir::ExprKind::Closure(c) hir::ExprKind::Closure(c)
})
} }
fn generator_movability_for_fn( fn generator_movability_for_fn(
@ -950,23 +951,23 @@ impl<'hir> LoweringContext<'_, 'hir> {
body_id body_id
}); });
let bound_generic_params = self.lower_lifetime_binder(closure_id, generic_params); self.lower_lifetime_binder(closure_id, generic_params, |lctx, bound_generic_params| {
// We need to lower the declaration outside the new scope, because we
// have to conserve the state of being inside a loop condition for the
// closure argument types.
let fn_decl = lctx.lower_fn_decl(&outer_decl, None, FnDeclKind::Closure, None);
// We need to lower the declaration outside the new scope, because we let c = lctx.arena.alloc(hir::Closure {
// have to conserve the state of being inside a loop condition for the binder: binder_clause,
// closure argument types. capture_clause,
let fn_decl = self.lower_fn_decl(&outer_decl, None, FnDeclKind::Closure, None); bound_generic_params,
fn_decl,
let c = self.arena.alloc(hir::Closure { body,
binder: binder_clause, fn_decl_span: lctx.lower_span(fn_decl_span),
capture_clause, movability: None,
bound_generic_params, });
fn_decl, hir::ExprKind::Closure(c)
body, })
fn_decl_span: self.lower_span(fn_decl_span),
movability: None,
});
hir::ExprKind::Closure(c)
} }
/// Destructure the LHS of complex assignments. /// Destructure the LHS of complex assignments.

53
compiler/rustc_ast_lowering/src/lib.rs
View file

@ -810,23 +810,31 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
/// name resolver owing to lifetime elision; this also populates the resolver's node-id->def-id /// name resolver owing to lifetime elision; this also populates the resolver's node-id->def-id
/// map, so that later calls to `opt_node_id_to_def_id` that refer to these extra lifetime /// map, so that later calls to `opt_node_id_to_def_id` that refer to these extra lifetime
/// parameters will be successful. /// parameters will be successful.
#[instrument(level = "debug", skip(self))] #[instrument(level = "debug", skip(self, in_binder))]
#[inline] #[inline]
fn lower_lifetime_binder( fn lower_lifetime_binder<R>(
&mut self, &mut self,
binder: NodeId, binder: NodeId,
generic_params: &[GenericParam], generic_params: &[GenericParam],
) -> &'hir [hir::GenericParam<'hir>] { in_binder: impl FnOnce(&mut Self, &'hir [hir::GenericParam<'hir>]) -> R,
let mut generic_params: Vec<_> = self.lower_generic_params_mut(generic_params).collect(); ) -> R {
let extra_lifetimes = self.resolver.take_extra_lifetime_params(binder); let extra_lifetimes = self.resolver.take_extra_lifetime_params(binder);
debug!(?extra_lifetimes); debug!(?extra_lifetimes);
generic_params.extend(extra_lifetimes.into_iter().filter_map(|(ident, node_id, res)| { let extra_lifetimes: Vec<_> = extra_lifetimes
self.lifetime_res_to_generic_param(ident, node_id, res) .into_iter()
})); .filter_map(|(ident, node_id, res)| {
self.lifetime_res_to_generic_param(ident, node_id, res)
})
.collect();
let generic_params: Vec<_> = self
.lower_generic_params_mut(generic_params)
.chain(extra_lifetimes.into_iter())
.collect();
let generic_params = self.arena.alloc_from_iter(generic_params); let generic_params = self.arena.alloc_from_iter(generic_params);
debug!(?generic_params); debug!(?generic_params);
generic_params in_binder(self, generic_params)
} }
fn with_dyn_type_scope<T>(&mut self, in_scope: bool, f: impl FnOnce(&mut Self) -> T) -> T { fn with_dyn_type_scope<T>(&mut self, in_scope: bool, f: impl FnOnce(&mut Self) -> T) -> T {
@ -1236,14 +1244,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
hir::TyKind::Rptr(lifetime, self.lower_mt(mt, itctx)) hir::TyKind::Rptr(lifetime, self.lower_mt(mt, itctx))
} }
TyKind::BareFn(ref f) => { TyKind::BareFn(ref f) => {
let generic_params = self.lower_lifetime_binder(t.id, &f.generic_params); self.lower_lifetime_binder(t.id, &f.generic_params, |lctx, generic_params| {
hir::TyKind::BareFn(self.arena.alloc(hir::BareFnTy { hir::TyKind::BareFn(lctx.arena.alloc(hir::BareFnTy {
generic_params, generic_params,
unsafety: self.lower_unsafety(f.unsafety), unsafety: lctx.lower_unsafety(f.unsafety),
abi: self.lower_extern(f.ext), abi: lctx.lower_extern(f.ext),
decl: self.lower_fn_decl(&f.decl, None, FnDeclKind::Pointer, None), decl: lctx.lower_fn_decl(&f.decl, None, FnDeclKind::Pointer, None),
param_names: self.lower_fn_params_to_names(&f.decl), param_names: lctx.lower_fn_params_to_names(&f.decl),
})) }))
})
} }
TyKind::Never => hir::TyKind::Never, TyKind::Never => hir::TyKind::Never,
TyKind::Tup(ref tys) => hir::TyKind::Tup( TyKind::Tup(ref tys) => hir::TyKind::Tup(
@ -2140,10 +2149,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
p: &PolyTraitRef, p: &PolyTraitRef,
itctx: &mut ImplTraitContext, itctx: &mut ImplTraitContext,
) -> hir::PolyTraitRef<'hir> { ) -> hir::PolyTraitRef<'hir> {
let bound_generic_params = self.lower_lifetime_binder(
self.lower_lifetime_binder(p.trait_ref.ref_id, &p.bound_generic_params); p.trait_ref.ref_id,
let trait_ref = self.lower_trait_ref(&p.trait_ref, itctx); &p.bound_generic_params,
hir::PolyTraitRef { bound_generic_params, trait_ref, span: self.lower_span(p.span) } |lctx, bound_generic_params| {
let trait_ref = lctx.lower_trait_ref(&p.trait_ref, itctx);
hir::PolyTraitRef { bound_generic_params, trait_ref, span: lctx.lower_span(p.span) }
},
)
} }
fn lower_mt(&mut self, mt: &MutTy, itctx: &mut ImplTraitContext) -> hir::MutTy<'hir> { fn lower_mt(&mut self, mt: &MutTy, itctx: &mut ImplTraitContext) -> hir::MutTy<'hir> {