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.

parsers/src/jingle_message.rs

@@ -6,8 +6,8 @@
 
 use crate::jingle::SessionId;
 use crate::ns;
-use crate::util::error::Error;
 use crate::Element;
+use xso::error::{Error, FromElementError};
 
 /// Defines a protocol for broadcasting Jingle requests to all of the clients
 /// of a user.
@@ -47,27 +47,27 @@ fn check_empty_and_get_sid(elem: Element) -> Result<SessionId, Error> {
 }
 
 impl TryFrom<Element> for JingleMI {
-    type Error = Error;
+    type Error = FromElementError;
 
-    fn try_from(elem: Element) -> Result<JingleMI, Error> {
+    fn try_from(elem: Element) -> Result<JingleMI, FromElementError> {
         if !elem.has_ns(ns::JINGLE_MESSAGE) {
-            return Err(Error::ParseError("This is not a Jingle message element."));
+            return Err(Error::Other("This is not a Jingle message element.").into());
         }
         Ok(match elem.name() {
             "propose" => {
                 let mut description = None;
                 for child in elem.children() {
                     if child.name() != "description" {
-                        return Err(Error::ParseError("Unknown child in propose element."));
+                        return Err(Error::Other("Unknown child in propose element.").into());
                     }
                     if description.is_some() {
-                        return Err(Error::ParseError("Too many children in propose element."));
+                        return Err(Error::Other("Too many children in propose element.").into());
                     }
                     description = Some(child.clone());
                 }
                 JingleMI::Propose {
                     sid: get_sid(elem)?,
-                    description: description.ok_or(Error::ParseError(
+                    description: description.ok_or(Error::Other(
                         "Propose element doesn’t contain a description.",
                     ))?,
                 }
@@ -76,7 +76,7 @@ impl TryFrom<Element> for JingleMI {
             "accept" => JingleMI::Accept(check_empty_and_get_sid(elem)?),
             "proceed" => JingleMI::Proceed(check_empty_and_get_sid(elem)?),
             "reject" => JingleMI::Reject(check_empty_and_get_sid(elem)?),
-            _ => return Err(Error::ParseError("This is not a Jingle message element.")),
+            _ => return Err(Error::Other("This is not a Jingle message element.").into()),
         })
     }
 }
@@ -134,7 +134,7 @@ mod tests {
                 .unwrap();
         let error = JingleMI::try_from(elem).unwrap_err();
         let message = match error {
-            Error::ParseError(string) => string,
+            FromElementError::Invalid(Error::Other(string)) => string,
             _ => panic!(),
         };
         assert_eq!(message, "Unknown child in propose element.");