18 files changed, 873 insertions, 625 deletions

diff --git a/crates/ra_assists/src/ast_editor.rs b/crates/ra_assists/src/ast_editor.rs
index 048478662..a710edce8 100644
--- a/crates/ra_assists/src/ast_editor.rs
+++ b/crates/ra_assists/src/ast_editor.rs
@@ -297,6 +297,11 @@ impl AstBuilder<ast::Path> {
         ast_node_from_file_text(text)
     }
 
+    pub fn from_name(name: ast::Name) -> ast::Path {
+        let name = name.syntax().to_string();
+        Self::from_text(name.as_str())
+    }
+
     pub fn from_pieces(enum_name: ast::Name, var_name: ast::Name) -> ast::Path {
         Self::from_text(&format!("{}::{}", enum_name.syntax(), var_name.syntax()))
     }
@@ -380,6 +385,31 @@ impl AstBuilder<ast::MatchArmList> {
     }
 }
 
+impl AstBuilder<ast::WherePred> {
+    fn from_text(text: &str) -> ast::WherePred {
+        ast_node_from_file_text(&format!("fn f() where {} {{ }}", text))
+    }
+
+    pub fn from_pieces(
+        path: ast::Path,
+        bounds: impl Iterator<Item = ast::TypeBound>,
+    ) -> ast::WherePred {
+        let bounds = bounds.map(|b| b.syntax().to_string()).collect::<Vec<_>>().join(" + ");
+        Self::from_text(&format!("{}: {}", path.syntax(), bounds))
+    }
+}
+
+impl AstBuilder<ast::WhereClause> {
+    fn from_text(text: &str) -> ast::WhereClause {
+        ast_node_from_file_text(&format!("fn f() where {} {{ }}", text))
+    }
+
+    pub fn from_predicates(preds: impl Iterator<Item = ast::WherePred>) -> ast::WhereClause {
+        let preds = preds.map(|p| p.syntax().to_string()).collect::<Vec<_>>().join(", ");
+        Self::from_text(preds.as_str())
+    }
+}
+
 fn ast_node_from_file_text<N: AstNode>(text: &str) -> N {
     let parse = SourceFile::parse(text);
     let res = parse.tree().syntax().descendants().find_map(N::cast).unwrap();
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 03eec73ad..10ccc345c 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -102,6 +102,7 @@ mod remove_dbg;
 pub mod auto_import;
 mod add_missing_impl_members;
 mod move_guard;
+mod move_bounds;
 
 fn all_assists<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assist>] {
     &[
@@ -123,6 +124,7 @@ fn all_assists<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assis
         inline_local_variable::inline_local_varialbe,
         move_guard::move_guard_to_arm_body,
         move_guard::move_arm_cond_to_match_guard,
+        move_bounds::move_bounds_to_where_clause,
     ]
 }
 
diff --git a/crates/ra_assists/src/move_bounds.rs b/crates/ra_assists/src/move_bounds.rs
new file mode 100644
index 000000000..526de1d98
--- /dev/null
+++ b/crates/ra_assists/src/move_bounds.rs
@@ -0,0 +1,135 @@
+use hir::db::HirDatabase;
+use ra_syntax::{
+    ast::{self, AstNode, NameOwner, TypeBoundsOwner},
+    SyntaxElement,
+    SyntaxKind::*,
+    TextRange,
+};
+
+use crate::{ast_editor::AstBuilder, Assist, AssistCtx, AssistId};
+
+pub(crate) fn move_bounds_to_where_clause(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let type_param_list = ctx.node_at_offset::<ast::TypeParamList>()?;
+
+    let mut type_params = type_param_list.type_params();
+    if type_params.all(|p| p.type_bound_list().is_none()) {
+        return None;
+    }
+
+    let parent = type_param_list.syntax().parent()?;
+    if parent.children_with_tokens().find(|it| it.kind() == WHERE_CLAUSE).is_some() {
+        return None;
+    }
+
+    let anchor: SyntaxElement = match parent.kind() {
+        FN_DEF => ast::FnDef::cast(parent)?.body()?.syntax().clone().into(),
+        TRAIT_DEF => ast::TraitDef::cast(parent)?.item_list()?.syntax().clone().into(),
+        IMPL_BLOCK => ast::ImplBlock::cast(parent)?.item_list()?.syntax().clone().into(),
+        ENUM_DEF => ast::EnumDef::cast(parent)?.variant_list()?.syntax().clone().into(),
+        STRUCT_DEF => parent
+            .children_with_tokens()
+            .find(|it| it.kind() == RECORD_FIELD_DEF_LIST || it.kind() == SEMI)?,
+        _ => return None,
+    };
+
+    ctx.add_action(
+        AssistId("move_bounds_to_where_clause"),
+        "move_bounds_to_where_clause",
+        |edit| {
+            let type_params = type_param_list.type_params().collect::<Vec<_>>();
+
+            for param in &type_params {
+                if let Some(bounds) = param.type_bound_list() {
+                    let colon = param
+                        .syntax()
+                        .children_with_tokens()
+                        .find(|it| it.kind() == COLON)
+                        .unwrap();
+                    let start = colon.text_range().start();
+                    let end = bounds.syntax().text_range().end();
+                    edit.delete(TextRange::from_to(start, end));
+                }
+            }
+
+            let predicates = type_params.iter().filter_map(build_predicate);
+            let where_clause = AstBuilder::<ast::WhereClause>::from_predicates(predicates);
+
+            let to_insert = match anchor.prev_sibling_or_token() {
+                Some(ref elem) if elem.kind() == WHITESPACE => {
+                    format!("{} ", where_clause.syntax())
+                }
+                _ => format!(" {}", where_clause.syntax()),
+            };
+            edit.insert(anchor.text_range().start(), to_insert);
+            edit.target(type_param_list.syntax().text_range());
+        },
+    );
+
+    ctx.build()
+}
+
+fn build_predicate(param: &ast::TypeParam) -> Option<ast::WherePred> {
+    let path = AstBuilder::<ast::Path>::from_name(param.name()?);
+    let predicate =
+        AstBuilder::<ast::WherePred>::from_pieces(path, param.type_bound_list()?.bounds());
+    Some(predicate)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::helpers::check_assist;
+
+    #[test]
+    fn move_bounds_to_where_clause_fn() {
+        check_assist(
+            move_bounds_to_where_clause,
+            r#"
+            fn foo<T: u32, <|>F: FnOnce(T) -> T>() {}
+            "#,
+            r#"
+            fn foo<T, <|>F>() where T: u32, F: FnOnce(T) -> T {}
+            "#,
+        );
+    }
+
+    #[test]
+    fn move_bounds_to_where_clause_impl() {
+        check_assist(
+            move_bounds_to_where_clause,
+            r#"
+            impl<U: u32, <|>T> A<U, T> {}
+            "#,
+            r#"
+            impl<U, <|>T> A<U, T> where U: u32 {}
+            "#,
+        );
+    }
+
+    #[test]
+    fn move_bounds_to_where_clause_struct() {
+        check_assist(
+            move_bounds_to_where_clause,
+            r#"
+            struct A<<|>T: Iterator<Item = u32>> {}
+            "#,
+            r#"
+            struct A<<|>T> where T: Iterator<Item = u32> {}
+            "#,
+        );
+    }
+
+    #[test]
+    fn move_bounds_to_where_clause_tuple_struct() {
+        check_assist(
+            move_bounds_to_where_clause,
+            r#"
+            struct Pair<<|>T: u32>(T, T);
+            "#,
+            r#"
+            struct Pair<<|>T>(T, T) where T: u32;
+            "#,
+        );
+    }
+}
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index f69179bf6..dc2e2172b 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -50,6 +50,7 @@
 mod per_ns;
 mod raw;
 mod collector;
+mod mod_resolution;
 #[cfg(test)]
 mod tests;
 
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index 698e40247..5af26f953 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -1,9 +1,5 @@
-use std::borrow::Cow;
-use std::sync::Arc;
-
-use ra_db::{FileId, SourceRoot};
-use ra_syntax::{ast, SmolStr};
-use relative_path::RelativePathBuf;
+use ra_db::FileId;
+use ra_syntax::ast;
 use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 
@@ -12,8 +8,10 @@ use crate::{
     ids::{AstItemDef, LocationCtx, MacroCallId, MacroCallLoc, MacroDefId, MacroFileKind},
     name::MACRO_RULES,
     nameres::{
-        diagnostics::DefDiagnostic, raw, CrateDefMap, CrateModuleId, ItemOrMacro, ModuleData,
-        ModuleDef, PerNs, ReachedFixedPoint, Resolution, ResolveMode,
+        diagnostics::DefDiagnostic,
+        mod_resolution::{resolve_submodule, ParentModule},
+        raw, CrateDefMap, CrateModuleId, ItemOrMacro, ModuleData, ModuleDef, PerNs,
+        ReachedFixedPoint, Resolution, ResolveMode,
     },
     AstId, Const, DefDatabase, Enum, Function, HirFileId, MacroDef, Module, Name, Path, Static,
     Struct, Trait, TypeAlias, Union,
@@ -583,7 +581,7 @@ where
                     name,
                     is_root,
                     attr_path.as_ref(),
-                    self.parent_module.as_ref(),
+                    self.parent_module,
                 ) {
                     Ok(file_id) => {
                         let module_id = self.push_child_module(name.clone(), ast_id, Some(file_id));
@@ -694,180 +692,6 @@ fn is_macro_rules(path: &Path) -> bool {
     path.as_ident() == Some(&MACRO_RULES)
 }
 
-fn resolve_submodule(
-    db: &impl DefDatabase,
-    file_id: HirFileId,
-    name: &Name,
-    is_root: bool,
-    attr_path: Option<&SmolStr>,
-    parent_module: Option<&ParentModule>,
-) -> Result<FileId, RelativePathBuf> {
-    let file_id = file_id.original_file(db);
-    let source_root_id = db.file_source_root(file_id);
-    let path = db.file_relative_path(file_id);
-    let root = RelativePathBuf::default();
-    let dir_path = path.parent().unwrap_or(&root);
-    let mod_name = path.file_stem().unwrap_or("unknown");
-
-    let resolve_mode = match (attr_path.filter(|p| !p.is_empty()), parent_module) {
-        (Some(file_path), Some(parent_module)) => {
-            let file_path = normalize_attribute_path(file_path);
-            match parent_module.attribute_path() {
-                Some(parent_module_attr_path) => {
-                    let path = dir_path
-                        .join(format!(
-                            "{}/{}",
-                            normalize_attribute_path(parent_module_attr_path),
-                            file_path
-                        ))
-                        .normalize();
-                    ResolutionMode::InlineModuleWithAttributePath(
-                        InsideInlineModuleMode::WithAttributePath(path),
-                    )
-                }
-                None => {
-                    let path =
-                        dir_path.join(format!("{}/{}", parent_module.name, file_path)).normalize();
-                    ResolutionMode::InsideInlineModule(InsideInlineModuleMode::WithAttributePath(
-                        path,
-                    ))
-                }
-            }
-        }
-        (None, Some(parent_module)) => match parent_module.attribute_path() {
-            Some(parent_module_attr_path) => {
-                let path = dir_path.join(format!(
-                    "{}/{}.rs",
-                    normalize_attribute_path(parent_module_attr_path),
-                    name
-                ));
-                ResolutionMode::InlineModuleWithAttributePath(InsideInlineModuleMode::File(path))
-            }
-            None => {
-                let path = dir_path.join(format!("{}/{}.rs", parent_module.name, name));
-                ResolutionMode::InsideInlineModule(InsideInlineModuleMode::File(path))
-            }
-        },
-        (Some(file_path), None) => {
-            let file_path = normalize_attribute_path(file_path);
-            let path = dir_path.join(file_path.as_ref()).normalize();
-            ResolutionMode::OutOfLine(OutOfLineMode::WithAttributePath(path))
-        }
-        _ => {
-            let is_dir_owner = is_root || mod_name == "mod";
-            if is_dir_owner {
-                let file_mod = dir_path.join(format!("{}.rs", name));
-                let dir_mod = dir_path.join(format!("{}/mod.rs", name));
-                ResolutionMode::OutOfLine(OutOfLineMode::RootOrModRs {
-                    file: file_mod,
-                    directory: dir_mod,
-                })
-            } else {
-                let path = dir_path.join(format!("{}/{}.rs", mod_name, name));
-                ResolutionMode::OutOfLine(OutOfLineMode::FileInDirectory(path))
-            }
-        }
-    };
-
-    resolve_mode.resolve(db.source_root(source_root_id))
-}
-
-fn normalize_attribute_path(file_path: &SmolStr) -> Cow<str> {
-    let current_dir = "./";
-    let windows_path_separator = r#"\"#;
-    let current_dir_normalize = if file_path.starts_with(current_dir) {
-        &file_path[current_dir.len()..]
-    } else {
-        file_path.as_str()
-    };
-    if current_dir_normalize.contains(windows_path_separator) {
-        Cow::Owned(current_dir_normalize.replace(windows_path_separator, "/"))
-    } else {
-        Cow::Borrowed(current_dir_normalize)
-    }
-}
-
-enum OutOfLineMode {
-    RootOrModRs { file: RelativePathBuf, directory: RelativePathBuf },
-    FileInDirectory(RelativePathBuf),
-    WithAttributePath(RelativePathBuf),
-}
-
-impl OutOfLineMode {
-    pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
-        match self {
-            OutOfLineMode::RootOrModRs { file, directory } => match source_root.files.get(file) {
-                None => resolve_simple_path(source_root, directory).map_err(|_| file.clone()),
-                file_id => resolve_find_result(file_id, file),
-            },
-            OutOfLineMode::FileInDirectory(path) => resolve_simple_path(source_root, path),
-            OutOfLineMode::WithAttributePath(path) => resolve_simple_path(source_root, path),
-        }
-    }
-}
-
-enum InsideInlineModuleMode {
-    File(RelativePathBuf),
-    WithAttributePath(RelativePathBuf),
-}
-
-impl InsideInlineModuleMode {
-    pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
-        match self {
-            InsideInlineModuleMode::File(path) => resolve_simple_path(source_root, path),
-            InsideInlineModuleMode::WithAttributePath(path) => {
-                resolve_simple_path(source_root, path)
-            }
-        }
-    }
-}
-
-enum ResolutionMode {
-    OutOfLine(OutOfLineMode),
-    InsideInlineModule(InsideInlineModuleMode),
-    InlineModuleWithAttributePath(InsideInlineModuleMode),
-}
-
-impl ResolutionMode {
-    pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
-        use self::ResolutionMode::*;
-
-        match self {
-            OutOfLine(mode) => mode.resolve(source_root),
-            InsideInlineModule(mode) => mode.resolve(source_root),
-            InlineModuleWithAttributePath(mode) => mode.resolve(source_root),
-        }
-    }
-}
-
-fn resolve_simple_path(
-    source_root: Arc<SourceRoot>,
-    path: &RelativePathBuf,
-) -> Result<FileId, RelativePathBuf> {
-    resolve_find_result(source_root.files.get(path), path)
-}
-
-fn resolve_find_result(
-    file_id: Option<&FileId>,
-    path: &RelativePathBuf,
-) -> Result<FileId, RelativePathBuf> {
-    match file_id {
-        Some(file_id) => Ok(file_id.clone()),
-        None => Err(path.clone()),
-    }
-}
-
-struct ParentModule<'a> {
-    name: &'a Name,
-    attr_path: Option<&'a SmolStr>,
-}
-
-impl<'a> ParentModule<'a> {
-    pub fn attribute_path(&self) -> Option<&SmolStr> {
-        self.attr_path.filter(|p| !p.is_empty())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use ra_db::SourceDatabase;
diff --git a/crates/ra_hir/src/nameres/mod_resolution.rs b/crates/ra_hir/src/nameres/mod_resolution.rs
new file mode 100644
index 000000000..94c9946ff
--- /dev/null
+++ b/crates/ra_hir/src/nameres/mod_resolution.rs
@@ -0,0 +1,182 @@
+use std::{borrow::Cow, sync::Arc};
+
+use ra_db::{FileId, SourceRoot};
+use ra_syntax::SmolStr;
+use relative_path::RelativePathBuf;
+
+use crate::{DefDatabase, HirFileId, Name};
+
+#[derive(Clone, Copy)]
+pub(super) struct ParentModule<'a> {
+    pub(super) name: &'a Name,
+    pub(super) attr_path: Option<&'a SmolStr>,
+}
+
+impl<'a> ParentModule<'a> {
+    fn attribute_path(&self) -> Option<&SmolStr> {
+        self.attr_path.filter(|p| !p.is_empty())
+    }
+}
+
+pub(super) fn resolve_submodule(
+    db: &impl DefDatabase,
+    file_id: HirFileId,
+    name: &Name,
+    is_root: bool,
+    attr_path: Option<&SmolStr>,
+    parent_module: Option<ParentModule<'_>>,
+) -> Result<FileId, RelativePathBuf> {
+    let file_id = file_id.original_file(db);
+    let source_root_id = db.file_source_root(file_id);
+    let path = db.file_relative_path(file_id);
+    let root = RelativePathBuf::default();
+    let dir_path = path.parent().unwrap_or(&root);
+    let mod_name = path.file_stem().unwrap_or("unknown");
+
+    let resolve_mode = match (attr_path.filter(|p| !p.is_empty()), parent_module) {
+        (Some(file_path), Some(parent_module)) => {
+            let file_path = normalize_attribute_path(file_path);
+            match parent_module.attribute_path() {
+                Some(parent_module_attr_path) => {
+                    let path = dir_path
+                        .join(format!(
+                            "{}/{}",
+                            normalize_attribute_path(parent_module_attr_path),
+                            file_path
+                        ))
+                        .normalize();
+                    ResolutionMode::InlineModuleWithAttributePath(
+                        InsideInlineModuleMode::WithAttributePath(path),
+                    )
+                }
+                None => {
+                    let path =
+                        dir_path.join(format!("{}/{}", parent_module.name, file_path)).normalize();
+                    ResolutionMode::InsideInlineModule(InsideInlineModuleMode::WithAttributePath(
+                        path,
+                    ))
+                }
+            }
+        }
+        (None, Some(parent_module)) => match parent_module.attribute_path() {
+            Some(parent_module_attr_path) => {
+                let path = dir_path.join(format!(
+                    "{}/{}.rs",
+                    normalize_attribute_path(parent_module_attr_path),
+                    name
+                ));
+                ResolutionMode::InlineModuleWithAttributePath(InsideInlineModuleMode::File(path))
+            }
+            None => {
+                let path = dir_path.join(format!("{}/{}.rs", parent_module.name, name));
+                ResolutionMode::InsideInlineModule(InsideInlineModuleMode::File(path))
+            }
+        },
+        (Some(file_path), None) => {
+            let file_path = normalize_attribute_path(file_path);
+            let path = dir_path.join(file_path.as_ref()).normalize();
+            ResolutionMode::OutOfLine(OutOfLineMode::WithAttributePath(path))
+        }
+        _ => {
+            let is_dir_owner = is_root || mod_name == "mod";
+            if is_dir_owner {
+                let file_mod = dir_path.join(format!("{}.rs", name));
+                let dir_mod = dir_path.join(format!("{}/mod.rs", name));
+                ResolutionMode::OutOfLine(OutOfLineMode::RootOrModRs {
+                    file: file_mod,
+                    directory: dir_mod,
+                })
+            } else {
+                let path = dir_path.join(format!("{}/{}.rs", mod_name, name));
+                ResolutionMode::OutOfLine(OutOfLineMode::FileInDirectory(path))
+            }
+        }
+    };
+
+    resolve_mode.resolve(db.source_root(source_root_id))
+}
+
+fn normalize_attribute_path(file_path: &SmolStr) -> Cow<str> {
+    let current_dir = "./";
+    let windows_path_separator = r#"\"#;
+    let current_dir_normalize = if file_path.starts_with(current_dir) {
+        &file_path[current_dir.len()..]
+    } else {
+        file_path.as_str()
+    };
+    if current_dir_normalize.contains(windows_path_separator) {
+        Cow::Owned(current_dir_normalize.replace(windows_path_separator, "/"))
+    } else {
+        Cow::Borrowed(current_dir_normalize)
+    }
+}
+
+enum OutOfLineMode {
+    RootOrModRs { file: RelativePathBuf, directory: RelativePathBuf },
+    FileInDirectory(RelativePathBuf),
+    WithAttributePath(RelativePathBuf),
+}
+
+impl OutOfLineMode {
+    pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
+        match self {
+            OutOfLineMode::RootOrModRs { file, directory } => match source_root.files.get(file) {
+                None => resolve_simple_path(source_root, directory).map_err(|_| file.clone()),
+                file_id => resolve_find_result(file_id, file),
+            },
+            OutOfLineMode::FileInDirectory(path) => resolve_simple_path(source_root, path),
+            OutOfLineMode::WithAttributePath(path) => resolve_simple_path(source_root, path),
+        }
+    }
+}
+
+enum InsideInlineModuleMode {
+    File(RelativePathBuf),
+    WithAttributePath(RelativePathBuf),
+}
+
+impl InsideInlineModuleMode {
+    pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
+        match self {
+            InsideInlineModuleMode::File(path) => resolve_simple_path(source_root, path),
+            InsideInlineModuleMode::WithAttributePath(path) => {
+                resolve_simple_path(source_root, path)
+            }
+        }
+    }
+}
+
+enum ResolutionMode {
+    OutOfLine(OutOfLineMode),
+    InsideInlineModule(InsideInlineModuleMode),
+    InlineModuleWithAttributePath(InsideInlineModuleMode),
+}
+
+impl ResolutionMode {
+    pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
+        use self::ResolutionMode::*;
+
+        match self {
+            OutOfLine(mode) => mode.resolve(source_root),
+            InsideInlineModule(mode) => mode.resolve(source_root),
+            InlineModuleWithAttributePath(mode) => mode.resolve(source_root),
+        }
+    }
+}
+
+fn resolve_simple_path(
+    source_root: Arc<SourceRoot>,
+    path: &RelativePathBuf,
+) -> Result<FileId, RelativePathBuf> {
+    resolve_find_result(source_root.files.get(path), path)
+}
+
+fn resolve_find_result(
+    file_id: Option<&FileId>,
+    path: &RelativePathBuf,
+) -> Result<FileId, RelativePathBuf> {
+    match file_id {
+        Some(file_id) => Ok(file_id.clone()),
+        None => Err(path.clone()),
+    }
+}
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index c1dbad283..4ff897ca5 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -2,7 +2,7 @@ mod macros;
 mod globs;
 mod incremental;
 mod primitives;
-mod mods;
+mod mod_resolution;
 
 use std::sync::Arc;
 
diff --git a/crates/ra_hir/src/nameres/tests/mods.rs b/crates/ra_hir/src/nameres/tests/mod_resolution.rs
index 4f8398460..4f8398460 100644
--- a/crates/ra_hir/src/nameres/tests/mods.rs
+++ b/crates/ra_hir/src/nameres/tests/mod_resolution.rs
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index 514dcaf96..e90fbd428 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -466,7 +466,7 @@ impl Analysis {
         &self,
         position: FilePosition,
     ) -> Cancelable<Option<ReferenceSearchResult>> {
-        self.with_db(|db| references::find_all_refs(db, position))
+        self.with_db(|db| references::find_all_refs(db, position).map(|it| it.info))
     }
 
     /// Returns a short text describing element at position.
@@ -536,7 +536,7 @@ impl Analysis {
         &self,
         position: FilePosition,
         new_name: &str,
-    ) -> Cancelable<Option<SourceChange>> {
+    ) -> Cancelable<Option<RangeInfo<SourceChange>>> {
         self.with_db(|db| references::rename(db, position, new_name))
     }
 
diff --git a/crates/ra_ide_api/src/references.rs b/crates/ra_ide_api/src/references.rs
index d8a00067f..5f1f0efc3 100644
--- a/crates/ra_ide_api/src/references.rs
+++ b/crates/ra_ide_api/src/references.rs
@@ -4,7 +4,7 @@ use ra_syntax::{algo::find_node_at_offset, ast, AstNode, SourceFile, SyntaxNode}
 use relative_path::{RelativePath, RelativePathBuf};
 
 use crate::{
-    db::RootDatabase, FileId, FilePosition, FileRange, FileSystemEdit, NavigationTarget,
+    db::RootDatabase, FileId, FilePosition, FileRange, FileSystemEdit, NavigationTarget, RangeInfo,
     SourceChange, SourceFileEdit, TextRange,
 };
 
@@ -48,9 +48,9 @@ impl IntoIterator for ReferenceSearchResult {
 pub(crate) fn find_all_refs(
     db: &RootDatabase,
     position: FilePosition,
-) -> Option<ReferenceSearchResult> {
+) -> Option<RangeInfo<ReferenceSearchResult>> {
     let parse = db.parse(position.file_id);
-    let (binding, analyzer) = find_binding(db, &parse.tree(), position)?;
+    let RangeInfo { range, info: (binding, analyzer) } = find_binding(db, &parse.tree(), position)?;
     let declaration = NavigationTarget::from_bind_pat(position.file_id, &binding);
 
     let references = analyzer
@@ -59,24 +59,26 @@ pub(crate) fn find_all_refs(
         .map(move |ref_desc| FileRange { file_id: position.file_id, range: ref_desc.range })
         .collect::<Vec<_>>();
 
-    return Some(ReferenceSearchResult { declaration, references });
+    return Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references }));
 
     fn find_binding<'a>(
         db: &RootDatabase,
         source_file: &SourceFile,
         position: FilePosition,
-    ) -> Option<(ast::BindPat, hir::SourceAnalyzer)> {
+    ) -> Option<RangeInfo<(ast::BindPat, hir::SourceAnalyzer)>> {
         let syntax = source_file.syntax();
         if let Some(binding) = find_node_at_offset::<ast::BindPat>(syntax, position.offset) {
+            let range = binding.syntax().text_range();
             let analyzer = hir::SourceAnalyzer::new(db, position.file_id, binding.syntax(), None);
-            return Some((binding, analyzer));
+            return Some(RangeInfo::new(range, (binding, analyzer)));
         };
         let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
+        let range = name_ref.syntax().text_range();
         let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
         let resolved = analyzer.resolve_local_name(&name_ref)?;
         if let Either::A(ptr) = resolved.ptr() {
             if let ast::Pat::BindPat(binding) = ptr.to_node(source_file.syntax()) {
-                return Some((binding, analyzer));
+                return Some(RangeInfo::new(range, (binding, analyzer)));
             }
         }
         None
@@ -87,12 +89,14 @@ pub(crate) fn rename(
     db: &RootDatabase,
     position: FilePosition,
     new_name: &str,
-) -> Option<SourceChange> {
+) -> Option<RangeInfo<SourceChange>> {
     let parse = db.parse(position.file_id);
     if let Some((ast_name, ast_module)) =
         find_name_and_module_at_offset(parse.tree().syntax(), position)
     {
+        let range = ast_name.syntax().text_range();
         rename_mod(db, &ast_name, &ast_module, position, new_name)
+            .map(|info| RangeInfo::new(range, info))
     } else {
         rename_reference(db, position, new_name)
     }
@@ -107,7 +111,7 @@ fn find_name_and_module_at_offset(
     Some((ast_name, ast_module))
 }
 
-fn source_edit_from_fileid_range(
+fn source_edit_from_file_id_range(
     file_id: FileId,
     range: TextRange,
     new_name: &str,
@@ -179,19 +183,19 @@ fn rename_reference(
     db: &RootDatabase,
     position: FilePosition,
     new_name: &str,
-) -> Option<SourceChange> {
-    let refs = find_all_refs(db, position)?;
+) -> Option<RangeInfo<SourceChange>> {
+    let RangeInfo { range, info: refs } = find_all_refs(db, position)?;
 
     let edit = refs
         .into_iter()
-        .map(|range| source_edit_from_fileid_range(range.file_id, range.range, new_name))
+        .map(|range| source_edit_from_file_id_range(range.file_id, range.range, new_name))
         .collect::<Vec<_>>();
 
     if edit.is_empty() {
         return None;
     }
 
-    Some(SourceChange::source_file_edits("rename", edit))
+    Some(RangeInfo::new(range, SourceChange::source_file_edits("rename", edit)))
 }
 
 #[cfg(test)]
@@ -342,38 +346,43 @@ mod tests {
         let new_name = "foo2";
         let source_change = analysis.rename(position, new_name).unwrap();
         assert_debug_snapshot!(&source_change,
-@r#"Some(
-    SourceChange {
-        label: "rename",
-        source_file_edits: [
-            SourceFileEdit {
-                file_id: FileId(
-                    2,
-                ),
-                edit: TextEdit {
-                    atoms: [
-                        AtomTextEdit {
-                            delete: [4; 7),
-                            insert: "foo2",
+@r###"
+        Some(
+            RangeInfo {
+                range: [4; 7),
+                info: SourceChange {
+                    label: "rename",
+                    source_file_edits: [
+                        SourceFileEdit {
+                            file_id: FileId(
+                                2,
+                            ),
+                            edit: TextEdit {
+                                atoms: [
+                                    AtomTextEdit {
+                                        delete: [4; 7),
+                                        insert: "foo2",
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                3,
+                            ),
+                            dst_source_root: SourceRootId(
+                                0,
+                            ),
+                            dst_path: "bar/foo2.rs",
                         },
                     ],
+                    cursor_position: None,
                 },
             },
-        ],
-        file_system_edits: [
-            MoveFile {
-                src: FileId(
-                    3,
-                ),
-                dst_source_root: SourceRootId(
-                    0,
-                ),
-                dst_path: "bar/foo2.rs",
-            },
-        ],
-        cursor_position: None,
-    },
-)"#);
+        )
+        "###);
     }
 
     #[test]
@@ -389,38 +398,43 @@ mod tests {
         let new_name = "foo2";
         let source_change = analysis.rename(position, new_name).unwrap();
         assert_debug_snapshot!(&source_change,
-        @r###"Some(
-    SourceChange {
-        label: "rename",
-        source_file_edits: [
-            SourceFileEdit {
-                file_id: FileId(
-                    1,
-                ),
-                edit: TextEdit {
-                    atoms: [
-                        AtomTextEdit {
-                            delete: [4; 7),
-                            insert: "foo2",
+        @r###"
+        Some(
+            RangeInfo {
+                range: [4; 7),
+                info: SourceChange {
+                    label: "rename",
+                    source_file_edits: [
+                        SourceFileEdit {
+                            file_id: FileId(
+                                1,
+                            ),
+                            edit: TextEdit {
+                                atoms: [
+                                    AtomTextEdit {
+                                        delete: [4; 7),
+                                        insert: "foo2",
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    file_system_edits: [
+                        MoveFile {
+                            src: FileId(
+                                2,
+                            ),
+                            dst_source_root: SourceRootId(
+                                0,
+                            ),
+                            dst_path: "foo2/mod.rs",
                         },
                     ],
+                    cursor_position: None,
                 },
             },
-        ],
-        file_system_edits: [
-            MoveFile {
-                src: FileId(
-                    2,
-                ),
-                dst_source_root: SourceRootId(
-                    0,
-                ),
-                dst_path: "foo2/mod.rs",
-            },
-        ],
-        cursor_position: None,
-    },
-)"###
+        )
+        "###
                );
     }
 
@@ -430,7 +444,7 @@ mod tests {
         let mut text_edit_builder = ra_text_edit::TextEditBuilder::default();
         let mut file_id: Option<FileId> = None;
         if let Some(change) = source_change {
-            for edit in change.source_file_edits {
+            for edit in change.info.source_file_edits {
                 file_id = Some(edit.file_id);
                 for atom in edit.edit.as_atoms() {
                     text_edit_builder.replace(atom.delete, atom.insert.clone());
diff --git a/crates/ra_ide_api/src/syntax_tree.rs b/crates/ra_ide_api/src/syntax_tree.rs
index 914759709..e2bb120b4 100644
--- a/crates/ra_ide_api/src/syntax_tree.rs
+++ b/crates/ra_ide_api/src/syntax_tree.rs
@@ -1,357 +1,357 @@
-use crate::db::RootDatabase;

-use ra_db::SourceDatabase;

-use ra_syntax::{

-    algo, AstNode, NodeOrToken, SourceFile,

-    SyntaxKind::{RAW_STRING, STRING},

-    SyntaxToken, TextRange,

-};

-

-pub use ra_db::FileId;

-

-pub(crate) fn syntax_tree(

-    db: &RootDatabase,

-    file_id: FileId,

-    text_range: Option<TextRange>,

-) -> String {

-    let parse = db.parse(file_id);

-    if let Some(text_range) = text_range {

-        let node = match algo::find_covering_element(parse.tree().syntax(), text_range) {

-            NodeOrToken::Node(node) => node,

-            NodeOrToken::Token(token) => {

-                if let Some(tree) = syntax_tree_for_string(&token, text_range) {

-                    return tree;

-                }

-                token.parent()

-            }

-        };

-

-        format!("{:#?}", node)

-    } else {

-        format!("{:#?}", parse.tree().syntax())

-    }

-}

-

-/// Attempts parsing the selected contents of a string literal

-/// as rust syntax and returns its syntax tree

-fn syntax_tree_for_string(token: &SyntaxToken, text_range: TextRange) -> Option<String> {

-    // When the range is inside a string

-    // we'll attempt parsing it as rust syntax

-    // to provide the syntax tree of the contents of the string

-    match token.kind() {

-        STRING | RAW_STRING => syntax_tree_for_token(token, text_range),

-        _ => None,

-    }

-}

-

-fn syntax_tree_for_token(node: &SyntaxToken, text_range: TextRange) -> Option<String> {

-    // Range of the full node

-    let node_range = node.text_range();

-    let text = node.text().to_string();

-

-    // We start at some point inside the node

-    // Either we have selected the whole string

-    // or our selection is inside it

-    let start = text_range.start() - node_range.start();

-

-    // how many characters we have selected

-    let len = text_range.len().to_usize();

-

-    let node_len = node_range.len().to_usize();

-

-    let start = start.to_usize();

-

-    // We want to cap our length

-    let len = len.min(node_len);

-

-    // Ensure our slice is inside the actual string

-    let end = if start + len < text.len() { start + len } else { text.len() - start };

-

-    let text = &text[start..end];

-

-    // Remove possible extra string quotes from the start

-    // and the end of the string

-    let text = text

-        .trim_start_matches('r')

-        .trim_start_matches('#')

-        .trim_start_matches('"')

-        .trim_end_matches('#')

-        .trim_end_matches('"')

-        .trim()

-        // Remove custom markers

-        .replace("<|>", "");

-

-    let parsed = SourceFile::parse(&text);

-

-    // If the "file" parsed without errors,

-    // return its syntax

-    if parsed.errors().is_empty() {

-        return Some(format!("{:#?}", parsed.tree().syntax()));

-    }

-

-    None

-}

-

-#[cfg(test)]

-mod tests {

-    use test_utils::assert_eq_text;

-

-    use crate::mock_analysis::{single_file, single_file_with_range};

-

-    #[test]

-    fn test_syntax_tree_without_range() {

-        // Basic syntax

-        let (analysis, file_id) = single_file(r#"fn foo() {}"#);

-        let syn = analysis.syntax_tree(file_id, None).unwrap();

-

-        assert_eq_text!(

-            syn.trim(),

-            r#"

-SOURCE_FILE@[0; 11)

-  FN_DEF@[0; 11)

-    FN_KW@[0; 2) "fn"

-    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_EXPR@[9; 11)

-      BLOCK@[9; 11)

-        L_CURLY@[9; 10) "{"

-        R_CURLY@[10; 11) "}"

-"#

-            .trim()

-        );

-

-        let (analysis, file_id) = single_file(

-            r#"

-fn test() {

-    assert!("

-    fn foo() {

-    }

-    ", "");

-}"#

-            .trim(),

-        );

-        let syn = analysis.syntax_tree(file_id, None).unwrap();

-

-        assert_eq_text!(

-            syn.trim(),

-            r#"

-SOURCE_FILE@[0; 60)

-  FN_DEF@[0; 60)

-    FN_KW@[0; 2) "fn"

-    WHITESPACE@[2; 3) " "

-    NAME@[3; 7)

-      IDENT@[3; 7) "test"

-    PARAM_LIST@[7; 9)

-      L_PAREN@[7; 8) "("

-      R_PAREN@[8; 9) ")"

-    WHITESPACE@[9; 10) " "

-    BLOCK_EXPR@[10; 60)

-      BLOCK@[10; 60)

-        L_CURLY@[10; 11) "{"

-        WHITESPACE@[11; 16) "\n    "

-        EXPR_STMT@[16; 58)

-          MACRO_CALL@[16; 57)

-            PATH@[16; 22)

-              PATH_SEGMENT@[16; 22)

-                NAME_REF@[16; 22)

-                  IDENT@[16; 22) "assert"

-            EXCL@[22; 23) "!"

-            TOKEN_TREE@[23; 57)

-              L_PAREN@[23; 24) "("

-              STRING@[24; 52) "\"\n    fn foo() {\n     ..."

-              COMMA@[52; 53) ","

-              WHITESPACE@[53; 54) " "

-              STRING@[54; 56) "\"\""

-              R_PAREN@[56; 57) ")"

-          SEMI@[57; 58) ";"

-        WHITESPACE@[58; 59) "\n"

-        R_CURLY@[59; 60) "}"

-"#

-            .trim()

-        );

-    }

-

-    #[test]

-    fn test_syntax_tree_with_range() {

-        let (analysis, range) = single_file_with_range(r#"<|>fn foo() {}<|>"#.trim());

-        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();

-

-        assert_eq_text!(

-            syn.trim(),

-            r#"

-FN_DEF@[0; 11)

-  FN_KW@[0; 2) "fn"

-  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_EXPR@[9; 11)

-    BLOCK@[9; 11)

-      L_CURLY@[9; 10) "{"

-      R_CURLY@[10; 11) "}"

-"#

-            .trim()

-        );

-

-        let (analysis, range) = single_file_with_range(

-            r#"fn test() {

-    <|>assert!("

-    fn foo() {

-    }

-    ", "");<|>

-}"#

-            .trim(),

-        );

-        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();

-

-        assert_eq_text!(

-            syn.trim(),

-            r#"

-EXPR_STMT@[16; 58)

-  MACRO_CALL@[16; 57)

-    PATH@[16; 22)

-      PATH_SEGMENT@[16; 22)

-        NAME_REF@[16; 22)

-          IDENT@[16; 22) "assert"

-    EXCL@[22; 23) "!"

-    TOKEN_TREE@[23; 57)

-      L_PAREN@[23; 24) "("

-      STRING@[24; 52) "\"\n    fn foo() {\n     ..."

-      COMMA@[52; 53) ","

-      WHITESPACE@[53; 54) " "

-      STRING@[54; 56) "\"\""

-      R_PAREN@[56; 57) ")"

-  SEMI@[57; 58) ";"

-"#

-            .trim()

-        );

-    }

-

-    #[test]

-    fn test_syntax_tree_inside_string() {

-        let (analysis, range) = single_file_with_range(

-            r#"fn test() {

-    assert!("

-<|>fn foo() {

-}<|>

-fn bar() {

-}

-    ", "");

-}"#

-            .trim(),

-        );

-        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();

-        assert_eq_text!(

-            syn.trim(),

-            r#"

-SOURCE_FILE@[0; 12)

-  FN_DEF@[0; 12)

-    FN_KW@[0; 2) "fn"

-    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_EXPR@[9; 12)

-      BLOCK@[9; 12)

-        L_CURLY@[9; 10) "{"

-        WHITESPACE@[10; 11) "\n"

-        R_CURLY@[11; 12) "}"

-"#

-            .trim()

-        );

-

-        // With a raw string

-        let (analysis, range) = single_file_with_range(

-            r###"fn test() {

-    assert!(r#"

-<|>fn foo() {

-}<|>

-fn bar() {

-}

-    "#, "");

-}"###

-                .trim(),

-        );

-        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();

-        assert_eq_text!(

-            syn.trim(),

-            r#"

-SOURCE_FILE@[0; 12)

-  FN_DEF@[0; 12)

-    FN_KW@[0; 2) "fn"

-    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_EXPR@[9; 12)

-      BLOCK@[9; 12)

-        L_CURLY@[9; 10) "{"

-        WHITESPACE@[10; 11) "\n"

-        R_CURLY@[11; 12) "}"

-"#

-            .trim()

-        );

-

-        // With a raw string

-        let (analysis, range) = single_file_with_range(

-            r###"fn test() {

-    assert!(r<|>#"

-fn foo() {

-}

-fn bar() {

-}"<|>#, "");

-}"###

-                .trim(),

-        );

-        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();

-        assert_eq_text!(

-            syn.trim(),

-            r#"

-SOURCE_FILE@[0; 25)

-  FN_DEF@[0; 12)

-    FN_KW@[0; 2) "fn"

-    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_EXPR@[9; 12)

-      BLOCK@[9; 12)

-        L_CURLY@[9; 10) "{"

-        WHITESPACE@[10; 11) "\n"

-        R_CURLY@[11; 12) "}"

-  WHITESPACE@[12; 13) "\n"

-  FN_DEF@[13; 25)

-    FN_KW@[13; 15) "fn"

-    WHITESPACE@[15; 16) " "

-    NAME@[16; 19)

-      IDENT@[16; 19) "bar"

-    PARAM_LIST@[19; 21)

-      L_PAREN@[19; 20) "("

-      R_PAREN@[20; 21) ")"

-    WHITESPACE@[21; 22) " "

-    BLOCK_EXPR@[22; 25)

-      BLOCK@[22; 25)

-        L_CURLY@[22; 23) "{"

-        WHITESPACE@[23; 24) "\n"

-        R_CURLY@[24; 25) "}"

-"#

-            .trim()

-        );

-    }

-}

+use crate::db::RootDatabase;
+use ra_db::SourceDatabase;
+use ra_syntax::{
+    algo, AstNode, NodeOrToken, SourceFile,
+    SyntaxKind::{RAW_STRING, STRING},
+    SyntaxToken, TextRange,
+};
+
+pub use ra_db::FileId;
+
+pub(crate) fn syntax_tree(
+    db: &RootDatabase,
+    file_id: FileId,
+    text_range: Option<TextRange>,
+) -> String {
+    let parse = db.parse(file_id);
+    if let Some(text_range) = text_range {
+        let node = match algo::find_covering_element(parse.tree().syntax(), text_range) {
+            NodeOrToken::Node(node) => node,
+            NodeOrToken::Token(token) => {
+                if let Some(tree) = syntax_tree_for_string(&token, text_range) {
+                    return tree;
+                }
+                token.parent()
+            }
+        };
+
+        format!("{:#?}", node)
+    } else {
+        format!("{:#?}", parse.tree().syntax())
+    }
+}
+
+/// Attempts parsing the selected contents of a string literal
+/// as rust syntax and returns its syntax tree
+fn syntax_tree_for_string(token: &SyntaxToken, text_range: TextRange) -> Option<String> {
+    // When the range is inside a string
+    // we'll attempt parsing it as rust syntax
+    // to provide the syntax tree of the contents of the string
+    match token.kind() {
+        STRING | RAW_STRING => syntax_tree_for_token(token, text_range),
+        _ => None,
+    }
+}
+
+fn syntax_tree_for_token(node: &SyntaxToken, text_range: TextRange) -> Option<String> {
+    // Range of the full node
+    let node_range = node.text_range();
+    let text = node.text().to_string();
+
+    // We start at some point inside the node
+    // Either we have selected the whole string
+    // or our selection is inside it
+    let start = text_range.start() - node_range.start();
+
+    // how many characters we have selected
+    let len = text_range.len().to_usize();
+
+    let node_len = node_range.len().to_usize();
+
+    let start = start.to_usize();
+
+    // We want to cap our length
+    let len = len.min(node_len);
+
+    // Ensure our slice is inside the actual string
+    let end = if start + len < text.len() { start + len } else { text.len() - start };
+
+    let text = &text[start..end];
+
+    // Remove possible extra string quotes from the start
+    // and the end of the string
+    let text = text
+        .trim_start_matches('r')
+        .trim_start_matches('#')
+        .trim_start_matches('"')
+        .trim_end_matches('#')
+        .trim_end_matches('"')
+        .trim()
+        // Remove custom markers
+        .replace("<|>", "");
+
+    let parsed = SourceFile::parse(&text);
+
+    // If the "file" parsed without errors,
+    // return its syntax
+    if parsed.errors().is_empty() {
+        return Some(format!("{:#?}", parsed.tree().syntax()));
+    }
+
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use test_utils::assert_eq_text;
+
+    use crate::mock_analysis::{single_file, single_file_with_range};
+
+    #[test]
+    fn test_syntax_tree_without_range() {
+        // Basic syntax
+        let (analysis, file_id) = single_file(r#"fn foo() {}"#);
+        let syn = analysis.syntax_tree(file_id, None).unwrap();
+
+        assert_eq_text!(
+            syn.trim(),
+            r#"
+SOURCE_FILE@[0; 11)
+  FN_DEF@[0; 11)
+    FN_KW@[0; 2) "fn"
+    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_EXPR@[9; 11)
+      BLOCK@[9; 11)
+        L_CURLY@[9; 10) "{"
+        R_CURLY@[10; 11) "}"
+"#
+            .trim()
+        );
+
+        let (analysis, file_id) = single_file(
+            r#"
+fn test() {
+    assert!("
+    fn foo() {
+    }
+    ", "");
+}"#
+            .trim(),
+        );
+        let syn = analysis.syntax_tree(file_id, None).unwrap();
+
+        assert_eq_text!(
+            syn.trim(),
+            r#"
+SOURCE_FILE@[0; 60)
+  FN_DEF@[0; 60)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 7)
+      IDENT@[3; 7) "test"
+    PARAM_LIST@[7; 9)
+      L_PAREN@[7; 8) "("
+      R_PAREN@[8; 9) ")"
+    WHITESPACE@[9; 10) " "
+    BLOCK_EXPR@[10; 60)
+      BLOCK@[10; 60)
+        L_CURLY@[10; 11) "{"
+        WHITESPACE@[11; 16) "\n    "
+        EXPR_STMT@[16; 58)
+          MACRO_CALL@[16; 57)
+            PATH@[16; 22)
+              PATH_SEGMENT@[16; 22)
+                NAME_REF@[16; 22)
+                  IDENT@[16; 22) "assert"
+            EXCL@[22; 23) "!"
+            TOKEN_TREE@[23; 57)
+              L_PAREN@[23; 24) "("
+              STRING@[24; 52) "\"\n    fn foo() {\n     ..."
+              COMMA@[52; 53) ","
+              WHITESPACE@[53; 54) " "
+              STRING@[54; 56) "\"\""
+              R_PAREN@[56; 57) ")"
+          SEMI@[57; 58) ";"
+        WHITESPACE@[58; 59) "\n"
+        R_CURLY@[59; 60) "}"
+"#
+            .trim()
+        );
+    }
+
+    #[test]
+    fn test_syntax_tree_with_range() {
+        let (analysis, range) = single_file_with_range(r#"<|>fn foo() {}<|>"#.trim());
+        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
+
+        assert_eq_text!(
+            syn.trim(),
+            r#"
+FN_DEF@[0; 11)
+  FN_KW@[0; 2) "fn"
+  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_EXPR@[9; 11)
+    BLOCK@[9; 11)
+      L_CURLY@[9; 10) "{"
+      R_CURLY@[10; 11) "}"
+"#
+            .trim()
+        );
+
+        let (analysis, range) = single_file_with_range(
+            r#"fn test() {
+    <|>assert!("
+    fn foo() {
+    }
+    ", "");<|>
+}"#
+            .trim(),
+        );
+        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
+
+        assert_eq_text!(
+            syn.trim(),
+            r#"
+EXPR_STMT@[16; 58)
+  MACRO_CALL@[16; 57)
+    PATH@[16; 22)
+      PATH_SEGMENT@[16; 22)
+        NAME_REF@[16; 22)
+          IDENT@[16; 22) "assert"
+    EXCL@[22; 23) "!"
+    TOKEN_TREE@[23; 57)
+      L_PAREN@[23; 24) "("
+      STRING@[24; 52) "\"\n    fn foo() {\n     ..."
+      COMMA@[52; 53) ","
+      WHITESPACE@[53; 54) " "
+      STRING@[54; 56) "\"\""
+      R_PAREN@[56; 57) ")"
+  SEMI@[57; 58) ";"
+"#
+            .trim()
+        );
+    }
+
+    #[test]
+    fn test_syntax_tree_inside_string() {
+        let (analysis, range) = single_file_with_range(
+            r#"fn test() {
+    assert!("
+<|>fn foo() {
+}<|>
+fn bar() {
+}
+    ", "");
+}"#
+            .trim(),
+        );
+        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
+        assert_eq_text!(
+            syn.trim(),
+            r#"
+SOURCE_FILE@[0; 12)
+  FN_DEF@[0; 12)
+    FN_KW@[0; 2) "fn"
+    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_EXPR@[9; 12)
+      BLOCK@[9; 12)
+        L_CURLY@[9; 10) "{"
+        WHITESPACE@[10; 11) "\n"
+        R_CURLY@[11; 12) "}"
+"#
+            .trim()
+        );
+
+        // With a raw string
+        let (analysis, range) = single_file_with_range(
+            r###"fn test() {
+    assert!(r#"
+<|>fn foo() {
+}<|>
+fn bar() {
+}
+    "#, "");
+}"###
+                .trim(),
+        );
+        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
+        assert_eq_text!(
+            syn.trim(),
+            r#"
+SOURCE_FILE@[0; 12)
+  FN_DEF@[0; 12)
+    FN_KW@[0; 2) "fn"
+    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_EXPR@[9; 12)
+      BLOCK@[9; 12)
+        L_CURLY@[9; 10) "{"
+        WHITESPACE@[10; 11) "\n"
+        R_CURLY@[11; 12) "}"
+"#
+            .trim()
+        );
+
+        // With a raw string
+        let (analysis, range) = single_file_with_range(
+            r###"fn test() {
+    assert!(r<|>#"
+fn foo() {
+}
+fn bar() {
+}"<|>#, "");
+}"###
+                .trim(),
+        );
+        let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
+        assert_eq_text!(
+            syn.trim(),
+            r#"
+SOURCE_FILE@[0; 25)
+  FN_DEF@[0; 12)
+    FN_KW@[0; 2) "fn"
+    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_EXPR@[9; 12)
+      BLOCK@[9; 12)
+        L_CURLY@[9; 10) "{"
+        WHITESPACE@[10; 11) "\n"
+        R_CURLY@[11; 12) "}"
+  WHITESPACE@[12; 13) "\n"
+  FN_DEF@[13; 25)
+    FN_KW@[13; 15) "fn"
+    WHITESPACE@[15; 16) " "
+    NAME@[16; 19)
+      IDENT@[16; 19) "bar"
+    PARAM_LIST@[19; 21)
+      L_PAREN@[19; 20) "("
+      R_PAREN@[20; 21) ")"
+    WHITESPACE@[21; 22) " "
+    BLOCK_EXPR@[22; 25)
+      BLOCK@[22; 25)
+        L_CURLY@[22; 23) "{"
+        WHITESPACE@[23; 24) "\n"
+        R_CURLY@[24; 25) "}"
+"#
+            .trim()
+        );
+    }
+}
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index eb805a6d3..948d543ea 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -460,18 +460,16 @@ pub fn handle_prepare_rename(
 
     // We support renaming references like handle_rename does.
     // In the future we may want to reject the renaming of things like keywords here too.
-    let refs = match world.analysis().find_all_refs(position)? {
+    let optional_change = world.analysis().rename(position, "dummy")?;
+    let range = match optional_change {
         None => return Ok(None),
-        Some(refs) => refs,
+        Some(it) => it.range,
     };
 
-    // Refs should always have a declaration
-    let r = refs.declaration();
     let file_id = params.text_document.try_conv_with(&world)?;
     let line_index = world.analysis().file_line_index(file_id)?;
-    let loc = to_location(r.file_id(), r.range(), &world, &line_index)?;
-
-    Ok(Some(PrepareRenameResponse::Range(loc.range)))
+    let range = range.conv_with(&line_index);
+    Ok(Some(PrepareRenameResponse::Range(range)))
 }
 
 pub fn handle_rename(world: WorldSnapshot, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
@@ -488,7 +486,7 @@ pub fn handle_rename(world: WorldSnapshot, params: RenameParams) -> Result<Optio
     let optional_change = world.analysis().rename(position, &*params.new_name)?;
     let change = match optional_change {
         None => return Ok(None),
-        Some(it) => it,
+        Some(it) => it.info,
     };
 
     let source_change_req = change.try_conv_with(&world)?;
diff --git a/crates/ra_parser/src/grammar/items.rs b/crates/ra_parser/src/grammar/items.rs
index 6d426206e..b4327b78f 100644
--- a/crates/ra_parser/src/grammar/items.rs
+++ b/crates/ra_parser/src/grammar/items.rs
@@ -31,7 +31,7 @@ pub(super) enum ItemFlavor {
 
 pub(super) const ITEM_RECOVERY_SET: TokenSet = token_set![
     FN_KW, STRUCT_KW, ENUM_KW, IMPL_KW, TRAIT_KW, CONST_KW, STATIC_KW, LET_KW, MOD_KW, PUB_KW,
-    CRATE_KW
+    CRATE_KW, USE_KW
 ];
 
 pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool, flavor: ItemFlavor) {
diff --git a/crates/ra_parser/src/grammar/items/use_item.rs b/crates/ra_parser/src/grammar/items/use_item.rs
index c0c7d0ec6..83a65e226 100644
--- a/crates/ra_parser/src/grammar/items/use_item.rs
+++ b/crates/ra_parser/src/grammar/items/use_item.rs
@@ -101,7 +101,10 @@ fn use_tree(p: &mut Parser) {
         }
         _ => {
             m.abandon(p);
-            p.err_and_bump("expected one of `*`, `::`, `{`, `self`, `super` or an indentifier");
+            p.err_recover(
+                "expected one of `*`, `::`, `{`, `self`, `super` or an identifier",
+                ITEM_RECOVERY_SET,
+            );
             return;
         }
     }
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index 676dc4941..9b2f534e7 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -153,7 +153,7 @@ impl ProjectWorkspace {
                     if let Some(file_id) = load(krate.root(&sysroot)) {
                         sysroot_crates.insert(
                             krate,
-                            crate_graph.add_crate_root(file_id, Edition::Edition2015),
+                            crate_graph.add_crate_root(file_id, Edition::Edition2018),
                         );
                     }
                 }
diff --git a/crates/ra_syntax/test_data/parser/err/0002_duplicate_shebang.txt b/crates/ra_syntax/test_data/parser/err/0002_duplicate_shebang.txt
index 84867026f..bdb5fa6c5 100644
--- a/crates/ra_syntax/test_data/parser/err/0002_duplicate_shebang.txt
+++ b/crates/ra_syntax/test_data/parser/err/0002_duplicate_shebang.txt
@@ -28,7 +28,7 @@ SOURCE_FILE@[0; 42)
   WHITESPACE@[41; 42) "\n"
 error 23: expected `[`
 error 23: expected an item
-error 27: expected one of `*`, `::`, `{`, `self`, `super` or an indentifier
+error 27: expected one of `*`, `::`, `{`, `self`, `super` or an identifier
 error 28: expected SEMI
 error 31: expected EXCL
 error 31: expected `{`, `[`, `(`
diff --git a/crates/ra_syntax/test_data/parser/err/0035_use_recover.rs b/crates/ra_syntax/test_data/parser/err/0035_use_recover.rs
new file mode 100644
index 000000000..4a2668126
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/err/0035_use_recover.rs
@@ -0,0 +1,5 @@
+use foo::bar;
+use
+use crate::baz;
+use
+fn f() {}
diff --git a/crates/ra_syntax/test_data/parser/err/0035_use_recover.txt b/crates/ra_syntax/test_data/parser/err/0035_use_recover.txt
new file mode 100644
index 000000000..636840828
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/err/0035_use_recover.txt
@@ -0,0 +1,54 @@
+SOURCE_FILE@[0; 48)
+  USE_ITEM@[0; 13)
+    USE_KW@[0; 3) "use"
+    WHITESPACE@[3; 4) " "
+    USE_TREE@[4; 12)
+      PATH@[4; 12)
+        PATH@[4; 7)
+          PATH_SEGMENT@[4; 7)
+            NAME_REF@[4; 7)
+              IDENT@[4; 7) "foo"
+        COLONCOLON@[7; 9) "::"
+        PATH_SEGMENT@[9; 12)
+          NAME_REF@[9; 12)
+            IDENT@[9; 12) "bar"
+    SEMI@[12; 13) ";"
+  WHITESPACE@[13; 14) "\n"
+  USE_ITEM@[14; 17)
+    USE_KW@[14; 17) "use"
+  WHITESPACE@[17; 18) "\n"
+  USE_ITEM@[18; 33)
+    USE_KW@[18; 21) "use"
+    WHITESPACE@[21; 22) " "
+    USE_TREE@[22; 32)
+      PATH@[22; 32)
+        PATH@[22; 27)
+          PATH_SEGMENT@[22; 27)
+            CRATE_KW@[22; 27) "crate"
+        COLONCOLON@[27; 29) "::"
+        PATH_SEGMENT@[29; 32)
+          NAME_REF@[29; 32)
+            IDENT@[29; 32) "baz"
+    SEMI@[32; 33) ";"
+  WHITESPACE@[33; 34) "\n"
+  USE_ITEM@[34; 37)
+    USE_KW@[34; 37) "use"
+  WHITESPACE@[37; 38) "\n"
+  FN_DEF@[38; 47)
+    FN_KW@[38; 40) "fn"
+    WHITESPACE@[40; 41) " "
+    NAME@[41; 42)
+      IDENT@[41; 42) "f"
+    PARAM_LIST@[42; 44)
+      L_PAREN@[42; 43) "("
+      R_PAREN@[43; 44) ")"
+    WHITESPACE@[44; 45) " "
+    BLOCK_EXPR@[45; 47)
+      BLOCK@[45; 47)
+        L_CURLY@[45; 46) "{"
+        R_CURLY@[46; 47) "}"
+  WHITESPACE@[47; 48) "\n"
+error 17: expected one of `*`, `::`, `{`, `self`, `super` or an identifier
+error 17: expected SEMI
+error 37: expected one of `*`, `::`, `{`, `self`, `super` or an identifier
+error 37: expected SEMI