pub struct Ty<'tcx>(Interned<'tcx, WithCachedTypeInfo<TyKind<'tcx>>>);
Expand description
Use this rather than TyKind
, whenever possible.
Tuple Fields§
§0: Interned<'tcx, WithCachedTypeInfo<TyKind<'tcx>>>
Implementations§
Source§impl<'tcx> Ty<'tcx>
impl<'tcx> Ty<'tcx>
pub fn sort_string(self, tcx: TyCtxt<'tcx>) -> Cow<'static, str>
pub fn prefix_string(self, tcx: TyCtxt<'_>) -> Cow<'static, str>
Source§impl<'tcx> Ty<'tcx>
impl<'tcx> Ty<'tcx>
pub fn inhabited_predicate(self, tcx: TyCtxt<'tcx>) -> InhabitedPredicate<'tcx>
Sourcepub fn is_inhabited_from(
self,
tcx: TyCtxt<'tcx>,
module: DefId,
typing_env: TypingEnv<'tcx>,
) -> bool
pub fn is_inhabited_from( self, tcx: TyCtxt<'tcx>, module: DefId, typing_env: TypingEnv<'tcx>, ) -> bool
Checks whether a type is visibly uninhabited from a particular module.
§Example
#![feature(never_type)]
enum Void {}
mod a {
pub mod b {
pub struct SecretlyUninhabited {
_priv: !,
}
}
}
mod c {
use super::Void;
pub struct AlsoSecretlyUninhabited {
_priv: Void,
}
mod d {
}
}
struct Foo {
x: a::b::SecretlyUninhabited,
y: c::AlsoSecretlyUninhabited,
}
In this code, the type Foo
will only be visibly uninhabited inside the
modules b, c and d. This effects pattern-matching on Foo
or types that
contain Foo
.
§Example
let foo_result: Result<T, Foo> = ... ;
let Ok(t) = foo_result;
This code should only compile in modules where the uninhabitedness of Foo is visible.
Sourcepub fn is_privately_uninhabited(
self,
tcx: TyCtxt<'tcx>,
typing_env: TypingEnv<'tcx>,
) -> bool
pub fn is_privately_uninhabited( self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, ) -> bool
Returns true if the type is uninhabited without regard to visibility
Source§impl<'tcx> Ty<'tcx>
impl<'tcx> Ty<'tcx>
Sourcepub fn primitive_size(self, tcx: TyCtxt<'tcx>) -> Size
pub fn primitive_size(self, tcx: TyCtxt<'tcx>) -> Size
Returns the Size
for primitive types (bool, uint, int, char, float).
pub fn int_size_and_signed(self, tcx: TyCtxt<'tcx>) -> (Size, bool)
Sourcepub fn numeric_min_and_max_as_bits(
self,
tcx: TyCtxt<'tcx>,
) -> Option<(u128, u128)>
pub fn numeric_min_and_max_as_bits( self, tcx: TyCtxt<'tcx>, ) -> Option<(u128, u128)>
Returns the minimum and maximum values for the given numeric type (including char
s) or
returns None
if the type is not numeric.
Sourcepub fn numeric_max_val(self, tcx: TyCtxt<'tcx>) -> Option<Const<'tcx>>
pub fn numeric_max_val(self, tcx: TyCtxt<'tcx>) -> Option<Const<'tcx>>
Returns the maximum value for the given numeric type (including char
s)
or returns None
if the type is not numeric.
Sourcepub fn numeric_min_val(self, tcx: TyCtxt<'tcx>) -> Option<Const<'tcx>>
pub fn numeric_min_val(self, tcx: TyCtxt<'tcx>) -> Option<Const<'tcx>>
Returns the minimum value for the given numeric type (including char
s)
or returns None
if the type is not numeric.
Sourcepub fn is_sized(self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>) -> bool
pub fn is_sized(self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>) -> bool
Checks whether values of this type T
have a size known at
compile time (i.e., whether T: Sized
). Lifetimes are ignored
for the purposes of this check, so it can be an
over-approximation in generic contexts, where one can have
strange rules like <T as Foo<'static>>::Bar: Sized
that
actually carry lifetime requirements.
Sourcepub fn is_freeze(self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>) -> bool
pub fn is_freeze(self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>) -> bool
Checks whether values of this type T
implement the Freeze
trait – frozen types are those that do not contain an
UnsafeCell
anywhere. This is a language concept used to
distinguish “true immutability”, which is relevant to
optimization as well as the rules around static values. Note
that the Freeze
trait is not exposed to end users and is
effectively an implementation detail.
Sourcepub fn is_trivially_freeze(self) -> bool
pub fn is_trivially_freeze(self) -> bool
Fast path helper for testing if a type is Freeze
.
Returning true means the type is known to be Freeze
. Returning
false
means nothing – could be Freeze
, might not be.
Sourcepub fn is_unpin(self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>) -> bool
pub fn is_unpin(self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>) -> bool
Checks whether values of this type T
implement the Unpin
trait.
Sourcefn is_trivially_unpin(self) -> bool
fn is_trivially_unpin(self) -> bool
Fast path helper for testing if a type is Unpin
.
Returning true means the type is known to be Unpin
. Returning
false
means nothing – could be Unpin
, might not be.
Sourcepub fn has_unsafe_fields(self) -> bool
pub fn has_unsafe_fields(self) -> bool
Checks whether this type is an ADT that has unsafe fields.
Sourcepub fn async_drop_glue_morphology(
self,
tcx: TyCtxt<'tcx>,
) -> AsyncDropGlueMorphology
pub fn async_drop_glue_morphology( self, tcx: TyCtxt<'tcx>, ) -> AsyncDropGlueMorphology
Get morphology of the async drop glue, needed for types which do not
use async drop. To get async drop glue morphology for a definition see
TyCtxt::async_drop_glue_morphology
. Used for AsyncDestruct::Destructor
type construction.
Sourcepub fn needs_drop(self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>) -> bool
pub fn needs_drop(self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>) -> bool
If ty.needs_drop(...)
returns true
, then ty
is definitely
non-copy and might have a destructor attached; if it returns
false
, then ty
definitely has no destructor (i.e., no drop glue).
(Note that this implies that if ty
has a destructor attached,
then needs_drop
will definitely return true
for ty
.)
Note that this method is used to check eligible types in unions.
Sourcepub fn needs_async_drop(
self,
tcx: TyCtxt<'tcx>,
typing_env: TypingEnv<'tcx>,
) -> bool
pub fn needs_async_drop( self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, ) -> bool
If ty.needs_async_drop(...)
returns true
, then ty
is definitely
non-copy and might have a async destructor attached; if it returns
false
, then ty
definitely has no async destructor (i.e., no async
drop glue).
(Note that this implies that if ty
has an async destructor attached,
then needs_async_drop
will definitely return true
for ty
.)
When constructing AsyncDestruct::Destructor
type, use
Ty::async_drop_glue_morphology
instead.
Sourcepub fn has_significant_drop(
self,
tcx: TyCtxt<'tcx>,
typing_env: TypingEnv<'tcx>,
) -> bool
pub fn has_significant_drop( self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, ) -> bool
Checks if ty
has a significant drop.
Note that this method can return false even if ty
has a destructor
attached; even if that is the case then the adt has been marked with
the attribute rustc_insignificant_dtor
.
Note that this method is used to check for change in drop order for 2229 drop reorder migration analysis.
Sourcepub fn is_structural_eq_shallow(self, tcx: TyCtxt<'tcx>) -> bool
pub fn is_structural_eq_shallow(self, tcx: TyCtxt<'tcx>) -> bool
Returns true
if equality for this type is both reflexive and structural.
Reflexive equality for a type is indicated by an Eq
impl for that type.
Primitive types (u32
, str
) have structural equality by definition. For composite data
types, equality for the type as a whole is structural when it is the same as equality
between all components (fields, array elements, etc.) of that type. For ADTs, structural
equality is indicated by an implementation of StructuralPartialEq
for that type.
This function is “shallow” because it may return true
for a composite type whose fields
are not StructuralPartialEq
. For example, [T; 4]
has structural equality regardless of T
because equality for arrays is determined by the equality of each array element. If you
want to know whether a given call to PartialEq::eq
will proceed structurally all the way
down, you will need to use a type visitor.
Sourcepub fn peel_refs(self) -> Ty<'tcx>
pub fn peel_refs(self) -> Ty<'tcx>
Peel off all reference types in this type until there are none left.
This method is idempotent, i.e. ty.peel_refs().peel_refs() == ty.peel_refs()
.
§Examples
u8
->u8
&'a mut u8
->u8
&'a &'b u8
->u8
&'a *const &'b u8 -> *const &'b u8
pub fn outer_exclusive_binder(self) -> DebruijnIndex
Source§impl<'tcx> Ty<'tcx>
impl<'tcx> Ty<'tcx>
Sourcepub fn walk(self) -> TypeWalker<'tcx> ⓘ
pub fn walk(self) -> TypeWalker<'tcx> ⓘ
Iterator that walks self
and any types reachable from
self
, in depth-first order. Note that just walks the types
that appear in self
, it does not descend into the fields of
structs or variants. For example:
isize => { isize }
Foo<Bar<isize>> => { Foo<Bar<isize>>, Bar<isize>, isize }
[isize] => { [isize], isize }
Source§impl<'tcx> Ty<'tcx>
impl<'tcx> Ty<'tcx>
Sourcepub fn is_primitive_ty(self) -> bool
pub fn is_primitive_ty(self) -> bool
Similar to Ty::is_primitive
, but also considers inferred numeric values to be primitive.
Sourcepub fn is_simple_ty(self) -> bool
pub fn is_simple_ty(self) -> bool
Whether the type is succinctly representable as a type instead of just referred to with a description in error messages. This is used in the main error message.
Sourcepub fn is_simple_text(self, tcx: TyCtxt<'tcx>) -> bool
pub fn is_simple_text(self, tcx: TyCtxt<'tcx>) -> bool
Whether the type is succinctly representable as a type instead of just referred to with a
description in error messages. This is used in the primary span label. Beyond what
is_simple_ty
includes, it also accepts ADTs with no type arguments and references to
ADTs with no type arguments.
Source§impl<'tcx> Ty<'tcx>
Constructors for Ty
impl<'tcx> Ty<'tcx>
Constructors for Ty
Sourcepub fn new(tcx: TyCtxt<'tcx>, st: TyKind<'tcx>) -> Ty<'tcx>
pub fn new(tcx: TyCtxt<'tcx>, st: TyKind<'tcx>) -> Ty<'tcx>
Avoid using this in favour of more specific new_*
methods, where possible.
The more specific methods will often optimize their creation.
pub fn new_infer(tcx: TyCtxt<'tcx>, infer: InferTy) -> Ty<'tcx>
pub fn new_var(tcx: TyCtxt<'tcx>, v: TyVid) -> Ty<'tcx>
pub fn new_int_var(tcx: TyCtxt<'tcx>, v: IntVid) -> Ty<'tcx>
pub fn new_float_var(tcx: TyCtxt<'tcx>, v: FloatVid) -> Ty<'tcx>
pub fn new_fresh(tcx: TyCtxt<'tcx>, n: u32) -> Ty<'tcx>
pub fn new_fresh_int(tcx: TyCtxt<'tcx>, n: u32) -> Ty<'tcx>
pub fn new_fresh_float(tcx: TyCtxt<'tcx>, n: u32) -> Ty<'tcx>
pub fn new_param(tcx: TyCtxt<'tcx>, index: u32, name: Symbol) -> Ty<'tcx>
pub fn new_bound( tcx: TyCtxt<'tcx>, index: DebruijnIndex, bound_ty: BoundTy, ) -> Ty<'tcx>
pub fn new_placeholder( tcx: TyCtxt<'tcx>, placeholder: PlaceholderType, ) -> Ty<'tcx>
pub fn new_alias( tcx: TyCtxt<'tcx>, kind: AliasTyKind, alias_ty: AliasTy<'tcx>, ) -> Ty<'tcx>
pub fn new_pat( tcx: TyCtxt<'tcx>, base: Ty<'tcx>, pat: Pattern<'tcx>, ) -> Ty<'tcx>
pub fn new_opaque( tcx: TyCtxt<'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>, ) -> Ty<'tcx>
Sourcepub fn new_error(tcx: TyCtxt<'tcx>, guar: ErrorGuaranteed) -> Ty<'tcx>
pub fn new_error(tcx: TyCtxt<'tcx>, guar: ErrorGuaranteed) -> Ty<'tcx>
Constructs a TyKind::Error
type with current ErrorGuaranteed
Sourcepub fn new_misc_error(tcx: TyCtxt<'tcx>) -> Ty<'tcx>
pub fn new_misc_error(tcx: TyCtxt<'tcx>) -> Ty<'tcx>
Constructs a TyKind::Error
type and registers a span_delayed_bug
to ensure it gets used.
Sourcepub fn new_error_with_message<S: Into<MultiSpan>>(
tcx: TyCtxt<'tcx>,
span: S,
msg: impl Into<Cow<'static, str>>,
) -> Ty<'tcx>
pub fn new_error_with_message<S: Into<MultiSpan>>( tcx: TyCtxt<'tcx>, span: S, msg: impl Into<Cow<'static, str>>, ) -> Ty<'tcx>
Constructs a TyKind::Error
type and registers a span_delayed_bug
with the given msg
to
ensure it gets used.
pub fn new_int(tcx: TyCtxt<'tcx>, i: IntTy) -> Ty<'tcx>
pub fn new_uint(tcx: TyCtxt<'tcx>, ui: UintTy) -> Ty<'tcx>
pub fn new_float(tcx: TyCtxt<'tcx>, f: FloatTy) -> Ty<'tcx>
pub fn new_ref( tcx: TyCtxt<'tcx>, r: Region<'tcx>, ty: Ty<'tcx>, mutbl: Mutability, ) -> Ty<'tcx>
pub fn new_mut_ref(tcx: TyCtxt<'tcx>, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx>
pub fn new_imm_ref(tcx: TyCtxt<'tcx>, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx>
pub fn new_pinned_ref( tcx: TyCtxt<'tcx>, r: Region<'tcx>, ty: Ty<'tcx>, mutbl: Mutability, ) -> Ty<'tcx>
pub fn new_ptr(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, mutbl: Mutability) -> Ty<'tcx>
pub fn new_mut_ptr(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx>
pub fn new_imm_ptr(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx>
pub fn new_adt( tcx: TyCtxt<'tcx>, def: AdtDef<'tcx>, args: GenericArgsRef<'tcx>, ) -> Ty<'tcx>
pub fn new_foreign(tcx: TyCtxt<'tcx>, def_id: DefId) -> Ty<'tcx>
pub fn new_array(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, n: u64) -> Ty<'tcx>
pub fn new_array_with_const_len( tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, ct: Const<'tcx>, ) -> Ty<'tcx>
pub fn new_slice(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx>
pub fn new_tup(tcx: TyCtxt<'tcx>, ts: &[Ty<'tcx>]) -> Ty<'tcx>
pub fn new_tup_from_iter<I, T>(tcx: TyCtxt<'tcx>, iter: I) -> T::Output
pub fn new_fn_def( tcx: TyCtxt<'tcx>, def_id: DefId, args: impl IntoIterator<Item: Into<GenericArg<'tcx>>>, ) -> Ty<'tcx>
pub fn new_fn_ptr(tcx: TyCtxt<'tcx>, fty: PolyFnSig<'tcx>) -> Ty<'tcx>
pub fn new_dynamic( tcx: TyCtxt<'tcx>, obj: &'tcx List<PolyExistentialPredicate<'tcx>>, reg: Region<'tcx>, repr: DynKind, ) -> Ty<'tcx>
pub fn new_projection_from_args( tcx: TyCtxt<'tcx>, item_def_id: DefId, args: GenericArgsRef<'tcx>, ) -> Ty<'tcx>
pub fn new_projection( tcx: TyCtxt<'tcx>, item_def_id: DefId, args: impl IntoIterator<Item: Into<GenericArg<'tcx>>>, ) -> Ty<'tcx>
pub fn new_closure( tcx: TyCtxt<'tcx>, def_id: DefId, closure_args: GenericArgsRef<'tcx>, ) -> Ty<'tcx>
pub fn new_coroutine_closure( tcx: TyCtxt<'tcx>, def_id: DefId, closure_args: GenericArgsRef<'tcx>, ) -> Ty<'tcx>
pub fn new_coroutine( tcx: TyCtxt<'tcx>, def_id: DefId, coroutine_args: GenericArgsRef<'tcx>, ) -> Ty<'tcx>
pub fn new_coroutine_witness( tcx: TyCtxt<'tcx>, id: DefId, args: GenericArgsRef<'tcx>, ) -> Ty<'tcx>
pub fn new_static_str(tcx: TyCtxt<'tcx>) -> Ty<'tcx>
pub fn new_diverging_default(tcx: TyCtxt<'tcx>) -> Ty<'tcx>
fn new_generic_adt( tcx: TyCtxt<'tcx>, wrapper_def_id: DefId, ty_param: Ty<'tcx>, ) -> Ty<'tcx>
pub fn new_lang_item( tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, item: LangItem, ) -> Option<Ty<'tcx>>
pub fn new_diagnostic_item( tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, name: Symbol, ) -> Option<Ty<'tcx>>
pub fn new_box(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx>
pub fn new_maybe_uninit(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx>
Sourcepub fn new_task_context(tcx: TyCtxt<'tcx>) -> Ty<'tcx>
pub fn new_task_context(tcx: TyCtxt<'tcx>) -> Ty<'tcx>
Creates a &mut Context<'_>
Ty
with erased lifetimes.
Source§impl<'tcx> Ty<'tcx>
Type utilities
impl<'tcx> Ty<'tcx>
Type utilities
pub fn kind(self) -> &'tcx TyKind<'tcx>
pub fn flags(self) -> TypeFlags
pub fn is_unit(self) -> bool
pub fn is_never(self) -> bool
pub fn is_primitive(self) -> bool
pub fn is_adt(self) -> bool
pub fn is_ref(self) -> bool
pub fn is_ty_var(self) -> bool
pub fn ty_vid(self) -> Option<TyVid>
pub fn is_ty_or_numeric_infer(self) -> bool
pub fn is_phantom_data(self) -> bool
pub fn is_bool(self) -> bool
pub fn is_param(self, index: u32) -> bool
pub fn is_slice(self) -> bool
pub fn is_array_slice(self) -> bool
pub fn is_array(self) -> bool
pub fn is_simd(self) -> bool
pub fn sequence_element_type(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
pub fn simd_size_and_type(self, tcx: TyCtxt<'tcx>) -> (u64, Ty<'tcx>)
pub fn is_mutable_ptr(self) -> bool
Sourcepub fn ref_mutability(self) -> Option<Mutability>
pub fn ref_mutability(self) -> Option<Mutability>
Get the mutability of the reference or None
when not a reference
pub fn is_unsafe_ptr(self) -> bool
Sourcepub fn is_any_ptr(self) -> bool
pub fn is_any_ptr(self) -> bool
Tests if this is any kind of primitive pointer type (reference, raw pointer, fn pointer).
Box
is not considered a pointer here!
pub fn is_box(self) -> bool
Sourcepub fn is_box_global(self, tcx: TyCtxt<'tcx>) -> bool
pub fn is_box_global(self, tcx: TyCtxt<'tcx>) -> bool
Tests whether this is a Box definitely using the global allocator.
If the allocator is still generic, the answer is false
, but it may
later turn out that it does use the global allocator.
pub fn boxed_ty(self) -> Option<Ty<'tcx>>
Sourcepub fn expect_boxed_ty(self) -> Ty<'tcx>
pub fn expect_boxed_ty(self) -> Ty<'tcx>
Panics if called on any type other than Box<T>
.
Sourcepub fn is_scalar(self) -> bool
pub fn is_scalar(self) -> bool
A scalar type is one that denotes an atomic datum, with no sub-components. (A RawPtr is scalar because it represents a non-managed pointer, so its contents are abstract to rustc.)
Sourcepub fn is_floating_point(self) -> bool
pub fn is_floating_point(self) -> bool
Returns true
if this type is a floating point type.
pub fn is_trait(self) -> bool
pub fn is_dyn_star(self) -> bool
pub fn is_enum(self) -> bool
pub fn is_union(self) -> bool
pub fn is_closure(self) -> bool
pub fn is_coroutine(self) -> bool
pub fn is_coroutine_closure(self) -> bool
pub fn is_integral(self) -> bool
pub fn is_fresh_ty(self) -> bool
pub fn is_fresh(self) -> bool
pub fn is_char(self) -> bool
pub fn is_numeric(self) -> bool
pub fn is_signed(self) -> bool
pub fn is_ptr_sized_integral(self) -> bool
pub fn has_concrete_skeleton(self) -> bool
Sourcepub fn contains(self, other: Ty<'tcx>) -> bool
pub fn contains(self, other: Ty<'tcx>) -> bool
Checks whether a type recursively contains another type
Example: Option<()>
contains ()
Sourcepub fn contains_closure(self) -> bool
pub fn contains_closure(self) -> bool
Checks whether a type recursively contains any closure
Example: Option<{closure@file.rs:4:20}>
returns true
Sourcepub fn builtin_deref(self, explicit: bool) -> Option<Ty<'tcx>>
pub fn builtin_deref(self, explicit: bool) -> Option<Ty<'tcx>>
Returns the type and mutability of *ty
.
The parameter explicit
indicates if this is an explicit dereference.
Some types – notably unsafe ptrs – can only be dereferenced explicitly.
Sourcepub fn builtin_index(self) -> Option<Ty<'tcx>>
pub fn builtin_index(self) -> Option<Ty<'tcx>>
Returns the type of ty[i]
.
pub fn fn_sig(self, tcx: TyCtxt<'tcx>) -> PolyFnSig<'tcx>
pub fn is_fn(self) -> bool
pub fn is_fn_ptr(self) -> bool
pub fn is_impl_trait(self) -> bool
pub fn ty_adt_def(self) -> Option<AdtDef<'tcx>>
Sourcepub fn tuple_fields(self) -> &'tcx List<Ty<'tcx>>
pub fn tuple_fields(self) -> &'tcx List<Ty<'tcx>>
Iterates over tuple fields. Panics when called on anything but a tuple.
Sourcepub fn variant_range(self, tcx: TyCtxt<'tcx>) -> Option<Range<VariantIdx>>
pub fn variant_range(self, tcx: TyCtxt<'tcx>) -> Option<Range<VariantIdx>>
If the type contains variants, returns the valid range of variant indices.
Sourcepub fn discriminant_for_variant(
self,
tcx: TyCtxt<'tcx>,
variant_index: VariantIdx,
) -> Option<Discr<'tcx>>
pub fn discriminant_for_variant( self, tcx: TyCtxt<'tcx>, variant_index: VariantIdx, ) -> Option<Discr<'tcx>>
If the type contains variants, returns the variant for variant_index
.
Panics if variant_index
is out of range.
Sourcepub fn discriminant_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
pub fn discriminant_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
Returns the type of the discriminant of this type.
Sourcepub fn async_destructor_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
pub fn async_destructor_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
Returns the type of the async destructor of this type.
fn adt_async_destructor_ty<I>(self, tcx: TyCtxt<'tcx>, variants: I) -> Ty<'tcx>
fn surface_async_dropper_ty(self, tcx: TyCtxt<'tcx>) -> Option<Ty<'tcx>>
fn async_destructor_combinator( tcx: TyCtxt<'tcx>, lang_item: LangItem, ) -> EarlyBinder<'tcx, Ty<'tcx>>
Sourcepub fn ptr_metadata_ty_or_tail(
self,
tcx: TyCtxt<'tcx>,
normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
) -> Result<Ty<'tcx>, Ty<'tcx>>
pub fn ptr_metadata_ty_or_tail( self, tcx: TyCtxt<'tcx>, normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>, ) -> Result<Ty<'tcx>, Ty<'tcx>>
Returns the type of metadata for (potentially wide) pointers to this type, or the struct tail if the metadata type cannot be determined.
Sourcepub fn ptr_metadata_ty(
self,
tcx: TyCtxt<'tcx>,
normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>,
) -> Ty<'tcx>
pub fn ptr_metadata_ty( self, tcx: TyCtxt<'tcx>, normalize: impl FnMut(Ty<'tcx>) -> Ty<'tcx>, ) -> Ty<'tcx>
Returns the type of metadata for (potentially wide) pointers to this type. Causes an ICE if the metadata type cannot be determined.
Sourcepub fn pointee_metadata_ty_or_projection(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
pub fn pointee_metadata_ty_or_projection(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
Given a pointer or reference type, returns the type of the pointee’s
metadata. If it can’t be determined exactly (perhaps due to still
being generic) then a projection through ptr::Pointee
will be returned.
This is particularly useful for getting the type of the result of
UnOp::PtrMetadata
.
Panics if self
is not dereferencable.
Sourcepub fn to_opt_closure_kind(self) -> Option<ClosureKind>
pub fn to_opt_closure_kind(self) -> Option<ClosureKind>
When we create a closure, we record its kind (i.e., what trait
it implements, constrained by how it uses its borrows) into its
ty::ClosureArgs
or ty::CoroutineClosureArgs
using a type
parameter. This is kind of a phantom type, except that the
most convenient thing for us to are the integral types. This
function converts such a special type into the closure
kind. To go the other way, use Ty::from_closure_kind
.
Note that during type checking, we use an inference variable
to represent the closure kind, because it has not yet been
inferred. Once upvar inference (in rustc_hir_analysis/src/check/upvar.rs
)
is complete, that type variable will be unified with one of
the integral types.
if let TyKind::Closure(def_id, args) = closure_ty.kind()
&& let Some(closure_kind) = args.as_closure().kind_ty().to_opt_closure_kind()
{
println!("{closure_kind:?}");
} else if let TyKind::CoroutineClosure(def_id, args) = closure_ty.kind()
&& let Some(closure_kind) = args.as_coroutine_closure().kind_ty().to_opt_closure_kind()
{
println!("{closure_kind:?}");
}
After upvar analysis, you should instead use ty::ClosureArgs::kind()
or ty::CoroutineClosureArgs::kind()
to assert that the ClosureKind
has been constrained instead of manually calling this method.
if let TyKind::Closure(def_id, args) = closure_ty.kind()
{
println!("{:?}", args.as_closure().kind());
} else if let TyKind::CoroutineClosure(def_id, args) = closure_ty.kind()
{
println!("{:?}", args.as_coroutine_closure().kind());
}
Sourcepub fn from_closure_kind(tcx: TyCtxt<'tcx>, kind: ClosureKind) -> Ty<'tcx>
pub fn from_closure_kind(tcx: TyCtxt<'tcx>, kind: ClosureKind) -> Ty<'tcx>
Inverse of Ty::to_opt_closure_kind
. See docs on that method
for explanation of the relationship between Ty
and ty::ClosureKind
.
Sourcepub fn from_coroutine_closure_kind(
tcx: TyCtxt<'tcx>,
kind: ClosureKind,
) -> Ty<'tcx>
pub fn from_coroutine_closure_kind( tcx: TyCtxt<'tcx>, kind: ClosureKind, ) -> Ty<'tcx>
Like Ty::to_opt_closure_kind
, but it caps the “maximum” closure kind
to FnMut
. This is because although we have three capability states,
AsyncFn
/AsyncFnMut
/AsyncFnOnce
, we only need to distinguish two coroutine
bodies: by-ref and by-value.
See the definition of AsyncFn
and AsyncFnMut
and the CallRefFuture
associated type for why we don’t distinguish ty::ClosureKind::Fn
and
ty::ClosureKind::FnMut
for the purpose of the generated MIR bodies.
This method should be used when constructing a Coroutine
out of a
CoroutineClosure
, when the Coroutine
’s kind
field is being populated
directly from the CoroutineClosure
’s kind
.
Sourcepub fn is_trivially_sized(self, tcx: TyCtxt<'tcx>) -> bool
pub fn is_trivially_sized(self, tcx: TyCtxt<'tcx>) -> bool
Fast path helper for testing if a type is Sized
.
Returning true means the type is known to be sized. Returning
false
means nothing – could be sized, might not be.
Note that we could never rely on the fact that a type such as [_]
is
trivially !Sized
because we could be in a type environment with a
bound such as [_]: Copy
. A function with such a bound obviously never
can be called, but that doesn’t mean it shouldn’t typecheck. This is why
this method doesn’t return Option<bool>
.
Sourcepub fn is_trivially_pure_clone_copy(self) -> bool
pub fn is_trivially_pure_clone_copy(self) -> bool
Fast path helper for primitives which are always Copy
and which
have a side-effect-free Clone
impl.
Returning true means the type is known to be pure and Copy+Clone
.
Returning false
means nothing – could be Copy
, might not be.
This is mostly useful for optimizations, as these are the types on which we can replace cloning with dereferencing.
Sourcepub fn primitive_symbol(self) -> Option<Symbol>
pub fn primitive_symbol(self) -> Option<Symbol>
If self
is a primitive, return its Symbol
.
pub fn is_c_void(self, tcx: TyCtxt<'_>) -> bool
Sourcepub fn is_known_rigid(self) -> bool
pub fn is_known_rigid(self) -> bool
Returns true
when the outermost type cannot be further normalized,
resolved, or instantiated. This includes all primitive types, but also
things like ADTs and trait objects, since even if their arguments or
nested types may be further simplified, the outermost TyKind
or
type constructor remains the same.
Trait Implementations§
Source§impl<'tcx> Flags for Ty<'tcx>
impl<'tcx> Flags for Ty<'tcx>
fn flags(&self) -> TypeFlags
fn outer_exclusive_binder(&self) -> DebruijnIndex
Source§impl<'tcx> From<Ty<'tcx>> for GenericArg<'tcx>
impl<'tcx> From<Ty<'tcx>> for GenericArg<'tcx>
Source§fn from(ty: Ty<'tcx>) -> GenericArg<'tcx>
fn from(ty: Ty<'tcx>) -> GenericArg<'tcx>
Source§impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for Ty<'tcx>
impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for Ty<'tcx>
fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher, )
Source§impl IntoDiagArg for Ty<'_>
impl IntoDiagArg for Ty<'_>
fn into_diag_arg(self) -> DiagArgValue
Source§impl<'tcx> Key for Ty<'tcx>
impl<'tcx> Key for Ty<'tcx>
type Cache<V> = DefaultCache<Ty<'tcx>, V>
Source§fn default_span(&self, _: TyCtxt<'_>) -> Span
fn default_span(&self, _: TyCtxt<'_>) -> Span
self
, what span should we use?Source§fn def_id_for_ty_in_cycle(&self) -> Option<DefId>
fn def_id_for_ty_in_cycle(&self) -> Option<DefId>
Source§impl<'tcx> Relate<TyCtxt<'tcx>> for Ty<'tcx>
impl<'tcx> Relate<TyCtxt<'tcx>> for Ty<'tcx>
fn relate<R: TypeRelation<TyCtxt<'tcx>>>( relation: &mut R, a: Ty<'tcx>, b: Ty<'tcx>, ) -> RelateResult<'tcx, Ty<'tcx>>
Source§impl<'tcx> Ty<TyCtxt<'tcx>> for Ty<'tcx>
impl<'tcx> Ty<TyCtxt<'tcx>> for Ty<'tcx>
fn new_bool(tcx: TyCtxt<'tcx>) -> Self
fn new_u8(tcx: TyCtxt<'tcx>) -> Self
fn new_infer(tcx: TyCtxt<'tcx>, infer: InferTy) -> Self
fn new_var(tcx: TyCtxt<'tcx>, vid: TyVid) -> Self
fn new_param(tcx: TyCtxt<'tcx>, param: ParamTy) -> Self
fn new_placeholder(tcx: TyCtxt<'tcx>, placeholder: PlaceholderType) -> Self
fn new_bound( interner: TyCtxt<'tcx>, debruijn: DebruijnIndex, var: BoundTy, ) -> Self
fn new_anon_bound( tcx: TyCtxt<'tcx>, debruijn: DebruijnIndex, var: BoundVar, ) -> Self
fn new_alias( interner: TyCtxt<'tcx>, kind: AliasTyKind, alias_ty: AliasTy<'tcx>, ) -> Self
fn new_error(interner: TyCtxt<'tcx>, guar: ErrorGuaranteed) -> Self
fn new_adt( interner: TyCtxt<'tcx>, adt_def: AdtDef<'tcx>, args: GenericArgsRef<'tcx>, ) -> Self
fn new_foreign(interner: TyCtxt<'tcx>, def_id: DefId) -> Self
fn new_dynamic( interner: TyCtxt<'tcx>, preds: &'tcx List<PolyExistentialPredicate<'tcx>>, region: Region<'tcx>, kind: DynKind, ) -> Self
fn new_coroutine( interner: TyCtxt<'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>, ) -> Self
fn new_coroutine_closure( interner: TyCtxt<'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>, ) -> Self
fn new_closure( interner: TyCtxt<'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>, ) -> Self
fn new_coroutine_witness( interner: TyCtxt<'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>, ) -> Self
fn new_ptr(interner: TyCtxt<'tcx>, ty: Self, mutbl: Mutability) -> Self
fn new_ref( interner: TyCtxt<'tcx>, region: Region<'tcx>, ty: Self, mutbl: Mutability, ) -> Self
fn new_array_with_const_len( interner: TyCtxt<'tcx>, ty: Self, len: Const<'tcx>, ) -> Self
fn new_slice(interner: TyCtxt<'tcx>, ty: Self) -> Self
fn new_tup(interner: TyCtxt<'tcx>, tys: &[Ty<'tcx>]) -> Self
fn new_tup_from_iter<It, T>(interner: TyCtxt<'tcx>, iter: It) -> T::Outputwhere
It: Iterator<Item = T>,
T: CollectAndApply<Self, Self>,
fn tuple_fields(self) -> &'tcx List<Ty<'tcx>>
fn to_opt_closure_kind(self) -> Option<ClosureKind>
fn from_closure_kind(interner: TyCtxt<'tcx>, kind: ClosureKind) -> Self
fn from_coroutine_closure_kind( interner: TyCtxt<'tcx>, kind: ClosureKind, ) -> Self
fn new_fn_def( interner: TyCtxt<'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>, ) -> Self
fn new_fn_ptr(interner: TyCtxt<'tcx>, sig: Binder<'tcx, FnSig<'tcx>>) -> Self
fn new_pat(interner: TyCtxt<'tcx>, ty: Self, pat: Pattern<'tcx>) -> Self
fn new_unit(interner: TyCtxt<'tcx>) -> Self
fn new_usize(interner: TyCtxt<'tcx>) -> Self
fn discriminant_ty(self, interner: TyCtxt<'tcx>) -> Ty<'tcx>
fn async_destructor_ty(self, interner: TyCtxt<'tcx>) -> Ty<'tcx>
Source§fn has_unsafe_fields(self) -> bool
fn has_unsafe_fields(self) -> bool
fn new_projection_from_args( interner: I, def_id: <I as Interner>::DefId, args: <I as Interner>::GenericArgs, ) -> Self
fn new_projection(
interner: I,
def_id: <I as Interner>::DefId,
args: impl IntoIterator- >,
) -> Self
fn is_ty_var(self) -> bool
fn is_floating_point(self) -> bool
fn is_integral(self) -> bool
fn is_fn_ptr(self) -> bool
fn fn_sig(self, interner: I) -> Binder<I, FnSig<I>>
Source§fn is_known_rigid(self) -> bool
fn is_known_rigid(self) -> bool
true
when the outermost type cannot be further normalized,
resolved, or instantiated. This includes all primitive types, but also
things like ADTs and trait objects, since even if their arguments or
nested types may be further simplified, the outermost ty::TyKind
or
type constructor remains the same.Source§impl<'tcx, C> TyAbiInterface<'tcx, C> for Ty<'tcx>where
C: HasTyCtxt<'tcx> + HasTypingEnv<'tcx>,
impl<'tcx, C> TyAbiInterface<'tcx, C> for Ty<'tcx>where
C: HasTyCtxt<'tcx> + HasTypingEnv<'tcx>,
Source§fn ty_and_layout_pointee_info_at(
this: TyAndLayout<'tcx>,
cx: &C,
offset: Size,
) -> Option<PointeeInfo>
fn ty_and_layout_pointee_info_at( this: TyAndLayout<'tcx>, cx: &C, offset: Size, ) -> Option<PointeeInfo>
Compute the information for the pointer stored at the given offset inside this type. This will recurse into fields of ADTs to find the inner pointer.
fn ty_and_layout_for_variant( this: TyAndLayout<'tcx>, cx: &C, variant_index: VariantIdx, ) -> TyAndLayout<'tcx>
fn ty_and_layout_field( this: TyAndLayout<'tcx>, cx: &C, i: usize, ) -> TyAndLayout<'tcx>
fn is_adt(this: TyAndLayout<'tcx>) -> bool
fn is_never(this: TyAndLayout<'tcx>) -> bool
fn is_tuple(this: TyAndLayout<'tcx>) -> bool
fn is_unit(this: TyAndLayout<'tcx>) -> bool
fn is_transparent(this: TyAndLayout<'tcx>) -> bool
Source§impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Ty<'tcx>
impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Ty<'tcx>
Source§fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
self,
folder: &mut F,
) -> Result<Self, F::Error>
fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, folder: &mut F, ) -> Result<Self, F::Error>
Source§fn fold_with<F>(self, folder: &mut F) -> Selfwhere
F: TypeFolder<I>,
fn fold_with<F>(self, folder: &mut F) -> Selfwhere
F: TypeFolder<I>,
try_fold_with
for use with infallible
folders. Do not override this method, to ensure coherence with
try_fold_with
.Source§impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx>
impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx>
Source§fn try_super_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
self,
folder: &mut F,
) -> Result<Self, F::Error>
fn try_super_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, folder: &mut F, ) -> Result<Self, F::Error>
TypeFolder
methods, when a non-custom traversal
is desired for the value of the type of interest passed to that method.
For example, in MyFolder::try_fold_ty(ty)
, it is valid to call
ty.try_super_fold_with(self)
, but any other folding should be done
with xyz.try_fold_with(self)
.Source§fn super_fold_with<F>(self, folder: &mut F) -> Selfwhere
F: TypeFolder<I>,
fn super_fold_with<F>(self, folder: &mut F) -> Selfwhere
F: TypeFolder<I>,
try_super_fold_with
for use with
infallible folders. Do not override this method, to ensure coherence
with try_super_fold_with
.Source§impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx>
impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx>
Source§fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(
&self,
visitor: &mut V,
) -> V::Result
fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>( &self, visitor: &mut V, ) -> V::Result
TypeVisitor
methods, when a non-custom
traversal is desired for the value of the type of interest passed to
that method. For example, in MyVisitor::visit_ty(ty)
, it is valid to
call ty.super_visit_with(self)
, but any other visiting should be done
with xyz.visit_with(self)
.Source§impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Ty<'tcx>
impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Ty<'tcx>
Source§fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result
fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result
Source§impl<'tcx> Value<TyCtxt<'tcx>> for Ty<'_>
impl<'tcx> Value<TyCtxt<'tcx>> for Ty<'_>
fn from_cycle_error( tcx: TyCtxt<'tcx>, _: &CycleError, guar: ErrorGuaranteed, ) -> Self
impl<'tcx> Copy for Ty<'tcx>
impl<'tcx> Eq for Ty<'tcx>
impl<'tcx> StructuralPartialEq for Ty<'tcx>
Auto Trait Implementations§
impl<'tcx> DynSend for Ty<'tcx>
impl<'tcx> DynSync for Ty<'tcx>
impl<'tcx> Freeze for Ty<'tcx>
impl<'tcx> !RefUnwindSafe for Ty<'tcx>
impl<'tcx> Send for Ty<'tcx>
impl<'tcx> Sync for Ty<'tcx>
impl<'tcx> Unpin for Ty<'tcx>
impl<'tcx> !UnwindSafe for Ty<'tcx>
Blanket Implementations§
Source§impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
fn allocate_on(self, arena: &'tcx Arena<'tcx>) -> &'tcx mut T
fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = T>, ) -> &'tcx mut [T]
Source§impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere
T: Copy,
fn allocate_on(self, arena: &'tcx Arena<'tcx>) -> &'tcx mut T
fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = T>, ) -> &'tcx mut [T]
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
Source§impl<Tcx, T> DepNodeParams<Tcx> for T
impl<Tcx, T> DepNodeParams<Tcx> for T
default fn fingerprint_style() -> FingerprintStyle
Source§default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint
default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint
default fn to_debug_str(&self, _: Tcx) -> String
Source§default fn recover(_: Tcx, _: &DepNode) -> Option<T>
default fn recover(_: Tcx, _: &DepNode) -> Option<T>
DepNode
,
something which is needed when forcing DepNode
s during red-green
evaluation. The query system will only call this method if
fingerprint_style()
is not FingerprintStyle::Opaque
.
It is always valid to return None
here, in which case incremental
compilation will treat the query as having changed instead of forcing it.Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.Source§impl<T> Filterable for T
impl<T> Filterable for T
Source§fn filterable(
self,
filter_name: &'static str,
) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
Source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moreSource§impl<P> IntoQueryParam<P> for P
impl<P> IntoQueryParam<P> for P
fn into_query_param(self) -> P
Source§impl<'tcx, T> IsSuggestable<'tcx> for T
impl<'tcx, T> IsSuggestable<'tcx> for T
Source§impl<T> MaybeResult<T> for T
impl<T> MaybeResult<T> for T
Source§impl<T> Pointable for T
impl<T> Pointable for T
Source§impl<I, T> TypeVisitableExt<I> for Twhere
I: Interner,
T: TypeVisitable<I>,
impl<I, T> TypeVisitableExt<I> for Twhere
I: Interner,
T: TypeVisitable<I>,
fn has_type_flags(&self, flags: TypeFlags) -> bool
Source§fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool
fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool
true
if self
has any late-bound regions that are either
bound by binder
or bound by some binder outside of binder
.
If binder
is ty::INNERMOST
, this indicates whether
there are any late-bound regions that appear free.fn error_reported(&self) -> Result<(), <I as Interner>::ErrorGuaranteed>
Source§fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool
fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool
true
if this type has any regions that escape binder
(and
hence are not bound by it).Source§fn has_escaping_bound_vars(&self) -> bool
fn has_escaping_bound_vars(&self) -> bool
true
if this type has regions that are not a part of the type.
For example, for<'a> fn(&'a i32)
return false
, while fn(&'a i32)
would return true
. The latter can occur when traversing through the
former. Read morefn has_aliases(&self) -> bool
fn has_opaque_types(&self) -> bool
fn has_coroutines(&self) -> bool
fn references_error(&self) -> bool
fn has_non_region_param(&self) -> bool
fn has_infer_regions(&self) -> bool
fn has_infer_types(&self) -> bool
fn has_non_region_infer(&self) -> bool
fn has_infer(&self) -> bool
fn has_placeholders(&self) -> bool
fn has_non_region_placeholders(&self) -> bool
fn has_param(&self) -> bool
Source§fn has_free_regions(&self) -> bool
fn has_free_regions(&self) -> bool
fn has_erased_regions(&self) -> bool
Source§fn has_erasable_regions(&self) -> bool
fn has_erasable_regions(&self) -> bool
Source§fn is_global(&self) -> bool
fn is_global(&self) -> bool
Source§fn has_bound_regions(&self) -> bool
fn has_bound_regions(&self) -> bool
Source§fn has_non_region_bound_vars(&self) -> bool
fn has_non_region_bound_vars(&self) -> bool
Source§fn has_bound_vars(&self) -> bool
fn has_bound_vars(&self) -> bool
Source§fn still_further_specializable(&self) -> bool
fn still_further_specializable(&self) -> bool
impl
specialization.Source§impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
Source§impl<I, T> UpcastFrom<I, T> for T
impl<I, T> UpcastFrom<I, T> for T
fn upcast_from(from: T, _tcx: I) -> T
Source§impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T
Source§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
Source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
Source§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
impl<T> ErasedDestructor for Twhere
T: 'static,
impl<T> MaybeSendSync for T
Layout§
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.
Size: 8 bytes