[wip] feat: compilation restrictions

Author: klkvr

Cargo.lock

@@ -264,3 +264,6 @@ soldeer = "0.2.19"
 
 proptest = "1"
 comfy-table = "7"
+
+[patch.crates-io]
+foundry-compilers = { git = "https://github.com/foundry-rs/compilers", rev = "f7970a3" }

Cargo.toml

@@ -0,0 +1,75 @@
+use crate::{filter::GlobMatcher, serde_helpers};
+use foundry_compilers::{
+    artifacts::EvmVersion,
+    multi::{MultiCompilerRestrictions, MultiCompilerSettings},
+    settings::VyperRestrictions,
+    solc::{EvmVersionRestriction, SolcRestrictions},
+    RestrictionsWithVersion,
+};
+use semver::VersionReq;
+use serde::{Deserialize, Serialize};
+
+/// Keeps possible overrides for default settings which users may configure to construct additional
+/// settings profile.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct SettingsOverrides {
+    via_ir: Option<bool>,
+    #[serde(default, with = "serde_helpers::display_from_str_opt")]
+    evm_version: Option<EvmVersion>,
+    optimizer: Option<bool>,
+    optimizer_runs: Option<usize>,
+}
+
+impl SettingsOverrides {
+    /// Applies the overrides to the given settings.
+    pub fn apply(&self, settings: &mut MultiCompilerSettings) {
+        if let Some(via_ir) = self.via_ir {
+            settings.solc.via_ir = Some(via_ir);
+        }
+
+        if let Some(evm_version) = self.evm_version {
+            settings.solc.evm_version = Some(evm_version);
+            settings.vyper.evm_version = Some(evm_version);
+        }
+
+        if let Some(enabled) = self.optimizer {
+            settings.solc.optimizer.enabled = Some(enabled);
+        }
+
+        if let Some(optimizer_runs) = self.optimizer_runs {
+            settings.solc.optimizer.runs = Some(optimizer_runs);
+        }
+    }
+}
+
+/// Restrictions for compilation of given paths.
+///
+/// Only purpose of this type is to accept user input to later construct
+/// `RestrictionsWithVersion<MultiCompilerRestrictions>`.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct CompilationRestrictions {
+    pub paths: GlobMatcher,
+    version: Option<VersionReq>,
+    via_ir: Option<bool>,
+    min_optimizer_runs: Option<usize>,
+    max_optimizer_runs: Option<usize>,
+    #[serde(flatten)]
+    evm_version: EvmVersionRestriction,
+}
+
+impl From<CompilationRestrictions> for RestrictionsWithVersion<MultiCompilerRestrictions> {
+    fn from(value: CompilationRestrictions) -> Self {
+        RestrictionsWithVersion {
+            restrictions: MultiCompilerRestrictions {
+                solc: SolcRestrictions {
+                    evm_version: value.evm_version,
+                    via_ir: value.via_ir,
+                    min_optimizer_runs: value.min_optimizer_runs,
+                    max_optimizer_runs: value.max_optimizer_runs,
+                },
+                vyper: VyperRestrictions { evm_version: value.evm_version },
+            },
+            version: value.version,
+        }
+    }
+}

crates/config/src/compilation.rs

@@ -33,8 +33,10 @@ use foundry_compilers::{
         Compiler,
     },
     error::SolcError,
+    multi::{MultiCompilerParsedSource, MultiCompilerRestrictions},
     solc::{CliSettings, SolcSettings},
-    ConfigurableArtifacts, Project, ProjectPathsConfig, VyperLanguage,
+    ConfigurableArtifacts, Graph, Project, ProjectPathsConfig, RestrictionsWithVersion,
+    VyperLanguage,
 };
 use inflector::Inflector;
 use regex::Regex;
@@ -43,7 +45,7 @@ use semver::Version;
 use serde::{Deserialize, Serialize, Serializer};
 use std::{
     borrow::Cow,
-    collections::HashMap,
+    collections::{BTreeMap, HashMap},
     fs,
     path::{Path, PathBuf},
     str::FromStr,
@@ -115,6 +117,9 @@ use vyper::VyperConfig;
 mod bind_json;
 use bind_json::BindJsonConfig;
 
+mod compilation;
+use compilation::{CompilationRestrictions, SettingsOverrides};
+
 /// Foundry configuration
 ///
 /// # Defaults
@@ -451,6 +456,14 @@ pub struct Config {
     #[serde(rename = "__warnings", default, skip_serializing)]
     pub warnings: Vec<Warning>,
 
+    /// Additional settings profiles to use when compiling.
+    #[serde(default)]
+    pub additional_compiler_profiles: BTreeMap<String, SettingsOverrides>,
+
+    /// Restrictions on compilation of certain files.
+    #[serde(default)]
+    pub compilation_restrictions: Vec<CompilationRestrictions>,
+
     /// PRIVATE: This structure may grow, As such, constructing this structure should
     /// _always_ be done using a public constructor or update syntax:
     ///
@@ -816,12 +829,65 @@ impl Config {
         self.create_project(false, true)
     }
 
+    /// Builds mapping with additional settings profiles.
+    fn additional_settings(
+        &self,
+        base: &MultiCompilerSettings,
+    ) -> BTreeMap<String, MultiCompilerSettings> {
+        let mut map = BTreeMap::new();
+
+        for (name, profile) in &self.additional_compiler_profiles {
+            let mut settings = base.clone();
+            profile.apply(&mut settings);
+            map.insert(name.clone(), settings);
+        }
+
+        map
+    }
+
+    /// Resolves globs and builds a mapping from individual source files to their restrictions
+    fn restrictions(
+        &self,
+        paths: &ProjectPathsConfig,
+    ) -> Result<BTreeMap<PathBuf, RestrictionsWithVersion<MultiCompilerRestrictions>>, SolcError>
+    {
+        let mut map = BTreeMap::new();
+
+        let graph = Graph::<MultiCompilerParsedSource>::resolve(paths)?;
+        let (sources, _) = graph.into_sources();
+
+        for res in &self.compilation_restrictions {
+            for source in sources.keys().filter(|path| {
+                if res.paths.is_match(path) {
+                    true
+                } else if let Ok(path) = path.strip_prefix(&paths.root) {
+                    res.paths.is_match(path)
+                } else {
+                    false
+                }
+            }) {
+                let res: RestrictionsWithVersion<_> = res.clone().into();
+                if !map.contains_key(source) {
+                    map.insert(source.clone(), res);
+                } else {
+                    map.get_mut(source.as_path()).unwrap().merge(res);
+                }
+            }
+        }
+
+        Ok(map)
+    }
+
     /// Creates a [Project] with the given `cached` and `no_artifacts` flags
     pub fn create_project(&self, cached: bool, no_artifacts: bool) -> Result<Project, SolcError> {
+        let settings = self.compiler_settings()?;
+        let paths = self.project_paths();
         let mut builder = Project::builder()
             .artifacts(self.configured_artifacts_handler())
-            .paths(self.project_paths())
-            .settings(self.compiler_settings()?)
+            .additional_settings(self.additional_settings(&settings))
+            .restrictions(self.restrictions(&paths)?)
+            .settings(settings)
+            .paths(paths)
             .ignore_error_codes(self.ignored_error_codes.iter().copied().map(Into::into))
             .ignore_paths(self.ignored_file_paths.clone())
             .set_compiler_severity_filter(if self.deny_warnings {
@@ -2139,6 +2205,8 @@ impl Default for Config {
             warnings: vec![],
             extra_args: vec![],
             eof_version: None,
+            additional_compiler_profiles: Default::default(),
+            compilation_restrictions: vec![],
             _non_exhaustive: (),
         }
     }

crates/config/src/lib.rs

@@ -72,7 +72,7 @@ impl BindJsonArgs {
         // We only generate bindings for a single Solidity version to avoid conflicts.
         let mut sources = graph
             // resolve graph into mapping language -> version -> sources
-            .into_sources_by_version(project.offline, &project.locked_versions, &project.compiler)?
+            .into_sources_by_version(&project)?
             .0
             .into_iter()
             // we are only interested in Solidity sources
@@ -81,7 +81,7 @@ impl BindJsonArgs {
             .1
             .into_iter()
             // For now, we are always picking the latest version.
-            .max_by(|(v1, _), (v2, _)| v1.cmp(v2))
+            .max_by(|(v1, _, _), (v2, _, _)| v1.cmp(v2))
             .unwrap()
             .1;
 

crates/forge/bin/cmd/bind_json.rs

@@ -90,7 +90,7 @@ impl EtherscanFlattenedSource {
         let out = SolcCompiler::Specific(solc).compile(&input)?;
         if out.errors.iter().any(|e| e.is_error()) {
             let mut o = AggregatedCompilerOutput::<SolcCompiler>::default();
-            o.extend(version, RawBuildInfo::new(&input, &out, false)?, out);
+            o.extend(version, RawBuildInfo::new(&input, &out, false)?, "default", out);
             let diags = o.diagnostics(&[], &[], Default::default());
 
             eyre::bail!(