facet-json: Incorrect de/serialization of flattened adjacently-tagged enums

[kylewlacy]

Easiest to show with an example:

#[derive(Facet, Clone, PartialEq, Debug)]
pub struct Wrapper {
    value: String,
    #[facet(flatten)]
    inner: AdjacentlyTagged,
}

#[derive(Facet, Clone, PartialEq, Debug)]
#[repr(u8)]
#[facet(tag = "tag", content = "content")]
pub enum AdjacentlyTagged {
    Foo { foo: String },
    Bar { bar: String },
}

fn main() {
  let value = Wrapper {
    value: "".to_string(),
    inner: AdjacentlyTagged::Foo { foo: "".to_string() },
  };
  let json = facet_json::to_string(&value).unwrap();
  println!("Serialized:\n{json}");
  println!("Deserialized:\n{:?}", facet_json::from_str::<Wrapper>(&json));
}

(Tested with facet = "=0.44.1" and facet-json locked to 451b761)

facet_json serializes this type as:

{
  "value": "",
  "Foo": {
    "tag": "Foo",
    "content": {"foo": ""}
  }
}

...which is to say, the inner field gets wrapped in an extra field named after its variant, as if it were externally-tagged (I think). Instead, I'd expect this (i.e. what serde_json does):

{
  "value": "",
  "tag": "Foo",
  "content": {"foo": ""}
}

Deserialization fails with either version of the JSON.

[kylewlacy]

There was a similar issue for internally-tagged enums recently (facet-rs/facet#2124) (which I thought might resolve this issue, but no dice!). I started toying around with code by referencing the PR that resolved that issue, and ended up with a patch that fixes serialization (or seems to, anyway).

If I have some time this weekend, I could try to at least clean this up and turn it into a WIP PR for someone else to pick up or to track progress, if that would help at all. But I don't think I'll have the time to get this across the finish line any time soon. Just wanted to throw out what I'd found so far.

(Base: 451b761:facet-format/src/serializer.rs)

diff --git a/facet-format/src/serializer.rs b/facet-format/src/serializer.rs
index 23ae59a94c..a9425ef23a 100644
--- a/facet-format/src/serializer.rs
+++ b/facet-format/src/serializer.rs
@@ -1065,6 +1065,111 @@
                     continue;
                 }
 
+                // Check for flattened adjacently-tagged enum
+                if field_item.flattened
+                    && let Some(field) = field_item.field
+                    && let shape = field.shape()
+                    && let Some(tag_key) = shape.get_tag_attr()
+                    && let Some(content_key) = shape.get_content_attr()
+                    && let Ok(enum_) = field_value.into_enum()
+                    && let Ok(variant) = enum_.active_variant()
+                {
+                    let variant_name = field_item.effective_name();
+
+                    if field_mode == StructFieldMode::Named {
+                        self.serializer
+                            .field_key(tag_key)
+                            .map_err(SerializeError::Backend)?;
+                    }
+                    self.serializer
+                        .scalar(ScalarValue::Str(Cow::Borrowed(variant_name)))
+                        .map_err(SerializeError::Backend)?;
+
+                    match variant.data.kind {
+                        StructKind::Unit => {}
+                        StructKind::Struct => {
+                            self.serializer
+                                .field_key(content_key)
+                                .map_err(SerializeError::Backend)?;
+                            self.serializer
+                                .begin_struct()
+                                .map_err(SerializeError::Backend)?;
+                            let mut fields: alloc::vec::Vec<_> =
+                                if field_mode == StructFieldMode::Unnamed {
+                                    enum_.fields_for_binary_serialize().collect()
+                                } else {
+                                    enum_.fields_for_serialize().collect()
+                                };
+                            sort_fields_if_needed(self.serializer, &mut fields);
+                            for (field_item, field_value) in fields {
+                                self.serializer
+                                    .field_metadata(&field_item)
+                                    .map_err(SerializeError::Backend)?;
+                                if field_mode == StructFieldMode::Named {
+                                    self.serializer
+                                        .field_key(field_item.effective_name())
+                                        .map_err(SerializeError::Backend)?;
+                                }
+                                self.push(PathSegment::Field(Cow::Owned(
+                                    field_item.effective_name().to_string(),
+                                )));
+                                self.serialize_field_value(&field_item, field_value)?;
+                                self.pop();
+                            }
+                            self.serializer
+                                .end_struct()
+                                .map_err(SerializeError::Backend)?;
+                        }
+                        StructKind::TupleStruct | StructKind::Tuple => {
+                            self.serializer
+                                .field_key(content_key)
+                                .map_err(SerializeError::Backend)?;
+
+                            let field_count = variant.data.fields.len();
+                            if field_count == 1 {
+                                let inner = enum_
+                                    .field(0)
+                                    .map_err(|_| {
+                                        SerializeError::Internal(Cow::Borrowed(
+                                            "variant field lookup failed",
+                                        ))
+                                    })?
+                                    .ok_or(SerializeError::Internal(Cow::Borrowed(
+                                        "variant reported 1 field but field(0) returned None",
+                                    )))?;
+                                let field_def = variant.data.fields.first().copied();
+                                self.with_field_context(field_def, |this| {
+                                    this.serialize_impl(inner)
+                                })?;
+                            } else {
+                                self.serializer
+                                    .begin_seq()
+                                    .map_err(SerializeError::Backend)?;
+                                for idx in 0..field_count {
+                                    let inner = enum_
+                                        .field(idx)
+                                        .map_err(|_| {
+                                            SerializeError::Internal(Cow::Borrowed(
+                                                "variant field lookup failed",
+                                            ))
+                                        })?
+                                        .ok_or(SerializeError::Internal(Cow::Borrowed(
+                                            "variant field missing while iterating tuple fields",
+                                        )))?;
+                                    self.push(PathSegment::Index(idx));
+                                    let field_def = variant.data.fields.get(idx).copied();
+                                    self.with_field_context(field_def, |this| {
+                                        this.serialize_impl(inner)
+                                    })?;
+                                    self.pop();
+                                }
+                                self.serializer.end_seq().map_err(SerializeError::Backend)?;
+                            }
+                        }
+                    }
+                    continue;
+                }
+
                 // Flattened externally-tagged enum fields should contribute exactly one
                 // key/value pair to the parent object. `field_item.effective_name()` is
                 // already the active variant key for flattened enum fields.