bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

compiletest: Stricter parsing of //@ normalize-* headers

Browse source
This commit is contained in:
Zalathar 2024-06-13 00:32:38 +10:00
parent c9d880bf01
commit e09eedbe93
2 changed files with 60 additions and 48 deletions
Download patch file Download diff file Expand all files Collapse all files

48
src/tools/compiletest/src/header.rs
View file

@ -14,6 +14,7 @@ use crate::common::{Config, Debugger, FailMode, Mode, PassMode};
use crate::header::cfg::parse_cfg_name_directive; use crate::header::cfg::parse_cfg_name_directive;
use crate::header::cfg::MatchOutcome; use crate::header::cfg::MatchOutcome;
use crate::header::needs::CachedNeedsConditions; use crate::header::needs::CachedNeedsConditions;
use crate::util::static_regex;
use crate::{extract_cdb_version, extract_gdb_version}; use crate::{extract_cdb_version, extract_gdb_version};
mod cfg; mod cfg;
@ -1186,11 +1187,11 @@ impl Config {
} }
} }
fn parse_custom_normalization(&self, mut line: &str, prefix: &str) -> Option<(String, String)> { fn parse_custom_normalization(&self, line: &str, prefix: &str) -> Option<(String, String)> {
if parse_cfg_name_directive(self, line, prefix).outcome == MatchOutcome::Match { if parse_cfg_name_directive(self, line, prefix).outcome == MatchOutcome::Match {
let from = parse_normalization_string(&mut line)?; let (regex, replacement) = parse_normalize_rule(line)
let to = parse_normalization_string(&mut line)?; .unwrap_or_else(|| panic!("couldn't parse custom normalization rule: `{line}`"));
Some((from, to)) Some((regex, replacement))
} else { } else {
None None
} }
@ -1311,24 +1312,29 @@ fn expand_variables(mut value: String, config: &Config) -> String {
value value
} }
/// Finds the next quoted string `"..."` in `line`, and extract the content from it. Move the `line` /// Parses the regex and replacement values of a `//@ normalize-*` header,
/// variable after the end of the quoted string. /// in the format:
/// /// ```text
/// # Examples /// normalize-*: "REGEX" -> "REPLACEMENT"
///
/// ``` /// ```
/// let mut s = "normalize-stderr-32bit: \"something (32 bits)\" -> \"something ($WORD bits)\"."; fn parse_normalize_rule(header: &str) -> Option<(String, String)> {
/// let first = parse_normalization_string(&mut s); // FIXME(#126370): A colon after the header name should be mandatory, but
/// assert_eq!(first, Some("something (32 bits)".to_owned())); // currently is not, and there are many tests that lack the colon.
/// assert_eq!(s, " -> \"something ($WORD bits)\"."); // FIXME: Support escaped double-quotes in strings.
/// ``` let captures = static_regex!(
fn parse_normalization_string(line: &mut &str) -> Option<String> { r#"(?x) # (verbose mode regex)
// FIXME support escapes in strings. ^
let begin = line.find('"')? + 1; [^:\s]+:?\s* # (header name followed by optional colon)
let end = line[begin..].find('"')? + begin; "(?<regex>[^"]*)" # "REGEX"
let result = line[begin..end].to_owned(); \s+->\s+ # ->
*line = &line[end + 1..]; "(?<replacement>[^"]*)" # "REPLACEMENT"
Some(result) $
"#
)
.captures(header)?;
let regex = captures["regex"].to_owned();
let replacement = captures["replacement"].to_owned();
Some((regex, replacement))
} }
pub fn extract_llvm_version(version: &str) -> Option<u32> { pub fn extract_llvm_version(version: &str) -> Option<u32> {

60
src/tools/compiletest/src/header/tests.rs
View file

@ -3,7 +3,7 @@ use std::path::Path;
use std::str::FromStr; use std::str::FromStr;
use crate::common::{Config, Debugger, Mode}; use crate::common::{Config, Debugger, Mode};
use crate::header::{parse_normalization_string, EarlyProps, HeadersCache}; use crate::header::{parse_normalize_rule, EarlyProps, HeadersCache};
use super::iter_header; use super::iter_header;
@ -32,35 +32,41 @@ fn make_test_description<R: Read>(
} }
#[test] #[test]
fn test_parse_normalization_string() { fn test_parse_normalize_rule() {
let mut s = "normalize-stderr-32bit: \"something (32 bits)\" -> \"something ($WORD bits)\"."; let good_data = &[
let first = parse_normalization_string(&mut s); (
assert_eq!(first, Some("something (32 bits)".to_owned())); r#"normalize-stderr-32bit: "something (32 bits)" -> "something ($WORD bits)""#,
assert_eq!(s, " -> \"something ($WORD bits)\"."); "something (32 bits)",
"something ($WORD bits)",
),
// FIXME(#126370): A colon after the header name should be mandatory,
// but currently is not, and there are many tests that lack the colon.
(
r#"normalize-stderr-32bit "something (32 bits)" -> "something ($WORD bits)""#,
"something (32 bits)",
"something ($WORD bits)",
),
];
// Nothing to normalize (No quotes) for &(input, expected_regex, expected_replacement) in good_data {
let mut s = "normalize-stderr-32bit: something (32 bits) -> something ($WORD bits)."; let parsed = parse_normalize_rule(input);
let first = parse_normalization_string(&mut s); let parsed =
assert_eq!(first, None); parsed.as_ref().map(|(regex, replacement)| (regex.as_str(), replacement.as_str()));
assert_eq!(s, r#"normalize-stderr-32bit: something (32 bits) -> something ($WORD bits)."#); assert_eq!(parsed, Some((expected_regex, expected_replacement)));
}
// Nothing to normalize (Only a single quote) let bad_data = &[
let mut s = "normalize-stderr-32bit: \"something (32 bits) -> something ($WORD bits)."; r#"normalize-stderr-16bit: something (16 bits) -> something ($WORD bits)"#,
let first = parse_normalization_string(&mut s); r#"normalize-stderr-32bit: something (32 bits) -> something ($WORD bits)"#,
assert_eq!(first, None); r#"normalize-stderr-32bit: "something (32 bits) -> something ($WORD bits)"#,
assert_eq!(s, "normalize-stderr-32bit: \"something (32 bits) -> something ($WORD bits)."); r#"normalize-stderr-32bit: "something (32 bits)" -> "something ($WORD bits)"#,
r#"normalize-stderr-32bit: "something (32 bits)" -> "something ($WORD bits)"."#,
];
// Nothing to normalize (Three quotes) for &input in bad_data {
let mut s = "normalize-stderr-32bit: \"something (32 bits)\" -> \"something ($WORD bits)."; let parsed = parse_normalize_rule(input);
let first = parse_normalization_string(&mut s); assert_eq!(parsed, None);
assert_eq!(first, Some("something (32 bits)".to_owned())); }
assert_eq!(s, " -> \"something ($WORD bits).");
// Nothing to normalize (No quotes, 16-bit)
let mut s = "normalize-stderr-16bit: something (16 bits) -> something ($WORD bits).";
let first = parse_normalization_string(&mut s);
assert_eq!(first, None);
assert_eq!(s, r#"normalize-stderr-16bit: something (16 bits) -> something ($WORD bits)."#);
} }
#[derive(Default)] #[derive(Default)]