Remove that whole ~const bound thing

Definitely not worth it.

Author: Techcable

libs/context/src/collector.rs

@@ -336,12 +336,6 @@ unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
         &*(self as *const CollectorId<C> as *const CollectorRef<C>)
     }
 }
-unsafe impl<C: ~const ConstRawCollectorImpl> const zerogc::internals::ConstCollectorId for CollectorId<C> {
-    #[inline]
-    fn resolve_array_len_const<T>(repr: &GcArray<'_, T, CollectorId<C>>) -> usize {
-        C::resolve_array_len_const(repr)
-    }
-}
 zerogc::impl_nulltrace_for_static!(CollectorId<C>, params => [C: RawCollectorImpl]);
 
 pub struct WeakCollectorRef<C: RawCollectorImpl> {

libs/context/src/lib.rs

@@ -2,7 +2,6 @@
     negative_impls, // !Send is much cleaner than `PhantomData<Rc>`
     untagged_unions, // I want to avoid ManuallyDrop in unions
     generic_associated_types, // Finally!
-    const_trait_impl,
     ptr_metadata
 )]
 #![allow(

src/array.rs

@@ -8,7 +8,7 @@ use core::fmt::{self, Formatter, Debug, Display};
 use core::hash::{Hash, Hasher};
 use core::marker::PhantomData;
 
-use crate::{CollectorId, internals::ConstCollectorId, GcSafe, GcRebrand, Gc};
+use crate::{CollectorId, GcSafe, GcRebrand, Gc};
 use zerogc_derive::{Trace, unsafe_gc_impl};
 
 use self::repr::{GcArrayPtr};
@@ -64,29 +64,6 @@ impl<'gc, Id: CollectorId> GcString<'gc, Id> {
         unsafe { str::from_utf8_unchecked(self.as_bytes().as_slice()) }
     }
 }
-/// Const access to [GcString]
-pub trait ConstStringAccess<'gc> {
-    /// Get this string as a slice of bytes
-    fn as_bytes_const(&self) -> &'gc [u8];
-    /// Convert this string to a `str` slice
-    fn as_str_const(&self) -> &'gc str;
-    /// Get the length of this string (in bytes)
-    fn len_const(&self) -> usize;
-}
-impl<'gc, Id: ~const ConstCollectorId> const ConstStringAccess<'gc> for GcString<'gc, Id> {
-    #[inline]
-    fn as_bytes_const(&self) -> &'gc [u8] {
-        self.bytes.as_slice_const()
-    }
-    #[inline]
-    fn as_str_const(&self) -> &'gc str {
-        unsafe { str::from_utf8_unchecked(self.as_bytes_const()) }
-    }
-    #[inline]
-    fn len_const(&self) -> usize {
-        self.bytes.len_const()
-    }
-}
 impl<'gc, Id: CollectorId> Deref for GcString<'gc, Id> {
     type Target = str;
     #[inline]
@@ -180,59 +157,6 @@ unsafe impl<'gc, T, Id> Sync for GcArray<'gc, T, Id>
     where T: Sync, Id: CollectorId + Sync {}
 unsafe impl<'gc, T, Id> Send for GcArray<'gc, T, Id>
     where T: Sync, Id: CollectorId + Sync {}
-/// Const access to [GcString]
-pub trait ConstArrayAccess<'gc, T> {
-    /// The value of the array as a slice
-    fn as_slice_const<'a>(&self) -> &'a [T] where 'gc: 'a;
-    /// Load a raw pointer to the array's value
-    fn as_raw_ptr_const(&self) -> *mut T;
-    /// The length of this array
-    fn len_const(&self) -> usize;
-}
-// Relax T: GcSafe bound
-impl<'gc, T, Id: ~const ConstCollectorId> const ConstArrayAccess<'gc, T> for GcArray<'gc, T, Id> {
-    #[inline]
-    fn as_slice_const<'a>(&self) -> &'a [T] where 'gc: 'a {
-        /*
-         * TODO: This is horrible, but currently nessicarry
-         * to do this in a const-fn context.
-         */
-        match Id::ArrayPtr::UNCHECKED_KIND {
-            repr::ArrayPtrKind::Fat => {
-                unsafe {
-                    core::mem::transmute_copy::<
-                        Id::ArrayPtr,
-                        &'a [T]
-                    >(&self.ptr)
-                }
-            },
-            repr::ArrayPtrKind::Thin => {
-                unsafe {
-                    let ptr = core::mem::transmute_copy::<
-                        Id::ArrayPtr,
-                        NonNull<T>
-                    >(&self.ptr);
-                    &*core::ptr::slice_from_raw_parts(
-                        ptr.as_ptr(),
-                        Id::resolve_array_len_const(
-                            self
-                        )
-                    )
-                }
-            },
-        }
-    }
-    /// Load a raw pointer to the array's value
-    #[inline]
-    fn as_raw_ptr_const(&self) -> *mut T {
-        self.as_slice_const().as_ptr() as *mut T
-    }
-    /// Load the length of the array
-    #[inline]
-    fn len_const(&self) -> usize {
-        self.as_slice_const().len()
-    }
-}
 impl<'gc, T, I, Id: CollectorId> Index<I> for GcArray<'gc, T, Id>
     where I: SliceIndex<[T]> {
     type Output = I::Output;

src/epsilon.rs

@@ -13,7 +13,7 @@ mod alloc;
 mod handle;
 
 
-use crate::{CollectorId, GcContext, GcSafe, GcSimpleAlloc, GcSystem, Trace, internals::ConstCollectorId};
+use crate::{CollectorId, GcContext, GcSafe, GcSimpleAlloc, GcSystem, Trace};
 use std::ptr::NonNull;
 use std::alloc::Layout;
 use std::rc::Rc;
@@ -382,12 +382,6 @@ pub struct EpsilonCollectorId {
     _priv: ()
 }
 crate::impl_nulltrace_for_static!(EpsilonCollectorId);
-unsafe impl const ConstCollectorId for EpsilonCollectorId {
-    #[inline]
-    fn resolve_array_len_const<T>(repr: &GcArray<'_, T>) -> usize {
-        unsafe { repr.as_internal_ptr_repr() }.len()
-    }
-}
 unsafe impl CollectorId for EpsilonCollectorId {
     type System = EpsilonSystem;
     type Context = EpsilonContext;

src/internals.rs

@@ -10,7 +10,6 @@
     alloc_layout_extra,
     const_mut_refs,
     const_option,
-    const_trait_impl, // EXPERIMENTAL: const Deref
     const_slice_from_raw_parts,
     const_transmute_copy,
     slice_range, // Convenient for bounds checking :)
@@ -78,7 +77,6 @@ pub mod prelude;
 pub mod epsilon;
 pub mod array;
 pub mod vec;
-pub mod internals;
 #[cfg(feature = "errors")]
 pub mod errors;
 #[cfg(feature = "allocator-api")]
@@ -675,7 +673,7 @@ pub unsafe trait CollectorId: Copy + Eq + Hash + Debug + NullTrace + TrustedDrop
     type RawVec<'gc, T: GcSafe<'gc, Self>>: crate::vec::raw::GcRawVec<'gc, T, Id=Self>;
     /// The raw representation of `GcArray` pointers
     /// in this collector.
-    type ArrayPtr: ~const crate::array::repr::GcArrayPtr<Id=Self>;
+    type ArrayPtr: crate::array::repr::GcArrayPtr<Id=Self>;
 
     /// Get the runtime id of the collector that allocated the [Gc]
     ///
@@ -869,7 +867,7 @@ unsafe impl<'gc, T: ?Sized + GcSafe<'gc, Id>, Id: CollectorId> Trace for Gc<'gc,
         }
     }
 }
-impl<'gc, T: GcSafe<'gc, Id> + ?Sized, Id: CollectorId> const Deref for Gc<'gc, T, Id> {
+impl<'gc, T: GcSafe<'gc, Id> + ?Sized, Id: CollectorId> Deref for Gc<'gc, T, Id> {
     type Target = T;
 
     #[inline(always)]

src/lib.rs

@@ -1,12 +1,10 @@
-#![feature(const_trait_impl)]
 use std::fmt::Debug;
 
 use zerogc_derive::Trace;
 
 use zerogc::{
     Gc, GcArray, GcSimpleAlloc, safepoint_recurse,
 };
-use zerogc::array::ConstArrayAccess;
 use zerogc::epsilon::{self, EpsilonCollectorId, EpsilonContext, EpsilonSystem};
 
 #[derive(Trace)]
@@ -73,11 +71,5 @@ fn static_alloc() {
     recurse_array(&ctx, &*FOO, array);
 }
 
-pub const fn const_gc<'gc, T: 'gc>(gc: Gc<'gc, T, EpsilonCollectorId>) {
-    gc.value();
-}
 
-pub const fn const_array<'gc, T: 'gc>(gc: GcArray<'gc, T, EpsilonCollectorId>) {
-    gc.as_slice_const();
-}