Struct FnSigKind 

pub struct FnSigKind<I>
where
    I: Interner,
{
    flags: u8,
    splatted: u8,
    _marker: PhantomData<fn() -> I>,
}

Contains the packed non-type fields of a function signature.

Fields

flags: u8

splatted: u8

_marker: PhantomData<fn() -> I>

Implementations

impl<I> FnSigKind<I>

where I: Interner,

pub const NO_SPLATTED_ARG_INDEX: u8 = u8::MAX

The marker index for “no splatted arguments”. Higher values are also not supported, for performance reasons.

Must have the same value as FnDeclFlags::NO_SPLATTED_ARG_INDEX and rustc_ast::FnDecl::NO_SPLATTED_ARG_INDEX.

This is an implementation detail, which should only be used in low-level encoding.

pub fn new( abi: ExternAbi, safety: <I as Interner>::Safety, c_variadic: bool, splatted: Option<u8>, args_len: usize, ) -> Result<FnSigKind<I>, SplattedArgIndexError>

Create a new FnSigKind with the given ABI, safety, C-style variadic, and splatted argument index.

pub fn dummy() -> FnSigKind<I>

Create a new safe FnSigKind with the extern "Rust" ABI, that isn’t C-style variadic or splatted.

pub fn set_abi(self, abi: ExternAbi) -> FnSigKind<I>

Set the ABI, including the unwind flag.

pub fn set_safety(self, safety: <I as Interner>::Safety) -> FnSigKind<I>

Set the safety flag, true is Safe.

pub fn set_c_variadic(self, c_variadic: bool) -> FnSigKind<I>

Set the C-style variadic argument flag.

pub fn set_splatted( self, splatted: Option<u8>, args_len: usize, ) -> Result<FnSigKind<I>, SplattedArgIndexError>

Set the splatted argument index. The number of function arguments is used for error checking.

pub fn set_no_splatted_args(self) -> FnSigKind<I>

Set the splatted argument index to “no splatted arguments”.

pub fn abi(self) -> ExternAbi

Get the ABI, including the unwind flag.

pub fn is_safe(self) -> bool

Get the safety flag.

pub fn safety(self) -> <I as Interner>::Safety

Returns the safety mode.

pub fn c_variadic(self) -> bool

Do the function arguments end with a C-style variadic argument?

pub fn splatted(self) -> Option<u8>

Get the index of the splatted argument, if any.

Trait Implementations

impl<I> Clone for FnSigKind<I>

where I: Interner,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Copy for FnSigKind<I>

where I: Interner,

impl<I> Debug for FnSigKind<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 FnSigKind<I>

where I: Interner, __D: Decoder, PhantomData<fn() -> I>: Decodable<__D>,

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

impl<I> Default for FnSigKind<I>

where I: Interner,

fn default() -> FnSigKind<I>

Create a new FnSigKind with the “Rust” ABI, “Unsafe” safety, and no C-style variadic or splatted arguments. To modify these flags, use the set_* methods, for readability.

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

where I: Interner, __E: Encoder, PhantomData<fn() -> I>: Encodable<__E>,

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

impl<I> Eq for FnSigKind<I>

where I: Interner,

impl<I> Hash for FnSigKind<I>

where I: Interner,

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

where __H: 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, J> Lift<J> for FnSigKind<I>

where I: Interner + LiftInto<J>, J: Interner,

type Lifted = FnSigKind<J>

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

impl<I> PartialEq for FnSigKind<I>

where I: Interner,

fn eq(&self, __other: &FnSigKind<I>) -> 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<I> StableHash for FnSigKind<I>

where I: Interner, PhantomData<fn() -> I>: StableHash,

fn stable_hash<__Hcx>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher<SipHasher128>, )

where __Hcx: StableHashCtxt,

impl<I> TypeFoldable<I> for FnSigKind<I>

where I: Interner,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<FnSigKind<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) -> FnSigKind<I>

where __F: TypeFolder<I>,

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

impl<I> TypeVisitable<I> for FnSigKind<I>

where I: Interner,

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

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: 2 bytes