feat: allow multiple compiler configs

Author: klkvr

crates/compilers/src/compile/project.rs

@@ -109,23 +109,23 @@ use crate::{
     output::{AggregatedCompilerOutput, Builds},
     report,
     resolver::GraphEdges,
-    ArtifactOutput, Graph, Project, ProjectCompileOutput, Sources,
+    ArtifactOutput, CompilerSettings, Graph, Project, ProjectCompileOutput, Sources,
 };
 use foundry_compilers_core::error::Result;
 use rayon::prelude::*;
 use semver::Version;
 use std::{collections::HashMap, path::PathBuf, time::Instant};
 
 /// A set of different Solc installations with their version and the sources to be compiled
-pub(crate) type VersionedSources<L> = HashMap<L, HashMap<Version, Sources>>;
+pub(crate) type VersionedSources<L, S> = HashMap<L, Vec<(Version, Sources, S)>>;
 
 #[derive(Debug)]
 pub struct ProjectCompiler<'a, T: ArtifactOutput, C: Compiler> {
     /// Contains the relationship of the source files and their imports
     edges: GraphEdges<C::ParsedSource>,
     project: &'a Project<C, T>,
     /// how to compile all the sources
-    sources: CompilerSources<C::Language>,
+    sources: CompilerSources<C::Language, C::Settings>,
 }
 
 impl<'a, T: ArtifactOutput, C: Compiler> ProjectCompiler<'a, T, C> {
@@ -146,11 +146,7 @@ impl<'a, T: ArtifactOutput, C: Compiler> ProjectCompiler<'a, T, C> {
             sources.retain(|f, _| filter.is_match(f))
         }
         let graph = Graph::resolve_sources(&project.paths, sources)?;
-        let (sources, edges) = graph.into_sources_by_version(
-            project.offline,
-            &project.locked_versions,
-            &project.compiler,
-        )?;
+        let (sources, edges) = graph.into_sources_by_version(project)?;
 
         // If there are multiple different versions, and we can use multiple jobs we can compile
         // them in parallel.
@@ -218,7 +214,7 @@ impl<'a, T: ArtifactOutput, C: Compiler> ProjectCompiler<'a, T, C> {
 #[derive(Debug)]
 struct PreprocessedState<'a, T: ArtifactOutput, C: Compiler> {
     /// Contains all the sources to compile.
-    sources: CompilerSources<C::Language>,
+    sources: CompilerSources<C::Language, C::Settings>,
 
     /// Cache that holds `CacheEntry` objects if caching is enabled and the project is recompiled
     cache: ArtifactsCache<'a, T, C>,
@@ -358,14 +354,14 @@ impl<'a, T: ArtifactOutput, C: Compiler> ArtifactsState<'a, T, C> {
 
 /// Determines how the `solc <-> sources` pairs are executed.
 #[derive(Debug, Clone)]
-struct CompilerSources<L> {
+struct CompilerSources<L, S> {
     /// The sources to compile.
-    sources: VersionedSources<L>,
+    sources: VersionedSources<L, S>,
     /// The number of jobs to use for parallel compilation.
     jobs: Option<usize>,
 }
 
-impl<L: Language> CompilerSources<L> {
+impl<L: Language, S: CompilerSettings> CompilerSources<L, S> {
     /// Converts all `\\` separators to `/`.
     ///
     /// This effectively ensures that `solc` can find imported files like `/src/Cheats.sol` in the
@@ -395,7 +391,7 @@ impl<L: Language> CompilerSources<L> {
     ) {
         cache.remove_dirty_sources();
         for versioned_sources in self.sources.values_mut() {
-            for (version, sources) in versioned_sources {
+            for (version, sources, _) in versioned_sources {
                 trace!("Filtering {} sources for {}", sources.len(), version);
                 cache.filter(sources, version);
                 trace!(
@@ -408,7 +404,7 @@ impl<L: Language> CompilerSources<L> {
     }
 
     /// Compiles all the files with `Solc`
-    fn compile<C: Compiler<Language = L>, T: ArtifactOutput>(
+    fn compile<C: Compiler<Language = L, Settings = S>, T: ArtifactOutput>(
         self,
         cache: &mut ArtifactsCache<'_, T, C>,
     ) -> Result<AggregatedCompilerOutput<C>> {
@@ -425,7 +421,7 @@ impl<L: Language> CompilerSources<L> {
 
         let mut jobs = Vec::new();
         for (language, versioned_sources) in self.sources {
-            for (version, sources) in versioned_sources {
+            for (version, sources, mut opt_settings) in versioned_sources {
                 if sources.is_empty() {
                     // nothing to compile
                     trace!("skip {} for empty sources set", version);
@@ -434,7 +430,6 @@ impl<L: Language> CompilerSources<L> {
 
                 // depending on the composition of the filtered sources, the output selection can be
                 // optimized
-                let mut opt_settings = project.settings.clone();
                 let actually_dirty =
                     sparse_output.sparse_sources(&sources, &mut opt_settings, graph);
 
@@ -677,7 +672,7 @@ mod tests {
         // single solc
         assert_eq!(len, 1);
 
-        let filtered = &sources.values().next().unwrap().values().next().unwrap();
+        let filtered = &sources.values().next().unwrap()[0].1;
 
         // 3 contracts total
         assert_eq!(filtered.0.len(), 3);

crates/compilers/src/compilers/mod.rs

@@ -61,10 +61,18 @@ impl fmt::Display for CompilerVersion {
     }
 }
 
+pub trait CompilerSettingsRestrictions: Debug + Sync + Send + Clone + Default {
+    fn merge(&mut self, other: &Self);
+}
+
 /// Compilation settings including evm_version, output_selection, etc.
 pub trait CompilerSettings:
     Default + Serialize + DeserializeOwned + Clone + Debug + Send + Sync + 'static
 {
+    /// We allow configuring settings restrictions which might optionally contain specific
+    /// requiremets for compiler configuration. e.g. min/max evm_version, optimizer runs
+    type Restrictions: CompilerSettingsRestrictions;
+
     /// Executes given fn with mutable reference to configured [OutputSelection].
     fn update_output_selection(&mut self, f: impl FnOnce(&mut OutputSelection) + Copy);
 
@@ -74,6 +82,9 @@ pub trait CompilerSettings:
     /// Ensures that all settings fields are equal except for `output_selection` which is required
     /// to be a subset of `cached.output_selection`.
     fn can_use_cached(&self, other: &Self) -> bool;
+
+    /// Returns whether current settings satisfy given restrictions.
+    fn satisfies_restrictions(&self, restrictions: &Self::Restrictions) -> bool;
 }
 
 /// Input of a compiler, including sources and settings used for their compilation.

crates/compilers/src/compilers/multi.rs

@@ -10,6 +10,9 @@ use super::{
 use crate::{
     artifacts::vyper::{VyperCompilationError, VyperSettings},
     resolver::parse::SolData,
+    settings::VyperRestrictions,
+    solc::SolcRestrictions,
+    CompilerSettingsRestrictions,
 };
 use foundry_compilers_artifacts::{
     error::SourceLocation,
@@ -124,6 +127,19 @@ impl fmt::Display for MultiCompilerError {
     }
 }
 
+#[derive(Clone, Copy, Debug, Default)]
+pub struct MultiCompilerRestrictions {
+    pub solc: SolcRestrictions,
+    pub vyper: VyperRestrictions,
+}
+
+impl CompilerSettingsRestrictions for MultiCompilerRestrictions {
+    fn merge(&mut self, other: &Self) {
+        self.solc.merge(&other.solc);
+        self.vyper.merge(&other.vyper);
+    }
+}
+
 /// Settings for the [MultiCompiler]. Includes settings for both Solc and Vyper compilers.
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 pub struct MultiCompilerSettings {
@@ -132,6 +148,8 @@ pub struct MultiCompilerSettings {
 }
 
 impl CompilerSettings for MultiCompilerSettings {
+    type Restrictions = MultiCompilerRestrictions;
+
     fn can_use_cached(&self, other: &Self) -> bool {
         self.solc.can_use_cached(&other.solc) && self.vyper.can_use_cached(&other.vyper)
     }
@@ -140,6 +158,11 @@ impl CompilerSettings for MultiCompilerSettings {
         f(&mut self.solc.output_selection);
         f(&mut self.vyper.output_selection);
     }
+
+    fn satisfies_restrictions(&self, restrictions: &Self::Restrictions) -> bool {
+        self.solc.satisfies_restrictions(&restrictions.solc)
+            && self.vyper.satisfies_restrictions(&restrictions.vyper)
+    }
 }
 
 impl From<MultiCompilerSettings> for SolcSettings {

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

@@ -2,14 +2,14 @@ use super::{
     CompilationError, Compiler, CompilerInput, CompilerOutput, CompilerSettings, CompilerVersion,
     Language, ParsedSource,
 };
-use crate::resolver::parse::SolData;
+use crate::{resolver::parse::SolData, CompilerSettingsRestrictions};
 pub use foundry_compilers_artifacts::SolcLanguage;
 use foundry_compilers_artifacts::{
     error::SourceLocation,
     output_selection::OutputSelection,
     remappings::Remapping,
     sources::{Source, Sources},
-    Error, Settings as SolcSettings, Severity, SolcInput,
+    Error, EvmVersion, Settings as SolcSettings, Severity, SolcInput,
 };
 use foundry_compilers_core::error::Result;
 use itertools::Itertools;
@@ -178,7 +178,58 @@ impl CompilerInput for SolcVersionedInput {
     }
 }
 
+#[derive(Debug, Clone, Copy, Default)]
+pub struct EvmVersionRestriction {
+    pub min_evm_version: Option<EvmVersion>,
+    pub max_evm_version: Option<EvmVersion>,
+}
+
+impl EvmVersionRestriction {
+    /// Returns true if the given version satisfies the restrictions
+    ///
+    /// If given None, only returns true if no restrictions are set
+    pub fn satisfies(&self, version: Option<EvmVersion>) -> bool {
+        self.min_evm_version.map_or(true, |min| version.map_or(false, |v| v >= min))
+            && self.max_evm_version.map_or(true, |max| version.map_or(false, |v| v <= max))
+    }
+
+    pub fn merge(&mut self, other: &Self) {
+        let Self { min_evm_version, max_evm_version } = other;
+
+        if let Some(min_evm_version) = min_evm_version {
+            if self.min_evm_version.map_or(true, |e| e < *min_evm_version) {
+                self.min_evm_version.replace(*min_evm_version);
+            }
+        }
+
+        if let Some(max_evm_version) = max_evm_version {
+            if self.max_evm_version.map_or(true, |e| e > *max_evm_version) {
+                self.max_evm_version.replace(*max_evm_version);
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct SolcRestrictions {
+    pub evm_version: EvmVersionRestriction,
+    pub via_ir: Option<bool>,
+}
+
+impl CompilerSettingsRestrictions for SolcRestrictions {
+    fn merge(&mut self, other: &Self) {
+        self.evm_version.merge(&other.evm_version);
+
+        // Preserve true
+        if self.via_ir.map_or(true, |via_ir| !via_ir) {
+            self.via_ir = other.via_ir;
+        }
+    }
+}
+
 impl CompilerSettings for SolcSettings {
+    type Restrictions = SolcRestrictions;
+
     fn update_output_selection(&mut self, f: impl FnOnce(&mut OutputSelection) + Copy) {
         f(&mut self.output_selection)
     }
@@ -208,6 +259,16 @@ impl CompilerSettings for SolcSettings {
             && *libraries == other.libraries
             && output_selection.is_subset_of(&other.output_selection)
     }
+
+    fn satisfies_restrictions(&self, restrictions: &Self::Restrictions) -> bool {
+        let mut satisfies = true;
+
+        satisfies &= restrictions.evm_version.satisfies(self.evm_version);
+        satisfies &=
+            restrictions.via_ir.map_or(true, |via_ir| via_ir == self.via_ir.unwrap_or_default());
+
+        satisfies
+    }
 }
 
 impl ParsedSource for SolData {

crates/compilers/src/compilers/vyper/settings.rs

@@ -1,8 +1,23 @@
 pub use crate::artifacts::vyper::VyperSettings;
-use crate::compilers::CompilerSettings;
+use crate::{
+    compilers::CompilerSettings, solc::EvmVersionRestriction, CompilerSettingsRestrictions,
+};
 use foundry_compilers_artifacts::output_selection::OutputSelection;
 
+#[derive(Clone, Copy, Debug, Default)]
+pub struct VyperRestrictions {
+    pub evm_version: EvmVersionRestriction,
+}
+
+impl CompilerSettingsRestrictions for VyperRestrictions {
+    fn merge(&mut self, other: &Self) {
+        self.evm_version.merge(&other.evm_version);
+    }
+}
+
 impl CompilerSettings for VyperSettings {
+    type Restrictions = VyperRestrictions;
+
     fn update_output_selection(&mut self, f: impl FnOnce(&mut OutputSelection)) {
         f(&mut self.output_selection)
     }
@@ -16,4 +31,8 @@ impl CompilerSettings for VyperSettings {
             && output_selection.is_subset_of(&other.output_selection)
             && search_paths == &other.search_paths
     }
+
+    fn satisfies_restrictions(&self, restrictions: &Self::Restrictions) -> bool {
+        restrictions.evm_version.satisfies(self.evm_version)
+    }
 }