1#![warn(missing_docs, rust_2018_idioms)]
2//! A macro which makes errors easy to write
3//!
4//! Minimum type is like this:
5//!
6//! ```rust
7//! #[macro_use] extern crate quick_error;
8//! # fn main() {}
9//!
10//! quick_error! {
11//! #[derive(Debug)]
12//! pub enum SomeError {
13//! Variant1 {}
14//! }
15//! }
16//! ```
17//! Both ``pub`` and non-public types may be declared, and all meta attributes
18//! (such as ``#[derive(Debug)]``) are forwarded as is. The `Debug` must be
19//! implemented (but you may do that yourself if you like). The documentation
20//! comments ``/// something`` (as well as other meta attrbiutes) on variants
21//! are allowed.
22//!
23//! # Allowed Syntax
24//!
25//! You may add arbitrary parameters to any struct variant:
26//!
27//! ```rust
28//! # #[macro_use] extern crate quick_error;
29//! # fn main() {}
30//! #
31//! quick_error! {
32//! #[derive(Debug)]
33//! pub enum SomeError {
34//! /// IO Error
35//! Io(err: std::io::Error) {}
36//! /// Utf8 Error
37//! Utf8(err: std::str::Utf8Error) {}
38//! }
39//! }
40//! ```
41//!
42//! Note unlike in normal Enum declarations you declare names of fields (which
43//! are omitted from type). How they can be used is outlined below.
44//!
45//! Now you might have noticed trailing braces `{}`. They are used to define
46//! implementations. By default:
47//!
48//! * `Error::source()` returns None (even if type wraps some value)
49//! * `Display` outputs debug representation
50//! * No `From` implementations are defined
51//!
52//! ```rust
53//! # #[macro_use] extern crate quick_error;
54//! # fn main() {}
55//! #
56//! quick_error! {
57//! #[derive(Debug)]
58//! pub enum SomeError {
59//! Io(err: std::io::Error) {
60//! display("{}", err)
61//! }
62//! Utf8(err: std::str::Utf8Error) {
63//! display("utf8 error")
64//! }
65//! }
66//! }
67//! ```
68//!
69//! To change `source` method to return some error, add `source(value)`, for
70//! example:
71//!
72//! ```rust
73//! # #[macro_use] extern crate quick_error;
74//! # fn main() {}
75//! #
76//! quick_error! {
77//! #[derive(Debug)]
78//! pub enum SomeError {
79//! Io(err: std::io::Error) {
80//! source(err)
81//! }
82//! Utf8(err: std::str::Utf8Error) {
83//! display("utf8 error")
84//! }
85//! Other(err: Box<std::error::Error>) {
86//! source(&**err)
87//! }
88//! }
89//! }
90//! ```
91//! Note you don't need to wrap value in `Some`, its implicit. In case you want
92//! `None` returned just omit the `source`. You can't return `None`
93//! conditionally.
94//!
95//! To change how each clause is `Display`ed add `display(pattern,..args)`,
96//! for example:
97//!
98//! ```rust
99//! # #[macro_use] extern crate quick_error;
100//! # fn main() {}
101//! #
102//! quick_error! {
103//! #[derive(Debug)]
104//! pub enum SomeError {
105//! Io(err: std::io::Error) {
106//! display("I/O error: {}", err)
107//! }
108//! Utf8(err: std::str::Utf8Error) {
109//! display("Utf8 error, valid up to {}", err.valid_up_to())
110//! }
111//! }
112//! }
113//! ```
114//!
115//! If you need a reference to the error when `Display`ing, you can instead use
116//! `display(x) -> (pattern, ..args)`, where `x` sets the name of the reference.
117//!
118//! ```rust
119//! # #[macro_use] extern crate quick_error;
120//! # fn main() {}
121//! #
122//! use std::error::Error; // put methods like `source()` of this trait into scope
123//!
124//! quick_error! {
125//! #[derive(Debug)]
126//! pub enum SomeError {
127//! Io(err: std::io::Error) {
128//! display(x) -> ("I/O: {}", err)
129//! }
130//! Utf8(err: std::str::Utf8Error) {
131//! display(self_) -> ("UTF-8 error. Valid up to {}", err.valid_up_to())
132//! }
133//! }
134//! }
135//! ```
136//!
137//! To convert to the type from any other, use one of the three forms of
138//! `from` clause.
139//!
140//! For example, to convert simple wrapper use bare `from()`:
141//!
142//! ```rust
143//! # #[macro_use] extern crate quick_error;
144//! # fn main() {}
145//! #
146//! quick_error! {
147//! #[derive(Debug)]
148//! pub enum SomeError {
149//! Io(err: std::io::Error) {
150//! from()
151//! }
152//! }
153//! }
154//! ```
155//!
156//! This implements ``From<io::Error>``.
157//!
158//! To convert to singleton enumeration type (discarding the value), use
159//! the `from(type)` form:
160//!
161//! ```rust
162//! # #[macro_use] extern crate quick_error;
163//! # fn main() {}
164//! #
165//! quick_error! {
166//! #[derive(Debug)]
167//! pub enum SomeError {
168//! FormatError {
169//! from(std::fmt::Error)
170//! }
171//! }
172//! }
173//! ```
174//!
175//! And the most powerful form is `from(var: type) -> (arguments...)`. It
176//! might be used to convert to type with multiple arguments or for arbitrary
177//! value conversions:
178//!
179//! ```rust
180//! # #[macro_use] extern crate quick_error;
181//! # fn main() {}
182//! #
183//! quick_error! {
184//! #[derive(Debug)]
185//! pub enum SomeError {
186//! FailedOperation(s: &'static str, errno: i32) {
187//! from(errno: i32) -> ("os error", errno)
188//! from(e: std::io::Error) -> ("io error", e.raw_os_error().unwrap())
189//! }
190//! /// Converts from both kinds of utf8 errors
191//! Utf8(err: std::str::Utf8Error) {
192//! from()
193//! from(err: std::string::FromUtf8Error) -> (err.utf8_error())
194//! }
195//! }
196//! }
197//! ```
198//! # Context
199//!
200//! Since quick-error 1.1 we also have a `context` declaration, which is
201//! similar to (the longest form of) `from`, but allows adding some context to
202//! the error. We need a longer example to demonstrate this:
203//!
204//! ```rust
205//! # #[macro_use] extern crate quick_error;
206//! # use std::io;
207//! # use std::fs::File;
208//! # use std::path::{Path, PathBuf};
209//! #
210//! use quick_error::ResultExt;
211//!
212//! quick_error! {
213//! #[derive(Debug)]
214//! pub enum Error {
215//! File(filename: PathBuf, err: io::Error) {
216//! context(path: &'a Path, err: io::Error)
217//! -> (path.to_path_buf(), err)
218//! }
219//! }
220//! }
221//!
222//! fn openfile(path: &Path) -> Result<(), Error> {
223//! File::open(path).context(path)?;
224//!
225//! // If we didn't have context, the line above would be written as;
226//! //
227//! // File::open(path)
228//! // .map_err(|err| Error::File(path.to_path_buf(), err))?;
229//!
230//! Ok(())
231//! }
232//!
233//! # fn main() {
234//! # openfile(Path::new("/etc/somefile")).ok();
235//! # }
236//! ```
237//!
238//! Each `context(a: A, b: B)` clause implements
239//! `From<Context<A, B>> for Error`. Which means multiple `context` clauses
240//! are a subject to the normal coherence rules. Unfortunately, we can't
241//! provide full support of generics for the context, but you may either use a
242//! lifetime `'a` for references or `AsRef<Type>` (the latter means `A:
243//! AsRef<Type>`, and `Type` must be concrete). It's also occasionally useful
244//! to use a tuple as a type of the first argument.
245//!
246//! You also need to `use quick_error::ResultExt` extension trait to get
247//! working `.context()` method.
248//!
249//! More info on context in [this article](http://bit.ly/1PsuxDt).
250//!
251//! All forms of `from`, `display`, `source`, and `context`
252//! clauses can be combined and put in arbitrary order. Only `from` and
253//! `context` can be used multiple times in single variant of enumeration.
254//! Docstrings are also okay. Empty braces can be omitted as of quick_error
255//! 0.1.3.
256//!
257//! # Private Enums
258//!
259//! Since quick-error 1.2.0 we have a way to make a private enum that is
260//! wrapped by public structure:
261//!
262//! ```rust
263//! #[macro_use] extern crate quick_error;
264//! # fn main() {}
265//!
266//! quick_error! {
267//! #[derive(Debug)]
268//! pub enum PubError wraps ErrorEnum {
269//! Variant1 {}
270//! }
271//! }
272//! ```
273//!
274//! This generates data structures like this
275//!
276//! ```rust
277//!
278//! pub struct PubError(ErrorEnum);
279//!
280//! enum ErrorEnum {
281//! Variant1,
282//! }
283//!
284//! ```
285//!
286//! Which in turn allows you to export just `PubError` in your crate and keep
287//! actual enumeration private to the crate. This is useful to keep backwards
288//! compatibility for error types. Currently there is no shorcuts to define
289//! error constructors for the inner type, but we consider adding some in
290//! future versions.
291//!
292//! It's possible to declare internal enum as public too.
293//!
294//!
295
296/// Main macro that does all the work
297#[macro_export]
298macro_rules! quick_error {
299
300 ( $(#[$meta:meta])*
301 pub enum $name:ident { $($chunks:tt)* }
302 ) => {
303 quick_error!(SORT [pub enum $name $(#[$meta])* ]
304 items [] buf []
305 queue [ $($chunks)* ]);
306 };
307 ( $(#[$meta:meta])*
308 enum $name:ident { $($chunks:tt)* }
309 ) => {
310 quick_error!(SORT [enum $name $(#[$meta])* ]
311 items [] buf []
312 queue [ $($chunks)* ]);
313 };
314
315 ( $(#[$meta:meta])*
316 pub enum $name:ident wraps $enum_name:ident { $($chunks:tt)* }
317 ) => {
318 quick_error!(WRAPPER $enum_name [ pub struct ] $name $(#[$meta])*);
319 quick_error!(SORT [enum $enum_name $(#[$meta])* ]
320 items [] buf []
321 queue [ $($chunks)* ]);
322 };
323
324 ( $(#[$meta:meta])*
325 pub enum $name:ident wraps pub $enum_name:ident { $($chunks:tt)* }
326 ) => {
327 quick_error!(WRAPPER $enum_name [ pub struct ] $name $(#[$meta])*);
328 quick_error!(SORT [pub enum $enum_name $(#[$meta])* ]
329 items [] buf []
330 queue [ $($chunks)* ]);
331 };
332 ( $(#[$meta:meta])*
333 enum $name:ident wraps $enum_name:ident { $($chunks:tt)* }
334 ) => {
335 quick_error!(WRAPPER $enum_name [ struct ] $name $(#[$meta])*);
336 quick_error!(SORT [enum $enum_name $(#[$meta])* ]
337 items [] buf []
338 queue [ $($chunks)* ]);
339 };
340
341 ( $(#[$meta:meta])*
342 enum $name:ident wraps pub $enum_name:ident { $($chunks:tt)* }
343 ) => {
344 quick_error!(WRAPPER $enum_name [ struct ] $name $(#[$meta])*);
345 quick_error!(SORT [pub enum $enum_name $(#[$meta])* ]
346 items [] buf []
347 queue [ $($chunks)* ]);
348 };
349
350
351 (
352 WRAPPER $internal:ident [ $($strdef:tt)* ] $strname:ident
353 $(#[$meta:meta])*
354 ) => {
355 $(#[$meta])*
356 $($strdef)* $strname ( $internal );
357
358 impl ::std::fmt::Display for $strname {
359 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>)
360 -> ::std::fmt::Result
361 {
362 ::std::fmt::Display::fmt(&self.0, f)
363 }
364 }
365
366 impl From<$internal> for $strname {
367 fn from(err: $internal) -> Self {
368 $strname(err)
369 }
370 }
371
372 impl ::std::error::Error for $strname {
373 fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
374 self.0.source()
375 }
376 }
377 };
378
379 // Queue is empty, can do the work
380 (SORT [enum $name:ident $( #[$meta:meta] )*]
381 items [$($( #[$imeta:meta] )*
382 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
383 {$( $ifuncs:tt )*} )* ]
384 buf [ ]
385 queue [ ]
386 ) => {
387 quick_error!(ENUM_DEFINITION [enum $name $( #[$meta] )*]
388 body []
389 queue [$($( #[$imeta] )*
390 => $iitem: $imode [$( $ivar: $ityp ),*] )*]
391 );
392 quick_error!(IMPLEMENTATIONS $name {$(
393 $iitem: $imode [$(#[$imeta])*] [$( $ivar: $ityp ),*] {$( $ifuncs )*}
394 )*});
395 $(
396 quick_error!(ERROR_CHECK $imode $($ifuncs)*);
397 )*
398 };
399 (SORT [pub enum $name:ident $( #[$meta:meta] )*]
400 items [$($( #[$imeta:meta] )*
401 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
402 {$( $ifuncs:tt )*} )* ]
403 buf [ ]
404 queue [ ]
405 ) => {
406 quick_error!(ENUM_DEFINITION [pub enum $name $( #[$meta] )*]
407 body []
408 queue [$($( #[$imeta] )*
409 => $iitem: $imode [$( $ivar: $ityp ),*] )*]
410 );
411 quick_error!(IMPLEMENTATIONS $name {$(
412 $iitem: $imode [$(#[$imeta])*] [$( $ivar: $ityp ),*] {$( $ifuncs )*}
413 )*});
414 $(
415 quick_error!(ERROR_CHECK $imode $($ifuncs)*);
416 )*
417 };
418 // Add meta to buffer
419 (SORT [$( $def:tt )*]
420 items [$($( #[$imeta:meta] )*
421 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
422 {$( $ifuncs:tt )*} )* ]
423 buf [$( #[$bmeta:meta] )*]
424 queue [ #[$qmeta:meta] $( $tail:tt )*]
425 ) => {
426 quick_error!(SORT [$( $def )*]
427 items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*]
428 buf [$( #[$bmeta] )* #[$qmeta] ]
429 queue [$( $tail )*]);
430 };
431 // Add ident to buffer
432 (SORT [$( $def:tt )*]
433 items [$($( #[$imeta:meta] )*
434 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
435 {$( $ifuncs:tt )*} )* ]
436 buf [$( #[$bmeta:meta] )*]
437 queue [ $qitem:ident $( $tail:tt )*]
438 ) => {
439 quick_error!(SORT [$( $def )*]
440 items [$( $(#[$imeta])*
441 => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*]
442 buf [$(#[$bmeta])* => $qitem : UNIT [ ] ]
443 queue [$( $tail )*]);
444 };
445 // Flush buffer on meta after ident
446 (SORT [$( $def:tt )*]
447 items [$($( #[$imeta:meta] )*
448 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
449 {$( $ifuncs:tt )*} )* ]
450 buf [$( #[$bmeta:meta] )*
451 => $bitem:ident: $bmode:tt [$( $bvar:ident: $btyp:ty ),*] ]
452 queue [ #[$qmeta:meta] $( $tail:tt )*]
453 ) => {
454 quick_error!(SORT [$( $def )*]
455 items [$($( #[$imeta:meta] )*
456 => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*
457 $bitem: $bmode [$( $bvar:$btyp ),*] {} ]
458 buf [ #[$qmeta] ]
459 queue [$( $tail )*]);
460 };
461 // Add tuple enum-variant
462 (SORT [$( $def:tt )*]
463 items [$($( #[$imeta:meta] )*
464 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
465 {$( $ifuncs:tt )*} )* ]
466 buf [$( #[$bmeta:meta] )* => $bitem:ident: UNIT [ ] ]
467 queue [($( $qvar:ident: $qtyp:ty ),+) $( $tail:tt )*]
468 ) => {
469 quick_error!(SORT [$( $def )*]
470 items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*]
471 buf [$( #[$bmeta] )* => $bitem: TUPLE [$( $qvar:$qtyp ),+] ]
472 queue [$( $tail )*]
473 );
474 };
475 // Add struct enum-variant - e.g. { descr: &'static str }
476 (SORT [$( $def:tt )*]
477 items [$($( #[$imeta:meta] )*
478 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
479 {$( $ifuncs:tt )*} )* ]
480 buf [$( #[$bmeta:meta] )* => $bitem:ident: UNIT [ ] ]
481 queue [{ $( $qvar:ident: $qtyp:ty ),+} $( $tail:tt )*]
482 ) => {
483 quick_error!(SORT [$( $def )*]
484 items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*]
485 buf [$( #[$bmeta] )* => $bitem: STRUCT [$( $qvar:$qtyp ),+] ]
486 queue [$( $tail )*]);
487 };
488 // Add struct enum-variant, with excess comma - e.g. { descr: &'static str, }
489 (SORT [$( $def:tt )*]
490 items [$($( #[$imeta:meta] )*
491 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
492 {$( $ifuncs:tt )*} )* ]
493 buf [$( #[$bmeta:meta] )* => $bitem:ident: UNIT [ ] ]
494 queue [{$( $qvar:ident: $qtyp:ty ),+ ,} $( $tail:tt )*]
495 ) => {
496 quick_error!(SORT [$( $def )*]
497 items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*]
498 buf [$( #[$bmeta] )* => $bitem: STRUCT [$( $qvar:$qtyp ),+] ]
499 queue [$( $tail )*]);
500 };
501 // Add braces and flush always on braces
502 (SORT [$( $def:tt )*]
503 items [$($( #[$imeta:meta] )*
504 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
505 {$( $ifuncs:tt )*} )* ]
506 buf [$( #[$bmeta:meta] )*
507 => $bitem:ident: $bmode:tt [$( $bvar:ident: $btyp:ty ),*] ]
508 queue [ {$( $qfuncs:tt )*} $( $tail:tt )*]
509 ) => {
510 quick_error!(SORT [$( $def )*]
511 items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*
512 $(#[$bmeta])* => $bitem: $bmode [$( $bvar:$btyp ),*] {$( $qfuncs )*} ]
513 buf [ ]
514 queue [$( $tail )*]);
515 };
516 // Flush buffer on double ident
517 (SORT [$( $def:tt )*]
518 items [$($( #[$imeta:meta] )*
519 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
520 {$( $ifuncs:tt )*} )* ]
521 buf [$( #[$bmeta:meta] )*
522 => $bitem:ident: $bmode:tt [$( $bvar:ident: $btyp:ty ),*] ]
523 queue [ $qitem:ident $( $tail:tt )*]
524 ) => {
525 quick_error!(SORT [$( $def )*]
526 items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*
527 $(#[$bmeta])* => $bitem: $bmode [$( $bvar:$btyp ),*] {} ]
528 buf [ => $qitem : UNIT [ ] ]
529 queue [$( $tail )*]);
530 };
531 // Flush buffer on end
532 (SORT [$( $def:tt )*]
533 items [$($( #[$imeta:meta] )*
534 => $iitem:ident: $imode:tt [$( $ivar:ident: $ityp:ty ),*]
535 {$( $ifuncs:tt )*} )* ]
536 buf [$( #[$bmeta:meta] )*
537 => $bitem:ident: $bmode:tt [$( $bvar:ident: $btyp:ty ),*] ]
538 queue [ ]
539 ) => {
540 quick_error!(SORT [$( $def )*]
541 items [$( $(#[$imeta])* => $iitem: $imode [$( $ivar:$ityp ),*] {$( $ifuncs )*} )*
542 $(#[$bmeta])* => $bitem: $bmode [$( $bvar:$btyp ),*] {} ]
543 buf [ ]
544 queue [ ]);
545 };
546 // Public enum (Queue Empty)
547 (ENUM_DEFINITION [pub enum $name:ident $( #[$meta:meta] )*]
548 body [$($( #[$imeta:meta] )*
549 => $iitem:ident ($(($( $ttyp:ty ),+))*) {$({$( $svar:ident: $styp:ty ),*})*} )* ]
550 queue [ ]
551 ) => {
552 #[allow(unknown_lints)] // no unused_doc_comments in older rust
553 #[allow(renamed_and_removed_lints)]
554 #[allow(unused_doc_comment)]
555 #[allow(unused_doc_comments)]
556 $(#[$meta])*
557 pub enum $name {
558 $(
559 $(#[$imeta])*
560 $iitem $(($( $ttyp ),+))* $({$( $svar: $styp ),*})*,
561 )*
562 }
563 };
564 // Private enum (Queue Empty)
565 (ENUM_DEFINITION [enum $name:ident $( #[$meta:meta] )*]
566 body [$($( #[$imeta:meta] )*
567 => $iitem:ident ($(($( $ttyp:ty ),+))*) {$({$( $svar:ident: $styp:ty ),*})*} )* ]
568 queue [ ]
569 ) => {
570 #[allow(unknown_lints)] // no unused_doc_comments in older rust
571 #[allow(renamed_and_removed_lints)]
572 #[allow(unused_doc_comment)]
573 #[allow(unused_doc_comments)]
574 $(#[$meta])*
575 enum $name {
576 $(
577 $(#[$imeta])*
578 $iitem $(($( $ttyp ),+))* $({$( $svar: $styp ),*})*,
579 )*
580 }
581 };
582 // Unit variant
583 (ENUM_DEFINITION [$( $def:tt )*]
584 body [$($( #[$imeta:meta] )*
585 => $iitem:ident ($(($( $ttyp:ty ),+))*) {$({$( $svar:ident: $styp:ty ),*})*} )* ]
586 queue [$( #[$qmeta:meta] )*
587 => $qitem:ident: UNIT [ ] $( $queue:tt )*]
588 ) => {
589 quick_error!(ENUM_DEFINITION [ $($def)* ]
590 body [$($( #[$imeta] )* => $iitem ($(($( $ttyp ),+))*) {$({$( $svar: $styp ),*})*} )*
591 $( #[$qmeta] )* => $qitem () {} ]
592 queue [ $($queue)* ]
593 );
594 };
595 // Tuple variant
596 (ENUM_DEFINITION [$( $def:tt )*]
597 body [$($( #[$imeta:meta] )*
598 => $iitem:ident ($(($( $ttyp:ty ),+))*) {$({$( $svar:ident: $styp:ty ),*})*} )* ]
599 queue [$( #[$qmeta:meta] )*
600 => $qitem:ident: TUPLE [$( $qvar:ident: $qtyp:ty ),+] $( $queue:tt )*]
601 ) => {
602 quick_error!(ENUM_DEFINITION [ $($def)* ]
603 body [$($( #[$imeta] )* => $iitem ($(($( $ttyp ),+))*) {$({$( $svar: $styp ),*})*} )*
604 $( #[$qmeta] )* => $qitem (($( $qtyp ),+)) {} ]
605 queue [ $($queue)* ]
606 );
607 };
608 // Struct variant
609 (ENUM_DEFINITION [$( $def:tt )*]
610 body [$($( #[$imeta:meta] )*
611 => $iitem:ident ($(($( $ttyp:ty ),+))*) {$({$( $svar:ident: $styp:ty ),*})*} )* ]
612 queue [$( #[$qmeta:meta] )*
613 => $qitem:ident: STRUCT [$( $qvar:ident: $qtyp:ty ),*] $( $queue:tt )*]
614 ) => {
615 quick_error!(ENUM_DEFINITION [ $($def)* ]
616 body [$($( #[$imeta] )* => $iitem ($(($( $ttyp ),+))*) {$({$( $svar: $styp ),*})*} )*
617 $( #[$qmeta] )* => $qitem () {{$( $qvar: $qtyp ),*}} ]
618 queue [ $($queue)* ]
619 );
620 };
621 (IMPLEMENTATIONS
622 $name:ident {$(
623 $item:ident: $imode:tt [$(#[$imeta:meta])*] [$( $var:ident: $typ:ty ),*] {$( $funcs:tt )*}
624 )*}
625 ) => {
626 #[allow(unused_variables)]
627 #[allow(unknown_lints)] // no unused_doc_comments in older rust
628 #[allow(renamed_and_removed_lints)]
629 #[allow(unused_doc_comment)]
630 #[allow(unused_doc_comments)]
631 impl ::std::fmt::Display for $name {
632 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>)
633 -> ::std::fmt::Result
634 {
635 match *self {
636 $(
637 $(#[$imeta])*
638 quick_error!(ITEM_PATTERN
639 $name $item: $imode [$( ref $var ),*]
640 ) => {
641 let display_fn = quick_error!(FIND_DISPLAY_IMPL
642 $name $item: $imode
643 {$( $funcs )*});
644
645 display_fn(self, fmt)
646 }
647 )*
648 }
649 }
650 }
651 #[allow(unused_variables)]
652 #[allow(unknown_lints)] // no unused_doc_comments in older rust
653 #[allow(renamed_and_removed_lints)]
654 #[allow(unused_doc_comment)]
655 #[allow(unused_doc_comments)]
656 impl ::std::error::Error for $name {
657 fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
658 match *self {
659 $(
660 $(#[$imeta])*
661 quick_error!(ITEM_PATTERN
662 $name $item: $imode [$( ref $var ),*]
663 ) => {
664 quick_error!(FIND_SOURCE_IMPL
665 $item: $imode [$( $var ),*]
666 {$( $funcs )*})
667 }
668 )*
669 }
670 }
671 }
672 $(
673 quick_error!(FIND_FROM_IMPL
674 $name $item: $imode [$( $var:$typ ),*]
675 {$( $funcs )*});
676 )*
677 $(
678 quick_error!(FIND_CONTEXT_IMPL
679 $name $item: $imode [$( $var:$typ ),*]
680 {$( $funcs )*});
681 )*
682 };
683 (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
684 { display($self_:tt) -> ($( $exprs:tt )*) $( $tail:tt )*}
685 ) => {
686 |quick_error!(IDENT $self_): &$name, f: &mut ::std::fmt::Formatter<'_>| { write!(f, $( $exprs )*) }
687 };
688 (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
689 { display($pattern:expr) $( $tail:tt )*}
690 ) => {
691 |_, f: &mut ::std::fmt::Formatter<'_>| { write!(f, $pattern) }
692 };
693 (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
694 { display($pattern:expr, $( $exprs:tt )*) $( $tail:tt )*}
695 ) => {
696 |_, f: &mut ::std::fmt::Formatter<'_>| { write!(f, $pattern, $( $exprs )*) }
697 };
698 (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
699 { $t:tt $( $tail:tt )*}
700 ) => {
701 quick_error!(FIND_DISPLAY_IMPL
702 $name $item: $imode
703 {$( $tail )*})
704 };
705 (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
706 { }
707 ) => {
708 |self_: &$name, f: &mut ::std::fmt::Formatter<'_>| {
709 write!(f, "{:?}", self_)
710 }
711 };
712 (FIND_SOURCE_IMPL $item:ident: $imode:tt
713 [$( $var:ident ),*]
714 { source($expr:expr) $( $tail:tt )*}
715 ) => {
716 Some($expr)
717 };
718 (FIND_SOURCE_IMPL $item:ident: $imode:tt
719 [$( $var:ident ),*]
720 { $t:tt $( $tail:tt )*}
721 ) => {
722 quick_error!(FIND_SOURCE_IMPL
723 $item: $imode [$( $var ),*]
724 { $($tail)* })
725 };
726 (FIND_SOURCE_IMPL $item:ident: $imode:tt
727 [$( $var:ident ),*]
728 { }
729 ) => {
730 None
731 };
732 // ----------------------------- FROM IMPL --------------------------
733 (FIND_FROM_IMPL $name:ident $item:ident: $imode:tt
734 [$( $var:ident: $typ:ty ),*]
735 { from() $( $tail:tt )*}
736 ) => {
737 $(
738 impl From<$typ> for $name {
739 fn from($var: $typ) -> $name {
740 $name::$item($var)
741 }
742 }
743 )*
744 quick_error!(FIND_FROM_IMPL
745 $name $item: $imode [$( $var:$typ ),*]
746 {$( $tail )*});
747 };
748 (FIND_FROM_IMPL $name:ident $item:ident: UNIT
749 [ ]
750 { from($ftyp:ty) $( $tail:tt )*}
751 ) => {
752 impl From<$ftyp> for $name {
753 fn from(_discarded_error: $ftyp) -> $name {
754 $name::$item
755 }
756 }
757 quick_error!(FIND_FROM_IMPL
758 $name $item: UNIT [ ]
759 {$( $tail )*});
760 };
761 (FIND_FROM_IMPL $name:ident $item:ident: TUPLE
762 [$( $var:ident: $typ:ty ),*]
763 { from($fvar:ident: $ftyp:ty) -> ($( $texpr:expr ),*) $( $tail:tt )*}
764 ) => {
765 impl From<$ftyp> for $name {
766 fn from($fvar: $ftyp) -> $name {
767 $name::$item($( $texpr ),*)
768 }
769 }
770 quick_error!(FIND_FROM_IMPL
771 $name $item: TUPLE [$( $var:$typ ),*]
772 { $($tail)* });
773 };
774 (FIND_FROM_IMPL $name:ident $item:ident: STRUCT
775 [$( $var:ident: $typ:ty ),*]
776 { from($fvar:ident: $ftyp:ty) -> {$( $tvar:ident: $texpr:expr ),*} $( $tail:tt )*}
777 ) => {
778 impl From<$ftyp> for $name {
779 fn from($fvar: $ftyp) -> $name {
780 $name::$item {
781 $( $tvar: $texpr ),*
782 }
783 }
784 }
785 quick_error!(FIND_FROM_IMPL
786 $name $item: STRUCT [$( $var:$typ ),*]
787 { $($tail)* });
788 };
789 (FIND_FROM_IMPL $name:ident $item:ident: $imode:tt
790 [$( $var:ident: $typ:ty ),*]
791 { $t:tt $( $tail:tt )*}
792 ) => {
793 quick_error!(FIND_FROM_IMPL
794 $name $item: $imode [$( $var:$typ ),*]
795 {$( $tail )*}
796 );
797 };
798 (FIND_FROM_IMPL $name:ident $item:ident: $imode:tt
799 [$( $var:ident: $typ:ty ),*]
800 { }
801 ) => {
802 };
803 // ----------------------------- CONTEXT IMPL --------------------------
804 (FIND_CONTEXT_IMPL $name:ident $item:ident: TUPLE
805 [$( $var:ident: $typ:ty ),*]
806 { context($cvar:ident: AsRef<$ctyp:ty>, $fvar:ident: $ftyp:ty)
807 -> ($( $texpr:expr ),*) $( $tail:tt )* }
808 ) => {
809 impl<T: AsRef<$ctyp>> From<$crate::Context<T, $ftyp>> for $name {
810 fn from(
811 $crate::Context($cvar, $fvar): $crate::Context<T, $ftyp>)
812 -> $name
813 {
814 $name::$item($( $texpr ),*)
815 }
816 }
817 quick_error!(FIND_CONTEXT_IMPL
818 $name $item: TUPLE [$( $var:$typ ),*]
819 { $($tail)* });
820 };
821 (FIND_CONTEXT_IMPL $name:ident $item:ident: TUPLE
822 [$( $var:ident: $typ:ty ),*]
823 { context($cvar:ident: $ctyp:ty, $fvar:ident: $ftyp:ty)
824 -> ($( $texpr:expr ),*) $( $tail:tt )* }
825 ) => {
826 impl<'a> From<$crate::Context<$ctyp, $ftyp>> for $name {
827 fn from(
828 $crate::Context($cvar, $fvar): $crate::Context<$ctyp, $ftyp>)
829 -> $name
830 {
831 $name::$item($( $texpr ),*)
832 }
833 }
834 quick_error!(FIND_CONTEXT_IMPL
835 $name $item: TUPLE [$( $var:$typ ),*]
836 { $($tail)* });
837 };
838 (FIND_CONTEXT_IMPL $name:ident $item:ident: STRUCT
839 [$( $var:ident: $typ:ty ),*]
840 { context($cvar:ident: AsRef<$ctyp:ty>, $fvar:ident: $ftyp:ty)
841 -> {$( $tvar:ident: $texpr:expr ),*} $( $tail:tt )* }
842 ) => {
843 impl<T: AsRef<$ctyp>> From<$crate::Context<T, $ftyp>> for $name {
844 fn from(
845 $crate::Context($cvar, $fvar): $crate::Context<$ctyp, $ftyp>)
846 -> $name
847 {
848 $name::$item {
849 $( $tvar: $texpr ),*
850 }
851 }
852 }
853 quick_error!(FIND_CONTEXT_IMPL
854 $name $item: STRUCT [$( $var:$typ ),*]
855 { $($tail)* });
856 };
857 (FIND_CONTEXT_IMPL $name:ident $item:ident: STRUCT
858 [$( $var:ident: $typ:ty ),*]
859 { context($cvar:ident: $ctyp:ty, $fvar:ident: $ftyp:ty)
860 -> {$( $tvar:ident: $texpr:expr ),*} $( $tail:tt )* }
861 ) => {
862 impl<'a> From<$crate::Context<$ctyp, $ftyp>> for $name {
863 fn from(
864 $crate::Context($cvar, $fvar): $crate::Context<$ctyp, $ftyp>)
865 -> $name
866 {
867 $name::$item {
868 $( $tvar: $texpr ),*
869 }
870 }
871 }
872 quick_error!(FIND_CONTEXT_IMPL
873 $name $item: STRUCT [$( $var:$typ ),*]
874 { $($tail)* });
875 };
876 (FIND_CONTEXT_IMPL $name:ident $item:ident: $imode:tt
877 [$( $var:ident: $typ:ty ),*]
878 { $t:tt $( $tail:tt )*}
879 ) => {
880 quick_error!(FIND_CONTEXT_IMPL
881 $name $item: $imode [$( $var:$typ ),*]
882 {$( $tail )*}
883 );
884 };
885 (FIND_CONTEXT_IMPL $name:ident $item:ident: $imode:tt
886 [$( $var:ident: $typ:ty ),*]
887 { }
888 ) => {
889 };
890 // ----------------------------- ITEM IMPL --------------------------
891 (ITEM_BODY $(#[$imeta:meta])* $item:ident: UNIT
892 ) => { };
893 (ITEM_BODY $(#[$imeta:meta])* $item:ident: TUPLE
894 [$( $typ:ty ),*]
895 ) => {
896 ($( $typ ),*)
897 };
898 (ITEM_BODY $(#[$imeta:meta])* $item:ident: STRUCT
899 [$( $var:ident: $typ:ty ),*]
900 ) => {
901 {$( $var:$typ ),*}
902 };
903 (ITEM_PATTERN $name:ident $item:ident: UNIT []
904 ) => {
905 $name::$item
906 };
907 (ITEM_PATTERN $name:ident $item:ident: TUPLE
908 [$( ref $var:ident ),*]
909 ) => {
910 $name::$item ($( ref $var ),*)
911 };
912 (ITEM_PATTERN $name:ident $item:ident: STRUCT
913 [$( ref $var:ident ),*]
914 ) => {
915 $name::$item {$( ref $var ),*}
916 };
917 // This one should match all allowed sequences in "funcs" but not match
918 // anything else.
919 // This is to contrast FIND_* clauses which just find stuff they need and
920 // skip everything else completely
921 (ERROR_CHECK $imode:tt display($self_:tt) -> ($( $exprs:tt )*) $( $tail:tt )*)
922 => { quick_error!(ERROR_CHECK $imode $($tail)*); };
923 (ERROR_CHECK $imode:tt display($pattern: expr) $( $tail:tt )*)
924 => { quick_error!(ERROR_CHECK $imode $($tail)*); };
925 (ERROR_CHECK $imode:tt display($pattern: expr, $( $exprs:tt )*) $( $tail:tt )*)
926 => { quick_error!(ERROR_CHECK $imode $($tail)*); };
927 (ERROR_CHECK $imode:tt source($expr:expr) $($tail:tt)*)
928 => { quick_error!(ERROR_CHECK $imode $($tail)*); };
929 (ERROR_CHECK $imode:tt from() $($tail:tt)*)
930 => { quick_error!(ERROR_CHECK $imode $($tail)*); };
931 (ERROR_CHECK $imode:tt from($ftyp:ty) $($tail:tt)*)
932 => { quick_error!(ERROR_CHECK $imode $($tail)*); };
933 (ERROR_CHECK TUPLE from($fvar:ident: $ftyp:ty) -> ($( $e:expr ),*) $( $tail:tt )*)
934 => { quick_error!(ERROR_CHECK TUPLE $($tail)*); };
935 (ERROR_CHECK STRUCT from($fvar:ident: $ftyp:ty) -> {$( $v:ident: $e:expr ),*} $( $tail:tt )*)
936 => { quick_error!(ERROR_CHECK STRUCT $($tail)*); };
937
938 (ERROR_CHECK TUPLE context($cvar:ident: $ctyp:ty, $fvar:ident: $ftyp:ty)
939 -> ($( $e:expr ),*) $( $tail:tt )*)
940 => { quick_error!(ERROR_CHECK TUPLE $($tail)*); };
941 (ERROR_CHECK STRUCT context($cvar:ident: $ctyp:ty, $fvar:ident: $ftyp:ty)
942 -> {$( $v:ident: $e:expr ),*} $( $tail:tt )*)
943 => { quick_error!(ERROR_CHECK STRUCT $($tail)*); };
944
945 (ERROR_CHECK $imode:tt ) => {};
946 // Utility functions
947 (IDENT $ident:ident) => { $ident }
948}
949
950/// Generic context type
951///
952/// Used mostly as a transport for `ResultExt::context` method
953#[derive(Debug)]
954pub struct Context<X, E>(pub X, pub E);
955
956/// Result extension trait adding a `context` method
957pub trait ResultExt<T, E> {
958 /// The method is use to add context information to current operation
959 ///
960 /// The context data is then used in error constructor to store additional
961 /// information within error. For example, you may add a filename as a
962 /// context for file operation. See crate documentation for the actual
963 /// example.
964 fn context<X>(self, x: X) -> Result<T, Context<X, E>>;
965}
966
967impl<T, E> ResultExt<T, E> for Result<T, E> {
968 fn context<X>(self, x: X) -> Result<T, Context<X, E>> {
969 self.map_err(|e: E| Context(x, e))
970 }
971}
972
973#[cfg(test)]
974mod test {
975 use std::error::Error;
976 use std::num::{ParseFloatError, ParseIntError};
977 use std::path::{Path, PathBuf};
978 use std::str::Utf8Error;
979 use std::string::FromUtf8Error;
980
981 use super::ResultExt;
982
983 quick_error! {
984 #[derive(Debug)]
985 pub enum Bare {
986 One
987 Two
988 }
989 }
990
991 #[test]
992 fn bare_item_direct() {
993 assert_eq!(format!("{}", Bare::One), "One".to_string());
994 assert_eq!(format!("{:?}", Bare::One), "One".to_string());
995 assert!(Bare::One.source().is_none());
996 }
997
998 #[test]
999 fn bare_item_trait() {
1000 let err: &dyn Error = &Bare::Two;
1001 assert_eq!(format!("{}", err), "Two".to_string());
1002 assert_eq!(format!("{:?}", err), "Two".to_string());
1003 assert!(err.source().is_none());
1004 }
1005
1006 quick_error! {
1007 #[derive(Debug)]
1008 pub enum Wrapper wraps Wrapped {
1009 One
1010 Two(s: String) {
1011 display("two: {}", s)
1012 from()
1013 }
1014 }
1015 }
1016
1017 #[test]
1018 fn wrapper() {
1019 assert_eq!(
1020 format!("{}", Wrapper::from(Wrapped::One)),
1021 "One".to_string()
1022 );
1023 assert_eq!(
1024 format!("{}", Wrapper::from(Wrapped::from(String::from("hello")))),
1025 "two: hello".to_string()
1026 );
1027 assert_eq!(
1028 format!("{:?}", Wrapper::from(Wrapped::One)),
1029 "Wrapper(One)".to_string()
1030 );
1031 }
1032
1033 quick_error! {
1034 #[derive(Debug, PartialEq)]
1035 pub enum TupleWrapper {
1036 /// ParseFloat Error
1037 ParseFloatError(err: ParseFloatError) {
1038 from()
1039 display("parse float error: {err}", err=err)
1040 source(err)
1041 }
1042 Other(descr: &'static str) {
1043 display("Error: {}", descr)
1044 }
1045 /// FromUtf8 Error
1046 FromUtf8Error(err: Utf8Error, source: Vec<u8>) {
1047 source(err)
1048 display(me) -> ("{desc} at index {pos}: {err}", desc="utf8 error", pos=err.valid_up_to(), err=err)
1049 from(err: FromUtf8Error) -> (err.utf8_error().clone(), err.into_bytes())
1050 }
1051 Discard {
1052 from(&'static str)
1053 }
1054 Singleton {
1055 display("Just a string")
1056 }
1057 }
1058 }
1059
1060 #[test]
1061 fn tuple_wrapper_err() {
1062 let source = "one and a half times pi".parse::<f32>().unwrap_err();
1063 let err = TupleWrapper::ParseFloatError(source.clone());
1064 assert_eq!(format!("{}", err), format!("parse float error: {}", source));
1065 assert_eq!(
1066 format!("{:?}", err),
1067 format!("ParseFloatError({:?})", source)
1068 );
1069 assert_eq!(
1070 format!("{:?}", err.source().unwrap()),
1071 format!("{:?}", source)
1072 );
1073 }
1074
1075 #[test]
1076 fn tuple_wrapper_trait_str() {
1077 let desc = "hello";
1078 let err: &dyn Error = &TupleWrapper::Other(desc);
1079 assert_eq!(format!("{}", err), format!("Error: {}", desc));
1080 assert_eq!(format!("{:?}", err), format!("Other({:?})", desc));
1081 assert!(err.source().is_none());
1082 }
1083
1084 #[test]
1085 fn tuple_wrapper_trait_two_fields() {
1086 let invalid_utf8: Vec<u8> = vec![0, 159, 146, 150];
1087 let source = String::from_utf8(invalid_utf8.clone())
1088 .unwrap_err()
1089 .utf8_error();
1090 let err: &dyn Error = &TupleWrapper::FromUtf8Error(source.clone(), invalid_utf8.clone());
1091 assert_eq!(
1092 format!("{}", err),
1093 format!(
1094 "{desc} at index {pos}: {source}",
1095 desc = "utf8 error",
1096 pos = source.valid_up_to(),
1097 source = source
1098 )
1099 );
1100 assert_eq!(
1101 format!("{:?}", err),
1102 format!("FromUtf8Error({:?}, {:?})", source, invalid_utf8)
1103 );
1104 assert_eq!(
1105 format!("{:?}", err.source().unwrap()),
1106 format!("{:?}", source)
1107 );
1108 }
1109
1110 #[test]
1111 fn tuple_wrapper_from() {
1112 let source = "one and a half times pi".parse::<f32>().unwrap_err();
1113 let err = TupleWrapper::ParseFloatError(source.clone());
1114 let err_from: TupleWrapper = From::from(source);
1115 assert_eq!(err_from, err);
1116 }
1117
1118 #[test]
1119 fn tuple_wrapper_custom_from() {
1120 let invalid_utf8: Vec<u8> = vec![0, 159, 146, 150];
1121 let source = String::from_utf8(invalid_utf8.clone()).unwrap_err();
1122 let err = TupleWrapper::FromUtf8Error(source.utf8_error().clone(), invalid_utf8);
1123 let err_from: TupleWrapper = From::from(source);
1124 assert_eq!(err_from, err);
1125 }
1126
1127 #[test]
1128 fn tuple_wrapper_discard() {
1129 let err: TupleWrapper = From::from("hello");
1130 assert_eq!(format!("{}", err), format!("Discard"));
1131 assert_eq!(format!("{:?}", err), format!("Discard"));
1132 assert!(err.source().is_none());
1133 }
1134
1135 #[test]
1136 fn tuple_wrapper_singleton() {
1137 let err: TupleWrapper = TupleWrapper::Singleton;
1138 assert_eq!(format!("{}", err), format!("Just a string"));
1139 assert_eq!(format!("{:?}", err), format!("Singleton"));
1140 assert!(err.source().is_none());
1141 }
1142
1143 quick_error! {
1144 #[derive(Debug, PartialEq)]
1145 pub enum StructWrapper {
1146 // Utf8 Error
1147 Utf8Error{ err: Utf8Error, hint: Option<&'static str> } {
1148 source(err)
1149 display(me) -> ("{desc} at index {pos}: {err}", desc="utf8 error", pos=err.valid_up_to(), err=err)
1150 from(err: Utf8Error) -> { err: err, hint: None }
1151 }
1152 // Utf8 Error
1153 ExcessComma { descr: &'static str, } {
1154 display("Error: {}", descr)
1155 }
1156 }
1157 }
1158
1159 #[test]
1160 fn struct_wrapper_err() {
1161 let invalid_utf8: Vec<u8> = vec![0, 159, 146, 150];
1162 let source = String::from_utf8(invalid_utf8.clone())
1163 .unwrap_err()
1164 .utf8_error();
1165 let err: &dyn Error = &StructWrapper::Utf8Error {
1166 err: source.clone(),
1167 hint: Some("nonsense"),
1168 };
1169 assert_eq!(
1170 format!("{}", err),
1171 format!(
1172 "{desc} at index {pos}: {source}",
1173 desc = "utf8 error",
1174 pos = source.valid_up_to(),
1175 source = source
1176 )
1177 );
1178 assert_eq!(
1179 format!("{:?}", err),
1180 format!(
1181 "Utf8Error {{ err: {:?}, hint: {:?} }}",
1182 source,
1183 Some("nonsense")
1184 )
1185 );
1186 assert_eq!(
1187 format!("{:?}", err.source().unwrap()),
1188 format!("{:?}", source)
1189 );
1190 }
1191
1192 #[test]
1193 fn struct_wrapper_struct_from() {
1194 let invalid_utf8: Vec<u8> = vec![0, 159, 146, 150];
1195 let source = String::from_utf8(invalid_utf8.clone())
1196 .unwrap_err()
1197 .utf8_error();
1198 let err = StructWrapper::Utf8Error {
1199 err: source.clone(),
1200 hint: None,
1201 };
1202 let err_from: StructWrapper = From::from(source);
1203 assert_eq!(err_from, err);
1204 }
1205
1206 #[test]
1207 fn struct_wrapper_excess_comma() {
1208 let descr = "hello";
1209 let err = StructWrapper::ExcessComma { descr: descr };
1210 assert_eq!(format!("{}", err), format!("Error: {}", descr));
1211 assert_eq!(
1212 format!("{:?}", err),
1213 format!("ExcessComma {{ descr: {:?} }}", descr)
1214 );
1215 assert!(err.source().is_none());
1216 }
1217
1218 quick_error! {
1219 #[derive(Debug)]
1220 pub enum ContextErr {
1221 Float(src: String, err: ParseFloatError) {
1222 context(s: &'a str, e: ParseFloatError) -> (s.to_string(), e)
1223 display("Float error {:?}: {}", src, err)
1224 }
1225 Int { src: String, err: ParseIntError } {
1226 context(s: &'a str, e: ParseIntError)
1227 -> {src: s.to_string(), err: e}
1228 display("Int error {:?}: {}", src, err)
1229 }
1230 Utf8(path: PathBuf, err: Utf8Error) {
1231 context(p: AsRef<Path>, e: Utf8Error)
1232 -> (p.as_ref().to_path_buf(), e)
1233 display("Path error at {:?}: {}", path, err)
1234 }
1235 Utf8Str(s: String, err: ::std::io::Error) {
1236 context(s: AsRef<str>, e: ::std::io::Error)
1237 -> (s.as_ref().to_string(), e)
1238 display("Str error {:?}: {}", s, err)
1239 }
1240 }
1241 }
1242
1243 #[test]
1244 fn parse_float_error() {
1245 fn parse_float(s: &str) -> Result<f32, ContextErr> {
1246 Ok(s.parse().context(s)?)
1247 }
1248 assert_eq!(
1249 format!("{}", parse_float("12ab").unwrap_err()),
1250 r#"Float error "12ab": invalid float literal"#
1251 );
1252 }
1253
1254 #[test]
1255 fn parse_int_error() {
1256 fn parse_int(s: &str) -> Result<i32, ContextErr> {
1257 Ok(s.parse().context(s)?)
1258 }
1259 assert_eq!(
1260 format!("{}", parse_int("12.5").unwrap_err()),
1261 r#"Int error "12.5": invalid digit found in string"#
1262 );
1263 }
1264
1265 #[test]
1266 fn debug_context() {
1267 fn parse_int(s: &str) -> i32 {
1268 s.parse().context(s).unwrap()
1269 }
1270 assert_eq!(parse_int("12"), 12);
1271 assert_eq!(
1272 format!("{:?}", "x".parse::<i32>().context("x")),
1273 r#"Err(Context("x", ParseIntError { kind: InvalidDigit }))"#
1274 );
1275 }
1276
1277 #[test]
1278 fn path_context() {
1279 fn parse_utf<P: AsRef<Path>>(s: &[u8], p: P) -> Result<(), ContextErr> {
1280 ::std::str::from_utf8(s).context(p)?;
1281 Ok(())
1282 }
1283 let etext = parse_utf(b"a\x80\x80", "/etc").unwrap_err().to_string();
1284 assert!(etext.starts_with("Path error at \"/etc\": invalid utf-8"));
1285 let etext = parse_utf(b"\x80\x80", PathBuf::from("/tmp"))
1286 .unwrap_err()
1287 .to_string();
1288 assert!(etext.starts_with("Path error at \"/tmp\": invalid utf-8"));
1289 }
1290
1291 #[test]
1292 fn conditional_compilation() {
1293 quick_error! {
1294 #[allow(dead_code)]
1295 #[derive(Debug)]
1296 pub enum Test {
1297 #[cfg(feature = "foo")]
1298 Variant
1299 }
1300 }
1301 }
1302
1303 #[test]
1304 #[allow(deprecated)]
1305 fn cause_struct_wrapper_err() {
1306 let invalid_utf8: Vec<u8> = vec![0, 159, 146, 150];
1307 let cause = String::from_utf8(invalid_utf8.clone())
1308 .unwrap_err()
1309 .utf8_error();
1310 let err: &dyn Error = &StructWrapper::Utf8Error {
1311 err: cause.clone(),
1312 hint: Some("nonsense"),
1313 };
1314 assert_eq!(
1315 format!("{}", err),
1316 format!(
1317 "{desc} at index {pos}: {cause}",
1318 desc = "utf8 error",
1319 pos = cause.valid_up_to(),
1320 cause = cause
1321 )
1322 );
1323 assert_eq!(
1324 format!("{:?}", err),
1325 format!(
1326 "Utf8Error {{ err: {:?}, hint: {:?} }}",
1327 cause,
1328 Some("nonsense")
1329 )
1330 );
1331 assert_eq!(
1332 format!("{:?}", err.cause().unwrap()),
1333 format!("{:?}", cause)
1334 );
1335 }
1336}
1337