rustc_hir_analysis/collect/
generics_of.rs

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

rustc_hir_analysis/collect/
generics_of.rs
