Merge remote-tracking branch 'upstream/master' into issue251

Author: Erik Zscheile

.travis.yml

@@ -5,7 +5,8 @@ rust:
 - nightly
 # Oldest supported version for all features.
 # Use of https://github.com/rust-lang/rfcs/pull/16
-- 1.14.0
+# and Backtrace needs 1.25 (see https://github.com/alexcrichton/backtrace-rs/pull/137)
+- 1.25.0
 # Oldest supported version as dependency, with no features, tests, or examples.
 - 1.10.0
 

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Unreleased
 
+# 0.12.1
+
+- [`std::error::Error::cause` deprecation update](https://github.com/rust-lang-nursery/error-chain/pull/255)
+- [Macro invocations use 2018 style](https://github.com/rust-lang-nursery/error-chain/pull/253)
+
 # 0.12.0
 
 - [Remove `impl Deref<Kind> for Error`](https://github.com/rust-lang-nursery/error-chain/pull/192)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "error-chain"
-version = "0.12.0" # remember to update html_root_url
+version = "0.12.1" # remember to update html_root_url
 authors = [ "Brian Anderson <banderson@mozilla.com>",
             "Paul Colomiets <paul@colomiets.name>",
             "Colin Kiegel <kiegel@gmx.de>",
@@ -15,12 +15,12 @@ readme = "README.md"
 
 license = "MIT/Apache-2.0"
 
-[badges]
-travis-ci = { repository = "rust-lang-nursery/error-chain" }
-
 [features]
 default = ["backtrace", "example_generated"]
 example_generated = []
 
 [dependencies]
 backtrace = { version = "0.3.3", optional = true }
+
+[build-dependencies]
+version_check = "0.1.5"

README.md

@@ -1,8 +1,8 @@
 # error-chain - Consistent error handling for Rust
 
-[![Build Status](https://api.travis-ci.org/rust-lang-nursery/error-chain.svg?branch=master)](https://travis-ci.org/rust-lang-nursery/error-chain)
+[![Build Status](https://travis-ci.com/rust-lang-nursery/error-chain.svg?branch=master)](https://travis-ci.com/rust-lang-nursery/error-chain)
 [![Latest Version](https://img.shields.io/crates/v/error-chain.svg)](https://crates.io/crates/error-chain)
-[![License](https://img.shields.io/github/license/rust-lang-nursery/error-chain.svg)](https://github.com/rust-lang-nursery/error-chain)
+[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-green.svg)](https://github.com/rust-lang-nursery/error-chain)
 
 `error-chain` makes it easy to take full advantage of Rust's error
 handling features without the overhead of maintaining boilerplate

build.rs

@@ -0,0 +1,12 @@
+extern crate version_check;
+
+use version_check::is_min_version;
+
+fn main() {
+    // Switch on for versions that have Error::source
+    // As introduced by https://github.com/rust-lang/rust/pull/53533
+    if is_min_version("1.30").map(|(is_high_enough, _actual_version)| is_high_enough).unwrap_or(false)
+    {
+        println!("cargo:rustc-cfg=has_error_source");
+    }
+}

src/backtrace.rs

@@ -7,7 +7,7 @@ mod imp {
     use std::cell::UnsafeCell;
     use std::env;
     use std::fmt;
-    use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
+    use std::sync::atomic::{AtomicUsize, Ordering};
     use std::sync::{Arc, Mutex};
 
     /// Internal representation of a backtrace
@@ -33,7 +33,7 @@ mod imp {
         /// in the generated error implementations.
         #[doc(hidden)]
         pub fn new() -> InternalBacktrace {
-            static ENABLED: AtomicUsize = ATOMIC_USIZE_INIT;
+            static ENABLED: AtomicUsize = AtomicUsize::new(0);
 
             match ENABLED.load(Ordering::SeqCst) {
                 0 => {

src/error_chain.rs

@@ -1,6 +1,76 @@
-/// Prefer to use `error_chain` instead of this macro.
 #[doc(hidden)]
 #[macro_export]
+#[cfg(not(has_error_source))]
+macro_rules! impl_error_chain_cause_or_source {
+    (
+        types {
+            $error_kind_name:ident
+        }
+
+        foreign_links {
+            $( $foreign_link_variant:ident ( $foreign_link_error_path:path )
+               $( #[$meta_foreign_links:meta] )*; )*
+        }
+    ) => {
+        #[allow(unknown_lints, renamed_and_removed_lints)]
+        #[allow(unused_doc_comment, unused_doc_comments)]
+        fn cause(&self) -> Option<&::std::error::Error> {
+            match self.1.next_error {
+                Some(ref c) => Some(&**c),
+                None => {
+                    match self.0 {
+                        $(
+                            $(#[$meta_foreign_links])*
+                            $error_kind_name::$foreign_link_variant(ref foreign_err) => {
+                                foreign_err.cause()
+                            }
+                        ) *
+                        _ => None
+                    }
+                }
+            }
+        }
+    };
+}
+
+#[cfg(has_error_source)]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! impl_error_chain_cause_or_source {
+    (
+        types {
+             $error_kind_name:ident
+        }
+
+        foreign_links {
+            $( $foreign_link_variant:ident ( $foreign_link_error_path:path )
+               $( #[$meta_foreign_links:meta] )*; )*
+        }
+    ) => {
+            #[allow(unknown_lints, renamed_and_removed_lints)]
+            #[allow(unused_doc_comment, unused_doc_comments)]
+            fn source(&self) -> Option<&(std::error::Error + 'static)> {
+                match self.1.next_error {
+                    Some(ref c) => Some(&**c),
+                    None => {
+                        match self.0 {
+                        $(
+                            $(#[$meta_foreign_links])*
+                            $error_kind_name::$foreign_link_variant(ref foreign_err) => {
+                                foreign_err.source()
+                            }
+                        ) *
+                            _ => None
+                        }
+                    }
+                }
+            }
+        };
+}
+
+/// Prefer to use `error_chain` instead of this macro.
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
 macro_rules! impl_error_chain_processed {
     // Default values for `types`.
     (
@@ -179,22 +249,13 @@ macro_rules! impl_error_chain_processed {
                 self.description()
             }
 
-            #[allow(unknown_lints, renamed_and_removed_lints)]
-            #[allow(unused_doc_comment, unused_doc_comments)]
-            fn cause(&self) -> Option<&::std::error::Error> {
-                match self.1.next_error {
-                    Some(ref c) => Some(&**c),
-                    None => {
-                        match self.0 {
-                            $(
-                                $(#[$meta_foreign_links])*
-                                $error_kind_name::$foreign_link_variant(ref foreign_err) => {
-                                    foreign_err.cause()
-                                }
-                            ) *
-                            _ => None
-                        }
-                    }
+            impl_error_chain_cause_or_source!{
+                types {
+                    $error_kind_name
+                }
+                foreign_links {
+                    $( $foreign_link_variant ( $foreign_link_error_path )
+                    $( #[$meta_foreign_links] )*; )*
                 }
             }
         }
@@ -348,7 +409,7 @@ macro_rules! impl_error_chain_processed {
 
 /// Internal macro used for reordering of the fields.
 #[doc(hidden)]
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! error_chain_processing {
     (
         ({}, $b:tt, $c:tt, $d:tt)
@@ -401,7 +462,7 @@ macro_rules! error_chain_processing {
 }
 
 /// Macro for generating error types and traits. See crate level documentation for details.
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! error_chain {
     ( $( $block_name:ident { $( $block_content:tt )* } )* ) => {
         error_chain_processing! {

src/impl_error_chain_kind.rs

@@ -1,9 +1,24 @@
-// From https://github.com/tailhook/quick-error
-// Changes:
-//   - replace `impl Error` by `impl Item::description`
-//   - $imeta
+/// From https://github.com/tailhook/quick-error
+/// Changes:
+///   - replace `impl Error` by `impl Item::description`
+///   - $imeta
 
+/// Because of the `#[macro_export(local_inner_macros)]` usage on `impl_error_chain_kind` that macro
+/// will only look inside this crate for macros to invoke. So using `stringify` or `write` from
+/// the standard library will fail. Thus we here create simple wrappers for them that are not
+/// exported as `local_inner_macros`, and thus they can in turn use the standard library macros.
 #[macro_export]
+macro_rules! stringify_internal {
+    ($($t:tt)*) => { stringify!($($t)*) }
+}
+
+/// Macro used interally for output expanding an expression
+#[macro_export]
+macro_rules! write_internal {
+    ($dst:expr, $($arg:tt)*) => (write!($dst, $($arg)*))
+}
+
+#[macro_export(local_inner_macros)]
 #[doc(hidden)]
 macro_rules! impl_error_chain_kind {
     (   $(#[$meta:meta])*
@@ -274,18 +289,18 @@ macro_rules! impl_error_chain_kind {
         { display($self_:tt) -> ($( $exprs:tt )*) $( $tail:tt )*}
     ) => {
         |impl_error_chain_kind!(IDENT $self_): &$name, f: &mut ::std::fmt::Formatter| {
-            write!(f, $( $exprs )*)
+            write_internal!(f, $( $exprs )*)
         }
     };
     (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
         { display($pattern:expr) $( $tail:tt )*}
     ) => {
-        |_, f: &mut ::std::fmt::Formatter| { write!(f, $pattern) }
+        |_, f: &mut ::std::fmt::Formatter| { write_internal!(f, $pattern) }
     };
     (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
         { display($pattern:expr, $( $exprs:tt )*) $( $tail:tt )*}
     ) => {
-        |_, f: &mut ::std::fmt::Formatter| { write!(f, $pattern, $( $exprs )*) }
+        |_, f: &mut ::std::fmt::Formatter| { write_internal!(f, $pattern, $( $exprs )*) }
     };
     (FIND_DISPLAY_IMPL $name:ident $item:ident: $imode:tt
         { $t:tt $( $tail:tt )*}
@@ -298,7 +313,7 @@ macro_rules! impl_error_chain_kind {
         { }
     ) => {
         |self_: &$name, f: &mut ::std::fmt::Formatter| {
-            write!(f, "{}", self_.description())
+            write_internal!(f, "{}", self_.description())
         }
     };
     (FIND_DESCRIPTION_IMPL $item:ident: $imode:tt $me:ident $fmt:ident
@@ -319,7 +334,7 @@ macro_rules! impl_error_chain_kind {
         [$( $var:ident ),*]
         { }
     ) => {
-        stringify!($item)
+        stringify_internal!($item)
     };
     (ITEM_BODY $(#[$imeta:meta])* $item:ident: UNIT
     ) => { };

src/lib.rs

@@ -1,5 +1,5 @@
 #![deny(missing_docs)]
-#![doc(html_root_url = "https://docs.rs/error-chain/0.12.0")]
+#![doc(html_root_url = "https://docs.rs/error-chain/0.12.1")]
 
 //! A library for consistent and reliable error handling
 //!
@@ -570,7 +570,12 @@ impl<'a> Iterator for Iter<'a> {
     fn next<'b>(&'b mut self) -> Option<&'a error::Error> {
         match self.0.take() {
             Some(e) => {
-                self.0 = e.cause();
+                self.0 = match () {
+                    #[cfg(not(has_error_source))]
+                    () => e.cause(),
+                    #[cfg(has_error_source)]
+                    () => e.source(),
+                };
                 Some(e)
             }
             None => None,
@@ -783,7 +788,7 @@ macro_rules! bail {
 /// ```
 ///
 /// See documentation for `bail!` macro for further details.
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! ensure {
     ($cond:expr, $e:expr) => {
         if !($cond) {

tests/tests.rs

@@ -292,9 +292,15 @@ mod foreign_link_test {
             "Foreign error description"
         }
 
+        #[cfg(not(has_error_source))]
         fn cause(&self) -> Option<&::std::error::Error> {
             Some(&self.cause)
         }
+
+        #[cfg(has_error_source)]
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            Some(&self.cause)
+        }
     }
 
     impl fmt::Display for ForeignError {
@@ -311,9 +317,15 @@ mod foreign_link_test {
             "Foreign error cause description"
         }
 
+        #[cfg(not(has_error_source))]
         fn cause(&self) -> Option<&::std::error::Error> {
             None
         }
+
+        #[cfg(has_error_source)]
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            None
+        }
     }
 
     impl fmt::Display for ForeignErrorCause {
@@ -342,12 +354,21 @@ mod foreign_link_test {
     }
 
     #[test]
+    #[cfg(not(has_error_source))]
     fn finds_cause() {
         let chained_error = try_foreign_error().err().unwrap();
         assert_eq!(format!("{}", ForeignErrorCause {}),
                    format!("{}", ::std::error::Error::cause(&chained_error).unwrap()));
     }
 
+    #[test]
+    #[cfg(has_error_source)]
+    fn finds_source() {
+        let chained_error = try_foreign_error().err().unwrap();
+        assert_eq!(format!("{}", ForeignErrorCause {}),
+                   format!("{}", ::std::error::Error::source(&chained_error).unwrap()));
+    }
+
     #[test]
     fn iterates() {
         let chained_error = try_foreign_error().err().unwrap();