wip

Author: klkvr

crates/compilers/src/artifact_output/mod.rs

@@ -52,6 +52,7 @@ pub struct ArtifactId {
     pub version: Version,
     /// `solc` build id
     pub build_id: String,
+    pub profile: String,
 }
 
 impl ArtifactId {
@@ -299,6 +300,7 @@ impl<T> Artifacts<T> {
                                 source: source.clone(),
                                 version: artifact.version.clone(),
                                 build_id: artifact.build_id.clone(),
+                                profile: artifact.profile.clone(),
                             }
                             .with_slashed_paths(),
                             &artifact.artifact,
@@ -325,6 +327,7 @@ impl<T> Artifacts<T> {
                                 source: source.clone(),
                                 version: artifact.version,
                                 build_id: artifact.build_id.clone(),
+                                profile: artifact.profile.clone(),
                             }
                             .with_slashed_paths(),
                             artifact.artifact,
@@ -873,13 +876,11 @@ pub trait ArtifactOutput {
                 let unique_profiles =
                     versioned_contracts.iter().map(|c| &c.profile).collect::<HashSet<_>>();
                 for contract in versioned_contracts {
+                    non_standalone_sources.insert(file);
+
                     // track `SourceFile`s that can be mapped to contracts
                     let source_file = sources.find_file_and_version(file, &contract.version);
 
-                    if let Some(source) = source_file {
-                        non_standalone_sources.insert((source.id, &contract.version));
-                    }
-
                     let artifact_path = Self::get_artifact_path(
                         &ctx,
                         &taken_paths_lowercase,
@@ -934,7 +935,7 @@ pub trait ArtifactOutput {
             let unique_versions = sources.iter().map(|s| &s.version).collect::<HashSet<_>>();
             let unique_profiles = sources.iter().map(|s| &s.profile).collect::<HashSet<_>>();
             for source in sources {
-                if !non_standalone_sources.contains(&(source.source_file.id, &source.version)) {
+                if !non_standalone_sources.contains(file) {
                     // scan the ast as a safe measure to ensure this file does not include any
                     // source units
                     // there's also no need to create a standalone artifact for source files that
@@ -962,24 +963,21 @@ pub trait ArtifactOutput {
                                 unique_profiles.len() > 1,
                             );
 
-                            let entries = artifacts
+                            taken_paths_lowercase
+                                .insert(artifact_path.to_slash_lossy().to_lowercase());
+
+                            artifacts
                                 .entry(file.clone())
                                 .or_default()
                                 .entry(name.to_string())
-                                .or_default();
-
-                            if entries.iter().all(|entry| entry.version != source.version) {
-                                taken_paths_lowercase
-                                    .insert(artifact_path.to_slash_lossy().to_lowercase());
-
-                                entries.push(ArtifactFile {
+                                .or_default()
+                                .push(ArtifactFile {
                                     artifact,
                                     file: artifact_path,
                                     version: source.version.clone(),
                                     build_id: source.build_id.clone(),
                                     profile: source.profile.clone(),
                                 });
-                            }
                         }
                     }
                 }

crates/compilers/src/cache.rs

@@ -64,11 +64,6 @@ impl<S: CompilerSettings> CompilerCache<S> {
         self.files.is_empty()
     }
 
-    /// Returns `true` if the cache contains any artifacts for the given file and version.
-    pub fn contains(&self, file: &Path, version: &Version) -> bool {
-        self.files.get(file).map_or(true, |entry| !entry.contains_version(version))
-    }
-
     /// Removes entry for the given file
     pub fn remove(&mut self, file: &Path) -> Option<CacheEntry> {
         self.files.remove(file)
@@ -533,8 +528,10 @@ impl CacheEntry {
     }
 
     /// Returns `true` if the artifacts set contains the given version
-    pub fn contains_version(&self, version: &Version) -> bool {
-        self.artifacts_versions().any(|(v, _, _)| v == version)
+    pub fn contains(&self, version: &Version, profile: &str) -> bool {
+        self.artifacts.values().any(|artifacts| {
+            artifacts.get(version).and_then(|artifacts| artifacts.get(profile)).is_some()
+        })
     }
 
     /// Iterator that yields all artifact files and their version
@@ -688,7 +685,7 @@ impl<'a, T: ArtifactOutput, C: Compiler> ArtifactsCacheInner<'a, T, C> {
     /// 2. [SourceCompilationKind::Optimized] - the file is not dirty, but is imported by a dirty
     ///    file and thus will be processed by solc. For such files we don't need full data, so we
     ///    are marking them as clean to optimize output selection later.
-    fn filter(&mut self, sources: &mut Sources, version: &Version) {
+    fn filter(&mut self, sources: &mut Sources, version: &Version, profile: &str) {
         // sources that should be passed to compiler.
         let mut compile_complete = HashSet::new();
         let mut compile_optimized = HashSet::new();
@@ -697,7 +694,7 @@ impl<'a, T: ArtifactOutput, C: Compiler> ArtifactsCacheInner<'a, T, C> {
             self.sources_in_scope.insert(file.clone(), version.clone());
 
             // If we are missing artifact for file, compile it.
-            if self.is_missing_artifacts(file, version) {
+            if self.is_missing_artifacts(file, version, profile) {
                 compile_complete.insert(file.clone());
             }
 
@@ -731,7 +728,7 @@ impl<'a, T: ArtifactOutput, C: Compiler> ArtifactsCacheInner<'a, T, C> {
 
     /// Returns whether we are missing artifacts for the given file and version.
     #[instrument(level = "trace", skip(self))]
-    fn is_missing_artifacts(&self, file: &Path, version: &Version) -> bool {
+    fn is_missing_artifacts(&self, file: &Path, version: &Version, profile: &str) -> bool {
         let Some(entry) = self.cache.entry(file) else {
             trace!("missing cache entry");
             return true;
@@ -745,7 +742,7 @@ impl<'a, T: ArtifactOutput, C: Compiler> ArtifactsCacheInner<'a, T, C> {
             return false;
         }
 
-        if !entry.contains_version(version) {
+        if !entry.contains(version, profile) {
             trace!("missing linked artifacts");
             return true;
         }
@@ -788,6 +785,7 @@ impl<'a, T: ArtifactOutput, C: Compiler> ArtifactsCacheInner<'a, T, C> {
                 .get(profile.as_str())
                 .map_or(false, |p| p.can_use_cached(settings))
             {
+                trace!("dirty profile: {}", profile);
                 dirty_profiles.insert(profile.clone());
             }
         }
@@ -796,15 +794,20 @@ impl<'a, T: ArtifactOutput, C: Compiler> ArtifactsCacheInner<'a, T, C> {
             self.cache.profiles.remove(profile);
         }
 
-        for (_, entry) in &mut self.cache.files {
+        self.cache.files.retain(|_, entry| {
+            // keep entries which already had no artifacts
+            if entry.artifacts.is_empty() {
+                return true;
+            }
             entry.artifacts.retain(|_, artifacts| {
                 artifacts.retain(|_, artifacts| {
                     artifacts.retain(|profile, _| !dirty_profiles.contains(profile));
                     !artifacts.is_empty()
                 });
                 !artifacts.is_empty()
             });
-        }
+            !entry.artifacts.is_empty()
+        });
 
         for (profile, settings) in existing_profiles {
             if !self.cache.profiles.contains_key(profile) {
@@ -1031,10 +1034,10 @@ impl<'a, T: ArtifactOutput, C: Compiler> ArtifactsCache<'a, T, C> {
     }
 
     /// Filters out those sources that don't need to be compiled
-    pub fn filter(&mut self, sources: &mut Sources, version: &Version) {
+    pub fn filter(&mut self, sources: &mut Sources, version: &Version, profile: &str) {
         match self {
             ArtifactsCache::Ephemeral(..) => {}
-            ArtifactsCache::Cached(cache) => cache.filter(sources, version),
+            ArtifactsCache::Cached(cache) => cache.filter(sources, version, profile),
         }
     }
 

crates/compilers/src/compile/project.rs

@@ -392,9 +392,9 @@ impl<L: Language, S: CompilerSettings> CompilerSources<'_, L, S> {
     ) {
         cache.remove_dirty_sources();
         for versioned_sources in self.sources.values_mut() {
-            for (version, sources, _) in versioned_sources {
+            for (version, sources, (profile, _)) in versioned_sources {
                 trace!("Filtering {} sources for {}", sources.len(), version);
-                cache.filter(sources, version);
+                cache.filter(sources, version, profile);
                 trace!(
                     "Detected {} sources to compile {:?}",
                     sources.dirty().count(),

crates/compilers/src/compilers/multi.rs

@@ -138,9 +138,9 @@ 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(&mut self, other: Self) {
+        self.solc.merge(other.solc);
+        self.vyper.merge(other.vyper);
     }
 }
 

crates/compilers/src/compilers/restrictions.rs

@@ -6,27 +6,40 @@ use std::{
 use semver::VersionReq;
 
 pub trait CompilerSettingsRestrictions: Debug + Sync + Send + Clone + Default {
-    fn merge(&mut self, other: &Self);
+    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,
+    pub restrictions: T,
+}
+
+impl<T: CompilerSettingsRestrictions> RestrictionsWithVersion<T> {
+    pub fn merge(&mut self, other: Self) {
+        if let Some(version) = other.version {
+            if let Some(self_version) = self.version.as_mut() {
+                self_version.comparators.extend(version.comparators);
+            } else {
+                self.version = Some(version.clone());
+            }
+        }
+        self.restrictions.merge(other.restrictions);
+    }
 }
 
 impl<T> Deref for RestrictionsWithVersion<T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        &self.settings
+        &self.restrictions
     }
 }
 
 impl<T> DerefMut for RestrictionsWithVersion<T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.settings
+        &mut self.restrictions
     }
 }

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

@@ -234,13 +234,27 @@ pub struct SolcRestrictions {
 }
 
 impl CompilerSettingsRestrictions for SolcRestrictions {
-    fn merge(&mut self, other: &Self) {
+    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;
+        }
+
+        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;
+        }
     }
 }
 

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

@@ -13,7 +13,7 @@ pub struct VyperRestrictions {
 }
 
 impl CompilerSettingsRestrictions for VyperRestrictions {
-    fn merge(&mut self, other: &Self) {
+    fn merge(&mut self, other: Self) {
         self.evm_version.merge(&other.evm_version);
     }
 }

crates/compilers/src/resolver/mod.rs

@@ -500,7 +500,7 @@ impl<L: Language, D: ParsedSource<Language = L>> Graph<D> {
         }
 
         let versioned_nodes = self.get_input_node_versions(project)?;
-        let versioned_nodes = self.resolve_settings(project, versioned_nodes);
+        let versioned_nodes = self.resolve_settings(project, versioned_nodes)?;
         let (nodes, edges) = self.split();
 
         let mut all_nodes = nodes.into_iter().enumerate().collect::<HashMap<_, _>>();
@@ -557,16 +557,20 @@ impl<L: Language, D: ParsedSource<Language = L>> Graph<D> {
     ///     path/to/c.sol (<version>)
     ///     ...
     /// ```
-    fn format_imports_list<W: std::fmt::Write>(
+    fn format_imports_list<W: std::fmt::Write, C: Compiler<Language = L>, T: ArtifactOutput>(
         &self,
         idx: usize,
+        project: &Project<C, T>,
         f: &mut W,
     ) -> std::result::Result<(), std::fmt::Error> {
         let node = self.node(idx);
         write!(f, "{} ", utils::source_name(&node.path, &self.root).display())?;
         if let Some(req) = node.data.version_req() {
             write!(f, "{req}")?;
         }
+        if let Some(req) = project.restrictions.get(&node.path).and_then(|r| r.version.as_ref()) {
+            write!(f, "{req}")?;
+        }
         write!(f, " imports:")?;
         for dep in self.node_ids(idx).skip(1) {
             let dep = self.node(dep);
@@ -701,7 +705,7 @@ impl<L: Language, D: ParsedSource<Language = L>> Graph<D> {
                         ));
                     } else {
                         let mut msg = String::new();
-                        self.format_imports_list(idx, &mut msg).unwrap();
+                        self.format_imports_list(idx, project, &mut msg).unwrap();
                         errors.push(format!("Found incompatible versions:\n{msg}"));
                     }
 
@@ -762,34 +766,37 @@ impl<L: Language, D: ParsedSource<Language = L>> Graph<D> {
         &self,
         project: &Project<C, T>,
         input_nodes_versions: HashMap<L, HashMap<Version, Vec<usize>>>,
-    ) -> HashMap<L, HashMap<Version, HashMap<usize, Vec<usize>>>> {
+    ) -> Result<HashMap<L, HashMap<Version, HashMap<usize, Vec<usize>>>>> {
         let mut resulted_sources = HashMap::new();
+        let mut errors = Vec::new();
         for (language, versions) in input_nodes_versions {
             let mut versioned_sources = HashMap::new();
             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);
 
                     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()
-                        );
+                        let mut msg = String::new();
+                        self.format_imports_list(idx, project, &mut msg).unwrap();
+                        errors.push(format!("Found incompatible settings restrictions:\n{msg}"));
                     }
-                    println!("resolved");
                 }
                 versioned_sources.insert(version, profile_to_nodes);
             }
             resulted_sources.insert(language, versioned_sources);
         }
 
-        resulted_sources
+        if errors.is_empty() {
+            Ok(resulted_sources)
+        } else {
+            error!("failed to resolve settings");
+            Err(SolcError::msg(errors.join("\n")))
+        }
     }
 
     /// Tries to find the "best" set of versions to nodes, See [Solc version