Fix semantic merge conflict between session serde and foreign encodings

vortex-array/src/array/foreign.rs

@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
 use std::fmt;
+use std::fmt::Display;
 use std::fmt::Formatter;
 use std::hash::Hash;
 use std::hash::Hasher;
@@ -40,6 +41,12 @@ impl ForeignArrayData {
     }
 }
 
+impl Display for ForeignArrayData {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "ForeignArrayData({}B)", self.metadata.len())
+    }
+}
+
 impl ArrayHash for ForeignArrayData {
     fn array_hash<H: Hasher>(&self, state: &mut H, precision: crate::Precision) {
         self.metadata.hash(state);
@@ -112,14 +119,13 @@ impl VTable for ForeignArray {
         Some(format!("buffer[{idx}]"))
     }
 
-    fn serialize(array: ArrayView<'_, Self>) -> VortexResult<Option<Vec<u8>>> {
+    fn serialize(
+        array: ArrayView<'_, Self>,
+        _session: &VortexSession,
+    ) -> VortexResult<Option<Vec<u8>>> {
         Ok(Some(array.metadata.clone()))
     }
 
-    fn fmt_metadata(array: ArrayView<'_, Self>, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "ForeignMetadata({}B)", array.metadata.len())
-    }
-
     fn deserialize(
         &self,
         dtype: &DType,

vortex-array/src/serde.rs

@@ -704,6 +704,8 @@ impl TryFrom<BufferHandle> for SerializedArray {
 
 #[cfg(test)]
 mod tests {
+    use std::sync::LazyLock;
+
     use flatbuffers::FlatBufferBuilder;
     use vortex_session::VortexSession;
     use vortex_session::registry::ReadContext;
@@ -717,6 +719,8 @@ mod tests {
     use crate::flatbuffers as fba;
     use crate::session::ArraySession;
 
+    static SESSION: LazyLock<VortexSession> = LazyLock::new(VortexSession::empty);
+
     #[test]
     fn unknown_array_encoding_allow_unknown() {
         let mut fbb = FlatBufferBuilder::new();
@@ -774,14 +778,23 @@ mod tests {
             decoded.nth_child(0).unwrap().encoding_id().as_ref(),
             "vortex.test.foreign_child"
         );
-        assert_eq!(decoded.metadata().unwrap().unwrap(), vec![1, 2, 3]);
+        assert_eq!(decoded.metadata(&SESSION).unwrap().unwrap(), vec![1, 2, 3]);
         assert_eq!(
-            decoded.nth_child(0).unwrap().metadata().unwrap().unwrap(),
+            decoded
+                .nth_child(0)
+                .unwrap()
+                .metadata(&SESSION)
+                .unwrap()
+                .unwrap(),
             vec![9]
         );
 
         let serialized = decoded
-            .serialize(&ArrayContext::default(), &SerializeOptions::default())
+            .serialize(
+                &ArrayContext::default(),
+                &SESSION,
+                &SerializeOptions::default(),
+            )
             .unwrap();
         assert!(!serialized.is_empty());
     }