[WIP] Core support

Yamakaky · Yamakaky · commit f83806d58978 · 2016-11-19T11:53:44.000-05:00
Fixes #37.
diff --git a/Cargo.toml b/Cargo.toml
@@ -14,7 +14,8 @@ repository = "https://github.com/brson/error-chain"
 license = "MIT OR Apache-2.0"
 
 [features]
-default = ["backtrace"]
+default = ["backtrace", "alloc"]
+alloc = []
 
 [dependencies]
 backtrace = {version = "0.2.1", optional = true}
diff --git a/examples/size.rs b/examples/size.rs
@@ -30,7 +30,7 @@ fn main() {
         println!("      State.next_error: {}", size_of_val(&state.next_error));
         println!("      State.backtrace: {}", size_of_val(&state.backtrace));
     }
-    #[cfg(not(feature = "backtrace"))]
+    #[cfg(all(not(feature = "backtrace"), feature = "alloc"))]
     {
         let state = error_chain::State {
             next_error: None,
diff --git a/src/error_chain.rs b/src/error_chain.rs
@@ -26,7 +26,7 @@ macro_rules! error_chain_processed {
             $( $rest )*
         }
         /// Convenient wrapper around `std::Result`.
-        pub type $result_name<T> = ::std::result::Result<T, $error_name>;
+        pub type $result_name<T> = $crate::std::result::Result<T, $error_name>;
     };
     (
         types {
@@ -81,26 +81,16 @@ macro_rules! error_chain_processed {
             }
         }
 
-        impl ::std::error::Error for $error_name {
+        impl $crate::Error for $error_name {
             fn description(&self) -> &str {
                 self.kind.description()
             }
 
-            fn cause(&self) -> Option<&::std::error::Error> {
-                match self.state.next_error {
-                    Some(ref c) => Some(&**c),
-                    None => {
-                        match self.kind {
-                            $(
-                                $(#[$meta_foreign_links])*
-                                $error_kind_name::$foreign_link_variant(ref foreign_err) => {
-                                    foreign_err.cause()
-                                }
-                            ) *
-                            _ => None
-                        }
-                    }
-                }
+            impl_cause! {
+                $error_kind_name
+                $( $foreign_link_error_path,
+                   $foreign_link_variant
+                   $(, #[$meta_foreign_links])*; )*
             }
         }
 
@@ -168,11 +158,7 @@ macro_rules! error_chain_processed {
             #[derive(Debug)]
             pub enum $error_kind_name {
 
-                /// A convenient variant for String.
-                Msg(s: String) {
-                    description(&s)
-                    display("{}", s)
-                }
+                variant_string! {}
 
                 $(
                     $(#[$meta_links])*
@@ -185,7 +171,7 @@ macro_rules! error_chain_processed {
                 $(
                     $(#[$meta_foreign_links])*
                     $foreign_link_variant(err: $foreign_link_error_path) {
-                        description(::std::error::Error::description(err))
+                        description($crate::Error::description(err))
                         display("{}", err)
                     }
                 ) *
@@ -360,3 +346,76 @@ macro_rules! impl_error {
         }
     }
 }
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(feature = "alloc")]
+macro_rules! impl_cause {
+    (
+        $error_kind_name: ident
+        $( $foreign_link_error_path:path,
+           $foreign_link_variant:ident
+           $(, #[$meta_foreign_links:meta])*; )*
+    ) => {
+        fn cause(&self) -> Option<&$crate::Error> {
+            match self.state.next_error {
+                Some(ref c) => Some(&**c),
+                None => {
+                    match self.kind {
+                        $(
+                            $(#[$meta_foreign_links])*
+                            $error_kind_name::$foreign_link_variant(ref foreign_err) => {
+                                foreign_err.cause()
+                            }
+                         ) *
+                            _ => None
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(not(feature = "alloc"))]
+macro_rules! impl_cause {
+    (
+        $error_kind_name: ident
+        $( $foreign_link_error_path:path,
+           $foreign_link_variant:ident
+           $(, #[$meta_foreign_links:meta])*; )*
+    ) => {
+        fn cause(&self) -> Option<&$crate::Error> {
+            match self.kind {
+                $(
+                    $(#[$meta_foreign_links])*
+                    $error_kind_name::$foreign_link_variant(ref foreign_err) => {
+                        foreign_err.cause()
+                    }
+                 ) *
+                    _ => None
+            }
+        }
+    }
+}
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(feature = "alloc")]
+macro_rules! variant_string {
+    () => {
+        /// A convenient variant for String.
+        Msg(s: String) {
+            description(&s)
+                display("{}", s)
+        }
+    }
+}
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(not(feature = "alloc"))]
+macro_rules! variant_string {
+    () => {}
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,4 +1,5 @@
 #![warn(missing_docs)]
+#![cfg_attr(not(feature = "alloc"), no_std)]
 
 //! A library for consistent and reliable error handling
 //!
@@ -28,12 +29,12 @@
 //! * Instead of defining the custom `Error` type as an enum, it is a
 //!   struct containing an `ErrorKind` (which defines the
 //!   `description` and `display` methods for the error), an opaque,
-//!   optional, boxed `std::error::Error + Send + 'static` object
+//!   optional, boxed `self::std::error::Error + Send + 'static` object
 //!   (which defines the `cause`, and establishes the links in the
 //!   error chain), and a `Backtrace`.
 //! * This crate additionally defines the  trait `ResultExt`
 //!   that defines a `chain_err` method. This method
-//!   on all `std::error::Error + Send + 'static` types extends
+//!   on all `self::std::error::Error + Send + 'static` types extends
 //!   the error chain by boxing the current error into an opaque
 //!   object and putting it inside a new concrete error.
 //! * It provides automatic `From` conversions between other error types
@@ -53,7 +54,7 @@
 //!   errors, requiring an `Into` or `From` conversion; as well as
 //!   slightly more cumbersome to match on errors with another layer
 //!   of types to match.
-//! * Because the error type contains `std::error::Error + Send + 'static` objects,
+//! * Because the error type contains `self::std::error::Error + Send + 'static` objects,
 //!   it can't implement `PartialEq` for easy comparisons.
 //!
 //! ## Quick start
@@ -182,8 +183,8 @@
 //! following:
 //!
 //! ```ignore
-//! use std::error::Error as StdError;
-//! use std::sync::Arc;
+//! use self::std::error::Error as StdError;
+//! use self::std::sync::Arc;
 //!
 //! #[derive(Debug)]
 //! pub struct Error(pub ErrorKind,
@@ -248,7 +249,7 @@
 //!
 //! Note that the return type is the typedef `Result`, which is
 //! defined by the macro as `pub type Result<T> =
-//! ::std::result::Result<T, Error>`. Note that in both cases
+//! ::self::std::result::Result<T, Error>`. Note that in both cases
 //! `.into()` is called to convert a type into the `Error` type; both
 //! strings and `ErrorKind` have `From` conversions to turn them into
 //! `Error`.
@@ -278,7 +279,7 @@
 //! ```
 //!
 //! `chain_err` can be called on any `Result` type where the contained
-//! error type implements `std::error::Error + Send + 'static`.  If
+//! error type implements `self::std::error::Error + Send + 'static`.  If
 //! the `Result` is an `Err` then `chain_err` evaluates the closure,
 //! which returns *some type that can be converted to `ErrorKind`*,
 //! boxes the original error to store as the cause, then returns a new
@@ -324,10 +325,14 @@
 #[cfg(feature = "backtrace")]
 extern crate backtrace;
 
-use std::error;
-use std::iter::Iterator;
+#[cfg(feature = "alloc")]
+pub use std;
+#[cfg(not(feature = "alloc"))]
+pub extern crate core as std;
+
+use self::std::iter::Iterator;
 #[cfg(feature = "backtrace")]
-use std::sync::Arc;
+use self::std::sync::Arc;
 
 #[cfg(feature = "backtrace")]
 pub use backtrace::Backtrace;
@@ -336,12 +341,12 @@ mod quick_error;
 mod error_chain;
 
 /// Iterator over the error chain.
-pub struct ErrorChainIter<'a>(pub Option<&'a error::Error>);
+pub struct ErrorChainIter<'a>(pub Option<&'a Error>);
 
 impl<'a> Iterator for ErrorChainIter<'a> {
-    type Item = &'a error::Error;
+    type Item = &'a Error;
 
-    fn next<'b>(&'b mut self) -> Option<&'a error::Error> {
+    fn next<'b>(&'b mut self) -> Option<&'a Error> {
         match self.0.take() {
             Some(e) => {
                 self.0 = e.cause();
@@ -358,65 +363,81 @@ impl<'a> Iterator for ErrorChainIter<'a> {
 #[cfg(feature = "backtrace")]
 #[doc(hidden)]
 pub fn make_backtrace() -> Option<Arc<Backtrace>> {
-    match std::env::var_os("RUST_BACKTRACE") {
+    match self::std::env::var_os("RUST_BACKTRACE") {
         Some(ref val) if val != "0" => Some(Arc::new(Backtrace::new())),
         _ => None
     }
 }
 
 /// This trait is implemented on all the errors generated by the `error_chain`
 /// macro.
-pub trait ChainedError: error::Error + Send + 'static {
+pub trait ChainedError: Error + Send + 'static {
     /// Associated kind type.
     type ErrorKind;
     /// Creates an error from it's parts.
     fn new(kind: Self::ErrorKind, state: State) -> Self;
     /// Returns the first known backtrace, either from it's State or from one
     /// of the errors from `foreign_links`.
     #[cfg(feature = "backtrace")]
-    fn extract_backtrace(e: &(error::Error + Send + 'static))
+    fn extract_backtrace(e: &(Error + Send + 'static))
         -> Option<Option<Arc<Backtrace>>>;
 }
 
-/// Additionnal methods for `Result`, for easy interaction with this crate.
-pub trait ResultExt<T, E: ChainedError> {
-    /// If the `Result` is an `Err` then `chain_err` evaluates the closure,
-    /// which returns *some type that can be converted to `ErrorKind`*, boxes
-    /// the original error to store as the cause, then returns a new error
-    /// containing the original error.
-    fn chain_err<F, EK>(self, callback: F) -> Result<T, E>
-        where F: FnOnce() -> EK,
-        EK: Into<E::ErrorKind>;
-}
+pub use alloc::*;
+
+#[cfg(feature = "alloc")]
+mod alloc {
+    pub use std::error::Error;
 
-impl<T, E> ResultExt<T, E> for Result<T, E> where E: ChainedError {
-    fn chain_err<F, EK>(self, callback: F) -> Result<T, E>
-        where F: FnOnce() -> EK,
-        EK: Into<E::ErrorKind> {
-        self.map_err(move |e| {
-            #[cfg(feature = "backtrace")]
-            let error = {
-                let backtrace = E::extract_backtrace(&e)
-                                  .unwrap_or_else(make_backtrace);
-                E::new(callback().into(), State {
-                    next_error: Some(Box::new(e)),
-                    backtrace: backtrace,
+    /// Additionnal methods for `Result`, for easy interaction with this crate.
+    pub trait ResultExt<T, E: ChainedError> {
+        /// If the `Result` is an `Err` then `chain_err` evaluates the closure,
+        /// which returns *some type that can be converted to `ErrorKind`*, boxes
+        /// the original error to store as the cause, then returns a new error
+        /// containing the original error.
+        fn chain_err<F, EK>(self, callback: F) -> Result<T, E>
+            where F: FnOnce() -> EK,
+            EK: Into<E::ErrorKind>;
+    }
+
+    impl<T, E> ResultExt<T, E> for Result<T, E> where E: ChainedError {
+        fn chain_err<F, EK>(self, callback: F) -> Result<T, E>
+            where F: FnOnce() -> EK,
+            EK: Into<E::ErrorKind> {
+                self.map_err(move |e| {
+                    #[cfg(feature = "backtrace")]
+                    let error = {
+                        let backtrace = E::extract_backtrace(&e)
+                            .unwrap_or_else(make_backtrace);
+                        E::new(callback().into(), State {
+                            next_error: Some(Box::new(e)),
+                            backtrace: backtrace,
+                        })
+                    };
+                    #[cfg(not(feature = "backtrace"))]
+                    let error = E::new(callback().into(), State {
+                        next_error: Some(Box::new(e)),
+                    });
+                    error
                 })
-            };
-            #[cfg(not(feature = "backtrace"))]
-            let error = E::new(callback().into(), State {
-                next_error: Some(Box::new(e)),
-            });
-            error
-        })
+            }
     }
 }
 
+#[cfg(not(feature = "alloc"))]
+mod alloc {
+    pub trait Error {
+        fn description(&self) -> &str;
+
+        fn cause(&self) -> Option<&Error> { None }
+    }
+}
 
 /// Common state between errors.
 #[derive(Debug)]
 pub struct State {
     /// Next error in the error chain.
+    #[cfg(feature = "alloc")]
     pub next_error: Option<Box<error::Error + Send>>,
     /// Backtrace for the current error.
     #[cfg(feature = "backtrace")]
@@ -430,10 +451,13 @@ impl Default for State {
             next_error: None,
             backtrace: make_backtrace(),
         };
-        #[cfg(not(feature = "backtrace"))]
+        #[cfg(all(not(feature = "backtrace"), feature = "alloc"))]
         let state = State {
             next_error: None,
         };
+        #[cfg(not(feature = "alloc"))]
+        let state = State {
+        };
         state
     }
 }
diff --git a/tests/tests.rs b/tests/tests.rs

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ fn main() {`
`30`	`30`	`println!(" State.next_error: {}", size_of_val(&state.next_error));`
`31`	`31`	`println!(" State.backtrace: {}", size_of_val(&state.backtrace));`
`32`	`32`	`}`
`33`		`- #[cfg(not(feature = "backtrace"))]`
	`33`	`+ #[cfg(all(not(feature = "backtrace"), feature = "alloc"))]`
`34`	`34`	`{`
`35`	`35`	`let state = error_chain::State {`
`36`	`36`	`next_error: None,`