1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
|
//@ run-pass
macro_rules! mtester {
($l:literal) => {
&format!("macro caught literal: {}", $l)
};
($e:expr) => {
&format!("macro caught expr: {}", $e)
};
}
macro_rules! two_negative_literals {
($l1:literal $l2:literal) => {
&format!("macro caught literals: {}, {}", $l1, $l2)
};
}
macro_rules! only_expr {
($e:expr) => {
&format!("macro caught expr: {}", $e)
};
}
#[allow(unused_macro_rules)]
macro_rules! mtester_dbg {
($l:literal) => {
&format!("macro caught literal: {:?}", $l)
};
($e:expr) => {
&format!("macro caught expr: {:?}", $e)
};
}
macro_rules! catch_range {
($s:literal ..= $e:literal) => {
&format!("macro caught literal: {} ..= {}", $s, $e)
};
(($s:expr) ..= ($e:expr)) => { // Must use ')' before '..='
&format!("macro caught expr: {} ..= {}", $s, $e)
};
}
macro_rules! pat_match {
($s:literal ..= $e:literal) => {
match 3 {
$s ..= $e => "literal, in range",
_ => "literal, other",
}
};
($s:pat) => {
match 3 {
$s => "pat, single",
_ => "pat, other",
}
};
}
macro_rules! match_attr {
(#[$attr:meta] $e:literal) => {
"attr matched literal"
};
(#[$attr:meta] $e:expr) => {
"attr matched expr"
};
}
macro_rules! match_produced_attr {
($lit: literal) => {
// Struct with doc comment passed via $literal
#[doc = $lit]
struct LiteralProduced;
};
($expr: expr) => {
struct ExprProduced;
};
}
macro_rules! test_user {
($s:literal, $e:literal) => {
{
let mut v = Vec::new();
for i in $s .. $e {
v.push(i);
}
"literal"
}
};
($s:expr, $e: expr) => {
{
let mut v = Vec::new();
for i in $s .. $e {
v.push(i);
}
"expr"
}
};
}
pub fn main() {
// Cases where 'literal' catches
assert_eq!(mtester!("str"), "macro caught literal: str");
assert_eq!(mtester!(2), "macro caught literal: 2");
assert_eq!(mtester!(2.2), "macro caught literal: 2.2");
assert_eq!(mtester!(1u32), "macro caught literal: 1");
assert_eq!(mtester!(0x32), "macro caught literal: 50");
assert_eq!(mtester!('c'), "macro caught literal: c");
assert_eq!(mtester!(-1.2), "macro caught literal: -1.2");
assert_eq!(two_negative_literals!(-2 -3), "macro caught literals: -2, -3");
assert_eq!(catch_range!(2 ..= 3), "macro caught literal: 2 ..= 3");
assert_eq!(match_attr!(#[attr] 1), "attr matched literal");
assert_eq!(test_user!(10, 20), "literal");
assert_eq!(mtester!(false), "macro caught literal: false");
assert_eq!(mtester!(true), "macro caught literal: true");
match_produced_attr!("a");
let _a = LiteralProduced;
assert_eq!(pat_match!(1 ..= 3), "literal, in range");
assert_eq!(pat_match!(4 ..= 6), "literal, other");
// Cases where 'expr' catches
assert_eq!(mtester!((-1.2)), "macro caught expr: -1.2");
assert_eq!(only_expr!(-1.2), "macro caught expr: -1.2");
assert_eq!(mtester!((1 + 3)), "macro caught expr: 4");
assert_eq!(mtester_dbg!(()), "macro caught expr: ()");
assert_eq!(catch_range!((1 + 1) ..= (2 + 2)), "macro caught expr: 2 ..= 4");
assert_eq!(match_attr!(#[attr] (1 + 2)), "attr matched expr");
assert_eq!(test_user!(10, (20 + 2)), "expr");
match_produced_attr!((3 + 2));
let _b = ExprProduced;
// Cases where 'pat' matched
assert_eq!(pat_match!(3), "pat, single");
assert_eq!(pat_match!(6), "pat, other");
}
|