1 use super::{AnonymousLifetimeMode, LoweringContext, ParamMode}
;
2 use super::{ImplTraitContext, ImplTraitPosition}
;
5 use rustc_ast
::node_id
::NodeMap
;
7 use rustc_ast
::visit
::{self, AssocCtxt, FnCtxt, FnKind, Visitor}
;
9 use rustc_data_structures
::fx
::FxHashSet
;
10 use rustc_errors
::struct_span_err
;
12 use rustc_hir
::def
::{DefKind, Res}
;
13 use rustc_hir
::def_id
::LocalDefId
;
14 use rustc_span
::source_map
::{respan, DesugaringKind}
;
15 use rustc_span
::symbol
::{kw, sym, Ident}
;
17 use rustc_target
::spec
::abi
;
19 use smallvec
::{smallvec, SmallVec}
;
20 use std
::collections
::BTreeSet
;
23 pub(super) struct ItemLowerer
<'a
, 'lowering
, 'hir
> {
24 pub(super) lctx
: &'a
mut LoweringContext
<'lowering
, 'hir
>,
27 impl ItemLowerer
<'_
, '_
, '_
> {
28 fn with_trait_impl_ref(&mut self, impl_ref
: &Option
<TraitRef
>, f
: impl FnOnce(&mut Self)) {
29 let old
= self.lctx
.is_in_trait_impl
;
30 self.lctx
.is_in_trait_impl
= if let &None
= impl_ref { false }
else { true }
;
32 self.lctx
.is_in_trait_impl
= old
;
36 impl<'a
> Visitor
<'a
> for ItemLowerer
<'a
, '_
, '_
> {
37 fn visit_mod(&mut self, m
: &'a Mod
, _s
: Span
, _attrs
: &[Attribute
], n
: NodeId
) {
38 let hir_id
= self.lctx
.lower_node_id(n
);
40 self.lctx
.modules
.insert(
43 items
: BTreeSet
::new(),
44 trait_items
: BTreeSet
::new(),
45 impl_items
: BTreeSet
::new(),
49 let old
= self.lctx
.current_module
;
50 self.lctx
.current_module
= hir_id
;
51 visit
::walk_mod(self, m
);
52 self.lctx
.current_module
= old
;
55 fn visit_item(&mut self, item
: &'a Item
) {
56 let mut item_hir_id
= None
;
57 self.lctx
.with_hir_id_owner(item
.id
, |lctx
| {
58 lctx
.without_in_scope_lifetime_defs(|lctx
| {
59 if let Some(hir_item
) = lctx
.lower_item(item
) {
60 item_hir_id
= Some(hir_item
.hir_id
);
61 lctx
.insert_item(hir_item
);
66 if let Some(hir_id
) = item_hir_id
{
67 self.lctx
.with_parent_item_lifetime_defs(hir_id
, |this
| {
68 let this
= &mut ItemLowerer { lctx: this }
;
69 if let ItemKind
::Impl { ref of_trait, .. }
= item
.kind
{
70 this
.with_trait_impl_ref(of_trait
, |this
| visit
::walk_item(this
, item
));
72 visit
::walk_item(this
, item
);
78 fn visit_fn(&mut self, fk
: FnKind
<'a
>, sp
: Span
, _
: NodeId
) {
80 FnKind
::Fn(FnCtxt
::Foreign
, _
, sig
, _
, _
) => {
81 self.visit_fn_header(&sig
.header
);
82 visit
::walk_fn_decl(self, &sig
.decl
);
83 // Don't visit the foreign function body even if it has one, since lowering the
84 // body would have no meaning and will have already been caught as a parse error.
86 _
=> visit
::walk_fn(self, fk
, sp
),
90 fn visit_assoc_item(&mut self, item
: &'a AssocItem
, ctxt
: AssocCtxt
) {
91 self.lctx
.with_hir_id_owner(item
.id
, |lctx
| match ctxt
{
93 let hir_item
= lctx
.lower_trait_item(item
);
94 let id
= hir
::TraitItemId { hir_id: hir_item.hir_id }
;
95 lctx
.trait_items
.insert(id
, hir_item
);
96 lctx
.modules
.get_mut(&lctx
.current_module
).unwrap().trait_items
.insert(id
);
99 let hir_item
= lctx
.lower_impl_item(item
);
100 let id
= hir
::ImplItemId { hir_id: hir_item.hir_id }
;
101 lctx
.impl_items
.insert(id
, hir_item
);
102 lctx
.modules
.get_mut(&lctx
.current_module
).unwrap().impl_items
.insert(id
);
106 visit
::walk_assoc_item(self, item
, ctxt
);
110 impl<'hir
> LoweringContext
<'_
, 'hir
> {
111 // Same as the method above, but accepts `hir::GenericParam`s
112 // instead of `ast::GenericParam`s.
113 // This should only be used with generics that have already had their
114 // in-band lifetimes added. In practice, this means that this function is
115 // only used when lowering a child item of a trait or impl.
116 fn with_parent_item_lifetime_defs
<T
>(
118 parent_hir_id
: hir
::HirId
,
119 f
: impl FnOnce(&mut LoweringContext
<'_
, '_
>) -> T
,
121 let old_len
= self.in_scope_lifetimes
.len();
123 let parent_generics
= match self.items
.get(&parent_hir_id
).unwrap().kind
{
124 hir
::ItemKind
::Impl { ref generics, .. }
125 | hir
::ItemKind
::Trait(_
, _
, ref generics
, ..) => &generics
.params
[..],
128 let lt_def_names
= parent_generics
.iter().filter_map(|param
| match param
.kind
{
129 hir
::GenericParamKind
::Lifetime { .. }
=> Some(param
.name
.normalize_to_macros_2_0()),
132 self.in_scope_lifetimes
.extend(lt_def_names
);
136 self.in_scope_lifetimes
.truncate(old_len
);
140 // Clears (and restores) the `in_scope_lifetimes` field. Used when
141 // visiting nested items, which never inherit in-scope lifetimes
142 // from their surrounding environment.
143 fn without_in_scope_lifetime_defs
<T
>(
145 f
: impl FnOnce(&mut LoweringContext
<'_
, '_
>) -> T
,
147 let old_in_scope_lifetimes
= std
::mem
::replace(&mut self.in_scope_lifetimes
, vec
![]);
149 // this vector is only used when walking over impl headers,
150 // input types, and the like, and should not be non-empty in
152 assert
!(self.lifetimes_to_define
.is_empty());
156 assert
!(self.in_scope_lifetimes
.is_empty());
157 self.in_scope_lifetimes
= old_in_scope_lifetimes
;
162 pub(super) fn lower_mod(&mut self, m
: &Mod
) -> hir
::Mod
<'hir
> {
167 .alloc_from_iter(m
.items
.iter().flat_map(|x
| self.lower_item_id(x
))),
171 pub(super) fn lower_item_id(&mut self, i
: &Item
) -> SmallVec
<[hir
::ItemId
; 1]> {
172 let node_ids
= match i
.kind
{
173 ItemKind
::Use(ref use_tree
) => {
174 let mut vec
= smallvec
![i
.id
];
175 self.lower_item_id_use_tree(use_tree
, i
.id
, &mut vec
);
178 ItemKind
::MacroDef(..) => SmallVec
::new(),
179 ItemKind
::Fn(..) | ItemKind
::Impl { of_trait: None, .. }
=> smallvec
![i
.id
],
180 _
=> smallvec
![i
.id
],
185 .map(|node_id
| hir
::ItemId { id: self.allocate_hir_id_counter(node_id) }
)
189 fn lower_item_id_use_tree(
193 vec
: &mut SmallVec
<[NodeId
; 1]>,
196 UseTreeKind
::Nested(ref nested_vec
) => {
197 for &(ref nested
, id
) in nested_vec
{
199 self.lower_item_id_use_tree(nested
, id
, vec
);
202 UseTreeKind
::Glob
=> {}
203 UseTreeKind
::Simple(_
, id1
, id2
) => {
205 self.expect_full_res_from_use(base_id
).skip(1).zip([id1
, id2
].iter())
213 pub fn lower_item(&mut self, i
: &Item
) -> Option
<hir
::Item
<'hir
>> {
214 let mut ident
= i
.ident
;
215 let mut vis
= self.lower_visibility(&i
.vis
, None
);
216 let attrs
= self.lower_attrs(&i
.attrs
);
218 if let ItemKind
::MacroDef(MacroDef { ref body, macro_rules }
) = i
.kind
{
219 if !macro_rules
|| self.sess
.contains_name(&i
.attrs
, sym
::macro_export
) {
220 let hir_id
= self.lower_node_id(i
.id
);
221 let body
= P(self.lower_mac_args(body
));
222 self.exported_macros
.push(hir
::MacroDef
{
228 ast
: MacroDef { body, macro_rules }
,
231 self.non_exported_macro_attrs
.extend(attrs
.iter().cloned());
236 let kind
= self.lower_item_kind(i
.span
, i
.id
, &mut ident
, attrs
, &mut vis
, &i
.kind
);
238 Some(hir
::Item { hir_id: self.lower_node_id(i.id), ident, attrs, kind, vis, span: i.span }
)
246 attrs
: &'hir
[Attribute
],
247 vis
: &mut hir
::Visibility
<'hir
>,
249 ) -> hir
::ItemKind
<'hir
> {
251 ItemKind
::ExternCrate(orig_name
) => hir
::ItemKind
::ExternCrate(orig_name
),
252 ItemKind
::Use(ref use_tree
) => {
253 // Start with an empty prefix.
254 let prefix
= Path { segments: vec![], span: use_tree.span }
;
256 self.lower_use_tree(use_tree
, &prefix
, id
, vis
, ident
, attrs
)
258 ItemKind
::Static(ref t
, m
, ref e
) => {
259 let (ty
, body_id
) = self.lower_const_item(t
, span
, e
.as_deref());
260 hir
::ItemKind
::Static(ty
, m
, body_id
)
262 ItemKind
::Const(_
, ref t
, ref e
) => {
263 let (ty
, body_id
) = self.lower_const_item(t
, span
, e
.as_deref());
264 hir
::ItemKind
::Const(ty
, body_id
)
268 FnSig { ref decl, header, span: fn_sig_span }
,
272 let fn_def_id
= self.resolver
.local_def_id(id
);
273 self.with_new_scopes(|this
| {
274 this
.current_item
= Some(ident
.span
);
276 // Note: we don't need to change the return type from `T` to
277 // `impl Future<Output = T>` here because lower_body
278 // only cares about the input argument patterns in the function
279 // declaration (decl), not the return types.
280 let asyncness
= header
.asyncness
;
282 this
.lower_maybe_async_body(span
, &decl
, asyncness
, body
.as_deref());
284 let (generics
, decl
) = this
.add_in_band_defs(
287 AnonymousLifetimeMode
::PassThrough
,
289 let ret_id
= asyncness
.opt_return_id();
292 Some((fn_def_id
.to_def_id(), idty
)),
298 let sig
= hir
::FnSig
{
300 header
: this
.lower_fn_header(header
),
303 hir
::ItemKind
::Fn(sig
, generics
, body_id
)
306 ItemKind
::Mod(ref m
) => hir
::ItemKind
::Mod(self.lower_mod(m
)),
307 ItemKind
::ForeignMod(ref nm
) => hir
::ItemKind
::ForeignMod(self.lower_foreign_mod(nm
)),
308 ItemKind
::GlobalAsm(ref ga
) => hir
::ItemKind
::GlobalAsm(self.lower_global_asm(ga
)),
309 ItemKind
::TyAlias(_
, ref gen
, _
, Some(ref ty
)) => {
312 // type Foo = impl Trait
317 // opaque type Foo1: Trait
318 let ty
= self.lower_ty(
320 ImplTraitContext
::OtherOpaqueTy
{
321 capturable_lifetimes
: &mut FxHashSet
::default(),
322 origin
: hir
::OpaqueTyOrigin
::Misc
,
325 let generics
= self.lower_generics(gen
, ImplTraitContext
::disallowed());
326 hir
::ItemKind
::TyAlias(ty
, generics
)
328 ItemKind
::TyAlias(_
, ref generics
, _
, None
) => {
329 let ty
= self.arena
.alloc(self.ty(span
, hir
::TyKind
::Err
));
330 let generics
= self.lower_generics(generics
, ImplTraitContext
::disallowed());
331 hir
::ItemKind
::TyAlias(ty
, generics
)
333 ItemKind
::Enum(ref enum_definition
, ref generics
) => hir
::ItemKind
::Enum(
335 variants
: self.arena
.alloc_from_iter(
336 enum_definition
.variants
.iter().map(|x
| self.lower_variant(x
)),
339 self.lower_generics(generics
, ImplTraitContext
::disallowed()),
341 ItemKind
::Struct(ref struct_def
, ref generics
) => {
342 let struct_def
= self.lower_variant_data(struct_def
);
343 hir
::ItemKind
::Struct(
345 self.lower_generics(generics
, ImplTraitContext
::disallowed()),
348 ItemKind
::Union(ref vdata
, ref generics
) => {
349 let vdata
= self.lower_variant_data(vdata
);
350 hir
::ItemKind
::Union(
352 self.lower_generics(generics
, ImplTraitContext
::disallowed()),
360 generics
: ref ast_generics
,
361 of_trait
: ref trait_ref
,
363 items
: ref impl_items
,
365 let def_id
= self.resolver
.local_def_id(id
);
367 // Lower the "impl header" first. This ordering is important
368 // for in-band lifetimes! Consider `'a` here:
370 // impl Foo<'a> for u32 {
371 // fn method(&'a self) { .. }
374 // Because we start by lowering the `Foo<'a> for u32`
375 // part, we will add `'a` to the list of generics on
376 // the impl. When we then encounter it later in the
377 // method, it will not be considered an in-band
378 // lifetime to be added, but rather a reference to a
380 let lowered_trait_impl_id
= self.lower_node_id(id
);
381 let (generics
, (trait_ref
, lowered_ty
)) = self.add_in_band_defs(
384 AnonymousLifetimeMode
::CreateParameter
,
386 let trait_ref
= trait_ref
.as_ref().map(|trait_ref
| {
387 this
.lower_trait_ref(trait_ref
, ImplTraitContext
::disallowed())
390 if let Some(ref trait_ref
) = trait_ref
{
391 if let Res
::Def(DefKind
::Trait
, def_id
) = trait_ref
.path
.res
{
395 .push(lowered_trait_impl_id
);
399 let lowered_ty
= this
.lower_ty(ty
, ImplTraitContext
::disallowed());
401 (trait_ref
, lowered_ty
)
406 self.with_in_scope_lifetime_defs(&ast_generics
.params
, |this
| {
407 this
.arena
.alloc_from_iter(
408 impl_items
.iter().map(|item
| this
.lower_impl_item_ref(item
)),
412 // `defaultness.has_value()` is never called for an `impl`, always `true` in order
413 // to not cause an assertion failure inside the `lower_defaultness` function.
415 let (defaultness
, defaultness_span
) = self.lower_defaultness(defaultness
, has_val
);
416 hir
::ItemKind
::Impl
{
417 unsafety
: self.lower_unsafety(unsafety
),
421 constness
: self.lower_constness(constness
),
425 items
: new_impl_items
,
428 ItemKind
::Trait(is_auto
, unsafety
, ref generics
, ref bounds
, ref items
) => {
429 let bounds
= self.lower_param_bounds(bounds
, ImplTraitContext
::disallowed());
432 .alloc_from_iter(items
.iter().map(|item
| self.lower_trait_item_ref(item
)));
433 hir
::ItemKind
::Trait(
435 self.lower_unsafety(unsafety
),
436 self.lower_generics(generics
, ImplTraitContext
::disallowed()),
441 ItemKind
::TraitAlias(ref generics
, ref bounds
) => hir
::ItemKind
::TraitAlias(
442 self.lower_generics(generics
, ImplTraitContext
::disallowed()),
443 self.lower_param_bounds(bounds
, ImplTraitContext
::disallowed()),
445 ItemKind
::MacroDef(..) | ItemKind
::MacCall(..) => {
446 panic
!("`TyMac` should have been expanded by now")
456 ) -> (&'hir hir
::Ty
<'hir
>, hir
::BodyId
) {
457 let mut capturable_lifetimes
;
458 let itctx
= if self.sess
.features_untracked().impl_trait_in_bindings
{
459 capturable_lifetimes
= FxHashSet
::default();
460 ImplTraitContext
::OtherOpaqueTy
{
461 capturable_lifetimes
: &mut capturable_lifetimes
,
462 origin
: hir
::OpaqueTyOrigin
::Misc
,
465 ImplTraitContext
::Disallowed(ImplTraitPosition
::Binding
)
467 let ty
= self.lower_ty(ty
, itctx
);
468 (ty
, self.lower_const_body(span
, body
))
476 vis
: &mut hir
::Visibility
<'hir
>,
478 attrs
: &'hir
[Attribute
],
479 ) -> hir
::ItemKind
<'hir
> {
480 debug
!("lower_use_tree(tree={:?})", tree
);
481 debug
!("lower_use_tree: vis = {:?}", vis
);
483 let path
= &tree
.prefix
;
484 let segments
= prefix
.segments
.iter().chain(path
.segments
.iter()).cloned().collect();
487 UseTreeKind
::Simple(rename
, id1
, id2
) => {
488 *ident
= tree
.ident();
490 // First, apply the prefix to the path.
491 let mut path
= Path { segments, span: path.span }
;
493 // Correctly resolve `self` imports.
494 if path
.segments
.len() > 1
495 && path
.segments
.last().unwrap().ident
.name
== kw
::SelfLower
497 let _
= path
.segments
.pop();
498 if rename
.is_none() {
499 *ident
= path
.segments
.last().unwrap().ident
;
503 let mut resolutions
= self.expect_full_res_from_use(id
);
504 // We want to return *something* from this function, so hold onto the first item
506 let ret_res
= self.lower_res(resolutions
.next().unwrap_or(Res
::Err
));
508 // Here, we are looping over namespaces, if they exist for the definition
509 // being imported. We only handle type and value namespaces because we
510 // won't be dealing with macros in the rest of the compiler.
511 // Essentially a single `use` which imports two names is desugared into
513 for (res
, &new_node_id
) in resolutions
.zip([id1
, id2
].iter()) {
515 let mut path
= path
.clone();
516 for seg
in &mut path
.segments
{
517 seg
.id
= self.resolver
.next_node_id();
519 let span
= path
.span
;
521 self.with_hir_id_owner(new_node_id
, |this
| {
522 let new_id
= this
.lower_node_id(new_node_id
);
523 let res
= this
.lower_res(res
);
524 let path
= this
.lower_path_extra(res
, &path
, ParamMode
::Explicit
, None
);
525 let kind
= hir
::ItemKind
::Use(path
, hir
::UseKind
::Single
);
526 let vis
= this
.rebuild_vis(&vis
);
528 this
.insert_item(hir
::Item
{
539 let path
= self.lower_path_extra(ret_res
, &path
, ParamMode
::Explicit
, None
);
540 hir
::ItemKind
::Use(path
, hir
::UseKind
::Single
)
542 UseTreeKind
::Glob
=> {
544 self.lower_path(id
, &Path { segments, span: path.span }
, ParamMode
::Explicit
);
545 hir
::ItemKind
::Use(path
, hir
::UseKind
::Glob
)
547 UseTreeKind
::Nested(ref trees
) => {
548 // Nested imports are desugared into simple imports.
549 // So, if we start with
552 // pub(x) use foo::{a, b};
555 // we will create three items:
558 // pub(x) use foo::a;
559 // pub(x) use foo::b;
560 // pub(x) use foo::{}; // <-- this is called the `ListStem`
563 // The first two are produced by recursively invoking
564 // `lower_use_tree` (and indeed there may be things
565 // like `use foo::{a::{b, c}}` and so forth). They
566 // wind up being directly added to
567 // `self.items`. However, the structure of this
568 // function also requires us to return one item, and
569 // for that we return the `{}` import (called the
572 let prefix
= Path { segments, span: prefix.span.to(path.span) }
;
574 // Add all the nested `PathListItem`s to the HIR.
575 for &(ref use_tree
, id
) in trees
{
576 let new_hir_id
= self.lower_node_id(id
);
578 let mut prefix
= prefix
.clone();
580 // Give the segments new node-ids since they are being cloned.
581 for seg
in &mut prefix
.segments
{
582 seg
.id
= self.resolver
.next_node_id();
585 // Each `use` import is an item and thus are owners of the
586 // names in the path. Up to this point the nested import is
587 // the current owner, since we want each desugared import to
588 // own its own names, we have to adjust the owner before
589 // lowering the rest of the import.
590 self.with_hir_id_owner(id
, |this
| {
591 let mut vis
= this
.rebuild_vis(&vis
);
592 let mut ident
= *ident
;
595 this
.lower_use_tree(use_tree
, &prefix
, id
, &mut vis
, &mut ident
, attrs
);
597 this
.insert_item(hir
::Item
{
608 // Subtle and a bit hacky: we lower the privacy level
609 // of the list stem to "private" most of the time, but
610 // not for "restricted" paths. The key thing is that
611 // we don't want it to stay as `pub` (with no caveats)
612 // because that affects rustdoc and also the lints
613 // about `pub` items. But we can't *always* make it
614 // private -- particularly not for restricted paths --
615 // because it contains node-ids that would then be
616 // unused, failing the check that HirIds are "densely
619 hir
::VisibilityKind
::Public
620 | hir
::VisibilityKind
::Crate(_
)
621 | hir
::VisibilityKind
::Inherited
=> {
622 *vis
= respan(prefix
.span
.shrink_to_lo(), hir
::VisibilityKind
::Inherited
);
624 hir
::VisibilityKind
::Restricted { .. }
=> {
625 // Do nothing here, as described in the comment on the match.
629 let res
= self.expect_full_res_from_use(id
).next().unwrap_or(Res
::Err
);
630 let res
= self.lower_res(res
);
631 let path
= self.lower_path_extra(res
, &prefix
, ParamMode
::Explicit
, None
);
632 hir
::ItemKind
::Use(path
, hir
::UseKind
::ListStem
)
637 /// Paths like the visibility path in `pub(super) use foo::{bar, baz}` are repeated
638 /// many times in the HIR tree; for each occurrence, we need to assign distinct
639 /// `NodeId`s. (See, e.g., #56128.)
640 fn rebuild_use_path(&mut self, path
: &hir
::Path
<'hir
>) -> &'hir hir
::Path
<'hir
> {
641 debug
!("rebuild_use_path(path = {:?})", path
);
643 self.arena
.alloc_from_iter(path
.segments
.iter().map(|seg
| hir
::PathSegment
{
645 hir_id
: seg
.hir_id
.map(|_
| self.next_id()),
648 infer_args
: seg
.infer_args
,
650 self.arena
.alloc(hir
::Path { span: path.span, res: path.res, segments }
)
653 fn rebuild_vis(&mut self, vis
: &hir
::Visibility
<'hir
>) -> hir
::Visibility
<'hir
> {
654 let vis_kind
= match vis
.node
{
655 hir
::VisibilityKind
::Public
=> hir
::VisibilityKind
::Public
,
656 hir
::VisibilityKind
::Crate(sugar
) => hir
::VisibilityKind
::Crate(sugar
),
657 hir
::VisibilityKind
::Inherited
=> hir
::VisibilityKind
::Inherited
,
658 hir
::VisibilityKind
::Restricted { ref path, hir_id: _ }
=> {
659 hir
::VisibilityKind
::Restricted
{
660 path
: self.rebuild_use_path(path
),
661 hir_id
: self.next_id(),
665 respan(vis
.span
, vis_kind
)
668 fn lower_foreign_item(&mut self, i
: &ForeignItem
) -> hir
::ForeignItem
<'hir
> {
669 let def_id
= self.resolver
.local_def_id(i
.id
);
671 hir_id
: self.lower_node_id(i
.id
),
673 attrs
: self.lower_attrs(&i
.attrs
),
675 ForeignItemKind
::Fn(_
, ref sig
, ref generics
, _
) => {
676 let fdec
= &sig
.decl
;
677 let (generics
, (fn_dec
, fn_args
)) = self.add_in_band_defs(
680 AnonymousLifetimeMode
::PassThrough
,
683 // Disallow `impl Trait` in foreign items.
684 this
.lower_fn_decl(fdec
, None
, false, None
),
685 this
.lower_fn_params_to_names(fdec
),
690 hir
::ForeignItemKind
::Fn(fn_dec
, fn_args
, generics
)
692 ForeignItemKind
::Static(ref t
, m
, _
) => {
693 let ty
= self.lower_ty(t
, ImplTraitContext
::disallowed());
694 hir
::ForeignItemKind
::Static(ty
, m
)
696 ForeignItemKind
::TyAlias(..) => hir
::ForeignItemKind
::Type
,
697 ForeignItemKind
::MacCall(_
) => panic
!("macro shouldn't exist here"),
699 vis
: self.lower_visibility(&i
.vis
, None
),
704 fn lower_foreign_mod(&mut self, fm
: &ForeignMod
) -> hir
::ForeignMod
<'hir
> {
706 abi
: fm
.abi
.map_or(abi
::Abi
::C
, |abi
| self.lower_abi(abi
)),
707 items
: self.arena
.alloc_from_iter(fm
.items
.iter().map(|x
| self.lower_foreign_item(x
))),
711 fn lower_global_asm(&mut self, ga
: &GlobalAsm
) -> &'hir hir
::GlobalAsm
{
712 self.arena
.alloc(hir
::GlobalAsm { asm: ga.asm }
)
715 fn lower_variant(&mut self, v
: &Variant
) -> hir
::Variant
<'hir
> {
717 attrs
: self.lower_attrs(&v
.attrs
),
718 data
: self.lower_variant_data(&v
.data
),
719 disr_expr
: v
.disr_expr
.as_ref().map(|e
| self.lower_anon_const(e
)),
720 id
: self.lower_node_id(v
.id
),
726 fn lower_variant_data(&mut self, vdata
: &VariantData
) -> hir
::VariantData
<'hir
> {
728 VariantData
::Struct(ref fields
, recovered
) => hir
::VariantData
::Struct(
730 .alloc_from_iter(fields
.iter().enumerate().map(|f
| self.lower_struct_field(f
))),
733 VariantData
::Tuple(ref fields
, id
) => hir
::VariantData
::Tuple(
735 .alloc_from_iter(fields
.iter().enumerate().map(|f
| self.lower_struct_field(f
))),
736 self.lower_node_id(id
),
738 VariantData
::Unit(id
) => hir
::VariantData
::Unit(self.lower_node_id(id
)),
742 fn lower_struct_field(&mut self, (index
, f
): (usize, &StructField
)) -> hir
::StructField
<'hir
> {
743 let ty
= if let TyKind
::Path(ref qself
, ref path
) = f
.ty
.kind
{
744 let t
= self.lower_path_ty(
748 ParamMode
::ExplicitNamed
, // no `'_` in declarations (Issue #61124)
749 ImplTraitContext
::disallowed(),
753 self.lower_ty(&f
.ty
, ImplTraitContext
::disallowed())
757 hir_id
: self.lower_node_id(f
.id
),
758 ident
: match f
.ident
{
759 Some(ident
) => ident
,
760 // FIXME(jseyfried): positional field hygiene.
761 None
=> Ident
::new(sym
::integer(index
), f
.span
),
763 vis
: self.lower_visibility(&f
.vis
, None
),
765 attrs
: self.lower_attrs(&f
.attrs
),
769 fn lower_trait_item(&mut self, i
: &AssocItem
) -> hir
::TraitItem
<'hir
> {
770 let trait_item_def_id
= self.resolver
.local_def_id(i
.id
);
772 let (generics
, kind
) = match i
.kind
{
773 AssocItemKind
::Const(_
, ref ty
, ref default) => {
774 let ty
= self.lower_ty(ty
, ImplTraitContext
::disallowed());
775 let body
= default.as_ref().map(|x
| self.lower_const_body(i
.span
, Some(x
)));
776 (hir
::Generics
::empty(), hir
::TraitItemKind
::Const(ty
, body
))
778 AssocItemKind
::Fn(_
, ref sig
, ref generics
, None
) => {
779 let names
= self.lower_fn_params_to_names(&sig
.decl
);
780 let (generics
, sig
) =
781 self.lower_method_sig(generics
, sig
, trait_item_def_id
, false, None
);
782 (generics
, hir
::TraitItemKind
::Fn(sig
, hir
::TraitFn
::Required(names
)))
784 AssocItemKind
::Fn(_
, ref sig
, ref generics
, Some(ref body
)) => {
785 let body_id
= self.lower_fn_body_block(i
.span
, &sig
.decl
, Some(body
));
786 let (generics
, sig
) =
787 self.lower_method_sig(generics
, sig
, trait_item_def_id
, false, None
);
788 (generics
, hir
::TraitItemKind
::Fn(sig
, hir
::TraitFn
::Provided(body_id
)))
790 AssocItemKind
::TyAlias(_
, ref generics
, ref bounds
, ref default) => {
791 let ty
= default.as_ref().map(|x
| self.lower_ty(x
, ImplTraitContext
::disallowed()));
792 let generics
= self.lower_generics(generics
, ImplTraitContext
::disallowed());
793 let kind
= hir
::TraitItemKind
::Type(
794 self.lower_param_bounds(bounds
, ImplTraitContext
::disallowed()),
800 AssocItemKind
::MacCall(..) => panic
!("macro item shouldn't exist at this point"),
804 hir_id
: self.lower_node_id(i
.id
),
806 attrs
: self.lower_attrs(&i
.attrs
),
813 fn lower_trait_item_ref(&mut self, i
: &AssocItem
) -> hir
::TraitItemRef
{
814 let (kind
, has_default
) = match &i
.kind
{
815 AssocItemKind
::Const(_
, _
, default) => (hir
::AssocItemKind
::Const
, default.is_some()),
816 AssocItemKind
::TyAlias(_
, _
, _
, default) => {
817 (hir
::AssocItemKind
::Type
, default.is_some())
819 AssocItemKind
::Fn(_
, sig
, _
, default) => {
820 (hir
::AssocItemKind
::Fn { has_self: sig.decl.has_self() }
, default.is_some())
822 AssocItemKind
::MacCall(..) => unimplemented
!(),
824 let id
= hir
::TraitItemId { hir_id: self.lower_node_id(i.id) }
;
825 let defaultness
= hir
::Defaultness
::Default { has_value: has_default }
;
826 hir
::TraitItemRef { id, ident: i.ident, span: i.span, defaultness, kind }
829 /// Construct `ExprKind::Err` for the given `span`.
830 crate fn expr_err(&mut self, span
: Span
) -> hir
::Expr
<'hir
> {
831 self.expr(span
, hir
::ExprKind
::Err
, AttrVec
::new())
834 fn lower_impl_item(&mut self, i
: &AssocItem
) -> hir
::ImplItem
<'hir
> {
835 let impl_item_def_id
= self.resolver
.local_def_id(i
.id
);
837 let (generics
, kind
) = match &i
.kind
{
838 AssocItemKind
::Const(_
, ty
, expr
) => {
839 let ty
= self.lower_ty(ty
, ImplTraitContext
::disallowed());
841 hir
::Generics
::empty(),
842 hir
::ImplItemKind
::Const(ty
, self.lower_const_body(i
.span
, expr
.as_deref())),
845 AssocItemKind
::Fn(_
, sig
, generics
, body
) => {
846 self.current_item
= Some(i
.span
);
847 let asyncness
= sig
.header
.asyncness
;
849 self.lower_maybe_async_body(i
.span
, &sig
.decl
, asyncness
, body
.as_deref());
850 let impl_trait_return_allow
= !self.is_in_trait_impl
;
851 let (generics
, sig
) = self.lower_method_sig(
855 impl_trait_return_allow
,
856 asyncness
.opt_return_id(),
859 (generics
, hir
::ImplItemKind
::Fn(sig
, body_id
))
861 AssocItemKind
::TyAlias(_
, generics
, _
, ty
) => {
862 let generics
= self.lower_generics(generics
, ImplTraitContext
::disallowed());
863 let kind
= match ty
{
865 let ty
= self.arena
.alloc(self.ty(i
.span
, hir
::TyKind
::Err
));
866 hir
::ImplItemKind
::TyAlias(ty
)
869 let ty
= self.lower_ty(
871 ImplTraitContext
::OtherOpaqueTy
{
872 capturable_lifetimes
: &mut FxHashSet
::default(),
873 origin
: hir
::OpaqueTyOrigin
::Misc
,
876 hir
::ImplItemKind
::TyAlias(ty
)
881 AssocItemKind
::MacCall(..) => panic
!("`TyMac` should have been expanded by now"),
884 // Since `default impl` is not yet implemented, this is always true in impls.
885 let has_value
= true;
886 let (defaultness
, _
) = self.lower_defaultness(i
.kind
.defaultness(), has_value
);
888 hir_id
: self.lower_node_id(i
.id
),
890 attrs
: self.lower_attrs(&i
.attrs
),
892 vis
: self.lower_visibility(&i
.vis
, None
),
899 fn lower_impl_item_ref(&mut self, i
: &AssocItem
) -> hir
::ImplItemRef
<'hir
> {
900 // Since `default impl` is not yet implemented, this is always true in impls.
901 let has_value
= true;
902 let (defaultness
, _
) = self.lower_defaultness(i
.kind
.defaultness(), has_value
);
904 id
: hir
::ImplItemId { hir_id: self.lower_node_id(i.id) }
,
907 vis
: self.lower_visibility(&i
.vis
, Some(i
.id
)),
909 kind
: match &i
.kind
{
910 AssocItemKind
::Const(..) => hir
::AssocItemKind
::Const
,
911 AssocItemKind
::TyAlias(..) => hir
::AssocItemKind
::Type
,
912 AssocItemKind
::Fn(_
, sig
, ..) => {
913 hir
::AssocItemKind
::Fn { has_self: sig.decl.has_self() }
915 AssocItemKind
::MacCall(..) => unimplemented
!(),
920 /// If an `explicit_owner` is given, this method allocates the `HirId` in
921 /// the address space of that item instead of the item currently being
922 /// lowered. This can happen during `lower_impl_item_ref()` where we need to
923 /// lower a `Visibility` value although we haven't lowered the owning
924 /// `ImplItem` in question yet.
928 explicit_owner
: Option
<NodeId
>,
929 ) -> hir
::Visibility
<'hir
> {
930 let node
= match v
.node
{
931 VisibilityKind
::Public
=> hir
::VisibilityKind
::Public
,
932 VisibilityKind
::Crate(sugar
) => hir
::VisibilityKind
::Crate(sugar
),
933 VisibilityKind
::Restricted { ref path, id }
=> {
934 debug
!("lower_visibility: restricted path id = {:?}", id
);
935 let lowered_id
= if let Some(owner
) = explicit_owner
{
936 self.lower_node_id_with_owner(id
, owner
)
938 self.lower_node_id(id
)
940 let res
= self.expect_full_res(id
);
941 let res
= self.lower_res(res
);
942 hir
::VisibilityKind
::Restricted
{
943 path
: self.lower_path_extra(res
, path
, ParamMode
::Explicit
, explicit_owner
),
947 VisibilityKind
::Inherited
=> hir
::VisibilityKind
::Inherited
,
952 fn lower_defaultness(
956 ) -> (hir
::Defaultness
, Option
<Span
>) {
958 Defaultness
::Default(sp
) => (hir
::Defaultness
::Default { has_value }
, Some(sp
)),
959 Defaultness
::Final
=> {
961 (hir
::Defaultness
::Final
, None
)
968 params
: &'hir
[hir
::Param
<'hir
>],
969 value
: hir
::Expr
<'hir
>,
971 let body
= hir
::Body { generator_kind: self.generator_kind, params, value }
;
973 self.bodies
.insert(id
, body
);
977 pub(super) fn lower_body(
979 f
: impl FnOnce(&mut Self) -> (&'hir
[hir
::Param
<'hir
>], hir
::Expr
<'hir
>),
981 let prev_gen_kind
= self.generator_kind
.take();
982 let task_context
= self.task_context
.take();
983 let (parameters
, result
) = f(self);
984 let body_id
= self.record_body(parameters
, result
);
985 self.task_context
= task_context
;
986 self.generator_kind
= prev_gen_kind
;
990 fn lower_param(&mut self, param
: &Param
) -> hir
::Param
<'hir
> {
992 attrs
: self.lower_attrs(¶m
.attrs
),
993 hir_id
: self.lower_node_id(param
.id
),
994 pat
: self.lower_pat(¶m
.pat
),
995 ty_span
: param
.ty
.span
,
1000 pub(super) fn lower_fn_body(
1003 body
: impl FnOnce(&mut Self) -> hir
::Expr
<'hir
>,
1005 self.lower_body(|this
| {
1007 this
.arena
.alloc_from_iter(decl
.inputs
.iter().map(|x
| this
.lower_param(x
))),
1013 fn lower_fn_body_block(
1017 body
: Option
<&Block
>,
1019 self.lower_fn_body(decl
, |this
| this
.lower_block_expr_opt(span
, body
))
1022 fn lower_block_expr_opt(&mut self, span
: Span
, block
: Option
<&Block
>) -> hir
::Expr
<'hir
> {
1024 Some(block
) => self.lower_block_expr(block
),
1025 None
=> self.expr_err(span
),
1029 pub(super) fn lower_const_body(&mut self, span
: Span
, expr
: Option
<&Expr
>) -> hir
::BodyId
{
1030 self.lower_body(|this
| {
1034 Some(expr
) => this
.lower_expr_mut(expr
),
1035 None
=> this
.expr_err(span
),
1041 fn lower_maybe_async_body(
1046 body
: Option
<&Block
>,
1048 let closure_id
= match asyncness
{
1049 Async
::Yes { closure_id, .. }
=> closure_id
,
1050 Async
::No
=> return self.lower_fn_body_block(span
, decl
, body
),
1053 self.lower_body(|this
| {
1054 let mut parameters
: Vec
<hir
::Param
<'_
>> = Vec
::new();
1055 let mut statements
: Vec
<hir
::Stmt
<'_
>> = Vec
::new();
1057 // Async function parameters are lowered into the closure body so that they are
1058 // captured and so that the drop order matches the equivalent non-async functions.
1062 // async fn foo(<pattern>: <ty>, <pattern>: <ty>, <pattern>: <ty>) {
1068 // fn foo(__arg0: <ty>, __arg1: <ty>, __arg2: <ty>) {
1070 // let __arg2 = __arg2;
1071 // let <pattern> = __arg2;
1072 // let __arg1 = __arg1;
1073 // let <pattern> = __arg1;
1074 // let __arg0 = __arg0;
1075 // let <pattern> = __arg0;
1076 // drop-temps { <body> } // see comments later in fn for details
1080 // If `<pattern>` is a simple ident, then it is lowered to a single
1081 // `let <pattern> = <pattern>;` statement as an optimization.
1083 // Note that the body is embedded in `drop-temps`; an
1084 // equivalent desugaring would be `return { <body>
1085 // };`. The key point is that we wish to drop all the
1086 // let-bound variables and temporaries created in the body
1087 // (and its tail expression!) before we drop the
1088 // parameters (c.f. rust-lang/rust#64512).
1089 for (index
, parameter
) in decl
.inputs
.iter().enumerate() {
1090 let parameter
= this
.lower_param(parameter
);
1091 let span
= parameter
.pat
.span
;
1093 // Check if this is a binding pattern, if so, we can optimize and avoid adding a
1094 // `let <pat> = __argN;` statement. In this case, we do not rename the parameter.
1095 let (ident
, is_simple_parameter
) = match parameter
.pat
.kind
{
1096 hir
::PatKind
::Binding(hir
::BindingAnnotation
::Unannotated
, _
, ident
, _
) => {
1100 // Replace the ident for bindings that aren't simple.
1101 let name
= format
!("__arg{}", index
);
1102 let ident
= Ident
::from_str(&name
);
1108 let desugared_span
= this
.mark_span_with_reason(DesugaringKind
::Async
, span
, None
);
1110 // Construct a parameter representing `__argN: <ty>` to replace the parameter of the
1113 // If this is the simple case, this parameter will end up being the same as the
1114 // original parameter, but with a different pattern id.
1115 let mut stmt_attrs
= AttrVec
::new();
1116 stmt_attrs
.extend(parameter
.attrs
.iter().cloned());
1117 let (new_parameter_pat
, new_parameter_id
) = this
.pat_ident(desugared_span
, ident
);
1118 let new_parameter
= hir
::Param
{
1119 attrs
: parameter
.attrs
,
1120 hir_id
: parameter
.hir_id
,
1121 pat
: new_parameter_pat
,
1122 ty_span
: parameter
.ty_span
,
1123 span
: parameter
.span
,
1126 if is_simple_parameter
{
1127 // If this is the simple case, then we only insert one statement that is
1128 // `let <pat> = <pat>;`. We re-use the original argument's pattern so that
1129 // `HirId`s are densely assigned.
1130 let expr
= this
.expr_ident(desugared_span
, ident
, new_parameter_id
);
1131 let stmt
= this
.stmt_let_pat(
1136 hir
::LocalSource
::AsyncFn
,
1138 statements
.push(stmt
);
1140 // If this is not the simple case, then we construct two statements:
1143 // let __argN = __argN;
1144 // let <pat> = __argN;
1147 // The first statement moves the parameter into the closure and thus ensures
1148 // that the drop order is correct.
1150 // The second statement creates the bindings that the user wrote.
1152 // Construct the `let mut __argN = __argN;` statement. It must be a mut binding
1153 // because the user may have specified a `ref mut` binding in the next
1155 let (move_pat
, move_id
) = this
.pat_ident_binding_mode(
1158 hir
::BindingAnnotation
::Mutable
,
1160 let move_expr
= this
.expr_ident(desugared_span
, ident
, new_parameter_id
);
1161 let move_stmt
= this
.stmt_let_pat(
1166 hir
::LocalSource
::AsyncFn
,
1169 // Construct the `let <pat> = __argN;` statement. We re-use the original
1170 // parameter's pattern so that `HirId`s are densely assigned.
1171 let pattern_expr
= this
.expr_ident(desugared_span
, ident
, move_id
);
1172 let pattern_stmt
= this
.stmt_let_pat(
1177 hir
::LocalSource
::AsyncFn
,
1180 statements
.push(move_stmt
);
1181 statements
.push(pattern_stmt
);
1184 parameters
.push(new_parameter
);
1187 let body_span
= body
.map_or(span
, |b
| b
.span
);
1188 let async_expr
= this
.make_async_expr(
1193 hir
::AsyncGeneratorKind
::Fn
,
1195 // Create a block from the user's function body:
1196 let user_body
= this
.lower_block_expr_opt(body_span
, body
);
1198 // Transform into `drop-temps { <user-body> }`, an expression:
1199 let desugared_span
=
1200 this
.mark_span_with_reason(DesugaringKind
::Async
, user_body
.span
, None
);
1201 let user_body
= this
.expr_drop_temps(
1203 this
.arena
.alloc(user_body
),
1207 // As noted above, create the final block like
1211 // let $param_pattern = $raw_param;
1213 // drop-temps { <user-body> }
1216 let body
= this
.block_all(
1218 this
.arena
.alloc_from_iter(statements
),
1222 this
.expr_block(body
, AttrVec
::new())
1227 this
.arena
.alloc_from_iter(parameters
),
1228 this
.expr(body_span
, async_expr
, AttrVec
::new()),
1233 fn lower_method_sig(
1235 generics
: &Generics
,
1237 fn_def_id
: LocalDefId
,
1238 impl_trait_return_allow
: bool
,
1239 is_async
: Option
<NodeId
>,
1240 ) -> (hir
::Generics
<'hir
>, hir
::FnSig
<'hir
>) {
1241 let header
= self.lower_fn_header(sig
.header
);
1242 let (generics
, decl
) = self.add_in_band_defs(
1245 AnonymousLifetimeMode
::PassThrough
,
1249 Some((fn_def_id
.to_def_id(), idty
)),
1250 impl_trait_return_allow
,
1255 (generics
, hir
::FnSig { header, decl, span: sig.span }
)
1258 fn lower_fn_header(&mut self, h
: FnHeader
) -> hir
::FnHeader
{
1260 unsafety
: self.lower_unsafety(h
.unsafety
),
1261 asyncness
: self.lower_asyncness(h
.asyncness
),
1262 constness
: self.lower_constness(h
.constness
),
1263 abi
: self.lower_extern(h
.ext
),
1267 pub(super) fn lower_abi(&mut self, abi
: StrLit
) -> abi
::Abi
{
1268 abi
::lookup(&abi
.symbol_unescaped
.as_str()).unwrap_or_else(|| {
1269 self.error_on_invalid_abi(abi
);
1274 pub(super) fn lower_extern(&mut self, ext
: Extern
) -> abi
::Abi
{
1276 Extern
::None
=> abi
::Abi
::Rust
,
1277 Extern
::Implicit
=> abi
::Abi
::C
,
1278 Extern
::Explicit(abi
) => self.lower_abi(abi
),
1282 fn error_on_invalid_abi(&self, abi
: StrLit
) {
1283 struct_span_err
!(self.sess
, abi
.span
, E0703
, "invalid ABI: found `{}`", abi
.symbol
)
1284 .span_label(abi
.span
, "invalid ABI")
1285 .help(&format
!("valid ABIs: {}", abi
::all_names().join(", ")))
1289 fn lower_asyncness(&mut self, a
: Async
) -> hir
::IsAsync
{
1291 Async
::Yes { .. }
=> hir
::IsAsync
::Async
,
1292 Async
::No
=> hir
::IsAsync
::NotAsync
,
1296 fn lower_constness(&mut self, c
: Const
) -> hir
::Constness
{
1298 Const
::Yes(_
) => hir
::Constness
::Const
,
1299 Const
::No
=> hir
::Constness
::NotConst
,
1303 pub(super) fn lower_unsafety(&mut self, u
: Unsafe
) -> hir
::Unsafety
{
1305 Unsafe
::Yes(_
) => hir
::Unsafety
::Unsafe
,
1306 Unsafe
::No
=> hir
::Unsafety
::Normal
,
1310 pub(super) fn lower_generics_mut(
1312 generics
: &Generics
,
1313 itctx
: ImplTraitContext
<'_
, 'hir
>,
1314 ) -> GenericsCtor
<'hir
> {
1315 // Collect `?Trait` bounds in where clause and move them to parameter definitions.
1316 // FIXME: this could probably be done with less rightward drift. It also looks like two
1317 // control paths where `report_error` is called are the only paths that advance to after the
1318 // match statement, so the error reporting could probably just be moved there.
1319 let mut add_bounds
: NodeMap
<Vec
<_
>> = Default
::default();
1320 for pred
in &generics
.where_clause
.predicates
{
1321 if let WherePredicate
::BoundPredicate(ref bound_pred
) = *pred
{
1322 'next_bound
: for bound
in &bound_pred
.bounds
{
1323 if let GenericBound
::Trait(_
, TraitBoundModifier
::Maybe
) = *bound
{
1324 let report_error
= |this
: &mut Self| {
1325 this
.diagnostic().span_err(
1326 bound_pred
.bounded_ty
.span
,
1327 "`?Trait` bounds are only permitted at the \
1328 point where a type parameter is declared",
1331 // Check if the where clause type is a plain type parameter.
1332 match bound_pred
.bounded_ty
.kind
{
1333 TyKind
::Path(None
, ref path
)
1334 if path
.segments
.len() == 1
1335 && bound_pred
.bound_generic_params
.is_empty() =>
1337 if let Some(Res
::Def(DefKind
::TyParam
, def_id
)) = self
1339 .get_partial_res(bound_pred
.bounded_ty
.id
)
1340 .map(|d
| d
.base_res())
1342 if let Some(def_id
) = def_id
.as_local() {
1343 for param
in &generics
.params
{
1344 if let GenericParamKind
::Type { .. }
= param
.kind
{
1345 if def_id
== self.resolver
.local_def_id(param
.id
) {
1349 .push(bound
.clone());
1350 continue 'next_bound
;
1358 _
=> report_error(self),
1366 params
: self.lower_generic_params_mut(&generics
.params
, &add_bounds
, itctx
).collect(),
1367 where_clause
: self.lower_where_clause(&generics
.where_clause
),
1368 span
: generics
.span
,
1372 pub(super) fn lower_generics(
1374 generics
: &Generics
,
1375 itctx
: ImplTraitContext
<'_
, 'hir
>,
1376 ) -> hir
::Generics
<'hir
> {
1377 let generics_ctor
= self.lower_generics_mut(generics
, itctx
);
1378 generics_ctor
.into_generics(self.arena
)
1381 fn lower_where_clause(&mut self, wc
: &WhereClause
) -> hir
::WhereClause
<'hir
> {
1382 self.with_anonymous_lifetime_mode(AnonymousLifetimeMode
::ReportError
, |this
| {
1384 predicates
: this
.arena
.alloc_from_iter(
1385 wc
.predicates
.iter().map(|predicate
| this
.lower_where_predicate(predicate
)),
1392 fn lower_where_predicate(&mut self, pred
: &WherePredicate
) -> hir
::WherePredicate
<'hir
> {
1394 WherePredicate
::BoundPredicate(WhereBoundPredicate
{
1395 ref bound_generic_params
,
1400 self.with_in_scope_lifetime_defs(&bound_generic_params
, |this
| {
1401 hir
::WherePredicate
::BoundPredicate(hir
::WhereBoundPredicate
{
1402 bound_generic_params
: this
.lower_generic_params(
1403 bound_generic_params
,
1404 &NodeMap
::default(),
1405 ImplTraitContext
::disallowed(),
1407 bounded_ty
: this
.lower_ty(bounded_ty
, ImplTraitContext
::disallowed()),
1408 bounds
: this
.arena
.alloc_from_iter(bounds
.iter().filter_map(|bound
| {
1410 // Ignore `?Trait` bounds.
1411 // They were copied into type parameters already.
1412 GenericBound
::Trait(_
, TraitBoundModifier
::Maybe
) => None
,
1414 this
.lower_param_bound(bound
, ImplTraitContext
::disallowed()),
1422 WherePredicate
::RegionPredicate(WhereRegionPredicate
{
1426 }) => hir
::WherePredicate
::RegionPredicate(hir
::WhereRegionPredicate
{
1428 lifetime
: self.lower_lifetime(lifetime
),
1429 bounds
: self.lower_param_bounds(bounds
, ImplTraitContext
::disallowed()),
1431 WherePredicate
::EqPredicate(WhereEqPredicate { id, ref lhs_ty, ref rhs_ty, span }
) => {
1432 hir
::WherePredicate
::EqPredicate(hir
::WhereEqPredicate
{
1433 hir_id
: self.lower_node_id(id
),
1434 lhs_ty
: self.lower_ty(lhs_ty
, ImplTraitContext
::disallowed()),
1435 rhs_ty
: self.lower_ty(rhs_ty
, ImplTraitContext
::disallowed()),
1443 /// Helper struct for delayed construction of Generics.
1444 pub(super) struct GenericsCtor
<'hir
> {
1445 pub(super) params
: SmallVec
<[hir
::GenericParam
<'hir
>; 4]>,
1446 where_clause
: hir
::WhereClause
<'hir
>,
1450 impl<'hir
> GenericsCtor
<'hir
> {
1451 pub(super) fn into_generics(self, arena
: &'hir Arena
<'hir
>) -> hir
::Generics
<'hir
> {
1453 params
: arena
.alloc_from_iter(self.params
),
1454 where_clause
: self.where_clause
,