wip

Author: klkvr

crates/compilers/src/cache.rs

@@ -163,6 +163,7 @@ impl<S: CompilerSettings> CompilerCache<S> {
                 .entries()
                 .flat_map(|e| e.artifacts.values())
                 .flat_map(|a| a.values())
+                .flat_map(|a| a.values())
                 .any(|a| a.build_id == *build_id)
             {
                 outdated.push(build_id.to_owned());

crates/compilers/src/compilers/mod.rs

@@ -24,6 +24,9 @@ pub mod solc;
 pub mod vyper;
 pub use vyper::*;
 
+mod restrictions;
+pub use restrictions::{CompilerSettingsRestrictions, RestrictionsWithVersion};
+
 /// A compiler version is either installed (available locally) or can be downloaded, from the remote
 /// endpoint
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
@@ -61,10 +64,6 @@ 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

crates/compilers/src/compilers/multi.rs

@@ -1,4 +1,5 @@
 use super::{
+    restrictions::CompilerSettingsRestrictions,
     solc::{SolcCompiler, SolcSettings, SolcVersionedInput, SOLC_EXTENSIONS},
     vyper::{
         input::VyperVersionedInput, parser::VyperParsedSource, Vyper, VyperLanguage,
@@ -12,7 +13,6 @@ use crate::{
     resolver::parse::SolData,
     settings::VyperRestrictions,
     solc::SolcRestrictions,
-    CompilerSettingsRestrictions,
 };
 use foundry_compilers_artifacts::{
     error::SourceLocation,

crates/compilers/src/compilers/restrictions.rs

@@ -0,0 +1,32 @@
+use std::{
+    fmt::Debug,
+    ops::{Deref, DerefMut},
+};
+
+use semver::VersionReq;
+
+pub trait CompilerSettingsRestrictions: Debug + Sync + Send + Clone + Default {
+    fn merge(&mut self, other: &Self);
+}
+
+/// Combines [CompilerVersionRestriction] with a restrictions on compiler versions for a given
+/// source file.
+#[derive(Debug, Clone, Default)]
+pub struct RestrictionsWithVersion<T> {
+    pub version: Option<VersionReq>,
+    pub settings: T,
+}
+
+impl<T> Deref for RestrictionsWithVersion<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.settings
+    }
+}
+
+impl<T> DerefMut for RestrictionsWithVersion<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.settings
+    }
+}

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

@@ -1,13 +1,14 @@
 use super::{
-    CompilationError, Compiler, CompilerInput, CompilerOutput, CompilerSettings, CompilerVersion,
-    Language, ParsedSource,
+    restrictions::CompilerSettingsRestrictions, CompilationError, Compiler, CompilerInput,
+    CompilerOutput, CompilerSettings, CompilerVersion, Language, ParsedSource,
 };
-use crate::{resolver::parse::SolData, CompilerSettingsRestrictions};
+use crate::resolver::parse::SolData;
 pub use foundry_compilers_artifacts::SolcLanguage;
 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,
 };
@@ -190,9 +191,11 @@ impl DerefMut for SolcSettings {
     }
 }
 
-#[derive(Debug, Clone, Copy, Default)]
+#[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>,
 }
 
@@ -226,6 +229,8 @@ impl EvmVersionRestriction {
 pub struct SolcRestrictions {
     pub evm_version: EvmVersionRestriction,
     pub via_ir: Option<bool>,
+    pub min_optimizer_runs: Option<usize>,
+    pub max_optimizer_runs: Option<usize>,
 }
 
 impl CompilerSettingsRestrictions for SolcRestrictions {
@@ -305,6 +310,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
     }

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

@@ -2,7 +2,8 @@ use std::{collections::BTreeSet, path::PathBuf};
 
 pub use crate::artifacts::vyper::VyperSettings;
 use crate::{
-    compilers::CompilerSettings, solc::EvmVersionRestriction, CompilerSettingsRestrictions,
+    compilers::{restrictions::CompilerSettingsRestrictions, CompilerSettings},
+    solc::EvmVersionRestriction,
 };
 use foundry_compilers_artifacts::output_selection::OutputSelection;
 

crates/compilers/src/lib.rs

@@ -78,7 +78,8 @@ pub struct Project<C: Compiler = MultiCompiler, T: ArtifactOutput = Configurable
     /// Additional settings for cases when default compiler settings are not enough to cover all
     /// possible restrictions.
     pub additional_settings: BTreeMap<String, C::Settings>,
-    pub restrictions: BTreeMap<PathBuf, <C::Settings as CompilerSettings>::Restrictions>,
+    pub restrictions:
+        BTreeMap<PathBuf, RestrictionsWithVersion<<C::Settings as CompilerSettings>::Restrictions>>,
     /// Whether caching is enabled
     pub cached: bool,
     /// Whether to output build information with each solc call.
@@ -455,6 +456,9 @@ pub struct ProjectBuilder<C: Compiler = MultiCompiler, T: ArtifactOutput = Confi
     paths: Option<ProjectPathsConfig<C::Language>>,
     /// How solc invocation should be configured.
     settings: Option<C::Settings>,
+    additional_settings: BTreeMap<String, C::Settings>,
+    restrictions:
+        BTreeMap<PathBuf, RestrictionsWithVersion<<C::Settings as CompilerSettings>::Restrictions>>,
     /// Whether caching is enabled, default is true.
     cached: bool,
     /// Whether to output build information with each solc call.
@@ -495,6 +499,8 @@ impl<C: Compiler, T: ArtifactOutput> ProjectBuilder<C, T> {
             solc_jobs: None,
             settings: None,
             sparse_output: None,
+            additional_settings: BTreeMap::new(),
+            restrictions: BTreeMap::new(),
         }
     }
 
@@ -619,6 +625,24 @@ impl<C: Compiler, T: ArtifactOutput> ProjectBuilder<C, T> {
         self
     }
 
+    #[must_use]
+    pub fn additional_settings(mut self, additional: BTreeMap<String, C::Settings>) -> Self {
+        self.additional_settings = additional;
+        self
+    }
+
+    #[must_use]
+    pub fn restrictions(
+        mut self,
+        restrictions: BTreeMap<
+            PathBuf,
+            RestrictionsWithVersion<<C::Settings as CompilerSettings>::Restrictions>,
+        >,
+    ) -> Self {
+        self.restrictions = restrictions;
+        self
+    }
+
     /// Set arbitrary `ArtifactOutputHandler`
     pub fn artifacts<A: ArtifactOutput>(self, artifacts: A) -> ProjectBuilder<C, A> {
         let Self {
@@ -634,12 +658,16 @@ impl<C: Compiler, T: ArtifactOutput> ProjectBuilder<C, T> {
             ignored_file_paths,
             settings,
             sparse_output,
+            additional_settings,
+            restrictions,
             ..
         } = self;
         ProjectBuilder {
             paths,
             cached,
             no_artifacts,
+            additional_settings,
+            restrictions,
             offline,
             slash_paths,
             artifacts,
@@ -668,6 +696,8 @@ impl<C: Compiler, T: ArtifactOutput> ProjectBuilder<C, T> {
             slash_paths,
             settings,
             sparse_output,
+            additional_settings,
+            restrictions,
         } = self;
 
         let mut paths = paths.map(Ok).unwrap_or_else(ProjectPathsConfig::current_hardhat)?;
@@ -694,8 +724,8 @@ impl<C: Compiler, T: ArtifactOutput> ProjectBuilder<C, T> {
             slash_paths,
             settings: settings.unwrap_or_default(),
             sparse_output,
-            additional_settings: Default::default(),
-            restrictions: Default::default(),
+            additional_settings,
+            restrictions,
         })
     }
 }

crates/compilers/src/resolver/mod.rs

@@ -580,10 +580,20 @@ impl<L: Language, D: ParsedSource<Language = L>> Graph<D> {
     }
 
     /// Filters incompatible versions from the `candidates`.
-    fn retain_compatible_versions(&self, idx: usize, candidates: &mut Vec<&CompilerVersion>) {
+    fn retain_compatible_versions<C: Compiler, T: ArtifactOutput>(
+        &self,
+        idx: usize,
+        project: &Project<C, T>,
+        candidates: &mut Vec<&CompilerVersion>,
+    ) {
         let nodes: HashSet<_> = self.node_ids(idx).collect();
         for node in nodes {
-            if let Some(req) = &self.node(node).data.version_req() {
+            let node = self.node(node);
+            if let Some(req) = node.data.version_req() {
+                candidates.retain(|v| req.matches(v.as_ref()));
+            }
+            if let Some(req) = project.restrictions.get(&node.path).and_then(|r| r.version.as_ref())
+            {
                 candidates.retain(|v| req.matches(v.as_ref()));
             }
             if candidates.is_empty() {
@@ -604,7 +614,7 @@ impl<L: Language, D: ParsedSource<Language = L>> Graph<D> {
             let node = self.node(node);
             if let Some(requirement) = project.restrictions.get(&node.path) {
                 candidates
-                    .retain(|(_, (_, settings))| settings.satisfies_restrictions(requirement));
+                    .retain(|(_, (_, settings))| settings.satisfies_restrictions(&*requirement));
             }
             if candidates.is_empty() {
                 // nothing to filter anymore
@@ -677,7 +687,7 @@ impl<L: Language, D: ParsedSource<Language = L>> Graph<D> {
                 let mut candidates = all_versions.iter().collect::<Vec<_>>();
                 // remove all incompatible versions from the candidates list by checking the node
                 // and all its imports
-                self.retain_compatible_versions(idx, &mut candidates);
+                self.retain_compatible_versions(idx, project, &mut candidates);
 
                 if candidates.is_empty() && !erroneous_nodes.contains(&idx) {
                     // check if the version is even valid
@@ -759,14 +769,20 @@ impl<L: Language, D: ParsedSource<Language = L>> Graph<D> {
             for (version, nodes) in versions {
                 let mut profile_to_nodes = HashMap::new();
                 for idx in nodes {
+                    println!("resolving {:?}", self.node(idx).path.display());
                     let mut profile_candidates =
                         project.settings_profiles().enumerate().collect::<Vec<_>>();
                     self.retain_compatible_profiles(idx, project, &mut profile_candidates);
 
-                    profile_to_nodes
-                        .entry(profile_candidates[0].0)
-                        .or_insert_with(Vec::new)
-                        .push(idx);
+                    if let Some((profile_idx, _)) = profile_candidates.first() {
+                        profile_to_nodes.entry(*profile_idx).or_insert_with(Vec::new).push(idx);
+                    } else {
+                        panic!(
+                            "failed to resolve settings for node {}",
+                            self.node(idx).path.display()
+                        );
+                    }
+                    println!("resolved");
                 }
                 versioned_sources.insert(version, profile_to_nodes);
             }