Struct SemanticIndex 

pub struct SemanticIndex {

    pub symbols: Vec<Symbol>,
    pub tokens: Vec<Token>,
    pub references: Vec<Reference>,
    pub scopes: Vec<Scope>,
    pub edges: Vec<Edge>,
    pub symbol_by_name: HashMap<CompactString, SmallVec<[u32; 4]>>,
    pub token_by_name: HashMap<CompactString, Vec<u32>>,
    pub incoming_edges: Vec<SmallVec<[u32; 8]>>,
    pub outgoing_edges: Vec<SmallVec<[u32; 8]>>,
    pub refs_to_symbol: Vec<Vec<u32>>,
    pub files: Vec<PathBuf>,
    pub strings: StringTable,
    pub entry_points: Vec<u32>,
}

The main semantic index containing all code structure information

This structure is designed for:

• Fast lookup by name (HashMap)
• Fast traversal (adjacency lists with SmallVec)
• Memory efficiency (interned strings, compact types)
• Mmap compatibility (repr(C) data types)

Fields

symbols: Vec<Symbol>

All symbol definitions

tokens: Vec<Token>

All token occurrences

references: Vec<Reference>

All symbol references

scopes: Vec<Scope>

All scopes

edges: Vec<Edge>

All call graph edges

symbol_by_name: HashMap<CompactString, SmallVec<[u32; 4]>>

Symbol lookup by name -> list of symbol IDs with that name SmallVec<[u32; 4]> because most names have 1-4 definitions

token_by_name: HashMap<CompactString, Vec<u32>>

Token lookup by name -> list of token IDs with that name

incoming_edges: Vec<SmallVec<[u32; 8]>>

Incoming edges per symbol (who calls this symbol) SmallVec<[u32; 8]> because most functions have <8 callers

outgoing_edges: Vec<SmallVec<[u32; 8]>>

Outgoing edges per symbol (what does this symbol call) SmallVec<[u32; 8]> because most functions call <8 others

refs_to_symbol: Vec<Vec<u32>>

References to each symbol (index by symbol_id)

files: Vec<PathBuf>

List of indexed files (index = file_id)

strings: StringTable

Interned string storage

entry_points: Vec<u32>

Entry point symbol IDs (for fast traversal starting points)

Implementations

impl SemanticIndex

pub fn new() -> Self

Create a new empty semantic index

pub fn with_capacity( symbols: usize, tokens: usize, references: usize, scopes: usize, edges: usize, files: usize, ) -> Self

Create with estimated capacity for better allocation

pub fn add_file(&mut self, path: PathBuf) -> u16

Add a file to the index, returning its file_id

pub fn add_symbol(&mut self, symbol: Symbol, name: &str)

Add a symbol to the index

pub fn add_token(&mut self, token: Token, name: &str)

Add a token to the index

pub fn add_reference(&mut self, reference: Reference)

Add a reference to the index

pub fn add_scope(&mut self, scope: Scope)

Add a scope to the index

pub fn add_edge(&mut self, edge: Edge)

Add an edge to the index

pub fn rebuild_lookups(&mut self)

Rebuild all lookup structures from raw data

Call this after loading from storage to populate HashMaps and adjacency lists.

pub fn symbols_by_name(&self, name: &str) -> Option<&SmallVec<[u32; 4]>>

Find symbols by exact name

pub fn symbols_matching(&self, pattern: &str) -> Vec<u32>

Find symbols matching a name pattern (substring match)

pub fn tokens_by_name(&self, name: &str) -> Option<&Vec<u32>>

Find tokens by exact name

pub fn tokens_matching(&self, pattern: &str) -> Vec<u32>

Find tokens matching a name pattern (substring match)

pub fn symbol(&self, id: u32) -> Option<&Symbol>

Get a symbol by ID

pub fn token(&self, id: u32) -> Option<&Token>

Get a token by ID

pub fn scope(&self, id: u32) -> Option<&Scope>

Get a scope by ID

pub fn symbol_name(&self, symbol: &Symbol) -> Option<&str>

Get the name of a symbol

pub fn token_name(&self, token: &Token) -> Option<&str>

Get the name of a token

pub fn file_path(&self, file_id: u16) -> Option<&PathBuf>

Get the file path for a file_id

pub fn callers(&self, symbol_id: u32) -> &[u32]

Get symbols that call a given symbol (incoming edges)

pub fn callees(&self, symbol_id: u32) -> &[u32]

Get symbols that a given symbol calls (outgoing edges)

pub fn references_to( &self, symbol_id: u32, ) -> impl Iterator<Item = &Reference> + '_

Get all references to a symbol

pub fn references_of_kind( &self, symbol_id: u32, kind: RefKind, ) -> impl Iterator<Item = &Reference>

Get references of a specific kind to a symbol

pub fn call_references( &self, symbol_id: u32, ) -> impl Iterator<Item = &Reference>

Get call references to a symbol

pub fn entry_point_symbols(&self) -> impl Iterator<Item = &Symbol>

Get all entry point symbols

pub fn symbols_in_file(&self, file_id: u16) -> impl Iterator<Item = &Symbol>

Find symbols in a specific file

pub fn tokens_in_file(&self, file_id: u16) -> impl Iterator<Item = &Token>

Find tokens in a specific file

pub fn stats(&self) -> IndexStats

Get index statistics

pub fn file_id_for_path(&self, path: &Path) -> Option<u16>

Find file_id for a given path, if it exists in the index

pub fn remove_file_data(&mut self, file_id: u16) -> usize

Remove all data associated with a specific file.

This removes symbols, tokens, references, scopes, and edges for the file, and cleans up the lookup structures accordingly.

Returns the number of symbols removed.

pub fn next_symbol_id(&self) -> u32

Get the next available symbol ID (for incremental additions)

pub fn next_token_id(&self) -> u32

Get the next available token ID (for incremental additions)

pub fn next_scope_id(&self) -> u32

Get the next available scope ID (for incremental additions)

pub fn has_file(&self, path: &Path) -> bool

Check if a file path is already indexed

Trait Implementations

impl Debug for SemanticIndex

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

Formats the value using the given formatter.

impl Default for SemanticIndex

fn default() -> Self

Returns the “default value” for a type.