rustc_hir_analysis/collect/
generics_of.rs

1use std::assert_matches::assert_matches;
2use std::ops::ControlFlow;
3
4use hir::intravisit::{self, Visitor};
5use hir::{GenericParamKind, HirId, Node};
6use rustc_hir::def::DefKind;
7use rustc_hir::def_id::LocalDefId;
8use rustc_hir::intravisit::VisitorExt;
9use rustc_hir::{self as hir, AmbigArg};
10use rustc_middle::ty::{self, TyCtxt};
11use rustc_session::lint;
12use rustc_span::{Span, Symbol, kw};
13use tracing::{debug, instrument};
14
15use crate::delegation::inherit_generics_for_delegation_item;
16use crate::middle::resolve_bound_vars as rbv;
17
18#[instrument(level = "debug", skip(tcx), ret)]
19pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
20    use rustc_hir::*;
21
22    // For an RPITIT, synthesize generics which are equal to the opaque's generics
23    // and parent fn's generics compressed into one list.
24    if let Some(ty::ImplTraitInTraitData::Trait { fn_def_id, opaque_def_id }) =
25        tcx.opt_rpitit_info(def_id.to_def_id())
26    {
27        debug!("RPITIT fn_def_id={fn_def_id:?} opaque_def_id={opaque_def_id:?}");
28        let trait_def_id = tcx.parent(fn_def_id);
29        let opaque_ty_generics = tcx.generics_of(opaque_def_id);
30        let opaque_ty_parent_count = opaque_ty_generics.parent_count;
31        let mut own_params = opaque_ty_generics.own_params.clone();
32
33        let parent_generics = tcx.generics_of(trait_def_id);
34        let parent_count = parent_generics.parent_count + parent_generics.own_params.len();
35
36        let mut trait_fn_params = tcx.generics_of(fn_def_id).own_params.clone();
37
38        for param in &mut own_params {
39            param.index = param.index + parent_count as u32 + trait_fn_params.len() as u32
40                - opaque_ty_parent_count as u32;
41        }
42
43        trait_fn_params.extend(own_params);
44        own_params = trait_fn_params;
45
46        let param_def_id_to_index =
47            own_params.iter().map(|param| (param.def_id, param.index)).collect();
48
49        return ty::Generics {
50            parent: Some(trait_def_id),
51            parent_count,
52            own_params,
53            param_def_id_to_index,
54            has_self: opaque_ty_generics.has_self,
55            has_late_bound_regions: opaque_ty_generics.has_late_bound_regions,
56        };
57    }
58
59    let hir_id = tcx.local_def_id_to_hir_id(def_id);
60
61    let node = tcx.hir_node(hir_id);
62    if let Some(sig) = node.fn_sig()
63        && let Some(sig_id) = sig.decl.opt_delegation_sig_id()
64    {
65        return inherit_generics_for_delegation_item(tcx, def_id, sig_id);
66    }
67
68    let parent_def_id = match node {
69        Node::ImplItem(_)
70        | Node::TraitItem(_)
71        | Node::Variant(_)
72        | Node::Ctor(..)
73        | Node::Field(_) => {
74            let parent_id = tcx.hir_get_parent_item(hir_id);
75            Some(parent_id.to_def_id())
76        }
77        // FIXME(#43408) always enable this once `lazy_normalization` is
78        // stable enough and does not need a feature gate anymore.
79        Node::AnonConst(_) => {
80            let parent_did = tcx.parent(def_id.to_def_id());
81
82            // We don't do this unconditionally because the `DefId` parent of an anon const
83            // might be an implicitly created closure during `async fn` desugaring. This would
84            // have the wrong generics.
85            //
86            // i.e. `async fn foo<'a>() { let a = [(); { 1 + 2 }]; bar().await() }`
87            // would implicitly have a closure in its body that would be the parent of
88            // the `{ 1 + 2 }` anon const. This closure's generics is simply a witness
89            // instead of `['a]`.
90            let parent_did = if let DefKind::AnonConst = tcx.def_kind(parent_did) {
91                parent_did
92            } else {
93                tcx.hir_get_parent_item(hir_id).to_def_id()
94            };
95            debug!(?parent_did);
96
97            let mut in_param_ty = false;
98            for (_parent, node) in tcx.hir_parent_iter(hir_id) {
99                if let Some(generics) = node.generics() {
100                    let mut visitor = AnonConstInParamTyDetector { in_param_ty: false, ct: hir_id };
101
102                    in_param_ty = visitor.visit_generics(generics).is_break();
103                    break;
104                }
105            }
106
107            match tcx.anon_const_kind(def_id) {
108                // Stable: anon consts are not able to use any generic parameters...
109                ty::AnonConstKind::MCG => None,
110                // we provide generics to repeat expr counts as a backwards compatibility hack. #76200
111                ty::AnonConstKind::RepeatExprCount => Some(parent_did),
112
113                // Even GCE anon const should not be allowed to use generic parameters as it would be
114                // trivially forward declared uses once desugared. E.g. `const N: [u8; ANON::<N>]`.
115                //
116                // We could potentially mirror the hack done for defaults of generic parameters but
117                // this case just doesn't come up much compared to `const N: u32 = ...`. Long term the
118                // hack for defaulted parameters should be removed eventually anyway.
119                ty::AnonConstKind::GCE if in_param_ty => None,
120                // GCE anon consts as a default for a generic parameter should have their provided generics
121                // "truncated" up to whatever generic parameter this anon const is within the default of.
122                //
123                // FIXME(generic_const_exprs): This only handles `const N: usize = /*defid*/` but not type
124                // parameter defaults, e.g. `T = Foo</*defid*/>`.
125                ty::AnonConstKind::GCE
126                    if let Some(param_id) =
127                        tcx.hir_opt_const_param_default_param_def_id(hir_id) =>
128                {
129                    // If the def_id we are calling generics_of on is an anon ct default i.e:
130                    //
131                    // struct Foo<const N: usize = { .. }>;
132                    //        ^^^       ^          ^^^^^^ def id of this anon const
133                    //        ^         ^ param_id
134                    //        ^ parent_def_id
135                    //
136                    // then we only want to return generics for params to the left of `N`. If we don't do that we
137                    // end up with that const looking like: `ty::ConstKind::Unevaluated(def_id, args: [N#0])`.
138                    //
139                    // This causes ICEs (#86580) when building the args for Foo in `fn foo() -> Foo { .. }` as
140                    // we instantiate the defaults with the partially built args when we build the args. Instantiating
141                    // the `N#0` on the unevaluated const indexes into the empty args we're in the process of building.
142                    //
143                    // We fix this by having this function return the parent's generics ourselves and truncating the
144                    // generics to only include non-forward declared params (with the exception of the `Self` ty)
145                    //
146                    // For the above code example that means we want `args: []`
147                    // For the following struct def we want `args: [N#0]` when generics_of is called on
148                    // the def id of the `{ N + 1 }` anon const
149                    // struct Foo<const N: usize, const M: usize = { N + 1 }>;
150                    //
151                    // This has some implications for how we get the predicates available to the anon const
152                    // see `explicit_predicates_of` for more information on this
153                    let generics = tcx.generics_of(parent_did);
154                    let param_def_idx = generics.param_def_id_to_index[&param_id.to_def_id()];
155                    // In the above example this would be .params[..N#0]
156                    let own_params = generics.params_to(param_def_idx as usize, tcx).to_owned();
157                    let param_def_id_to_index =
158                        own_params.iter().map(|param| (param.def_id, param.index)).collect();
159
160                    return ty::Generics {
161                        // we set the parent of these generics to be our parent's parent so that we
162                        // dont end up with args: [N, M, N] for the const default on a struct like this:
163                        // struct Foo<const N: usize, const M: usize = { ... }>;
164                        parent: generics.parent,
165                        parent_count: generics.parent_count,
166                        own_params,
167                        param_def_id_to_index,
168                        has_self: generics.has_self,
169                        has_late_bound_regions: generics.has_late_bound_regions,
170                    };
171                }
172                ty::AnonConstKind::GCE => Some(parent_did),
173
174                // Field defaults are allowed to use generic parameters, e.g. `field: u32 = /*defid: N + 1*/`
175                ty::AnonConstKind::NonTypeSystem
176                    if matches!(tcx.parent_hir_node(hir_id), Node::TyPat(_) | Node::Field(_)) =>
177                {
178                    Some(parent_did)
179                }
180                // Default to no generic parameters for other kinds of anon consts
181                ty::AnonConstKind::NonTypeSystem => None,
182            }
183        }
184        Node::ConstBlock(_)
185        | Node::Expr(&hir::Expr { kind: hir::ExprKind::Closure { .. }, .. }) => {
186            Some(tcx.typeck_root_def_id(def_id.to_def_id()))
187        }
188        Node::OpaqueTy(&hir::OpaqueTy {
189            origin:
190                hir::OpaqueTyOrigin::FnReturn { parent: fn_def_id, in_trait_or_impl }
191                | hir::OpaqueTyOrigin::AsyncFn { parent: fn_def_id, in_trait_or_impl },
192            ..
193        }) => {
194            if in_trait_or_impl.is_some() {
195                assert_matches!(tcx.def_kind(fn_def_id), DefKind::AssocFn);
196            } else {
197                assert_matches!(tcx.def_kind(fn_def_id), DefKind::AssocFn | DefKind::Fn);
198            }
199            Some(fn_def_id.to_def_id())
200        }
201        Node::OpaqueTy(&hir::OpaqueTy {
202            origin: hir::OpaqueTyOrigin::TyAlias { parent, in_assoc_ty },
203            ..
204        }) => {
205            if in_assoc_ty {
206                assert_matches!(tcx.def_kind(parent), DefKind::AssocTy);
207            } else {
208                assert_matches!(tcx.def_kind(parent), DefKind::TyAlias);
209            }
210            debug!("generics_of: parent of opaque ty {:?} is {:?}", def_id, parent);
211            // Opaque types are always nested within another item, and
212            // inherit the generics of the item.
213            Some(parent.to_def_id())
214        }
215        _ => None,
216    };
217
218    enum Defaults {
219        Allowed,
220        // See #36887
221        FutureCompatDisallowed,
222        Deny,
223    }
224
225    let hir_generics = node.generics().unwrap_or(hir::Generics::empty());
226    let (opt_self, allow_defaults) = match node {
227        Node::Item(item) => {
228            match item.kind {
229                ItemKind::Trait(..) | ItemKind::TraitAlias(..) => {
230                    // Add in the self type parameter.
231                    //
232                    // Something of a hack: use the node id for the trait, also as
233                    // the node id for the Self type parameter.
234                    let opt_self = Some(ty::GenericParamDef {
235                        index: 0,
236                        name: kw::SelfUpper,
237                        def_id: def_id.to_def_id(),
238                        pure_wrt_drop: false,
239                        kind: ty::GenericParamDefKind::Type {
240                            has_default: false,
241                            synthetic: false,
242                        },
243                    });
244
245                    (opt_self, Defaults::Allowed)
246                }
247                ItemKind::TyAlias(..)
248                | ItemKind::Enum(..)
249                | ItemKind::Struct(..)
250                | ItemKind::Union(..) => (None, Defaults::Allowed),
251                ItemKind::Const(..) => (None, Defaults::Deny),
252                _ => (None, Defaults::FutureCompatDisallowed),
253            }
254        }
255
256        Node::OpaqueTy(..) => (None, Defaults::Allowed),
257
258        // GATs
259        Node::TraitItem(item) if matches!(item.kind, TraitItemKind::Type(..)) => {
260            (None, Defaults::Deny)
261        }
262        Node::ImplItem(item) if matches!(item.kind, ImplItemKind::Type(..)) => {
263            (None, Defaults::Deny)
264        }
265
266        _ => (None, Defaults::FutureCompatDisallowed),
267    };
268
269    let has_self = opt_self.is_some();
270    let mut parent_has_self = false;
271    let mut own_start = has_self as u32;
272    let parent_count = parent_def_id.map_or(0, |def_id| {
273        let generics = tcx.generics_of(def_id);
274        assert!(!has_self);
275        parent_has_self = generics.has_self;
276        own_start = generics.count() as u32;
277        generics.parent_count + generics.own_params.len()
278    });
279
280    let mut own_params: Vec<_> = Vec::with_capacity(hir_generics.params.len() + has_self as usize);
281
282    if let Some(opt_self) = opt_self {
283        own_params.push(opt_self);
284    }
285
286    let early_lifetimes = super::early_bound_lifetimes_from_generics(tcx, hir_generics);
287    own_params.extend(early_lifetimes.enumerate().map(|(i, param)| ty::GenericParamDef {
288        name: param.name.ident().name,
289        index: own_start + i as u32,
290        def_id: param.def_id.to_def_id(),
291        pure_wrt_drop: param.pure_wrt_drop,
292        kind: ty::GenericParamDefKind::Lifetime,
293    }));
294
295    // Now create the real type and const parameters.
296    let type_start = own_start - has_self as u32 + own_params.len() as u32;
297    let mut i: u32 = 0;
298    let mut next_index = || {
299        let prev = i;
300        i += 1;
301        prev + type_start
302    };
303
304    const TYPE_DEFAULT_NOT_ALLOWED: &'static str = "defaults for type parameters are only allowed in \
305    `struct`, `enum`, `type`, or `trait` definitions";
306
307    own_params.extend(hir_generics.params.iter().filter_map(|param| match param.kind {
308        GenericParamKind::Lifetime { .. } => None,
309        GenericParamKind::Type { default, synthetic, .. } => {
310            if default.is_some() {
311                match allow_defaults {
312                    Defaults::Allowed => {}
313                    Defaults::FutureCompatDisallowed => {
314                        tcx.node_span_lint(
315                            lint::builtin::INVALID_TYPE_PARAM_DEFAULT,
316                            param.hir_id,
317                            param.span,
318                            |lint| {
319                                lint.primary_message(TYPE_DEFAULT_NOT_ALLOWED);
320                            },
321                        );
322                    }
323                    Defaults::Deny => {
324                        tcx.dcx().span_err(param.span, TYPE_DEFAULT_NOT_ALLOWED);
325                    }
326                }
327            }
328
329            let kind = ty::GenericParamDefKind::Type { has_default: default.is_some(), synthetic };
330
331            Some(ty::GenericParamDef {
332                index: next_index(),
333                name: param.name.ident().name,
334                def_id: param.def_id.to_def_id(),
335                pure_wrt_drop: param.pure_wrt_drop,
336                kind,
337            })
338        }
339        GenericParamKind::Const { ty: _, default, synthetic } => {
340            if !matches!(allow_defaults, Defaults::Allowed) && default.is_some() {
341                tcx.dcx().span_err(
342                    param.span,
343                    "defaults for const parameters are only allowed in \
344                    `struct`, `enum`, `type`, or `trait` definitions",
345                );
346            }
347
348            let index = next_index();
349
350            Some(ty::GenericParamDef {
351                index,
352                name: param.name.ident().name,
353                def_id: param.def_id.to_def_id(),
354                pure_wrt_drop: param.pure_wrt_drop,
355                kind: ty::GenericParamDefKind::Const { has_default: default.is_some(), synthetic },
356            })
357        }
358    }));
359
360    // provide junk type parameter defs - the only place that
361    // cares about anything but the length is instantiation,
362    // and we don't do that for closures.
363    if let Node::Expr(&hir::Expr {
364        kind: hir::ExprKind::Closure(hir::Closure { kind, .. }), ..
365    }) = node
366    {
367        // See `ClosureArgsParts`, `CoroutineArgsParts`, and `CoroutineClosureArgsParts`
368        // for info on the usage of each of these fields.
369        let dummy_args = match kind {
370            ClosureKind::Closure => &["<closure_kind>", "<closure_signature>", "<upvars>"][..],
371            ClosureKind::Coroutine(_) => &[
372                "<coroutine_kind>",
373                "<resume_ty>",
374                "<yield_ty>",
375                "<return_ty>",
376                "<witness>",
377                "<upvars>",
378            ][..],
379            ClosureKind::CoroutineClosure(_) => &[
380                "<closure_kind>",
381                "<closure_signature_parts>",
382                "<upvars>",
383                "<bound_captures_by_ref>",
384                "<witness>",
385            ][..],
386        };
387
388        own_params.extend(dummy_args.iter().map(|&arg| ty::GenericParamDef {
389            index: next_index(),
390            name: Symbol::intern(arg),
391            def_id: def_id.to_def_id(),
392            pure_wrt_drop: false,
393            kind: ty::GenericParamDefKind::Type { has_default: false, synthetic: false },
394        }));
395    }
396
397    // provide junk type parameter defs for const blocks.
398    if let Node::ConstBlock(_) = node {
399        own_params.push(ty::GenericParamDef {
400            index: next_index(),
401            name: rustc_span::sym::const_ty_placeholder,
402            def_id: def_id.to_def_id(),
403            pure_wrt_drop: false,
404            kind: ty::GenericParamDefKind::Type { has_default: false, synthetic: false },
405        });
406    }
407
408    if let Node::OpaqueTy(&hir::OpaqueTy { .. }) = node {
409        assert!(own_params.is_empty());
410
411        let lifetimes = tcx.opaque_captured_lifetimes(def_id);
412        debug!(?lifetimes);
413
414        own_params.extend(lifetimes.iter().map(|&(_, param)| ty::GenericParamDef {
415            name: tcx.item_name(param.to_def_id()),
416            index: next_index(),
417            def_id: param.to_def_id(),
418            pure_wrt_drop: false,
419            kind: ty::GenericParamDefKind::Lifetime,
420        }))
421    }
422
423    let param_def_id_to_index =
424        own_params.iter().map(|param| (param.def_id, param.index)).collect();
425
426    ty::Generics {
427        parent: parent_def_id,
428        parent_count,
429        own_params,
430        param_def_id_to_index,
431        has_self: has_self || parent_has_self,
432        has_late_bound_regions: has_late_bound_regions(tcx, node),
433    }
434}
435
436fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option<Span> {
437    struct LateBoundRegionsDetector<'tcx> {
438        tcx: TyCtxt<'tcx>,
439        outer_index: ty::DebruijnIndex,
440    }
441
442    impl<'tcx> Visitor<'tcx> for LateBoundRegionsDetector<'tcx> {
443        type Result = ControlFlow<Span>;
444        fn visit_ty(&mut self, ty: &'tcx hir::Ty<'tcx, AmbigArg>) -> ControlFlow<Span> {
445            match ty.kind {
446                hir::TyKind::BareFn(..) => {
447                    self.outer_index.shift_in(1);
448                    let res = intravisit::walk_ty(self, ty);
449                    self.outer_index.shift_out(1);
450                    res
451                }
452                hir::TyKind::UnsafeBinder(_) => {
453                    self.outer_index.shift_in(1);
454                    let res = intravisit::walk_ty(self, ty);
455                    self.outer_index.shift_out(1);
456                    res
457                }
458                _ => intravisit::walk_ty(self, ty),
459            }
460        }
461
462        fn visit_poly_trait_ref(&mut self, tr: &'tcx hir::PolyTraitRef<'tcx>) -> ControlFlow<Span> {
463            self.outer_index.shift_in(1);
464            let res = intravisit::walk_poly_trait_ref(self, tr);
465            self.outer_index.shift_out(1);
466            res
467        }
468
469        fn visit_lifetime(&mut self, lt: &'tcx hir::Lifetime) -> ControlFlow<Span> {
470            match self.tcx.named_bound_var(lt.hir_id) {
471                Some(rbv::ResolvedArg::StaticLifetime | rbv::ResolvedArg::EarlyBound(..)) => {
472                    ControlFlow::Continue(())
473                }
474                Some(rbv::ResolvedArg::LateBound(debruijn, _, _))
475                    if debruijn < self.outer_index =>
476                {
477                    ControlFlow::Continue(())
478                }
479                Some(
480                    rbv::ResolvedArg::LateBound(..)
481                    | rbv::ResolvedArg::Free(..)
482                    | rbv::ResolvedArg::Error(_),
483                )
484                | None => ControlFlow::Break(lt.ident.span),
485            }
486        }
487    }
488
489    fn has_late_bound_regions<'tcx>(
490        tcx: TyCtxt<'tcx>,
491        generics: &'tcx hir::Generics<'tcx>,
492        decl: &'tcx hir::FnDecl<'tcx>,
493    ) -> Option<Span> {
494        let mut visitor = LateBoundRegionsDetector { tcx, outer_index: ty::INNERMOST };
495        for param in generics.params {
496            if let GenericParamKind::Lifetime { .. } = param.kind {
497                if tcx.is_late_bound(param.hir_id) {
498                    return Some(param.span);
499                }
500            }
501        }
502        visitor.visit_fn_decl(decl).break_value()
503    }
504
505    let decl = node.fn_decl()?;
506    let generics = node.generics()?;
507    has_late_bound_regions(tcx, generics, decl)
508}
509
510struct AnonConstInParamTyDetector {
511    in_param_ty: bool,
512    ct: HirId,
513}
514
515impl<'v> Visitor<'v> for AnonConstInParamTyDetector {
516    type Result = ControlFlow<()>;
517
518    fn visit_generic_param(&mut self, p: &'v hir::GenericParam<'v>) -> Self::Result {
519        if let GenericParamKind::Const { ty, default: _, synthetic: _ } = p.kind {
520            let prev = self.in_param_ty;
521            self.in_param_ty = true;
522            let res = self.visit_ty_unambig(ty);
523            self.in_param_ty = prev;
524            res
525        } else {
526            ControlFlow::Continue(())
527        }
528    }
529
530    fn visit_anon_const(&mut self, c: &'v hir::AnonConst) -> Self::Result {
531        if self.in_param_ty && self.ct == c.hir_id {
532            return ControlFlow::Break(());
533        }
534        intravisit::walk_anon_const(self, c)
535    }
536}
rustc_hir_analysis/collect/generics_of.rs

rustc_hir_analysis/collect/
generics_of.rs
