Owned&Borrowed nodes

HOLLY COW, UNLIKE C++, WE CAN BE GENERIC WRT OWNERSHIP/BORROWING, SO
WE CAN BOTH MAKE SYNTAX NODES OWNED (WHICH IS CONVENIENT) AND
BORROWED (WHICH IS CONVENIENT FOR LOCAL PROCESSING, BC YOU DON'T NEED
TO BUMP REFCOUNTS).

3 files changed, 37 insertions, 17 deletions

diff --git a/src/yellow/builder.rs b/src/yellow/builder.rs
index 73b4b5ff9..65cc97ff9 100644
--- a/src/yellow/builder.rs
+++ b/src/yellow/builder.rs
@@ -1,6 +1,6 @@
 use {
     SyntaxKind, TextRange, TextUnit,
-    yellow::{SyntaxNode, GreenNode, GreenNodeBuilder, SyntaxError},
+    yellow::{SyntaxNode, SyntaxRoot, GreenNode, GreenNodeBuilder, SyntaxError},
     parser::Sink
 };
 
@@ -57,7 +57,8 @@ impl Sink for GreenBuilder {
     }
 
     fn finish(self) -> SyntaxNode {
-        SyntaxNode::new(self.root.unwrap(), self.errors)
+        let root = SyntaxRoot::new(self.root.unwrap(), self.errors);
+        SyntaxNode::new_owned(root)
     }
 }
 
diff --git a/src/yellow/mod.rs b/src/yellow/mod.rs
index 4fd0d24d7..89eefc98b 100644
--- a/src/yellow/mod.rs
+++ b/src/yellow/mod.rs
@@ -6,7 +6,7 @@ mod builder;
 pub(crate) use self::{
     green::{GreenNode, GreenNodeBuilder},
     red::RedNode,
-    syntax::SyntaxError,
+    syntax::{SyntaxError, SyntaxRoot},
     builder::GreenBuilder,
 };
-pub use self::syntax::SyntaxNode;
+pub use self::syntax::{SyntaxNode, SyntaxNodeRef};
diff --git a/src/yellow/syntax.rs b/src/yellow/syntax.rs
index cc6122689..0fa24fb47 100644
--- a/src/yellow/syntax.rs
+++ b/src/yellow/syntax.rs
@@ -10,17 +10,28 @@ use {
     yellow::{RedNode, GreenNode},
 };
 
-#[derive(Clone)]
-pub struct SyntaxNode {
-    pub(crate) root: SyntaxRoot,
+#[derive(Clone, Copy)]
+pub struct SyntaxNode<ROOT: ::std::ops::Deref<Target=SyntaxRoot> + Clone = Arc<SyntaxRoot>> {
+    pub(crate) root: ROOT,
     // guaranteed to be alive bc SyntaxRoot holds a strong ref
     red: ptr::NonNull<RedNode>,
 }
 
-#[derive(Clone)]
+pub type SyntaxNodeRef<'a> = SyntaxNode<&'a SyntaxRoot>;
+
+#[derive(Debug)]
 pub struct SyntaxRoot {
-    red: Arc<RedNode>,
-    pub(crate) errors: Arc<Vec<SyntaxError>>,
+    red: RedNode,
+    pub(crate) errors: Vec<SyntaxError>,
+}
+
+impl SyntaxRoot {
+    pub(crate) fn new(green: GreenNode, errors: Vec<SyntaxError>) -> SyntaxRoot {
+        SyntaxRoot {
+            red: RedNode::new_root(green),
+            errors,
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
@@ -29,13 +40,21 @@ pub(crate) struct SyntaxError {
     pub(crate) offset: TextUnit,
 }
 
-impl SyntaxNode {
-    pub(crate) fn new(root: GreenNode, errors: Vec<SyntaxError>) -> SyntaxNode {
-        let red = Arc::new(RedNode::new_root(root));
-        let red_weak: ptr::NonNull<RedNode> = (&*red).into();
-        let root = SyntaxRoot { red, errors: Arc::new(errors) };
+impl SyntaxNode<Arc<SyntaxRoot>> {
+    pub(crate) fn new_owned(root: SyntaxRoot) -> Self {
+        let root = Arc::new(root);
+        let red_weak = ptr::NonNull::from(&root.red);
         SyntaxNode { root, red: red_weak }
     }
+}
+
+impl<ROOT: ::std::ops::Deref<Target=SyntaxRoot> + Clone> SyntaxNode<ROOT> {
+    pub fn borrow<'a>(&'a self) -> SyntaxNode<&'a SyntaxRoot> {
+        SyntaxNode {
+            root: &*self.root,
+            red: ptr::NonNull::clone(&self.red),
+        }
+    }
 
     pub fn kind(&self) -> SyntaxKind {
         self.red().green().kind()
@@ -53,7 +72,7 @@ impl SyntaxNode {
         self.red().green().text()
     }
 
-    pub fn children(&self) -> Vec<SyntaxNode> {
+    pub fn children(&self) -> Vec<SyntaxNode<ROOT>> {
         let red = self.red();
         let n_children = red.n_children();
         let mut res = Vec::with_capacity(n_children);
@@ -71,7 +90,7 @@ impl SyntaxNode {
     }
 }
 
-impl fmt::Debug for SyntaxNode {
+impl<ROOT: ::std::ops::Deref<Target=SyntaxRoot> + Clone> fmt::Debug for SyntaxNode<ROOT> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "{:?}@{:?}", self.kind(), self.range())?;
         if has_short_text(self.kind()) {