chore: simplify pragma parsing

crates/compilers/src/compilers/solc/compiler.rs

@@ -128,9 +128,7 @@ impl Solc {
     /// Parses the given source looking for the `pragma` definition and
     /// returns the corresponding SemVer version requirement.
     pub fn source_version_req(source: &Source) -> Result<VersionReq> {
-        let version =
-            utils::find_version_pragma(&source.content).ok_or(SolcError::PragmaNotFound)?;
-        Ok(SolData::parse_version_req(version.as_str())?)
+        Ok(SolData::parse_version_pragma(&source.content).ok_or(SolcError::PragmaNotFound)??)
     }
 
     /// Given a Solidity source, it detects the latest compiler version which can be used

crates/compilers/src/config.rs

@@ -211,7 +211,7 @@ impl ProjectPathsConfig<SolcLanguage> {
             sources.push(content);
         }
 
-        if let Some(version) = combine_version_pragmas(version_pragmas) {
+        if let Some(version) = combine_version_pragmas(&version_pragmas) {
             result.push_str(&version);
             result.push('\n');
         }

crates/compilers/src/flatten.rs

@@ -17,7 +17,7 @@ use foundry_compilers_core::{
 };
 use itertools::Itertools;
 use std::{
-    collections::{HashMap, HashSet},
+    collections::{BTreeSet, HashMap, HashSet},
     hash::Hash,
     path::{Path, PathBuf},
 };
@@ -724,7 +724,7 @@ impl Flattener {
 
         let mut pragmas = Vec::new();
 
-        if let Some(version_pragma) = combine_version_pragmas(version_pragmas) {
+        if let Some(version_pragma) = combine_version_pragmas(&version_pragmas) {
             pragmas.push(version_pragma);
         }
 
@@ -881,26 +881,17 @@ pub fn collect_ordered_deps<D: ParsedSource + MaybeSolData>(
     Ok(ordered_deps)
 }
 
-pub fn combine_version_pragmas(pragmas: Vec<&str>) -> Option<String> {
-    let mut versions = pragmas
-        .into_iter()
-        .filter_map(|p| {
-            SolData::parse_version_req(
-                p.replace("pragma", "").replace("solidity", "").replace(';', "").trim(),
-            )
-            .ok()
-        })
+pub fn combine_version_pragmas(pragmas: &[impl AsRef<str>]) -> Option<String> {
+    let versions = pragmas
+        .iter()
+        .map(AsRef::as_ref)
+        .filter_map(SolData::parse_version_pragma)
+        .filter_map(Result::ok)
         .flat_map(|req| req.comparators)
-        .collect::<HashSet<_>>()
-        .into_iter()
         .map(|comp| comp.to_string())
-        .collect::<Vec<_>>();
-
-    versions.sort();
-
-    if !versions.is_empty() {
-        return Some(format!("pragma solidity {};", versions.iter().format(" ")));
+        .collect::<BTreeSet<_>>();
+    if versions.is_empty() {
+        return None;
     }
-
-    None
+    Some(format!("pragma solidity {};", versions.iter().format(" ")))
 }

crates/compilers/src/resolver/parse.rs

@@ -160,6 +160,14 @@ impl SolData {
         }
     }
 
+    /// Parses the version pragma and returns the corresponding SemVer version requirement.
+    ///
+    /// See [`parse_version_req`](Self::parse_version_req).
+    pub fn parse_version_pragma(pragma: &str) -> Option<Result<VersionReq, semver::Error>> {
+        let version = utils::find_version_pragma(pragma)?.as_str();
+        Some(Self::parse_version_req(version))
+    }
+
     /// Returns the corresponding SemVer version requirement for the solidity version.
     ///
     /// Note: This is a workaround for the fact that `VersionReq::parse` does not support whitespace