Struct rustc::ty::TyS [−] [src]

pub struct TyS<'tcx> {
    pub sty: TypeVariants<'tcx>,
    pub flags: Cell<TypeFlags>,
    // some fields omitted
}
Unstable (rustc_private)

Fields

sty: TypeVariants<'tcx>
Unstable (rustc_private)
flags: Cell<TypeFlags>
Unstable (rustc_private)

Methods

impl<'a, 'gcx, 'tcx> TyS<'tcx>
[src]

fn adjust<F>(&'tcx self, tcx: TyCtxt<'a, 'gcx, 'tcx>, span: Span, expr_id: NodeId, adjustment: Option<&AutoAdjustment<'tcx>>, method_type: F) -> Ty<'tcx> where F: FnMut(MethodCall) -> Option<Ty<'tcx>>

Unstable (rustc_private)

See expr_ty_adjusted

fn adjust_for_autoderef<F>(&'tcx self, tcx: TyCtxt<'a, 'gcx, 'tcx>, expr_id: NodeId, expr_span: Span, autoderef: u32, method_type: F) -> Ty<'tcx> where F: FnMut(MethodCall) -> Option<Ty<'tcx>>

fn adjust_for_autoref(&'tcx self, tcx: TyCtxt<'a, 'gcx, 'tcx>, autoref: Option<AutoRef<'tcx>>) -> Ty<'tcx>

impl<'a, 'tcx> TyS<'tcx>
[src]

fn moves_by_default(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>, param_env: &ParameterEnvironment<'tcx>, span: Span) -> bool

fn is_sized(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>, param_env: &ParameterEnvironment<'tcx>, span: Span) -> bool

fn layout<'lcx>(&'tcx self, infcx: &InferCtxt<'a, 'tcx, 'lcx>) -> Result<&'tcx Layout, LayoutError<'tcx>>

fn is_representable(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>, sp: Span) -> Representability

Unstable (rustc_private)

Check whether a type is representable. This means it cannot contain unboxed structural recursion. This check is needed for structs and enums.

impl<'a, 'tcx> TyS<'tcx>
[src]

fn type_contents(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> TypeContents

impl<'a, 'gcx, 'tcx> TyS<'tcx>
[src]

fn as_opt_param_ty(&self) -> Option<ParamTy>

fn is_nil(&self) -> bool

fn is_empty(&self, _cx: TyCtxt) -> bool

fn is_primitive(&self) -> bool

fn is_ty_var(&self) -> bool

fn is_phantom_data(&self) -> bool

fn is_bool(&self) -> bool

fn is_param(&self, space: ParamSpace, index: u32) -> bool

fn is_self(&self) -> bool

fn is_slice(&self) -> bool

fn is_structural(&self) -> bool

fn is_simd(&self) -> bool

fn sequence_element_type(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx>

fn simd_type(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx>

fn simd_size(&self, _cx: TyCtxt) -> usize

fn is_region_ptr(&self) -> bool

fn is_unsafe_ptr(&self) -> bool

fn is_unique(&self) -> bool

fn is_scalar(&self) -> bool

fn is_floating_point(&self) -> bool

Unstable (rustc_private)

Returns true if this type is a floating point type and false otherwise.

fn is_trait(&self) -> bool

fn is_integral(&self) -> bool

fn is_fresh(&self) -> bool

fn is_uint(&self) -> bool

fn is_char(&self) -> bool

fn is_fp(&self) -> bool

fn is_numeric(&self) -> bool

fn is_signed(&self) -> bool

fn is_machine(&self) -> bool

fn has_concrete_skeleton(&self) -> bool

fn builtin_deref(&self, explicit: bool, pref: LvaluePreference) -> Option<TypeAndMut<'tcx>>

fn builtin_index(&self) -> Option<Ty<'tcx>>

fn fn_sig(&self) -> &'tcx PolyFnSig<'tcx>

fn fn_abi(&self) -> Abi

Unstable (rustc_private)

Returns the ABI of the given function.

fn fn_args(&self) -> Binder<Vec<Ty<'tcx>>>

fn fn_ret(&self) -> Binder<FnOutput<'tcx>>

fn is_fn(&self) -> bool

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

fn ty_adt_def(&self) -> Option<AdtDef<'tcx>>

fn regions(&self) -> Vec<Region>

Unstable (rustc_private)

Returns the regions directly referenced from this type (but not types reachable from this type via walk_tys). This ignores late-bound regions binders.

impl<'tcx> TyS<'tcx>
[src]

fn walk(&'tcx self) -> TypeWalker<'tcx>

Unstable (rustc_private)

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 }

fn walk_shallow(&'tcx self) -> IntoIter<Ty<'tcx>>

Unstable (rustc_private)

Iterator that walks the immediate children of self. Hence Foo<Bar<i32>, u32> yields the sequence [Bar<i32>, u32] (but not i32, like walk).

fn maybe_walk<F>(&'tcx self, f: F) where F: FnMut(Ty<'tcx>) -> bool

Unstable (rustc_private)

Walks ty and any types appearing within ty, invoking the callback f on each type. If the callback returns false, then the children of the current type are ignored.

Note: prefer ty.walk() where possible.

Trait Implementations

impl<'tcx> PartialEq for TyS<'tcx>
[src]

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

This method tests for self and other values to be equal, and is used by ==. Read more

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

This method tests for !=.

impl<'tcx> Eq for TyS<'tcx>
[src]

impl<'tcx> Hash for TyS<'tcx>
[src]

fn hash<H: Hasher>(&self, s: &mut H)

Feeds this value into the state given, updating the hasher as necessary.

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

Feeds a slice of this type into the state provided.

impl<'tcx> Debug for TyS<'tcx>
[src]

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

Formats the value using the given formatter.

impl<'tcx> Display for TyS<'tcx>
[src]

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

Formats the value using the given formatter.