src/test/ui/macros/macro-literal.rs

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