From 3e622128e80d0cd6900e9612150c8545ca6771b5 Mon Sep 17 00:00:00 2001 From: Gavrilikhin Daniil Date: Fri, 12 May 2023 21:28:52 +0800 Subject: [PATCH] Fix macro --- src/eyreish/macros.rs | 61 +++++++++++++++++------------------------- src/lib.rs | 4 +-- tests/test_chain.rs | 2 +- tests/test_downcast.rs | 38 +++++++++++++++++++++----- 4 files changed, 59 insertions(+), 46 deletions(-) diff --git a/src/eyreish/macros.rs b/src/eyreish/macros.rs index 039e4dd..d3abcf2 100644 --- a/src/eyreish/macros.rs +++ b/src/eyreish/macros.rs @@ -55,7 +55,7 @@ /// fn divide(x: f64, y: f64) -> Result { /// if y.abs() < 1e-3 { /// bail!( -/// severity = Severity::Warning; +/// severity = Severity::Warning, /// "dividing by value ({y}) close to 0" /// ); /// } @@ -64,16 +64,13 @@ /// ``` #[macro_export] macro_rules! bail { - ($err:expr $(,)?) => { - return $crate::private::Err($crate::miette!($err)); - }; - ($($key:ident = $value:expr),+; $($fmt:tt)+) => { + ($($key:ident = $value:expr,)* $fmt:literal $($arg:tt)*) => { return $crate::private::Err( - $crate::miette!($($key = $value),+; $($fmt)+) + $crate::miette!($($key = $value,)* $fmt $($arg)*) ); }; - ($($fmt:tt)+) => { - return $crate::private::Err($crate::miette!($($fmt)+)); + ($err:expr $(,)?) => { + return $crate::private::Err($crate::miette!($err)); }; } @@ -128,7 +125,7 @@ macro_rules! bail { /// fn divide(x: f64, y: f64) -> Result { /// ensure!( /// y.abs() >= 1e-3, -/// severity = Severity::Warning; +/// severity = Severity::Warning, /// "dividing by value ({y}) close to 0" /// ); /// Ok(x / y) @@ -136,21 +133,16 @@ macro_rules! bail { /// ``` #[macro_export] macro_rules! ensure { - ($cond:expr, $err:expr $(,)?) => { - if !$cond { - return $crate::private::Err($crate::miette!($err)); - } - }; - ($cond:expr, $($key:ident = $value:expr),+; $($fmt:tt)+) => { + ($cond:expr, $($key:ident = $value:expr,)* $fmt:literal $($arg:tt)*) => { if !$cond { return $crate::private::Err( - $crate::miette!($($key = $value),+; $($fmt)+) + $crate::miette!($($key = $value,)* $fmt $($arg)*) ); } }; - ($cond:expr, $fmt:expr, $($arg:tt)*) => { + ($cond:expr, $err:expr $(,)?) => { if !$cond { - return $crate::private::Err($crate::miette!($fmt, $($arg)*)); + return $crate::private::Err($crate::miette!($err)); } }; } @@ -167,7 +159,8 @@ macro_rules! ensure { /// let report = miette!("{x} + {} = {z}", y, z = x + y); /// assert_eq!(report.to_string().as_str(), "1 + 2 = 3"); /// -/// let report = miette!("{x} + {y} = {x + y}"); +/// let z = x + y; +/// let report = miette!("{x} + {y} = {z}"); /// assert_eq!(report.to_string().as_str(), "1 + 2 = 3"); /// ``` /// @@ -182,8 +175,7 @@ macro_rules! ensure { /// code = "expected::rparen", /// help = "always close your parens", /// labels = vec![LabeledSpan::at_offset(6, "here")], -/// url = "https://example.com"; // <- semicolon separates fields from message -/// +/// url = "https://example.com", /// // Rest of the arguments are passed to `format!` /// // to form diagnostic message /// "expected closing ')'" @@ -196,19 +188,16 @@ macro_rules! ensure { /// You can just replace `use`s of the `anyhow!`/`eyre!` macros with `miette!`. #[macro_export] macro_rules! miette { + ($($key:ident = $value:expr,)* $fmt:literal $($arg:tt)*) => { + $crate::Report::from( + $crate::diagnostic!($($key = $value,)* $fmt $($arg)*) + ) + }; ($err:expr $(,)?) => ({ use $crate::private::kind::*; let error = $err; (&error).miette_kind().new(error) }); - ($($key:ident = $value:expr),+; $($fmt:tt)+) => { - $crate::Report::from( - $crate::diagnostic!($($key = $value),+; $($fmt)+) - ) - }; - ($($fmt:tt)+) => { - $crate::private::new_adhoc(format!($($fmt)+)) - }; } /// Construct a [`MietteDiagnostic`] in more user-friendly way. @@ -224,8 +213,7 @@ macro_rules! miette { /// code = "expected::rparen", /// help = "always close your parens", /// labels = vec![LabeledSpan::at_offset(6, "here")], -/// url = "https://example.com"; // <- semicolon separates fields from message -/// +/// url = "https://example.com", /// // Rest of the arguments are passed to `format!` /// // to form diagnostic message /// "expected closing ')'", @@ -239,15 +227,16 @@ macro_rules! miette { /// /// let diag = diagnostic!("{x} + {} = {z}", y, z = x + y); /// assert_eq!(diag.message, "1 + 2 = 3"); +/// +/// let z = x + y; +/// let diag = diagnostic!("{x} + {y} = {z}"); +/// assert_eq!(diag.message, "1 + 2 = 3"); /// ``` #[macro_export] macro_rules! diagnostic { - ($($key:ident = $value:expr),+; $($fmt:tt)+) => {{ - let mut diag = $crate::MietteDiagnostic::new(format!($($fmt)+)); + ($($key:ident = $value:expr,)* $fmt:literal $($arg:tt)*) => {{ + let mut diag = $crate::MietteDiagnostic::new(format!($fmt $($arg)*)); $(diag.$key = Some($value.into());)* diag }}; - ($($fmt:tt)+) => {{ - $crate::MietteDiagnostic::new(format!($($fmt)+)) - }}; } diff --git a/src/lib.rs b/src/lib.rs index 0c64321..d1fb3ea 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -604,11 +604,11 @@ //! //! let source = "2 + 2 * 2 = 8".to_string(); //! let report = miette!( -//! "Wrong answer", //! labels = vec[ //! LabeledSpan::at(12..13, "this should be 6"), //! ], -//! help = "'*' has greater precedence than '+'" +//! help = "'*' has greater precedence than '+'", +//! "Wrong answer" //! ).with_source_code(source); //! println!("{:?}", report) //! ``` diff --git a/tests/test_chain.rs b/tests/test_chain.rs index 3fdd4cd..29d3927 100644 --- a/tests/test_chain.rs +++ b/tests/test_chain.rs @@ -1,7 +1,7 @@ use miette::{miette, Report}; fn error() -> Report { - miette!(0).wrap_err(1).wrap_err(2).wrap_err(3) + miette!("0").wrap_err(1).wrap_err(2).wrap_err(3) } #[test] diff --git a/tests/test_downcast.rs b/tests/test_downcast.rs index 2823177..cf5ab2e 100644 --- a/tests/test_downcast.rs +++ b/tests/test_downcast.rs @@ -3,7 +3,7 @@ mod drop; use self::common::*; use self::drop::{DetectDrop, Flag}; -use miette::{Diagnostic, Report}; +use miette::{Diagnostic, MietteDiagnostic, Report}; use std::error::Error as StdError; use std::fmt::{self, Display}; use std::io; @@ -12,11 +12,19 @@ use std::io; fn test_downcast() { assert_eq!( "oh no!", - bail_literal().unwrap_err().downcast::<&str>().unwrap(), + bail_literal() + .unwrap_err() + .downcast::() + .unwrap() + .message, ); assert_eq!( "oh no!", - bail_fmt().unwrap_err().downcast::().unwrap(), + bail_fmt() + .unwrap_err() + .downcast::() + .unwrap() + .message, ); assert_eq!( "oh no!", @@ -32,11 +40,19 @@ fn test_downcast() { fn test_downcast_ref() { assert_eq!( "oh no!", - *bail_literal().unwrap_err().downcast_ref::<&str>().unwrap(), + bail_literal() + .unwrap_err() + .downcast_ref::() + .unwrap() + .message, ); assert_eq!( "oh no!", - bail_fmt().unwrap_err().downcast_ref::().unwrap(), + bail_fmt() + .unwrap_err() + .downcast_ref::() + .unwrap() + .message, ); assert_eq!( "oh no!", @@ -52,11 +68,19 @@ fn test_downcast_ref() { fn test_downcast_mut() { assert_eq!( "oh no!", - *bail_literal().unwrap_err().downcast_mut::<&str>().unwrap(), + bail_literal() + .unwrap_err() + .downcast_mut::() + .unwrap() + .message, ); assert_eq!( "oh no!", - bail_fmt().unwrap_err().downcast_mut::().unwrap(), + bail_fmt() + .unwrap_err() + .downcast_mut::() + .unwrap() + .message, ); assert_eq!( "oh no!",