Merge #1548

1548: use Parse in mbe r=matklad a=matklad



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

1 files changed, 38 insertions, 13 deletions

diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 0fa2fe382..534c206a6 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -43,8 +43,8 @@ pub use crate::{
     ptr::{AstPtr, SyntaxNodePtr},
     syntax_error::{Location, SyntaxError, SyntaxErrorKind},
     syntax_node::{
-        Direction, InsertPosition, SyntaxElement, SyntaxNode, SyntaxToken, SyntaxTreeBuilder,
-        TreeArc, WalkEvent,
+        Direction, InsertPosition, SyntaxElement, SyntaxNode, SyntaxNodeWrapper, SyntaxToken,
+        SyntaxTreeBuilder, TreeArc, WalkEvent,
     },
     syntax_text::SyntaxText,
 };
@@ -57,14 +57,24 @@ pub use rowan::{SmolStr, TextRange, TextUnit};
 ///
 /// Note that we always produce a syntax tree, even for completely invalid
 /// files.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Parse {
-    tree: TreeArc<SourceFile>,
+#[derive(Debug, PartialEq, Eq)]
+pub struct Parse<T: SyntaxNodeWrapper> {
+    tree: TreeArc<T>,
     errors: Arc<Vec<SyntaxError>>,
 }
 
-impl Parse {
-    pub fn tree(&self) -> &SourceFile {
+impl<T: SyntaxNodeWrapper> Clone for Parse<T> {
+    fn clone(&self) -> Parse<T> {
+        Parse { tree: self.tree.clone(), errors: self.errors.clone() }
+    }
+}
+
+impl<T: SyntaxNodeWrapper> Parse<T> {
+    fn new(tree: TreeArc<T>, errors: Vec<SyntaxError>) -> Parse<T> {
+        Parse { tree, errors: Arc::new(errors) }
+    }
+
+    pub fn tree(&self) -> &T {
         &*self.tree
     }
 
@@ -72,18 +82,22 @@ impl Parse {
         &*self.errors
     }
 
-    pub fn ok(self) -> Result<TreeArc<SourceFile>, Arc<Vec<SyntaxError>>> {
+    pub fn ok(self) -> Result<TreeArc<T>, Arc<Vec<SyntaxError>>> {
         if self.errors.is_empty() {
             Ok(self.tree)
         } else {
             Err(self.errors)
         }
     }
+}
 
-    pub fn reparse(&self, edit: &AtomTextEdit) -> Parse {
-        self.incremental_reparse(edit).unwrap_or_else(|| self.full_reparse(edit))
+impl<T: AstNode> Parse<T> {
+    pub fn to_syntax(this: Self) -> Parse<SyntaxNode> {
+        Parse { tree: this.tree().syntax().to_owned(), errors: this.errors }
     }
+}
 
+impl Parse<SourceFile> {
     pub fn debug_dump(&self) -> String {
         let mut buf = self.tree.syntax().debug_dump();
         for err in self.errors.iter() {
@@ -92,7 +106,11 @@ impl Parse {
         buf
     }
 
-    fn incremental_reparse(&self, edit: &AtomTextEdit) -> Option<Parse> {
+    pub fn reparse(&self, edit: &AtomTextEdit) -> Parse<SourceFile> {
+        self.incremental_reparse(edit).unwrap_or_else(|| self.full_reparse(edit))
+    }
+
+    fn incremental_reparse(&self, edit: &AtomTextEdit) -> Option<Parse<SourceFile>> {
         // FIXME: validation errors are not handled here
         parsing::incremental_reparse(self.tree.syntax(), edit, self.errors.to_vec()).map(
             |(green_node, errors, _reparsed_range)| Parse {
@@ -102,12 +120,19 @@ impl Parse {
         )
     }
 
-    fn full_reparse(&self, edit: &AtomTextEdit) -> Parse {
+    fn full_reparse(&self, edit: &AtomTextEdit) -> Parse<SourceFile> {
         let text = edit.apply(self.tree.syntax().text().to_string());
         SourceFile::parse(&text)
     }
 }
 
+impl Parse<SyntaxNode> {
+    pub fn cast<T: AstNode>(self) -> Option<Parse<T>> {
+        let node = T::cast(&self.tree)?;
+        Some(Parse { tree: node.to_owned(), errors: self.errors })
+    }
+}
+
 /// `SourceFile` represents a parse tree for a single Rust file.
 pub use crate::ast::SourceFile;
 
@@ -121,7 +146,7 @@ impl SourceFile {
         TreeArc::cast(root)
     }
 
-    pub fn parse(text: &str) -> Parse {
+    pub fn parse(text: &str) -> Parse<SourceFile> {
         let (green, mut errors) = parsing::parse_text(text);
         let tree = SourceFile::new(green);
         errors.extend(validation::validate(&tree));