Struct ImportFact 

pub struct ImportFact {
    pub from_file: String,
    pub module_specifier: String,
    pub name: String,
}

An import fact: a dependency from one file to another module.

Maps to Datalog: import(from_file, to_module, name)

Fields

from_file: String

File containing the import

module_specifier: String

Raw module specifier as written in the source.

The value depends on the language and import style:

• Relative or absolute file path — e.g. "../foo", "./utils" (JS/TS, Python relative imports). The path is as written in source, not resolved to an absolute path.
• Module name — e.g. "os" (Python stdlib), "std::collections" (Rust), "fmt" (Go). These are not file paths and cannot be resolved without a module resolver.
• Empty string "" — when the grammar does not expose a module path for the import, or for star imports that name no explicit module (e.g. some wildcard import syntaxes). Callers should treat "" as “module not known”.

Resolved file paths (when available) are stored separately in the index, not here.

name: String

Name being imported (or “*” for wildcard)

Trait Implementations

impl Archive for ImportFact

where String: 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 = ArchivedImportFact

The archived representation of this type.

type Resolver = ImportFactResolver

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 ImportFact

fn clone(&self) -> ImportFact

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ImportFact

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

Formats the value using the given formatter.

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

where String: Archive, <String as Archive>::Archived: Deserialize<String, __D>,

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

Deserializes using the given deserializer

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

where String: 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.