Struct SourceCache 

pub struct SourceCache {
    pub files: Files,
    pub file_paths: HashMap<FileId, SourcePath>,
    pub file_ids: HashMap<SourcePath, NameIdEntry>,
    pub import_paths: Vec<PathBuf>,
    pub packages: HashMap<FileId, PathBuf>,
    pub package_map: Option<PackageMap>,
}

The source cache handles reading textual data from the file system or other souces and storing it in a Files instance.

While not ideal, we have to make most of the fields public to allow the LSP to perform its own import resolution.

Fields

files: Files

The content of the program sources plus imports.

file_paths: HashMap<FileId, SourcePath>

Reverse map from file ids to source paths.

file_ids: HashMap<SourcePath, NameIdEntry>

The name-id table, holding file ids stored in the database indexed by source names.

import_paths: Vec<PathBuf>

Paths where to look for imports, as included by the user through either the CLI argument --import-path or the environment variable $NICKEL_IMPORT_PATH.

packages: HashMap<FileId, PathBuf>

A table mapping FileIds to the package that they belong to.

Path dependencies have already been canonicalized to absolute paths.

package_map: Option<PackageMap>

The map used to resolve package imports.

Implementations

impl SourceCache

pub fn new() -> Self

pub fn name(&self, file_id: FileId) -> &OsStr

Retrieves the name of a source given an id.

pub fn add_import_paths<P>(&mut self, paths: impl Iterator<Item = P>)

where PathBuf: From<P>,

Add paths to the import path list, where the resolver is looking for imported files.

pub fn set_package_map(&mut self, map: PackageMap)

Sets the package map to use for package import resolution.

pub fn add_file( &mut self, path: impl Into<OsString>, format: InputFormat, ) -> Result<FileId>

Loads a file and adds it to the name-id table.

Uses the normalized path and the modified at timestamp as the name-id table entry. Overrides any existing entry with the same name.

pub fn get_or_add_file( &mut self, path: impl Into<OsString>, format: InputFormat, ) -> Result<CacheOp<FileId>>

Try to retrieve the id of a file from the cache.

If it was not in cache, try to read it and add it as a new entry.

In memory sources

As a temporary fix for #2362, if a file path starts with IN_MEMORY_SOURCE_PATH_PREFIX, the suffix is looked up un-normalized value first, which makes it possible to hit in-memory only sources by importing a path "{SOURCE_PATH_PREFX}{src_name}". If it can’t be found, it is looked up normally, so that it doesn’t break strange file names that happen to contain the source path prefix.

It is theoretically possible that if both the source “abc” and the file “{IN_MEMORY_SOURCE_PATH_PREFIX}abc” exist, the source is imported instead of the intended file. However, given the prefix, it just can’t be accidental. As we want to give access to in-memory sources in any case, although this can be surprising, I don’t see any obvious attack scenario here. This fix is also intended to be temporary. If you still need to make sure this doesn’t happen, one way would be to add some randomness to the name of the sources, so that they can’t be predicted beforehand.

pub fn add_source<T>( &mut self, source_name: SourcePath, source: T, ) -> Result<FileId>

where T: Read,

Load a source and add it to the name-id table.

Do not check if a source with the same name already exists: if it is the case, Self::add_source will happily will override the old entry in the name-id table.

pub fn source(&self, id: FileId) -> &str

Returns the content of a file.

Panics if the file id is invalid.

pub fn clone_source(&self, id: FileId) -> Arc<str>

Returns a cloned Arc to the content of the file.

The Arc is here for the LSP, where the background evaluation is handled by background threads and processes.

Panics if the file id is invalid.

pub fn add_string(&mut self, source_name: SourcePath, s: String) -> FileId

Loads a new source as a string and add it to the name-id table.

Do not check if a source with the same name already exists: if it is the case, this one will override the old entry in the name-id table but the old FileId will remain valid.

pub fn replace_string(&mut self, source_name: SourcePath, s: String) -> FileId

Loads a new source as a string, replacing any existing source with the same name.

As opposed to CacheHub::replace_string, this method doesn’t update the other caches. It just affects the source cache.

pub fn close_in_memory_file( &mut self, path: PathBuf, format: InputFormat, ) -> Result<FileCloseResult, FileCloseError>

Closes a file that has been opened in memory and reloads it from the filesystem. Returns the file ID of the replacement file loaded from the filesystem.

pub fn id_of(&self, name: &SourcePath) -> Option<FileId>

Retrieves the id of a source given a name.

Note that files added via Self::add_file are indexed by their full normalized path (cf normalize_path).

pub fn files(&self) -> &Files

Gets a reference to the underlying files. Required by the WASM REPL error reporting code and LSP functions.

pub fn parse_nickel<'ast>( &self, alloc: &'ast AstAlloc, file_id: FileId, ) -> Result<Ast<'ast>, ParseErrors>

Parses a Nickel source without querying nor populating other caches.

pub fn parse_other( &self, pos_table: &mut PosTable, file_id: FileId, format: InputFormat, ) -> Result<NickelValue, ParseError>

Parses a source that isn’t Nickel code without querying nor populating the other caches. Support multiple formats.

The Nickel/non Nickel distinction is a bit artificial at the moment, due to the fact that parsing Nickel returns the new crate::ast::Ast, while parsing other formats don’t go through the new AST first but directly deserialize to the legacy crate::term::Term for simplicity and performance reasons.

Once RFC007 is fully implemented, we might clean it up.

Panic

This function panics if format is InputFormat::Nickel.

pub fn is_stdlib_module(&self, file: FileId) -> bool

Returns true if a particular file id represents a Nickel standard library file, false otherwise.

pub fn get_submodule_file_id(&self, module: StdlibModule) -> Option<FileId>

Retrieves the file id for a given standard libray module.

pub fn stdlib_modules( &self, ) -> impl Iterator<Item = (StdlibModule, FileId)> + use<>

Returns the list of file ids corresponding to the standard library modules.

pub fn input_format(&self, file_id: FileId) -> Option<InputFormat>

Return the format of a given source. Returns None if there is no entry in the source cache for file_id, or if there is no well-defined input format (e.g. for REPL inputs, field assignments, etc.).

Trait Implementations

impl Clone for SourceCache

fn clone(&self) -> SourceCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.