perf: cache interface_hash in ArtifactsCacheInner

Author: DaniPopes

crates/compilers/src/cache.rs

@@ -4,9 +4,10 @@ use crate::{
     buildinfo::RawBuildInfo,
     compilers::{Compiler, CompilerSettings, Language},
     output::Builds,
+    preprocessor::interface_repr_hash,
     resolver::GraphEdges,
-    ArtifactFile, ArtifactOutput, Artifacts, ArtifactsMap, Graph, OutputContext, ParsedSource,
-    Project, ProjectPaths, ProjectPathsConfig, SourceCompilationKind,
+    ArtifactFile, ArtifactOutput, Artifacts, ArtifactsMap, Graph, OutputContext, Project,
+    ProjectPaths, ProjectPathsConfig, SourceCompilationKind,
 };
 use foundry_compilers_artifacts::{
     sources::{Source, Sources},
@@ -681,11 +682,8 @@ impl<T: ArtifactOutput<CompilerContract = C::CompilerContract>, C: Compiler>
             .map(|import| strip_prefix(import, self.project.root()).into())
             .collect();
 
-        let interface_repr_hash = if self.cache.preprocessed && self.is_source_file(&file) {
-            self.edges.get_parsed_source(&file).and_then(ParsedSource::interface_repr_hash)
-        } else {
-            None
-        };
+        let interface_repr_hash = (self.cache.preprocessed && self.is_source_file(&file))
+            .then(|| self.interface_repr_hash(source, &file).to_string());
 
         let entry = CacheEntry {
             last_modification_date: CacheEntry::read_last_modification_date(&file)
@@ -703,6 +701,27 @@ impl<T: ArtifactOutput<CompilerContract = C::CompilerContract>, C: Compiler>
         self.cache.files.insert(file, entry);
     }
 
+    /// Gets or calculates the content hash for the given source file.
+    fn content_hash(&mut self, source: &Source, file: &Path) -> &str {
+        self.content_hashes.entry(file.to_path_buf()).or_insert_with(|| source.content_hash())
+    }
+
+    /// Gets or calculates the interface representation hash for the given source file.
+    fn interface_repr_hash(&mut self, source: &Source, file: &Path) -> &str {
+        self.interface_repr_hashes
+            .entry(file.to_path_buf())
+            .or_insert_with(|| {
+                if let Some(r) = interface_repr_hash(&source.content, file) {
+                    return r;
+                }
+                self.content_hashes
+                    .entry(file.to_path_buf())
+                    .or_insert_with(|| source.content_hash())
+                    .clone()
+            })
+            .as_str()
+    }
+
     /// Returns the set of [Source]s that need to be compiled to produce artifacts for requested
     /// input.
     ///
@@ -956,17 +975,11 @@ impl<T: ArtifactOutput<CompilerContract = C::CompilerContract>, C: Compiler>
     /// Adds the file's hashes to the set if not set yet
     fn fill_hashes(&mut self, sources: &Sources) {
         for (file, source) in sources {
-            let content_hash =
-                self.content_hashes.entry(file.clone()).or_insert_with(|| source.content_hash());
+            let _ = self.content_hash(source, file);
 
             // Fill interface representation hashes for source files
             if self.cache.preprocessed && self.project.paths.is_source_file(file) {
-                self.interface_repr_hashes.entry(file.clone()).or_insert_with(|| {
-                    self.edges
-                        .get_parsed_source(file)
-                        .and_then(ParsedSource::interface_repr_hash)
-                        .unwrap_or_else(|| content_hash.clone())
-                });
+                let _ = self.interface_repr_hash(source, file);
             }
         }
     }

crates/compilers/src/compilers/mod.rs

@@ -186,11 +186,6 @@ pub trait ParsedSource: Debug + Sized + Send + Clone {
     {
         vec![].into_iter()
     }
-
-    /// Returns the hash of the interface of the source.
-    fn interface_repr_hash(&self) -> Option<String> {
-        None
-    }
 }
 
 /// Error returned by compiler. Might also represent a warning or informational message.

crates/compilers/src/compilers/multi.rs

@@ -387,13 +387,6 @@ impl ParsedSource for MultiCompilerParsedSource {
         }
         .into_iter()
     }
-
-    fn interface_repr_hash(&self) -> Option<String> {
-        match self {
-            Self::Solc(parsed) => parsed.interface_repr_hash(),
-            Self::Vyper(parsed) => parsed.interface_repr_hash(),
-        }
-    }
 }
 
 impl CompilationError for MultiCompilerError {

crates/compilers/src/compilers/solc/mod.rs

@@ -397,10 +397,6 @@ impl ParsedSource for SolData {
     {
         imported_nodes.filter_map(|(path, node)| (!node.libraries.is_empty()).then_some(path))
     }
-
-    fn interface_repr_hash(&self) -> Option<String> {
-        self.interface_repr_hash.clone()
-    }
 }
 
 impl CompilationError for Error {

crates/compilers/src/preprocessor/mod.rs

@@ -134,6 +134,15 @@ impl Preprocessor<MultiCompiler> for TestOptimizerPreprocessor {
     }
 }
 
+pub(crate) fn interface_repr_hash(content: &str, path: &Path) -> Option<String> {
+    let src = interface_repr(content, path).ok()?;
+    Some(foundry_compilers_artifacts::Source::content_hash_of(&src))
+}
+
+pub(crate) fn interface_repr(content: &str, path: &Path) -> Result<String, EmittedDiagnostics> {
+    parse_one_source(content, path, |ast| interface_representation_ast(content, &ast))
+}
+
 pub(crate) fn parse_one_source<R>(
     content: &str,
     path: &Path,
@@ -210,11 +219,6 @@ pub(crate) fn interface_representation_ast(
 mod tests {
     use super::*;
 
-    fn interface_representation(content: &str) -> String {
-        parse_one_source(content, Path::new(""), |ast| interface_representation_ast(content, &ast))
-            .unwrap()
-    }
-
     #[test]
     fn test_interface_representation() {
         let content = r#"
@@ -235,7 +239,7 @@ contract A {
     }
 }"#;
 
-        let result = interface_representation(content);
+        let result = interface_repr(content, Path::new("")).unwrap();
         assert_eq!(
             result,
             r#"library Lib {function libFn() internal {// logic to keep}}contract A {function a() externalfunction b() publicfunction e() external }"#

crates/compilers/src/resolver/parse.rs

@@ -19,7 +19,6 @@ pub struct SolData {
     pub contract_names: Vec<String>,
     pub is_yul: bool,
     pub parse_result: Result<(), String>,
-    pub interface_repr_hash: Option<String>,
 }
 
 impl SolData {
@@ -51,7 +50,6 @@ impl SolData {
         let mut libraries = Vec::new();
         let mut contract_names = Vec::new();
         let mut parse_result = Ok(());
-        let mut interface_repr_hash = None;
 
         let result = crate::preprocessor::parse_one_source(content, file, |ast| {
             for item in ast.items.iter() {
@@ -103,10 +101,6 @@ impl SolData {
 
                     _ => {}
                 }
-
-                interface_repr_hash = Some(foundry_compilers_artifacts::Source::content_hash_of(
-                    &crate::preprocessor::interface_representation_ast(content, &ast),
-                ));
             }
         });
         if let Err(e) = result {
@@ -153,7 +147,6 @@ impl SolData {
             contract_names,
             is_yul,
             parse_result,
-            interface_repr_hash,
         }
     }