31 files changed, 821 insertions, 226 deletions
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 66cf32524..756acf415 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -96,6 +96,7 @@ mod fill_match_arms;
 mod merge_match_arms;
 mod introduce_variable;
 mod inline_local_variable;
+mod raw_string;
 mod replace_if_let_with_match;
 mod split_import;
 mod remove_dbg;
@@ -125,6 +126,10 @@ fn all_assists<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assis
        move_guard::move_guard_to_arm_body,
        move_guard::move_arm_cond_to_match_guard,
        move_bounds::move_bounds_to_where_clause,
+        raw_string::add_hash,
+        raw_string::make_raw_string,
+        raw_string::make_usual_string,
+        raw_string::remove_hash,
    ]
 }
diff --git a/crates/ra_assists/src/raw_string.rs b/crates/ra_assists/src/raw_string.rs
new file mode 100644
index 000000000..e00267060
--- /dev/null
+++ b/crates/ra_assists/src/raw_string.rs
@@ -0,0 +1,370 @@
+use hir::db::HirDatabase;
+use ra_syntax::{ast::AstNode, ast::Literal, TextRange, TextUnit};
+use crate::{Assist, AssistCtx, AssistId};
+pub(crate) fn make_raw_string(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let literal = ctx.node_at_offset::<Literal>()?;
+    if literal.token().kind() != ra_syntax::SyntaxKind::STRING {
+        return None;
+    }
+    ctx.add_action(AssistId("make_raw_string"), "make raw string", |edit| {
+        edit.target(literal.syntax().text_range());
+        edit.insert(literal.syntax().text_range().start(), "r");
+    });
+    ctx.build()
+}
+fn find_usual_string_range(s: &str) -> Option<TextRange> {
+    Some(TextRange::from_to(
+        TextUnit::from(s.find('"')? as u32),
+        TextUnit::from(s.rfind('"')? as u32),
+    ))
+}
+pub(crate) fn make_usual_string(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let literal = ctx.node_at_offset::<Literal>()?;
+    if literal.token().kind() != ra_syntax::SyntaxKind::RAW_STRING {
+        return None;
+    }
+    let token = literal.token();
+    let text = token.text().as_str();
+    let usual_string_range = find_usual_string_range(text)?;
+    ctx.add_action(AssistId("make_usual_string"), "make usual string", |edit| {
+        edit.target(literal.syntax().text_range());
+        // parse inside string to escape `"`
+        let start_of_inside = usual_string_range.start().to_usize() + 1;
+        let end_of_inside = usual_string_range.end().to_usize();
+        let inside_str = &text[start_of_inside..end_of_inside];
+        let escaped = inside_str.escape_default().to_string();
+        edit.replace(literal.syntax().text_range(), format!("\"{}\"", escaped));
+    });
+    ctx.build()
+}
+pub(crate) fn add_hash(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let literal = ctx.node_at_offset::<Literal>()?;
+    if literal.token().kind() != ra_syntax::SyntaxKind::RAW_STRING {
+        return None;
+    }
+    ctx.add_action(AssistId("add_hash"), "add hash to raw string", |edit| {
+        edit.target(literal.syntax().text_range());
+        edit.insert(literal.syntax().text_range().start() + TextUnit::of_char('r'), "#");
+        edit.insert(literal.syntax().text_range().end(), "#");
+    });
+    ctx.build()
+}
+pub(crate) fn remove_hash(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let literal = ctx.node_at_offset::<Literal>()?;
+    if literal.token().kind() != ra_syntax::SyntaxKind::RAW_STRING {
+        return None;
+    }
+    let token = literal.token();
+    let text = token.text().as_str();
+    if text.starts_with("r\"") {
+        // no hash to remove
+        return None;
+    }
+    ctx.add_action(AssistId("remove_hash"), "remove hash from raw string", |edit| {
+        edit.target(literal.syntax().text_range());
+        let result = &text[2..text.len() - 1];
+        let result = if result.starts_with("\"") {
+            // no more hash, escape
+            let internal_str = &result[1..result.len() - 1];
+            format!("\"{}\"", internal_str.escape_default().to_string())
+        } else {
+            result.to_owned()
+        };
+        edit.replace(literal.syntax().text_range(), format!("r{}", result));
+    });
+    ctx.build()
+}
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::helpers::{check_assist, check_assist_not_applicable, check_assist_target};
+    #[test]
+    fn make_raw_string_target() {
+        check_assist_target(
+            make_raw_string,
+            r#"
+            fn f() {
+                let s = <|>"random string";
+            }
+            "#,
+            r#""random string""#,
+        );
+    }
+    #[test]
+    fn make_raw_string_works() {
+        check_assist(
+            make_raw_string,
+            r#"
+            fn f() {
+                let s = <|>"random string";
+            }
+            "#,
+            r#"
+            fn f() {
+                let s = <|>r"random string";
+            }
+            "#,
+        )
+    }
+    #[test]
+    fn make_raw_string_with_escaped_works() {
+        check_assist(
+            make_raw_string,
+            r#"
+            fn f() {
+                let s = <|>"random\nstring";
+            }
+            "#,
+            r#"
+            fn f() {
+                let s = <|>r"random\nstring";
+            }
+            "#,
+        )
+    }
+    #[test]
+    fn make_raw_string_not_works() {
+        check_assist_not_applicable(
+            make_raw_string,
+            r#"
+            fn f() {
+                let s = <|>r"random string";
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn add_hash_target() {
+        check_assist_target(
+            add_hash,
+            r#"
+            fn f() {
+                let s = <|>r"random string";
+            }
+            "#,
+            r#"r"random string""#,
+        );
+    }
+    #[test]
+    fn add_hash_works() {
+        check_assist(
+            add_hash,
+            r#"
+            fn f() {
+                let s = <|>r"random string";
+            }
+            "#,
+            r##"
+            fn f() {
+                let s = <|>r#"random string"#;
+            }
+            "##,
+        )
+    }
+    #[test]
+    fn add_more_hash_works() {
+        check_assist(
+            add_hash,
+            r##"
+            fn f() {
+                let s = <|>r#"random"string"#;
+            }
+            "##,
+            r###"
+            fn f() {
+                let s = <|>r##"random"string"##;
+            }
+            "###,
+        )
+    }
+    #[test]
+    fn add_hash_not_works() {
+        check_assist_not_applicable(
+            add_hash,
+            r#"
+            fn f() {
+                let s = <|>"random string";
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn remove_hash_target() {
+        check_assist_target(
+            remove_hash,
+            r##"
+            fn f() {
+                let s = <|>r#"random string"#;
+            }
+            "##,
+            r##"r#"random string"#"##,
+        );
+    }
+    #[test]
+    fn remove_hash_works() {
+        check_assist(
+            remove_hash,
+            r##"
+            fn f() {
+                let s = <|>r#"random string"#;
+            }
+            "##,
+            r#"
+            fn f() {
+                let s = <|>r"random string";
+            }
+            "#,
+        )
+    }
+    #[test]
+    fn remove_hash_with_quote_works() {
+        check_assist(
+            remove_hash,
+            r##"
+            fn f() {
+                let s = <|>r#"random"str"ing"#;
+            }
+            "##,
+            r#"
+            fn f() {
+                let s = <|>r"random\"str\"ing";
+            }
+            "#,
+        )
+    }
+    #[test]
+    fn remove_more_hash_works() {
+        check_assist(
+            remove_hash,
+            r###"
+            fn f() {
+                let s = <|>r##"random string"##;
+            }
+            "###,
+            r##"
+            fn f() {
+                let s = <|>r#"random string"#;
+            }
+            "##,
+        )
+    }
+    #[test]
+    fn remove_hash_not_works() {
+        check_assist_not_applicable(
+            remove_hash,
+            r#"
+            fn f() {
+                let s = <|>"random string";
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn remove_hash_no_hash_not_works() {
+        check_assist_not_applicable(
+            remove_hash,
+            r#"
+            fn f() {
+                let s = <|>r"random string";
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn make_usual_string_target() {
+        check_assist_target(
+            make_usual_string,
+            r##"
+            fn f() {
+                let s = <|>r#"random string"#;
+            }
+            "##,
+            r##"r#"random string"#"##,
+        );
+    }
+    #[test]
+    fn make_usual_string_works() {
+        check_assist(
+            make_usual_string,
+            r##"
+            fn f() {
+                let s = <|>r#"random string"#;
+            }
+            "##,
+            r#"
+            fn f() {
+                let s = <|>"random string";
+            }
+            "#,
+        )
+    }
+    #[test]
+    fn make_usual_string_with_quote_works() {
+        check_assist(
+            make_usual_string,
+            r##"
+            fn f() {
+                let s = <|>r#"random"str"ing"#;
+            }
+            "##,
+            r#"
+            fn f() {
+                let s = <|>"random\"str\"ing";
+            }
+            "#,
+        )
+    }
+    #[test]
+    fn make_usual_string_more_hash_works() {
+        check_assist(
+            make_usual_string,
+            r###"
+            fn f() {
+                let s = <|>r##"random string"##;
+            }
+            "###,
+            r##"
+            fn f() {
+                let s = <|>"random string";
+            }
+            "##,
+        )
+    }
+    #[test]
+    fn make_usual_string_not_works() {
+        check_assist_not_applicable(
+            make_usual_string,
+            r#"
+            fn f() {
+                let s = <|>"random string";
+            }
+            "#,
+        );
+    }
+}
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 706d24c32..28002f740 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -313,7 +313,7 @@ pub struct StructField {
    pub(crate) id: StructFieldId,
 }
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum FieldSource {
    Named(ast::RecordFieldDef),
    Pos(ast::TupleFieldDef),
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
new file mode 100644
index 000000000..c6ad85fc7
--- /dev/null
+++ b/crates/ra_hir/src/from_source.rs
@@ -0,0 +1,211 @@
+use ra_db::{FileId, FilePosition};
+use ra_syntax::{
+    algo::find_node_at_offset,
+    ast::{self, AstNode, NameOwner},
+    SyntaxNode,
+};
+use crate::{
+    db::{AstDatabase, DefDatabase, HirDatabase},
+    ids::{AstItemDef, LocationCtx},
+    name::AsName,
+    Const, Crate, Enum, EnumVariant, FieldSource, Function, HasSource, ImplBlock, Module,
+    ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias, Union, VariantDef,
+};
+pub trait FromSource: Sized {
+    type Ast;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self>;
+}
+impl FromSource for Struct {
+    type Ast = ast::StructDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Struct { id })
+    }
+}
+impl FromSource for Union {
+    type Ast = ast::StructDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Union { id })
+    }
+}
+impl FromSource for Enum {
+    type Ast = ast::EnumDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Enum { id })
+    }
+}
+impl FromSource for Trait {
+    type Ast = ast::TraitDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Trait { id })
+    }
+}
+impl FromSource for Function {
+    type Ast = ast::FnDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Function { id })
+    }
+}
+impl FromSource for Const {
+    type Ast = ast::ConstDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Const { id })
+    }
+}
+impl FromSource for Static {
+    type Ast = ast::StaticDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(Static { id })
+    }
+}
+impl FromSource for TypeAlias {
+    type Ast = ast::TypeAliasDef;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let id = from_source(db, src)?;
+        Some(TypeAlias { id })
+    }
+}
+// FIXME: add impl FromSource for MacroDef
+impl FromSource for ImplBlock {
+    type Ast = ast::ImplBlock;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let module_src = crate::ModuleSource::from_child_node(
+            db,
+            src.file_id.original_file(db),
+            &src.ast.syntax(),
+        );
+        let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
+        let impls = module.impl_blocks(db);
+        impls.into_iter().find(|b| b.source(db) == src)
+    }
+}
+impl FromSource for EnumVariant {
+    type Ast = ast::EnumVariant;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let parent_enum = src.ast.parent_enum();
+        let src_enum = Source { file_id: src.file_id, ast: parent_enum };
+        let variants = Enum::from_source(db, src_enum)?.variants(db);
+        variants.into_iter().find(|v| v.source(db) == src)
+    }
+}
+impl FromSource for StructField {
+    type Ast = FieldSource;
+    fn from_source(db: &(impl DefDatabase + AstDatabase), src: Source<Self::Ast>) -> Option<Self> {
+        let variant_def: VariantDef = match src.ast {
+            FieldSource::Named(ref field) => {
+                let ast = field.syntax().ancestors().find_map(ast::StructDef::cast)?;
+                let src = Source { file_id: src.file_id, ast };
+                let def = Struct::from_source(db, src)?;
+                VariantDef::from(def)
+            }
+            FieldSource::Pos(ref field) => {
+                let ast = field.syntax().ancestors().find_map(ast::EnumVariant::cast)?;
+                let src = Source { file_id: src.file_id, ast };
+                let def = EnumVariant::from_source(db, src)?;
+                VariantDef::from(def)
+            }
+        };
+        variant_def
+            .variant_data(db)
+            .fields()
+            .into_iter()
+            .flat_map(|it| it.iter())
+            .map(|(id, _)| StructField { parent: variant_def.clone(), id })
+            .find(|f| f.source(db) == src)
+    }
+}
+// FIXME: simplify it
+impl ModuleSource {
+    pub fn from_position(
+        db: &(impl DefDatabase + AstDatabase),
+        position: FilePosition,
+    ) -> ModuleSource {
+        let parse = db.parse(position.file_id);
+        match &find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset) {
+            Some(m) if !m.has_semi() => ModuleSource::Module(m.clone()),
+            _ => {
+                let source_file = parse.tree().to_owned();
+                ModuleSource::SourceFile(source_file)
+            }
+        }
+    }
+    pub fn from_child_node(
+        db: &(impl DefDatabase + AstDatabase),
+        file_id: FileId,
+        child: &SyntaxNode,
+    ) -> ModuleSource {
+        if let Some(m) = child.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi()) {
+            ModuleSource::Module(m.clone())
+        } else {
+            let source_file = db.parse(file_id).tree().to_owned();
+            ModuleSource::SourceFile(source_file)
+        }
+    }
+    pub fn from_file_id(db: &(impl DefDatabase + AstDatabase), file_id: FileId) -> ModuleSource {
+        let source_file = db.parse(file_id).tree().to_owned();
+        ModuleSource::SourceFile(source_file)
+    }
+}
+impl Module {
+    pub fn from_declaration(db: &impl HirDatabase, src: Source<ast::Module>) -> Option<Self> {
+        let src_parent = Source {
+            file_id: src.file_id,
+            ast: ModuleSource::new(db, Some(src.file_id.original_file(db)), None),
+        };
+        let parent_module = Module::from_definition(db, src_parent)?;
+        let child_name = src.ast.name()?;
+        parent_module.child(db, &child_name.as_name())
+    }
+    pub fn from_definition(
+        db: &(impl DefDatabase + AstDatabase),
+        src: Source<ModuleSource>,
+    ) -> Option<Self> {
+        let decl_id = match src.ast {
+            ModuleSource::Module(ref module) => {
+                assert!(!module.has_semi());
+                let ast_id_map = db.ast_id_map(src.file_id);
+                let item_id = ast_id_map.ast_id(module).with_file_id(src.file_id);
+                Some(item_id)
+            }
+            ModuleSource::SourceFile(_) => None,
+        };
+        let source_root_id = db.file_source_root(src.file_id.original_file(db));
+        db.source_root_crates(source_root_id).iter().map(|&crate_id| Crate { crate_id }).find_map(
+            |krate| {
+                let def_map = db.crate_def_map(krate);
+                let module_id = def_map.find_module_by_source(src.file_id, decl_id)?;
+                Some(Module { krate, module_id })
+            },
+        )
+    }
+}
+fn from_source<N, DEF>(db: &(impl DefDatabase + AstDatabase), src: Source<N>) -> Option<DEF>
+where
+    N: AstNode,
+    DEF: AstItemDef<N>,
+{
+    let module_src =
+        crate::ModuleSource::from_child_node(db, src.file_id.original_file(db), &src.ast.syntax());
+    let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
+    let ctx = LocationCtx::new(db, module, src.file_id);
+    Some(DEF::from_ast(ctx, &src.ast))
+}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index e7a576aa0..a9de9fb6b 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -53,6 +53,8 @@ pub mod diagnostics;
 mod code_model;
+pub mod from_source;
 #[cfg(test)]
 mod marks;
@@ -67,6 +69,7 @@ pub use self::{
    adt::VariantDef,
    either::Either,
    expr::ExprScopes,
+    from_source::FromSource,
    generics::{GenericParam, GenericParams, HasGenericParams},
    ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
    impl_block::ImplBlock,
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index 8dcea5071..cb405091e 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -93,7 +93,11 @@ impl MockDatabase {
        let mut files: Vec<FileId> = self.files.values().copied().collect();
        files.sort();
        for file in files {
-            let module = crate::source_binder::module_from_file_id(self, file).unwrap();
+            let src = crate::Source {
+                file_id: file.into(),
+                ast: crate::ModuleSource::new(self, Some(file), None),
+            };
+            let module = crate::Module::from_definition(self, src).unwrap();
            module.diagnostics(
                self,
                &mut DiagnosticSink::new(|d| {
diff --git a/crates/ra_hir/src/nameres/tests/incremental.rs b/crates/ra_hir/src/nameres/tests/incremental.rs
index bc721f6e0..c41862a0b 100644
--- a/crates/ra_hir/src/nameres/tests/incremental.rs
+++ b/crates/ra_hir/src/nameres/tests/incremental.rs
@@ -114,7 +114,11 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
    );
    {
        let events = db.log_executed(|| {
-            let module = crate::source_binder::module_from_file_id(&db, pos.file_id).unwrap();
+            let src = crate::Source {
+                file_id: pos.file_id.into(),
+                ast: crate::ModuleSource::new(&db, Some(pos.file_id), None),
+            };
+            let module = crate::Module::from_definition(&db, src).unwrap();
            let decls = module.declarations(&db);
            assert_eq!(decls.len(), 18);
        });
@@ -124,7 +128,11 @@ fn typing_inside_a_macro_should_not_invalidate_def_map() {
    {
        let events = db.log_executed(|| {
-            let module = crate::source_binder::module_from_file_id(&db, pos.file_id).unwrap();
+            let src = crate::Source {
+                file_id: pos.file_id.into(),
+                ast: crate::ModuleSource::new(&db, Some(pos.file_id), None),
+            };
+            let module = crate::Module::from_definition(&db, src).unwrap();
            let decls = module.declarations(&db);
            assert_eq!(decls.len(), 18);
        });
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 4d895f0a1..296acc364 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -7,10 +7,9 @@
 /// purely for "IDE needs".
 use std::sync::Arc;
-use ra_db::{FileId, FilePosition};
+use ra_db::FileId;
 use ra_syntax::{
-    algo::find_node_at_offset,
+    ast::{self, AstNode},
-    ast::{self, AstNode, NameOwner},
    AstPtr,
    SyntaxKind::*,
    SyntaxNode, SyntaxNodePtr, TextRange, TextUnit,
@@ -28,119 +27,28 @@ use crate::{
    path::known,
    resolve::{ScopeDef, TypeNs, ValueNs},
    ty::method_resolution::implements_trait,
-    AsName, AstId, Const, Crate, DefWithBody, Either, Enum, Function, HasBody, HirFileId, MacroDef,
+    AsName, Const, DefWithBody, Either, Enum, FromSource, Function, HasBody, HirFileId, MacroDef,
-    Module, Name, Path, Resolver, Static, Struct, Trait, Ty,
+    Module, Name, Path, Resolver, Static, Struct, Ty,
 };
-/// Locates the module by `FileId`. Picks topmost module in the file.
-pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Option<Module> {
-    module_from_source(db, file_id.into(), None)
-}
-/// Locates the child module by `mod child;` declaration.
-pub fn module_from_declaration(
-    db: &impl HirDatabase,
-    file_id: FileId,
-    decl: ast::Module,
-) -> Option<Module> {
-    let parent_module = module_from_file_id(db, file_id);
-    let child_name = decl.name();
-    match (parent_module, child_name) {
-        (Some(parent_module), Some(child_name)) => parent_module.child(db, &child_name.as_name()),
-        _ => None,
-    }
-}
-/// Locates the module by position in the source code.
-pub fn module_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Module> {
-    let parse = db.parse(position.file_id);
-    match &find_node_at_offset::<ast::Module>(parse.tree().syntax(), position.offset) {
-        Some(m) if !m.has_semi() => module_from_inline(db, position.file_id, m.clone()),
-        _ => module_from_file_id(db, position.file_id),
-    }
-}
-fn module_from_inline(
-    db: &impl HirDatabase,
-    file_id: FileId,
-    module: ast::Module,
-) -> Option<Module> {
-    assert!(!module.has_semi());
-    let file_id = file_id.into();
-    let ast_id_map = db.ast_id_map(file_id);
-    let item_id = ast_id_map.ast_id(&module).with_file_id(file_id);
-    module_from_source(db, file_id, Some(item_id))
-}
-/// Locates the module by child syntax element within the module
-pub fn module_from_child_node(
-    db: &impl HirDatabase,
-    file_id: FileId,
-    child: &SyntaxNode,
-) -> Option<Module> {
-    if let Some(m) = child.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi()) {
-        module_from_inline(db, file_id, m)
-    } else {
-        module_from_file_id(db, file_id)
-    }
-}
-fn module_from_source(
-    db: &impl HirDatabase,
-    file_id: HirFileId,
-    decl_id: Option<AstId<ast::Module>>,
-) -> Option<Module> {
-    let source_root_id = db.file_source_root(file_id.as_original_file());
-    db.source_root_crates(source_root_id).iter().map(|&crate_id| Crate { crate_id }).find_map(
-        |krate| {
-            let def_map = db.crate_def_map(krate);
-            let module_id = def_map.find_module_by_source(file_id, decl_id)?;
-            Some(Module { krate, module_id })
-        },
-    )
-}
-pub fn struct_from_module(
-    db: &impl HirDatabase,
-    module: Module,
-    struct_def: &ast::StructDef,
-) -> Struct {
-    let file_id = module.definition_source(db).file_id;
-    let ctx = LocationCtx::new(db, module, file_id);
-    Struct { id: ctx.to_def(struct_def) }
-}
-pub fn enum_from_module(db: &impl HirDatabase, module: Module, enum_def: &ast::EnumDef) -> Enum {
-    let file_id = module.definition_source(db).file_id;
-    let ctx = LocationCtx::new(db, module, file_id);
-    Enum { id: ctx.to_def(enum_def) }
-}
-pub fn trait_from_module(
-    db: &impl HirDatabase,
-    module: Module,
-    trait_def: &ast::TraitDef,
-) -> Trait {
-    let file_id = module.definition_source(db).file_id;
-    let ctx = LocationCtx::new(db, module, file_id);
-    Trait { id: ctx.to_def(trait_def) }
-}
 fn try_get_resolver_for_node(
    db: &impl HirDatabase,
    file_id: FileId,
    node: &SyntaxNode,
 ) -> Option<Resolver> {
    if let Some(module) = ast::Module::cast(node.clone()) {
-        Some(module_from_declaration(db, file_id, module)?.resolver(db))
+        let src = crate::Source { file_id: file_id.into(), ast: module };
-    } else if let Some(_) = ast::SourceFile::cast(node.clone()) {
+        Some(crate::Module::from_declaration(db, src)?.resolver(db))
-        Some(module_from_source(db, file_id.into(), None)?.resolver(db))
+    } else if let Some(file) = ast::SourceFile::cast(node.clone()) {
+        let src =
+            crate::Source { file_id: file_id.into(), ast: crate::ModuleSource::SourceFile(file) };
+        Some(crate::Module::from_definition(db, src)?.resolver(db))
    } else if let Some(s) = ast::StructDef::cast(node.clone()) {
-        let module = module_from_child_node(db, file_id, s.syntax())?;
+        let src = crate::Source { file_id: file_id.into(), ast: s };
-        Some(struct_from_module(db, module, &s).resolver(db))
+        Some(Struct::from_source(db, src)?.resolver(db))
    } else if let Some(e) = ast::EnumDef::cast(node.clone()) {
-        let module = module_from_child_node(db, file_id, e.syntax())?;
+        let src = crate::Source { file_id: file_id.into(), ast: e };
-        Some(enum_from_module(db, module, &e).resolver(db))
+        Some(Enum::from_source(db, src)?.resolver(db))
    } else if node.kind() == FN_DEF || node.kind() == CONST_DEF || node.kind() == STATIC_DEF {
        Some(def_with_body_from_child_node(db, file_id, node)?.resolver(db))
    } else {
@@ -154,8 +62,10 @@ fn def_with_body_from_child_node(
    file_id: FileId,
    node: &SyntaxNode,
 ) -> Option<DefWithBody> {
-    let module = module_from_child_node(db, file_id, node)?;
+    let src = crate::ModuleSource::from_child_node(db, file_id, node);
+    let module = Module::from_definition(db, crate::Source { file_id: file_id.into(), ast: src })?;
    let ctx = LocationCtx::new(db, module, file_id.into());
    node.ancestors().find_map(|node| {
        if let Some(def) = ast::FnDef::cast(node.clone()) {
            return Some(Function { id: ctx.to_def(&def) }.into());
diff --git a/crates/ra_ide_api/src/completion/completion_context.rs b/crates/ra_ide_api/src/completion/completion_context.rs
index 7139947b3..59bd3689b 100644
--- a/crates/ra_ide_api/src/completion/completion_context.rs
+++ b/crates/ra_ide_api/src/completion/completion_context.rs
@@ -1,4 +1,3 @@
-use hir::source_binder;
 use ra_syntax::{
    algo::{find_covering_element, find_node_at_offset},
    ast, AstNode, Parse, SourceFile,
@@ -47,7 +46,11 @@ impl<'a> CompletionContext<'a> {
        original_parse: &'a Parse<ast::SourceFile>,
        position: FilePosition,
    ) -> Option<CompletionContext<'a>> {
-        let module = source_binder::module_from_position(db, position);
+        let src = hir::ModuleSource::from_position(db, position);
+        let module = hir::Module::from_definition(
+            db,
+            hir::Source { file_id: position.file_id.into(), ast: src },
+        );
        let token =
            original_parse.tree().syntax().token_at_offset(position.offset).left_biased()?;
        let analyzer =
diff --git a/crates/ra_ide_api/src/diagnostics.rs b/crates/ra_ide_api/src/diagnostics.rs
index c448aa8c5..1ae152e5b 100644
--- a/crates/ra_ide_api/src/diagnostics.rs
+++ b/crates/ra_ide_api/src/diagnostics.rs
@@ -1,9 +1,6 @@
 use std::cell::RefCell;
-use hir::{
+use hir::diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink};
-    diagnostics::{AstDiagnostic, Diagnostic as _, DiagnosticSink},
-    source_binder,
-};
 use itertools::Itertools;
 use ra_assists::ast_editor::{AstBuilder, AstEditor};
 use ra_db::SourceDatabase;
@@ -89,7 +86,10 @@ pub(crate) fn diagnostics(db: &RootDatabase, file_id: FileId) -> Vec<Diagnostic>
            fix: Some(fix),
        })
    });
-    if let Some(m) = source_binder::module_from_file_id(db, file_id) {
+    let source_file = db.parse(file_id).tree().to_owned();
+    let src =
+        hir::Source { file_id: file_id.into(), ast: hir::ModuleSource::SourceFile(source_file) };
+    if let Some(m) = hir::Module::from_definition(db, src) {
        m.diagnostics(db, &mut sink);
    };
    drop(sink);
diff --git a/crates/ra_ide_api/src/goto_definition.rs b/crates/ra_ide_api/src/goto_definition.rs
index 503dcacff..bc8863dad 100644
--- a/crates/ra_ide_api/src/goto_definition.rs
+++ b/crates/ra_ide_api/src/goto_definition.rs
@@ -96,9 +96,8 @@ pub(crate) fn name_definition(
    if let Some(module) = ast::Module::cast(parent.clone()) {
        if module.has_semi() {
-            if let Some(child_module) =
+            let src = hir::Source { file_id: file_id.into(), ast: module };
-                hir::source_binder::module_from_declaration(db, file_id, module)
+            if let Some(child_module) = hir::Module::from_declaration(db, src) {
-            {
                let nav = NavigationTarget::from_module(db, child_module);
                return Some(vec![nav]);
            }
diff --git a/crates/ra_ide_api/src/impls.rs b/crates/ra_ide_api/src/impls.rs
index c5620dd52..f57f9a21b 100644
--- a/crates/ra_ide_api/src/impls.rs
+++ b/crates/ra_ide_api/src/impls.rs
@@ -1,4 +1,4 @@
-use hir::{db::HirDatabase, source_binder, ApplicationTy, Ty, TypeCtor};
+use hir::{db::HirDatabase, ApplicationTy, FromSource, Ty, TypeCtor};
 use ra_db::SourceDatabase;
 use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
@@ -11,17 +11,21 @@ pub(crate) fn goto_implementation(
    let parse = db.parse(position.file_id);
    let syntax = parse.tree().syntax().clone();
-    let module = source_binder::module_from_position(db, position)?;
+    let src = hir::ModuleSource::from_position(db, position);
+    let module = hir::Module::from_definition(
+        db,
+        hir::Source { file_id: position.file_id.into(), ast: src },
+    )?;
    if let Some(nominal_def) = find_node_at_offset::<ast::NominalDef>(&syntax, position.offset) {
        return Some(RangeInfo::new(
            nominal_def.syntax().text_range(),
-            impls_for_def(db, &nominal_def, module)?,
+            impls_for_def(db, position, &nominal_def, module)?,
        ));
    } else if let Some(trait_def) = find_node_at_offset::<ast::TraitDef>(&syntax, position.offset) {
        return Some(RangeInfo::new(
            trait_def.syntax().text_range(),
-            impls_for_trait(db, &trait_def, module)?,
+            impls_for_trait(db, position, &trait_def, module)?,
        ));
    }
@@ -30,14 +34,19 @@ pub(crate) fn goto_implementation(
 fn impls_for_def(
    db: &RootDatabase,
+    position: FilePosition,
    node: &ast::NominalDef,
    module: hir::Module,
 ) -> Option<Vec<NavigationTarget>> {
    let ty = match node {
        ast::NominalDef::StructDef(def) => {
-            source_binder::struct_from_module(db, module, &def).ty(db)
+            let src = hir::Source { file_id: position.file_id.into(), ast: def.clone() };
+            hir::Struct::from_source(db, src)?.ty(db)
+        }
+        ast::NominalDef::EnumDef(def) => {
+            let src = hir::Source { file_id: position.file_id.into(), ast: def.clone() };
+            hir::Enum::from_source(db, src)?.ty(db)
        }
-        ast::NominalDef::EnumDef(def) => source_binder::enum_from_module(db, module, &def).ty(db),
    };
    let krate = module.krate(db)?;
@@ -54,10 +63,12 @@ fn impls_for_def(
 fn impls_for_trait(
    db: &RootDatabase,
+    position: FilePosition,
    node: &ast::TraitDef,
    module: hir::Module,
 ) -> Option<Vec<NavigationTarget>> {
-    let tr = source_binder::trait_from_module(db, module, node);
+    let src = hir::Source { file_id: position.file_id.into(), ast: node.clone() };
+    let tr = hir::Trait::from_source(db, src)?;
    let krate = module.krate(db)?;
    let impls = db.impls_in_crate(krate);
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index e90fbd428..412dc4d71 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -223,6 +223,7 @@ impl Query {
    }
 }
+/// Info associated with a text range.
 #[derive(Debug)]
 pub struct RangeInfo<T> {
    pub range: TextRange,
@@ -235,6 +236,8 @@ impl<T> RangeInfo<T> {
    }
 }
+/// Contains information about a call site. Specifically the
+/// `FunctionSignature`and current parameter.
 #[derive(Debug)]
 pub struct CallInfo {
    pub signature: FunctionSignature,
@@ -325,11 +328,12 @@ impl Analysis {
        (host.analysis(), file_id)
    }
+    /// Features for Analysis.
    pub fn feature_flags(&self) -> &FeatureFlags {
        &self.db.feature_flags
    }
-    /// Debug info about the current state of the analysis
+    /// Debug info about the current state of the analysis.
    pub fn status(&self) -> Cancelable<String> {
        self.with_db(|db| status::status(&*db))
    }
@@ -440,6 +444,7 @@ impl Analysis {
        })
    }
+    /// Returns the definitions from the symbol at `position`.
    pub fn goto_definition(
        &self,
        position: FilePosition,
@@ -447,6 +452,7 @@ impl Analysis {
        self.with_db(|db| goto_definition::goto_definition(db, position))
    }
+    /// Returns the impls from the symbol at `position`.
    pub fn goto_implementation(
        &self,
        position: FilePosition,
@@ -454,6 +460,7 @@ impl Analysis {
        self.with_db(|db| impls::goto_implementation(db, position))
    }
+    /// Returns the type definitions for the symbol at `position`.
    pub fn goto_type_definition(
        &self,
        position: FilePosition,
@@ -540,6 +547,7 @@ impl Analysis {
        self.with_db(|db| references::rename(db, position, new_name))
    }
+    /// Performs an operation on that may be Canceled.
    fn with_db<F: FnOnce(&db::RootDatabase) -> T + std::panic::UnwindSafe, T>(
        &self,
        f: F,
diff --git a/crates/ra_ide_api/src/parent_module.rs b/crates/ra_ide_api/src/parent_module.rs
index 7d5f9ea2c..3668da8d7 100644
--- a/crates/ra_ide_api/src/parent_module.rs
+++ b/crates/ra_ide_api/src/parent_module.rs
@@ -5,7 +5,11 @@ use crate::{db::RootDatabase, NavigationTarget};
 /// This returns `Vec` because a module may be included from several places. We
 /// don't handle this case yet though, so the Vec has length at most one.
 pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<NavigationTarget> {
-    let module = match hir::source_binder::module_from_position(db, position) {
+    let src = hir::ModuleSource::from_position(db, position);
+    let module = match hir::Module::from_definition(
+        db,
+        hir::Source { file_id: position.file_id.into(), ast: src },
+    ) {
        None => return Vec::new(),
        Some(it) => it,
    };
@@ -15,10 +19,12 @@ pub(crate) fn parent_module(db: &RootDatabase, position: FilePosition) -> Vec<Na
 /// Returns `Vec` for the same reason as `parent_module`
 pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
-    let module = match hir::source_binder::module_from_file_id(db, file_id) {
+    let src = hir::ModuleSource::from_file_id(db, file_id);
-        Some(it) => it,
+    let module =
-        None => return Vec::new(),
+        match hir::Module::from_definition(db, hir::Source { file_id: file_id.into(), ast: src }) {
-    };
+            Some(it) => it,
+            None => return Vec::new(),
+        };
    let krate = match module.krate(db) {
        Some(it) => it,
        None => return Vec::new(),
diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
index 5f1f0efc3..acca71f2a 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -1,4 +1,4 @@
-use hir::{source_binder, Either, ModuleSource};
+use hir::{Either, ModuleSource};
 use ra_db::SourceDatabase;
 use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxNode};
 use relative_path::{RelativePath, RelativePathBuf};
@@ -135,9 +135,8 @@ fn rename_mod(
 ) -> Option<SourceChange> {
    let mut source_file_edits = Vec::new();
    let mut file_system_edits = Vec::new();
-    if let Some(module) =
+    let module_src = hir::Source { file_id: position.file_id.into(), ast: ast_module.clone() };
-        source_binder::module_from_declaration(db, position.file_id, ast_module.clone())
+    if let Some(module) = hir::Module::from_declaration(db, module_src) {
-    {
        let src = module.definition_source(db);
        let file_id = src.file_id.as_original_file();
        match src.ast {
diff --git a/crates/ra_ide_api/src/runnables.rs b/crates/ra_ide_api/src/runnables.rs
index 9d84b3d08..095ca56c4 100644
--- a/crates/ra_ide_api/src/runnables.rs
+++ b/crates/ra_ide_api/src/runnables.rs
@@ -63,7 +63,9 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Opti
        return None;
    }
    let range = module.syntax().text_range();
-    let module = hir::source_binder::module_from_child_node(db, file_id, module.syntax())?;
+    let src = hir::ModuleSource::from_child_node(db, file_id, &module.syntax());
+    let module =
+        hir::Module::from_definition(db, hir::Source { file_id: file_id.into(), ast: src })?;
    let path = module.path_to_root(db).into_iter().rev().filter_map(|it| it.name(db)).join("::");
    Some(Runnable { range, kind: RunnableKind::TestMod { path } })
diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs
index 0158f9b8a..e2355aff9 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -212,7 +212,7 @@ fn opt_visibility(p: &mut Parser) -> bool {
        // fn foo() { crate::foo(); }
        T![crate] if !p.nth_at(1, T![::]) => {
            let m = p.start();
-            p.bump_any();
+            p.bump(T![crate]);
            m.complete(p, VISIBILITY);
        }
        _ => return false,
@@ -223,7 +223,7 @@ fn opt_visibility(p: &mut Parser) -> bool {
 fn opt_alias(p: &mut Parser) {
    if p.at(T![as]) {
        let m = p.start();
-        p.bump_any();
+        p.bump(T![as]);
        if !p.eat(T![_]) {
            name(p);
        }
@@ -234,7 +234,7 @@ fn opt_alias(p: &mut Parser) {
 fn abi(p: &mut Parser) {
    assert!(p.at(T![extern]));
    let abi = p.start();
-    p.bump_any();
+    p.bump(T![extern]);
    match p.current() {
        STRING | RAW_STRING => p.bump_any(),
        _ => (),
@@ -257,7 +257,7 @@ fn opt_fn_ret_type(p: &mut Parser) -> bool {
 fn name_r(p: &mut Parser, recovery: TokenSet) {
    if p.at(IDENT) {
        let m = p.start();
-        p.bump_any();
+        p.bump(IDENT);
        m.complete(p, NAME);
    } else {
        p.err_recover("expected a name", recovery);
@@ -271,11 +271,11 @@ fn name(p: &mut Parser) {
 fn name_ref(p: &mut Parser) {
    if p.at(IDENT) {
        let m = p.start();
-        p.bump_any();
+        p.bump(IDENT);
        m.complete(p, NAME_REF);
    } else if p.at(T![self]) {
        let m = p.start();
-        p.bump_any();
+        p.bump(T![self]);
        m.complete(p, T![self]);
    } else {
        p.err_and_bump("expected identifier");
@@ -296,7 +296,7 @@ fn error_block(p: &mut Parser, message: &str) {
    assert!(p.at(T!['{']));
    let m = p.start();
    p.error(message);
-    p.bump_any();
+    p.bump(T!['{']);
    expressions::expr_block_contents(p);
    p.eat(T!['}']);
    m.complete(p, ERROR);
diff --git a/crates/ra_parser/src/grammar/attributes.rs b/crates/ra_parser/src/grammar/attributes.rs
index 81a363a57..1cfd301b5 100644
--- a/crates/ra_parser/src/grammar/attributes.rs
+++ b/crates/ra_parser/src/grammar/attributes.rs
@@ -15,11 +15,11 @@ pub(super) fn outer_attributes(p: &mut Parser) {
 fn attribute(p: &mut Parser, inner: bool) {
    let attr = p.start();
    assert!(p.at(T![#]));
-    p.bump_any();
+    p.bump(T![#]);
    if inner {
        assert!(p.at(T![!]));
-        p.bump_any();
+        p.bump(T![!]);
    }
    if p.at(T!['[']) {
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 1dd9a586c..80b085280 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -43,7 +43,7 @@ pub(crate) fn block(p: &mut Parser) {
 pub(crate) fn naked_block(p: &mut Parser) {
    assert!(p.at(T!['{']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['{']);
    expr_block_contents(p);
    p.expect(T!['}']);
    m.complete(p, BLOCK);
@@ -150,7 +150,7 @@ pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
    // }
    fn let_stmt(p: &mut Parser, m: Marker, with_semi: StmtWithSemi) {
        assert!(p.at(T![let]));
-        p.bump_any();
+        p.bump(T![let]);
        patterns::pattern(p);
        if p.at(T![:]) {
            types::ascription(p);
@@ -195,7 +195,7 @@ pub(crate) fn expr_block_contents(p: &mut Parser) {
        // }
        if p.at(T![;]) {
-            p.bump_any();
+            p.bump(T![;]);
            continue;
        }
@@ -297,7 +297,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
        // }
        T![&] => {
            m = p.start();
-            p.bump_any();
+            p.bump(T![&]);
            p.eat(T![mut]);
            REF_EXPR
        }
@@ -438,7 +438,7 @@ fn call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
    assert!(p.at(T!['[']));
    let m = lhs.precede(p);
-    p.bump_any();
+    p.bump(T!['[']);
    expr(p);
    p.expect(T![']']);
    m.complete(p, INDEX_EXPR)
@@ -478,7 +478,7 @@ fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
    assert!(p.at(T![.]));
    let m = lhs.precede(p);
-    p.bump_any();
+    p.bump(T![.]);
    if p.at(IDENT) || p.at(INT_NUMBER) {
        name_ref_or_index(p)
    } else if p.at(FLOAT_NUMBER) {
@@ -497,7 +497,7 @@ fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
    assert!(p.at(T![?]));
    let m = lhs.precede(p);
-    p.bump_any();
+    p.bump(T![?]);
    m.complete(p, TRY_EXPR)
 }
@@ -511,7 +511,7 @@ fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
    assert!(p.at(T![as]));
    let m = lhs.precede(p);
-    p.bump_any();
+    p.bump(T![as]);
    // Use type_no_bounds(), because cast expressions are not
    // allowed to have bounds.
    types::type_no_bounds(p);
@@ -521,7 +521,7 @@ fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 fn arg_list(p: &mut Parser) {
    assert!(p.at(T!['(']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['(']);
    while !p.at(T![')']) && !p.at(EOF) {
        if !p.at_ts(EXPR_FIRST) {
            p.error("expected expression");
@@ -570,7 +570,7 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
 pub(crate) fn record_field_list(p: &mut Parser) {
    assert!(p.at(T!['{']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['{']);
    while !p.at(EOF) && !p.at(T!['}']) {
        match p.current() {
            // test record_literal_field_with_attr
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index 6e295fbf9..6c7fdc2cd 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -101,14 +101,14 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
        }
        T![async] if la == T!['{'] || (la == T![move] && p.nth(2) == T!['{']) => {
            let m = p.start();
-            p.bump_any();
+            p.bump(T![async]);
            p.eat(T![move]);
            block_expr(p, Some(m))
        }
        T![match] => match_expr(p),
        T![unsafe] if la == T!['{'] => {
            let m = p.start();
-            p.bump_any();
+            p.bump(T![unsafe]);
            block_expr(p, Some(m))
        }
        T!['{'] => {
@@ -180,7 +180,7 @@ fn tuple_expr(p: &mut Parser) -> CompletedMarker {
 fn array_expr(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T!['[']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['[']);
    if p.eat(T![']']) {
        return m.complete(p, ARRAY_EXPR);
    }
@@ -262,11 +262,11 @@ fn lambda_expr(p: &mut Parser) -> CompletedMarker {
 fn if_expr(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T![if]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![if]);
    cond(p);
    block(p);
    if p.at(T![else]) {
-        p.bump_any();
+        p.bump(T![else]);
        if p.at(T![if]) {
            if_expr(p);
        } else {
@@ -285,7 +285,7 @@ fn if_expr(p: &mut Parser) -> CompletedMarker {
 fn label(p: &mut Parser) {
    assert!(p.at(LIFETIME) && p.nth(1) == T![:]);
    let m = p.start();
-    p.bump_any();
+    p.bump(LIFETIME);
    p.bump_any();
    m.complete(p, LABEL);
 }
@@ -297,7 +297,7 @@ fn label(p: &mut Parser) {
 fn loop_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
    assert!(p.at(T![loop]));
    let m = m.unwrap_or_else(|| p.start());
-    p.bump_any();
+    p.bump(T![loop]);
    block(p);
    m.complete(p, LOOP_EXPR)
 }
@@ -310,7 +310,7 @@ fn loop_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
    assert!(p.at(T![while]));
    let m = m.unwrap_or_else(|| p.start());
-    p.bump_any();
+    p.bump(T![while]);
    cond(p);
    block(p);
    m.complete(p, WHILE_EXPR)
@@ -323,7 +323,7 @@ fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
    assert!(p.at(T![for]));
    let m = m.unwrap_or_else(|| p.start());
-    p.bump_any();
+    p.bump(T![for]);
    patterns::pattern(p);
    p.expect(T![in]);
    expr_no_struct(p);
@@ -357,7 +357,7 @@ fn cond(p: &mut Parser) {
 fn match_expr(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T![match]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![match]);
    expr_no_struct(p);
    if p.at(T!['{']) {
        match_arm_list(p);
@@ -453,7 +453,7 @@ fn match_arm(p: &mut Parser) -> BlockLike {
 fn match_guard(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T![if]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![if]);
    expr(p);
    m.complete(p, MATCH_GUARD)
 }
@@ -479,7 +479,7 @@ pub(super) fn block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 fn return_expr(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T![return]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![return]);
    if p.at_ts(EXPR_FIRST) {
        expr(p);
    }
@@ -496,7 +496,7 @@ fn return_expr(p: &mut Parser) -> CompletedMarker {
 fn continue_expr(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T![continue]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![continue]);
    p.eat(LIFETIME);
    m.complete(p, CONTINUE_EXPR)
 }
@@ -513,7 +513,7 @@ fn continue_expr(p: &mut Parser) -> CompletedMarker {
 fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
    assert!(p.at(T![break]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![break]);
    p.eat(LIFETIME);
    // test break_ambiguity
    // fn foo(){
@@ -535,7 +535,7 @@ fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
 fn try_block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
    assert!(p.at(T![try]));
    let m = m.unwrap_or_else(|| p.start());
-    p.bump_any();
+    p.bump(T![try]);
    block(p);
    m.complete(p, TRY_EXPR)
 }
@@ -549,7 +549,7 @@ fn try_block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
 fn box_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
    assert!(p.at(T![box]));
    let m = m.unwrap_or_else(|| p.start());
-    p.bump_any();
+    p.bump(T![box]);
    if p.at_ts(EXPR_FIRST) {
        expr(p);
    }
diff --git a/crates/ra_parser/src/grammar/items.rs b/crates/ra_parser/src/grammar/items.rs
index 4dd80d443..4c67a5c2e 100644
--- a/crates/ra_parser/src/grammar/items.rs
+++ b/crates/ra_parser/src/grammar/items.rs
@@ -64,7 +64,7 @@ pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool, flavor: ItemF
        } else if p.at(T!['}']) && !stop_on_r_curly {
            let e = p.start();
            p.error("unmatched `}`");
-            p.bump_any();
+            p.bump(T!['}']);
            e.complete(p, ERROR);
        } else if !p.at(EOF) && !p.at(T!['}']) {
            p.err_and_bump("expected an item");
@@ -276,9 +276,9 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
 fn extern_crate_item(p: &mut Parser, m: Marker) {
    assert!(p.at(T![extern]));
-    p.bump_any();
+    p.bump(T![extern]);
    assert!(p.at(T![crate]));
-    p.bump_any();
+    p.bump(T![crate]);
    name_ref(p);
    opt_alias(p);
    p.expect(T![;]);
@@ -288,7 +288,7 @@ fn extern_crate_item(p: &mut Parser, m: Marker) {
 pub(crate) fn extern_item_list(p: &mut Parser) {
    assert!(p.at(T!['{']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['{']);
    mod_contents(p, true);
    p.expect(T!['}']);
    m.complete(p, EXTERN_ITEM_LIST);
@@ -296,7 +296,7 @@ pub(crate) fn extern_item_list(p: &mut Parser) {
 fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
    assert!(p.at(T![fn]));
-    p.bump_any();
+    p.bump(T![fn]);
    name_r(p, ITEM_RECOVERY_SET);
    // test function_type_params
@@ -323,7 +323,7 @@ fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
    // test fn_decl
    // trait T { fn foo(); }
    if p.at(T![;]) {
-        p.bump_any();
+        p.bump(T![;]);
    } else {
        expressions::block(p)
    }
@@ -333,7 +333,7 @@ fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
 // type Foo = Bar;
 fn type_def(p: &mut Parser, m: Marker) {
    assert!(p.at(T![type]));
-    p.bump_any();
+    p.bump(T![type]);
    name(p);
@@ -357,7 +357,7 @@ fn type_def(p: &mut Parser, m: Marker) {
 pub(crate) fn mod_item(p: &mut Parser, m: Marker) {
    assert!(p.at(T![mod]));
-    p.bump_any();
+    p.bump(T![mod]);
    name(p);
    if p.at(T!['{']) {
@@ -371,7 +371,7 @@ pub(crate) fn mod_item(p: &mut Parser, m: Marker) {
 pub(crate) fn mod_item_list(p: &mut Parser) {
    assert!(p.at(T!['{']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['{']);
    mod_contents(p, true);
    p.expect(T!['}']);
    m.complete(p, ITEM_LIST);
diff --git a/crates/ra_parser/src/grammar/items/consts.rs b/crates/ra_parser/src/grammar/items/consts.rs
index 63e0e6e0c..310260689 100644
--- a/crates/ra_parser/src/grammar/items/consts.rs
+++ b/crates/ra_parser/src/grammar/items/consts.rs
@@ -10,7 +10,7 @@ pub(super) fn const_def(p: &mut Parser, m: Marker) {
 fn const_or_static(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
    assert!(p.at(kw));
-    p.bump_any();
+    p.bump(kw);
    p.eat(T![mut]); // FIXME: validator to forbid const mut
    // Allow `_` in place of an identifier in a `const`.
diff --git a/crates/ra_parser/src/grammar/items/nominal.rs b/crates/ra_parser/src/grammar/items/nominal.rs
index 460acd65e..bede3b692 100644
--- a/crates/ra_parser/src/grammar/items/nominal.rs
+++ b/crates/ra_parser/src/grammar/items/nominal.rs
@@ -11,7 +11,7 @@ pub(super) fn struct_def(p: &mut Parser, m: Marker, kind: SyntaxKind) {
            type_params::opt_where_clause(p);
            match p.current() {
                T![;] => {
-                    p.bump_any();
+                    p.bump(T![;]);
                }
                T!['{'] => record_field_def_list(p),
                _ => {
@@ -21,7 +21,7 @@ pub(super) fn struct_def(p: &mut Parser, m: Marker, kind: SyntaxKind) {
            }
        }
        T![;] if kind == T![struct] => {
-            p.bump_any();
+            p.bump(T![;]);
        }
        T!['{'] => record_field_def_list(p),
        T!['('] if kind == T![struct] => {
@@ -44,7 +44,7 @@ pub(super) fn struct_def(p: &mut Parser, m: Marker, kind: SyntaxKind) {
 pub(super) fn enum_def(p: &mut Parser, m: Marker) {
    assert!(p.at(T![enum]));
-    p.bump_any();
+    p.bump(T![enum]);
    name_r(p, ITEM_RECOVERY_SET);
    type_params::opt_type_param_list(p);
    type_params::opt_where_clause(p);
@@ -59,7 +59,7 @@ pub(super) fn enum_def(p: &mut Parser, m: Marker) {
 pub(crate) fn enum_variant_list(p: &mut Parser) {
    assert!(p.at(T!['{']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['{']);
    while !p.at(EOF) && !p.at(T!['}']) {
        if p.at(T!['{']) {
            error_block(p, "expected enum variant");
@@ -73,7 +73,7 @@ pub(crate) fn enum_variant_list(p: &mut Parser) {
                T!['{'] => record_field_def_list(p),
                T!['('] => tuple_field_def_list(p),
                T![=] => {
-                    p.bump_any();
+                    p.bump(T![=]);
                    expressions::expr(p);
                }
                _ => (),
@@ -94,7 +94,7 @@ pub(crate) fn enum_variant_list(p: &mut Parser) {
 pub(crate) fn record_field_def_list(p: &mut Parser) {
    assert!(p.at(T!['{']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['{']);
    while !p.at(T!['}']) && !p.at(EOF) {
        if p.at(T!['{']) {
            error_block(p, "expected field");
diff --git a/crates/ra_parser/src/grammar/items/traits.rs b/crates/ra_parser/src/grammar/items/traits.rs
index b49221a4b..3742fd197 100644
--- a/crates/ra_parser/src/grammar/items/traits.rs
+++ b/crates/ra_parser/src/grammar/items/traits.rs
@@ -5,7 +5,7 @@ use super::*;
 // trait X<U: Debug + Display>: Hash + Clone where U: Copy {}
 pub(super) fn trait_def(p: &mut Parser) {
    assert!(p.at(T![trait]));
-    p.bump_any();
+    p.bump(T![trait]);
    name_r(p, ITEM_RECOVERY_SET);
    type_params::opt_type_param_list(p);
    if p.at(T![:]) {
@@ -29,7 +29,7 @@ pub(super) fn trait_def(p: &mut Parser) {
 pub(crate) fn trait_item_list(p: &mut Parser) {
    assert!(p.at(T!['{']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['{']);
    while !p.at(EOF) && !p.at(T!['}']) {
        if p.at(T!['{']) {
            error_block(p, "expected an item");
@@ -45,7 +45,7 @@ pub(crate) fn trait_item_list(p: &mut Parser) {
 // impl Foo {}
 pub(super) fn impl_block(p: &mut Parser) {
    assert!(p.at(T![impl]));
-    p.bump_any();
+    p.bump(T![impl]);
    if choose_type_params_over_qpath(p) {
        type_params::opt_type_param_list(p);
    }
@@ -78,7 +78,7 @@ pub(super) fn impl_block(p: &mut Parser) {
 pub(crate) fn impl_item_list(p: &mut Parser) {
    assert!(p.at(T!['{']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['{']);
    // test impl_inner_attributes
    // enum F{}
    // impl F {
diff --git a/crates/ra_parser/src/grammar/items/use_item.rs b/crates/ra_parser/src/grammar/items/use_item.rs
index f28f522b8..2af2ad315 100644
--- a/crates/ra_parser/src/grammar/items/use_item.rs
+++ b/crates/ra_parser/src/grammar/items/use_item.rs
@@ -2,7 +2,7 @@ use super::*;
 pub(super) fn use_item(p: &mut Parser, m: Marker) {
    assert!(p.at(T![use]));
-    p.bump_any();
+    p.bump(T![use]);
    use_tree(p);
    p.expect(T![;]);
    m.complete(p, USE_ITEM);
@@ -84,7 +84,7 @@ fn use_tree(p: &mut Parser) {
                    p.bump(T![::]);
                    match p.current() {
                        T![*] => {
-                            p.bump_any();
+                            p.bump(T![*]);
                        }
                        // test use_tree_list_after_path
                        // use crate::{Item};
@@ -114,7 +114,7 @@ fn use_tree(p: &mut Parser) {
 pub(crate) fn use_tree_list(p: &mut Parser) {
    assert!(p.at(T!['{']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['{']);
    while !p.at(EOF) && !p.at(T!['}']) {
        use_tree(p);
        if !p.at(T!['}']) {
diff --git a/crates/ra_parser/src/grammar/params.rs b/crates/ra_parser/src/grammar/params.rs
index 5893b22fd..efc329243 100644
--- a/crates/ra_parser/src/grammar/params.rs
+++ b/crates/ra_parser/src/grammar/params.rs
@@ -39,7 +39,7 @@ fn list_(p: &mut Parser, flavor: Flavor) {
    let (bra, ket) = if flavor.type_required() { (T!['('], T![')']) } else { (T![|], T![|]) };
    assert!(p.at(bra));
    let m = p.start();
-    p.bump_any();
+    p.bump(bra);
    if flavor.type_required() {
        // test self_param_outer_attr
        // fn f(#[must_use] self) {}
diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs
index 919b0f37d..a4ffd6960 100644
--- a/crates/ra_parser/src/grammar/patterns.rs
+++ b/crates/ra_parser/src/grammar/patterns.rs
@@ -106,7 +106,7 @@ fn literal_pat(p: &mut Parser) -> CompletedMarker {
    assert!(is_literal_pat_start(p));
    let m = p.start();
    if p.at(T![-]) {
-        p.bump_any();
+        p.bump(T![-]);
    }
    expressions::literal(p);
    m.complete(p, LITERAL_PAT)
@@ -146,7 +146,7 @@ fn path_pat(p: &mut Parser) -> CompletedMarker {
 // }
 fn tuple_pat_fields(p: &mut Parser) {
    assert!(p.at(T!['(']));
-    p.bump_any();
+    p.bump(T!['(']);
    pat_list(p, T![')']);
    p.expect(T![')']);
 }
@@ -161,7 +161,7 @@ fn tuple_pat_fields(p: &mut Parser) {
 fn record_field_pat_list(p: &mut Parser) {
    assert!(p.at(T!['{']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['{']);
    while !p.at(EOF) && !p.at(T!['}']) {
        match p.current() {
            // A trailing `..` is *not* treated as a DOT_DOT_PAT.
@@ -200,7 +200,7 @@ fn record_field_pat(p: &mut Parser) {
 fn placeholder_pat(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T![_]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![_]);
    m.complete(p, PLACEHOLDER_PAT)
 }
@@ -245,7 +245,7 @@ fn dot_dot_pat(p: &mut Parser) -> CompletedMarker {
 fn ref_pat(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T![&]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![&]);
    p.eat(T![mut]);
    pattern(p);
    m.complete(p, REF_PAT)
@@ -269,7 +269,7 @@ fn tuple_pat(p: &mut Parser) -> CompletedMarker {
 fn slice_pat(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T!['[']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['[']);
    pat_list(p, T![']']);
    p.expect(T![']']);
    m.complete(p, SLICE_PAT)
@@ -318,7 +318,7 @@ fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
 fn box_pat(p: &mut Parser) -> CompletedMarker {
    assert!(p.at(T![box]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![box]);
    pattern(p);
    m.complete(p, BOX_PAT)
 }
diff --git a/crates/ra_parser/src/grammar/type_args.rs b/crates/ra_parser/src/grammar/type_args.rs
index edc7d4ff2..8e97fe03c 100644
--- a/crates/ra_parser/src/grammar/type_args.rs
+++ b/crates/ra_parser/src/grammar/type_args.rs
@@ -29,7 +29,7 @@ fn type_arg(p: &mut Parser) {
    let m = p.start();
    match p.current() {
        LIFETIME => {
-            p.bump_any();
+            p.bump(LIFETIME);
            m.complete(p, LIFETIME_ARG);
        }
        // test associated_type_bounds
diff --git a/crates/ra_parser/src/grammar/type_params.rs b/crates/ra_parser/src/grammar/type_params.rs
index 31d709d81..7071c70ea 100644
--- a/crates/ra_parser/src/grammar/type_params.rs
+++ b/crates/ra_parser/src/grammar/type_params.rs
@@ -10,7 +10,7 @@ pub(super) fn opt_type_param_list(p: &mut Parser) {
 fn type_param_list(p: &mut Parser) {
    assert!(p.at(T![<]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![<]);
    while !p.at(EOF) && !p.at(T![>]) {
        let m = p.start();
@@ -38,7 +38,7 @@ fn type_param_list(p: &mut Parser) {
 fn lifetime_param(p: &mut Parser, m: Marker) {
    assert!(p.at(LIFETIME));
-    p.bump_any();
+    p.bump(LIFETIME);
    if p.at(T![:]) {
        lifetime_bounds(p);
    }
@@ -54,7 +54,7 @@ fn type_param(p: &mut Parser, m: Marker) {
    // test type_param_default
    // struct S<T = i32>;
    if p.at(T![=]) {
-        p.bump_any();
+        p.bump(T![=]);
        types::type_(p)
    }
    m.complete(p, TYPE_PARAM);
@@ -64,15 +64,15 @@ fn type_param(p: &mut Parser, m: Marker) {
 // struct S<T: 'a + ?Sized + (Copy)>;
 pub(super) fn bounds(p: &mut Parser) {
    assert!(p.at(T![:]));
-    p.bump_any();
+    p.bump(T![:]);
    bounds_without_colon(p);
 }
 fn lifetime_bounds(p: &mut Parser) {
    assert!(p.at(T![:]));
-    p.bump_any();
+    p.bump(T![:]);
    while p.at(LIFETIME) {
-        p.bump_any();
+        p.bump(LIFETIME);
        if !p.eat(T![+]) {
            break;
        }
@@ -99,7 +99,7 @@ fn type_bound(p: &mut Parser) -> bool {
    let has_paren = p.eat(T!['(']);
    p.eat(T![?]);
    match p.current() {
-        LIFETIME => p.bump_any(),
+        LIFETIME => p.bump(LIFETIME),
        T![for] => types::for_type(p),
        _ if paths::is_use_path_start(p) => types::path_type_(p, false),
        _ => {
@@ -128,7 +128,7 @@ pub(super) fn opt_where_clause(p: &mut Parser) {
        return;
    }
    let m = p.start();
-    p.bump_any();
+    p.bump(T![where]);
    while is_where_predicate(p) {
        where_predicate(p);
@@ -166,7 +166,7 @@ fn where_predicate(p: &mut Parser) {
    let m = p.start();
    match p.current() {
        LIFETIME => {
-            p.bump_any();
+            p.bump(LIFETIME);
            if p.at(T![:]) {
                bounds(p);
            } else {
diff --git a/crates/ra_parser/src/grammar/types.rs b/crates/ra_parser/src/grammar/types.rs
index a5a5b6d73..4e3522d48 100644
--- a/crates/ra_parser/src/grammar/types.rs
+++ b/crates/ra_parser/src/grammar/types.rs
@@ -44,7 +44,7 @@ pub(super) fn ascription(p: &mut Parser) {
 fn paren_or_tuple_type(p: &mut Parser) {
    assert!(p.at(T!['(']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['(']);
    let mut n_types: u32 = 0;
    let mut trailing_comma: bool = false;
    while !p.at(EOF) && !p.at(T![')']) {
@@ -79,14 +79,14 @@ fn paren_or_tuple_type(p: &mut Parser) {
 fn never_type(p: &mut Parser) {
    assert!(p.at(T![!]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![!]);
    m.complete(p, NEVER_TYPE);
 }
 fn pointer_type(p: &mut Parser) {
    assert!(p.at(T![*]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![*]);
    match p.current() {
        // test pointer_type_mut
@@ -110,21 +110,21 @@ fn pointer_type(p: &mut Parser) {
 fn array_or_slice_type(p: &mut Parser) {
    assert!(p.at(T!['[']));
    let m = p.start();
-    p.bump_any();
+    p.bump(T!['[']);
    type_(p);
    let kind = match p.current() {
        // test slice_type
        // type T = [()];
        T![']'] => {
-            p.bump_any();
+            p.bump(T![']']);
            SLICE_TYPE
        }
        // test array_type
        // type T = [(); 92];
        T![;] => {
-            p.bump_any();
+            p.bump(T![;]);
            expressions::expr(p);
            p.expect(T![']']);
            ARRAY_TYPE
@@ -146,7 +146,7 @@ fn array_or_slice_type(p: &mut Parser) {
 fn reference_type(p: &mut Parser) {
    assert!(p.at(T![&]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![&]);
    p.eat(LIFETIME);
    p.eat(T![mut]);
    type_no_bounds(p);
@@ -158,7 +158,7 @@ fn reference_type(p: &mut Parser) {
 fn placeholder_type(p: &mut Parser) {
    assert!(p.at(T![_]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![_]);
    m.complete(p, PLACEHOLDER_TYPE);
 }
@@ -193,7 +193,7 @@ fn fn_pointer_type(p: &mut Parser) {
 pub(super) fn for_binder(p: &mut Parser) {
    assert!(p.at(T![for]));
-    p.bump_any();
+    p.bump(T![for]);
    if p.at(T![<]) {
        type_params::opt_type_param_list(p);
    } else {
@@ -224,7 +224,7 @@ pub(super) fn for_type(p: &mut Parser) {
 fn impl_trait_type(p: &mut Parser) {
    assert!(p.at(T![impl]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![impl]);
    type_params::bounds_without_colon(p);
    m.complete(p, IMPL_TRAIT_TYPE);
 }
@@ -234,7 +234,7 @@ fn impl_trait_type(p: &mut Parser) {
 fn dyn_trait_type(p: &mut Parser) {
    assert!(p.at(T![dyn ]));
    let m = p.start();
-    p.bump_any();
+    p.bump(T![dyn ]);
    type_params::bounds_without_colon(p);
    m.complete(p, DYN_TRAIT_TYPE);
 }
diff --git a/docs/user/features.md b/docs/user/features.md
index 1034a5117..93e565315 100644
--- a/docs/user/features.md
+++ b/docs/user/features.md
@@ -445,6 +445,62 @@ fn foo<T: u32, F: FnOnce(T) -> T>() {}
 fn foo<T, F>() where T: u32, F: FnOnce(T) -> T {}
 ```
+- Make raw string
+```rust
+// before:
+fn f() {
+    let s = <|>"abcd";
+}
+// after:
+fn f() {
+    let s = <|>r"abcd";
+}
+```
+- Make usual string
+```rust
+// before:
+fn f() {
+    let s = <|>r#"abcd"#;
+}
+// after:
+fn f() {
+    let s = <|>"abcd";
+}
+```
+- Add hash
+```rust
+// before:
+fn f() {
+    let s = <|>r"abcd";
+}
+// after:
+fn f() {
+    let s = <|>r#"abcd"#;
+}
+```
+- Remove hash
+```rust
+// before:
+fn f() {
+    let s = <|>r#"abcd"#;
+}
+// after:
+fn f() {
+    let s = <|>r"abcd";
+}
+```
 ### Magic Completions
 In addition to usual reference completion, rust-analyzer provides some ✨magic✨