impl_deserialize_for_internally_tagged_enum panic on deserialize when inner element is itself an enum #928

Activity

1. Mingun commented on Jan 4, 2026

   

   Mingun

   on Jan 4, 2026

   Collaborator

   More actions

   Unfortunately rustexplorer links does not open for me. Could you post the code here?
2. Mingun

   added

   serdeIssues related to mapping from Rust types to XMLIssues related to mapping from Rust types to XML

   on Jan 4, 2026
3. mattr555 commented on Jan 5, 2026

   

   mattr555

   on Jan 5, 2026

   Author

   More actions

   @Mingun apologies, here is the code that demonstrates the test assert:

   /*
   [dependencies]
   quick-xml = { version = "0.38.4", features = ["serde-types", "serialize"] }
   serde = { version = "1.0", features = ["derive"] }
   pretty_assertions = "1.0"
   */
   use pretty_assertions::assert_eq;
   use quick_xml::impl_deserialize_for_internally_tagged_enum;
   use serde::Deserialize;
   
   #[derive(Default, Debug, Deserialize, PartialEq)]
   struct Root {
       #[serde(rename = "$value")]
       actions: Vec<Action>,
   }
   
   #[derive(Debug, Deserialize, Clone, PartialEq)]
   struct Tag {
       #[serde(rename = "@k")]
       k: String,
       #[serde(rename = "@v")]
       v: String,
   }
   
   #[derive(Debug, Deserialize, PartialEq)]
   #[serde(rename_all = "kebab-case")]
   enum Element {
       Node {
           #[serde(rename = "@id")]
           id: u64,
           #[serde(rename = "$value")]
           tags: Option<Vec<Tag>>,
       },
       Way,
       #[serde(other)]
       Other,
   }
   
   #[derive(Debug, Deserialize, PartialEq)]
   struct ElementHolder {
       #[serde(rename = "$value")]
       e: Element,
   }
   
   #[derive(Debug, PartialEq)]
   enum Action {
       Create(Element),
       Modify {
           old: ElementHolder,
           new: ElementHolder,
       },
       Delete {
           old: ElementHolder,
           new: ElementHolder,
       },
   }
   
   impl_deserialize_for_internally_tagged_enum! {
       Action, "@type",
       ("create" => Create(Element)),
       ("modify" => Modify {
           old: ElementHolder,
           new: ElementHolder
       }),
       ("delete" => Delete {
           old: ElementHolder,
           new: ElementHolder
       })
   }
   
   fn main() {
       assert_eq!(
           quick_xml::de::from_str::<Root>(
               r#"
   <root>
     <action type="create">
       <node id="123">
         <tag k="key" v="value"/>
       </node>
     </action>
     <action type="modify">
       <old>
         <node id="456">
           <tag k="key" v="old_value"/>
         </node>
       </old>
       <new>
         <node id="456">
           <tag k="key" v="new_value"/>
         </node>
       </new>
     </action>
     <action type="modify">
       <old>
         <way />
       </old>
       <new>
         <way />
       </new>
     </action>
   </root>
        "#
           )
           .unwrap(),
           Root {
               actions: vec![
                   Action::Create(Element::Node {
                       id: 123,
                       tags: Some(vec![Tag {
                           k: "key".to_string(),
                           v: "value".to_string()
                       }])
                   }),
                   Action::Modify {
                       old: ElementHolder {
                           e: Element::Node {
                               id: 456,
                               tags: Some(vec![Tag {
                                   k: "key".to_string(),
                                   v: "old_value".to_string()
                               }])
                           }
                       },
                       new: ElementHolder {
                           e: Element::Node {
                               id: 456,
                               tags: Some(vec![Tag {
                                   k: "key".to_string(),
                                   v: "new_value".to_string()
                               }])
                           }
                       }
                   },
                   Action::Modify {
                       old: ElementHolder { e: Element::Way },
                       new: ElementHolder { e: Element::Way }
                   }
               ]
           },
       );
   }

   This assertion passes as expected:

   fn main() {
       assert_eq!(
           quick_xml::de::from_str::<Root>(
               r#"
   <root>
     <action type="modify">
       <old>
         <node id="456">
           <tag k="key" v="old_value"/>
         </node>
       </old>
       <new>
         <node id="456">
           <tag k="key" v="new_value"/>
         </node>
       </new>
     </action>
     <action type="modify">
       <old>
         <way />
       </old>
       <new>
         <way />
       </new>
     </action>
   </root>
        "#
           )
           .unwrap(),
           Root {
               actions: vec![
                   Action::Modify {
                       old: ElementHolder {
                           e: Element::Node {
                               id: 456,
                               tags: Some(vec![Tag {
                                   k: "key".to_string(),
                                   v: "old_value".to_string()
                               }])
                           }
                       },
                       new: ElementHolder {
                           e: Element::Node {
                               id: 456,
                               tags: Some(vec![Tag {
                                   k: "key".to_string(),
                                   v: "new_value".to_string()
                               }])
                           }
                       }
                   },
                   Action::Modify {
                       old: ElementHolder { e: Element::Way },
                       new: ElementHolder { e: Element::Way }
                   }
               ]
           },
       );
   }
4. Mingun commented on Jan 5, 2026

   

   Mingun

   on Jan 5, 2026

   Collaborator

   More actions

   While some bug exists, you mapping not entirely correct. Note, that every Action variant is deserialized from the <action> tag (look carefully, you assume this in Modify and Delete variants), so your Action::Create should contain ElementHolder as well. See:

   XML	Rust value
   <tag k="key" v="old_value"/>	Tag { ... }
   <node id="123"><tag k="key" v="old_value"/></node>	Element::Node { ... }
   <action><node id="123"><tag k="key" v="old_value"/></node></action>	ElementHolder { ... }
   <old ><node id="123"><tag k="key" v="old_value"/></node></old>	ElementHolder { ... }
   <new ><node id="123"><tag k="key" v="old_value"/></node></new>	ElementHolder { ... }

   Also, it seems, that actions and tags fields are unnecessarily accept any XML tag (because they are renamed to $value). It seems that it is enough for them to be renamed to action and tag correspondingly (the tag names in XML).

   Considering all above, the correct mapping should be:

   #[derive(Default, Debug, Deserialize, PartialEq)]
   struct Root {
       #[serde(rename = "action")] // <<<<< not $value. Also probably "default"/Option required for empty list of actions
       actions: Vec<Action>,
   }
   
   #[derive(Debug, Deserialize, Clone, PartialEq)]
   struct Tag {
       #[serde(rename = "@k")]
       k: String,
       #[serde(rename = "@v")]
       v: String,
   }
   
   #[derive(Debug, Deserialize, PartialEq)]
   #[serde(rename_all = "kebab-case")]
   enum Element {
       Node {
           #[serde(rename = "@id")]
           id: u64,
           #[serde(rename = "tag")] // <<<<< not $value
           tags: Option<Vec<Tag>>,
       },
       Way,
       #[serde(other)]
       Other,
   }
   
   #[derive(Debug, Deserialize, PartialEq)]
   struct ElementHolder {
       #[serde(rename = "$value")]
       e: Element,
   }
   
   #[derive(Debug, PartialEq)]
   enum Action {
       Create(ElementHolder),
       Modify {
           old: ElementHolder,
           new: ElementHolder,
       },
       Delete {
           old: ElementHolder,
           new: ElementHolder,
       },
   }

   Unfortunately, this is also not work. Under the hood, content of Action variants deserialized from the MapAccessDeserializer. So, ElementHolder will be deserialized from the MapAccessDeserializer<quick_xml::de::map::ElementMapAccess>.

   ElementMapAccess is created by the impl_deserialize_for_internally_tagged_enum when it calls deserialize_map:
   

   quick-xml/src/serde_helpers.rs

   Lines 286 to 288 in d7838c3

   	// Tell the deserializer to deserialize the data as a map,
   	// using the TheVisitor as the decoder
   	deserializer.deserialize_map(TheVisitor)

   Because of using deserialize_map instead of deserialize_struct the ElementMapAccess does not known that specially named field $value exists in the ElementHolder and cannot provide the corresponding key from MapAccess::next_key_seed.

   I doesn't see easy generic solution here. It seems to me, that you should implement impl_deserialize_for_internally_tagged_enum manually for your use case and call deserialize_struct("", &["$value"], TheVisitor) instead of deserialize_map.
5. Mingun

   added

   bug

   on Jan 5, 2026
6. Mingun commented on Jan 5, 2026

   

   Mingun

   on Jan 5, 2026

   Collaborator

   More actions

   Ok, actually, extend the impl_deserialize_for_internally_tagged_enum! macro was not so hard, so in the next version you could use it for your case. That's not fixes the original bug (we shouldn't trigger debug asserts), so I keep this open until the reason of the bug would be investigated & fixed.
7. mattr555 commented on Jan 6, 2026

   

   mattr555

   on Jan 6, 2026

   Author

   More actions

   Thanks very much for your support! Your suggestions make sense to me - indeed I had tried that but was led astray by the missing $value field.