[Rust] Support struct type field with key attribute

- Derive `Eq` for struct types
- Impl `Ord` and `PartialOrd` for struct types

Fixes #8603

Author: emesare

samples/rust_generated/my_game/sample/vec_3_generated.rs

@@ -11,7 +11,7 @@ use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 // struct Vec3, aligned to 4
 #[repr(transparent)]
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Vec3(pub [u8; 12]);
 impl Default for Vec3 { 
   fn default() -> Self { 
@@ -27,6 +27,18 @@ impl core::fmt::Debug for Vec3 {
       .finish()
   }
 }
+impl core::cmp::Ord for Vec3 {
+  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    self.x().total_cmp(&other.x())
+      .then(self.y().total_cmp(&other.y()))
+      .then(self.z().total_cmp(&other.z()))
+  }
+}
+impl core::cmp::PartialOrd for Vec3 {
+  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    Some(self.cmp(other))
+  }
+}
 
 impl flatbuffers::SimpleToVerifyInSlice for Vec3 {}
 impl<'a> flatbuffers::Follow<'a> for Vec3 {

src/idl_gen_rust.cpp

@@ -2625,7 +2625,7 @@ class RustGenerator : public BaseGenerator {
     // hold for PartialOrd/Ord.
     code_ += "// struct {{STRUCT_TY}}, aligned to {{ALIGN}}";
     code_ += "#[repr(transparent)]";
-    code_ += "#[derive(Clone, Copy, PartialEq)]";
+    code_ += "#[derive(Clone, Copy, PartialEq, Eq)]";
     code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}(pub [u8; {{STRUCT_SIZE}}]);";
     code_ += "impl Default for {{STRUCT_TY}} { ";
     code_ += "  fn default() -> Self { ";
@@ -2646,6 +2646,30 @@ class RustGenerator : public BaseGenerator {
     code_ += "      .finish()";
     code_ += "  }";
     code_ += "}";
+
+    // Ord for structs.
+    code_ += "impl core::cmp::Ord for {{STRUCT_TY}} {";
+    code_ += "  fn cmp(&self, other: &Self) -> core::cmp::Ordering {";
+    bool first = true;
+    ForAllStructFields(struct_def, [&](const FieldDef &field) {
+      // Floating point types don't impl Ord, use `total_cmp` instead.
+      const auto cmp_fn =
+          IsFloat(field.value.type.base_type) ? "total_cmp" : "cmp";
+      const auto cmp_expr = "self." + namer_.Field(field) + "()." + cmp_fn +
+                            "(&other." + namer_.Field(field) + "())";
+      // If we are not the first comparison, we use `then` to chain.
+      code_ += first ? "  " + cmp_expr : "    .then(" + cmp_expr + ")";
+      first = false;
+    });
+    code_ += "  }";
+    code_ += "}";
+
+    // PartialOrd for structs.
+    code_ += "impl core::cmp::PartialOrd for {{STRUCT_TY}} {";
+    code_ += "  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {";
+    code_ += "    Some(self.cmp(other))";
+    code_ += "  }";
+    code_ += "}";
     code_ += "";
 
     // Generate impls for SafeSliceAccess (because all structs are endian-safe),

tests/arrays_test/my_game/example/array_struct_generated.rs

@@ -11,7 +11,7 @@ use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 // struct ArrayStruct, aligned to 8
 #[repr(transparent)]
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct ArrayStruct(pub [u8; 160]);
 impl Default for ArrayStruct { 
   fn default() -> Self { 
@@ -30,6 +30,21 @@ impl core::fmt::Debug for ArrayStruct {
       .finish()
   }
 }
+impl core::cmp::Ord for ArrayStruct {
+  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    self.a().total_cmp(&other.a())
+      .then(self.b().cmp(&other.b()))
+      .then(self.c().cmp(&other.c()))
+      .then(self.d().cmp(&other.d()))
+      .then(self.e().cmp(&other.e()))
+      .then(self.f().cmp(&other.f()))
+  }
+}
+impl core::cmp::PartialOrd for ArrayStruct {
+  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    Some(self.cmp(other))
+  }
+}
 
 impl flatbuffers::SimpleToVerifyInSlice for ArrayStruct {}
 impl<'a> flatbuffers::Follow<'a> for ArrayStruct {

tests/arrays_test/my_game/example/nested_struct_generated.rs

@@ -11,7 +11,7 @@ use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 // struct NestedStruct, aligned to 8
 #[repr(transparent)]
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct NestedStruct(pub [u8; 32]);
 impl Default for NestedStruct { 
   fn default() -> Self { 
@@ -28,6 +28,19 @@ impl core::fmt::Debug for NestedStruct {
       .finish()
   }
 }
+impl core::cmp::Ord for NestedStruct {
+  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    self.a().cmp(&other.a())
+      .then(self.b().cmp(&other.b()))
+      .then(self.c().cmp(&other.c()))
+      .then(self.d().cmp(&other.d()))
+  }
+}
+impl core::cmp::PartialOrd for NestedStruct {
+  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    Some(self.cmp(other))
+  }
+}
 
 impl flatbuffers::SimpleToVerifyInSlice for NestedStruct {}
 impl<'a> flatbuffers::Follow<'a> for NestedStruct {

tests/include_test1/my_game/other_name_space/unused_generated.rs

@@ -11,7 +11,7 @@ use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 // struct Unused, aligned to 4
 #[repr(transparent)]
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Unused(pub [u8; 4]);
 impl Default for Unused { 
   fn default() -> Self { 
@@ -25,6 +25,16 @@ impl core::fmt::Debug for Unused {
       .finish()
   }
 }
+impl core::cmp::Ord for Unused {
+  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    self.a().cmp(&other.a())
+  }
+}
+impl core::cmp::PartialOrd for Unused {
+  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    Some(self.cmp(other))
+  }
+}
 
 impl flatbuffers::SimpleToVerifyInSlice for Unused {}
 impl<'a> flatbuffers::Follow<'a> for Unused {

tests/include_test2/my_game/other_name_space/unused_generated.rs

@@ -11,7 +11,7 @@ use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 // struct Unused, aligned to 4
 #[repr(transparent)]
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Unused(pub [u8; 4]);
 impl Default for Unused { 
   fn default() -> Self { 
@@ -25,6 +25,16 @@ impl core::fmt::Debug for Unused {
       .finish()
   }
 }
+impl core::cmp::Ord for Unused {
+  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    self.a().cmp(&other.a())
+  }
+}
+impl core::cmp::PartialOrd for Unused {
+  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    Some(self.cmp(other))
+  }
+}
 
 impl flatbuffers::SimpleToVerifyInSlice for Unused {}
 impl<'a> flatbuffers::Follow<'a> for Unused {

tests/monster_test/my_game/example/ability_generated.rs

@@ -11,7 +11,7 @@ use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 // struct Ability, aligned to 4
 #[repr(transparent)]
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Ability(pub [u8; 8]);
 impl Default for Ability { 
   fn default() -> Self { 
@@ -26,6 +26,17 @@ impl core::fmt::Debug for Ability {
       .finish()
   }
 }
+impl core::cmp::Ord for Ability {
+  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    self.id().cmp(&other.id())
+      .then(self.distance().cmp(&other.distance()))
+  }
+}
+impl core::cmp::PartialOrd for Ability {
+  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    Some(self.cmp(other))
+  }
+}
 
 impl flatbuffers::SimpleToVerifyInSlice for Ability {}
 impl<'a> flatbuffers::Follow<'a> for Ability {

tests/monster_test/my_game/example/struct_of_structs_generated.rs

@@ -11,7 +11,7 @@ use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 // struct StructOfStructs, aligned to 4
 #[repr(transparent)]
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct StructOfStructs(pub [u8; 20]);
 impl Default for StructOfStructs { 
   fn default() -> Self { 
@@ -27,6 +27,18 @@ impl core::fmt::Debug for StructOfStructs {
       .finish()
   }
 }
+impl core::cmp::Ord for StructOfStructs {
+  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    self.a().cmp(&other.a())
+      .then(self.b().cmp(&other.b()))
+      .then(self.c().cmp(&other.c()))
+  }
+}
+impl core::cmp::PartialOrd for StructOfStructs {
+  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    Some(self.cmp(other))
+  }
+}
 
 impl flatbuffers::SimpleToVerifyInSlice for StructOfStructs {}
 impl<'a> flatbuffers::Follow<'a> for StructOfStructs {

tests/monster_test/my_game/example/struct_of_structs_of_structs_generated.rs

@@ -11,7 +11,7 @@ use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 // struct StructOfStructsOfStructs, aligned to 4
 #[repr(transparent)]
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct StructOfStructsOfStructs(pub [u8; 20]);
 impl Default for StructOfStructsOfStructs { 
   fn default() -> Self { 
@@ -25,6 +25,16 @@ impl core::fmt::Debug for StructOfStructsOfStructs {
       .finish()
   }
 }
+impl core::cmp::Ord for StructOfStructsOfStructs {
+  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    self.a().cmp(&other.a())
+  }
+}
+impl core::cmp::PartialOrd for StructOfStructsOfStructs {
+  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    Some(self.cmp(other))
+  }
+}
 
 impl flatbuffers::SimpleToVerifyInSlice for StructOfStructsOfStructs {}
 impl<'a> flatbuffers::Follow<'a> for StructOfStructsOfStructs {

tests/monster_test/my_game/example/test_generated.rs

@@ -11,7 +11,7 @@ use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 // struct Test, aligned to 2
 #[repr(transparent)]
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Test(pub [u8; 4]);
 impl Default for Test { 
   fn default() -> Self { 
@@ -26,6 +26,17 @@ impl core::fmt::Debug for Test {
       .finish()
   }
 }
+impl core::cmp::Ord for Test {
+  fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+    self.a().cmp(&other.a())
+      .then(self.b().cmp(&other.b()))
+  }
+}
+impl core::cmp::PartialOrd for Test {
+  fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+    Some(self.cmp(other))
+  }
+}
 
 impl flatbuffers::SimpleToVerifyInSlice for Test {}
 impl<'a> flatbuffers::Follow<'a> for Test {