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();
-}