refactor(solc): rewrite compiler passes and cache change detection

ethers-solc/src/artifact_output.rs

@@ -197,6 +197,20 @@ pub trait Artifact {
 
     /// Returns the contents of this type as a single tuple of abi, bytecode and deployed bytecode
     fn into_parts(self) -> (Option<Abi>, Option<Bytes>, Option<Bytes>);
+
+    /// Same as [`Self::into_parts()`] but returns `Err` if an element is `None`
+    fn try_into_parts(self) -> Result<(Abi, Bytes, Bytes)>
+    where
+        Self: Sized,
+    {
+        let (abi, bytecode, deployed_bytecode) = self.into_parts();
+
+        Ok((
+            abi.ok_or_else(|| SolcError::msg("abi missing"))?,
+            bytecode.ok_or_else(|| SolcError::msg("bytecode missing"))?,
+            deployed_bytecode.ok_or_else(|| SolcError::msg("deployed bytecode missing"))?,
+        ))
+    }
 }
 
 impl<T> Artifact for T

ethers-solc/src/cache.rs

@@ -5,7 +5,8 @@ use crate::{
     contracts::VersionedContracts,
     error::{Result, SolcError},
     resolver::GraphEdges,
-    utils, ArtifactFile, ArtifactOutput, Artifacts, ArtifactsMap, Project, Source,
+    utils, ArtifactFile, ArtifactOutput, Artifacts, ArtifactsMap, Project, ProjectPathsConfig,
+    Source,
 };
 use semver::Version;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
@@ -63,6 +64,8 @@ impl SolFilesCache {
 
     /// Reads the cache json file from the given path
     ///
+    /// See also [`Self::read_joined()`]
+    ///
     /// # Errors
     ///
     /// If the cache file does not exist
@@ -88,6 +91,26 @@ impl SolFilesCache {
         Ok(cache)
     }
 
+    /// Reads the cache json file from the given path and returns the cache with modified paths
+    ///
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # fn t() {
+    /// use ethers_solc::cache::SolFilesCache;
+    /// use ethers_solc::Project;
+    ///
+    /// let project = Project::builder().build().unwrap();
+    /// let cache = SolFilesCache::read_joined(&project.paths).unwrap();
+    /// # }
+    /// ```
+    pub fn read_joined(paths: &ProjectPathsConfig) -> Result<Self> {
+        let mut cache = SolFilesCache::read(&paths.cache)?;
+        cache.join_all(&paths.artifacts);
+        Ok(cache)
+    }
+
     /// Write the cache as json file to the given path
     pub fn write(&self, path: impl AsRef<Path>) -> Result<()> {
         let path = path.as_ref();
@@ -130,6 +153,59 @@ impl SolFilesCache {
         self.files.values().all(|entry| entry.all_artifacts_exist())
     }
 
+    /// Returns the path to the artifact of the given `(file, contract)` pair
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # fn t() {
+    /// use ethers_solc::cache::SolFilesCache;
+    /// use ethers_solc::Project;
+    ///
+    /// let project = Project::builder().build().unwrap();
+    /// let cache = SolFilesCache::read_joined(&project.paths).unwrap();
+    /// cache.find_artifact_path("/.../src/Greeter.sol", "Greeter");
+    /// # }
+    /// ```
+    pub fn find_artifact_path(
+        &self,
+        contract_file: impl AsRef<Path>,
+        contract_name: impl AsRef<str>,
+    ) -> Option<&PathBuf> {
+        let entry = self.entry(contract_file)?;
+        entry.find_artifact_path(contract_name)
+    }
+
+    /// Finds the path to the artifact of the given `(file, contract)` pair, see
+    /// [`Self::find_artifact_path()`], and reads the artifact as json file
+    /// # Example
+    ///
+    /// ```
+    /// # fn t() {
+    /// use ethers_solc::cache::SolFilesCache;
+    /// use ethers_solc::Project;
+    ///
+    /// let project = Project::builder().build().unwrap();
+    /// let cache = SolFilesCache::read_joined(&project.paths).unwrap();
+    /// cache.read_artifact("/.../src/Greeter.sol", "Greeter");
+    /// # }
+    /// ```
+    pub fn read_artifact<Artifact: DeserializeOwned>(
+        &self,
+        contract_file: impl AsRef<Path>,
+        contract_name: impl AsRef<str>,
+    ) -> Result<Artifact> {
+        let contract_file = contract_file.as_ref();
+        let contract_name = contract_name.as_ref();
+
+        let artifact_path =
+            self.find_artifact_path(contract_file, contract_name).ok_or_else(|| {
+                SolcError::ArtifactNotFound(contract_file.to_path_buf(), contract_name.to_string())
+            })?;
+
+        utils::read_json_file(artifact_path)
+    }
+
     /// Reads all cached artifacts from disk using the given ArtifactOutput handler
     ///
     /// # Example
@@ -140,8 +216,7 @@ impl SolFilesCache {
     /// use ethers_solc::artifacts::CompactContractBytecode;
     /// # fn t() {
     /// let project = Project::builder().build().unwrap();
-    /// let mut cache = SolFilesCache::read(project.cache_path()).unwrap();
-    /// cache.join_all(project.artifacts_path());
+    /// let cache = SolFilesCache::read_joined(&project.paths).unwrap();
     /// let artifacts = cache.read_artifacts::<CompactContractBytecode>().unwrap();
     /// # }
     /// ```
@@ -257,6 +332,17 @@ impl CacheEntry {
         Duration::from_millis(self.last_modification_date)
     }
 
+    /// Returns the artifact path for the contract name
+    /// ```
+    /// use ethers_solc::cache::CacheEntry;
+    /// # fn t(entry: CacheEntry) {
+    /// entry.find_artifact_path("Greeter");
+    /// # }
+    /// ```
+    pub fn find_artifact_path(&self, contract_name: impl AsRef<str>) -> Option<&PathBuf> {
+        self.artifacts.get(contract_name.as_ref())?.iter().next().map(|(_, p)| p)
+    }
+
     /// Reads the last modification date from the file's metadata
     pub fn read_last_modification_date(file: impl AsRef<Path>) -> Result<u64> {
         let file = file.as_ref();
@@ -552,9 +638,7 @@ impl<'a, T: ArtifactOutput> ArtifactsCache<'a, T> {
         let cache = if project.cached {
             // read the cache file if it already exists
             let cache = if project.cache_path().exists() {
-                let mut cache = SolFilesCache::read(project.cache_path()).unwrap_or_default();
-                cache.join_all(project.artifacts_path()).remove_missing_files();
-                cache
+                SolFilesCache::read_joined(&project.paths).unwrap_or_default()
             } else {
                 SolFilesCache::default()
             };

ethers-solc/src/compile/contracts.rs

@@ -87,6 +87,15 @@ impl VersionedContracts {
             .flat_map(|c| c.iter().flat_map(|(name, c)| c.iter().map(move |c| (name, &c.contract))))
     }
 
+    /// Returns an iterator over (`file`, `name`, `Contract`)
+    pub fn contracts_with_files(&self) -> impl Iterator<Item = (&String, &String, &Contract)> {
+        self.0.iter().flat_map(|(file, contracts)| {
+            contracts
+                .iter()
+                .flat_map(move |(name, c)| c.iter().map(move |c| (file, name, &c.contract)))
+        })
+    }
+
     /// Returns an iterator over all contracts and their source names.
     ///
     /// ```

ethers-solc/src/error.rs

@@ -34,6 +34,9 @@ pub enum SolcError {
     #[error("{0}")]
     Message(String),
 
+    #[error("No artifact found for `{}:{}`", .0.display(), .1)]
+    ArtifactNotFound(PathBuf, String),
+
     #[cfg(feature = "project-util")]
     #[error(transparent)]
     FsExtra(#[from] fs_extra::error::Error),

ethers-solc/src/utils.rs

@@ -254,7 +254,7 @@ pub(crate) fn tempdir(name: &str) -> Result<tempfile::TempDir, SolcIoError> {
 }
 
 /// Reads the json file and deserialize it into the provided type
-pub(crate) fn read_json_file<T: DeserializeOwned>(path: impl AsRef<Path>) -> Result<T, SolcError> {
+pub fn read_json_file<T: DeserializeOwned>(path: impl AsRef<Path>) -> Result<T, SolcError> {
     let path = path.as_ref();
     let file = std::fs::File::open(path).map_err(|err| SolcError::io(err, path))?;
     let file = std::io::BufReader::new(file);