Add tests for 'epsilon_static_array!' (FAILS)

New plan: Make GcArray generic over the underlying array
representation.

Author: Techcable

src/epsilon.rs

@@ -26,10 +26,13 @@ use self::{alloc::{EpsilonAlloc}, layout::TypeInfo};
 /// This will never actually be collected
 /// and will always be valid
 #[inline]
-pub fn gc<'gc, T: GcSafe<'gc, EpsilonCollectorId> + 'gc>(ptr: &'gc T) -> Gc<'gc, T> {
-    unsafe {
-        Gc::from_raw(NonNull::from(ptr))
-    }
+pub const fn gc<'gc, T: GcSafe<'gc, EpsilonCollectorId> + 'gc>(ptr: &'gc T) -> Gc<'gc, T> {
+    /*
+     * SAFETY: Epsilon never collects unless explicitly added to
+     * the linked list of allocated objects.
+     * Therefore any reference can be assumed to be a Gc ptr.
+     */
+    unsafe { std::mem::transmute::<&'gc T, crate::Gc<'gc, T, EpsilonCollectorId>>(ptr) }
 }
 
 /// Statically allocate an array of the specified values
@@ -50,7 +53,7 @@ macro_rules! epsilon_static_array {
         };
         std::mem::transmute::<
             &'static ArrayWithHeader<$target, { $len }>,
-            $crate::epsilon::GcArray<'static, $target, $crate::epsilon::EpsilonCollectorId>,
+            $crate::vec::GcArray<'static, $target, $crate::epsilon::EpsilonCollectorId>,
         >(HEADERED)
     }}
 }

src/epsilon/layout.rs

@@ -16,6 +16,12 @@ pub struct EpsilonHeader {
     /// The next allocated object, or `None` if this is the final object.
     pub next: Option<NonNull<EpsilonHeader>>
 }
+/*
+ * We are Send + Sync because once we are allocated
+ * `next` and `type_info` cannot change
+ */
+unsafe impl Send for EpsilonHeader {}
+unsafe impl Sync for EpsilonHeader {}
 impl EpsilonHeader {
     pub const LAYOUT: Layout = Layout::new::<Self>();
     /// Assume the specified object has a header,

tests/epsilon.rs

@@ -1,7 +1,9 @@
+use std::fmt::Debug;
+
 use zerogc_derive::Trace;
 
-use zerogc::{safepoint_recurse, Gc, GcSimpleAlloc};
-use zerogc::epsilon::{EpsilonCollectorId, EpsilonContext, EpsilonSystem};
+use zerogc::{Gc, GcArray, GcContext, GcSimpleAlloc, epsilon_static_array, safepoint_recurse};
+use zerogc::epsilon::{self, EpsilonCollectorId, EpsilonContext, EpsilonSystem};
 
 #[derive(Trace)]
 #[zerogc(collector_ids(EpsilonCollectorId))]
@@ -41,3 +43,29 @@ fn recursive() {
     safepoint_recurse!(ctx, first, |ctx, root| recurse(ctx, 18, root));
 }
 
+#[test]
+fn static_alloc() {
+    fn recurse<'gc, T: ?Sized + PartialEq + Debug>(
+        _ctx: &'gc EpsilonContext,
+        expected: &T,
+        test: Gc<'gc, T, EpsilonCollectorId>
+    ) {
+        assert_eq!(test.value(), expected);
+    } 
+    fn recurse_array<'gc, T: PartialEq + Debug>(
+        _ctx: &'gc EpsilonContext,
+        expected: &[T],
+        test: GcArray<'gc, T, EpsilonCollectorId>
+    ) {
+        assert_eq!(test.as_slice(), expected);
+    } 
+    const BAR: &i32 = &12;
+    let sys = EpsilonSystem::leak();
+    let ctx = sys.new_context();
+    recurse(&ctx, BAR, epsilon::gc(BAR));
+    const FOO: &[u8; 29] = b"Do you wanna build a snowman?";
+    const FOO_LEN: usize = FOO.len();
+    let array: GcArray<'static, u8, EpsilonCollectorId>
+        = epsilon_static_array!([u8; FOO_LEN] => *FOO);
+    recurse_array(&ctx, &*FOO, array);
+}