parsers: use Error type from xso

This is a large change and as such, it needs good motivation. Let me
remind you of the ultimate goal: we want a derive macro which allows us
to FromXml/IntoXml, and that derive macro should be usable from
`xmpp_parsers` and other crates.

For that, any code generated by the derive macro mustn't depend on any
code in the `xmpp_parsers` crate, because you cannot name the crate you
are in portably (`xmpp_parsers::..` wouldn't resolve within
`xmpp_parsers`, and `crate::..` would point at other crates if the macro
was used in other crates).

We also want to interoperate with code already implementing
`TryFrom<Element>` and `Into<Element>` on structs. This ultimately
requires that we have an error type which is shared by the two
implementations and that error type must be declared in the `xso` crate
to be usable by the macros.

Thus, we port the error type over to use the type declared in `xso`.

This changes the structure of the error type greatly; I do not think
that `xso` should have to know about all the different types we are
parsing there and they don't deserve special treatment. Wrapping them in
a `Box<dyn ..>` seems more appropriate.

xso/src/error.rs

@@ -23,7 +23,7 @@ pub enum Error {
     TextParseError(Box<dyn std::error::Error + Send + Sync + 'static>),
 
     /// Generic, unspecified other error.
-    Other(Box<str>),
+    Other(&'static str),
 
     /// An element header did not match an expected element.
     ///
@@ -33,6 +33,16 @@ pub enum Error {
     TypeMismatch,
 }
 
+impl Error {
+    /// Convenience function to create a [`Self::TextParseError`] variant.
+    ///
+    /// This includes the `Box::new(.)` call, making it directly usable as
+    /// argument to [`Result::map_err`].
+    pub fn text_parse_error<T: std::error::Error + Send + Sync + 'static>(e: T) -> Self {
+        Self::TextParseError(Box::new(e))
+    }
+}
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -121,3 +131,75 @@ impl std::error::Error for FromEventsError {
         }
     }
 }
+
+impl From<Error> for Result<minidom::Element, Error> {
+    fn from(other: Error) -> Self {
+        Self::Err(other)
+    }
+}
+
+/// Error returned by the `TryFrom<Element>` implementations.
+#[derive(Debug)]
+pub enum FromElementError {
+    /// The XML element header did not match the expectations of the type
+    /// implementing `TryFrom`.
+    ///
+    /// Contains the original `Element` unmodified.
+    Mismatch(minidom::Element),
+
+    /// During processing of the element, an (unrecoverable) error occured.
+    Invalid(Error),
+}
+
+impl fmt::Display for FromElementError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Mismatch(ref el) => write!(
+                f,
+                "expected different XML element (got {} in namespace {})",
+                el.name(),
+                el.ns()
+            ),
+            Self::Invalid(ref e) => fmt::Display::fmt(e, f),
+        }
+    }
+}
+
+impl std::error::Error for FromElementError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::Mismatch(_) => None,
+            Self::Invalid(ref e) => Some(e),
+        }
+    }
+}
+
+impl From<Result<minidom::Element, Error>> for FromElementError {
+    fn from(other: Result<minidom::Element, Error>) -> Self {
+        match other {
+            Ok(v) => Self::Mismatch(v),
+            Err(e) => Self::Invalid(e),
+        }
+    }
+}
+
+impl From<Error> for FromElementError {
+    fn from(other: Error) -> Self {
+        Self::Invalid(other)
+    }
+}
+
+impl From<FromElementError> for Error {
+    fn from(other: FromElementError) -> Self {
+        match other {
+            FromElementError::Invalid(e) => e,
+            FromElementError::Mismatch(..) => Self::TypeMismatch,
+        }
+    }
+}
+
+impl From<core::convert::Infallible> for FromElementError {
+    fn from(other: core::convert::Infallible) -> Self {
+        match other {}
+    }
+}