1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 // Type substitutions.
13 use hir
::def_id
::DefId
;
14 use ty
::{self, Ty, TyCtxt}
;
15 use ty
::fold
::{TypeFoldable, TypeFolder, TypeVisitor}
;
17 use serialize
::{self, Encodable, Encoder, Decodable, Decoder}
;
18 use syntax_pos
::{Span, DUMMY_SP}
;
20 use core
::nonzero
::NonZero
;
23 use std
::marker
::PhantomData
;
26 /// An entity in the Rust typesystem, which can be one of
27 /// several kinds (only types and lifetimes for now).
28 /// To reduce memory usage, a `Kind` is a interned pointer,
29 /// with the lowest 2 bits being reserved for a tag to
30 /// indicate the type (`Ty` or `Region`) it points to.
31 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
32 pub struct Kind
<'tcx
> {
34 marker
: PhantomData
<(Ty
<'tcx
>, &'tcx ty
::Region
)>
37 const TAG_MASK
: usize = 0b11;
38 const TYPE_TAG
: usize = 0b00;
39 const REGION_TAG
: usize = 0b01;
41 impl<'tcx
> From
<Ty
<'tcx
>> for Kind
<'tcx
> {
42 fn from(ty
: Ty
<'tcx
>) -> Kind
<'tcx
> {
43 // Ensure we can use the tag bits.
44 assert_eq
!(mem
::align_of_val(ty
) & TAG_MASK
, 0);
46 let ptr
= ty
as *const _
as usize;
49 NonZero
::new(ptr
| TYPE_TAG
)
56 impl<'tcx
> From
<&'tcx ty
::Region
> for Kind
<'tcx
> {
57 fn from(r
: &'tcx ty
::Region
) -> Kind
<'tcx
> {
58 // Ensure we can use the tag bits.
59 assert_eq
!(mem
::align_of_val(r
) & TAG_MASK
, 0);
61 let ptr
= r
as *const _
as usize;
64 NonZero
::new(ptr
| REGION_TAG
)
71 impl<'tcx
> Kind
<'tcx
> {
73 unsafe fn downcast
<T
>(self, tag
: usize) -> Option
<&'tcx T
> {
75 if ptr
& TAG_MASK
== tag
{
76 Some(&*((ptr
& !TAG_MASK
) as *const _
))
83 pub fn as_type(self) -> Option
<Ty
<'tcx
>> {
85 self.downcast(TYPE_TAG
)
90 pub fn as_region(self) -> Option
<&'tcx ty
::Region
> {
92 self.downcast(REGION_TAG
)
97 impl<'tcx
> fmt
::Debug
for Kind
<'tcx
> {
98 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
99 if let Some(ty
) = self.as_type() {
100 write
!(f
, "{:?}", ty
)
101 } else if let Some(r
) = self.as_region() {
104 write
!(f
, "<unknwon @ {:p}>", *self.ptr
as *const ())
109 impl<'tcx
> TypeFoldable
<'tcx
> for Kind
<'tcx
> {
110 fn super_fold_with
<'gcx
: 'tcx
, F
: TypeFolder
<'gcx
, 'tcx
>>(&self, folder
: &mut F
) -> Self {
111 if let Some(ty
) = self.as_type() {
112 Kind
::from(ty
.fold_with(folder
))
113 } else if let Some(r
) = self.as_region() {
114 Kind
::from(r
.fold_with(folder
))
120 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
121 if let Some(ty
) = self.as_type() {
122 ty
.visit_with(visitor
)
123 } else if let Some(r
) = self.as_region() {
124 r
.visit_with(visitor
)
131 impl<'tcx
> Encodable
for Kind
<'tcx
> {
132 fn encode
<E
: Encoder
>(&self, e
: &mut E
) -> Result
<(), E
::Error
> {
133 e
.emit_enum("Kind", |e
| {
134 if let Some(ty
) = self.as_type() {
135 e
.emit_enum_variant("Ty", TYPE_TAG
, 1, |e
| {
136 e
.emit_enum_variant_arg(0, |e
| ty
.encode(e
))
138 } else if let Some(r
) = self.as_region() {
139 e
.emit_enum_variant("Region", REGION_TAG
, 1, |e
| {
140 e
.emit_enum_variant_arg(0, |e
| r
.encode(e
))
149 impl<'tcx
> Decodable
for Kind
<'tcx
> {
150 fn decode
<D
: Decoder
>(d
: &mut D
) -> Result
<Kind
<'tcx
>, D
::Error
> {
151 d
.read_enum("Kind", |d
| {
152 d
.read_enum_variant(&["Ty", "Region"], |d
, tag
| {
154 TYPE_TAG
=> Ty
::decode(d
).map(Kind
::from
),
155 REGION_TAG
=> <&ty
::Region
>::decode(d
).map(Kind
::from
),
156 _
=> Err(d
.error("invalid Kind tag"))
163 /// A substitution mapping type/region parameters to new values.
164 #[derive(Clone, PartialEq, Eq, Debug, Hash, RustcEncodable, RustcDecodable)]
165 pub struct Substs
<'tcx
> {
166 params
: Vec
<Kind
<'tcx
>>
169 impl<'a
, 'gcx
, 'tcx
> Substs
<'tcx
> {
170 pub fn new
<I
>(tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>, params
: I
)
171 -> &'tcx Substs
<'tcx
>
172 where I
: IntoIterator
<Item
=Kind
<'tcx
>> {
173 tcx
.mk_substs(Substs
{
174 params
: params
.into_iter().collect()
178 pub fn maybe_new
<I
, E
>(tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>, params
: I
)
179 -> Result
<&'tcx Substs
<'tcx
>, E
>
180 where I
: IntoIterator
<Item
=Result
<Kind
<'tcx
>, E
>> {
181 Ok(tcx
.mk_substs(Substs
{
182 params
: params
.into_iter().collect
::<Result
<_
, _
>>()?
186 pub fn new_trait(tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
189 -> &'tcx Substs
<'tcx
>
191 let t
= iter
::once(s
).chain(t
.iter().cloned());
192 Substs
::new(tcx
, t
.map(Kind
::from
))
195 pub fn empty(tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>) -> &'tcx Substs
<'tcx
> {
196 Substs
::new(tcx
, vec
![])
199 /// Creates a Substs for generic parameter definitions,
200 /// by calling closures to obtain each region and type.
201 /// The closures get to observe the Substs as they're
202 /// being built, which can be used to correctly
203 /// substitute defaults of type parameters.
204 pub fn for_item
<FR
, FT
>(tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
208 -> &'tcx Substs
<'tcx
>
209 where FR
: FnMut(&ty
::RegionParameterDef
, &Substs
<'tcx
>) -> &'tcx ty
::Region
,
210 FT
: FnMut(&ty
::TypeParameterDef
<'tcx
>, &Substs
<'tcx
>) -> Ty
<'tcx
> {
211 let defs
= tcx
.lookup_generics(def_id
);
212 let mut substs
= Substs
{
213 params
: Vec
::with_capacity(defs
.count())
216 substs
.fill_item(tcx
, defs
, &mut mk_region
, &mut mk_type
);
218 tcx
.mk_substs(substs
)
221 fn fill_item
<FR
, FT
>(&mut self,
222 tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
223 defs
: &ty
::Generics
<'tcx
>,
226 where FR
: FnMut(&ty
::RegionParameterDef
, &Substs
<'tcx
>) -> &'tcx ty
::Region
,
227 FT
: FnMut(&ty
::TypeParameterDef
<'tcx
>, &Substs
<'tcx
>) -> Ty
<'tcx
> {
228 if let Some(def_id
) = defs
.parent
{
229 let parent_defs
= tcx
.lookup_generics(def_id
);
230 self.fill_item(tcx
, parent_defs
, mk_region
, mk_type
);
233 // Handle Self first, before all regions.
234 let mut types
= defs
.types
.iter();
235 if defs
.parent
.is_none() && defs
.has_self
{
236 let def
= types
.next().unwrap();
237 let ty
= mk_type(def
, self);
238 assert_eq
!(def
.index
as usize, self.params
.len());
239 self.params
.push(Kind
::from(ty
));
242 for def
in &defs
.regions
{
243 let region
= mk_region(def
, self);
244 assert_eq
!(def
.index
as usize, self.params
.len());
245 self.params
.push(Kind
::from(region
));
249 let ty
= mk_type(def
, self);
250 assert_eq
!(def
.index
as usize, self.params
.len());
251 self.params
.push(Kind
::from(ty
));
255 pub fn is_noop(&self) -> bool
{
256 self.params
.is_empty()
260 pub fn params(&self) -> &[Kind
<'tcx
>] {
265 pub fn types(&'a
self) -> impl DoubleEndedIterator
<Item
=Ty
<'tcx
>> + 'a
{
266 self.params
.iter().filter_map(|k
| k
.as_type())
270 pub fn regions(&'a
self) -> impl DoubleEndedIterator
<Item
=&'tcx ty
::Region
> + 'a
{
271 self.params
.iter().filter_map(|k
| k
.as_region())
275 pub fn type_at(&self, i
: usize) -> Ty
<'tcx
> {
276 self.params
[i
].as_type().unwrap_or_else(|| {
277 bug
!("expected type for param #{} in {:?}", i
, self.params
);
282 pub fn region_at(&self, i
: usize) -> &'tcx ty
::Region
{
283 self.params
[i
].as_region().unwrap_or_else(|| {
284 bug
!("expected region for param #{} in {:?}", i
, self.params
);
289 pub fn type_for_def(&self, ty_param_def
: &ty
::TypeParameterDef
) -> Ty
<'tcx
> {
290 self.type_at(ty_param_def
.index
as usize)
294 pub fn region_for_def(&self, def
: &ty
::RegionParameterDef
) -> &'tcx ty
::Region
{
295 self.region_at(def
.index
as usize)
298 /// Transform from substitutions for a child of `source_ancestor`
299 /// (e.g. a trait or impl) to substitutions for the same child
300 /// in a different item, with `target_substs` as the base for
301 /// the target impl/trait, with the source child-specific
302 /// parameters (e.g. method parameters) on top of that base.
303 pub fn rebase_onto(&self, tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
304 source_ancestor
: DefId
,
305 target_substs
: &Substs
<'tcx
>)
306 -> &'tcx Substs
<'tcx
> {
307 let defs
= tcx
.lookup_generics(source_ancestor
);
308 tcx
.mk_substs(Substs
{
309 params
: target_substs
.params
.iter()
310 .chain(&self.params
[defs
.own_count()..]).cloned().collect()
315 impl<'tcx
> TypeFoldable
<'tcx
> for &'tcx Substs
<'tcx
> {
316 fn super_fold_with
<'gcx
: 'tcx
, F
: TypeFolder
<'gcx
, 'tcx
>>(&self, folder
: &mut F
) -> Self {
317 let params
= self.params
.iter().map(|k
| k
.fold_with(folder
)).collect();
318 folder
.tcx().mk_substs(Substs
{
323 fn fold_with
<'gcx
: 'tcx
, F
: TypeFolder
<'gcx
, 'tcx
>>(&self, folder
: &mut F
) -> Self {
324 folder
.fold_substs(self)
327 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
328 self.params
.visit_with(visitor
)
332 impl<'tcx
> serialize
::UseSpecializedDecodable
for &'tcx Substs
<'tcx
> {}
334 ///////////////////////////////////////////////////////////////////////////
335 // Public trait `Subst`
337 // Just call `foo.subst(tcx, substs)` to perform a substitution across
338 // `foo`. Or use `foo.subst_spanned(tcx, substs, Some(span))` when
339 // there is more information available (for better errors).
341 pub trait Subst
<'tcx
> : Sized
{
342 fn subst
<'a
, 'gcx
>(&self, tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
343 substs
: &Substs
<'tcx
>) -> Self {
344 self.subst_spanned(tcx
, substs
, None
)
347 fn subst_spanned
<'a
, 'gcx
>(&self, tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
348 substs
: &Substs
<'tcx
>,
353 impl<'tcx
, T
:TypeFoldable
<'tcx
>> Subst
<'tcx
> for T
{
354 fn subst_spanned
<'a
, 'gcx
>(&self, tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
355 substs
: &Substs
<'tcx
>,
359 let mut folder
= SubstFolder
{ tcx
: tcx
,
364 region_binders_passed
: 0 };
365 (*self).fold_with(&mut folder
)
369 ///////////////////////////////////////////////////////////////////////////
370 // The actual substitution engine itself is a type folder.
372 struct SubstFolder
<'a
, 'gcx
: 'a
+'tcx
, 'tcx
: 'a
> {
373 tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
374 substs
: &'a Substs
<'tcx
>,
376 // The location for which the substitution is performed, if available.
379 // The root type that is being substituted, if available.
380 root_ty
: Option
<Ty
<'tcx
>>,
382 // Depth of type stack
383 ty_stack_depth
: usize,
385 // Number of region binders we have passed through while doing the substitution
386 region_binders_passed
: u32,
389 impl<'a
, 'gcx
, 'tcx
> TypeFolder
<'gcx
, 'tcx
> for SubstFolder
<'a
, 'gcx
, 'tcx
> {
390 fn tcx
<'b
>(&'b
self) -> TyCtxt
<'b
, 'gcx
, 'tcx
> { self.tcx }
392 fn fold_binder
<T
: TypeFoldable
<'tcx
>>(&mut self, t
: &ty
::Binder
<T
>) -> ty
::Binder
<T
> {
393 self.region_binders_passed
+= 1;
394 let t
= t
.super_fold_with(self);
395 self.region_binders_passed
-= 1;
399 fn fold_region(&mut self, r
: &'tcx ty
::Region
) -> &'tcx ty
::Region
{
400 // Note: This routine only handles regions that are bound on
401 // type declarations and other outer declarations, not those
402 // bound in *fn types*. Region substitution of the bound
403 // regions that appear in a function signature is done using
404 // the specialized routine `ty::replace_late_regions()`.
406 ty
::ReEarlyBound(data
) => {
407 let r
= self.substs
.params
.get(data
.index
as usize)
408 .and_then(|k
| k
.as_region());
411 self.shift_region_through_binders(r
)
414 let span
= self.span
.unwrap_or(DUMMY_SP
);
417 "Region parameter out of range \
418 when substituting in region {} (root type={:?}) \
430 fn fold_ty(&mut self, t
: Ty
<'tcx
>) -> Ty
<'tcx
> {
431 if !t
.needs_subst() {
435 // track the root type we were asked to substitute
436 let depth
= self.ty_stack_depth
;
438 self.root_ty
= Some(t
);
440 self.ty_stack_depth
+= 1;
442 let t1
= match t
.sty
{
444 self.ty_for_param(p
, t
)
447 t
.super_fold_with(self)
451 assert_eq
!(depth
+ 1, self.ty_stack_depth
);
452 self.ty_stack_depth
-= 1;
461 impl<'a
, 'gcx
, 'tcx
> SubstFolder
<'a
, 'gcx
, 'tcx
> {
462 fn ty_for_param(&self, p
: ty
::ParamTy
, source_ty
: Ty
<'tcx
>) -> Ty
<'tcx
> {
463 // Look up the type in the substitutions. It really should be in there.
464 let opt_ty
= self.substs
.params
.get(p
.idx
as usize)
465 .and_then(|k
| k
.as_type());
466 let ty
= match opt_ty
{
469 let span
= self.span
.unwrap_or(DUMMY_SP
);
472 "Type parameter `{:?}` ({:?}/{}) out of range \
473 when substituting (root type={:?}) substs={:?}",
482 self.shift_regions_through_binders(ty
)
485 /// It is sometimes necessary to adjust the debruijn indices during substitution. This occurs
486 /// when we are substituting a type with escaping regions into a context where we have passed
487 /// through region binders. That's quite a mouthful. Let's see an example:
490 /// type Func<A> = fn(A);
491 /// type MetaFunc = for<'a> fn(Func<&'a int>)
494 /// The type `MetaFunc`, when fully expanded, will be
496 /// for<'a> fn(fn(&'a int))
499 /// | | DebruijnIndex of 2
502 /// Here the `'a` lifetime is bound in the outer function, but appears as an argument of the
503 /// inner one. Therefore, that appearance will have a DebruijnIndex of 2, because we must skip
504 /// over the inner binder (remember that we count Debruijn indices from 1). However, in the
505 /// definition of `MetaFunc`, the binder is not visible, so the type `&'a int` will have a
506 /// debruijn index of 1. It's only during the substitution that we can see we must increase the
507 /// depth by 1 to account for the binder that we passed through.
509 /// As a second example, consider this twist:
512 /// type FuncTuple<A> = (A,fn(A));
513 /// type MetaFuncTuple = for<'a> fn(FuncTuple<&'a int>)
516 /// Here the final type will be:
518 /// for<'a> fn((&'a int, fn(&'a int)))
521 /// DebruijnIndex of 1 |
522 /// DebruijnIndex of 2
524 /// As indicated in the diagram, here the same type `&'a int` is substituted once, but in the
525 /// first case we do not increase the Debruijn index and in the second case we do. The reason
526 /// is that only in the second case have we passed through a fn binder.
527 fn shift_regions_through_binders(&self, ty
: Ty
<'tcx
>) -> Ty
<'tcx
> {
528 debug
!("shift_regions(ty={:?}, region_binders_passed={:?}, has_escaping_regions={:?})",
529 ty
, self.region_binders_passed
, ty
.has_escaping_regions());
531 if self.region_binders_passed
== 0 || !ty
.has_escaping_regions() {
535 let result
= ty
::fold
::shift_regions(self.tcx(), self.region_binders_passed
, &ty
);
536 debug
!("shift_regions: shifted result = {:?}", result
);
541 fn shift_region_through_binders(&self, region
: &'tcx ty
::Region
) -> &'tcx ty
::Region
{
542 self.tcx().mk_region(ty
::fold
::shift_region(*region
, self.region_binders_passed
))
546 // Helper methods that modify substitutions.
548 impl<'a
, 'gcx
, 'tcx
> ty
::TraitRef
<'tcx
> {
549 pub fn from_method(tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
551 substs
: &Substs
<'tcx
>)
552 -> ty
::TraitRef
<'tcx
> {
553 let defs
= tcx
.lookup_generics(trait_id
);
555 let params
= substs
.params
[..defs
.own_count()].iter().cloned();
558 substs
: Substs
::new(tcx
, params
)
563 impl<'a
, 'gcx
, 'tcx
> ty
::ExistentialTraitRef
<'tcx
> {
564 pub fn erase_self_ty(tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
565 trait_ref
: ty
::TraitRef
<'tcx
>)
566 -> ty
::ExistentialTraitRef
<'tcx
> {
567 // Assert there is a Self.
568 trait_ref
.substs
.type_at(0);
570 let params
= trait_ref
.substs
.params
[1..].iter().cloned();
571 ty
::ExistentialTraitRef
{
572 def_id
: trait_ref
.def_id
,
573 substs
: Substs
::new(tcx
, params
)
578 impl<'a
, 'gcx
, 'tcx
> ty
::PolyExistentialTraitRef
<'tcx
> {
579 /// Object types don't have a self-type specified. Therefore, when
580 /// we convert the principal trait-ref into a normal trait-ref,
581 /// you must give *some* self-type. A common choice is `mk_err()`
582 /// or some skolemized type.
583 pub fn with_self_ty(&self, tcx
: TyCtxt
<'a
, 'gcx
, 'tcx
>,
585 -> ty
::PolyTraitRef
<'tcx
> {
586 // otherwise the escaping regions would be captured by the binder
587 assert
!(!self_ty
.has_escaping_regions());
589 self.map_bound(|trait_ref
| {
590 let params
= trait_ref
.substs
.params
.iter().cloned();
591 let params
= iter
::once(Kind
::from(self_ty
)).chain(params
);
593 def_id
: trait_ref
.def_id
,
594 substs
: Substs
::new(tcx
, params
)