Struct FunctionSignature

pub struct FunctionSignature {
    pub name: String,
    pub params: Vec<Variable>,
    pub return_type: Option<DieTypeDefinition>,
    pub self_type: Option<SelfType>,
    pub callable: bool,
    pub debug_location: String,
}

Fields

name: String

Short name of the function, e.g. “len” for “std::vec::Vec::len”

params: Vec<Variable>

Params for the function, e.g. “self: &mut Self, index: usize”

return_type: Option<DieTypeDefinition>

Return type of the function, e.g. “usize” for “std::vec::Vec::len”

self_type: Option<SelfType>

Somewhat duplicative with the params field, this determines (a) if we have a self parameter, and (b) what kind of self parameter it is.

callable: bool

callable indicates that we expect this function to be callable. This is true if the function has a symbol in the binary. If false, it means this is a synthetic method or a function that cannot be called (e.g., a trait method without an implementation).

debug_location: String

e.g. /path/to/debug_info.rgcu.o 0x12345

Mostly useful for debugging

Implementations

impl FunctionSignature

pub fn new( name: String, params: Vec<Variable>, return_type: Option<DieTypeDefinition>, self_type: Option<SelfType>, callable: bool, debug_location: String, ) -> Self

impl FunctionSignature

pub fn print_sig(&self) -> String

Trait Implementations

impl Clone for FunctionSignature

fn clone(&self) -> FunctionSignature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FunctionSignature

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

Formats the value using the given formatter.

impl Hash for FunctionSignature

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 PartialEq for FunctionSignature

fn eq(&self, other: &FunctionSignature) -> 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 Update for FunctionSignature

unsafe fn maybe_update(old_pointer_: *mut Self, new_value_: Self) -> bool

Returns

impl Eq for FunctionSignature

impl StructuralPartialEq for FunctionSignature