1 //! This module contains `TyKind` and its major components.
3 #![allow(rustc::usage_of_ty_tykind)]
8 use crate::infer
::canonical
::Canonical
;
9 use crate::middle
::region
;
10 use crate::mir
::interpret
::ConstValue
;
11 use crate::mir
::interpret
::{LitToConstInput, Scalar}
;
12 use crate::mir
::Promoted
;
13 use crate::ty
::subst
::{GenericArg, InternalSubsts, Subst, SubstsRef}
;
15 self, AdtDef
, DefIdTree
, Discr
, Ty
, TyCtxt
, TypeFlags
, TypeFoldable
, WithConstness
,
17 use crate::ty
::{List, ParamEnv, ParamEnvAnd, TyS}
;
18 use polonius_engine
::Atom
;
19 use rustc_ast
::ast
::{self, Ident}
;
20 use rustc_data_structures
::captures
::Captures
;
21 use rustc_errors
::ErrorReported
;
23 use rustc_hir
::def_id
::{DefId, LocalDefId}
;
24 use rustc_index
::vec
::Idx
;
25 use rustc_macros
::HashStable
;
26 use rustc_span
::symbol
::{kw, Symbol}
;
27 use rustc_target
::abi
::{Size, VariantIdx}
;
28 use rustc_target
::spec
::abi
;
30 use std
::cmp
::Ordering
;
31 use std
::marker
::PhantomData
;
34 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)]
35 #[derive(HashStable, TypeFoldable, Lift)]
36 pub struct TypeAndMut
<'tcx
> {
38 pub mutbl
: hir
::Mutability
,
41 #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, RustcEncodable, RustcDecodable, Copy)]
43 /// A "free" region `fr` can be interpreted as "some region
44 /// at least as big as the scope `fr.scope`".
45 pub struct FreeRegion
{
47 pub bound_region
: BoundRegion
,
50 #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, RustcEncodable, RustcDecodable, Copy)]
52 pub enum BoundRegion
{
53 /// An anonymous region parameter for a given fn (&T)
56 /// Named region parameters for functions (a in &'a T)
58 /// The `DefId` is needed to distinguish free regions in
59 /// the event of shadowing.
60 BrNamed(DefId
, Symbol
),
62 /// Anonymous region for the implicit env pointer parameter
68 pub fn is_named(&self) -> bool
{
70 BoundRegion
::BrNamed(_
, name
) => name
!= kw
::UnderscoreLifetime
,
75 /// When canonicalizing, we replace unbound inference variables and free
76 /// regions with anonymous late bound regions. This method asserts that
77 /// we have an anonymous late bound region, which hence may refer to
78 /// a canonical variable.
79 pub fn assert_bound_var(&self) -> BoundVar
{
81 BoundRegion
::BrAnon(var
) => BoundVar
::from_u32(var
),
82 _
=> bug
!("bound region is not anonymous"),
87 /// N.B., if you change this, you'll probably want to change the corresponding
88 /// AST structure in `librustc_ast/ast.rs` as well.
89 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, Debug)]
91 #[rustc_diagnostic_item = "TyKind"]
92 pub enum TyKind
<'tcx
> {
93 /// The primitive boolean type. Written as `bool`.
96 /// The primitive character type; holds a Unicode scalar value
97 /// (a non-surrogate code point). Written as `char`.
100 /// A primitive signed integer type. For example, `i32`.
103 /// A primitive unsigned integer type. For example, `u32`.
106 /// A primitive floating-point type. For example, `f64`.
109 /// Structures, enumerations and unions.
111 /// InternalSubsts here, possibly against intuition, *may* contain `Param`s.
112 /// That is, even after substitution it is possible that there are type
113 /// variables. This happens when the `Adt` corresponds to an ADT
114 /// definition and not a concrete use of it.
115 Adt(&'tcx AdtDef
, SubstsRef
<'tcx
>),
117 /// An unsized FFI type that is opaque to Rust. Written as `extern type T`.
120 /// The pointee of a string slice. Written as `str`.
123 /// An array with the given length. Written as `[T; n]`.
124 Array(Ty
<'tcx
>, &'tcx ty
::Const
<'tcx
>),
126 /// The pointee of an array slice. Written as `[T]`.
129 /// A raw pointer. Written as `*mut T` or `*const T`
130 RawPtr(TypeAndMut
<'tcx
>),
132 /// A reference; a pointer with an associated lifetime. Written as
133 /// `&'a mut T` or `&'a T`.
134 Ref(Region
<'tcx
>, Ty
<'tcx
>, hir
::Mutability
),
136 /// The anonymous type of a function declaration/definition. Each
137 /// function has a unique type, which is output (for a function
138 /// named `foo` returning an `i32`) as `fn() -> i32 {foo}`.
140 /// For example the type of `bar` here:
143 /// fn foo() -> i32 { 1 }
144 /// let bar = foo; // bar: fn() -> i32 {foo}
146 FnDef(DefId
, SubstsRef
<'tcx
>),
148 /// A pointer to a function. Written as `fn() -> i32`.
150 /// For example the type of `bar` here:
153 /// fn foo() -> i32 { 1 }
154 /// let bar: fn() -> i32 = foo;
156 FnPtr(PolyFnSig
<'tcx
>),
158 /// A trait, defined with `trait`.
159 Dynamic(Binder
<&'tcx List
<ExistentialPredicate
<'tcx
>>>, ty
::Region
<'tcx
>),
161 /// The anonymous type of a closure. Used to represent the type of
163 Closure(DefId
, SubstsRef
<'tcx
>),
165 /// The anonymous type of a generator. Used to represent the type of
167 Generator(DefId
, SubstsRef
<'tcx
>, hir
::Movability
),
169 /// A type representin the types stored inside a generator.
170 /// This should only appear in GeneratorInteriors.
171 GeneratorWitness(Binder
<&'tcx List
<Ty
<'tcx
>>>),
173 /// The never type `!`
176 /// A tuple type. For example, `(i32, bool)`.
177 /// Use `TyS::tuple_fields` to iterate over the field types.
178 Tuple(SubstsRef
<'tcx
>),
180 /// The projection of an associated type. For example,
181 /// `<T as Trait<..>>::N`.
182 Projection(ProjectionTy
<'tcx
>),
184 /// A placeholder type used when we do not have enough information
185 /// to normalize the projection of an associated type to an
186 /// existing concrete type. Currently only used with chalk-engine.
187 UnnormalizedProjection(ProjectionTy
<'tcx
>),
189 /// Opaque (`impl Trait`) type found in a return type.
190 /// The `DefId` comes either from
191 /// * the `impl Trait` ast::Ty node,
192 /// * or the `type Foo = impl Trait` declaration
193 /// The substitutions are for the generics of the function in question.
194 /// After typeck, the concrete type can be found in the `types` map.
195 Opaque(DefId
, SubstsRef
<'tcx
>),
197 /// A type parameter; for example, `T` in `fn f<T>(x: T) {}
200 /// Bound type variable, used only when preparing a trait query.
201 Bound(ty
::DebruijnIndex
, BoundTy
),
203 /// A placeholder type - universally quantified higher-ranked type.
204 Placeholder(ty
::PlaceholderType
),
206 /// A type variable used during type checking.
209 /// A placeholder for a type which could not be computed; this is
210 /// propagated to avoid useless error messages.
214 // `TyKind` is used a lot. Make sure it doesn't unintentionally get bigger.
215 #[cfg(target_arch = "x86_64")]
216 static_assert_size
!(TyKind
<'_
>, 24);
218 /// A closure can be modeled as a struct that looks like:
220 /// struct Closure<'l0...'li, T0...Tj, CK, CS, U>(...U);
224 /// - 'l0...'li and T0...Tj are the generic parameters
225 /// in scope on the function that defined the closure,
226 /// - CK represents the *closure kind* (Fn vs FnMut vs FnOnce). This
227 /// is rather hackily encoded via a scalar type. See
228 /// `TyS::to_opt_closure_kind` for details.
229 /// - CS represents the *closure signature*, representing as a `fn()`
230 /// type. For example, `fn(u32, u32) -> u32` would mean that the closure
231 /// implements `CK<(u32, u32), Output = u32>`, where `CK` is the trait
233 /// - U is a type parameter representing the types of its upvars, tupled up
234 /// (borrowed, if appropriate; that is, if an U field represents a by-ref upvar,
235 /// and the up-var has the type `Foo`, then that field of U will be `&Foo`).
237 /// So, for example, given this function:
239 /// fn foo<'a, T>(data: &'a mut T) {
240 /// do(|| data.count += 1)
243 /// the type of the closure would be something like:
245 /// struct Closure<'a, T, U>(...U);
247 /// Note that the type of the upvar is not specified in the struct.
248 /// You may wonder how the impl would then be able to use the upvar,
249 /// if it doesn't know it's type? The answer is that the impl is
250 /// (conceptually) not fully generic over Closure but rather tied to
251 /// instances with the expected upvar types:
253 /// impl<'b, 'a, T> FnMut() for Closure<'a, T, (&'b mut &'a mut T,)> {
257 /// You can see that the *impl* fully specified the type of the upvar
258 /// and thus knows full well that `data` has type `&'b mut &'a mut T`.
259 /// (Here, I am assuming that `data` is mut-borrowed.)
261 /// Now, the last question you may ask is: Why include the upvar types
262 /// in an extra type parameter? The reason for this design is that the
263 /// upvar types can reference lifetimes that are internal to the
264 /// creating function. In my example above, for example, the lifetime
265 /// `'b` represents the scope of the closure itself; this is some
266 /// subset of `foo`, probably just the scope of the call to the to
267 /// `do()`. If we just had the lifetime/type parameters from the
268 /// enclosing function, we couldn't name this lifetime `'b`. Note that
269 /// there can also be lifetimes in the types of the upvars themselves,
270 /// if one of them happens to be a reference to something that the
271 /// creating fn owns.
273 /// OK, you say, so why not create a more minimal set of parameters
274 /// that just includes the extra lifetime parameters? The answer is
275 /// primarily that it would be hard --- we don't know at the time when
276 /// we create the closure type what the full types of the upvars are,
277 /// nor do we know which are borrowed and which are not. In this
278 /// design, we can just supply a fresh type parameter and figure that
281 /// All right, you say, but why include the type parameters from the
282 /// original function then? The answer is that codegen may need them
283 /// when monomorphizing, and they may not appear in the upvars. A
284 /// closure could capture no variables but still make use of some
285 /// in-scope type parameter with a bound (e.g., if our example above
286 /// had an extra `U: Default`, and the closure called `U::default()`).
288 /// There is another reason. This design (implicitly) prohibits
289 /// closures from capturing themselves (except via a trait
290 /// object). This simplifies closure inference considerably, since it
291 /// means that when we infer the kind of a closure or its upvars, we
292 /// don't have to handle cycles where the decisions we make for
293 /// closure C wind up influencing the decisions we ought to make for
294 /// closure C (which would then require fixed point iteration to
295 /// handle). Plus it fixes an ICE. :P
299 /// Generators are handled similarly in `GeneratorSubsts`. The set of
300 /// type parameters is similar, but `CK` and `CS` are replaced by the
301 /// following type parameters:
303 /// * `GS`: The generator's "resume type", which is the type of the
304 /// argument passed to `resume`, and the type of `yield` expressions
305 /// inside the generator.
306 /// * `GY`: The "yield type", which is the type of values passed to
307 /// `yield` inside the generator.
308 /// * `GR`: The "return type", which is the type of value returned upon
309 /// completion of the generator.
310 /// * `GW`: The "generator witness".
311 #[derive(Copy, Clone, Debug, TypeFoldable)]
312 pub struct ClosureSubsts
<'tcx
> {
313 /// Lifetime and type parameters from the enclosing function,
314 /// concatenated with a tuple containing the types of the upvars.
316 /// These are separated out because codegen wants to pass them around
317 /// when monomorphizing.
318 pub substs
: SubstsRef
<'tcx
>,
321 /// Struct returned by `split()`. Note that these are subslices of the
322 /// parent slice and not canonical substs themselves.
323 struct SplitClosureSubsts
<'tcx
> {
324 closure_kind_ty
: GenericArg
<'tcx
>,
325 closure_sig_as_fn_ptr_ty
: GenericArg
<'tcx
>,
326 tupled_upvars_ty
: GenericArg
<'tcx
>,
329 impl<'tcx
> ClosureSubsts
<'tcx
> {
330 /// Divides the closure substs into their respective
331 /// components. Single source of truth with respect to the
333 fn split(self) -> SplitClosureSubsts
<'tcx
> {
334 match self.substs
[..] {
335 [.., closure_kind_ty
, closure_sig_as_fn_ptr_ty
, tupled_upvars_ty
] => {
336 SplitClosureSubsts { closure_kind_ty, closure_sig_as_fn_ptr_ty, tupled_upvars_ty }
338 _
=> bug
!("closure substs missing synthetics"),
342 /// Returns `true` only if enough of the synthetic types are known to
343 /// allow using all of the methods on `ClosureSubsts` without panicking.
345 /// Used primarily by `ty::print::pretty` to be able to handle closure
346 /// types that haven't had their synthetic types substituted in.
347 pub fn is_valid(self) -> bool
{
348 self.substs
.len() >= 3 && matches
!(self.split().tupled_upvars_ty
.expect_ty().kind
, Tuple(_
))
352 pub fn upvar_tys(self) -> impl Iterator
<Item
= Ty
<'tcx
>> + 'tcx
{
353 self.split().tupled_upvars_ty
.expect_ty().tuple_fields()
356 /// Returns the closure kind for this closure; may return a type
357 /// variable during inference. To get the closure kind during
358 /// inference, use `infcx.closure_kind(substs)`.
359 pub fn kind_ty(self) -> Ty
<'tcx
> {
360 self.split().closure_kind_ty
.expect_ty()
363 /// Returns the `fn` pointer type representing the closure signature for this
365 // FIXME(eddyb) this should be unnecessary, as the shallowly resolved
366 // type is known at the time of the creation of `ClosureSubsts`,
367 // see `rustc_typeck::check::closure`.
368 pub fn sig_as_fn_ptr_ty(self) -> Ty
<'tcx
> {
369 self.split().closure_sig_as_fn_ptr_ty
.expect_ty()
372 /// Returns the closure kind for this closure; only usable outside
373 /// of an inference context, because in that context we know that
374 /// there are no type variables.
376 /// If you have an inference context, use `infcx.closure_kind()`.
377 pub fn kind(self) -> ty
::ClosureKind
{
378 self.kind_ty().to_opt_closure_kind().unwrap()
381 /// Extracts the signature from the closure.
382 pub fn sig(self) -> ty
::PolyFnSig
<'tcx
> {
383 let ty
= self.sig_as_fn_ptr_ty();
385 ty
::FnPtr(sig
) => sig
,
386 _
=> bug
!("closure_sig_as_fn_ptr_ty is not a fn-ptr: {:?}", ty
.kind
),
391 /// Similar to `ClosureSubsts`; see the above documentation for more.
392 #[derive(Copy, Clone, Debug, TypeFoldable)]
393 pub struct GeneratorSubsts
<'tcx
> {
394 pub substs
: SubstsRef
<'tcx
>,
397 struct SplitGeneratorSubsts
<'tcx
> {
398 resume_ty
: GenericArg
<'tcx
>,
399 yield_ty
: GenericArg
<'tcx
>,
400 return_ty
: GenericArg
<'tcx
>,
401 witness
: GenericArg
<'tcx
>,
402 tupled_upvars_ty
: GenericArg
<'tcx
>,
405 impl<'tcx
> GeneratorSubsts
<'tcx
> {
406 fn split(self) -> SplitGeneratorSubsts
<'tcx
> {
407 match self.substs
[..] {
408 [.., resume_ty
, yield_ty
, return_ty
, witness
, tupled_upvars_ty
] => {
409 SplitGeneratorSubsts { resume_ty, yield_ty, return_ty, witness, tupled_upvars_ty }
411 _
=> bug
!("generator substs missing synthetics"),
415 /// Returns `true` only if enough of the synthetic types are known to
416 /// allow using all of the methods on `GeneratorSubsts` without panicking.
418 /// Used primarily by `ty::print::pretty` to be able to handle generator
419 /// types that haven't had their synthetic types substituted in.
420 pub fn is_valid(self) -> bool
{
421 self.substs
.len() >= 5 && matches
!(self.split().tupled_upvars_ty
.expect_ty().kind
, Tuple(_
))
424 /// This describes the types that can be contained in a generator.
425 /// It will be a type variable initially and unified in the last stages of typeck of a body.
426 /// It contains a tuple of all the types that could end up on a generator frame.
427 /// The state transformation MIR pass may only produce layouts which mention types
428 /// in this tuple. Upvars are not counted here.
429 pub fn witness(self) -> Ty
<'tcx
> {
430 self.split().witness
.expect_ty()
434 pub fn upvar_tys(self) -> impl Iterator
<Item
= Ty
<'tcx
>> + 'tcx
{
435 self.split().tupled_upvars_ty
.expect_ty().tuple_fields()
438 /// Returns the type representing the resume type of the generator.
439 pub fn resume_ty(self) -> Ty
<'tcx
> {
440 self.split().resume_ty
.expect_ty()
443 /// Returns the type representing the yield type of the generator.
444 pub fn yield_ty(self) -> Ty
<'tcx
> {
445 self.split().yield_ty
.expect_ty()
448 /// Returns the type representing the return type of the generator.
449 pub fn return_ty(self) -> Ty
<'tcx
> {
450 self.split().return_ty
.expect_ty()
453 /// Returns the "generator signature", which consists of its yield
454 /// and return types.
456 /// N.B., some bits of the code prefers to see this wrapped in a
457 /// binder, but it never contains bound regions. Probably this
458 /// function should be removed.
459 pub fn poly_sig(self) -> PolyGenSig
<'tcx
> {
460 ty
::Binder
::dummy(self.sig())
463 /// Returns the "generator signature", which consists of its resume, yield
464 /// and return types.
465 pub fn sig(self) -> GenSig
<'tcx
> {
467 resume_ty
: self.resume_ty(),
468 yield_ty
: self.yield_ty(),
469 return_ty
: self.return_ty(),
474 impl<'tcx
> GeneratorSubsts
<'tcx
> {
475 /// Generator has not been resumed yet.
476 pub const UNRESUMED
: usize = 0;
477 /// Generator has returned or is completed.
478 pub const RETURNED
: usize = 1;
479 /// Generator has been poisoned.
480 pub const POISONED
: usize = 2;
482 const UNRESUMED_NAME
: &'
static str = "Unresumed";
483 const RETURNED_NAME
: &'
static str = "Returned";
484 const POISONED_NAME
: &'
static str = "Panicked";
486 /// The valid variant indices of this generator.
488 pub fn variant_range(&self, def_id
: DefId
, tcx
: TyCtxt
<'tcx
>) -> Range
<VariantIdx
> {
489 // FIXME requires optimized MIR
490 let num_variants
= tcx
.generator_layout(def_id
).variant_fields
.len();
491 VariantIdx
::new(0)..VariantIdx
::new(num_variants
)
494 /// The discriminant for the given variant. Panics if the `variant_index` is
497 pub fn discriminant_for_variant(
501 variant_index
: VariantIdx
,
503 // Generators don't support explicit discriminant values, so they are
504 // the same as the variant index.
505 assert
!(self.variant_range(def_id
, tcx
).contains(&variant_index
));
506 Discr { val: variant_index.as_usize() as u128, ty: self.discr_ty(tcx) }
509 /// The set of all discriminants for the generator, enumerated with their
512 pub fn discriminants(
516 ) -> impl Iterator
<Item
= (VariantIdx
, Discr
<'tcx
>)> + Captures
<'tcx
> {
517 self.variant_range(def_id
, tcx
).map(move |index
| {
518 (index
, Discr { val: index.as_usize() as u128, ty: self.discr_ty(tcx) }
)
522 /// Calls `f` with a reference to the name of the enumerator for the given
525 pub fn variant_name(self, v
: VariantIdx
) -> Cow
<'
static, str> {
527 Self::UNRESUMED
=> Cow
::from(Self::UNRESUMED_NAME
),
528 Self::RETURNED
=> Cow
::from(Self::RETURNED_NAME
),
529 Self::POISONED
=> Cow
::from(Self::POISONED_NAME
),
530 _
=> Cow
::from(format
!("Suspend{}", v
.as_usize() - 3)),
534 /// The type of the state discriminant used in the generator type.
536 pub fn discr_ty(&self, tcx
: TyCtxt
<'tcx
>) -> Ty
<'tcx
> {
540 /// This returns the types of the MIR locals which had to be stored across suspension points.
541 /// It is calculated in rustc_mir::transform::generator::StateTransform.
542 /// All the types here must be in the tuple in GeneratorInterior.
544 /// The locals are grouped by their variant number. Note that some locals may
545 /// be repeated in multiple variants.
551 ) -> impl Iterator
<Item
= impl Iterator
<Item
= Ty
<'tcx
>> + Captures
<'tcx
>> {
552 let layout
= tcx
.generator_layout(def_id
);
553 layout
.variant_fields
.iter().map(move |variant
| {
554 variant
.iter().map(move |field
| layout
.field_tys
[*field
].subst(tcx
, self.substs
))
558 /// This is the types of the fields of a generator which are not stored in a
561 pub fn prefix_tys(self) -> impl Iterator
<Item
= Ty
<'tcx
>> {
566 #[derive(Debug, Copy, Clone)]
567 pub enum UpvarSubsts
<'tcx
> {
568 Closure(SubstsRef
<'tcx
>),
569 Generator(SubstsRef
<'tcx
>),
572 impl<'tcx
> UpvarSubsts
<'tcx
> {
574 pub fn upvar_tys(self) -> impl Iterator
<Item
= Ty
<'tcx
>> + 'tcx
{
575 let tupled_upvars_ty
= match self {
576 UpvarSubsts
::Closure(substs
) => substs
.as_closure().split().tupled_upvars_ty
,
577 UpvarSubsts
::Generator(substs
) => substs
.as_generator().split().tupled_upvars_ty
,
579 tupled_upvars_ty
.expect_ty().tuple_fields()
583 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Hash, RustcEncodable, RustcDecodable)]
584 #[derive(HashStable, TypeFoldable)]
585 pub enum ExistentialPredicate
<'tcx
> {
586 /// E.g., `Iterator`.
587 Trait(ExistentialTraitRef
<'tcx
>),
588 /// E.g., `Iterator::Item = T`.
589 Projection(ExistentialProjection
<'tcx
>),
594 impl<'tcx
> ExistentialPredicate
<'tcx
> {
595 /// Compares via an ordering that will not change if modules are reordered or other changes are
596 /// made to the tree. In particular, this ordering is preserved across incremental compilations.
597 pub fn stable_cmp(&self, tcx
: TyCtxt
<'tcx
>, other
: &Self) -> Ordering
{
598 use self::ExistentialPredicate
::*;
599 match (*self, *other
) {
600 (Trait(_
), Trait(_
)) => Ordering
::Equal
,
601 (Projection(ref a
), Projection(ref b
)) => {
602 tcx
.def_path_hash(a
.item_def_id
).cmp(&tcx
.def_path_hash(b
.item_def_id
))
604 (AutoTrait(ref a
), AutoTrait(ref b
)) => {
605 tcx
.trait_def(*a
).def_path_hash
.cmp(&tcx
.trait_def(*b
).def_path_hash
)
607 (Trait(_
), _
) => Ordering
::Less
,
608 (Projection(_
), Trait(_
)) => Ordering
::Greater
,
609 (Projection(_
), _
) => Ordering
::Less
,
610 (AutoTrait(_
), _
) => Ordering
::Greater
,
615 impl<'tcx
> Binder
<ExistentialPredicate
<'tcx
>> {
616 pub fn with_self_ty(&self, tcx
: TyCtxt
<'tcx
>, self_ty
: Ty
<'tcx
>) -> ty
::Predicate
<'tcx
> {
617 use crate::ty
::ToPredicate
;
618 match *self.skip_binder() {
619 ExistentialPredicate
::Trait(tr
) => {
620 Binder(tr
).with_self_ty(tcx
, self_ty
).without_const().to_predicate()
622 ExistentialPredicate
::Projection(p
) => {
623 ty
::Predicate
::Projection(Binder(p
.with_self_ty(tcx
, self_ty
)))
625 ExistentialPredicate
::AutoTrait(did
) => {
627 Binder(ty
::TraitRef { def_id: did, substs: tcx.mk_substs_trait(self_ty, &[]) }
);
628 trait_ref
.without_const().to_predicate()
634 impl<'tcx
> rustc_serialize
::UseSpecializedDecodable
for &'tcx List
<ExistentialPredicate
<'tcx
>> {}
636 impl<'tcx
> List
<ExistentialPredicate
<'tcx
>> {
637 /// Returns the "principal `DefId`" of this set of existential predicates.
639 /// A Rust trait object type consists (in addition to a lifetime bound)
640 /// of a set of trait bounds, which are separated into any number
641 /// of auto-trait bounds, and at most one non-auto-trait bound. The
642 /// non-auto-trait bound is called the "principal" of the trait
645 /// Only the principal can have methods or type parameters (because
646 /// auto traits can have neither of them). This is important, because
647 /// it means the auto traits can be treated as an unordered set (methods
648 /// would force an order for the vtable, while relating traits with
649 /// type parameters without knowing the order to relate them in is
650 /// a rather non-trivial task).
652 /// For example, in the trait object `dyn fmt::Debug + Sync`, the
653 /// principal bound is `Some(fmt::Debug)`, while the auto-trait bounds
654 /// are the set `{Sync}`.
656 /// It is also possible to have a "trivial" trait object that
657 /// consists only of auto traits, with no principal - for example,
658 /// `dyn Send + Sync`. In that case, the set of auto-trait bounds
659 /// is `{Send, Sync}`, while there is no principal. These trait objects
660 /// have a "trivial" vtable consisting of just the size, alignment,
662 pub fn principal(&self) -> Option
<ExistentialTraitRef
<'tcx
>> {
664 ExistentialPredicate
::Trait(tr
) => Some(tr
),
669 pub fn principal_def_id(&self) -> Option
<DefId
> {
670 self.principal().map(|trait_ref
| trait_ref
.def_id
)
674 pub fn projection_bounds
<'a
>(
676 ) -> impl Iterator
<Item
= ExistentialProjection
<'tcx
>> + 'a
{
677 self.iter().filter_map(|predicate
| match *predicate
{
678 ExistentialPredicate
::Projection(projection
) => Some(projection
),
684 pub fn auto_traits
<'a
>(&'a
self) -> impl Iterator
<Item
= DefId
> + 'a
{
685 self.iter().filter_map(|predicate
| match *predicate
{
686 ExistentialPredicate
::AutoTrait(did
) => Some(did
),
692 impl<'tcx
> Binder
<&'tcx List
<ExistentialPredicate
<'tcx
>>> {
693 pub fn principal(&self) -> Option
<ty
::Binder
<ExistentialTraitRef
<'tcx
>>> {
694 self.skip_binder().principal().map(Binder
::bind
)
697 pub fn principal_def_id(&self) -> Option
<DefId
> {
698 self.skip_binder().principal_def_id()
702 pub fn projection_bounds
<'a
>(
704 ) -> impl Iterator
<Item
= PolyExistentialProjection
<'tcx
>> + 'a
{
705 self.skip_binder().projection_bounds().map(Binder
::bind
)
709 pub fn auto_traits
<'a
>(&'a
self) -> impl Iterator
<Item
= DefId
> + 'a
{
710 self.skip_binder().auto_traits()
715 ) -> impl DoubleEndedIterator
<Item
= Binder
<ExistentialPredicate
<'tcx
>>> + 'tcx
{
716 self.skip_binder().iter().cloned().map(Binder
::bind
)
720 /// A complete reference to a trait. These take numerous guises in syntax,
721 /// but perhaps the most recognizable form is in a where-clause:
725 /// This would be represented by a trait-reference where the `DefId` is the
726 /// `DefId` for the trait `Foo` and the substs define `T` as parameter 0,
727 /// and `U` as parameter 1.
729 /// Trait references also appear in object types like `Foo<U>`, but in
730 /// that case the `Self` parameter is absent from the substitutions.
732 /// Note that a `TraitRef` introduces a level of region binding, to
733 /// account for higher-ranked trait bounds like `T: for<'a> Foo<&'a U>`
734 /// or higher-ranked object types.
735 #[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
736 #[derive(HashStable, TypeFoldable)]
737 pub struct TraitRef
<'tcx
> {
739 pub substs
: SubstsRef
<'tcx
>,
742 impl<'tcx
> TraitRef
<'tcx
> {
743 pub fn new(def_id
: DefId
, substs
: SubstsRef
<'tcx
>) -> TraitRef
<'tcx
> {
744 TraitRef { def_id, substs }
747 /// Returns a `TraitRef` of the form `P0: Foo<P1..Pn>` where `Pi`
748 /// are the parameters defined on trait.
749 pub fn identity(tcx
: TyCtxt
<'tcx
>, def_id
: DefId
) -> TraitRef
<'tcx
> {
750 TraitRef { def_id, substs: InternalSubsts::identity_for_item(tcx, def_id) }
754 pub fn self_ty(&self) -> Ty
<'tcx
> {
755 self.substs
.type_at(0)
761 substs
: SubstsRef
<'tcx
>,
762 ) -> ty
::TraitRef
<'tcx
> {
763 let defs
= tcx
.generics_of(trait_id
);
765 ty
::TraitRef { def_id: trait_id, substs: tcx.intern_substs(&substs[..defs.params.len()]) }
769 pub type PolyTraitRef
<'tcx
> = Binder
<TraitRef
<'tcx
>>;
771 impl<'tcx
> PolyTraitRef
<'tcx
> {
772 pub fn self_ty(&self) -> Ty
<'tcx
> {
773 self.skip_binder().self_ty()
776 pub fn def_id(&self) -> DefId
{
777 self.skip_binder().def_id
780 pub fn to_poly_trait_predicate(&self) -> ty
::PolyTraitPredicate
<'tcx
> {
781 // Note that we preserve binding levels
782 Binder(ty
::TraitPredicate { trait_ref: *self.skip_binder() }
)
786 /// An existential reference to a trait, where `Self` is erased.
787 /// For example, the trait object `Trait<'a, 'b, X, Y>` is:
789 /// exists T. T: Trait<'a, 'b, X, Y>
791 /// The substitutions don't include the erased `Self`, only trait
792 /// type and lifetime parameters (`[X, Y]` and `['a, 'b]` above).
793 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
794 #[derive(HashStable, TypeFoldable)]
795 pub struct ExistentialTraitRef
<'tcx
> {
797 pub substs
: SubstsRef
<'tcx
>,
800 impl<'tcx
> ExistentialTraitRef
<'tcx
> {
801 pub fn erase_self_ty(
803 trait_ref
: ty
::TraitRef
<'tcx
>,
804 ) -> ty
::ExistentialTraitRef
<'tcx
> {
805 // Assert there is a Self.
806 trait_ref
.substs
.type_at(0);
808 ty
::ExistentialTraitRef
{
809 def_id
: trait_ref
.def_id
,
810 substs
: tcx
.intern_substs(&trait_ref
.substs
[1..]),
814 /// Object types don't have a self type specified. Therefore, when
815 /// we convert the principal trait-ref into a normal trait-ref,
816 /// you must give *some* self type. A common choice is `mk_err()`
817 /// or some placeholder type.
818 pub fn with_self_ty(&self, tcx
: TyCtxt
<'tcx
>, self_ty
: Ty
<'tcx
>) -> ty
::TraitRef
<'tcx
> {
819 // otherwise the escaping vars would be captured by the binder
820 // debug_assert!(!self_ty.has_escaping_bound_vars());
822 ty
::TraitRef { def_id: self.def_id, substs: tcx.mk_substs_trait(self_ty, self.substs) }
826 pub type PolyExistentialTraitRef
<'tcx
> = Binder
<ExistentialTraitRef
<'tcx
>>;
828 impl<'tcx
> PolyExistentialTraitRef
<'tcx
> {
829 pub fn def_id(&self) -> DefId
{
830 self.skip_binder().def_id
833 /// Object types don't have a self type specified. Therefore, when
834 /// we convert the principal trait-ref into a normal trait-ref,
835 /// you must give *some* self type. A common choice is `mk_err()`
836 /// or some placeholder type.
837 pub fn with_self_ty(&self, tcx
: TyCtxt
<'tcx
>, self_ty
: Ty
<'tcx
>) -> ty
::PolyTraitRef
<'tcx
> {
838 self.map_bound(|trait_ref
| trait_ref
.with_self_ty(tcx
, self_ty
))
842 /// Binder is a binder for higher-ranked lifetimes or types. It is part of the
843 /// compiler's representation for things like `for<'a> Fn(&'a isize)`
844 /// (which would be represented by the type `PolyTraitRef ==
845 /// Binder<TraitRef>`). Note that when we instantiate,
846 /// erase, or otherwise "discharge" these bound vars, we change the
847 /// type from `Binder<T>` to just `T` (see
848 /// e.g., `liberate_late_bound_regions`).
849 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)]
850 pub struct Binder
<T
>(T
);
853 /// Wraps `value` in a binder, asserting that `value` does not
854 /// contain any bound vars that would be bound by the
855 /// binder. This is commonly used to 'inject' a value T into a
856 /// different binding level.
857 pub fn dummy
<'tcx
>(value
: T
) -> Binder
<T
>
859 T
: TypeFoldable
<'tcx
>,
861 debug_assert
!(!value
.has_escaping_bound_vars());
865 /// Wraps `value` in a binder, binding higher-ranked vars (if any).
866 pub fn bind(value
: T
) -> Binder
<T
> {
870 /// Skips the binder and returns the "bound" value. This is a
871 /// risky thing to do because it's easy to get confused about
872 /// De Bruijn indices and the like. It is usually better to
873 /// discharge the binder using `no_bound_vars` or
874 /// `replace_late_bound_regions` or something like
875 /// that. `skip_binder` is only valid when you are either
876 /// extracting data that has nothing to do with bound vars, you
877 /// are doing some sort of test that does not involve bound
878 /// regions, or you are being very careful about your depth
881 /// Some examples where `skip_binder` is reasonable:
883 /// - extracting the `DefId` from a PolyTraitRef;
884 /// - comparing the self type of a PolyTraitRef to see if it is equal to
885 /// a type parameter `X`, since the type `X` does not reference any regions
886 pub fn skip_binder(&self) -> &T
{
890 pub fn as_ref(&self) -> Binder
<&T
> {
894 pub fn map_bound_ref
<F
, U
>(&self, f
: F
) -> Binder
<U
>
898 self.as_ref().map_bound(f
)
901 pub fn map_bound
<F
, U
>(self, f
: F
) -> Binder
<U
>
908 /// Unwraps and returns the value within, but only if it contains
909 /// no bound vars at all. (In other words, if this binder --
910 /// and indeed any enclosing binder -- doesn't bind anything at
911 /// all.) Otherwise, returns `None`.
913 /// (One could imagine having a method that just unwraps a single
914 /// binder, but permits late-bound vars bound by enclosing
915 /// binders, but that would require adjusting the debruijn
916 /// indices, and given the shallow binding structure we often use,
917 /// would not be that useful.)
918 pub fn no_bound_vars
<'tcx
>(self) -> Option
<T
>
920 T
: TypeFoldable
<'tcx
>,
922 if self.skip_binder().has_escaping_bound_vars() {
925 Some(self.skip_binder().clone())
929 /// Given two things that have the same binder level,
930 /// and an operation that wraps on their contents, executes the operation
931 /// and then wraps its result.
933 /// `f` should consider bound regions at depth 1 to be free, and
934 /// anything it produces with bound regions at depth 1 will be
935 /// bound in the resulting return value.
936 pub fn fuse
<U
, F
, R
>(self, u
: Binder
<U
>, f
: F
) -> Binder
<R
>
938 F
: FnOnce(T
, U
) -> R
,
940 Binder(f(self.0, u
.0))
943 /// Splits the contents into two things that share the same binder
944 /// level as the original, returning two distinct binders.
946 /// `f` should consider bound regions at depth 1 to be free, and
947 /// anything it produces with bound regions at depth 1 will be
948 /// bound in the resulting return values.
949 pub fn split
<U
, V
, F
>(self, f
: F
) -> (Binder
<U
>, Binder
<V
>)
951 F
: FnOnce(T
) -> (U
, V
),
953 let (u
, v
) = f(self.0);
954 (Binder(u
), Binder(v
))
958 /// Represents the projection of an associated type. In explicit UFCS
959 /// form this would be written `<T as Trait<..>>::N`.
960 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)]
961 #[derive(HashStable, TypeFoldable)]
962 pub struct ProjectionTy
<'tcx
> {
963 /// The parameters of the associated item.
964 pub substs
: SubstsRef
<'tcx
>,
966 /// The `DefId` of the `TraitItem` for the associated type `N`.
968 /// Note that this is not the `DefId` of the `TraitRef` containing this
969 /// associated type, which is in `tcx.associated_item(item_def_id).container`.
970 pub item_def_id
: DefId
,
973 impl<'tcx
> ProjectionTy
<'tcx
> {
974 /// Construct a `ProjectionTy` by searching the trait from `trait_ref` for the
975 /// associated item named `item_name`.
976 pub fn from_ref_and_name(
978 trait_ref
: ty
::TraitRef
<'tcx
>,
980 ) -> ProjectionTy
<'tcx
> {
981 let item_def_id
= tcx
982 .associated_items(trait_ref
.def_id
)
983 .find_by_name_and_kind(tcx
, item_name
, ty
::AssocKind
::Type
, trait_ref
.def_id
)
987 ProjectionTy { substs: trait_ref.substs, item_def_id }
990 /// Extracts the underlying trait reference from this projection.
991 /// For example, if this is a projection of `<T as Iterator>::Item`,
992 /// then this function would return a `T: Iterator` trait reference.
993 pub fn trait_ref(&self, tcx
: TyCtxt
<'tcx
>) -> ty
::TraitRef
<'tcx
> {
994 let def_id
= tcx
.associated_item(self.item_def_id
).container
.id();
995 ty
::TraitRef { def_id, substs: self.substs.truncate_to(tcx, tcx.generics_of(def_id)) }
998 pub fn self_ty(&self) -> Ty
<'tcx
> {
999 self.substs
.type_at(0)
1003 #[derive(Clone, Debug, TypeFoldable)]
1004 pub struct GenSig
<'tcx
> {
1005 pub resume_ty
: Ty
<'tcx
>,
1006 pub yield_ty
: Ty
<'tcx
>,
1007 pub return_ty
: Ty
<'tcx
>,
1010 pub type PolyGenSig
<'tcx
> = Binder
<GenSig
<'tcx
>>;
1012 impl<'tcx
> PolyGenSig
<'tcx
> {
1013 pub fn resume_ty(&self) -> ty
::Binder
<Ty
<'tcx
>> {
1014 self.map_bound_ref(|sig
| sig
.resume_ty
)
1016 pub fn yield_ty(&self) -> ty
::Binder
<Ty
<'tcx
>> {
1017 self.map_bound_ref(|sig
| sig
.yield_ty
)
1019 pub fn return_ty(&self) -> ty
::Binder
<Ty
<'tcx
>> {
1020 self.map_bound_ref(|sig
| sig
.return_ty
)
1024 /// Signature of a function type, which we have arbitrarily
1025 /// decided to use to refer to the input/output types.
1027 /// - `inputs`: is the list of arguments and their modes.
1028 /// - `output`: is the return type.
1029 /// - `c_variadic`: indicates whether this is a C-variadic function.
1030 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
1031 #[derive(HashStable, TypeFoldable)]
1032 pub struct FnSig
<'tcx
> {
1033 pub inputs_and_output
: &'tcx List
<Ty
<'tcx
>>,
1034 pub c_variadic
: bool
,
1035 pub unsafety
: hir
::Unsafety
,
1039 impl<'tcx
> FnSig
<'tcx
> {
1040 pub fn inputs(&self) -> &'tcx
[Ty
<'tcx
>] {
1041 &self.inputs_and_output
[..self.inputs_and_output
.len() - 1]
1044 pub fn output(&self) -> Ty
<'tcx
> {
1045 self.inputs_and_output
[self.inputs_and_output
.len() - 1]
1048 // Creates a minimal `FnSig` to be used when encountering a `TyKind::Error` in a fallible
1050 fn fake() -> FnSig
<'tcx
> {
1052 inputs_and_output
: List
::empty(),
1054 unsafety
: hir
::Unsafety
::Normal
,
1055 abi
: abi
::Abi
::Rust
,
1060 pub type PolyFnSig
<'tcx
> = Binder
<FnSig
<'tcx
>>;
1062 impl<'tcx
> PolyFnSig
<'tcx
> {
1064 pub fn inputs(&self) -> Binder
<&'tcx
[Ty
<'tcx
>]> {
1065 self.map_bound_ref(|fn_sig
| fn_sig
.inputs())
1068 pub fn input(&self, index
: usize) -> ty
::Binder
<Ty
<'tcx
>> {
1069 self.map_bound_ref(|fn_sig
| fn_sig
.inputs()[index
])
1071 pub fn inputs_and_output(&self) -> ty
::Binder
<&'tcx List
<Ty
<'tcx
>>> {
1072 self.map_bound_ref(|fn_sig
| fn_sig
.inputs_and_output
)
1075 pub fn output(&self) -> ty
::Binder
<Ty
<'tcx
>> {
1076 self.map_bound_ref(|fn_sig
| fn_sig
.output())
1078 pub fn c_variadic(&self) -> bool
{
1079 self.skip_binder().c_variadic
1081 pub fn unsafety(&self) -> hir
::Unsafety
{
1082 self.skip_binder().unsafety
1084 pub fn abi(&self) -> abi
::Abi
{
1085 self.skip_binder().abi
1089 pub type CanonicalPolyFnSig
<'tcx
> = Canonical
<'tcx
, Binder
<FnSig
<'tcx
>>>;
1091 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
1092 #[derive(HashStable)]
1093 pub struct ParamTy
{
1098 impl<'tcx
> ParamTy
{
1099 pub fn new(index
: u32, name
: Symbol
) -> ParamTy
{
1100 ParamTy { index, name }
1103 pub fn for_self() -> ParamTy
{
1104 ParamTy
::new(0, kw
::SelfUpper
)
1107 pub fn for_def(def
: &ty
::GenericParamDef
) -> ParamTy
{
1108 ParamTy
::new(def
.index
, def
.name
)
1111 pub fn to_ty(self, tcx
: TyCtxt
<'tcx
>) -> Ty
<'tcx
> {
1112 tcx
.mk_ty_param(self.index
, self.name
)
1116 #[derive(Copy, Clone, Hash, RustcEncodable, RustcDecodable, Eq, PartialEq, Ord, PartialOrd)]
1117 #[derive(HashStable)]
1118 pub struct ParamConst
{
1123 impl<'tcx
> ParamConst
{
1124 pub fn new(index
: u32, name
: Symbol
) -> ParamConst
{
1125 ParamConst { index, name }
1128 pub fn for_def(def
: &ty
::GenericParamDef
) -> ParamConst
{
1129 ParamConst
::new(def
.index
, def
.name
)
1132 pub fn to_const(self, tcx
: TyCtxt
<'tcx
>, ty
: Ty
<'tcx
>) -> &'tcx Const
<'tcx
> {
1133 tcx
.mk_const_param(self.index
, self.name
, ty
)
1137 rustc_index
::newtype_index
! {
1138 /// A [De Bruijn index][dbi] is a standard means of representing
1139 /// regions (and perhaps later types) in a higher-ranked setting. In
1140 /// particular, imagine a type like this:
1142 /// for<'a> fn(for<'b> fn(&'b isize, &'a isize), &'a char)
1145 /// | +------------+ 0 | |
1147 /// +--------------------------------+ 1 |
1149 /// +------------------------------------------+ 0
1151 /// In this type, there are two binders (the outer fn and the inner
1152 /// fn). We need to be able to determine, for any given region, which
1153 /// fn type it is bound by, the inner or the outer one. There are
1154 /// various ways you can do this, but a De Bruijn index is one of the
1155 /// more convenient and has some nice properties. The basic idea is to
1156 /// count the number of binders, inside out. Some examples should help
1157 /// clarify what I mean.
1159 /// Let's start with the reference type `&'b isize` that is the first
1160 /// argument to the inner function. This region `'b` is assigned a De
1161 /// Bruijn index of 0, meaning "the innermost binder" (in this case, a
1162 /// fn). The region `'a` that appears in the second argument type (`&'a
1163 /// isize`) would then be assigned a De Bruijn index of 1, meaning "the
1164 /// second-innermost binder". (These indices are written on the arrays
1165 /// in the diagram).
1167 /// What is interesting is that De Bruijn index attached to a particular
1168 /// variable will vary depending on where it appears. For example,
1169 /// the final type `&'a char` also refers to the region `'a` declared on
1170 /// the outermost fn. But this time, this reference is not nested within
1171 /// any other binders (i.e., it is not an argument to the inner fn, but
1172 /// rather the outer one). Therefore, in this case, it is assigned a
1173 /// De Bruijn index of 0, because the innermost binder in that location
1174 /// is the outer fn.
1176 /// [dbi]: http://en.wikipedia.org/wiki/De_Bruijn_index
1177 #[derive(HashStable)]
1178 pub struct DebruijnIndex
{
1179 DEBUG_FORMAT
= "DebruijnIndex({})",
1180 const INNERMOST
= 0,
1184 pub type Region
<'tcx
> = &'tcx RegionKind
;
1186 /// Representation of (lexical) regions. Note that the NLL checker
1187 /// uses a distinct representation of regions. For this reason, it
1188 /// internally replaces all the regions with inference variables --
1189 /// the index of the variable is then used to index into internal NLL
1190 /// data structures. See `rustc_mir::borrow_check` module for more
1193 /// ## The Region lattice within a given function
1195 /// In general, the (lexical, and hence deprecated) region lattice
1199 /// static ----------+-----...------+ (greatest)
1201 /// early-bound and | |
1202 /// free regions | |
1204 /// scope regions | |
1206 /// empty(root) placeholder(U1) |
1208 /// | / placeholder(Un)
1213 /// empty(Un) -------- (smallest)
1216 /// Early-bound/free regions are the named lifetimes in scope from the
1217 /// function declaration. They have relationships to one another
1218 /// determined based on the declared relationships from the
1219 /// function. They all collectively outlive the scope regions. (See
1220 /// `RegionRelations` type, and particularly
1221 /// `crate::infer::outlives::free_region_map::FreeRegionMap`.)
1223 /// The scope regions are related to one another based on the AST
1224 /// structure. (See `RegionRelations` type, and particularly the
1225 /// `rustc_middle::middle::region::ScopeTree`.)
1227 /// Note that inference variables and bound regions are not included
1228 /// in this diagram. In the case of inference variables, they should
1229 /// be inferred to some other region from the diagram. In the case of
1230 /// bound regions, they are excluded because they don't make sense to
1231 /// include -- the diagram indicates the relationship between free
1234 /// ## Inference variables
1236 /// During region inference, we sometimes create inference variables,
1237 /// represented as `ReVar`. These will be inferred by the code in
1238 /// `infer::lexical_region_resolve` to some free region from the
1239 /// lattice above (the minimal region that meets the
1242 /// During NLL checking, where regions are defined differently, we
1243 /// also use `ReVar` -- in that case, the index is used to index into
1244 /// the NLL region checker's data structures. The variable may in fact
1245 /// represent either a free region or an inference variable, in that
1248 /// ## Bound Regions
1250 /// These are regions that are stored behind a binder and must be substituted
1251 /// with some concrete region before being used. There are two kind of
1252 /// bound regions: early-bound, which are bound in an item's `Generics`,
1253 /// and are substituted by a `InternalSubsts`, and late-bound, which are part of
1254 /// higher-ranked types (e.g., `for<'a> fn(&'a ())`), and are substituted by
1255 /// the likes of `liberate_late_bound_regions`. The distinction exists
1256 /// because higher-ranked lifetimes aren't supported in all places. See [1][2].
1258 /// Unlike `Param`s, bound regions are not supposed to exist "in the wild"
1259 /// outside their binder, e.g., in types passed to type inference, and
1260 /// should first be substituted (by placeholder regions, free regions,
1261 /// or region variables).
1263 /// ## Placeholder and Free Regions
1265 /// One often wants to work with bound regions without knowing their precise
1266 /// identity. For example, when checking a function, the lifetime of a borrow
1267 /// can end up being assigned to some region parameter. In these cases,
1268 /// it must be ensured that bounds on the region can't be accidentally
1269 /// assumed without being checked.
1271 /// To do this, we replace the bound regions with placeholder markers,
1272 /// which don't satisfy any relation not explicitly provided.
1274 /// There are two kinds of placeholder regions in rustc: `ReFree` and
1275 /// `RePlaceholder`. When checking an item's body, `ReFree` is supposed
1276 /// to be used. These also support explicit bounds: both the internally-stored
1277 /// *scope*, which the region is assumed to outlive, as well as other
1278 /// relations stored in the `FreeRegionMap`. Note that these relations
1279 /// aren't checked when you `make_subregion` (or `eq_types`), only by
1280 /// `resolve_regions_and_report_errors`.
1282 /// When working with higher-ranked types, some region relations aren't
1283 /// yet known, so you can't just call `resolve_regions_and_report_errors`.
1284 /// `RePlaceholder` is designed for this purpose. In these contexts,
1285 /// there's also the risk that some inference variable laying around will
1286 /// get unified with your placeholder region: if you want to check whether
1287 /// `for<'a> Foo<'_>: 'a`, and you substitute your bound region `'a`
1288 /// with a placeholder region `'%a`, the variable `'_` would just be
1289 /// instantiated to the placeholder region `'%a`, which is wrong because
1290 /// the inference variable is supposed to satisfy the relation
1291 /// *for every value of the placeholder region*. To ensure that doesn't
1292 /// happen, you can use `leak_check`. This is more clearly explained
1293 /// by the [rustc dev guide].
1295 /// [1]: http://smallcultfollowing.com/babysteps/blog/2013/10/29/intermingled-parameter-lists/
1296 /// [2]: http://smallcultfollowing.com/babysteps/blog/2013/11/04/intermingled-parameter-lists/
1297 /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/hrtb.html
1298 #[derive(Clone, PartialEq, Eq, Hash, Copy, RustcEncodable, RustcDecodable, PartialOrd, Ord)]
1299 pub enum RegionKind
{
1300 /// Region bound in a type or fn declaration which will be
1301 /// substituted 'early' -- that is, at the same time when type
1302 /// parameters are substituted.
1303 ReEarlyBound(EarlyBoundRegion
),
1305 /// Region bound in a function scope, which will be substituted when the
1306 /// function is called.
1307 ReLateBound(DebruijnIndex
, BoundRegion
),
1309 /// When checking a function body, the types of all arguments and so forth
1310 /// that refer to bound region parameters are modified to refer to free
1311 /// region parameters.
1314 /// A concrete region naming some statically determined scope
1315 /// (e.g., an expression or sequence of statements) within the
1316 /// current function.
1317 ReScope(region
::Scope
),
1319 /// Static data that has an "infinite" lifetime. Top in the region lattice.
1322 /// A region variable. Should not exist after typeck.
1325 /// A placeholder region -- basically, the higher-ranked version of `ReFree`.
1326 /// Should not exist after typeck.
1327 RePlaceholder(ty
::PlaceholderRegion
),
1329 /// Empty lifetime is for data that is never accessed. We tag the
1330 /// empty lifetime with a universe -- the idea is that we don't
1331 /// want `exists<'a> { forall<'b> { 'b: 'a } }` to be satisfiable.
1332 /// Therefore, the `'empty` in a universe `U` is less than all
1333 /// regions visible from `U`, but not less than regions not visible
1335 ReEmpty(ty
::UniverseIndex
),
1337 /// Erased region, used by trait selection, in MIR and during codegen.
1341 impl<'tcx
> rustc_serialize
::UseSpecializedDecodable
for Region
<'tcx
> {}
1343 #[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug, PartialOrd, Ord)]
1344 pub struct EarlyBoundRegion
{
1350 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
1355 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
1356 pub struct ConstVid
<'tcx
> {
1358 pub phantom
: PhantomData
<&'
tcx ()>,
1361 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
1366 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
1367 pub struct FloatVid
{
1371 rustc_index
::newtype_index
! {
1372 pub struct RegionVid
{
1373 DEBUG_FORMAT
= custom
,
1377 impl Atom
for RegionVid
{
1378 fn index(self) -> usize {
1383 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
1384 #[derive(HashStable)]
1390 /// A `FreshTy` is one that is generated as a replacement for an
1391 /// unbound type variable. This is convenient for caching etc. See
1392 /// `infer::freshen` for more details.
1398 rustc_index
::newtype_index
! {
1399 pub struct BoundVar { .. }
1402 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)]
1403 #[derive(HashStable)]
1404 pub struct BoundTy
{
1406 pub kind
: BoundTyKind
,
1409 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)]
1410 #[derive(HashStable)]
1411 pub enum BoundTyKind
{
1416 impl From
<BoundVar
> for BoundTy
{
1417 fn from(var
: BoundVar
) -> Self {
1418 BoundTy { var, kind: BoundTyKind::Anon }
1422 /// A `ProjectionPredicate` for an `ExistentialTraitRef`.
1423 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)]
1424 #[derive(HashStable, TypeFoldable)]
1425 pub struct ExistentialProjection
<'tcx
> {
1426 pub item_def_id
: DefId
,
1427 pub substs
: SubstsRef
<'tcx
>,
1431 pub type PolyExistentialProjection
<'tcx
> = Binder
<ExistentialProjection
<'tcx
>>;
1433 impl<'tcx
> ExistentialProjection
<'tcx
> {
1434 /// Extracts the underlying existential trait reference from this projection.
1435 /// For example, if this is a projection of `exists T. <T as Iterator>::Item == X`,
1436 /// then this function would return a `exists T. T: Iterator` existential trait
1438 pub fn trait_ref(&self, tcx
: TyCtxt
<'_
>) -> ty
::ExistentialTraitRef
<'tcx
> {
1439 let def_id
= tcx
.associated_item(self.item_def_id
).container
.id();
1440 ty
::ExistentialTraitRef { def_id, substs: self.substs }
1443 pub fn with_self_ty(
1447 ) -> ty
::ProjectionPredicate
<'tcx
> {
1448 // otherwise the escaping regions would be captured by the binders
1449 debug_assert
!(!self_ty
.has_escaping_bound_vars());
1451 ty
::ProjectionPredicate
{
1452 projection_ty
: ty
::ProjectionTy
{
1453 item_def_id
: self.item_def_id
,
1454 substs
: tcx
.mk_substs_trait(self_ty
, self.substs
),
1461 impl<'tcx
> PolyExistentialProjection
<'tcx
> {
1462 pub fn with_self_ty(
1466 ) -> ty
::PolyProjectionPredicate
<'tcx
> {
1467 self.map_bound(|p
| p
.with_self_ty(tcx
, self_ty
))
1470 pub fn item_def_id(&self) -> DefId
{
1471 self.skip_binder().item_def_id
1475 impl DebruijnIndex
{
1476 /// Returns the resulting index when this value is moved into
1477 /// `amount` number of new binders. So, e.g., if you had
1479 /// for<'a> fn(&'a x)
1481 /// and you wanted to change it to
1483 /// for<'a> fn(for<'b> fn(&'a x))
1485 /// you would need to shift the index for `'a` into a new binder.
1487 pub fn shifted_in(self, amount
: u32) -> DebruijnIndex
{
1488 DebruijnIndex
::from_u32(self.as_u32() + amount
)
1491 /// Update this index in place by shifting it "in" through
1492 /// `amount` number of binders.
1493 pub fn shift_in(&mut self, amount
: u32) {
1494 *self = self.shifted_in(amount
);
1497 /// Returns the resulting index when this value is moved out from
1498 /// `amount` number of new binders.
1500 pub fn shifted_out(self, amount
: u32) -> DebruijnIndex
{
1501 DebruijnIndex
::from_u32(self.as_u32() - amount
)
1504 /// Update in place by shifting out from `amount` binders.
1505 pub fn shift_out(&mut self, amount
: u32) {
1506 *self = self.shifted_out(amount
);
1509 /// Adjusts any De Bruijn indices so as to make `to_binder` the
1510 /// innermost binder. That is, if we have something bound at `to_binder`,
1511 /// it will now be bound at INNERMOST. This is an appropriate thing to do
1512 /// when moving a region out from inside binders:
1515 /// for<'a> fn(for<'b> for<'c> fn(&'a u32), _)
1516 /// // Binder: D3 D2 D1 ^^
1519 /// Here, the region `'a` would have the De Bruijn index D3,
1520 /// because it is the bound 3 binders out. However, if we wanted
1521 /// to refer to that region `'a` in the second argument (the `_`),
1522 /// those two binders would not be in scope. In that case, we
1523 /// might invoke `shift_out_to_binder(D3)`. This would adjust the
1524 /// De Bruijn index of `'a` to D1 (the innermost binder).
1526 /// If we invoke `shift_out_to_binder` and the region is in fact
1527 /// bound by one of the binders we are shifting out of, that is an
1528 /// error (and should fail an assertion failure).
1529 pub fn shifted_out_to_binder(self, to_binder
: DebruijnIndex
) -> Self {
1530 self.shifted_out(to_binder
.as_u32() - INNERMOST
.as_u32())
1534 /// Region utilities
1536 /// Is this region named by the user?
1537 pub fn has_name(&self) -> bool
{
1539 RegionKind
::ReEarlyBound(ebr
) => ebr
.has_name(),
1540 RegionKind
::ReLateBound(_
, br
) => br
.is_named(),
1541 RegionKind
::ReFree(fr
) => fr
.bound_region
.is_named(),
1542 RegionKind
::ReScope(..) => false,
1543 RegionKind
::ReStatic
=> true,
1544 RegionKind
::ReVar(..) => false,
1545 RegionKind
::RePlaceholder(placeholder
) => placeholder
.name
.is_named(),
1546 RegionKind
::ReEmpty(_
) => false,
1547 RegionKind
::ReErased
=> false,
1551 pub fn is_late_bound(&self) -> bool
{
1553 ty
::ReLateBound(..) => true,
1558 pub fn is_placeholder(&self) -> bool
{
1560 ty
::RePlaceholder(..) => true,
1565 pub fn bound_at_or_above_binder(&self, index
: DebruijnIndex
) -> bool
{
1567 ty
::ReLateBound(debruijn
, _
) => debruijn
>= index
,
1572 /// Adjusts any De Bruijn indices so as to make `to_binder` the
1573 /// innermost binder. That is, if we have something bound at `to_binder`,
1574 /// it will now be bound at INNERMOST. This is an appropriate thing to do
1575 /// when moving a region out from inside binders:
1578 /// for<'a> fn(for<'b> for<'c> fn(&'a u32), _)
1579 /// // Binder: D3 D2 D1 ^^
1582 /// Here, the region `'a` would have the De Bruijn index D3,
1583 /// because it is the bound 3 binders out. However, if we wanted
1584 /// to refer to that region `'a` in the second argument (the `_`),
1585 /// those two binders would not be in scope. In that case, we
1586 /// might invoke `shift_out_to_binder(D3)`. This would adjust the
1587 /// De Bruijn index of `'a` to D1 (the innermost binder).
1589 /// If we invoke `shift_out_to_binder` and the region is in fact
1590 /// bound by one of the binders we are shifting out of, that is an
1591 /// error (and should fail an assertion failure).
1592 pub fn shifted_out_to_binder(&self, to_binder
: ty
::DebruijnIndex
) -> RegionKind
{
1594 ty
::ReLateBound(debruijn
, r
) => {
1595 ty
::ReLateBound(debruijn
.shifted_out_to_binder(to_binder
), r
)
1601 pub fn type_flags(&self) -> TypeFlags
{
1602 let mut flags
= TypeFlags
::empty();
1606 flags
= flags
| TypeFlags
::HAS_FREE_REGIONS
;
1607 flags
= flags
| TypeFlags
::HAS_FREE_LOCAL_REGIONS
;
1608 flags
= flags
| TypeFlags
::HAS_RE_INFER
;
1609 flags
= flags
| TypeFlags
::STILL_FURTHER_SPECIALIZABLE
;
1611 ty
::RePlaceholder(..) => {
1612 flags
= flags
| TypeFlags
::HAS_FREE_REGIONS
;
1613 flags
= flags
| TypeFlags
::HAS_FREE_LOCAL_REGIONS
;
1614 flags
= flags
| TypeFlags
::HAS_RE_PLACEHOLDER
;
1615 flags
= flags
| TypeFlags
::STILL_FURTHER_SPECIALIZABLE
;
1617 ty
::ReEarlyBound(..) => {
1618 flags
= flags
| TypeFlags
::HAS_FREE_REGIONS
;
1619 flags
= flags
| TypeFlags
::HAS_FREE_LOCAL_REGIONS
;
1620 flags
= flags
| TypeFlags
::HAS_RE_PARAM
;
1621 flags
= flags
| TypeFlags
::STILL_FURTHER_SPECIALIZABLE
;
1623 ty
::ReFree { .. }
| ty
::ReScope { .. }
=> {
1624 flags
= flags
| TypeFlags
::HAS_FREE_REGIONS
;
1625 flags
= flags
| TypeFlags
::HAS_FREE_LOCAL_REGIONS
;
1627 ty
::ReEmpty(_
) | ty
::ReStatic
=> {
1628 flags
= flags
| TypeFlags
::HAS_FREE_REGIONS
;
1630 ty
::ReLateBound(..) => {
1631 flags
= flags
| TypeFlags
::HAS_RE_LATE_BOUND
;
1634 flags
= flags
| TypeFlags
::HAS_RE_ERASED
;
1638 debug
!("type_flags({:?}) = {:?}", self, flags
);
1643 /// Given an early-bound or free region, returns the `DefId` where it was bound.
1644 /// For example, consider the regions in this snippet of code:
1648 /// ^^ -- early bound, declared on an impl
1650 /// fn bar<'b, 'c>(x: &self, y: &'b u32, z: &'c u64) where 'static: 'c
1651 /// ^^ ^^ ^ anonymous, late-bound
1652 /// | early-bound, appears in where-clauses
1653 /// late-bound, appears only in fn args
1658 /// Here, `free_region_binding_scope('a)` would return the `DefId`
1659 /// of the impl, and for all the other highlighted regions, it
1660 /// would return the `DefId` of the function. In other cases (not shown), this
1661 /// function might return the `DefId` of a closure.
1662 pub fn free_region_binding_scope(&self, tcx
: TyCtxt
<'_
>) -> DefId
{
1664 ty
::ReEarlyBound(br
) => tcx
.parent(br
.def_id
).unwrap(),
1665 ty
::ReFree(fr
) => fr
.scope
,
1666 _
=> bug
!("free_region_binding_scope invoked on inappropriate region: {:?}", self),
1672 impl<'tcx
> TyS
<'tcx
> {
1674 pub fn is_unit(&self) -> bool
{
1676 Tuple(ref tys
) => tys
.is_empty(),
1682 pub fn is_never(&self) -> bool
{
1689 /// Checks whether a type is definitely uninhabited. This is
1690 /// conservative: for some types that are uninhabited we return `false`,
1691 /// but we only return `true` for types that are definitely uninhabited.
1692 /// `ty.conservative_is_privately_uninhabited` implies that any value of type `ty`
1693 /// will be `Abi::Uninhabited`. (Note that uninhabited types may have nonzero
1694 /// size, to account for partial initialisation. See #49298 for details.)
1695 pub fn conservative_is_privately_uninhabited(&self, tcx
: TyCtxt
<'tcx
>) -> bool
{
1696 // FIXME(varkor): we can make this less conversative by substituting concrete
1700 ty
::Adt(def
, _
) if def
.is_union() => {
1701 // For now, `union`s are never considered uninhabited.
1704 ty
::Adt(def
, _
) => {
1705 // Any ADT is uninhabited if either:
1706 // (a) It has no variants (i.e. an empty `enum`);
1707 // (b) Each of its variants (a single one in the case of a `struct`) has at least
1708 // one uninhabited field.
1709 def
.variants
.iter().all(|var
| {
1710 var
.fields
.iter().any(|field
| {
1711 tcx
.type_of(field
.did
).conservative_is_privately_uninhabited(tcx
)
1716 self.tuple_fields().any(|ty
| ty
.conservative_is_privately_uninhabited(tcx
))
1718 ty
::Array(ty
, len
) => {
1719 match len
.try_eval_usize(tcx
, ParamEnv
::empty()) {
1720 // If the array is definitely non-empty, it's uninhabited if
1721 // the type of its elements is uninhabited.
1722 Some(n
) if n
!= 0 => ty
.conservative_is_privately_uninhabited(tcx
),
1727 // References to uninitialised memory is valid for any type, including
1728 // uninhabited types, in unsafe code, so we treat all references as
1737 pub fn is_primitive(&self) -> bool
{
1739 Bool
| Char
| Int(_
) | Uint(_
) | Float(_
) => true,
1745 pub fn is_ty_var(&self) -> bool
{
1747 Infer(TyVar(_
)) => true,
1753 pub fn is_ty_infer(&self) -> bool
{
1761 pub fn is_phantom_data(&self) -> bool
{
1762 if let Adt(def
, _
) = self.kind { def.is_phantom_data() }
else { false }
1766 pub fn is_bool(&self) -> bool
{
1770 /// Returns `true` if this type is a `str`.
1772 pub fn is_str(&self) -> bool
{
1777 pub fn is_param(&self, index
: u32) -> bool
{
1779 ty
::Param(ref data
) => data
.index
== index
,
1785 pub fn is_slice(&self) -> bool
{
1787 RawPtr(TypeAndMut { ty, .. }
) | Ref(_
, ty
, _
) => match ty
.kind
{
1788 Slice(_
) | Str
=> true,
1796 pub fn is_simd(&self) -> bool
{
1798 Adt(def
, _
) => def
.repr
.simd(),
1803 pub fn sequence_element_type(&self, tcx
: TyCtxt
<'tcx
>) -> Ty
<'tcx
> {
1805 Array(ty
, _
) | Slice(ty
) => ty
,
1806 Str
=> tcx
.mk_mach_uint(ast
::UintTy
::U8
),
1807 _
=> bug
!("`sequence_element_type` called on non-sequence value: {}", self),
1811 pub fn simd_type(&self, tcx
: TyCtxt
<'tcx
>) -> Ty
<'tcx
> {
1813 Adt(def
, substs
) => def
.non_enum_variant().fields
[0].ty(tcx
, substs
),
1814 _
=> bug
!("`simd_type` called on invalid type"),
1818 pub fn simd_size(&self, _tcx
: TyCtxt
<'tcx
>) -> u64 {
1819 // Parameter currently unused, but probably needed in the future to
1820 // allow `#[repr(simd)] struct Simd<T, const N: usize>([T; N]);`.
1822 Adt(def
, _
) => def
.non_enum_variant().fields
.len() as u64,
1823 _
=> bug
!("`simd_size` called on invalid type"),
1827 pub fn simd_size_and_type(&self, tcx
: TyCtxt
<'tcx
>) -> (u64, Ty
<'tcx
>) {
1829 Adt(def
, substs
) => {
1830 let variant
= def
.non_enum_variant();
1831 (variant
.fields
.len() as u64, variant
.fields
[0].ty(tcx
, substs
))
1833 _
=> bug
!("`simd_size_and_type` called on invalid type"),
1838 pub fn is_region_ptr(&self) -> bool
{
1846 pub fn is_mutable_ptr(&self) -> bool
{
1848 RawPtr(TypeAndMut { mutbl: hir::Mutability::Mut, .. }
)
1849 | Ref(_
, _
, hir
::Mutability
::Mut
) => true,
1855 pub fn is_unsafe_ptr(&self) -> bool
{
1862 /// Tests if this is any kind of primitive pointer type (reference, raw pointer, fn pointer).
1864 pub fn is_any_ptr(&self) -> bool
{
1865 self.is_region_ptr() || self.is_unsafe_ptr() || self.is_fn_ptr()
1869 pub fn is_box(&self) -> bool
{
1871 Adt(def
, _
) => def
.is_box(),
1876 /// Panics if called on any type other than `Box<T>`.
1877 pub fn boxed_ty(&self) -> Ty
<'tcx
> {
1879 Adt(def
, substs
) if def
.is_box() => substs
.type_at(0),
1880 _
=> bug
!("`boxed_ty` is called on non-box type {:?}", self),
1884 /// A scalar type is one that denotes an atomic datum, with no sub-components.
1885 /// (A RawPtr is scalar because it represents a non-managed pointer, so its
1886 /// contents are abstract to rustc.)
1888 pub fn is_scalar(&self) -> bool
{
1895 | Infer(IntVar(_
) | FloatVar(_
))
1898 | RawPtr(_
) => true,
1903 /// Returns `true` if this type is a floating point type.
1905 pub fn is_floating_point(&self) -> bool
{
1907 Float(_
) | Infer(FloatVar(_
)) => true,
1913 pub fn is_trait(&self) -> bool
{
1915 Dynamic(..) => true,
1921 pub fn is_enum(&self) -> bool
{
1923 Adt(adt_def
, _
) => adt_def
.is_enum(),
1929 pub fn is_closure(&self) -> bool
{
1931 Closure(..) => true,
1937 pub fn is_generator(&self) -> bool
{
1939 Generator(..) => true,
1945 pub fn is_integral(&self) -> bool
{
1947 Infer(IntVar(_
)) | Int(_
) | Uint(_
) => true,
1953 pub fn is_fresh_ty(&self) -> bool
{
1955 Infer(FreshTy(_
)) => true,
1961 pub fn is_fresh(&self) -> bool
{
1963 Infer(FreshTy(_
)) => true,
1964 Infer(FreshIntTy(_
)) => true,
1965 Infer(FreshFloatTy(_
)) => true,
1971 pub fn is_char(&self) -> bool
{
1979 pub fn is_numeric(&self) -> bool
{
1980 self.is_integral() || self.is_floating_point()
1984 pub fn is_signed(&self) -> bool
{
1992 pub fn is_ptr_sized_integral(&self) -> bool
{
1994 Int(ast
::IntTy
::Isize
) | Uint(ast
::UintTy
::Usize
) => true,
2000 pub fn is_machine(&self) -> bool
{
2002 Int(..) | Uint(..) | Float(..) => true,
2008 pub fn has_concrete_skeleton(&self) -> bool
{
2010 Param(_
) | Infer(_
) | Error
=> false,
2015 /// Returns the type and mutability of `*ty`.
2017 /// The parameter `explicit` indicates if this is an *explicit* dereference.
2018 /// Some types -- notably unsafe ptrs -- can only be dereferenced explicitly.
2019 pub fn builtin_deref(&self, explicit
: bool
) -> Option
<TypeAndMut
<'tcx
>> {
2021 Adt(def
, _
) if def
.is_box() => {
2022 Some(TypeAndMut { ty: self.boxed_ty(), mutbl: hir::Mutability::Not }
)
2024 Ref(_
, ty
, mutbl
) => Some(TypeAndMut { ty, mutbl }
),
2025 RawPtr(mt
) if explicit
=> Some(mt
),
2030 /// Returns the type of `ty[i]`.
2031 pub fn builtin_index(&self) -> Option
<Ty
<'tcx
>> {
2033 Array(ty
, _
) | Slice(ty
) => Some(ty
),
2038 pub fn fn_sig(&self, tcx
: TyCtxt
<'tcx
>) -> PolyFnSig
<'tcx
> {
2040 FnDef(def_id
, substs
) => tcx
.fn_sig(def_id
).subst(tcx
, substs
),
2043 // ignore errors (#54954)
2044 ty
::Binder
::dummy(FnSig
::fake())
2046 Closure(..) => bug
!(
2047 "to get the signature of a closure, use `substs.as_closure().sig()` not `fn_sig()`",
2049 _
=> bug
!("Ty::fn_sig() called on non-fn type: {:?}", self),
2054 pub fn is_fn(&self) -> bool
{
2056 FnDef(..) | FnPtr(_
) => true,
2062 pub fn is_fn_ptr(&self) -> bool
{
2070 pub fn is_impl_trait(&self) -> bool
{
2078 pub fn ty_adt_def(&self) -> Option
<&'tcx AdtDef
> {
2080 Adt(adt
, _
) => Some(adt
),
2085 /// Iterates over tuple fields.
2086 /// Panics when called on anything but a tuple.
2087 pub fn tuple_fields(&self) -> impl DoubleEndedIterator
<Item
= Ty
<'tcx
>> {
2089 Tuple(substs
) => substs
.iter().map(|field
| field
.expect_ty()),
2090 _
=> bug
!("tuple_fields called on non-tuple"),
2094 /// If the type contains variants, returns the valid range of variant indices.
2096 // FIXME: This requires the optimized MIR in the case of generators.
2098 pub fn variant_range(&self, tcx
: TyCtxt
<'tcx
>) -> Option
<Range
<VariantIdx
>> {
2100 TyKind
::Adt(adt
, _
) => Some(adt
.variant_range()),
2101 TyKind
::Generator(def_id
, substs
, _
) => {
2102 Some(substs
.as_generator().variant_range(def_id
, tcx
))
2108 /// If the type contains variants, returns the variant for `variant_index`.
2109 /// Panics if `variant_index` is out of range.
2111 // FIXME: This requires the optimized MIR in the case of generators.
2113 pub fn discriminant_for_variant(
2116 variant_index
: VariantIdx
,
2117 ) -> Option
<Discr
<'tcx
>> {
2119 TyKind
::Adt(adt
, _
) => Some(adt
.discriminant_for_variant(tcx
, variant_index
)),
2120 TyKind
::Generator(def_id
, substs
, _
) => {
2121 Some(substs
.as_generator().discriminant_for_variant(def_id
, tcx
, variant_index
))
2127 /// When we create a closure, we record its kind (i.e., what trait
2128 /// it implements) into its `ClosureSubsts` using a type
2129 /// parameter. This is kind of a phantom type, except that the
2130 /// most convenient thing for us to are the integral types. This
2131 /// function converts such a special type into the closure
2132 /// kind. To go the other way, use
2133 /// `tcx.closure_kind_ty(closure_kind)`.
2135 /// Note that during type checking, we use an inference variable
2136 /// to represent the closure kind, because it has not yet been
2137 /// inferred. Once upvar inference (in `src/librustc_typeck/check/upvar.rs`)
2138 /// is complete, that type variable will be unified.
2139 pub fn to_opt_closure_kind(&self) -> Option
<ty
::ClosureKind
> {
2141 Int(int_ty
) => match int_ty
{
2142 ast
::IntTy
::I8
=> Some(ty
::ClosureKind
::Fn
),
2143 ast
::IntTy
::I16
=> Some(ty
::ClosureKind
::FnMut
),
2144 ast
::IntTy
::I32
=> Some(ty
::ClosureKind
::FnOnce
),
2145 _
=> bug
!("cannot convert type `{:?}` to a closure kind", self),
2148 // "Bound" types appear in canonical queries when the
2149 // closure type is not yet known
2150 Bound(..) | Infer(_
) => None
,
2152 Error
=> Some(ty
::ClosureKind
::Fn
),
2154 _
=> bug
!("cannot convert type `{:?}` to a closure kind", self),
2158 /// Fast path helper for testing if a type is `Sized`.
2160 /// Returning true means the type is known to be sized. Returning
2161 /// `false` means nothing -- could be sized, might not be.
2162 pub fn is_trivially_sized(&self, tcx
: TyCtxt
<'tcx
>) -> bool
{
2164 ty
::Infer(ty
::IntVar(_
) | ty
::FloatVar(_
))
2175 | ty
::GeneratorWitness(..)
2179 | ty
::Error
=> true,
2181 ty
::Str
| ty
::Slice(_
) | ty
::Dynamic(..) | ty
::Foreign(..) => false,
2183 ty
::Tuple(tys
) => tys
.iter().all(|ty
| ty
.expect_ty().is_trivially_sized(tcx
)),
2185 ty
::Adt(def
, _substs
) => def
.sized_constraint(tcx
).is_empty(),
2187 ty
::Projection(_
) | ty
::Param(_
) | ty
::Opaque(..) => false,
2189 ty
::UnnormalizedProjection(..) => bug
!("only used with chalk-engine"),
2191 ty
::Infer(ty
::TyVar(_
)) => false,
2194 | ty
::Placeholder(..)
2195 | ty
::Infer(ty
::FreshTy(_
) | ty
::FreshIntTy(_
) | ty
::FreshFloatTy(_
)) => {
2196 bug
!("`is_trivially_sized` applied to unexpected type: {:?}", self)
2202 /// Typed constant value.
2203 #[derive(Copy, Clone, Debug, Hash, RustcEncodable, RustcDecodable, Eq, PartialEq, Ord, PartialOrd)]
2204 #[derive(HashStable)]
2205 pub struct Const
<'tcx
> {
2208 pub val
: ConstKind
<'tcx
>,
2211 #[cfg(target_arch = "x86_64")]
2212 static_assert_size
!(Const
<'_
>, 48);
2214 impl<'tcx
> Const
<'tcx
> {
2215 /// Literals and const generic parameters are eagerly converted to a constant, everything else
2216 /// becomes `Unevaluated`.
2217 pub fn from_anon_const(tcx
: TyCtxt
<'tcx
>, def_id
: LocalDefId
) -> &'tcx
Self {
2218 debug
!("Const::from_anon_const(id={:?})", def_id
);
2220 let hir_id
= tcx
.hir().local_def_id_to_hir_id(def_id
);
2222 let body_id
= match tcx
.hir().get(hir_id
) {
2223 hir
::Node
::AnonConst(ac
) => ac
.body
,
2225 tcx
.def_span(def_id
.to_def_id()),
2226 "from_anon_const can only process anonymous constants"
2230 let expr
= &tcx
.hir().body(body_id
).value
;
2232 let ty
= tcx
.type_of(def_id
.to_def_id());
2234 let lit_input
= match expr
.kind
{
2235 hir
::ExprKind
::Lit(ref lit
) => Some(LitToConstInput { lit: &lit.node, ty, neg: false }
),
2236 hir
::ExprKind
::Unary(hir
::UnOp
::UnNeg
, ref expr
) => match expr
.kind
{
2237 hir
::ExprKind
::Lit(ref lit
) => {
2238 Some(LitToConstInput { lit: &lit.node, ty, neg: true }
)
2245 if let Some(lit_input
) = lit_input
{
2246 // If an error occurred, ignore that it's a literal and leave reporting the error up to
2248 if let Ok(c
) = tcx
.at(expr
.span
).lit_to_const(lit_input
) {
2251 tcx
.sess
.delay_span_bug(expr
.span
, "Const::from_anon_const: couldn't lit_to_const");
2255 // Unwrap a block, so that e.g. `{ P }` is recognised as a parameter. Const arguments
2256 // currently have to be wrapped in curly brackets, so it's necessary to special-case.
2257 let expr
= match &expr
.kind
{
2258 hir
::ExprKind
::Block(block
, _
) if block
.stmts
.is_empty() && block
.expr
.is_some() => {
2259 block
.expr
.as_ref().unwrap()
2264 use hir
::{def::DefKind::ConstParam, def::Res, ExprKind, Path, QPath}
;
2265 let val
= match expr
.kind
{
2266 ExprKind
::Path(QPath
::Resolved(_
, &Path { res: Res::Def(ConstParam, def_id), .. }
)) => {
2267 // Find the name and index of the const parameter by indexing the generics of
2268 // the parent item and construct a `ParamConst`.
2269 let hir_id
= tcx
.hir().as_local_hir_id(def_id
).unwrap();
2270 let item_id
= tcx
.hir().get_parent_node(hir_id
);
2271 let item_def_id
= tcx
.hir().local_def_id(item_id
);
2272 let generics
= tcx
.generics_of(item_def_id
);
2273 let index
= generics
.param_def_id_to_index
[&tcx
.hir().local_def_id(hir_id
)];
2274 let name
= tcx
.hir().name(hir_id
);
2275 ty
::ConstKind
::Param(ty
::ParamConst
::new(index
, name
))
2277 _
=> ty
::ConstKind
::Unevaluated(
2279 InternalSubsts
::identity_for_item(tcx
, def_id
.to_def_id()),
2284 tcx
.mk_const(ty
::Const { val, ty }
)
2288 /// Interns the given value as a constant.
2289 pub fn from_value(tcx
: TyCtxt
<'tcx
>, val
: ConstValue
<'tcx
>, ty
: Ty
<'tcx
>) -> &'tcx
Self {
2290 tcx
.mk_const(Self { val: ConstKind::Value(val), ty }
)
2294 /// Interns the given scalar as a constant.
2295 pub fn from_scalar(tcx
: TyCtxt
<'tcx
>, val
: Scalar
, ty
: Ty
<'tcx
>) -> &'tcx
Self {
2296 Self::from_value(tcx
, ConstValue
::Scalar(val
), ty
)
2300 /// Creates a constant with the given integer value and interns it.
2301 pub fn from_bits(tcx
: TyCtxt
<'tcx
>, bits
: u128
, ty
: ParamEnvAnd
<'tcx
, Ty
<'tcx
>>) -> &'tcx
Self {
2304 .unwrap_or_else(|e
| panic
!("could not compute layout for {:?}: {:?}", ty
, e
))
2306 Self::from_scalar(tcx
, Scalar
::from_uint(bits
, size
), ty
.value
)
2310 /// Creates an interned zst constant.
2311 pub fn zero_sized(tcx
: TyCtxt
<'tcx
>, ty
: Ty
<'tcx
>) -> &'tcx
Self {
2312 Self::from_scalar(tcx
, Scalar
::zst(), ty
)
2316 /// Creates an interned bool constant.
2317 pub fn from_bool(tcx
: TyCtxt
<'tcx
>, v
: bool
) -> &'tcx
Self {
2318 Self::from_bits(tcx
, v
as u128
, ParamEnv
::empty().and(tcx
.types
.bool
))
2322 /// Creates an interned usize constant.
2323 pub fn from_usize(tcx
: TyCtxt
<'tcx
>, n
: u64) -> &'tcx
Self {
2324 Self::from_bits(tcx
, n
as u128
, ParamEnv
::empty().and(tcx
.types
.usize))
2328 /// Attempts to evaluate the given constant to bits. Can fail to evaluate in the presence of
2329 /// generics (or erroneous code) or if the value can't be represented as bits (e.g. because it
2330 /// contains const generic parameters or pointers).
2331 pub fn try_eval_bits(
2334 param_env
: ParamEnv
<'tcx
>,
2337 assert_eq
!(self.ty
, ty
);
2338 let size
= tcx
.layout_of(param_env
.with_reveal_all().and(ty
)).ok()?
.size
;
2339 // if `ty` does not depend on generic parameters, use an empty param_env
2340 self.eval(tcx
, param_env
).val
.try_to_bits(size
)
2344 /// Tries to evaluate the constant if it is `Unevaluated`. If that doesn't succeed, return the
2345 /// unevaluated constant.
2346 pub fn eval(&self, tcx
: TyCtxt
<'tcx
>, param_env
: ParamEnv
<'tcx
>) -> &Const
<'tcx
> {
2347 if let ConstKind
::Unevaluated(did
, substs
, promoted
) = self.val
{
2348 use crate::mir
::interpret
::ErrorHandled
;
2350 let param_env_and_substs
= param_env
.with_reveal_all().and(substs
);
2352 // HACK(eddyb) this erases lifetimes even though `const_eval_resolve`
2353 // also does later, but we want to do it before checking for
2354 // inference variables.
2355 let param_env_and_substs
= tcx
.erase_regions(¶m_env_and_substs
);
2357 // HACK(eddyb) when the query key would contain inference variables,
2358 // attempt using identity substs and `ParamEnv` instead, that will succeed
2359 // when the expression doesn't depend on any parameters.
2360 // FIXME(eddyb, skinny121) pass `InferCtxt` into here when it's available, so that
2361 // we can call `infcx.const_eval_resolve` which handles inference variables.
2362 let param_env_and_substs
= if param_env_and_substs
.needs_infer() {
2363 tcx
.param_env(did
).and(InternalSubsts
::identity_for_item(tcx
, did
))
2365 param_env_and_substs
2368 // FIXME(eddyb) maybe the `const_eval_*` methods should take
2369 // `ty::ParamEnvAnd<SubstsRef>` instead of having them separate.
2370 let (param_env
, substs
) = param_env_and_substs
.into_parts();
2371 // try to resolve e.g. associated constants to their definition on an impl, and then
2372 // evaluate the const.
2373 match tcx
.const_eval_resolve(param_env
, did
, substs
, promoted
, None
) {
2374 // NOTE(eddyb) `val` contains no lifetimes/types/consts,
2375 // and we use the original type, so nothing from `substs`
2376 // (which may be identity substs, see above),
2377 // can leak through `val` into the const we return.
2378 Ok(val
) => Const
::from_value(tcx
, val
, self.ty
),
2379 Err(ErrorHandled
::TooGeneric
| ErrorHandled
::Linted
) => self,
2380 Err(ErrorHandled
::Reported(ErrorReported
)) => {
2381 tcx
.mk_const(ty
::Const { val: ty::ConstKind::Error, ty: self.ty }
)
2390 pub fn try_eval_bool(&self, tcx
: TyCtxt
<'tcx
>, param_env
: ParamEnv
<'tcx
>) -> Option
<bool
> {
2391 self.try_eval_bits(tcx
, param_env
, tcx
.types
.bool
).and_then(|v
| match v
{
2399 pub fn try_eval_usize(&self, tcx
: TyCtxt
<'tcx
>, param_env
: ParamEnv
<'tcx
>) -> Option
<u64> {
2400 self.try_eval_bits(tcx
, param_env
, tcx
.types
.usize).map(|v
| v
as u64)
2404 /// Panics if the value cannot be evaluated or doesn't contain a valid integer of the given type.
2405 pub fn eval_bits(&self, tcx
: TyCtxt
<'tcx
>, param_env
: ParamEnv
<'tcx
>, ty
: Ty
<'tcx
>) -> u128
{
2406 self.try_eval_bits(tcx
, param_env
, ty
)
2407 .unwrap_or_else(|| bug
!("expected bits of {:#?}, got {:#?}", ty
, self))
2411 /// Panics if the value cannot be evaluated or doesn't contain a valid `usize`.
2412 pub fn eval_usize(&self, tcx
: TyCtxt
<'tcx
>, param_env
: ParamEnv
<'tcx
>) -> u64 {
2413 self.eval_bits(tcx
, param_env
, tcx
.types
.usize) as u64
2417 impl<'tcx
> rustc_serialize
::UseSpecializedDecodable
for &'tcx Const
<'tcx
> {}
2419 /// Represents a constant in Rust.
2420 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash)]
2421 #[derive(HashStable)]
2422 pub enum ConstKind
<'tcx
> {
2423 /// A const generic parameter.
2426 /// Infer the value of the const.
2427 Infer(InferConst
<'tcx
>),
2429 /// Bound const variable, used only when preparing a trait query.
2430 Bound(DebruijnIndex
, BoundVar
),
2432 /// A placeholder const - universally quantified higher-ranked const.
2433 Placeholder(ty
::PlaceholderConst
),
2435 /// Used in the HIR by using `Unevaluated` everywhere and later normalizing to one of the other
2436 /// variants when the code is monomorphic enough for that.
2437 Unevaluated(DefId
, SubstsRef
<'tcx
>, Option
<Promoted
>),
2439 /// Used to hold computed value.
2440 Value(ConstValue
<'tcx
>),
2442 /// A placeholder for a const which could not be computed; this is
2443 /// propagated to avoid useless error messages.
2447 #[cfg(target_arch = "x86_64")]
2448 static_assert_size
!(ConstKind
<'_
>, 40);
2450 impl<'tcx
> ConstKind
<'tcx
> {
2452 pub fn try_to_scalar(&self) -> Option
<Scalar
> {
2453 if let ConstKind
::Value(val
) = self { val.try_to_scalar() }
else { None }
2457 pub fn try_to_bits(&self, size
: Size
) -> Option
<u128
> {
2458 if let ConstKind
::Value(val
) = self { val.try_to_bits(size) }
else { None }
2462 /// An inference variable for a const, for use in const generics.
2463 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash)]
2464 #[derive(HashStable)]
2465 pub enum InferConst
<'tcx
> {
2466 /// Infer the value of the const.
2467 Var(ConstVid
<'tcx
>),
2468 /// A fresh const variable. See `infer::freshen` for more details.