Make forge compiler resolve work correctly when resolc.resolc_compile is set (#129)

* resolve compile

Author: pkhry

.config/nextest.toml

@@ -2,7 +2,7 @@
 chisel-serial = { max-threads = 1 }
 
 [profile.default]
-retries = { backoff = "exponential", count = 2, delay = "3s", jitter = true }
+retries = { backoff = "exponential", count = 2, delay = "5s", jitter = true }
 slow-timeout = { period = "1m", terminate-after = 3 }
 
 [[profile.default.overrides]]

crates/forge/src/cmd/compiler.rs

@@ -1,7 +1,9 @@
 use clap::{Parser, Subcommand, ValueHint};
 use eyre::Result;
 use foundry_common::shell;
-use foundry_compilers::{artifacts::EvmVersion, Graph};
+use foundry_compilers::{
+    artifacts::EvmVersion, multi::MultiCompilerInput, Compiler, CompilerInput, Graph,
+};
 use foundry_config::Config;
 use semver::Version;
 use serde::Serialize;
@@ -29,9 +31,18 @@ pub enum CompilerSubcommands {
     Resolve(ResolveArgs),
 }
 
+/// Dependency info struct, exists only because tuple gets serialized as an array.
+#[derive(Serialize)]
+struct Dependency {
+    name: String,
+    version: Version,
+}
+
 /// Resolved compiler within the project.
 #[derive(Serialize)]
 struct ResolvedCompiler {
+    /// Compiler name
+    name: String,
     /// Compiler version.
     version: Version,
     /// Max supported EVM version of compiler.
@@ -40,6 +51,9 @@ struct ResolvedCompiler {
     /// Source paths.
     #[serde(skip_serializing_if = "Vec::is_empty")]
     paths: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// dependency of the compiler
+    dependency: Option<Dependency>,
 }
 
 /// CLI arguments for `forge compiler resolve`.
@@ -59,18 +73,17 @@ impl ResolveArgs {
         let Self { root, skip } = self;
 
         let root = root.unwrap_or_else(|| PathBuf::from("."));
-        let config = Config::load_with_root(&root)?;
+        let config = Config::load_with_root(&root)?.canonic_at(root);
         let project = config.project()?;
 
         let graph = Graph::resolve(&project.paths)?;
         let sources = graph.into_sources_by_version(&project)?.sources;
-
         let mut output: BTreeMap<String, Vec<ResolvedCompiler>> = BTreeMap::new();
 
         for (language, sources) in sources {
             let mut versions_with_paths: Vec<ResolvedCompiler> = sources
                 .iter()
-                .map(|(version, sources, _)| {
+                .map(|(version, sources, (_, settings))| {
                     let paths: Vec<String> = sources
                         .iter()
                         .filter_map(|(path_file, _)| {
@@ -101,14 +114,48 @@ impl ResolveArgs {
                     } else {
                         None
                     };
+                    let input = MultiCompilerInput::build(
+                        sources.clone(),
+                        settings.to_owned().clone(),
+                        language,
+                        version.clone(),
+                    );
+                    let compiler_version = project.compiler.compiler_version(&input);
+                    let mut compiler_name = project.compiler.compiler_name(&input).into_owned();
+
+                    let dependency = {
+                        // `Input.version` will always differ from `compiler_version`
+                        if config.resolc.resolc_compile {
+                            let names = compiler_name;
+                            let mut names = names.split_whitespace();
+                            compiler_name =
+                                names.next().expect("Malformed compiler name").to_owned();
+                            names
+                                .last()
+                                .map(|item| item.to_owned())
+                                .zip(Some(version.clone()))
+                                .map(|(name, version)| Dependency { name, version })
+                        } else {
+                            None
+                        }
+                    };
 
-                    ResolvedCompiler { version: version.clone(), evm_version, paths }
+                    ResolvedCompiler {
+                        name: compiler_name,
+                        version: compiler_version,
+                        evm_version,
+                        paths,
+                        dependency,
+                    }
                 })
                 .filter(|version| !version.paths.is_empty())
                 .collect();
 
             // Sort by SemVer version.
-            versions_with_paths.sort_by(|v1, v2| Version::cmp(&v1.version, &v2.version));
+            versions_with_paths.sort_by(|v1, v2| {
+                (&v1.version, &v1.dependency.as_ref().map(|x| &x.version))
+                    .cmp(&(&v2.version, &v2.dependency.as_ref().map(|x| &x.version)))
+            });
 
             // Skip language if no paths are found after filtering.
             if !versions_with_paths.is_empty() {
@@ -135,13 +182,23 @@ impl ResolveArgs {
 
             for resolved_compiler in compilers {
                 let version = &resolved_compiler.version;
+                let extras =
+                    if let Some(Dependency { name, version }) = &resolved_compiler.dependency {
+                        format!(", {name} v{version}")
+                    } else {
+                        String::new()
+                    };
                 match shell::verbosity() {
-                    0 => sh_println!("- {version}")?,
+                    0 => sh_println!("- {} v{version}{}", resolved_compiler.name, extras)?,
                     _ => {
                         if let Some(evm) = &resolved_compiler.evm_version {
-                            sh_println!("{version} (<= {evm}):")?
+                            sh_println!(
+                                "{} v{version}{} (<= {evm}):",
+                                resolved_compiler.name,
+                                extras
+                            )?
                         } else {
-                            sh_println!("{version}:")?
+                            sh_println!("{} v{version}{}:", resolved_compiler.name, extras)?
                         }
                     }
                 }

crates/forge/tests/cli/compiler.rs

@@ -70,7 +70,7 @@ forgetest!(can_resolve_path, |prj, cmd| {
         .assert_success()
         .stdout_eq(str![[r#"
 Solidity:
-- 0.8.4
+- Solc v0.8.4
 
 
 "#]]);
@@ -81,7 +81,7 @@ forgetest!(can_list_resolved_compiler_versions, |prj, cmd| {
 
     cmd.args(["compiler", "resolve"]).assert_success().stdout_eq(str![[r#"
 Solidity:
-- 0.8.4
+- Solc v0.8.4
 
 
 "#]]);
@@ -93,11 +93,12 @@ forgetest!(can_list_resolved_compiler_versions_json, |prj, cmd| {
     cmd.args(["compiler", "resolve", "--json"]).assert_success().stdout_eq(
         str![[r#"
 {
-   "Solidity":[
-      {
-         "version":"0.8.4"
-      }
-   ]
+  "Solidity": [
+    {
+      "name": "Solc",
+      "version": "0.8.4"
+    }
+  ]
 }
 "#]]
         .is_json(),
@@ -111,7 +112,7 @@ forgetest!(can_list_resolved_compiler_versions_verbose, |prj, cmd| {
     cmd.args(["compiler", "resolve", "-v"]).assert_success().stdout_eq(str![[r#"
 Solidity:
 
-0.8.27:
+Solc v0.8.27:
 ├── src/ContractC.sol
 └── src/ContractD.sol
 
@@ -128,6 +129,7 @@ forgetest!(can_list_resolved_compiler_versions_verbose_json, |prj, cmd| {
 {
   "Solidity": [
     {
+      "name": "Solc",
       "version": "0.8.27",
       "paths": [
         "src/ContractC.sol",
@@ -151,12 +153,12 @@ forgetest!(can_list_resolved_multiple_compiler_versions, |prj, cmd| {
 
     cmd.args(["compiler", "resolve"]).assert_success().stdout_eq(str![[r#"
 Solidity:
-- 0.8.4
-- 0.8.11
-- 0.8.27
+- Solc v0.8.4
+- Solc v0.8.11
+- Solc v0.8.27
 
 Vyper:
-- 0.4.0
+- Vyper v0.4.0
 
 
 "#]]);
@@ -174,7 +176,7 @@ forgetest!(can_list_resolved_multiple_compiler_versions_skipped, |prj, cmd| {
         r#"
 Vyper:
 
-0.4.0:
+Vyper v0.4.0:
 ├── src/Counter.vy
 └── src/ICounter.vyi
 
@@ -198,6 +200,7 @@ forgetest!(can_list_resolved_multiple_compiler_versions_skipped_json, |prj, cmd|
 {
   "Solidity": [
     {
+      "name": "Solc",
       "version": "0.8.27",
       "paths": [
         "src/ContractD.sol"
@@ -206,6 +209,7 @@ forgetest!(can_list_resolved_multiple_compiler_versions_skipped_json, |prj, cmd|
   ],
   "Vyper": [
     {
+      "name": "Vyper",
       "version": "0.4.0",
       "paths": [
         "src/Counter.vy",
@@ -230,19 +234,19 @@ forgetest!(can_list_resolved_multiple_compiler_versions_verbose, |prj, cmd| {
     cmd.args(["compiler", "resolve", "-vv"]).assert_success().stdout_eq(str![[r#"
 Solidity:
 
-0.8.4 (<= istanbul):
+Solc v0.8.4 (<= istanbul):
 └── src/ContractA.sol
 
-0.8.11 (<= london):
+Solc v0.8.11 (<= london):
 └── src/ContractB.sol
 
-0.8.27 (<= [..]):
+Solc v0.8.27 (<= cancun):
 ├── src/ContractC.sol
 └── src/ContractD.sol
 
 Vyper:
 
-0.4.0 (<= cancun):
+Vyper v0.4.0 (<= cancun):
 ├── src/Counter.vy
 └── src/ICounter.vyi
 
@@ -263,20 +267,23 @@ forgetest!(can_list_resolved_multiple_compiler_versions_verbose_json, |prj, cmd|
 {
   "Solidity": [
     {
+      "name": "Solc",
       "version": "0.8.4",
       "evm_version": "Istanbul",
       "paths": [
         "src/ContractA.sol"
       ]
     },
     {
+      "name": "Solc",
       "version": "0.8.11",
       "evm_version": "London",
       "paths": [
         "src/ContractB.sol"
       ]
     },
     {
+      "name": "Solc",
       "version": "0.8.27",
       "evm_version": "[..]",
       "paths": [
@@ -287,6 +294,7 @@ forgetest!(can_list_resolved_multiple_compiler_versions_verbose_json, |prj, cmd|
   ],
   "Vyper": [
     {
+      "name": "Vyper",
       "version": "0.4.0",
       "evm_version": "[..]",
       "paths": [

crates/forge/tests/cli/main.rs

@@ -23,6 +23,7 @@ mod inline_config;
 mod multi_script;
 mod revive_build;
 mod revive_cmd;
+mod revive_compiler;
 mod revive_config;
 mod revive_create;
 mod revive_inspect;