Properly use xsi:nil to deserialize null values via serde

This commit fixes an issue that causes `quick-xml` trying to deserialize
empty tags via the serde interface even if these tags were explicitly
marked as `xsi:nil="true"`

For example the following XML failed to deserialize before this commit:

```xml
<bar>
	<foo xsi:nil="true"/>
</bar>
```

into the following rust type:

```rust
#[derive(Deserialize)]
struct Bar {
    foo: Option<Inner>,
}

#[derive(Deserialize)]
struct Foo {
    baz: String,
}
```

Before this commit this failed to deserialize with an error message that
complained that the `baz` field was missing. After this commit this uses
the `xsi:nil` attribute to deserialize this into `foo: None` instead.
The standard (https://www.w3.org/TR/xmlschema-1/#xsi_nil) seems to
support this behaviour. 

Fix #497

Author: weiznich

src/de/map.rs

@@ -542,6 +542,13 @@ where
     {
         match self.map.de.peek()? {
             DeEvent::Text(t) if t.is_empty() => visitor.visit_none(),
+            DeEvent::Start(start)
+                // if the `xsi:nil` attribute is set to true we got a none value
+                if start.attributes().is_xsi_nil() =>
+            {
+                self.map.de.skip_nil_tag()?;
+                visitor.visit_none()
+            }
             _ => visitor.visit_some(self),
         }
     }

src/de/mod.rs

@@ -2764,6 +2764,33 @@ where
         }
         self.reader.read_to_end(name)
     }
+
+    fn skip_nil_tag(&mut self) -> Result<(), DeError> {
+        use serde::de::Error;
+        let DeEvent::Start(start) = self.peek()? else {
+            unreachable!("Only call this if the next event is a start event")
+        };
+        let name = start.name().0.to_vec();
+        let name = QName(&name);
+        loop {
+            match self.next()? {
+                DeEvent::Eof => return Err(DeError::UnexpectedEof),
+                DeEvent::Start(s) if s.name() == name => {}
+                DeEvent::End(e) if e.name() == name => break,
+                DeEvent::Start(s) => return Err(DeError::UnexpectedStart(s.name().0.to_vec())),
+                DeEvent::Text(t) => {
+                    return Err(DeError::custom(format!("Unexpected text found: `{t:?}`")))
+                }
+                DeEvent::End(e) => {
+                    return Err(DeError::custom(format!(
+                        "Unkexpected end tag found: `{:?}`",
+                        e.name()
+                    )))
+                }
+            }
+        }
+        Ok(())
+    }
 }
 
 impl<'de> Deserializer<'de, SliceReader<'de>> {
@@ -2948,6 +2975,13 @@ where
         match self.peek()? {
             DeEvent::Text(t) if t.is_empty() => visitor.visit_none(),
             DeEvent::Eof => visitor.visit_none(),
+            DeEvent::Start(start)
+                // if the `xsi:nil` attribute is set to true we got a none value
+                if start.attributes().is_xsi_nil() =>
+            {
+                self.skip_nil_tag()?;
+                visitor.visit_none()
+            }
             _ => visitor.visit_some(self),
         }
     }
@@ -4680,4 +4714,43 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn deserialize_nil() {
+        #[derive(Debug, serde::Deserialize, PartialEq)]
+        struct Foo {
+            bar: String,
+        }
+
+        let data = r#"<foo xsi:nil="true"/>"#;
+
+        let res = super::from_str::<Option<Foo>>(data).unwrap();
+        assert!(res.is_none());
+
+        let data = r#"<foo xsi:nil="false"><bar>Boom</bar></foo>"#;
+        let res = super::from_str::<Option<Foo>>(data).unwrap();
+        assert_eq!(
+            res,
+            Some(Foo {
+                bar: String::from("Boom")
+            })
+        );
+    }
+
+    #[test]
+    fn deserialize_nested_nil() {
+        #[derive(Debug, serde::Deserialize, PartialEq)]
+        struct Foo {
+            bar: String,
+        }
+
+        #[derive(Debug, serde::Deserialize, PartialEq)]
+        struct Bar {
+            foo: Option<Foo>,
+        }
+
+        let data = r#"<bar><foo xsi:nil="true"/></bar>"#;
+        let res = super::from_str::<Bar>(data).unwrap();
+        assert_eq!(res, Bar { foo: None });
+    }
 }

src/events/attributes.rs

@@ -234,6 +234,14 @@ impl<'a> Attributes<'a> {
         self.state.check_duplicates = val;
         self
     }
+
+    pub(crate) fn is_xsi_nil(&self) -> bool {
+        self.clone().any(|attr| {
+            matches!(attr, Ok(crate::events::attributes::Attribute{
+                        key: QName(b"xsi:nil"), value
+                    }) if &*value == b"true")
+        })
+    }
 }
 
 impl<'a> Iterator for Attributes<'a> {