feat(coverage): caching for coverage

crates/config/src/lib.rs

@@ -1058,6 +1058,8 @@ impl Config {
         };
         remove_test_dir(&self.fuzz.failure_persist_dir);
         remove_test_dir(&self.invariant.failure_persist_dir);
+        remove_test_dir(&Some(self.cache_path.clone().join("coverage")));
+        remove_test_dir(&Some(self.cache_path.clone()));
 
         // Remove snapshot directory.
         let snapshot_dir = project.root().join(&self.snapshots);

crates/evm/coverage/Cargo.toml

@@ -21,6 +21,6 @@ foundry-evm-core.workspace = true
 alloy-primitives.workspace = true
 eyre.workspace = true
 revm.workspace = true
-semver.workspace = true
 tracing.workspace = true
 rayon.workspace = true
+semver.workspace = true

crates/evm/coverage/src/analysis.rs

@@ -1,18 +1,19 @@
 use super::{CoverageItem, CoverageItemKind, SourceLocation};
 use alloy_primitives::map::HashMap;
+use core::fmt;
 use foundry_common::TestFunctionExt;
 use foundry_compilers::artifacts::{
     ast::{self, Ast, Node, NodeType},
     Source,
 };
 use rayon::prelude::*;
-use std::sync::Arc;
+use std::{borrow::Cow, sync::Arc};
 
 /// A visitor that walks the AST of a single contract and finds coverage items.
 #[derive(Clone, Debug)]
 pub struct ContractVisitor<'a> {
     /// The source ID of the contract.
-    source_id: usize,
+    source_id: SourceIdentifier,
     /// The source code that contains the AST being walked.
     source: &'a str,
 
@@ -29,7 +30,7 @@ pub struct ContractVisitor<'a> {
 }
 
 impl<'a> ContractVisitor<'a> {
-    pub fn new(source_id: usize, source: &'a str, contract_name: &'a Arc<str>) -> Self {
+    pub fn new(source_id: SourceIdentifier, source: &'a str, contract_name: &'a Arc<str>) -> Self {
         Self { source_id, source, contract_name, branch_id: 0, last_line: 0, items: Vec::new() }
     }
 
@@ -484,7 +485,7 @@ impl<'a> ContractVisitor<'a> {
         let n_lines = self.source[bytes.start as usize..bytes.end as usize].lines().count() as u32;
         let lines = start_line..start_line + n_lines;
         SourceLocation {
-            source_id: self.source_id,
+            source_id: self.source_id.clone(),
             contract_name: self.contract_name.clone(),
             bytes,
             lines,
@@ -545,7 +546,7 @@ impl<'a> SourceAnalyzer<'a> {
             .sources
             .sources
             .par_iter()
-            .flat_map_iter(|(&source_id, SourceFile { source, ast })| {
+            .flat_map_iter(|(source_id, SourceFile { source, ast })| {
                 ast.nodes.iter().map(move |node| {
                     if !matches!(node.node_type, NodeType::ContractDefinition) {
                         return Ok(vec![]);
@@ -563,7 +564,7 @@ impl<'a> SourceAnalyzer<'a> {
                         .attribute("name")
                         .ok_or_else(|| eyre::eyre!("Contract has no name"))?;
 
-                    let mut visitor = ContractVisitor::new(source_id, &source.content, &name);
+                    let mut visitor = ContractVisitor::new(source_id.clone(), &source.content, &name);
                     visitor.visit_contract(node)?;
                     let mut items = visitor.items;
 
@@ -590,7 +591,31 @@ impl<'a> SourceAnalyzer<'a> {
 #[derive(Debug, Default)]
 pub struct SourceFiles<'a> {
     /// The versioned sources.
-    pub sources: HashMap<usize, SourceFile<'a>>,
+    /// Keyed by build_id and source_id.
+    pub sources: HashMap<SourceIdentifier, SourceFile<'a>>,
+}
+
+/// Serves as a unique identifier for sources across multiple compiler runs.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct SourceIdentifier {
+    /// Source ID is unique for each source file per compilation job but may not be across
+    /// different jobs.
+    pub source_id: usize,
+    /// Artifact build id is same for all sources in a single compilation job. But always unique
+    /// across different jobs.
+    pub build_id: String,
+}
+
+impl fmt::Display for SourceIdentifier {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "source_id={} build_id={}", self.source_id, self.build_id,)
+    }
+}
+
+impl SourceIdentifier {
+    pub fn new(source_id: usize, build_id: String) -> Self {
+        Self { source_id, build_id }
+    }
 }
 
 /// The source code and AST of a file.
@@ -599,5 +624,5 @@ pub struct SourceFile<'a> {
     /// The source code.
     pub source: Source,
     /// The AST of the source code.
-    pub ast: &'a Ast,
+    pub ast: Cow<'a, Ast>,
 }

crates/evm/coverage/src/anchors.rs

@@ -1,3 +1,5 @@
+use crate::analysis::SourceIdentifier;
+
 use super::{CoverageItem, CoverageItemKind, ItemAnchor, SourceLocation};
 use alloy_primitives::map::{DefaultHashBuilder, HashMap, HashSet};
 use eyre::ensure;
@@ -11,12 +13,16 @@ pub fn find_anchors(
     source_map: &SourceMap,
     ic_pc_map: &IcPcMap,
     items: &[CoverageItem],
-    items_by_source_id: &HashMap<usize, Vec<usize>>,
+    items_by_source_id: &HashMap<SourceIdentifier, Vec<usize>>,
+    source_id: &SourceIdentifier,
 ) -> Vec<ItemAnchor> {
     let mut seen = HashSet::with_hasher(DefaultHashBuilder::default());
     source_map
         .iter()
-        .filter_map(|element| items_by_source_id.get(&(element.index()? as usize)))
+        .filter_map(|element| {
+            items_by_source_id
+                .get(&SourceIdentifier::new(element.index()? as usize, source_id.build_id.clone()))
+        })
         .flatten()
         .filter_map(|&item_id| {
             if !seen.insert(item_id) {
@@ -171,7 +177,8 @@ pub fn find_anchor_branch(
 /// Calculates whether `element` is within the range of the target `location`.
 fn is_in_source_range(element: &SourceElement, location: &SourceLocation) -> bool {
     // Source IDs must match.
-    let source_ids_match = element.index().is_some_and(|a| a as usize == location.source_id);
+    let source_ids_match =
+        element.index().is_some_and(|a| a as usize == location.source_id.source_id);
     if !source_ids_match {
         return false;
     }

crates/evm/coverage/src/lib.rs

@@ -12,6 +12,7 @@ use alloy_primitives::{
     map::{B256HashMap, HashMap},
     Bytes,
 };
+use analysis::SourceIdentifier;
 use eyre::Result;
 use foundry_compilers::artifacts::sourcemap::SourceMap;
 use semver::Version;
@@ -37,29 +38,31 @@ pub use inspector::CoverageCollector;
 #[derive(Clone, Debug, Default)]
 pub struct CoverageReport {
     /// A map of source IDs to the source path.
-    pub source_paths: HashMap<(Version, usize), PathBuf>,
+    pub source_paths: HashMap<SourceIdentifier, PathBuf>,
     /// A map of source paths to source IDs.
-    pub source_paths_to_ids: HashMap<(Version, PathBuf), usize>,
+    pub source_paths_to_ids: HashMap<(Version, PathBuf), SourceIdentifier>,
     /// All coverage items for the codebase, keyed by the compiler version.
-    pub items: HashMap<Version, Vec<CoverageItem>>,
+    pub items: HashMap<SourceIdentifier, Vec<CoverageItem>>,
     /// All item anchors for the codebase, keyed by their contract ID.
     pub anchors: HashMap<ContractId, (Vec<ItemAnchor>, Vec<ItemAnchor>)>,
     /// All the bytecode hits for the codebase.
     pub bytecode_hits: HashMap<ContractId, HitMap>,
     /// The bytecode -> source mappings.
     pub source_maps: HashMap<ContractId, (SourceMap, SourceMap)>,
+    /// Anchor Item ID by source ID
+    pub item_ids_by_source_id: HashMap<SourceIdentifier, Vec<usize>>,
 }
 
 impl CoverageReport {
     /// Add a source file path.
-    pub fn add_source(&mut self, version: Version, source_id: usize, path: PathBuf) {
-        self.source_paths.insert((version.clone(), source_id), path.clone());
+    pub fn add_source(&mut self, version: Version, source_id: SourceIdentifier, path: PathBuf) {
+        self.source_paths.insert(source_id.clone(), path.clone());
         self.source_paths_to_ids.insert((version, path), source_id);
     }
 
     /// Get the source ID for a specific source file path.
-    pub fn get_source_id(&self, version: Version, path: PathBuf) -> Option<usize> {
-        self.source_paths_to_ids.get(&(version, path)).copied()
+    pub fn get_source_id(&self, version: Version, path: PathBuf) -> Option<SourceIdentifier> {
+        self.source_paths_to_ids.get(&(version, path)).cloned()
     }
 
     /// Add the source maps.
@@ -71,8 +74,10 @@ impl CoverageReport {
     }
 
     /// Add coverage items to this report.
-    pub fn add_items(&mut self, version: Version, items: impl IntoIterator<Item = CoverageItem>) {
-        self.items.entry(version).or_default().extend(items);
+    pub fn add_items(&mut self, items: impl IntoIterator<Item = CoverageItem>) {
+        for item in items.into_iter() {
+            self.items.entry(item.loc.source_id.clone()).or_default().push(item);
+        }
     }
 
     /// Add anchors to this report.
@@ -98,10 +103,9 @@ impl CoverageReport {
         mut f: impl FnMut(&mut T, &'a CoverageItem),
     ) -> impl Iterator<Item = (&'a Path, T)> {
         let mut by_file: BTreeMap<&Path, T> = BTreeMap::new();
-        for (version, items) in &self.items {
+        for (key, items) in &self.items {
             for item in items {
-                let key = (version.clone(), item.loc.source_id);
-                let Some(path) = self.source_paths.get(&key) else { continue };
+                let Some(path) = self.source_paths.get(key) else { continue };
                 f(by_file.entry(path).or_default(), item);
             }
         }
@@ -131,8 +135,12 @@ impl CoverageReport {
             for anchor in anchors {
                 if let Some(hits) = hit_map.get(anchor.instruction) {
                     self.items
-                        .get_mut(&contract_id.version)
-                        .and_then(|items| items.get_mut(anchor.item_id))
+                        .get_mut(&contract_id.source_id)
+                        .and_then(|items| {
+                            let scaled_item_id = anchor.item_id % items.len();
+
+                            items.get_mut(scaled_item_id)
+                        })
                         .expect("Anchor refers to non-existent coverage item")
                         .hits += hits.get();
                 }
@@ -146,12 +154,9 @@ impl CoverageReport {
     /// This function should only be called after all the sources were used, otherwise, the output
     /// will be missing the ones that are dependent on them.
     pub fn filter_out_ignored_sources(&mut self, filter: impl Fn(&Path) -> bool) {
-        self.items.retain(|version, items| {
-            items.retain(|item| {
-                self.source_paths
-                    .get(&(version.clone(), item.loc.source_id))
-                    .map(|path| filter(path))
-                    .unwrap_or(false)
+        self.items.retain(|source_id, items| {
+            items.retain(|_item| {
+                self.source_paths.get(source_id).map(|path| filter(path)).unwrap_or(false)
             });
             !items.is_empty()
         });
@@ -276,18 +281,13 @@ impl HitMap {
 /// A unique identifier for a contract
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct ContractId {
-    pub version: Version,
-    pub source_id: usize,
+    pub source_id: SourceIdentifier,
     pub contract_name: Arc<str>,
 }
 
 impl Display for ContractId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "Contract \"{}\" (solc {}, source ID {})",
-            self.contract_name, self.version, self.source_id
-        )
+        write!(f, "Contract \"{}\" source ID {}", self.contract_name, self.source_id)
     }
 }
 
@@ -367,7 +367,7 @@ impl Display for CoverageItem {
 #[derive(Clone, Debug)]
 pub struct SourceLocation {
     /// The source ID.
-    pub source_id: usize,
+    pub source_id: SourceIdentifier,
     /// The contract this source range is in.
     pub contract_name: Arc<str>,
     /// Byte range.