separate filters from their args with colons like other commands

Author: oli-obk

CHANGELOG.md

@@ -18,6 +18,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * default comment symbols for `Config::cargo` changed to `#`
 * Ctrl+C now prints the summary of the tests that were run before Ctrl+C is pressed
+* `//@only-target` and `//@only-host` are now separated from the triple substring by a `:` instead of a `-`
+* `//@only-64bit` is now `//@only-bitwidth: 64`
 
 ### Removed
 

README.md

@@ -45,9 +45,9 @@ Any other comments will be ignored, and all `//@` comments must be formatted pre
 their command specifies, or the test will fail without even being run.
 
 * `//@ignore-C` avoids running the test when condition `C` is met.
-    * `C` can be `target-XXX`, which checks whether the target triple contains `XXX`.
-    * `C` can be `host-XXX`, which checks whether the host triple contains `XXX`.
-    * `C` can also be one of `64bit`, `32bit` or `16bit`.
+    * `C` can be `target: XXX`, which checks whether the target triple contains `XXX`.
+    * `C` can be `host: XXX`, which checks whether the host triple contains `XXX`.
+    * `C` can also be `bitwidth:` followed by an integer size like `64`, `32` or `16`.
     * `C` can also be `on-host`, which will only run the test during cross compilation testing.
 * `//@only-C` **only** runs the test when condition `C` is met. The conditions are the same as with `ignore`.
 * `//@needs-asm-support` **only** runs the test when the target supports `asm!`.

src/parser.rs

@@ -262,22 +262,18 @@ pub(crate) struct ErrorMatch {
 }
 
 impl Condition {
-    fn parse(c: &str) -> std::result::Result<Self, String> {
-        if c == "on-host" {
-            Ok(Condition::OnHost)
-        } else if let Some(bits) = c.strip_suffix("bit") {
-            let bits: u8 = bits.parse().map_err(|_err| {
-                format!("invalid ignore/only filter ending in 'bit': {c:?} is not a valid bitwdith")
-            })?;
-            Ok(Condition::Bitwidth(bits))
-        } else if let Some(triple_substr) = c.strip_prefix("target-") {
-            Ok(Condition::Target(triple_substr.to_owned()))
-        } else if let Some(triple_substr) = c.strip_prefix("host-") {
-            Ok(Condition::Host(triple_substr.to_owned()))
-        } else {
-            Err(format!(
-                "`{c}` is not a valid condition, expected `on-host`, /[0-9]+bit/, /host-.*/, or /target-.*/"
-            ))
+    fn parse(c: &str, args: &str) -> std::result::Result<Self, String> {
+        match c {
+            "on-host" => Ok(Condition::OnHost),
+            "bitwidth" => {
+                let bits: u8 = args.parse().map_err(|_err| {
+                    format!("invalid ignore/only filter ending in 'bit': {c:?} is not a valid bitwdith")
+                })?;
+                Ok(Condition::Bitwidth(bits))
+            }
+            "target" => Ok(Condition::Target(args.to_owned())),
+            "host" => Ok(Condition::Host(args.to_owned())),
+            _ => Err(format!("`{c}` is not a valid condition, expected `on-host`, /[0-9]+bit/, /host-.*/, or /target-.*/")),
         }
     }
 }
@@ -769,17 +765,20 @@ impl CommentParser<&mut Revisioned> {
     fn parse_command(&mut self, command: Spanned<&str>, args: Spanned<&str>) {
         if let Some(command_handler) = self.commands.get(*command) {
             command_handler(self, args, command.span());
-        } else if let Some(s) = command.strip_prefix("ignore-") {
-            // args are ignored (can be used as comment)
-            match Condition::parse(*s) {
-                Ok(cond) => self.ignore.push(cond),
-                Err(msg) => self.error(s.span(), msg),
-            }
-        } else if let Some(s) = command.strip_prefix("only-") {
+        } else if let Some(rest) = command
+            .strip_prefix("ignore-")
+            .or_else(|| command.strip_prefix("only-"))
+        {
             // args are ignored (can be used as comment)
-            match Condition::parse(*s) {
-                Ok(cond) => self.only.push(cond),
-                Err(msg) => self.error(s.span(), msg),
+            match Condition::parse(*rest, *args) {
+                Ok(cond) => {
+                    if command.starts_with("ignore") {
+                        self.ignore.push(cond)
+                    } else {
+                        self.only.push(cond)
+                    }
+                }
+                Err(msg) => self.error(rest.span(), msg),
             }
         } else {
             let best_match = self

src/parser/tests.rs

@@ -238,7 +238,7 @@ use std::mem;
 
 #[test]
 fn parse_x86_64() {
-    let s = r"//@ only-target-x86_64-unknown-linux";
+    let s = r"//@ only-target:x86_64-unknown-linux";
     let comments = Comments::parse(
         Spanned::new(
             s.as_bytes(),