Merge #85

85: start moving syntax tree to a separate crate r=matklad a=matklad

WIP

Co-authored-by: Aleksey Kladov <[email protected]>

11 files changed, 137 insertions, 530 deletions

diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index a0fd633e0..6345e4725 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -6,11 +6,10 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 unicode-xid = "0.1.0"
-text_unit = "0.1.4"
 itertools = "0.7.8"
 drop_bomb = "0.1.4"
 parking_lot = "0.6.0"
-smol_str = "0.1.6"
+rowan = "0.1.0"
 
 [dev-dependencies]
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_syntax/src/ast/mod.rs b/crates/ra_syntax/src/ast/mod.rs
index a6da82957..c1570b868 100644
--- a/crates/ra_syntax/src/ast/mod.rs
+++ b/crates/ra_syntax/src/ast/mod.rs
@@ -3,10 +3,9 @@ mod generated;
 use std::marker::PhantomData;
 
 use itertools::Itertools;
-use smol_str::SmolStr;
 
 use {
-    SyntaxNodeRef, SyntaxKind::*,
+    SmolStr, SyntaxNodeRef, SyntaxKind::*,
     yellow::{RefRoot, SyntaxNodeChildren},
 };
 pub use self::generated::*;
@@ -76,7 +75,7 @@ impl<'a> Attr<'a> {
         let tt = self.value()?;
         let (_bra, attr, _ket) = tt.syntax().children().collect_tuple()?;
         if attr.kind() == IDENT {
-            Some(attr.leaf_text().unwrap())
+            Some(attr.leaf_text().unwrap().clone())
         } else {
             None
         }
@@ -87,7 +86,7 @@ impl<'a> Attr<'a> {
         let (_bra, attr, args, _ket) = tt.syntax().children().collect_tuple()?;
         let args = TokenTree::cast(args)?;
         if attr.kind() == IDENT {
-            Some((attr.leaf_text().unwrap(), args))
+            Some((attr.leaf_text().unwrap().clone(), args))
         } else {
             None
         }
@@ -96,7 +95,7 @@ impl<'a> Attr<'a> {
 
 impl<'a> Lifetime<'a> {
     pub fn text(&self) -> SmolStr {
-        self.syntax().leaf_text().unwrap()
+        self.syntax().leaf_text().unwrap().clone()
     }
 }
 
@@ -104,7 +103,7 @@ impl<'a> Name<'a> {
     pub fn text(&self) -> SmolStr {
         let ident = self.syntax().first_child()
             .unwrap();
-        ident.leaf_text().unwrap()
+        ident.leaf_text().unwrap().clone()
     }
 }
 
@@ -112,7 +111,7 @@ impl<'a> NameRef<'a> {
     pub fn text(&self) -> SmolStr {
         let ident = self.syntax().first_child()
             .unwrap();
-        ident.leaf_text().unwrap()
+        ident.leaf_text().unwrap().clone()
     }
 }
 
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index eb271762e..c7eda4563 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -24,8 +24,7 @@ extern crate itertools;
 extern crate unicode_xid;
 extern crate drop_bomb;
 extern crate parking_lot;
-extern crate smol_str;
-extern crate text_unit;
+extern crate rowan;
 
 #[cfg(test)]
 #[macro_use]
@@ -48,8 +47,7 @@ pub mod utils;
 pub mod text_utils;
 
 pub use {
-    text_unit::{TextRange, TextUnit},
-    smol_str::SmolStr,
+    rowan::{SmolStr, TextRange, TextUnit},
     ast::AstNode,
     lexer::{tokenize, Token},
     syntax_kinds::SyntaxKind,
@@ -58,7 +56,7 @@ pub use {
 };
 
 use {
-    yellow::{GreenNode, SyntaxRoot},
+    yellow::{GreenNode},
 };
 
 #[derive(Clone, Debug, Hash)]
@@ -68,8 +66,7 @@ pub struct File {
 
 impl File {
     fn new(green: GreenNode, errors: Vec<SyntaxError>) -> File {
-        let root = SyntaxRoot::new(green, errors);
-        let root = SyntaxNode::new_owned(root);
+        let root = SyntaxNode::new(green, errors);
         if cfg!(debug_assertions) {
             utils::validate_block_structure(root.borrowed());
         }
@@ -100,6 +97,6 @@ impl File {
         self.root.borrowed()
     }
     pub fn errors(&self) -> Vec<SyntaxError> {
-        self.syntax().root.syntax_root().errors.clone()
+        self.root.root_data().clone()
     }
 }
diff --git a/crates/ra_syntax/src/reparsing.rs b/crates/ra_syntax/src/reparsing.rs
index da44913c5..e3c200d1e 100644
--- a/crates/ra_syntax/src/reparsing.rs
+++ b/crates/ra_syntax/src/reparsing.rs
@@ -1,11 +1,11 @@
 use algo;
 use grammar;
 use lexer::{tokenize, Token};
-use text_unit::{TextRange, TextUnit};
-use yellow::{self, SyntaxNodeRef, GreenNode, SyntaxError};
+use yellow::{self, GreenNode, SyntaxNodeRef, SyntaxError};
 use parser_impl;
 use parser_api::Parser;
 use {
+    TextUnit, TextRange,
     SyntaxKind::*,
 };
 use text_utils::replace_range;
@@ -65,7 +65,7 @@ fn reparse_leaf<'node>(
                 return None;
             }
 
-            let green = GreenNode::new_leaf(node.kind(), &text);
+            let green = GreenNode::new_leaf(node.kind(), text.into());
             let new_errors = vec![];
             Some((node, green, new_errors))
         }
@@ -340,4 +340,4 @@ enum Foo {
 }
 ", "Clone");
     }
-}
\ No newline at end of file
+}
diff --git a/crates/ra_syntax/src/utils.rs b/crates/ra_syntax/src/utils.rs
index 671dd7afa..8bc5f0e24 100644
--- a/crates/ra_syntax/src/utils.rs
+++ b/crates/ra_syntax/src/utils.rs
@@ -1,12 +1,12 @@
 use std::fmt::Write;
 use {
     algo::walk::{preorder, walk, WalkEvent},
-    SyntaxKind, File, SyntaxNodeRef, TreeRoot,
+    SyntaxKind, File, SyntaxNodeRef
 };
 
 /// Parse a file and create a string representation of the resulting parse tree.
 pub fn dump_tree(syntax: SyntaxNodeRef) -> String {
-    let mut errors: Vec<_> = syntax.root.syntax_root().errors.iter().cloned().collect();
+    let mut errors: Vec<_> = syntax.root_data().iter().cloned().collect();
     errors.sort_by_key(|e| e.offset);
     let mut err_pos = 0;
     let mut level = 0;
diff --git a/crates/ra_syntax/src/yellow/builder.rs b/crates/ra_syntax/src/yellow/builder.rs
index e4ab37899..35dbaec05 100644
--- a/crates/ra_syntax/src/yellow/builder.rs
+++ b/crates/ra_syntax/src/yellow/builder.rs
@@ -1,15 +1,15 @@
+use rowan::GreenNodeBuilder;
 use {
     parser_impl::Sink,
-    yellow::{GreenNode, SyntaxError},
+    yellow::{GreenNode, SyntaxError, RaTypes},
     SyntaxKind, TextRange, TextUnit,
 };
 
 pub(crate) struct GreenBuilder<'a> {
     text: &'a str,
-    parents: Vec<(SyntaxKind, usize)>,
-    children: Vec<GreenNode>,
     pos: TextUnit,
     errors: Vec<SyntaxError>,
+    inner: GreenNodeBuilder<RaTypes>,
 }
 
 impl<'a> Sink<'a> for GreenBuilder<'a> {
@@ -18,35 +18,25 @@ impl<'a> Sink<'a> for GreenBuilder<'a> {
     fn new(text: &'a str) -> Self {
         GreenBuilder {
             text,
-            parents: Vec::new(),
-            children: Vec::new(),
             pos: 0.into(),
             errors: Vec::new(),
+            inner: GreenNodeBuilder::new(),
         }
     }
 
     fn leaf(&mut self, kind: SyntaxKind, len: TextUnit) {
         let range = TextRange::offset_len(self.pos, len);
         self.pos += len;
-        let text = &self.text[range];
-        self.children.push(
-            GreenNode::new_leaf(kind, text)
-        );
+        let text = self.text[range].into();
+        self.inner.leaf(kind, text);
     }
 
     fn start_internal(&mut self, kind: SyntaxKind) {
-        let len = self.children.len();
-        self.parents.push((kind, len));
+        self.inner.start_internal(kind)
     }
 
     fn finish_internal(&mut self) {
-        let (kind, first_child) = self.parents.pop().unwrap();
-        let children: Vec<_> = self.children
-            .drain(first_child..)
-            .collect();
-        self.children.push(
-            GreenNode::new_branch(kind, children.into_boxed_slice())
-        );
+        self.inner.finish_internal();
     }
 
     fn error(&mut self, message: String) {
@@ -56,9 +46,7 @@ impl<'a> Sink<'a> for GreenBuilder<'a> {
         })
     }
 
-    fn finish(mut self) -> (GreenNode, Vec<SyntaxError>) {
-        assert_eq!(self.children.len(), 1);
-        let root = self.children.pop().unwrap();
-        (root, self.errors)
+    fn finish(self) -> (GreenNode, Vec<SyntaxError>) {
+        (self.inner.finish(), self.errors)
     }
 }
diff --git a/crates/ra_syntax/src/yellow/green.rs b/crates/ra_syntax/src/yellow/green.rs
deleted file mode 100644
index 8fb691643..000000000
--- a/crates/ra_syntax/src/yellow/green.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-use std::sync::Arc;
-
-use smol_str::SmolStr;
-
-use {SyntaxKind, TextUnit};
-
-#[derive(Clone, Debug)]
-pub(crate) enum GreenNode {
-    Leaf {
-        kind: SyntaxKind,
-        text: SmolStr,
-    },
-    Branch(Arc<GreenBranch>),
-}
-
-impl GreenNode {
-    pub(crate) fn new_leaf(kind: SyntaxKind, text: &str) -> GreenNode {
-        GreenNode::Leaf { kind, text: SmolStr::new(text) }
-    }
-
-    pub(crate) fn new_branch(kind: SyntaxKind, children: Box<[GreenNode]>) -> GreenNode {
-        GreenNode::Branch(Arc::new(GreenBranch::new(kind, children)))
-    }
-
-    pub fn kind(&self) -> SyntaxKind {
-        match self {
-            GreenNode::Leaf { kind, .. } => *kind,
-            GreenNode::Branch(b) => b.kind(),
-        }
-    }
-
-    pub fn text_len(&self) -> TextUnit {
-        match self {
-            GreenNode::Leaf { text, .. } => TextUnit::from(text.len() as u32),
-            GreenNode::Branch(b) => b.text_len(),
-        }
-    }
-
-    pub fn children(&self) -> &[GreenNode] {
-        match self {
-            GreenNode::Leaf { .. } => &[],
-            GreenNode::Branch(b) => b.children(),
-        }
-    }
-
-    pub fn leaf_text_ref(&self) -> Option<&SmolStr> {
-        match self {
-            GreenNode::Leaf { text, .. } => Some(text),
-            GreenNode::Branch(_) => None,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct GreenBranch {
-    text_len: TextUnit,
-    kind: SyntaxKind,
-    children: Box<[GreenNode]>,
-}
-
-impl GreenBranch {
-    fn new(kind: SyntaxKind, children: Box<[GreenNode]>) -> GreenBranch {
-        let text_len = children.iter().map(|x| x.text_len()).sum::<TextUnit>();
-        GreenBranch {
-            text_len,
-            kind,
-            children,
-        }
-    }
-
-    pub fn kind(&self) -> SyntaxKind {
-        self.kind
-    }
-
-    pub fn text_len(&self) -> TextUnit {
-        self.text_len
-    }
-
-    pub fn children(&self) -> &[GreenNode] {
-        &*self.children
-    }
-}
-
-#[test]
-fn test_sizes() {
-    use std::mem::size_of;
-    println!("GreenBranch = {}", size_of::<GreenBranch>());
-    println!("GreenNode   = {}", size_of::<GreenNode>());
-    println!("SmolStr     = {}", size_of::<SmolStr>());
-}
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,
+    }
 }
diff --git a/crates/ra_syntax/src/yellow/red.rs b/crates/ra_syntax/src/yellow/red.rs
deleted file mode 100644
index 84cfe4fba..000000000
--- a/crates/ra_syntax/src/yellow/red.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use parking_lot::RwLock;
-use {yellow::{GreenNode, RedPtr}, TextUnit};
-
-#[derive(Debug)]
-pub(crate) struct RedNode {
-    green: GreenNode,
-    parent: Option<ParentData>,
-    children: RwLock<Box<[RedChild]>>,
-}
-
-#[derive(Debug)]
-enum RedChild {
-    Zigot(TextUnit),
-    Child(RedNode)
-}
-
-impl RedChild {
-    fn set(&mut self, node: RedNode) -> &RedNode {
-        match self {
-            RedChild::Child(node) => return node,
-            RedChild::Zigot(_) => {
-                *self = RedChild::Child(node);
-                match self {
-                    RedChild::Child(node) => return node,
-                    RedChild::Zigot(_) => unreachable!()
-                }
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-struct ParentData {
-    parent: RedPtr,
-    start_offset: TextUnit,
-    index_in_parent: usize,
-}
-
-impl RedNode {
-    pub fn new_root(green: GreenNode) -> RedNode {
-        RedNode::new(green, None)
-    }
-
-    fn new_child(
-        green: GreenNode,
-        parent: RedPtr,
-        start_offset: TextUnit,
-        index_in_parent: usize,
-    ) -> RedNode {
-        let parent_data = ParentData {
-            parent,
-            start_offset,
-            index_in_parent,
-        };
-        RedNode::new(green, Some(parent_data))
-    }
-
-    fn new(green: GreenNode, parent: Option<ParentData>) -> RedNode {
-        let mut start_offset = parent.as_ref().map(|it| it.start_offset).unwrap_or(0.into());
-        let children = green.children()
-            .iter()
-            .map(|child| {
-                let off = start_offset;
-                start_offset += child.text_len();
-                RedChild::Zigot(off)
-            })
-            .collect::<Vec<_>>()
-            .into_boxed_slice();
-        RedNode {
-            green,
-            parent,
-            children: RwLock::new(children),
-        }
-    }
-
-    pub(crate) fn green(&self) -> &GreenNode {
-        &self.green
-    }
-
-    pub(crate) fn start_offset(&self) -> TextUnit {
-        match &self.parent {
-            None => 0.into(),
-            Some(p) => p.start_offset,
-        }
-    }
-
-    pub(crate) fn n_children(&self) -> usize {
-        self.green.children().len()
-    }
-
-    pub(crate) fn get_child(&self, idx: usize) -> Option<RedPtr> {
-        if idx >= self.n_children() {
-            return None;
-        }
-        let start_offset = match &self.children.read()[idx] {
-            RedChild::Child(child) => return Some(RedPtr::new(child)),
-            RedChild::Zigot(start_offset) => *start_offset,
-        };
-        let green_children = self.green.children();
-        let child =
-            RedNode::new_child(green_children[idx].clone(), RedPtr::new(self), start_offset, idx);
-        let mut children = self.children.write();
-        let child = children[idx].set(child);
-        Some(RedPtr::new(child))
-    }
-
-    pub(crate) fn parent(&self) -> Option<RedPtr> {
-        Some(self.parent.as_ref()?.parent)
-    }
-    pub(crate) fn index_in_parent(&self) -> Option<usize> {
-        Some(self.parent.as_ref()?.index_in_parent)
-    }
-}
diff --git a/crates/ra_syntax/src/yellow/syntax.rs b/crates/ra_syntax/src/yellow/syntax.rs
deleted file mode 100644
index 1d99cab4a..000000000
--- a/crates/ra_syntax/src/yellow/syntax.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-use std::{
-    fmt, sync::Arc,
-    hash::{Hasher, Hash},
-    ops::Range,
-};
-
-use smol_str::SmolStr;
-
-use {
-    yellow::{GreenNode, RedNode, TreeRoot, SyntaxRoot, RedPtr, RefRoot, OwnedRoot, SyntaxText},
-    SyntaxKind::{self, *},
-    TextRange, TextUnit,
-};
-
-
-#[derive(Clone, Copy)]
-pub struct SyntaxNode<R: TreeRoot = OwnedRoot> {
-    pub(crate) root: R,
-    // Guaranteed to not dangle, because `root` holds a
-    // strong reference to red's ancestor
-    red: RedPtr,
-}
-
-unsafe impl<R: TreeRoot> Send for SyntaxNode<R> {}
-unsafe impl<R: TreeRoot> Sync for SyntaxNode<R> {}
-
-impl<R1: TreeRoot, R2: TreeRoot> PartialEq<SyntaxNode<R1>> for SyntaxNode<R2> {
-    fn eq(&self, other: &SyntaxNode<R1>) -> bool {
-        self.red == other.red
-    }
-}
-
-impl<R: TreeRoot> Eq for SyntaxNode<R> {}
-impl<R: TreeRoot> Hash for SyntaxNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.red.hash(state)
-    }
-}
-
-pub type SyntaxNodeRef<'a> = SyntaxNode<RefRoot<'a>>;
-
-#[test]
-fn syntax_node_ref_is_copy() {
-    fn assert_copy<T: Copy>(){}
-    assert_copy::<SyntaxNodeRef>()
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
-pub struct SyntaxError {
-    pub msg: String,
-    pub offset: TextUnit,
-}
-
-impl SyntaxNode<OwnedRoot> {
-    pub(crate) fn new_owned(root: SyntaxRoot) -> Self {
-        let root = OwnedRoot(Arc::new(root));
-        let red = RedPtr::new(&root.syntax_root().red);
-        SyntaxNode { root, red }
-    }
-}
-
-impl<'a> SyntaxNode<RefRoot<'a>> {
-    pub(crate) fn leaf_text_ref(self) -> Option<&'a SmolStr> {
-        let red = unsafe { self.red.get(self.root.syntax_root()) };
-        red.green().leaf_text_ref()
-    }
-}
-
-impl<R: TreeRoot> SyntaxNode<R> {
-    pub fn borrowed<'a>(&'a self) -> SyntaxNodeRef<'a> {
-        SyntaxNode {
-            root: self.root.borrowed(),
-            red: self.red,
-        }
-    }
-
-    pub fn owned(&self) -> SyntaxNode {
-        SyntaxNode {
-            root: self.root.owned(),
-            red: self.red,
-        }
-    }
-
-    pub fn kind(&self) -> SyntaxKind {
-        self.red().green().kind()
-    }
-
-    pub fn range(&self) -> TextRange {
-        let red = self.red();
-        TextRange::offset_len(red.start_offset(), red.green().text_len())
-    }
-
-    pub fn text(&self) -> SyntaxText {
-        SyntaxText::new(self.borrowed())
-    }
-
-    pub fn children(&self) -> SyntaxNodeChildren<R> {
-        SyntaxNodeChildren {
-            parent: self.clone(),
-            iter: (0..self.red().n_children())
-        }
-    }
-
-    pub fn parent(&self) -> Option<SyntaxNode<R>> {
-        let parent = self.red().parent()?;
-        Some(SyntaxNode {
-            root: self.root.clone(),
-            red: parent,
-        })
-    }
-
-    pub fn first_child(&self) -> Option<SyntaxNode<R>> {
-        let red = self.red().get_child(0)?;
-        Some(SyntaxNode { root: self.root.clone(), red })
-    }
-
-    pub fn last_child(&self) -> Option<SyntaxNode<R>> {
-        let n = self.red().n_children();
-        let n = n.checked_sub(1)?;
-        let red = self.red().get_child(n)?;
-        Some(SyntaxNode { root: self.root.clone(), red })
-    }
-
-    pub fn next_sibling(&self) -> Option<SyntaxNode<R>> {
-        let red = self.red();
-        let parent = self.parent()?;
-        let next_sibling_idx = red.index_in_parent()? + 1;
-        let sibling_red = parent.red().get_child(next_sibling_idx)?;
-        Some(SyntaxNode {
-            root: self.root.clone(),
-            red: sibling_red,
-        })
-    }
-
-    pub fn prev_sibling(&self) -> Option<SyntaxNode<R>> {
-        let red = self.red();
-        let parent = self.parent()?;
-        let prev_sibling_idx = red.index_in_parent()?.checked_sub(1)?;
-        let sibling_red = parent.red().get_child(prev_sibling_idx)?;
-        Some(SyntaxNode {
-            root: self.root.clone(),
-            red: sibling_red,
-        })
-    }
-
-    pub fn is_leaf(&self) -> bool {
-        self.first_child().is_none()
-    }
-
-    pub fn leaf_text(&self) -> Option<SmolStr> {
-        self.borrowed().leaf_text_ref().map(|it| it.clone())
-    }
-
-    pub(crate) fn replace_with(&self, green: GreenNode) -> GreenNode {
-        assert_eq!(self.kind(), green.kind());
-        match self.parent() {
-            None => green,
-            Some(parent) => {
-                let children: Vec<_> = parent.children().map(|child| {
-                    if child == *self {
-                        green.clone()
-                    } else {
-                        child.red().green().clone()
-                    }
-                }).collect();
-                let new_parent = GreenNode::new_branch(
-                    parent.kind(),
-                    children.into_boxed_slice(),
-                );
-                parent.replace_with(new_parent)
-            },
-        }
-    }
-
-    fn red(&self) -> &RedNode {
-        unsafe { self.red.get(self.root.syntax_root()) }
-    }
-}
-
-impl<R: TreeRoot> 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(Debug)]
-pub struct SyntaxNodeChildren<R: TreeRoot> {
-    parent: SyntaxNode<R>,
-    iter: Range<usize>,
-}
-
-impl<R: TreeRoot> Iterator for SyntaxNodeChildren<R> {
-    type Item = SyntaxNode<R>;
-
-    fn next(&mut self) -> Option<SyntaxNode<R>> {
-        self.iter.next().map(|i| {
-            let red = self.parent.red();
-            SyntaxNode {
-                root: self.parent.root.clone(),
-                red: red.get_child(i).unwrap(),
-            }
-        })
-    }
-}
-
-fn has_short_text(kind: SyntaxKind) -> bool {
-    match kind {
-        IDENT | LIFETIME | INT_NUMBER | FLOAT_NUMBER => true,
-        _ => false,
-    }
-}
diff --git a/crates/ra_syntax/src/yellow/syntax_text.rs b/crates/ra_syntax/src/yellow/syntax_text.rs
index 280bedd78..affd7f9c7 100644
--- a/crates/ra_syntax/src/yellow/syntax_text.rs
+++ b/crates/ra_syntax/src/yellow/syntax_text.rs
@@ -25,7 +25,7 @@ impl<'a> SyntaxText<'a> {
         let range = self.range;
         preorder(self.node)
             .filter_map(move |node| {
-                let text = node.leaf_text_ref()?;
+                let text = node.leaf_text()?;
                 let range = intersect(range, node.range())?;
                 let range = range - node.range().start();
                 Some(&text[range])