WIP integrate new Mode/ParsedMode into rest of code

crates/format/src/case.rs

@@ -4,14 +4,14 @@ use revive_dt_common::macros::define_wrapper_type;
 
 use crate::{
     input::{Expected, Input},
-    mode::Mode,
+    mode::ParsedMode,
 };
 
 #[derive(Debug, Default, Deserialize, Clone, Eq, PartialEq)]
 pub struct Case {
     pub name: Option<String>,
     pub comment: Option<String>,
-    pub modes: Option<Vec<Mode>>,
+    pub modes: Option<Vec<ParsedMode>>,
     pub inputs: Vec<Input>,
     pub group: Option<String>,
     pub expected: Option<Expected>,

crates/format/src/metadata.rs

@@ -13,7 +13,7 @@ use revive_dt_common::{iterators::FilesWithExtensionIterator, macros::define_wra
 
 use crate::{
     case::Case,
-    mode::{Mode, SolcMode},
+    mode::{Mode, ParsedMode},
 };
 
 pub const METADATA_FILE_EXTENSION: &str = "json";
@@ -51,26 +51,17 @@ pub struct Metadata {
     // TODO: Convert into wrapper types for clarity.
     pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
     pub ignore: Option<bool>,
-    pub modes: Option<Vec<Mode>>,
+    pub modes: Option<Vec<ParsedMode>>,
     pub file_path: Option<PathBuf>,
 }
 
 impl Metadata {
-    /// Returns the solc modes of this metadata, inserting a default mode if not present.
-    pub fn solc_modes(&self) -> Vec<SolcMode> {
-        self.modes
-            .to_owned()
-            .unwrap_or_else(|| vec![Mode::Solidity(Default::default())])
-            .iter()
-            .filter_map(|mode| match mode {
-                Mode::Solidity(solc_mode) => Some(solc_mode),
-                Mode::Unknown(mode) => {
-                    tracing::debug!("compiler: ignoring unknown mode '{mode}'");
-                    None
-                }
-            })
-            .cloned()
-            .collect()
+    /// Returns the modes that we should test from this metadata.
+    pub fn test_modes(&self) -> Vec<Mode> {
+        match &self.modes {
+            Some(modes) => Mode::from_parsed_modes(modes.iter()).collect(),
+            None => Mode::all().collect()
+        }
     }
 
     /// Returns the base directory of this metadata.

crates/format/src/mode.rs

@@ -14,14 +14,14 @@ use std::collections::HashSet;
 /// in its requirements, and then expanding it out into a list of [`TestMode`]s.
 /// 
 /// Use [`ParsedMode::to_test_modes()`] to do this.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct TestMode {
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct Mode {
     pub pipeline: ModePipeline,
     pub optimize_setting: ModeOptimizerSetting,
     pub version: Option<semver::VersionReq>,
 }
 
-impl Display for TestMode {
+impl Display for Mode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         fmt_mode_parts(
             Some(&self.pipeline),
@@ -33,7 +33,7 @@ impl Display for TestMode {
     }
 }
 
-impl TestMode {
+impl Mode {
     /// Return a set of [`TestMode`]s that correspond to the given [`ParsedMode`]s.
     /// This avoids any duplicate entries. 
     pub fn from_parsed_modes<'a>(parsed: impl Iterator<Item = &'a ParsedMode>) -> impl Iterator<Item = Self> {
@@ -62,7 +62,7 @@ impl TestMode {
 /// ```
 /// 
 /// We can parse valid mode strings into [`ParsedMode`] using [`ParsedMode::from_str`].
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct ParsedMode {
     pub pipeline: Option<ModePipeline>,
     pub optimize_flag: Option<bool>,
@@ -118,6 +118,26 @@ impl FromStr for ParsedMode {
     }
 }
 
+impl<'de> Deserialize<'de> for ParsedMode {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let mode_string = String::deserialize(deserializer)?;
+        ParsedMode::from_str(&mode_string).map_err(serde::de::Error::custom)
+    }
+}
+
+impl Serialize for ParsedMode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mode_string = self.to_string();
+        serializer.serialize_str(&mode_string)
+    }
+}
+
 impl Display for ParsedMode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         fmt_mode_parts(
@@ -163,7 +183,7 @@ fn fmt_mode_parts(
 
 impl ParsedMode {
     /// This takes a [`ParsedMode`] and expands it into a list of [`TestMode`]s that we should try.
-    pub fn to_test_modes(&self) -> impl Iterator<Item = TestMode> {
+    pub fn to_test_modes(&self) -> impl Iterator<Item = Mode> {
         let pipeline_iter = self.pipeline.as_ref().map_or_else(
             || EitherIter::A(ModePipeline::test_cases()),
             |p| EitherIter::B(std::iter::once(*p)),
@@ -185,7 +205,7 @@ impl ParsedMode {
 
         pipeline_iter.flat_map(move |pipeline| {
             optimize_settings_iter.clone().map(move |optimize_setting| {
-                TestMode {
+                Mode {
                     pipeline,
                     optimize_setting,
                     version: self.version.clone(),
@@ -208,7 +228,7 @@ pub enum ParseModeError {
 }
 
 /// What do we want the compiler to do?
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
 pub enum ModePipeline {
     /// Compile Solidity code via Yul IR
     Y,
@@ -247,7 +267,7 @@ impl ModePipeline {
     }
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
 pub enum ModeOptimizerSetting {
     /// 0 / -: Don't apply any optimizations
     M0,
@@ -395,7 +415,7 @@ mod tests {
 
 
 
-
+/*
 
 
 
@@ -500,3 +520,5 @@ impl<'de> Deserialize<'de> for Mode {
         Ok(Self::Unknown(mode_string))
     }
 }
+
+*/