Struct FunctionDefItem 

pub struct FunctionDefItem {
    pub name: String,
    pub return_type: TypeInfo,
    pub is_static: bool,
    pub is_inline: bool,
    pub parameters: Vec<Parameter>,
    pub body_statements: Vec<Statement>,
    pub location: SourceLocation,
    pub body_location: Option<SourceLocation>,
    pub doc: Option<FunctionDoc>,
}

Fields

name: String

return_type: TypeInfo

is_static: bool

is_inline: bool

parameters: Vec<Parameter>

body_statements: Vec<Statement>

location: SourceLocation

body_location: Option<SourceLocation>

doc: Option<FunctionDoc>

Implementations

impl FunctionDefItem

pub fn find_calls<'a>( &'a self, function_names: &[&str], ) -> Vec<&'a CallExpression>

Find all calls to specific functions in the body Returns references to all CallExpression nodes that match any of the given function names

pub fn find_calls_matching<F>(&self, predicate: F) -> Vec<&CallExpression>

where F: Fn(&str) -> bool,

Find all calls matching a predicate in the body

pub fn find_signal_registrations(&self, type_name: &str) -> Vec<Signal>

Extract signal registrations from the function body. Populates enum_value when the signal is assigned via signals[ENUM] = g_signal_new(...).

pub fn iter_local_declarations(&self) -> impl Iterator<Item = &VariableDecl>

Iterate all local variable declarations in the function body recursively

pub fn collect_return_values(&self) -> Vec<&Expression>

Collect all return values from the function body

pub fn is_var_returned(&self, type_info: &TypeInfo) -> bool

Check if any variable of the given type is directly returned from the function

pub fn is_var_passed_to_cleanup(&self, type_info: &TypeInfo) -> bool

Check if any variable of the given type is passed to a cleanup call (g_object_unref, g_free, etc.)

pub fn is_var_passed_to_function( &self, var_name: &str, func_name: &str, arg_index: usize, ) -> bool

Check if the named variable is passed to a specific function at a specific argument position

pub fn is_var_allocated(&self, type_info: &TypeInfo) -> bool

Check if any variable of the given type is allocated via an allocation call Uses call.is_allocation_call() to detect allocations by default

pub fn is_var_allocated_with( &self, type_info: &TypeInfo, is_allocation: impl Fn(&CallExpression) -> bool, ) -> bool

Check if any variable of the given type is allocated via a custom allocation predicate

pub fn find_install_properties_calls(&self) -> Vec<&CallExpression>

Find all g_object_class_install_properties calls in the function body

pub fn local_var_types(&self) -> HashMap<&str, &TypeInfo>

Map every named parameter and local variable to its TypeInfo. Parameters appear first; local declarations in body order after that, so an inner-scope shadowing declaration overwrites the outer one.

pub fn get_param_by_name(&self, name: &str) -> Option<&Parameter>

Get a parameter by name

Trait Implementations

impl Clone for FunctionDefItem

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FunctionDefItem

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

Formats the value using the given formatter.

impl Serialize for FunctionDefItem

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.