src/test/ui/hygiene/hygiene.rs

   1 // run-pass
   2 #![allow(unused)]
   3
   4 fn f() {
   5     let x = 0;
   6     macro_rules! foo { () => {
   7         assert_eq!(x, 0);
   8     } }
   9
  10     let x = 1;
  11     foo!();
  12 }
  13
  14 fn g() {
  15     let x = 0;
  16     macro_rules! m { ($m1:ident, $m2:ident, $x:ident) => {
  17         macro_rules! $m1 { () => { ($x, x) } }
  18         let x = 1;
  19         macro_rules! $m2 { () => { ($x, x) } }
  20     } }
  21
  22     let x = 2;
  23     m!(m2, m3, x);
  24
  25     let x = 3;
  26     assert_eq!(m2!(), (2, 0));
  27     assert_eq!(m3!(), (2, 1));
  28
  29     let x = 4;
  30     m!(m4, m5, x);
  31     assert_eq!(m4!(), (4, 0));
  32     assert_eq!(m5!(), (4, 1));
  33 }
  34
  35 mod foo {
  36     macro_rules! m {
  37         ($f:ident : |$x:ident| $e:expr) => {
  38             pub fn $f() -> (i32, i32) {
  39                 let x = 0;
  40                 let $x = 1;
  41                 (x, $e)
  42             }
  43         }
  44     }
  45
  46     m!(f: |x| x + 10);
  47 }
  48
  49 fn interpolated_pattern() {
  50     let x = 0;
  51     macro_rules! m {
  52         ($p:pat, $e:expr) => {
  53             let $p = 1;
  54             assert_eq!((x, $e), (0, 1));
  55         }
  56     }
  57
  58     m!(x, x);
  59 }
  60
  61 fn patterns_in_macro_generated_macros() {
  62     let x = 0;
  63     macro_rules! m {
  64         ($a:expr, $b:expr) => {
  65             assert_eq!(x, 0);
  66             let x = $a;
  67             macro_rules! n {
  68                 () => {
  69                     (x, $b)
  70                 }
  71             }
  72         }
  73     }
  74
  75     let x = 1;
  76     m!(2, x);
  77
  78     let x = 3;
  79     assert_eq!(n!(), (2, 1));
  80 }
  81
  82 fn match_hygiene() {
  83     let x = 0;
  84
  85     macro_rules! m {
  86         ($p:pat, $e:expr) => {
  87             for result in &[Ok(1), Err(1)] {
  88                 match *result {
  89                     $p => { assert_eq!(($e, x), (1, 0)); }
  90                     Err(x) => { assert_eq!(($e, x), (2, 1)); }
  91                 }
  92             }
  93         }
  94     }
  95
  96     let x = 2;
  97     m!(Ok(x), x);
  98 }
  99
 100 fn label_hygiene() {
 101     'a: loop {
 102         macro_rules! m { () => { break 'a; } }
 103         m!();
 104     }
 105 }
 106
 107 fn main() {
 108     f();
 109     g();
 110     assert_eq!(foo::f(), (0, 11));
 111     interpolated_pattern();
 112     patterns_in_macro_generated_macros();
 113     match_hygiene();
 114 }