Struct rustc_trait_selection::infer::canonical::ir::FnSig

pub struct FnSig<I>
where
    I: Interner,
{
    pub inputs_and_output: <I as Interner>::Tys,
    pub c_variadic: bool,
    pub safety: <I as Interner>::Safety,
    pub abi: <I as Interner>::Abi,
}

Fields

inputs_and_output: <I as Interner>::Tys

c_variadic: bool

safety: <I as Interner>::Safety

abi: <I as Interner>::Abi

Implementations

impl<I> FnSig<I>

where I: Interner,

pub fn split_inputs_and_output( self, ) -> (<I as Interner>::FnInputTys, <I as Interner>::Ty)

pub fn inputs(self) -> <I as Interner>::FnInputTys

pub fn output(self) -> <I as Interner>::Ty

pub fn is_fn_trait_compatible(self) -> bool

Trait Implementations

impl<I> Clone for FnSig<I>

where I: Interner,

fn clone(&self) -> FnSig<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I> Debug for FnSig<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I, __D> Decodable<__D> for FnSig<I>

where I: Interner, __D: TyDecoder<I = I>, <I as Interner>::Tys: Decodable<__D>, <I as Interner>::Safety: Decodable<__D>, <I as Interner>::Abi: Decodable<__D>,

fn decode(__decoder: &mut __D) -> FnSig<I>

impl<I> Display for FnSig<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I, __E> Encodable<__E> for FnSig<I>

where I: Interner, __E: TyEncoder<I = I>, <I as Interner>::Tys: Encodable<__E>, <I as Interner>::Safety: Encodable<__E>, <I as Interner>::Abi: Encodable<__E>,

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

impl<'tcx> EraseType for FnSig<TyCtxt<'tcx>>

type Result = [u8; 16]

impl<I> Hash for FnSig<I>

where I: Interner,

fn hash<__HI>(&self, __state: &mut __HI)

where __HI: Hasher,

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<I, __CTX> HashStable<__CTX> for FnSig<I>

where I: Interner, <I as Interner>::Tys: HashStable<__CTX>, <I as Interner>::Safety: HashStable<__CTX>, <I as Interner>::Abi: HashStable<__CTX>,

fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )

impl<I> IntoDiagArg for FnSig<I>

where I: Interner,

fn into_diag_arg(self) -> DiagArgValue

impl<I, J> Lift<J> for FnSig<I>

where J: Interner, <I as Interner>::Tys: Lift<J, Lifted = <J as Interner>::Tys>, bool: Lift<J, Lifted = bool>, <I as Interner>::Safety: Lift<J, Lifted = <J as Interner>::Safety>, I: Interner, <I as Interner>::Abi: Lift<J, Lifted = <J as Interner>::Abi>,

type Lifted = FnSig<J>

fn lift_to_interner(self, interner: J) -> Option<FnSig<J>>

impl ParameterizedOverTcx for FnSig<TyCtxt<'static>>

type Value<'tcx> = FnSig<TyCtxt<'tcx>>

impl<I> PartialEq for FnSig<I>

where I: Interner,

fn eq(&self, other: &FnSig<I>) -> bool

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

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

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

impl<'tcx, P> Print<'tcx, P> for FnSig<TyCtxt<'tcx>>

where P: PrettyPrinter<'tcx>,

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

impl<I> Relate<I> for FnSig<I>

where I: Interner,

fn relate<R>( relation: &mut R, a: FnSig<I>, b: FnSig<I>, ) -> Result<FnSig<I>, TypeError<I>>

where R: TypeRelation<I>,

impl<'tcx> ToTrace<'tcx> for FnSig<TyCtxt<'tcx>>

fn to_trace( cause: &ObligationCause<'tcx>, a_is_expected: bool, a: FnSig<TyCtxt<'tcx>>, b: FnSig<TyCtxt<'tcx>>, ) -> TypeTrace<'tcx>

impl<I> TypeFoldable<I> for FnSig<I>

where I: Interner, <I as Interner>::Tys: TypeFoldable<I>, <I as Interner>::Safety: TypeFoldable<I>, <I as Interner>::Abi: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<FnSig<I>, <__F as FallibleTypeFolder<I>>::Error>

where __F: FallibleTypeFolder<I>,

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<I> TypeVisitable<I> for FnSig<I>

where I: Interner, <I as Interner>::Tys: TypeVisitable<I>, <I as Interner>::Safety: TypeVisitable<I>, <I as Interner>::Abi: TypeVisitable<I>,

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<I>>::Result

where __V: TypeVisitor<I>,

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

impl<I> Copy for FnSig<I>

where I: Interner,

impl<I> Eq for FnSig<I>

where I: Interner,

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.