Use Error::source not Error::cause in Rust versions that have it

Author: palfrey

Cargo.toml

@@ -21,6 +21,10 @@ travis-ci = { repository = "rust-lang-nursery/error-chain" }
 [features]
 default = ["backtrace", "example_generated"]
 example_generated = []
+has_error_source = [] # Determined by build.rs
 
 [dependencies]
 backtrace = { version = "0.3.3", optional = true }
+
+[build-dependencies]
+version_check = "0.1.5"

build.rs

@@ -0,0 +1,18 @@
+extern crate version_check;
+
+use version_check::{is_beta, is_min_date, is_min_version, is_nightly};
+
+fn main() {
+    // Switch on for versions that have Error::source
+    // As introduced by https://github.com/rust-lang/rust/pull/53533
+    if (is_beta().unwrap_or(false)
+        && is_min_version("1.33.0-beta.3")
+            .unwrap_or((false, "".to_string())).0)
+        || (is_nightly().unwrap_or(false)
+            && is_min_date("2018-09-02")
+                .unwrap_or((false, "".to_string())).0)
+        || is_min_version("1.30").unwrap_or((false, "".to_string())).0
+    {
+        println!("cargo:rustc-cfg=has_error_source");
+    }
+}

src/error_chain.rs

@@ -188,7 +188,12 @@ macro_rules! impl_error_chain_processed {
                             $(
                                 $(#[$meta_foreign_links])*
                                 $error_kind_name::$foreign_link_variant(ref foreign_err) => {
-                                    foreign_err.cause()
+                                    match () {
+                                        #[cfg(not(has_error_source))]
+                                        () => foreign_err.cause(),
+                                        #[cfg(has_error_source)]
+                                        () => foreign_err.source(),
+                                    }
                                 }
                             ) *
                             _ => None

src/lib.rs

@@ -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,

tests/tests.rs

@@ -342,21 +342,34 @@ 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!(::std::error::Error::source(&chained_error).is_none());
+    }
+
     #[test]
     fn iterates() {
         let chained_error = try_foreign_error().err().unwrap();
         let mut error_iter = chained_error.iter();
         assert!(!format!("{:?}", error_iter).is_empty());
         assert_eq!(format!("{}", ForeignError { cause: ForeignErrorCause {} }),
                    format!("{}", error_iter.next().unwrap()));
-        assert_eq!(format!("{}", ForeignErrorCause {}),
-                   format!("{}", error_iter.next().unwrap()));
+        match () {
+            #[cfg(not(has_error_source))]
+            () => assert_eq!(format!("{}", ForeignErrorCause {}),
+                             format!("{}", error_iter.next().unwrap())),
+            #[cfg(has_error_source)]
+            () => assert!(error_iter.next().is_none()),
+        };
         assert_eq!(format!("{:?}", None as Option<&::std::error::Error>),
                    format!("{:?}", error_iter.next()));
     }