Struct Function 

pub struct Function {

    pub name: SmolStr,
    pub args: Box<[(SmolStr, Option<DataType>)]>,
    pub code: Rc<[Expr]>,
    pub impls: Vec<FunctionImpl>,
    pub is_recursive: Option<bool>,
    pub returns_null: bool,
    pub src_file: u16,
    pub return_type_cache: Vec<(Box<[DataType]>, DataType)>,
    pub direct_calls: Box<[SmolStr]>,
    pub name_span: Span,
    pub return_type: Option<(DataType, Span)>,
    pub generics: Option<Box<FnGenerics>>,
    pub captures: Box<[(SmolStr, DataType, Option<DataType>)]>,
    pub entry_register: Option<u16>,
}

Fields

name: SmolStr

args: Box<[(SmolStr, Option<DataType>)]>

code: Rc<[Expr]>

impls: Vec<FunctionImpl>

is_recursive: Option<bool>

returns_null: bool

src_file: u16

return_type_cache: Vec<(Box<[DataType]>, DataType)>

Cache of return types from track_returns, keyed by Box

direct_calls: Box<[SmolStr]>

name_span: Span

return_type: Option<(DataType, Span)>

The declared -> Type return annotation with the span it was written at.

None leaves the return type inferred from the body. When present, the inferred return type of every specialisation is checked against it.

generics: Option<Box<FnGenerics>>

Set for a function that has type parameters of its own (fn first<T>) or that came from an impl block on a generic type. None for an ordinary function.

captures: Box<[(SmolStr, DataType, Option<DataType>)]>

The variables an anonymous function reads from the scope it was written in, with the type each had there, in the order the environment records them. Empty for a declared function and for a closure that reads only its own parameters, which is what keeps that closure lowering the way it did before capture existed. The third member is the type the variable’s let declared, which a write inside the body is held to.

entry_register: Option<u16>

The register holding where this function’s body starts, for a function that becomes a value. It is the first slot of every value built for the function, and an indirect call jumps to what it holds. None for a function no value is ever made of, which is every function a program only calls by name.

Implementations

impl Function

pub fn declared_params(&self) -> Option<Box<[DataType]>>

The parameter types a function that annotates every parameter declares, which is what a call that cannot be seen passes it. None for a function with a bare parameter or type parameters, whose types only a call site settles.

Trait Implementations

impl Debug for Function

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

Formats the value using the given formatter.