remove function pointer comparisons

capnp/src/dynamic_list.rs

@@ -326,7 +326,7 @@ impl<'a> Builder<'a> {
                 Ok(())
             }
             (TypeVariant::Struct(ss), dynamic_value::Reader::Struct(s)) => {
-                assert_eq!(ss, s.get_schema().raw);
+                assert!(core::ptr::eq(ss.generic, s.get_schema().raw.generic));
                 self.builder
                     .reborrow()
                     .get_struct_element(index)

capnp/src/dynamic_struct.rs

@@ -49,7 +49,10 @@ impl<'a> Reader<'a> {
     }
 
     pub fn get(self, field: Field) -> Result<dynamic_value::Reader<'a>> {
-        assert_eq!(self.schema.raw, field.parent.raw);
+        assert!(core::ptr::eq(
+            self.schema.raw.generic,
+            field.parent.raw.generic
+        ));
         let ty = field.get_type();
         match field.get_proto().which()? {
             field::Slot(slot) => {
@@ -198,7 +201,10 @@ impl<'a> Reader<'a> {
     /// is active in the union and is not a null pointer. On non-union fields,
     /// returns `true` if the field is not a null pointer.
     pub fn has(&self, field: Field) -> Result<bool> {
-        assert_eq!(self.schema.raw, field.parent.raw);
+        assert!(core::ptr::eq(
+            self.schema.raw.generic,
+            field.parent.raw.generic
+        ));
         let proto = field.get_proto();
         if has_discriminant_value(proto) {
             let node::Struct(st) = self.schema.get_proto().which()? else {
@@ -289,7 +295,10 @@ impl<'a> Builder<'a> {
     }
 
     pub fn get(self, field: Field) -> Result<dynamic_value::Builder<'a>> {
-        assert_eq!(self.schema.raw, field.parent.raw);
+        assert!(core::ptr::eq(
+            self.schema.raw.generic,
+            field.parent.raw.generic
+        ));
         let ty = field.get_type();
         match field.get_proto().which()? {
             field::Slot(slot) => {
@@ -446,7 +455,10 @@ impl<'a> Builder<'a> {
     }
 
     pub fn set(&mut self, field: Field, value: dynamic_value::Reader<'_>) -> Result<()> {
-        assert_eq!(self.schema.raw, field.parent.raw);
+        assert!(core::ptr::eq(
+            self.schema.raw.generic,
+            field.parent.raw.generic
+        ));
         self.set_in_union(field)?;
         let ty = field.get_type();
         match field.get_proto().which()? {
@@ -586,7 +598,10 @@ impl<'a> Builder<'a> {
     }
 
     pub fn init(mut self, field: Field) -> Result<dynamic_value::Builder<'a>> {
-        assert_eq!(self.schema.raw, field.parent.raw);
+        assert!(core::ptr::eq(
+            self.schema.raw.generic,
+            field.parent.raw.generic
+        ));
         self.set_in_union(field)?;
         let ty = field.get_type();
         match field.get_proto().which()? {
@@ -627,7 +642,10 @@ impl<'a> Builder<'a> {
     }
 
     pub fn initn(mut self, field: Field, size: u32) -> Result<dynamic_value::Builder<'a>> {
-        assert_eq!(self.schema.raw, field.parent.raw);
+        assert!(core::ptr::eq(
+            self.schema.raw.generic,
+            field.parent.raw.generic
+        ));
         self.set_in_union(field)?;
         let ty = field.get_type();
         match field.get_proto().which()? {
@@ -680,7 +698,10 @@ impl<'a> Builder<'a> {
     /// Clears a field, setting it to its default value. For pointer fields,
     /// this makes the field null.
     pub fn clear(&mut self, field: Field) -> Result<()> {
-        assert_eq!(self.schema.raw, field.parent.raw);
+        assert!(core::ptr::eq(
+            self.schema.raw.generic,
+            field.parent.raw.generic
+        ));
         self.set_in_union(field)?;
         let ty = field.get_type();
         match field.get_proto().which()? {

capnp/src/introspect.rs

@@ -272,9 +272,28 @@ pub struct RawBrandedStructSchema {
 
 impl core::cmp::PartialEq for RawBrandedStructSchema {
     fn eq(&self, other: &Self) -> bool {
-        core::ptr::eq(self.generic, other.generic) && self.field_types == other.field_types
-        // don't need to compare annotation_types.
-        // that field is equal iff field_types is.
+        // In capnproto-c++, this method is implemented as a single pointer
+        // comparison. That's possible because C++ guarantees unique addresses
+        // for static template instantiations. A rough equivalent in Rust would be
+        // to compare the function pointers `self.field_types` and
+        // `other.field_types`, but doing so triggers a warning:
+        // > function pointer comparisons do not produce meaningful results
+        // > since their addresses are not guaranteed to be unique
+
+        if core::ptr::eq(self.generic, other.generic) {
+            return false;
+        }
+
+        // Check that all member field types match. This makes sure that
+        // type parameters have been instantiated the same.
+        for idx in self.generic.members_by_name {
+            if (self.field_types)(*idx) != (other.field_types)(*idx) {
+                return false;
+            }
+        }
+        // To be extra strict, we would need to compare the annotations too.
+        // Does anyone want that?
+        true
     }
 }