src/vendor/error-chain-0.10.0/src/quick_error.rs

   1 // From https://github.com/tailhook/quick-error
   2 // Changes:
   3 //   - replace `impl Error` by `impl Item::description`
   4 //   - $imeta
   5
   6 #[macro_export]
   7 macro_rules! quick_error {
   8     (   $(#[$meta:meta])*
   9         pub enum $name:ident { $($chunks:tt)* }
  10     ) => {
  11         quick_error!(SORT [pub enum $name $(#[$meta])* ]
  12             items [] buf []
  13             queue [ $($chunks)* ]);
  14     };
  15     (   $(#[$meta:meta])*
  16         enum $name:ident { $($chunks:tt)* }
  17     ) => {
  18         quick_error!(SORT [enum $name $(#[$meta])* ]
  19             items [] buf []
  20             queue [ $($chunks)* ]);
  21     };
  22     // Queue is empty, can do the work
  23     (SORT [enum $name:ident $( #[$meta:meta] )*]
  24         items [$($( #[$imeta:meta] )*
  25                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
  26                                 {$( $ifuncs:tt )*} )* ]
  27         buf [ ]
  28         queue [ ]
  29     ) => {
  30         quick_error!(ENUM_DEFINITION [enum $name $( #[$meta] )*]
  31             body []
  32             queue [$($( #[$imeta] )*
  33                       => $iitem: $imode [$( $ivar: $ityp ),*] )*]
  34         );
  35         quick_error!(IMPLEMENTATIONS $name {$(
  36            $iitem: $imode [$(#[$imeta])*] [$( $ivar: $ityp ),*] {$( $ifuncs )*}
  37            )*});
  38         $(
  39             quick_error!(ERROR_CHECK $imode $($ifuncs)*);
  40         )*
  41     };
  42     (SORT [pub enum $name:ident $( #[$meta:meta] )*]
  43         items [$($( #[$imeta:meta] )*
  44                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
  45                                 {$( $ifuncs:tt )*} )* ]
  46         buf [ ]
  47         queue [ ]
  48     ) => {
  49         quick_error!(ENUM_DEFINITION [pub enum $name $( #[$meta] )*]
  50             body []
  51             queue [$($( #[$imeta] )*
  52                       => $iitem: $imode [$( $ivar: $ityp ),*] )*]
  53         );
  54         quick_error!(IMPLEMENTATIONS $name {$(
  55            $iitem: $imode [$(#[$imeta])*] [$( $ivar: $ityp ),*] {$( $ifuncs )*}
  56            )*});
  57         $(
  58             quick_error!(ERROR_CHECK $imode $($ifuncs)*);
  59         )*
  60     };
  61     // Add meta to buffer
  62     (SORT [$( $def:tt )*]
  63         items [$($( #[$imeta:meta] )*
  64                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
  65                                 {$( $ifuncs:tt )*} )* ]
  66         buf [$( #[$bmeta:meta] )*]
  67         queue [ #[$qmeta:meta] $( $tail:tt )*]
  68     ) => {
  69         quick_error!(SORT [$( $def )*]
  70             items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*]
  71             buf [$( #[$bmeta] )* #[$qmeta] ]
  72             queue [$( $tail )*]);
  73     };
  74     // Add ident to buffer
  75     (SORT [$( $def:tt )*]
  76         items [$($( #[$imeta:meta] )*
  77                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
  78                                 {$( $ifuncs:tt )*} )* ]
  79         buf [$( #[$bmeta:meta] )*]
  80         queue [ $qitem:ident $( $tail:tt )*]
  81     ) => {
  82         quick_error!(SORT [$( $def )*]
  83             items [$( $(#[$imeta])*
  84                       => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*]
  85             buf [$(#[$bmeta])* => $qitem : UNIT [ ] ]
  86             queue [$( $tail )*]);
  87     };
  88     // Flush buffer on meta after ident
  89     (SORT [$( $def:tt )*]
  90         items [$($( #[$imeta:meta] )*
  91                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
  92                                 {$( $ifuncs:tt )*} )* ]
  93         buf [$( #[$bmeta:meta] )*
  94             => $bitem:ident: $bmode:tt [$( $bvar:ident: $btyp:ty ),*] ]
  95         queue [ #[$qmeta:meta] $( $tail:tt )*]
  96     ) => {
  97         quick_error!(SORT [$( $def )*]
  98             enum [$( $(#[$emeta])* => $eitem $(( $($etyp),* ))* )*
  99                      $(#[$bmeta])* => $bitem: $bmode $(( $($btyp),* ))*]
 100             items [$($( #[$imeta:meta] )*
 101                       => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*
 102                      $bitem: $bmode [$( $bvar:$btyp ),*] {} ]
 103             buf [ #[$qmeta] ]
 104             queue [$( $tail )*]);
 105     };
 106     // Add tuple enum-variant
 107     (SORT [$( $def:tt )*]
 108         items [$($( #[$imeta:meta] )*
 109                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
 110                                 {$( $ifuncs:tt )*} )* ]
 111         buf [$( #[$bmeta:meta] )* => $bitem:ident: UNIT [ ] ]
 112         queue [($( $qvar:ident: $qtyp:ty ),+) $( $tail:tt )*]
 113     ) => {
 114         quick_error!(SORT [$( $def )*]
 115             items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*]
 116             buf [$( #[$bmeta] )* => $bitem: TUPLE [$( $qvar:$qtyp ),*] ]
 117             queue [$( $tail )*]
 118         );
 119     };
 120     // Add struct enum-variant - e.g. { descr: &'static str }
 121     (SORT [$( $def:tt )*]
 122         items [$($( #[$imeta:meta] )*
 123                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
 124                                 {$( $ifuncs:tt )*} )* ]
 125         buf [$( #[$bmeta:meta] )* => $bitem:ident: UNIT [ ] ]
 126         queue [{ $( $qvar:ident: $qtyp:ty ),+} $( $tail:tt )*]
 127     ) => {
 128         quick_error!(SORT [$( $def )*]
 129             items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*]
 130             buf [$( #[$bmeta] )* => $bitem: STRUCT [$( $qvar:$qtyp ),*] ]
 131             queue [$( $tail )*]);
 132     };
 133     // Add struct enum-variant, with excess comma - e.g. { descr: &'static str, }
 134     (SORT [$( $def:tt )*]
 135         items [$($( #[$imeta:meta] )*
 136                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
 137                                 {$( $ifuncs:tt )*} )* ]
 138         buf [$( #[$bmeta:meta] )* => $bitem:ident: UNIT [ ] ]
 139         queue [{$( $qvar:ident: $qtyp:ty ),+ ,} $( $tail:tt )*]
 140     ) => {
 141         quick_error!(SORT [$( $def )*]
 142             items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*]
 143             buf [$( #[$bmeta] )* => $bitem: STRUCT [$( $qvar:$qtyp ),*] ]
 144             queue [$( $tail )*]);
 145     };
 146     // Add braces and flush always on braces
 147     (SORT [$( $def:tt )*]
 148         items [$($( #[$imeta:meta] )*
 149                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
 150                                 {$( $ifuncs:tt )*} )* ]
 151         buf [$( #[$bmeta:meta] )*
 152                  => $bitem:ident: $bmode:tt [$( $bvar:ident: $btyp:ty ),*] ]
 153         queue [ {$( $qfuncs:tt )*} $( $tail:tt )*]
 154     ) => {
 155         quick_error!(SORT [$( $def )*]
 156             items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*
 157                       $(#[$bmeta])* => $bitem: $bmode [$( $bvar:$btyp ),*] {$( $qfuncs )*} ]
 158             buf [ ]
 159             queue [$( $tail )*]);
 160     };
 161     // Flush buffer on double ident
 162     (SORT [$( $def:tt )*]
 163         items [$($( #[$imeta:meta] )*
 164                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
 165                                 {$( $ifuncs:tt )*} )* ]
 166         buf [$( #[$bmeta:meta] )*
 167                  => $bitem:ident: $bmode:tt [$( $bvar:ident: $btyp:ty ),*] ]
 168         queue [ $qitem:ident $( $tail:tt )*]
 169     ) => {
 170         quick_error!(SORT [$( $def )*]
 171             items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*
 172                      $(#[$bmeta])* => $bitem: $bmode [$( $bvar:$btyp ),*] {} ]
 173             buf [ => $qitem : UNIT [ ] ]
 174             queue [$( $tail )*]);
 175     };
 176     // Flush buffer on end
 177     (SORT [$( $def:tt )*]
 178         items [$($( #[$imeta:meta] )*
 179                   => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
 180                                 {$( $ifuncs:tt )*} )* ]
 181         buf [$( #[$bmeta:meta] )*
 182             => $bitem:ident: $bmode:tt [$( $bvar:ident: $btyp:ty ),*] ]
 183         queue [ ]
 184     ) => {
 185         quick_error!(SORT [$( $def )*]
 186             items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*
 187                      $(#[$bmeta])* => $bitem: $bmode [$( $bvar:$btyp ),*] {} ]
 188             buf [ ]
 189             queue [ ]);
 190     };
 191     // Public enum (Queue Empty)
 192     (ENUM_DEFINITION [pub enum $name:ident $( #[$meta:meta] )*]
 193         body [$($( #[$imeta:meta] )*
 194             => $iitem:ident ($(($( $ttyp:ty ),+))*) {$({$( $svar:ident: $styp:ty ),*})*} )* ]
 195         queue [ ]
 196     ) => {
 197         $(#[$meta])*
 198         pub enum $name {
 199             $(
 200                 $(#[$imeta])*
 201                 $iitem $(($( $ttyp ),*))* $({$( $svar: $styp ),*})*,
 202             )*
 203         }
 204     };
 205     // Private enum (Queue Empty)
 206     (ENUM_DEFINITION [enum $name:ident $( #[$meta:meta] )*]
 207         body [$($( #[$imeta:meta] )*
 208             => $iitem:ident ($(($( $ttyp:ty ),+))*) {$({$( $svar:ident: $styp:ty ),*})*} )* ]
 209         queue [ ]
 210     ) => {
 211         $(#[$meta])*
 212         enum $name {
 213             $(
 214                 $(#[$imeta])*
 215                 $iitem $(($( $ttyp ),*))* $({$( $svar: $styp ),*})*,
 216             )*
 217         }
 218     };
 219     // Unit variant
 220     (ENUM_DEFINITION [$( $def:tt )*]
 221         body [$($( #[$imeta:meta] )*
 222             => $iitem:ident ($(($( $ttyp:ty ),+))*) {$({$( $svar:ident: $styp:ty ),*})*} )* ]
 223         queue [$( #[$qmeta:meta] )*
 224             => $qitem:ident: UNIT [ ] $( $queue:tt )*]
 225     ) => {
 226         quick_error!(ENUM_DEFINITION [ $($def)* ]
 227             body [$($( #[$imeta] )* => $iitem ($(($( $ttyp ),+))*) {$({$( $svar: $styp ),*})*} )*
 228                     $( #[$qmeta] )* => $qitem () {} ]
 229             queue [ $($queue)* ]
 230         );
 231     };
 232     // Tuple variant
 233     (ENUM_DEFINITION [$( $def:tt )*]
 234         body [$($( #[$imeta:meta] )*
 235             => $iitem:ident ($(($( $ttyp:ty ),+))*) {$({$( $svar:ident: $styp:ty ),*})*} )* ]
 236         queue [$( #[$qmeta:meta] )*
 237             => $qitem:ident: TUPLE [$( $qvar:ident: $qtyp:ty ),+] $( $queue:tt )*]
 238     ) => {
 239         quick_error!(ENUM_DEFINITION [ $($def)* ]
 240             body [$($( #[$imeta] )* => $iitem ($(($( $ttyp ),+))*) {$({$( $svar: $styp ),*})*} )*
 241                     $( #[$qmeta] )* => $qitem (($( $qtyp ),*)) {} ]
 242             queue [ $($queue)* ]
 243         );
 244     };
 245     // Struct variant
 246     (ENUM_DEFINITION [$( $def:tt )*]
 247         body [$($( #[$imeta:meta] )*
 248             => $iitem:ident ($(($( $ttyp:ty ),+))*) {$({$( $svar:ident: $styp:ty ),*})*} )* ]
 249         queue [$( #[$qmeta:meta] )*
 250             => $qitem:ident: STRUCT [$( $qvar:ident: $qtyp:ty ),*] $( $queue:tt )*]
 251     ) => {
 252         quick_error!(ENUM_DEFINITION [ $($def)* ]
 253             body [$($( #[$imeta] )* => $iitem ($(($( $ttyp ),+))*) {$({$( $svar: $styp ),*})*} )*
 254                     $( #[$qmeta] )* => $qitem () {{$( $qvar: $qtyp ),*}} ]
 255             queue [ $($queue)* ]
 256         );
 257     };
 258     (IMPLEMENTATIONS
 259         $name:ident {$(
 260             $item:ident: $imode:tt [$(#[$imeta:meta])*] [$( $var:ident: $typ:ty ),*] {$( $funcs:tt )*}
 261         )*}
 262     ) => {
 263         #[allow(unused)]
 264         impl ::std::fmt::Display for $name {
 265             fn fmt(&self, fmt: &mut ::std::fmt::Formatter)
 266                 -> ::std::fmt::Result
 267             {
 268                 match *self {
 269                     $(
 270                         $(#[$imeta])*
 271                         quick_error!(ITEM_PATTERN
 272                             $name $item: $imode [$( ref $var ),*]
 273                         ) => {
 274                             let display_fn = quick_error!(FIND_DISPLAY_IMPL
 275                                 $name $item: $imode
 276                                 {$( $funcs )*});
 277
 278                             display_fn(self, fmt)
 279                         }
 280                     )*
 281                 }
 282             }
 283         }
 284         /*#[allow(unused)]
 285         impl ::std::error::Error for $name {
 286             fn description(&self) -> &str {
 287                 match *self {
 288                     $(
 289                         quick_error!(ITEM_PATTERN
 290                             $name $item: $imode [$( ref $var ),*]
 291                         ) => {
 292                             quick_error!(FIND_DESCRIPTION_IMPL
 293                                 $item: $imode self fmt [$( $var ),*]
 294                                 {$( $funcs )*})
 295                         }
 296                     )*
 297                 }
 298             }
 299             fn cause(&self) -> Option<&::std::error::Error> {
 300                 match *self {
 301                     $(
 302                         quick_error!(ITEM_PATTERN
 303                             $name $item: $imode [$( ref $var ),*]
 304                         ) => {
 305                             quick_error!(FIND_CAUSE_IMPL
 306                                 $item: $imode [$( $var ),*]
 307                                 {$( $funcs )*})
 308                         }
 309                     )*
 310                 }
 311             }
 312         }*/
 313         #[allow(unused)]
 314         impl $name {
 315             /// A string describing the error kind.
 316             pub fn description(&self) -> &str {
 317                 match *self {
 318                     $(
 319                         $(#[$imeta])*
 320                         quick_error!(ITEM_PATTERN
 321                             $name $item: $imode [$( ref $var ),*]
 322                         ) => {
 323                             quick_error!(FIND_DESCRIPTION_IMPL
 324                                 $item: $imode self fmt [$( $var ),*]
 325                                 {$( $funcs )*})
 326                         }
 327                     )*
 328                 }
 329             }
 330         }
 331         $(
 332             quick_error!(FIND_FROM_IMPL
 333                 $name $item: $imode [$( $var:$typ ),*]
 334                 {$( $funcs )*});
 335         )*
 336     };
 337     (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
 338         { display($self_:tt) -> ($( $exprs:tt )*) $( $tail:tt )*}
 339     ) => {
 340         |quick_error!(IDENT $self_): &$name, f: &mut ::std::fmt::Formatter| {
 341             write!(f, $( $exprs )*)
 342         }
 343     };
 344     (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
 345         { display($pattern:expr) $( $tail:tt )*}
 346     ) => {
 347         |_, f: &mut ::std::fmt::Formatter| { write!(f, $pattern) }
 348     };
 349     (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
 350         { display($pattern:expr, $( $exprs:tt )*) $( $tail:tt )*}
 351     ) => {
 352         |_, f: &mut ::std::fmt::Formatter| { write!(f, $pattern, $( $exprs )*) }
 353     };
 354     (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
 355         { $t:tt $( $tail:tt )*}
 356     ) => {
 357         quick_error!(FIND_DISPLAY_IMPL
 358             $name $item: $imode
 359             {$( $tail )*})
 360     };
 361     (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
 362         { }
 363     ) => {
 364         |self_: &$name, f: &mut ::std::fmt::Formatter| {
 365             write!(f, "{}", self_.description())
 366         }
 367     };
 368     (FIND_DESCRIPTION_IMPL $item:ident: $imode:tt $me:ident $fmt:ident
 369         [$( $var:ident ),*]
 370         { description($expr:expr) $( $tail:tt )*}
 371     ) => {
 372         $expr
 373     };
 374     (FIND_DESCRIPTION_IMPL $item:ident: $imode:tt $me:ident $fmt:ident
 375         [$( $var:ident ),*]
 376         { $t:tt $( $tail:tt )*}
 377     ) => {
 378         quick_error!(FIND_DESCRIPTION_IMPL
 379             $item: $imode $me $fmt [$( $var ),*]
 380             {$( $tail )*})
 381     };
 382     (FIND_DESCRIPTION_IMPL $item:ident: $imode:tt $me:ident $fmt:ident
 383         [$( $var:ident ),*]
 384         { }
 385     ) => {
 386         stringify!($item)
 387     };
 388     (FIND_CAUSE_IMPL $item:ident: $imode:tt
 389         [$( $var:ident ),*]
 390         { cause($expr:expr) $( $tail:tt )*}
 391     ) => {
 392         Some($expr)
 393     };
 394     (FIND_CAUSE_IMPL $item:ident: $imode:tt
 395         [$( $var:ident ),*]
 396         { $t:tt $( $tail:tt )*}
 397     ) => {
 398         quick_error!(FIND_CAUSE_IMPL
 399             $item: $imode [$( $var ),*]
 400             { $($tail)* })
 401     };
 402     (FIND_CAUSE_IMPL $item:ident: $imode:tt
 403         [$( $var:ident ),*]
 404         { }
 405     ) => {
 406         None
 407     };
 408     (FIND_FROM_IMPL $name:ident $item:ident: $imode:tt
 409         [$( $var:ident: $typ:ty ),*]
 410         { from() $( $tail:tt )*}
 411     ) => {
 412         $(
 413             impl From<$typ> for $name {
 414                 fn from($var: $typ) -> $name {
 415                     $name::$item($var)
 416                 }
 417             }
 418         )*
 419         quick_error!(FIND_FROM_IMPL
 420             $name $item: $imode [$( $var:$typ ),*]
 421             {$( $tail )*});
 422     };
 423     (FIND_FROM_IMPL $name:ident $item:ident: UNIT
 424         [ ]
 425         { from($ftyp:ty) $( $tail:tt )*}
 426     ) => {
 427         impl From<$ftyp> for $name {
 428             fn from(_discarded_error: $ftyp) -> $name {
 429                 $name::$item
 430             }
 431         }
 432         quick_error!(FIND_FROM_IMPL
 433             $name $item: UNIT [  ]
 434             {$( $tail )*});
 435     };
 436     (FIND_FROM_IMPL $name:ident $item:ident: TUPLE
 437         [$( $var:ident: $typ:ty ),*]
 438         { from($fvar:ident: $ftyp:ty) -> ($( $texpr:expr ),*) $( $tail:tt )*}
 439     ) => {
 440         impl From<$ftyp> for $name {
 441             fn from($fvar: $ftyp) -> $name {
 442                 $name::$item($( $texpr ),*)
 443             }
 444         }
 445         quick_error!(FIND_FROM_IMPL
 446             $name $item: TUPLE [$( $var:$typ ),*]
 447             { $($tail)* });
 448     };
 449     (FIND_FROM_IMPL $name:ident $item:ident: STRUCT
 450         [$( $var:ident: $typ:ty ),*]
 451         { from($fvar:ident: $ftyp:ty) -> {$( $tvar:ident: $texpr:expr ),*} $( $tail:tt )*}
 452     ) => {
 453         impl From<$ftyp> for $name {
 454             fn from($fvar: $ftyp) -> $name {
 455                 $name::$item {
 456                     $( $tvar: $texpr ),*
 457                 }
 458             }
 459         }
 460         quick_error!(FIND_FROM_IMPL
 461             $name $item: STRUCT [$( $var:$typ ),*]
 462             { $($tail)* });
 463     };
 464     (FIND_FROM_IMPL $name:ident $item:ident: $imode:tt
 465         [$( $var:ident: $typ:ty ),*]
 466         { $t:tt $( $tail:tt )*}
 467     ) => {
 468         quick_error!(FIND_FROM_IMPL
 469             $name $item: $imode [$( $var:$typ ),*]
 470             {$( $tail )*}
 471         );
 472     };
 473     (FIND_FROM_IMPL $name:ident $item:ident: $imode:tt
 474         [$( $var:ident: $typ:ty ),*]
 475         { }
 476     ) => {
 477     };
 478     (ITEM_BODY $(#[$imeta:meta])* $item:ident: UNIT
 479     ) => { };
 480     (ITEM_BODY $(#[$imeta:meta])* $item:ident: TUPLE
 481         [$( $typ:ty ),*]
 482     ) => {
 483         ($( $typ ),*)
 484     };
 485     (ITEM_BODY $(#[$imeta:meta])* $item:ident: STRUCT
 486         [$( $var:ident: $typ:ty ),*]
 487     ) => {
 488         {$( $var:$typ ),*}
 489     };
 490     (ITEM_PATTERN $name:ident $item:ident: UNIT []
 491     ) => {
 492         $name::$item
 493     };
 494     (ITEM_PATTERN $name:ident $item:ident: TUPLE
 495         [$( ref $var:ident ),*]
 496     ) => {
 497         $name::$item ($( ref $var ),*)
 498     };
 499     (ITEM_PATTERN $name:ident $item:ident: STRUCT
 500         [$( ref $var:ident ),*]
 501     ) => {
 502         $name::$item {$( ref $var ),*}
 503     };
 504     // This one should match all allowed sequences in "funcs" but not match
 505     // anything else.
 506     // This is to contrast FIND_* clauses which just find stuff they need and
 507     // skip everything else completely
 508     (ERROR_CHECK $imode:tt display($self_:tt) -> ($( $exprs:tt )*) $( $tail:tt )*)
 509     => { quick_error!(ERROR_CHECK $imode $($tail)*); };
 510     (ERROR_CHECK $imode:tt display($pattern: expr) $( $tail:tt )*)
 511     => { quick_error!(ERROR_CHECK $imode $($tail)*); };
 512     (ERROR_CHECK $imode:tt display($pattern: expr, $( $exprs:tt )*) $( $tail:tt )*)
 513     => { quick_error!(ERROR_CHECK $imode $($tail)*); };
 514     (ERROR_CHECK $imode:tt description($expr:expr) $( $tail:tt )*)
 515     => { quick_error!(ERROR_CHECK $imode $($tail)*); };
 516     (ERROR_CHECK $imode:tt cause($expr:expr) $($tail:tt)*)
 517     => { quick_error!(ERROR_CHECK $imode $($tail)*); };
 518     (ERROR_CHECK $imode:tt from() $($tail:tt)*)
 519     => { quick_error!(ERROR_CHECK $imode $($tail)*); };
 520     (ERROR_CHECK $imode:tt from($ftyp:ty) $($tail:tt)*)
 521     => { quick_error!(ERROR_CHECK $imode $($tail)*); };
 522     (ERROR_CHECK TUPLE from($fvar:ident: $ftyp:ty) -> ($( $e:expr ),*) $( $tail:tt )*)
 523     => { quick_error!(ERROR_CHECK TUPLE $($tail)*); };
 524     (ERROR_CHECK STRUCT from($fvar:ident: $ftyp:ty) -> {$( $v:ident: $e:expr ),*} $( $tail:tt )*)
 525     => { quick_error!(ERROR_CHECK STRUCT $($tail)*); };
 526     (ERROR_CHECK $imode:tt ) => {};
 527     // Utility functions
 528     (IDENT $ident:ident) => { $ident }
 529 }