Struct TypeFlowTracker 

pub struct TypeFlowTracker { /* private fields */ }

Tracks types flowing through Python code

The tracker maintains three primary mappings:

1. Variable -> Types: tracks type flow through variable assignments
2. Collection -> Types: tracks types added to collections (lists, sets, etc.)
3. Parameter -> Types: tracks types passed as function parameters

All mappings use conservative over-approximation: if a type might flow, it’s recorded.

Implementations

impl TypeFlowTracker

pub fn new() -> Self

Create a new type flow tracker

pub fn record_assignment(&mut self, target: &str, type_id: TypeId)

Record that a type flows into a variable

Example

let mut tracker = TypeFlowTracker::new();
let type_id = TypeId::from_name("Observer");
tracker.record_assignment("x", type_id);

pub fn record_assignment_expr(&mut self, target: &Expr, type_id: TypeId)

Record that a type flows into a variable via AST expression

This is a convenience method for integration with AST analysis

pub fn record_collection_add(&mut self, collection: &str, type_id: TypeId)

Record that a type is added to a collection

Example

let mut tracker = TypeFlowTracker::new();
let type_id = TypeId::from_name("ConcreteObserver");
tracker.record_collection_add("self.observers", type_id);

pub fn record_collection_extend( &mut self, collection: &str, type_ids: Vec<TypeId>, )

Record that types are added to a collection via extend operation

pub fn track_collection_operation( &mut self, collection: &str, operation: CollectionOp, )

Track collection operation (append, extend, etc.)

pub fn record_parameter_flow( &mut self, func: &str, param_idx: usize, type_id: TypeId, )

Record that a type flows into a parameter

Example

let mut tracker = TypeFlowTracker::new();
let type_id = TypeId::from_name("Observer");
tracker.record_parameter_flow("Subject.attach", 0, type_id);

pub fn register_type(&mut self, type_info: TypeInfo)

Register type information in the type registry

pub fn get_variable_types(&self, variable: &str) -> Vec<&TypeInfo>

Get all types that have flowed into a variable

pub fn get_collection_types(&self, collection: &str) -> Vec<&TypeInfo>

Get all types that have flowed into a collection

pub fn get_collection_type_ids(&self, collection: &str) -> Vec<TypeId>

Get all type IDs (without full info) that have flowed into a collection

pub fn get_parameter_types( &self, func: &str, param_idx: usize, ) -> Vec<&TypeInfo>

Get all types that have flowed into a parameter

pub fn get_variable_type(&self, variable: &str) -> Option<TypeId>

Get a single variable type (returns first if multiple)

This is useful when you expect a variable to have a single type

Trait Implementations

impl Debug for TypeFlowTracker

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

Formats the value using the given formatter.

impl Default for TypeFlowTracker

fn default() -> Self

Returns the “default value” for a type.