Struct chalk_solve::rust_ir::FnDefDatum

pub struct FnDefDatum<I: Interner> {
    pub id: FnDefId<I>,
    pub sig: FnSig<I>,
    pub binders: Binders<FnDefDatumBound<I>>,
}

A rust intermediate representation (rust_ir) of a function definition/declaration. For example, in the following rust code:

fn foo<T>() -> i32 where T: Eq;

This would represent the declaration of foo.

Note this is distinct from a function pointer, which points to a function with a given type signature, whereas this represents a specific function definition.

Fields

id: FnDefId<I>

sig: FnSig<I>

binders: Binders<FnDefDatumBound<I>>

Trait Implementations

impl<I: Clone + Interner> Clone for FnDefDatum<I>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Interner> Debug for FnDefDatum<I>

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

Formats the value using the given formatter.

impl<I: Hash + Interner> Hash for FnDefDatum<I>

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<I: PartialEq + Interner> PartialEq for FnDefDatum<I>

fn eq(&self, other: &FnDefDatum<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<I: Interner> RenderAsRust<I> for FnDefDatum<I>

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

fn display<'a>( &'a self, s: &'a InternalWriterState<'a, I>, ) -> DisplayRenderAsRust<'a, I, Self>

where Self: Sized,

impl<I: Interner> ToProgramClauses<I> for FnDefDatum<I>

fn to_program_clauses( &self, builder: &mut ClauseBuilder<'_, I>, _environment: &Environment<I>, )

Given the following function definition: fn bar<T>() where T: Eq, generate:

-- Rule WellFormed-Type
forall<T> {
    WF(bar<T>) :- WF(T: Eq)
}

-- Rule Implied-Bound-From-Type
forall<T> {
    FromEnv(T: Eq) :- FromEnv(bar<T>).
}

forall<T> {
    IsFullyVisible(bar<T>) :- IsFullyVisible(T).
}

impl<I: Interner> TypeVisitable<I> for FnDefDatum<I>

Avoids visiting I::FnAbi

fn visit_with<B>( &self, visitor: &mut dyn TypeVisitor<I, BreakTy = B>, outer_binder: DebruijnIndex, ) -> ControlFlow<B>

Apply the given visitor visitor to self; binders is the number of binders that are in scope when beginning the visitor. Typically binders starts as 0, but is adjusted when we encounter Binders<T> in the IR or other similar constructs.

impl<I: Eq + Interner> Eq for FnDefDatum<I>

impl<I: Interner> StructuralPartialEq for FnDefDatum<I>