google · jtdavis777 · Dec 3, 2025 · Nov 24, 2025 · Nov 25, 2025 · Nov 26, 2025
@@ -841,6 +841,29 @@ class RustGenerator : public BaseGenerator {
       code_ += "  }";
       code_ += "}";
       code_ += "";
+
+      if (!IsBitFlagsEnum(enum_def)) {
+        code_ += "impl<'de> serde::Deserialize<'de> for {{ENUM_TY}} {";
+        code_ +=
+            "    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>";
+        code_ += "    where";
+        code_ += "        D: serde::Deserializer<'de>,";
+        code_ += "    {";
+        code_ += "        let s = String::deserialize(deserializer)?;";
+        code_ += "        for item in {{ENUM_TY}}::ENUM_VALUES {";
+        code_ += "            if let Some(item_name) = item.variant_name() {";
+        code_ += "                if item_name == s {";
+        code_ += "                    return Ok(item.clone());";
+        code_ += "                }";
+        code_ += "            }";
+        code_ += "        }";
+        code_ += "        Err(serde::de::Error::custom(format!(";
+        code_ += "            \"Unknown {{ENUM_TY}} variant: {s}\"";
+        code_ += "        )))";
+        code_ += "    }";
+        code_ += "}";
+        code_ += "";
+      }
     }
 
     // Generate Follow and Push so we can serialize and stuff.

@@ -71,6 +71,25 @@ impl Serialize for AnyAmbiguousAliases {
   }
 }
 
+impl<'de> serde::Deserialize<'de> for AnyAmbiguousAliases {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        for item in AnyAmbiguousAliases::ENUM_VALUES {
+            if let Some(item_name) = item.variant_name() {
+                if item_name == s {
+                    return Ok(item.clone());
+                }
+            }
+        }
+        Err(serde::de::Error::custom(format!(
+            "Unknown AnyAmbiguousAliases variant: {s}"
+        )))
+    }
+}
+
 impl<'a> flatbuffers::Follow<'a> for AnyAmbiguousAliases {
   type Inner = Self;
   #[inline]

@@ -71,6 +71,25 @@ impl Serialize for Any {
   }
 }
 
+impl<'de> serde::Deserialize<'de> for Any {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        for item in Any::ENUM_VALUES {
+            if let Some(item_name) = item.variant_name() {
+                if item_name == s {
+                    return Ok(item.clone());
+                }
+            }
+        }
+        Err(serde::de::Error::custom(format!(
+            "Unknown Any variant: {s}"
+        )))
+    }
+}
+
 impl<'a> flatbuffers::Follow<'a> for Any {
   type Inner = Self;
   #[inline]

@@ -71,6 +71,25 @@ impl Serialize for AnyUniqueAliases {
   }
 }
 
+impl<'de> serde::Deserialize<'de> for AnyUniqueAliases {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        for item in AnyUniqueAliases::ENUM_VALUES {
+            if let Some(item_name) = item.variant_name() {
+                if item_name == s {
+                    return Ok(item.clone());
+                }
+            }
+        }
+        Err(serde::de::Error::custom(format!(
+            "Unknown AnyUniqueAliases variant: {s}"
+        )))
+    }
+}
+
 impl<'a> flatbuffers::Follow<'a> for AnyUniqueAliases {
   type Inner = Self;
   #[inline]

@@ -71,6 +71,25 @@ impl Serialize for Race {
   }
 }
 
+impl<'de> serde::Deserialize<'de> for Race {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        for item in Race::ENUM_VALUES {
+            if let Some(item_name) = item.variant_name() {
+                if item_name == s {
+                    return Ok(item.clone());
+                }
+            }
+        }
+        Err(serde::de::Error::custom(format!(
+            "Unknown Race variant: {s}"
+        )))
+    }
+}
+
 impl<'a> flatbuffers::Follow<'a> for Race {
   type Inner = Self;
   #[inline]

@@ -59,6 +59,25 @@ impl Serialize for FromInclude {
   }
 }
 
+impl<'de> serde::Deserialize<'de> for FromInclude {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        for item in FromInclude::ENUM_VALUES {
+            if let Some(item_name) = item.variant_name() {
+                if item_name == s {
+                    return Ok(item.clone());
+                }
+            }
+        }
+        Err(serde::de::Error::custom(format!(
+            "Unknown FromInclude variant: {s}"
+        )))
+    }
+}
+
 impl<'a> flatbuffers::Follow<'a> for FromInclude {
   type Inner = Self;
   #[inline]

@@ -9,4 +9,3 @@ edition = "2021"
 flatbuffers = { path = "../../rust/flatbuffers", features=["serialize"] }
 serde = "1.0"
 serde_json = "1.0"
-
@@ -3,6 +3,9 @@
 mod monster_test_serialize_generated;
 pub use monster_test_serialize_generated::my_game;
 
+use crate::my_game::example::AnyAmbiguousAliases;
+use std::collections::HashMap;
+
 fn create_serialized_example_with_generated_code(builder: &mut flatbuffers::FlatBufferBuilder) {
     let mon = {
         let s0 = builder.create_string("test1");
@@ -29,7 +32,10 @@ fn create_serialized_example_with_generated_code(builder: &mut flatbuffers::Flat
             test: Some(
                 my_game::example::Monster::create(
                     builder,
-                    &my_game::example::MonsterArgs { name: Some(fred_name), ..Default::default() },
+                    &my_game::example::MonsterArgs {
+                        name: Some(fred_name),
+                        ..Default::default()
+                    },
                 )
                 .as_union_value(),
             ),
@@ -83,4 +89,8 @@ fn main() {
 
     let t1 = testarrayofstring[1].as_str().unwrap();
     assert_eq!(t1, "test2");
+
+    let s = r#"{"val":"M1"}"#;
+    let des = serde_json::from_str::<HashMap<String, AnyAmbiguousAliases>>(s).unwrap();
+    assert_eq!(*des.get("val").unwrap(), AnyAmbiguousAliases::M1);
 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -9,4 +9,3 @@ edition = "2021"
		flatbuffers = { path = "../../rust/flatbuffers", features=["serialize"] }
		serde = "1.0"
		serde_json = "1.0"