Struct Graph 

pub struct Graph { /* private fields */ }

Main call graph structure containing nodes and edges

Implementations

impl CallGraph

pub fn entry_point_criticality_factor(is_entry_point: bool) -> f64

Pure function to calculate entry point criticality factor

pub fn dependency_count_criticality_factor(dependency_count: usize) -> f64

Pure function to calculate dependency count criticality factor

pub fn has_entry_point_caller<F>( callers: &[FunctionId], is_entry_point_fn: F, ) -> bool

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

Pure function to check if any caller is an entry point

pub fn entry_point_caller_criticality_factor( has_entry_point_caller: bool, ) -> f64

Pure function to calculate entry point caller criticality factor

pub fn calculate_criticality(&self, func_id: &FunctionId) -> f64

impl CallGraph

pub fn resolve_cross_file_calls(&mut self)

Resolve cross-file function calls using parallel processing

This method processes unresolved calls in two phases:

1. Parallel Resolution: Uses Rayon to resolve calls concurrently across multiple CPU cores, leveraging the pure functional nature of the resolution logic.
2. Sequential Updates: Applies all resolutions to the graph sequentially to maintain data structure consistency.

Performance

Expected speedup: 10-15% on multi-core systems (4-8 cores). Scales linearly with number of unresolved calls and available cores.

Memory Usage

Memory overhead is minimal and predictable:

• Stores resolved call pairs in a Vec<(FunctionCall, FunctionId)>
• For typical codebases with 1000-2000 unresolved calls:
  • Each tuple: ~200-300 bytes (two FunctionId + one FunctionCall)
  • Total overhead: ~200KB-600KB for 1000-2000 resolutions
• Peak memory during phase 1 (parallel resolution)
• Memory freed after phase 2 (sequential updates)
• Well under the 10MB budget specified in requirements

Thread Safety

The resolution phase is thread-safe because:

• Resolution logic is pure (no side effects)
• All input data is immutable during resolution
• No shared mutable state between threads

pub fn resolve_cross_file_calls_sequential(&mut self)

Sequential resolution for testing and benchmarking

This method provides a non-parallel baseline for comparison with the parallel resolve_cross_file_calls() method. It’s primarily used for:

• Verifying correctness of parallel implementation (determinism tests)
• Performance benchmarking and comparison
• Debugging and development

In production, prefer resolve_cross_file_calls() for better performance.

impl CallGraph

pub fn merge(&mut self, other: CallGraph)

pub fn add_function( &mut self, id: FunctionId, is_entry_point: bool, is_test: bool, complexity: u32, lines: usize, )

pub fn add_call(&mut self, call: FunctionCall)

pub fn add_call_parts( &mut self, caller: FunctionId, callee: FunctionId, call_type: CallType, )

pub fn get_callees(&self, func_id: &FunctionId) -> Vec<FunctionId>

pub fn get_callees_exact(&self, func_id: &FunctionId) -> Vec<FunctionId>

pub fn node_count(&self) -> usize

pub fn get_callers(&self, func_id: &FunctionId) -> Vec<FunctionId>

pub fn get_callers_exact(&self, func_id: &FunctionId) -> Vec<FunctionId>

pub fn get_dependency_count(&self, func_id: &FunctionId) -> usize

pub fn get_all_functions(&self) -> impl Iterator<Item = &FunctionId>

Get all functions in the graph

pub fn get_function_info( &self, func_id: &FunctionId, ) -> Option<(bool, bool, u32, usize)>

Get function info

pub fn mark_as_trait_dispatch(&mut self, func_id: FunctionId)

Mark a function as being reachable through trait dispatch This helps reduce false positives in dead code detection

pub fn is_entry_point(&self, func_id: &FunctionId) -> bool

pub fn is_test_function(&self, func_id: &FunctionId) -> bool

pub fn has_test_function_named(&self, name: &str) -> bool

pub fn add_edge_by_name(&mut self, from: String, to: String, file: PathBuf)

Add an edge between two functions by name (used by critical path analyzer)

pub fn get_callees_by_name(&self, function: &str) -> Vec<String>

Get callees by function name (returns function names)

pub fn get_callers_by_name(&self, function: &str) -> Vec<String>

Get callers by function name (returns function names)

pub fn get_transitive_callees( &self, func_id: &FunctionId, max_depth: usize, ) -> HashSet<FunctionId>

pub fn get_transitive_callers( &self, func_id: &FunctionId, max_depth: usize, ) -> HashSet<FunctionId>

pub fn find_entry_points(&self) -> Vec<FunctionId>

pub fn find_all_functions(&self) -> Vec<FunctionId>

pub fn get_functions_by_file(&self, file: &PathBuf) -> Vec<FunctionId>

Get all functions in a specific file

pub fn get_functions_by_name(&self, name: &str) -> Vec<FunctionId>

Get all functions with a specific name

pub fn get_functions_with_no_callers(&self) -> Vec<FunctionId>

Get all functions that have no callers

pub fn get_function_calls(&self, func_id: &FunctionId) -> Vec<FunctionCall>

pub fn get_all_calls(&self) -> Vec<FunctionCall>

Get all function calls in the graph (for testing and debugging)

pub fn is_empty(&self) -> bool

pub fn find_function(&self, query: &FunctionId) -> Option<FunctionId>

Find a function using fallback matching strategies Tries exact match first, then fuzzy match, then name-only match

pub fn find_function_at_location( &self, file: &PathBuf, line: usize, ) -> Option<FunctionId>

Find a function at a specific file and line location Returns the function that contains the given line

pub fn functions_in_file<'a>( nodes: &'a HashMap<FunctionId, FunctionNode>, file: &PathBuf, ) -> Vec<&'a FunctionId>

Pure function to filter functions by file

pub fn find_best_line_match( functions: &[&FunctionId], target_line: usize, ) -> Option<FunctionId>

Pure function to find the best matching function by line proximity

pub fn is_recursive(&self, func_id: &FunctionId) -> bool

Check if a function is recursive (calls itself directly or through a cycle)

Uses iterative DFS with explicit stack to avoid stack overflow on large graphs.

pub fn topological_sort(&self) -> Result<Vec<FunctionId>, String>

Topological sort of functions for bottom-up analysis Returns functions in dependency order (leaves first, roots last)

Uses iterative DFS with explicit stack to avoid stack overflow on large graphs.

impl CallGraph

pub fn meets_delegation_criteria( orchestrator_complexity: u32, callee_count: usize, ) -> bool

Pure function to check if delegation pattern criteria are met

pub fn calculate_average_callee_complexity( callees: &[FunctionId], nodes: &HashMap<FunctionId, FunctionNode>, ) -> f64

Pure function to calculate average complexity of callees

pub fn indicates_delegation( orchestrator_complexity: u32, avg_callee_complexity: f64, ) -> bool

Pure function to determine if complexity indicates delegation

pub fn detect_delegation_pattern(&self, func_id: &FunctionId) -> bool

impl CallGraph

pub fn find_test_functions(&self) -> Vec<FunctionId>

pub fn is_test_helper(&self, func_id: &FunctionId) -> bool

Check if a function is only called by test functions (test helper) Returns true if:

• The function has at least one caller
• All callers are test functions

pub fn is_production_entry_point( node: &FunctionNode, callers: &[FunctionId], ) -> bool

Pure function to check if a node is a production entry point

pub fn find_test_only_functions(&self) -> HashSet<FunctionId>

Identify functions that are only reachable from test functions These are test infrastructure functions (mocks, helpers, fixtures, etc.)

impl CallGraph

pub fn new() -> Self

Trait Implementations

impl Clone for CallGraph

fn clone(&self) -> CallGraph

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CallGraph

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

Formats the value using the given formatter.

impl Default for CallGraph

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CallGraph

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CallGraph

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

where __S: Serializer,

Serialize this value into the given Serde serializer.