feat: avoid reparsing for interface_repr_hash

Author: DaniPopes

crates/artifacts/solc/src/sources.rs

@@ -198,7 +198,13 @@ impl Source {
     /// Generate a non-cryptographically secure checksum of the file's content.
     #[cfg(feature = "checksum")]
     pub fn content_hash(&self) -> String {
-        alloy_primitives::hex::encode(<md5::Md5 as md5::Digest>::digest(self.content.as_bytes()))
+        Self::content_hash_of(&self.content)
+    }
+
+    /// Generate a non-cryptographically secure checksum of the given source.
+    #[cfg(feature = "checksum")]
+    pub fn content_hash_of(src: &str) -> String {
+        alloy_primitives::hex::encode(<md5::Md5 as md5::Digest>::digest(src))
     }
 }
 

crates/compilers/src/cache.rs

@@ -4,10 +4,9 @@ use crate::{
     buildinfo::RawBuildInfo,
     compilers::{Compiler, CompilerSettings, Language},
     output::Builds,
-    preprocessor::interface_representation_hash,
     resolver::GraphEdges,
-    ArtifactFile, ArtifactOutput, Artifacts, ArtifactsMap, Graph, OutputContext, Project,
-    ProjectPaths, ProjectPathsConfig, SourceCompilationKind,
+    ArtifactFile, ArtifactOutput, Artifacts, ArtifactsMap, Graph, OutputContext, ParsedSource,
+    Project, ProjectPaths, ProjectPathsConfig, SourceCompilationKind,
 };
 use foundry_compilers_artifacts::{
     sources::{Source, Sources},
@@ -366,10 +365,7 @@ impl<S: CompilerSettings> CompilerCache<S> {
     {
         match tokio::task::spawn_blocking(f).await {
             Ok(res) => res,
-            Err(_) => Err(SolcError::io(
-                std::io::Error::new(std::io::ErrorKind::Other, "background task failed"),
-                "",
-            )),
+            Err(_) => Err(SolcError::io(std::io::Error::other("background task failed"), "")),
         }
     }
 }
@@ -673,8 +669,7 @@ impl<T: ArtifactOutput<CompilerContract = C::CompilerContract>, C: Compiler>
 {
     /// Whether given file is a source file or a test/script file.
     fn is_source_file(&self, file: &Path) -> bool {
-        !file.starts_with(&self.project.paths.tests)
-            && !file.starts_with(&self.project.paths.scripts)
+        !self.project.paths.is_test_or_script(file)
     }
 
     /// Creates a new cache entry for the file
@@ -686,8 +681,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).then(|| interface_representation_hash(source, &file))
+        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
         };
@@ -961,16 +956,17 @@ 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 {
-            if let hash_map::Entry::Vacant(entry) = self.content_hashes.entry(file.clone()) {
-                entry.insert(source.content_hash());
-            }
+            let content_hash =
+                self.content_hashes.entry(file.clone()).or_insert_with(|| source.content_hash());
+
             // Fill interface representation hashes for source files
-            if self.cache.preprocessed && self.is_source_file(file) {
-                if let hash_map::Entry::Vacant(entry) =
-                    self.interface_repr_hashes.entry(file.clone())
-                {
-                    entry.insert(interface_representation_hash(source, file));
-                }
+            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())
+                });
             }
         }
     }

crates/compilers/src/compilers/mod.rs

@@ -186,6 +186,11 @@ 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,6 +387,13 @@ 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,6 +397,10 @@ 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/config.rs

@@ -250,6 +250,16 @@ impl<L> ProjectPathsConfig<L> {
         Self::dapptools(&std::env::current_dir().map_err(|err| SolcError::io(err, "."))?)
     }
 
+    pub(crate) fn is_test_or_script(&self, path: &Path) -> bool {
+        let test_dir = self.tests.strip_prefix(&self.root).unwrap_or(&self.tests);
+        let script_dir = self.scripts.strip_prefix(&self.root).unwrap_or(&self.scripts);
+        path.starts_with(test_dir) || path.starts_with(script_dir)
+    }
+
+    pub(crate) fn is_source_file(&self, path: &Path) -> bool {
+        !self.is_test_or_script(path)
+    }
+
     /// Returns a new [ProjectPaths] instance that contains all directories configured for this
     /// project
     pub fn paths(&self) -> ProjectPaths {

crates/compilers/src/preprocessor/mod.rs

@@ -10,10 +10,8 @@ use crate::{
     solc::{SolcCompiler, SolcVersionedInput},
     Compiler, ProjectPathsConfig, Result,
 };
-use alloy_primitives::hex;
-use foundry_compilers_artifacts::{SolcLanguage, Source};
+use foundry_compilers_artifacts::SolcLanguage;
 use foundry_compilers_core::{error::SolcError, utils};
-use md5::Digest;
 use solar_parse::{
     ast::{FunctionKind, ItemKind, Span, Visibility},
     interface::{diagnostics::EmittedDiagnostics, source_map::FileName, Session, SourceMap},
@@ -48,7 +46,7 @@ impl Preprocessor<SolcCompiler> for TestOptimizerPreprocessor {
     ) -> Result<()> {
         let sources = &mut input.input.sources;
         // Skip if we are not preprocessing any tests or scripts. Avoids unnecessary AST parsing.
-        if sources.iter().all(|(path, _)| !is_test_or_script(path, paths)) {
+        if sources.iter().all(|(path, _)| !paths.is_test_or_script(path)) {
             trace!("no tests or sources to preprocess");
             return Ok(());
         }
@@ -72,7 +70,7 @@ impl Preprocessor<SolcCompiler> for TestOptimizerPreprocessor {
             // Add the sources into the context.
             let mut preprocessed_paths = vec![];
             for (path, source) in sources.iter() {
-                if is_test_or_script(path, paths) {
+                if paths.is_test_or_script(path) {
                     if let Ok(src_file) =
                         sess.source_map().new_source_file(path.clone(), source.content.as_str())
                     {
@@ -136,91 +134,86 @@ impl Preprocessor<MultiCompiler> for TestOptimizerPreprocessor {
     }
 }
 
-/// Helper function to compute hash of [`interface_representation`] of the source.
-pub(crate) fn interface_representation_hash(source: &Source, file: &Path) -> String {
-    let Ok(repr) = interface_representation(&source.content, file) else {
-        return source.content_hash();
-    };
-    let mut hasher = md5::Md5::new();
-    hasher.update(&repr);
-    let result = hasher.finalize();
-    hex::encode(result)
+pub(crate) fn parse_one_source<R>(
+    content: &str,
+    path: &Path,
+    f: impl FnOnce(solar_sema::ast::SourceUnit<'_>) -> R,
+) -> Result<R, EmittedDiagnostics> {
+    let sess = Session::builder().with_buffer_emitter(Default::default()).build();
+    let res = sess.enter(|| -> solar_parse::interface::Result<_> {
+        let arena = solar_parse::ast::Arena::new();
+        let filename = FileName::Real(path.to_path_buf());
+        let mut parser = Parser::from_source_code(&sess, &arena, filename, content.to_string())?;
+        let ast = parser.parse_file().map_err(|e| e.emit())?;
+        Ok(f(ast))
+    });
+
+    // Return if any diagnostics emitted during content parsing.
+    if let Err(err) = sess.emitted_errors().unwrap() {
+        trace!("failed parsing {path:?}:\n{err}");
+        return Err(err);
+    }
+
+    Ok(res.unwrap())
 }
 
 /// Helper function to remove parts of the contract which do not alter its interface:
 ///   - Internal functions
 ///   - External functions bodies
 ///
 /// Preserves all libraries and interfaces.
-fn interface_representation(content: &str, file: &Path) -> Result<String, EmittedDiagnostics> {
+pub(crate) fn interface_representation_ast(
+    content: &str,
+    ast: &solar_parse::ast::SourceUnit<'_>,
+) -> String {
     let mut spans_to_remove: Vec<Span> = Vec::new();
-    let sess = Session::builder().with_buffer_emitter(Default::default()).build();
-    sess.enter(|| {
-        let arena = solar_parse::ast::Arena::new();
-        let filename = FileName::Real(file.to_path_buf());
-        let Ok(mut parser) = Parser::from_source_code(&sess, &arena, filename, content.to_string())
-        else {
-            return;
+    for item in ast.items.iter() {
+        let ItemKind::Contract(contract) = &item.kind else {
+            continue;
         };
-        let Ok(ast) = parser.parse_file().map_err(|e| e.emit()) else { return };
-        for item in ast.items {
-            let ItemKind::Contract(contract) = &item.kind else {
-                continue;
-            };
-
-            if contract.kind.is_interface() || contract.kind.is_library() {
-                continue;
-            }
 
-            for contract_item in contract.body.iter() {
-                if let ItemKind::Function(function) = &contract_item.kind {
-                    let is_exposed = match function.kind {
-                        // Function with external or public visibility
-                        FunctionKind::Function => {
-                            function.header.visibility >= Some(Visibility::Public)
-                        }
-                        FunctionKind::Constructor
-                        | FunctionKind::Fallback
-                        | FunctionKind::Receive => true,
-                        FunctionKind::Modifier => false,
-                    };
-
-                    // If function is not exposed we remove the entire span (signature and
-                    // body). Otherwise we keep function signature and
-                    // remove only the body.
-                    if !is_exposed {
-                        spans_to_remove.push(contract_item.span);
-                    } else {
-                        spans_to_remove.push(function.body_span);
+        if contract.kind.is_interface() || contract.kind.is_library() {
+            continue;
+        }
+
+        for contract_item in contract.body.iter() {
+            if let ItemKind::Function(function) = &contract_item.kind {
+                let is_exposed = match function.kind {
+                    // Function with external or public visibility
+                    FunctionKind::Function => {
+                        function.header.visibility >= Some(Visibility::Public)
+                    }
+                    FunctionKind::Constructor | FunctionKind::Fallback | FunctionKind::Receive => {
+                        true
                     }
+                    FunctionKind::Modifier => false,
+                };
+
+                // If function is not exposed we remove the entire span (signature and
+                // body). Otherwise we keep function signature and
+                // remove only the body.
+                if !is_exposed {
+                    spans_to_remove.push(contract_item.span);
+                } else {
+                    spans_to_remove.push(function.body_span);
                 }
             }
         }
-    });
-
-    // Return if any diagnostics emitted during content parsing.
-    if let Err(err) = sess.emitted_errors().unwrap() {
-        trace!("failed parsing {file:?}: {err}");
-        return Err(err);
     }
-
     let content =
         replace_source_content(content, spans_to_remove.iter().map(|span| (span.to_range(), "")))
             .replace("\n", "");
-    Ok(utils::RE_TWO_OR_MORE_SPACES.replace_all(&content, "").to_string())
-}
-
-/// Checks if the given path is a test/script file.
-fn is_test_or_script<L>(path: &Path, paths: &ProjectPathsConfig<L>) -> bool {
-    let test_dir = paths.tests.strip_prefix(&paths.root).unwrap_or(&paths.root);
-    let script_dir = paths.scripts.strip_prefix(&paths.root).unwrap_or(&paths.root);
-    path.starts_with(test_dir) || path.starts_with(script_dir)
+    utils::RE_TWO_OR_MORE_SPACES.replace_all(&content, "").into_owned()
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::path::PathBuf;
+
+    fn interface_representation(content: &str) -> String {
+        parse_one_source(content, Path::new(""), |ast| interface_representation_ast(content, &ast))
+            .unwrap()
+    }
 
     #[test]
     fn test_interface_representation() {
@@ -242,7 +235,7 @@ contract A {
     }
 }"#;
 
-        let result = interface_representation(content, &PathBuf::new()).unwrap();
+        let result = interface_representation(content);
         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

@@ -8,6 +8,7 @@ use std::{
 
 /// Represents various information about a Solidity file.
 #[derive(Clone, Debug)]
+#[non_exhaustive]
 pub struct SolData {
     pub license: Option<Spanned<String>>,
     pub version: Option<Spanned<String>>,
@@ -18,6 +19,7 @@ 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 {
@@ -49,20 +51,10 @@ 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 sess = solar_parse::interface::Session::builder()
-            .with_buffer_emitter(Default::default())
-            .build();
-        sess.enter(|| {
-            let arena = ast::Arena::new();
-            let filename = solar_parse::interface::source_map::FileName::Real(file.to_path_buf());
-            let Ok(mut parser) =
-                solar_parse::Parser::from_source_code(&sess, &arena, filename, content.to_string())
-            else {
-                return;
-            };
-            let Ok(ast) = parser.parse_file().map_err(|e| e.emit()) else { return };
-            for item in ast.items {
+        let result = crate::preprocessor::parse_one_source(content, file, |ast| {
+            for item in ast.items.iter() {
                 let loc = item.span.lo().to_usize()..item.span.hi().to_usize();
                 match &item.kind {
                     ast::ItemKind::Pragma(pragma) => match &pragma.tokens {
@@ -111,9 +103,13 @@ impl SolData {
 
                     _ => {}
                 }
+
+                interface_repr_hash = Some(foundry_compilers_artifacts::Source::content_hash_of(
+                    &crate::preprocessor::interface_representation_ast(content, &ast),
+                ));
             }
         });
-        if let Err(e) = sess.emitted_errors().unwrap() {
+        if let Err(e) = result {
             let e = e.to_string();
             trace!("failed parsing {file:?}: {e}");
             parse_result = Err(e);
@@ -157,6 +153,7 @@ impl SolData {
             contract_names,
             is_yul,
             parse_result,
+            interface_repr_hash,
         }
     }