3 files changed, 268 insertions, 249 deletions

diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index ffd115cef..beef2c6e2 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -1,17 +1,24 @@
 //! Abstract Syntax Tree, layered on top of untyped `SyntaxNode`s
 mod generated;
+mod traits;
+mod tokens;
 
 use std::marker::PhantomData;
 
 use itertools::Itertools;
 
-pub use self::generated::*;
 use crate::{
-    syntax_node::{SyntaxNode, SyntaxNodeChildren, TreeArc, RaTypes, SyntaxToken, SyntaxElement, SyntaxElementChildren},
+    syntax_node::{SyntaxNode, SyntaxNodeChildren, TreeArc, RaTypes, SyntaxToken, SyntaxElement},
     SmolStr,
     SyntaxKind::*,
 };
 
+pub use self::{
+    generated::*,
+    traits::*,
+    tokens::*,
+};
+
 /// 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
@@ -25,134 +32,32 @@ pub trait AstNode:
     fn syntax(&self) -> &SyntaxNode;
 }
 
-pub trait TypeAscriptionOwner: AstNode {
-    fn ascribed_type(&self) -> Option<&TypeRef> {
-        child_opt(self)
-    }
-}
-
-pub trait NameOwner: AstNode {
-    fn name(&self) -> Option<&Name> {
-        child_opt(self)
-    }
-}
-
-pub trait VisibilityOwner: AstNode {
-    fn visibility(&self) -> Option<&Visibility> {
-        child_opt(self)
-    }
-}
-
-pub trait LoopBodyOwner: AstNode {
-    fn loop_body(&self) -> Option<&Block> {
-        child_opt(self)
-    }
-}
-
-pub trait ArgListOwner: AstNode {
-    fn arg_list(&self) -> Option<&ArgList> {
-        child_opt(self)
-    }
-}
-
-pub trait FnDefOwner: AstNode {
-    fn functions(&self) -> AstChildren<FnDef> {
-        children(self)
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ItemOrMacro<'a> {
-    Item(&'a ModuleItem),
-    Macro(&'a MacroCall),
-}
-
-pub trait ModuleItemOwner: AstNode {
-    fn items(&self) -> AstChildren<ModuleItem> {
-        children(self)
-    }
-    fn items_with_macros(&self) -> ItemOrMacroIter {
-        ItemOrMacroIter(self.syntax().children())
-    }
-}
-
 #[derive(Debug)]
-pub struct ItemOrMacroIter<'a>(SyntaxNodeChildren<'a>);
-
-impl<'a> Iterator for ItemOrMacroIter<'a> {
-    type Item = ItemOrMacro<'a>;
-    fn next(&mut self) -> Option<ItemOrMacro<'a>> {
-        loop {
-            let n = self.0.next()?;
-            if let Some(item) = ModuleItem::cast(n) {
-                return Some(ItemOrMacro::Item(item));
-            }
-            if let Some(call) = MacroCall::cast(n) {
-                return Some(ItemOrMacro::Macro(call));
-            }
-        }
-    }
-}
-
-pub trait TypeParamsOwner: AstNode {
-    fn type_param_list(&self) -> Option<&TypeParamList> {
-        child_opt(self)
-    }
-
-    fn where_clause(&self) -> Option<&WhereClause> {
-        child_opt(self)
-    }
+pub struct AstChildren<'a, N> {
+    inner: SyntaxNodeChildren<'a>,
+    ph: PhantomData<N>,
 }
 
-pub trait TypeBoundsOwner: AstNode {
-    fn type_bound_list(&self) -> Option<&TypeBoundList> {
-        child_opt(self)
+impl<'a, N> AstChildren<'a, N> {
+    fn new(parent: &'a SyntaxNode) -> Self {
+        AstChildren { inner: parent.children(), ph: PhantomData }
     }
 }
 
-pub trait AttrsOwner: AstNode {
-    fn attrs(&self) -> AstChildren<Attr> {
-        children(self)
-    }
-    fn has_atom_attr(&self, atom: &str) -> bool {
-        self.attrs().filter_map(|x| x.as_atom()).any(|x| x == atom)
+impl<'a, N: AstNode + 'a> Iterator for AstChildren<'a, N> {
+    type Item = &'a N;
+    fn next(&mut self) -> Option<&'a N> {
+        self.inner.by_ref().find_map(N::cast)
     }
 }
 
-pub trait DocCommentsOwner: AstNode {
-    fn doc_comments(&self) -> CommentIter {
-        CommentIter { iter: self.syntax().children_with_tokens() }
-    }
-
-    /// Returns the textual content of a doc comment block as a single string.
-    /// That is, strips leading `///` (+ optional 1 character of whitespace)
-    /// and joins lines.
-    fn doc_comment_text(&self) -> Option<std::string::String> {
-        let docs = self
-            .doc_comments()
-            .filter(|comment| comment.is_doc_comment())
-            .map(|comment| {
-                let prefix_len = comment.prefix().len();
-
-                let line = comment.text().as_str();
-
-                // Determine if the prefix or prefix + 1 char is stripped
-                let pos =
-                    if line.chars().nth(prefix_len).map(|c| c.is_whitespace()).unwrap_or(false) {
-                        prefix_len + 1
-                    } else {
-                        prefix_len
-                    };
-
-                line[pos..].to_owned()
-            })
-            .join("\n");
-
-        if docs.is_empty() {
-            None
-        } else {
-            Some(docs)
-        }
+pub trait AstToken<'a> {
+    fn cast(token: SyntaxToken<'a>) -> Option<Self>
+    where
+        Self: Sized;
+    fn syntax(&self) -> SyntaxToken<'a>;
+    fn text(&self) -> &'a SmolStr {
+        self.syntax().text()
     }
 }
 
@@ -203,111 +108,6 @@ impl Attr {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct Comment<'a>(SyntaxToken<'a>);
-
-impl<'a> Comment<'a> {
-    pub fn cast(token: SyntaxToken<'a>) -> Option<Self> {
-        if token.kind() == COMMENT {
-            Some(Comment(token))
-        } else {
-            None
-        }
-    }
-
-    pub fn syntax(&self) -> SyntaxToken<'a> {
-        self.0
-    }
-
-    pub fn text(&self) -> &'a SmolStr {
-        self.0.text()
-    }
-
-    pub fn flavor(&self) -> CommentFlavor {
-        let text = self.text();
-        if text.starts_with("///") {
-            CommentFlavor::Doc
-        } else if text.starts_with("//!") {
-            CommentFlavor::ModuleDoc
-        } else if text.starts_with("//") {
-            CommentFlavor::Line
-        } else {
-            CommentFlavor::Multiline
-        }
-    }
-
-    pub fn is_doc_comment(&self) -> bool {
-        self.flavor().is_doc_comment()
-    }
-
-    pub fn prefix(&self) -> &'static str {
-        self.flavor().prefix()
-    }
-}
-
-pub struct CommentIter<'a> {
-    iter: SyntaxElementChildren<'a>,
-}
-
-impl<'a> Iterator for CommentIter<'a> {
-    type Item = Comment<'a>;
-    fn next(&mut self) -> Option<Comment<'a>> {
-        self.iter.by_ref().find_map(|el| el.as_token().and_then(Comment::cast))
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum CommentFlavor {
-    Line,
-    Doc,
-    ModuleDoc,
-    Multiline,
-}
-
-impl CommentFlavor {
-    pub fn prefix(&self) -> &'static str {
-        use self::CommentFlavor::*;
-        match *self {
-            Line => "//",
-            Doc => "///",
-            ModuleDoc => "//!",
-            Multiline => "/*",
-        }
-    }
-
-    pub fn is_doc_comment(&self) -> bool {
-        match self {
-            CommentFlavor::Doc | CommentFlavor::ModuleDoc => true,
-            _ => false,
-        }
-    }
-}
-
-pub struct Whitespace<'a>(SyntaxToken<'a>);
-
-impl<'a> Whitespace<'a> {
-    pub fn cast(token: SyntaxToken<'a>) -> Option<Self> {
-        if token.kind() == WHITESPACE {
-            Some(Whitespace(token))
-        } else {
-            None
-        }
-    }
-
-    pub fn syntax(&self) -> SyntaxToken<'a> {
-        self.0
-    }
-
-    pub fn text(&self) -> &'a SmolStr {
-        self.0.text()
-    }
-
-    pub fn spans_multiple_lines(&self) -> bool {
-        let text = self.text();
-        text.find('\n').map_or(false, |idx| text[idx + 1..].contains('\n'))
-    }
-}
-
 impl Name {
     pub fn text(&self) -> &SmolStr {
         let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap();
@@ -468,29 +268,6 @@ fn children<P: AstNode, C: AstNode>(parent: &P) -> AstChildren<C> {
     AstChildren::new(parent.syntax())
 }
 
-#[derive(Debug)]
-pub struct AstChildren<'a, N> {
-    inner: SyntaxNodeChildren<'a>,
-    ph: PhantomData<N>,
-}
-
-impl<'a, N> AstChildren<'a, N> {
-    fn new(parent: &'a SyntaxNode) -> Self {
-        AstChildren { inner: parent.children(), ph: PhantomData }
-    }
-}
-
-impl<'a, N: AstNode + 'a> Iterator for AstChildren<'a, N> {
-    type Item = &'a N;
-    fn next(&mut self) -> Option<&'a N> {
-        loop {
-            if let Some(n) = N::cast(self.inner.next()?) {
-                return Some(n);
-            }
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum StructFlavor<'a> {
     Tuple(&'a PosFieldDefList),
diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs
new file mode 100644
index 000000000..76a12cd64
--- /dev/null
+++ b/crates/ra_syntax/src/ast/tokens.rs
@@ -0,0 +1,92 @@
+use crate::{
+    SyntaxToken,
+    SyntaxKind::{COMMENT, WHITESPACE},
+    ast::AstToken,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Comment<'a>(SyntaxToken<'a>);
+
+impl<'a> AstToken<'a> for Comment<'a> {
+    fn cast(token: SyntaxToken<'a>) -> Option<Self> {
+        if token.kind() == COMMENT {
+            Some(Comment(token))
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> SyntaxToken<'a> {
+        self.0
+    }
+}
+
+impl<'a> Comment<'a> {
+    pub fn flavor(&self) -> CommentFlavor {
+        let text = self.text();
+        if text.starts_with("///") {
+            CommentFlavor::OuterDoc
+        } else if text.starts_with("//!") {
+            CommentFlavor::InnerDoc
+        } else if text.starts_with("//") {
+            CommentFlavor::Line
+        } else {
+            CommentFlavor::Multiline
+        }
+    }
+
+    pub fn is_doc_comment(&self) -> bool {
+        self.flavor().is_doc_comment()
+    }
+
+    pub fn prefix(&self) -> &'static str {
+        self.flavor().prefix()
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum CommentFlavor {
+    Line,
+    OuterDoc,
+    InnerDoc,
+    Multiline,
+}
+
+impl CommentFlavor {
+    pub fn prefix(&self) -> &'static str {
+        match *self {
+            CommentFlavor::Line => "//",
+            CommentFlavor::OuterDoc => "///",
+            CommentFlavor::InnerDoc => "//!",
+            CommentFlavor::Multiline => "/*",
+        }
+    }
+
+    pub fn is_doc_comment(&self) -> bool {
+        match self {
+            CommentFlavor::OuterDoc | CommentFlavor::InnerDoc => true,
+            _ => false,
+        }
+    }
+}
+
+pub struct Whitespace<'a>(SyntaxToken<'a>);
+
+impl<'a> AstToken<'a> for Whitespace<'a> {
+    fn cast(token: SyntaxToken<'a>) -> Option<Self> {
+        if token.kind() == WHITESPACE {
+            Some(Whitespace(token))
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> SyntaxToken<'a> {
+        self.0
+    }
+}
+
+impl<'a> Whitespace<'a> {
+    pub fn spans_multiple_lines(&self) -> bool {
+        let text = self.text();
+        text.find('\n').map_or(false, |idx| text[idx + 1..].contains('\n'))
+    }
+}
diff --git a/crates/ra_syntax/src/ast/traits.rs b/crates/ra_syntax/src/ast/traits.rs
new file mode 100644
index 000000000..43d1509fa
--- /dev/null
+++ b/crates/ra_syntax/src/ast/traits.rs
@@ -0,0 +1,150 @@
+use itertools::Itertools;
+
+use crate::{
+    syntax_node::{SyntaxNodeChildren, SyntaxElementChildren},
+    ast::{self, child_opt, children, AstNode, AstToken, AstChildren},
+};
+
+pub trait TypeAscriptionOwner: AstNode {
+    fn ascribed_type(&self) -> Option<&ast::TypeRef> {
+        child_opt(self)
+    }
+}
+
+pub trait NameOwner: AstNode {
+    fn name(&self) -> Option<&ast::Name> {
+        child_opt(self)
+    }
+}
+
+pub trait VisibilityOwner: AstNode {
+    fn visibility(&self) -> Option<&ast::Visibility> {
+        child_opt(self)
+    }
+}
+
+pub trait LoopBodyOwner: AstNode {
+    fn loop_body(&self) -> Option<&ast::Block> {
+        child_opt(self)
+    }
+}
+
+pub trait ArgListOwner: AstNode {
+    fn arg_list(&self) -> Option<&ast::ArgList> {
+        child_opt(self)
+    }
+}
+
+pub trait FnDefOwner: AstNode {
+    fn functions(&self) -> AstChildren<ast::FnDef> {
+        children(self)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ItemOrMacro<'a> {
+    Item(&'a ast::ModuleItem),
+    Macro(&'a ast::MacroCall),
+}
+
+pub trait ModuleItemOwner: AstNode {
+    fn items(&self) -> AstChildren<ast::ModuleItem> {
+        children(self)
+    }
+    fn items_with_macros(&self) -> ItemOrMacroIter {
+        ItemOrMacroIter(self.syntax().children())
+    }
+}
+
+#[derive(Debug)]
+pub struct ItemOrMacroIter<'a>(SyntaxNodeChildren<'a>);
+
+impl<'a> Iterator for ItemOrMacroIter<'a> {
+    type Item = ItemOrMacro<'a>;
+    fn next(&mut self) -> Option<ItemOrMacro<'a>> {
+        loop {
+            let n = self.0.next()?;
+            if let Some(item) = ast::ModuleItem::cast(n) {
+                return Some(ItemOrMacro::Item(item));
+            }
+            if let Some(call) = ast::MacroCall::cast(n) {
+                return Some(ItemOrMacro::Macro(call));
+            }
+        }
+    }
+}
+
+pub trait TypeParamsOwner: AstNode {
+    fn type_param_list(&self) -> Option<&ast::TypeParamList> {
+        child_opt(self)
+    }
+
+    fn where_clause(&self) -> Option<&ast::WhereClause> {
+        child_opt(self)
+    }
+}
+
+pub trait TypeBoundsOwner: AstNode {
+    fn type_bound_list(&self) -> Option<&ast::TypeBoundList> {
+        child_opt(self)
+    }
+}
+
+pub trait AttrsOwner: AstNode {
+    fn attrs(&self) -> AstChildren<ast::Attr> {
+        children(self)
+    }
+    fn has_atom_attr(&self, atom: &str) -> bool {
+        self.attrs().filter_map(|x| x.as_atom()).any(|x| x == atom)
+    }
+}
+
+pub trait DocCommentsOwner: AstNode {
+    fn doc_comments(&self) -> CommentIter {
+        CommentIter { iter: self.syntax().children_with_tokens() }
+    }
+
+    /// Returns the textual content of a doc comment block as a single string.
+    /// That is, strips leading `///` (+ optional 1 character of whitespace)
+    /// and joins lines.
+    fn doc_comment_text(&self) -> Option<String> {
+        let mut has_comments = false;
+        let docs = self
+            .doc_comments()
+            .filter(|comment| comment.is_doc_comment())
+            .map(|comment| {
+                has_comments = true;
+                let prefix_len = comment.prefix().len();
+
+                let line = comment.text().as_str();
+
+                // Determine if the prefix or prefix + 1 char is stripped
+                let pos =
+                    if line.chars().nth(prefix_len).map(|c| c.is_whitespace()).unwrap_or(false) {
+                        prefix_len + 1
+                    } else {
+                        prefix_len
+                    };
+
+                line[pos..].to_owned()
+            })
+            .join("\n");
+
+        if has_comments {
+            Some(docs)
+        } else {
+            None
+        }
+    }
+}
+
+pub struct CommentIter<'a> {
+    iter: SyntaxElementChildren<'a>,
+}
+
+impl<'a> Iterator for CommentIter<'a> {
+    type Item = ast::Comment<'a>;
+    fn next(&mut self) -> Option<ast::Comment<'a>> {
+        self.iter.by_ref().find_map(|el| el.as_token().and_then(ast::Comment::cast))
+    }
+}