1 files changed, 108 insertions, 66 deletions

diff --git a/crates/ra_syntax/src/yellow/mod.rs b/crates/ra_syntax/src/yellow/mod.rs
index 0596e702f..c621b1d6a 100644
--- a/crates/ra_syntax/src/yellow/mod.rs
+++ b/crates/ra_syntax/src/yellow/mod.rs
@@ -1,100 +1,142 @@
 mod builder;
-mod green;
-mod red;
-mod syntax;
 mod syntax_text;
 
 use std::{
-    sync::Arc,
-    ptr,
-};
-pub use self::syntax::{SyntaxNode, SyntaxNodeRef, SyntaxError, SyntaxNodeChildren};
-pub(crate) use self::{
-    builder::GreenBuilder,
-    green::GreenNode,
-    red::RedNode,
-    syntax_text::SyntaxText,
+    fmt,
+    hash::{Hash, Hasher},
 };
+use rowan::Types;
+use {SyntaxKind, TextUnit, TextRange, SmolStr};
+use self::syntax_text::SyntaxText;
 
-#[derive(Debug)]
-pub struct SyntaxRoot {
-    red: RedNode,
-    pub(crate) errors: Vec<SyntaxError>,
+pub use rowan::{TreeRoot};
+pub(crate) use self::builder::GreenBuilder;
+
+#[derive(Debug, Clone, Copy)]
+pub enum RaTypes {}
+impl Types for RaTypes {
+    type Kind = SyntaxKind;
+    type RootData = Vec<SyntaxError>;
 }
 
-pub trait TreeRoot: Clone + Send + Sync {
-    fn borrowed(&self) -> RefRoot;
-    fn owned(&self) -> OwnedRoot;
+pub type OwnedRoot = ::rowan::OwnedRoot<RaTypes>;
+pub type RefRoot<'a> = ::rowan::RefRoot<'a, RaTypes>;
+
+pub type GreenNode = ::rowan::GreenNode<RaTypes>;
 
-    #[doc(hidden)]
-    fn syntax_root(&self) -> &SyntaxRoot;
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct SyntaxError {
+    pub msg: String,
+    pub offset: TextUnit,
 }
-#[derive(Clone, Debug)]
-pub struct OwnedRoot(Arc<SyntaxRoot>);
-#[derive(Clone, Copy, Debug)]
-pub struct RefRoot<'a>(&'a OwnedRoot); // TODO: shared_from_this instead of double indirection
 
-impl<'a> RefRoot<'a> {
-    fn syntax_root(&self) -> &'a SyntaxRoot {
-        self.0.syntax_root()
+#[derive(Clone, Copy)]
+pub struct SyntaxNode<R: TreeRoot<RaTypes> = OwnedRoot>(
+    ::rowan::SyntaxNode<RaTypes, R>,
+);
+pub type SyntaxNodeRef<'a> = SyntaxNode<RefRoot<'a>>;
+
+impl<R1, R2> PartialEq<SyntaxNode<R1>> for SyntaxNode<R2>
+where
+    R1: TreeRoot<RaTypes>,
+    R2: TreeRoot<RaTypes>,
+{
+    fn eq(&self, other: &SyntaxNode<R1>) -> bool {
+        self.0 == other.0
     }
 }
 
-impl TreeRoot for OwnedRoot {
-    fn borrowed(&self) -> RefRoot {
-        RefRoot(&self)
-    }
-    fn owned(&self) -> OwnedRoot {
-        self.clone()
+impl<R: TreeRoot<RaTypes>> Eq for SyntaxNode<R> {}
+impl<R: TreeRoot<RaTypes>> Hash for SyntaxNode<R> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.hash(state)
     }
+}
 
-    fn syntax_root(&self) -> &SyntaxRoot {
-        &*self.0
+impl SyntaxNode<OwnedRoot> {
+    pub(crate) fn new(green: GreenNode, errors: Vec<SyntaxError>) -> SyntaxNode {
+        SyntaxNode(::rowan::SyntaxNode::new(green, errors))
+    }
+}
+impl<'a> SyntaxNode<RefRoot<'a>> {
+    pub fn leaf_text(self) -> Option<&'a SmolStr> {
+        self.0.leaf_text()
     }
 }
 
-impl<'a> TreeRoot for RefRoot<'a> {
-    fn borrowed(&self) -> RefRoot {
-        *self
+impl<R: TreeRoot<RaTypes>> SyntaxNode<R> {
+    pub(crate) fn root_data(&self) -> &Vec<SyntaxError> {
+        self.0.root_data()
+    }
+    pub(crate) fn replace_with(&self, replacement: GreenNode) -> GreenNode {
+        self.0.replace_with(replacement)
+    }
+    pub fn borrowed<'a>(&'a self) -> SyntaxNode<RefRoot<'a>> {
+        SyntaxNode(self.0.borrowed())
+    }
+    pub fn owned(&self) -> SyntaxNode<OwnedRoot> {
+        SyntaxNode(self.0.owned())
+    }
+    pub fn kind(&self) -> SyntaxKind {
+        self.0.kind()
     }
-    fn owned(&self) -> OwnedRoot {
-        self.0.clone()
+    pub fn range(&self) -> TextRange {
+        self.0.range()
     }
-    fn syntax_root(&self) -> &SyntaxRoot {
-        self.0.syntax_root()
+    pub fn text(&self) -> SyntaxText {
+        SyntaxText::new(self.borrowed())
+    }
+    pub fn is_leaf(&self) -> bool {
+        self.0.is_leaf()
+    }
+    pub fn parent(&self) -> Option<SyntaxNode<R>> {
+        self.0.parent().map(SyntaxNode)
+    }
+    pub fn first_child(&self) -> Option<SyntaxNode<R>> {
+        self.0.first_child().map(SyntaxNode)
+    }
+    pub fn last_child(&self) -> Option<SyntaxNode<R>> {
+        self.0.last_child().map(SyntaxNode)
+    }
+    pub fn next_sibling(&self) -> Option<SyntaxNode<R>> {
+        self.0.next_sibling().map(SyntaxNode)
+    }
+    pub fn prev_sibling(&self) -> Option<SyntaxNode<R>> {
+        self.0.prev_sibling().map(SyntaxNode)
+    }
+    pub fn children(&self) -> SyntaxNodeChildren<R> {
+        SyntaxNodeChildren(self.0.children())
     }
 }
 
-impl SyntaxRoot {
-    pub(crate) fn new(green: GreenNode, errors: Vec<SyntaxError>) -> SyntaxRoot {
-        SyntaxRoot {
-            red: RedNode::new_root(green),
-            errors,
+impl<R: TreeRoot<RaTypes>> fmt::Debug for SyntaxNode<R> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{:?}@{:?}", self.kind(), self.range())?;
+        if has_short_text(self.kind()) {
+            write!(fmt, " \"{}\"", self.text())?;
         }
+        Ok(())
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
-pub(crate) struct RedPtr(ptr::NonNull<RedNode>);
-
-unsafe impl Send for RedPtr {}
-
-unsafe impl Sync for RedPtr {}
+#[derive(Debug)]
+pub struct SyntaxNodeChildren<R: TreeRoot<RaTypes>>(
+    ::rowan::SyntaxNodeChildren<RaTypes, R>
+);
 
-impl RedPtr {
-    fn new(red: &RedNode) -> RedPtr {
-        RedPtr(red.into())
-    }
+impl<R: TreeRoot<RaTypes>> Iterator for SyntaxNodeChildren<R> {
+    type Item = SyntaxNode<R>;
 
-    unsafe fn get<'a>(self, _root: &'a SyntaxRoot) -> &'a RedNode {
-        &*self.0.as_ptr()
+    fn next(&mut self) -> Option<SyntaxNode<R>> {
+        self.0.next().map(SyntaxNode)
     }
 }
 
-#[test]
-fn assert_send_sync() {
-    fn f<T: Send + Sync>() {}
-    f::<GreenNode>();
-    f::<RedNode>();
-    f::<SyntaxNode>();
+
+fn has_short_text(kind: SyntaxKind) -> bool {
+    use SyntaxKind::*;
+    match kind {
+        IDENT | LIFETIME | INT_NUMBER | FLOAT_NUMBER => true,
+        _ => false,
+    }
 }