308 files changed, 4569 insertions, 1571 deletions
diff --git a/crates/gen_lsp_server/Cargo.toml b/crates/gen_lsp_server/Cargo.toml
index 6c91e38aa..9776a82e3 100644
--- a/crates/gen_lsp_server/Cargo.toml
+++ b/crates/gen_lsp_server/Cargo.toml
@@ -12,6 +12,5 @@ languageserver-types = "0.53.0"
 log = "0.4.3"
 failure = "0.1.2"
 serde_json = "1.0.24"
-serde = "1.0.71"
+serde = { version = "1.0.71", features = ["derive"] }
-serde_derive = "1.0.71"
 crossbeam-channel = "0.2.4"
diff --git a/crates/gen_lsp_server/src/msg.rs b/crates/gen_lsp_server/src/msg.rs
index 22d273d55..f68cbc541 100644
--- a/crates/gen_lsp_server/src/msg.rs
+++ b/crates/gen_lsp_server/src/msg.rs
@@ -1,13 +1,13 @@
 use std::io::{BufRead, Write};
 use languageserver_types::{notification::Notification, request::Request};
-use serde_derive::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 use serde_json::{from_str, from_value, to_string, to_value, Value};
 use failure::{bail, format_err};
 use crate::Result;
-#[derive(Debug, Serialize, Deserialize, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(untagged)]
 pub enum RawMessage {
    Request(RawRequest),
@@ -152,12 +152,18 @@ impl RawNotification {
            params: to_value(params).unwrap(),
        }
    }
+    pub fn is<N>(&self) -> bool
+    where
+        N: Notification,
+    {
+        self.method == N::METHOD
+    }
    pub fn cast<N>(self) -> ::std::result::Result<N::Params, RawNotification>
    where
        N: Notification,
        N::Params: serde::de::DeserializeOwned,
    {
-        if self.method != N::METHOD {
+        if !self.is::<N>() {
            return Err(self);
        }
        Ok(from_value(self.params).unwrap())
diff --git a/crates/ra_analysis/src/completion.rs b/crates/ra_analysis/src/completion.rs
index f480af611..d742d6295 100644
--- a/crates/ra_analysis/src/completion.rs
+++ b/crates/ra_analysis/src/completion.rs
@@ -1,444 +1,60 @@
-mod reference_completion;
+mod completion_item;
+mod completion_context;
+mod complete_fn_param;
+mod complete_keyword;
+mod complete_snippet;
+mod complete_path;
+mod complete_scope;
-use ra_editor::find_node_at_offset;
-use ra_text_edit::AtomTextEdit;
-use ra_syntax::{
-    algo::visit::{visitor_ctx, VisitorCtx},
-    ast,
-    AstNode,
-    SyntaxNodeRef,
-};
 use ra_db::SyntaxDatabase;
-use rustc_hash::{FxHashMap};
-use hir::source_binder;
 use crate::{
    db,
-    Cancelable, FilePosition
+    Cancelable, FilePosition,
+    completion::{
+        completion_item::{Completions, CompletionKind},
+        completion_context::CompletionContext,
+    },
 };
-#[derive(Debug)]
+pub use crate::completion::completion_item::{CompletionItem, InsertText, CompletionItemKind};
-pub struct CompletionItem {
-    /// What user sees in pop-up
-    pub label: String,
-    /// What string is used for filtering, defaults to label
-    pub lookup: Option<String>,
-    /// What is inserted, defaults to label
-    pub snippet: Option<String>,
-}
+/// Main entry point for copmletion. We run comletion as a two-phase process.
+///
+/// First, we look at the position and collect a so-called `CompletionContext.
+/// This is a somewhat messy process, because, during completion, syntax tree is
+/// incomplete and can look readlly weired.
+///
+/// Once the context is collected, we run a series of completion routines whihc
+/// look at the context and produce completion items.
 pub(crate) fn completions(
    db: &db::RootDatabase,
    position: FilePosition,
-) -> Cancelable<Option<Vec<CompletionItem>>> {
+) -> Cancelable<Option<Completions>> {
    let original_file = db.source_file(position.file_id);
-    // Insert a fake ident to get a valid parse tree
+    let ctx = ctry!(CompletionContext::new(db, &original_file, position)?);
-    let file = {
-        let edit = AtomTextEdit::insert(position.offset, "intellijRulezz".to_string());
-        original_file.reparse(&edit)
-    };
-    let module = ctry!(source_binder::module_from_position(db, position)?);
-    let mut res = Vec::new();
+    let mut acc = Completions::default();
-    let mut has_completions = false;
-    // First, let's try to complete a reference to some declaration.
-    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
-        has_completions = true;
-        reference_completion::completions(&mut res, db, &module, &file, name_ref)?;
-        // special case, `trait T { fn foo(i_am_a_name_ref) {} }`
-        if is_node::<ast::Param>(name_ref.syntax()) {
-            param_completions(name_ref.syntax(), &mut res);
-        }
-    }
-    // Otherwise, if this is a declaration, use heuristics to suggest a name.
+    complete_fn_param::complete_fn_param(&mut acc, &ctx);
-    if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), position.offset) {
+    complete_keyword::complete_expr_keyword(&mut acc, &ctx);
-        if is_node::<ast::Param>(name.syntax()) {
+    complete_snippet::complete_expr_snippet(&mut acc, &ctx);
-            has_completions = true;
+    complete_snippet::complete_item_snippet(&mut acc, &ctx);
-            param_completions(name.syntax(), &mut res);
+    complete_path::complete_path(&mut acc, &ctx)?;
-        }
+    complete_scope::complete_scope(&mut acc, &ctx)?;
-    }
-    let res = if has_completions { Some(res) } else { None };
-    Ok(res)
-}
-fn param_completions(ctx: SyntaxNodeRef, acc: &mut Vec<CompletionItem>) {
-    let mut params = FxHashMap::default();
-    for node in ctx.ancestors() {
-        let _ = visitor_ctx(&mut params)
-            .visit::<ast::SourceFile, _>(process)
-            .visit::<ast::ItemList, _>(process)
-            .accept(node);
-    }
-    params
-        .into_iter()
-        .filter_map(|(label, (count, param))| {
-            let lookup = param.pat()?.syntax().text().to_string();
-            if count < 2 {
-                None
-            } else {
-                Some((label, lookup))
-            }
-        })
-        .for_each(|(label, lookup)| {
-            acc.push(CompletionItem {
-                label,
-                lookup: Some(lookup),
-                snippet: None,
-            })
-        });
-    fn process<'a, N: ast::FnDefOwner<'a>>(
-        node: N,
-        params: &mut FxHashMap<String, (u32, ast::Param<'a>)>,
-    ) {
-        node.functions()
-            .filter_map(|it| it.param_list())
-            .flat_map(|it| it.params())
-            .for_each(|param| {
-                let text = param.syntax().text().to_string();
-                params.entry(text).or_insert((0, param)).0 += 1;
-            })
-    }
-}
-fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
+    Ok(Some(acc))
-    match node.ancestors().filter_map(N::cast).next() {
-        None => false,
-        Some(n) => n.syntax().range() == node.range(),
-    }
 }
 #[cfg(test)]
-mod tests {
+fn check_completion(code: &str, expected_completions: &str, kind: CompletionKind) {
-    use test_utils::assert_eq_dbg;
+    use crate::mock_analysis::{single_file_with_position, analysis_and_position};
+    let (analysis, position) = if code.contains("//-") {
-    use crate::mock_analysis::single_file_with_position;
+        analysis_and_position(code)
+    } else {
-    use super::*;
+        single_file_with_position(code)
+    };
-    fn check_scope_completion(code: &str, expected_completions: &str) {
+    let completions = completions(&analysis.imp.db, position).unwrap().unwrap();
-        let (analysis, position) = single_file_with_position(code);
+    completions.assert_match(expected_completions, kind);
-        let completions = completions(&analysis.imp.db, position)
-            .unwrap()
-            .unwrap()
-            .into_iter()
-            .filter(|c| c.snippet.is_none())
-            .collect::<Vec<_>>();
-        assert_eq_dbg(expected_completions, &completions);
-    }
-    fn check_snippet_completion(code: &str, expected_completions: &str) {
-        let (analysis, position) = single_file_with_position(code);
-        let completions = completions(&analysis.imp.db, position)
-            .unwrap()
-            .unwrap()
-            .into_iter()
-            .filter(|c| c.snippet.is_some())
-            .collect::<Vec<_>>();
-        assert_eq_dbg(expected_completions, &completions);
-    }
-    #[test]
-    fn test_completion_let_scope() {
-        check_scope_completion(
-            r"
-            fn quux(x: i32) {
-                let y = 92;
-                1 + <|>;
-                let z = ();
-            }
-            ",
-            r#"[CompletionItem { label: "y", lookup: None, snippet: None },
-                   CompletionItem { label: "x", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_completion_if_let_scope() {
-        check_scope_completion(
-            r"
-            fn quux() {
-                if let Some(x) = foo() {
-                    let y = 92;
-                };
-                if let Some(a) = bar() {
-                    let b = 62;
-                    1 + <|>
-                }
-            }
-            ",
-            r#"[CompletionItem { label: "b", lookup: None, snippet: None },
-                   CompletionItem { label: "a", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_completion_for_scope() {
-        check_scope_completion(
-            r"
-            fn quux() {
-                for x in &[1, 2, 3] {
-                    <|>
-                }
-            }
-            ",
-            r#"[CompletionItem { label: "x", lookup: None, snippet: None },
-                   CompletionItem { label: "quux", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_completion_mod_scope() {
-        check_scope_completion(
-            r"
-            struct Foo;
-            enum Baz {}
-            fn quux() {
-                <|>
-            }
-            ",
-            r#"[CompletionItem { label: "quux", lookup: None, snippet: None },
-                CompletionItem { label: "Foo", lookup: None, snippet: None },
-                CompletionItem { label: "Baz", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_completion_mod_scope_no_self_use() {
-        check_scope_completion(
-            r"
-            use foo<|>;
-            ",
-            r#"[]"#,
-        );
-    }
-    #[test]
-    fn test_completion_self_path() {
-        check_scope_completion(
-            r"
-            use self::m::<|>;
-            mod m {
-                struct Bar;
-            }
-            ",
-            r#"[CompletionItem { label: "Bar", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_completion_mod_scope_nested() {
-        check_scope_completion(
-            r"
-            struct Foo;
-            mod m {
-                struct Bar;
-                fn quux() { <|> }
-            }
-            ",
-            r#"[CompletionItem { label: "quux", lookup: None, snippet: None },
-                CompletionItem { label: "Bar", lookup: None, snippet: None }]"#,
-        );
-    }
-    #[test]
-    fn test_complete_type() {
-        check_scope_completion(
-            r"
-            struct Foo;
-            fn x() -> <|>
-        ",
-            r#"[CompletionItem { label: "Foo", lookup: None, snippet: None },
-               CompletionItem { label: "x", lookup: None, snippet: None }]"#,
-        )
-    }
-    #[test]
-    fn test_complete_shadowing() {
-        check_scope_completion(
-            r"
-            fn foo() -> {
-                let bar = 92;
-                {
-                    let bar = 62;
-                    <|>
-                }
-            }
-        ",
-            r#"[CompletionItem { label: "bar", lookup: None, snippet: None },
-               CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
-        )
-    }
-    #[test]
-    fn test_complete_self() {
-        check_scope_completion(
-            r"
-            impl S { fn foo(&self) { <|> } }
-        ",
-            r#"[CompletionItem { label: "self", lookup: None, snippet: None }]"#,
-        )
-    }
-    #[test]
-    fn test_completion_kewords() {
-        check_snippet_completion(r"
-            fn quux() {
-                <|>
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-    }
-    #[test]
-    fn test_completion_else() {
-        check_snippet_completion(r"
-            fn quux() {
-                if true {
-                    ()
-                } <|>
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "else", lookup: None, snippet: Some("else {$0}") },
-                   CompletionItem { label: "else if", lookup: None, snippet: Some("else if $0 {}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-    }
-    #[test]
-    fn test_completion_return_value() {
-        check_snippet_completion(r"
-            fn quux() -> i32 {
-                <|>
-                92
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return $0;") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-        check_snippet_completion(r"
-            fn quux() {
-                <|>
-                92
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return;") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-    }
-    #[test]
-    fn test_completion_return_no_stmt() {
-        check_snippet_completion(r"
-            fn quux() -> i32 {
-                match () {
-                    () => <|>
-                }
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return $0") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-    }
-    #[test]
-    fn test_continue_break_completion() {
-        check_snippet_completion(r"
-            fn quux() -> i32 {
-                loop { <|> }
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "continue", lookup: None, snippet: Some("continue") },
-                   CompletionItem { label: "break", lookup: None, snippet: Some("break") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return $0") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-        check_snippet_completion(r"
-            fn quux() -> i32 {
-                loop { || { <|> } }
-            }
-            ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") },
-                   CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") },
-                   CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") },
-                   CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") },
-                   CompletionItem { label: "return", lookup: None, snippet: Some("return $0") },
-                   CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") },
-                   CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#);
-    }
-    #[test]
-    fn test_param_completion_last_param() {
-        check_scope_completion(r"
-            fn foo(file_id: FileId) {}
-            fn bar(file_id: FileId) {}
-            fn baz(file<|>) {}
-        ", r#"[CompletionItem { label: "file_id: FileId", lookup: Some("file_id"), snippet: None }]"#);
-    }
-    #[test]
-    fn test_param_completion_nth_param() {
-        check_scope_completion(r"
-            fn foo(file_id: FileId) {}
-            fn bar(file_id: FileId) {}
-            fn baz(file<|>, x: i32) {}
-        ", r#"[CompletionItem { label: "file_id: FileId", lookup: Some("file_id"), snippet: None }]"#);
-    }
-    #[test]
-    fn test_param_completion_trait_param() {
-        check_scope_completion(r"
-            pub(crate) trait SourceRoot {
-                pub fn contains(&self, file_id: FileId) -> bool;
-                pub fn module_map(&self) -> &ModuleMap;
-                pub fn lines(&self, file_id: FileId) -> &LineIndex;
-                pub fn syntax(&self, file<|>)
-            }
-        ", r#"[CompletionItem { label: "self", lookup: None, snippet: None },
-               CompletionItem { label: "SourceRoot", lookup: None, snippet: None },
-               CompletionItem { label: "file_id: FileId", lookup: Some("file_id"), snippet: None }]"#);
-    }
-    #[test]
-    fn test_item_snippets() {
-        // check_snippet_completion(r"
-        //     <|>
-        //     ",
-        //     r##"[CompletionItem { label: "Test function", lookup: None, snippet: Some("#[test]\nfn test_${1:feature}() {\n$0\n}"##,
-        // );
-        check_snippet_completion(r"
-            #[cfg(test)]
-            mod tests {
-                <|>
-            }
-            ",
-            r##"[CompletionItem { label: "Test function", lookup: Some("tfn"), snippet: Some("#[test]\nfn ${1:feature}() {\n$0\n}") },
-                 CompletionItem { label: "pub(crate)", lookup: None, snippet: Some("pub(crate) $0") }]"##,
-        );
-    }
 }
diff --git a/crates/ra_analysis/src/completion/complete_fn_param.rs b/crates/ra_analysis/src/completion/complete_fn_param.rs
new file mode 100644
index 000000000..bb5fdfda0
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_fn_param.rs
@@ -0,0 +1,102 @@
+use ra_syntax::{
+    algo::visit::{visitor_ctx, VisitorCtx},
+    ast,
+    AstNode,
+};
+use rustc_hash::FxHashMap;
+use crate::completion::{CompletionContext, Completions, CompletionKind, CompletionItem};
+/// Complete repeated parametes, both name and type. For example, if all
+/// functions in a file have a `spam: &mut Spam` parameter, a completion with
+/// `spam: &mut Spam` insert text/label and `spam` lookup string will be
+/// suggested.
+pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) {
+    if !ctx.is_param {
+        return;
+    }
+    let mut params = FxHashMap::default();
+    for node in ctx.leaf.ancestors() {
+        let _ = visitor_ctx(&mut params)
+            .visit::<ast::SourceFile, _>(process)
+            .visit::<ast::ItemList, _>(process)
+            .accept(node);
+    }
+    params
+        .into_iter()
+        .filter_map(|(label, (count, param))| {
+            let lookup = param.pat()?.syntax().text().to_string();
+            if count < 2 {
+                None
+            } else {
+                Some((label, lookup))
+            }
+        })
+        .for_each(|(label, lookup)| {
+            CompletionItem::new(CompletionKind::Magic, label)
+                .lookup_by(lookup)
+                .add_to(acc)
+        });
+    fn process<'a, N: ast::FnDefOwner<'a>>(
+        node: N,
+        params: &mut FxHashMap<String, (u32, ast::Param<'a>)>,
+    ) {
+        node.functions()
+            .filter_map(|it| it.param_list())
+            .flat_map(|it| it.params())
+            .for_each(|param| {
+                let text = param.syntax().text().to_string();
+                params.entry(text).or_insert((0, param)).0 += 1;
+            })
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::completion::*;
+    fn check_magic_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Magic);
+    }
+    #[test]
+    fn test_param_completion_last_param() {
+        check_magic_completion(
+            r"
+            fn foo(file_id: FileId) {}
+            fn bar(file_id: FileId) {}
+            fn baz(file<|>) {}
+            ",
+            r#"file_id "file_id: FileId""#,
+        );
+    }
+    #[test]
+    fn test_param_completion_nth_param() {
+        check_magic_completion(
+            r"
+            fn foo(file_id: FileId) {}
+            fn bar(file_id: FileId) {}
+            fn baz(file<|>, x: i32) {}
+            ",
+            r#"file_id "file_id: FileId""#,
+        );
+    }
+    #[test]
+    fn test_param_completion_trait_param() {
+        check_magic_completion(
+            r"
+            pub(crate) trait SourceRoot {
+                pub fn contains(&self, file_id: FileId) -> bool;
+                pub fn module_map(&self) -> &ModuleMap;
+                pub fn lines(&self, file_id: FileId) -> &LineIndex;
+                pub fn syntax(&self, file<|>)
+            }
+            ",
+            r#"file_id "file_id: FileId""#,
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_keyword.rs b/crates/ra_analysis/src/completion/complete_keyword.rs
new file mode 100644
index 000000000..5427fcb11
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_keyword.rs
@@ -0,0 +1,204 @@
+use ra_syntax::{
+    algo::visit::{visitor, Visitor},
+    AstNode,
+    ast::{self, LoopBodyOwner},
+    SyntaxKind::*, SyntaxNodeRef,
+};
+use crate::completion::{CompletionContext, CompletionItem, Completions, CompletionKind, CompletionItemKind};
+fn keyword(kw: &str, snippet: &str) -> CompletionItem {
+    CompletionItem::new(CompletionKind::Keyword, kw)
+        .kind(CompletionItemKind::Keyword)
+        .snippet(snippet)
+        .build()
+}
+pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
+    if !ctx.is_trivial_path {
+        return;
+    }
+    let fn_def = match ctx.enclosing_fn {
+        Some(it) => it,
+        None => return,
+    };
+    acc.add(keyword("if", "if $0 {}"));
+    acc.add(keyword("match", "match $0 {}"));
+    acc.add(keyword("while", "while $0 {}"));
+    acc.add(keyword("loop", "loop {$0}"));
+    if ctx.after_if {
+        acc.add(keyword("else", "else {$0}"));
+        acc.add(keyword("else if", "else if $0 {}"));
+    }
+    if is_in_loop_body(ctx.leaf) {
+        acc.add(keyword("continue", "continue"));
+        acc.add(keyword("break", "break"));
+    }
+    acc.add_all(complete_return(fn_def, ctx.is_stmt));
+}
+fn is_in_loop_body(leaf: SyntaxNodeRef) -> bool {
+    for node in leaf.ancestors() {
+        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
+            break;
+        }
+        let loop_body = visitor()
+            .visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
+            .visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
+            .accept(node);
+        if let Some(Some(body)) = loop_body {
+            if leaf.range().is_subrange(&body.syntax().range()) {
+                return true;
+            }
+        }
+    }
+    false
+}
+fn complete_return(fn_def: ast::FnDef, is_stmt: bool) -> Option<CompletionItem> {
+    let snip = match (is_stmt, fn_def.ret_type().is_some()) {
+        (true, true) => "return $0;",
+        (true, false) => "return;",
+        (false, true) => "return $0",
+        (false, false) => "return",
+    };
+    Some(keyword("return", snip))
+}
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+    fn check_keyword_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Keyword);
+    }
+    #[test]
+    fn test_completion_kewords() {
+        check_keyword_completion(
+            r"
+            fn quux() {
+                <|>
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return"
+            "#,
+        );
+    }
+    #[test]
+    fn test_completion_else() {
+        check_keyword_completion(
+            r"
+            fn quux() {
+                if true {
+                    ()
+                } <|>
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            else "else {$0}"
+            else if "else if $0 {}"
+            return "return"
+            "#,
+        );
+    }
+    #[test]
+    fn test_completion_return_value() {
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                <|>
+                92
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return $0;"
+            "#,
+        );
+        check_keyword_completion(
+            r"
+            fn quux() {
+                <|>
+                92
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return;"
+            "#,
+        );
+    }
+    #[test]
+    fn test_completion_return_no_stmt() {
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                match () {
+                    () => <|>
+                }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return $0"
+            "#,
+        );
+    }
+    #[test]
+    fn test_continue_break_completion() {
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                loop { <|> }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            continue "continue"
+            break "break"
+            return "return $0"
+            "#,
+        );
+        check_keyword_completion(
+            r"
+            fn quux() -> i32 {
+                loop { || { <|> } }
+            }
+            ",
+            r#"
+            if "if $0 {}"
+            match "match $0 {}"
+            while "while $0 {}"
+            loop "loop {$0}"
+            return "return $0"
+            "#,
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_path.rs b/crates/ra_analysis/src/completion/complete_path.rs
new file mode 100644
index 000000000..ad4d68a33
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_path.rs
@@ -0,0 +1,95 @@
+use crate::{
+    Cancelable,
+    completion::{CompletionItem, Completions, CompletionKind, CompletionContext},
+};
+pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
+    let (path, module) = match (&ctx.path_prefix, &ctx.module) {
+        (Some(path), Some(module)) => (path.clone(), module),
+        _ => return Ok(()),
+    };
+    let def_id = match module.resolve_path(ctx.db, path)? {
+        Some(it) => it,
+        None => return Ok(()),
+    };
+    let target_module = match def_id.resolve(ctx.db)? {
+        hir::Def::Module(it) => it,
+        _ => return Ok(()),
+    };
+    let module_scope = target_module.scope(ctx.db)?;
+    module_scope.entries().for_each(|(name, res)| {
+        CompletionItem::new(CompletionKind::Reference, name.to_string())
+            .from_resolution(ctx.db, res)
+            .add_to(acc)
+    });
+    Ok(())
+}
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+    fn check_reference_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Reference);
+    }
+    #[test]
+    fn completes_use_item_starting_with_self() {
+        check_reference_completion(
+            r"
+            use self::m::<|>;
+            mod m {
+                struct Bar;
+            }
+            ",
+            "Bar",
+        );
+    }
+    #[test]
+    fn completes_use_item_starting_with_crate() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            mod foo;
+            struct Spam;
+            //- /foo.rs
+            use crate::Sp<|>
+            ",
+            "Spam;foo",
+        );
+    }
+    #[test]
+    fn completes_nested_use_tree() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            mod foo;
+            struct Spam;
+            //- /foo.rs
+            use crate::{Sp<|>};
+            ",
+            "Spam;foo",
+        );
+    }
+    #[test]
+    fn completes_deeply_nested_use_tree() {
+        check_reference_completion(
+            "
+            //- /lib.rs
+            mod foo;
+            pub mod bar {
+                pub mod baz {
+                    pub struct Spam;
+                }
+            }
+            //- /foo.rs
+            use crate::{bar::{baz::Sp<|>}};
+            ",
+            "Spam",
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_scope.rs b/crates/ra_analysis/src/completion/complete_scope.rs
new file mode 100644
index 000000000..a57670e3b
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_scope.rs
@@ -0,0 +1,173 @@
+use rustc_hash::FxHashSet;
+use ra_syntax::TextUnit;
+use crate::{
+    Cancelable,
+    completion::{CompletionItem, CompletionItemKind, Completions, CompletionKind, CompletionContext},
+};
+pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> {
+    if !ctx.is_trivial_path {
+        return Ok(());
+    }
+    let module = match &ctx.module {
+        Some(it) => it,
+        None => return Ok(()),
+    };
+    if let Some(fn_def) = ctx.enclosing_fn {
+        let function = hir::source_binder::function_from_module(ctx.db, module, fn_def);
+        let scopes = function.scopes(ctx.db);
+        complete_fn(acc, &scopes, ctx.offset);
+    }
+    let module_scope = module.scope(ctx.db)?;
+    module_scope
+        .entries()
+        .filter(|(_name, res)| {
+            // Don't expose this item
+            match res.import {
+                None => true,
+                Some(import) => {
+                    let range = import.range(ctx.db, module.source().file_id());
+                    !range.is_subrange(&ctx.leaf.range())
+                }
+            }
+        })
+        .for_each(|(name, res)| {
+            CompletionItem::new(CompletionKind::Reference, name.to_string())
+                .from_resolution(ctx.db, res)
+                .add_to(acc)
+        });
+    Ok(())
+}
+fn complete_fn(acc: &mut Completions, scopes: &hir::FnScopes, offset: TextUnit) {
+    let mut shadowed = FxHashSet::default();
+    scopes
+        .scope_chain_for_offset(offset)
+        .flat_map(|scope| scopes.entries(scope).iter())
+        .filter(|entry| shadowed.insert(entry.name()))
+        .for_each(|entry| {
+            CompletionItem::new(CompletionKind::Reference, entry.name().to_string())
+                .kind(CompletionItemKind::Binding)
+                .add_to(acc)
+        });
+    if scopes.self_param.is_some() {
+        CompletionItem::new(CompletionKind::Reference, "self").add_to(acc);
+    }
+}
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+    fn check_reference_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Reference);
+    }
+    #[test]
+    fn completes_bindings_from_let() {
+        check_reference_completion(
+            r"
+            fn quux(x: i32) {
+                let y = 92;
+                1 + <|>;
+                let z = ();
+            }
+            ",
+            "y;x;quux",
+        );
+    }
+    #[test]
+    fn completes_bindings_from_if_let() {
+        check_reference_completion(
+            r"
+            fn quux() {
+                if let Some(x) = foo() {
+                    let y = 92;
+                };
+                if let Some(a) = bar() {
+                    let b = 62;
+                    1 + <|>
+                }
+            }
+            ",
+            "b;a;quux",
+        );
+    }
+    #[test]
+    fn completes_bindings_from_for() {
+        check_reference_completion(
+            r"
+            fn quux() {
+                for x in &[1, 2, 3] {
+                    <|>
+                }
+            }
+            ",
+            "x;quux",
+        );
+    }
+    #[test]
+    fn completes_module_items() {
+        check_reference_completion(
+            r"
+            struct Foo;
+            enum Baz {}
+            fn quux() {
+                <|>
+            }
+            ",
+            "quux;Foo;Baz",
+        );
+    }
+    #[test]
+    fn completes_module_items_in_nested_modules() {
+        check_reference_completion(
+            r"
+            struct Foo;
+            mod m {
+                struct Bar;
+                fn quux() { <|> }
+            }
+            ",
+            "quux;Bar",
+        );
+    }
+    #[test]
+    fn completes_return_type() {
+        check_reference_completion(
+            r"
+            struct Foo;
+            fn x() -> <|>
+            ",
+            "Foo;x",
+        )
+    }
+    #[test]
+    fn dont_show_to_completions_for_shadowing() {
+        check_reference_completion(
+            r"
+            fn foo() -> {
+                let bar = 92;
+                {
+                    let bar = 62;
+                    <|>
+                }
+            }
+            ",
+            "bar;foo",
+        )
+    }
+    #[test]
+    fn completes_self_in_methods() {
+        check_reference_completion(r"impl S { fn foo(&self) { <|> } }", "self")
+    }
+}
diff --git a/crates/ra_analysis/src/completion/complete_snippet.rs b/crates/ra_analysis/src/completion/complete_snippet.rs
new file mode 100644
index 000000000..fb9da0a4f
--- /dev/null
+++ b/crates/ra_analysis/src/completion/complete_snippet.rs
@@ -0,0 +1,73 @@
+use crate::completion::{CompletionItem, Completions, CompletionKind, CompletionItemKind, CompletionContext, completion_item::Builder};
+fn snippet(label: &str, snippet: &str) -> Builder {
+    CompletionItem::new(CompletionKind::Snippet, label)
+        .snippet(snippet)
+        .kind(CompletionItemKind::Snippet)
+}
+pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
+    if !(ctx.is_trivial_path && ctx.enclosing_fn.is_some()) {
+        return;
+    }
+    snippet("pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
+    snippet("ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
+}
+pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionContext) {
+    if !ctx.is_new_item {
+        return;
+    }
+    snippet(
+        "Test function",
+        "\
+#[test]
+fn ${1:feature}() {
+    $0
+}",
+    )
+    .lookup_by("tfn")
+    .add_to(acc);
+    snippet("pub(crate)", "pub(crate) $0").add_to(acc);
+}
+#[cfg(test)]
+mod tests {
+    use crate::completion::{CompletionKind, check_completion};
+    fn check_snippet_completion(code: &str, expected_completions: &str) {
+        check_completion(code, expected_completions, CompletionKind::Snippet);
+    }
+    #[test]
+    fn completes_snippets_in_expressions() {
+        check_snippet_completion(
+            r"fn foo(x: i32) { <|> }",
+            r##"
+            pd "eprintln!(\"$0 = {:?}\", $0);"
+            ppd "eprintln!(\"$0 = {:#?}\", $0);"
+            "##,
+        );
+    }
+    #[test]
+    fn completes_snippets_in_items() {
+        // check_snippet_completion(r"
+        //     <|>
+        //     ",
+        //     r##"[CompletionItem { label: "Test function", lookup: None, snippet: Some("#[test]\nfn test_${1:feature}() {\n$0\n}"##,
+        // );
+        check_snippet_completion(
+            r"
+            #[cfg(test)]
+            mod tests {
+                <|>
+            }
+            ",
+            r##"
+            tfn "Test function" "#[test]\nfn ${1:feature}() {\n    $0\n}"
+            pub(crate) "pub(crate) $0"
+            "##,
+        );
+    }
+}
diff --git a/crates/ra_analysis/src/completion/completion_context.rs b/crates/ra_analysis/src/completion/completion_context.rs
new file mode 100644
index 000000000..064fbc6f7
--- /dev/null
+++ b/crates/ra_analysis/src/completion/completion_context.rs
@@ -0,0 +1,156 @@
+use ra_editor::find_node_at_offset;
+use ra_text_edit::AtomTextEdit;
+use ra_syntax::{
+    algo::find_leaf_at_offset,
+    ast,
+    AstNode,
+    SyntaxNodeRef,
+    SourceFileNode,
+    TextUnit,
+    SyntaxKind::*,
+};
+use hir::source_binder;
+use crate::{db, FilePosition, Cancelable};
+/// `CompletionContext` is created early during completion to figure out, where
+/// exactly is the cursor, syntax-wise.
+#[derive(Debug)]
+pub(super) struct CompletionContext<'a> {
+    pub(super) db: &'a db::RootDatabase,
+    pub(super) offset: TextUnit,
+    pub(super) leaf: SyntaxNodeRef<'a>,
+    pub(super) module: Option<hir::Module>,
+    pub(super) enclosing_fn: Option<ast::FnDef<'a>>,
+    pub(super) is_param: bool,
+    /// A single-indent path, like `foo`.
+    pub(super) is_trivial_path: bool,
+    /// If not a trivial, path, the prefix (qualifier).
+    pub(super) path_prefix: Option<hir::Path>,
+    pub(super) after_if: bool,
+    pub(super) is_stmt: bool,
+    /// Something is typed at the "top" level, in module or impl/trait.
+    pub(super) is_new_item: bool,
+}
+impl<'a> CompletionContext<'a> {
+    pub(super) fn new(
+        db: &'a db::RootDatabase,
+        original_file: &'a SourceFileNode,
+        position: FilePosition,
+    ) -> Cancelable<Option<CompletionContext<'a>>> {
+        let module = source_binder::module_from_position(db, position)?;
+        let leaf =
+            ctry!(find_leaf_at_offset(original_file.syntax(), position.offset).left_biased());
+        let mut ctx = CompletionContext {
+            db,
+            leaf,
+            offset: position.offset,
+            module,
+            enclosing_fn: None,
+            is_param: false,
+            is_trivial_path: false,
+            path_prefix: None,
+            after_if: false,
+            is_stmt: false,
+            is_new_item: false,
+        };
+        ctx.fill(original_file, position.offset);
+        Ok(Some(ctx))
+    }
+    fn fill(&mut self, original_file: &SourceFileNode, offset: TextUnit) {
+        // Insert a fake ident to get a valid parse tree. We will use this file
+        // to determine context, though the original_file will be used for
+        // actual completion.
+        let file = {
+            let edit = AtomTextEdit::insert(offset, "intellijRulezz".to_string());
+            original_file.reparse(&edit)
+        };
+        // First, let's try to complete a reference to some declaration.
+        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), offset) {
+            // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`.
+            // See RFC#1685.
+            if is_node::<ast::Param>(name_ref.syntax()) {
+                self.is_param = true;
+                return;
+            }
+            self.classify_name_ref(&file, name_ref);
+        }
+        // Otherwise, see if this is a declaration. We can use heuristics to
+        // suggest declaration names, see `CompletionKind::Magic`.
+        if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), offset) {
+            if is_node::<ast::Param>(name.syntax()) {
+                self.is_param = true;
+                return;
+            }
+        }
+    }
+    fn classify_name_ref(&mut self, file: &SourceFileNode, name_ref: ast::NameRef) {
+        let name_range = name_ref.syntax().range();
+        let top_node = name_ref
+            .syntax()
+            .ancestors()
+            .take_while(|it| it.range() == name_range)
+            .last()
+            .unwrap();
+        match top_node.parent().map(|it| it.kind()) {
+            Some(SOURCE_FILE) | Some(ITEM_LIST) => {
+                self.is_new_item = true;
+                return;
+            }
+            _ => (),
+        }
+        let parent = match name_ref.syntax().parent() {
+            Some(it) => it,
+            None => return,
+        };
+        if let Some(segment) = ast::PathSegment::cast(parent) {
+            let path = segment.parent_path();
+            if let Some(mut path) = hir::Path::from_ast(path) {
+                if !path.is_ident() {
+                    path.segments.pop().unwrap();
+                    self.path_prefix = Some(path);
+                    return;
+                }
+            }
+            if path.qualifier().is_none() {
+                self.is_trivial_path = true;
+                self.enclosing_fn = self
+                    .leaf
+                    .ancestors()
+                    .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
+                    .find_map(ast::FnDef::cast);
+                self.is_stmt = match name_ref
+                    .syntax()
+                    .ancestors()
+                    .filter_map(ast::ExprStmt::cast)
+                    .next()
+                {
+                    None => false,
+                    Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(),
+                };
+                if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) {
+                    if let Some(if_expr) = find_node_at_offset::<ast::IfExpr>(file.syntax(), off) {
+                        if if_expr.syntax().range().end() < name_ref.syntax().range().start() {
+                            self.after_if = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
+    match node.ancestors().filter_map(N::cast).next() {
+        None => false,
+        Some(n) => n.syntax().range() == node.range(),
+    }
+}
diff --git a/crates/ra_analysis/src/completion/completion_item.rs b/crates/ra_analysis/src/completion/completion_item.rs
new file mode 100644
index 000000000..911f08468
--- /dev/null
+++ b/crates/ra_analysis/src/completion/completion_item.rs
@@ -0,0 +1,214 @@
+use crate::db;
+/// `CompletionItem` describes a single completion variant in the editor pop-up.
+/// It is basically a POD with various properties. To construct a
+/// `CompletionItem`, use `new` method and the `Builder` struct.
+#[derive(Debug)]
+pub struct CompletionItem {
+    /// Used only internally in tests, to check only specific kind of
+    /// completion.
+    completion_kind: CompletionKind,
+    label: String,
+    lookup: Option<String>,
+    snippet: Option<String>,
+    kind: Option<CompletionItemKind>,
+}
+pub enum InsertText {
+    PlainText { text: String },
+    Snippet { text: String },
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CompletionItemKind {
+    Snippet,
+    Keyword,
+    Module,
+    Function,
+    Binding,
+}
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum CompletionKind {
+    /// Parser-based keyword completion.
+    Keyword,
+    /// Your usual "complete all valid identifiers".
+    Reference,
+    /// "Secret sauce" completions.
+    Magic,
+    Snippet,
+}
+impl CompletionItem {
+    pub(crate) fn new(completion_kind: CompletionKind, label: impl Into<String>) -> Builder {
+        let label = label.into();
+        Builder {
+            completion_kind,
+            label,
+            lookup: None,
+            snippet: None,
+            kind: None,
+        }
+    }
+    /// What user sees in pop-up in the UI.
+    pub fn label(&self) -> &str {
+        &self.label
+    }
+    /// What string is used for filtering.
+    pub fn lookup(&self) -> &str {
+        self.lookup
+            .as_ref()
+            .map(|it| it.as_str())
+            .unwrap_or(self.label())
+    }
+    /// What is inserted.
+    pub fn insert_text(&self) -> InsertText {
+        match &self.snippet {
+            None => InsertText::PlainText {
+                text: self.label.clone(),
+            },
+            Some(it) => InsertText::Snippet { text: it.clone() },
+        }
+    }
+    pub fn kind(&self) -> Option<CompletionItemKind> {
+        self.kind
+    }
+}
+/// A helper to make `CompletionItem`s.
+#[must_use]
+pub(crate) struct Builder {
+    completion_kind: CompletionKind,
+    label: String,
+    lookup: Option<String>,
+    snippet: Option<String>,
+    kind: Option<CompletionItemKind>,
+}
+impl Builder {
+    pub(crate) fn add_to(self, acc: &mut Completions) {
+        acc.add(self.build())
+    }
+    pub(crate) fn build(self) -> CompletionItem {
+        CompletionItem {
+            label: self.label,
+            lookup: self.lookup,
+            snippet: self.snippet,
+            kind: self.kind,
+            completion_kind: self.completion_kind,
+        }
+    }
+    pub(crate) fn lookup_by(mut self, lookup: impl Into<String>) -> Builder {
+        self.lookup = Some(lookup.into());
+        self
+    }
+    pub(crate) fn snippet(mut self, snippet: impl Into<String>) -> Builder {
+        self.snippet = Some(snippet.into());
+        self
+    }
+    pub(crate) fn kind(mut self, kind: CompletionItemKind) -> Builder {
+        self.kind = Some(kind);
+        self
+    }
+    pub(crate) fn from_resolution(
+        mut self,
+        db: &db::RootDatabase,
+        resolution: &hir::Resolution,
+    ) -> Builder {
+        if let Some(def_id) = resolution.def_id {
+            if let Ok(def) = def_id.resolve(db) {
+                let kind = match def {
+                    hir::Def::Module(..) => CompletionItemKind::Module,
+                    hir::Def::Function(..) => CompletionItemKind::Function,
+                    _ => return self,
+                };
+                self.kind = Some(kind);
+            }
+        }
+        self
+    }
+}
+impl Into<CompletionItem> for Builder {
+    fn into(self) -> CompletionItem {
+        self.build()
+    }
+}
+/// Represents an in-progress set of completions being built.
+#[derive(Debug, Default)]
+pub(crate) struct Completions {
+    buf: Vec<CompletionItem>,
+}
+impl Completions {
+    pub(crate) fn add(&mut self, item: impl Into<CompletionItem>) {
+        self.buf.push(item.into())
+    }
+    pub(crate) fn add_all<I>(&mut self, items: I)
+    where
+        I: IntoIterator,
+        I::Item: Into<CompletionItem>,
+    {
+        items.into_iter().for_each(|item| self.add(item.into()))
+    }
+    #[cfg(test)]
+    pub(crate) fn assert_match(&self, expected: &str, kind: CompletionKind) {
+        let expected = normalize(expected);
+        let actual = self.debug_render(kind);
+        test_utils::assert_eq_text!(expected.as_str(), actual.as_str(),);
+        /// Normalize the textual representation of `Completions`:
+        /// replace `;` with newlines, normalize whitespace
+        fn normalize(expected: &str) -> String {
+            use ra_syntax::{tokenize, TextUnit, TextRange, SyntaxKind::SEMI};
+            let mut res = String::new();
+            for line in expected.trim().lines() {
+                let line = line.trim();
+                let mut start_offset: TextUnit = 0.into();
+                // Yep, we use rust tokenize in completion tests :-)
+                for token in tokenize(line) {
+                    let range = TextRange::offset_len(start_offset, token.len);
+                    start_offset += token.len;
+                    if token.kind == SEMI {
+                        res.push('\n');
+                    } else {
+                        res.push_str(&line[range]);
+                    }
+                }
+                res.push('\n');
+            }
+            res
+        }
+    }
+    #[cfg(test)]
+    fn debug_render(&self, kind: CompletionKind) -> String {
+        let mut res = String::new();
+        for c in self.buf.iter() {
+            if c.completion_kind == kind {
+                if let Some(lookup) = &c.lookup {
+                    res.push_str(lookup);
+                    res.push_str(&format!(" {:?}", c.label));
+                } else {
+                    res.push_str(&c.label);
+                }
+                if let Some(snippet) = &c.snippet {
+                    res.push_str(&format!(" {:?}", snippet));
+                }
+                res.push('\n');
+            }
+        }
+        res
+    }
+}
+impl Into<Vec<CompletionItem>> for Completions {
+    fn into(self) -> Vec<CompletionItem> {
+        self.buf
+    }
+}
diff --git a/crates/ra_analysis/src/completion/reference_completion.rs b/crates/ra_analysis/src/completion/reference_completion.rs
deleted file mode 100644
index f483ed045..000000000
--- a/crates/ra_analysis/src/completion/reference_completion.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-use rustc_hash::{FxHashSet};
-use ra_editor::find_node_at_offset;
-use ra_syntax::{
-    algo::visit::{visitor, Visitor},
-    SourceFileNode, AstNode,
-    ast::{self, LoopBodyOwner},
-    SyntaxKind::*,
-};
-use     hir::{
-        self,
-        FnScopes,
-        Def,
-        Path,
-};
-use crate::{
-    db::RootDatabase,
-    completion::CompletionItem,
-    Cancelable
-};
-pub(super) fn completions(
-    acc: &mut Vec<CompletionItem>,
-    db: &RootDatabase,
-    module: &hir::Module,
-    file: &SourceFileNode,
-    name_ref: ast::NameRef,
-) -> Cancelable<()> {
-    let kind = match classify_name_ref(name_ref) {
-        Some(it) => it,
-        None => return Ok(()),
-    };
-    match kind {
-        NameRefKind::LocalRef { enclosing_fn } => {
-            if let Some(fn_def) = enclosing_fn {
-                let scopes = FnScopes::new(fn_def);
-                complete_fn(name_ref, &scopes, acc);
-                complete_expr_keywords(&file, fn_def, name_ref, acc);
-                complete_expr_snippets(acc);
-            }
-            let module_scope = module.scope(db)?;
-            acc.extend(
-                module_scope
-                    .entries()
-                    .filter(|(_name, res)| {
-                        // Don't expose this item
-                        match res.import {
-                            None => true,
-                            Some(import) => {
-                                let range = import.range(db, module.source().file_id());
-                                !range.is_subrange(&name_ref.syntax().range())
-                            }
-                        }
-                    })
-                    .map(|(name, _res)| CompletionItem {
-                        label: name.to_string(),
-                        lookup: None,
-                        snippet: None,
-                    }),
-            );
-        }
-        NameRefKind::Path(path) => complete_path(acc, db, module, path)?,
-        NameRefKind::BareIdentInMod => {
-            let name_range = name_ref.syntax().range();
-            let top_node = name_ref
-                .syntax()
-                .ancestors()
-                .take_while(|it| it.range() == name_range)
-                .last()
-                .unwrap();
-            match top_node.parent().map(|it| it.kind()) {
-                Some(SOURCE_FILE) | Some(ITEM_LIST) => complete_mod_item_snippets(acc),
-                _ => (),
-            }
-        }
-    }
-    Ok(())
-}
-enum NameRefKind<'a> {
-    /// NameRef is a part of single-segment path, for example, a refernece to a
-    /// local variable.
-    LocalRef {
-        enclosing_fn: Option<ast::FnDef<'a>>,
-    },
-    /// NameRef is the last segment in some path
-    Path(Path),
-    /// NameRef is bare identifier at the module's root.
-    /// Used for keyword completion
-    BareIdentInMod,
-}
-fn classify_name_ref(name_ref: ast::NameRef) -> Option<NameRefKind> {
-    let name_range = name_ref.syntax().range();
-    let top_node = name_ref
-        .syntax()
-        .ancestors()
-        .take_while(|it| it.range() == name_range)
-        .last()
-        .unwrap();
-    match top_node.parent().map(|it| it.kind()) {
-        Some(SOURCE_FILE) | Some(ITEM_LIST) => return Some(NameRefKind::BareIdentInMod),
-        _ => (),
-    }
-    let parent = name_ref.syntax().parent()?;
-    if let Some(segment) = ast::PathSegment::cast(parent) {
-        let path = segment.parent_path();
-        if let Some(path) = Path::from_ast(path) {
-            if !path.is_ident() {
-                return Some(NameRefKind::Path(path));
-            }
-        }
-        if path.qualifier().is_none() {
-            let enclosing_fn = name_ref
-                .syntax()
-                .ancestors()
-                .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
-                .find_map(ast::FnDef::cast);
-            return Some(NameRefKind::LocalRef { enclosing_fn });
-        }
-    }
-    None
-}
-fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
-    let mut shadowed = FxHashSet::default();
-    acc.extend(
-        scopes
-            .scope_chain(name_ref.syntax())
-            .flat_map(|scope| scopes.entries(scope).iter())
-            .filter(|entry| shadowed.insert(entry.name()))
-            .map(|entry| CompletionItem {
-                label: entry.name().to_string(),
-                lookup: None,
-                snippet: None,
-            }),
-    );
-    if scopes.self_param.is_some() {
-        acc.push(CompletionItem {
-            label: "self".to_string(),
-            lookup: None,
-            snippet: None,
-        })
-    }
-}
-fn complete_path(
-    acc: &mut Vec<CompletionItem>,
-    db: &RootDatabase,
-    module: &hir::Module,
-    mut path: Path,
-) -> Cancelable<()> {
-    if path.segments.is_empty() {
-        return Ok(());
-    }
-    path.segments.pop();
-    let def_id = match module.resolve_path(db, path)? {
-        None => return Ok(()),
-        Some(it) => it,
-    };
-    let target_module = match def_id.resolve(db)? {
-        Def::Module(it) => it,
-        _ => return Ok(()),
-    };
-    let module_scope = target_module.scope(db)?;
-    let completions = module_scope.entries().map(|(name, _res)| CompletionItem {
-        label: name.to_string(),
-        lookup: None,
-        snippet: None,
-    });
-    acc.extend(completions);
-    Ok(())
-}
-fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
-    acc.push(CompletionItem {
-        label: "Test function".to_string(),
-        lookup: Some("tfn".to_string()),
-        snippet: Some(
-            "#[test]\n\
-             fn ${1:feature}() {\n\
-             $0\n\
-             }"
-            .to_string(),
-        ),
-    });
-    acc.push(CompletionItem {
-        label: "pub(crate)".to_string(),
-        lookup: None,
-        snippet: Some("pub(crate) $0".to_string()),
-    })
-}
-fn complete_expr_keywords(
-    file: &SourceFileNode,
-    fn_def: ast::FnDef,
-    name_ref: ast::NameRef,
-    acc: &mut Vec<CompletionItem>,
-) {
-    acc.push(keyword("if", "if $0 {}"));
-    acc.push(keyword("match", "match $0 {}"));
-    acc.push(keyword("while", "while $0 {}"));
-    acc.push(keyword("loop", "loop {$0}"));
-    if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) {
-        if let Some(if_expr) = find_node_at_offset::<ast::IfExpr>(file.syntax(), off) {
-            if if_expr.syntax().range().end() < name_ref.syntax().range().start() {
-                acc.push(keyword("else", "else {$0}"));
-                acc.push(keyword("else if", "else if $0 {}"));
-            }
-        }
-    }
-    if is_in_loop_body(name_ref) {
-        acc.push(keyword("continue", "continue"));
-        acc.push(keyword("break", "break"));
-    }
-    acc.extend(complete_return(fn_def, name_ref));
-}
-fn is_in_loop_body(name_ref: ast::NameRef) -> bool {
-    for node in name_ref.syntax().ancestors() {
-        if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
-            break;
-        }
-        let loop_body = visitor()
-            .visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
-            .visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
-            .visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
-            .accept(node);
-        if let Some(Some(body)) = loop_body {
-            if name_ref
-                .syntax()
-                .range()
-                .is_subrange(&body.syntax().range())
-            {
-                return true;
-            }
-        }
-    }
-    false
-}
-fn complete_return(fn_def: ast::FnDef, name_ref: ast::NameRef) -> Option<CompletionItem> {
-    // let is_last_in_block = name_ref.syntax().ancestors().filter_map(ast::Expr::cast)
-    //     .next()
-    //     .and_then(|it| it.syntax().parent())
-    //     .and_then(ast::Block::cast)
-    //     .is_some();
-    // if is_last_in_block {
-    //     return None;
-    // }
-    let is_stmt = match name_ref
-        .syntax()
-        .ancestors()
-        .filter_map(ast::ExprStmt::cast)
-        .next()
-    {
-        None => false,
-        Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(),
-    };
-    let snip = match (is_stmt, fn_def.ret_type().is_some()) {
-        (true, true) => "return $0;",
-        (true, false) => "return;",
-        (false, true) => "return $0",
-        (false, false) => "return",
-    };
-    Some(keyword("return", snip))
-}
-fn keyword(kw: &str, snip: &str) -> CompletionItem {
-    CompletionItem {
-        label: kw.to_string(),
-        lookup: None,
-        snippet: Some(snip.to_string()),
-    }
-}
-fn complete_expr_snippets(acc: &mut Vec<CompletionItem>) {
-    acc.push(CompletionItem {
-        label: "pd".to_string(),
-        lookup: None,
-        snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()),
-    });
-    acc.push(CompletionItem {
-        label: "ppd".to_string(),
-        lookup: None,
-        snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()),
-    });
-}
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 3d0f13f34..94729d296 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{fmt, sync::Arc};
 use salsa::{self, Database};
 use ra_db::{LocationIntener, BaseDatabase};
 use hir::{self, DefId, DefLoc};
@@ -13,11 +13,19 @@ pub(crate) struct RootDatabase {
    id_maps: Arc<IdMaps>,
 }
-#[derive(Debug, Default)]
+#[derive(Default)]
 struct IdMaps {
    defs: LocationIntener<DefLoc, DefId>,
 }
+impl fmt::Debug for IdMaps {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("IdMaps")
+            .field("n_defs", &self.defs.len())
+            .finish()
+    }
+}
 impl salsa::Database for RootDatabase {
    fn salsa_runtime(&self) -> &salsa::Runtime<RootDatabase> {
        &self.runtime
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index b44d9297a..b01382808 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -25,7 +25,7 @@ use crate::{
    db,
    symbol_index::{SymbolIndex, SymbolsDatabase, LibrarySymbolsQuery},
    AnalysisChange, RootChange, Cancelable, CrateId, Diagnostic, FileId,
-    FileSystemEdit, FilePosition, Query, SourceChange, SourceFileNodeEdit,
+    FileSystemEdit, FilePosition, Query, SourceChange, SourceFileEdit,
    ReferenceResolution,
 };
@@ -219,7 +219,8 @@ impl AnalysisImpl {
        self.db.crate_graph().crate_root(crate_id)
    }
    pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
-        completions(&self.db, position)
+        let completions = completions(&self.db, position)?;
+        Ok(completions.map(|it| it.into()))
    }
    pub fn approximately_resolve_symbol(
        &self,
@@ -234,7 +235,7 @@ impl AnalysisImpl {
                position.file_id,
                name_ref.syntax(),
            )? {
-                let scope = fn_descr.scope(&*self.db);
+                let scope = fn_descr.scopes(&*self.db);
                // First try to resolve the symbol locally
                if let Some(entry) = scope.resolve_local_name(name_ref) {
                    rr.add_resolution(
@@ -293,7 +294,7 @@ impl AnalysisImpl {
        let mut ret = vec![(position.file_id, binding.syntax().range())];
        ret.extend(
            descr
-                .scope(&*self.db)
+                .scopes(&*self.db)
                .find_all_refs(binding)
                .into_iter()
                .map(|ref_desc| (position.file_id, ref_desc.range)),
@@ -321,7 +322,7 @@ impl AnalysisImpl {
                position.file_id,
                name_ref.syntax(),
            )?);
-            let scope = descr.scope(db);
+            let scope = descr.scopes(db);
            let resolved = ctry!(scope.resolve_local_name(name_ref));
            let resolved = resolved.ptr().resolve(source_file);
            let binding = ctry!(find_node_at_offset::<ast::BindPat>(
@@ -368,10 +369,11 @@ impl AnalysisImpl {
            .collect::<Vec<_>>();
        if let Some(m) = source_binder::module_from_file_id(&*self.db, file_id)? {
            for (name_node, problem) in m.problems(&*self.db) {
+                let source_root = self.db.file_source_root(file_id);
                let diag = match problem {
                    Problem::UnresolvedModule { candidate } => {
                        let create_file = FileSystemEdit::CreateFile {
-                            anchor: file_id,
+                            source_root,
                            path: candidate.clone(),
                        };
                        let fix = SourceChange {
@@ -388,11 +390,12 @@ impl AnalysisImpl {
                    }
                    Problem::NotDirOwner { move_to, candidate } => {
                        let move_file = FileSystemEdit::MoveFile {
-                            file: file_id,
+                            src: file_id,
-                            path: move_to.clone(),
+                            dst_source_root: source_root,
+                            dst_path: move_to.clone(),
                        };
                        let create_file = FileSystemEdit::CreateFile {
-                            anchor: file_id,
+                            source_root,
                            path: move_to.join(candidate),
                        };
                        let fix = SourceChange {
@@ -518,9 +521,9 @@ impl AnalysisImpl {
 impl SourceChange {
    pub(crate) fn from_local_edit(file_id: FileId, label: &str, edit: LocalEdit) -> SourceChange {
-        let file_edit = SourceFileNodeEdit {
+        let file_edit = SourceFileEdit {
            file_id,
-            edits: edit.edit.into_atoms(),
+            edit: edit.edit,
        };
        SourceChange {
            label: label.to_string(),
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index a1d462528..85df9c089 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -20,7 +20,7 @@ use std::{fmt, sync::Arc};
 use rustc_hash::FxHashMap;
 use ra_syntax::{SourceFileNode, TextRange, TextUnit};
-use ra_text_edit::AtomTextEdit;
+use ra_text_edit::TextEdit;
 use rayon::prelude::*;
 use relative_path::RelativePathBuf;
@@ -30,7 +30,7 @@ use crate::{
 };
 pub use crate::{
-    completion::CompletionItem,
+    completion::{CompletionItem, CompletionItemKind, InsertText},
 };
 pub use ra_editor::{
    FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable, RunnableKind, StructureNode,
@@ -72,13 +72,23 @@ struct RemoveFile {
 impl fmt::Debug for AnalysisChange {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("AnalysisChange")
+        let mut d = fmt.debug_struct("AnalysisChange");
-            .field("new_roots", &self.new_roots)
+        if !self.new_roots.is_empty() {
-            .field("roots_changed", &self.roots_changed)
+            d.field("new_roots", &self.new_roots);
-            .field("files_changed", &self.files_changed.len())
+        }
-            .field("libraries_added", &self.libraries_added.len())
+        if !self.roots_changed.is_empty() {
-            .field("crate_graph", &self.crate_graph)
+            d.field("roots_changed", &self.roots_changed);
-            .finish()
+        }
+        if !self.files_changed.is_empty() {
+            d.field("files_changed", &self.files_changed.len());
+        }
+        if !self.libraries_added.is_empty() {
+            d.field("libraries_added", &self.libraries_added.len());
+        }
+        if !self.crate_graph.is_some() {
+            d.field("crate_graph", &self.crate_graph);
+        }
+        d.finish()
    }
 }
@@ -159,26 +169,27 @@ impl AnalysisHost {
 #[derive(Debug)]
 pub struct SourceChange {
    pub label: String,
-    pub source_file_edits: Vec<SourceFileNodeEdit>,
+    pub source_file_edits: Vec<SourceFileEdit>,
    pub file_system_edits: Vec<FileSystemEdit>,
    pub cursor_position: Option<FilePosition>,
 }
 #[derive(Debug)]
-pub struct SourceFileNodeEdit {
+pub struct SourceFileEdit {
    pub file_id: FileId,
-    pub edits: Vec<AtomTextEdit>,
+    pub edit: TextEdit,
 }
 #[derive(Debug)]
 pub enum FileSystemEdit {
    CreateFile {
-        anchor: FileId,
+        source_root: SourceRootId,
        path: RelativePathBuf,
    },
    MoveFile {
-        file: FileId,
+        src: FileId,
-        path: RelativePathBuf,
+        dst_source_root: SourceRootId,
+        dst_path: RelativePathBuf,
    },
 }
@@ -357,13 +368,22 @@ impl Analysis {
    }
 }
-#[derive(Debug)]
 pub struct LibraryData {
    root_id: SourceRootId,
    root_change: RootChange,
    symbol_index: SymbolIndex,
 }
+impl fmt::Debug for LibraryData {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("LibraryData")
+            .field("root_id", &self.root_id)
+            .field("root_change", &self.root_change)
+            .field("n_symbols", &self.symbol_index.len())
+            .finish()
+    }
+}
 impl LibraryData {
    pub fn prepare(
        root_id: SourceRootId,
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index b48a37229..e5bdf0aa1 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -56,6 +56,10 @@ impl Hash for SymbolIndex {
 }
 impl SymbolIndex {
+    pub(crate) fn len(&self) -> usize {
+        self.symbols.len()
+    }
    pub(crate) fn for_files(
        files: impl ParallelIterator<Item = (FileId, SourceFileNode)>,
    ) -> SymbolIndex {
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
index 889b568b9..938ca797a 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/tests.rs
@@ -81,7 +81,7 @@ fn test_unresolved_module_diagnostic() {
            fix: Some(SourceChange {
                label: "create module",
                source_file_edits: [],
-                file_system_edits: [CreateFile { anchor: FileId(1), path: "../foo.rs" }],
+                file_system_edits: [CreateFile { source_root: SourceRootId(0), path: "foo.rs" }],
                cursor_position: None }) }]"#,
        &diagnostics,
    );
@@ -452,63 +452,3 @@ fn test_find_all_refs_for_fn_param() {
    let refs = get_all_refs(code);
    assert_eq!(refs.len(), 2);
 }
-#[test]
-fn test_complete_crate_path() {
-    let (analysis, position) = analysis_and_position(
-        "
-        //- /lib.rs
-        mod foo;
-        struct Spam;
-        //- /foo.rs
-        use crate::Sp<|>
-    ",
-    );
-    let completions = analysis.completions(position).unwrap().unwrap();
-    assert_eq_dbg(
-        r#"[CompletionItem { label: "Spam", lookup: None, snippet: None },
-            CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
-        &completions,
-    );
-}
-#[test]
-fn test_complete_crate_path_with_braces() {
-    let (analysis, position) = analysis_and_position(
-        "
-        //- /lib.rs
-        mod foo;
-        struct Spam;
-        //- /foo.rs
-        use crate::{Sp<|>};
-    ",
-    );
-    let completions = analysis.completions(position).unwrap().unwrap();
-    assert_eq_dbg(
-        r#"[CompletionItem { label: "Spam", lookup: None, snippet: None },
-            CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
-        &completions,
-    );
-}
-#[test]
-fn test_complete_crate_path_in_nested_tree() {
-    let (analysis, position) = analysis_and_position(
-        "
-        //- /lib.rs
-        mod foo;
-        pub mod bar {
-            pub mod baz {
-                pub struct Spam;
-            }
-        }
-        //- /foo.rs
-        use crate::{bar::{baz::Sp<|>}};
-    ",
-    );
-    let completions = analysis.completions(position).unwrap().unwrap();
-    assert_eq_dbg(
-        r#"[CompletionItem { label: "Spam", lookup: None, snippet: None }]"#,
-        &completions,
-    );
-}
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index f12dd9345..7c3dd9296 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -7,11 +7,13 @@
 /// actual IO is done and lowered to input.
 use std::sync::Arc;
-use rustc_hash::{FxHashMap};
 use relative_path::RelativePathBuf;
-use ra_syntax::SmolStr;
+use rustc_hash::FxHashMap;
 use salsa;
+use ra_syntax::SmolStr;
+use rustc_hash::FxHashSet;
 /// `FileId` is an integer which uniquely identifies a file. File paths are
 /// messy and system-dependent, so most of the code should work directly with
 /// `FileId`, without inspecting the path. The mapping between `FileId` and path
@@ -92,12 +94,16 @@ impl CrateGraph {
        assert!(prev.is_none());
        crate_id
    }
-    // FIXME: check that we don't have cycles here.
-    // Just a simple depth first search from `to` should work,
-    // the graph is small.
    pub fn add_dep(&mut self, from: CrateId, name: SmolStr, to: CrateId) {
+        let mut visited = FxHashSet::default();
+        if self.dfs_find(from, to, &mut visited) {
+            panic!("Cycle dependencies found.")
+        }
        self.arena.get_mut(&from).unwrap().add_dep(name, to)
    }
+    pub fn is_empty(&self) -> bool {
+        self.arena.is_empty()
+    }
    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
        self.arena[&crate_id].file_id
    }
@@ -114,6 +120,52 @@ impl CrateGraph {
    ) -> impl Iterator<Item = &'a Dependency> + 'a {
        self.arena[&crate_id].dependencies.iter()
    }
+    fn dfs_find(&self, target: CrateId, from: CrateId, visited: &mut FxHashSet<CrateId>) -> bool {
+        if !visited.insert(from) {
+            return false;
+        }
+        for dep in self.dependencies(from) {
+            let crate_id = dep.crate_id();
+            if crate_id == target {
+                return true;
+            }
+            if self.dfs_find(target, crate_id, visited) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::{CrateGraph, FxHashMap, FileId, SmolStr};
+    #[test]
+    #[should_panic]
+    fn it_should_painc_because_of_cycle_dependencies() {
+        let mut graph = CrateGraph::default();
+        let crate1 = graph.add_crate_root(FileId(1u32));
+        let crate2 = graph.add_crate_root(FileId(2u32));
+        let crate3 = graph.add_crate_root(FileId(3u32));
+        graph.add_dep(crate1, SmolStr::new("crate2"), crate2);
+        graph.add_dep(crate2, SmolStr::new("crate3"), crate3);
+        graph.add_dep(crate3, SmolStr::new("crate1"), crate1);
+    }
+    #[test]
+    fn it_works() {
+        let mut graph = CrateGraph {
+            arena: FxHashMap::default(),
+        };
+        let crate1 = graph.add_crate_root(FileId(1u32));
+        let crate2 = graph.add_crate_root(FileId(2u32));
+        let crate3 = graph.add_crate_root(FileId(3u32));
+        graph.add_dep(crate1, SmolStr::new("crate2"), crate2);
+        graph.add_dep(crate2, SmolStr::new("crate3"), crate3);
+    }
 }
 salsa::query_group! {
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index 65fa3cbfa..0aca6f343 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -15,7 +15,7 @@ pub type Cancelable<T> = Result<T, Canceled>;
 impl std::fmt::Display for Canceled {
    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        fmt.write_str("Canceled")
+        fmt.write_str("canceled")
    }
 }
diff --git a/crates/ra_db/src/loc2id.rs b/crates/ra_db/src/loc2id.rs
index 69ba43d0f..2dc7930d8 100644
--- a/crates/ra_db/src/loc2id.rs
+++ b/crates/ra_db/src/loc2id.rs
@@ -42,6 +42,10 @@ where
    ID: NumericId,
    LOC: Clone + Eq + Hash,
 {
+    pub fn len(&self) -> usize {
+        self.loc2id.len()
+    }
    pub fn loc2id(&mut self, loc: &LOC) -> ID {
        match self.loc2id.get(loc) {
            Some(id) => return id.clone(),
@@ -91,6 +95,9 @@ where
    ID: NumericId,
    LOC: Clone + Eq + Hash,
 {
+    pub fn len(&self) -> usize {
+        self.map.lock().len()
+    }
    pub fn loc2id(&self, loc: &LOC) -> ID {
        self.map.lock().loc2id(loc)
    }
diff --git a/crates/ra_editor/src/folding_ranges.rs b/crates/ra_editor/src/folding_ranges.rs
index 2a8fa3cda..da542ecf0 100644
--- a/crates/ra_editor/src/folding_ranges.rs
+++ b/crates/ra_editor/src/folding_ranges.rs
@@ -10,6 +10,7 @@ use ra_syntax::{
 pub enum FoldKind {
    Comment,
    Imports,
+    Block,
 }
 #[derive(Debug)]
@@ -62,6 +63,8 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
    match kind {
        COMMENT => Some(FoldKind::Comment),
        USE_ITEM => Some(FoldKind::Imports),
+        NAMED_FIELD_DEF_LIST | FIELD_PAT_LIST | ITEM_LIST | EXTERN_ITEM_LIST | USE_TREE_LIST
+        | BLOCK | ENUM_VARIANT_LIST => Some(FoldKind::Block),
        _ => None,
    }
 }
@@ -170,7 +173,7 @@ mod tests {
    use test_utils::extract_ranges;
    fn do_check(text: &str, fold_kinds: &[FoldKind]) {
-        let (ranges, text) = extract_ranges(text);
+        let (ranges, text) = extract_ranges(text, "fold");
        let file = SourceFileNode::parse(&text);
        let folds = folding_ranges(&file);
@@ -198,26 +201,27 @@ mod tests {
    #[test]
    fn test_fold_comments() {
        let text = r#"
-<|>// Hello
+<fold>// Hello
 // this is a multiline
 // comment
-//<|>
+//</fold>
 // But this is not
-fn main() {
+fn main() <fold>{
-    <|>// We should
+    <fold>// We should
    // also
    // fold
-    // this one.<|>
+    // this one.</fold>
-    <|>//! But this one is different
+    <fold>//! But this one is different
-    //! because it has another flavor<|>
+    //! because it has another flavor</fold>
-    <|>/* As does this
+    <fold>/* As does this
-    multiline comment */<|>
+    multiline comment */</fold>
-}"#;
+}</fold>"#;
        let fold_kinds = &[
            FoldKind::Comment,
+            FoldKind::Block,
            FoldKind::Comment,
            FoldKind::Comment,
            FoldKind::Comment,
@@ -228,60 +232,66 @@ fn main() {
    #[test]
    fn test_fold_imports() {
        let text = r#"
-<|>use std::{
+<fold>use std::<fold>{
    str,
    vec,
    io as iop
-};<|>
+}</fold>;</fold>
-fn main() {
+fn main() <fold>{
-}"#;
+}</fold>"#;
-        let folds = &[FoldKind::Imports];
+        let folds = &[FoldKind::Imports, FoldKind::Block, FoldKind::Block];
        do_check(text, folds);
    }
    #[test]
    fn test_fold_import_groups() {
        let text = r#"
-<|>use std::str;
+<fold>use std::str;
 use std::vec;
-use std::io as iop;<|>
+use std::io as iop;</fold>
-<|>use std::mem;
+<fold>use std::mem;
-use std::f64;<|>
+use std::f64;</fold>
 use std::collections::HashMap;
 // Some random comment
 use std::collections::VecDeque;
-fn main() {
+fn main() <fold>{
-}"#;
+}</fold>"#;
-        let folds = &[FoldKind::Imports, FoldKind::Imports];
+        let folds = &[FoldKind::Imports, FoldKind::Imports, FoldKind::Block];
        do_check(text, folds);
    }
    #[test]
    fn test_fold_import_and_groups() {
        let text = r#"
-<|>use std::str;
+<fold>use std::str;
 use std::vec;
-use std::io as iop;<|>
+use std::io as iop;</fold>
-<|>use std::mem;
+<fold>use std::mem;
-use std::f64;<|>
+use std::f64;</fold>
-<|>use std::collections::{
+<fold>use std::collections::<fold>{
    HashMap,
    VecDeque,
-};<|>
+}</fold>;</fold>
 // Some random comment
-fn main() {
+fn main() <fold>{
-}"#;
+}</fold>"#;
-        let folds = &[FoldKind::Imports, FoldKind::Imports, FoldKind::Imports];
+        let folds = &[
+            FoldKind::Imports,
+            FoldKind::Imports,
+            FoldKind::Imports,
+            FoldKind::Block,
+            FoldKind::Block,
+        ];
        do_check(text, folds);
    }
diff --git a/crates/ra_editor/src/typing.rs b/crates/ra_editor/src/typing.rs
index 46a6e2d62..5e412bcfa 100644
--- a/crates/ra_editor/src/typing.rs
+++ b/crates/ra_editor/src/typing.rs
@@ -164,6 +164,16 @@ fn remove_newline(
    if join_single_expr_block(edit, node).is_some() {
        return;
    }
+    // ditto for
+    //
+    // ```
+    // use foo::{<|>
+    //    bar
+    // };
+    // ```
+    if join_single_use_tree(edit, node).is_some() {
+        return;
+    }
    // The node is between two other nodes
    let prev = node.prev_sibling().unwrap();
@@ -228,6 +238,36 @@ fn single_expr(block: ast::Block) -> Option<ast::Expr> {
    res
 }
+fn join_single_use_tree(edit: &mut TextEditBuilder, node: SyntaxNodeRef) -> Option<()> {
+    let use_tree_list = ast::UseTreeList::cast(node.parent()?)?;
+    let tree = single_use_tree(use_tree_list)?;
+    edit.replace(
+        use_tree_list.syntax().range(),
+        tree.syntax().text().to_string(),
+    );
+    Some(())
+}
+fn single_use_tree(tree_list: ast::UseTreeList) -> Option<ast::UseTree> {
+    let mut res = None;
+    for child in tree_list.syntax().children() {
+        if let Some(tree) = ast::UseTree::cast(child) {
+            if tree.syntax().text().contains('\n') {
+                return None;
+            }
+            if mem::replace(&mut res, Some(tree)).is_some() {
+                return None;
+            }
+        } else {
+            match child.kind() {
+                WHITESPACE | L_CURLY | R_CURLY | COMMA => (),
+                _ => return None,
+            }
+        }
+    }
+    res
+}
 fn compute_ws(left: SyntaxNodeRef, right: SyntaxNodeRef) -> &'static str {
    match left.kind() {
        L_PAREN | L_BRACK => return "",
@@ -306,6 +346,24 @@ fn foo() {
    }
    #[test]
+    fn test_join_lines_use_tree() {
+        check_join_lines(
+            r"
+use ra_syntax::{
+    algo::<|>{
+        find_leaf_at_offset,
+    },
+    ast,
+};",
+            r"
+use ra_syntax::{
+    algo::<|>find_leaf_at_offset,
+    ast,
+};",
+        );
+    }
+    #[test]
    fn test_join_lines_normal_comments() {
        check_join_lines(
            r"
diff --git a/crates/ra_hir/src/function.rs b/crates/ra_hir/src/function.rs
index 5187dc051..2925beb16 100644
--- a/crates/ra_hir/src/function.rs
+++ b/crates/ra_hir/src/function.rs
@@ -27,7 +27,7 @@ impl Function {
        Function { fn_id }
    }
-    pub fn scope(&self, db: &impl HirDatabase) -> Arc<FnScopes> {
+    pub fn scopes(&self, db: &impl HirDatabase) -> Arc<FnScopes> {
        db.fn_scopes(self.fn_id)
    }
diff --git a/crates/ra_hir/src/function/scope.rs b/crates/ra_hir/src/function/scope.rs
index 863453291..a1a580979 100644
--- a/crates/ra_hir/src/function/scope.rs
+++ b/crates/ra_hir/src/function/scope.rs
@@ -1,7 +1,7 @@
 use rustc_hash::{FxHashMap, FxHashSet};
 use ra_syntax::{
-    AstNode, SmolStr, SyntaxNodeRef, TextRange,
+    AstNode, SmolStr, SyntaxNodeRef, TextUnit, TextRange,
    algo::generate,
    ast::{self, ArgListOwner, LoopBodyOwner, NameOwner},
 };
@@ -33,7 +33,7 @@ pub struct ScopeData {
 }
 impl FnScopes {
-    pub fn new(fn_def: ast::FnDef) -> FnScopes {
+    pub(crate) fn new(fn_def: ast::FnDef) -> FnScopes {
        let mut scopes = FnScopes {
            self_param: fn_def
                .param_list()
@@ -57,6 +57,48 @@ impl FnScopes {
            self.scopes[scope].parent
        })
    }
+    pub fn scope_chain_for_offset<'a>(
+        &'a self,
+        offset: TextUnit,
+    ) -> impl Iterator<Item = ScopeId> + 'a {
+        let scope = self
+            .scope_for
+            .iter()
+            // find containin scope
+            .min_by_key(|(ptr, _scope)| {
+                (
+                    !(ptr.range().start() <= offset && offset <= ptr.range().end()),
+                    ptr.range().len(),
+                )
+            })
+            .map(|(ptr, scope)| self.adjust(*ptr, *scope, offset));
+        generate(scope, move |&scope| self.scopes[scope].parent)
+    }
+    // XXX: during completion, cursor might be outside of any particular
+    // expression. Try to figure out the correct scope...
+    fn adjust(&self, ptr: LocalSyntaxPtr, original_scope: ScopeId, offset: TextUnit) -> ScopeId {
+        let r = ptr.range();
+        let child_scopes = self
+            .scope_for
+            .iter()
+            .map(|(ptr, scope)| (ptr.range(), scope))
+            .filter(|(range, _)| range.start() <= offset && range.is_subrange(&r) && *range != r);
+        child_scopes
+            .max_by(|(r1, _), (r2, _)| {
+                if r2.is_subrange(&r1) {
+                    std::cmp::Ordering::Greater
+                } else if r1.is_subrange(&r2) {
+                    std::cmp::Ordering::Less
+                } else {
+                    r1.start().cmp(&r2.start())
+                }
+            })
+            .map(|(_ptr, scope)| *scope)
+            .unwrap_or(original_scope)
+    }
    pub fn resolve_local_name<'a>(&'a self, name_ref: ast::NameRef) -> Option<&'a ScopeEntry> {
        let mut shadowed = FxHashSet::default();
        let ret = self
@@ -144,6 +186,8 @@ impl ScopeEntry {
 }
 fn compute_block_scopes(block: ast::Block, scopes: &mut FnScopes, mut scope: ScopeId) {
+    // A hack for completion :(
+    scopes.set_scope(block.syntax(), scope);
    for stmt in block.statements() {
        match stmt {
            ast::Stmt::LetStmt(stmt) => {
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 5941a9ea3..f56214b47 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -39,7 +39,7 @@ use crate::{
 pub use self::{
    path::{Path, PathKind},
    krate::Crate,
-    module::{Module, ModuleId, Problem, nameres::ItemMap},
+    module::{Module, ModuleId, Problem, nameres::ItemMap, ModuleScope, Resolution},
    function::{Function, FnScopes},
 };
diff --git a/crates/ra_hir/src/module.rs b/crates/ra_hir/src/module.rs
index d5866f6ef..cd31e8cfe 100644
--- a/crates/ra_hir/src/module.rs
+++ b/crates/ra_hir/src/module.rs
@@ -16,7 +16,7 @@ use crate::{
    arena::{Arena, Id},
 };
-pub use self::nameres::ModuleScope;
+pub use self::nameres::{ModuleScope, Resolution};
 /// `Module` is API entry point to get all the information
 /// about a particular module.
diff --git a/crates/ra_hir/src/module/imp.rs b/crates/ra_hir/src/module/imp.rs
index f3a346152..748fdb64e 100644
--- a/crates/ra_hir/src/module/imp.rs
+++ b/crates/ra_hir/src/module/imp.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
    ast::{self, NameOwner},
    SmolStr,
 };
-use relative_path::{RelativePathBuf, RelativePath};
+use relative_path::RelativePathBuf;
 use rustc_hash::{FxHashMap, FxHashSet};
 use arrayvec::ArrayVec;
 use ra_db::{SourceRoot, SourceRootId, Cancelable, FileId};
@@ -184,11 +184,7 @@ fn resolve_submodule(
        .collect::<Vec<_>>();
    let problem = if points_to.is_empty() {
        Some(Problem::UnresolvedModule {
-            candidate: RelativePath::new("../").join(&if is_dir_owner {
+            candidate: if is_dir_owner { file_mod } else { file_dir_mod },
-                file_mod
-            } else {
-                file_dir_mod
-            }),
        })
    } else {
        None
diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs
index f44abc730..39e891cda 100644
--- a/crates/ra_hir/src/module/nameres.rs
+++ b/crates/ra_hir/src/module/nameres.rs
@@ -49,7 +49,7 @@ pub struct ModuleScope {
 }
 impl ModuleScope {
-    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a SmolStr, &Resolution)> + 'a {
+    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a SmolStr, &'a Resolution)> + 'a {
        self.items.iter()
    }
    pub fn get(&self, name: &SmolStr) -> Option<&Resolution> {
diff --git a/crates/ra_hir/src/module/nameres/tests.rs b/crates/ra_hir/src/module/nameres/tests.rs
index 9fa9146e3..3e29c3954 100644
--- a/crates/ra_hir/src/module/nameres/tests.rs
+++ b/crates/ra_hir/src/module/nameres/tests.rs
@@ -44,6 +44,25 @@ fn item_map_smoke_test() {
 }
 #[test]
+fn test_self() {
+    let (item_map, module_id) = item_map(
+        "
+            //- /lib.rs
+            mod foo;
+            use crate::foo::bar::Baz::{self};
+            <|>
+            //- /foo/mod.rs
+            pub mod bar;
+            //- /foo/bar.rs
+            pub struct Baz;
+        ",
+    );
+    let name = SmolStr::from("Baz");
+    let resolution = &item_map.per_module[&module_id].items[&name];
+    assert!(resolution.def_id.is_some());
+}
+#[test]
 fn item_map_across_crates() {
    let (mut db, sr) = MockDatabase::with_files(
        "
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index 4a2e427cd..e04d00900 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -76,17 +76,32 @@ fn expand_use_tree(
 ) {
    if let Some(use_tree_list) = tree.use_tree_list() {
        let prefix = match tree.path() {
+            // E.g. use something::{{{inner}}};
            None => prefix,
+            // E.g. `use something::{inner}` (prefix is `None`, path is `something`)
+            // or `use something::{path::{inner::{innerer}}}` (prefix is `something::path`, path is `inner`)
            Some(path) => match convert_path(prefix, path) {
                Some(it) => Some(it),
                None => return, // TODO: report errors somewhere
            },
        };
-        for tree in use_tree_list.use_trees() {
+        for child_tree in use_tree_list.use_trees() {
-            expand_use_tree(prefix.clone(), tree, cb);
+            expand_use_tree(prefix.clone(), child_tree, cb);
        }
    } else {
        if let Some(ast_path) = tree.path() {
+            // Handle self in a path.
+            // E.g. `use something::{self, <...>}`
+            if ast_path.qualifier().is_none() {
+                if let Some(segment) = ast_path.segment() {
+                    if segment.kind() == Some(ast::PathSegmentKind::SelfKw) {
+                        if let Some(prefix) = prefix {
+                            cb(prefix, Some(segment.syntax().range()));
+                            return;
+                        }
+                    }
+                }
+            }
            if let Some(path) = convert_path(prefix, ast_path) {
                let range = if tree.has_star() {
                    None
@@ -96,6 +111,8 @@ fn expand_use_tree(
                };
                cb(path, range)
            }
+            // TODO: report errors somewhere
+            // We get here if we do
        }
    }
 }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index ce2a0f2e8..a0165aef2 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -74,6 +74,16 @@ pub fn function_from_source(
    fn_def: ast::FnDef,
 ) -> Cancelable<Option<Function>> {
    let module = ctry!(module_from_child_node(db, file_id, fn_def.syntax())?);
+    let res = function_from_module(db, &module, fn_def);
+    Ok(Some(res))
+}
+pub fn function_from_module(
+    db: &impl HirDatabase,
+    module: &Module,
+    fn_def: ast::FnDef,
+) -> Function {
+    let file_id = module.source().file_id();
    let file_items = db.file_items(file_id);
    let item_id = file_items.id_of(file_id, fn_def.syntax());
    let source_item_id = SourceItemId {
@@ -86,7 +96,7 @@ pub fn function_from_source(
        module_id: module.module_id,
        source_item_id,
    };
-    Ok(Some(Function::new(def_loc.id(db))))
+    Function::new(def_loc.id(db))
 }
 pub fn function_from_child_node(
diff --git a/crates/ra_lsp_server/Cargo.toml b/crates/ra_lsp_server/Cargo.toml
index fc10096e5..3c8c240cd 100644
--- a/crates/ra_lsp_server/Cargo.toml
+++ b/crates/ra_lsp_server/Cargo.toml
@@ -12,7 +12,6 @@ failure = "0.1.2"
 failure_derive = "0.1.2"
 serde_json = "1.0.24"
 serde = "1.0.71"
-serde_derive = "1.0.71"
 drop_bomb = "0.1.0"
 crossbeam-channel = "0.2.4"
 flexi_logger = "0.10.0"
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index 7467f472c..051f1f995 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -1,8 +1,8 @@
 use languageserver_types::{
    self, Location, Position, Range, SymbolKind, TextDocumentEdit, TextDocumentIdentifier,
-    TextDocumentItem, TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier,
+    TextDocumentItem, TextDocumentPositionParams, Url, VersionedTextDocumentIdentifier, InsertTextFormat,
 };
-use ra_analysis::{FileId, FileSystemEdit, SourceChange, SourceFileNodeEdit, FilePosition};
+use ra_analysis::{FileId, FileSystemEdit, SourceChange, SourceFileEdit, FilePosition, CompletionItem, CompletionItemKind, InsertText};
 use ra_editor::{LineCol, LineIndex};
 use ra_text_edit::{AtomTextEdit, TextEdit};
 use ra_syntax::{SyntaxKind, TextRange, TextUnit};
@@ -45,6 +45,46 @@ impl Conv for SyntaxKind {
    }
 }
+impl Conv for CompletionItemKind {
+    type Output = ::languageserver_types::CompletionItemKind;
+    fn conv(self) -> <Self as Conv>::Output {
+        use ::languageserver_types::CompletionItemKind::*;
+        match self {
+            CompletionItemKind::Keyword => Keyword,
+            CompletionItemKind::Snippet => Snippet,
+            CompletionItemKind::Module => Module,
+            CompletionItemKind::Function => Function,
+            CompletionItemKind::Binding => Variable,
+        }
+    }
+}
+impl Conv for CompletionItem {
+    type Output = ::languageserver_types::CompletionItem;
+    fn conv(self) -> <Self as Conv>::Output {
+        let mut res = ::languageserver_types::CompletionItem {
+            label: self.label().to_string(),
+            filter_text: Some(self.lookup().to_string()),
+            kind: self.kind().map(|it| it.conv()),
+            ..Default::default()
+        };
+        match self.insert_text() {
+            InsertText::PlainText { text } => {
+                res.insert_text = Some(text);
+                res.insert_text_format = Some(InsertTextFormat::PlainText);
+            }
+            InsertText::Snippet { text } => {
+                res.insert_text = Some(text);
+                res.insert_text_format = Some(InsertTextFormat::Snippet);
+                res.kind = Some(languageserver_types::CompletionItemKind::Keyword);
+            }
+        }
+        res
+    }
+}
 impl ConvWith for Position {
    type Ctx = LineIndex;
    type Output = TextUnit;
@@ -97,21 +137,21 @@ impl ConvWith for TextEdit {
    type Output = Vec<languageserver_types::TextEdit>;
    fn conv_with(self, line_index: &LineIndex) -> Vec<languageserver_types::TextEdit> {
-        self.into_atoms()
+        self.as_atoms()
            .into_iter()
            .map_conv_with(line_index)
            .collect()
    }
 }
-impl ConvWith for AtomTextEdit {
+impl<'a> ConvWith for &'a AtomTextEdit {
    type Ctx = LineIndex;
    type Output = languageserver_types::TextEdit;
    fn conv_with(self, line_index: &LineIndex) -> languageserver_types::TextEdit {
        languageserver_types::TextEdit {
            range: self.delete.conv_with(line_index),
-            new_text: self.insert,
+            new_text: self.insert.clone(),
        }
    }
 }
@@ -199,7 +239,7 @@ impl TryConvWith for SourceChange {
                    .source_file_edits
                    .iter()
                    .find(|it| it.file_id == pos.file_id)
-                    .map(|it| it.edits.as_slice())
+                    .map(|it| it.edit.as_atoms())
                    .unwrap_or(&[]);
                let line_col = translate_offset_with_edit(&*line_index, pos.offset, edits);
                let position =
@@ -256,7 +296,7 @@ fn translate_offset_with_edit(
    }
 }
-impl TryConvWith for SourceFileNodeEdit {
+impl TryConvWith for SourceFileEdit {
    type Ctx = ServerWorld;
    type Output = TextDocumentEdit;
    fn try_conv_with(self, world: &ServerWorld) -> Result<TextDocumentEdit> {
@@ -265,7 +305,12 @@ impl TryConvWith for SourceFileNodeEdit {
            version: None,
        };
        let line_index = world.analysis().file_line_index(self.file_id);
-        let edits = self.edits.into_iter().map_conv_with(&line_index).collect();
+        let edits = self
+            .edit
+            .as_atoms()
+            .iter()
+            .map_conv_with(&line_index)
+            .collect();
        Ok(TextDocumentEdit {
            text_document,
            edits,
@@ -278,16 +323,17 @@ impl TryConvWith for FileSystemEdit {
    type Output = req::FileSystemEdit;
    fn try_conv_with(self, world: &ServerWorld) -> Result<req::FileSystemEdit> {
        let res = match self {
-            FileSystemEdit::CreateFile { anchor, path } => {
+            FileSystemEdit::CreateFile { source_root, path } => {
-                let uri = world.file_id_to_uri(anchor)?;
+                let uri = world.path_to_uri(source_root, &path)?;
-                let path = &path.as_str()[3..]; // strip `../` b/c url is weird
-                let uri = uri.join(path)?;
                req::FileSystemEdit::CreateFile { uri }
            }
-            FileSystemEdit::MoveFile { file, path } => {
+            FileSystemEdit::MoveFile {
-                let src = world.file_id_to_uri(file)?;
+                src,
-                let path = &path.as_str()[3..]; // strip `../` b/c url is weird
+                dst_source_root,
-                let dst = src.join(path)?;
+                dst_path,
+            } => {
+                let src = world.file_id_to_uri(src)?;
+                let dst = world.path_to_uri(dst_source_root, &dst_path)?;
                req::FileSystemEdit::MoveFile { src, dst }
            }
        };
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs
index 721665eed..33aa30d70 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/ra_lsp_server/src/main.rs
@@ -1,7 +1,7 @@
-use serde_derive::Deserialize;
+use serde::Deserialize;
-use serde::Deserialize as _D;
 use flexi_logger::{Duplicate, Logger};
 use gen_lsp_server::{run_server, stdio_transport};
 use ra_lsp_server::Result;
 fn main() -> Result<()> {
diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 8b787c329..a5a2b5eec 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -2,6 +2,7 @@ mod handlers;
 mod subscriptions;
 use std::{
+    fmt,
    path::PathBuf,
    sync::Arc,
 };
@@ -109,6 +110,50 @@ pub fn main_loop(
    Ok(())
 }
+enum Event {
+    Msg(RawMessage),
+    Task(Task),
+    Vfs(VfsTask),
+    Lib(LibraryData),
+}
+impl fmt::Debug for Event {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let debug_verbose_not = |not: &RawNotification, f: &mut fmt::Formatter| {
+            f.debug_struct("RawNotification")
+                .field("method", &not.method)
+                .finish()
+        };
+        match self {
+            Event::Msg(RawMessage::Notification(not)) => {
+                if not.is::<req::DidOpenTextDocument>() || not.is::<req::DidChangeTextDocument>() {
+                    return debug_verbose_not(not, f);
+                }
+            }
+            Event::Task(Task::Notify(not)) => {
+                if not.is::<req::PublishDecorations>() || not.is::<req::PublishDiagnostics>() {
+                    return debug_verbose_not(not, f);
+                }
+            }
+            Event::Task(Task::Respond(resp)) => {
+                return f
+                    .debug_struct("RawResponse")
+                    .field("id", &resp.id)
+                    .field("error", &resp.error)
+                    .finish();
+            }
+            _ => (),
+        }
+        match self {
+            Event::Msg(it) => fmt::Debug::fmt(it, f),
+            Event::Task(it) => fmt::Debug::fmt(it, f),
+            Event::Vfs(it) => fmt::Debug::fmt(it, f),
+            Event::Lib(it) => fmt::Debug::fmt(it, f),
+        }
+    }
+}
 fn main_loop_inner(
    internal_mode: bool,
    supports_decorations: bool,
@@ -123,13 +168,6 @@ fn main_loop_inner(
 ) -> Result<()> {
    let (libdata_sender, libdata_receiver) = unbounded();
    loop {
-        #[derive(Debug)]
-        enum Event {
-            Msg(RawMessage),
-            Task(Task),
-            Vfs(VfsTask),
-            Lib(LibraryData),
-        }
        log::trace!("selecting");
        let event = select! {
            recv(msg_receiver, msg) => match msg {
@@ -143,7 +181,8 @@ fn main_loop_inner(
            }
            recv(libdata_receiver, data) => Event::Lib(data.unwrap())
        };
-        log::info!("{:?}", event);
+        log::info!("loop_turn = {:?}", event);
+        let start = std::time::Instant::now();
        let mut state_changed = false;
        match event {
            Event::Task(task) => on_task(task, msg_sender, pending_requests),
@@ -206,6 +245,7 @@ fn main_loop_inner(
                subs.subscriptions(),
            )
        }
+        log::info!("loop_turn = {:?}", start.elapsed());
    }
 }
@@ -387,7 +427,7 @@ impl<'a> PoolDispatcher<'a> {
                                    RawResponse::err(
                                        id,
                                        ErrorCode::ContentModified as i32,
-                                        e.to_string(),
+                                        format!("content modified: {}", e),
                                    )
                                } else {
                                    RawResponse::err(
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 572ae7fb5..252d1ba3e 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -2,9 +2,9 @@ use std::collections::HashMap;
 use gen_lsp_server::ErrorCode;
 use languageserver_types::{
-    CodeActionResponse, Command, CompletionItem, CompletionItemKind, Diagnostic,
+    CodeActionResponse, Command, Diagnostic,
    DiagnosticSeverity, DocumentSymbol, Documentation, FoldingRange, FoldingRangeKind,
-    FoldingRangeParams, InsertTextFormat, Location, MarkupContent, MarkupKind, MarkedString, Position,
+    FoldingRangeParams, Location, MarkupContent, MarkupKind, MarkedString, Position,
    PrepareRenameResponse, RenameParams, SymbolInformation, TextDocumentIdentifier, TextEdit,
    WorkspaceEdit, ParameterInformation, ParameterLabel, SignatureInformation, Hover, HoverContents,
 };
@@ -107,9 +107,16 @@ pub fn handle_on_type_formatting(
    };
    let edits = match world.analysis().on_eq_typed(position) {
        None => return Ok(None),
-        Some(mut action) => action.source_file_edits.pop().unwrap().edits,
+        Some(mut action) => action
+            .source_file_edits
+            .pop()
+            .unwrap()
+            .edit
+            .as_atoms()
+            .iter()
+            .map_conv_with(&line_index)
+            .collect(),
    };
-    let edits = edits.into_iter().map_conv_with(&line_index).collect();
    Ok(Some(edits))
 }
@@ -412,22 +419,7 @@ pub fn handle_completion(
        None => return Ok(None),
        Some(items) => items,
    };
-    let items = items
+    let items = items.into_iter().map(|item| item.conv()).collect();
-        .into_iter()
-        .map(|item| {
-            let mut res = CompletionItem {
-                label: item.label,
-                filter_text: item.lookup,
-                ..Default::default()
-            };
-            if let Some(snip) = item.snippet {
-                res.insert_text = Some(snip);
-                res.insert_text_format = Some(InsertTextFormat::Snippet);
-                res.kind = Some(CompletionItemKind::Keyword);
-            };
-            res
-        })
-        .collect();
    Ok(Some(req::CompletionResponse::Array(items)))
 }
@@ -446,8 +438,9 @@ pub fn handle_folding_range(
            .into_iter()
            .map(|fold| {
                let kind = match fold.kind {
-                    FoldKind::Comment => FoldingRangeKind::Comment,
+                    FoldKind::Comment => Some(FoldingRangeKind::Comment),
-                    FoldKind::Imports => FoldingRangeKind::Imports,
+                    FoldKind::Imports => Some(FoldingRangeKind::Imports),
+                    FoldKind::Block => None,
                };
                let range = fold.range.conv_with(&line_index);
                FoldingRange {
@@ -455,7 +448,7 @@ pub fn handle_folding_range(
                    start_character: Some(range.start.character),
                    end_line: range.end.line,
                    end_character: Some(range.start.character),
-                    kind: Some(kind),
+                    kind,
                }
            })
            .collect(),
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index 999792ecb..747ab8a8c 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -1,4 +1,4 @@
-use serde_derive::{Serialize, Deserialize};
+use serde::{Serialize, Deserialize};
 use languageserver_types::{Location, Position, Range, TextDocumentIdentifier, Url};
 use rustc_hash::FxHashMap;
 use url_serde;
diff --git a/crates/ra_lsp_server/src/server_world.rs b/crates/ra_lsp_server/src/server_world.rs
index 785877c4b..c183c25af 100644
--- a/crates/ra_lsp_server/src/server_world.rs
+++ b/crates/ra_lsp_server/src/server_world.rs
@@ -8,7 +8,7 @@ use ra_analysis::{
    Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, LibraryData,
    SourceRootId
 };
-use ra_vfs::{Vfs, VfsChange, VfsFile};
+use ra_vfs::{Vfs, VfsChange, VfsFile, VfsRoot};
 use rustc_hash::FxHashMap;
 use relative_path::RelativePathBuf;
 use parking_lot::RwLock;
@@ -107,7 +107,6 @@ impl ServerWorldState {
        let mut libs = Vec::new();
        let mut change = AnalysisChange::new();
        for c in changes {
-            log::info!("vfs change {:?}", c);
            match c {
                VfsChange::AddRoot { root, files } => {
                    let root_path = self.vfs.read().root2path(root);
@@ -183,4 +182,12 @@ impl ServerWorld {
            .map_err(|_| format_err!("can't convert path to url: {}", path.display()))?;
        Ok(url)
    }
+    pub fn path_to_uri(&self, root: SourceRootId, path: &RelativePathBuf) -> Result<Url> {
+        let base = self.vfs.read().root2path(VfsRoot(root.0));
+        let path = path.to_path(base);
+        let url = Url::from_file_path(&path)
+            .map_err(|_| format_err!("can't convert path to url: {}", path.display()))?;
+        Ok(url)
+    }
 }
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 91c67119f..f12479fb4 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -284,7 +284,7 @@ impl<'a> IfExpr<'a> {
    }
 }
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PathSegmentKind<'a> {
    Name(NameRef<'a>),
    SelfKw,
diff --git a/crates/ra_syntax/src/grammar/expressions.rs b/crates/ra_syntax/src/grammar/expressions.rs
index 4f8c46ab3..da78d85a2 100644
--- a/crates/ra_syntax/src/grammar/expressions.rs
+++ b/crates/ra_syntax/src/grammar/expressions.rs
@@ -42,9 +42,15 @@ pub(crate) fn block(p: &mut Parser) {
    }
    let m = p.start();
    p.bump();
    while !p.at(EOF) && !p.at(R_CURLY) {
        match p.current() {
            LET_KW => let_stmt(p),
+            // test nocontentexpr
+            // fn foo(){
+            //     ;;;some_expr();;;;{;;;};;;;Ok(())
+            // }
+            SEMI => p.bump(),
            _ => {
                // test block_items
                // fn a() { fn b() {} }
@@ -206,7 +212,7 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
 }
 const LHS_FIRST: TokenSet = token_set_union![
-    token_set![AMP, STAR, EXCL, DOTDOT, MINUS],
+    token_set![AMP, STAR, EXCL, DOTDOT, DOTDOTEQ, MINUS],
    atom::ATOM_EXPR_FIRST,
 ];
@@ -237,7 +243,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
        }
        // test full_range_expr
        // fn foo() { xs[..]; }
-        DOTDOT => {
+        DOTDOT | DOTDOTEQ => {
            m = p.start();
            p.bump();
            if p.at_ts(EXPR_FIRST) {
@@ -287,7 +293,7 @@ fn postfix_expr(
            DOT if p.nth(1) == INT_NUMBER => field_expr(p, lhs),
            // test postfix_range
            // fn foo() { let x = 1..; }
-            DOTDOT if !EXPR_FIRST.contains(p.nth(1)) => {
+            DOTDOT | DOTDOTEQ if !EXPR_FIRST.contains(p.nth(1)) => {
                let m = lhs.precede(p);
                p.bump();
                m.complete(p, RANGE_EXPR)
diff --git a/crates/ra_syntax/src/grammar/expressions/atom.rs b/crates/ra_syntax/src/grammar/expressions/atom.rs
index cd7d62aff..31b09ac5b 100644
--- a/crates/ra_syntax/src/grammar/expressions/atom.rs
+++ b/crates/ra_syntax/src/grammar/expressions/atom.rs
@@ -35,11 +35,12 @@ pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
    Some(m.complete(p, LITERAL))
 }
+// E.g. for after the break in `if break {}`, this should not match
 pub(super) const ATOM_EXPR_FIRST: TokenSet = token_set_union![
    LITERAL_FIRST,
    token_set![
-        L_CURLY,
        L_PAREN,
+        L_CURLY,
        L_BRACK,
        PIPE,
        MOVE_KW,
@@ -88,7 +89,7 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
                WHILE_KW => while_expr(p, Some(m)),
                L_CURLY => block_expr(p, Some(m)),
                _ => {
-                    // test misplaced_label_err
+                    // test_err misplaced_label_err
                    // fn main() {
                    //     'loop: impl
                    // }
@@ -108,7 +109,7 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
        L_CURLY => block_expr(p, None),
        RETURN_KW => return_expr(p),
        CONTINUE_KW => continue_expr(p),
-        BREAK_KW => break_expr(p),
+        BREAK_KW => break_expr(p, r),
        _ => {
            p.err_recover("expected expression", EXPR_RECOVERY_SET);
            return None;
@@ -353,7 +354,7 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
 // fn foo() {
 //     match () {
 //         _ => (),
-//         _ if Test>{field: 0} => (),
+//         _ if Test > Test{field: 0} => (),
 //         X | Y if Z => (),
 //         | X | Y if Z => (),
 //         | X => (),
@@ -427,12 +428,19 @@ fn continue_expr(p: &mut Parser) -> CompletedMarker {
 //         break 'l 92;
 //     }
 // }
-fn break_expr(p: &mut Parser) -> CompletedMarker {
+fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
    assert!(p.at(BREAK_KW));
    let m = p.start();
    p.bump();
    p.eat(LIFETIME);
-    if p.at_ts(EXPR_FIRST) {
+    // test break_ambiguity
+    // fn foo(){
+    //     if break {}
+    //     while break {}
+    //     for i in break {}
+    //     match break {}
+    // }
+    if p.at_ts(EXPR_FIRST) && !(r.forbid_structs && p.at(L_CURLY)) {
        expr(p);
    }
    m.complete(p, BREAK_EXPR)
diff --git a/crates/ra_syntax/src/grammar/items.rs b/crates/ra_syntax/src/grammar/items.rs
index 4473c2fab..aa5fe0777 100644
--- a/crates/ra_syntax/src/grammar/items.rs
+++ b/crates/ra_syntax/src/grammar/items.rs
@@ -89,7 +89,7 @@ pub(super) fn maybe_item(p: &mut Parser, flavor: ItemFlavor) -> MaybeItem {
    // modifiers
    has_mods |= p.eat(CONST_KW);
-    // test unsafe_block_in_mod
+    // test_err unsafe_block_in_mod
    // fn foo(){} unsafe { } fn bar(){}
    if p.at(UNSAFE_KW) && p.nth(1) != L_CURLY {
        p.eat(UNSAFE_KW);
@@ -202,7 +202,7 @@ fn items_without_modifiers(p: &mut Parser) -> Option<SyntaxKind> {
            }
            STRUCT_DEF
        }
-        IDENT if p.at_contextual_kw("union") => {
+        IDENT if p.at_contextual_kw("union") && p.nth(1) == IDENT => {
            // test union_items
            // union Foo {}
            // union Foo {
diff --git a/crates/ra_syntax/src/grammar/items/traits.rs b/crates/ra_syntax/src/grammar/items/traits.rs
index 31258c253..d4da8b2f7 100644
--- a/crates/ra_syntax/src/grammar/items/traits.rs
+++ b/crates/ra_syntax/src/grammar/items/traits.rs
@@ -116,7 +116,7 @@ fn choose_type_params_over_qpath(p: &Parser) -> bool {
        && (p.nth(2) == R_ANGLE || p.nth(2) == COMMA || p.nth(2) == COLON || p.nth(2) == EQ)
 }
-// test impl_type
+// test_err impl_type
 // impl Type {}
 // impl Trait1 for T {}
 // impl impl NotType {}
diff --git a/crates/ra_syntax/src/grammar/items/use_item.rs b/crates/ra_syntax/src/grammar/items/use_item.rs
index b3c78f351..5111d37eb 100644
--- a/crates/ra_syntax/src/grammar/items/use_item.rs
+++ b/crates/ra_syntax/src/grammar/items/use_item.rs
@@ -74,7 +74,7 @@ fn use_tree(p: &mut Parser) {
                    //  other::path as some_other_name,
                    //  different::path as different_name,
                    //  yet::another::path,
-                    //  running::out::of::synonyms::for::different::*
+                    //  running::out::of::synonyms::for_::different::*
                    // };
                    opt_alias(p);
                }
diff --git a/crates/ra_syntax/src/grammar/type_args.rs b/crates/ra_syntax/src/grammar/type_args.rs
index 29ff6e534..f889419c5 100644
--- a/crates/ra_syntax/src/grammar/type_args.rs
+++ b/crates/ra_syntax/src/grammar/type_args.rs
@@ -26,7 +26,7 @@ pub(super) fn opt_type_arg_list(p: &mut Parser, colon_colon_required: bool) {
 }
 // test type_arg
-// type A = B<'static, i32, Item=u64>
+// type A = B<'static, i32, Item=u64>;
 fn type_arg(p: &mut Parser) {
    let m = p.start();
    match p.current() {
diff --git a/crates/ra_syntax/src/grammar/type_params.rs b/crates/ra_syntax/src/grammar/type_params.rs
index f4c98675c..7db25beba 100644
--- a/crates/ra_syntax/src/grammar/type_params.rs
+++ b/crates/ra_syntax/src/grammar/type_params.rs
@@ -96,6 +96,7 @@ pub(super) fn bounds_without_colon(p: &mut Parser) {
 //    'a: 'b + 'c,
 //    T: Clone + Copy + 'static,
 //    Iterator::Item: 'a,
+//    <T as Iterator>::Item: 'a
 // {}
 pub(super) fn opt_where_clause(p: &mut Parser) {
    if !p.at(WHERE_KW) {
@@ -104,11 +105,15 @@ pub(super) fn opt_where_clause(p: &mut Parser) {
    let m = p.start();
    p.bump();
    loop {
-        if !(paths::is_path_start(p) || p.current() == LIFETIME || p.current() == FOR_KW) {
+        if !(paths::is_path_start(p)
+            || p.current() == LIFETIME
+            || p.current() == FOR_KW
+            || p.current() == L_ANGLE)
+        {
            break;
        }
        where_predicate(p);
-        if p.current() != L_CURLY && p.current() != SEMI {
+        if p.current() != L_CURLY && p.current() != SEMI && p.current() != EQ {
            p.expect(COMMA);
        }
    }
diff --git a/crates/ra_syntax/src/grammar/types.rs b/crates/ra_syntax/src/grammar/types.rs
index 811d399d4..a933b986b 100644
--- a/crates/ra_syntax/src/grammar/types.rs
+++ b/crates/ra_syntax/src/grammar/types.rs
@@ -97,7 +97,7 @@ fn pointer_type(p: &mut Parser) {
        // type C = *mut ();
        MUT_KW | CONST_KW => p.bump(),
        _ => {
-            // test pointer_type_no_mutability
+            // test_err pointer_type_no_mutability
            // type T = *();
            p.error(
                "expected mut or const in raw pointer type \
@@ -132,7 +132,7 @@ fn array_or_slice_type(p: &mut Parser) {
            p.expect(R_BRACK);
            ARRAY_TYPE
        }
-        // test array_type_missing_semi
+        // test_err array_type_missing_semi
        // type T = [() 92];
        _ => {
            p.error("expected `;` or `]`");
@@ -175,7 +175,7 @@ fn fn_pointer_type(p: &mut Parser) {
    if p.at(EXTERN_KW) {
        abi(p);
    }
-    // test fn_pointer_type_missing_fn
+    // test_err fn_pointer_type_missing_fn
    // type F = unsafe ();
    if !p.eat(FN_KW) {
        m.abandon(p);
diff --git a/crates/ra_syntax/src/lexer.rs b/crates/ra_syntax/src/lexer.rs
index f388da273..c6acd095e 100644
--- a/crates/ra_syntax/src/lexer.rs
+++ b/crates/ra_syntax/src/lexer.rs
@@ -160,7 +160,7 @@ fn next_token_inner(c: char, ptr: &mut Ptr) -> SyntaxKind {
                // if we find one, then this is an invalid character literal
                if ptr.at('\'') {
                    ptr.bump();
-                    return CHAR; // TODO: error reporting
+                    return CHAR;
                }
                LIFETIME
            } else {
diff --git a/crates/ra_syntax/src/string_lexing/byte.rs b/crates/ra_syntax/src/string_lexing/byte.rs
index 24424349c..b3228d6ca 100644
--- a/crates/ra_syntax/src/string_lexing/byte.rs
+++ b/crates/ra_syntax/src/string_lexing/byte.rs
@@ -40,7 +40,7 @@ impl<'a> Iterator for ByteComponentIterator<'a> {
        assert!(
            self.parser.peek() == None,
-            "byte literal should leave no unparsed input: src = {}, pos = {}, length = {}",
+            "byte literal should leave no unparsed input: src = {:?}, pos = {}, length = {}",
            self.parser.src,
            self.parser.pos,
            self.parser.src.len()
diff --git a/crates/ra_syntax/src/string_lexing/byte_string.rs b/crates/ra_syntax/src/string_lexing/byte_string.rs
index 5b6dda760..a6056159b 100644
--- a/crates/ra_syntax/src/string_lexing/byte_string.rs
+++ b/crates/ra_syntax/src/string_lexing/byte_string.rs
@@ -40,7 +40,7 @@ impl<'a> Iterator for ByteStringComponentIterator<'a> {
        assert!(
            self.parser.peek() == None,
-            "byte string literal should leave no unparsed input: src = {}, pos = {}, length = {}",
+            "byte string literal should leave no unparsed input: src = {:?}, pos = {}, length = {}",
            self.parser.src,
            self.parser.pos,
            self.parser.src.len()
diff --git a/crates/ra_syntax/src/string_lexing/char.rs b/crates/ra_syntax/src/string_lexing/char.rs
index 885c03b14..e01813176 100644
--- a/crates/ra_syntax/src/string_lexing/char.rs
+++ b/crates/ra_syntax/src/string_lexing/char.rs
@@ -35,7 +35,7 @@ impl<'a> Iterator for CharComponentIterator<'a> {
        assert!(
            self.parser.peek() == None,
-            "char literal should leave no unparsed input: src = {}, pos = {}, length = {}",
+            "char literal should leave no unparsed input: src = {:?}, pos = {}, length = {}",
            self.parser.src,
            self.parser.pos,
            self.parser.src.len()
diff --git a/crates/ra_syntax/src/string_lexing/string.rs b/crates/ra_syntax/src/string_lexing/string.rs
index 1b23029c6..d8351e9af 100644
--- a/crates/ra_syntax/src/string_lexing/string.rs
+++ b/crates/ra_syntax/src/string_lexing/string.rs
@@ -35,7 +35,7 @@ impl<'a> Iterator for StringComponentIterator<'a> {
        assert!(
            self.parser.peek() == None,
-            "string literal should leave no unparsed input: src = {}, pos = {}, length = {}",
+            "string literal should leave no unparsed input: src = {:?}, pos = {}, length = {}",
            self.parser.src,
            self.parser.pos,
            self.parser.src.len()
diff --git a/crates/ra_syntax/tests/data/parser/ok/0034_macro_2.0.rs b/crates/ra_syntax/tests/data/parser/err/0028_macro_2.0.rs
index 2a70ee83a..781047ba1 100644
--- a/crates/ra_syntax/tests/data/parser/ok/0034_macro_2.0.rs
+++ b/crates/ra_syntax/tests/data/parser/err/0028_macro_2.0.rs
@@ -13,4 +13,3 @@ fn test_use_tree_merge() {
        );
    }
 }
diff --git a/crates/ra_syntax/tests/data/parser/ok/0034_macro_2.0.txt b/crates/ra_syntax/tests/data/parser/err/0028_macro_2.0.txt
index caff8df76..12919fab7 100644
--- a/crates/ra_syntax/tests/data/parser/ok/0034_macro_2.0.txt
+++ b/crates/ra_syntax/tests/data/parser/err/0028_macro_2.0.txt
@@ -1,4 +1,4 @@
-SOURCE_FILE@[0; 350)
+SOURCE_FILE@[0; 349)
  MACRO_CALL@[0; 41)
    PATH@[0; 5)
      PATH_SEGMENT@[0; 5)
@@ -314,4 +314,4 @@ SOURCE_FILE@[0; 350)
          R_CURLY@[345; 346)
      WHITESPACE@[346; 347)
      R_CURLY@[347; 348)
-  WHITESPACE@[348; 350)
+  WHITESPACE@[348; 349)
diff --git a/crates/ra_syntax/tests/data/parser/inline/0058_type_arg.rs b/crates/ra_syntax/tests/data/parser/inline/0058_type_arg.rs
deleted file mode 100644
index f0c8cc3a8..000000000
--- a/crates/ra_syntax/tests/data/parser/inline/0058_type_arg.rs
+++ /dev/null
@@ -1 +0,0 @@
-type A = B<'static, i32, Item=u64>
diff --git a/crates/ra_syntax/tests/data/parser/inline/0063_lambda_expr.txt b/crates/ra_syntax/tests/data/parser/inline/0063_lambda_expr.txt
deleted file mode 100644
index 8c1340c4a..000000000
--- a/crates/ra_syntax/tests/data/parser/inline/0063_lambda_expr.txt
+++ /dev/null
@@ -1,91 +0,0 @@
-SOURCE_FILE@[0; 74)
-  FN_DEF@[0; 74)
-    FN_KW@[0; 2)
-    NAME@[2; 6)
-      WHITESPACE@[2; 3)
-      IDENT@[3; 6) "foo"
-    PARAM_LIST@[6; 9)
-      L_PAREN@[6; 7)
-      R_PAREN@[7; 8)
-      WHITESPACE@[8; 9)
-    BLOCK_EXPR@[9; 74)
-      L_CURLY@[9; 10)
-      EXPR_STMT@[10; 26)
-        LAMBDA_EXPR@[10; 20)
-          PARAM_LIST@[10; 18)
-            WHITESPACE@[10; 15)
-            PIPE@[15; 16)
-            PIPE@[16; 17)
-            WHITESPACE@[17; 18)
-          TUPLE_EXPR@[18; 20)
-            L_PAREN@[18; 19)
-            R_PAREN@[19; 20)
-        SEMI@[20; 21)
-        WHITESPACE@[21; 26)
-      EXPR_STMT@[26; 48)
-        LAMBDA_EXPR@[26; 42)
-          PARAM_LIST@[26; 29)
-            PIPE@[26; 27)
-            PIPE@[27; 28)
-            WHITESPACE@[28; 29)
-          THIN_ARROW@[29; 31)
-          PATH_TYPE@[31; 36)
-            PATH@[31; 36)
-              PATH_SEGMENT@[31; 36)
-                NAME_REF@[31; 36)
-                  WHITESPACE@[31; 32)
-                  IDENT@[32; 35) "i32"
-                  WHITESPACE@[35; 36)
-          BLOCK_EXPR@[36; 42)
-            L_CURLY@[36; 37)
-            LITERAL@[37; 41)
-              WHITESPACE@[37; 38)
-              INT_NUMBER@[38; 40) "92"
-              WHITESPACE@[40; 41)
-            R_CURLY@[41; 42)
-        SEMI@[42; 43)
-        WHITESPACE@[43; 48)
-      EXPR_STMT@[48; 59)
-        LAMBDA_EXPR@[48; 53)
-          PARAM_LIST@[48; 52)
-            PIPE@[48; 49)
-            PARAM@[49; 50)
-              BIND_PAT@[49; 50)
-                NAME@[49; 50)
-                  IDENT@[49; 50) "x"
-            PIPE@[50; 51)
-            WHITESPACE@[51; 52)
-          PATH_EXPR@[52; 53)
-            PATH@[52; 53)
-              PATH_SEGMENT@[52; 53)
-                NAME_REF@[52; 53)
-                  IDENT@[52; 53) "x"
-        SEMI@[53; 54)
-        WHITESPACE@[54; 59)
-      EXPR_STMT@[59; 72)
-        LAMBDA_EXPR@[59; 70)
-          PARAM_LIST@[59; 69)
-            PIPE@[59; 60)
-            PARAM@[60; 66)
-              BIND_PAT@[60; 61)
-                NAME@[60; 61)
-                  IDENT@[60; 61) "x"
-              COLON@[61; 62)
-              PATH_TYPE@[62; 66)
-                PATH@[62; 66)
-                  PATH_SEGMENT@[62; 66)
-                    NAME_REF@[62; 66)
-                      WHITESPACE@[62; 63)
-                      IDENT@[63; 66) "i32"
-            COMMA@[66; 67)
-            PIPE@[67; 68)
-            WHITESPACE@[68; 69)
-          PATH_EXPR@[69; 70)
-            PATH@[69; 70)
-              PATH_SEGMENT@[69; 70)
-                NAME_REF@[69; 70)
-                  IDENT@[69; 70) "x"
-        SEMI@[70; 71)
-        WHITESPACE@[71; 72)
-      R_CURLY@[72; 73)
-      WHITESPACE@[73; 74)
diff --git a/crates/ra_syntax/tests/data/parser/inline/0069_match_arm.txt b/crates/ra_syntax/tests/data/parser/inline/0069_match_arm.txt
deleted file mode 100644
index e5647765c..000000000
--- a/crates/ra_syntax/tests/data/parser/inline/0069_match_arm.txt
+++ /dev/null
@@ -1,148 +0,0 @@
-SOURCE_FILE@[0; 161)
-  FN_DEF@[0; 160)
-    FN_KW@[0; 2)
-    WHITESPACE@[2; 3)
-    NAME@[3; 6)
-      IDENT@[3; 6) "foo"
-    PARAM_LIST@[6; 8)
-      L_PAREN@[6; 7)
-      R_PAREN@[7; 8)
-    WHITESPACE@[8; 9)
-    BLOCK@[9; 160)
-      L_CURLY@[9; 10)
-      WHITESPACE@[10; 15)
-      EXPR_STMT@[15; 158)
-        MATCH_EXPR@[15; 157)
-          MATCH_KW@[15; 20)
-          WHITESPACE@[20; 21)
-          TUPLE_EXPR@[21; 23)
-            L_PAREN@[21; 22)
-            R_PAREN@[22; 23)
-          WHITESPACE@[23; 24)
-          MATCH_ARM_LIST@[24; 157)
-            L_CURLY@[24; 25)
-            WHITESPACE@[25; 34)
-            MATCH_ARM@[34; 41)
-              PLACEHOLDER_PAT@[34; 35)
-                UNDERSCORE@[34; 35)
-              WHITESPACE@[35; 36)
-              FAT_ARROW@[36; 38)
-              WHITESPACE@[38; 39)
-              TUPLE_EXPR@[39; 41)
-                L_PAREN@[39; 40)
-                R_PAREN@[40; 41)
-            COMMA@[41; 42)
-            WHITESPACE@[42; 51)
-            MATCH_ARM@[51; 77)
-              PLACEHOLDER_PAT@[51; 52)
-                UNDERSCORE@[51; 52)
-              WHITESPACE@[52; 53)
-              IF_KW@[53; 55)
-              WHITESPACE@[55; 56)
-              BIN_EXPR@[56; 71)
-                PATH_EXPR@[56; 60)
-                  PATH@[56; 60)
-                    PATH_SEGMENT@[56; 60)
-                      NAME_REF@[56; 60)
-                        IDENT@[56; 60) "Test"
-                R_ANGLE@[60; 61)
-                BLOCK_EXPR@[61; 71)
-                  BLOCK@[61; 71)
-                    L_CURLY@[61; 62)
-                    EXPR_STMT@[62; 67)
-                      PATH_EXPR@[62; 67)
-                        PATH@[62; 67)
-                          PATH_SEGMENT@[62; 67)
-                            NAME_REF@[62; 67)
-                              IDENT@[62; 67) "field"
-                              err: `expected SEMI`
-                              err: `expected expression`
-                    EXPR_STMT@[67; 68)
-                      ERROR@[67; 68)
-                        COLON@[67; 68)
-                        err: `expected SEMI`
-                    WHITESPACE@[68; 69)
-                    LITERAL@[69; 70)
-                      INT_NUMBER@[69; 70) "0"
-                    R_CURLY@[70; 71)
-              WHITESPACE@[71; 72)
-              FAT_ARROW@[72; 74)
-              WHITESPACE@[74; 75)
-              TUPLE_EXPR@[75; 77)
-                L_PAREN@[75; 76)
-                R_PAREN@[76; 77)
-            COMMA@[77; 78)
-            WHITESPACE@[78; 87)
-            MATCH_ARM@[87; 103)
-              BIND_PAT@[87; 88)
-                NAME@[87; 88)
-                  IDENT@[87; 88) "X"
-              WHITESPACE@[88; 89)
-              PIPE@[89; 90)
-              WHITESPACE@[90; 91)
-              BIND_PAT@[91; 92)
-                NAME@[91; 92)
-                  IDENT@[91; 92) "Y"
-              WHITESPACE@[92; 93)
-              IF_KW@[93; 95)
-              WHITESPACE@[95; 96)
-              PATH_EXPR@[96; 97)
-                PATH@[96; 97)
-                  PATH_SEGMENT@[96; 97)
-                    NAME_REF@[96; 97)
-                      IDENT@[96; 97) "Z"
-              WHITESPACE@[97; 98)
-              FAT_ARROW@[98; 100)
-              WHITESPACE@[100; 101)
-              TUPLE_EXPR@[101; 103)
-                L_PAREN@[101; 102)
-                R_PAREN@[102; 103)
-            COMMA@[103; 104)
-            WHITESPACE@[104; 113)
-            MATCH_ARM@[113; 131)
-              PIPE@[113; 114)
-              WHITESPACE@[114; 115)
-              BIND_PAT@[115; 116)
-                NAME@[115; 116)
-                  IDENT@[115; 116) "X"
-              WHITESPACE@[116; 117)
-              PIPE@[117; 118)
-              WHITESPACE@[118; 119)
-              BIND_PAT@[119; 120)
-                NAME@[119; 120)
-                  IDENT@[119; 120) "Y"
-              WHITESPACE@[120; 121)
-              IF_KW@[121; 123)
-              WHITESPACE@[123; 124)
-              PATH_EXPR@[124; 125)
-                PATH@[124; 125)
-                  PATH_SEGMENT@[124; 125)
-                    NAME_REF@[124; 125)
-                      IDENT@[124; 125) "Z"
-              WHITESPACE@[125; 126)
-              FAT_ARROW@[126; 128)
-              WHITESPACE@[128; 129)
-              TUPLE_EXPR@[129; 131)
-                L_PAREN@[129; 130)
-                R_PAREN@[130; 131)
-            COMMA@[131; 132)
-            WHITESPACE@[132; 141)
-            MATCH_ARM@[141; 150)
-              PIPE@[141; 142)
-              WHITESPACE@[142; 143)
-              BIND_PAT@[143; 144)
-                NAME@[143; 144)
-                  IDENT@[143; 144) "X"
-              WHITESPACE@[144; 145)
-              FAT_ARROW@[145; 147)
-              WHITESPACE@[147; 148)
-              TUPLE_EXPR@[148; 150)
-                L_PAREN@[148; 149)
-                R_PAREN@[149; 150)
-            COMMA@[150; 151)
-            WHITESPACE@[151; 156)
-            R_CURLY@[156; 157)
-        SEMI@[157; 158)
-      WHITESPACE@[158; 159)
-      R_CURLY@[159; 160)
-  WHITESPACE@[160; 161)
diff --git a/crates/ra_syntax/tests/data/parser/inline/0023_array_type_missing_semi.rs b/crates/ra_syntax/tests/data/parser/inline/err/0001_array_type_missing_semi.rs
index a94851443..a94851443 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0023_array_type_missing_semi.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0001_array_type_missing_semi.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0023_array_type_missing_semi.txt b/crates/ra_syntax/tests/data/parser/inline/err/0001_array_type_missing_semi.txt
index 036363587..036363587 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0023_array_type_missing_semi.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0001_array_type_missing_semi.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0108_misplaced_label_err.rs b/crates/ra_syntax/tests/data/parser/inline/err/0002_misplaced_label_err.rs
index a2164c510..a2164c510 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0108_misplaced_label_err.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0002_misplaced_label_err.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0108_misplaced_label_err.txt b/crates/ra_syntax/tests/data/parser/inline/err/0002_misplaced_label_err.txt
index 75533ecc1..75533ecc1 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0108_misplaced_label_err.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0002_misplaced_label_err.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0021_pointer_type_no_mutability.rs b/crates/ra_syntax/tests/data/parser/inline/err/0003_pointer_type_no_mutability.rs
index fae705131..fae705131 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0021_pointer_type_no_mutability.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0003_pointer_type_no_mutability.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0021_pointer_type_no_mutability.txt b/crates/ra_syntax/tests/data/parser/inline/err/0003_pointer_type_no_mutability.txt
index 189aa563e..189aa563e 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0021_pointer_type_no_mutability.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0003_pointer_type_no_mutability.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0111_impl_type.rs b/crates/ra_syntax/tests/data/parser/inline/err/0004_impl_type.rs
index b8c7b65e3..b8c7b65e3 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0111_impl_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0004_impl_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0111_impl_type.txt b/crates/ra_syntax/tests/data/parser/inline/err/0004_impl_type.txt
index 7279d5cae..7279d5cae 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0111_impl_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0004_impl_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0029_fn_pointer_type_missing_fn.rs b/crates/ra_syntax/tests/data/parser/inline/err/0005_fn_pointer_type_missing_fn.rs
index f014914ff..f014914ff 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0029_fn_pointer_type_missing_fn.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0005_fn_pointer_type_missing_fn.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0029_fn_pointer_type_missing_fn.txt b/crates/ra_syntax/tests/data/parser/inline/err/0005_fn_pointer_type_missing_fn.txt
index f97db4bff..f97db4bff 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0029_fn_pointer_type_missing_fn.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0005_fn_pointer_type_missing_fn.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0013_unsafe_block_in_mod.rs b/crates/ra_syntax/tests/data/parser/inline/err/0006_unsafe_block_in_mod.rs
index 26141e904..26141e904 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0013_unsafe_block_in_mod.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0006_unsafe_block_in_mod.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0013_unsafe_block_in_mod.txt b/crates/ra_syntax/tests/data/parser/inline/err/0006_unsafe_block_in_mod.txt
index d2da2bad7..d2da2bad7 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0013_unsafe_block_in_mod.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/err/0006_unsafe_block_in_mod.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0049_trait_item_list.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0001_trait_item_list.rs
index a5ec3239f..a5ec3239f 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0049_trait_item_list.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0001_trait_item_list.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0049_trait_item_list.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0001_trait_item_list.txt
index 998ac3da9..998ac3da9 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0049_trait_item_list.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0001_trait_item_list.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0118_use_tree_list.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0002_use_tree_list.rs
index 06c387cee..06c387cee 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0118_use_tree_list.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0002_use_tree_list.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0118_use_tree_list.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0002_use_tree_list.txt
index 89a0b9f2a..89a0b9f2a 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0118_use_tree_list.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0002_use_tree_list.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0113_where_pred_for.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0003_where_pred_for.rs
index b448c6178..b448c6178 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0113_where_pred_for.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0003_where_pred_for.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0113_where_pred_for.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0003_where_pred_for.txt
index 921bdacf4..921bdacf4 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0113_where_pred_for.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0003_where_pred_for.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0096_value_parameters_no_patterns.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0004_value_parameters_no_patterns.rs
index d8c23c76a..d8c23c76a 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0096_value_parameters_no_patterns.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0004_value_parameters_no_patterns.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0096_value_parameters_no_patterns.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0004_value_parameters_no_patterns.txt
index f2d7e866b..f2d7e866b 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0096_value_parameters_no_patterns.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0004_value_parameters_no_patterns.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0060_function_type_params.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0005_function_type_params.rs
index 9df40ed39..9df40ed39 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0060_function_type_params.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0005_function_type_params.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0060_function_type_params.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0005_function_type_params.txt
index b20f13267..b20f13267 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0060_function_type_params.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0005_function_type_params.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0055_self_param.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0006_self_param.rs
index 80c0a43f5..80c0a43f5 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0055_self_param.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0006_self_param.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0055_self_param.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0006_self_param.txt
index 53027c852..53027c852 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0055_self_param.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0006_self_param.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0041_type_param_bounds.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0007_type_param_bounds.rs
index 919bde0ee..919bde0ee 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0041_type_param_bounds.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0007_type_param_bounds.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0041_type_param_bounds.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0007_type_param_bounds.txt
index 745cf8798..745cf8798 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0041_type_param_bounds.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0007_type_param_bounds.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0072_path_part.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0008_path_part.rs
index f6e32c7c1..f6e32c7c1 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0072_path_part.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0008_path_part.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0072_path_part.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0008_path_part.txt
index 0020cfb4d..0020cfb4d 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0072_path_part.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0008_path_part.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0084_loop_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0009_loop_expr.rs
index 9f078fa48..9f078fa48 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0084_loop_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0009_loop_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0084_loop_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0009_loop_expr.txt
index c3c64c322..c3c64c322 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0084_loop_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0009_loop_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0003_extern_block.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0010_extern_block.rs
index 26a9ccd1e..26a9ccd1e 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0003_extern_block.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0010_extern_block.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0003_extern_block.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0010_extern_block.txt
index 7e79c2280..7e79c2280 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0003_extern_block.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0010_extern_block.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0052_field_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0011_field_expr.rs
index 3e69538e5..3e69538e5 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0052_field_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0011_field_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0052_field_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0011_field_expr.txt
index 03fbf092b..03fbf092b 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0052_field_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0011_field_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0016_type_item_where_clause.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0012_type_item_where_clause.rs
index a602d07f0..a602d07f0 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0016_type_item_where_clause.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0012_type_item_where_clause.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0016_type_item_where_clause.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0012_type_item_where_clause.txt
index f38b2f79a..dbb705acf 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0016_type_item_where_clause.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0012_type_item_where_clause.txt
@@ -21,7 +21,6 @@ SOURCE_FILE@[0; 31)
            PATH_SEGMENT@[20; 24)
              NAME_REF@[20; 24)
                IDENT@[20; 24) "Copy"
-                err: `expected COMMA`
    WHITESPACE@[24; 25)
    EQ@[25; 26)
    WHITESPACE@[26; 27)
diff --git a/crates/ra_syntax/tests/data/parser/inline/0022_pointer_type_mut.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0013_pointer_type_mut.rs
index 04b2bb9ba..04b2bb9ba 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0022_pointer_type_mut.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0013_pointer_type_mut.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0022_pointer_type_mut.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0013_pointer_type_mut.txt
index 149cd571d..149cd571d 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0022_pointer_type_mut.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0013_pointer_type_mut.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0020_never_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0014_never_type.rs
index de399fcf4..de399fcf4 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0020_never_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0014_never_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0020_never_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0014_never_type.txt
index e0cae644d..e0cae644d 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0020_never_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0014_never_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0105_continue_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0015_continue_expr.rs
index 474cc3f0e..474cc3f0e 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0105_continue_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0015_continue_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0105_continue_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0015_continue_expr.txt
index 39be5b2c8..39be5b2c8 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0105_continue_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0015_continue_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0007_unsafe_trait.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0016_unsafe_trait.rs
index 04e021550..04e021550 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0007_unsafe_trait.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0016_unsafe_trait.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0007_unsafe_trait.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0016_unsafe_trait.txt
index 3669c93a8..3669c93a8 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0007_unsafe_trait.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0016_unsafe_trait.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0024_array_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0017_array_type.rs
index 27eb22f22..27eb22f22 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0024_array_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0017_array_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0024_array_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0017_array_type.txt
index 2c2b615fc..2c2b615fc 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0024_array_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0017_array_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0104_arb_self_types.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0018_arb_self_types.rs
index 6a170d5ac..6a170d5ac 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0104_arb_self_types.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0018_arb_self_types.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0104_arb_self_types.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0018_arb_self_types.txt
index b2f04ea7b..b2f04ea7b 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0104_arb_self_types.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0018_arb_self_types.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0074_unary_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0019_unary_expr.rs
index f1c3f7118..f1c3f7118 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0074_unary_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0019_unary_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0074_unary_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0019_unary_expr.txt
index 72d7d8bfb..72d7d8bfb 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0074_unary_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0019_unary_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0116_use_star.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0020_use_star.rs
index 6f15769a8..6f15769a8 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0116_use_star.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0020_use_star.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0116_use_star.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0020_use_star.txt
index 2db3cbf9e..2db3cbf9e 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0116_use_star.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0020_use_star.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0073_impl_item_list.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0021_impl_item_list.rs
index f10851487..f10851487 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0073_impl_item_list.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0021_impl_item_list.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0073_impl_item_list.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0021_impl_item_list.txt
index b15f93cd2..b15f93cd2 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0073_impl_item_list.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0021_impl_item_list.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0037_crate_visibility.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0022_crate_visibility.rs
index faeefde94..faeefde94 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0037_crate_visibility.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0022_crate_visibility.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0037_crate_visibility.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0022_crate_visibility.txt
index 7d137cfe9..7d137cfe9 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0037_crate_visibility.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0022_crate_visibility.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0027_placeholder_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0023_placeholder_type.rs
index 7952dbd57..7952dbd57 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0027_placeholder_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0023_placeholder_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0027_placeholder_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0023_placeholder_type.txt
index 43ada95d4..43ada95d4 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0027_placeholder_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0023_placeholder_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0089_slice_pat.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0024_slice_pat.rs
index 7955973b9..7955973b9 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0089_slice_pat.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0024_slice_pat.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0089_slice_pat.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0024_slice_pat.txt
index 72987308d..72987308d 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0089_slice_pat.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0024_slice_pat.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0025_slice_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0025_slice_type.rs
index 4da1af827..4da1af827 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0025_slice_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0025_slice_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0025_slice_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0025_slice_type.txt
index db18c7139..db18c7139 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0025_slice_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0025_slice_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0071_tuple_pat_fields.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0026_tuple_pat_fields.rs
index 0dfe63629..0dfe63629 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0071_tuple_pat_fields.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0026_tuple_pat_fields.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0071_tuple_pat_fields.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0026_tuple_pat_fields.txt
index 737fbec22..737fbec22 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0071_tuple_pat_fields.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0026_tuple_pat_fields.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0035_ref_pat.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0027_ref_pat.rs
index de41f5cae..de41f5cae 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0035_ref_pat.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0027_ref_pat.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0035_ref_pat.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0027_ref_pat.txt
index 008f4f159..008f4f159 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0035_ref_pat.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0027_ref_pat.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0063_impl_trait_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0028_impl_trait_type.rs
index 54c5a7c46..54c5a7c46 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0063_impl_trait_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0028_impl_trait_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0063_impl_trait_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0028_impl_trait_type.txt
index efd4dd42a..efd4dd42a 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0063_impl_trait_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0028_impl_trait_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0079_cast_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0029_cast_expr.rs
index b571a5860..b571a5860 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0079_cast_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0029_cast_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0079_cast_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0029_cast_expr.txt
index cb56aef0b..cb56aef0b 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0079_cast_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0029_cast_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0076_cond.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0030_cond.rs
index fdb37ee6f..fdb37ee6f 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0076_cond.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0030_cond.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0076_cond.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0030_cond.txt
index 641a09fff..641a09fff 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0076_cond.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0030_cond.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0077_while_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0031_while_expr.rs
index 293046a04..293046a04 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0077_while_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0031_while_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0077_while_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0031_while_expr.txt
index f9b074e82..f9b074e82 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0077_while_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0031_while_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0028_fn_pointer_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0032_fn_pointer_type.rs
index c9bf3bdb4..c9bf3bdb4 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0028_fn_pointer_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0032_fn_pointer_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0028_fn_pointer_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0032_fn_pointer_type.txt
index 0c508ec27..0c508ec27 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0028_fn_pointer_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0032_fn_pointer_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0026_reference_type;.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0033_reference_type;.rs
index 3ac0badab..3ac0badab 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0026_reference_type;.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0033_reference_type;.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0026_reference_type;.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0033_reference_type;.txt
index 7f35254d1..7f35254d1 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0026_reference_type;.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0033_reference_type;.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0106_break_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0034_break_expr.rs
index 1b4094636..1b4094636 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0106_break_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0034_break_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0106_break_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0034_break_expr.txt
index 1877311e8..1877311e8 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0106_break_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0034_break_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0068_pub_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0035_pub_expr.rs
index d9d99d2d3..d9d99d2d3 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0068_pub_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0035_pub_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0068_pub_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0035_pub_expr.txt
index de20eee7a..de20eee7a 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0068_pub_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0035_pub_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0012_unsafe_extern_fn.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0036_unsafe_extern_fn.rs
index 1295c2cd2..1295c2cd2 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0012_unsafe_extern_fn.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0036_unsafe_extern_fn.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0012_unsafe_extern_fn.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0036_unsafe_extern_fn.txt
index 0cde40595..0cde40595 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0012_unsafe_extern_fn.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0036_unsafe_extern_fn.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0101_qual_paths.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0037_qual_paths.rs
index d140692e2..d140692e2 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0101_qual_paths.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0037_qual_paths.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0101_qual_paths.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0037_qual_paths.txt
index 394fc7f5b..394fc7f5b 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0101_qual_paths.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0037_qual_paths.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0102_full_range_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0038_full_range_expr.rs
index ae21ad94c..ae21ad94c 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0102_full_range_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0038_full_range_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0102_full_range_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0038_full_range_expr.txt
index caef145ce..caef145ce 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0102_full_range_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0038_full_range_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0039_type_arg.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0039_type_arg.rs
new file mode 100644
index 000000000..385c43131
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0039_type_arg.rs
@@ -0,0 +1 @@
+type A = B<'static, i32, Item=u64>;
diff --git a/crates/ra_syntax/tests/data/parser/inline/0058_type_arg.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0039_type_arg.txt
index 086a74bdb..ccef7188f 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0058_type_arg.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0039_type_arg.txt
@@ -1,5 +1,5 @@
-SOURCE_FILE@[0; 35)
+SOURCE_FILE@[0; 36)
-  TYPE_DEF@[0; 34)
+  TYPE_DEF@[0; 35)
    TYPE_KW@[0; 4)
    WHITESPACE@[4; 5)
    NAME@[5; 6)
@@ -36,5 +36,5 @@ SOURCE_FILE@[0; 35)
                    NAME_REF@[30; 33)
                      IDENT@[30; 33) "u64"
            R_ANGLE@[33; 34)
-            err: `expected SEMI`
+    SEMI@[34; 35)
-  WHITESPACE@[34; 35)
+  WHITESPACE@[35; 36)
diff --git a/crates/ra_syntax/tests/data/parser/inline/0099_crate_keyword_vis.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0040_crate_keyword_vis.rs
index 660d927cf..660d927cf 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0099_crate_keyword_vis.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0040_crate_keyword_vis.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0099_crate_keyword_vis.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0040_crate_keyword_vis.txt
index ff5add838..ff5add838 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0099_crate_keyword_vis.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0040_crate_keyword_vis.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0056_trait_item.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0041_trait_item.rs
index 4385afca9..4385afca9 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0056_trait_item.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0041_trait_item.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0056_trait_item.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0041_trait_item.txt
index 333a737ec..333a737ec 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0056_trait_item.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0041_trait_item.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0043_call_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.rs
index 0c9a20718..0c9a20718 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0043_call_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0043_call_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.txt
index 6364dc73c..6364dc73c 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0043_call_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0042_call_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0115_use_alias.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0043_use_alias.rs
index c7a141bbd..544caa020 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0115_use_alias.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0043_use_alias.rs
@@ -3,5 +3,5 @@ use some::{
 other::path as some_other_name,
 different::path as different_name,
 yet::another::path,
- running::out::of::synonyms::for::different::*
+ running::out::of::synonyms::for_::different::*
 };
diff --git a/crates/ra_syntax/tests/data/parser/inline/0115_use_alias.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0043_use_alias.txt
index f7b599476..8ef0ecbc6 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0115_use_alias.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0043_use_alias.txt
@@ -1,4 +1,4 @@
-SOURCE_FILE@[0; 181)
+SOURCE_FILE@[0; 182)
  USE_ITEM@[0; 28)
    USE_KW@[0; 3)
    WHITESPACE@[3; 4)
@@ -20,16 +20,16 @@ SOURCE_FILE@[0; 181)
          IDENT@[18; 27) "some_name"
    SEMI@[27; 28)
  WHITESPACE@[28; 29)
-  USE_ITEM@[29; 180)
+  USE_ITEM@[29; 181)
    USE_KW@[29; 32)
    WHITESPACE@[32; 33)
-    USE_TREE@[33; 179)
+    USE_TREE@[33; 180)
      PATH@[33; 37)
        PATH_SEGMENT@[33; 37)
          NAME_REF@[33; 37)
            IDENT@[33; 37) "some"
      COLONCOLON@[37; 39)
-      USE_TREE_LIST@[39; 179)
+      USE_TREE_LIST@[39; 180)
        L_CURLY@[39; 40)
        WHITESPACE@[40; 42)
        USE_TREE@[42; 72)
@@ -85,9 +85,9 @@ SOURCE_FILE@[0; 181)
                IDENT@[125; 129) "path"
        COMMA@[129; 130)
        WHITESPACE@[130; 132)
-        USE_TREE@[132; 177)
+        USE_TREE@[132; 178)
-          PATH@[132; 174)
+          PATH@[132; 175)
-            PATH@[132; 163)
+            PATH@[132; 164)
              PATH@[132; 158)
                PATH@[132; 148)
                  PATH@[132; 144)
@@ -108,17 +108,16 @@ SOURCE_FILE@[0; 181)
                  NAME_REF@[150; 158)
                    IDENT@[150; 158) "synonyms"
              COLONCOLON@[158; 160)
-              err: `expected identifier`
+              PATH_SEGMENT@[160; 164)
-              PATH_SEGMENT@[160; 163)
+                NAME_REF@[160; 164)
-                ERROR@[160; 163)
+                  IDENT@[160; 164) "for_"
-                  FOR_KW@[160; 163)
+            COLONCOLON@[164; 166)
-            COLONCOLON@[163; 165)
+            PATH_SEGMENT@[166; 175)
-            PATH_SEGMENT@[165; 174)
+              NAME_REF@[166; 175)
-              NAME_REF@[165; 174)
+                IDENT@[166; 175) "different"
-                IDENT@[165; 174) "different"
+          COLONCOLON@[175; 177)
-          COLONCOLON@[174; 176)
+          STAR@[177; 178)
-          STAR@[176; 177)
+        WHITESPACE@[178; 179)
-        WHITESPACE@[177; 178)
+        R_CURLY@[179; 180)
-        R_CURLY@[178; 179)
+    SEMI@[180; 181)
-    SEMI@[179; 180)
+  WHITESPACE@[181; 182)
-  WHITESPACE@[180; 181)
diff --git a/crates/ra_syntax/tests/data/parser/inline/0053_block_items.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0044_block_items.rs
index d9868718c..d9868718c 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0053_block_items.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0044_block_items.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0053_block_items.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0044_block_items.txt
index dd1843ee5..dd1843ee5 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0053_block_items.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0044_block_items.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0097_param_list_opt_patterns.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0045_param_list_opt_patterns.rs
index 9b93442c0..9b93442c0 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0097_param_list_opt_patterns.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0045_param_list_opt_patterns.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0097_param_list_opt_patterns.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0045_param_list_opt_patterns.txt
index 2ce7a6714..2ce7a6714 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0097_param_list_opt_patterns.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0045_param_list_opt_patterns.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0019_singleton_tuple_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0046_singleton_tuple_type.rs
index cb66bad24..cb66bad24 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0019_singleton_tuple_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0046_singleton_tuple_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0019_singleton_tuple_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0046_singleton_tuple_type.txt
index 173c325d0..173c325d0 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0019_singleton_tuple_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0046_singleton_tuple_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0010_unsafe_default_impl.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0047_unsafe_default_impl.rs
index 9cd6c57bd..9cd6c57bd 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0010_unsafe_default_impl.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0047_unsafe_default_impl.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0010_unsafe_default_impl.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0047_unsafe_default_impl.txt
index 6003ba645..6003ba645 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0010_unsafe_default_impl.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0047_unsafe_default_impl.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0095_path_type_with_bounds.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0048_path_type_with_bounds.rs
index 215210e27..215210e27 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0095_path_type_with_bounds.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0048_path_type_with_bounds.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0095_path_type_with_bounds.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0048_path_type_with_bounds.txt
index 911a27ea1..911a27ea1 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0095_path_type_with_bounds.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0048_path_type_with_bounds.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0050_let_stmt;.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0049_let_stmt;.rs
index 0a9af907f..0a9af907f 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0050_let_stmt;.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0049_let_stmt;.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0050_let_stmt;.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0049_let_stmt;.txt
index 9c2aad7e0..9c2aad7e0 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0050_let_stmt;.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0049_let_stmt;.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0091_fn_decl.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0050_fn_decl.rs
index c9f74f7f5..c9f74f7f5 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0091_fn_decl.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0050_fn_decl.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0091_fn_decl.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0050_fn_decl.txt
index bb87e1d06..bb87e1d06 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0091_fn_decl.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0050_fn_decl.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0018_unit_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0051_unit_type.rs
index c039cf7d3..c039cf7d3 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0018_unit_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0051_unit_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0018_unit_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0051_unit_type.txt
index 9fd19ba4a..9fd19ba4a 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0018_unit_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0051_unit_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0032_path_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0052_path_type.rs
index bf94f32e1..bf94f32e1 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0032_path_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0052_path_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0032_path_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0052_path_type.txt
index b72b96e95..b72b96e95 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0032_path_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0052_path_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0039_path_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0053_path_expr.rs
index 333ebabef..333ebabef 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0039_path_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0053_path_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0039_path_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0053_path_expr.txt
index 673ea1d3d..673ea1d3d 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0039_path_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0053_path_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0103_field_attrs.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0054_field_attrs.rs
index 4744d8ac0..4744d8ac0 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0103_field_attrs.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0054_field_attrs.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0103_field_attrs.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0054_field_attrs.txt
index e02ebf400..e02ebf400 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0103_field_attrs.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0054_field_attrs.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0092_literal_pattern.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0055_literal_pattern.rs
index 16f674d9d..16f674d9d 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0092_literal_pattern.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0055_literal_pattern.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0092_literal_pattern.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0055_literal_pattern.txt
index 99b289d56..99b289d56 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0092_literal_pattern.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0055_literal_pattern.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0098_where_clause.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0056_where_clause.rs
index 592a005f9..19d7e571b 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0098_where_clause.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0056_where_clause.rs
@@ -3,4 +3,5 @@ where
   'a: 'b + 'c,
   T: Clone + Copy + 'static,
   Iterator::Item: 'a,
+   <T as Iterator>::Item: 'a
 {}
diff --git a/crates/ra_syntax/tests/data/parser/inline/0098_where_clause.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0056_where_clause.txt
index 54c3d64f1..68485dc0b 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0098_where_clause.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0056_where_clause.txt
@@ -1,5 +1,5 @@
-SOURCE_FILE@[0; 87)
+SOURCE_FILE@[0; 116)
-  FN_DEF@[0; 86)
+  FN_DEF@[0; 115)
    FN_KW@[0; 2)
    WHITESPACE@[2; 3)
    NAME@[3; 6)
@@ -8,7 +8,7 @@ SOURCE_FILE@[0; 87)
      L_PAREN@[6; 7)
      R_PAREN@[7; 8)
    WHITESPACE@[8; 9)
-    WHERE_CLAUSE@[9; 83)
+    WHERE_CLAUSE@[9; 112)
      WHERE_KW@[9; 14)
      WHITESPACE@[14; 18)
      WHERE_PRED@[18; 29)
@@ -64,8 +64,36 @@ SOURCE_FILE@[0; 87)
        WHITESPACE@[79; 80)
        LIFETIME@[80; 82) "'a"
      COMMA@[82; 83)
-    WHITESPACE@[83; 84)
+      WHITESPACE@[83; 87)
-    BLOCK@[84; 86)
+      WHERE_PRED@[87; 112)
-      L_CURLY@[84; 85)
+        PATH_TYPE@[87; 108)
-      R_CURLY@[85; 86)
+          PATH@[87; 108)
-  WHITESPACE@[86; 87)
+            PATH@[87; 102)
+              PATH_SEGMENT@[87; 102)
+                L_ANGLE@[87; 88)
+                PATH_TYPE@[88; 89)
+                  PATH@[88; 89)
+                    PATH_SEGMENT@[88; 89)
+                      NAME_REF@[88; 89)
+                        IDENT@[88; 89) "T"
+                WHITESPACE@[89; 90)
+                AS_KW@[90; 92)
+                WHITESPACE@[92; 93)
+                PATH_TYPE@[93; 101)
+                  PATH@[93; 101)
+                    PATH_SEGMENT@[93; 101)
+                      NAME_REF@[93; 101)
+                        IDENT@[93; 101) "Iterator"
+                R_ANGLE@[101; 102)
+            COLONCOLON@[102; 104)
+            PATH_SEGMENT@[104; 108)
+              NAME_REF@[104; 108)
+                IDENT@[104; 108) "Item"
+        COLON@[108; 109)
+        WHITESPACE@[109; 110)
+        LIFETIME@[110; 112) "'a"
+    WHITESPACE@[112; 113)
+    BLOCK@[113; 115)
+      L_CURLY@[113; 114)
+      R_CURLY@[114; 115)
+  WHITESPACE@[115; 116)
diff --git a/crates/ra_syntax/tests/data/parser/inline/0002_const_fn.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0057_const_fn.rs
index 8c84d9cd7..8c84d9cd7 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0002_const_fn.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0057_const_fn.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0002_const_fn.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0057_const_fn.txt
index 8206d973b..8206d973b 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0002_const_fn.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0057_const_fn.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0094_range_pat.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0058_range_pat.rs
index c12ab6fce..c12ab6fce 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0094_range_pat.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0058_range_pat.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0094_range_pat.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0058_range_pat.txt
index d47f38903..d47f38903 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0094_range_pat.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0058_range_pat.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0085_match_arms_commas.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0059_match_arms_commas.rs
index 1f25d577a..1f25d577a 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0085_match_arms_commas.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0059_match_arms_commas.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0085_match_arms_commas.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0059_match_arms_commas.txt
index 1034846c8..1034846c8 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0085_match_arms_commas.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0059_match_arms_commas.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0005_extern_crate.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0060_extern_crate.rs
index 49af74e1b..49af74e1b 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0005_extern_crate.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0060_extern_crate.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0005_extern_crate.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0060_extern_crate.txt
index 7ffdc7fbd..7ffdc7fbd 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0005_extern_crate.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0060_extern_crate.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0061_struct_lit.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0061_struct_lit.rs
index eb711f68a..eb711f68a 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0061_struct_lit.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0061_struct_lit.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0061_struct_lit.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0061_struct_lit.txt
index aec25403d..aec25403d 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0061_struct_lit.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0061_struct_lit.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0078_mod_contents.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0062_mod_contents.rs
index 24a15c5c5..24a15c5c5 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0078_mod_contents.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0062_mod_contents.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0078_mod_contents.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0062_mod_contents.txt
index 62528ca47..62528ca47 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0078_mod_contents.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0062_mod_contents.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0048_impl_item_neg.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_item_neg.rs
index b7527c870..b7527c870 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0048_impl_item_neg.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_item_neg.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0048_impl_item_neg.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_item_neg.txt
index b83db380e..b83db380e 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0048_impl_item_neg.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0063_impl_item_neg.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0065_if_expr.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0064_if_expr.rs
index 4b0d9af89..4b0d9af89 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0065_if_expr.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0064_if_expr.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0065_if_expr.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0064_if_expr.txt
index 637d23d9e..637d23d9e 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0065_if_expr.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0064_if_expr.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0100_dyn_trait_type.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0065_dyn_trait_type.rs
index c3ecabb99..c3ecabb99 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0100_dyn_trait_type.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0065_dyn_trait_type.rs
diff --git a/crates/ra_syntax/tests/data/parser/inline/0100_dyn_trait_type.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0065_dyn_trait_type.txt
index d07fe70b2..d07fe70b2 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0100_dyn_trait_type.txt
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0065_dyn_trait_type.txt
diff --git a/crates/ra_syntax/tests/data/parser/inline/0069_match_arm.rs b/crates/ra_syntax/tests/data/parser/inline/ok/0066_match_arm.rs
index 3380fa4ca..9e009e24f 100644
--- a/crates/ra_syntax/tests/data/parser/inline/0069_match_arm.rs
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0066_match_arm.rs
@@ -1,7 +1,7 @@
 fn foo() {
    match () {
        _ => (),
-        _ if Test>{field: 0} => (),
+        _ if Test > Test{field: 0} => (),
        X | Y if Z => (),
        | X | Y if Z => (),
        | X => (),
diff --git a/crates/ra_syntax/tests/data/parser/inline/ok/0066_match_arm.txt b/crates/ra_syntax/tests/data/parser/inline/ok/0066_match_arm.txt
new file mode 100644
index 000000000..98e7535a3
--- /dev/null
+++ b/crates/ra_syntax/tests/data/parser/inline/ok/0066_match_arm.txt
@@ -0,0 +1,146 @@