rustc_middle/ty/
generic_args.rs

1// Generic arguments.
2
3use 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/// An entity in the Rust type system, which can be one of
28/// several kinds (types, lifetimes, and consts).
29/// To reduce memory usage, a `GenericArg` is an interned pointer,
30/// with the lowest 2 bits being reserved for a tag to
31/// indicate the type (`Ty`, `Region`, or `Const`) it points to.
32///
33/// Note: the `PartialEq`, `Eq` and `Hash` derives are only valid because `Ty`,
34/// `Region` and `Const` are all interned.
35#[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                // Ensure we can use the tag bits.
179                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                // Ensure we can use the tag bits.
184                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                // Ensure we can use the tag bits.
189                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        // SAFETY: use of `Interned::new_unchecked` here is ok because these
234        // pointers were originally created from `Interned` types in `pack()`,
235        // and this is just going in the other direction.
236        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    /// Unpack the `GenericArg` as a region when it is known certainly to be a region.
277    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    /// Unpack the `GenericArg` as a type when it is known certainly to be a type.
282    /// This is true in cases where `GenericArgs` is used in places where the kinds are known
283    /// to be limited (e.g. in tuples, where the only parameters are type parameters).
284    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    /// Unpack the `GenericArg` as a const when it is known certainly to be a const.
289    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            // FIXME: This shouldn't return numerical/float.
297            GenericArgKind::Type(ty) => ty.is_ty_or_numeric_infer(),
298            GenericArgKind::Const(ct) => ct.is_ct_infer(),
299        }
300    }
301
302    /// Iterator that walks `self` and any types reachable from
303    /// `self`, in depth-first order. Note that just walks the types
304    /// that appear in `self`, it does not descend into the fields of
305    /// structs or variants. For example:
306    ///
307    /// ```text
308    /// isize => { isize }
309    /// Foo<Bar<isize>> => { Foo<Bar<isize>>, Bar<isize>, isize }
310    /// [isize] => { [isize], isize }
311    /// ```
312    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
372/// List of generic arguments that are gonna be used to replace generic parameters.
373pub type GenericArgs<'tcx> = List<GenericArg<'tcx>>;
374
375pub type GenericArgsRef<'tcx> = &'tcx GenericArgs<'tcx>;
376
377impl<'tcx> GenericArgs<'tcx> {
378    /// Converts generic args to a type list.
379    ///
380    /// # Panics
381    ///
382    /// If any of the generic arguments are not types.
383    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    /// Interpret these generic args as the args of a closure type.
391    /// Closure args have a particular structure controlled by the
392    /// compiler that encodes information like the signature and closure kind;
393    /// see `ty::ClosureArgs` struct for more comments.
394    pub fn as_closure(&'tcx self) -> ClosureArgs<TyCtxt<'tcx>> {
395        ClosureArgs { args: self }
396    }
397
398    /// Interpret these generic args as the args of a coroutine-closure type.
399    /// Coroutine-closure args have a particular structure controlled by the
400    /// compiler that encodes information like the signature and closure kind;
401    /// see `ty::CoroutineClosureArgs` struct for more comments.
402    pub fn as_coroutine_closure(&'tcx self) -> CoroutineClosureArgs<TyCtxt<'tcx>> {
403        CoroutineClosureArgs { args: self }
404    }
405
406    /// Interpret these generic args as the args of a coroutine type.
407    /// Coroutine args have a particular structure controlled by the
408    /// compiler that encodes information like the signature and coroutine kind;
409    /// see `ty::CoroutineArgs` struct for more comments.
410    pub fn as_coroutine(&'tcx self) -> CoroutineArgs<TyCtxt<'tcx>> {
411        CoroutineArgs { args: self }
412    }
413
414    /// Interpret these generic args as the args of an inline const.
415    /// Inline const args have a particular structure controlled by the
416    /// compiler that encodes information like the inferred type;
417    /// see `ty::InlineConstArgs` struct for more comments.
418    pub fn as_inline_const(&'tcx self) -> InlineConstArgs<'tcx> {
419        InlineConstArgs { args: self }
420    }
421
422    /// Creates a [`GenericArgs`] that maps each generic parameter to itself.
423    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    /// Creates a [`GenericArgs`] for generic parameter definitions,
428    /// by calling closures to obtain each kind.
429    /// The closures get to observe the [`GenericArgs`] as they're
430    /// being built, which can be used to correctly
431    /// replace defaults of generic parameters.
432    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    // Extend an `original_args` list to the full number of args expected by `def_id`,
488    // filling in the missing parameters with error ty/ct or 'static regions.
489    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    /// Returns generic arguments that are not lifetimes.
519    #[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    /// Transform from generic args for a child of `source_ancestor`
554    /// (e.g., a trait or impl) to args for the same child
555    /// in a different item, with `target_args` as the base for
556    /// the target impl/trait, with the source child-specific
557    /// parameters (e.g., method parameters) on top of that base.
558    ///
559    /// For example given:
560    ///
561    /// ```no_run
562    /// trait X<S> { fn f<T>(); }
563    /// impl<U> X<U> for U { fn f<V>() {} }
564    /// ```
565    ///
566    /// * If `self` is `[Self, S, T]`: the identity args of `f` in the trait.
567    /// * If `source_ancestor` is the def_id of the trait.
568    /// * If `target_args` is `[U]`, the args for the impl.
569    /// * Then we will return `[U, T]`, the arg for `f` in the impl that
570    ///   are needed for it to match the trait.
571    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        // This code is hot enough that it's worth specializing for the most
597        // common length lists, to avoid the overhead of `SmallVec` creation.
598        // The match arms are in order of frequency. The 1, 2, and 0 cases are
599        // typically hit in 90--99.99% of cases. When folding doesn't change
600        // the args, it's faster to reuse the existing args rather than
601        // calling `mk_args`.
602        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        // See justification for this behavior in `try_fold_with`.
623        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        // This code is fairly hot, though not as hot as `GenericArgsRef`.
649        //
650        // When compiling stage 2, I get the following results:
651        //
652        // len |   total   |   %
653        // --- | --------- | -----
654        //  2  |  15083590 |  48.1
655        //  3  |   7540067 |  24.0
656        //  1  |   5300377 |  16.9
657        //  4  |   1351897 |   4.3
658        //  0  |   1256849 |   4.0
659        //
660        // I've tried it with some private repositories and got
661        // close to the same result, with 4 and 0 swapping places
662        // sometimes.
663        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        // See comment justifying behavior in `try_fold_with`.
679        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/// Stores the user-given args to reach some fully qualified path
703/// (e.g., `<T>::Item` or `<T as Trait>::Item`).
704#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
705#[derive(HashStable, TypeFoldable, TypeVisitable)]
706pub struct UserArgs<'tcx> {
707    /// The args for the item as given by the user.
708    pub args: GenericArgsRef<'tcx>,
709
710    /// The self type, in the case of a `<T>::Item` path (when applied
711    /// to an inherent impl). See `UserSelfTy` below.
712    pub user_self_ty: Option<UserSelfTy<'tcx>>,
713}
714
715/// Specifies the user-given self type. In the case of a path that
716/// refers to a member in an inherent impl, this self type is
717/// sometimes needed to constrain the type parameters on the impl. For
718/// example, in this code:
719///
720/// ```ignore (illustrative)
721/// struct Foo<T> { }
722/// impl<A> Foo<A> { fn method() { } }
723/// ```
724///
725/// when you then have a path like `<Foo<&'static u32>>::method`,
726/// this struct would carry the `DefId` of the impl along with the
727/// self type `Foo<u32>`. Then we can instantiate the parameters of
728/// the impl (with the args from `UserArgs`) and apply those to
729/// the self type, giving `Foo<?A>`. Finally, we unify that with
730/// the self type here, which contains `?A` to be `&'static u32`
731#[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}