468 files changed, 28664 insertions, 27092 deletions
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index c3e653299..2fe7c3de3 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -5,12 +5,12 @@ use ra_fmt::{leading_indent, reindent};
 use ra_ide_db::RootDatabase;
 use ra_syntax::{
    algo::{self, find_covering_element, find_node_at_offset},
-    AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextUnit,
+    AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextSize,
    TokenAtOffset,
 };
 use ra_text_edit::TextEditBuilder;
-use crate::{AssistAction, AssistId, AssistLabel, GroupLabel, ResolvedAssist};
+use crate::{AssistAction, AssistFile, AssistId, AssistLabel, GroupLabel, ResolvedAssist};
 use algo::SyntaxRewriter;
 #[derive(Clone, Debug)]
@@ -178,8 +178,9 @@ impl<'a> AssistGroup<'a> {
 #[derive(Default)]
 pub(crate) struct ActionBuilder {
    edit: TextEditBuilder,
-    cursor_position: Option<TextUnit>,
+    cursor_position: Option<TextSize>,
    target: Option<TextRange>,
+    file: AssistFile,
 }
 impl ActionBuilder {
@@ -210,12 +211,12 @@ impl ActionBuilder {
    }
    /// Append specified `text` at the given `offset`
-    pub(crate) fn insert(&mut self, offset: TextUnit, text: impl Into<String>) {
+    pub(crate) fn insert(&mut self, offset: TextSize, text: impl Into<String>) {
        self.edit.insert(offset, text.into())
    }
    /// Specify desired position of the cursor after the assist is applied.
-    pub(crate) fn set_cursor(&mut self, offset: TextUnit) {
+    pub(crate) fn set_cursor(&mut self, offset: TextSize) {
        self.cursor_position = Some(offset)
    }
@@ -241,11 +242,16 @@ impl ActionBuilder {
        algo::diff(&node, &new).into_text_edit(&mut self.edit)
    }
+    pub(crate) fn set_file(&mut self, assist_file: AssistFile) {
+        self.file = assist_file
+    }
    fn build(self) -> AssistAction {
        AssistAction {
            edit: self.edit.finish(),
            cursor_position: self.cursor_position,
            target: self.target,
+            file: self.file,
        }
    }
 }
diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index b39e60870..e4fa9ee36 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -66,7 +66,7 @@ fn doctest_add_function() {
 struct Baz;
 fn baz() -> Baz { Baz }
 fn foo() {
-     bar<|>("", baz());
+    bar<|>("", baz());
 }
 "#####,
@@ -74,7 +74,7 @@ fn foo() {
 struct Baz;
 fn baz() -> Baz { Baz }
 fn foo() {
-     bar("", baz());
+    bar("", baz());
 }
 fn bar(arg: &str, baz: Baz) {
diff --git a/crates/ra_assists/src/handlers/add_custom_impl.rs b/crates/ra_assists/src/handlers/add_custom_impl.rs
index 15f9b216b..4ea26a550 100644
--- a/crates/ra_assists/src/handlers/add_custom_impl.rs
+++ b/crates/ra_assists/src/handlers/add_custom_impl.rs
@@ -2,7 +2,7 @@ use ra_syntax::{
    ast::{self, AstNode},
    Direction, SmolStr,
    SyntaxKind::{IDENT, WHITESPACE},
-    TextRange, TextUnit,
+    TextRange, TextSize,
 };
 use stdx::SepBy;
@@ -60,7 +60,6 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx) -> Option<Assist> {
            .collect::<Vec<SmolStr>>();
        let has_more_derives = !new_attr_input.is_empty();
        let new_attr_input = new_attr_input.iter().sep_by(", ").surround_with("(", ")").to_string();
-        let new_attr_input_len = new_attr_input.len();
        let mut buf = String::new();
        buf.push_str("\n\nimpl ");
@@ -70,8 +69,9 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx) -> Option<Assist> {
        buf.push_str(" {\n");
        let cursor_delta = if has_more_derives {
+            let delta = input.syntax().text_range().len() - TextSize::of(&new_attr_input);
            edit.replace(input.syntax().text_range(), new_attr_input);
-            input.syntax().text_range().len() - TextUnit::from_usize(new_attr_input_len)
+            delta
        } else {
            let attr_range = attr.syntax().text_range();
            edit.delete(attr_range);
@@ -81,13 +81,13 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx) -> Option<Assist> {
                .next_sibling_or_token()
                .filter(|t| t.kind() == WHITESPACE)
                .map(|t| t.text_range())
-                .unwrap_or_else(|| TextRange::from_to(TextUnit::from(0), TextUnit::from(0)));
+                .unwrap_or_else(|| TextRange::new(TextSize::from(0), TextSize::from(0)));
            edit.delete(line_break_range);
            attr_range.len() + line_break_range.len()
        };
-        edit.set_cursor(start_offset + TextUnit::of_str(&buf) - cursor_delta);
+        edit.set_cursor(start_offset + TextSize::of(&buf) - cursor_delta);
        buf.push_str("\n}");
        edit.insert(start_offset, buf);
    })
diff --git a/crates/ra_assists/src/handlers/add_derive.rs b/crates/ra_assists/src/handlers/add_derive.rs
index b0d1a0a80..6254eb7c4 100644
--- a/crates/ra_assists/src/handlers/add_derive.rs
+++ b/crates/ra_assists/src/handlers/add_derive.rs
@@ -1,7 +1,7 @@
 use ra_syntax::{
    ast::{self, AstNode, AttrsOwner},
    SyntaxKind::{COMMENT, WHITESPACE},
-    TextUnit,
+    TextSize,
 };
 use crate::{Assist, AssistCtx, AssistId};
@@ -37,9 +37,9 @@ pub(crate) fn add_derive(ctx: AssistCtx) -> Option<Assist> {
        let offset = match derive_attr {
            None => {
                edit.insert(node_start, "#[derive()]\n");
-                node_start + TextUnit::of_str("#[derive(")
+                node_start + TextSize::of("#[derive(")
            }
-            Some(tt) => tt.syntax().text_range().end() - TextUnit::of_char(')'),
+            Some(tt) => tt.syntax().text_range().end() - TextSize::of(')'),
        };
        edit.target(nominal.syntax().text_range());
        edit.set_cursor(offset)
@@ -47,7 +47,7 @@ pub(crate) fn add_derive(ctx: AssistCtx) -> Option<Assist> {
 }
 // Insert `derive` after doc comments.
-fn derive_insertion_offset(nominal: &ast::NominalDef) -> Option<TextUnit> {
+fn derive_insertion_offset(nominal: &ast::NominalDef) -> Option<TextSize> {
    let non_ws_child = nominal
        .syntax()
        .children_with_tokens()
diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index 6c56d93d8..bc313782b 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -37,8 +37,8 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx) -> Option<Assist> {
    let stmt_range = stmt.syntax().text_range();
    let eq_range = stmt.eq_token()?.text_range();
    // Assist should only be applicable if cursor is between 'let' and '='
-    let let_range = TextRange::from_to(stmt_range.start(), eq_range.start());
+    let let_range = TextRange::new(stmt_range.start(), eq_range.start());
-    let cursor_in_range = ctx.frange.range.is_subrange(&let_range);
+    let cursor_in_range = let_range.contains_range(ctx.frange.range);
    if !cursor_in_range {
        return None;
    }
diff --git a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
index 0621487e8..03806724a 100644
--- a/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
+++ b/crates/ra_assists/src/handlers/add_from_impl_for_enum.rs
@@ -1,6 +1,6 @@
 use ra_syntax::{
    ast::{self, AstNode, NameOwner},
-    TextUnit,
+    TextSize,
 };
 use stdx::format_to;
@@ -65,7 +65,7 @@ impl From<{0}> for {1} {{
                variant_name
            );
            edit.insert(start_offset, buf);
-            edit.set_cursor(start_offset + TextUnit::of_str("\n\n"));
+            edit.set_cursor(start_offset + TextSize::of("\n\n"));
        },
    )
 }
diff --git a/crates/ra_assists/src/handlers/add_function.rs b/crates/ra_assists/src/handlers/add_function.rs
index ad4ab66ed..6c7456579 100644
--- a/crates/ra_assists/src/handlers/add_function.rs
+++ b/crates/ra_assists/src/handlers/add_function.rs
@@ -1,10 +1,10 @@
 use ra_syntax::{
    ast::{self, AstNode},
-    SyntaxKind, SyntaxNode, TextUnit,
+    SyntaxKind, SyntaxNode, TextSize,
 };
-use crate::{Assist, AssistCtx, AssistId};
+use crate::{Assist, AssistCtx, AssistFile, AssistId};
-use ast::{edit::IndentLevel, ArgListOwner, CallExpr, Expr};
+use ast::{edit::IndentLevel, ArgListOwner, ModuleItemOwner};
 use hir::HirDisplay;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -16,7 +16,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 // struct Baz;
 // fn baz() -> Baz { Baz }
 // fn foo() {
-//      bar<|>("", baz());
+//     bar<|>("", baz());
 // }
 //
 // ```
@@ -25,7 +25,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 // struct Baz;
 // fn baz() -> Baz { Baz }
 // fn foo() {
-//      bar("", baz());
+//     bar("", baz());
 // }
 //
 // fn bar(arg: &str, baz: Baz) {
@@ -38,21 +38,30 @@ pub(crate) fn add_function(ctx: AssistCtx) -> Option<Assist> {
    let call = path_expr.syntax().parent().and_then(ast::CallExpr::cast)?;
    let path = path_expr.path()?;
-    if path.qualifier().is_some() {
-        return None;
-    }
    if ctx.sema.resolve_path(&path).is_some() {
        // The function call already resolves, no need to add a function
        return None;
    }
-    let function_builder = FunctionBuilder::from_call(&ctx, &call)?;
+    let target_module = if let Some(qualifier) = path.qualifier() {
+        if let Some(hir::PathResolution::Def(hir::ModuleDef::Module(module))) =
+            ctx.sema.resolve_path(&qualifier)
+        {
+            Some(module.definition_source(ctx.sema.db))
+        } else {
+            return None;
+        }
+    } else {
+        None
+    };
+    let function_builder = FunctionBuilder::from_call(&ctx, &call, &path, target_module)?;
    ctx.add_assist(AssistId("add_function"), "Add function", |edit| {
        edit.target(call.syntax().text_range());
        if let Some(function_template) = function_builder.render() {
+            edit.set_file(function_template.file);
            edit.set_cursor(function_template.cursor_offset);
            edit.insert(function_template.insert_offset, function_template.fn_def.to_string());
        }
@@ -60,32 +69,70 @@ pub(crate) fn add_function(ctx: AssistCtx) -> Option<Assist> {
 }
 struct FunctionTemplate {
-    insert_offset: TextUnit,
+    insert_offset: TextSize,
-    cursor_offset: TextUnit,
+    cursor_offset: TextSize,
    fn_def: ast::SourceFile,
+    file: AssistFile,
 }
 struct FunctionBuilder {
-    append_fn_at: SyntaxNode,
+    target: GeneratedFunctionTarget,
    fn_name: ast::Name,
    type_params: Option<ast::TypeParamList>,
    params: ast::ParamList,
+    file: AssistFile,
+    needs_pub: bool,
 }
 impl FunctionBuilder {
-    fn from_call(ctx: &AssistCtx, call: &ast::CallExpr) -> Option<Self> {
+    /// Prepares a generated function that matches `call` in `generate_in`
-        let append_fn_at = next_space_for_fn(&call)?;
+    /// (or as close to `call` as possible, if `generate_in` is `None`)
-        let fn_name = fn_name(&call)?;
+    fn from_call(
+        ctx: &AssistCtx,
+        call: &ast::CallExpr,
+        path: &ast::Path,
+        target_module: Option<hir::InFile<hir::ModuleSource>>,
+    ) -> Option<Self> {
+        let needs_pub = target_module.is_some();
+        let mut file = AssistFile::default();
+        let target = if let Some(target_module) = target_module {
+            let (in_file, target) = next_space_for_fn_in_module(ctx.sema.db, target_module)?;
+            file = in_file;
+            target
+        } else {
+            next_space_for_fn_after_call_site(&call)?
+        };
+        let fn_name = fn_name(&path)?;
        let (type_params, params) = fn_args(ctx, &call)?;
-        Some(Self { append_fn_at, fn_name, type_params, params })
+        Some(Self { target, fn_name, type_params, params, file, needs_pub })
    }
    fn render(self) -> Option<FunctionTemplate> {
        let placeholder_expr = ast::make::expr_todo();
        let fn_body = ast::make::block_expr(vec![], Some(placeholder_expr));
-        let fn_def = ast::make::fn_def(self.fn_name, self.type_params, self.params, fn_body);
+        let mut fn_def = ast::make::fn_def(self.fn_name, self.type_params, self.params, fn_body);
-        let fn_def = ast::make::add_newlines(2, fn_def);
+        if self.needs_pub {
-        let fn_def = IndentLevel::from_node(&self.append_fn_at).increase_indent(fn_def);
+            fn_def = ast::make::add_pub_crate_modifier(fn_def);
-        let insert_offset = self.append_fn_at.text_range().end();
+        }
+        let (fn_def, insert_offset) = match self.target {
+            GeneratedFunctionTarget::BehindItem(it) => {
+                let with_leading_blank_line = ast::make::add_leading_newlines(2, fn_def);
+                let indented = IndentLevel::from_node(&it).increase_indent(with_leading_blank_line);
+                (indented, it.text_range().end())
+            }
+            GeneratedFunctionTarget::InEmptyItemList(it) => {
+                let indent_once = IndentLevel(1);
+                let indent = IndentLevel::from_node(it.syntax());
+                let fn_def = ast::make::add_leading_newlines(1, fn_def);
+                let fn_def = indent_once.increase_indent(fn_def);
+                let fn_def = ast::make::add_trailing_newlines(1, fn_def);
+                let fn_def = indent.increase_indent(fn_def);
+                (fn_def, it.syntax().text_range().start() + TextSize::of('{'))
+            }
+        };
        let cursor_offset_from_fn_start = fn_def
            .syntax()
            .descendants()
@@ -94,19 +141,24 @@ impl FunctionBuilder {
            .text_range()
            .start();
        let cursor_offset = insert_offset + cursor_offset_from_fn_start;
-        Some(FunctionTemplate { insert_offset, cursor_offset, fn_def })
+        Some(FunctionTemplate { insert_offset, cursor_offset, fn_def, file: self.file })
    }
 }
-fn fn_name(call: &CallExpr) -> Option<ast::Name> {
+enum GeneratedFunctionTarget {
-    let name = call.expr()?.syntax().to_string();
+    BehindItem(SyntaxNode),
+    InEmptyItemList(ast::ItemList),
+}
+fn fn_name(call: &ast::Path) -> Option<ast::Name> {
+    let name = call.segment()?.syntax().to_string();
    Some(ast::make::name(&name))
 }
 /// Computes the type variables and arguments required for the generated function
 fn fn_args(
    ctx: &AssistCtx,
-    call: &CallExpr,
+    call: &ast::CallExpr,
 ) -> Option<(Option<ast::TypeParamList>, ast::ParamList)> {
    let mut arg_names = Vec::new();
    let mut arg_types = Vec::new();
@@ -158,9 +210,9 @@ fn deduplicate_arg_names(arg_names: &mut Vec<String>) {
    }
 }
-fn fn_arg_name(fn_arg: &Expr) -> Option<String> {
+fn fn_arg_name(fn_arg: &ast::Expr) -> Option<String> {
    match fn_arg {
-        Expr::CastExpr(cast_expr) => fn_arg_name(&cast_expr.expr()?),
+        ast::Expr::CastExpr(cast_expr) => fn_arg_name(&cast_expr.expr()?),
        _ => Some(
            fn_arg
                .syntax()
@@ -172,7 +224,7 @@ fn fn_arg_name(fn_arg: &Expr) -> Option<String> {
    }
 }
-fn fn_arg_type(ctx: &AssistCtx, fn_arg: &Expr) -> Option<String> {
+fn fn_arg_type(ctx: &AssistCtx, fn_arg: &ast::Expr) -> Option<String> {
    let ty = ctx.sema.type_of_expr(fn_arg)?;
    if ty.is_unknown() {
        return None;
@@ -184,7 +236,7 @@ fn fn_arg_type(ctx: &AssistCtx, fn_arg: &Expr) -> Option<String> {
 /// directly after the current block
 /// We want to write the generated function directly after
 /// fns, impls or macro calls, but inside mods
-fn next_space_for_fn(expr: &CallExpr) -> Option<SyntaxNode> {
+fn next_space_for_fn_after_call_site(expr: &ast::CallExpr) -> Option<GeneratedFunctionTarget> {
    let mut ancestors = expr.syntax().ancestors().peekable();
    let mut last_ancestor: Option<SyntaxNode> = None;
    while let Some(next_ancestor) = ancestors.next() {
@@ -201,7 +253,32 @@ fn next_space_for_fn(expr: &CallExpr) -> Option<SyntaxNode> {
        }
        last_ancestor = Some(next_ancestor);
    }
-    last_ancestor
+    last_ancestor.map(GeneratedFunctionTarget::BehindItem)
+}
+fn next_space_for_fn_in_module(
+    db: &dyn hir::db::AstDatabase,
+    module: hir::InFile<hir::ModuleSource>,
+) -> Option<(AssistFile, GeneratedFunctionTarget)> {
+    let file = module.file_id.original_file(db);
+    let assist_file = AssistFile::TargetFile(file);
+    let assist_item = match module.value {
+        hir::ModuleSource::SourceFile(it) => {
+            if let Some(last_item) = it.items().last() {
+                GeneratedFunctionTarget::BehindItem(last_item.syntax().clone())
+            } else {
+                GeneratedFunctionTarget::BehindItem(it.syntax().clone())
+            }
+        }
+        hir::ModuleSource::Module(it) => {
+            if let Some(last_item) = it.item_list().and_then(|it| it.items().last()) {
+                GeneratedFunctionTarget::BehindItem(last_item.syntax().clone())
+            } else {
+                GeneratedFunctionTarget::InEmptyItemList(it.item_list()?)
+            }
+        }
+    };
+    Some((assist_file, assist_item))
 }
 #[cfg(test)]
@@ -714,6 +791,111 @@ fn bar(baz_1: Baz, baz_2: Baz, arg_1: &str, arg_2: &str) {
    }
    #[test]
+    fn add_function_in_module() {
+        check_assist(
+            add_function,
+            r"
+mod bar {}
+fn foo() {
+    bar::my_fn<|>()
+}
+",
+            r"
+mod bar {
+    pub(crate) fn my_fn() {
+        <|>todo!()
+    }
+}
+fn foo() {
+    bar::my_fn()
+}
+",
+        )
+    }
+    #[test]
+    fn add_function_in_module_containing_other_items() {
+        check_assist(
+            add_function,
+            r"
+mod bar {
+    fn something_else() {}
+}
+fn foo() {
+    bar::my_fn<|>()
+}
+",
+            r"
+mod bar {
+    fn something_else() {}
+    pub(crate) fn my_fn() {
+        <|>todo!()
+    }
+}
+fn foo() {
+    bar::my_fn()
+}
+",
+        )
+    }
+    #[test]
+    fn add_function_in_nested_module() {
+        check_assist(
+            add_function,
+            r"
+mod bar {
+    mod baz {}
+}
+fn foo() {
+    bar::baz::my_fn<|>()
+}
+",
+            r"
+mod bar {
+    mod baz {
+        pub(crate) fn my_fn() {
+            <|>todo!()
+        }
+    }
+}
+fn foo() {
+    bar::baz::my_fn()
+}
+",
+        )
+    }
+    #[test]
+    fn add_function_in_another_file() {
+        check_assist(
+            add_function,
+            r"
+//- /main.rs
+mod foo;
+fn main() {
+    foo::bar<|>()
+}
+//- /foo.rs
+",
+            r"
+pub(crate) fn bar() {
+    <|>todo!()
+}",
+        )
+    }
+    #[test]
    fn add_function_not_applicable_if_function_already_exists() {
        check_assist_not_applicable(
            add_function,
diff --git a/crates/ra_assists/src/handlers/add_impl.rs b/crates/ra_assists/src/handlers/add_impl.rs
index 6622eadb2..d26f8b93d 100644
--- a/crates/ra_assists/src/handlers/add_impl.rs
+++ b/crates/ra_assists/src/handlers/add_impl.rs
@@ -1,6 +1,6 @@
 use ra_syntax::{
    ast::{self, AstNode, NameOwner, TypeParamsOwner},
-    TextUnit,
+    TextSize,
 };
 use stdx::{format_to, SepBy};
@@ -51,7 +51,7 @@ pub(crate) fn add_impl(ctx: AssistCtx) -> Option<Assist> {
            format_to!(buf, "<{}>", generic_params)
        }
        buf.push_str(" {\n");
-        edit.set_cursor(start_offset + TextUnit::of_str(&buf));
+        edit.set_cursor(start_offset + TextSize::of(&buf));
        buf.push_str("\n}");
        edit.insert(start_offset, buf);
    })
diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs
index 240b19fa3..0f9174a29 100644
--- a/crates/ra_assists/src/handlers/add_new.rs
+++ b/crates/ra_assists/src/handlers/add_new.rs
@@ -3,7 +3,7 @@ use ra_syntax::{
    ast::{
        self, AstNode, NameOwner, StructKind, TypeAscriptionOwner, TypeParamsOwner, VisibilityOwner,
    },
-    TextUnit, T,
+    TextSize, T,
 };
 use stdx::{format_to, SepBy};
@@ -77,16 +77,16 @@ pub(crate) fn add_new(ctx: AssistCtx) -> Option<Assist> {
                    .text_range()
                    .end();
-                Some((start, TextUnit::from_usize(1)))
+                Some((start, TextSize::of("\n")))
            })
            .unwrap_or_else(|| {
                buf = generate_impl_text(&strukt, &buf);
                let start = strukt.syntax().text_range().end();
-                (start, TextUnit::from_usize(3))
+                (start, TextSize::of("\n}\n"))
            });
-        edit.set_cursor(start_offset + TextUnit::of_str(&buf) - end_offset);
+        edit.set_cursor(start_offset + TextSize::of(&buf) - end_offset);
        edit.insert(start_offset, buf);
    })
 }
diff --git a/crates/ra_assists/src/handlers/apply_demorgan.rs b/crates/ra_assists/src/handlers/apply_demorgan.rs
index 239807e24..260b9e073 100644
--- a/crates/ra_assists/src/handlers/apply_demorgan.rs
+++ b/crates/ra_assists/src/handlers/apply_demorgan.rs
@@ -26,7 +26,7 @@ pub(crate) fn apply_demorgan(ctx: AssistCtx) -> Option<Assist> {
    let op = expr.op_kind()?;
    let op_range = expr.op_token()?.text_range();
    let opposite_op = opposite_logic_op(op)?;
-    let cursor_in_range = ctx.frange.range.is_subrange(&op_range);
+    let cursor_in_range = op_range.contains_range(ctx.frange.range);
    if !cursor_in_range {
        return None;
    }
diff --git a/crates/ra_assists/src/handlers/change_visibility.rs b/crates/ra_assists/src/handlers/change_visibility.rs
index cd6d1ee6c..44f6a1dae 100644
--- a/crates/ra_assists/src/handlers/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -5,7 +5,7 @@ use ra_syntax::{
        ATTR, COMMENT, CONST_DEF, ENUM_DEF, FN_DEF, MODULE, STRUCT_DEF, TRAIT_DEF, VISIBILITY,
        WHITESPACE,
    },
-    SyntaxNode, TextUnit, T,
+    SyntaxNode, TextSize, T,
 };
 use crate::{Assist, AssistCtx, AssistId};
@@ -67,7 +67,7 @@ fn add_vis(ctx: AssistCtx) -> Option<Assist> {
    })
 }
-fn vis_offset(node: &SyntaxNode) -> TextUnit {
+fn vis_offset(node: &SyntaxNode) -> TextSize {
    node.children_with_tokens()
        .skip_while(|it| match it.kind() {
            WHITESPACE | COMMENT | ATTR => true,
diff --git a/crates/ra_assists/src/handlers/flip_binexpr.rs b/crates/ra_assists/src/handlers/flip_binexpr.rs
index bfcc09e90..8030efb35 100644
--- a/crates/ra_assists/src/handlers/flip_binexpr.rs
+++ b/crates/ra_assists/src/handlers/flip_binexpr.rs
@@ -23,7 +23,7 @@ pub(crate) fn flip_binexpr(ctx: AssistCtx) -> Option<Assist> {
    let rhs = expr.rhs()?.syntax().clone();
    let op_range = expr.op_token()?.text_range();
    // The assist should be applied only if the cursor is on the operator
-    let cursor_in_range = ctx.frange.range.is_subrange(&op_range);
+    let cursor_in_range = op_range.contains_range(ctx.frange.range);
    if !cursor_in_range {
        return None;
    }
diff --git a/crates/ra_assists/src/handlers/inline_local_variable.rs b/crates/ra_assists/src/handlers/inline_local_variable.rs
index c4fb425b0..f5702f6e0 100644
--- a/crates/ra_assists/src/handlers/inline_local_variable.rs
+++ b/crates/ra_assists/src/handlers/inline_local_variable.rs
@@ -52,7 +52,7 @@ pub(crate) fn inline_local_variable(ctx: AssistCtx) -> Option<Assist> {
        .next_sibling_or_token()
        .and_then(|it| ast::Whitespace::cast(it.as_token()?.clone()))
    {
-        TextRange::from_to(
+        TextRange::new(
            let_stmt.syntax().text_range().start(),
            whitespace.syntax().text_range().end(),
        )
diff --git a/crates/ra_assists/src/handlers/introduce_variable.rs b/crates/ra_assists/src/handlers/introduce_variable.rs
index 8c09e6bcd..eda9ac296 100644
--- a/crates/ra_assists/src/handlers/introduce_variable.rs
+++ b/crates/ra_assists/src/handlers/introduce_variable.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
        BLOCK_EXPR, BREAK_EXPR, COMMENT, LAMBDA_EXPR, LOOP_EXPR, MATCH_ARM, PATH_EXPR, RETURN_EXPR,
        WHITESPACE,
    },
-    SyntaxNode, TextUnit,
+    SyntaxNode, TextSize,
 };
 use stdx::format_to;
 use test_utils::tested_by;
@@ -47,10 +47,10 @@ pub(crate) fn introduce_variable(ctx: AssistCtx) -> Option<Assist> {
        let cursor_offset = if wrap_in_block {
            buf.push_str("{ let var_name = ");
-            TextUnit::of_str("{ let ")
+            TextSize::of("{ let ")
        } else {
            buf.push_str("let var_name = ");
-            TextUnit::of_str("let ")
+            TextSize::of("let ")
        };
        format_to!(buf, "{}", expr.syntax());
        let full_stmt = ast::ExprStmt::cast(anchor_stmt.clone());
diff --git a/crates/ra_assists/src/handlers/invert_if.rs b/crates/ra_assists/src/handlers/invert_if.rs
index 4c5716868..682e08512 100644
--- a/crates/ra_assists/src/handlers/invert_if.rs
+++ b/crates/ra_assists/src/handlers/invert_if.rs
@@ -28,7 +28,7 @@ pub(crate) fn invert_if(ctx: AssistCtx) -> Option<Assist> {
    let if_keyword = ctx.find_token_at_offset(T![if])?;
    let expr = ast::IfExpr::cast(if_keyword.parent())?;
    let if_range = if_keyword.text_range();
-    let cursor_in_range = ctx.frange.range.is_subrange(&if_range);
+    let cursor_in_range = if_range.contains_range(ctx.frange.range);
    if !cursor_in_range {
        return None;
    }
diff --git a/crates/ra_assists/src/handlers/merge_match_arms.rs b/crates/ra_assists/src/handlers/merge_match_arms.rs
index eb967ab92..5a77d3dbc 100644
--- a/crates/ra_assists/src/handlers/merge_match_arms.rs
+++ b/crates/ra_assists/src/handlers/merge_match_arms.rs
@@ -3,7 +3,7 @@ use std::iter::successors;
 use ra_syntax::{
    algo::neighbor,
    ast::{self, AstNode},
-    Direction, TextUnit,
+    Direction, TextSize,
 };
 use crate::{Assist, AssistCtx, AssistId, TextRange};
@@ -42,8 +42,8 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
    let current_text_range = current_arm.syntax().text_range();
    enum CursorPos {
-        InExpr(TextUnit),
+        InExpr(TextSize),
-        InPat(TextUnit),
+        InPat(TextSize),
    }
    let cursor_pos = ctx.frange.range.start();
    let cursor_pos = if current_expr.syntax().text_range().contains(cursor_pos) {
@@ -89,10 +89,10 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx) -> Option<Assist> {
        edit.target(current_text_range);
        edit.set_cursor(match cursor_pos {
-            CursorPos::InExpr(back_offset) => start + TextUnit::from_usize(arm.len()) - back_offset,
+            CursorPos::InExpr(back_offset) => start + TextSize::of(&arm) - back_offset,
            CursorPos::InPat(offset) => offset,
        });
-        edit.replace(TextRange::from_to(start, end), arm);
+        edit.replace(TextRange::new(start, end), arm);
    })
 }
diff --git a/crates/ra_assists/src/handlers/move_guard.rs b/crates/ra_assists/src/handlers/move_guard.rs
index 1cc498638..d5ccdd91c 100644
--- a/crates/ra_assists/src/handlers/move_guard.rs
+++ b/crates/ra_assists/src/handlers/move_guard.rs
@@ -1,7 +1,7 @@
 use ra_syntax::{
    ast,
    ast::{AstNode, AstToken, IfExpr, MatchArm},
-    TextUnit,
+    TextSize,
 };
 use crate::{Assist, AssistCtx, AssistId};
@@ -49,16 +49,16 @@ pub(crate) fn move_guard_to_arm_body(ctx: AssistCtx) -> Option<Assist> {
                    edit.delete(ele);
                    ele.len()
                } else {
-                    TextUnit::from(0)
+                    TextSize::from(0)
                }
            }
-            _ => TextUnit::from(0),
+            _ => TextSize::from(0),
        };
        edit.delete(guard.syntax().text_range());
        edit.replace_node_and_indent(arm_expr.syntax(), buf);
        edit.set_cursor(
-            arm_expr.syntax().text_range().start() + TextUnit::from(3) - offseting_amount,
+            arm_expr.syntax().text_range().start() + TextSize::from(3) - offseting_amount,
        );
    })
 }
@@ -123,7 +123,7 @@ pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx) -> Option<Assist> {
            }
            edit.insert(match_pat.syntax().text_range().end(), buf);
-            edit.set_cursor(match_pat.syntax().text_range().end() + TextUnit::from(1));
+            edit.set_cursor(match_pat.syntax().text_range().end() + TextSize::from(1));
        },
    )
 }
diff --git a/crates/ra_assists/src/handlers/raw_string.rs b/crates/ra_assists/src/handlers/raw_string.rs
index 7e4b83f13..567400b9c 100644
--- a/crates/ra_assists/src/handlers/raw_string.rs
+++ b/crates/ra_assists/src/handlers/raw_string.rs
@@ -2,7 +2,7 @@ use ra_syntax::{
    ast::{self, HasStringValue},
    AstToken,
    SyntaxKind::{RAW_STRING, STRING},
-    TextUnit,
+    TextSize,
 };
 use crate::{Assist, AssistCtx, AssistId};
@@ -81,7 +81,7 @@ pub(crate) fn add_hash(ctx: AssistCtx) -> Option<Assist> {
    let token = ctx.find_token_at_offset(RAW_STRING)?;
    ctx.add_assist(AssistId("add_hash"), "Add # to raw string", |edit| {
        edit.target(token.text_range());
-        edit.insert(token.text_range().start() + TextUnit::of_char('r'), "#");
+        edit.insert(token.text_range().start() + TextSize::of('r'), "#");
        edit.insert(token.text_range().end(), "#");
    })
 }
diff --git a/crates/ra_assists/src/handlers/remove_dbg.rs b/crates/ra_assists/src/handlers/remove_dbg.rs
index 5085649b4..4e5eb4350 100644
--- a/crates/ra_assists/src/handlers/remove_dbg.rs
+++ b/crates/ra_assists/src/handlers/remove_dbg.rs
@@ -1,6 +1,6 @@
 use ra_syntax::{
    ast::{self, AstNode},
-    TextUnit, T,
+    TextSize, T,
 };
 use crate::{Assist, AssistCtx, AssistId};
@@ -38,9 +38,9 @@ pub(crate) fn remove_dbg(ctx: AssistCtx) -> Option<Assist> {
        let offset_start = file_range
            .start()
            .checked_sub(macro_range.start())
-            .unwrap_or_else(|| TextUnit::from(0));
+            .unwrap_or_else(|| TextSize::from(0));
-        let dbg_size = TextUnit::of_str("dbg!(");
+        let dbg_size = TextSize::of("dbg!(");
        if offset_start > dbg_size {
            file_range.start() - dbg_size
@@ -53,7 +53,7 @@ pub(crate) fn remove_dbg(ctx: AssistCtx) -> Option<Assist> {
        let macro_args = macro_call.token_tree()?.syntax().clone();
        let text = macro_args.text();
-        let without_parens = TextUnit::of_char('(')..text.len() - TextUnit::of_char(')');
+        let without_parens = TextSize::of('(')..text.len() - TextSize::of(')');
        text.slice(without_parens).to_string()
    };
diff --git a/crates/ra_assists/src/handlers/remove_mut.rs b/crates/ra_assists/src/handlers/remove_mut.rs
index 6884830eb..e598023b2 100644
--- a/crates/ra_assists/src/handlers/remove_mut.rs
+++ b/crates/ra_assists/src/handlers/remove_mut.rs
@@ -27,6 +27,6 @@ pub(crate) fn remove_mut(ctx: AssistCtx) -> Option<Assist> {
    ctx.add_assist(AssistId("remove_mut"), "Remove `mut` keyword", |edit| {
        edit.set_cursor(delete_from);
-        edit.delete(TextRange::from_to(delete_from, delete_to));
+        edit.delete(TextRange::new(delete_from, delete_to));
    })
 }
diff --git a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index 94f5d6c50..2f02df303 100644
--- a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -43,7 +43,7 @@ pub(crate) fn replace_qualified_name_with_use(ctx: AssistCtx) -> Option<Assist>
            if let Some(last) = path.segment() {
                // Here we are assuming the assist will provide a correct use statement
                // so we can delete the path qualifier
-                edit.delete(TextRange::from_to(
+                edit.delete(TextRange::new(
                    path.syntax().text_range().start(),
                    last.syntax().text_range().start(),
                ));
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index a00136da1..64bd87afb 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -17,9 +17,9 @@ mod doc_tests;
 pub mod utils;
 pub mod ast_transform;
-use ra_db::FileRange;
+use ra_db::{FileId, FileRange};
 use ra_ide_db::RootDatabase;
-use ra_syntax::{TextRange, TextUnit};
+use ra_syntax::{TextRange, TextSize};
 use ra_text_edit::TextEdit;
 pub(crate) use crate::assist_ctx::{Assist, AssistCtx, AssistHandler};
@@ -51,9 +51,10 @@ impl AssistLabel {
 #[derive(Debug, Clone)]
 pub struct AssistAction {
    pub edit: TextEdit,
-    pub cursor_position: Option<TextUnit>,
+    pub cursor_position: Option<TextSize>,
    // FIXME: This belongs to `AssistLabel`
    pub target: Option<TextRange>,
+    pub file: AssistFile,
 }
 #[derive(Debug, Clone)]
@@ -63,6 +64,18 @@ pub struct ResolvedAssist {
    pub action: AssistAction,
 }
+#[derive(Debug, Clone, Copy)]
+pub enum AssistFile {
+    CurrentFile,
+    TargetFile(FileId),
+}
+impl Default for AssistFile {
+    fn default() -> Self {
+        Self::CurrentFile
+    }
+}
 /// Return all the assists applicable at the given position.
 ///
 /// Assists are returned in the "unresolved" state, that is only labels are
@@ -91,7 +104,7 @@ pub fn resolved_assists(db: &RootDatabase, range: FileRange) -> Vec<ResolvedAssi
        .flat_map(|it| it.0)
        .map(|it| it.into_resolved().unwrap())
        .collect::<Vec<_>>();
-    a.sort_by_key(|it| it.action.target.map_or(TextUnit::from(!0u32), |it| it.len()));
+    a.sort_by_key(|it| it.action.target.map_or(TextSize::from(!0u32), |it| it.len()));
    a
 }
@@ -184,7 +197,7 @@ mod helpers {
    use ra_ide_db::{symbol_index::SymbolsDatabase, RootDatabase};
    use test_utils::{add_cursor, assert_eq_text, extract_range_or_offset, RangeOrOffset};
-    use crate::{AssistCtx, AssistHandler};
+    use crate::{AssistCtx, AssistFile, AssistHandler};
    use hir::Semantics;
    pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
@@ -246,7 +259,13 @@ mod helpers {
            (Some(assist), ExpectedResult::After(after)) => {
                let action = assist.0[0].action.clone().unwrap();
-                let mut actual = action.edit.apply(&text_without_caret);
+                let assisted_file_text = if let AssistFile::TargetFile(file_id) = action.file {
+                    db.file_text(file_id).as_ref().to_owned()
+                } else {
+                    text_without_caret
+                };
+                let mut actual = action.edit.apply(&assisted_file_text);
                match action.cursor_position {
                    None => {
                        if let RangeOrOffset::Offset(before_cursor_pos) = range_or_offset {
@@ -289,8 +308,7 @@ mod tests {
        let before = "struct Foo { <|>bar: u32 }";
        let (before_cursor_pos, before) = extract_offset(before);
        let (db, file_id) = helpers::with_single_file(&before);
-        let frange =
+        let frange = FileRange { file_id, range: TextRange::empty(before_cursor_pos) };
-            FileRange { file_id, range: TextRange::offset_len(before_cursor_pos, 0.into()) };
        let assists = resolved_assists(&db, frange);
        let mut assists = assists.iter();
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index a06f59c14..fd4280de2 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -6,7 +6,7 @@ pub mod fixture;
 use std::{panic, sync::Arc};
 use ra_prof::profile;
-use ra_syntax::{ast, Parse, SourceFile, TextRange, TextUnit};
+use ra_syntax::{ast, Parse, SourceFile, TextRange, TextSize};
 pub use crate::{
    cancellation::Canceled,
@@ -75,7 +75,7 @@ impl<T: salsa::Database> CheckCanceled for T {
 #[derive(Clone, Copy, Debug)]
 pub struct FilePosition {
    pub file_id: FileId,
-    pub offset: TextUnit,
+    pub offset: TextSize,
 }
 #[derive(Clone, Copy, Debug)]
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 43f932e20..3f645a1dd 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -13,8 +13,8 @@ use hir_def::{
    resolver::{HasResolver, Resolver},
    type_ref::{Mutability, TypeRef},
    AdtId, AssocContainerId, ConstId, DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule,
-    ImplId, LocalEnumVariantId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId,
+    ImplId, LocalEnumVariantId, LocalFieldId, LocalModuleId, Lookup, ModuleId, StaticId, StructId,
-    StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
+    TraitId, TypeAliasId, TypeParamId, UnionId,
 };
 use hir_expand::{
    diagnostics::DiagnosticSink,
@@ -294,9 +294,9 @@ impl Module {
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct StructField {
+pub struct Field {
    pub(crate) parent: VariantDef,
-    pub(crate) id: LocalStructFieldId,
+    pub(crate) id: LocalFieldId,
 }
 #[derive(Debug, PartialEq, Eq)]
@@ -305,7 +305,7 @@ pub enum FieldSource {
    Pos(ast::TupleFieldDef),
 }
-impl StructField {
+impl Field {
    pub fn name(&self, db: &dyn HirDatabase) -> Name {
        self.parent.variant_data(db).fields()[self.id].name.clone()
    }
@@ -331,7 +331,7 @@ impl StructField {
    }
 }
-impl HasVisibility for StructField {
+impl HasVisibility for Field {
    fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
        let variant_data = self.parent.variant_data(db);
        let visibility = &variant_data.fields()[self.id].visibility;
@@ -358,12 +358,12 @@ impl Struct {
        db.struct_data(self.id).name.clone()
    }
-    pub fn fields(self, db: &dyn HirDatabase) -> Vec<StructField> {
+    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
        db.struct_data(self.id)
            .variant_data
            .fields()
            .iter()
-            .map(|(id, _)| StructField { parent: self.into(), id })
+            .map(|(id, _)| Field { parent: self.into(), id })
            .collect()
    }
@@ -394,12 +394,12 @@ impl Union {
        Type::from_def(db, self.id.lookup(db.upcast()).container.module(db.upcast()).krate, self.id)
    }
-    pub fn fields(self, db: &dyn HirDatabase) -> Vec<StructField> {
+    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
        db.union_data(self.id)
            .variant_data
            .fields()
            .iter()
-            .map(|(id, _)| StructField { parent: self.into(), id })
+            .map(|(id, _)| Field { parent: self.into(), id })
            .collect()
    }
@@ -457,11 +457,11 @@ impl EnumVariant {
        db.enum_data(self.parent.id).variants[self.id].name.clone()
    }
-    pub fn fields(self, db: &dyn HirDatabase) -> Vec<StructField> {
+    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
        self.variant_data(db)
            .fields()
            .iter()
-            .map(|(id, _)| StructField { parent: self.into(), id })
+            .map(|(id, _)| Field { parent: self.into(), id })
            .collect()
    }
@@ -527,7 +527,7 @@ pub enum VariantDef {
 impl_froms!(VariantDef: Struct, Union, EnumVariant);
 impl VariantDef {
-    pub fn fields(self, db: &dyn HirDatabase) -> Vec<StructField> {
+    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
        match self {
            VariantDef::Struct(it) => it.fields(db),
            VariantDef::Union(it) => it.fields(db),
@@ -1148,7 +1148,7 @@ impl Type {
        }
    }
-    pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(StructField, Type)> {
+    pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> {
        if let Ty::Apply(a_ty) = &self.ty.value {
            if let TypeCtor::Adt(AdtId::StructId(s)) = a_ty.ctor {
                let var_def = s.into();
@@ -1156,7 +1156,7 @@ impl Type {
                    .field_types(var_def)
                    .iter()
                    .map(|(local_id, ty)| {
-                        let def = StructField { parent: var_def.into(), id: local_id };
+                        let def = Field { parent: var_def.into(), id: local_id };
                        let ty = ty.clone().subst(&a_ty.parameters);
                        (def, self.derived(ty))
                    })
@@ -1352,7 +1352,7 @@ impl ScopeDef {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum AttrDef {
    Module(Module),
-    StructField(StructField),
+    Field(Field),
    Adt(Adt),
    Function(Function),
    EnumVariant(EnumVariant),
@@ -1365,7 +1365,7 @@ pub enum AttrDef {
 impl_froms!(
    AttrDef: Module,
-    StructField,
+    Field,
    Adt(Struct, Enum, Union),
    EnumVariant,
    Static,
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index 62fb52e72..679ae8121 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -4,13 +4,13 @@
 //! are splitting the hir.
 use hir_def::{
-    expr::PatId, AdtId, AssocItemId, AttrDefId, DefWithBodyId, EnumVariantId, GenericDefId,
+    expr::PatId, AdtId, AssocItemId, AttrDefId, DefWithBodyId, EnumVariantId, FieldId,
-    ModuleDefId, StructFieldId, VariantId,
+    GenericDefId, ModuleDefId, VariantId,
 };
 use crate::{
-    code_model::ItemInNs, Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, Local,
+    code_model::ItemInNs, Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, Field, GenericDef,
-    MacroDef, ModuleDef, StructField, VariantDef,
+    Local, MacroDef, ModuleDef, VariantDef,
 };
 macro_rules! from_id {
@@ -184,15 +184,15 @@ impl From<VariantDef> for VariantId {
    }
 }
-impl From<StructField> for StructFieldId {
+impl From<Field> for FieldId {
-    fn from(def: StructField) -> Self {
+    fn from(def: Field) -> Self {
-        StructFieldId { parent: def.parent.into(), local_id: def.id }
+        FieldId { parent: def.parent.into(), local_id: def.id }
    }
 }
-impl From<StructFieldId> for StructField {
+impl From<FieldId> for Field {
-    fn from(def: StructFieldId) -> Self {
+    fn from(def: FieldId) -> Self {
-        StructField { parent: def.parent.into(), id: def.local_id }
+        Field { parent: def.parent.into(), id: def.local_id }
    }
 }
@@ -200,7 +200,7 @@ impl From<AttrDef> for AttrDefId {
    fn from(def: AttrDef) -> Self {
        match def {
            AttrDef::Module(it) => AttrDefId::ModuleId(it.id),
-            AttrDef::StructField(it) => AttrDefId::StructFieldId(it.into()),
+            AttrDef::Field(it) => AttrDefId::FieldId(it.into()),
            AttrDef::Adt(it) => AttrDefId::AdtId(it.into()),
            AttrDef::Function(it) => AttrDefId::FunctionId(it.id),
            AttrDef::EnumVariant(it) => AttrDefId::EnumVariantId(it.into()),
diff --git a/crates/ra_hir/src/has_source.rs b/crates/ra_hir/src/has_source.rs
index 129764e0a..63b8fd369 100644
--- a/crates/ra_hir/src/has_source.rs
+++ b/crates/ra_hir/src/has_source.rs
@@ -9,8 +9,8 @@ use hir_def::{
 use ra_syntax::ast;
 use crate::{
-    db::HirDatabase, Const, Enum, EnumVariant, FieldSource, Function, ImplDef, MacroDef, Module,
+    db::HirDatabase, Const, Enum, EnumVariant, Field, FieldSource, Function, ImplDef, MacroDef,
-    Static, Struct, StructField, Trait, TypeAlias, TypeParam, Union,
+    Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
 };
 pub use hir_expand::InFile;
@@ -37,7 +37,7 @@ impl Module {
    }
 }
-impl HasSource for StructField {
+impl HasSource for Field {
    type Ast = FieldSource;
    fn source(self, db: &dyn HirDatabase) -> InFile<FieldSource> {
        let var = VariantId::from(self.parent);
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 5af7e5d6d..312ef3814 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -52,9 +52,9 @@ mod has_source;
 pub use crate::{
    code_model::{
        Adt, AsAssocItem, AssocItem, AssocItemContainer, AttrDef, Const, Crate, CrateDependency,
-        DefWithBody, Docs, Enum, EnumVariant, FieldSource, Function, GenericDef, HasAttrs,
+        DefWithBody, Docs, Enum, EnumVariant, Field, FieldSource, Function, GenericDef, HasAttrs,
        HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, ScopeDef, Static, Struct,
-        StructField, Trait, Type, TypeAlias, TypeParam, Union, VariantDef, Visibility,
+        Trait, Type, TypeAlias, TypeParam, Union, VariantDef, Visibility,
    },
    has_source::HasSource,
    semantics::{original_range, PathResolution, Semantics, SemanticsScope},
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 5d6edc45c..86bfb416c 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -14,7 +14,7 @@ use ra_db::{FileId, FileRange};
 use ra_prof::profile;
 use ra_syntax::{
    algo::{find_node_at_offset, skip_trivia_token},
-    ast, AstNode, Direction, SyntaxNode, SyntaxToken, TextRange, TextUnit,
+    ast, AstNode, Direction, SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -23,8 +23,8 @@ use crate::{
    diagnostics::Diagnostic,
    semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
    source_analyzer::{resolve_hir_path, SourceAnalyzer},
-    AssocItem, Function, HirFileId, ImplDef, InFile, Local, MacroDef, Module, ModuleDef, Name,
+    AssocItem, Field, Function, HirFileId, ImplDef, InFile, Local, MacroDef, Module, ModuleDef,
-    Origin, Path, ScopeDef, StructField, Trait, Type, TypeParam,
+    Name, Origin, Path, ScopeDef, Trait, Type, TypeParam,
 };
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -95,7 +95,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        let token = successors(Some(parent.with_value(token)), |token| {
            let macro_call = token.value.ancestors().find_map(ast::MacroCall::cast)?;
            let tt = macro_call.token_tree()?;
-            if !token.value.text_range().is_subrange(&tt.syntax().text_range()) {
+            if !tt.syntax().text_range().contains_range(token.value.text_range()) {
                return None;
            }
            let file_id = sa.expand(self.db, token.with_value(&macro_call))?;
@@ -114,7 +114,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    pub fn descend_node_at_offset<N: ast::AstNode>(
        &self,
        node: &SyntaxNode,
-        offset: TextUnit,
+        offset: TextSize,
    ) -> Option<N> {
        // Handle macro token cases
        node.token_at_offset(offset)
@@ -142,7 +142,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    pub fn ancestors_at_offset_with_macros(
        &self,
        node: &SyntaxNode,
-        offset: TextUnit,
+        offset: TextSize,
    ) -> impl Iterator<Item = SyntaxNode> + '_ {
        node.token_at_offset(offset)
            .map(|token| self.ancestors_with_macros(token.parent()))
@@ -154,7 +154,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    pub fn find_node_at_offset_with_macros<N: AstNode>(
        &self,
        node: &SyntaxNode,
-        offset: TextUnit,
+        offset: TextSize,
    ) -> Option<N> {
        self.ancestors_at_offset_with_macros(node, offset).find_map(N::cast)
    }
@@ -164,7 +164,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    pub fn find_node_at_offset_with_descend<N: AstNode>(
        &self,
        node: &SyntaxNode,
-        offset: TextUnit,
+        offset: TextSize,
    ) -> Option<N> {
        if let Some(it) = find_node_at_offset(&node, offset) {
            return Some(it);
@@ -184,18 +184,15 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.analyze(call.syntax()).resolve_method_call(self.db, call)
    }
-    pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<StructField> {
+    pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<Field> {
        self.analyze(field.syntax()).resolve_field(self.db, field)
    }
-    pub fn resolve_record_field(
+    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<(Field, Option<Local>)> {
-        &self,
-        field: &ast::RecordField,
-    ) -> Option<(StructField, Option<Local>)> {
        self.analyze(field.syntax()).resolve_record_field(self.db, field)
    }
-    pub fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option<StructField> {
+    pub fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option<Field> {
        self.analyze(field.syntax()).resolve_record_field_pat(self.db, field)
    }
@@ -216,19 +213,13 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    // FIXME: use this instead?
    // pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option<???>;
-    pub fn record_literal_missing_fields(
+    pub fn record_literal_missing_fields(&self, literal: &ast::RecordLit) -> Vec<(Field, Type)> {
-        &self,
-        literal: &ast::RecordLit,
-    ) -> Vec<(StructField, Type)> {
        self.analyze(literal.syntax())
            .record_literal_missing_fields(self.db, literal)
            .unwrap_or_default()
    }
-    pub fn record_pattern_missing_fields(
+    pub fn record_pattern_missing_fields(&self, pattern: &ast::RecordPat) -> Vec<(Field, Type)> {
-        &self,
-        pattern: &ast::RecordPat,
-    ) -> Vec<(StructField, Type)> {
        self.analyze(pattern.syntax())
            .record_pattern_missing_fields(self.db, pattern)
            .unwrap_or_default()
@@ -255,7 +246,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        SemanticsScope { db: self.db, resolver }
    }
-    pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextUnit) -> SemanticsScope<'db, DB> {
+    pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db, DB> {
        let node = self.find_file(node.clone());
        let resolver = self.analyze2(node.as_ref(), Some(offset)).resolver;
        SemanticsScope { db: self.db, resolver }
@@ -271,7 +262,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
        self.analyze2(src.as_ref(), None)
    }
-    fn analyze2(&self, src: InFile<&SyntaxNode>, offset: Option<TextUnit>) -> SourceAnalyzer {
+    fn analyze2(&self, src: InFile<&SyntaxNode>, offset: Option<TextSize>) -> SourceAnalyzer {
        let _p = profile("Semantics::analyze2");
        let container = match self.with_ctx(|ctx| ctx.find_container(src)) {
@@ -359,8 +350,8 @@ to_def_impls![
    (crate::Const, ast::ConstDef, const_to_def),
    (crate::Static, ast::StaticDef, static_to_def),
    (crate::Function, ast::FnDef, fn_to_def),
-    (crate::StructField, ast::RecordFieldDef, record_field_to_def),
+    (crate::Field, ast::RecordFieldDef, record_field_to_def),
-    (crate::StructField, ast::TupleFieldDef, tuple_field_to_def),
+    (crate::Field, ast::TupleFieldDef, tuple_field_to_def),
    (crate::EnumVariant, ast::EnumVariant, enum_variant_to_def),
    (crate::TypeParam, ast::TypeParam, type_param_to_def),
    (crate::MacroDef, ast::MacroCall, macro_call_to_def), // this one is dubious, not all calls are macros
@@ -463,7 +454,7 @@ fn original_range_opt(
            return None;
        }
-        Some(first.with_value(first.value.text_range().extend_to(&last.value.text_range())))
+        Some(first.with_value(first.value.text_range().cover(last.value.text_range())))
    })?)
 }
diff --git a/crates/ra_hir/src/semantics/source_to_def.rs b/crates/ra_hir/src/semantics/source_to_def.rs
index 66724919b..6f3b5b2da 100644
--- a/crates/ra_hir/src/semantics/source_to_def.rs
+++ b/crates/ra_hir/src/semantics/source_to_def.rs
@@ -5,8 +5,8 @@ use hir_def::{
    dyn_map::DynMap,
    expr::PatId,
    keys::{self, Key},
-    ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, ModuleId,
+    ConstId, DefWithBodyId, EnumId, EnumVariantId, FieldId, FunctionId, GenericDefId, ImplId,
-    StaticId, StructFieldId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId, VariantId,
+    ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId, VariantId,
 };
 use hir_expand::{name::AsName, AstId, MacroDefKind};
 use ra_db::FileId;
@@ -97,13 +97,13 @@ impl SourceToDefCtx<'_, '_> {
    pub(super) fn record_field_to_def(
        &mut self,
        src: InFile<ast::RecordFieldDef>,
-    ) -> Option<StructFieldId> {
+    ) -> Option<FieldId> {
        self.to_def(src, keys::RECORD_FIELD)
    }
    pub(super) fn tuple_field_to_def(
        &mut self,
        src: InFile<ast::TupleFieldDef>,
-    ) -> Option<StructFieldId> {
+    ) -> Option<FieldId> {
        self.to_def(src, keys::TUPLE_FIELD)
    }
    pub(super) fn enum_variant_to_def(
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index 0ed6d0958..74d64c97d 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -14,7 +14,7 @@ use hir_def::{
    },
    expr::{ExprId, Pat, PatId},
    resolver::{resolver_for_scope, Resolver, TypeNs, ValueNs},
-    AsMacroCall, DefWithBodyId, LocalStructFieldId, StructFieldId, VariantId,
+    AsMacroCall, DefWithBodyId, FieldId, LocalFieldId, VariantId,
 };
 use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
 use hir_ty::{
@@ -23,12 +23,12 @@ use hir_ty::{
 };
 use ra_syntax::{
    ast::{self, AstNode},
-    SyntaxNode, TextRange, TextUnit,
+    SyntaxNode, TextRange, TextSize,
 };
 use crate::{
-    db::HirDatabase, semantics::PathResolution, Adt, Const, EnumVariant, Function, Local, MacroDef,
+    db::HirDatabase, semantics::PathResolution, Adt, Const, EnumVariant, Field, Function, Local,
-    ModPath, ModuleDef, Path, PathKind, Static, Struct, StructField, Trait, Type, TypeAlias,
+    MacroDef, ModPath, ModuleDef, Path, PathKind, Static, Struct, Trait, Type, TypeAlias,
    TypeParam,
 };
 use ra_db::CrateId;
@@ -50,7 +50,7 @@ impl SourceAnalyzer {
        db: &dyn HirDatabase,
        def: DefWithBodyId,
        node: InFile<&SyntaxNode>,
-        offset: Option<TextUnit>,
+        offset: Option<TextSize>,
    ) -> SourceAnalyzer {
        let (body, source_map) = db.body_with_source_map(def);
        let scopes = db.expr_scopes(def);
@@ -140,7 +140,7 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        field: &ast::FieldExpr,
-    ) -> Option<StructField> {
+    ) -> Option<Field> {
        let expr_id = self.expr_id(db, &field.clone().into())?;
        self.infer.as_ref()?.field_resolution(expr_id).map(|it| it.into())
    }
@@ -149,7 +149,7 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        field: &ast::RecordField,
-    ) -> Option<(StructField, Option<Local>)> {
+    ) -> Option<(Field, Option<Local>)> {
        let expr = field.expr()?;
        let expr_id = self.expr_id(db, &expr)?;
        let local = if field.name_ref().is_some() {
@@ -172,7 +172,7 @@ impl SourceAnalyzer {
        &self,
        _db: &dyn HirDatabase,
        field: &ast::RecordFieldPat,
-    ) -> Option<StructField> {
+    ) -> Option<Field> {
        let pat_id = self.pat_id(&field.pat()?)?;
        let struct_field = self.infer.as_ref()?.record_field_pat_resolution(pat_id)?;
        Some(struct_field.into())
@@ -232,7 +232,7 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        literal: &ast::RecordLit,
-    ) -> Option<Vec<(StructField, Type)>> {
+    ) -> Option<Vec<(Field, Type)>> {
        let krate = self.resolver.krate()?;
        let body = self.body.as_ref()?;
        let infer = self.infer.as_ref()?;
@@ -253,7 +253,7 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        pattern: &ast::RecordPat,
-    ) -> Option<Vec<(StructField, Type)>> {
+    ) -> Option<Vec<(Field, Type)>> {
        let krate = self.resolver.krate()?;
        let body = self.body.as_ref()?;
        let infer = self.infer.as_ref()?;
@@ -276,14 +276,14 @@ impl SourceAnalyzer {
        krate: CrateId,
        substs: &Substs,
        variant: VariantId,
-        missing_fields: Vec<LocalStructFieldId>,
+        missing_fields: Vec<LocalFieldId>,
-    ) -> Vec<(StructField, Type)> {
+    ) -> Vec<(Field, Type)> {
        let field_types = db.field_types(variant);
        missing_fields
            .into_iter()
            .map(|local_id| {
-                let field = StructFieldId { parent: variant, local_id };
+                let field = FieldId { parent: variant, local_id };
                let ty = field_types[local_id].clone().subst(substs);
                (field.into(), Type::new_with_resolver_inner(db, krate, &self.resolver, ty))
            })
@@ -318,7 +318,7 @@ fn scope_for_offset(
    db: &dyn HirDatabase,
    scopes: &ExprScopes,
    source_map: &BodySourceMap,
-    offset: InFile<TextUnit>,
+    offset: InFile<TextSize>,
 ) -> Option<ScopeId> {
    scopes
        .scope_by_expr()
@@ -354,7 +354,7 @@ fn adjust(
    source_map: &BodySourceMap,
    expr_range: TextRange,
    file_id: HirFileId,
-    offset: TextUnit,
+    offset: TextSize,
 ) -> Option<ScopeId> {
    let child_scopes = scopes
        .scope_by_expr()
@@ -369,15 +369,15 @@ fn adjust(
            let node = source.value.to_node(&root);
            Some((node.syntax().text_range(), scope))
        })
-        .filter(|(range, _)| {
+        .filter(|&(range, _)| {
-            range.start() <= offset && range.is_subrange(&expr_range) && *range != expr_range
+            range.start() <= offset && expr_range.contains_range(range) && range != expr_range
        });
    child_scopes
-        .max_by(|(r1, _), (r2, _)| {
+        .max_by(|&(r1, _), &(r2, _)| {
-            if r2.is_subrange(&r1) {
+            if r1.contains_range(r2) {
                std::cmp::Ordering::Greater
-            } else if r1.is_subrange(&r2) {
+            } else if r2.contains_range(r1) {
                std::cmp::Ordering::Less
            } else {
                r1.start().cmp(&r2.start())
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 7c0d93691..753becc3d 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -14,7 +14,7 @@ use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner};
 use crate::{
    body::CfgExpander, db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace,
    type_ref::TypeRef, visibility::RawVisibility, EnumId, HasModule, LocalEnumVariantId,
-    LocalStructFieldId, Lookup, ModuleId, StructId, UnionId, VariantId,
+    LocalFieldId, Lookup, ModuleId, StructId, UnionId, VariantId,
 };
 /// Note that we use `StructData` for unions as well!
@@ -38,14 +38,14 @@ pub struct EnumVariantData {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum VariantData {
-    Record(Arena<StructFieldData>),
+    Record(Arena<FieldData>),
-    Tuple(Arena<StructFieldData>),
+    Tuple(Arena<FieldData>),
    Unit,
 }
 /// A single field of an enum variant or struct
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct StructFieldData {
+pub struct FieldData {
    pub name: Name,
    pub type_ref: TypeRef,
    pub visibility: RawVisibility,
@@ -133,15 +133,15 @@ impl VariantData {
        }
    }
-    pub fn fields(&self) -> &Arena<StructFieldData> {
+    pub fn fields(&self) -> &Arena<FieldData> {
-        const EMPTY: &Arena<StructFieldData> = &Arena::new();
+        const EMPTY: &Arena<FieldData> = &Arena::new();
        match &self {
            VariantData::Record(fields) | VariantData::Tuple(fields) => fields,
            _ => EMPTY,
        }
    }
-    pub fn field(&self, name: &Name) -> Option<LocalStructFieldId> {
+    pub fn field(&self, name: &Name) -> Option<LocalFieldId> {
        self.fields().iter().find_map(|(id, data)| if &data.name == name { Some(id) } else { None })
    }
@@ -155,7 +155,7 @@ impl VariantData {
 }
 impl HasChildSource for VariantId {
-    type ChildId = LocalStructFieldId;
+    type ChildId = LocalFieldId;
    type Value = Either<ast::TupleFieldDef, ast::RecordFieldDef>;
    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
@@ -195,7 +195,7 @@ pub enum StructKind {
 fn lower_struct(
    db: &dyn DefDatabase,
    expander: &mut CfgExpander,
-    trace: &mut Trace<StructFieldData, Either<ast::TupleFieldDef, ast::RecordFieldDef>>,
+    trace: &mut Trace<FieldData, Either<ast::TupleFieldDef, ast::RecordFieldDef>>,
    ast: &InFile<ast::StructKind>,
 ) -> StructKind {
    match &ast.value {
@@ -208,7 +208,7 @@ fn lower_struct(
                trace.alloc(
                    || Either::Left(fd.clone()),
-                    || StructFieldData {
+                    || FieldData {
                        name: Name::new_tuple_field(i),
                        type_ref: TypeRef::from_ast_opt(fd.type_ref()),
                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
@@ -226,7 +226,7 @@ fn lower_struct(
                trace.alloc(
                    || Either::Right(fd.clone()),
-                    || StructFieldData {
+                    || FieldData {
                        name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing),
                        type_ref: TypeRef::from_ast_opt(fd.ascribed_type()),
                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 2f2e3e5ba..5a86af8ba 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -13,7 +13,8 @@ use ra_syntax::{
 use tt::Subtree;
 use crate::{
-    db::DefDatabase, path::ModPath, src::HasChildSource, src::HasSource, AdtId, AttrDefId, Lookup,
+    db::DefDatabase, nameres::ModuleSource, path::ModPath, src::HasChildSource, src::HasSource,
+    AdtId, AttrDefId, Lookup,
 };
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
@@ -37,13 +38,21 @@ impl Attrs {
        match def {
            AttrDefId::ModuleId(module) => {
                let def_map = db.crate_def_map(module.krate);
-                let src = match def_map[module.local_id].declaration_source(db) {
+                let mod_data = &def_map[module.local_id];
-                    Some(it) => it,
+                match mod_data.declaration_source(db) {
-                    None => return Attrs::default(),
+                    Some(it) => {
-                };
+                        Attrs::from_attrs_owner(db, it.as_ref().map(|it| it as &dyn AttrsOwner))
-                Attrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn AttrsOwner))
+                    }
+                    None => Attrs::from_attrs_owner(
+                        db,
+                        mod_data.definition_source(db).as_ref().map(|src| match src {
+                            ModuleSource::SourceFile(file) => file as &dyn AttrsOwner,
+                            ModuleSource::Module(module) => module as &dyn AttrsOwner,
+                        }),
+                    ),
+                }
            }
-            AttrDefId::StructFieldId(it) => {
+            AttrDefId::FieldId(it) => {
                let src = it.parent.child_source(db);
                match &src.value[it.local_id] {
                    Either::Left(_tuple) => Attrs::default(),
@@ -106,7 +115,9 @@ pub struct Attr {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum AttrInput {
+    /// `#[attr = "string"]`
    Literal(SmolStr),
+    /// `#[attr(subtree)]`
    TokenTree(Subtree),
 }
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs
index 5b36a7cc1..86f953c80 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -194,7 +194,7 @@ mod tests {
        let (off, code) = extract_offset(code);
        let code = {
            let mut buf = String::new();
-            let off = off.to_usize();
+            let off: usize = off.into();
            buf.push_str(&code[..off]);
            buf.push_str("marker");
            buf.push_str(&code[off..]);
diff --git a/crates/ra_hir_def/src/child_by_source.rs b/crates/ra_hir_def/src/child_by_source.rs
index 7009f21d1..a885ec96d 100644
--- a/crates/ra_hir_def/src/child_by_source.rs
+++ b/crates/ra_hir_def/src/child_by_source.rs
@@ -12,8 +12,8 @@ use crate::{
    item_scope::ItemScope,
    keys,
    src::{HasChildSource, HasSource},
-    AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, ImplId, Lookup, ModuleDefId,
+    AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, FieldId, ImplId, Lookup, ModuleDefId,
-    ModuleId, StructFieldId, TraitId, VariantId,
+    ModuleId, TraitId, VariantId,
 };
 pub trait ChildBySource {
@@ -140,7 +140,7 @@ impl ChildBySource for VariantId {
        let arena_map = self.child_source(db);
        let arena_map = arena_map.as_ref();
        for (local_id, source) in arena_map.value.iter() {
-            let id = StructFieldId { parent: *self, local_id };
+            let id = FieldId { parent: *self, local_id };
            match source {
                Either::Left(source) => {
                    res[keys::TUPLE_FIELD].insert(arena_map.with_value(source.clone()), id)
diff --git a/crates/ra_hir_def/src/docs.rs b/crates/ra_hir_def/src/docs.rs
index 0539a77d4..b221ae1ce 100644
--- a/crates/ra_hir_def/src/docs.rs
+++ b/crates/ra_hir_def/src/docs.rs
@@ -43,7 +43,7 @@ impl Documentation {
                let src = def_map[module.local_id].declaration_source(db)?;
                docs_from_ast(&src.value)
            }
-            AttrDefId::StructFieldId(it) => {
+            AttrDefId::FieldId(it) => {
                let src = it.parent.child_source(db);
                match &src.value[it.local_id] {
                    Either::Left(_tuple) => None,
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index 81eff5bfe..70dcb03e6 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -19,7 +19,7 @@ impl ModPath {
    // When std library is present, paths starting with `std::`
    // should be preferred over paths starting with `core::` and `alloc::`
-    fn should_start_with_std(&self) -> bool {
+    fn can_start_with_std(&self) -> bool {
        self.segments
            .first()
            .filter(|&first_segment| {
@@ -132,6 +132,9 @@ fn find_path_inner(
    }
    // - otherwise, look for modules containing (reexporting) it and import it from one of those
+    let crate_root = ModuleId { local_id: def_map.root, krate: from.krate };
+    let crate_attrs = db.attrs(crate_root.into());
+    let prefer_no_std = crate_attrs.by_key("no_std").exists();
    let importable_locations = find_importable_locations(db, item, from);
    let mut best_path = None;
    let mut best_path_len = max_len;
@@ -147,21 +150,32 @@ fn find_path_inner(
        };
        path.segments.push(name);
-        let new_path =
+        let new_path = if let Some(best_path) = best_path {
-            if let Some(best_path) = best_path { select_best_path(best_path, path) } else { path };
+            select_best_path(best_path, path, prefer_no_std)
+        } else {
+            path
+        };
        best_path_len = new_path.len();
        best_path = Some(new_path);
    }
    best_path
 }
-fn select_best_path(old_path: ModPath, new_path: ModPath) -> ModPath {
+fn select_best_path(old_path: ModPath, new_path: ModPath, prefer_no_std: bool) -> ModPath {
-    if old_path.starts_with_std() && new_path.should_start_with_std() {
+    if old_path.starts_with_std() && new_path.can_start_with_std() {
        tested_by!(prefer_std_paths);
-        old_path
+        if prefer_no_std {
-    } else if new_path.starts_with_std() && old_path.should_start_with_std() {
+            new_path
+        } else {
+            old_path
+        }
+    } else if new_path.starts_with_std() && old_path.can_start_with_std() {
        tested_by!(prefer_std_paths);
-        new_path
+        if prefer_no_std {
+            old_path
+        } else {
+            new_path
+        }
    } else if new_path.len() < old_path.len() {
        new_path
    } else {
@@ -513,6 +527,54 @@ mod tests {
    }
    #[test]
+    fn prefer_alloc_paths_over_std() {
+        covers!(prefer_std_paths);
+        let code = r#"
+        //- /main.rs crate:main deps:alloc,std
+        #![no_std]
+        <|>
+        //- /std.rs crate:std deps:alloc
+        pub mod sync {
+            pub use alloc::sync::Arc;
+        }
+        //- /zzz.rs crate:alloc
+        pub mod sync {
+            pub struct Arc;
+        }
+        "#;
+        check_found_path(code, "alloc::sync::Arc");
+    }
+    #[test]
+    fn prefer_core_paths_over_std() {
+        covers!(prefer_std_paths);
+        let code = r#"
+        //- /main.rs crate:main deps:core,std
+        #![no_std]
+        <|>
+        //- /std.rs crate:std deps:core
+        pub mod fmt {
+            pub use core::fmt::Error;
+        }
+        //- /zzz.rs crate:core
+        pub mod fmt {
+            pub struct Error;
+        }
+        "#;
+        check_found_path(code, "core::fmt::Error");
+    }
+    #[test]
    fn prefer_shorter_paths_if_not_alloc() {
        let code = r#"
        //- /main.rs crate:main deps:megaalloc,std
diff --git a/crates/ra_hir_def/src/keys.rs b/crates/ra_hir_def/src/keys.rs
index 8cd70eb9a..a7349a21d 100644
--- a/crates/ra_hir_def/src/keys.rs
+++ b/crates/ra_hir_def/src/keys.rs
@@ -8,7 +8,7 @@ use rustc_hash::FxHashMap;
 use crate::{
    dyn_map::{DynMap, Policy},
-    ConstId, EnumId, EnumVariantId, FunctionId, ImplId, StaticId, StructFieldId, StructId, TraitId,
+    ConstId, EnumId, EnumVariantId, FieldId, FunctionId, ImplId, StaticId, StructId, TraitId,
    TypeAliasId, TypeParamId, UnionId,
 };
@@ -25,8 +25,8 @@ pub const UNION: Key<ast::UnionDef, UnionId> = Key::new();
 pub const ENUM: Key<ast::EnumDef, EnumId> = Key::new();
 pub const ENUM_VARIANT: Key<ast::EnumVariant, EnumVariantId> = Key::new();
-pub const TUPLE_FIELD: Key<ast::TupleFieldDef, StructFieldId> = Key::new();
+pub const TUPLE_FIELD: Key<ast::TupleFieldDef, FieldId> = Key::new();
-pub const RECORD_FIELD: Key<ast::RecordFieldDef, StructFieldId> = Key::new();
+pub const RECORD_FIELD: Key<ast::RecordFieldDef, FieldId> = Key::new();
 pub const TYPE_PARAM: Key<ast::TypeParam, TypeParamId> = Key::new();
 pub const MACRO: Key<ast::MacroCall, MacroDefId> = Key::new();
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index 2d27bbdf8..518772e8a 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -133,12 +133,12 @@ pub struct EnumVariantId {
 pub type LocalEnumVariantId = Idx<adt::EnumVariantData>;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct StructFieldId {
+pub struct FieldId {
    pub parent: VariantId,
-    pub local_id: LocalStructFieldId,
+    pub local_id: LocalFieldId,
 }
-pub type LocalStructFieldId = Idx<adt::StructFieldData>;
+pub type LocalFieldId = Idx<adt::FieldData>;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ConstId(salsa::InternId);
@@ -299,7 +299,7 @@ impl From<AssocItemId> for GenericDefId {
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum AttrDefId {
    ModuleId(ModuleId),
-    StructFieldId(StructFieldId),
+    FieldId(FieldId),
    AdtId(AdtId),
    FunctionId(FunctionId),
    EnumVariantId(EnumVariantId),
@@ -313,7 +313,7 @@ pub enum AttrDefId {
 impl_froms!(
    AttrDefId: ModuleId,
-    StructFieldId,
+    FieldId,
    AdtId(StructId, EnumId, UnionId),
    EnumVariantId,
    StaticId,
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index 3da137f2e..e0fef613d 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -2,7 +2,7 @@
 use crate::db::AstDatabase;
 use crate::{
    ast::{self, AstToken, HasStringValue},
-    name, AstId, CrateId, MacroDefId, MacroDefKind, TextUnit,
+    name, AstId, CrateId, MacroDefId, MacroDefKind, TextSize,
 };
 use crate::{quote, EagerMacroId, LazyMacroId, MacroCallId};
@@ -127,7 +127,7 @@ fn stringify_expand(
        let arg = loc.kind.arg(db).ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
        let macro_args = arg;
        let text = macro_args.text();
-        let without_parens = TextUnit::of_char('(')..text.len() - TextUnit::of_char(')');
+        let without_parens = TextSize::of('(')..text.len() - TextSize::of(')');
        text.slice(without_parens).to_string()
    };
@@ -358,7 +358,7 @@ fn env_expand(
    // However, we cannot use an empty string here, because for
    // `include!(concat!(env!("OUT_DIR"), "/foo.rs"))` will become
    // `include!("foo.rs"), which might go to infinite loop
-    let s = get_env_inner(db, arg_id, &key).unwrap_or("__RA_UNIMPLEMENTATED__".to_string());
+    let s = get_env_inner(db, arg_id, &key).unwrap_or_else(|| "__RA_UNIMPLEMENTATED__".to_string());
    let expanded = quote! { #s };
    Ok((expanded, FragmentKind::Expr))
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 86299459f..754a0f005 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -22,7 +22,7 @@ use ra_db::{impl_intern_key, salsa, CrateId, FileId};
 use ra_syntax::{
    algo,
    ast::{self, AstNode},
-    SyntaxNode, SyntaxToken, TextUnit,
+    SyntaxNode, SyntaxToken, TextSize,
 };
 use crate::ast_id_map::FileAstId;
@@ -348,7 +348,7 @@ impl<N: AstNode> AstId<N> {
 ///
 /// * `InFile<SyntaxNode>` -- syntax node in a file
 /// * `InFile<ast::FnDef>` -- ast node in a file
-/// * `InFile<TextUnit>` -- offset in a file
+/// * `InFile<TextSize>` -- offset in a file
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct InFile<T> {
    pub file_id: HirFileId,
diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs
index 9e5dfeab3..fdb49560b 100644
--- a/crates/ra_hir_ty/src/db.rs
+++ b/crates/ra_hir_ty/src/db.rs
@@ -3,7 +3,7 @@
 use std::sync::Arc;
 use hir_def::{
-    db::DefDatabase, DefWithBodyId, GenericDefId, ImplId, LocalStructFieldId, TraitId, TypeParamId,
+    db::DefDatabase, DefWithBodyId, GenericDefId, ImplId, LocalFieldId, TraitId, TypeParamId,
    VariantId,
 };
 use ra_arena::map::ArenaMap;
@@ -43,7 +43,7 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
    fn impl_trait(&self, def: ImplId) -> Option<Binders<TraitRef>>;
    #[salsa::invoke(crate::lower::field_types_query)]
-    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalStructFieldId, Binders<Ty>>>;
+    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>>;
    #[salsa::invoke(crate::callable_item_sig)]
    fn callable_item_signature(&self, def: CallableDef) -> PolyFnSig;
diff --git a/crates/ra_hir_ty/src/expr.rs b/crates/ra_hir_ty/src/expr.rs
index fd59f4320..f04968e14 100644
--- a/crates/ra_hir_ty/src/expr.rs
+++ b/crates/ra_hir_ty/src/expr.rs
@@ -24,7 +24,7 @@ pub use hir_def::{
        ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp,
        MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, UnaryOp,
    },
-    LocalStructFieldId, VariantId,
+    LocalFieldId, VariantId,
 };
 pub struct ExprValidator<'a, 'b: 'a> {
@@ -83,7 +83,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        id: ExprId,
        db: &dyn HirDatabase,
        variant_def: VariantId,
-        missed_fields: Vec<LocalStructFieldId>,
+        missed_fields: Vec<LocalFieldId>,
    ) {
        // XXX: only look at source_map if we do have missing fields
        let (_, source_map) = db.body_with_source_map(self.func.into());
@@ -112,7 +112,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        id: PatId,
        db: &dyn HirDatabase,
        variant_def: VariantId,
-        missed_fields: Vec<LocalStructFieldId>,
+        missed_fields: Vec<LocalFieldId>,
    ) {
        // XXX: only look at source_map if we do have missing fields
        let (_, source_map) = db.body_with_source_map(self.func.into());
@@ -256,7 +256,7 @@ pub fn record_literal_missing_fields(
    infer: &InferenceResult,
    id: ExprId,
    expr: &Expr,
-) -> Option<(VariantId, Vec<LocalStructFieldId>, /*exhaustive*/ bool)> {
+) -> Option<(VariantId, Vec<LocalFieldId>, /*exhaustive*/ bool)> {
    let (fields, exhausitve) = match expr {
        Expr::RecordLit { path: _, fields, spread } => (fields, spread.is_none()),
        _ => return None,
@@ -270,7 +270,7 @@ pub fn record_literal_missing_fields(
    let variant_data = variant_data(db.upcast(), variant_def);
    let specified_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect();
-    let missed_fields: Vec<LocalStructFieldId> = variant_data
+    let missed_fields: Vec<LocalFieldId> = variant_data
        .fields()
        .iter()
        .filter_map(|(f, d)| if specified_fields.contains(&d.name) { None } else { Some(f) })
@@ -286,7 +286,7 @@ pub fn record_pattern_missing_fields(
    infer: &InferenceResult,
    id: PatId,
    pat: &Pat,
-) -> Option<(VariantId, Vec<LocalStructFieldId>, /*exhaustive*/ bool)> {
+) -> Option<(VariantId, Vec<LocalFieldId>, /*exhaustive*/ bool)> {
    let (fields, exhaustive) = match pat {
        Pat::Record { path: _, args, ellipsis } => (args, !ellipsis),
        _ => return None,
@@ -300,7 +300,7 @@ pub fn record_pattern_missing_fields(
    let variant_data = variant_data(db.upcast(), variant_def);
    let specified_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect();
-    let missed_fields: Vec<LocalStructFieldId> = variant_data
+    let missed_fields: Vec<LocalFieldId> = variant_data
        .fields()
        .iter()
        .filter_map(|(f, d)| if specified_fields.contains(&d.name) { None } else { Some(f) })
diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs
index dfb6a435f..6a53be621 100644
--- a/crates/ra_hir_ty/src/infer.rs
+++ b/crates/ra_hir_ty/src/infer.rs
@@ -28,7 +28,7 @@ use hir_def::{
    path::{path, Path},
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{Mutability, TypeRef},
-    AdtId, AssocItemId, DefWithBodyId, FunctionId, StructFieldId, TraitId, TypeAliasId, VariantId,
+    AdtId, AssocItemId, DefWithBodyId, FieldId, FunctionId, TraitId, TypeAliasId, VariantId,
 };
 use hir_expand::{diagnostics::DiagnosticSink, name::name};
 use ra_arena::map::ArenaMap;
@@ -124,10 +124,10 @@ pub struct InferenceResult {
    /// For each method call expr, records the function it resolves to.
    method_resolutions: FxHashMap<ExprId, FunctionId>,
    /// For each field access expr, records the field it resolves to.
-    field_resolutions: FxHashMap<ExprId, StructFieldId>,
+    field_resolutions: FxHashMap<ExprId, FieldId>,
    /// For each field in record literal, records the field it resolves to.
-    record_field_resolutions: FxHashMap<ExprId, StructFieldId>,
+    record_field_resolutions: FxHashMap<ExprId, FieldId>,
-    record_field_pat_resolutions: FxHashMap<PatId, StructFieldId>,
+    record_field_pat_resolutions: FxHashMap<PatId, FieldId>,
    /// For each struct literal, records the variant it resolves to.
    variant_resolutions: FxHashMap<ExprOrPatId, VariantId>,
    /// For each associated item record what it resolves to
@@ -142,13 +142,13 @@ impl InferenceResult {
    pub fn method_resolution(&self, expr: ExprId) -> Option<FunctionId> {
        self.method_resolutions.get(&expr).copied()
    }
-    pub fn field_resolution(&self, expr: ExprId) -> Option<StructFieldId> {
+    pub fn field_resolution(&self, expr: ExprId) -> Option<FieldId> {
        self.field_resolutions.get(&expr).copied()
    }
-    pub fn record_field_resolution(&self, expr: ExprId) -> Option<StructFieldId> {
+    pub fn record_field_resolution(&self, expr: ExprId) -> Option<FieldId> {
        self.record_field_resolutions.get(&expr).copied()
    }
-    pub fn record_field_pat_resolution(&self, pat: PatId) -> Option<StructFieldId> {
+    pub fn record_field_pat_resolution(&self, pat: PatId) -> Option<FieldId> {
        self.record_field_pat_resolutions.get(&pat).copied()
    }
    pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantId> {
@@ -249,7 +249,7 @@ impl<'a> InferenceContext<'a> {
        self.result.method_resolutions.insert(expr, func);
    }
-    fn write_field_resolution(&mut self, expr: ExprId, field: StructFieldId) {
+    fn write_field_resolution(&mut self, expr: ExprId, field: FieldId) {
        self.result.field_resolutions.insert(expr, field);
    }
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 1fdb235a0..83f946eee 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -8,7 +8,7 @@ use hir_def::{
    expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
    path::{GenericArg, GenericArgs},
    resolver::resolver_for_expr,
-    AdtId, AssocContainerId, Lookup, StructFieldId,
+    AdtId, AssocContainerId, FieldId, Lookup,
 };
 use hir_expand::name::Name;
 use ra_syntax::ast::RangeOp;
@@ -216,9 +216,7 @@ impl<'a> InferenceContext<'a> {
                for (field_idx, field) in fields.iter().enumerate() {
                    let field_def =
                        variant_data.as_ref().and_then(|it| match it.field(&field.name) {
-                            Some(local_id) => {
+                            Some(local_id) => Some(FieldId { parent: def_id.unwrap(), local_id }),
-                                Some(StructFieldId { parent: def_id.unwrap(), local_id })
-                            }
                            None => {
                                self.push_diagnostic(InferenceDiagnostic::NoSuchField {
                                    expr: tgt_expr,
@@ -257,7 +255,7 @@ impl<'a> InferenceContext<'a> {
                            .and_then(|idx| a_ty.parameters.0.get(idx).cloned()),
                        TypeCtor::Adt(AdtId::StructId(s)) => {
                            self.db.struct_data(s).variant_data.field(name).map(|local_id| {
-                                let field = StructFieldId { parent: s.into(), local_id };
+                                let field = FieldId { parent: s.into(), local_id };
                                self.write_field_resolution(tgt_expr, field);
                                self.db.field_types(s.into())[field.local_id]
                                    .clone()
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index 7c2ad4384..54ec870df 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -7,7 +7,7 @@ use hir_def::{
    expr::{BindingAnnotation, Pat, PatId, RecordFieldPat},
    path::Path,
    type_ref::Mutability,
-    StructFieldId,
+    FieldId,
 };
 use hir_expand::name::Name;
 use test_utils::tested_by;
@@ -69,7 +69,7 @@ impl<'a> InferenceContext<'a> {
        for subpat in subpats {
            let matching_field = var_data.as_ref().and_then(|it| it.field(&subpat.name));
            if let Some(local_id) = matching_field {
-                let field_def = StructFieldId { parent: def.unwrap(), local_id };
+                let field_def = FieldId { parent: def.unwrap(), local_id };
                self.result.record_field_pat_resolutions.insert(subpat.pat, field_def);
            }
diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs
index c2812e178..b57214296 100644
--- a/crates/ra_hir_ty/src/lower.rs
+++ b/crates/ra_hir_ty/src/lower.rs
@@ -18,8 +18,8 @@ use hir_def::{
    resolver::{HasResolver, Resolver, TypeNs},
    type_ref::{TypeBound, TypeRef},
    AdtId, AssocContainerId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, HasModule,
-    ImplId, LocalStructFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId, TypeParamId,
+    ImplId, LocalFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
-    UnionId, VariantId,
+    VariantId,
 };
 use ra_arena::map::ArenaMap;
 use ra_db::CrateId;
@@ -682,7 +682,7 @@ pub fn callable_item_sig(db: &dyn HirDatabase, def: CallableDef) -> PolyFnSig {
 pub(crate) fn field_types_query(
    db: &dyn HirDatabase,
    variant_id: VariantId,
-) -> Arc<ArenaMap<LocalStructFieldId, Binders<Ty>>> {
+) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>> {
    let var_data = variant_data(db.upcast(), variant_id);
    let (resolver, def): (_, GenericDefId) = match variant_id {
        VariantId::StructId(it) => (it.resolver(db.upcast()), it.into()),
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 846005baa..b6a96bb5c 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -117,7 +117,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
            let macro_prefix = if node.file_id != file_id.into() { "!" } else { "" };
            format_to!(
                buf,
-                "{}{} '{}': {}\n",
+                "{}{:?} '{}': {}\n",
                macro_prefix,
                range,
                ellipsize(text, 15),
@@ -134,7 +134,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String {
                let macro_prefix = if src_ptr.file_id != file_id.into() { "!" } else { "" };
                format_to!(
                    buf,
-                    "{}{}: expected {}, got {}\n",
+                    "{}{:?}: expected {}, got {}\n",
                    macro_prefix,
                    range,
                    mismatch.expected.display(&db),
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index b2c971f02..e6fb3e123 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -29,10 +29,10 @@ fn test() {
 }
 "#),
        @r###"
-    [11; 41) '{     ...4 }; }': ()
+    11..41 '{     ...4 }; }': ()
-    [21; 22) 'a': i32
+    21..22 'a': i32
-    [30; 38) '{ 1i64 }': i64
+    30..38 '{ 1i64 }': i64
-    [32; 36) '1i64': i64
+    32..36 '1i64': i64
    "###);
 }
@@ -63,50 +63,50 @@ fn test2() {
 }
 "#),
        @r###"
-    [31; 32) '_': &[T]
+    31..32 '_': &[T]
-    [45; 56) '{ loop {} }': T
+    45..56 '{ loop {} }': T
-    [47; 54) 'loop {}': !
+    47..54 'loop {}': !
-    [52; 54) '{}': ()
+    52..54 '{}': ()
-    [65; 66) '_': S<&[T]>
+    65..66 '_': S<&[T]>
-    [82; 93) '{ loop {} }': T
+    82..93 '{ loop {} }': T
-    [84; 91) 'loop {}': !
+    84..91 'loop {}': !
-    [89; 91) '{}': ()
+    89..91 '{}': ()
-    [122; 133) '{ loop {} }': *mut [T; _]
+    122..133 '{ loop {} }': *mut [T; _]
-    [124; 131) 'loop {}': !
+    124..131 'loop {}': !
-    [129; 131) '{}': ()
+    129..131 '{}': ()
-    [160; 173) '{     gen() }': *mut [U]
+    160..173 '{     gen() }': *mut [U]
-    [166; 169) 'gen': fn gen<U>() -> *mut [U; _]
+    166..169 'gen': fn gen<U>() -> *mut [U; _]
-    [166; 171) 'gen()': *mut [U; _]
+    166..171 'gen()': *mut [U; _]
-    [186; 420) '{     ...rr); }': ()
+    186..420 '{     ...rr); }': ()
-    [196; 199) 'arr': &[u8; _]
+    196..199 'arr': &[u8; _]
-    [212; 216) '&[1]': &[u8; _]
+    212..216 '&[1]': &[u8; _]
-    [213; 216) '[1]': [u8; _]
+    213..216 '[1]': [u8; _]
-    [214; 215) '1': u8
+    214..215 '1': u8
-    [227; 228) 'a': &[u8]
+    227..228 'a': &[u8]
-    [237; 240) 'arr': &[u8; _]
+    237..240 'arr': &[u8; _]
-    [250; 251) 'b': u8
+    250..251 'b': u8
-    [254; 255) 'f': fn f<u8>(&[u8]) -> u8
+    254..255 'f': fn f<u8>(&[u8]) -> u8
-    [254; 260) 'f(arr)': u8
+    254..260 'f(arr)': u8
-    [256; 259) 'arr': &[u8; _]
+    256..259 'arr': &[u8; _]
-    [270; 271) 'c': &[u8]
+    270..271 'c': &[u8]
-    [280; 287) '{ arr }': &[u8]
+    280..287 '{ arr }': &[u8]
-    [282; 285) 'arr': &[u8; _]
+    282..285 'arr': &[u8; _]
-    [297; 298) 'd': u8
+    297..298 'd': u8
-    [301; 302) 'g': fn g<u8>(S<&[u8]>) -> u8
+    301..302 'g': fn g<u8>(S<&[u8]>) -> u8
-    [301; 316) 'g(S { a: arr })': u8
+    301..316 'g(S { a: arr })': u8
-    [303; 315) 'S { a: arr }': S<&[u8]>
+    303..315 'S { a: arr }': S<&[u8]>
-    [310; 313) 'arr': &[u8; _]
+    310..313 'arr': &[u8; _]
-    [326; 327) 'e': [&[u8]; _]
+    326..327 'e': [&[u8]; _]
-    [341; 346) '[arr]': [&[u8]; _]
+    341..346 '[arr]': [&[u8]; _]
-    [342; 345) 'arr': &[u8; _]
+    342..345 'arr': &[u8; _]
-    [356; 357) 'f': [&[u8]; _]
+    356..357 'f': [&[u8]; _]
-    [371; 379) '[arr; 2]': [&[u8]; _]
+    371..379 '[arr; 2]': [&[u8]; _]
-    [372; 375) 'arr': &[u8; _]
+    372..375 'arr': &[u8; _]
-    [377; 378) '2': usize
+    377..378 '2': usize
-    [389; 390) 'g': (&[u8], &[u8])
+    389..390 'g': (&[u8], &[u8])
-    [407; 417) '(arr, arr)': (&[u8], &[u8])
+    407..417 '(arr, arr)': (&[u8], &[u8])
-    [408; 411) 'arr': &[u8; _]
+    408..411 'arr': &[u8; _]
-    [413; 416) 'arr': &[u8; _]
+    413..416 'arr': &[u8; _]
    "###
    );
 }
@@ -120,11 +120,11 @@ fn test() {
 }
 "#),
        @r###"
-    [11; 40) '{     ...[1]; }': ()
+    11..40 '{     ...[1]; }': ()
-    [21; 22) 'x': &[i32]
+    21..22 'x': &[i32]
-    [33; 37) '&[1]': &[i32; _]
+    33..37 '&[1]': &[i32; _]
-    [34; 37) '[1]': [i32; _]
+    34..37 '[1]': [i32; _]
-    [35; 36) '1': i32
+    35..36 '1': i32
    "###);
 }
@@ -150,31 +150,31 @@ fn test(a: A<[u8; 2]>, b: B<[u8; 2]>, c: C<[u8; 2]>) {
 }
 "#),
        @r###"
-    [258; 259) 'x': A<[T]>
+    258..259 'x': A<[T]>
-    [279; 284) '{ x }': A<[T]>
+    279..284 '{ x }': A<[T]>
-    [281; 282) 'x': A<[T]>
+    281..282 'x': A<[T]>
-    [296; 297) 'x': B<[T]>
+    296..297 'x': B<[T]>
-    [317; 322) '{ x }': B<[T]>
+    317..322 '{ x }': B<[T]>
-    [319; 320) 'x': B<[T]>
+    319..320 'x': B<[T]>
-    [334; 335) 'x': C<[T]>
+    334..335 'x': C<[T]>
-    [355; 360) '{ x }': C<[T]>
+    355..360 '{ x }': C<[T]>
-    [357; 358) 'x': C<[T]>
+    357..358 'x': C<[T]>
-    [370; 371) 'a': A<[u8; _]>
+    370..371 'a': A<[u8; _]>
-    [385; 386) 'b': B<[u8; _]>
+    385..386 'b': B<[u8; _]>
-    [400; 401) 'c': C<[u8; _]>
+    400..401 'c': C<[u8; _]>
-    [415; 481) '{     ...(c); }': ()
+    415..481 '{     ...(c); }': ()
-    [425; 426) 'd': A<[{unknown}]>
+    425..426 'd': A<[{unknown}]>
-    [429; 433) 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
+    429..433 'foo1': fn foo1<{unknown}>(A<[{unknown}]>) -> A<[{unknown}]>
-    [429; 436) 'foo1(a)': A<[{unknown}]>
+    429..436 'foo1(a)': A<[{unknown}]>
-    [434; 435) 'a': A<[u8; _]>
+    434..435 'a': A<[u8; _]>
-    [446; 447) 'e': B<[u8]>
+    446..447 'e': B<[u8]>
-    [450; 454) 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
+    450..454 'foo2': fn foo2<u8>(B<[u8]>) -> B<[u8]>
-    [450; 457) 'foo2(b)': B<[u8]>
+    450..457 'foo2(b)': B<[u8]>
-    [455; 456) 'b': B<[u8; _]>
+    455..456 'b': B<[u8; _]>
-    [467; 468) 'f': C<[u8]>
+    467..468 'f': C<[u8]>
-    [471; 475) 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
+    471..475 'foo3': fn foo3<u8>(C<[u8]>) -> C<[u8]>
-    [471; 478) 'foo3(c)': C<[u8]>
+    471..478 'foo3(c)': C<[u8]>
-    [476; 477) 'c': C<[u8; _]>
+    476..477 'c': C<[u8; _]>
    "###
    );
 }
@@ -193,24 +193,24 @@ fn test() {
 }
 "#),
        @r###"
-    [11; 12) 'x': &[T]
+    11..12 'x': &[T]
-    [28; 39) '{ loop {} }': &[T]
+    28..39 '{ loop {} }': &[T]
-    [30; 37) 'loop {}': !
+    30..37 'loop {}': !
-    [35; 37) '{}': ()
+    35..37 '{}': ()
-    [50; 126) '{     ...  }; }': ()
+    50..126 '{     ...  }; }': ()
-    [60; 61) 'x': &[i32]
+    60..61 'x': &[i32]
-    [64; 123) 'if tru...     }': &[i32]
+    64..123 'if tru...     }': &[i32]
-    [67; 71) 'true': bool
+    67..71 'true': bool
-    [72; 97) '{     ...     }': &[i32]
+    72..97 '{     ...     }': &[i32]
-    [82; 85) 'foo': fn foo<i32>(&[i32]) -> &[i32]
+    82..85 'foo': fn foo<i32>(&[i32]) -> &[i32]
-    [82; 91) 'foo(&[1])': &[i32]
+    82..91 'foo(&[1])': &[i32]
-    [86; 90) '&[1]': &[i32; _]
+    86..90 '&[1]': &[i32; _]
-    [87; 90) '[1]': [i32; _]
+    87..90 '[1]': [i32; _]
-    [88; 89) '1': i32
+    88..89 '1': i32
-    [103; 123) '{     ...     }': &[i32; _]
+    103..123 '{     ...     }': &[i32; _]
-    [113; 117) '&[1]': &[i32; _]
+    113..117 '&[1]': &[i32; _]
-    [114; 117) '[1]': [i32; _]
+    114..117 '[1]': [i32; _]
-    [115; 116) '1': i32
+    115..116 '1': i32
    "###
    );
 }
@@ -229,24 +229,24 @@ fn test() {
 }
 "#),
        @r###"
-    [11; 12) 'x': &[T]
+    11..12 'x': &[T]
-    [28; 39) '{ loop {} }': &[T]
+    28..39 '{ loop {} }': &[T]
-    [30; 37) 'loop {}': !
+    30..37 'loop {}': !
-    [35; 37) '{}': ()
+    35..37 '{}': ()
-    [50; 126) '{     ...  }; }': ()
+    50..126 '{     ...  }; }': ()
-    [60; 61) 'x': &[i32]
+    60..61 'x': &[i32]
-    [64; 123) 'if tru...     }': &[i32]
+    64..123 'if tru...     }': &[i32]
-    [67; 71) 'true': bool
+    67..71 'true': bool
-    [72; 92) '{     ...     }': &[i32; _]
+    72..92 '{     ...     }': &[i32; _]
-    [82; 86) '&[1]': &[i32; _]
+    82..86 '&[1]': &[i32; _]
-    [83; 86) '[1]': [i32; _]
+    83..86 '[1]': [i32; _]
-    [84; 85) '1': i32
+    84..85 '1': i32
-    [98; 123) '{     ...     }': &[i32]
+    98..123 '{     ...     }': &[i32]
-    [108; 111) 'foo': fn foo<i32>(&[i32]) -> &[i32]
+    108..111 'foo': fn foo<i32>(&[i32]) -> &[i32]
-    [108; 117) 'foo(&[1])': &[i32]
+    108..117 'foo(&[1])': &[i32]
-    [112; 116) '&[1]': &[i32; _]
+    112..116 '&[1]': &[i32; _]
-    [113; 116) '[1]': [i32; _]
+    113..116 '[1]': [i32; _]
-    [114; 115) '1': i32
+    114..115 '1': i32
    "###
    );
 }
@@ -265,31 +265,31 @@ fn test(i: i32) {
 }
 "#),
        @r###"
-    [11; 12) 'x': &[T]
+    11..12 'x': &[T]
-    [28; 39) '{ loop {} }': &[T]
+    28..39 '{ loop {} }': &[T]
-    [30; 37) 'loop {}': !
+    30..37 'loop {}': !
-    [35; 37) '{}': ()
+    35..37 '{}': ()
-    [48; 49) 'i': i32
+    48..49 'i': i32
-    [56; 150) '{     ...  }; }': ()
+    56..150 '{     ...  }; }': ()
-    [66; 67) 'x': &[i32]
+    66..67 'x': &[i32]
-    [70; 147) 'match ...     }': &[i32]
+    70..147 'match ...     }': &[i32]
-    [76; 77) 'i': i32
+    76..77 'i': i32
-    [88; 89) '2': i32
+    88..89 '2': i32
-    [88; 89) '2': i32
+    88..89 '2': i32
-    [93; 96) 'foo': fn foo<i32>(&[i32]) -> &[i32]
+    93..96 'foo': fn foo<i32>(&[i32]) -> &[i32]
-    [93; 102) 'foo(&[2])': &[i32]
+    93..102 'foo(&[2])': &[i32]
-    [97; 101) '&[2]': &[i32; _]
+    97..101 '&[2]': &[i32; _]
-    [98; 101) '[2]': [i32; _]
+    98..101 '[2]': [i32; _]
-    [99; 100) '2': i32
+    99..100 '2': i32
-    [112; 113) '1': i32
+    112..113 '1': i32
-    [112; 113) '1': i32
+    112..113 '1': i32
-    [117; 121) '&[1]': &[i32; _]
+    117..121 '&[1]': &[i32; _]
-    [118; 121) '[1]': [i32; _]
+    118..121 '[1]': [i32; _]
-    [119; 120) '1': i32
+    119..120 '1': i32
-    [131; 132) '_': i32
+    131..132 '_': i32
-    [136; 140) '&[3]': &[i32; _]
+    136..140 '&[3]': &[i32; _]
-    [137; 140) '[3]': [i32; _]
+    137..140 '[3]': [i32; _]
-    [138; 139) '3': i32
+    138..139 '3': i32
    "###
    );
 }
@@ -308,31 +308,31 @@ fn test(i: i32) {
 }
 "#),
        @r###"
-    [11; 12) 'x': &[T]
+    11..12 'x': &[T]
-    [28; 39) '{ loop {} }': &[T]
+    28..39 '{ loop {} }': &[T]
-    [30; 37) 'loop {}': !
+    30..37 'loop {}': !
-    [35; 37) '{}': ()
+    35..37 '{}': ()
-    [48; 49) 'i': i32
+    48..49 'i': i32
-    [56; 150) '{     ...  }; }': ()
+    56..150 '{     ...  }; }': ()
-    [66; 67) 'x': &[i32]
+    66..67 'x': &[i32]
-    [70; 147) 'match ...     }': &[i32]
+    70..147 'match ...     }': &[i32]
-    [76; 77) 'i': i32
+    76..77 'i': i32
-    [88; 89) '1': i32
+    88..89 '1': i32
-    [88; 89) '1': i32
+    88..89 '1': i32
-    [93; 97) '&[1]': &[i32; _]
+    93..97 '&[1]': &[i32; _]
-    [94; 97) '[1]': [i32; _]
+    94..97 '[1]': [i32; _]
-    [95; 96) '1': i32
+    95..96 '1': i32
-    [107; 108) '2': i32
+    107..108 '2': i32
-    [107; 108) '2': i32
+    107..108 '2': i32
-    [112; 115) 'foo': fn foo<i32>(&[i32]) -> &[i32]
+    112..115 'foo': fn foo<i32>(&[i32]) -> &[i32]
-    [112; 121) 'foo(&[2])': &[i32]
+    112..121 'foo(&[2])': &[i32]
-    [116; 120) '&[2]': &[i32; _]
+    116..120 '&[2]': &[i32; _]
-    [117; 120) '[2]': [i32; _]
+    117..120 '[2]': [i32; _]
-    [118; 119) '2': i32
+    118..119 '2': i32
-    [131; 132) '_': i32
+    131..132 '_': i32
-    [136; 140) '&[3]': &[i32; _]
+    136..140 '&[3]': &[i32; _]
-    [137; 140) '[3]': [i32; _]
+    137..140 '[3]': [i32; _]
-    [138; 139) '3': i32
+    138..139 '3': i32
    "###
    );
 }
@@ -353,24 +353,24 @@ fn test() {
 }
 "#),
        @r###"
-    [11; 145) '{     ...  }; }': ()
+    11..145 '{     ...  }; }': ()
-    [21; 22) 't': &mut i32
+    21..22 't': &mut i32
-    [25; 31) '&mut 1': &mut i32
+    25..31 '&mut 1': &mut i32
-    [30; 31) '1': i32
+    30..31 '1': i32
-    [41; 42) 'x': *const i32
+    41..42 'x': *const i32
-    [45; 142) 'match ...     }': *const i32
+    45..142 'match ...     }': *const i32
-    [51; 52) '1': i32
+    51..52 '1': i32
-    [63; 64) '1': i32
+    63..64 '1': i32
-    [63; 64) '1': i32
+    63..64 '1': i32
-    [68; 69) 't': &mut i32
+    68..69 't': &mut i32
-    [68; 81) 't as *mut i32': *mut i32
+    68..81 't as *mut i32': *mut i32
-    [91; 92) '2': i32
+    91..92 '2': i32
-    [91; 92) '2': i32
+    91..92 '2': i32
-    [96; 97) 't': &mut i32
+    96..97 't': &mut i32
-    [96; 105) 't as &i32': &i32
+    96..105 't as &i32': &i32
-    [115; 116) '_': i32
+    115..116 '_': i32
-    [120; 121) 't': &mut i32
+    120..121 't': &mut i32
-    [120; 135) 't as *const i32': *const i32
+    120..135 't as *const i32': *const i32
    "###
    );
 }
@@ -384,9 +384,9 @@ fn foo() -> u32 {
 }
 "#, true),
        @r###"
-    [17; 40) '{     ...own; }': !
+    17..40 '{     ...own; }': !
-    [23; 37) 'return unknown': !
+    23..37 'return unknown': !
-    [30; 37) 'unknown': u32
+    30..37 'unknown': u32
    "###
    );
 }
@@ -404,24 +404,24 @@ fn test() {
 }
 "#, true),
        @r###"
-    [30; 31) 'x': &Foo
+    30..31 'x': &Foo
-    [39; 41) '{}': ()
+    39..41 '{}': ()
-    [52; 133) '{     ...oo); }': ()
+    52..133 '{     ...oo); }': ()
-    [58; 71) 'takes_ref_foo': fn takes_ref_foo(&Foo)
+    58..71 'takes_ref_foo': fn takes_ref_foo(&Foo)
-    [58; 77) 'takes_...(&Foo)': ()
+    58..77 'takes_...(&Foo)': ()
-    [72; 76) '&Foo': &Foo
+    72..76 '&Foo': &Foo
-    [73; 76) 'Foo': Foo
+    73..76 'Foo': Foo
-    [83; 96) 'takes_ref_foo': fn takes_ref_foo(&Foo)
+    83..96 'takes_ref_foo': fn takes_ref_foo(&Foo)
-    [83; 103) 'takes_...&&Foo)': ()
+    83..103 'takes_...&&Foo)': ()
-    [97; 102) '&&Foo': &&Foo
+    97..102 '&&Foo': &&Foo
-    [98; 102) '&Foo': &Foo
+    98..102 '&Foo': &Foo
-    [99; 102) 'Foo': Foo
+    99..102 'Foo': Foo
-    [109; 122) 'takes_ref_foo': fn takes_ref_foo(&Foo)
+    109..122 'takes_ref_foo': fn takes_ref_foo(&Foo)
-    [109; 130) 'takes_...&&Foo)': ()
+    109..130 'takes_...&&Foo)': ()
-    [123; 129) '&&&Foo': &&&Foo
+    123..129 '&&&Foo': &&&Foo
-    [124; 129) '&&Foo': &&Foo
+    124..129 '&&Foo': &&Foo
-    [125; 129) '&Foo': &Foo
+    125..129 '&Foo': &Foo
-    [126; 129) 'Foo': Foo
+    126..129 'Foo': Foo
    "###
    );
 }
@@ -439,26 +439,26 @@ fn test() {
 }
 "#, true),
        @r###"
-    [29; 30) 'x': &T
+    29..30 'x': &T
-    [41; 47) '{ *x }': T
+    41..47 '{ *x }': T
-    [43; 45) '*x': T
+    43..45 '*x': T
-    [44; 45) 'x': &T
+    44..45 'x': &T
-    [58; 127) '{     ...oo); }': ()
+    58..127 '{     ...oo); }': ()
-    [64; 73) 'takes_ref': fn takes_ref<Foo>(&Foo) -> Foo
+    64..73 'takes_ref': fn takes_ref<Foo>(&Foo) -> Foo
-    [64; 79) 'takes_ref(&Foo)': Foo
+    64..79 'takes_ref(&Foo)': Foo
-    [74; 78) '&Foo': &Foo
+    74..78 '&Foo': &Foo
-    [75; 78) 'Foo': Foo
+    75..78 'Foo': Foo
-    [85; 94) 'takes_ref': fn takes_ref<&Foo>(&&Foo) -> &Foo
+    85..94 'takes_ref': fn takes_ref<&Foo>(&&Foo) -> &Foo
-    [85; 101) 'takes_...&&Foo)': &Foo
+    85..101 'takes_...&&Foo)': &Foo
-    [95; 100) '&&Foo': &&Foo
+    95..100 '&&Foo': &&Foo
-    [96; 100) '&Foo': &Foo
+    96..100 '&Foo': &Foo
-    [97; 100) 'Foo': Foo
+    97..100 'Foo': Foo
-    [107; 116) 'takes_ref': fn takes_ref<&&Foo>(&&&Foo) -> &&Foo
+    107..116 'takes_ref': fn takes_ref<&&Foo>(&&&Foo) -> &&Foo
-    [107; 124) 'takes_...&&Foo)': &&Foo
+    107..124 'takes_...&&Foo)': &&Foo
-    [117; 123) '&&&Foo': &&&Foo
+    117..123 '&&&Foo': &&&Foo
-    [118; 123) '&&Foo': &&Foo
+    118..123 '&&Foo': &&Foo
-    [119; 123) '&Foo': &Foo
+    119..123 '&Foo': &Foo
-    [120; 123) 'Foo': Foo
+    120..123 'Foo': Foo
    "###
    );
 }
@@ -478,18 +478,18 @@ fn test() {
 }
 "#, true),
        @r###"
-    [127; 128) 'x': &str
+    127..128 'x': &str
-    [136; 138) '{}': ()
+    136..138 '{}': ()
-    [169; 180) '{ loop {} }': String
+    169..180 '{ loop {} }': String
-    [171; 178) 'loop {}': !
+    171..178 'loop {}': !
-    [176; 178) '{}': ()
+    176..178 '{}': ()
-    [191; 236) '{     ... }); }': ()
+    191..236 '{     ... }); }': ()
-    [197; 210) 'takes_ref_str': fn takes_ref_str(&str)
+    197..210 'takes_ref_str': fn takes_ref_str(&str)
-    [197; 233) 'takes_...g() })': ()
+    197..233 'takes_...g() })': ()
-    [211; 232) '&{ ret...ng() }': &String
+    211..232 '&{ ret...ng() }': &String
-    [212; 232) '{ retu...ng() }': String
+    212..232 '{ retu...ng() }': String
-    [214; 228) 'returns_string': fn returns_string() -> String
+    214..228 'returns_string': fn returns_string() -> String
-    [214; 230) 'return...ring()': String
+    214..230 'return...ring()': String
    "###
    );
 }
@@ -508,19 +508,19 @@ fn foo() {
 }
 "#, true),
        @r###"
-    [10; 106) '{     ...  }; }': ()
+    10..106 '{     ...  }; }': ()
-    [20; 21) 'x': || -> &u32
+    20..21 'x': || -> &u32
-    [24; 103) '|| {  ...     }': || -> &u32
+    24..103 '|| {  ...     }': || -> &u32
-    [27; 103) '{     ...     }': &u32
+    27..103 '{     ...     }': &u32
-    [37; 82) 'if tru...     }': ()
+    37..82 'if tru...     }': ()
-    [40; 44) 'true': bool
+    40..44 'true': bool
-    [45; 82) '{     ...     }': !
+    45..82 '{     ...     }': !
-    [59; 71) 'return &1u32': !
+    59..71 'return &1u32': !
-    [66; 71) '&1u32': &u32
+    66..71 '&1u32': &u32
-    [67; 71) '1u32': u32
+    67..71 '1u32': u32
-    [91; 97) '&&1u32': &&u32
+    91..97 '&&1u32': &&u32
-    [92; 97) '&1u32': &u32
+    92..97 '&1u32': &u32
-    [93; 97) '1u32': u32
+    93..97 '1u32': u32
    "###
    );
 }
@@ -535,12 +535,12 @@ fn test() {
 }
 "#, true),
        @r###"
-    [8; 9) 'x': u32
+    8..9 'x': u32
-    [25; 30) '{ 1 }': isize
+    25..30 '{ 1 }': isize
-    [27; 28) '1': isize
+    27..28 '1': isize
-    [41; 79) '{     ...foo; }': ()
+    41..79 '{     ...foo; }': ()
-    [51; 52) 'f': fn(u32) -> isize
+    51..52 'f': fn(u32) -> isize
-    [73; 76) 'foo': fn foo(u32) -> isize
+    73..76 'foo': fn foo(u32) -> isize
    "###
    );
 }
@@ -554,12 +554,12 @@ fn test() {
 }
 "#, true),
        @r###"
-    [11; 55) '{     ...1 }; }': ()
+    11..55 '{     ...1 }; }': ()
-    [21; 22) 'f': fn(u32) -> isize
+    21..22 'f': fn(u32) -> isize
-    [43; 52) '|x| { 1 }': |u32| -> isize
+    43..52 '|x| { 1 }': |u32| -> isize
-    [44; 45) 'x': u32
+    44..45 'x': u32
-    [47; 52) '{ 1 }': isize
+    47..52 '{ 1 }': isize
-    [49; 50) '1': isize
+    49..50 '1': isize
    "###
    );
 }
@@ -577,11 +577,11 @@ impl<TT> S<TT> {
 }
 "#, true),
        @r###"
-    [51; 55) 'self': &S<TT>
+    51..55 'self': &S<TT>
-    [64; 87) '{     ...     }': &TT
+    64..87 '{     ...     }': &TT
-    [74; 81) '&self.t': &TT
+    74..81 '&self.t': &TT
-    [75; 79) 'self': &S<TT>
+    75..79 'self': &S<TT>
-    [75; 81) 'self.t': TT
+    75..81 'self.t': TT
    "###
    );
 }
@@ -602,13 +602,13 @@ fn test() {
 }
 "#, true),
        @r###"
-    [162; 199) '{     ... 3]; }': ()
+    162..199 '{     ... 3]; }': ()
-    [172; 173) 'f': &[usize]
+    172..173 'f': &[usize]
-    [186; 196) '&[1, 2, 3]': &[usize; _]
+    186..196 '&[1, 2, 3]': &[usize; _]
-    [187; 196) '[1, 2, 3]': [usize; _]
+    187..196 '[1, 2, 3]': [usize; _]
-    [188; 189) '1': usize
+    188..189 '1': usize
-    [191; 192) '2': usize
+    191..192 '2': usize
-    [194; 195) '3': usize
+    194..195 '3': usize
    "###
    );
 }
@@ -642,19 +642,19 @@ fn test() {
 }
 "#, true),
        @r###"
-    [388; 573) '{     ...bj2; }': ()
+    388..573 '{     ...bj2; }': ()
-    [398; 401) 'obj': &dyn Baz<i8, i16>
+    398..401 'obj': &dyn Baz<i8, i16>
-    [423; 425) '&S': &S<i8, i16>
+    423..425 '&S': &S<i8, i16>
-    [424; 425) 'S': S<i8, i16>
+    424..425 'S': S<i8, i16>
-    [435; 438) 'obj': &dyn Bar<usize, i8, i16>
+    435..438 'obj': &dyn Bar<usize, i8, i16>
-    [460; 463) 'obj': &dyn Baz<i8, i16>
+    460..463 'obj': &dyn Baz<i8, i16>
-    [473; 476) 'obj': &dyn Foo<i8, usize>
+    473..476 'obj': &dyn Foo<i8, usize>
-    [495; 498) 'obj': &dyn Bar<usize, i8, i16>
+    495..498 'obj': &dyn Bar<usize, i8, i16>
-    [508; 512) 'obj2': &dyn Baz<i8, i16>
+    508..512 'obj2': &dyn Baz<i8, i16>
-    [534; 536) '&S': &S<i8, i16>
+    534..536 '&S': &S<i8, i16>
-    [535; 536) 'S': S<i8, i16>
+    535..536 'S': S<i8, i16>
-    [546; 547) '_': &dyn Foo<i8, usize>
+    546..547 '_': &dyn Foo<i8, usize>
-    [566; 570) 'obj2': &dyn Baz<i8, i16>
+    566..570 'obj2': &dyn Baz<i8, i16>
    "###
    );
 }
@@ -687,12 +687,12 @@ fn test() {
 }
 "#, true),
        @r###"
-    [292; 348) '{     ...obj; }': ()
+    292..348 '{     ...obj; }': ()
-    [302; 305) 'obj': &dyn D
+    302..305 'obj': &dyn D
-    [316; 318) '&S': &S
+    316..318 '&S': &S
-    [317; 318) 'S': S
+    317..318 'S': S
-    [328; 331) 'obj': &dyn A
+    328..331 'obj': &dyn A
-    [342; 345) 'obj': &dyn D
+    342..345 'obj': &dyn D
    "###
    );
 }
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index f2a9b1c40..6b5267232 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -67,12 +67,12 @@ fn main() {
 }
 "#),
        @r###"
-    ![0; 17) '{Foo(v...,2,])}': Foo
+    !0..17 '{Foo(v...,2,])}': Foo
-    ![1; 4) 'Foo': Foo({unknown}) -> Foo
+    !1..4 'Foo': Foo({unknown}) -> Foo
-    ![1; 16) 'Foo(vec![1,2,])': Foo
+    !1..16 'Foo(vec![1,2,])': Foo
-    ![5; 15) 'vec![1,2,]': {unknown}
+    !5..15 'vec![1,2,]': {unknown}
-    [156; 182) '{     ...,2); }': ()
+    156..182 '{     ...,2); }': ()
-    [166; 167) 'x': Foo
+    166..167 'x': Foo
    "###
    );
 }
@@ -100,14 +100,14 @@ fn main() {
 }
 "#),
        @r###"
-    ![0; 17) '{Foo(v...,2,])}': Foo
+    !0..17 '{Foo(v...,2,])}': Foo
-    ![1; 4) 'Foo': Foo({unknown}) -> Foo
+    !1..4 'Foo': Foo({unknown}) -> Foo
-    ![1; 16) 'Foo(vec![1,2,])': Foo
+    !1..16 'Foo(vec![1,2,])': Foo
-    ![5; 15) 'vec![1,2,]': {unknown}
+    !5..15 'vec![1,2,]': {unknown}
-    [195; 251) '{     ...,2); }': ()
+    195..251 '{     ...,2); }': ()
-    [205; 206) 'x': Foo
+    205..206 'x': Foo
-    [228; 229) 'y': {unknown}
+    228..229 'y': {unknown}
-    [232; 248) 'crate:...!(1,2)': {unknown}
+    232..248 'crate:...!(1,2)': {unknown}
    "###
    );
 }
@@ -131,11 +131,11 @@ fn main() {
 }
 "#),
        @r###"
-    ![0; 5) '42i32': i32
+    !0..5 '42i32': i32
-    ![0; 5) '42i32': i32
+    !0..5 '42i32': i32
-    [111; 164) '{     ...!(); }': ()
+    111..164 '{     ...!(); }': ()
-    [121; 122) 'x': i32
+    121..122 'x': i32
-    [148; 149) 'y': i32
+    148..149 'y': i32
    "###
    );
 }
@@ -172,51 +172,51 @@ fn spam() {
 }
 "#),
        @r###"
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    ![0; 6) '1isize': isize
+    !0..6 '1isize': isize
-    [54; 457) '{     ...!(); }': !
+    54..457 '{     ...!(); }': !
-    [88; 109) 'spam!(...am!())': {unknown}
+    88..109 'spam!(...am!())': {unknown}
-    [115; 134) 'for _ ...!() {}': ()
+    115..134 'for _ ...!() {}': ()
-    [119; 120) '_': {unknown}
+    119..120 '_': {unknown}
-    [132; 134) '{}': ()
+    132..134 '{}': ()
-    [139; 149) '|| spam!()': || -> isize
+    139..149 '|| spam!()': || -> isize
-    [155; 171) 'while ...!() {}': ()
+    155..171 'while ...!() {}': ()
-    [169; 171) '{}': ()
+    169..171 '{}': ()
-    [176; 189) 'break spam!()': !
+    176..189 'break spam!()': !
-    [195; 209) 'return spam!()': !
+    195..209 'return spam!()': !
-    [215; 269) 'match ...     }': isize
+    215..269 'match ...     }': isize
-    [239; 240) '_': isize
+    239..240 '_': isize
-    [274; 290) 'spam!(...am!())': {unknown}
+    274..290 'spam!(...am!())': {unknown}
-    [296; 318) 'Spam {...m!() }': {unknown}
+    296..318 'Spam {...m!() }': {unknown}
-    [324; 340) 'spam!(...am!()]': {unknown}
+    324..340 'spam!(...am!()]': {unknown}
-    [365; 381) 'spam!(... usize': usize
+    365..381 'spam!(... usize': usize
-    [387; 395) '&spam!()': &isize
+    387..395 '&spam!()': &isize
-    [401; 409) '-spam!()': isize
+    401..409 '-spam!()': isize
-    [415; 431) 'spam!(...pam!()': {unknown}
+    415..431 'spam!(...pam!()': {unknown}
-    [437; 454) 'spam!(...pam!()': isize
+    437..454 'spam!(...pam!()': isize
    "###
    );
 }
@@ -244,9 +244,9 @@ fn foo() {
 }
 "#),
        @r###"
-    ![0; 5) '42i32': i32
+    !0..5 '42i32': i32
-    [171; 206) '{     ...32); }': ()
+    171..206 '{     ...32); }': ()
-    [181; 184) 'foo': i32
+    181..184 'foo': i32
    "###
    );
 }
@@ -357,12 +357,12 @@ fn main() {
 }
 "#),
        @r###"
-        [159; 164) '{ 0 }': u64
+        159..164 '{ 0 }': u64
-        [161; 162) '0': u64
+        161..162 '0': u64
-        [175; 197) '{     ...f(); }': ()
+        175..197 '{     ...f(); }': ()
-        [185; 187) '_a': u64
+        185..187 '_a': u64
-        [191; 192) 'f': fn f() -> u64
+        191..192 'f': fn f() -> u64
-        [191; 194) 'f()': u64
+        191..194 'f()': u64
    "###
    );
 }
@@ -379,10 +379,10 @@ fn main() {
 }
 "#),
        @r###"
-        ![0; 6) '1usize': usize
+        !0..6 '1usize': usize
-        [11; 90) '{     ...!(); }': ()
+        11..90 '{     ...!(); }': ()
-        [17; 66) 'macro_...     }': {unknown}
+        17..66 'macro_...     }': {unknown}
-        [75; 77) '_a': usize
+        75..77 '_a': usize
    "###
    );
 }
@@ -399,9 +399,9 @@ fn main() {
 }
 "#),
        @r###"
-    ![0; 1) '0': i32
+    !0..1 '0': i32
-    [64; 88) '{     ...!(); }': ()
+    64..88 '{     ...!(); }': ()
-    [74; 75) 'x': i32
+    74..75 'x': i32
    "###
    );
 }
@@ -418,9 +418,9 @@ fn main() {
 }
 "#),
        @r###"
-    ![0; 2) '""': &str
+    !0..2 '""': &str
-    [64; 88) '{     ...!(); }': ()
+    64..88 '{     ...!(); }': ()
-    [74; 75) 'x': &str
+    74..75 'x': &str
    "###
    );
 }
@@ -437,9 +437,9 @@ fn main() {
 }
 "#),
        @r###"
-    ![0; 1) '0': i32
+    !0..1 '0': i32
-    [66; 92) '{     ...!(); }': ()
+    66..92 '{     ...!(); }': ()
-    [76; 77) 'x': i32
+    76..77 'x': i32
    "###
    );
 }
@@ -456,9 +456,9 @@ fn main() {
 }
 "#),
        @r###"
-    ![0; 13) '"helloworld!"': &str
+    !0..13 '"helloworld!"': &str
-    [66; 122) '{     ...")); }': ()
+    66..122 '{     ...")); }': ()
-    [76; 77) 'x': &str
+    76..77 'x': &str
    "###
    );
 }
@@ -591,9 +591,9 @@ fn main() {
 }
 "#),
        @r###"
-    ![0; 13) '"helloworld!"': &str
+    !0..13 '"helloworld!"': &str
-    [104; 161) '{     ...")); }': ()
+    104..161 '{     ...")); }': ()
-    [114; 115) 'x': &str
+    114..115 'x': &str
    "###
    );
 }
@@ -611,9 +611,9 @@ fn main() {
 }
 "#),
        @r###"
-    ![0; 5) '"bar"': &str
+    !0..5 '"bar"': &str
-    [88; 116) '{     ...o"); }': ()
+    88..116 '{     ...o"); }': ()
-    [98; 99) 'x': &str
+    98..99 'x': &str
    "###
    );
 }
@@ -703,12 +703,12 @@ fn main() {
 }
 "#),
        @r###"
-    [52; 111) '{     ...  }; }': ()
+    52..111 '{     ...  }; }': ()
-    [62; 63) 'x': u32
+    62..63 'x': u32
-    [66; 108) 'match ...     }': u32
+    66..108 'match ...     }': u32
-    [72; 74) '()': ()
+    72..74 '()': ()
-    [85; 92) 'unit!()': ()
+    85..92 'unit!()': ()
-    [96; 101) '92u32': u32
+    96..101 '92u32': u32
    "###
    );
 }
diff --git a/crates/ra_hir_ty/src/tests/method_resolution.rs b/crates/ra_hir_ty/src/tests/method_resolution.rs
index af3e5b12c..ab87f598a 100644
--- a/crates/ra_hir_ty/src/tests/method_resolution.rs
+++ b/crates/ra_hir_ty/src/tests/method_resolution.rs
@@ -22,14 +22,14 @@ fn test() {
 }
 "#),
        @r###"
-    [45; 49) 'self': &[T]
+    45..49 'self': &[T]
-    [56; 79) '{     ...     }': T
+    56..79 '{     ...     }': T
-    [66; 73) 'loop {}': !
+    66..73 'loop {}': !
-    [71; 73) '{}': ()
+    71..73 '{}': ()
-    [133; 160) '{     ...o"); }': ()
+    133..160 '{     ...o"); }': ()
-    [139; 149) '<[_]>::foo': fn foo<u8>(&[u8]) -> u8
+    139..149 '<[_]>::foo': fn foo<u8>(&[u8]) -> u8
-    [139; 157) '<[_]>:..."foo")': u8
+    139..157 '<[_]>:..."foo")': u8
-    [150; 156) 'b"foo"': &[u8]
+    150..156 'b"foo"': &[u8]
    "###
    );
 }
@@ -51,15 +51,15 @@ fn test() {
 }
 "#),
        @r###"
-    [49; 75) '{     ...     }': A
+    49..75 '{     ...     }': A
-    [59; 69) 'A { x: 0 }': A
+    59..69 'A { x: 0 }': A
-    [66; 67) '0': u32
+    66..67 '0': u32
-    [88; 122) '{     ...a.x; }': ()
+    88..122 '{     ...a.x; }': ()
-    [98; 99) 'a': A
+    98..99 'a': A
-    [102; 108) 'A::new': fn new() -> A
+    102..108 'A::new': fn new() -> A
-    [102; 110) 'A::new()': A
+    102..110 'A::new()': A
-    [116; 117) 'a': A
+    116..117 'a': A
-    [116; 119) 'a.x': u32
+    116..119 'a.x': u32
    "###
    );
 }
@@ -86,19 +86,19 @@ fn test() {
 }
 "#),
        @r###"
-    [47; 67) '{     ...     }': A
+    47..67 '{     ...     }': A
-    [57; 61) 'A::B': A
+    57..61 'A::B': A
-    [88; 108) '{     ...     }': A
+    88..108 '{     ...     }': A
-    [98; 102) 'A::C': A
+    98..102 'A::C': A
-    [121; 178) '{     ...  c; }': ()
+    121..178 '{     ...  c; }': ()
-    [131; 132) 'a': A
+    131..132 'a': A
-    [135; 139) 'A::b': fn b() -> A
+    135..139 'A::b': fn b() -> A
-    [135; 141) 'A::b()': A
+    135..141 'A::b()': A
-    [147; 148) 'a': A
+    147..148 'a': A
-    [158; 159) 'c': A
+    158..159 'c': A
-    [162; 166) 'A::c': fn c() -> A
+    162..166 'A::c': fn c() -> A
-    [162; 168) 'A::c()': A
+    162..168 'A::c()': A
-    [174; 175) 'c': A
+    174..175 'c': A
    "###
    );
 }
@@ -130,22 +130,22 @@ fn test() {
 }
 "#),
        @r###"
-    [56; 64) '{ A {} }': A
+    56..64 '{ A {} }': A
-    [58; 62) 'A {}': A
+    58..62 'A {}': A
-    [126; 132) '{ 99 }': u32
+    126..132 '{ 99 }': u32
-    [128; 130) '99': u32
+    128..130 '99': u32
-    [202; 210) '{ C {} }': C
+    202..210 '{ C {} }': C
-    [204; 208) 'C {}': C
+    204..208 'C {}': C
-    [241; 325) '{     ...g(); }': ()
+    241..325 '{     ...g(); }': ()
-    [251; 252) 'x': A
+    251..252 'x': A
-    [255; 266) 'a::A::thing': fn thing() -> A
+    255..266 'a::A::thing': fn thing() -> A
-    [255; 268) 'a::A::thing()': A
+    255..268 'a::A::thing()': A
-    [278; 279) 'y': u32
+    278..279 'y': u32
-    [282; 293) 'b::B::thing': fn thing() -> u32
+    282..293 'b::B::thing': fn thing() -> u32
-    [282; 295) 'b::B::thing()': u32
+    282..295 'b::B::thing()': u32
-    [305; 306) 'z': C
+    305..306 'z': C
-    [309; 320) 'c::C::thing': fn thing() -> C
+    309..320 'c::C::thing': fn thing() -> C
-    [309; 322) 'c::C::thing()': C
+    309..322 'c::C::thing()': C
    "###
    );
 }
@@ -169,15 +169,15 @@ fn test() {
 }
 "#),
        @r###"
-    [64; 67) 'val': T
+    64..67 'val': T
-    [82; 109) '{     ...     }': Gen<T>
+    82..109 '{     ...     }': Gen<T>
-    [92; 103) 'Gen { val }': Gen<T>
+    92..103 'Gen { val }': Gen<T>
-    [98; 101) 'val': T
+    98..101 'val': T
-    [123; 155) '{     ...32); }': ()
+    123..155 '{     ...32); }': ()
-    [133; 134) 'a': Gen<u32>
+    133..134 'a': Gen<u32>
-    [137; 146) 'Gen::make': fn make<u32>(u32) -> Gen<u32>
+    137..146 'Gen::make': fn make<u32>(u32) -> Gen<u32>
-    [137; 152) 'Gen::make(0u32)': Gen<u32>
+    137..152 'Gen::make(0u32)': Gen<u32>
-    [147; 151) '0u32': u32
+    147..151 '0u32': u32
    "###
    );
 }
@@ -201,13 +201,13 @@ fn test() {
 }
 "#),
        @r###"
-    [80; 104) '{     ...     }': Gen<T>
+    80..104 '{     ...     }': Gen<T>
-    [90; 98) 'loop { }': !
+    90..98 'loop { }': !
-    [95; 98) '{ }': ()
+    95..98 '{ }': ()
-    [118; 146) '{     ...e(); }': ()
+    118..146 '{     ...e(); }': ()
-    [128; 129) 'a': Gen<u32>
+    128..129 'a': Gen<u32>
-    [132; 141) 'Gen::make': fn make<u32>() -> Gen<u32>
+    132..141 'Gen::make': fn make<u32>() -> Gen<u32>
-    [132; 143) 'Gen::make()': Gen<u32>
+    132..143 'Gen::make()': Gen<u32>
    "###
    );
 }
@@ -255,13 +255,13 @@ fn test() {
 }
 "#),
        @r###"
-    [76; 100) '{     ...     }': Gen<T>
+    76..100 '{     ...     }': Gen<T>
-    [86; 94) 'loop { }': !
+    86..94 'loop { }': !
-    [91; 94) '{ }': ()
+    91..94 '{ }': ()
-    [114; 149) '{     ...e(); }': ()
+    114..149 '{     ...e(); }': ()
-    [124; 125) 'a': Gen<u32>
+    124..125 'a': Gen<u32>
-    [128; 144) 'Gen::<...::make': fn make<u32>() -> Gen<u32>
+    128..144 'Gen::<...::make': fn make<u32>() -> Gen<u32>
-    [128; 146) 'Gen::<...make()': Gen<u32>
+    128..146 'Gen::<...make()': Gen<u32>
    "###
    );
 }
@@ -286,13 +286,13 @@ fn test() {
 }
 "#),
        @r###"
-    [102; 126) '{     ...     }': Gen<u32, T>
+    102..126 '{     ...     }': Gen<u32, T>
-    [112; 120) 'loop { }': !
+    112..120 'loop { }': !
-    [117; 120) '{ }': ()
+    117..120 '{ }': ()
-    [140; 180) '{     ...e(); }': ()
+    140..180 '{     ...e(); }': ()
-    [150; 151) 'a': Gen<u32, u64>
+    150..151 'a': Gen<u32, u64>
-    [154; 175) 'Gen::<...::make': fn make<u64>() -> Gen<u32, u64>
+    154..175 'Gen::<...::make': fn make<u64>() -> Gen<u32, u64>
-    [154; 177) 'Gen::<...make()': Gen<u32, u64>
+    154..177 'Gen::<...make()': Gen<u32, u64>
    "###
    );
 }
@@ -340,13 +340,13 @@ fn test() {
 }
 "#),
        @r###"
-    [31; 35) 'self': &Self
+    31..35 'self': &Self
-    [110; 114) 'self': &Self
+    110..114 'self': &Self
-    [170; 228) '{     ...i128 }': ()
+    170..228 '{     ...i128 }': ()
-    [176; 178) 'S1': S1
+    176..178 'S1': S1
-    [176; 187) 'S1.method()': u32
+    176..187 'S1.method()': u32
-    [203; 205) 'S2': S2
+    203..205 'S2': S2
-    [203; 214) 'S2.method()': i128
+    203..214 'S2.method()': i128
    "###
    );
 }
@@ -387,14 +387,14 @@ mod bar_test {
 }
 "#),
        @r###"
-    [63; 67) 'self': &Self
+    63..67 'self': &Self
-    [169; 173) 'self': &Self
+    169..173 'self': &Self
-    [300; 337) '{     ...     }': ()
+    300..337 '{     ...     }': ()
-    [310; 311) 'S': S
+    310..311 'S': S
-    [310; 320) 'S.method()': u32
+    310..320 'S.method()': u32
-    [416; 454) '{     ...     }': ()
+    416..454 '{     ...     }': ()
-    [426; 427) 'S': S
+    426..427 'S': S
-    [426; 436) 'S.method()': i128
+    426..436 'S.method()': i128
    "###
    );
 }
@@ -414,10 +414,10 @@ fn test() {
 }
 "#),
        @r###"
-    [33; 37) 'self': &Self
+    33..37 'self': &Self
-    [92; 111) '{     ...d(); }': ()
+    92..111 '{     ...d(); }': ()
-    [98; 99) 'S': S
+    98..99 'S': S
-    [98; 108) 'S.method()': u32
+    98..108 'S.method()': u32
    "###
    );
 }
@@ -443,17 +443,17 @@ fn test() {
 }
 "#),
        @r###"
-    [43; 47) 'self': &Self
+    43..47 'self': &Self
-    [82; 86) 'self': &Self
+    82..86 'self': &Self
-    [210; 361) '{     ..., i8 }': ()
+    210..361 '{     ..., i8 }': ()
-    [216; 218) 'S1': S1
+    216..218 'S1': S1
-    [216; 228) 'S1.method1()': (u8, u16, u32)
+    216..228 'S1.method1()': (u8, u16, u32)
-    [250; 252) 'S1': S1
+    250..252 'S1': S1
-    [250; 262) 'S1.method2()': (u32, u16, u8)
+    250..262 'S1.method2()': (u32, u16, u8)
-    [284; 286) 'S2': S2
+    284..286 'S2': S2
-    [284; 296) 'S2.method1()': (i8, i16, {unknown})
+    284..296 'S2.method1()': (i8, i16, {unknown})
-    [324; 326) 'S2': S2
+    324..326 'S2': S2
-    [324; 336) 'S2.method2()': ({unknown}, i16, i8)
+    324..336 'S2.method2()': ({unknown}, i16, i8)
    "###
    );
 }
@@ -473,12 +473,12 @@ fn test() {
 }
 "#),
        @r###"
-    [33; 37) 'self': &Self
+    33..37 'self': &Self
-    [102; 127) '{     ...d(); }': ()
+    102..127 '{     ...d(); }': ()
-    [108; 109) 'S': S<u32>(u32) -> S<u32>
+    108..109 'S': S<u32>(u32) -> S<u32>
-    [108; 115) 'S(1u32)': S<u32>
+    108..115 'S(1u32)': S<u32>
-    [108; 124) 'S(1u32...thod()': u32
+    108..124 'S(1u32...thod()': u32
-    [110; 114) '1u32': u32
+    110..114 '1u32': u32
    "###
    );
 }
@@ -499,16 +499,16 @@ fn test() {
 }
 "#),
        @r###"
-    [87; 193) '{     ...t(); }': ()
+    87..193 '{     ...t(); }': ()
-    [97; 99) 's1': S
+    97..99 's1': S
-    [105; 121) 'Defaul...efault': fn default<S>() -> S
+    105..121 'Defaul...efault': fn default<S>() -> S
-    [105; 123) 'Defaul...ault()': S
+    105..123 'Defaul...ault()': S
-    [133; 135) 's2': S
+    133..135 's2': S
-    [138; 148) 'S::default': fn default<S>() -> S
+    138..148 'S::default': fn default<S>() -> S
-    [138; 150) 'S::default()': S
+    138..150 'S::default()': S
-    [160; 162) 's3': S
+    160..162 's3': S
-    [165; 188) '<S as ...efault': fn default<S>() -> S
+    165..188 '<S as ...efault': fn default<S>() -> S
-    [165; 190) '<S as ...ault()': S
+    165..190 '<S as ...ault()': S
    "###
    );
 }
@@ -531,16 +531,16 @@ fn test() {
 }
 "#),
        @r###"
-    [127; 211) '{     ...e(); }': ()
+    127..211 '{     ...e(); }': ()
-    [137; 138) 'a': u32
+    137..138 'a': u32
-    [141; 148) 'S::make': fn make<S, u32>() -> u32
+    141..148 'S::make': fn make<S, u32>() -> u32
-    [141; 150) 'S::make()': u32
+    141..150 'S::make()': u32
-    [160; 161) 'b': u64
+    160..161 'b': u64
-    [164; 178) 'G::<u64>::make': fn make<G<u64>, u64>() -> u64
+    164..178 'G::<u64>::make': fn make<G<u64>, u64>() -> u64
-    [164; 180) 'G::<u6...make()': u64
+    164..180 'G::<u6...make()': u64
-    [190; 191) 'c': f64
+    190..191 'c': f64
-    [199; 206) 'G::make': fn make<G<f64>, f64>() -> f64
+    199..206 'G::make': fn make<G<f64>, f64>() -> f64
-    [199; 208) 'G::make()': f64
+    199..208 'G::make()': f64
    "###
    );
 }
@@ -565,22 +565,22 @@ fn test() {
 }
 "#),
        @r###"
-    [135; 313) '{     ...e(); }': ()
+    135..313 '{     ...e(); }': ()
-    [145; 146) 'a': (u32, i64)
+    145..146 'a': (u32, i64)
-    [149; 163) 'S::make::<i64>': fn make<S, u32, i64>() -> (u32, i64)
+    149..163 'S::make::<i64>': fn make<S, u32, i64>() -> (u32, i64)
-    [149; 165) 'S::mak...i64>()': (u32, i64)
+    149..165 'S::mak...i64>()': (u32, i64)
-    [175; 176) 'b': (u32, i64)
+    175..176 'b': (u32, i64)
-    [189; 196) 'S::make': fn make<S, u32, i64>() -> (u32, i64)
+    189..196 'S::make': fn make<S, u32, i64>() -> (u32, i64)
-    [189; 198) 'S::make()': (u32, i64)
+    189..198 'S::make()': (u32, i64)
-    [208; 209) 'c': (u32, i64)
+    208..209 'c': (u32, i64)
-    [212; 233) 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
+    212..233 'G::<u3...:<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
-    [212; 235) 'G::<u3...i64>()': (u32, i64)
+    212..235 'G::<u3...i64>()': (u32, i64)
-    [245; 246) 'd': (u32, i64)
+    245..246 'd': (u32, i64)
-    [259; 273) 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
+    259..273 'G::make::<i64>': fn make<G<u32>, u32, i64>() -> (u32, i64)
-    [259; 275) 'G::mak...i64>()': (u32, i64)
+    259..275 'G::mak...i64>()': (u32, i64)
-    [285; 286) 'e': (u32, i64)
+    285..286 'e': (u32, i64)
-    [301; 308) 'G::make': fn make<G<u32>, u32, i64>() -> (u32, i64)
+    301..308 'G::make': fn make<G<u32>, u32, i64>() -> (u32, i64)
-    [301; 310) 'G::make()': (u32, i64)
+    301..310 'G::make()': (u32, i64)
    "###
    );
 }
@@ -599,10 +599,10 @@ fn test() {
 }
 "#),
        @r###"
-    [101; 127) '{     ...e(); }': ()
+    101..127 '{     ...e(); }': ()
-    [111; 112) 'a': (S<i32>, i64)
+    111..112 'a': (S<i32>, i64)
-    [115; 122) 'S::make': fn make<S<i32>, i64>() -> (S<i32>, i64)
+    115..122 'S::make': fn make<S<i32>, i64>() -> (S<i32>, i64)
-    [115; 124) 'S::make()': (S<i32>, i64)
+    115..124 'S::make()': (S<i32>, i64)
    "###
    );
 }
@@ -623,13 +623,13 @@ fn test() {
 }
 "#),
        @r###"
-    [131; 203) '{     ...e(); }': ()
+    131..203 '{     ...e(); }': ()
-    [141; 142) 'a': (S<u64>, i64)
+    141..142 'a': (S<u64>, i64)
-    [158; 165) 'S::make': fn make<S<u64>, i64>() -> (S<u64>, i64)
+    158..165 'S::make': fn make<S<u64>, i64>() -> (S<u64>, i64)
-    [158; 167) 'S::make()': (S<u64>, i64)
+    158..167 'S::make()': (S<u64>, i64)
-    [177; 178) 'b': (S<u32>, i32)
+    177..178 'b': (S<u32>, i32)
-    [191; 198) 'S::make': fn make<S<u32>, i32>() -> (S<u32>, i32)
+    191..198 'S::make': fn make<S<u32>, i32>() -> (S<u32>, i32)
-    [191; 200) 'S::make()': (S<u32>, i32)
+    191..200 'S::make()': (S<u32>, i32)
    "###
    );
 }
@@ -649,13 +649,13 @@ fn test() {
 }
 "#),
        @r###"
-    [107; 211) '{     ...>(); }': ()
+    107..211 '{     ...>(); }': ()
-    [117; 118) 'a': (S<u64>, i64, u8)
+    117..118 'a': (S<u64>, i64, u8)
-    [121; 150) '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
+    121..150 '<S as ...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
-    [121; 152) '<S as ...<u8>()': (S<u64>, i64, u8)
+    121..152 '<S as ...<u8>()': (S<u64>, i64, u8)
-    [162; 163) 'b': (S<u64>, i64, u8)
+    162..163 'b': (S<u64>, i64, u8)
-    [182; 206) 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
+    182..206 'Trait:...::<u8>': fn make<S<u64>, i64, u8>() -> (S<u64>, i64, u8)
-    [182; 208) 'Trait:...<u8>()': (S<u64>, i64, u8)
+    182..208 'Trait:...<u8>()': (S<u64>, i64, u8)
    "###
    );
 }
@@ -672,11 +672,11 @@ fn test<T: Trait>(t: T) {
 }
 "#),
        @r###"
-    [30; 34) 'self': &Self
+    30..34 'self': &Self
-    [64; 65) 't': T
+    64..65 't': T
-    [70; 89) '{     ...d(); }': ()
+    70..89 '{     ...d(); }': ()
-    [76; 77) 't': T
+    76..77 't': T
-    [76; 86) 't.method()': u32
+    76..86 't.method()': u32
    "###
    );
 }
@@ -693,11 +693,11 @@ fn test<U, T: Trait<U>>(t: T) {
 }
 "#),
        @r###"
-    [33; 37) 'self': &Self
+    33..37 'self': &Self
-    [71; 72) 't': T
+    71..72 't': T
-    [77; 96) '{     ...d(); }': ()
+    77..96 '{     ...d(); }': ()
-    [83; 84) 't': T
+    83..84 't': T
-    [83; 93) 't.method()': U
+    83..93 't.method()': U
    "###
    );
 }
@@ -719,18 +719,18 @@ fn test() {
 }
 "#),
        @r###"
-    [29; 33) 'self': Self
+    29..33 'self': Self
-    [111; 202) '{     ...(S); }': ()
+    111..202 '{     ...(S); }': ()
-    [121; 122) 'x': u32
+    121..122 'x': u32
-    [130; 131) 'S': S
+    130..131 'S': S
-    [130; 138) 'S.into()': u32
+    130..138 'S.into()': u32
-    [148; 149) 'y': u64
+    148..149 'y': u64
-    [157; 158) 'S': S
+    157..158 'S': S
-    [157; 165) 'S.into()': u64
+    157..165 'S.into()': u64
-    [175; 176) 'z': u64
+    175..176 'z': u64
-    [179; 196) 'Into::...::into': fn into<S, u64>(S) -> u64
+    179..196 'Into::...::into': fn into<S, u64>(S) -> u64
-    [179; 199) 'Into::...nto(S)': u64
+    179..199 'Into::...nto(S)': u64
-    [197; 198) 'S': S
+    197..198 'S': S
    "###
    );
 }
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index 6ea51d5d3..af291092d 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -30,54 +30,54 @@ fn test(x: &i32) {
 }
 "#),
        @r###"
-    [9; 10) 'x': &i32
+    9..10 'x': &i32
-    [18; 369) '{     ...o_x; }': ()
+    18..369 '{     ...o_x; }': ()
-    [28; 29) 'y': &i32
+    28..29 'y': &i32
-    [32; 33) 'x': &i32
+    32..33 'x': &i32
-    [43; 45) '&z': &i32
+    43..45 '&z': &i32
-    [44; 45) 'z': i32
+    44..45 'z': i32
-    [48; 49) 'x': &i32
+    48..49 'x': &i32
-    [59; 60) 'a': i32
+    59..60 'a': i32
-    [63; 64) 'z': i32
+    63..64 'z': i32
-    [74; 80) '(c, d)': (i32, &str)
+    74..80 '(c, d)': (i32, &str)
-    [75; 76) 'c': i32
+    75..76 'c': i32
-    [78; 79) 'd': &str
+    78..79 'd': &str
-    [83; 95) '(1, "hello")': (i32, &str)
+    83..95 '(1, "hello")': (i32, &str)
-    [84; 85) '1': i32
+    84..85 '1': i32
-    [87; 94) '"hello"': &str
+    87..94 '"hello"': &str
-    [102; 152) 'for (e...     }': ()
+    102..152 'for (e...     }': ()
-    [106; 112) '(e, f)': ({unknown}, {unknown})
+    106..112 '(e, f)': ({unknown}, {unknown})
-    [107; 108) 'e': {unknown}
+    107..108 'e': {unknown}
-    [110; 111) 'f': {unknown}
+    110..111 'f': {unknown}
-    [116; 125) 'some_iter': {unknown}
+    116..125 'some_iter': {unknown}
-    [126; 152) '{     ...     }': ()
+    126..152 '{     ...     }': ()
-    [140; 141) 'g': {unknown}
+    140..141 'g': {unknown}
-    [144; 145) 'e': {unknown}
+    144..145 'e': {unknown}
-    [158; 205) 'if let...     }': ()
+    158..205 'if let...     }': ()
-    [165; 170) '[val]': [{unknown}]
+    165..170 '[val]': [{unknown}]
-    [166; 169) 'val': {unknown}
+    166..169 'val': {unknown}
-    [173; 176) 'opt': [{unknown}]
+    173..176 'opt': [{unknown}]
-    [177; 205) '{     ...     }': ()
+    177..205 '{     ...     }': ()
-    [191; 192) 'h': {unknown}
+    191..192 'h': {unknown}
-    [195; 198) 'val': {unknown}
+    195..198 'val': {unknown}
-    [215; 221) 'lambda': |u64, u64, i32| -> i32
+    215..221 'lambda': |u64, u64, i32| -> i32
-    [224; 256) '|a: u6...b; c }': |u64, u64, i32| -> i32
+    224..256 '|a: u6...b; c }': |u64, u64, i32| -> i32
-    [225; 226) 'a': u64
+    225..226 'a': u64
-    [233; 234) 'b': u64
+    233..234 'b': u64
-    [236; 237) 'c': i32
+    236..237 'c': i32
-    [244; 256) '{ a + b; c }': i32
+    244..256 '{ a + b; c }': i32
-    [246; 247) 'a': u64
+    246..247 'a': u64
-    [246; 251) 'a + b': u64
+    246..251 'a + b': u64
-    [250; 251) 'b': u64
+    250..251 'b': u64
-    [253; 254) 'c': i32
+    253..254 'c': i32
-    [267; 279) 'ref ref_to_x': &&i32
+    267..279 'ref ref_to_x': &&i32
-    [282; 283) 'x': &i32
+    282..283 'x': &i32
-    [293; 302) 'mut mut_x': &i32
+    293..302 'mut mut_x': &i32
-    [305; 306) 'x': &i32
+    305..306 'x': &i32
-    [316; 336) 'ref mu...f_to_x': &mut &i32
+    316..336 'ref mu...f_to_x': &mut &i32
-    [339; 340) 'x': &i32
+    339..340 'x': &i32
-    [350; 351) 'k': &mut &i32
+    350..351 'k': &mut &i32
-    [354; 366) 'mut_ref_to_x': &mut &i32
+    354..366 'mut_ref_to_x': &mut &i32
    "###
    );
 }
@@ -97,47 +97,47 @@ fn test(x: &i32) {
 }
 "#, true),
        @r###"
-    [18; 29) '{ loop {} }': T
+    18..29 '{ loop {} }': T
-    [20; 27) 'loop {}': !
+    20..27 'loop {}': !
-    [25; 27) '{}': ()
+    25..27 '{}': ()
-    [38; 39) 'x': &i32
+    38..39 'x': &i32
-    [47; 209) '{     ...) {} }': ()
+    47..209 '{     ...) {} }': ()
-    [53; 76) 'if let...y() {}': ()
+    53..76 'if let...y() {}': ()
-    [60; 65) '"foo"': &str
+    60..65 '"foo"': &str
-    [60; 65) '"foo"': &str
+    60..65 '"foo"': &str
-    [68; 71) 'any': fn any<&str>() -> &str
+    68..71 'any': fn any<&str>() -> &str
-    [68; 73) 'any()': &str
+    68..73 'any()': &str
-    [74; 76) '{}': ()
+    74..76 '{}': ()
-    [81;