fix: implement std::error::Error for data-url

This commit implements std::error::Error for errors in the `data-url`
crate. This commit does not implement `Error` on `DecodeError` because
there is no trait bound for `Error` on the `E` type argument of
`DecodeError`.

data-url/src/forgiving_base64.rs

@@ -1,10 +1,26 @@
 //! <https://infra.spec.whatwg.org/#forgiving-base64-decode>
 
 use alloc::vec::Vec;
+use core::fmt;
 
 #[derive(Debug)]
 pub struct InvalidBase64(InvalidBase64Details);
 
+impl fmt::Display for InvalidBase64 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.0 {
+            InvalidBase64Details::UnexpectedSymbol(code_point) => {
+                write!(f, "symbol with codepoint {} not expected", code_point)
+            }
+            InvalidBase64Details::AlphabetSymbolAfterPadding => {
+                write!(f, "alphabet symbol present after padding")
+            }
+            InvalidBase64Details::LoneAlphabetSymbol => write!(f, "lone alphabet symbol present"),
+            InvalidBase64Details::Padding => write!(f, "incorrect padding"),
+        }
+    }
+}
+
 #[derive(Debug)]
 enum InvalidBase64Details {
     UnexpectedSymbol(u8),
@@ -19,6 +35,18 @@ pub enum DecodeError<E> {
     WriteError(E),
 }
 
+impl<E: fmt::Display> fmt::Display for DecodeError<E> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::InvalidBase64(inner) => write!(f, "base64 not valid: {}", inner),
+            Self::WriteError(err) => write!(f, "write error: {}", err),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<E: std::error::Error> std::error::Error for DecodeError<E> {}
+
 impl<E> From<InvalidBase64Details> for DecodeError<E> {
     fn from(e: InvalidBase64Details) -> Self {
         DecodeError::InvalidBase64(InvalidBase64(e))

data-url/src/lib.rs

@@ -18,7 +18,7 @@
 
 // For forwards compatibility
 #[cfg(feature = "std")]
-extern crate std as _;
+extern crate std;
 
 #[macro_use]
 extern crate alloc;
@@ -27,6 +27,7 @@ extern crate alloc;
 compile_error!("the `alloc` feature must be enabled");
 
 use alloc::{string::String, vec::Vec};
+use core::fmt;
 
 macro_rules! require {
     ($condition: expr) => {
@@ -51,6 +52,21 @@ pub enum DataUrlError {
     NoComma,
 }
 
+impl fmt::Display for DataUrlError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::NotADataUrl => write!(f, "not a valid data url"),
+            Self::NoComma => write!(
+                f,
+                "data url is missing comma delimiting attributes and body"
+            ),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for DataUrlError {}
+
 impl<'a> DataUrl<'a> {
     /// <https://fetch.spec.whatwg.org/#data-url-processor>
     /// but starting from a string rather than a parsed `Url`, to avoid extra string copies.

data-url/src/mime.rs

@@ -26,6 +26,15 @@ impl Mime {
 #[derive(Debug)]
 pub struct MimeParsingError(());
 
+impl fmt::Display for MimeParsingError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "invalid mime type")
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for MimeParsingError {}
+
 /// <https://mimesniff.spec.whatwg.org/#parsing-a-mime-type>
 impl FromStr for Mime {
     type Err = MimeParsingError;