pezkuwichain/revive-differential-tests
1
0
Fork 0
mirror of https://github.com/pezkuwichain/revive-differential-tests.git synced 2026-06-13 01:11:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement compilation modes

Browse Source
This commit is contained in:
Omar Abdulla
2025-08-15 06:50:06 +03:00
parent f2045db0e9
commit 49f99f6152
8 changed files with 529 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/format/src/case.rs
+10 -3
View File
@@ -1,9 +1,12 @@
use std::collections::HashSet;
use serde::{Deserialize, Serialize};
use revive_dt_common::macros::define_wrapper_type;
use crate::{
input::{Expected, Step},
metadata::{deserialize_compilation_modes, serialize_compilation_modes},
mode::Mode,
};
@@ -15,8 +18,13 @@ pub struct Case {
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub modes: Option<Vec<Mode>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "deserialize_compilation_modes",
serialize_with = "serialize_compilation_modes"
)]
pub modes: Option<HashSet<Mode>>,
#[serde(rename = "inputs")]
pub steps: Vec<Step>,
@@ -32,7 +40,6 @@ pub struct Case {
}
impl Case {
#[allow(irrefutable_let_patterns)]
pub fn steps_iterator(&self) -> impl Iterator<Item = Step> {
let steps_len = self.steps.len();
self.steps
crates/format/src/metadata.rs
+41 -5
View File
@@ -1,6 +1,6 @@
use std::{
cmp::Ordering,
collections::BTreeMap,
collections::{BTreeMap, HashSet},
fmt::Display,
fs::{File, read_to_string},
ops::Deref,
@@ -8,7 +8,7 @@ use std::{
str::FromStr,
};
use serde::{Deserialize, Serialize};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use revive_common::EVMVersion;
use revive_dt_common::{iterators::FilesWithExtensionIterator, macros::define_wrapper_type};
@@ -65,8 +65,13 @@ pub struct Metadata {
#[serde(skip_serializing_if = "Option::is_none")]
pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub modes: Option<Vec<Mode>>,
#[serde(
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "deserialize_compilation_modes",
serialize_with = "serialize_compilation_modes"
)]
pub modes: Option<HashSet<Mode>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub file_path: Option<PathBuf>,
@@ -88,7 +93,7 @@ impl Metadata {
pub fn solc_modes(&self) -> Vec<SolcMode> {
self.modes
.to_owned()
.unwrap_or_else(|| vec![Mode::Solidity(Default::default())])
.unwrap_or_else(|| SolcMode::ALL.map(Mode::Solidity).iter().cloned().collect())
.iter()
.filter_map(|mode| match mode {
Mode::Solidity(solc_mode) => Some(solc_mode),
@@ -265,6 +270,37 @@ impl Metadata {
}
}
pub fn deserialize_compilation_modes<'de, D>(
deserializer: D,
) -> Result<Option<HashSet<Mode>>, D::Error>
where
D: Deserializer<'de>,
{
let maybe_strings = Option::<Vec<String>>::deserialize(deserializer)?;
Ok(maybe_strings.map(|strings| {
strings
.into_iter()
.flat_map(Mode::parse_from_string)
.collect()
}))
}
pub fn serialize_compilation_modes<S>(
value: &Option<HashSet<Mode>>,
serializer: S,
) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match value {
None => serializer.serialize_none(),
Some(modes) => {
let strings: Vec<String> = modes.iter().cloned().map(Into::<String>::into).collect();
serializer.serialize_some(&strings)
}
}
}
define_wrapper_type!(
/// Represents a contract instance found a metadata file.
///
crates/format/src/mode.rs
+362 -92
View File
@@ -1,123 +1,393 @@
use std::{fmt::Display, str::FromStr};
use revive_dt_common::types::VersionOrRequirement;
use semver::Version;
use serde::de::Deserializer;
use serde::{Deserialize, Serialize};
use serde::Serialize;
/// Specifies the compilation mode of the test artifact.
#[derive(Hash, Debug, Clone, Eq, PartialEq)]
/// Specifies a compilation mode for the test artifact that it requires. This is used as a filter
/// when used in the [`Metadata`] and is used as a directive when used in the core crate.
///
/// [`Metadata`]: crate::metadata::Metadata
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum Mode {
/// A compilation mode that's been parsed from a String and into its contents.
Solidity(SolcMode),
/// An unknown compilation mode.
Unknown(String),
}
/// Specify Solidity specific compiler options.
#[derive(Hash, Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize)]
impl From<Mode> for String {
fn from(value: Mode) -> Self {
value.to_string()
}
}
impl Display for Mode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Mode::Solidity(mode) => mode.fmt(f),
Mode::Unknown(string) => string.fmt(f),
}
}
}
impl Mode {
pub fn parse_from_string(str: impl AsRef<str>) -> Vec<Self> {
let mut chars = str.as_ref().chars().peekable();
let compile_via_ir = match chars.next() {
Some('Y') => true,
Some('E') => false,
_ => {
tracing::warn!("Encountered an unknown mode {}", str.as_ref());
return vec![Self::Unknown(str.as_ref().to_string())];
}
};
let optimize_flag = match chars.peek() {
Some('+') => {
let _ = chars.next();
Some(true)
}
Some('-') => {
let _ = chars.next();
Some(false)
}
_ => None,
};
let mut chars = chars.skip_while(|char| *char == ' ').peekable();
let version_requirement = match chars.peek() {
Some('=' | '>' | '<' | '~' | '^' | '*' | '0'..='9') => {
let version_requirement = chars.take_while(|char| *char != ' ').collect::<String>();
let Ok(version_requirement) = VersionOrRequirement::from_str(&version_requirement)
else {
return vec![Self::Unknown(str.as_ref().to_string())];
};
Some(version_requirement)
}
_ => None,
};
match optimize_flag {
Some(flag) => {
vec![Self::Solidity(SolcMode {
via_ir: compile_via_ir,
optimize: flag,
compiler_version_requirement: version_requirement,
})]
}
None => {
vec![
Self::Solidity(SolcMode {
via_ir: compile_via_ir,
optimize: true,
compiler_version_requirement: version_requirement.clone(),
}),
Self::Solidity(SolcMode {
via_ir: compile_via_ir,
optimize: false,
compiler_version_requirement: version_requirement,
}),
]
}
}
}
pub fn matches(&self, other: &Self) -> bool {
match (self, other) {
(
Mode::Solidity(SolcMode {
via_ir: self_via_ir,
optimize: self_optimize,
compiler_version_requirement: self_compiler_version_requirement,
}),
Mode::Solidity(SolcMode {
via_ir: other_via_ir,
optimize: other_optimize,
compiler_version_requirement: other_compiler_version_requirement,
}),
) => {
let mut matches = true;
matches &= self_via_ir == other_via_ir;
matches &= self_optimize == other_optimize;
match (
self_compiler_version_requirement,
other_compiler_version_requirement,
) {
(
Some(VersionOrRequirement::Version(self_version)),
Some(VersionOrRequirement::Version(other_version)),
) => {
matches &= self_version == other_version;
}
(
Some(VersionOrRequirement::Version(version)),
Some(VersionOrRequirement::Requirement(requirement)),
)
| (
Some(VersionOrRequirement::Requirement(requirement)),
Some(VersionOrRequirement::Version(version)),
) => matches &= requirement.matches(version),
(
Some(VersionOrRequirement::Requirement(..)),
Some(VersionOrRequirement::Requirement(..)),
) => matches = false,
(Some(_), None) | (None, Some(_)) | (None, None) => {}
}
matches
}
(Mode::Solidity { .. }, Mode::Unknown(_))
| (Mode::Unknown(_), Mode::Solidity { .. })
| (Mode::Unknown(_), Mode::Unknown(_)) => false,
}
}
pub fn as_solc_mode(&self) -> Option<&SolcMode> {
if let Self::Solidity(mode) = self {
Some(mode)
} else {
None
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
#[serde(into = "String")]
pub struct SolcMode {
pub solc_version: Option<semver::VersionReq>,
solc_optimize: Option<bool>,
pub llvm_optimizer_settings: Vec<String>,
mode_string: String,
pub via_ir: bool,
pub optimize: bool,
pub compiler_version_requirement: Option<VersionOrRequirement>,
}
impl SolcMode {
/// Try to parse a mode string into a solc mode.
/// Returns `None` if the string wasn't a solc YUL mode string.
///
/// The mode string is expected to start with the `Y` ID (YUL ID),
/// optionally followed by `+` or `-` for the solc optimizer settings.
///
/// Options can be separated by a whitespace contain the following
/// - A solc `SemVer version requirement` string
/// - One or more `-OX` where X is a supposed to be an LLVM opt mode
pub fn parse_from_mode_string(mode_string: &str) -> Option<Self> {
let mut result = Self {
mode_string: mode_string.to_string(),
..Default::default()
};
pub const ALL: [Self; 4] = [
SolcMode {
via_ir: false,
optimize: false,
compiler_version_requirement: None,
},
SolcMode {
via_ir: false,
optimize: true,
compiler_version_requirement: None,
},
SolcMode {
via_ir: true,
optimize: false,
compiler_version_requirement: None,
},
SolcMode {
via_ir: true,
optimize: true,
compiler_version_requirement: None,
},
];
let mut parts = mode_string.trim().split(" ");
match parts.next()? {
"Y" => {}
"Y+" => result.solc_optimize = Some(true),
"Y-" => result.solc_optimize = Some(false),
_ => return None,
}
for part in parts {
if let Ok(solc_version) = semver::VersionReq::parse(part) {
result.solc_version = Some(solc_version);
continue;
}
if let Some(level) = part.strip_prefix("-O") {
result.llvm_optimizer_settings.push(level.to_string());
continue;
}
panic!("the YUL mode string {mode_string} failed to parse, invalid part: {part}")
}
Some(result)
}
/// Returns whether to enable the solc optimizer.
pub fn solc_optimize(&self) -> bool {
self.solc_optimize.unwrap_or(true)
}
/// Calculate the latest matching solc patch version. Returns:
/// - `latest_supported` if no version request was specified.
/// - A matching version with the same minor version as `latest_supported`, if any.
/// - `None` if no minor version of the `latest_supported` version matches.
pub fn last_patch_version(&self, latest_supported: &Version) -> Option<Version> {
let Some(version_req) = self.solc_version.as_ref() else {
return Some(latest_supported.to_owned());
};
// lgtm
for patch in (0..latest_supported.patch + 1).rev() {
let version = Version::new(0, latest_supported.minor, patch);
if version_req.matches(&version) {
return Some(version);
}
}
None
pub fn matches(&self, other: &Self) -> bool {
Mode::Solidity(self.clone()).matches(&Mode::Solidity(other.clone()))
}
/// Resolves the [`SolcMode`]'s solidity version requirement into a [`VersionOrRequirement`] if
/// the requirement is present on the object. Otherwise, the passed default version is used.
pub fn compiler_version_to_use(&self, default: Version) -> VersionOrRequirement {
match self.solc_version {
Some(ref requirement) => requirement.clone().into(),
match self.compiler_version_requirement {
Some(ref requirement) => requirement.clone(),
None => default.into(),
}
}
}
impl<'de> Deserialize<'de> for Mode {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let mode_string = String::deserialize(deserializer)?;
impl Display for SolcMode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let Self {
via_ir,
optimize,
compiler_version_requirement,
} = self;
if let Some(solc_mode) = SolcMode::parse_from_mode_string(&mode_string) {
return Ok(Self::Solidity(solc_mode));
if *via_ir {
write!(f, "Y")?;
} else {
write!(f, "E")?;
}
Ok(Self::Unknown(mode_string))
if *optimize {
write!(f, "+")?;
} else {
write!(f, "-")?;
}
if let Some(req) = compiler_version_requirement {
write!(f, " {req}")?;
}
Ok(())
}
}
impl Serialize for Mode {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let string = match self {
Mode::Solidity(solc_mode) => &solc_mode.mode_string,
Mode::Unknown(string) => string,
};
string.serialize(serializer)
impl From<SolcMode> for String {
fn from(value: SolcMode) -> Self {
value.to_string()
}
}
#[cfg(test)]
mod test {
use semver::Version;
use super::*;
#[test]
fn mode_can_be_parsed_as_expected() {
// Arrange
let fixtures = [
(
"Y",
vec![
Mode::Solidity(SolcMode {
via_ir: true,
optimize: true,
compiler_version_requirement: None,
}),
Mode::Solidity(SolcMode {
via_ir: true,
optimize: false,
compiler_version_requirement: None,
}),
],
),
(
"Y+",
vec![Mode::Solidity(SolcMode {
via_ir: true,
optimize: true,
compiler_version_requirement: None,
})],
),
(
"Y-",
vec![Mode::Solidity(SolcMode {
via_ir: true,
optimize: false,
compiler_version_requirement: None,
})],
),
(
"E",
vec![
Mode::Solidity(SolcMode {
via_ir: false,
optimize: true,
compiler_version_requirement: None,
}),
Mode::Solidity(SolcMode {
via_ir: false,
optimize: false,
compiler_version_requirement: None,
}),
],
),
(
"E+",
vec![Mode::Solidity(SolcMode {
via_ir: false,
optimize: true,
compiler_version_requirement: None,
})],
),
(
"E-",
vec![Mode::Solidity(SolcMode {
via_ir: false,
optimize: false,
compiler_version_requirement: None,
})],
),
(
"Y >=0.8.3",
vec![
Mode::Solidity(SolcMode {
via_ir: true,
optimize: true,
compiler_version_requirement: Some(VersionOrRequirement::Requirement(
">=0.8.3".parse().unwrap(),
)),
}),
Mode::Solidity(SolcMode {
via_ir: true,
optimize: false,
compiler_version_requirement: Some(VersionOrRequirement::Requirement(
">=0.8.3".parse().unwrap(),
)),
}),
],
),
(
"Y 0.8.3",
vec![
Mode::Solidity(SolcMode {
via_ir: true,
optimize: true,
compiler_version_requirement: Some(VersionOrRequirement::Version(
Version {
major: 0,
minor: 8,
patch: 3,
pre: Default::default(),
build: Default::default(),
},
)),
}),
Mode::Solidity(SolcMode {
via_ir: true,
optimize: false,
compiler_version_requirement: Some(VersionOrRequirement::Version(
Version {
major: 0,
minor: 8,
patch: 3,
pre: Default::default(),
build: Default::default(),
},
)),
}),
],
),
];
for (string, expectation) in fixtures {
// Act
let actual = Mode::parse_from_string(string);
// Assert
assert_eq!(
actual, expectation,
"Parsed {string} into {actual:?} but expected {expectation:?}"
)
}
}
#[test]
#[allow(clippy::uninlined_format_args)]
fn mode_matches_as_expected() {
// Arrange
let fixtures = [("Y+", "Y+", true), ("Y+ >=0.8.3", "Y+", true)];
for (self_mode, other_mode, expected_result) in fixtures {
let self_mode = Mode::parse_from_string(self_mode).pop().unwrap();
let other_mode = Mode::parse_from_string(other_mode).pop().unwrap();
// Act
let actual = self_mode.matches(&other_mode);
// Assert
assert_eq!(
actual, expected_result,
"Match of {} and {} failed. Expected {} but got {}",
self_mode, other_mode, expected_result, actual
);
}
}
}