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