Struct CompilerCache

pub struct CompilerCache<S = Settings> {
    pub format: String,
    pub paths: ProjectPaths,
    pub files: BTreeMap<PathBuf, CacheEntry>,
    pub builds: BTreeSet<String>,
    pub profiles: BTreeMap<String, S>,
    pub preprocessed: bool,
    pub mocks: HashSet<PathBuf>,
}

A multi version cache file

Fields

format: String

paths: ProjectPaths

contains all directories used for the project

files: BTreeMap<PathBuf, CacheEntry>

builds: BTreeSet<String>

profiles: BTreeMap<String, S>

preprocessed: bool

mocks: HashSet<PathBuf>

Implementations

impl<S> CompilerCache<S>

pub fn new(format: String, paths: ProjectPaths, preprocessed: bool) -> Self

impl<S: CompilerSettings> CompilerCache<S>

pub fn is_empty(&self) -> bool

pub fn remove(&mut self, file: &Path) -> Option<CacheEntry>

Removes entry for the given file

pub fn len(&self) -> usize

How many entries the cache contains where each entry represents a sourc file

pub fn artifacts_len(&self) -> usize

How many Artifacts this cache references, where a source file can have multiple artifacts

pub fn entries(&self) -> impl Iterator<Item = &CacheEntry>

Returns an iterator over all CacheEntry this cache contains

pub fn entry(&self, file: &Path) -> Option<&CacheEntry>

Returns the corresponding CacheEntry for the file if it exists

pub fn entry_mut(&mut self, file: &Path) -> Option<&mut CacheEntry>

Returns the corresponding CacheEntry for the file if it exists

pub fn read(path: &Path) -> Result<Self>

Reads the cache json file from the given path

See also Self::read_joined()

Errors

If the cache file does not exist

Examples

use foundry_compilers::{cache::CompilerCache, solc::SolcSettings, Project};

let project = Project::builder().build(Default::default())?;
let mut cache = CompilerCache::<SolcSettings>::read(project.cache_path())?;
cache.join_artifacts_files(project.artifacts_path());

pub fn read_joined<L>(paths: &ProjectPathsConfig<L>) -> Result<Self>

Reads the cache json file from the given path and returns the cache with paths adjoined to the ProjectPathsConfig.

This expects the artifact files to be relative to the artifacts dir of the paths and the CachEntry paths to be relative to the root dir of the paths

Examples

use foundry_compilers::{cache::CompilerCache, solc::SolcSettings, Project};

let project = Project::builder().build(Default::default())?;
let cache: CompilerCache<SolcSettings> = CompilerCache::read_joined(&project.paths)?;

pub fn write(&self, path: &Path) -> Result<()>

Write the cache as json file to the given path

pub fn remove_outdated_builds(&mut self)

Removes build infos which don’t have any artifacts linked to them.

pub fn join_entries(&mut self, root: &Path) -> &mut Self

Sets the CacheEntry’s file paths to root adjoined to self.file.

pub fn strip_entries_prefix(&mut self, base: &Path) -> &mut Self

Removes base from all CacheEntry paths

pub fn join_artifacts_files(&mut self, base: &Path) -> &mut Self

Sets the artifact files location to base adjoined to the CachEntries artifacts.

pub fn strip_artifact_files_prefixes(&mut self, base: &Path) -> &mut Self

Removes base from all artifact file paths

pub fn remove_missing_files(&mut self)

Removes all CacheEntry which source files don’t exist on disk

NOTE: this assumes the files are absolute

pub fn all_artifacts_exist(&self) -> bool

Checks if all artifact files exist

pub fn with_stripped_file_prefixes(self, base: &Path) -> Self

Strips the given prefix from all file paths that identify a CacheEntry to make them relative to the given base argument

In other words this sets the keys (the file path of a solidity file) relative to the base argument, so that the key /Users/me/project/src/Greeter.sol will be changed to src/Greeter.sol if base is /Users/me/project

Examples

use foundry_compilers::{
    artifacts::contract::CompactContract, cache::CompilerCache, solc::SolcSettings, Project,
};

let project = Project::builder().build(Default::default())?;
let cache: CompilerCache<SolcSettings> =
    CompilerCache::read(project.cache_path())?.with_stripped_file_prefixes(project.root());
let artifact: CompactContract = cache.read_artifact("src/Greeter.sol".as_ref(), "Greeter")?;

Note: this only affects the source files, see Self::strip_artifact_files_prefixes()

pub fn find_artifact_path( &self, contract_file: &Path, contract_name: &str, ) -> Option<&Path>

Returns the path to the artifact of the given (file, contract) pair

Examples

use foundry_compilers::{cache::CompilerCache, solc::SolcSettings, Project};

let project = Project::builder().build(Default::default())?;
let cache: CompilerCache<SolcSettings> = CompilerCache::read_joined(&project.paths)?;
cache.find_artifact_path("/Users/git/myproject/src/Greeter.sol".as_ref(), "Greeter");

pub fn read_artifact<Artifact: DeserializeOwned>( &self, contract_file: &Path, contract_name: &str, ) -> Result<Artifact>

Finds the path to the artifact of the given (file, contract) pair (see Self::find_artifact_path()) and deserializes the artifact file as JSON.

Examples

use foundry_compilers::{
    artifacts::contract::CompactContract, cache::CompilerCache, solc::SolcSettings, Project,
};

let project = Project::builder().build(Default::default())?;
let cache = CompilerCache::<SolcSettings>::read_joined(&project.paths)?;
let artifact: CompactContract =
    cache.read_artifact("/Users/git/myproject/src/Greeter.sol".as_ref(), "Greeter")?;

NOTE: unless the cache’s files keys were modified contract_file is expected to be absolute.

pub fn read_artifacts<Artifact: DeserializeOwned + Send + Sync>( &self, ) -> Result<Artifacts<Artifact>>

Reads all cached artifacts from disk using the given ArtifactOutput handler

Examples

use foundry_compilers::{
    artifacts::contract::CompactContractBytecode, cache::CompilerCache, solc::SolcSettings,
    Project,
};

let project = Project::builder().build(Default::default())?;
let cache: CompilerCache<SolcSettings> = CompilerCache::read_joined(&project.paths)?;
let artifacts = cache.read_artifacts::<CompactContractBytecode>()?;

pub fn read_builds<L: Language>( &self, build_info_dir: &Path, ) -> Result<Builds<L>>

Reads all cached BuildContexts from disk. BuildContext is inlined into RawBuildInfo objects, so we are basically just partially deserializing build infos here.

Trait Implementations

impl<S: Clone> Clone for CompilerCache<S>

fn clone(&self) -> CompilerCache<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for CompilerCache<S>

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

Formats the value using the given formatter.

impl<S> Default for CompilerCache<S>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, S> Deserialize<'de> for CompilerCache<S>

where S: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, S: CompilerSettings> From<&'a ProjectPathsConfig> for CompilerCache<S>

fn from(config: &'a ProjectPathsConfig) -> Self

Converts to this type from the input type.

impl<S: PartialEq> PartialEq for CompilerCache<S>

fn eq(&self, other: &CompilerCache<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> Serialize for CompilerCache<S>

where S: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Eq> Eq for CompilerCache<S>

impl<S> StructuralPartialEq for CompilerCache<S>