Rename ModePipeline::E/Y

crates/common/src/types/mode.rs

@@ -245,9 +245,11 @@ pub enum ParseModeError {
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
 pub enum ModePipeline {
     /// Compile Solidity code via Yul IR
-    Y,
+    #[serde(rename = "Y")]
+    ViaYulIR,
     /// Compile Solidity direct to assembly
-    E,
+    #[serde(rename = "E")]
+    ViaEVMAssembly,
 }
 
 impl FromStr for ModePipeline {
@@ -255,9 +257,9 @@ impl FromStr for ModePipeline {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             // via Yul IR
-            "Y" => Ok(ModePipeline::Y),
+            "Y" => Ok(ModePipeline::ViaYulIR),
             // Don't go via Yul IR
-            "E" => Ok(ModePipeline::E),
+            "E" => Ok(ModePipeline::ViaEVMAssembly),
             // Anything else that we see isn't a mode at all
             _ => Err(ParseModeError::UnsupportedPipeline(
                 s.chars().next().unwrap_or('?'),
@@ -269,8 +271,8 @@ impl FromStr for ModePipeline {
 impl Display for ModePipeline {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ModePipeline::Y => f.write_str("Y"),
-            ModePipeline::E => f.write_str("E"),
+            ModePipeline::ViaYulIR => f.write_str("Y"),
+            ModePipeline::ViaEVMAssembly => f.write_str("E"),
         }
     }
 }
@@ -278,13 +280,13 @@ impl Display for ModePipeline {
 impl ModePipeline {
     /// Should we go via Yul IR?
     pub fn via_yul_ir(&self) -> bool {
-        matches!(self, ModePipeline::Y)
+        matches!(self, ModePipeline::ViaYulIR)
     }
 
     /// An iterator over the available pipelines that we'd like to test,
     /// when an explicit pipeline was not specified.
     pub fn test_cases() -> impl Iterator<Item = ModePipeline> + Clone {
-        [ModePipeline::Y, ModePipeline::E].into_iter()
+        [ModePipeline::ViaYulIR, ModePipeline::ViaEVMAssembly].into_iter()
     }
 }
 

crates/compiler/src/constants.rs

@@ -1,4 +1,4 @@
 use semver::Version;
 
 /// This is the first version of solc that supports the `--via-ir` flag / "viaIR" input JSON.
-pub const VERSION_SUPPORTING_VIA_IR: Version = Version::new(0, 8, 13);
+pub const SOLC_VERSION_SUPPORTING_VIA_YUL_IR: Version = Version::new(0, 8, 13);

crates/compiler/src/revive_resolc.rs

@@ -14,7 +14,7 @@ use revive_solc_json_interface::{
     SolcStandardJsonOutput,
 };
 
-use super::constants::VERSION_SUPPORTING_VIA_IR;
+use super::constants::SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
 use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
 
 use alloy::json_abi::JsonAbi;
@@ -53,7 +53,7 @@ impl SolidityCompiler for Resolc {
         }: CompilerInput,
         additional_options: Self::Options,
     ) -> anyhow::Result<CompilerOutput> {
-        if !matches!(pipeline, None | Some(ModePipeline::Y)) {
+        if !matches!(pipeline, None | Some(ModePipeline::ViaYulIR)) {
             anyhow::bail!(
                 "Resolc only supports the Y (via Yul IR) pipeline, but the provided pipeline is {pipeline:?}"
             );
@@ -249,7 +249,8 @@ impl SolidityCompiler for Resolc {
         // We only support the Y (IE compile via Yul IR) mode here, which also means that we can
         // only use solc version 0.8.13 and above. We must always compile via Yul IR as resolc
         // needs this to translate to LLVM IR and then RISCV.
-        pipeline == ModePipeline::Y && compiler_version >= &VERSION_SUPPORTING_VIA_IR
+        pipeline == ModePipeline::ViaYulIR
+            && compiler_version >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR
     }
 }
 

crates/compiler/src/solc.rs

@@ -10,7 +10,7 @@ use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 use revive_dt_solc_binaries::download_solc;
 
-use super::constants::VERSION_SUPPORTING_VIA_IR;
+use super::constants::SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
 use crate::{CompilerInput, CompilerOutput, ModeOptimizerSetting, ModePipeline, SolidityCompiler};
 
 use anyhow::Context;
@@ -47,7 +47,7 @@ impl SolidityCompiler for Solc {
         }: CompilerInput,
         _: Self::Options,
     ) -> anyhow::Result<CompilerOutput> {
-        let compiler_supports_via_ir = self.version()? >= VERSION_SUPPORTING_VIA_IR;
+        let compiler_supports_via_ir = self.version()? >= SOLC_VERSION_SUPPORTING_VIA_YUL_IR;
 
         // Be careful to entirely omit the viaIR field if the compiler does not support it,
         // as it will error if you provide fields it does not know about. Because
@@ -242,8 +242,9 @@ impl SolidityCompiler for Solc {
     ) -> bool {
         // solc 0.8.13 and above supports --via-ir, and less than that does not. Thus, we support mode E
         // (ie no Yul IR) in either case, but only support Y (via Yul IR) if the compiler is new enough.
-        pipeline == ModePipeline::E
-            || (pipeline == ModePipeline::Y && compiler_version >= &VERSION_SUPPORTING_VIA_IR)
+        pipeline == ModePipeline::ViaEVMAssembly
+            || (pipeline == ModePipeline::ViaYulIR
+                && compiler_version >= &SOLC_VERSION_SUPPORTING_VIA_YUL_IR)
     }
 }