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>,
}

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)

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

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,

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>,

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>,

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.