247 files changed, 11292 insertions, 10830 deletions
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 7e70dad3f..1a763fb47 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -13,7 +13,7 @@ unicode-xid = "0.1.0"
 itertools = "0.8.0"
 drop_bomb = "0.1.4"
 parking_lot = "0.7.0"
-rowan = "0.3.3"
+rowan = "0.4.0"
 # ideally, `serde` should be enabled by `ra_lsp_server`, but we enable it here
 # to reduce number of compilations
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index e2b4f0388..06b45135c 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -1,18 +1,14 @@
 pub mod visit;
-use rowan::TransparentNewType;
+use crate::{SyntaxNode, TextRange, TextUnit, AstNode, Direction, SyntaxToken, SyntaxElement};
-use crate::{SyntaxNode, TextRange, TextUnit, AstNode, Direction};
+pub use rowan::TokenAtOffset;
-pub use rowan::LeafAtOffset;
+pub fn find_token_at_offset(node: &SyntaxNode, offset: TextUnit) -> TokenAtOffset<SyntaxToken> {
+    match node.0.token_at_offset(offset) {
-pub fn find_leaf_at_offset(node: &SyntaxNode, offset: TextUnit) -> LeafAtOffset<&SyntaxNode> {
+        TokenAtOffset::None => TokenAtOffset::None,
-    match node.0.leaf_at_offset(offset) {
+        TokenAtOffset::Single(n) => TokenAtOffset::Single(n.into()),
-        LeafAtOffset::None => LeafAtOffset::None,
+        TokenAtOffset::Between(l, r) => TokenAtOffset::Between(l.into(), r.into()),
-        LeafAtOffset::Single(n) => LeafAtOffset::Single(SyntaxNode::from_repr(n)),
-        LeafAtOffset::Between(l, r) => {
-            LeafAtOffset::Between(SyntaxNode::from_repr(l), SyntaxNode::from_repr(r))
-        }
    }
 }
@@ -26,16 +22,29 @@ pub fn find_leaf_at_offset(node: &SyntaxNode, offset: TextUnit) -> LeafAtOffset<
 ///
 /// then the left node will be silently preferred.
 pub fn find_node_at_offset<N: AstNode>(syntax: &SyntaxNode, offset: TextUnit) -> Option<&N> {
-    find_leaf_at_offset(syntax, offset).find_map(|leaf| leaf.ancestors().find_map(N::cast))
+    find_token_at_offset(syntax, offset)
+        .find_map(|leaf| leaf.parent().ancestors().find_map(N::cast))
 }
 /// Finds the first sibling in the given direction which is not `trivia`
-pub fn non_trivia_sibling(node: &SyntaxNode, direction: Direction) -> Option<&SyntaxNode> {
+pub fn non_trivia_sibling(element: SyntaxElement, direction: Direction) -> Option<SyntaxElement> {
-    node.siblings(direction).skip(1).find(|node| !node.kind().is_trivia())
+    return match element {
+        SyntaxElement::Node(node) => node.siblings_with_tokens(direction).skip(1).find(not_trivia),
+        SyntaxElement::Token(token) => {
+            token.siblings_with_tokens(direction).skip(1).find(not_trivia)
+        }
+    };
+    fn not_trivia(element: &SyntaxElement) -> bool {
+        match element {
+            SyntaxElement::Node(_) => true,
+            SyntaxElement::Token(token) => !token.kind().is_trivia(),
+        }
+    }
 }
-pub fn find_covering_node(root: &SyntaxNode, range: TextRange) -> &SyntaxNode {
+pub fn find_covering_element(root: &SyntaxNode, range: TextRange) -> SyntaxElement {
-    SyntaxNode::from_repr(root.0.covering_node(range))
+    root.0.covering_node(range).into()
 }
 // Replace with `std::iter::successors` in `1.34.0`
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index a6fac07c4..9f5c41b0c 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -1,15 +1,24 @@
 //! Abstract Syntax Tree, layered on top of untyped `SyntaxNode`s
 mod generated;
+mod traits;
+mod tokens;
+mod extensions;
+mod expr_extensions;
 use std::marker::PhantomData;
-use itertools::Itertools;
-pub use self::generated::*;
 use crate::{
-    syntax_node::{SyntaxNode, SyntaxNodeChildren, TreeArc, RaTypes},
+    syntax_node::{SyntaxNode, SyntaxNodeChildren, TreeArc, RaTypes, SyntaxToken},
    SmolStr,
-    SyntaxKind::*,
+};
+pub use self::{
+    generated::*,
+    traits::*,
+    tokens::*,
+    extensions::{PathSegmentKind, StructKind, SelfParamKind},
+    expr_extensions::{ElseBranch, PrefixOp, BinOp, LiteralKind},
 };
 /// The main trait to go from untyped `SyntaxNode`  to a typed ast. The
@@ -25,412 +34,18 @@ pub trait AstNode:
    fn syntax(&self) -> &SyntaxNode;
 }
-pub trait AstToken: AstNode {
+/// Like `AstNode`, but wraps tokens rather than interior nodes.
-    fn text(&self) -> &SmolStr {
+pub trait AstToken<'a> {
-        self.syntax().leaf_text().unwrap()
+    fn cast(token: SyntaxToken<'a>) -> Option<Self>
-    }
+    where
-}
+        Self: Sized;
+    fn syntax(&self) -> SyntaxToken<'a>;
-pub trait TypeAscriptionOwner: AstNode {
+    fn text(&self) -> &'a SmolStr {
-    fn ascribed_type(&self) -> Option<&TypeRef> {
+        self.syntax().text()
-        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 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)
-    }
-}
-pub trait DocCommentsOwner: AstNode {
-    fn doc_comments(&self) -> AstChildren<Comment> {
-        children(self)
-    }
-    /// 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)
-        }
-    }
-}
-impl Attr {
-    pub fn is_inner(&self) -> bool {
-        let tt = match self.value() {
-            None => return false,
-            Some(tt) => tt,
-        };
-        let prev = match tt.syntax().prev_sibling() {
-            None => return false,
-            Some(prev) => prev,
-        };
-        prev.kind() == EXCL
-    }
-    pub fn as_atom(&self) -> Option<SmolStr> {
-        let tt = self.value()?;
-        let (_bra, attr, _ket) = tt.syntax().children().collect_tuple()?;
-        if attr.kind() == IDENT {
-            Some(attr.leaf_text().unwrap().clone())
-        } else {
-            None
-        }
-    }
-    pub fn as_call(&self) -> Option<(SmolStr, &TokenTree)> {
-        let tt = self.value()?;
-        let (_bra, attr, args, _ket) = tt.syntax().children().collect_tuple()?;
-        let args = TokenTree::cast(args)?;
-        if attr.kind() == IDENT {
-            Some((attr.leaf_text().unwrap().clone(), args))
-        } else {
-            None
-        }
-    }
-    pub fn as_named(&self) -> Option<SmolStr> {
-        let tt = self.value()?;
-        let attr = tt.syntax().children().nth(1)?;
-        if attr.kind() == IDENT {
-            Some(attr.leaf_text().unwrap().clone())
-        } else {
-            None
-        }
-    }
-}
-impl Comment {
-    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 fn count_newlines_lazy(&self) -> impl Iterator<Item = &()> {
-        self.text().chars().filter(|&c| c == '\n').map(|_| &())
-    }
-    pub fn has_newlines(&self) -> bool {
-        self.count_newlines_lazy().count() > 0
-    }
-}
-#[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,
-        }
-    }
-}
-impl Whitespace {
-    pub fn count_newlines_lazy(&self) -> impl Iterator<Item = &()> {
-        self.text().chars().filter(|&c| c == '\n').map(|_| &())
-    }
-    pub fn has_newlines(&self) -> bool {
-        self.text().contains('\n')
-    }
-}
-impl Name {
-    pub fn text(&self) -> &SmolStr {
-        let ident = self.syntax().first_child().unwrap();
-        ident.leaf_text().unwrap()
-    }
-}
-impl NameRef {
-    pub fn text(&self) -> &SmolStr {
-        let ident = self.syntax().first_child().unwrap();
-        ident.leaf_text().unwrap()
-    }
-}
-impl ImplBlock {
-    pub fn target_type(&self) -> Option<&TypeRef> {
-        match self.target() {
-            (Some(t), None) | (_, Some(t)) => Some(t),
-            _ => None,
-        }
-    }
-    pub fn target_trait(&self) -> Option<&TypeRef> {
-        match self.target() {
-            (Some(t), Some(_)) => Some(t),
-            _ => None,
-        }
-    }
-    fn target(&self) -> (Option<&TypeRef>, Option<&TypeRef>) {
-        let mut types = children(self);
-        let first = types.next();
-        let second = types.next();
-        (first, second)
-    }
-}
-impl Module {
-    pub fn has_semi(&self) -> bool {
-        match self.syntax().last_child() {
-            None => false,
-            Some(node) => node.kind() == SEMI,
-        }
-    }
-}
-impl LetStmt {
-    pub fn has_semi(&self) -> bool {
-        match self.syntax().last_child() {
-            None => false,
-            Some(node) => node.kind() == SEMI,
-        }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ElseBranchFlavor<'a> {
-    Block(&'a Block),
-    IfExpr(&'a IfExpr),
-}
-impl IfExpr {
-    pub fn then_branch(&self) -> Option<&Block> {
-        self.blocks().nth(0)
-    }
-    pub fn else_branch(&self) -> Option<ElseBranchFlavor> {
-        let res = match self.blocks().nth(1) {
-            Some(block) => ElseBranchFlavor::Block(block),
-            None => {
-                let elif: &IfExpr = child_opt(self)?;
-                ElseBranchFlavor::IfExpr(elif)
-            }
-        };
-        Some(res)
-    }
-    fn blocks(&self) -> AstChildren<Block> {
-        children(self)
-    }
-}
-impl ExprStmt {
-    pub fn has_semi(&self) -> bool {
-        match self.syntax().last_child() {
-            None => false,
-            Some(node) => node.kind() == SEMI,
-        }
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum PathSegmentKind<'a> {
-    Name(&'a NameRef),
-    SelfKw,
-    SuperKw,
-    CrateKw,
-}
-impl PathSegment {
-    pub fn parent_path(&self) -> &Path {
-        self.syntax().parent().and_then(Path::cast).expect("segments are always nested in paths")
-    }
-    pub fn kind(&self) -> Option<PathSegmentKind> {
-        let res = if let Some(name_ref) = self.name_ref() {
-            PathSegmentKind::Name(name_ref)
-        } else {
-            match self.syntax().first_child()?.kind() {
-                SELF_KW => PathSegmentKind::SelfKw,
-                SUPER_KW => PathSegmentKind::SuperKw,
-                CRATE_KW => PathSegmentKind::CrateKw,
-                _ => return None,
-            }
-        };
-        Some(res)
-    }
-    pub fn has_colon_colon(&self) -> bool {
-        match self.syntax.first_child().map(|s| s.kind()) {
-            Some(COLONCOLON) => true,
-            _ => false,
-        }
-    }
-}
-impl Path {
-    pub fn parent_path(&self) -> Option<&Path> {
-        self.syntax().parent().and_then(Path::cast)
-    }
-}
-impl UseTree {
-    pub fn has_star(&self) -> bool {
-        self.syntax().children().any(|it| it.kind() == STAR)
-    }
-}
-impl UseTreeList {
-    pub fn parent_use_tree(&self) -> &UseTree {
-        self.syntax()
-            .parent()
-            .and_then(UseTree::cast)
-            .expect("UseTreeLists are always nested in UseTrees")
-    }
-}
-impl RefPat {
-    pub fn is_mut(&self) -> bool {
-        self.syntax().children().any(|n| n.kind() == MUT_KW)
    }
 }
-fn child_opt<P: AstNode, C: AstNode>(parent: &P) -> Option<&C> {
+/// An iterator over `SyntaxNode` children of a particular AST type.
-    children(parent).next()
-}
-fn children<P: AstNode, C: AstNode>(parent: &P) -> AstChildren<C> {
-    AstChildren::new(parent.syntax())
-}
 #[derive(Debug)]
 pub struct AstChildren<'a, N> {
    inner: SyntaxNodeChildren<'a>,
@@ -446,310 +61,16 @@ impl<'a, N> AstChildren<'a, N> {
 impl<'a, N: AstNode + 'a> Iterator for AstChildren<'a, N> {
    type Item = &'a N;
    fn next(&mut self) -> Option<&'a N> {
-        loop {
+        self.inner.by_ref().find_map(N::cast)
-            if let Some(n) = N::cast(self.inner.next()?) {
-                return Some(n);
-            }
-        }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum StructFlavor<'a> {
-    Tuple(&'a PosFieldDefList),
-    Named(&'a NamedFieldDefList),
-    Unit,
-}
-impl StructFlavor<'_> {
-    fn from_node<N: AstNode>(node: &N) -> StructFlavor {
-        if let Some(nfdl) = child_opt::<_, NamedFieldDefList>(node) {
-            StructFlavor::Named(nfdl)
-        } else if let Some(pfl) = child_opt::<_, PosFieldDefList>(node) {
-            StructFlavor::Tuple(pfl)
-        } else {
-            StructFlavor::Unit
-        }
    }
 }
-impl StructDef {
+fn child_opt<P: AstNode, C: AstNode>(parent: &P) -> Option<&C> {
-    pub fn flavor(&self) -> StructFlavor {
+    children(parent).next()
-        StructFlavor::from_node(self)
-    }
-}
-impl EnumVariant {
-    pub fn parent_enum(&self) -> &EnumDef {
-        self.syntax()
-            .parent()
-            .and_then(|it| it.parent())
-            .and_then(EnumDef::cast)
-            .expect("EnumVariants are always nested in Enums")
-    }
-    pub fn flavor(&self) -> StructFlavor {
-        StructFlavor::from_node(self)
-    }
-}
-impl PointerType {
-    pub fn is_mut(&self) -> bool {
-        self.syntax().children().any(|n| n.kind() == MUT_KW)
-    }
-}
-impl ReferenceType {
-    pub fn is_mut(&self) -> bool {
-        self.syntax().children().any(|n| n.kind() == MUT_KW)
-    }
-}
-impl RefExpr {
-    pub fn is_mut(&self) -> bool {
-        self.syntax().children().any(|n| n.kind() == MUT_KW)
-    }
-}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum PrefixOp {
-    /// The `*` operator for dereferencing
-    Deref,
-    /// The `!` operator for logical inversion
-    Not,
-    /// The `-` operator for negation
-    Neg,
-}
-impl PrefixExpr {
-    pub fn op_kind(&self) -> Option<PrefixOp> {
-        match self.syntax().first_child()?.kind() {
-            STAR => Some(PrefixOp::Deref),
-            EXCL => Some(PrefixOp::Not),
-            MINUS => Some(PrefixOp::Neg),
-            _ => None,
-        }
-    }
-    pub fn op(&self) -> Option<&SyntaxNode> {
-        self.syntax().first_child()
-    }
-}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum BinOp {
-    /// The `||` operator for boolean OR
-    BooleanOr,
-    /// The `&&` operator for boolean AND
-    BooleanAnd,
-    /// The `==` operator for equality testing
-    EqualityTest,
-    /// The `!=` operator for equality testing
-    NegatedEqualityTest,
-    /// The `<=` operator for lesser-equal testing
-    LesserEqualTest,
-    /// The `>=` operator for greater-equal testing
-    GreaterEqualTest,
-    /// The `<` operator for comparison
-    LesserTest,
-    /// The `>` operator for comparison
-    GreaterTest,
-    /// The `+` operator for addition
-    Addition,
-    /// The `*` operator for multiplication
-    Multiplication,
-    /// The `-` operator for subtraction
-    Subtraction,
-    /// The `/` operator for division
-    Division,
-    /// The `%` operator for remainder after division
-    Remainder,
-    /// The `<<` operator for left shift
-    LeftShift,
-    /// The `>>` operator for right shift
-    RightShift,
-    /// The `^` operator for bitwise XOR
-    BitwiseXor,
-    /// The `|` operator for bitwise OR
-    BitwiseOr,
-    /// The `&` operator for bitwise AND
-    BitwiseAnd,
-    /// The `..` operator for right-open ranges
-    RangeRightOpen,
-    /// The `..=` operator for right-closed ranges
-    RangeRightClosed,
-    /// The `=` operator for assignment
-    Assignment,
-    /// The `+=` operator for assignment after addition
-    AddAssign,
-    /// The `/=` operator for assignment after division
-    DivAssign,
-    /// The `*=` operator for assignment after multiplication
-    MulAssign,
-    /// The `%=` operator for assignment after remainders
-    RemAssign,
-    /// The `>>=` operator for assignment after shifting right
-    ShrAssign,
-    /// The `<<=` operator for assignment after shifting left
-    ShlAssign,
-    /// The `-=` operator for assignment after subtraction
-    SubAssign,
-    /// The `|=` operator for assignment after bitwise OR
-    BitOrAssign,
-    /// The `&=` operator for assignment after bitwise AND
-    BitAndAssign,
-    /// The `^=` operator for assignment after bitwise XOR
-    BitXorAssign,
-}
-impl BinExpr {
-    fn op_details(&self) -> Option<(&SyntaxNode, BinOp)> {
-        self.syntax().children().find_map(|c| match c.kind() {
-            PIPEPIPE => Some((c, BinOp::BooleanOr)),
-            AMPAMP => Some((c, BinOp::BooleanAnd)),
-            EQEQ => Some((c, BinOp::EqualityTest)),
-            NEQ => Some((c, BinOp::NegatedEqualityTest)),
-            LTEQ => Some((c, BinOp::LesserEqualTest)),
-            GTEQ => Some((c, BinOp::GreaterEqualTest)),
-            L_ANGLE => Some((c, BinOp::LesserTest)),
-            R_ANGLE => Some((c, BinOp::GreaterTest)),
-            PLUS => Some((c, BinOp::Addition)),
-            STAR => Some((c, BinOp::Multiplication)),
-            MINUS => Some((c, BinOp::Subtraction)),
-            SLASH => Some((c, BinOp::Division)),
-            PERCENT => Some((c, BinOp::Remainder)),
-            SHL => Some((c, BinOp::LeftShift)),
-            SHR => Some((c, BinOp::RightShift)),
-            CARET => Some((c, BinOp::BitwiseXor)),
-            PIPE => Some((c, BinOp::BitwiseOr)),
-            AMP => Some((c, BinOp::BitwiseAnd)),
-            DOTDOT => Some((c, BinOp::RangeRightOpen)),
-            DOTDOTEQ => Some((c, BinOp::RangeRightClosed)),
-            EQ => Some((c, BinOp::Assignment)),
-            PLUSEQ => Some((c, BinOp::AddAssign)),
-            SLASHEQ => Some((c, BinOp::DivAssign)),
-            STAREQ => Some((c, BinOp::MulAssign)),
-            PERCENTEQ => Some((c, BinOp::RemAssign)),
-            SHREQ => Some((c, BinOp::ShrAssign)),
-            SHLEQ => Some((c, BinOp::ShlAssign)),
-            MINUSEQ => Some((c, BinOp::SubAssign)),
-            PIPEEQ => Some((c, BinOp::BitOrAssign)),
-            AMPEQ => Some((c, BinOp::BitAndAssign)),
-            CARETEQ => Some((c, BinOp::BitXorAssign)),
-            _ => None,
-        })
-    }
-    pub fn op_kind(&self) -> Option<BinOp> {
-        self.op_details().map(|t| t.1)
-    }
-    pub fn op(&self) -> Option<&SyntaxNode> {
-        self.op_details().map(|t| t.0)
-    }
-    pub fn lhs(&self) -> Option<&Expr> {
-        children(self).nth(0)
-    }
-    pub fn rhs(&self) -> Option<&Expr> {
-        children(self).nth(1)
-    }
-    pub fn sub_exprs(&self) -> (Option<&Expr>, Option<&Expr>) {
-        let mut children = children(self);
-        let first = children.next();
-        let second = children.next();
-        (first, second)
-    }
-}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum SelfParamFlavor {
-    /// self
-    Owned,
-    /// &self
-    Ref,
-    /// &mut self
-    MutRef,
-}
-impl SelfParam {
-    pub fn flavor(&self) -> SelfParamFlavor {
-        let borrowed = self.syntax().children().any(|n| n.kind() == AMP);
-        if borrowed {
-            // check for a `mut` coming after the & -- `mut &self` != `&mut self`
-            if self.syntax().children().skip_while(|n| n.kind() != AMP).any(|n| n.kind() == MUT_KW)
-            {
-                SelfParamFlavor::MutRef
-            } else {
-                SelfParamFlavor::Ref
-            }
-        } else {
-            SelfParamFlavor::Owned
-        }
-    }
-}
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub enum LiteralFlavor {
-    String,
-    ByteString,
-    Char,
-    Byte,
-    IntNumber { suffix: Option<SmolStr> },
-    FloatNumber { suffix: Option<SmolStr> },
-    Bool,
-}
-impl LiteralExpr {
-    pub fn flavor(&self) -> LiteralFlavor {
-        let syntax = self.syntax();
-        match syntax.kind() {
-            INT_NUMBER => {
-                let allowed_suffix_list = [
-                    "isize", "i128", "i64", "i32", "i16", "i8", "usize", "u128", "u64", "u32",
-                    "u16", "u8",
-                ];
-                let text = syntax.text().to_string();
-                let suffix = allowed_suffix_list
-                    .iter()
-                    .find(|&s| text.ends_with(s))
-                    .map(|&suf| SmolStr::new(suf));
-                LiteralFlavor::IntNumber { suffix: suffix }
-            }
-            FLOAT_NUMBER => {
-                let allowed_suffix_list = ["f64", "f32"];
-                let text = syntax.text().to_string();
-                let suffix = allowed_suffix_list
-                    .iter()
-                    .find(|&s| text.ends_with(s))
-                    .map(|&suf| SmolStr::new(suf));
-                LiteralFlavor::FloatNumber { suffix: suffix }
-            }
-            STRING | RAW_STRING => LiteralFlavor::String,
-            TRUE_KW | FALSE_KW => LiteralFlavor::Bool,
-            BYTE_STRING | RAW_BYTE_STRING => LiteralFlavor::ByteString,
-            CHAR => LiteralFlavor::Char,
-            BYTE => LiteralFlavor::Byte,
-            _ => unreachable!(),
-        }
-    }
-}
-impl NamedField {
-    pub fn parent_struct_lit(&self) -> &StructLit {
-        self.syntax().ancestors().find_map(StructLit::cast).unwrap()
-    }
 }
-impl BindPat {
+fn children<P: AstNode, C: AstNode>(parent: &P) -> AstChildren<C> {
-    pub fn is_mutable(&self) -> bool {
+    AstChildren::new(parent.syntax())
-        self.syntax().children().any(|n| n.kind() == MUT_KW)
-    }
-    pub fn is_ref(&self) -> bool {
-        self.syntax().children().any(|n| n.kind() == REF_KW)
-    }
 }
 #[test]
@@ -793,3 +114,70 @@ fn test_doc_comment_preserves_indents() {
    let module = file.syntax().descendants().find_map(Module::cast).unwrap();
    assert_eq!("doc1\n```\nfn foo() {\n    // ...\n}\n```", module.doc_comment_text().unwrap());
 }
+#[test]
+fn test_where_predicates() {
+    fn assert_bound(text: &str, bound: Option<&TypeBound>) {
+        assert_eq!(text, bound.unwrap().syntax().text().to_string());
+    }
+    let file = SourceFile::parse(
+        r#"
+fn foo()
+where
+   T: Clone + Copy + Debug + 'static,
+   'a: 'b + 'c,
+   Iterator::Item: 'a + Debug,
+   Iterator::Item: Debug + 'a,
+   <T as Iterator>::Item: Debug + 'a,
+   for<'a> F: Fn(&'a str)
+{}
+        "#,
+    );
+    let where_clause = file.syntax().descendants().find_map(WhereClause::cast).unwrap();
+    let mut predicates = where_clause.predicates();
+    let pred = predicates.next().unwrap();
+    let mut bounds = pred.type_bound_list().unwrap().bounds();
+    assert_eq!("T", pred.type_ref().unwrap().syntax().text().to_string());
+    assert_bound("Clone", bounds.next());
+    assert_bound("Copy", bounds.next());
+    assert_bound("Debug", bounds.next());
+    assert_bound("'static", bounds.next());
+    let pred = predicates.next().unwrap();
+    let mut bounds = pred.type_bound_list().unwrap().bounds();
+    assert_eq!("'a", pred.lifetime_token().unwrap().text());
+    assert_bound("'b", bounds.next());
+    assert_bound("'c", bounds.next());
+    let pred = predicates.next().unwrap();
+    let mut bounds = pred.type_bound_list().unwrap().bounds();
+    assert_eq!("Iterator::Item", pred.type_ref().unwrap().syntax().text().to_string());
+    assert_bound("'a", bounds.next());
+    let pred = predicates.next().unwrap();
+    let mut bounds = pred.type_bound_list().unwrap().bounds();
+    assert_eq!("Iterator::Item", pred.type_ref().unwrap().syntax().text().to_string());
+    assert_bound("Debug", bounds.next());
+    assert_bound("'a", bounds.next());
+    let pred = predicates.next().unwrap();
+    let mut bounds = pred.type_bound_list().unwrap().bounds();
+    assert_eq!("<T as Iterator>::Item", pred.type_ref().unwrap().syntax().text().to_string());
+    assert_bound("Debug", bounds.next());
+    assert_bound("'a", bounds.next());
+    let pred = predicates.next().unwrap();
+    let mut bounds = pred.type_bound_list().unwrap().bounds();
+    assert_eq!("for<'a> F", pred.type_ref().unwrap().syntax().text().to_string());
+    assert_bound("Fn(&'a str)", bounds.next());
+}
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
new file mode 100644
index 000000000..1d8313810
--- /dev/null
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -0,0 +1,252 @@
+//! Various extension methods to ast Expr Nodes, which are hard to code-generate.
+use crate::{
+    SyntaxToken, SyntaxElement, SmolStr,
+    ast::{self, AstNode, AstChildren, children, child_opt},
+    SyntaxKind::*
+};
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ElseBranch<'a> {
+    Block(&'a ast::Block),
+    IfExpr(&'a ast::IfExpr),
+}
+impl ast::IfExpr {
+    pub fn then_branch(&self) -> Option<&ast::Block> {
+        self.blocks().nth(0)
+    }
+    pub fn else_branch(&self) -> Option<ElseBranch> {
+        let res = match self.blocks().nth(1) {
+            Some(block) => ElseBranch::Block(block),
+            None => {
+                let elif: &ast::IfExpr = child_opt(self)?;
+                ElseBranch::IfExpr(elif)
+            }
+        };
+        Some(res)
+    }
+    fn blocks(&self) -> AstChildren<ast::Block> {
+        children(self)
+    }
+}
+impl ast::RefExpr {
+    pub fn is_mut(&self) -> bool {
+        self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
+    }
+}
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum PrefixOp {
+    /// The `*` operator for dereferencing
+    Deref,
+    /// The `!` operator for logical inversion
+    Not,
+    /// The `-` operator for negation
+    Neg,
+}
+impl ast::PrefixExpr {
+    pub fn op_kind(&self) -> Option<PrefixOp> {
+        match self.op_token()?.kind() {
+            STAR => Some(PrefixOp::Deref),
+            EXCL => Some(PrefixOp::Not),
+            MINUS => Some(PrefixOp::Neg),
+            _ => None,
+        }
+    }
+    pub fn op_token(&self) -> Option<SyntaxToken> {
+        self.syntax().first_child_or_token()?.as_token()
+    }
+}
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum BinOp {
+    /// The `||` operator for boolean OR
+    BooleanOr,
+    /// The `&&` operator for boolean AND
+    BooleanAnd,
+    /// The `==` operator for equality testing
+    EqualityTest,
+    /// The `!=` operator for equality testing
+    NegatedEqualityTest,
+    /// The `<=` operator for lesser-equal testing
+    LesserEqualTest,
+    /// The `>=` operator for greater-equal testing
+    GreaterEqualTest,
+    /// The `<` operator for comparison
+    LesserTest,
+    /// The `>` operator for comparison
+    GreaterTest,
+    /// The `+` operator for addition
+    Addition,
+    /// The `*` operator for multiplication
+    Multiplication,
+    /// The `-` operator for subtraction
+    Subtraction,
+    /// The `/` operator for division
+    Division,
+    /// The `%` operator for remainder after division
+    Remainder,
+    /// The `<<` operator for left shift
+    LeftShift,
+    /// The `>>` operator for right shift
+    RightShift,
+    /// The `^` operator for bitwise XOR
+    BitwiseXor,
+    /// The `|` operator for bitwise OR
+    BitwiseOr,
+    /// The `&` operator for bitwise AND
+    BitwiseAnd,
+    /// The `..` operator for right-open ranges
+    RangeRightOpen,
+    /// The `..=` operator for right-closed ranges
+    RangeRightClosed,
+    /// The `=` operator for assignment
+    Assignment,
+    /// The `+=` operator for assignment after addition
+    AddAssign,
+    /// The `/=` operator for assignment after division
+    DivAssign,
+    /// The `*=` operator for assignment after multiplication
+    MulAssign,
+    /// The `%=` operator for assignment after remainders
+    RemAssign,
+    /// The `>>=` operator for assignment after shifting right
+    ShrAssign,
+    /// The `<<=` operator for assignment after shifting left
+    ShlAssign,
+    /// The `-=` operator for assignment after subtraction
+    SubAssign,
+    /// The `|=` operator for assignment after bitwise OR
+    BitOrAssign,
+    /// The `&=` operator for assignment after bitwise AND
+    BitAndAssign,
+    /// The `^=` operator for assignment after bitwise XOR
+    BitXorAssign,
+}
+impl ast::BinExpr {
+    fn op_details(&self) -> Option<(SyntaxToken, BinOp)> {
+        self.syntax().children_with_tokens().filter_map(|it| it.as_token()).find_map(|c| {
+            match c.kind() {
+                PIPEPIPE => Some((c, BinOp::BooleanOr)),
+                AMPAMP => Some((c, BinOp::BooleanAnd)),
+                EQEQ => Some((c, BinOp::EqualityTest)),
+                NEQ => Some((c, BinOp::NegatedEqualityTest)),
+                LTEQ => Some((c, BinOp::LesserEqualTest)),
+                GTEQ => Some((c, BinOp::GreaterEqualTest)),
+                L_ANGLE => Some((c, BinOp::LesserTest)),
+                R_ANGLE => Some((c, BinOp::GreaterTest)),
+                PLUS => Some((c, BinOp::Addition)),
+                STAR => Some((c, BinOp::Multiplication)),
+                MINUS => Some((c, BinOp::Subtraction)),
+                SLASH => Some((c, BinOp::Division)),
+                PERCENT => Some((c, BinOp::Remainder)),
+                SHL => Some((c, BinOp::LeftShift)),
+                SHR => Some((c, BinOp::RightShift)),
+                CARET => Some((c, BinOp::BitwiseXor)),
+                PIPE => Some((c, BinOp::BitwiseOr)),
+                AMP => Some((c, BinOp::BitwiseAnd)),
+                DOTDOT => Some((c, BinOp::RangeRightOpen)),
+                DOTDOTEQ => Some((c, BinOp::RangeRightClosed)),
+                EQ => Some((c, BinOp::Assignment)),
+                PLUSEQ => Some((c, BinOp::AddAssign)),
+                SLASHEQ => Some((c, BinOp::DivAssign)),
+                STAREQ => Some((c, BinOp::MulAssign)),
+                PERCENTEQ => Some((c, BinOp::RemAssign)),
+                SHREQ => Some((c, BinOp::ShrAssign)),
+                SHLEQ => Some((c, BinOp::ShlAssign)),
+                MINUSEQ => Some((c, BinOp::SubAssign)),
+                PIPEEQ => Some((c, BinOp::BitOrAssign)),
+                AMPEQ => Some((c, BinOp::BitAndAssign)),
+                CARETEQ => Some((c, BinOp::BitXorAssign)),
+                _ => None,
+            }
+        })
+    }
+    pub fn op_kind(&self) -> Option<BinOp> {
+        self.op_details().map(|t| t.1)
+    }
+    pub fn op_token(&self) -> Option<SyntaxToken> {
+        self.op_details().map(|t| t.0)
+    }
+    pub fn lhs(&self) -> Option<&ast::Expr> {
+        children(self).nth(0)
+    }
+    pub fn rhs(&self) -> Option<&ast::Expr> {
+        children(self).nth(1)
+    }
+    pub fn sub_exprs(&self) -> (Option<&ast::Expr>, Option<&ast::Expr>) {
+        let mut children = children(self);
+        let first = children.next();
+        let second = children.next();
+        (first, second)
+    }
+}
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum LiteralKind {
+    String,
+    ByteString,
+    Char,
+    Byte,
+    IntNumber { suffix: Option<SmolStr> },
+    FloatNumber { suffix: Option<SmolStr> },
+    Bool,
+}
+impl ast::Literal {
+    pub fn token(&self) -> SyntaxToken {
+        match self.syntax().first_child_or_token().unwrap() {
+            SyntaxElement::Token(token) => token,
+            _ => unreachable!(),
+        }
+    }
+    pub fn kind(&self) -> LiteralKind {
+        match self.token().kind() {
+            INT_NUMBER => {
+                let allowed_suffix_list = [
+                    "isize", "i128", "i64", "i32", "i16", "i8", "usize", "u128", "u64", "u32",
+                    "u16", "u8",
+                ];
+                let text = self.token().text().to_string();
+                let suffix = allowed_suffix_list
+                    .iter()
+                    .find(|&s| text.ends_with(s))
+                    .map(|&suf| SmolStr::new(suf));
+                LiteralKind::IntNumber { suffix }
+            }
+            FLOAT_NUMBER => {
+                let allowed_suffix_list = ["f64", "f32"];
+                let text = self.token().text().to_string();
+                let suffix = allowed_suffix_list
+                    .iter()
+                    .find(|&s| text.ends_with(s))
+                    .map(|&suf| SmolStr::new(suf));
+                LiteralKind::FloatNumber { suffix: suffix }
+            }
+            STRING | RAW_STRING => LiteralKind::String,
+            TRUE_KW | FALSE_KW => LiteralKind::Bool,
+            BYTE_STRING | RAW_BYTE_STRING => LiteralKind::ByteString,
+            CHAR => LiteralKind::Char,
+            BYTE => LiteralKind::Byte,
+            _ => unreachable!(),
+        }
+    }
+}
+impl ast::NamedField {
+    pub fn parent_struct_lit(&self) -> &ast::StructLit {
+        self.syntax().ancestors().find_map(ast::StructLit::cast).unwrap()
+    }
+}
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
new file mode 100644
index 000000000..aec57c380
--- /dev/null
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -0,0 +1,303 @@
+//! Various extension methods to ast Nodes, which are hard to code-generate.
+//! Extensions for various expressions live in a sibling `expr_extensions` module.
+use itertools::Itertools;
+use crate::{
+    SmolStr, SyntaxToken,
+    ast::{self, AstNode, children, child_opt},
+    SyntaxKind::*,
+};
+impl ast::Name {
+    pub fn text(&self) -> &SmolStr {
+        let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap();
+        ident.text()
+    }
+}
+impl ast::NameRef {
+    pub fn text(&self) -> &SmolStr {
+        let ident = self.syntax().first_child_or_token().unwrap().as_token().unwrap();
+        ident.text()
+    }
+}
+impl ast::Attr {
+    pub fn is_inner(&self) -> bool {
+        let tt = match self.value() {
+            None => return false,
+            Some(tt) => tt,
+        };
+        let prev = match tt.syntax().prev_sibling() {
+            None => return false,
+            Some(prev) => prev,
+        };
+        prev.kind() == EXCL
+    }
+    pub fn as_atom(&self) -> Option<SmolStr> {
+        let tt = self.value()?;
+        let (_bra, attr, _ket) = tt.syntax().children_with_tokens().collect_tuple()?;
+        if attr.kind() == IDENT {
+            Some(attr.as_token()?.text().clone())
+        } else {
+            None
+        }
+    }
+    pub fn as_call(&self) -> Option<(SmolStr, &ast::TokenTree)> {
+        let tt = self.value()?;
+        let (_bra, attr, args, _ket) = tt.syntax().children_with_tokens().collect_tuple()?;
+        let args = ast::TokenTree::cast(args.as_node()?)?;
+        if attr.kind() == IDENT {
+            Some((attr.as_token()?.text().clone(), args))
+        } else {
+            None
+        }
+    }
+    pub fn as_named(&self) -> Option<SmolStr> {
+        let tt = self.value()?;
+        let attr = tt.syntax().children_with_tokens().nth(1)?;
+        if attr.kind() == IDENT {
+            Some(attr.as_token()?.text().clone())
+        } else {
+            None
+        }
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PathSegmentKind<'a> {
+    Name(&'a ast::NameRef),
+    SelfKw,
+    SuperKw,
+    CrateKw,
+}
+impl ast::PathSegment {
+    pub fn parent_path(&self) -> &ast::Path {
+        self.syntax()
+            .parent()
+            .and_then(ast::Path::cast)
+            .expect("segments are always nested in paths")
+    }
+    pub fn kind(&self) -> Option<PathSegmentKind> {
+        let res = if let Some(name_ref) = self.name_ref() {
+            PathSegmentKind::Name(name_ref)
+        } else {
+            match self.syntax().first_child_or_token()?.kind() {
+                SELF_KW => PathSegmentKind::SelfKw,
+                SUPER_KW => PathSegmentKind::SuperKw,
+                CRATE_KW => PathSegmentKind::CrateKw,
+                _ => return None,
+            }
+        };
+        Some(res)
+    }
+    pub fn has_colon_colon(&self) -> bool {
+        match self.syntax.first_child_or_token().map(|s| s.kind()) {
+            Some(COLONCOLON) => true,
+            _ => false,
+        }
+    }
+}
+impl ast::Path {
+    pub fn parent_path(&self) -> Option<&ast::Path> {
+        self.syntax().parent().and_then(ast::Path::cast)
+    }
+}
+impl ast::Module {
+    pub fn has_semi(&self) -> bool {
+        match self.syntax().last_child_or_token() {
+            None => false,
+            Some(node) => node.kind() == SEMI,
+        }
+    }
+}
+impl ast::UseTree {
+    pub fn has_star(&self) -> bool {
+        self.syntax().children_with_tokens().any(|it| it.kind() == STAR)
+    }
+}
+impl ast::UseTreeList {
+    pub fn parent_use_tree(&self) -> &ast::UseTree {
+        self.syntax()
+            .parent()
+            .and_then(ast::UseTree::cast)
+            .expect("UseTreeLists are always nested in UseTrees")
+    }
+}
+impl ast::ImplBlock {
+    pub fn target_type(&self) -> Option<&ast::TypeRef> {
+        match self.target() {
+            (Some(t), None) | (_, Some(t)) => Some(t),
+            _ => None,
+        }
+    }
+    pub fn target_trait(&self) -> Option<&ast::TypeRef> {
+        match self.target() {
+            (Some(t), Some(_)) => Some(t),
+            _ => None,
+        }
+    }
+    fn target(&self) -> (Option<&ast::TypeRef>, Option<&ast::TypeRef>) {
+        let mut types = children(self);
+        let first = types.next();
+        let second = types.next();
+        (first, second)
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum StructKind<'a> {
+    Tuple(&'a ast::PosFieldDefList),
+    Named(&'a ast::NamedFieldDefList),
+    Unit,
+}
+impl StructKind<'_> {
+    fn from_node<N: AstNode>(node: &N) -> StructKind {
+        if let Some(nfdl) = child_opt::<_, ast::NamedFieldDefList>(node) {
+            StructKind::Named(nfdl)
+        } else if let Some(pfl) = child_opt::<_, ast::PosFieldDefList>(node) {
+            StructKind::Tuple(pfl)
+        } else {
+            StructKind::Unit
+        }
+    }
+}
+impl ast::StructDef {
+    pub fn kind(&self) -> StructKind {
+        StructKind::from_node(self)
+    }
+}
+impl ast::EnumVariant {
+    pub fn parent_enum(&self) -> &ast::EnumDef {
+        self.syntax()
+            .parent()
+            .and_then(|it| it.parent())
+            .and_then(ast::EnumDef::cast)
+            .expect("EnumVariants are always nested in Enums")
+    }
+    pub fn kind(&self) -> StructKind {
+        StructKind::from_node(self)
+    }
+}
+impl ast::LetStmt {
+    pub fn has_semi(&self) -> bool {
+        match self.syntax().last_child_or_token() {
+            None => false,
+            Some(node) => node.kind() == SEMI,
+        }
+    }
+}
+impl ast::ExprStmt {
+    pub fn has_semi(&self) -> bool {
+        match self.syntax().last_child_or_token() {
+            None => false,
+            Some(node) => node.kind() == SEMI,
+        }
+    }
+}
+impl ast::RefPat {
+    pub fn is_mut(&self) -> bool {
+        self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
+    }
+}
+impl ast::BindPat {
+    pub fn is_mutable(&self) -> bool {
+        self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
+    }
+    pub fn is_ref(&self) -> bool {
+        self.syntax().children_with_tokens().any(|n| n.kind() == REF_KW)
+    }
+}
+impl ast::PointerType {
+    pub fn is_mut(&self) -> bool {
+        self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
+    }
+}
+impl ast::ReferenceType {
+    pub fn is_mut(&self) -> bool {
+        self.syntax().children_with_tokens().any(|n| n.kind() == MUT_KW)
+    }
+}
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum SelfParamKind {
+    /// self
+    Owned,
+    /// &self
+    Ref,
+    /// &mut self
+    MutRef,
+}
+impl ast::SelfParam {
+    pub fn self_kw_token(&self) -> SyntaxToken {
+        self.syntax()
+            .children_with_tokens()
+            .filter_map(|it| it.as_token())
+            .find(|it| it.kind() == SELF_KW)
+            .expect("invalid tree: self param must have self")
+    }
+    pub fn kind(&self) -> SelfParamKind {
+        let borrowed = self.syntax().children_with_tokens().any(|n| n.kind() == AMP);
+        if borrowed {
+            // check for a `mut` coming after the & -- `mut &self` != `&mut self`
+            if self
+                .syntax()
+                .children_with_tokens()
+                .skip_while(|n| n.kind() != AMP)
+                .any(|n| n.kind() == MUT_KW)
+            {
+                SelfParamKind::MutRef
+            } else {
+                SelfParamKind::Ref
+            }
+        } else {
+            SelfParamKind::Owned
+        }
+    }
+}
+impl ast::LifetimeParam {
+    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
+        self.syntax()
+            .children_with_tokens()
+            .filter_map(|it| it.as_token())
+            .find(|it| it.kind() == LIFETIME)
+    }
+}
+impl ast::WherePred {
+    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
+        self.syntax()
+            .children_with_tokens()
+            .filter_map(|it| it.as_token())
+            .find(|it| it.kind() == LIFETIME)
+    }
+}
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 84f39cda1..0376c91c8 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -376,64 +376,6 @@ impl BreakExpr {
    }
 }
-// Byte
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct Byte {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for Byte {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for Byte {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            BYTE => Some(Byte::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for Byte {
-    type Owned = TreeArc<Byte>;
-    fn to_owned(&self) -> TreeArc<Byte> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for Byte {}
-impl Byte {}
-// ByteString
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct ByteString {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for ByteString {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for ByteString {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            BYTE_STRING => Some(ByteString::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for ByteString {
-    type Owned = TreeArc<ByteString>;
-    fn to_owned(&self) -> TreeArc<ByteString> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for ByteString {}
-impl ByteString {}
 // CallExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -503,64 +445,6 @@ impl CastExpr {
    }
 }
-// Char
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct Char {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for Char {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for Char {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            CHAR => Some(Char::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for Char {
-    type Owned = TreeArc<Char>;
-    fn to_owned(&self) -> TreeArc<Char> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for Char {}
-impl Char {}
-// Comment
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct Comment {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for Comment {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for Comment {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            COMMENT => Some(Comment::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for Comment {
-    type Owned = TreeArc<Comment>;
-    fn to_owned(&self) -> TreeArc<Comment> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for Comment {}
-impl Comment {}
 // Condition
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -689,6 +573,7 @@ impl ToOwned for DynTraitType {
 }
+impl ast::TypeBoundsOwner for DynTraitType {}
 impl DynTraitType {}
 // EnumDef
@@ -834,6 +719,7 @@ pub enum ExprKind<'a> {
    RangeExpr(&'a RangeExpr),
    BinExpr(&'a BinExpr),
    Literal(&'a Literal),
+    MacroCall(&'a MacroCall),
 }
 impl<'a> From<&'a TupleExpr> for &'a Expr {
    fn from(n: &'a TupleExpr) -> &'a Expr {
@@ -970,6 +856,11 @@ impl<'a> From<&'a Literal> for &'a Expr {
        Expr::cast(&n.syntax).unwrap()
    }
 }
+impl<'a> From<&'a MacroCall> for &'a Expr {
+    fn from(n: &'a MacroCall) -> &'a Expr {
+        Expr::cast(&n.syntax).unwrap()
+    }
+}
 impl AstNode for Expr {
@@ -1001,7 +892,8 @@ impl AstNode for Expr {
            | PREFIX_EXPR
            | RANGE_EXPR
            | BIN_EXPR
-            | LITERAL => Some(Expr::from_repr(syntax.into_repr())),
+            | LITERAL
+            | MACRO_CALL => Some(Expr::from_repr(syntax.into_repr())),
            _ => None,
        }
    }
@@ -1043,6 +935,7 @@ impl Expr {
            RANGE_EXPR => ExprKind::RangeExpr(RangeExpr::cast(&self.syntax).unwrap()),
            BIN_EXPR => ExprKind::BinExpr(BinExpr::cast(&self.syntax).unwrap()),
            LITERAL => ExprKind::Literal(Literal::cast(&self.syntax).unwrap()),
+            MACRO_CALL => ExprKind::MacroCall(MacroCall::cast(&self.syntax).unwrap()),
            _ => unreachable!(),
        }
    }
@@ -1118,35 +1011,6 @@ impl ExternCrateItem {
    }
 }
-// FalseKw
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct FalseKw {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for FalseKw {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for FalseKw {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            FALSE_KW => Some(FalseKw::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for FalseKw {
-    type Owned = TreeArc<FalseKw>;
-    fn to_owned(&self) -> TreeArc<FalseKw> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for FalseKw {}
-impl FalseKw {}
 // FieldExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -1252,35 +1116,6 @@ impl FieldPatList {
    }
 }
-// FloatNumber
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct FloatNumber {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for FloatNumber {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for FloatNumber {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            FLOAT_NUMBER => Some(FloatNumber::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for FloatNumber {
-    type Owned = TreeArc<FloatNumber>;
-    fn to_owned(&self) -> TreeArc<FloatNumber> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for FloatNumber {}
-impl FloatNumber {}
 // FnDef
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -1585,6 +1420,7 @@ impl ToOwned for ImplTraitType {
 }
+impl ast::TypeBoundsOwner for ImplTraitType {}
 impl ImplTraitType {}
 // IndexExpr
@@ -1615,35 +1451,6 @@ impl ToOwned for IndexExpr {
 impl IndexExpr {}
-// IntNumber
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct IntNumber {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for IntNumber {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for IntNumber {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            INT_NUMBER => Some(IntNumber::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for IntNumber {
-    type Owned = TreeArc<IntNumber>;
-    fn to_owned(&self) -> TreeArc<IntNumber> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for IntNumber {}
-impl IntNumber {}
 // ItemList
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -1779,35 +1586,6 @@ impl LetStmt {
    }
 }
-// Lifetime
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct Lifetime {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for Lifetime {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for Lifetime {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            LIFETIME => Some(Lifetime::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for Lifetime {
-    type Owned = TreeArc<Lifetime>;
-    fn to_owned(&self) -> TreeArc<Lifetime> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for Lifetime {}
-impl Lifetime {}
 // LifetimeArg
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -1834,11 +1612,7 @@ impl ToOwned for LifetimeArg {
 }
-impl LifetimeArg {
+impl LifetimeArg {}
-    pub fn lifetime(&self) -> Option<&Lifetime> {
-        super::child_opt(self)
-    }
-}
 // LifetimeParam
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -1867,11 +1641,7 @@ impl ToOwned for LifetimeParam {
 impl ast::AttrsOwner for LifetimeParam {}
-impl LifetimeParam {
+impl LifetimeParam {}
-    pub fn lifetime(&self) -> Option<&Lifetime> {
-        super::child_opt(self)
-    }
-}
 // Literal
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -1899,130 +1669,7 @@ impl ToOwned for Literal {
 }
-impl Literal {
+impl Literal {}
-    pub fn literal_expr(&self) -> Option<&LiteralExpr> {
-        super::child_opt(self)
-    }
-}
-// LiteralExpr
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct LiteralExpr {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for LiteralExpr {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum LiteralExprKind<'a> {
-    String(&'a String),
-    ByteString(&'a ByteString),
-    RawString(&'a RawString),
-    RawByteString(&'a RawByteString),
-    Char(&'a Char),
-    Byte(&'a Byte),
-    IntNumber(&'a IntNumber),
-    FloatNumber(&'a FloatNumber),
-    TrueKw(&'a TrueKw),
-    FalseKw(&'a FalseKw),
-}
-impl<'a> From<&'a String> for &'a LiteralExpr {
-    fn from(n: &'a String) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a ByteString> for &'a LiteralExpr {
-    fn from(n: &'a ByteString) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a RawString> for &'a LiteralExpr {
-    fn from(n: &'a RawString) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a RawByteString> for &'a LiteralExpr {
-    fn from(n: &'a RawByteString) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a Char> for &'a LiteralExpr {
-    fn from(n: &'a Char) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a Byte> for &'a LiteralExpr {
-    fn from(n: &'a Byte) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a IntNumber> for &'a LiteralExpr {
-    fn from(n: &'a IntNumber) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a FloatNumber> for &'a LiteralExpr {
-    fn from(n: &'a FloatNumber) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a TrueKw> for &'a LiteralExpr {
-    fn from(n: &'a TrueKw) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl<'a> From<&'a FalseKw> for &'a LiteralExpr {
-    fn from(n: &'a FalseKw) -> &'a LiteralExpr {
-        LiteralExpr::cast(&n.syntax).unwrap()
-    }
-}
-impl AstNode for LiteralExpr {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            | STRING
-            | BYTE_STRING
-            | RAW_STRING
-            | RAW_BYTE_STRING
-            | CHAR
-            | BYTE
-            | INT_NUMBER
-            | FLOAT_NUMBER
-            | TRUE_KW
-            | FALSE_KW => Some(LiteralExpr::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for LiteralExpr {
-    type Owned = TreeArc<LiteralExpr>;
-    fn to_owned(&self) -> TreeArc<LiteralExpr> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl LiteralExpr {
-    pub fn kind(&self) -> LiteralExprKind {
-        match self.syntax.kind() {
-            STRING => LiteralExprKind::String(String::cast(&self.syntax).unwrap()),
-            BYTE_STRING => LiteralExprKind::ByteString(ByteString::cast(&self.syntax).unwrap()),
-            RAW_STRING => LiteralExprKind::RawString(RawString::cast(&self.syntax).unwrap()),
-            RAW_BYTE_STRING => LiteralExprKind::RawByteString(RawByteString::cast(&self.syntax).unwrap()),
-            CHAR => LiteralExprKind::Char(Char::cast(&self.syntax).unwrap()),
-            BYTE => LiteralExprKind::Byte(Byte::cast(&self.syntax).unwrap()),
-            INT_NUMBER => LiteralExprKind::IntNumber(IntNumber::cast(&self.syntax).unwrap()),
-            FLOAT_NUMBER => LiteralExprKind::FloatNumber(FloatNumber::cast(&self.syntax).unwrap()),
-            TRUE_KW => LiteralExprKind::TrueKw(TrueKw::cast(&self.syntax).unwrap()),
-            FALSE_KW => LiteralExprKind::FalseKw(FalseKw::cast(&self.syntax).unwrap()),
-            _ => unreachable!(),
-        }
-    }
-}
-impl LiteralExpr {}
 // LiteralPat
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -3406,64 +3053,6 @@ impl ToOwned for RangePat {
 impl RangePat {}
-// RawByteString
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct RawByteString {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for RawByteString {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for RawByteString {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            RAW_BYTE_STRING => Some(RawByteString::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for RawByteString {
-    type Owned = TreeArc<RawByteString>;
-    fn to_owned(&self) -> TreeArc<RawByteString> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for RawByteString {}
-impl RawByteString {}
-// RawString
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct RawString {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for RawString {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for RawString {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            RAW_STRING => Some(RawString::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for RawString {
-    type Owned = TreeArc<RawString>;
-    fn to_owned(&self) -> TreeArc<RawString> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for RawString {}
-impl RawString {}
 // RefExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -3624,34 +3213,6 @@ impl ReturnExpr {
    }
 }
-// SelfKw
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct SelfKw {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for SelfKw {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for SelfKw {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            SELF_KW => Some(SelfKw::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for SelfKw {
-    type Owned = TreeArc<SelfKw>;
-    fn to_owned(&self) -> TreeArc<SelfKw> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl SelfKw {}
 // SelfParam
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -3679,11 +3240,7 @@ impl ToOwned for SelfParam {
 impl ast::TypeAscriptionOwner for SelfParam {}
-impl SelfParam {
+impl SelfParam {}
-    pub fn self_kw(&self) -> Option<&SelfKw> {
-        super::child_opt(self)
-    }
-}
 // SlicePat
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -3872,35 +3429,6 @@ impl Stmt {
 impl Stmt {}
-// String
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct String {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for String {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for String {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            STRING => Some(String::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for String {
-    type Owned = TreeArc<String>;
-    fn to_owned(&self) -> TreeArc<String> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for String {}
-impl String {}
 // StructDef
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -4069,41 +3597,13 @@ impl ast::NameOwner for TraitDef {}
 impl ast::AttrsOwner for TraitDef {}
 impl ast::DocCommentsOwner for TraitDef {}
 impl ast::TypeParamsOwner for TraitDef {}
+impl ast::TypeBoundsOwner for TraitDef {}
 impl TraitDef {
    pub fn item_list(&self) -> Option<&ItemList> {
        super::child_opt(self)
    }
 }
-// TrueKw
-#[derive(Debug, PartialEq, Eq, Hash)]
-#[repr(transparent)]
-pub struct TrueKw {
-    pub(crate) syntax: SyntaxNode,
-}
-unsafe impl TransparentNewType for TrueKw {
-    type Repr = rowan::SyntaxNode<RaTypes>;
-}
-impl AstNode for TrueKw {
-    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
-        match syntax.kind() {
-            TRUE_KW => Some(TrueKw::from_repr(syntax.into_repr())),
-            _ => None,
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode { &self.syntax }
-}
-impl ToOwned for TrueKw {
-    type Owned = TreeArc<TrueKw>;
-    fn to_owned(&self) -> TreeArc<TrueKw> { TreeArc::cast(self.syntax.to_owned()) }
-}
-impl ast::AstToken for TrueKw {}
-impl TrueKw {}
 // TryExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -4299,6 +3799,7 @@ impl ast::NameOwner for TypeAliasDef {}
 impl ast::TypeParamsOwner for TypeAliasDef {}
 impl ast::AttrsOwner for TypeAliasDef {}
 impl ast::DocCommentsOwner for TypeAliasDef {}
+impl ast::TypeBoundsOwner for TypeAliasDef {}
 impl TypeAliasDef {
    pub fn type_ref(&self) -> Option<&TypeRef> {
        super::child_opt(self)
@@ -4377,6 +3878,70 @@ impl TypeArgList {
    }
 }
+// TypeBound
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct TypeBound {
+    pub(crate) syntax: SyntaxNode,
+}
+unsafe impl TransparentNewType for TypeBound {
+    type Repr = rowan::SyntaxNode<RaTypes>;
+}
+impl AstNode for TypeBound {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+        match syntax.kind() {
+            TYPE_BOUND => Some(TypeBound::from_repr(syntax.into_repr())),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+impl ToOwned for TypeBound {
+    type Owned = TreeArc<TypeBound>;
+    fn to_owned(&self) -> TreeArc<TypeBound> { TreeArc::cast(self.syntax.to_owned()) }
+}
+impl TypeBound {
+    pub fn type_ref(&self) -> Option<&TypeRef> {
+        super::child_opt(self)
+    }
+}
+// TypeBoundList
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct TypeBoundList {
+    pub(crate) syntax: SyntaxNode,
+}
+unsafe impl TransparentNewType for TypeBoundList {
+    type Repr = rowan::SyntaxNode<RaTypes>;
+}
+impl AstNode for TypeBoundList {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+        match syntax.kind() {
+            TYPE_BOUND_LIST => Some(TypeBoundList::from_repr(syntax.into_repr())),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+impl ToOwned for TypeBoundList {
+    type Owned = TreeArc<TypeBoundList>;
+    fn to_owned(&self) -> TreeArc<TypeBoundList> { TreeArc::cast(self.syntax.to_owned()) }
+}
+impl TypeBoundList {
+    pub fn bounds(&self) -> impl Iterator<Item = &TypeBound> {
+        super::children(self)
+    }
+}
 // TypeParam
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
@@ -4405,6 +3970,7 @@ impl ToOwned for TypeParam {
 impl ast::NameOwner for TypeParam {}
 impl ast::AttrsOwner for TypeParam {}
+impl ast::TypeBoundsOwner for TypeParam {}
 impl TypeParam {}
 // TypeParamList
@@ -4745,67 +4311,75 @@ impl ToOwned for WhereClause {
 }
-impl WhereClause {}
+impl WhereClause {
+    pub fn predicates(&self) -> impl Iterator<Item = &WherePred> {
+        super::children(self)
+    }
+}
-// WhileExpr
+// WherePred
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
-pub struct WhileExpr {
+pub struct WherePred {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for WhileExpr {
+unsafe impl TransparentNewType for WherePred {
    type Repr = rowan::SyntaxNode<RaTypes>;
 }
-impl AstNode for WhileExpr {
+impl AstNode for WherePred {
    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
        match syntax.kind() {
-            WHILE_EXPR => Some(WhileExpr::from_repr(syntax.into_repr())),
+            WHERE_PRED => Some(WherePred::from_repr(syntax.into_repr())),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for WhileExpr {
+impl ToOwned for WherePred {
-    type Owned = TreeArc<WhileExpr>;
+    type Owned = TreeArc<WherePred>;
-    fn to_owned(&self) -> TreeArc<WhileExpr> { TreeArc::cast(self.syntax.to_owned()) }
+    fn to_owned(&self) -> TreeArc<WherePred> { TreeArc::cast(self.syntax.to_owned()) }
 }
-impl ast::LoopBodyOwner for WhileExpr {}
+impl ast::TypeBoundsOwner for WherePred {}
-impl WhileExpr {
+impl WherePred {
-    pub fn condition(&self) -> Option<&Condition> {
+    pub fn type_ref(&self) -> Option<&TypeRef> {
        super::child_opt(self)
    }
 }
-// Whitespace
+// WhileExpr
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
-pub struct Whitespace {
+pub struct WhileExpr {
    pub(crate) syntax: SyntaxNode,
 }
-unsafe impl TransparentNewType for Whitespace {
+unsafe impl TransparentNewType for WhileExpr {
    type Repr = rowan::SyntaxNode<RaTypes>;
 }
-impl AstNode for Whitespace {
+impl AstNode for WhileExpr {
    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
        match syntax.kind() {
-            WHITESPACE => Some(Whitespace::from_repr(syntax.into_repr())),
+            WHILE_EXPR => Some(WhileExpr::from_repr(syntax.into_repr())),
            _ => None,
        }
    }
    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
-impl ToOwned for Whitespace {
+impl ToOwned for WhileExpr {
-    type Owned = TreeArc<Whitespace>;
+    type Owned = TreeArc<WhileExpr>;
-    fn to_owned(&self) -> TreeArc<Whitespace> { TreeArc::cast(self.syntax.to_owned()) }
+    fn to_owned(&self) -> TreeArc<WhileExpr> { TreeArc::cast(self.syntax.to_owned()) }
 }
-impl ast::AstToken for Whitespace {}
+impl ast::LoopBodyOwner for WhileExpr {}
-impl Whitespace {}
+impl WhileExpr {
+    pub fn condition(&self) -> Option<&Condition> {
+        super::child_opt(self)
+    }
+}
diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs
new file mode 100644
index 000000000..08882ea69
--- /dev/null
+++ b/crates/ra_syntax/src/ast/tokens.rs
@@ -0,0 +1,113 @@
+//! There are many AstNodes, but only a few tokens, so we hand-write them here.
+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 kind(&self) -> CommentKind {
+        kind_by_prefix(self.text())
+    }
+    pub fn prefix(&self) -> &'static str {
+        prefix_by_kind(self.kind())
+    }
+}
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct CommentKind {
+    pub shape: CommentShape,
+    pub doc: Option<CommentPlacement>,
+}
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum CommentShape {
+    Line,
+    Block,
+}
+impl CommentShape {
+    pub fn is_line(self) -> bool {
+        self == CommentShape::Line
+    }
+    pub fn is_block(self) -> bool {
+        self == CommentShape::Block
+    }
+}
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum CommentPlacement {
+    Inner,
+    Outer,
+}
+const COMMENT_PREFIX_TO_KIND: &[(&str, CommentKind)] = {
+    use {CommentShape::*, CommentPlacement::*};
+    &[
+        ("///", CommentKind { shape: Line, doc: Some(Outer) }),
+        ("//!", CommentKind { shape: Line, doc: Some(Inner) }),
+        ("/**", CommentKind { shape: Block, doc: Some(Outer) }),
+        ("/*!", CommentKind { shape: Block, doc: Some(Inner) }),
+        ("//", CommentKind { shape: Line, doc: None }),
+        ("/*", CommentKind { shape: Block, doc: None }),
+    ]
+};
+fn kind_by_prefix(text: &str) -> CommentKind {
+    for (prefix, kind) in COMMENT_PREFIX_TO_KIND.iter() {
+        if text.starts_with(prefix) {
+            return *kind;
+        }
+    }
+    panic!("bad comment text: {:?}", text)
+}
+fn prefix_by_kind(kind: CommentKind) -> &'static str {
+    for (prefix, k) in COMMENT_PREFIX_TO_KIND.iter() {
+        if *k == kind {
+            return prefix;
+        }
+    }
+    unreachable!()
+}
+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..aaf07d731
--- /dev/null
+++ b/crates/ra_syntax/src/ast/traits.rs
@@ -0,0 +1,154 @@
+//! Various traits that are implemented by ast nodes.
+//!
+//! The implementations are usually trivial, and live in generated.rs
+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.kind().doc.is_some())
+            .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))
+    }
+}
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index a21c3917d..0a35e25d5 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -243,6 +243,8 @@ Grammar(
        "PARAM",
        "SELF_PARAM",
        "ARG_LIST",
+        "TYPE_BOUND",
+        "TYPE_BOUND_LIST",
    ],
    ast: {
        "SourceFile": (
@@ -293,7 +295,7 @@ Grammar(
        "EnumVariantList": ( collections: [["variants", "EnumVariant"]] ),
        "EnumVariant": ( traits: ["NameOwner", "DocCommentsOwner", "AttrsOwner"], options: ["Expr"] ),
        "TraitDef": (
-            traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner", "TypeParamsOwner"],
+            traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner", "TypeParamsOwner", "TypeBoundsOwner"],
            options: ["ItemList"]
        ),
        "Module": (
@@ -332,7 +334,8 @@ Grammar(
                "NameOwner",
                "TypeParamsOwner",
                "AttrsOwner",
-                "DocCommentsOwner"
+                "DocCommentsOwner",
+                "TypeBoundsOwner",
            ],
            options: ["TypeRef"]
        ),
@@ -349,8 +352,12 @@ Grammar(
        "PlaceholderType": (),
        "FnPointerType": (options: ["ParamList", "RetType"]),
        "ForType": (options: ["TypeRef"]),
-        "ImplTraitType": (),
+        "ImplTraitType": (
-        "DynTraitType": (),
+            traits: ["TypeBoundsOwner"],
+        ),
+        "DynTraitType": (
+            traits: ["TypeBoundsOwner"],
+        ),
        "TypeRef": ( enum: [
            "ParenType",
@@ -458,31 +465,7 @@ Grammar(
        "RangeExpr": (),
        "BinExpr": (),
-        "IntNumber": ( traits: ["AstToken"] ),
+        "Literal": (),
-        "FloatNumber": ( traits: ["AstToken"] ),
-        "String": ( traits: ["AstToken"] ),
-        "RawString": ( traits: ["AstToken"] ),
-        "Byte": ( traits: ["AstToken"] ),
-        "RawByteString": ( traits: ["AstToken"] ),
-        "ByteString": ( traits: ["AstToken"] ),
-        "Char": ( traits: ["AstToken"] ),
-        "TrueKw": ( traits: ["AstToken"] ),
-        "FalseKw": ( traits: ["AstToken"] ),
-        "LiteralExpr": (
-            enum: [
-                "String",
-                "ByteString",
-                "RawString",
-                "RawByteString",
-                "Char",
-                "Byte",
-                "IntNumber",
-                "FloatNumber",
-                "TrueKw",
-                "FalseKw",
-            ]
-        ),
-        "Literal": (options: ["LiteralExpr"]),
        "Expr": (
            enum: [
@@ -513,6 +496,7 @@ Grammar(
                "RangeExpr",
                "BinExpr",
                "Literal",
+                "MacroCall",
            ],
        ),
@@ -573,13 +557,33 @@ Grammar(
                ["lifetime_params", "LifetimeParam" ],
            ]
        ),
-        "TypeParam": ( traits: ["NameOwner", "AttrsOwner"] ),
+        "TypeParam": ( traits: ["NameOwner", "AttrsOwner", "TypeBoundsOwner"] ),
        "LifetimeParam": (
-            options: [ "Lifetime"],
            traits: ["AttrsOwner"],
        ),
-        "Lifetime": ( traits: ["AstToken"] ),
+        "TypeBound": (
-        "WhereClause": (),
+            options: [
+                "TypeRef",
+            ]
+        ),
+        "TypeBoundList": (
+            collections: [
+                ["bounds", "TypeBound"],
+            ]
+        ),
+        "WherePred": (
+            options: [
+                "TypeRef",
+            ],
+            traits: [
+                "TypeBoundsOwner",
+            ],
+        ),
+        "WhereClause": (
+            collections: [
+                ["predicates", "WherePred"],
+            ],
+        ),
        "ExprStmt": (
            options: [ ["expr", "Expr"] ]
        ),
@@ -614,12 +618,10 @@ Grammar(
            ]
        ),
        "SelfParam": (
-            options: ["SelfKw"],
            traits: [
                "TypeAscriptionOwner",
            ]
        ),
-        "SelfKw": (),
        "Param": (
            options: [ "Pat" ],
            traits: [
@@ -663,8 +665,6 @@ Grammar(
        ]),
        "TypeArg": (options: ["TypeRef"]),
        "AssocTypeArg": (options: ["NameRef", "TypeRef"]),
-        "LifetimeArg": (options: ["Lifetime"]),
+        "LifetimeArg": (),
-        "Comment": ( traits: ["AstToken"] ),
-        "Whitespace": ( traits: ["AstToken"] ),
    },
 )
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 4f3020440..e1088e296 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -38,7 +38,7 @@ pub use crate::{
    ast::AstNode,
    syntax_error::{SyntaxError, SyntaxErrorKind, Location},
    syntax_text::SyntaxText,
-    syntax_node::{Direction,  SyntaxNode, WalkEvent, TreeArc, SyntaxTreeBuilder},
+    syntax_node::{Direction,  SyntaxNode, WalkEvent, TreeArc, SyntaxTreeBuilder, SyntaxElement, SyntaxToken},
    ptr::{SyntaxNodePtr, AstPtr},
    parsing::{tokenize, Token},
 };
@@ -70,7 +70,7 @@ impl SourceFile {
    pub fn incremental_reparse(&self, edit: &AtomTextEdit) -> Option<TreeArc<SourceFile>> {
        parsing::incremental_reparse(self.syntax(), edit, self.errors())
-            .map(|(green_node, errors)| SourceFile::new(green_node, errors))
+            .map(|(green_node, errors, _reparsed_range)| SourceFile::new(green_node, errors))
    }
    fn full_reparse(&self, edit: &AtomTextEdit) -> TreeArc<SourceFile> {
@@ -179,15 +179,23 @@ fn api_walkthrough() {
    // There's a bunch of traversal methods on `SyntaxNode`:
    assert_eq!(expr_syntax.parent(), Some(block.syntax()));
-    assert_eq!(block.syntax().first_child().map(|it| it.kind()), Some(SyntaxKind::L_CURLY));
+    assert_eq!(
-    assert_eq!(expr_syntax.next_sibling().map(|it| it.kind()), Some(SyntaxKind::WHITESPACE));
+        block.syntax().first_child_or_token().map(|it| it.kind()),
+        Some(SyntaxKind::L_CURLY)
+    );
+    assert_eq!(
+        expr_syntax.next_sibling_or_token().map(|it| it.kind()),
+        Some(SyntaxKind::WHITESPACE)
+    );
    // As well as some iterator helpers:
    let f = expr_syntax.ancestors().find_map(ast::FnDef::cast);
    assert_eq!(f, Some(&*func));
-    assert!(expr_syntax.siblings(Direction::Next).any(|it| it.kind() == SyntaxKind::R_CURLY));
+    assert!(expr_syntax
+        .siblings_with_tokens(Direction::Next)
+        .any(|it| it.kind() == SyntaxKind::R_CURLY));
    assert_eq!(
-        expr_syntax.descendants().count(),
+        expr_syntax.descendants_with_tokens().count(),
        8, // 5 tokens `1`, ` `, `+`, ` `, `!`
           // 2 child literal expressions: `1`, `1`
           // 1 the node itself: `1 + 1`
@@ -196,16 +204,14 @@ fn api_walkthrough() {
    // There's also a `preorder` method with a more fine-grained iteration control:
    let mut buf = String::new();
    let mut indent = 0;
-    for event in expr_syntax.preorder() {
+    for event in expr_syntax.preorder_with_tokens() {
        match event {
            WalkEvent::Enter(node) => {
-                buf += &format!(
+                let text = match node {
-                    "{:indent$}{:?} {:?}\n",
+                    SyntaxElement::Node(it) => it.text().to_string(),
-                    " ",
+                    SyntaxElement::Token(it) => it.text().to_string(),
-                    node.text(),
+                };
-                    node.kind(),
+                buf += &format!("{:indent$}{:?} {:?}\n", " ", text, node.kind(), indent = indent);
-                    indent = indent
-                );
                indent += 2;
            }
            WalkEvent::Leave(_) => indent -= 2,
diff --git a/crates/ra_syntax/src/parsing/reparsing.rs b/crates/ra_syntax/src/parsing/reparsing.rs
index 7e7f914f5..69887f500 100644
--- a/crates/ra_syntax/src/parsing/reparsing.rs
+++ b/crates/ra_syntax/src/parsing/reparsing.rs
@@ -12,7 +12,7 @@ use ra_parser::Reparser;
 use crate::{
    SyntaxKind::*, TextRange, TextUnit, SyntaxError,
    algo,
-    syntax_node::{GreenNode, SyntaxNode},
+    syntax_node::{GreenNode, SyntaxNode, GreenToken, SyntaxElement},
    parsing::{
        text_token_source::TextTokenSource,
        text_tree_sink::TextTreeSink,
@@ -24,60 +24,62 @@ pub(crate) fn incremental_reparse(
    node: &SyntaxNode,
    edit: &AtomTextEdit,
    errors: Vec<SyntaxError>,
-) -> Option<(GreenNode, Vec<SyntaxError>)> {
+) -> Option<(GreenNode, Vec<SyntaxError>, TextRange)> {
-    let (node, green, new_errors) =
+    if let Some((green, old_range)) = reparse_token(node, &edit) {
-        reparse_leaf(node, &edit).or_else(|| reparse_block(node, &edit))?;
+        return Some((green, merge_errors(errors, Vec::new(), old_range, edit), old_range));
-    let green_root = node.replace_with(green);
+    }
-    let errors = merge_errors(errors, new_errors, node, edit);
-    Some((green_root, errors))
+    if let Some((green, new_errors, old_range)) = reparse_block(node, &edit) {
+        return Some((green, merge_errors(errors, new_errors, old_range, edit), old_range));
+    }
+    None
 }
-fn reparse_leaf<'node>(
+fn reparse_token<'node>(
    root: &'node SyntaxNode,
    edit: &AtomTextEdit,
-) -> Option<(&'node SyntaxNode, GreenNode, Vec<SyntaxError>)> {
+) -> Option<(GreenNode, TextRange)> {
-    let node = algo::find_covering_node(root, edit.delete);
+    let token = algo::find_covering_element(root, edit.delete).as_token()?;
-    match node.kind() {
+    match token.kind() {
        WHITESPACE | COMMENT | IDENT | STRING | RAW_STRING => {
-            if node.kind() == WHITESPACE || node.kind() == COMMENT {
+            if token.kind() == WHITESPACE || token.kind() == COMMENT {
                // removing a new line may extends previous token
-                if node.text().to_string()[edit.delete - node.range().start()].contains('\n') {
+                if token.text().to_string()[edit.delete - token.range().start()].contains('\n') {
                    return None;
                }
            }
-            let text = get_text_after_edit(node, &edit);
+            let text = get_text_after_edit(token.into(), &edit);
-            let tokens = tokenize(&text);
+            let lex_tokens = tokenize(&text);
-            let token = match tokens[..] {
+            let lex_token = match lex_tokens[..] {
-                [token] if token.kind == node.kind() => token,
+                [lex_token] if lex_token.kind == token.kind() => lex_token,
                _ => return None,
            };
-            if token.kind == IDENT && is_contextual_kw(&text) {
+            if lex_token.kind == IDENT && is_contextual_kw(&text) {
                return None;
            }
-            if let Some(next_char) = root.text().char_at(node.range().end()) {
+            if let Some(next_char) = root.text().char_at(token.range().end()) {
                let tokens_with_next_char = tokenize(&format!("{}{}", text, next_char));
                if tokens_with_next_char.len() == 1 {
                    return None;
                }
            }
-            let green = GreenNode::new_leaf(node.kind(), text.into());
+            let new_token = GreenToken::new(token.kind(), text.into());
-            let new_errors = vec![];
+            Some((token.replace_with(new_token), token.range()))
-            Some((node, green, new_errors))
        }
        _ => None,
    }
 }
 fn reparse_block<'node>(
-    node: &'node SyntaxNode,
+    root: &'node SyntaxNode,
    edit: &AtomTextEdit,
-) -> Option<(&'node SyntaxNode, GreenNode, Vec<SyntaxError>)> {
+) -> Option<(GreenNode, Vec<SyntaxError>, TextRange)> {
-    let (node, reparser) = find_reparsable_node(node, edit.delete)?;
+    let (node, reparser) = find_reparsable_node(root, edit.delete)?;
-    let text = get_text_after_edit(node, &edit);
+    let text = get_text_after_edit(node.into(), &edit);
    let tokens = tokenize(&text);
    if !is_balanced(&tokens) {
        return None;
@@ -86,12 +88,16 @@ fn reparse_block<'node>(
    let mut tree_sink = TextTreeSink::new(&text, &tokens);
    reparser.parse(&token_source, &mut tree_sink);
    let (green, new_errors) = tree_sink.finish();
-    Some((node, green, new_errors))
+    Some((node.replace_with(green), new_errors, node.range()))
 }
-fn get_text_after_edit(node: &SyntaxNode, edit: &AtomTextEdit) -> String {
+fn get_text_after_edit(element: SyntaxElement, edit: &AtomTextEdit) -> String {
-    let edit = AtomTextEdit::replace(edit.delete - node.range().start(), edit.insert.clone());
+    let edit = AtomTextEdit::replace(edit.delete - element.range().start(), edit.insert.clone());
-    edit.apply(node.text().to_string())
+    let text = match element {
+        SyntaxElement::Token(token) => token.text().to_string(),
+        SyntaxElement::Node(node) => node.text().to_string(),
+    };
+    edit.apply(text)
 }
 fn is_contextual_kw(text: &str) -> bool {
@@ -102,9 +108,13 @@ fn is_contextual_kw(text: &str) -> bool {
 }
 fn find_reparsable_node(node: &SyntaxNode, range: TextRange) -> Option<(&SyntaxNode, Reparser)> {
-    let node = algo::find_covering_node(node, range);
+    let node = algo::find_covering_element(node, range);
-    node.ancestors().find_map(|node| {
+    let mut ancestors = match node {
-        let first_child = node.first_child().map(|it| it.kind());
+        SyntaxElement::Token(it) => it.parent().ancestors(),
+        SyntaxElement::Node(it) => it.ancestors(),
+    };
+    ancestors.find_map(|node| {
+        let first_child = node.first_child_or_token().map(|it| it.kind());
        let parent = node.parent().map(|it| it.kind());
        Reparser::for_node(node.kind(), first_child, parent).map(|r| (node, r))
    })
@@ -136,19 +146,19 @@ fn is_balanced(tokens: &[Token]) -> bool {
 fn merge_errors(
    old_errors: Vec<SyntaxError>,
    new_errors: Vec<SyntaxError>,
-    old_node: &SyntaxNode,
+    old_range: TextRange,
    edit: &AtomTextEdit,
 ) -> Vec<SyntaxError> {
    let mut res = Vec::new();
    for e in old_errors {
-        if e.offset() <= old_node.range().start() {
+        if e.offset() <= old_range.start() {
            res.push(e)
-        } else if e.offset() >= old_node.range().end() {
+        } else if e.offset() >= old_range.end() {
            res.push(e.add_offset(TextUnit::of_str(&edit.insert), edit.delete.len()));
        }
    }
    for e in new_errors {
-        res.push(e.add_offset(old_node.range().start(), 0.into()));
+        res.push(e.add_offset(old_range.start(), 0.into()));
    }
    res
 }
@@ -160,13 +170,7 @@ mod tests {
    use crate::{SourceFile, AstNode};
    use super::*;
-    fn do_check<F>(before: &str, replace_with: &str, reparser: F)
+    fn do_check(before: &str, replace_with: &str, reparsed_len: u32) {
-    where
-        for<'a> F: Fn(
-            &'a SyntaxNode,
-            &AtomTextEdit,
-        ) -> Option<(&'a SyntaxNode, GreenNode, Vec<SyntaxError>)>,
-    {
        let (range, before) = extract_range(before);
        let edit = AtomTextEdit::replace(range, replace_with.to_owned());
        let after = edit.apply(before.clone());
@@ -175,23 +179,20 @@ mod tests {
        let incrementally_reparsed = {
            let f = SourceFile::parse(&before);
            let edit = AtomTextEdit { delete: range, insert: replace_with.to_string() };
-            let (node, green, new_errors) =
+            let (green, new_errors, range) =
-                reparser(f.syntax(), &edit).expect("cannot incrementally reparse");
+                incremental_reparse(f.syntax(), &edit, f.errors()).unwrap();
-            let green_root = node.replace_with(green);
+            assert_eq!(range.len(), reparsed_len.into(), "reparsed fragment has wrong length");
-            let errors = super::merge_errors(f.errors(), new_errors, node, &edit);
+            SourceFile::new(green, new_errors)
-            SourceFile::new(green_root, errors)
        };
        assert_eq_text!(
            &fully_reparsed.syntax().debug_dump(),
            &incrementally_reparsed.syntax().debug_dump(),
-        )
+        );
    }
-    #[test]
+    #[test] // FIXME: some test here actually test token reparsing
    fn reparse_block_tests() {
-        let do_check = |before, replace_to| do_check(before, replace_to, reparse_block);
        do_check(
            r"
 fn foo() {
@@ -199,6 +200,7 @@ fn foo() {
 }
 ",
            "baz",
+            3,
        );
        do_check(
            r"
@@ -207,6 +209,7 @@ fn foo() {
 }
 ",
            "baz",
+            25,
        );
        do_check(
            r"
@@ -215,6 +218,7 @@ struct Foo {
 }
 ",
            ",\n    g: (),",
+            14,
        );
        do_check(
            r"
@@ -225,6 +229,7 @@ fn foo {
 }
 ",
            "62",
+            31, // FIXME: reparse only int literal here
        );
        do_check(
            r"
@@ -233,7 +238,9 @@ mod foo {
 }
 ",
            "bar",
+            11,
        );
        do_check(
            r"
 trait Foo {
@@ -241,6 +248,7 @@ trait Foo {
 }
 ",
            "Output",
+            3,
        );
        do_check(
            r"
@@ -249,13 +257,9 @@ impl IntoIterator<Item=i32> for Foo {
 }
 ",
            "n next(",
+            9,
        );
-        do_check(
+        do_check(r"use a::b::{foo,<|>,bar<|>};", "baz", 10);
-            r"
-use a::b::{foo,<|>,bar<|>};
-    ",
-            "baz",
-        );
        do_check(
            r"
 pub enum A {
@@ -263,12 +267,14 @@ pub enum A {
 }
 ",
            "\nBar;\n",
+            11,
        );
        do_check(
            r"
 foo!{a, b<|><|> d}
 ",
            ", c[3]",
+            8,
        );
        do_check(
            r"
@@ -277,6 +283,7 @@ fn foo() {
 }
 ",
            "123",
+            14,
        );
        do_check(
            r"
@@ -285,54 +292,60 @@ extern {
 }
 ",
            " exit(code: c_int)",
+            11,
        );
    }
    #[test]
-    fn reparse_leaf_tests() {
+    fn reparse_token_tests() {
-        let do_check = |before, replace_to| do_check(before, replace_to, reparse_leaf);
        do_check(
            r"<|><|>
 fn foo() -> i32 { 1 }
 ",
            "\n\n\n   \n",
+            1,
        );
        do_check(
            r"
 fn foo() -> <|><|> {}
 ",
            "  \n",
+            2,
        );
        do_check(
            r"
 fn <|>foo<|>() -> i32 { 1 }
 ",
            "bar",
+            3,
        );
        do_check(
            r"
 fn foo<|><|>foo() {  }
 ",
            "bar",
+            6,
        );
        do_check(
            r"
 fn foo /* <|><|> */ () {}
 ",
            "some comment",
+            6,
        );
        do_check(
            r"
 fn baz <|><|> () {}
 ",
            "    \t\t\n\n",
+            2,
        );
        do_check(
            r"
 fn baz <|><|> () {}
 ",
            "    \t\t\n\n",
+            2,
        );
        do_check(
            r"
@@ -340,24 +353,28 @@ fn baz <|><|> () {}
 mod { }
 ",
            "c",
+            14,
        );
        do_check(
            r#"
 fn -> &str { "Hello<|><|>" }
 "#,
            ", world",
+            7,
        );
        do_check(
            r#"
 fn -> &str { // "Hello<|><|>"
 "#,
            ", world",
+            10,
        );
        do_check(
            r##"
 fn -> &str { r#"Hello<|><|>"#
 "##,
            ", world",
+            10,
        );
        do_check(
            r"
@@ -367,6 +384,7 @@ enum Foo {
 }
 ",
            "Clone",
+            4,
        );
    }
 }
diff --git a/crates/ra_syntax/src/parsing/text_tree_sink.rs b/crates/ra_syntax/src/parsing/text_tree_sink.rs
index b17d06c61..71fc515f2 100644
--- a/crates/ra_syntax/src/parsing/text_tree_sink.rs
+++ b/crates/ra_syntax/src/parsing/text_tree_sink.rs
@@ -28,10 +28,10 @@ enum State {
 }
 impl<'a> TreeSink for TextTreeSink<'a> {
-    fn leaf(&mut self, kind: SyntaxKind, n_tokens: u8) {
+    fn token(&mut self, kind: SyntaxKind, n_tokens: u8) {
        match mem::replace(&mut self.state, State::Normal) {
            State::PendingStart => unreachable!(),
-            State::PendingFinish => self.inner.finish_branch(),
+            State::PendingFinish => self.inner.finish_node(),
            State::Normal => (),
        }
        self.eat_trivias();
@@ -40,18 +40,18 @@ impl<'a> TreeSink for TextTreeSink<'a> {
            .iter()
            .map(|it| it.len)
            .sum::<TextUnit>();
-        self.do_leaf(kind, len, n_tokens);
+        self.do_token(kind, len, n_tokens);
    }
-    fn start_branch(&mut self, kind: SyntaxKind) {
+    fn start_node(&mut self, kind: SyntaxKind) {
        match mem::replace(&mut self.state, State::Normal) {
            State::PendingStart => {
-                self.inner.start_branch(kind);
+                self.inner.start_node(kind);
                // No need to attach trivias to previous node: there is no
                // previous node.
                return;
            }
-            State::PendingFinish => self.inner.finish_branch(),
+            State::PendingFinish => self.inner.finish_node(),
            State::Normal => (),
        }
@@ -71,14 +71,14 @@ impl<'a> TreeSink for TextTreeSink<'a> {
            n_attached_trivias(kind, leading_trivias)
        };
        self.eat_n_trivias(n_trivias - n_attached_trivias);
-        self.inner.start_branch(kind);
+        self.inner.start_node(kind);
        self.eat_n_trivias(n_attached_trivias);
    }
-    fn finish_branch(&mut self) {
+    fn finish_node(&mut self) {
        match mem::replace(&mut self.state, State::PendingFinish) {
            State::PendingStart => unreachable!(),
-            State::PendingFinish => self.inner.finish_branch(),
+            State::PendingFinish => self.inner.finish_node(),
            State::Normal => (),
        }
    }
@@ -104,7 +104,7 @@ impl<'a> TextTreeSink<'a> {
        match mem::replace(&mut self.state, State::Normal) {
            State::PendingFinish => {
                self.eat_trivias();
-                self.inner.finish_branch()
+                self.inner.finish_node()
            }
            State::PendingStart | State::Normal => unreachable!(),
        }
@@ -117,7 +117,7 @@ impl<'a> TextTreeSink<'a> {
            if !token.kind.is_trivia() {
                break;
            }
-            self.do_leaf(token.kind, token.len, 1);
+            self.do_token(token.kind, token.len, 1);
        }
    }
@@ -125,16 +125,16 @@ impl<'a> TextTreeSink<'a> {
        for _ in 0..n {
            let token = self.tokens[self.token_pos];
            assert!(token.kind.is_trivia());
-            self.do_leaf(token.kind, token.len, 1);
+            self.do_token(token.kind, token.len, 1);
        }
    }
-    fn do_leaf(&mut self, kind: SyntaxKind, len: TextUnit, n_tokens: usize) {
+    fn do_token(&mut self, kind: SyntaxKind, len: TextUnit, n_tokens: usize) {
        let range = TextRange::offset_len(self.text_pos, len);
        let text: SmolStr = self.text[range].into();
        self.text_pos += len;
        self.token_pos += n_tokens;
-        self.inner.leaf(kind, text);
+        self.inner.token(kind, text);
    }
 }
diff --git a/crates/ra_syntax/src/string_lexing.rs b/crates/ra_syntax/src/string_lexing.rs
index 349733f3f..4c3eea3d2 100644
--- a/crates/ra_syntax/src/string_lexing.rs
+++ b/crates/ra_syntax/src/string_lexing.rs
@@ -1,7 +1,333 @@
-mod parser;
+use crate::{TextRange, TextUnit};
-mod string;
+use self::StringComponentKind::*;
-pub use self::{
+#[derive(Debug, Eq, PartialEq, Clone)]
-    parser::{StringComponent, StringComponentKind},
+pub(crate) struct StringComponent {
-    string::{parse_string_literal, parse_char_literal, parse_byte_literal, parse_byte_string_literal},
+    pub(crate) range: TextRange,
-};
+    pub(crate) kind: StringComponentKind,
+}
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub(crate) enum StringComponentKind {
+    IgnoreNewline,
+    CodePoint,
+    AsciiEscape,
+    AsciiCodeEscape,
+    UnicodeEscape,
+}
+pub(crate) fn parse_quoted_literal(
+    prefix: Option<char>,
+    quote: char,
+    src: &str,
+) -> StringComponentIter {
+    let prefix = prefix.map(|p| match p {
+        'b' => b'b',
+        _ => panic!("invalid prefix"),
+    });
+    let quote = match quote {
+        '\'' => b'\'',
+        '"' => b'"',
+        _ => panic!("invalid quote"),
+    };
+    StringComponentIter { src, prefix, quote, pos: 0, has_closing_quote: false, suffix: None }
+}
+pub(crate) struct StringComponentIter<'a> {
+    src: &'a str,
+    prefix: Option<u8>,
+    quote: u8,
+    pos: usize,
+    pub(crate) has_closing_quote: bool,
+    pub(crate) suffix: Option<TextRange>,
+}
+impl<'a> Iterator for StringComponentIter<'a> {
+    type Item = StringComponent;
+    fn next(&mut self) -> Option<StringComponent> {
+        if self.pos == 0 {
+            if let Some(prefix) = self.prefix {
+                assert!(
+                    self.advance() == prefix as char,
+                    "literal should start with a {:?}",
+                    prefix as char,
+                );
+            }