Struct Relations 

pub struct Relations {

    pub symbols: Vec<SymbolFact>,
    pub imports: Vec<ImportFact>,
    pub calls: Vec<CallFact>,
    pub visibilities: Vec<VisibilityFact>,
    pub attributes: Vec<AttributeFact>,
    pub parents: Vec<ParentFact>,
    pub qualifiers: Vec<QualifierFact>,
    pub symbol_ranges: Vec<SymbolRangeFact>,
    pub implements: Vec<ImplementsFact>,
    pub is_impls: Vec<IsImplFact>,
    pub type_methods: Vec<TypeMethodFact>,
    pub resolved_imports: Vec<ResolvedImportFact>,
    pub modules: Vec<ModuleFact>,
    pub exports: Vec<ExportFact>,
    pub reexports: Vec<ReexportFact>,
    pub symbol_uses: Vec<SymbolUseFact>,
    pub resolved_references: Vec<ResolvedReferenceFact>,
    pub resolved_calls: Vec<ResolvedCallFact>,
    pub module_search_paths: Vec<ModuleSearchPathFact>,
    pub cfg_blocks: Vec<CfgBlockFact>,
    pub cfg_edges: Vec<CfgEdgeFact>,
    pub cfg_defs: Vec<CfgDefFact>,
    pub cfg_uses: Vec<CfgUseFact>,
    pub cfg_effects: Vec<CfgEffectFact>,
}

All relations (facts) available to rules.

This is the complete set of facts extracted from a codebase. Rule packs receive this and apply Datalog rules over it.

Fields

symbols: Vec<SymbolFact>

All symbols defined in the codebase

imports: Vec<ImportFact>

All imports in the codebase

calls: Vec<CallFact>

All function calls in the codebase

visibilities: Vec<VisibilityFact>

Symbol visibility facts

attributes: Vec<AttributeFact>

Symbol attribute facts (one per attribute per symbol)

parents: Vec<ParentFact>

Symbol parent-child hierarchy

qualifiers: Vec<QualifierFact>

Call qualifier facts (receiver/module on calls)

symbol_ranges: Vec<SymbolRangeFact>

Symbol range facts (start and end lines)

implements: Vec<ImplementsFact>

Implements facts (symbol implements interface/trait)

is_impls: Vec<IsImplFact>

Is-impl facts (symbol is a trait/interface implementation)

type_methods: Vec<TypeMethodFact>

Type method facts (method signatures on types)

resolved_imports: Vec<ResolvedImportFact>

Resolved import facts (import resolved to a specific file)

modules: Vec<ModuleFact>

Module identity facts (file → canonical module path)

exports: Vec<ExportFact>

Export facts (symbol exported from a file)

reexports: Vec<ReexportFact>

Reexport facts (symbol re-exported through an intermediate)

symbol_uses: Vec<SymbolUseFact>

Symbol use facts (reference/use sites)

resolved_references: Vec<ResolvedReferenceFact>

Resolved reference facts (use resolved to definition)

resolved_calls: Vec<ResolvedCallFact>

Resolved call facts (call resolved to definition file)

module_search_paths: Vec<ModuleSearchPathFact>

Module search path facts (directories to search for modules)

cfg_blocks: Vec<CfgBlockFact>

CFG block facts (one per basic block per function)

cfg_edges: Vec<CfgEdgeFact>

CFG edge facts (one per control-flow edge per function)

cfg_defs: Vec<CfgDefFact>

CFG variable definition facts (one per def site per block)

cfg_uses: Vec<CfgUseFact>

CFG variable use facts (one per use site per block)

cfg_effects: Vec<CfgEffectFact>

CFG side-effect facts (await, defer, yield, acquire, release, send, receive)

Implementations

impl Relations

pub fn new() -> Self

Create empty relations

pub fn add_symbol(&mut self, file: &str, name: &str, kind: &str, line: u32)

Add a symbol fact

pub fn add_import(&mut self, from_file: &str, to_module: &str, name: &str)

Add an import fact

pub fn add_call( &mut self, caller_file: &str, caller_name: &str, callee_name: &str, line: u32, )

Add a call fact

pub fn add_visibility(&mut self, file: &str, name: &str, visibility: &str)

Add a visibility fact

pub fn add_attribute(&mut self, file: &str, name: &str, attribute: &str)

Add an attribute fact

pub fn add_parent(&mut self, file: &str, child_name: &str, parent_name: &str)

Add a parent fact

pub fn add_qualifier( &mut self, caller_file: &str, caller_name: &str, callee_name: &str, qualifier: &str, )

Add a qualifier fact

pub fn add_symbol_range( &mut self, file: &str, name: &str, start_line: u32, end_line: u32, )

Add a symbol range fact

pub fn add_implements(&mut self, file: &str, name: &str, interface: &str)

Add an implements fact

pub fn add_is_impl(&mut self, file: &str, name: &str)

Add an is_impl fact

pub fn add_type_method( &mut self, file: &str, type_name: &str, method_name: &str, )

Add a type method fact

pub fn add_resolved_import( &mut self, from_file: &str, to_file: &str, imported_name: &str, local_alias: &str, kind: &str, )

Add a resolved import fact

pub fn add_module(&mut self, file: &str, canonical_module_path: &str)

Add a module fact

pub fn add_export(&mut self, file: &str, name: &str, kind: &str)

Add an export fact

pub fn add_reexport( &mut self, from_file: &str, original_file: &str, original_name: &str, exported_as: &str, )

Add a reexport fact

pub fn add_symbol_use(&mut self, file: &str, name: &str, line: u32)

Add a symbol use fact

pub fn add_resolved_reference( &mut self, use_file: &str, use_line: u32, def_file: &str, def_name: &str, def_kind: &str, )

Add a resolved reference fact

pub fn add_resolved_call( &mut self, caller_file: &str, caller_name: &str, callee_file: &str, callee_name: &str, line: u32, )

Add a resolved call fact

pub fn add_module_search_path( &mut self, workspace_root: &str, language: &str, kind: &str, path: &str, )

Add a module search path fact

pub fn add_cfg_block( &mut self, file: &str, func: &str, func_line: u32, block: u32, kind: &str, )

Add a CFG block fact

pub fn add_cfg_edge( &mut self, file: &str, func: &str, func_line: u32, from: u32, to: u32, kind: &str, exception_type: &str, )

Add a CFG edge fact

pub fn add_cfg_def( &mut self, file: &str, func: &str, func_line: u32, block: u32, name: &str, )

Add a CFG variable definition fact

pub fn add_cfg_use( &mut self, file: &str, func: &str, func_line: u32, block: u32, name: &str, )

Add a CFG variable use fact

pub fn add_cfg_effect( &mut self, file: &str, func: &str, func_line: u32, block: u32, kind: &str, line: u32, label: &str, )

Add a CFG side-effect fact

Trait Implementations

impl Archive for Relations

where Vec<SymbolFact>: Archive, Vec<ImportFact>: Archive, Vec<CallFact>: Archive, Vec<VisibilityFact>: Archive, Vec<AttributeFact>: Archive, Vec<ParentFact>: Archive, Vec<QualifierFact>: Archive, Vec<SymbolRangeFact>: Archive, Vec<ImplementsFact>: Archive, Vec<IsImplFact>: Archive, Vec<TypeMethodFact>: Archive, Vec<ResolvedImportFact>: Archive, Vec<ModuleFact>: Archive, Vec<ExportFact>: Archive, Vec<ReexportFact>: Archive, Vec<SymbolUseFact>: Archive, Vec<ResolvedReferenceFact>: Archive, Vec<ResolvedCallFact>: Archive, Vec<ModuleSearchPathFact>: Archive, Vec<CfgBlockFact>: Archive, Vec<CfgEdgeFact>: Archive, Vec<CfgDefFact>: Archive, Vec<CfgUseFact>: Archive, Vec<CfgEffectFact>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedRelations

The archived representation of this type.

type Resolver = RelationsResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for Relations

fn clone(&self) -> Relations

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Relations

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

Formats the value using the given formatter.

impl Default for Relations

fn default() -> Relations

Returns the “default value” for a type.

impl<__D: Fallible + ?Sized> Deserialize<Relations, __D> for Archived<Relations>

where Vec<SymbolFact>: Archive, <Vec<SymbolFact> as Archive>::Archived: Deserialize<Vec<SymbolFact>, __D>, Vec<ImportFact>: Archive, <Vec<ImportFact> as Archive>::Archived: Deserialize<Vec<ImportFact>, __D>, Vec<CallFact>: Archive, <Vec<CallFact> as Archive>::Archived: Deserialize<Vec<CallFact>, __D>, Vec<VisibilityFact>: Archive, <Vec<VisibilityFact> as Archive>::Archived: Deserialize<Vec<VisibilityFact>, __D>, Vec<AttributeFact>: Archive, <Vec<AttributeFact> as Archive>::Archived: Deserialize<Vec<AttributeFact>, __D>, Vec<ParentFact>: Archive, <Vec<ParentFact> as Archive>::Archived: Deserialize<Vec<ParentFact>, __D>, Vec<QualifierFact>: Archive, <Vec<QualifierFact> as Archive>::Archived: Deserialize<Vec<QualifierFact>, __D>, Vec<SymbolRangeFact>: Archive, <Vec<SymbolRangeFact> as Archive>::Archived: Deserialize<Vec<SymbolRangeFact>, __D>, Vec<ImplementsFact>: Archive, <Vec<ImplementsFact> as Archive>::Archived: Deserialize<Vec<ImplementsFact>, __D>, Vec<IsImplFact>: Archive, <Vec<IsImplFact> as Archive>::Archived: Deserialize<Vec<IsImplFact>, __D>, Vec<TypeMethodFact>: Archive, <Vec<TypeMethodFact> as Archive>::Archived: Deserialize<Vec<TypeMethodFact>, __D>, Vec<ResolvedImportFact>: Archive, <Vec<ResolvedImportFact> as Archive>::Archived: Deserialize<Vec<ResolvedImportFact>, __D>, Vec<ModuleFact>: Archive, <Vec<ModuleFact> as Archive>::Archived: Deserialize<Vec<ModuleFact>, __D>, Vec<ExportFact>: Archive, <Vec<ExportFact> as Archive>::Archived: Deserialize<Vec<ExportFact>, __D>, Vec<ReexportFact>: Archive, <Vec<ReexportFact> as Archive>::Archived: Deserialize<Vec<ReexportFact>, __D>, Vec<SymbolUseFact>: Archive, <Vec<SymbolUseFact> as Archive>::Archived: Deserialize<Vec<SymbolUseFact>, __D>, Vec<ResolvedReferenceFact>: Archive, <Vec<ResolvedReferenceFact> as Archive>::Archived: Deserialize<Vec<ResolvedReferenceFact>, __D>, Vec<ResolvedCallFact>: Archive, <Vec<ResolvedCallFact> as Archive>::Archived: Deserialize<Vec<ResolvedCallFact>, __D>, Vec<ModuleSearchPathFact>: Archive, <Vec<ModuleSearchPathFact> as Archive>::Archived: Deserialize<Vec<ModuleSearchPathFact>, __D>, Vec<CfgBlockFact>: Archive, <Vec<CfgBlockFact> as Archive>::Archived: Deserialize<Vec<CfgBlockFact>, __D>, Vec<CfgEdgeFact>: Archive, <Vec<CfgEdgeFact> as Archive>::Archived: Deserialize<Vec<CfgEdgeFact>, __D>, Vec<CfgDefFact>: Archive, <Vec<CfgDefFact> as Archive>::Archived: Deserialize<Vec<CfgDefFact>, __D>, Vec<CfgUseFact>: Archive, <Vec<CfgUseFact> as Archive>::Archived: Deserialize<Vec<CfgUseFact>, __D>, Vec<CfgEffectFact>: Archive, <Vec<CfgEffectFact> as Archive>::Archived: Deserialize<Vec<CfgEffectFact>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Relations, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for Relations

where Vec<SymbolFact>: Serialize<__S>, Vec<ImportFact>: Serialize<__S>, Vec<CallFact>: Serialize<__S>, Vec<VisibilityFact>: Serialize<__S>, Vec<AttributeFact>: Serialize<__S>, Vec<ParentFact>: Serialize<__S>, Vec<QualifierFact>: Serialize<__S>, Vec<SymbolRangeFact>: Serialize<__S>, Vec<ImplementsFact>: Serialize<__S>, Vec<IsImplFact>: Serialize<__S>, Vec<TypeMethodFact>: Serialize<__S>, Vec<ResolvedImportFact>: Serialize<__S>, Vec<ModuleFact>: Serialize<__S>, Vec<ExportFact>: Serialize<__S>, Vec<ReexportFact>: Serialize<__S>, Vec<SymbolUseFact>: Serialize<__S>, Vec<ResolvedReferenceFact>: Serialize<__S>, Vec<ResolvedCallFact>: Serialize<__S>, Vec<ModuleSearchPathFact>: Serialize<__S>, Vec<CfgBlockFact>: Serialize<__S>, Vec<CfgEdgeFact>: Serialize<__S>, Vec<CfgDefFact>: Serialize<__S>, Vec<CfgUseFact>: Serialize<__S>, Vec<CfgEffectFact>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.