Prepare to store offset_in_parent in green nodes

Author: matklad

Cargo.toml

@@ -8,9 +8,7 @@ description = "Library for generic lossless syntax trees"
 edition = "2018"
 
 [dependencies]
-erasable = "1.2.1"
 rustc-hash = "1.0.1"
-slice-dst = "1.4.1"
 smol_str = "0.1.10"
 text-size = "1.0.0"
 triomphe = "0.1.1"

src/green.rs

@@ -3,8 +3,8 @@ mod token;
 mod element;
 mod builder;
 
+use self::element::GreenElement;
 pub(crate) use self::element::GreenElementRef;
-use self::element::{GreenElement, PackedGreenElement};
 
 pub use self::{
     builder::{Checkpoint, GreenNodeBuilder, NodeCache},
@@ -26,7 +26,6 @@ mod tests {
         f::<GreenNode>();
         f::<GreenToken>();
         f::<GreenElement>();
-        f::<PackedGreenElement>();
     }
 
     #[test]
@@ -36,6 +35,5 @@ mod tests {
         eprintln!("GreenNode          {}", size_of::<GreenNode>());
         eprintln!("GreenToken         {}", size_of::<GreenToken>());
         eprintln!("GreenElement       {}", size_of::<GreenElement>());
-        eprintln!("PackedGreenElement {}", size_of::<PackedGreenElement>());
     }
 }

src/green/element.rs

@@ -1,7 +1,3 @@
-use std::{fmt, hash, mem};
-
-use erasable::ErasedPtr;
-
 use crate::{
     green::{GreenNode, GreenToken, SyntaxKind},
     NodeOrToken, TextSize,
@@ -10,11 +6,6 @@ use crate::{
 pub(super) type GreenElement = NodeOrToken<GreenNode, GreenToken>;
 pub(crate) type GreenElementRef<'a> = NodeOrToken<&'a GreenNode, &'a GreenToken>;
 
-#[repr(transparent)]
-pub(super) struct PackedGreenElement {
-    ptr: ErasedPtr,
-}
-
 impl From<GreenNode> for GreenElement {
     #[inline]
     fn from(node: GreenNode) -> GreenElement {
@@ -29,13 +20,6 @@ impl<'a> From<&'a GreenNode> for GreenElementRef<'a> {
     }
 }
 
-impl From<GreenNode> for PackedGreenElement {
-    #[inline]
-    fn from(node: GreenNode) -> PackedGreenElement {
-        unsafe { mem::transmute(node) }
-    }
-}
-
 impl From<GreenToken> for GreenElement {
     #[inline]
     fn from(token: GreenToken) -> GreenElement {
@@ -50,13 +34,6 @@ impl<'a> From<&'a GreenToken> for GreenElementRef<'a> {
     }
 }
 
-impl From<GreenToken> for PackedGreenElement {
-    #[inline]
-    fn from(token: GreenToken) -> PackedGreenElement {
-        unsafe { mem::transmute(token) }
-    }
-}
-
 impl GreenElement {
     /// Returns kind of this element.
     #[inline]
@@ -90,121 +67,3 @@ impl GreenElementRef<'_> {
         }
     }
 }
-
-impl From<GreenElement> for PackedGreenElement {
-    fn from(element: GreenElement) -> Self {
-        match element {
-            NodeOrToken::Node(node) => node.into(),
-            NodeOrToken::Token(token) => token.into(),
-        }
-    }
-}
-
-impl From<PackedGreenElement> for GreenElement {
-    fn from(element: PackedGreenElement) -> Self {
-        if element.is_node() {
-            NodeOrToken::Node(element.into_node().unwrap())
-        } else {
-            NodeOrToken::Token(element.into_token().unwrap())
-        }
-    }
-}
-
-impl PackedGreenElement {
-    fn is_node(&self) -> bool {
-        self.ptr.as_ptr() as usize & 1 == 0
-    }
-
-    pub(crate) fn as_node(&self) -> Option<&GreenNode> {
-        if self.is_node() {
-            unsafe { Some(&*(&self.ptr as *const ErasedPtr as *const GreenNode)) }
-        } else {
-            None
-        }
-    }
-
-    pub(crate) fn into_node(self) -> Option<GreenNode> {
-        if self.is_node() {
-            unsafe { Some(mem::transmute(self)) }
-        } else {
-            None
-        }
-    }
-
-    pub(crate) fn as_token(&self) -> Option<&GreenToken> {
-        if !self.is_node() {
-            unsafe { Some(&*(&self.ptr as *const ErasedPtr as *const GreenToken)) }
-        } else {
-            None
-        }
-    }
-
-    pub(crate) fn into_token(self) -> Option<GreenToken> {
-        if !self.is_node() {
-            unsafe { Some(mem::transmute(self)) }
-        } else {
-            None
-        }
-    }
-
-    pub(crate) fn as_ref(&self) -> GreenElementRef<'_> {
-        if self.is_node() {
-            NodeOrToken::Node(self.as_node().unwrap())
-        } else {
-            NodeOrToken::Token(self.as_token().unwrap())
-        }
-    }
-}
-
-impl fmt::Debug for PackedGreenElement {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.is_node() {
-            self.as_node().unwrap().fmt(f)
-        } else {
-            self.as_token().unwrap().fmt(f)
-        }
-    }
-}
-
-impl Eq for PackedGreenElement {}
-impl PartialEq for PackedGreenElement {
-    fn eq(&self, other: &Self) -> bool {
-        self.as_node() == other.as_node() && self.as_token() == other.as_token()
-    }
-}
-
-impl hash::Hash for PackedGreenElement {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: hash::Hasher,
-    {
-        if self.is_node() {
-            self.as_node().unwrap().hash(state)
-        } else {
-            self.as_token().unwrap().hash(state)
-        }
-    }
-}
-
-impl Drop for PackedGreenElement {
-    fn drop(&mut self) {
-        if self.is_node() {
-            PackedGreenElement { ptr: self.ptr }.into_node();
-        } else {
-            PackedGreenElement { ptr: self.ptr }.into_token();
-        }
-    }
-}
-
-unsafe impl Send for PackedGreenElement
-where
-    GreenToken: Send,
-    GreenNode: Send,
-{
-}
-unsafe impl Sync for PackedGreenElement
-where
-    GreenToken: Sync,
-    GreenNode: Sync,
-{
-}

src/green/node.rs

@@ -1,14 +1,12 @@
-use std::{iter::FusedIterator, mem, slice, sync::Arc};
+use std::{ffi::c_void, fmt, iter::FusedIterator, mem, slice};
 
-use erasable::Thin;
-use slice_dst::SliceWithHeader;
+use triomphe::{Arc, ThinArc};
 
 use crate::{
-    green::{GreenElement, GreenElementRef, PackedGreenElement, SyntaxKind},
-    GreenToken, TextSize,
+    green::{GreenElement, GreenElementRef, SyntaxKind},
+    GreenToken, NodeOrToken, TextSize,
 };
 
-#[repr(align(2))] // NB: this is an at-least annotation
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(super) struct GreenNodeHead {
     kind: SyntaxKind,
@@ -17,23 +15,51 @@ pub(super) struct GreenNodeHead {
 
 /// Internal node in the immutable tree.
 /// It has other nodes and tokens as children.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[repr(transparent)]
+#[derive(Clone, PartialEq, Eq, Hash)]
 pub struct GreenNode {
-    pub(super) data: Thin<Arc<SliceWithHeader<GreenNodeHead, PackedGreenElement>>>,
+    data: ThinArc<GreenNodeHead, GreenChild>,
+}
+
+impl fmt::Debug for GreenNode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("GreenNode")
+            .field("kind", &self.kind())
+            .field("text_len", &self.text_len())
+            .field("n_children", &self.children().len())
+            .finish()
+    }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 enum GreenChild {
     Node {
         // offset: TextSize,
-        node: GreenNode
+        node: GreenNode,
     },
     Token {
         // offset: TextSize,
-        token: GreenToken
+        token: GreenToken,
     },
 }
 
+impl From<GreenElement> for GreenChild {
+    fn from(e: GreenElement) -> Self {
+        match e {
+            NodeOrToken::Node(node) => GreenChild::Node { node },
+            NodeOrToken::Token(token) => GreenChild::Token { token },
+        }
+    }
+}
+
+impl GreenChild {
+    fn as_ref(&self) -> GreenElementRef {
+        match self {
+            GreenChild::Node { node } => NodeOrToken::Node(node),
+            GreenChild::Token { token } => NodeOrToken::Token(token),
+        }
+    }
+}
+
 #[cfg(target_pointer_width = "64")]
 const _: () = {
     let cond = mem::size_of::<GreenChild>() == mem::size_of::<usize>() * 2;
@@ -49,30 +75,33 @@ impl GreenNode {
         I::IntoIter: ExactSizeIterator,
     {
         let mut text_len: TextSize = 0.into();
-        let children = children
-            .into_iter()
-            .inspect(|it| text_len += it.text_len())
-            .map(PackedGreenElement::from);
-        let mut data: Arc<_> =
-            SliceWithHeader::new(GreenNodeHead { kind, text_len: 0.into() }, children);
+        let children =
+            children.into_iter().inspect(|it| text_len += it.text_len()).map(GreenChild::from);
+
+        let data =
+            ThinArc::from_header_and_iter(GreenNodeHead { kind, text_len: 0.into() }, children);
 
         // XXX: fixup `text_len` after construction, because we can't iterate
         // `children` twice.
-        Arc::get_mut(&mut data).unwrap().header.text_len = text_len;
+        let data = {
+            let mut data = Arc::from_thin(data);
+            Arc::get_mut(&mut data).unwrap().header.header.text_len = text_len;
+            Arc::into_thin(data)
+        };
 
-        GreenNode { data: data.into() }
+        GreenNode { data }
     }
 
     /// Kind of this node.
     #[inline]
     pub fn kind(&self) -> SyntaxKind {
-        self.data.header.kind
+        self.data.header.header.kind
     }
 
     /// Returns the length of the text covered by this node.
     #[inline]
     pub fn text_len(&self) -> TextSize {
-        self.data.header.text_len
+        self.data.header.header.text_len
     }
 
     /// Children of this node.
@@ -81,15 +110,14 @@ impl GreenNode {
         Children { inner: self.data.slice.iter() }
     }
 
-    pub(crate) fn ptr(&self) -> *const u8 {
-        let r: &SliceWithHeader<_, _> = &*self.data;
-        r as *const _ as _
+    pub fn ptr(&self) -> *const c_void {
+        self.data.heap_ptr()
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct Children<'a> {
-    inner: slice::Iter<'a, PackedGreenElement>,
+    inner: slice::Iter<'a, GreenChild>,
 }
 
 // NB: forward everything stable that iter::Slice specializes as of Rust 1.39.0
@@ -105,7 +133,7 @@ impl<'a> Iterator for Children<'a> {
 
     #[inline]
     fn next(&mut self) -> Option<GreenElementRef<'a>> {
-        self.inner.next().map(PackedGreenElement::as_ref)
+        self.inner.next().map(GreenChild::as_ref)
     }
 
     #[inline]
@@ -123,7 +151,7 @@ impl<'a> Iterator for Children<'a> {
 
     #[inline]
     fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        self.inner.nth(n).map(PackedGreenElement::as_ref)
+        self.inner.nth(n).map(GreenChild::as_ref)
     }
 
     #[inline]
@@ -150,12 +178,12 @@ impl<'a> Iterator for Children<'a> {
 impl<'a> DoubleEndedIterator for Children<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
-        self.inner.next_back().map(PackedGreenElement::as_ref)
+        self.inner.next_back().map(GreenChild::as_ref)
     }
 
     #[inline]
     fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
-        self.inner.nth_back(n).map(PackedGreenElement::as_ref)
+        self.inner.nth_back(n).map(GreenChild::as_ref)
     }
 
     #[inline]