refactor restrictions

Author: klkvr

crates/compilers/src/compilers/multi.rs

@@ -138,9 +138,8 @@ pub struct MultiCompilerRestrictions {
 }
 
 impl CompilerSettingsRestrictions for MultiCompilerRestrictions {
-    fn merge(&mut self, other: Self) {
-        self.solc.merge(other.solc);
-        self.vyper.merge(other.vyper);
+    fn merge(self, other: Self) -> Option<Self> {
+        Some(Self { solc: self.solc.merge(other.solc)?, vyper: self.vyper.merge(other.vyper)? })
     }
 }
 

crates/compilers/src/compilers/restrictions.rs

@@ -5,8 +5,8 @@ use std::{
 
 use semver::VersionReq;
 
-pub trait CompilerSettingsRestrictions: Debug + Sync + Send + Clone + Default {
-    fn merge(&mut self, other: Self);
+pub trait CompilerSettingsRestrictions: Copy + Debug + Sync + Send + Clone + Default {
+    fn merge(self, other: Self) -> Option<Self>;
 }
 
 /// Combines [CompilerSettingsRestrictions] with a restrictions on compiler versions for a given

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

@@ -8,7 +8,6 @@ use foundry_compilers_artifacts::{
     error::SourceLocation,
     output_selection::OutputSelection,
     remappings::Remapping,
-    serde_helpers::display_from_str_opt,
     sources::{Source, Sources},
     Error, EvmVersion, Settings, Severity, SolcInput,
 };
@@ -191,70 +190,73 @@ impl DerefMut for SolcSettings {
     }
 }
 
-#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, Eq, PartialEq)]
-pub struct EvmVersionRestriction {
-    #[serde(default, with = "display_from_str_opt", skip_serializing_if = "Option::is_none")]
-    pub min_evm_version: Option<EvmVersion>,
-    #[serde(default, with = "display_from_str_opt", skip_serializing_if = "Option::is_none")]
-    pub max_evm_version: Option<EvmVersion>,
+#[derive(Debug, Clone, Copy, Eq, Default, PartialEq)]
+pub struct Restriction<V> {
+    pub min: Option<V>,
+    pub max: Option<V>,
 }
 
-impl EvmVersionRestriction {
+impl<V: PartialEq + Ord + Copy> Restriction<V> {
     /// 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);
+    pub fn satisfies(&self, value: Option<V>) -> bool {
+        self.min.map_or(true, |min| value.map_or(false, |v| v >= min))
+            && self.max.map_or(true, |max| value.map_or(false, |v| v <= max))
+    }
+
+    /// Combines two restrictions into a new one
+    pub fn merge(self, other: Self) -> Option<Self> {
+        let Self { mut min, mut max } = self;
+        let Self { min: other_min, max: other_max } = other;
+
+        min = min.map_or(other_min, |this_min| {
+            Some(other_min.map_or(this_min, |other_min| this_min.max(other_min)))
+        });
+        max = max.map_or(other_max, |this_max| {
+            Some(other_max.map_or(this_max, |other_max| this_max.min(other_max)))
+        });
+
+        if let (Some(min), Some(max)) = (min, max) {
+            if min > max {
+                return None;
             }
         }
 
-        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);
-            }
+        Some(Self { min, max })
+    }
+
+    pub fn apply(&self, value: Option<V>) -> Option<V> {
+        match (value, self.min, self.max) {
+            (None, Some(min), _) => Some(min),
+            (None, None, Some(max)) => Some(max),
+            (Some(cur), Some(min), _) if cur < min => Some(min),
+            (Some(cur), _, Some(max)) if cur > max => Some(max),
+            _ => value,
         }
     }
 }
 
 #[derive(Debug, Clone, Copy, Default)]
 pub struct SolcRestrictions {
-    pub evm_version: EvmVersionRestriction,
+    pub evm_version: Restriction<EvmVersion>,
     pub via_ir: Option<bool>,
-    pub min_optimizer_runs: Option<usize>,
-    pub max_optimizer_runs: Option<usize>,
+    pub optimizer_runs: Restriction<usize>,
 }
 
 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;
-        }
-
-        if self
-            .min_optimizer_runs
-            .map_or(true, |min| min < other.min_optimizer_runs.unwrap_or(usize::MAX))
-        {
-            self.min_optimizer_runs = other.min_optimizer_runs;
+    fn merge(self, other: Self) -> Option<Self> {
+        if let (Some(via_ir), Some(other_via_ir)) = (self.via_ir, other.via_ir) {
+            if via_ir != other_via_ir {
+                return None;
+            }
         }
 
-        if self
-            .max_optimizer_runs
-            .map_or(true, |max| max > other.max_optimizer_runs.unwrap_or(usize::MIN))
-        {
-            self.max_optimizer_runs = other.max_optimizer_runs;
-        }
+        Some(Self {
+            evm_version: self.evm_version.merge(other.evm_version)?,
+            via_ir: self.via_ir.or(other.via_ir),
+            optimizer_runs: self.optimizer_runs.merge(other.optimizer_runs)?,
+        })
     }
 }
 
@@ -324,16 +326,12 @@ impl CompilerSettings for SolcSettings {
         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 &= restrictions
-            .min_optimizer_runs
-            .map_or(true, |min| self.optimizer.runs.map_or(false, |runs| runs >= min));
-        satisfies &= restrictions
-            .max_optimizer_runs
-            .map_or(true, |max| self.optimizer.runs.map_or(false, |runs| runs <= max));
+        satisfies &= restrictions.optimizer_runs.satisfies(self.optimizer.runs);
 
         // Ensure that we either don't have min optimizer runs set or that the optimizer is enabled
         satisfies &= restrictions
-            .min_optimizer_runs
+            .optimizer_runs
+            .min
             .map_or(true, |min| min == 0 || self.optimizer.enabled.unwrap_or_default());
 
         satisfies

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

@@ -3,18 +3,18 @@ use std::{collections::BTreeSet, path::PathBuf};
 pub use crate::artifacts::vyper::VyperSettings;
 use crate::{
     compilers::{restrictions::CompilerSettingsRestrictions, CompilerSettings},
-    solc::EvmVersionRestriction,
+    solc::Restriction,
 };
-use foundry_compilers_artifacts::output_selection::OutputSelection;
+use foundry_compilers_artifacts::{output_selection::OutputSelection, EvmVersion};
 
 #[derive(Clone, Copy, Debug, Default)]
 pub struct VyperRestrictions {
-    pub evm_version: EvmVersionRestriction,
+    pub evm_version: Restriction<EvmVersion>,
 }
 
 impl CompilerSettingsRestrictions for VyperRestrictions {
-    fn merge(&mut self, other: Self) {
-        self.evm_version.merge(&other.evm_version);
+    fn merge(self, other: Self) -> Option<Self> {
+        Some(Self { evm_version: self.evm_version.merge(other.evm_version)? })
     }
 }
 

crates/compilers/tests/project.rs

@@ -16,7 +16,7 @@ use foundry_compilers::{
     info::ContractInfo,
     multi::MultiCompilerRestrictions,
     project_util::*,
-    solc::{EvmVersionRestriction, SolcRestrictions, SolcSettings},
+    solc::{Restriction, SolcRestrictions, SolcSettings},
     take_solc_installer_lock, Artifact, ConfigurableArtifacts, ExtraOutputValues, Graph, Project,
     ProjectBuilder, ProjectCompileOutput, ProjectPathsConfig, RestrictionsWithVersion,
     TestFileFilter,
@@ -4073,10 +4073,7 @@ contract SimpleContract {}
     let cancun_restriction = RestrictionsWithVersion {
         restrictions: MultiCompilerRestrictions {
             solc: SolcRestrictions {
-                evm_version: EvmVersionRestriction {
-                    min_evm_version: Some(EvmVersion::Cancun),
-                    ..Default::default()
-                },
+                evm_version: Restriction { min: Some(EvmVersion::Cancun), ..Default::default() },
                 ..Default::default()
             },
             ..Default::default()