Merge pull request #37 from ubolonton/replace-failure

Replace `failure` with `thiserror` and `anyhow`

Author: ubolonton

CHANGELOG.md

@@ -4,6 +4,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
+- Replaced `failure` with `anyhow` and `thiserror`. Re-export `anyhow` as `emacs::error::anyhow`.
 
 ## [0.15.1] - 2021-01-06
 - Fixed compilation errors on new versions of `syn`, which removed the `export` module.

Cargo.toml

@@ -23,8 +23,8 @@ include = [
 ]
 
 [dependencies]
-failure = { version = "0.1.5", features = ["std"] }
-failure_derive = "0.1.5"
+thiserror = "1.0"
+anyhow = "1.0"
 ctor = "0.1.12"
 once_cell = "1.2.0"
 emacs_module = { path = "emacs-module", version = "0.12.0" }

guide/src/custom-types.md

@@ -65,10 +65,10 @@ fn init(env: &Env) -> Result<()> {
     }
 
     #[defun]
-    fn process(v: Value<'_>) -> Result<Value<'_>> {
+    fn get(v: Value<'_>, key: String) -> Result<Value<'_>> {
         let lock: &RwLock<Map> = v.into_rust()?;
-        let map = lock.try_read().map_err(|_| failure::err_msg("map is busy"))?;
-        Ok(map.get(&key).into_lisp(v.env)?)
+        let map = lock.try_read().map_err(|_| Error::msg("map is busy"))?;
+        map.get(&key).into_lisp(v.env)
     }
     ```
 

guide/src/errors.md

@@ -2,10 +2,10 @@
 
 Emacs Lisp's [error handling mechanism](https://www.gnu.org/software/emacs/manual/html_node/elisp/Handling-Errors.html) uses [non-local exits](https://www.gnu.org/software/emacs/manual/html_node/elisp/Nonlocal-Exits.html). Rust uses `Result` enum. `emacs-module-rs` converts between the 2 at the Rust-Lisp boundaries (more precisely, Rust-C).
 
-The chosen error type is the `Error` struct from [`failure` crate](https://github.com/withoutboats/failure):
+The chosen error type is the `Error` struct from [`anyhow` crate](https://github.com/dtolnay/anyhow):
 
 ```rust
-pub type Result<T> = result::Result<T, failure::Error>;
+pub type Result<T> = result::Result<T, anyhow::Error>;
 ```
 
 ## Handling Lisp Errors in Rust
@@ -32,7 +32,7 @@ match env.call("insert", &[some_text]) {
 }
 ```
 
-Note the use of `unsafe` to extract the error symbol as a `Value`. The reason is that, `ErrorKind::Signal` is marked `Send+Sync`, for compatibility with `failure`, while `Value` is lifetime-bound by `env`. The `unsafe` contract here requires the error being handled (and its `TempValue`) to come from this `env`, not from another thread, or from a global/thread-local storage.
+Note the use of `unsafe` to extract the error symbol as a `Value`. The reason is that, `ErrorKind::Signal` is marked `Send+Sync`, for compatibility with `anyhow`, while `Value` is lifetime-bound by `env`. The `unsafe` contract here requires the error being handled (and its `TempValue`) to come from this `env`, not from another thread, or from a global/thread-local storage.
 
 ### Catching Values Thrown by Lisp
 

src/error.rs

@@ -1,14 +1,15 @@
 #[doc(no_inline)]
-pub use failure::Error;
-use failure_derive::Fail;
+pub use anyhow::{self, Error};
 use std::mem::MaybeUninit;
 use std::result;
 use std::thread;
 use std::any::Any;
+use thiserror::Error;
 
 use super::IntoLisp;
 use super::{Env, Value};
 use emacs_module::*;
+use crate::{symbol, GlobalRef};
 
 // We use const instead of enum, in case Emacs add more exit statuses in the future.
 // See https://github.com/rust-lang/rust/issues/36927
@@ -21,26 +22,26 @@ pub struct TempValue {
     raw: emacs_value,
 }
 
-const WRONG_TYPE_USER_PTR: &str = "rust-wrong-type-user-ptr";
-const ERROR: &str = "rust-error";
-const PANIC: &str = "rust-panic";
+pub const WRONG_TYPE_USER_PTR: &str = "rust-wrong-type-user-ptr";
+pub const ERROR: &str = "rust-error";
+pub const PANIC: &str = "rust-panic";
 
 /// Error types generic to all Rust dynamic modules.
 ///
 /// This list is intended to grow over time and it is not recommended to exhaustively match against
 /// it.
-#[derive(Debug, Fail)]
+#[derive(Debug, Error)]
 pub enum ErrorKind {
     /// An [error] signaled by Lisp code.
     ///
     /// [error]: https://www.gnu.org/software/emacs/manual/html_node/elisp/Signaling-Errors.html
-    #[fail(display = "Non-local signal: symbol={:?} data={:?}", symbol, data)]
+    #[error("Non-local signal: symbol={symbol:?} data={data:?}")]
     Signal { symbol: TempValue, data: TempValue },
 
     /// A [non-local exit] thrown by Lisp code.
     ///
     /// [non-local exit]: https://www.gnu.org/software/emacs/manual/html_node/elisp/Catch-and-Throw.html
-    #[fail(display = "Non-local throw: tag={:?} value={:?}", tag, value)]
+    #[error("Non-local throw: tag={tag:?} value={value:?}")]
     Throw { tag: TempValue, value: TempValue },
 
     /// An error indicating that the given value is not a `user-ptr` of the expected type.
@@ -71,7 +72,7 @@ pub enum ErrorKind {
     /// (unwrap (wrap 7))   ; 7
     /// (unwrap (wrap-f 7)) ; *** Eval error ***  Wrong type user-ptr: "expected: RefCell"
     /// ```
-    #[fail(display = "expected: {}", expected)]
+    #[error("expected: {expected}")]
     WrongTypeUserPtr { expected: &'static str },
 }
 
@@ -142,7 +143,7 @@ impl Env {
             Err(error) => match error.downcast_ref::<ErrorKind>() {
                 Some(err) => self.handle_known(err),
                 _ => self
-                    .signal_str(ERROR, &format!("{}", error))
+                    .signal_internal(symbol::rust_error, &format!("{}", error))
                     .unwrap_or_else(|_| panic!("Failed to signal {}", error)),
             },
         }
@@ -168,7 +169,7 @@ impl Env {
                 if let Err(error) = m {
                     m = Ok(format!("{:#?}", error));
                 }
-                self.signal_str(PANIC, &m.expect("Logic error")).expect("Fail to signal panic")
+                self.signal_internal(symbol::rust_panic, &m.expect("Logic error")).expect("Fail to signal panic")
             }
         }
     }
@@ -191,17 +192,15 @@ impl Env {
             ErrorKind::Signal { symbol, data } => self.signal(symbol.raw, data.raw),
             ErrorKind::Throw { tag, value } => self.throw(tag.raw, value.raw),
             ErrorKind::WrongTypeUserPtr { .. } => self
-                .signal_str(WRONG_TYPE_USER_PTR, &format!("{}", err))
+                .signal_internal(symbol::rust_wrong_type_user_ptr, &format!("{}", err))
                 .unwrap_or_else(|_| panic!("Failed to signal {}", err)),
         }
     }
 
-    // TODO: Prepare static values for the symbols.
-    fn signal_str(&self, symbol: &str, message: &str) -> Result<emacs_value> {
+    fn signal_internal(&self, symbol: &GlobalRef, message: &str) -> Result<emacs_value> {
         let message = message.into_lisp(&self)?;
         let data = self.list([message])?;
-        let symbol = self.intern(symbol)?;
-        unsafe { Ok(self.signal(symbol.raw, data.raw)) }
+        unsafe { Ok(self.signal(symbol.bind(self).raw, data.raw)) }
     }
 
     fn define_error(&self, name: &str, message: &str, parents: &[&str]) -> Result<Value<'_>> {

src/lib.rs

@@ -30,17 +30,14 @@
 #[doc(inline)]
 pub use emacs_macros::{defun, module};
 
-#[doc(no_inline)]
-pub use failure::{self, Error};
-
 #[doc(inline)]
 pub use self::{
     env::Env,
     value::Value,
     global::GlobalRef,
     types::{FromLisp, IntoLisp, Transfer, Vector},
     func::CallEnv,
-    error::{ErrorKind, Result, ResultExt},
+    error::{ErrorKind, Result, ResultExt, Error},
 };
 
 #[macro_use] mod macros;

src/macros.rs

@@ -74,7 +74,7 @@ macro_rules! global_refs {
     };
     ($registrator_name:ident ($init_method:ident) =>
         $(
-            $name:ident $( => $lisp_name:literal )?
+            $name:ident $( => $lisp_name:expr )?
         )*
     ) => {
         global_refs! {

src/symbol.rs

@@ -2,4 +2,7 @@
 
 global_refs! {common(init_to_symbol) =>
     nil t
+    rust_error => crate::error::ERROR
+    rust_panic => crate::error::PANIC
+    rust_wrong_type_user_ptr => crate::error::WRONG_TYPE_USER_PTR
 }