tests/target/macro_rules.rs

   1 // rustfmt-error_on_line_overflow: false
   2
   3 macro_rules! m {
   4     () => {};
   5     ($x: ident) => {};
   6     ($m1: ident, $m2: ident, $x: ident) => {};
   7     ($($beginning: ident),*; $middle: ident; $($end: ident),*) => {};
   8     (
   9         $($beginning: ident),*;
  10         $middle: ident;
  11         $($end: ident),*;
  12         $($beginning: ident),*;
  13         $middle: ident;
  14         $($end: ident),*
  15     ) => {};
  16     ($name: ident($($dol: tt $var: ident)*) $($body: tt)*) => {};
  17     (
  18         $($i: ident: $ty: ty, $def: expr, $stb: expr, $($dstring: tt),+);+ $(;)*
  19         $($i: ident: $ty: ty, $def: expr, $stb: expr, $($dstring: tt),+);+ $(;)*
  20     ) => {};
  21     ($foo: tt foo[$attr: meta] $name: ident) => {};
  22     ($foo: tt[$attr: meta] $name: ident) => {};
  23     ($foo: tt &'a[$attr: meta] $name: ident) => {};
  24     ($foo: tt foo #[$attr: meta] $name: ident) => {};
  25     ($foo: tt #[$attr: meta] $name: ident) => {};
  26     ($foo: tt &'a #[$attr: meta] $name: ident) => {};
  27     ($x: tt foo bar foo bar foo bar $y: tt => x * y * z $z: tt, $($a: tt),*) => {};
  28 }
  29
  30 macro_rules! impl_a_method {
  31     ($n: ident($a: ident: $ta: ty) -> $ret: ty { $body: expr }) => {
  32         fn $n($a: $ta) -> $ret {
  33             $body
  34         }
  35         macro_rules! $n {
  36             ($va: expr) => {
  37                 $n($va)
  38             };
  39         }
  40     };
  41     ($n: ident($a: ident: $ta: ty, $b: ident: $tb: ty) -> $ret: ty { $body: expr }) => {
  42         fn $n($a: $ta, $b: $tb) -> $ret {
  43             $body
  44         }
  45         macro_rules! $n {
  46             ($va: expr,$vb: expr) => {
  47                 $n($va, $vb)
  48             };
  49         }
  50     };
  51     (
  52         $n: ident($a: ident: $ta: ty, $b: ident: $tb: ty, $c: ident: $tc: ty) ->
  53         $ret: ty { $body: expr }
  54     ) => {
  55         fn $n($a: $ta, $b: $tb, $c: $tc) -> $ret {
  56             $body
  57         }
  58         macro_rules! $n {
  59             ($va: expr,$vb: expr,$vc: expr) => {
  60                 $n($va, $vb, $vc)
  61             };
  62         }
  63     };
  64     (
  65         $n: ident($a: ident: $ta: ty, $b: ident: $tb: ty, $c: ident: $tc: ty, $d: ident: $td: ty) ->
  66         $ret: ty { $body: expr }
  67     ) => {
  68         fn $n($a: $ta, $b: $tb, $c: $tc, $d: $td) -> $ret {
  69             $body
  70         }
  71         macro_rules! $n {
  72             ($va: expr,$vb: expr,$vc: expr,$vd: expr) => {
  73                 $n($va, $vb, $vc, $vd)
  74             };
  75         }
  76     };
  77 }
  78
  79 macro_rules! m {
  80     // a
  81     ($expr: expr, $($func: ident)*) => {{
  82         let x = $expr;
  83         $func(x)
  84     }};
  85
  86     /* b */
  87     () => {
  88         /* c */
  89     };
  90
  91     (@tag) => {};
  92
  93     // d
  94     ($item: ident) => {
  95         mod macro_item {
  96             struct $item;
  97         }
  98     };
  99 }
 100
 101 macro m2 {
 102     // a
 103     ($expr: expr, $($func: ident)*) => {{
 104         let x = $expr;
 105         $func(x)
 106     }}
 107
 108     /* b */
 109     () => {
 110         /* c */
 111     }
 112
 113     (@tag) => {}
 114
 115     // d
 116     ($item: ident) => {
 117         mod macro_item {
 118             struct $item;
 119         }
 120     }
 121 }
 122
 123 // #2438, #2476
 124 macro_rules! m {
 125     () => {
 126         fn foo() {
 127             this_line_is_98_characters_long_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx();
 128         }
 129     };
 130 }
 131 macro_rules! m {
 132     () => {
 133         fn foo() {
 134             this_line_is_99_characters_long_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(
 135             );
 136         }
 137     };
 138 }
 139 macro_rules! m {
 140     () => {
 141         fn foo() {
 142             this_line_is_100_characters_long_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(
 143             );
 144         }
 145     };
 146 }
 147 macro_rules! m {
 148     () => {
 149         fn foo() {
 150             this_line_is_101_characters_long_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(
 151             );
 152         }
 153     };
 154 }
 155
 156 // #2439
 157 macro_rules! m {
 158     (
 159         $line0_xxxxxxxxxxxxxxxxx: expr,
 160         $line1_xxxxxxxxxxxxxxxxx: expr,
 161         $line2_xxxxxxxxxxxxxxxxx: expr,
 162         $line3_xxxxxxxxxxxxxxxxx: expr,
 163     ) => {};
 164 }
 165
 166 // #2466
 167 // Skip formatting `macro_rules!` that are not using `{}`.
 168 macro_rules! m (
 169     () => ()
 170 );
 171 macro_rules! m [
 172     () => ()
 173 ];
 174
 175 // #2470
 176 macro foo($type_name: ident, $docs: expr) {
 177     #[allow(non_camel_case_types)]
 178     #[doc=$docs]
 179     #[derive(Debug, Clone, Copy)]
 180     pub struct $type_name;
 181 }
 182
 183 // #2538
 184 macro_rules! add_message_to_notes {
 185     ($msg: expr) => {{
 186         let mut lines = message.lines();
 187         notes.push_str(&format!("\n{}: {}", level, lines.next().unwrap()));
 188         for line in lines {
 189             notes.push_str(&format!(
 190                 "\n{:indent$}{line}",
 191                 "",
 192                 indent = level.len() + 2,
 193                 line = line,
 194             ));
 195         }
 196     }};
 197 }