Enum BaseTy

pub enum BaseTy {
    Int(IntTy),
    Uint(UintTy),
    Bool,
    Str,
    Char,
    Slice(Ty),
    Adt(AdtDef, GenericArgs),
    Float(FloatTy),
    RawPtr(Ty, Mutability),
    Ref(Region, Ty, Mutability),
    FnPtr(PolyFnSig),
    FnDef(DefId, GenericArgs),
    Tuple(List<Ty>),
    Alias(AliasKind, AliasTy),
    Array(Ty, Const),
    Never,
    Closure(DefId, List<Ty>, GenericArgs),
    Coroutine(DefId, Ty, List<Ty>),
    Dynamic(List<Binder<ExistentialPredicate>>, Region),
    Param(ParamTy),
    Infer(TyVid),
}

Variants

Int(IntTy)

Uint(UintTy)

Bool

Str

Char

Slice(Ty)

Adt(AdtDef, GenericArgs)

Float(FloatTy)

RawPtr(Ty, Mutability)

Ref(Region, Ty, Mutability)

FnPtr(PolyFnSig)

FnDef(DefId, GenericArgs)

Tuple(List<Ty>)

Alias(AliasKind, AliasTy)

Array(Ty, Const)

Never

Closure(DefId, List<Ty>, GenericArgs)

Coroutine(DefId, Ty, List<Ty>)

Dynamic(List<Binder<ExistentialPredicate>>, Region)

Param(ParamTy)

Infer(TyVid)

Implementations

impl BaseTy

pub fn opaque(alias_ty: AliasTy) -> BaseTy

pub fn projection(alias_ty: AliasTy) -> BaseTy

pub fn adt(adt_def: AdtDef, args: impl Into<GenericArgs>) -> BaseTy

pub fn fn_def(def_id: DefId, args: impl Into<GenericArgs>) -> BaseTy

pub fn from_primitive_str(s: &str) -> Option<BaseTy>

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

If self is a primitive, return its Symbol.

pub fn is_integral(&self) -> bool

pub fn is_numeric(&self) -> bool

pub fn is_signed(&self) -> bool

pub fn is_unsigned(&self) -> bool

pub fn is_float(&self) -> bool

pub fn is_bool(&self) -> bool

fn is_struct(&self) -> bool

fn is_array(&self) -> bool

fn is_slice(&self) -> bool

fn is_adt(&self) -> bool

pub fn is_box(&self) -> bool

pub fn is_char(&self) -> bool

pub fn is_str(&self) -> bool

pub fn unpack_box(&self) -> Option<(&Ty, &Ty)>

pub fn invariants(&self, overflow_checking: bool) -> &[Invariant]

pub fn to_ty(&self) -> Ty

pub fn to_subset_ty_ctor(&self) -> SubsetTyCtor

pub fn expect_adt(&self) -> (&AdtDef, &[GenericArg])

impl BaseTy

pub fn sort(&self) -> Sort

Trait Implementations

impl Clone for BaseTy

fn clone(&self) -> BaseTy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BaseTy

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

Formats the value using the given formatter.

impl<__D: TyDecoder> Decodable<__D> for BaseTy

fn decode(__decoder: &mut __D) -> Self

impl<__E: TyEncoder> Encodable<__E> for BaseTy

fn encode(&self, __encoder: &mut __E)

impl Hash for BaseTy

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 PartialEq for BaseTy

fn eq(&self, other: &BaseTy) -> 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 Pretty for BaseTy

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

fn default_cx(tcx: TyCtxt<'_>) -> PrettyCx<'_>

impl<'tcx> ToRustc<'tcx> for BaseTy

type T = Ty<'tcx>

fn to_rustc(&self, tcx: TyCtxt<'tcx>) -> Self::T

impl TypeFoldable for BaseTy

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

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

fn normalize_projections<'tcx>( &self, genv: GlobalEnv<'_, 'tcx>, infcx: &InferCtxt<'tcx>, callsite_def_id: DefId, ) -> QueryResult<Self>

fn normalize(&self, defns: &SpecFuncDefns) -> Self

Normalize expressions by applying beta reductions for tuples and lambda abstractions.

fn replace_holes( &self, f: impl FnMut(&[BoundVariableKinds], HoleKind) -> Expr, ) -> Self

Replaces all holes with the result of calling a closure. The closure takes a list with all the layers of bound variables at the point the hole was found. Each layer corresponds to the list of bound variables at that level. The list is ordered from outermost to innermost binder, i.e., the last element is the binder closest to the hole.

fn with_holes(&self) -> Self

Remove all refinements and turn each underlying BaseTy into a TyKind::Exists with a TyKind::Constr and a hole. For example, Vec<{v. i32[v] | v > 0}>[n] becomes {n. Vec<{v. i32[v] | *}>[n] | *}.

fn replace_evars(&self, evars: &EVarSol) -> Self

fn shift_in_escaping(&self, amount: u32) -> Self

fn shift_out_escaping(&self, amount: u32) -> Self

fn erase_regions(&self) -> Self

impl TypeSuperFoldable for BaseTy

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

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

impl TypeSuperVisitable for BaseTy

fn super_visit_with<V: TypeVisitor>( &self, visitor: &mut V, ) -> ControlFlow<V::BreakTy>

impl TypeVisitable for BaseTy

fn visit_with<V: TypeVisitor>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy>

fn has_escaping_bvars(&self) -> bool

fn has_escaping_bvars_at_or_above(&self, binder: DebruijnIndex) -> bool

Returns true if self has any late-bound vars 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 vars that appear free.

fn fvars(&self) -> FxHashSet<Name>

Returns the set of all free variables. For example, Vec<i32[n]>{v : v > m} returns {n, m}.

impl Eq for BaseTy

impl StructuralPartialEq for BaseTy