feat: add GCell and Orphan types. [no ci]

crates/oxc_ast/src/traverse/cell.rs

@@ -0,0 +1,156 @@
+//! Cell type and token for traversing AST.
+//!
+//! Based on `GhostCell`.
+//! All method implementations copied verbatim from original version by paper's authors
+//! https://gitlab.mpi-sws.org/FP/ghostcell/-/blob/master/ghostcell/src/lib.rs
+//! and `ghost_cell` crate https://docs.rs/ghost-cell .
+//!
+//! Only difference is that instead of using a lifetime to constrain the life of access tokens,
+//! here we provide only an unsafe method `Token::new_unchecked` and the user must maintain
+//! the invariant that only one token may be "in play" at same time
+//! (see below for exactly what "in play" means).
+//!
+//! This alteration removes a lifetime, and avoids the unergonomic pattern of all the code that
+//! works with a structure containing `GCell`s needing to be within a single closure.
+
+use std::cell::UnsafeCell;
+
+/// Access token for traversing AST.
+#[repr(transparent)]
+pub struct Token(());
+
+impl Token {
+    /// Create new access token for traversing AST.
+    ///
+    /// It is imperative that any code operating on a single AST does not have access to more
+    /// than 1 token. `GCell` uses this guarantee to make it impossible to obtain a `&mut`
+    /// reference to any AST node while another reference exists. If more than 1 token is "in play",
+    /// this guarantee can be broken, and may lead to undefined behavior.
+    ///
+    /// This function is used internally by `transform`, but probably should not be used elsewhere.
+    ///
+    /// It is permissable to create multiple tokens which are never used together on the same AST.
+    /// In practice, this means it is possible to transform multiple ASTs on different threads
+    /// simultaneously.
+    ///
+    /// If operating on multiple ASTs together (e.g. concatenating 2 files), then a single token
+    /// must be used to access all the ASTs involved in the operation NOT 1 token per AST.
+    ///
+    /// # SAFETY
+    /// Caller must ensure only a single token is used with any AST at one time.
+    #[inline]
+    pub unsafe fn new_unchecked() -> Self {
+        Self(())
+    }
+}
+
+/// A cell type providing interior mutability, with aliasing rules enforced at compile time.
+#[repr(transparent)]
+pub struct GCell<T: ?Sized> {
+    value: UnsafeCell<T>,
+}
+
+#[allow(dead_code)]
+impl<T> GCell<T> {
+    pub const fn new(value: T) -> Self {
+        GCell {
+            value: UnsafeCell::new(value),
+        }
+    }
+
+    pub fn into_inner(self) -> T {
+        self.value.into_inner()
+    }
+}
+
+#[allow(dead_code, unused_variables)]
+impl<T: ?Sized> GCell<T> {
+    #[inline]
+    pub fn borrow<'a>(&'a self, tk: &'a Token) -> &'a T {
+        unsafe { &*self.value.get() }
+    }
+
+    #[inline]
+    pub fn borrow_mut<'a>(&'a self, tk: &'a mut Token) -> &'a mut T {
+        unsafe { &mut *self.value.get() }
+    }
+
+    #[inline]
+    pub const fn as_ptr(&self) -> *mut T {
+        self.value.get()
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.value.get() }
+    }
+
+    #[inline]
+    pub fn from_mut(t: &mut T) -> &mut Self {
+        unsafe { &mut *(t as *mut T as *mut Self) }
+    }
+}
+
+#[allow(dead_code)]
+impl<T> GCell<[T]> {
+    #[inline]
+    pub fn as_slice_of_cells(&self) -> &[GCell<T>] {
+        unsafe { &*(self as *const GCell<[T]> as *const [GCell<T>]) }
+    }
+}
+
+#[allow(dead_code)]
+impl<T> GCell<T> {
+    #[inline]
+    pub fn replace(&self, value: T, tk: &mut Token) -> T {
+        std::mem::replace(self.borrow_mut(tk), value)
+    }
+
+    #[inline]
+    pub fn take(&self, tk: &mut Token) -> T
+    where
+        T: Default,
+    {
+        self.replace(T::default(), tk)
+    }
+}
+
+#[allow(dead_code)]
+impl<T: Clone> GCell<T> {
+    #[inline]
+    pub fn clone(&self, tk: &Token) -> Self {
+        GCell::new(self.borrow(tk).clone())
+    }
+}
+
+impl<T: Default> Default for GCell<T> {
+    #[inline]
+    fn default() -> Self {
+        Self::new(T::default())
+    }
+}
+
+impl<T: ?Sized> AsMut<T> for GCell<T> {
+    #[inline]
+    fn as_mut(&mut self) -> &mut T {
+        self.get_mut()
+    }
+}
+
+impl<T> From<T> for GCell<T> {
+    fn from(t: T) -> Self {
+        GCell::new(t)
+    }
+}
+
+// SAFETY: `GhostCell` is `Send` + `Sync`, so `GCell` can be too
+unsafe impl<T: ?Sized + Send> Send for GCell<T> {}
+unsafe impl<T: ?Sized + Send + Sync> Sync for GCell<T> {}
+
+/// Type alias for a shared ref to a `GCell`.
+/// This is the interior-mutable equivalent to `oxc_allocator::Box`.
+pub type SharedBox<'a, T> = &'a GCell<T>;
+
+/// Type alias for a shared Vec
+pub type SharedVec<'a, T> = oxc_allocator::Vec<'a, GCell<T>>;
+

crates/oxc_ast/src/traverse/mod.rs

@@ -1,5 +1,10 @@
+mod cell;
+mod orphan;
+
+pub use orphan::Orphan;
+
 /// This trait is only for checking that we didn't forgot to add `ast_node` attribute to any
-/// essential types, Would get removed after cleaning things up.
+/// of essential types, Would get removed after cleaning things up.
 pub trait TraversableTest {
     fn does_support_traversable() {
         // Yes, Yes it does my friend!

crates/oxc_ast/src/traverse/orphan.rs

@@ -0,0 +1,38 @@
+use std::ops::Deref;
+
+/// Wrapper for AST nodes which have been disconnected from the AST.
+///
+/// This type is central to preventing a node from being attached to the AST in multiple places.
+///
+/// `Orphan` cannot be `Copy` or `Clone`, or it would allow creating a duplicate ref to the
+/// contained node. The original `Orphan` could be attached to the AST, and then the copy
+/// could also be attached to the AST elsewhere.
+#[repr(transparent)]
+pub struct Orphan<T>(T);
+
+impl<T> Orphan<T> {
+    /// Wrap node to indicate it's disconnected from AST.
+    /// SAFETY: Caller must ensure that `node` is not attached to the AST.
+    #[inline]
+    pub unsafe fn new(node: T) -> Self {
+        Self(node)
+    }
+
+    /// Unwrap node from `Orphan<T>`.
+    /// This should only be done before inserting it into the AST.
+    /// Not unsafe as there is nothing bad you can do with an un-orphaned AST node.
+    /// No APIs are provided to attach nodes to the AST, unless they're wrapped in `Orphan<T>`.
+    #[inline]
+    pub fn inner(self) -> T {
+        self.0
+    }
+}
+
+impl<T> Deref for Orphan<T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &T {
+        &self.0
+    }
+}

crates/oxc_macros/src/ast_node.rs

@@ -35,8 +35,9 @@ fn modify_enum(item: &mut ItemEnum) -> NodeData {
 }
 
 fn validate_struct_attributes<'a>(mut attrs: slice::Iter<'a, Attribute>) {
-    // make sure that no structure derives Clone/Copy trait.
-    // TODO: It might fail if there is a manual Clone/Copy trait implemented for the struct.
+    // make sure that no structure derives Clone/Copy traits.
+    // TODO: It will fail if there is a manual Clone/Copy traits implemented for the struct.
+    // Negative traits (!Copy and !Clone) are nightly so I'm not sure how we can fully enforce it.
     assert!(!attrs.any(|attr| {
         let args = attr.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated);
         attr.path().is_ident("derive")