Integrate gc_arena to aiscript own crates (#18)

* Integrate gc_arena to aiscript own crates

* Cargo clippy --fix

Author: Folyd

Cargo.lock

@@ -3,6 +3,8 @@ members = [
     "aiscript",
     "aiscript-cli",
     "aiscript-lexer",
+    "aiscript-arena",
+    "aiscript-derived",
     "aiscript-directive",
     "aiscript-runtime",
     "aiscript-vm",

Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "aiscript-arena"
+description = "safe, incrementally garbage collected arenas"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+readme.workspace = true
+repository.workspace = true
+
+[features]
+default = ["std"]
+std = []
+tracing = ["dep:tracing"]
+allocator-api2 = ["dep:allocator-api2", "hashbrown?/allocator-api2"]
+
+[dependencies]
+allocator-api2 = { version = "0.2", optional = true, default-features = false, features = [
+    "alloc",
+] }
+aiscript-derived = { path = "../aiscript-derived", version = "0.1.0" }
+hashbrown = { version = "0.14", optional = true, default-features = false }
+sptr = "0.3.2"
+tracing = { version = "0.1.37", optional = true, default-features = false }
+
+[dev-dependencies]
+rand = "0.8"
+trybuild = "1.0"

aiscript-arena/Cargo.toml

@@ -0,0 +1,158 @@
+use std::{alloc::Layout, marker::PhantomData, ptr::NonNull};
+
+use allocator_api2::{
+    alloc::{AllocError, Allocator, Global},
+    boxed, vec,
+};
+
+use crate::{
+    collect::Collect,
+    context::{Collection, Mutation},
+    metrics::Metrics,
+    types::Invariant,
+};
+
+#[derive(Clone)]
+pub struct MetricsAlloc<'gc, A = Global> {
+    metrics: Metrics,
+    allocator: A,
+    _marker: Invariant<'gc>,
+}
+
+impl<'gc> MetricsAlloc<'gc> {
+    #[inline]
+    pub fn new(mc: &Mutation<'gc>) -> Self {
+        Self::new_in(mc, Global)
+    }
+
+    /// `MetricsAlloc` is normally branded with the `'gc` branding lifetime to ensure that it is not
+    /// placed in the wrong arena or used outside of the enclosing arena.
+    ///
+    /// This is actually completely artificial and only used as a lint: `aiscript_arena::metrics::Metrics`
+    /// has no lifetime at all. Therefore, we can safely provide a method that returns a
+    /// `MetricsAlloc` with an arbitrary lifetime.
+    ///
+    /// NOTE: Use `MetricsAlloc::new` if at all possible, because it is harder to misuse.
+    #[inline]
+    pub fn from_metrics(metrics: Metrics) -> Self {
+        Self::from_metrics_in(metrics, Global)
+    }
+}
+
+impl<'gc, A> MetricsAlloc<'gc, A> {
+    #[inline]
+    pub fn new_in(mc: &Mutation<'gc>, allocator: A) -> Self {
+        Self {
+            metrics: mc.metrics().clone(),
+            allocator,
+            _marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub fn from_metrics_in(metrics: Metrics, allocator: A) -> Self {
+        Self {
+            metrics,
+            allocator,
+            _marker: PhantomData,
+        }
+    }
+}
+
+unsafe impl<A: Allocator> Allocator for MetricsAlloc<'_, A> {
+    #[inline]
+    fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+        let ptr = self.allocator.allocate(layout)?;
+        self.metrics.mark_external_allocation(layout.size());
+        Ok(ptr)
+    }
+
+    #[inline]
+    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) { unsafe {
+        self.metrics.mark_external_deallocation(layout.size());
+        self.allocator.deallocate(ptr, layout);
+    }}
+
+    #[inline]
+    fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+        let ptr = self.allocator.allocate_zeroed(layout)?;
+        self.metrics.mark_external_allocation(layout.size());
+        Ok(ptr)
+    }
+
+    #[inline]
+    unsafe fn grow(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+    ) -> Result<NonNull<[u8]>, AllocError> { unsafe {
+        let ptr = self.allocator.grow(ptr, old_layout, new_layout)?;
+        self.metrics
+            .mark_external_allocation(new_layout.size() - old_layout.size());
+        Ok(ptr)
+    }}
+
+    #[inline]
+    unsafe fn grow_zeroed(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+    ) -> Result<NonNull<[u8]>, AllocError> { unsafe {
+        let ptr = self.allocator.grow_zeroed(ptr, old_layout, new_layout)?;
+        self.metrics
+            .mark_external_allocation(new_layout.size() - old_layout.size());
+        Ok(ptr)
+    }}
+
+    #[inline]
+    unsafe fn shrink(
+        &self,
+        ptr: NonNull<u8>,
+        old_layout: Layout,
+        new_layout: Layout,
+    ) -> Result<NonNull<[u8]>, AllocError> { unsafe {
+        let ptr = self.allocator.shrink(ptr, old_layout, new_layout)?;
+        self.metrics
+            .mark_external_deallocation(old_layout.size() - new_layout.size());
+        Ok(ptr)
+    }}
+}
+
+unsafe impl<A: 'static> Collect for MetricsAlloc<'_, A> {
+    #[inline]
+    fn needs_trace() -> bool {
+        false
+    }
+}
+
+unsafe impl Collect for Global {
+    #[inline]
+    fn needs_trace() -> bool {
+        false
+    }
+}
+
+unsafe impl<T: Collect + ?Sized, A: Collect + Allocator> Collect for boxed::Box<T, A> {
+    #[inline]
+    fn trace(&self, cc: &Collection) {
+        boxed::Box::allocator(self).trace(cc);
+        (**self).trace(cc)
+    }
+}
+
+unsafe impl<T: Collect, A: Collect + Allocator> Collect for vec::Vec<T, A> {
+    #[inline]
+    fn needs_trace() -> bool {
+        T::needs_trace() || A::needs_trace()
+    }
+
+    #[inline]
+    fn trace(&self, cc: &Collection) {
+        self.allocator().trace(cc);
+        for v in self {
+            v.trace(cc);
+        }
+    }
+}