1 files changed, 33 insertions, 1 deletions

diff --git a/crates/ra_syntax/src/ast/mod.rs b/crates/ra_syntax/src/ast/mod.rs
index 4355531d0..7077e3492 100644
--- a/crates/ra_syntax/src/ast/mod.rs
+++ b/crates/ra_syntax/src/ast/mod.rs
@@ -1,6 +1,7 @@
 mod generated;
 
 use std::marker::PhantomData;
+use std::string::String as RustString;
 
 use itertools::Itertools;
 
@@ -12,6 +13,10 @@ use crate::{
     SyntaxNodeRef,
 };
 
+/// The main trait to go from untyped `SyntaxNode`  to a typed ast. The
+/// conversion itself has zero runtime cost: ast and syntax nodes have exactly
+/// the same representation: a pointer to the tree root and a pointer to the
+/// node itself.
 pub trait AstNode<'a>: Clone + Copy + 'a {
     fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self>
     where
@@ -72,7 +77,7 @@ pub trait DocCommentsOwner<'a>: AstNode<'a> {
 
     /// Returns the textual content of a doc comment block as a single string.
     /// That is, strips leading `///` and joins lines
-    fn doc_comment_text(self) -> String {
+    fn doc_comment_text(self) -> RustString {
         self.doc_comments()
             .map(|comment| {
                 let prefix = comment.prefix();
@@ -129,6 +134,24 @@ impl<'a> Char<'a> {
     }
 }
 
+impl<'a> Byte<'a> {
+    pub fn text(&self) -> &SmolStr {
+        &self.syntax().leaf_text().unwrap()
+    }
+}
+
+impl<'a> ByteString<'a> {
+    pub fn text(&self) -> &SmolStr {
+        &self.syntax().leaf_text().unwrap()
+    }
+}
+
+impl<'a> String<'a> {
+    pub fn text(&self) -> &SmolStr {
+        &self.syntax().leaf_text().unwrap()
+    }
+}
+
 impl<'a> Comment<'a> {
     pub fn text(&self) -> &SmolStr {
         self.syntax().leaf_text().unwrap()
@@ -292,6 +315,15 @@ impl<'a> PathSegment<'a> {
     }
 }
 
+impl<'a> UseTreeList<'a> {
+    pub fn parent_use_tree(self) -> UseTree<'a> {
+        self.syntax()
+            .parent()
+            .and_then(UseTree::cast)
+            .expect("UseTreeLists are always nested in UseTrees")
+    }
+}
+
 fn child_opt<'a, P: AstNode<'a>, C: AstNode<'a>>(parent: P) -> Option<C> {
     children(parent).next()
 }