anyhow

Author: burrbull

Cargo.toml

@@ -35,13 +35,16 @@ path = "src/main.rs"
 cast = "0.2.2"
 clap = "2.26.0"
 env_logger = "~0.5"
-error-chain = "0.11.0"
 inflections = "1.1.0"
 log = { version = "~0.4", features = ["std"] }
 quote = "1.0"
 proc-macro2 = "1.0"
+anyhow = "1.0.19"
+thiserror = "1.0.5"
 
 [dependencies.svd-parser]
+git = "https://github.com/rust-embedded/svd"
+branch = "anyhow"
 version = "0.8.1"
 features = ["derive-from"]
 

src/errors.rs

@@ -4,7 +4,7 @@ use std::fs::File;
 use std::io::Write;
 use crate::svd::Device;
 
-use crate::errors::*;
+use anyhow::Result;
 use crate::util::{self, ToSanitizedUpperCase};
 use crate::Target;
 

src/generate/device.rs

@@ -5,7 +5,7 @@ use crate::svd::Peripheral;
 use cast::u64;
 use proc_macro2::{Ident, Span, TokenStream};
 
-use crate::errors::*;
+use anyhow::Result;
 use crate::util::{self, ToSanitizedUpperCase};
 use crate::Target;
 

src/generate/interrupt.rs

@@ -10,7 +10,7 @@ use proc_macro2::{Ident, Span, Punct, Spacing};
 use log::warn;
 use syn::{parse_str, Token};
 
-use crate::errors::*;
+use anyhow::{Context, Result, anyhow, bail};
 use crate::util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase, BITS_PER_BYTE};
 
 use crate::generate::register;
@@ -600,7 +600,7 @@ fn expand_cluster(cluster: &Cluster, defs: &RegisterProperties) -> Result<Vec<Re
     let defs = cluster.default_register_properties.derive_from(defs);
 
     let cluster_size = cluster_size_in_bits(cluster, &defs)
-        .chain_err(|| format!("Cluster {} has no determinable `size` field", cluster.name))?;
+        .context(format!("Cluster {} has no determinable `size` field", cluster.name))?;
 
     match cluster {
         Cluster::Single(info) => cluster_expanded.push(RegisterBlockField {
@@ -657,7 +657,7 @@ fn expand_register(
     let register_size = register
         .size
         .or(defs.size)
-        .ok_or_else(|| format!("Register {} has no `size` field", register.name))?;
+        .ok_or_else(|| anyhow!("Register {} has no `size` field", register.name))?;
 
     match register {
         Register::Single(info) => register_expanded.push(RegisterBlockField {

src/generate/peripheral.rs

@@ -6,7 +6,7 @@ use cast::u64;
 use log::warn;
 use proc_macro2::{TokenStream, Ident, Span, Punct, Spacing};
 
-use crate::errors::*;
+use anyhow::{Result, anyhow};
 use crate::util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase, U32Ext};
 
 pub fn render(
@@ -25,7 +25,7 @@ pub fn render(
     let rsize = register
         .size
         .or(defs.size)
-        .ok_or_else(|| format!("Register {} has no `size` field", register.name))?;
+        .ok_or_else(|| anyhow!("Register {} has no `size` field", register.name))?;
     let rsize = if rsize < 8 {
         8
     } else if rsize.is_power_of_two() {
@@ -616,7 +616,7 @@ impl Variant {
             .filter(|field| field.name.to_lowercase() != "reserved")
             .map(|ev| {
                 let value = u64(ev.value.ok_or_else(|| {
-                    format!("EnumeratedValue {} has no `<value>` field", ev.name)
+                    anyhow!("EnumeratedValue {} has no `<value>` field", ev.name)
                 })?);
 
                 Ok(Variant {
@@ -820,7 +820,7 @@ fn lookup_in_fields<'f>(
     if let Some(base_field) = fields.iter().find(|f| f.name == base_field) {
         return lookup_in_field(base_evs, None, None, base_field);
     } else {
-        Err(format!(
+        Err(anyhow!(
             "Field {} not found in register {}",
             base_field, register.name
         ))?
@@ -846,13 +846,13 @@ fn lookup_in_peripheral<'p>(
         {
             lookup_in_field(base_evs, Some(base_register), base_peripheral, field)
         } else {
-            Err(format!(
+            Err(anyhow!(
                 "No field {} in register {}",
                 base_field, register.name
             ))?
         }
     } else {
-        Err(format!(
+        Err(anyhow!(
             "No register {} in peripheral {}",
             base_register, peripheral.name
         ))?
@@ -878,7 +878,7 @@ fn lookup_in_field<'f>(
         }
     }
 
-    Err(format!(
+    Err(anyhow!(
         "No EnumeratedValues {} in field {}",
         base_evs, field.name
     ))?
@@ -901,7 +901,7 @@ fn lookup_in_register<'r>(
     }
 
     match matches.first() {
-        None => Err(format!(
+        None => Err(anyhow!(
             "EnumeratedValues {} not found in register {}",
             base_evs, register.name
         ))?,
@@ -917,7 +917,7 @@ fn lookup_in_register<'r>(
                 ))
             } else {
                 let fields = matches.iter().map(|(f, _)| &f.name).collect::<Vec<_>>();
-                Err(format!(
+                Err(anyhow!(
                     "Fields {:?} have an \
                      enumeratedValues named {}",
                     fields, base_evs
@@ -945,7 +945,7 @@ fn lookup_in_peripherals<'p>(
             peripheral,
         )
     } else {
-        Err(format!("No peripheral {}", base_peripheral))?
+        Err(anyhow!("No peripheral {}", base_peripheral))?
     }
 }
 

src/generate/register.rs

@@ -433,13 +433,10 @@
 //! compiler. Currently there are no nightly features the flag is only kept for compatibility with prior versions.
 #![recursion_limit = "128"]
 
-#[macro_use]
-extern crate error_chain;
 #[macro_use]
 extern crate quote;
 use svd_parser as svd;
 
-mod errors;
 mod generate;
 mod util;
 
@@ -461,18 +458,20 @@ pub struct DeviceSpecific {
     _extensible: (),
 }
 
-type Result<T> = std::result::Result<T, SvdError>;
-#[derive(Debug)]
+use anyhow::Result;
+#[derive(Debug, thiserror::Error)]
 pub enum SvdError {
+    #[error("Cannot format crate")]
     Fmt,
+    #[error("Cannot render SVD device")]
     Render,
 }
 
 /// Generates rust code for the specified svd content.
 pub fn generate(xml: &str, target: Target, nightly: bool) -> Result<Generation> {
     use std::fmt::Write;
 
-    let device = svd::parse(xml).unwrap(); //TODO(AJM)
+    let device = svd::parse(xml)?;
     let mut device_x = String::new();
     let items = generate::device::render(&device, target, nightly, false, &mut device_x)
         .or(Err(SvdError::Render))?;

src/lib.rs

@@ -1,24 +1,21 @@
 #![recursion_limit = "128"]
 
-#[macro_use]
-extern crate error_chain;
 #[macro_use]
 extern crate log;
 #[macro_use]
 extern crate quote;
 use svd_parser as svd;
 
-mod errors;
 mod generate;
 mod util;
 
 use std::fs::File;
 use std::io::Write;
 use std::process;
 
+use anyhow::{Context, Result};
 use clap::{App, Arg};
 
-use crate::errors::*;
 use crate::util::{build_rs, Target};
 
 fn run() -> Result<()> {
@@ -79,20 +76,20 @@ fn run() -> Result<()> {
     match matches.value_of("input") {
         Some(file) => {
             File::open(file)
-                .chain_err(|| "couldn't open the SVD file")?
+                .context("couldn't open the SVD file")?
                 .read_to_string(xml)
-                .chain_err(|| "couldn't read the SVD file")?;
+                .context("couldn't read the SVD file")?;
         }
         None => {
             let stdin = std::io::stdin();
             stdin
                 .lock()
                 .read_to_string(xml)
-                .chain_err(|| "couldn't read from stdin")?;
+                .context("couldn't read from stdin")?;
         }
     }
 
-    let device = svd::parse(xml).unwrap(); //TODO(AJM)
+    let device = svd::parse(xml)?;
 
     let nightly = matches.is_present("nightly_features");
 
@@ -144,15 +141,11 @@ fn main() {
     if let Err(ref e) = run() {
         error!("{}", e);
 
-        for e in e.iter().skip(1) {
+        for e in e.chain().skip(1) {
             error!("caused by: {}", e);
         }
 
-        if let Some(backtrace) = e.backtrace() {
-            error!("backtrace: {:?}", backtrace);
-        } else {
-            error!("note: run with `RUST_BACKTRACE=1` for a backtrace")
-        }
+        error!("backtrace: {:?}", e.backtrace());
 
         process::exit(1);
     }

src/main.rs

@@ -5,7 +5,7 @@ use crate::svd::{Access, Cluster, Register, RegisterCluster};
 use proc_macro2::{TokenStream, Ident, Span, Literal};
 use crate::quote::{TokenStreamExt, ToTokens};
 
-use crate::errors::*;
+use anyhow::{Result, anyhow, bail};
 
 pub const BITS_PER_BYTE: u32 = 8;
 
@@ -266,7 +266,7 @@ impl U32Ext for u32 {
             9..=16 => Ident::new("u16", span),
             17..=32 => Ident::new("u32", span),
             33..=64 => Ident::new("u64", span),
-            _ => Err(format!(
+            _ => Err(anyhow!(
                 "can't convert {} bits into a Rust integral type",
                 *self
             ))?,
@@ -280,7 +280,7 @@ impl U32Ext for u32 {
             9..=16 => 16,
             17..=32 => 32,
             33..=64 => 64,
-            _ => Err(format!(
+            _ => Err(anyhow!(
                 "can't convert {} bits into a Rust integral type width",
                 *self
             ))?,