Struct rustc_middle::ty::Ty

pub struct Ty<'tcx>(Interned<'tcx, WithCachedTypeInfo<TyKind<'tcx>>>);

Use this rather than TyKind, whenever possible.

Tuple Fields

0: Interned<'tcx, WithCachedTypeInfo<TyKind<'tcx>>>

Implementations

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>

impl<'tcx> Ty<'tcx>

pub fn inhabited_predicate(self, tcx: TyCtxt<'tcx>) -> InhabitedPredicate<'tcx>

pub fn is_inhabited_from( self, tcx: TyCtxt<'tcx>, module: DefId, param_env: ParamEnv<'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.

pub fn is_privately_uninhabited( self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ) -> bool

Returns true if the type is uninhabited without regard to visibility

impl<'tcx> Ty<'tcx>

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)

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 chars) or returns None if the type is not numeric.

pub fn numeric_max_val(self, tcx: TyCtxt<'tcx>) -> Option<Const<'tcx>>

Returns the maximum value for the given numeric type (including chars) or returns None if the type is not numeric.

pub fn numeric_min_val(self, tcx: TyCtxt<'tcx>) -> Option<Const<'tcx>>

Returns the minimum value for the given numeric type (including chars) or returns None if the type is not numeric.

pub fn is_copy_modulo_regions( self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ) -> bool

Checks whether values of this type T are moved or copied when referenced – this amounts to a check for whether T: Copy, but note that we don’t consider lifetimes when doing this check. This means that we may generate MIR which does copies even when the type actually doesn’t satisfy the full requirements for the Copy trait (cc #29149) – this winds up being reported as an error during NLL borrow check.

pub fn is_sized(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'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.

pub fn is_freeze(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'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.

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.

pub fn is_unpin(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>) -> bool

Checks whether values of this type T implement the Unpin trait.

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.

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.

pub fn needs_drop(self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'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.

pub fn needs_async_drop( self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'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.

pub fn has_significant_drop( self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'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.

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.

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

impl<'tcx> Ty<'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 }

impl<'tcx> Ty<'tcx>

pub fn is_primitive_ty(self) -> bool

Similar to Ty::is_primitive, but also considers inferred numeric values to be primitive.

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.

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.

impl<'tcx> Ty<'tcx>

Constructors for Ty

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>

pub fn new_error(tcx: TyCtxt<'tcx>, guar: ErrorGuaranteed) -> Ty<'tcx>

Constructs a TyKind::Error type with current ErrorGuaranteed

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.

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_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

where I: Iterator<Item = T>, T: CollectAndApply<Ty<'tcx>, Ty<'tcx>>,

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>

pub fn new_task_context(tcx: TyCtxt<'tcx>) -> Ty<'tcx>

Creates a &mut Context<'_> Ty with erased lifetimes.

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_str(self) -> bool

Returns true if this type is a str.

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

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

pub fn is_any_ptr(self) -> bool

Tests if this is any kind of primitive pointer type (reference, raw pointer, fn pointer).

pub fn is_box(self) -> 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) -> Ty<'tcx>

Panics if called on any type other than Box<T>.

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.)

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

pub fn contains(self, other: Ty<'tcx>) -> bool

Checks whether a type recursively contains another type

Example: Option<()> contains ()

pub fn contains_closure(self) -> bool

Checks whether a type recursively contains any closure

Example: Option<{closure@file.rs:4:20}> returns true

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.

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>>

pub fn tuple_fields(self) -> &'tcx List<Ty<'tcx>>

Iterates over tuple fields. Panics when called on anything but a tuple.

pub fn variant_range(self, tcx: TyCtxt<'tcx>) -> Option<Range<VariantIdx>>

If the type contains variants, returns the valid range of variant indices.

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.

pub fn discriminant_ty(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx>

Returns the type of the discriminant of this type.

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>

where I: Iterator + ExactSizeIterator, I::Item: IntoIterator<Item = 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>>

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 fat) pointers to this type, or the struct tail if the metadata type cannot be determined.

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 fat) pointers to this type. Causes an ICE if the metadata type cannot be determined.

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.

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());
}

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.

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.

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>.

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.

pub fn primitive_symbol(self) -> Option<Symbol>

If self is a primitive, return its Symbol.

pub fn is_c_void(self, tcx: TyCtxt<'_>) -> 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, sice even if their arguments or nested types may be further simplified, the outermost TyKind or type constructor remains the same.

Trait Implementations

impl<'tcx> Clone for Ty<'tcx>

fn clone(&self) -> Ty<'tcx>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tcx> Debug for Ty<'tcx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for Ty<'tcx>

fn decode(decoder: &mut D) -> Ty<'tcx>

impl<'tcx> Display for Ty<'tcx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<E> for Ty<'tcx>

fn encode(&self, e: &mut E)

impl<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>> EncodableWithShorthand<E> for Ty<'tcx>

type Variant = TyKind<TyCtxt<'tcx>>

fn variant(&self) -> &Self::Variant

impl<'tcx> EraseType for Ty<'tcx>

type Result = [u8; 8]

impl<'tcx> Flags for Ty<'tcx>

fn flags(&self) -> TypeFlags

fn outer_exclusive_binder(&self) -> DebruijnIndex

impl<'tcx> From<Ty<'tcx>> for GenericArg<'tcx>

fn from(ty: Ty<'tcx>) -> GenericArg<'tcx>

Converts to this type from the input type.

impl<'tcx> From<Ty<'tcx>> for Term<'tcx>

fn from(ty: Ty<'tcx>) -> Self

Converts to this type from the input type.

impl<'tcx> Hash for Ty<'tcx>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for Ty<'tcx>

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher, )

impl IntoDiagArg for Ty<'_>

fn into_diag_arg(self) -> DiagArgValue

impl<'tcx> IntoKind for Ty<'tcx>

type Kind = TyKind<TyCtxt<'tcx>>

fn kind(self) -> TyKind<'tcx>

impl<'tcx> Key for Ty<'tcx>

type Cache<V> = DefaultCache<Ty<'tcx>, V>

fn default_span(&self, _: TyCtxt<'_>) -> Span

In the event that a cycle occurs, if no explicit span has been given for a query with key self, what span should we use?

fn ty_def_id(&self) -> Option<DefId>

fn key_as_def_id(&self) -> Option<DefId>

If the key is a DefId or DefId–equivalent, return that DefId. Otherwise, return None.

impl<'a, 'tcx> Lift<TyCtxt<'tcx>> for Ty<'a>

type Lifted = Ty<'tcx>

fn lift_to_interner(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl ParameterizedOverTcx for Ty<'static>

type Value<'tcx> = Ty<'tcx>

impl<'tcx> PartialEq for Ty<'tcx>

fn eq(&self, other: &Ty<'tcx>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for Ty<'tcx>

fn print(&self, cx: &mut P) -> Result<(), PrintError>

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>>

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::Output

where 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>

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

where <impl IntoIterator as IntoIterator>::Item: Into<<I as Interner>::GenericArg>,

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>>

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, sice even if their arguments or nested types may be further simplified, the outermost ty::TyKind or type constructor remains the same.

impl<'tcx, C> TyAbiInterface<'tcx, C> for Ty<'tcx>

where C: HasTyCtxt<'tcx> + HasParamEnv<'tcx>,

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

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Ty<'tcx>

fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx>

fn try_super_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, folder: &mut F, ) -> Result<Self, F::Error>

Provides a default fold for a recursive type of interest. This should only be called within 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).

fn super_fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_super_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_super_fold_with.

impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx>

fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>( &self, visitor: &mut V, ) -> V::Result

Provides a default visit for a recursive type of interest. This should only be called within 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).

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Ty<'tcx>

fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

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>

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