From 3d6eae8cd2134f1db0b4cbd13ce702acba6f36c4 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 31 May 2022 11:31:57 -0300 Subject: [PATCH 01/14] Move defs and bounds from Universal to LoweringContext --- compiler/rustc_ast_lowering/src/item.rs | 28 +++--- compiler/rustc_ast_lowering/src/lib.rs | 113 ++++++++++-------------- compiler/rustc_ast_lowering/src/path.rs | 6 +- 3 files changed, 60 insertions(+), 87 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 12d1b8404eb8b..e12a3ad3b7963 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -83,6 +83,8 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> { task_context: None, current_item: None, captured_lifetimes: None, + impl_trait_defs: Vec::new(), + impl_trait_bounds: Vec::new(), allow_try_trait: Some([sym::try_trait_v2, sym::yeet_desugar_details][..].into()), allow_gen_future: Some([sym::gen_future][..].into()), allow_into_future: Some([sym::into_future][..].into()), @@ -264,16 +266,10 @@ impl<'hir> LoweringContext<'_, 'hir> { let body_id = this.lower_maybe_async_body(span, &decl, asyncness, body.as_deref()); - let (generics, decl) = - this.add_implicit_generics(generics, id, |this, idty, idpb| { - let ret_id = asyncness.opt_return_id(); - this.lower_fn_decl( - &decl, - Some((id, idty, idpb)), - FnDeclKind::Fn, - ret_id, - ) - }); + let (generics, decl) = this.add_implicit_generics(generics, id, |this| { + let ret_id = asyncness.opt_return_id(); + this.lower_fn_decl(&decl, Some(id), FnDeclKind::Fn, ret_id) + }); let sig = hir::FnSig { decl, header: this.lower_fn_header(header), @@ -387,7 +383,7 @@ impl<'hir> LoweringContext<'_, 'hir> { // lifetime to be added, but rather a reference to a // parent lifetime. let (generics, (trait_ref, lowered_ty)) = - self.add_implicit_generics(ast_generics, id, |this, _, _| { + self.add_implicit_generics(ast_generics, id, |this| { let trait_ref = trait_ref.as_ref().map(|trait_ref| { this.lower_trait_ref( trait_ref, @@ -652,7 +648,7 @@ impl<'hir> LoweringContext<'_, 'hir> { ForeignItemKind::Fn(box Fn { ref sig, ref generics, .. }) => { let fdec = &sig.decl; let (generics, (fn_dec, fn_args)) = - self.add_implicit_generics(generics, i.id, |this, _, _| { + self.add_implicit_generics(generics, i.id, |this| { ( // Disallow `impl Trait` in foreign items. this.lower_fn_decl(fdec, None, FnDeclKind::ExternFn, None), @@ -1231,8 +1227,8 @@ impl<'hir> LoweringContext<'_, 'hir> { is_async: Option, ) -> (&'hir hir::Generics<'hir>, hir::FnSig<'hir>) { let header = self.lower_fn_header(sig.header); - let (generics, decl) = self.add_implicit_generics(generics, id, |this, idty, idpb| { - this.lower_fn_decl(&sig.decl, Some((id, idty, idpb)), kind, is_async) + let (generics, decl) = self.add_implicit_generics(generics, id, |this| { + this.lower_fn_decl(&sig.decl, Some(id), kind, is_async) }); (generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) }) } @@ -1292,7 +1288,7 @@ impl<'hir> LoweringContext<'_, 'hir> { pub(super) fn lower_generics_mut( &mut self, generics: &Generics, - mut itctx: ImplTraitContext<'_, 'hir>, + mut itctx: ImplTraitContext, ) -> GenericsCtor<'hir> { // Error if `?Trait` bounds in where clauses don't refer directly to type parameters. // Note: we used to clone these bounds directly onto the type parameter (and avoid lowering @@ -1372,7 +1368,7 @@ impl<'hir> LoweringContext<'_, 'hir> { pub(super) fn lower_generics( &mut self, generics: &Generics, - itctx: ImplTraitContext<'_, 'hir>, + itctx: ImplTraitContext, ) -> &'hir hir::Generics<'hir> { let generics_ctor = self.lower_generics_mut(generics, itctx); generics_ctor.into_generics(self.arena) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index e59bc9aa6b399..fb846249103ed 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -121,6 +121,9 @@ struct LoweringContext<'a, 'hir: 'a> { local_id_to_def_id: SortedMap, trait_map: FxHashMap>, + impl_trait_defs: Vec>, + impl_trait_bounds: Vec>, + /// NodeIds that are lowered inside the current HIR owner. node_id_to_local_id: FxHashMap, @@ -244,13 +247,13 @@ pub trait ResolverAstLowering { /// Context of `impl Trait` in code, which determines whether it is allowed in an HIR subtree, /// and if so, what meaning it has. #[derive(Debug)] -enum ImplTraitContext<'b, 'a> { +enum ImplTraitContext { /// Treat `impl Trait` as shorthand for a new universal generic parameter. /// Example: `fn foo(x: impl Debug)`, where `impl Debug` is conceptually /// equivalent to a fresh universal parameter like `fn foo(x: T)`. /// /// Newly generated parameters should be inserted into the given `Vec`. - Universal(&'b mut Vec>, &'b mut Vec>, LocalDefId), + Universal(LocalDefId), /// Treat `impl Trait` as shorthand for a new opaque type. /// Example: `fn foo() -> impl Debug`, where `impl Debug` is conceptually @@ -290,11 +293,11 @@ enum ImplTraitPosition { ImplReturn, } -impl<'a> ImplTraitContext<'_, 'a> { - fn reborrow<'this>(&'this mut self) -> ImplTraitContext<'this, 'a> { +impl ImplTraitContext { + fn reborrow<'this>(&'this mut self) -> ImplTraitContext { use self::ImplTraitContext::*; match self { - Universal(params, bounds, parent) => Universal(params, bounds, *parent), + Universal(parent) => Universal(*parent), ReturnPositionOpaqueTy { origin } => ReturnPositionOpaqueTy { origin: *origin }, TypeAliasesOpaqueTy => TypeAliasesOpaqueTy, Disallowed(pos) => Disallowed(*pos), @@ -701,34 +704,24 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { &mut self, generics: &Generics, parent_node_id: NodeId, - f: impl FnOnce( - &mut Self, - &mut Vec>, - &mut Vec>, - ) -> T, + f: impl FnOnce(&mut Self) -> T, ) -> (&'hir hir::Generics<'hir>, T) { - let mut impl_trait_defs = Vec::new(); - let mut impl_trait_bounds = Vec::new(); - let mut lowered_generics = self.lower_generics_mut( - generics, - ImplTraitContext::Universal( - &mut impl_trait_defs, - &mut impl_trait_bounds, - self.current_hir_id_owner, - ), - ); - let res = f(self, &mut impl_trait_defs, &mut impl_trait_bounds); + let mut lowered_generics = self + .lower_generics_mut(generics, ImplTraitContext::Universal(self.current_hir_id_owner)); + let res = f(self); let extra_lifetimes = self.resolver.take_extra_lifetime_params(parent_node_id); + let impl_trait_defs = std::mem::take(&mut self.impl_trait_defs); lowered_generics.params.extend( extra_lifetimes .into_iter() .filter_map(|(ident, node_id, res)| { self.lifetime_res_to_generic_param(ident, node_id, res) }) - .chain(impl_trait_defs), + .chain(impl_trait_defs.into_iter()), ); - lowered_generics.predicates.extend(impl_trait_bounds); + let impl_trait_bounds = std::mem::take(&mut self.impl_trait_bounds); + lowered_generics.predicates.extend(impl_trait_bounds.into_iter()); let lowered_generics = lowered_generics.into_generics(self.arena); (lowered_generics, res) @@ -898,7 +891,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { fn lower_assoc_ty_constraint( &mut self, constraint: &AssocConstraint, - mut itctx: ImplTraitContext<'_, 'hir>, + mut itctx: ImplTraitContext, ) -> hir::TypeBinding<'hir> { debug!("lower_assoc_ty_constraint(constraint={:?}, itctx={:?})", constraint, itctx); @@ -962,7 +955,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { // so desugar to // // fn foo(x: dyn Iterator) - ImplTraitContext::Universal(_, _, parent) if self.is_in_dyn_type => { + ImplTraitContext::Universal(parent) if self.is_in_dyn_type => { parent_def_id = parent; (true, itctx) } @@ -1036,7 +1029,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { fn lower_generic_arg( &mut self, arg: &ast::GenericArg, - itctx: ImplTraitContext<'_, 'hir>, + itctx: ImplTraitContext, ) -> hir::GenericArg<'hir> { match arg { ast::GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(<)), @@ -1103,7 +1096,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { } } - fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext<'_, 'hir>) -> &'hir hir::Ty<'hir> { + fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext) -> &'hir hir::Ty<'hir> { self.arena.alloc(self.lower_ty_direct(t, itctx)) } @@ -1113,7 +1106,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { qself: &Option, path: &Path, param_mode: ParamMode, - itctx: ImplTraitContext<'_, 'hir>, + itctx: ImplTraitContext, ) -> hir::Ty<'hir> { let id = self.lower_node_id(t.id); let qpath = self.lower_qpath(t.id, qself, path, param_mode, itctx); @@ -1128,7 +1121,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { self.ty(span, hir::TyKind::Tup(tys)) } - fn lower_ty_direct(&mut self, t: &Ty, mut itctx: ImplTraitContext<'_, 'hir>) -> hir::Ty<'hir> { + fn lower_ty_direct(&mut self, t: &Ty, mut itctx: ImplTraitContext) -> hir::Ty<'hir> { let kind = match t.kind { TyKind::Infer => hir::TyKind::Infer, TyKind::Err => hir::TyKind::Err, @@ -1235,32 +1228,24 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { |this| this.lower_param_bounds(bounds, nested_itctx), ) } - ImplTraitContext::Universal( - in_band_ty_params, - in_band_ty_bounds, - parent_def_id, - ) => { + ImplTraitContext::Universal(parent_def_id) => { // Add a definition for the in-band `Param`. let def_id = self.resolver.local_def_id(def_node_id); - let hir_bounds = self.lower_param_bounds( - bounds, - ImplTraitContext::Universal( - in_band_ty_params, - in_band_ty_bounds, - parent_def_id, - ), - ); + let hir_bounds = self + .lower_param_bounds(bounds, ImplTraitContext::Universal(parent_def_id)); // Set the name to `impl Bound1 + Bound2`. let ident = Ident::from_str_and_span(&pprust::ty_to_string(t), span); - in_band_ty_params.push(hir::GenericParam { + let param = hir::GenericParam { hir_id: self.lower_node_id(def_node_id), name: ParamName::Plain(self.lower_ident(ident)), pure_wrt_drop: false, span: self.lower_span(span), kind: hir::GenericParamKind::Type { default: None, synthetic: true }, colon_span: None, - }); + }; + self.impl_trait_defs.push(param); + if let Some(preds) = self.lower_generic_bound_predicate( ident, def_node_id, @@ -1268,7 +1253,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { hir_bounds, hir::PredicateOrigin::ImplTrait, ) { - in_band_ty_bounds.push(preds) + self.impl_trait_bounds.push(preds) } hir::TyKind::Path(hir::QPath::Resolved( @@ -1442,21 +1427,17 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { fn lower_fn_decl( &mut self, decl: &FnDecl, - mut in_band_ty_params: Option<( - NodeId, - &mut Vec>, - &mut Vec>, - )>, + fn_node_id: Option, kind: FnDeclKind, make_ret_async: Option, ) -> &'hir hir::FnDecl<'hir> { debug!( "lower_fn_decl(\ fn_decl: {:?}, \ - in_band_ty_params: {:?}, \ + fn_node_id: {:?}, \ kind: {:?}, \ make_ret_async: {:?})", - decl, in_band_ty_params, kind, make_ret_async, + decl, fn_node_id, kind, make_ret_async, ); let c_variadic = decl.c_variadic(); @@ -1469,10 +1450,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { inputs = &inputs[..inputs.len() - 1]; } let inputs = self.arena.alloc_from_iter(inputs.iter().map(|param| { - if let Some((_, ibty, ibpb)) = &mut in_band_ty_params { + if fn_node_id.is_some() { self.lower_ty_direct( ¶m.ty, - ImplTraitContext::Universal(ibty, ibpb, self.current_hir_id_owner), + ImplTraitContext::Universal(self.current_hir_id_owner), ) } else { self.lower_ty_direct( @@ -1494,15 +1475,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let output = if let Some(ret_id) = make_ret_async { self.lower_async_fn_ret_ty( &decl.output, - in_band_ty_params.expect("`make_ret_async` but no `fn_def_id`").0, + fn_node_id.expect("`make_ret_async` but no `fn_def_id`"), ret_id, ) } else { match decl.output { FnRetTy::Ty(ref ty) => { - let context = match in_band_ty_params { - Some((node_id, _, _)) if kind.impl_trait_return_allowed() => { - let fn_def_id = self.resolver.local_def_id(node_id); + let context = match fn_node_id { + Some(fn_node_id) if kind.impl_trait_return_allowed() => { + let fn_def_id = self.resolver.local_def_id(fn_node_id); ImplTraitContext::ReturnPositionOpaqueTy { origin: hir::OpaqueTyOrigin::FnReturn(fn_def_id), } @@ -1788,7 +1769,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { fn lower_param_bound( &mut self, tpb: &GenericBound, - itctx: ImplTraitContext<'_, 'hir>, + itctx: ImplTraitContext, ) -> hir::GenericBound<'hir> { match tpb { GenericBound::Trait(p, modifier) => hir::GenericBound::Trait( @@ -1966,11 +1947,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { } } - fn lower_trait_ref( - &mut self, - p: &TraitRef, - itctx: ImplTraitContext<'_, 'hir>, - ) -> hir::TraitRef<'hir> { + fn lower_trait_ref(&mut self, p: &TraitRef, itctx: ImplTraitContext) -> hir::TraitRef<'hir> { let path = match self.lower_qpath(p.ref_id, &None, &p.path, ParamMode::Explicit, itctx) { hir::QPath::Resolved(None, path) => path, qpath => panic!("lower_trait_ref: unexpected QPath `{:?}`", qpath), @@ -1982,7 +1959,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { fn lower_poly_trait_ref( &mut self, p: &PolyTraitRef, - mut itctx: ImplTraitContext<'_, 'hir>, + mut itctx: ImplTraitContext, ) -> hir::PolyTraitRef<'hir> { let bound_generic_params = self.lower_generic_params(&p.bound_generic_params); @@ -1993,14 +1970,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { hir::PolyTraitRef { bound_generic_params, trait_ref, span: self.lower_span(p.span) } } - fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext<'_, 'hir>) -> hir::MutTy<'hir> { + fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext) -> hir::MutTy<'hir> { hir::MutTy { ty: self.lower_ty(&mt.ty, itctx), mutbl: mt.mutbl } } fn lower_param_bounds( &mut self, bounds: &[GenericBound], - itctx: ImplTraitContext<'_, 'hir>, + itctx: ImplTraitContext, ) -> hir::GenericBounds<'hir> { self.arena.alloc_from_iter(self.lower_param_bounds_mut(bounds, itctx)) } @@ -2008,7 +1985,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { fn lower_param_bounds_mut<'s>( &'s mut self, bounds: &'s [GenericBound], - mut itctx: ImplTraitContext<'s, 'hir>, + mut itctx: ImplTraitContext, ) -> impl Iterator> + Captures<'s> + Captures<'a> { bounds.iter().map(move |bound| self.lower_param_bound(bound, itctx.reborrow())) } diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs index 7fc8aac5116f9..0827fc8173e5d 100644 --- a/compiler/rustc_ast_lowering/src/path.rs +++ b/compiler/rustc_ast_lowering/src/path.rs @@ -21,7 +21,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { qself: &Option, p: &Path, param_mode: ParamMode, - mut itctx: ImplTraitContext<'_, 'hir>, + mut itctx: ImplTraitContext, ) -> hir::QPath<'hir> { debug!("lower_qpath(id: {:?}, qself: {:?}, p: {:?})", id, qself, p); let qself_position = qself.as_ref().map(|q| q.position); @@ -180,7 +180,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { segment: &PathSegment, param_mode: ParamMode, parenthesized_generic_args: ParenthesizedGenericArgs, - itctx: ImplTraitContext<'_, 'hir>, + itctx: ImplTraitContext, ) -> hir::PathSegment<'hir> { debug!("path_span: {:?}, lower_path_segment(segment: {:?})", path_span, segment,); let (mut generic_args, infer_args) = if let Some(ref generic_args) = segment.args { @@ -318,7 +318,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { &mut self, data: &AngleBracketedArgs, param_mode: ParamMode, - mut itctx: ImplTraitContext<'_, 'hir>, + mut itctx: ImplTraitContext, ) -> (GenericArgsCtor<'hir>, bool) { let has_non_lt_args = data.args.iter().any(|arg| match arg { AngleBracketedArg::Arg(ast::GenericArg::Lifetime(_)) From 1a71103c93424da73d893d53dec2a30e3b2af2cd Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 31 May 2022 11:48:12 -0300 Subject: [PATCH 02/14] Take and restore fields in with_hir_id_owner calls --- compiler/rustc_ast_lowering/src/lib.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index fb846249103ed..872c9f53fc0da 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -482,6 +482,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let current_owner = std::mem::replace(&mut self.current_hir_id_owner, def_id); let current_local_counter = std::mem::replace(&mut self.item_local_id_counter, hir::ItemLocalId::new(1)); + let current_impl_trait_defs = std::mem::take(&mut self.impl_trait_defs); + let current_impl_trait_bounds = std::mem::take(&mut self.impl_trait_bounds); // Always allocate the first `HirId` for the owner itself. let _old = self.node_id_to_local_id.insert(owner, hir::ItemLocalId::new(0)); @@ -489,6 +491,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let item = f(self); debug_assert_eq!(def_id, item.def_id()); + debug_assert!(self.impl_trait_defs.is_empty()); + debug_assert!(self.impl_trait_bounds.is_empty()); let info = self.make_owner_info(item); self.attrs = current_attrs; @@ -498,6 +502,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { self.trait_map = current_trait_map; self.current_hir_id_owner = current_owner; self.item_local_id_counter = current_local_counter; + self.impl_trait_defs = current_impl_trait_defs; + self.impl_trait_bounds = current_impl_trait_bounds; let _old = self.children.insert(def_id, hir::MaybeOwner::Owner(info)); debug_assert!(_old.is_none()) From 190b4a71528a1eb83d43119db6877d7051cf8add Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 31 May 2022 14:54:30 -0300 Subject: [PATCH 03/14] Add itctx: ImplTraitContext arg to add_implicit_generics --- compiler/rustc_ast_lowering/src/item.rs | 19 ++++++++++++------- compiler/rustc_ast_lowering/src/lib.rs | 12 ++++++++++-- 2 files changed, 22 insertions(+), 9 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index e12a3ad3b7963..f05a739a949fb 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -266,10 +266,12 @@ impl<'hir> LoweringContext<'_, 'hir> { let body_id = this.lower_maybe_async_body(span, &decl, asyncness, body.as_deref()); - let (generics, decl) = this.add_implicit_generics(generics, id, |this| { - let ret_id = asyncness.opt_return_id(); - this.lower_fn_decl(&decl, Some(id), FnDeclKind::Fn, ret_id) - }); + let itctx = ImplTraitContext::Universal(this.current_hir_id_owner); + let (generics, decl) = + this.add_implicit_generics(generics, id, itctx, |this| { + let ret_id = asyncness.opt_return_id(); + this.lower_fn_decl(&decl, Some(id), FnDeclKind::Fn, ret_id) + }); let sig = hir::FnSig { decl, header: this.lower_fn_header(header), @@ -382,8 +384,9 @@ impl<'hir> LoweringContext<'_, 'hir> { // method, it will not be considered an in-band // lifetime to be added, but rather a reference to a // parent lifetime. + let itctx = ImplTraitContext::Universal(self.current_hir_id_owner); let (generics, (trait_ref, lowered_ty)) = - self.add_implicit_generics(ast_generics, id, |this| { + self.add_implicit_generics(ast_generics, id, itctx, |this| { let trait_ref = trait_ref.as_ref().map(|trait_ref| { this.lower_trait_ref( trait_ref, @@ -647,8 +650,9 @@ impl<'hir> LoweringContext<'_, 'hir> { kind: match i.kind { ForeignItemKind::Fn(box Fn { ref sig, ref generics, .. }) => { let fdec = &sig.decl; + let itctx = ImplTraitContext::Universal(self.current_hir_id_owner); let (generics, (fn_dec, fn_args)) = - self.add_implicit_generics(generics, i.id, |this| { + self.add_implicit_generics(generics, i.id, itctx, |this| { ( // Disallow `impl Trait` in foreign items. this.lower_fn_decl(fdec, None, FnDeclKind::ExternFn, None), @@ -1227,7 +1231,8 @@ impl<'hir> LoweringContext<'_, 'hir> { is_async: Option, ) -> (&'hir hir::Generics<'hir>, hir::FnSig<'hir>) { let header = self.lower_fn_header(sig.header); - let (generics, decl) = self.add_implicit_generics(generics, id, |this| { + let itctx = ImplTraitContext::Universal(self.current_hir_id_owner); + let (generics, decl) = self.add_implicit_generics(generics, id, itctx, |this| { this.lower_fn_decl(&sig.decl, Some(id), kind, is_async) }); (generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) }) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 872c9f53fc0da..2752a201ab9d2 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -710,10 +710,18 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { &mut self, generics: &Generics, parent_node_id: NodeId, + itctx: ImplTraitContext, f: impl FnOnce(&mut Self) -> T, ) -> (&'hir hir::Generics<'hir>, T) { - let mut lowered_generics = self - .lower_generics_mut(generics, ImplTraitContext::Universal(self.current_hir_id_owner)); + match itctx { + ImplTraitContext::Universal(..) => {} + _ => { + debug_assert!(self.impl_trait_defs.is_empty()); + debug_assert!(self.impl_trait_bounds.is_empty()); + } + } + + let mut lowered_generics = self.lower_generics_mut(generics, itctx); let res = f(self); let extra_lifetimes = self.resolver.take_extra_lifetime_params(parent_node_id); From e080298e35b6eb9f34a64e450eb08dc17cf1a21b Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 31 May 2022 15:30:14 -0300 Subject: [PATCH 04/14] Replace calls to lower_generics with calls to add_implicit_generics --- compiler/rustc_ast_lowering/src/item.rs | 176 ++++++++++++------------ 1 file changed, 87 insertions(+), 89 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index f05a739a949fb..2a8769c8fa093 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -309,57 +309,59 @@ impl<'hir> LoweringContext<'_, 'hir> { // // type Foo = Foo1 // opaque type Foo1: Trait - let ty = self.lower_ty(ty, ImplTraitContext::TypeAliasesOpaqueTy); let mut generics = generics.clone(); add_ty_alias_where_clause(&mut generics, where_clauses, true); - let generics = self.lower_generics( + let (generics, ty) = self.add_implicit_generics( &generics, + id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), + |this| this.lower_ty(ty, ImplTraitContext::TypeAliasesOpaqueTy), ); hir::ItemKind::TyAlias(ty, generics) } ItemKind::TyAlias(box TyAlias { ref generics, ref where_clauses, ty: None, .. }) => { - let ty = self.arena.alloc(self.ty(span, hir::TyKind::Err)); let mut generics = generics.clone(); add_ty_alias_where_clause(&mut generics, *where_clauses, true); - let generics = self.lower_generics( + let (generics, ty) = self.add_implicit_generics( &generics, + id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), + |this| this.arena.alloc(this.ty(span, hir::TyKind::Err)), ); hir::ItemKind::TyAlias(ty, generics) } - ItemKind::Enum(ref enum_definition, ref generics) => hir::ItemKind::Enum( - hir::EnumDef { - variants: self.arena.alloc_from_iter( - enum_definition.variants.iter().map(|x| self.lower_variant(x)), - ), - }, - self.lower_generics( + ItemKind::Enum(ref enum_definition, ref generics) => { + let (generics, variants) = self.add_implicit_generics( generics, + id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), - ), - ), + |this| { + this.arena.alloc_from_iter( + enum_definition.variants.iter().map(|x| this.lower_variant(x)), + ) + }, + ); + hir::ItemKind::Enum(hir::EnumDef { variants }, generics) + } ItemKind::Struct(ref struct_def, ref generics) => { - let struct_def = self.lower_variant_data(hir_id, struct_def); - hir::ItemKind::Struct( - struct_def, - self.lower_generics( - generics, - ImplTraitContext::Disallowed(ImplTraitPosition::Generic), - ), - ) + let (generics, struct_def) = self.add_implicit_generics( + generics, + id, + ImplTraitContext::Disallowed(ImplTraitPosition::Generic), + |this| this.lower_variant_data(hir_id, struct_def), + ); + hir::ItemKind::Struct(struct_def, generics) } ItemKind::Union(ref vdata, ref generics) => { - let vdata = self.lower_variant_data(hir_id, vdata); - hir::ItemKind::Union( - vdata, - self.lower_generics( - generics, - ImplTraitContext::Disallowed(ImplTraitPosition::Generic), - ), - ) + let (generics, vdata) = self.add_implicit_generics( + generics, + id, + ImplTraitContext::Disallowed(ImplTraitPosition::Generic), + |this| this.lower_variant_data(hir_id, vdata), + ); + hir::ItemKind::Union(vdata, generics) } ItemKind::Impl(box Impl { unsafety, @@ -431,34 +433,38 @@ impl<'hir> LoweringContext<'_, 'hir> { ref bounds, ref items, }) => { - let bounds = self.lower_param_bounds( - bounds, - ImplTraitContext::Disallowed(ImplTraitPosition::Bound), + let (generics, (unsafety, items, bounds)) = self.add_implicit_generics( + generics, + id, + ImplTraitContext::Disallowed(ImplTraitPosition::Generic), + |this| { + let bounds = this.lower_param_bounds( + bounds, + ImplTraitContext::Disallowed(ImplTraitPosition::Bound), + ); + let items = this.arena.alloc_from_iter( + items.iter().map(|item| this.lower_trait_item_ref(item)), + ); + let unsafety = this.lower_unsafety(unsafety); + (unsafety, items, bounds) + }, ); - let items = self - .arena - .alloc_from_iter(items.iter().map(|item| self.lower_trait_item_ref(item))); - hir::ItemKind::Trait( - is_auto, - self.lower_unsafety(unsafety), - self.lower_generics( - generics, - ImplTraitContext::Disallowed(ImplTraitPosition::Generic), - ), - bounds, - items, - ) + hir::ItemKind::Trait(is_auto, unsafety, generics, bounds, items) } - ItemKind::TraitAlias(ref generics, ref bounds) => hir::ItemKind::TraitAlias( - self.lower_generics( + ItemKind::TraitAlias(ref generics, ref bounds) => { + let (generics, bounds) = self.add_implicit_generics( generics, + id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), - ), - self.lower_param_bounds( - bounds, - ImplTraitContext::Disallowed(ImplTraitPosition::Bound), - ), - ), + |this| { + this.lower_param_bounds( + bounds, + ImplTraitContext::Disallowed(ImplTraitPosition::Bound), + ) + }, + ); + hir::ItemKind::TraitAlias(generics, bounds) + } ItemKind::MacroDef(MacroDef { ref body, macro_rules }) => { let body = P(self.lower_mac_args(body)); let macro_kind = self.resolver.decl_macro_kind(self.resolver.local_def_id(id)); @@ -789,24 +795,25 @@ impl<'hir> LoweringContext<'_, 'hir> { ref ty, .. }) => { - let ty = ty.as_ref().map(|x| { - self.lower_ty(x, ImplTraitContext::Disallowed(ImplTraitPosition::Type)) - }); let mut generics = generics.clone(); add_ty_alias_where_clause(&mut generics, where_clauses, false); - let generics = self.lower_generics( + self.add_implicit_generics( &generics, + i.id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), - ); - let kind = hir::TraitItemKind::Type( - self.lower_param_bounds( - bounds, - ImplTraitContext::Disallowed(ImplTraitPosition::Generic), - ), - ty, - ); - - (generics, kind) + |this| { + let ty = ty.as_ref().map(|x| { + this.lower_ty(x, ImplTraitContext::Disallowed(ImplTraitPosition::Type)) + }); + hir::TraitItemKind::Type( + this.lower_param_bounds( + bounds, + ImplTraitContext::Disallowed(ImplTraitPosition::Generic), + ), + ty, + ) + }, + ) } AssocItemKind::MacCall(..) => panic!("macro item shouldn't exist at this point"), }; @@ -876,21 +883,21 @@ impl<'hir> LoweringContext<'_, 'hir> { AssocItemKind::TyAlias(box TyAlias { generics, where_clauses, ty, .. }) => { let mut generics = generics.clone(); add_ty_alias_where_clause(&mut generics, *where_clauses, false); - let generics = self.lower_generics( + self.add_implicit_generics( &generics, + i.id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), - ); - let kind = match ty { - None => { - let ty = self.arena.alloc(self.ty(i.span, hir::TyKind::Err)); - hir::ImplItemKind::TyAlias(ty) - } - Some(ty) => { - let ty = self.lower_ty(ty, ImplTraitContext::TypeAliasesOpaqueTy); - hir::ImplItemKind::TyAlias(ty) - } - }; - (generics, kind) + |this| match ty { + None => { + let ty = this.arena.alloc(this.ty(i.span, hir::TyKind::Err)); + hir::ImplItemKind::TyAlias(ty) + } + Some(ty) => { + let ty = this.lower_ty(ty, ImplTraitContext::TypeAliasesOpaqueTy); + hir::ImplItemKind::TyAlias(ty) + } + }, + ) } AssocItemKind::MacCall(..) => panic!("`TyMac` should have been expanded by now"), }; @@ -1370,15 +1377,6 @@ impl<'hir> LoweringContext<'_, 'hir> { } } - pub(super) fn lower_generics( - &mut self, - generics: &Generics, - itctx: ImplTraitContext, - ) -> &'hir hir::Generics<'hir> { - let generics_ctor = self.lower_generics_mut(generics, itctx); - generics_ctor.into_generics(self.arena) - } - pub(super) fn lower_generic_bound_predicate( &mut self, ident: Ident, From d5ab8b2f5b39690c6f73c3459df838fd4c8f44ff Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 31 May 2022 15:32:05 -0300 Subject: [PATCH 05/14] Rename add_implicit_generics to lower_generics --- compiler/rustc_ast_lowering/src/item.rs | 33 ++++++++++++------------- compiler/rustc_ast_lowering/src/lib.rs | 2 +- 2 files changed, 17 insertions(+), 18 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 2a8769c8fa093..09d679e6eb7aa 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -267,11 +267,10 @@ impl<'hir> LoweringContext<'_, 'hir> { this.lower_maybe_async_body(span, &decl, asyncness, body.as_deref()); let itctx = ImplTraitContext::Universal(this.current_hir_id_owner); - let (generics, decl) = - this.add_implicit_generics(generics, id, itctx, |this| { - let ret_id = asyncness.opt_return_id(); - this.lower_fn_decl(&decl, Some(id), FnDeclKind::Fn, ret_id) - }); + let (generics, decl) = this.lower_generics(generics, id, itctx, |this| { + let ret_id = asyncness.opt_return_id(); + this.lower_fn_decl(&decl, Some(id), FnDeclKind::Fn, ret_id) + }); let sig = hir::FnSig { decl, header: this.lower_fn_header(header), @@ -311,7 +310,7 @@ impl<'hir> LoweringContext<'_, 'hir> { // opaque type Foo1: Trait let mut generics = generics.clone(); add_ty_alias_where_clause(&mut generics, where_clauses, true); - let (generics, ty) = self.add_implicit_generics( + let (generics, ty) = self.lower_generics( &generics, id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), @@ -324,7 +323,7 @@ impl<'hir> LoweringContext<'_, 'hir> { }) => { let mut generics = generics.clone(); add_ty_alias_where_clause(&mut generics, *where_clauses, true); - let (generics, ty) = self.add_implicit_generics( + let (generics, ty) = self.lower_generics( &generics, id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), @@ -333,7 +332,7 @@ impl<'hir> LoweringContext<'_, 'hir> { hir::ItemKind::TyAlias(ty, generics) } ItemKind::Enum(ref enum_definition, ref generics) => { - let (generics, variants) = self.add_implicit_generics( + let (generics, variants) = self.lower_generics( generics, id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), @@ -346,7 +345,7 @@ impl<'hir> LoweringContext<'_, 'hir> { hir::ItemKind::Enum(hir::EnumDef { variants }, generics) } ItemKind::Struct(ref struct_def, ref generics) => { - let (generics, struct_def) = self.add_implicit_generics( + let (generics, struct_def) = self.lower_generics( generics, id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), @@ -355,7 +354,7 @@ impl<'hir> LoweringContext<'_, 'hir> { hir::ItemKind::Struct(struct_def, generics) } ItemKind::Union(ref vdata, ref generics) => { - let (generics, vdata) = self.add_implicit_generics( + let (generics, vdata) = self.lower_generics( generics, id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), @@ -388,7 +387,7 @@ impl<'hir> LoweringContext<'_, 'hir> { // parent lifetime. let itctx = ImplTraitContext::Universal(self.current_hir_id_owner); let (generics, (trait_ref, lowered_ty)) = - self.add_implicit_generics(ast_generics, id, itctx, |this| { + self.lower_generics(ast_generics, id, itctx, |this| { let trait_ref = trait_ref.as_ref().map(|trait_ref| { this.lower_trait_ref( trait_ref, @@ -433,7 +432,7 @@ impl<'hir> LoweringContext<'_, 'hir> { ref bounds, ref items, }) => { - let (generics, (unsafety, items, bounds)) = self.add_implicit_generics( + let (generics, (unsafety, items, bounds)) = self.lower_generics( generics, id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), @@ -452,7 +451,7 @@ impl<'hir> LoweringContext<'_, 'hir> { hir::ItemKind::Trait(is_auto, unsafety, generics, bounds, items) } ItemKind::TraitAlias(ref generics, ref bounds) => { - let (generics, bounds) = self.add_implicit_generics( + let (generics, bounds) = self.lower_generics( generics, id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), @@ -658,7 +657,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let fdec = &sig.decl; let itctx = ImplTraitContext::Universal(self.current_hir_id_owner); let (generics, (fn_dec, fn_args)) = - self.add_implicit_generics(generics, i.id, itctx, |this| { + self.lower_generics(generics, i.id, itctx, |this| { ( // Disallow `impl Trait` in foreign items. this.lower_fn_decl(fdec, None, FnDeclKind::ExternFn, None), @@ -797,7 +796,7 @@ impl<'hir> LoweringContext<'_, 'hir> { }) => { let mut generics = generics.clone(); add_ty_alias_where_clause(&mut generics, where_clauses, false); - self.add_implicit_generics( + self.lower_generics( &generics, i.id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), @@ -883,7 +882,7 @@ impl<'hir> LoweringContext<'_, 'hir> { AssocItemKind::TyAlias(box TyAlias { generics, where_clauses, ty, .. }) => { let mut generics = generics.clone(); add_ty_alias_where_clause(&mut generics, *where_clauses, false); - self.add_implicit_generics( + self.lower_generics( &generics, i.id, ImplTraitContext::Disallowed(ImplTraitPosition::Generic), @@ -1239,7 +1238,7 @@ impl<'hir> LoweringContext<'_, 'hir> { ) -> (&'hir hir::Generics<'hir>, hir::FnSig<'hir>) { let header = self.lower_fn_header(sig.header); let itctx = ImplTraitContext::Universal(self.current_hir_id_owner); - let (generics, decl) = self.add_implicit_generics(generics, id, itctx, |this| { + let (generics, decl) = self.lower_generics(generics, id, itctx, |this| { this.lower_fn_decl(&sig.decl, Some(id), kind, is_async) }); (generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) }) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 2752a201ab9d2..90fc9bf8940c7 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -706,7 +706,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { /// Creates a new `hir::GenericParam` for every new `Fresh` lifetime and /// universal `impl Trait` type parameter encountered while evaluating `f`. /// Definitions are created with the provided `parent_def_id`. - fn add_implicit_generics( + fn lower_generics( &mut self, generics: &Generics, parent_node_id: NodeId, From bd3a097d64dc5a6db9a9d62bb89a74fe5cf36871 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 31 May 2022 15:33:51 -0300 Subject: [PATCH 06/14] Move lower_generics definition to item.rs --- compiler/rustc_ast_lowering/src/item.rs | 38 +++++++++++++++++++++++++ compiler/rustc_ast_lowering/src/lib.rs | 38 ------------------------- 2 files changed, 38 insertions(+), 38 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 09d679e6eb7aa..1b7fa1da77f29 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -1296,6 +1296,44 @@ impl<'hir> LoweringContext<'_, 'hir> { } } + /// Creates a new `hir::GenericParam` for every new `Fresh` lifetime and + /// universal `impl Trait` type parameter encountered while evaluating `f`. + /// Definitions are created with the provided `parent_def_id`. + fn lower_generics( + &mut self, + generics: &Generics, + parent_node_id: NodeId, + itctx: ImplTraitContext, + f: impl FnOnce(&mut Self) -> T, + ) -> (&'hir hir::Generics<'hir>, T) { + match itctx { + ImplTraitContext::Universal(..) => {} + _ => { + debug_assert!(self.impl_trait_defs.is_empty()); + debug_assert!(self.impl_trait_bounds.is_empty()); + } + } + + let mut lowered_generics = self.lower_generics_mut(generics, itctx); + let res = f(self); + + let extra_lifetimes = self.resolver.take_extra_lifetime_params(parent_node_id); + let impl_trait_defs = std::mem::take(&mut self.impl_trait_defs); + lowered_generics.params.extend( + extra_lifetimes + .into_iter() + .filter_map(|(ident, node_id, res)| { + self.lifetime_res_to_generic_param(ident, node_id, res) + }) + .chain(impl_trait_defs.into_iter()), + ); + let impl_trait_bounds = std::mem::take(&mut self.impl_trait_bounds); + lowered_generics.predicates.extend(impl_trait_bounds.into_iter()); + + let lowered_generics = lowered_generics.into_generics(self.arena); + (lowered_generics, res) + } + pub(super) fn lower_generics_mut( &mut self, generics: &Generics, diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 90fc9bf8940c7..8315d7aa3f0b8 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -703,44 +703,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { }) } - /// Creates a new `hir::GenericParam` for every new `Fresh` lifetime and - /// universal `impl Trait` type parameter encountered while evaluating `f`. - /// Definitions are created with the provided `parent_def_id`. - fn lower_generics( - &mut self, - generics: &Generics, - parent_node_id: NodeId, - itctx: ImplTraitContext, - f: impl FnOnce(&mut Self) -> T, - ) -> (&'hir hir::Generics<'hir>, T) { - match itctx { - ImplTraitContext::Universal(..) => {} - _ => { - debug_assert!(self.impl_trait_defs.is_empty()); - debug_assert!(self.impl_trait_bounds.is_empty()); - } - } - - let mut lowered_generics = self.lower_generics_mut(generics, itctx); - let res = f(self); - - let extra_lifetimes = self.resolver.take_extra_lifetime_params(parent_node_id); - let impl_trait_defs = std::mem::take(&mut self.impl_trait_defs); - lowered_generics.params.extend( - extra_lifetimes - .into_iter() - .filter_map(|(ident, node_id, res)| { - self.lifetime_res_to_generic_param(ident, node_id, res) - }) - .chain(impl_trait_defs.into_iter()), - ); - let impl_trait_bounds = std::mem::take(&mut self.impl_trait_bounds); - lowered_generics.predicates.extend(impl_trait_bounds.into_iter()); - - let lowered_generics = lowered_generics.into_generics(self.arena); - (lowered_generics, res) - } - /// Setup lifetime capture for and impl-trait. /// The captures will be added to `captures`. fn while_capturing_lifetimes( From 208ffbbe8699d169f5f0124d91a6d2b1774172a8 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 31 May 2022 16:47:40 -0300 Subject: [PATCH 07/14] derive Copy, Clone, PartialEq, Eq for ImplTraitContext --- compiler/rustc_ast_lowering/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 8315d7aa3f0b8..a934bcbe337e7 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -246,7 +246,7 @@ pub trait ResolverAstLowering { /// Context of `impl Trait` in code, which determines whether it is allowed in an HIR subtree, /// and if so, what meaning it has. -#[derive(Debug)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] enum ImplTraitContext { /// Treat `impl Trait` as shorthand for a new universal generic parameter. /// Example: `fn foo(x: impl Debug)`, where `impl Debug` is conceptually From d327db9319e7b8ec7dff56f1fc2cfb199d3151b9 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 31 May 2022 16:46:15 -0300 Subject: [PATCH 08/14] Remove ImplTraitContext::reborrow --- compiler/rustc_ast_lowering/src/item.rs | 4 +-- compiler/rustc_ast_lowering/src/lib.rs | 43 +++++++------------------ compiler/rustc_ast_lowering/src/path.rs | 16 ++++----- 3 files changed, 21 insertions(+), 42 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 1b7fa1da77f29..c905f4f11bcd8 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -1337,7 +1337,7 @@ impl<'hir> LoweringContext<'_, 'hir> { pub(super) fn lower_generics_mut( &mut self, generics: &Generics, - mut itctx: ImplTraitContext, + itctx: ImplTraitContext, ) -> GenericsCtor<'hir> { // Error if `?Trait` bounds in where clauses don't refer directly to type parameters. // Note: we used to clone these bounds directly onto the type parameter (and avoid lowering @@ -1388,7 +1388,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let mut predicates = SmallVec::new(); predicates.extend(generics.params.iter().filter_map(|param| { - let bounds = self.lower_param_bounds(¶m.bounds, itctx.reborrow()); + let bounds = self.lower_param_bounds(¶m.bounds, itctx); self.lower_generic_bound_predicate( param.ident, param.id, diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index a934bcbe337e7..1bd2988576a03 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -293,18 +293,6 @@ enum ImplTraitPosition { ImplReturn, } -impl ImplTraitContext { - fn reborrow<'this>(&'this mut self) -> ImplTraitContext { - use self::ImplTraitContext::*; - match self { - Universal(parent) => Universal(*parent), - ReturnPositionOpaqueTy { origin } => ReturnPositionOpaqueTy { origin: *origin }, - TypeAliasesOpaqueTy => TypeAliasesOpaqueTy, - Disallowed(pos) => Disallowed(*pos), - } - } -} - impl std::fmt::Display for ImplTraitPosition { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let name = match self { @@ -867,7 +855,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { fn lower_assoc_ty_constraint( &mut self, constraint: &AssocConstraint, - mut itctx: ImplTraitContext, + itctx: ImplTraitContext, ) -> hir::TypeBinding<'hir> { debug!("lower_assoc_ty_constraint(constraint={:?}, itctx={:?})", constraint, itctx); @@ -875,12 +863,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let gen_args = if let Some(ref gen_args) = constraint.gen_args { let gen_args_ctor = match gen_args { GenericArgs::AngleBracketed(ref data) => { - self.lower_angle_bracketed_parameter_data( - data, - ParamMode::Explicit, - itctx.reborrow(), - ) - .0 + self.lower_angle_bracketed_parameter_data(data, ParamMode::Explicit, itctx).0 } GenericArgs::Parenthesized(ref data) => { let mut err = self.sess.struct_span_err( @@ -892,7 +875,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { self.lower_angle_bracketed_parameter_data( &data.as_angle_bracketed_args(), ParamMode::Explicit, - itctx.reborrow(), + itctx, ) .0 } @@ -1097,7 +1080,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { self.ty(span, hir::TyKind::Tup(tys)) } - fn lower_ty_direct(&mut self, t: &Ty, mut itctx: ImplTraitContext) -> hir::Ty<'hir> { + fn lower_ty_direct(&mut self, t: &Ty, itctx: ImplTraitContext) -> hir::Ty<'hir> { let kind = match t.kind { TyKind::Infer => hir::TyKind::Infer, TyKind::Err => hir::TyKind::Err, @@ -1129,11 +1112,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { })) }), TyKind::Never => hir::TyKind::Never, - TyKind::Tup(ref tys) => { - hir::TyKind::Tup(self.arena.alloc_from_iter( - tys.iter().map(|ty| self.lower_ty_direct(ty, itctx.reborrow())), - )) - } + TyKind::Tup(ref tys) => hir::TyKind::Tup( + self.arena.alloc_from_iter(tys.iter().map(|ty| self.lower_ty_direct(ty, itctx))), + ), TyKind::Paren(ref ty) => { return self.lower_ty_direct(ty, itctx); } @@ -1167,7 +1148,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { GenericBound::Trait( ref ty, TraitBoundModifier::None | TraitBoundModifier::MaybeConst, - ) => Some(this.lower_poly_trait_ref(ty, itctx.reborrow())), + ) => Some(this.lower_poly_trait_ref(ty, itctx)), // `~const ?Bound` will cause an error during AST validation // anyways, so treat it like `?Bound` as compilation proceeds. GenericBound::Trait( @@ -1935,12 +1916,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { fn lower_poly_trait_ref( &mut self, p: &PolyTraitRef, - mut itctx: ImplTraitContext, + itctx: ImplTraitContext, ) -> hir::PolyTraitRef<'hir> { let bound_generic_params = self.lower_generic_params(&p.bound_generic_params); let trait_ref = self.with_lifetime_binder(p.trait_ref.ref_id, |this| { - this.lower_trait_ref(&p.trait_ref, itctx.reborrow()) + this.lower_trait_ref(&p.trait_ref, itctx) }); hir::PolyTraitRef { bound_generic_params, trait_ref, span: self.lower_span(p.span) } @@ -1961,9 +1942,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { fn lower_param_bounds_mut<'s>( &'s mut self, bounds: &'s [GenericBound], - mut itctx: ImplTraitContext, + itctx: ImplTraitContext, ) -> impl Iterator> + Captures<'s> + Captures<'a> { - bounds.iter().map(move |bound| self.lower_param_bound(bound, itctx.reborrow())) + bounds.iter().map(move |bound| self.lower_param_bound(bound, itctx)) } /// Lowers a block directly to an expression, presuming that it diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs index 0827fc8173e5d..d56974b773de6 100644 --- a/compiler/rustc_ast_lowering/src/path.rs +++ b/compiler/rustc_ast_lowering/src/path.rs @@ -21,11 +21,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { qself: &Option, p: &Path, param_mode: ParamMode, - mut itctx: ImplTraitContext, + itctx: ImplTraitContext, ) -> hir::QPath<'hir> { debug!("lower_qpath(id: {:?}, qself: {:?}, p: {:?})", id, qself, p); let qself_position = qself.as_ref().map(|q| q.position); - let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx.reborrow())); + let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx)); let partial_res = self.resolver.get_partial_res(id).unwrap_or_else(|| PartialRes::new(Res::Err)); @@ -70,7 +70,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { segment, param_mode, parenthesized_generic_args, - itctx.reborrow(), + itctx, ) }, )), @@ -116,7 +116,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { segment, param_mode, ParenthesizedGenericArgs::Err, - itctx.reborrow(), + itctx, )); let qpath = hir::QPath::TypeRelative(ty, hir_segment); @@ -318,7 +318,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { &mut self, data: &AngleBracketedArgs, param_mode: ParamMode, - mut itctx: ImplTraitContext, + itctx: ImplTraitContext, ) -> (GenericArgsCtor<'hir>, bool) { let has_non_lt_args = data.args.iter().any(|arg| match arg { AngleBracketedArg::Arg(ast::GenericArg::Lifetime(_)) @@ -329,14 +329,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { .args .iter() .filter_map(|arg| match arg { - AngleBracketedArg::Arg(arg) => Some(self.lower_generic_arg(arg, itctx.reborrow())), + AngleBracketedArg::Arg(arg) => Some(self.lower_generic_arg(arg, itctx)), AngleBracketedArg::Constraint(_) => None, }) .collect(); let bindings = self.arena.alloc_from_iter(data.args.iter().filter_map(|arg| match arg { - AngleBracketedArg::Constraint(c) => { - Some(self.lower_assoc_ty_constraint(c, itctx.reborrow())) - } + AngleBracketedArg::Constraint(c) => Some(self.lower_assoc_ty_constraint(c, itctx)), AngleBracketedArg::Arg(_) => None, })); let ctor = GenericArgsCtor { args, bindings, parenthesized: false, span: data.span }; From 2ade55d908758a2c66a437d5667c1714bfa890c2 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 31 May 2022 16:57:16 -0300 Subject: [PATCH 09/14] Inline lower_generics_mut and remove GenericsCtor --- compiler/rustc_ast_lowering/src/item.rs | 83 +++++++++---------------- 1 file changed, 29 insertions(+), 54 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index c905f4f11bcd8..c5f9f4a9c0bf4 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -1314,31 +1314,6 @@ impl<'hir> LoweringContext<'_, 'hir> { } } - let mut lowered_generics = self.lower_generics_mut(generics, itctx); - let res = f(self); - - let extra_lifetimes = self.resolver.take_extra_lifetime_params(parent_node_id); - let impl_trait_defs = std::mem::take(&mut self.impl_trait_defs); - lowered_generics.params.extend( - extra_lifetimes - .into_iter() - .filter_map(|(ident, node_id, res)| { - self.lifetime_res_to_generic_param(ident, node_id, res) - }) - .chain(impl_trait_defs.into_iter()), - ); - let impl_trait_bounds = std::mem::take(&mut self.impl_trait_bounds); - lowered_generics.predicates.extend(impl_trait_bounds.into_iter()); - - let lowered_generics = lowered_generics.into_generics(self.arena); - (lowered_generics, res) - } - - pub(super) fn lower_generics_mut( - &mut self, - generics: &Generics, - itctx: ImplTraitContext, - ) -> GenericsCtor<'hir> { // Error if `?Trait` bounds in where clauses don't refer directly to type parameters. // Note: we used to clone these bounds directly onto the type parameter (and avoid lowering // these into hir when we lower thee where clauses), but this makes it quite difficult to @@ -1386,7 +1361,7 @@ impl<'hir> LoweringContext<'_, 'hir> { } } - let mut predicates = SmallVec::new(); + let mut predicates: SmallVec<[hir::WherePredicate<'hir>; 4]> = SmallVec::new(); predicates.extend(generics.params.iter().filter_map(|param| { let bounds = self.lower_param_bounds(¶m.bounds, itctx); self.lower_generic_bound_predicate( @@ -1405,13 +1380,34 @@ impl<'hir> LoweringContext<'_, 'hir> { .map(|predicate| self.lower_where_predicate(predicate)), ); - GenericsCtor { - params: self.lower_generic_params_mut(&generics.params).collect(), - predicates, - has_where_clause: !generics.where_clause.predicates.is_empty(), - where_clause_span: self.lower_span(generics.where_clause.span), - span: self.lower_span(generics.span), - } + let mut params: Vec<_> = self.lower_generic_params_mut(&generics.params).collect(); + let has_where_clause = !generics.where_clause.predicates.is_empty(); + let where_clause_span = self.lower_span(generics.where_clause.span); + let span = self.lower_span(generics.span); + let res = f(self); + + let extra_lifetimes = self.resolver.take_extra_lifetime_params(parent_node_id); + let impl_trait_defs = std::mem::take(&mut self.impl_trait_defs); + params.extend( + extra_lifetimes + .into_iter() + .filter_map(|(ident, node_id, res)| { + self.lifetime_res_to_generic_param(ident, node_id, res) + }) + .chain(impl_trait_defs.into_iter()), + ); + let impl_trait_bounds = std::mem::take(&mut self.impl_trait_bounds); + predicates.extend(impl_trait_bounds.into_iter()); + + let lowered_generics = self.arena.alloc(hir::Generics { + params: self.arena.alloc_from_iter(params), + predicates: self.arena.alloc_from_iter(predicates), + has_where_clause, + where_clause_span, + span, + }); + + (lowered_generics, res) } pub(super) fn lower_generic_bound_predicate( @@ -1527,24 +1523,3 @@ impl<'hir> LoweringContext<'_, 'hir> { } } } - -/// Helper struct for delayed construction of Generics. -pub(super) struct GenericsCtor<'hir> { - pub(super) params: SmallVec<[hir::GenericParam<'hir>; 4]>, - pub(super) predicates: SmallVec<[hir::WherePredicate<'hir>; 4]>, - has_where_clause: bool, - where_clause_span: Span, - span: Span, -} - -impl<'hir> GenericsCtor<'hir> { - pub(super) fn into_generics(self, arena: &'hir Arena<'hir>) -> &'hir hir::Generics<'hir> { - arena.alloc(hir::Generics { - params: arena.alloc_from_iter(self.params), - predicates: arena.alloc_from_iter(self.predicates), - has_where_clause: self.has_where_clause, - where_clause_span: self.where_clause_span, - span: self.span, - }) - } -} From 15f2b119b1e5266ebcaf058f5b4e8a5cd6332452 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Tue, 31 May 2022 17:40:50 -0300 Subject: [PATCH 10/14] Fix lower_generics rustdocs --- compiler/rustc_ast_lowering/src/item.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index c5f9f4a9c0bf4..f4301e9a84312 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -1296,9 +1296,8 @@ impl<'hir> LoweringContext<'_, 'hir> { } } - /// Creates a new `hir::GenericParam` for every new `Fresh` lifetime and - /// universal `impl Trait` type parameter encountered while evaluating `f`. - /// Definitions are created with the provided `parent_def_id`. + /// Return the pair of the lowered `generics` as `hir::Generics` and the evaluation of `f` with + /// the carried impl trait definitions and bounds. fn lower_generics( &mut self, generics: &Generics, From b3bc438f56693bd04b05eba44cd7a2e679f5ab0e Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Wed, 1 Jun 2022 14:43:16 -0300 Subject: [PATCH 11/14] Add debug_assert comment Co-authored-by: Camille Gillot --- compiler/rustc_ast_lowering/src/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 1bd2988576a03..b3aa605283fb3 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -479,6 +479,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let item = f(self); debug_assert_eq!(def_id, item.def_id()); + // `f` should have consumed all the elements in these vectors when constructing `item`. debug_assert!(self.impl_trait_defs.is_empty()); debug_assert!(self.impl_trait_bounds.is_empty()); let info = self.make_owner_info(item); From 2de2520e9421a7e2871eaf702c62172ac8eb6781 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Wed, 1 Jun 2022 14:42:16 -0300 Subject: [PATCH 12/14] Split extend + inner chain into to extend calls --- compiler/rustc_ast_lowering/src/item.rs | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index f4301e9a84312..deb9a8677cc74 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -1387,14 +1387,11 @@ impl<'hir> LoweringContext<'_, 'hir> { let extra_lifetimes = self.resolver.take_extra_lifetime_params(parent_node_id); let impl_trait_defs = std::mem::take(&mut self.impl_trait_defs); - params.extend( - extra_lifetimes - .into_iter() - .filter_map(|(ident, node_id, res)| { - self.lifetime_res_to_generic_param(ident, node_id, res) - }) - .chain(impl_trait_defs.into_iter()), - ); + params.extend(extra_lifetimes.into_iter().filter_map(|(ident, node_id, res)| { + self.lifetime_res_to_generic_param(ident, node_id, res) + })); + params.extend(impl_trait_defs.into_iter()); + let impl_trait_bounds = std::mem::take(&mut self.impl_trait_bounds); predicates.extend(impl_trait_bounds.into_iter()); From 67deaf9fea648ab39ff18cb4afe06938a0034381 Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Wed, 1 Jun 2022 14:48:02 -0300 Subject: [PATCH 13/14] instrument lower_fn_decl --- compiler/rustc_ast_lowering/src/lib.rs | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index b3aa605283fb3..2e93ce2f47e16 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -1382,6 +1382,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { // `make_ret_async`: if `Some`, converts `-> T` into `-> impl Future` in the // return type. This is used for `async fn` declarations. The `NodeId` is the ID of the // return type `impl Trait` item. + #[tracing::instrument(level = "debug", skip(self))] fn lower_fn_decl( &mut self, decl: &FnDecl, @@ -1389,15 +1390,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { kind: FnDeclKind, make_ret_async: Option, ) -> &'hir hir::FnDecl<'hir> { - debug!( - "lower_fn_decl(\ - fn_decl: {:?}, \ - fn_node_id: {:?}, \ - kind: {:?}, \ - make_ret_async: {:?})", - decl, fn_node_id, kind, make_ret_async, - ); - let c_variadic = decl.c_variadic(); // Skip the `...` (`CVarArgs`) trailing arguments from the AST, From 15a82d6917c66e695e8932771217f164c8fe008c Mon Sep 17 00:00:00 2001 From: Santiago Pastorino Date: Wed, 1 Jun 2022 15:38:37 -0300 Subject: [PATCH 14/14] Always assert that impl_trait_def|bounds are empty at start --- compiler/rustc_ast_lowering/src/item.rs | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index deb9a8677cc74..85d3bf66d8e1c 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -1305,13 +1305,8 @@ impl<'hir> LoweringContext<'_, 'hir> { itctx: ImplTraitContext, f: impl FnOnce(&mut Self) -> T, ) -> (&'hir hir::Generics<'hir>, T) { - match itctx { - ImplTraitContext::Universal(..) => {} - _ => { - debug_assert!(self.impl_trait_defs.is_empty()); - debug_assert!(self.impl_trait_bounds.is_empty()); - } - } + debug_assert!(self.impl_trait_defs.is_empty()); + debug_assert!(self.impl_trait_bounds.is_empty()); // Error if `?Trait` bounds in where clauses don't refer directly to type parameters. // Note: we used to clone these bounds directly onto the type parameter (and avoid lowering