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 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 Node::AnonConst(_) => {
79 let parent_did = tcx.parent(def_id.to_def_id());
80
81 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 ty::AnonConstKind::MCG => None,
109 ty::AnonConstKind::RepeatExprCount => Some(parent_did),
111
112 ty::AnonConstKind::GCE if in_param_ty => None,
119 ty::AnonConstKind::GCE
125 if let Some(param_id) =
126 tcx.hir_opt_const_param_default_param_def_id(hir_id) =>
127 {
128 let generics = tcx.generics_of(parent_did);
153 let param_def_idx = generics.param_def_id_to_index[¶m_id.to_def_id()];
154 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 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 ty::AnonConstKind::NonTypeSystem
175 if matches!(tcx.parent_hir_node(hir_id), Node::TyPat(_) | Node::Field(_)) =>
176 {
177 Some(parent_did)
178 }
179 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 Some(parent.to_def_id())
213 }
214
215 Node::Item(_) | Node::ForeignItem(_) => None,
217
218 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 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 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 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 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 if let Node::Expr(&hir::Expr {
375 kind: hir::ExprKind::Closure(hir::Closure { kind, .. }), ..
376 }) = node
377 {
378 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 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}