1use core::intrinsics;
4use std::marker::PhantomData;
5use std::num::NonZero;
6use std::ptr::NonNull;
7
8use rustc_data_structures::intern::Interned;
9use rustc_errors::{DiagArgValue, IntoDiagArg};
10use rustc_hir::def_id::DefId;
11use rustc_macros::{HashStable, TyDecodable, TyEncodable, extension};
12use rustc_serialize::{Decodable, Encodable};
13use rustc_type_ir::WithCachedTypeInfo;
14use rustc_type_ir::walk::TypeWalker;
15use smallvec::SmallVec;
16
17use crate::ty::codec::{TyDecoder, TyEncoder};
18use crate::ty::{
19 self, ClosureArgs, CoroutineArgs, CoroutineClosureArgs, FallibleTypeFolder, InlineConstArgs,
20 Lift, List, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeVisitable, TypeVisitor, VisitorResult,
21 walk_visitable_list,
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, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
163 self.to_string().into_diag_arg(&mut None)
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!(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!(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!(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 pub fn walk(self) -> TypeWalker<TyCtxt<'tcx>> {
313 TypeWalker::new(self)
314 }
315}
316
317impl<'a, 'tcx> Lift<TyCtxt<'tcx>> for GenericArg<'a> {
318 type Lifted = GenericArg<'tcx>;
319
320 fn lift_to_interner(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
321 match self.unpack() {
322 GenericArgKind::Lifetime(lt) => tcx.lift(lt).map(|lt| lt.into()),
323 GenericArgKind::Type(ty) => tcx.lift(ty).map(|ty| ty.into()),
324 GenericArgKind::Const(ct) => tcx.lift(ct).map(|ct| ct.into()),
325 }
326 }
327}
328
329impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for GenericArg<'tcx> {
330 fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
331 self,
332 folder: &mut F,
333 ) -> Result<Self, F::Error> {
334 match self.unpack() {
335 GenericArgKind::Lifetime(lt) => lt.try_fold_with(folder).map(Into::into),
336 GenericArgKind::Type(ty) => ty.try_fold_with(folder).map(Into::into),
337 GenericArgKind::Const(ct) => ct.try_fold_with(folder).map(Into::into),
338 }
339 }
340
341 fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
342 match self.unpack() {
343 GenericArgKind::Lifetime(lt) => lt.fold_with(folder).into(),
344 GenericArgKind::Type(ty) => ty.fold_with(folder).into(),
345 GenericArgKind::Const(ct) => ct.fold_with(folder).into(),
346 }
347 }
348}
349
350impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for GenericArg<'tcx> {
351 fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
352 match self.unpack() {
353 GenericArgKind::Lifetime(lt) => lt.visit_with(visitor),
354 GenericArgKind::Type(ty) => ty.visit_with(visitor),
355 GenericArgKind::Const(ct) => ct.visit_with(visitor),
356 }
357 }
358}
359
360impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for GenericArg<'tcx> {
361 fn encode(&self, e: &mut E) {
362 self.unpack().encode(e)
363 }
364}
365
366impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for GenericArg<'tcx> {
367 fn decode(d: &mut D) -> GenericArg<'tcx> {
368 GenericArgKind::decode(d).pack()
369 }
370}
371
372pub type GenericArgs<'tcx> = List<GenericArg<'tcx>>;
374
375pub type GenericArgsRef<'tcx> = &'tcx GenericArgs<'tcx>;
376
377impl<'tcx> GenericArgs<'tcx> {
378 pub fn into_type_list(&self, tcx: TyCtxt<'tcx>) -> &'tcx List<Ty<'tcx>> {
384 tcx.mk_type_list_from_iter(self.iter().map(|arg| match arg.unpack() {
385 GenericArgKind::Type(ty) => ty,
386 _ => bug!("`into_type_list` called on generic arg with non-types"),
387 }))
388 }
389
390 pub fn as_closure(&'tcx self) -> ClosureArgs<TyCtxt<'tcx>> {
395 ClosureArgs { args: self }
396 }
397
398 pub fn as_coroutine_closure(&'tcx self) -> CoroutineClosureArgs<TyCtxt<'tcx>> {
403 CoroutineClosureArgs { args: self }
404 }
405
406 pub fn as_coroutine(&'tcx self) -> CoroutineArgs<TyCtxt<'tcx>> {
411 CoroutineArgs { args: self }
412 }
413
414 pub fn as_inline_const(&'tcx self) -> InlineConstArgs<'tcx> {
419 InlineConstArgs { args: self }
420 }
421
422 pub fn identity_for_item(tcx: TyCtxt<'tcx>, def_id: impl Into<DefId>) -> GenericArgsRef<'tcx> {
424 Self::for_item(tcx, def_id.into(), |param, _| tcx.mk_param_from_def(param))
425 }
426
427 pub fn for_item<F>(tcx: TyCtxt<'tcx>, def_id: DefId, mut mk_kind: F) -> GenericArgsRef<'tcx>
433 where
434 F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
435 {
436 let defs = tcx.generics_of(def_id);
437 let count = defs.count();
438 let mut args = SmallVec::with_capacity(count);
439 Self::fill_item(&mut args, tcx, defs, &mut mk_kind);
440 tcx.mk_args(&args)
441 }
442
443 pub fn extend_to<F>(
444 &self,
445 tcx: TyCtxt<'tcx>,
446 def_id: DefId,
447 mut mk_kind: F,
448 ) -> GenericArgsRef<'tcx>
449 where
450 F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
451 {
452 Self::for_item(tcx, def_id, |param, args| {
453 self.get(param.index as usize).cloned().unwrap_or_else(|| mk_kind(param, args))
454 })
455 }
456
457 pub fn fill_item<F>(
458 args: &mut SmallVec<[GenericArg<'tcx>; 8]>,
459 tcx: TyCtxt<'tcx>,
460 defs: &ty::Generics,
461 mk_kind: &mut F,
462 ) where
463 F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
464 {
465 if let Some(def_id) = defs.parent {
466 let parent_defs = tcx.generics_of(def_id);
467 Self::fill_item(args, tcx, parent_defs, mk_kind);
468 }
469 Self::fill_single(args, defs, mk_kind)
470 }
471
472 pub fn fill_single<F>(
473 args: &mut SmallVec<[GenericArg<'tcx>; 8]>,
474 defs: &ty::Generics,
475 mk_kind: &mut F,
476 ) where
477 F: FnMut(&ty::GenericParamDef, &[GenericArg<'tcx>]) -> GenericArg<'tcx>,
478 {
479 args.reserve(defs.own_params.len());
480 for param in &defs.own_params {
481 let kind = mk_kind(param, args);
482 assert_eq!(param.index as usize, args.len(), "{args:#?}, {defs:#?}");
483 args.push(kind);
484 }
485 }
486
487 pub fn extend_with_error(
490 tcx: TyCtxt<'tcx>,
491 def_id: DefId,
492 original_args: &[GenericArg<'tcx>],
493 ) -> GenericArgsRef<'tcx> {
494 ty::GenericArgs::for_item(tcx, def_id, |def, _| {
495 if let Some(arg) = original_args.get(def.index as usize) {
496 *arg
497 } else {
498 def.to_error(tcx)
499 }
500 })
501 }
502
503 #[inline]
504 pub fn types(&self) -> impl DoubleEndedIterator<Item = Ty<'tcx>> {
505 self.iter().filter_map(|k| k.as_type())
506 }
507
508 #[inline]
509 pub fn regions(&self) -> impl DoubleEndedIterator<Item = ty::Region<'tcx>> {
510 self.iter().filter_map(|k| k.as_region())
511 }
512
513 #[inline]
514 pub fn consts(&self) -> impl DoubleEndedIterator<Item = ty::Const<'tcx>> {
515 self.iter().filter_map(|k| k.as_const())
516 }
517
518 #[inline]
520 pub fn non_erasable_generics(&self) -> impl DoubleEndedIterator<Item = GenericArgKind<'tcx>> {
521 self.iter().filter_map(|k| match k.unpack() {
522 ty::GenericArgKind::Lifetime(_) => None,
523 generic => Some(generic),
524 })
525 }
526
527 #[inline]
528 #[track_caller]
529 pub fn type_at(&self, i: usize) -> Ty<'tcx> {
530 self[i].as_type().unwrap_or_else(|| bug!("expected type for param #{} in {:?}", i, self))
531 }
532
533 #[inline]
534 #[track_caller]
535 pub fn region_at(&self, i: usize) -> ty::Region<'tcx> {
536 self[i]
537 .as_region()
538 .unwrap_or_else(|| bug!("expected region for param #{} in {:?}", i, self))
539 }
540
541 #[inline]
542 #[track_caller]
543 pub fn const_at(&self, i: usize) -> ty::Const<'tcx> {
544 self[i].as_const().unwrap_or_else(|| bug!("expected const for param #{} in {:?}", i, self))
545 }
546
547 #[inline]
548 #[track_caller]
549 pub fn type_for_def(&self, def: &ty::GenericParamDef) -> GenericArg<'tcx> {
550 self.type_at(def.index as usize).into()
551 }
552
553 pub fn rebase_onto(
572 &self,
573 tcx: TyCtxt<'tcx>,
574 source_ancestor: DefId,
575 target_args: GenericArgsRef<'tcx>,
576 ) -> GenericArgsRef<'tcx> {
577 let defs = tcx.generics_of(source_ancestor);
578 tcx.mk_args_from_iter(target_args.iter().chain(self.iter().skip(defs.count())))
579 }
580
581 pub fn truncate_to(&self, tcx: TyCtxt<'tcx>, generics: &ty::Generics) -> GenericArgsRef<'tcx> {
582 tcx.mk_args_from_iter(self.iter().take(generics.count()))
583 }
584
585 pub fn print_as_list(&self) -> String {
586 let v = self.iter().map(|arg| arg.to_string()).collect::<Vec<_>>();
587 format!("[{}]", v.join(", "))
588 }
589}
590
591impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for GenericArgsRef<'tcx> {
592 fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
593 self,
594 folder: &mut F,
595 ) -> Result<Self, F::Error> {
596 match self.len() {
603 1 => {
604 let param0 = self[0].try_fold_with(folder)?;
605 if param0 == self[0] { Ok(self) } else { Ok(folder.cx().mk_args(&[param0])) }
606 }
607 2 => {
608 let param0 = self[0].try_fold_with(folder)?;
609 let param1 = self[1].try_fold_with(folder)?;
610 if param0 == self[0] && param1 == self[1] {
611 Ok(self)
612 } else {
613 Ok(folder.cx().mk_args(&[param0, param1]))
614 }
615 }
616 0 => Ok(self),
617 _ => ty::util::try_fold_list(self, folder, |tcx, v| tcx.mk_args(v)),
618 }
619 }
620
621 fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
622 match self.len() {
624 1 => {
625 let param0 = self[0].fold_with(folder);
626 if param0 == self[0] { self } else { folder.cx().mk_args(&[param0]) }
627 }
628 2 => {
629 let param0 = self[0].fold_with(folder);
630 let param1 = self[1].fold_with(folder);
631 if param0 == self[0] && param1 == self[1] {
632 self
633 } else {
634 folder.cx().mk_args(&[param0, param1])
635 }
636 }
637 0 => self,
638 _ => ty::util::fold_list(self, folder, |tcx, v| tcx.mk_args(v)),
639 }
640 }
641}
642
643impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<Ty<'tcx>> {
644 fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
645 self,
646 folder: &mut F,
647 ) -> Result<Self, F::Error> {
648 match self.len() {
664 2 => {
665 let param0 = self[0].try_fold_with(folder)?;
666 let param1 = self[1].try_fold_with(folder)?;
667 if param0 == self[0] && param1 == self[1] {
668 Ok(self)
669 } else {
670 Ok(folder.cx().mk_type_list(&[param0, param1]))
671 }
672 }
673 _ => ty::util::try_fold_list(self, folder, |tcx, v| tcx.mk_type_list(v)),
674 }
675 }
676
677 fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(self, folder: &mut F) -> Self {
678 match self.len() {
680 2 => {
681 let param0 = self[0].fold_with(folder);
682 let param1 = self[1].fold_with(folder);
683 if param0 == self[0] && param1 == self[1] {
684 self
685 } else {
686 folder.cx().mk_type_list(&[param0, param1])
687 }
688 }
689 _ => ty::util::fold_list(self, folder, |tcx, v| tcx.mk_type_list(v)),
690 }
691 }
692}
693
694impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeVisitable<TyCtxt<'tcx>> for &'tcx ty::List<T> {
695 #[inline]
696 fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
697 walk_visitable_list!(visitor, self.iter());
698 V::Result::output()
699 }
700}
701
702#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
705#[derive(HashStable, TypeFoldable, TypeVisitable)]
706pub struct UserArgs<'tcx> {
707 pub args: GenericArgsRef<'tcx>,
709
710 pub user_self_ty: Option<UserSelfTy<'tcx>>,
713}
714
715#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
732#[derive(HashStable, TypeFoldable, TypeVisitable)]
733pub struct UserSelfTy<'tcx> {
734 pub impl_def_id: DefId,
735 pub self_ty: Ty<'tcx>,
736}