flatten artifacts

Author: klkvr

crates/compilers/src/artifact_output/mod.rs

@@ -32,7 +32,7 @@ mod hh;
 pub use hh::*;
 
 use crate::{
-    cache::{CachedArtifacts, CompilerCache},
+    cache::{CachedArtifact, CompilerCache},
     output::{
         contracts::VersionedContracts,
         sources::{VersionedSourceFile, VersionedSourceFiles},
@@ -860,8 +860,7 @@ pub trait ArtifactOutput {
             .existing_artifacts
             .values()
             .flat_map(|artifacts| artifacts.values())
-            .flat_map(|artifacts| artifacts.values())
-            .flat_map(|artifacts| artifacts.values())
+            .flatten()
             .map(|a| a.path.to_slash_lossy().to_lowercase())
             .collect::<HashSet<_>>();
 
@@ -1029,7 +1028,7 @@ pub struct OutputContext<'a> {
     /// └── inner
     ///     └── a.sol
     /// ```
-    pub existing_artifacts: BTreeMap<&'a Path, &'a CachedArtifacts>,
+    pub existing_artifacts: BTreeMap<&'a Path, &'a BTreeMap<String, Vec<CachedArtifact>>>,
 }
 
 // === impl OutputContext
@@ -1058,10 +1057,10 @@ impl<'a> OutputContext<'a> {
         profile: &str,
     ) -> Option<&Path> {
         self.existing_artifacts
-            .get(file)
-            .and_then(|contracts| contracts.get(contract))
-            .and_then(|versions| versions.get(version))
-            .and_then(|profiles| profiles.get(profile))
+            .get(file)?
+            .get(contract)?
+            .iter()
+            .find(|a| a.version == *version && a.profile == *profile)
             .map(|a| a.path.as_path())
     }
 }

crates/compilers/src/cache.rs

@@ -157,8 +157,7 @@ impl<S: CompilerSettings> CompilerCache<S> {
             if !self
                 .entries()
                 .flat_map(|e| e.artifacts.values())
-                .flat_map(|a| a.values())
-                .flat_map(|a| a.values())
+                .flatten()
                 .any(|a| a.build_id == *build_id)
             {
                 outdated.push(build_id.to_owned());
@@ -395,10 +394,12 @@ pub struct CachedArtifact {
     pub path: PathBuf,
     /// Build id which produced the given artifact.
     pub build_id: String,
+    /// Compiler version used to produce the artifact.
+    pub version: Version,
+    /// Profile used to produce the artifact.
+    pub profile: String,
 }
 
-pub type CachedArtifacts = BTreeMap<String, BTreeMap<Version, BTreeMap<String, CachedArtifact>>>;
-
 /// A `CacheEntry` in the cache file represents a solidity file
 ///
 /// A solidity file can contain several contracts, for every contract a separate `Artifact` is
@@ -426,9 +427,9 @@ pub struct CacheEntry {
     /// file `C` would be compiled twice, with `0.8.10` and `0.8.11`, producing two different
     /// artifacts.
     ///
-    /// This map tracks the artifacts by `name -> (Version -> profile -> PathBuf)`.
+    /// This map tracks the artifacts by `name -> vec of artifacts`
     /// This mimics the default artifacts directory structure
-    pub artifacts: CachedArtifacts,
+    pub artifacts: BTreeMap<String, Vec<CachedArtifact>>,
     /// Whether this file was compiled at least once.
     ///
     /// If this is true and `artifacts` are empty, it means that given version of the file does
@@ -460,12 +461,7 @@ impl CacheEntry {
     /// # }
     /// ```
     pub fn find_artifact_path(&self, contract_name: &str) -> Option<&Path> {
-        self.artifacts
-            .get(contract_name)?
-            .iter()
-            .next()
-            .and_then(|(_, a)| a.iter().next())
-            .map(|(_, p)| p.path.as_path())
+        self.artifacts.get(contract_name)?.iter().next().map(|a| a.path.as_path())
     }
 
     /// Reads the last modification date from the file's metadata
@@ -489,17 +485,15 @@ impl CacheEntry {
         let mut artifacts = BTreeMap::new();
         for (artifact_name, versioned_files) in self.artifacts.iter() {
             let mut files = Vec::with_capacity(versioned_files.len());
-            for (version, cached_artifact) in versioned_files {
-                for (profile, cached_artifact) in cached_artifact {
-                    let artifact: Artifact = utils::read_json_file(&cached_artifact.path)?;
-                    files.push(ArtifactFile {
-                        artifact,
-                        file: cached_artifact.path.clone(),
-                        version: version.clone(),
-                        build_id: cached_artifact.build_id.clone(),
-                        profile: profile.clone(),
-                    });
-                }
+            for cached_artifact in versioned_files {
+                let artifact: Artifact = utils::read_json_file(&cached_artifact.path)?;
+                files.push(ArtifactFile {
+                    artifact,
+                    file: cached_artifact.path.clone(),
+                    version: cached_artifact.version.clone(),
+                    build_id: cached_artifact.build_id.clone(),
+                    profile: cached_artifact.profile.clone(),
+                });
             }
             artifacts.insert(artifact_name.clone(), files);
         }
@@ -513,35 +507,27 @@ impl CacheEntry {
     {
         for (name, artifacts) in artifacts.into_iter() {
             for artifact in artifacts {
-                self.artifacts
-                    .entry(name.clone())
-                    .or_default()
-                    .entry(artifact.version.clone())
-                    .or_default()
-                    .insert(
-                        artifact.profile.clone(),
-                        CachedArtifact {
-                            build_id: artifact.build_id.clone(),
-                            path: artifact.file.clone(),
-                        },
-                    );
+                self.artifacts.entry(name.clone()).or_default().push(CachedArtifact {
+                    build_id: artifact.build_id.clone(),
+                    path: artifact.file.clone(),
+                    version: artifact.version.clone(),
+                    profile: artifact.profile.clone(),
+                });
             }
         }
     }
 
     /// Returns `true` if the artifacts set contains the given version
     pub fn contains(&self, version: &Version, profile: &str) -> bool {
-        self.artifacts.values().any(|artifacts| {
-            artifacts.get(version).and_then(|artifacts| artifacts.get(profile)).is_some()
-        })
-    }
-
-    /// Iterator that yields all artifact files and their version
-    pub fn artifacts_versions(&self) -> impl Iterator<Item = (&Version, &str, &CachedArtifact)> {
         self.artifacts
             .values()
             .flatten()
-            .flat_map(|(v, a)| a.iter().map(move |(p, a)| (v, p.as_str(), a)))
+            .any(|artifact| artifact.version == *version && artifact.profile == *profile)
+    }
+
+    /// Iterator that yields all artifact files
+    pub fn artifacts_versions(&self) -> impl Iterator<Item = (&Version, &str, &CachedArtifact)> {
+        self.artifacts.values().flatten().map(|a| (&a.version, a.profile.as_str(), a))
     }
 
     /// Returns the artifact file for the contract and version pair
@@ -552,9 +538,9 @@ impl CacheEntry {
         profile: &str,
     ) -> Option<&CachedArtifact> {
         self.artifacts
-            .get(contract)
-            .and_then(|files| files.get(version))
-            .and_then(|files| files.get(profile))
+            .get(contract)?
+            .iter()
+            .find(|a| a.version == *version && a.profile == *profile)
     }
 
     /// Iterator that yields all artifact files and their version
@@ -567,12 +553,12 @@ impl CacheEntry {
 
     /// Iterator that yields all artifact files
     pub fn artifacts(&self) -> impl Iterator<Item = &CachedArtifact> {
-        self.artifacts.values().flat_map(BTreeMap::values).flat_map(BTreeMap::values)
+        self.artifacts.values().flatten()
     }
 
     /// Mutable iterator over all artifact files
     pub fn artifacts_mut(&mut self) -> impl Iterator<Item = &mut CachedArtifact> {
-        self.artifacts.values_mut().flat_map(BTreeMap::values_mut).flat_map(BTreeMap::values_mut)
+        self.artifacts.values_mut().flatten()
     }
 
     /// Checks if all artifact files exist
@@ -802,10 +788,7 @@ impl<T: ArtifactOutput, C: Compiler> ArtifactsCacheInner<'_, T, C> {
                 return true;
             }
             entry.artifacts.retain(|_, artifacts| {
-                artifacts.retain(|_, artifacts| {
-                    artifacts.retain(|profile, _| !dirty_profiles.contains(profile));
-                    !artifacts.is_empty()
-                });
+                artifacts.retain(|artifact| !dirty_profiles.contains(&artifact.profile));
                 !artifacts.is_empty()
             });
             !entry.artifacts.is_empty()