1use core::intrinsics;
4use std::marker::PhantomData;
5use std::mem;
6use std::num::NonZero;
7use std::ptr::NonNull;
8
9use rustc_data_structures::intern::Interned;
10use rustc_errors::{DiagArgValue, IntoDiagArg};
11use rustc_hir::def_id::DefId;
12use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable, extension};
13use rustc_serialize::{Decodable, Encodable};
14use rustc_type_ir::WithCachedTypeInfo;
15use smallvec::SmallVec;
16
17use crate::ty::codec::{TyDecoder, TyEncoder};
18use crate::ty::fold::{FallibleTypeFolder, TypeFoldable};
19use crate::ty::visit::{TypeVisitable, TypeVisitor, VisitorResult, walk_visitable_list};
20use crate::ty::{
21 self, ClosureArgs, CoroutineArgs, CoroutineClosureArgs, InlineConstArgs, Lift, List, Ty, TyCtxt,
22};
23
24pub type GenericArgKind<'tcx> = rustc_type_ir::GenericArgKind<TyCtxt<'tcx>>;
25pub type TermKind<'tcx> = rustc_type_ir::TermKind<TyCtxt<'tcx>>;
26
27#[derive(Copy, Clone, PartialEq, Eq, Hash)]
36pub struct GenericArg<'tcx> {
37 ptr: NonNull<()>,
38 marker: PhantomData<(Ty<'tcx>, ty::Region<'tcx>, ty::Const<'tcx>)>,
39}
40
41impl<'tcx> rustc_type_ir::inherent::GenericArg<TyCtxt<'tcx>> for GenericArg<'tcx> {}
42
43impl<'tcx> rustc_type_ir::inherent::GenericArgs<TyCtxt<'tcx>> for ty::GenericArgsRef<'tcx> {
44 fn rebase_onto(
45 self,
46 tcx: TyCtxt<'tcx>,
47 source_ancestor: DefId,
48 target_args: GenericArgsRef<'tcx>,
49 ) -> GenericArgsRef<'tcx> {
50 self.rebase_onto(tcx, source_ancestor, target_args)
51 }
52
53 fn type_at(self, i: usize) -> Ty<'tcx> {
54 self.type_at(i)
55 }
56
57 fn region_at(self, i: usize) -> ty::Region<'tcx> {
58 self.region_at(i)
59 }
60
61 fn const_at(self, i: usize) -> ty::Const<'tcx> {
62 self.const_at(i)
63 }
64
65 fn identity_for_item(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::GenericArgsRef<'tcx> {
66 GenericArgs::identity_for_item(tcx, def_id)
67 }
68
69 fn extend_with_error(
70 tcx: TyCtxt<'tcx>,
71 def_id: DefId,
72 original_args: &[ty::GenericArg<'tcx>],
73 ) -> ty::GenericArgsRef<'tcx> {
74 ty::GenericArgs::extend_with_error(tcx, def_id, original_args)
75 }
76
77 fn split_closure_args(self) -> ty::ClosureArgsParts<TyCtxt<'tcx>> {
78 match self[..] {
79 [ref parent_args @ .., closure_kind_ty, closure_sig_as_fn_ptr_ty, tupled_upvars_ty] => {
80 ty::ClosureArgsParts {
81 parent_args,
82 closure_kind_ty: closure_kind_ty.expect_ty(),
83 closure_sig_as_fn_ptr_ty: closure_sig_as_fn_ptr_ty.expect_ty(),
84 tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
85 }
86 }
87 _ => bug!("closure args missing synthetics"),
88 }
89 }
90
91 fn split_coroutine_closure_args(self) -> ty::CoroutineClosureArgsParts<TyCtxt<'tcx>> {
92 match self[..] {
93 [
94 ref parent_args @ ..,
95 closure_kind_ty,
96 signature_parts_ty,
97 tupled_upvars_ty,
98 coroutine_captures_by_ref_ty,
99 coroutine_witness_ty,
100 ] => ty::CoroutineClosureArgsParts {
101 parent_args,
102 closure_kind_ty: closure_kind_ty.expect_ty(),
103 signature_parts_ty: signature_parts_ty.expect_ty(),
104 tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
105 coroutine_captures_by_ref_ty: coroutine_captures_by_ref_ty.expect_ty(),
106 coroutine_witness_ty: coroutine_witness_ty.expect_ty(),
107 },
108 _ => bug!("closure args missing synthetics"),
109 }
110 }
111
112 fn split_coroutine_args(self) -> ty::CoroutineArgsParts<TyCtxt<'tcx>> {
113 match self[..] {
114 [
115 ref parent_args @ ..,
116 kind_ty,
117 resume_ty,
118 yield_ty,
119 return_ty,
120 witness,
121 tupled_upvars_ty,
122 ] => ty::CoroutineArgsParts {
123 parent_args,
124 kind_ty: kind_ty.expect_ty(),
125 resume_ty: resume_ty.expect_ty(),
126 yield_ty: yield_ty.expect_ty(),
127 return_ty: return_ty.expect_ty(),
128 witness: witness.expect_ty(),
129 tupled_upvars_ty: tupled_upvars_ty.expect_ty(),
130 },
131 _ => bug!("coroutine args missing synthetics"),
132 }
133 }
134}
135
136impl<'tcx> rustc_type_ir::inherent::IntoKind for GenericArg<'tcx> {
137 type Kind = GenericArgKind<'tcx>;
138
139 fn kind(self) -> Self::Kind {
140 self.unpack()
141 }
142}
143
144unsafe impl<'tcx> rustc_data_structures::sync::DynSend for GenericArg<'tcx> where
145 &'tcx (Ty<'tcx>, ty::Region<'tcx>, ty::Const<'tcx>): rustc_data_structures::sync::DynSend
146{
147}
148unsafe impl<'tcx> rustc_data_structures::sync::DynSync for GenericArg<'tcx> where
149 &'tcx (Ty<'tcx>, ty::Region<'tcx>, ty::Const<'tcx>): rustc_data_structures::sync::DynSync
150{
151}
152unsafe impl<'tcx> Send for GenericArg<'tcx> where
153 &'tcx (Ty<'tcx>, ty::Region<'tcx>, ty::Const<'tcx>): Send
154{
155}
156unsafe impl<'tcx> Sync for GenericArg<'tcx> where
157 &'tcx (Ty<'tcx>, ty::Region<'tcx>, ty::Const<'tcx>): Sync
158{
159}
160
161impl<'tcx> IntoDiagArg for GenericArg<'tcx> {
162 fn into_diag_arg(self) -> DiagArgValue {
163 self.to_string().into_diag_arg()
164 }
165}
166
167const TAG_MASK: usize = 0b11;
168const TYPE_TAG: usize = 0b00;
169const REGION_TAG: usize = 0b01;
170const CONST_TAG: usize = 0b10;
171
172#[extension(trait GenericArgPackExt<'tcx>)]
173impl<'tcx> GenericArgKind<'tcx> {
174 #[inline]
175 fn pack(self) -> GenericArg<'tcx> {
176 let (tag, ptr) = match self {
177 GenericArgKind::Lifetime(lt) => {
178 assert_eq!(mem::align_of_val(&*lt.0.0) & TAG_MASK, 0);
180 (REGION_TAG, NonNull::from(lt.0.0).cast())
181 }
182 GenericArgKind::Type(ty) => {
183 assert_eq!(mem::align_of_val(&*ty.0.0) & TAG_MASK, 0);
185 (TYPE_TAG, NonNull::from(ty.0.0).cast())
186 }
187 GenericArgKind::Const(ct) => {
188 assert_eq!(mem::align_of_val(&*ct.0.0) & TAG_MASK, 0);
190 (CONST_TAG, NonNull::from(ct.0.0).cast())
191 }
192 };
193
194 GenericArg { ptr: ptr.map_addr(|addr| addr | tag), marker: PhantomData }
195 }
196}
197
198impl<'tcx> From<ty::Region<'tcx>> for GenericArg<'tcx> {
199 #[inline]
200 fn from(r: ty::Region<'tcx>) -> GenericArg<'tcx> {
201 GenericArgKind::Lifetime(r).pack()
202 }
203}
204
205impl<'tcx> From<Ty<'tcx>> for GenericArg<'tcx> {
206 #[inline]
207 fn from(ty: Ty<'tcx>) -> GenericArg<'tcx> {
208 GenericArgKind::Type(ty).pack()
209 }
210}
211
212impl<'tcx> From<ty::Const<'tcx>> for GenericArg<'tcx> {
213 #[inline]
214 fn from(c: ty::Const<'tcx>) -> GenericArg<'tcx> {
215 GenericArgKind::Const(c).pack()
216 }
217}
218
219impl<'tcx> From<ty::Term<'tcx>> for GenericArg<'tcx> {
220 fn from(value: ty::Term<'tcx>) -> Self {
221 match value.unpack() {
222 ty::TermKind::Ty(t) => t.into(),
223 ty::TermKind::Const(c) => c.into(),
224 }
225 }
226}
227
228impl<'tcx> GenericArg<'tcx> {
229 #[inline]
230 pub fn unpack(self) -> GenericArgKind<'tcx> {
231 let ptr =
232 unsafe { self.ptr.map_addr(|addr| NonZero::new_unchecked(addr.get() & !TAG_MASK)) };
233 unsafe {
237 match self.ptr.addr().get() & TAG_MASK {
238 REGION_TAG => GenericArgKind::Lifetime(ty::Region(Interned::new_unchecked(
239 ptr.cast::<ty::RegionKind<'tcx>>().as_ref(),
240 ))),
241 TYPE_TAG => GenericArgKind::Type(Ty(Interned::new_unchecked(
242 ptr.cast::<WithCachedTypeInfo<ty::TyKind<'tcx>>>().as_ref(),
243 ))),
244 CONST_TAG => GenericArgKind::Const(ty::Const(Interned::new_unchecked(
245 ptr.cast::<WithCachedTypeInfo<ty::ConstKind<'tcx>>>().as_ref(),
246 ))),
247 _ => intrinsics::unreachable(),
248 }
249 }
250 }
251
252 #[inline]
253 pub fn as_type(self) -> Option<Ty<'tcx>> {
254 match self.unpack() {
255 GenericArgKind::Type(ty) => Some(ty),
256 _ => None,
257 }
258 }
259
260 #[inline]
261 pub fn as_region(self) -> Option<ty::Region<'tcx>> {
262 match self.unpack() {
263 GenericArgKind::Lifetime(re) => Some(re),
264 _ => None,
265 }
266 }
267
268 #[inline]
269 pub fn as_const(self) -> Option<ty::Const<'tcx>> {
270 match self.unpack() {
271 GenericArgKind::Const(ct) => Some(ct),
272 _ => None,
273 }
274 }
275
276 pub fn expect_region(self) -> ty::Region<'tcx> {
278 self.as_region().unwrap_or_else(|| bug!("expected a region, but found another kind"))
279 }
280
281 pub fn expect_ty(self) -> Ty<'tcx> {
285 self.as_type().unwrap_or_else(|| bug!("expected a type, but found another kind"))
286 }
287
288 pub fn expect_const(self) -> ty::Const<'tcx> {
290 self.as_const().unwrap_or_else(|| bug!("expected a const, but found another kind"))
291 }
292
293 pub fn is_non_region_infer(self) -> bool {
294 match self.unpack() {
295 GenericArgKind::Lifetime(_) => false,
296 GenericArgKind::Type(ty) => ty.is_ty_or_numeric_infer(),
298 GenericArgKind::Const(ct) => ct.is_ct_infer(),
299 }
300 }
301}
302
303impl<'a, 'tcx> Lift<TyCtxt<'tcx>> for GenericArg<'a> {
304 type Lifted = GenericArg<'tcx>;
305
306 fn lift_to_interner(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
307 match self.unpack() {
308 GenericArgKind::Lifetime(lt) => tcx.lift(lt).map(|lt| lt.into()),
309 GenericArgKind::Type(ty) => tcx.lift(ty).map(|ty| ty.into()),
310 GenericArgKind::Const(ct) => tcx.lift(ct).map(|ct| ct.into()),
311 }
312 }
313}
314
315impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for GenericArg<'tcx> {
316 fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
317 self,
318 folder: &mut F,
319 ) -> Result<Self, F::Error> {
320 match self.unpack() {
321 GenericArgKind::Lifetime(lt) => lt.try_fold_with(folder).map(Into::into),
322 GenericArgKind::Type(ty) => ty.try_fold_with(folder).map(Into::into),
323 GenericArgKind::Const(ct) => ct.try_fold_with(folder).map(Into::into),
324 }
325 }
326}
327
328impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for GenericArg<'tcx> {
329 fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
330 match self.unpack() {
331 GenericArgKind::Lifetime(lt) => lt.visit_with(visitor),
332 GenericArgKind::Type(ty) => ty.visit_with(visitor),
333 GenericArgKind::Const(ct) => ct.visit_with(visitor),
334 }
335 }
336}
337
338impl<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<E> for GenericArg<'tcx> {
339 fn encode(&self, e: &mut E) {
340 self.unpack().encode(e)
341 }
342}
343
344impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for GenericArg<'tcx> {
345 fn decode(d: &mut D) -> GenericArg<'tcx> {
346 GenericArgKind::decode(d).pack()
347 }
348}
349
350pub type GenericArgs<'tcx> = List<GenericArg<'tcx>>;
352
353pub type GenericArgsRef<'tcx> = &'tcx GenericArgs<'tcx>;
354
355impl<'tcx> GenericArgs<'tcx> {
356 pub fn into_type_list(&self, tcx: TyCtxt<'tcx>) -> &'tcx List<Ty<'tcx>> {
362 tcx.mk_type_list_from_iter(self.iter().map(|arg| match arg.unpack() {
363 GenericArgKind::Type(ty) => ty,
364 _ => bug!("`into_type_list` called on generic arg with non-types"),
365 }))
366 }
367
368 pub fn as_closure(&'tcx self) -> ClosureArgs<TyCtxt<'tcx>> {
373 ClosureArgs { args: self }
374 }
375
376 pub fn as_coroutine_closure(&'tcx self) -> CoroutineClosureArgs<TyCtxt<'tcx>> {
381 CoroutineClosureArgs { args: self }
382 }
383
384 pub fn as_coroutine(&'tcx self) -> CoroutineArgs<TyCtxt<'tcx>> {
389 CoroutineArgs { args: self }
390 }
391
392 pub fn as_inline_const(&'tcx self) -> InlineConstArgs<'tcx> {
397 InlineConstArgs { args: self }
398 }
399
400 pub fn identity_for_item(tcx: TyCtxt<'tcx>, def_id: impl Into<DefId>) -> GenericArgsRef<'tcx> {
402 Self::for_item(tcx, def_id.into(), |param, _| tcx.mk_param_from_def(param))
403 }
404
405 pub fn for_item<F>(tcx: TyCtxt<'tcx>, def_id: DefId, mut mk_kind: F) -> GenericArgsRef<'tcx>
411 where
412 F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
413 {
414 let defs = tcx.generics_of(def_id);
415 let count = defs.count();
416 let mut args = SmallVec::with_capacity(count);
417 Self::fill_item(&mut args, tcx, defs, &mut mk_kind);
418 tcx.mk_args(&args)
419 }
420
421 pub fn extend_to<F>(
422 &self,
423 tcx: TyCtxt<'tcx>,
424 def_id: DefId,
425 mut mk_kind: F,
426 ) -> GenericArgsRef<'tcx>
427 where
428 F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
429 {
430 Self::for_item(tcx, def_id, |param, args| {
431 self.get(param.index as usize).cloned().unwrap_or_else(|| mk_kind(param, args))
432 })
433 }
434
435 pub fn fill_item<F>(
436 args: &mut SmallVec<[GenericArg<'tcx>; 8]>,
437 tcx: TyCtxt<'tcx>,
438 defs: &ty::Generics,
439 mk_kind: &mut F,
440 ) where
441 F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
442 {
443 if let Some(def_id) = defs.parent {
444 let parent_defs = tcx.generics_of(def_id);
445 Self::fill_item(args, tcx, parent_defs, mk_kind);
446 }
447 Self::fill_single(args, defs, mk_kind)
448 }
449
450 pub fn fill_single<F>(
451 args: &mut SmallVec<[GenericArg<'tcx>; 8]>,
452 defs: &ty::Generics,
453 mk_kind: &mut F,
454 ) where
455 F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
456 {
457 args.reserve(defs.own_params.len());
458 for param in &defs.own_params {
459 let kind = mk_kind(param, args);
460 assert_eq!(param.index as usize, args.len(), "{args:#?}, {defs:#?}");
461 args.push(kind);
462 }
463 }
464
465 pub fn extend_with_error(
468 tcx: TyCtxt<'tcx>,
469 def_id: DefId,
470 original_args: &[GenericArg<'tcx>],
471 ) -> GenericArgsRef<'tcx> {
472 ty::GenericArgs::for_item(tcx, def_id, |def, _| {
473 if let Some(arg) = original_args.get(def.index as usize) {
474 *arg
475 } else {
476 def.to_error(tcx)
477 }
478 })
479 }
480
481 #[inline]
482 pub fn types(&self) -> impl DoubleEndedIterator<Item = Ty<'tcx>> {
483 self.iter().filter_map(|k| k.as_type())
484 }
485
486 #[inline]
487 pub fn regions(&self) -> impl DoubleEndedIterator<Item = ty::Region<'tcx>> {
488 self.iter().filter_map(|k| k.as_region())
489 }
490
491 #[inline]
492 pub fn consts(&self) -> impl DoubleEndedIterator<Item = ty::Const<'tcx>> {
493 self.iter().filter_map(|k| k.as_const())
494 }
495
496 #[inline]
498 pub fn non_erasable_generics(&self) -> impl DoubleEndedIterator<Item = GenericArgKind<'tcx>> {
499 self.iter().filter_map(|k| match k.unpack() {
500 ty::GenericArgKind::Lifetime(_) => None,
501 generic => Some(generic),
502 })
503 }
504
505 #[inline]
506 #[track_caller]
507 pub fn type_at(&self, i: usize) -> Ty<'tcx> {
508 self[i].as_type().unwrap_or_else(|| bug!("expected type for param #{} in {:?}", i, self))
509 }
510
511 #[inline]
512 #[track_caller]
513 pub fn region_at(&self, i: usize) -> ty::Region<'tcx> {
514 self[i]
515 .as_region()
516 .unwrap_or_else(|| bug!("expected region for param #{} in {:?}", i, self))
517 }
518
519 #[inline]
520 #[track_caller]
521 pub fn const_at(&self, i: usize) -> ty::Const<'tcx> {
522 self[i].as_const().unwrap_or_else(|| bug!("expected const for param #{} in {:?}", i, self))
523 }
524
525 #[inline]
526 #[track_caller]
527 pub fn type_for_def(&self, def: &ty::GenericParamDef) -> GenericArg<'tcx> {
528 self.type_at(def.index as usize).into()
529 }
530
531 pub fn rebase_onto(
550 &self,
551 tcx: TyCtxt<'tcx>,
552 source_ancestor: DefId,
553 target_args: GenericArgsRef<'tcx>,
554 ) -> GenericArgsRef<'tcx> {
555 let defs = tcx.generics_of(source_ancestor);
556 tcx.mk_args_from_iter(target_args.iter().chain(self.iter().skip(defs.count())))
557 }
558
559 pub fn truncate_to(&self, tcx: TyCtxt<'tcx>, generics: &ty::Generics) -> GenericArgsRef<'tcx> {
560 tcx.mk_args_from_iter(self.iter().take(generics.count()))
561 }
562
563 pub fn print_as_list(&self) -> String {
564 let v = self.iter().map(|arg| arg.to_string()).collect::<Vec<_>>();
565 format!("[{}]", v.join(", "))
566 }
567}
568
569impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for GenericArgsRef<'tcx> {
570 fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
571 self,
572 folder: &mut F,
573 ) -> Result<Self, F::Error> {
574 match self.len() {
581 1 => {
582 let param0 = self[0].try_fold_with(folder)?;
583 if param0 == self[0] { Ok(self) } else { Ok(folder.cx().mk_args(&[param0])) }
584 }
585 2 => {
586 let param0 = self[0].try_fold_with(folder)?;
587 let param1 = self[1].try_fold_with(folder)?;
588 if param0 == self[0] && param1 == self[1] {
589 Ok(self)
590 } else {
591 Ok(folder.cx().mk_args(&[param0, param1]))
592 }
593 }
594 0 => Ok(self),
595 _ => ty::util::fold_list(self, folder, |tcx, v| tcx.mk_args(v)),
596 }
597 }
598}
599
600impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<Ty<'tcx>> {
601 fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
602 self,
603 folder: &mut F,
604 ) -> Result<Self, F::Error> {
605 match self.len() {
621 2 => {
622 let param0 = self[0].try_fold_with(folder)?;
623 let param1 = self[1].try_fold_with(folder)?;
624 if param0 == self[0] && param1 == self[1] {
625 Ok(self)
626 } else {
627 Ok(folder.cx().mk_type_list(&[param0, param1]))
628 }
629 }
630 _ => ty::util::fold_list(self, folder, |tcx, v| tcx.mk_type_list(v)),
631 }
632 }
633}
634
635impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeVisitable<TyCtxt<'tcx>> for &'tcx ty::List<T> {
636 #[inline]
637 fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
638 walk_visitable_list!(visitor, self.iter());
639 V::Result::output()
640 }
641}
642
643#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
646#[derive(HashStable, TypeFoldable, TypeVisitable)]
647pub struct UserArgs<'tcx> {
648 pub args: GenericArgsRef<'tcx>,
650
651 pub user_self_ty: Option<UserSelfTy<'tcx>>,
654}
655
656#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
673#[derive(HashStable, TypeFoldable, TypeVisitable)]
674pub struct UserSelfTy<'tcx> {
675 pub impl_def_id: DefId,
676 pub self_ty: Ty<'tcx>,
677}