impl Trace for arrayvec::ArrayVec

Of course this feature is optional :)

Author: Techcable

Cargo.toml

@@ -15,6 +15,7 @@ scopeguard = "1.1"
 # gives zerogc batteries included support.
 indexmap = { version = "1.6", optional = true }
 parking_lot = { version = "0.11", optional = true }
+arrayvec = { version = "0.7", optional = true }
 # Serde support (optional)
 serde = { version = "1", optional = true, features = ["derive"] }
 # Used for macros
@@ -37,7 +38,7 @@ std = ["alloc"]
 # This implements `Trace` for `Box` and collections like `Vec`
 alloc = []
 # Serde support
-serde1 = ["serde", "zerogc-derive/__serde-internal", "indexmap/serde-1"]
+serde1 = ["serde", "zerogc-derive/__serde-internal", "arrayvec/serde", "indexmap/serde-1"]
 # Support the "epsilon" no-op collector
 epsilon = []
 # Configure the "epsilon" collector use arena allocation

src/manually_traced/arrayvec.rs

@@ -0,0 +1,76 @@
+use arrayvec::{ArrayVec, ArrayString};
+
+use crate::{GcRebrand, NullTrace};
+
+use zerogc_derive::unsafe_gc_impl;
+
+unsafe_gc_impl!(
+    target => ArrayString<SIZE>,
+    params => [const SIZE: usize],
+    null_trace => always,
+    NEEDS_TRACE => false,
+    NEEDS_DROP => false,
+    branded_type => ArrayString<SIZE>,
+    trace_template => |self, visitor| { Ok(()) },
+    deserialize => delegate
+);
+
+unsafe_gc_impl!(
+    target => ArrayVec<T, SIZE>,
+    params => [T, const SIZE: usize],
+    null_trace => { where T: NullTrace },
+    NEEDS_TRACE => <T as Trace>::NEEDS_TRACE,
+    NEEDS_DROP => <T as Trace>::NEEDS_DROP,
+    bounds => {
+        GcRebrand => { where T: GcRebrand<'new_gc, Id>, T::Branded: Sized }, 
+    },
+    branded_type => ArrayVec<T::Branded, SIZE>,
+    trace_template => |self, visitor| {
+        for val in self.#iter() {
+            visitor.#trace_func(val)?;
+        }
+        Ok(())
+    },
+    deserialize => |ctx, deserializer| {
+        use core::marker::PhantomData;
+        use crate::{CollectorId, GcSystem};
+        use crate::serde::{GcDeserialize, GcDeserializeSeed};
+        use serde::de::{Visitor, Error, SeqAccess};
+        struct ArrayVecVisitor<
+            'gc, 'de, Id: CollectorId,
+            T: GcDeserialize<'gc, 'de, Id>,
+            const SIZE: usize
+        > {
+            ctx: &'gc <Id::System as GcSystem>::Context,
+            marker: PhantomData<fn(&'de ()) -> ArrayVec<T, SIZE>>
+        }
+        impl<
+            'gc, 'de, Id: CollectorId,
+            T: GcDeserialize<'gc, 'de, Id>,
+            const SIZE: usize
+        > Visitor<'de> for ArrayVecVisitor<'gc, 'de, Id, T, SIZE> {
+            type Value = ArrayVec<T, SIZE>;
+            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(f, "a array with size <= {}", SIZE)
+            }
+            #[inline]
+            fn visit_seq<A>(self, mut access: A) -> Result<Self::Value, A::Error>
+                where A: SeqAccess<'de>, {
+                let mut values = Self::Value::new();
+                while let Some(value) = access.next_element_seed(
+                    GcDeserializeSeed::new(self.ctx)
+                )? {
+                    match values.try_push(value) {
+                        Ok(()) => {},
+                        Err(_) => {
+                            return Err(A::Error::invalid_length(SIZE + 1, &self))
+                        }
+                    }
+                }
+                Ok(values)
+            }
+        }
+        let visitor: ArrayVecVisitor<Id, T, SIZE> = ArrayVecVisitor { ctx, marker: PhantomData };
+        deserializer.deserialize_seq(visitor)      
+    }
+);

src/manually_traced/mod.rs

@@ -136,3 +136,5 @@ mod stdlib;
 mod indexmap;
 #[cfg(feature = "parking_lot")]
 mod parking_lot;
+#[cfg(feature = "arrayvec")]
+mod arrayvec;