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