| // Part of the Crubit project, under the Apache License v2.0 with LLVM |
| // Exceptions. See /LICENSE for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| |
| use regex::Regex; |
| use std::borrow::Cow; |
| use std::cell::RefCell; |
| use std::collections::BTreeMap; |
| use std::fmt::{self, Arguments, Display, Formatter}; |
| use std::rc::Rc; |
| |
| use serde::Serialize; |
| |
| #[doc(hidden)] |
| pub mod macro_internal { |
| pub use anyhow; |
| pub use arc_anyhow; |
| pub use std::format_args; |
| } |
| |
| fn to_string_with_cause(error: &arc_anyhow::Error) -> String { |
| format!("{:#}", error) |
| } |
| |
| fn errors_to_string(errors: &[arc_anyhow::Error]) -> String { |
| errors.iter().map(to_string_with_cause).collect::<Vec<_>>().join("\n") |
| } |
| |
| /// A list of errors that, when converted to an `anyhow::Error`, can still be |
| /// individually reported when used with `ErrorReport`. |
| #[derive(Debug, Clone)] |
| pub struct ErrorList { |
| errors: Vec<arc_anyhow::Error>, |
| } |
| |
| impl From<Vec<arc_anyhow::Error>> for ErrorList { |
| fn from(errors: Vec<arc_anyhow::Error>) -> Self { |
| Self { errors } |
| } |
| } |
| |
| impl Display for ErrorList { |
| fn fmt(&self, f: &mut Formatter) -> fmt::Result { |
| f.write_str(&errors_to_string(&self.errors)) |
| } |
| } |
| |
| impl std::error::Error for ErrorList {} |
| |
| /// An error that stores its format string as well as the formatted message. |
| #[derive(Debug, Clone)] |
| pub struct FormattedError { |
| pub fmt: Cow<'static, str>, |
| pub message: Cow<'static, str>, |
| } |
| |
| impl FormattedError { |
| pub fn new_static(fmt: &'static str, args: Arguments) -> arc_anyhow::Error { |
| arc_anyhow::Error::from(anyhow::Error::from(match args.as_str() { |
| // This format string has no parameters to format at runtime. |
| // Note: The compiler can perform optimizations to return `Some`, when even when |
| // `fmt` contains placeholders, so we store `fmt` instead of `s` for `fmt` field. |
| Some(s) => Self { fmt: Cow::Borrowed(fmt), message: Cow::Borrowed(s) }, |
| // This format string has parameters and must be formatted. |
| None => Self { fmt: Cow::Borrowed(fmt), message: Cow::Owned(fmt::format(args)) }, |
| })) |
| } |
| |
| pub fn new_dynamic(err: impl Display) -> arc_anyhow::Error { |
| // Use the whole error as the format string. This is preferable to |
| // grouping all dynamic errors under the "{}" format string. |
| let message = format!("{}", err); |
| arc_anyhow::Error::from(anyhow::Error::from(Self { |
| fmt: Cow::Owned(message.clone()), |
| message: Cow::Owned(message), |
| })) |
| } |
| } |
| |
| impl Display for FormattedError { |
| fn fmt(&self, f: &mut Formatter) -> fmt::Result { |
| write!(f, "{}", self.message) |
| } |
| } |
| |
| impl std::error::Error for FormattedError {} |
| |
| /// Evaluates to an [`arc_anyhow::Error`]. |
| /// |
| /// Otherwise similar to [`anyhow::anyhow`]. |
| #[macro_export] |
| macro_rules! anyhow { |
| ($fmt:literal $(,)?) => { |
| $crate::FormattedError::new_static( |
| #[allow(clippy::literal_string_with_formatting_args)] $fmt, |
| $crate::macro_internal::format_args!($fmt), |
| ) |
| }; |
| ($err:expr $(,)?) => { |
| $crate::FormattedError::new_dynamic($err) |
| }; |
| ($fmt:expr, $($arg:tt)*) => { |
| $crate::FormattedError::new_static( |
| #[allow(clippy::literal_string_with_formatting_args)] $fmt, |
| $crate::macro_internal::format_args!($fmt, $($arg)*), |
| ) |
| }; |
| } |
| |
| /// Returns a [`Result::Err`] containing an [`arc_anyhow::Error`]. |
| /// |
| /// Otherwise similar to [`anyhow::bail`]. |
| #[macro_export] |
| macro_rules! bail { |
| ($fmt:literal $(,)?) => { |
| return Err($crate::anyhow!($fmt)) |
| }; |
| ($err:expr $(,)?) => { |
| return Err($crate::anyhow!($err)) |
| }; |
| ($fmt:expr, $($arg:tt)*) => { |
| return Err($crate::anyhow!($fmt, $($arg)*)) |
| }; |
| } |
| |
| /// Returns a [`Result::Err`] containing an [`arc_anyhow::Error`] if the given |
| /// condition evaluates to false. |
| /// |
| /// Otherwise similar to [`anyhow::ensure`]. |
| #[macro_export] |
| macro_rules! ensure { |
| ($cond:expr, $fmt:literal $(,)?) => { |
| if !$cond { $crate::bail!($fmt); } |
| }; |
| ($cond:expr, $err:expr $(,)?) => { |
| if !$cond { $crate::bail!($err); } |
| }; |
| ($cond:expr, $fmt:expr, $($arg:tt)*) => { |
| if !$cond { $crate::bail!($fmt, $($arg)*); } |
| }; |
| } |
| |
| /// An interface by which errors can be recorded to generate a structured |
| /// report. |
| pub trait ErrorReporting { |
| fn report(&self, error: &arc_anyhow::Error); |
| } |
| |
| pub struct IgnoreErrors; |
| |
| impl ErrorReporting for IgnoreErrors { |
| fn report(&self, _: &arc_anyhow::Error) {} |
| } |
| |
| fn hide_unstable_details(input: &str) -> String { |
| // Remove line:column in def id |
| let regex = Regex::new(r"DefId\(\d+:\d+ ~ ").unwrap(); |
| let res = regex.replace_all(input, "DefId(").to_string(); |
| |
| // Remove all hash id in the def id |
| let regex = Regex::new(r"\[[0-9a-fA-F]{4}\]").unwrap(); |
| regex.replace_all(res.as_str(), "").to_string() |
| } |
| |
| /// An aggregate of zero or more errors. |
| #[derive(Default, Debug)] |
| pub struct ErrorReport { |
| // The interior mutability / borrow_mut will never panic: it is never borrowed for longer than |
| // a method call, and the methods do not call each other. |
| map: RefCell<BTreeMap<Cow<'static, str>, ErrorReportEntry>>, |
| } |
| |
| impl ErrorReport { |
| pub fn new() -> Self { |
| Self::default() |
| } |
| |
| /// If `enable` is true, returns a pair of an `ErrorReport` and a `dyn |
| /// ErrorReporting` that will report errors into the `ErrorReport`. |
| /// |
| /// If `enable` is false, returns `None` with a `dyn ErrorReporting` that |
| /// will ignore errors. |
| pub fn new_rc_or_ignore(enable: bool) -> (Option<Rc<Self>>, Rc<dyn ErrorReporting>) { |
| if enable { |
| let this = Rc::new(Self::default()); |
| (Some(this.clone()), this) |
| } else { |
| (None, Rc::new(IgnoreErrors)) |
| } |
| } |
| |
| pub fn to_json_string(&self) -> String { |
| serde_json::to_string_pretty(&*self.map.borrow()) |
| .expect("ErrorReporting serialization to JSON failed unexpectedly") |
| } |
| } |
| |
| impl ErrorReporting for ErrorReport { |
| fn report(&self, error: &arc_anyhow::Error) { |
| let root_cause = error.root_cause(); |
| if let Some(error) = root_cause.downcast_ref::<FormattedError>() { |
| let sample_message = if error.message != error.fmt { &*error.message } else { "" }; |
| self.map |
| .borrow_mut() |
| .entry(error.fmt.clone()) |
| .or_default() |
| .add(Cow::Owned(hide_unstable_details(sample_message))); |
| } else if let Some(error) = root_cause.downcast_ref::<ErrorList>() { |
| for error in &error.errors { |
| self.report(error); |
| } |
| } else { |
| self.map |
| .borrow_mut() |
| .entry(Cow::Borrowed("{}")) |
| .or_default() |
| .add(Cow::Owned(hide_unstable_details(&format!("{error}")))); |
| } |
| } |
| } |
| |
| #[derive(Default, Debug, Serialize)] |
| struct ErrorReportEntry { |
| count: u64, |
| #[serde(skip_serializing_if = "String::is_empty")] |
| sample_message: String, |
| } |
| |
| impl ErrorReportEntry { |
| fn add(&mut self, message: Cow<str>) { |
| if self.count == 0 { |
| self.sample_message = message.into_owned(); |
| } |
| self.count += 1; |
| } |
| } |
| |
| /// Reporter for fatal errors that will cause bindings generation to fail. |
| pub trait ReportFatalError { |
| /// Reports a fatal error that will cause bindings generation to fail. |
| /// |
| /// These errors should be issued only in response to misusage of Crubit |
| /// itself, such as incorrect use of Crubit-specific annotations. |
| fn report(&self, msg: &str); |
| } |
| |
| /// A collection of errors that should cause bindings generation to fail. |
| #[derive(Default)] |
| pub struct FatalErrors { |
| fatal_errors: std::cell::RefCell<String>, |
| } |
| |
| impl ReportFatalError for FatalErrors { |
| fn report(&self, msg: &str) { |
| let mut errors = self.fatal_errors.borrow_mut(); |
| errors.push('\n'); |
| errors.push_str(msg); |
| } |
| } |
| |
| impl FatalErrors { |
| pub fn new() -> Self { |
| Self::default() |
| } |
| |
| pub fn take_string(&self) -> String { |
| std::mem::take(&mut *self.fatal_errors.borrow_mut()) |
| } |
| } |
| |
| impl Drop for FatalErrors { |
| fn drop(&mut self) { |
| let errors = self.fatal_errors.borrow(); |
| if !errors.is_empty() { |
| panic!("Fatal errors in binding generation were not reported:{}", errors); |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use googletest::prelude::*; |
| |
| use arc_anyhow::Result; |
| |
| #[gtest] |
| fn anyhow_1arg_static_plain() { |
| let arc_err = anyhow!("abc"); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Borrowed(_))); |
| assert_eq!(err.fmt, "abc"); |
| assert!(matches!(err.message, Cow::Borrowed(_))); |
| assert_eq!(err.message, "abc"); |
| } |
| |
| #[gtest] |
| fn anyhow_1arg_static_fmt() { |
| let some_var = "def"; |
| let arc_err = anyhow!("abc{some_var}"); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Borrowed(_))); |
| assert_eq!(err.fmt, "abc{some_var}"); |
| assert!(matches!(err.message, Cow::Owned(_))); |
| assert_eq!(err.message, "abcdef"); |
| } |
| |
| #[gtest] |
| fn anyhow_1arg_dynamic() { |
| let arc_err = anyhow!(format!("abc{}", "def")); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Owned(_))); |
| assert_eq!(err.fmt, "abcdef"); |
| assert!(matches!(err.message, Cow::Owned(_))); |
| assert_eq!(err.message, "abcdef"); |
| } |
| |
| #[gtest] |
| fn anyhow_2arg() { |
| let arc_err = anyhow!("abc{}", "def"); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Borrowed(_))); |
| assert_eq!(err.fmt, "abc{}"); |
| assert!(matches!(err.message, Cow::Borrowed(_))); |
| assert_eq!(err.message, "abcdef"); |
| } |
| |
| #[gtest] |
| fn bail_1arg_static_plain() { |
| let arc_err = (|| -> arc_anyhow::Result<()> { bail!("abc") })().unwrap_err(); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Borrowed(_))); |
| assert_eq!(err.fmt, "abc"); |
| assert!(matches!(err.message, Cow::Borrowed(_))); |
| assert_eq!(err.message, "abc"); |
| } |
| |
| #[gtest] |
| fn bail_1arg_static_fmt() { |
| let some_var = "def"; |
| let arc_err = (|| -> arc_anyhow::Result<()> { bail!("abc{some_var}") })().unwrap_err(); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Borrowed(_))); |
| assert_eq!(err.fmt, "abc{some_var}"); |
| assert!(matches!(err.message, Cow::Owned(_))); |
| assert_eq!(err.message, "abcdef"); |
| } |
| |
| #[gtest] |
| fn bail_1arg_dynamic() { |
| let arc_err = |
| (|| -> arc_anyhow::Result<()> { bail!(format!("abc{}", "def")) })().unwrap_err(); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Owned(_))); |
| assert_eq!(err.fmt, "abcdef"); |
| assert!(matches!(err.message, Cow::Owned(_))); |
| assert_eq!(err.message, "abcdef"); |
| } |
| |
| #[gtest] |
| fn bail_2arg() { |
| let arc_err = (|| -> arc_anyhow::Result<()> { bail!("abc{}", "def") })().unwrap_err(); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Borrowed(_))); |
| assert_eq!(err.fmt, "abc{}"); |
| assert!(matches!(err.message, Cow::Borrowed(_))); |
| assert_eq!(err.message, "abcdef"); |
| } |
| |
| #[gtest] |
| fn ensure_pass() { |
| let f = || { |
| ensure!(true, "unused message"); |
| Ok(()) |
| }; |
| f().unwrap(); |
| } |
| |
| #[gtest] |
| fn ensure_fail_1arg_static_plain() { |
| let arc_err = (|| { |
| ensure!(false, "abc"); |
| Ok(()) |
| })() |
| .unwrap_err(); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Borrowed(_))); |
| assert_eq!(err.fmt, "abc"); |
| assert!(matches!(err.message, Cow::Borrowed(_))); |
| assert_eq!(err.message, "abc"); |
| } |
| |
| #[gtest] |
| fn ensure_fail_1arg_static_fmt() { |
| let some_var = "def"; |
| let arc_err = (|| { |
| ensure!(false, "abc{some_var}"); |
| Ok(()) |
| })() |
| .unwrap_err(); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Borrowed(_))); |
| assert_eq!(err.fmt, "abc{some_var}"); |
| assert!(matches!(err.message, Cow::Owned(_))); |
| assert_eq!(err.message, "abcdef"); |
| } |
| |
| #[gtest] |
| fn ensure_fail_1arg_dynamic() { |
| let arc_err = (|| { |
| ensure!(false, format!("abc{}", "def")); |
| Ok(()) |
| })() |
| .unwrap_err(); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Owned(_))); |
| assert_eq!(err.fmt, "abcdef"); |
| assert!(matches!(err.message, Cow::Owned(_))); |
| assert_eq!(err.message, "abcdef"); |
| } |
| |
| #[gtest] |
| fn ensure_fail_2arg() { |
| let arc_err = (|| { |
| ensure!(false, "abc{}", "def"); |
| Ok(()) |
| })() |
| .unwrap_err(); |
| let err: &FormattedError = arc_err.downcast_ref().unwrap(); |
| assert!(matches!(err.fmt, Cow::Borrowed(_))); |
| assert_eq!(err.fmt, "abc{}"); |
| assert!(matches!(err.message, Cow::Borrowed(_))); |
| assert_eq!(err.message, "abcdef"); |
| } |
| |
| #[gtest] |
| fn error_report() { |
| let report = ErrorReport::new(); |
| report.report(&anyhow!("abc{}", "def")); |
| report.report(&anyhow!("abc{}", "123")); |
| report.report(&anyhow!("error code: {}", 65535)); |
| report.report(&anyhow!("no parameters")); |
| report.report(&anyhow!("no parameters")); |
| report.report(&anyhow!("no parameters")); |
| report.report(&anyhow::Error::msg("not attributed").into()); |
| report.report(&anyhow!("has context from arc_anyhow::context()").context("the context")); |
| report.report( |
| &arc_anyhow::Context::context( |
| Result::<(), _>::Err(anyhow!("has context from arc_anyhow::Context::context()")), |
| "the context", |
| ) |
| .unwrap_err(), |
| ); |
| report.report( |
| &arc_anyhow::Context::with_context( |
| Result::<(), _>::Err(anyhow!( |
| "has context from arc_anyhow::Context::with_context()" |
| )), |
| || "the context", |
| ) |
| .unwrap_err(), |
| ); |
| report.report( |
| &anyhow!("has three layers of context") |
| .context("context 1") |
| .context("context 2") |
| .context("context 3"), |
| ); |
| |
| expect_eq!( |
| serde_json::from_str::<serde_json::Value>(&report.to_json_string()).unwrap(), |
| serde_json::json!({ |
| "abc{}": { |
| "count": 2, |
| "sample_message": "abcdef" |
| }, |
| "error code: {}": { |
| "count": 1, |
| "sample_message": "error code: 65535" |
| }, |
| "has context from arc_anyhow::Context::context()": { |
| "count": 1 |
| }, |
| "has context from arc_anyhow::Context::with_context()": { |
| "count": 1 |
| }, |
| "has context from arc_anyhow::context()": { |
| "count": 1 |
| }, |
| "has three layers of context": { |
| "count": 1 |
| }, |
| "no parameters": { |
| "count": 3 |
| }, |
| "{}": { |
| "count": 1, |
| "sample_message": "not attributed" |
| } |
| }), |
| ); |
| } |
| |
| #[gtest] |
| fn test_error_list_elements_are_reported() { |
| let report = ErrorReport::new(); |
| report.report(&arc_anyhow::Error::from(ErrorList::from(vec![ |
| anyhow!("abc{}", "def"), |
| anyhow!("hijk"), |
| ]))); |
| expect_eq!( |
| serde_json::from_str::<serde_json::Value>(&report.to_json_string()).unwrap(), |
| serde_json::json!({ |
| "abc{}": { |
| "count": 1, |
| "sample_message": "abcdef" |
| }, |
| "hijk": { |
| "count": 1 |
| } |
| }), |
| ); |
| } |
| } |
