chore(evm): re-use project output in SourceData (#11541)

Author: DaniPopes

crates/cast/src/cmd/storage.rs

@@ -150,21 +150,23 @@ impl StorageArgs {
             eyre::bail!("Contract at provided address is not a valid Solidity contract")
         }
 
-        let version = metadata.compiler_version()?;
-        let auto_detect = version < MIN_SOLC;
-
         // Create a new temp project
         // TODO: Cache instead of using a temp directory: metadata from Etherscan won't change
         let root = tempfile::tempdir()?;
         let root_path = root.path();
         let mut project = etherscan_project(metadata, root_path)?;
         add_storage_layout_output(&mut project);
 
-        project.compiler = if auto_detect {
-            SolcCompiler::AutoDetect
-        } else {
-            SolcCompiler::Specific(Solc::find_or_install(&version)?)
-        };
+        let mut version = metadata.compiler_version()?;
+        let mut auto_detect = false;
+        if let Some(solcc) = project.compiler.solc.as_mut()
+            && let SolcCompiler::Specific(solc) = solcc
+            && solc.version < MIN_SOLC
+        {
+            version = solc.version.clone();
+            *solcc = SolcCompiler::AutoDetect;
+            auto_detect = true;
+        }
 
         // Compile
         let mut out = ProjectCompiler::new().quiet(true).compile(&project)?;
@@ -174,13 +176,14 @@ impl StorageArgs {
                 .find(|(name, _)| name == &metadata.contract_name)
                 .ok_or_else(|| eyre::eyre!("Could not find artifact"))?;
 
-            if is_storage_layout_empty(&artifact.storage_layout) && auto_detect {
+            if auto_detect && is_storage_layout_empty(&artifact.storage_layout) {
                 // try recompiling with the minimum version
                 sh_warn!(
-                    "The requested contract was compiled with {version} while the minimum version for storage layouts is {MIN_SOLC} and as a result the output may be empty."
+                    "The requested contract was compiled with {version} while the minimum version \
+                     for storage layouts is {MIN_SOLC} and as a result the output may be empty.",
                 )?;
                 let solc = Solc::find_or_install(&MIN_SOLC)?;
-                project.compiler = SolcCompiler::Specific(solc);
+                project.compiler.solc = Some(SolcCompiler::Specific(solc));
                 if let Ok(output) = ProjectCompiler::new().quiet(true).compile(&project) {
                     out = output;
                     let (_, new_artifact) = out

crates/chisel/src/source.rs

@@ -18,7 +18,7 @@ use foundry_evm::{backend::Backend, opts::EvmOpts};
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use solang_parser::pt;
-use solar::parse::interface::diagnostics::EmittedDiagnostics;
+use solar::interface::diagnostics::EmittedDiagnostics;
 use std::{cell::OnceCell, collections::HashMap, fmt, path::PathBuf};
 use walkdir::WalkDir;
 

crates/common/src/compile.rs

@@ -14,6 +14,7 @@ use foundry_compilers::{
         solc::{Solc, SolcCompiler},
     },
     info::ContractInfo as CompilerContractInfo,
+    multi::{MultiCompiler, MultiCompilerSettings},
     project::Preprocessor,
     report::{BasicStdoutReporter, NoReporter, Report},
     solc::SolcSettings,
@@ -519,11 +520,8 @@ where
 }
 
 /// Creates a [Project] from an Etherscan source.
-pub fn etherscan_project(
-    metadata: &Metadata,
-    target_path: impl AsRef<Path>,
-) -> Result<Project<SolcCompiler>> {
-    let target_path = dunce::canonicalize(target_path.as_ref())?;
+pub fn etherscan_project(metadata: &Metadata, target_path: &Path) -> Result<Project> {
+    let target_path = dunce::canonicalize(target_path)?;
     let sources_path = target_path.join(&metadata.contract_name);
     metadata.source_tree().write_to(&target_path)?;
 
@@ -553,14 +551,18 @@ pub fn etherscan_project(
         .remappings(settings.remappings.clone())
         .build_with_root(sources_path);
 
+    // TODO: detect vyper
     let v = metadata.compiler_version()?;
     let solc = Solc::find_or_install(&v)?;
 
-    let compiler = SolcCompiler::Specific(solc);
+    let compiler = MultiCompiler { solc: Some(SolcCompiler::Specific(solc)), vyper: None };
 
-    Ok(ProjectBuilder::<SolcCompiler>::default()
-        .settings(SolcSettings {
-            settings: SolcConfig::builder().settings(settings).build(),
+    Ok(ProjectBuilder::<MultiCompiler>::default()
+        .settings(MultiCompilerSettings {
+            solc: SolcSettings {
+                settings: SolcConfig::builder().settings(settings).build(),
+                ..Default::default()
+            },
             ..Default::default()
         })
         .paths(paths)

crates/common/src/preprocessor/mod.rs

@@ -52,7 +52,7 @@ impl Preprocessor<SolcCompiler> for DynamicTestLinkingPreprocessor {
         let mut compiler =
             foundry_compilers::resolver::parse::SolParser::new(paths.with_language_ref())
                 .into_compiler();
-        let _ = compiler.enter_mut(|compiler| -> solar::parse::interface::Result {
+        let _ = compiler.enter_mut(|compiler| -> solar::interface::Result {
             let mut pcx = compiler.parse();
 
             // Add the sources into the context.

crates/config/src/inline/natspec.rs

@@ -6,7 +6,7 @@ use foundry_compilers::{
 };
 use itertools::Itertools;
 use serde_json::Value;
-use solar::parse::ast;
+use solar::ast;
 use std::{collections::BTreeMap, path::Path};
 
 /// Convenient struct to hold in-line per-test configurations

crates/evm/traces/src/debug/sources.rs

@@ -1,17 +1,16 @@
 use eyre::{Context, Result};
 use foundry_common::{compact_to_contract, strip_bytecode_placeholders};
 use foundry_compilers::{
-    Artifact, Compiler, ProjectCompileOutput,
+    Artifact, ProjectCompileOutput,
     artifacts::{
-        Bytecode, Contract, ContractBytecodeSome, Libraries, Source,
+        Bytecode, ContractBytecodeSome, Libraries, Source,
         sourcemap::{SourceElement, SourceMap},
     },
     multi::MultiCompilerLanguage,
 };
 use foundry_evm_core::ic::PcIcMap;
 use foundry_linking::Linker;
 use rayon::prelude::*;
-use solar::parse::{Parser, interface::Session};
 use std::{
     collections::{BTreeMap, HashMap, HashSet},
     fmt::Write,
@@ -31,7 +30,13 @@ pub struct SourceData {
 }
 
 impl SourceData {
-    pub fn new(source: Arc<String>, language: MultiCompilerLanguage, path: PathBuf) -> Self {
+    pub fn new(
+        output: &ProjectCompileOutput,
+        source: Arc<String>,
+        language: MultiCompilerLanguage,
+        path: PathBuf,
+        root: &Path,
+    ) -> Self {
         let mut contract_definitions = Vec::new();
 
         match language {
@@ -42,21 +47,21 @@ impl SourceData {
                 }
             }
             MultiCompilerLanguage::Solc(_) => {
-                let sess = Session::builder().with_silent_emitter(None).build();
-                let _ = sess.enter(|| -> solar::parse::interface::Result<()> {
-                    let arena = solar::parse::ast::Arena::new();
-                    let filename = path.clone().into();
-                    let mut parser =
-                        Parser::from_source_code(&sess, &arena, filename, source.to_string())?;
-                    let ast = parser.parse_file().map_err(|e| e.emit())?;
-                    for item in ast.items {
-                        if let solar::parse::ast::ItemKind::Contract(contract) = &item.kind {
-                            let range = item.span.lo().to_usize()..item.span.hi().to_usize();
-                            contract_definitions.push((contract.name.to_string(), range));
+                let r = output.parser().solc().compiler().enter(|compiler| -> Option<()> {
+                    let (_, source) = compiler.gcx().get_ast_source(root.join(&path))?;
+                    for item in source.ast.as_ref()?.items.iter() {
+                        if let solar::ast::ItemKind::Contract(contract) = &item.kind {
+                            contract_definitions.push((
+                                contract.name.to_string(),
+                                compiler.sess().source_map().span_to_source(item.span).unwrap().1,
+                            ));
                         }
                     }
-                    Ok(())
+                    Some(())
                 });
+                if r.is_none() {
+                    warn!("failed to parse contract definitions for {}", path.display());
+                }
             }
         }
 
@@ -135,15 +140,12 @@ impl ContractSources {
         Ok(sources)
     }
 
-    pub fn insert<C: Compiler<CompilerContract = Contract>>(
+    pub fn insert(
         &mut self,
-        output: &ProjectCompileOutput<C>,
+        output: &ProjectCompileOutput,
         root: &Path,
         libraries: Option<&Libraries>,
-    ) -> Result<()>
-    where
-        C::Language: Into<MultiCompilerLanguage>,
-    {
+    ) -> Result<()> {
         let link_data = libraries.map(|libraries| {
             let linker = Linker::new(root, output.artifact_ids().collect());
             (linker, libraries)
@@ -197,9 +199,11 @@ impl ContractSources {
                         })?;
                         let stripped = path.strip_prefix(root).unwrap_or(path).to_path_buf();
                         let source_data = Arc::new(SourceData::new(
+                            output,
                             source.content.clone(),
-                            build.language.into(),
+                            build.language,
                             stripped,
+                            root,
                         ));
                         entry.insert(source_data.clone());
                         source_data

crates/forge/src/cmd/bind_json.rs

@@ -103,7 +103,7 @@ impl BindJsonArgs {
     /// in most of the cases.
     fn preprocess_sources(&self, sources: &mut Sources) -> Result<()> {
         let sess = Session::builder().with_stderr_emitter().build();
-        let result = sess.enter(|| -> solar::parse::interface::Result<()> {
+        let result = sess.enter(|| -> solar::interface::Result<()> {
             sources.0.par_iter_mut().try_for_each(|(path, source)| {
                 let mut content = Arc::try_unwrap(std::mem::take(&mut source.content)).unwrap();
 
@@ -426,7 +426,7 @@ impl PreprocessorVisitor {
 }
 
 impl<'ast> Visit<'ast> for PreprocessorVisitor {
-    type BreakValue = solar::parse::interface::data_structures::Never;
+    type BreakValue = solar::interface::data_structures::Never;
 
     fn visit_item_function(
         &mut self,