Introduce red-green syntax tree

1 files changed, 132 insertions, 0 deletions

diff --git a/src/yellow/syntax.rs b/src/yellow/syntax.rs
new file mode 100644
index 000000000..0c9ffeb14
--- /dev/null
+++ b/src/yellow/syntax.rs
@@ -0,0 +1,132 @@
+use std::{
+    fmt,
+    sync::Arc,
+};
+
+use {
+    TextRange, TextUnit, SyntaxKind,
+    yellow::{Ptr, RedNode, GreenNode, TextLen},
+};
+use yellow::green::GreenTrivia;
+
+#[derive(Clone)]
+pub struct SyntaxNode {
+    pub(crate) root: SyntaxRoot,
+    red: Ptr<RedNode>,
+    trivia_pos: Option<(usize, usize)>,
+}
+
+#[derive(Clone)]
+pub struct SyntaxRoot {
+    red: Arc<RedNode>,
+    pub(crate) errors: Arc<Vec<SError>>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub(crate) struct SError {
+    pub(crate) message: String,
+    pub(crate) offset: TextUnit,
+}
+
+impl SyntaxNode {
+    pub(crate) fn new(root: Arc<GreenNode>, errors: Vec<SError>) -> SyntaxNode {
+        let root = Arc::new(RedNode::new_root(root));
+        let red = Ptr::new(&root);
+        let root = SyntaxRoot { red: root, errors: Arc::new(errors) };
+        SyntaxNode { root, red, trivia_pos: None }
+    }
+
+    pub fn kind(&self) -> SyntaxKind {
+        let green = self.red().green();
+        match self.trivia_pos {
+            None => green.kind(),
+            Some((i, j)) => green.nth_trivias(i)[j].kind
+        }
+    }
+
+    pub fn range(&self) -> TextRange {
+        let red = self.red();
+        let green = red.green();
+        match self.trivia_pos {
+            None => TextRange::offset_len(red.start_offset(), red.green().text_len()),
+            Some((i, j)) => {
+                let trivias = green.nth_trivias(i);
+                let offset = if i == 0 {
+                    red.start_offset()
+                } else {
+                    let prev_child = red.nth_child(Ptr::clone(&self.red), i - 1);
+                    let mut offset = prev_child.start_offset() + prev_child.green().text_len();
+                    for k in 0..j {
+                        offset += &trivias[k].text_len();
+                    }
+                    offset
+                };
+                TextRange::offset_len(offset, trivias[j].text_len())
+            }
+        }
+    }
+
+    pub fn text(&self) -> String {
+        let green = self.red().green();
+        match self.trivia_pos {
+            None => green.text(),
+            Some((i, j)) => green.nth_trivias(i)[j].text.clone()
+        }
+    }
+
+    pub fn children(&self) -> Vec<SyntaxNode> {
+        let mut res = Vec::new();
+        let red = self.red();
+        let green = red.green();
+        if green.is_leaf() || self.trivia_pos.is_some() {
+            return Vec::new();
+        }
+        for (j, _) in green.nth_trivias(0).iter().enumerate() {
+            res.push(SyntaxNode {
+                root: self.root.clone(),
+                red: Ptr::clone(&self.red),
+                trivia_pos: Some((0, j)),
+            })
+        }
+
+        let n_children = red.n_children();
+        for i in 0..n_children {
+            res.push(SyntaxNode {
+                root: self.root.clone(),
+                red: Ptr::new(&red.nth_child(Ptr::clone(&self.red), i)),
+                trivia_pos: None,
+            });
+            for (j, _) in green.nth_trivias(i + 1).iter().enumerate() {
+                res.push(SyntaxNode {
+                    root: self.root.clone(),
+                    red: self.red.clone(),
+                    trivia_pos: Some((i + 1, j)),
+                })
+            }
+        }
+        res
+    }
+
+    fn red(&self) -> &RedNode {
+        // Safe b/c root ptr keeps red alive
+        unsafe { self.red.get() }
+    }
+}
+
+impl fmt::Debug for SyntaxNode {
+    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(())
+    }
+}
+
+fn has_short_text(kind: SyntaxKind) -> bool {
+    use syntax_kinds::*;
+    match kind {
+        IDENT | LIFETIME => true,
+        _ => false,
+    }
+}