30 files changed, 767 insertions, 157 deletions
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index c0810c69b..25e5bfb01 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -266,8 +266,7 @@ impl ModuleDef {
    }
    pub fn canonical_path(&self, db: &dyn HirDatabase) -> Option<String> {
-        let mut segments = Vec::new();
+        let mut segments = vec![self.name(db)?.to_string()];
-        segments.push(self.name(db)?.to_string());
        for m in self.module(db)?.path_to_root(db) {
            segments.extend(m.name(db).map(|it| it.to_string()))
        }
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index d546512cb..4d59293e9 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -161,8 +161,9 @@ impl SourceAnalyzer {
        db: &dyn HirDatabase,
        field: &ast::RecordExprField,
    ) -> Option<(Field, Option<Local>)> {
-        let expr = field.expr()?;
+        let expr_id =
-        let expr_id = self.expr_id(db, &expr)?;
+            self.body_source_map.as_ref()?.node_field(InFile::new(self.file_id, field))?;
        let local = if field.name_ref().is_some() {
            None
        } else {
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index 19c4eb521..8bcc350ce 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -253,11 +253,18 @@ pub type LabelSource = InFile<LabelPtr>;
 pub struct BodySourceMap {
    expr_map: FxHashMap<ExprSource, ExprId>,
    expr_map_back: ArenaMap<ExprId, Result<ExprSource, SyntheticSyntax>>,
    pat_map: FxHashMap<PatSource, PatId>,
    pat_map_back: ArenaMap<PatId, Result<PatSource, SyntheticSyntax>>,
    label_map: FxHashMap<LabelSource, LabelId>,
    label_map_back: ArenaMap<LabelId, LabelSource>,
-    field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordExprField>>>,
+    /// We don't create explicit nodes for record fields (`S { record_field: 92 }`).
+    /// Instead, we use id of expression (`92`) to identify the field.
+    field_map: FxHashMap<InFile<AstPtr<ast::RecordExprField>>, ExprId>,
+    field_map_back: FxHashMap<ExprId, InFile<AstPtr<ast::RecordExprField>>>,
    expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
    /// Diagnostics accumulated during body lowering. These contain `AstPtr`s and so are stored in
@@ -337,6 +344,8 @@ impl Index<LabelId> for Body {
    }
 }
+// FIXME: Change `node_` prefix to something more reasonable.
+// Perhaps `expr_syntax` and `expr_id`?
 impl BodySourceMap {
    pub fn expr_syntax(&self, expr: ExprId) -> Result<ExprSource, SyntheticSyntax> {
        self.expr_map_back[expr].clone()
@@ -375,8 +384,12 @@ impl BodySourceMap {
        self.label_map.get(&src).cloned()
    }
-    pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordExprField>> {
+    pub fn field_syntax(&self, expr: ExprId) -> InFile<AstPtr<ast::RecordExprField>> {
-        self.field_map[&(expr, field)].clone()
+        self.field_map_back[&expr].clone()
+    }
+    pub fn node_field(&self, node: InFile<&ast::RecordExprField>) -> Option<ExprId> {
+        let src = node.map(|it| AstPtr::new(it));
+        self.field_map.get(&src).cloned()
    }
    pub(crate) fn add_diagnostics(&self, _db: &dyn DefDatabase, sink: &mut DiagnosticSink<'_>) {
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 8c8eb8007..8934ae6c9 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -379,23 +379,22 @@ impl ExprCollector<'_> {
            }
            ast::Expr::RecordExpr(e) => {
                let path = e.path().and_then(|path| self.expander.parse_path(path));
-                let mut field_ptrs = Vec::new();
                let record_lit = if let Some(nfl) = e.record_expr_field_list() {
                    let fields = nfl
                        .fields()
-                        .inspect(|field| field_ptrs.push(AstPtr::new(field)))
                        .filter_map(|field| {
                            self.check_cfg(&field)?;
                            let name = field.field_name()?.as_name();
-                            Some(RecordLitField {
+                            let expr = match field.expr() {
-                                name,
+                                Some(e) => self.collect_expr(e),
-                                expr: match field.expr() {
+                                None => self.missing_expr(),
-                                    Some(e) => self.collect_expr(e),
+                            };
-                                    None => self.missing_expr(),
+                            let src = self.expander.to_source(AstPtr::new(&field));
-                                },
+                            self.source_map.field_map.insert(src.clone(), expr);
-                            })
+                            self.source_map.field_map_back.insert(expr, src);
+                            Some(RecordLitField { name, expr })
                        })
                        .collect();
                    let spread = nfl.spread().map(|s| self.collect_expr(s));
@@ -404,12 +403,7 @@ impl ExprCollector<'_> {
                    Expr::RecordLit { path, fields: Vec::new(), spread: None }
                };
-                let res = self.alloc_expr(record_lit, syntax_ptr);
+                self.alloc_expr(record_lit, syntax_ptr)
-                for (i, ptr) in field_ptrs.into_iter().enumerate() {
-                    let src = self.expander.to_source(ptr);
-                    self.source_map.field_map.insert((res, i), src);
-                }
-                res
            }
            ast::Expr::FieldExpr(e) => {
                let expr = self.collect_expr_opt(e.expr());
diff --git a/crates/hir_expand/src/builtin_derive.rs b/crates/hir_expand/src/builtin_derive.rs
index dfdb9cf59..5e908b223 100644
--- a/crates/hir_expand/src/builtin_derive.rs
+++ b/crates/hir_expand/src/builtin_derive.rs
@@ -108,7 +108,7 @@ fn parse_adt(tt: &tt::Subtree) -> Result<BasicAdtInfo, mbe::ExpandError> {
 }
 fn make_type_args(n: usize, bound: Vec<tt::TokenTree>) -> Vec<tt::TokenTree> {
-    let mut result = Vec::<tt::TokenTree>::new();
+    let mut result = Vec::<tt::TokenTree>::with_capacity(n * 2);
    result.push(
        tt::Leaf::Punct(tt::Punct {
            char: '<',
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 6dfe53902..9c385b845 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -802,7 +802,7 @@ mod diagnostics {
    #[derive(Debug, PartialEq, Eq, Clone)]
    pub(super) enum InferenceDiagnostic {
-        NoSuchField { expr: ExprId, field: usize },
+        NoSuchField { expr: ExprId },
        BreakOutsideOfLoop { expr: ExprId },
    }
@@ -814,9 +814,9 @@ mod diagnostics {
            sink: &mut DiagnosticSink,
        ) {
            match self {
-                InferenceDiagnostic::NoSuchField { expr, field } => {
+                InferenceDiagnostic::NoSuchField { expr } => {
                    let (_, source_map) = db.body_with_source_map(owner);
-                    let field = source_map.field_syntax(*expr, *field);
+                    let field = source_map.field_syntax(*expr);
                    sink.push(NoSuchField { file: field.file_id, field: field.value })
                }
                InferenceDiagnostic::BreakOutsideOfLoop { expr } => {
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 8c58a1b6c..f40dec17f 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -405,14 +405,13 @@ impl<'a> InferenceContext<'a> {
                let substs = ty.substs().cloned().unwrap_or_else(Substs::empty);
                let field_types = def_id.map(|it| self.db.field_types(it)).unwrap_or_default();
                let variant_data = def_id.map(|it| variant_data(self.db.upcast(), it));
-                for (field_idx, field) in fields.iter().enumerate() {
+                for field in fields.iter() {
                    let field_def =
                        variant_data.as_ref().and_then(|it| match it.field(&field.name) {
                            Some(local_id) => Some(FieldId { parent: def_id.unwrap(), local_id }),
                            None => {
                                self.push_diagnostic(InferenceDiagnostic::NoSuchField {
-                                    expr: tgt_expr,
+                                    expr: field.expr,
-                                    field: field_idx,
                                });
                                None
                            }
diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
index 107bd8432..6ae7c9e6c 100644
--- a/crates/ide/Cargo.toml
+++ b/crates/ide/Cargo.toml
@@ -38,3 +38,4 @@ hir = { path = "../hir", version = "0.0.0" }
 [dev-dependencies]
 test_utils = { path = "../test_utils" }
 expect-test = "1.1"
+cov-mark = "1.1.0"
diff --git a/crates/ide/src/annotations.rs b/crates/ide/src/annotations.rs
index 2e8e82b70..8e0a8fd8d 100644
--- a/crates/ide/src/annotations.rs
+++ b/crates/ide/src/annotations.rs
@@ -11,7 +11,7 @@ use crate::{
    goto_implementation::goto_implementation,
    references::find_all_refs,
    runnables::{runnables, Runnable},
-    NavigationTarget, RunnableKind,
+    NavigationTarget, RunnableKind, StructureNodeKind,
 };
 // Feature: Annotations
@@ -80,15 +80,17 @@ pub(crate) fn annotations(
        .filter(|node| {
            matches!(
                node.kind,
-                SymbolKind::Trait
+                StructureNodeKind::SymbolKind(SymbolKind::Trait)
-                    | SymbolKind::Struct
+                    | StructureNodeKind::SymbolKind(SymbolKind::Struct)
-                    | SymbolKind::Enum
+                    | StructureNodeKind::SymbolKind(SymbolKind::Enum)
-                    | SymbolKind::Union
+                    | StructureNodeKind::SymbolKind(SymbolKind::Union)
-                    | SymbolKind::Const
+                    | StructureNodeKind::SymbolKind(SymbolKind::Const)
            )
        })
        .for_each(|node| {
-            if config.annotate_impls && node.kind != SymbolKind::Const {
+            if config.annotate_impls
+                && node.kind != StructureNodeKind::SymbolKind(SymbolKind::Const)
+            {
                annotations.push(Annotation {
                    range: node.node_range,
                    kind: AnnotationKind::HasImpls {
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index fe32f39b6..22697a537 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -6,6 +6,7 @@
 mod fixes;
 mod field_shorthand;
+mod unlinked_file;
 use std::cell::RefCell;
@@ -22,6 +23,7 @@ use syntax::{
    SyntaxNode, SyntaxNodePtr, TextRange,
 };
 use text_edit::TextEdit;
+use unlinked_file::UnlinkedFile;
 use crate::{FileId, Label, SourceChange};
@@ -156,6 +158,18 @@ pub(crate) fn diagnostics(
                .with_code(Some(d.code())),
            );
        })
+        .on::<UnlinkedFile, _>(|d| {
+            // Override severity and mark as unused.
+            res.borrow_mut().push(
+                Diagnostic::hint(
+                    sema.diagnostics_display_range(d.display_source()).range,
+                    d.message(),
+                )
+                .with_unused(true)
+                .with_fix(d.fix(&sema))
+                .with_code(Some(d.code())),
+            );
+        })
        .on::<hir::diagnostics::UnresolvedProcMacro, _>(|d| {
            // Use more accurate position if available.
            let display_range = d
@@ -197,9 +211,13 @@ pub(crate) fn diagnostics(
            );
        });
-    if let Some(m) = sema.to_module_def(file_id) {
+    match sema.to_module_def(file_id) {
-        m.diagnostics(db, &mut sink);
+        Some(m) => m.diagnostics(db, &mut sink),
-    };
+        None => {
+            sink.push(UnlinkedFile { file_id, node: SyntaxNodePtr::new(&parse.tree().syntax()) });
+        }
+    }
    drop(sink);
    res.into_inner()
 }
@@ -307,6 +325,17 @@ mod tests {
        );
    }
+    /// Checks that there's a diagnostic *without* fix at `$0`.
+    fn check_no_fix(ra_fixture: &str) {
+        let (analysis, file_position) = fixture::position(ra_fixture);
+        let diagnostic = analysis
+            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+            .unwrap()
+            .pop()
+            .unwrap();
+        assert!(diagnostic.fix.is_none(), "got a fix when none was expected: {:?}", diagnostic);
+    }
    /// Takes a multi-file input fixture with annotated cursor position and checks that no diagnostics
    /// apply to the file containing the cursor.
    pub(crate) fn check_no_diagnostics(ra_fixture: &str) {
@@ -975,4 +1004,132 @@ impl TestStruct {
        check_fix(input, expected);
    }
+    #[test]
+    fn unlinked_file_prepend_first_item() {
+        cov_mark::check!(unlinked_file_prepend_before_first_item);
+        check_fix(
+            r#"
+//- /main.rs
+fn f() {}
+//- /foo.rs
+$0
+"#,
+            r#"
+mod foo;
+fn f() {}
+"#,
+        );
+    }
+    #[test]
+    fn unlinked_file_append_mod() {
+        cov_mark::check!(unlinked_file_append_to_existing_mods);
+        check_fix(
+            r#"
+//- /main.rs
+//! Comment on top
+mod preexisting;
+mod preexisting2;
+struct S;
+mod preexisting_bottom;)
+//- /foo.rs
+$0
+"#,
+            r#"
+//! Comment on top
+mod preexisting;
+mod preexisting2;
+mod foo;
+struct S;
+mod preexisting_bottom;)
+"#,
+        );
+    }
+    #[test]
+    fn unlinked_file_insert_in_empty_file() {
+        cov_mark::check!(unlinked_file_empty_file);
+        check_fix(
+            r#"
+//- /main.rs
+//- /foo.rs
+$0
+"#,
+            r#"
+mod foo;
+"#,
+        );
+    }
+    #[test]
+    fn unlinked_file_old_style_modrs() {
+        check_fix(
+            r#"
+//- /main.rs
+mod submod;
+//- /submod/mod.rs
+// in mod.rs
+//- /submod/foo.rs
+$0
+"#,
+            r#"
+// in mod.rs
+mod foo;
+"#,
+        );
+    }
+    #[test]
+    fn unlinked_file_new_style_mod() {
+        check_fix(
+            r#"
+//- /main.rs
+mod submod;
+//- /submod.rs
+//- /submod/foo.rs
+$0
+"#,
+            r#"
+mod foo;
+"#,
+        );
+    }
+    #[test]
+    fn unlinked_file_with_cfg_off() {
+        cov_mark::check!(unlinked_file_skip_fix_when_mod_already_exists);
+        check_no_fix(
+            r#"
+//- /main.rs
+#[cfg(never)]
+mod foo;
+//- /foo.rs
+$0
+"#,
+        );
+    }
+    #[test]
+    fn unlinked_file_with_cfg_on() {
+        check_no_diagnostics(
+            r#"
+//- /main.rs
+#[cfg(not(never))]
+mod foo;
+//- /foo.rs
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/diagnostics/unlinked_file.rs b/crates/ide/src/diagnostics/unlinked_file.rs
new file mode 100644
index 000000000..c5741bf6b
--- /dev/null
+++ b/crates/ide/src/diagnostics/unlinked_file.rs
@@ -0,0 +1,156 @@
+//! Diagnostic emitted for files that aren't part of any crate.
+use hir::{
+    db::DefDatabase,
+    diagnostics::{Diagnostic, DiagnosticCode},
+    InFile,
+};
+use ide_db::{
+    base_db::{FileId, FileLoader, SourceDatabase, SourceDatabaseExt},
+    source_change::SourceChange,
+    RootDatabase,
+};
+use syntax::{
+    ast::{self, ModuleItemOwner, NameOwner},
+    AstNode, SyntaxNodePtr,
+};
+use text_edit::TextEdit;
+use crate::Fix;
+use super::fixes::DiagnosticWithFix;
+#[derive(Debug)]
+pub(crate) struct UnlinkedFile {
+    pub(crate) file_id: FileId,
+    pub(crate) node: SyntaxNodePtr,
+}
+impl Diagnostic for UnlinkedFile {
+    fn code(&self) -> DiagnosticCode {
+        DiagnosticCode("unlinked-file")
+    }
+    fn message(&self) -> String {
+        "file not included in module tree".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file_id.into(), self.node.clone())
+    }
+    fn as_any(&self) -> &(dyn std::any::Any + Send + 'static) {
+        self
+    }
+}
+impl DiagnosticWithFix for UnlinkedFile {
+    fn fix(&self, sema: &hir::Semantics<RootDatabase>) -> Option<Fix> {
+        // If there's an existing module that could add a `mod` item to include the unlinked file,
+        // suggest that as a fix.
+        let source_root = sema.db.source_root(sema.db.file_source_root(self.file_id));
+        let our_path = source_root.path_for_file(&self.file_id)?;
+        let module_name = our_path.name_and_extension()?.0;
+        // Candidates to look for:
+        // - `mod.rs` in the same folder
+        //   - we also check `main.rs` and `lib.rs`
+        // - `$dir.rs` in the parent folder, where `$dir` is the directory containing `self.file_id`
+        let parent = our_path.parent()?;
+        let mut paths =
+            vec![parent.join("mod.rs")?, parent.join("main.rs")?, parent.join("lib.rs")?];
+        // `submod/bla.rs` -> `submod.rs`
+        if let Some(newmod) = (|| {
+            let name = parent.name_and_extension()?.0;
+            parent.parent()?.join(&format!("{}.rs", name))
+        })() {
+            paths.push(newmod);
+        }
+        for path in &paths {
+            if let Some(parent_id) = source_root.file_for_path(path) {
+                for krate in sema.db.relevant_crates(*parent_id).iter() {
+                    let crate_def_map = sema.db.crate_def_map(*krate);
+                    for (_, module) in crate_def_map.modules() {
+                        if module.origin.is_inline() {
+                            // We don't handle inline `mod parent {}`s, they use different paths.
+                            continue;
+                        }
+                        if module.origin.file_id() == Some(*parent_id) {
+                            return make_fix(sema.db, *parent_id, module_name, self.file_id);
+                        }
+                    }
+                }
+            }
+        }
+        None
+    }
+}
+fn make_fix(
+    db: &RootDatabase,
+    parent_file_id: FileId,
+    new_mod_name: &str,
+    added_file_id: FileId,
+) -> Option<Fix> {
+    fn is_outline_mod(item: &ast::Item) -> bool {
+        matches!(item, ast::Item::Module(m) if m.item_list().is_none())
+    }
+    let mod_decl = format!("mod {};", new_mod_name);
+    let ast: ast::SourceFile = db.parse(parent_file_id).tree();
+    let mut builder = TextEdit::builder();
+    // If there's an existing `mod m;` statement matching the new one, don't emit a fix (it's
+    // probably `#[cfg]`d out).
+    for item in ast.items() {
+        if let ast::Item::Module(m) = item {
+            if let Some(name) = m.name() {
+                if m.item_list().is_none() && name.to_string() == new_mod_name {
+                    cov_mark::hit!(unlinked_file_skip_fix_when_mod_already_exists);
+                    return None;
+                }
+            }
+        }
+    }
+    // If there are existing `mod m;` items, append after them (after the first group of them, rather).
+    match ast
+        .items()
+        .skip_while(|item| !is_outline_mod(item))
+        .take_while(|item| is_outline_mod(item))
+        .last()
+    {
+        Some(last) => {
+            cov_mark::hit!(unlinked_file_append_to_existing_mods);
+            builder.insert(last.syntax().text_range().end(), format!("\n{}", mod_decl));
+        }
+        None => {
+            // Prepend before the first item in the file.
+            match ast.items().next() {
+                Some(item) => {
+                    cov_mark::hit!(unlinked_file_prepend_before_first_item);
+                    builder.insert(item.syntax().text_range().start(), format!("{}\n\n", mod_decl));
+                }
+                None => {
+                    // No items in the file, so just append at the end.
+                    cov_mark::hit!(unlinked_file_empty_file);
+                    builder.insert(ast.syntax().text_range().end(), format!("{}\n", mod_decl));
+                }
+            }
+        }
+    }
+    let edit = builder.finish();
+    let trigger_range = db.parse(added_file_id).tree().syntax().text_range();
+    Some(Fix::new(
+        &format!("Insert `{}`", mod_decl),
+        SourceChange::from_text_edit(parent_file_id, edit),
+        trigger_range,
+    ))
+}
diff --git a/crates/ide/src/file_structure.rs b/crates/ide/src/file_structure.rs
index 26793bdb4..9f879a66e 100644
--- a/crates/ide/src/file_structure.rs
+++ b/crates/ide/src/file_structure.rs
@@ -1,7 +1,8 @@
 use ide_db::SymbolKind;
 use syntax::{
    ast::{self, AttrsOwner, GenericParamsOwner, NameOwner},
-    match_ast, AstNode, SourceFile, SyntaxNode, TextRange, WalkEvent,
+    match_ast, AstNode, AstToken, NodeOrToken, SourceFile, SyntaxNode, SyntaxToken, TextRange,
+    WalkEvent,
 };
 #[derive(Debug, Clone)]
@@ -10,11 +11,17 @@ pub struct StructureNode {
    pub label: String,
    pub navigation_range: TextRange,
    pub node_range: TextRange,
-    pub kind: SymbolKind,
+    pub kind: StructureNodeKind,
    pub detail: Option<String>,
    pub deprecated: bool,
 }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum StructureNodeKind {
+    SymbolKind(SymbolKind),
+    Region,
+}
 // Feature: File Structure
 //
 // Provides a tree of the symbols defined in the file. Can be used to
@@ -32,34 +39,46 @@ pub(crate) fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
    let mut res = Vec::new();
    let mut stack = Vec::new();
-    for event in file.syntax().preorder() {
+    for event in file.syntax().preorder_with_tokens() {
        match event {
-            WalkEvent::Enter(node) => {
+            WalkEvent::Enter(NodeOrToken::Node(node)) => {
                if let Some(mut symbol) = structure_node(&node) {
                    symbol.parent = stack.last().copied();
                    stack.push(res.len());
                    res.push(symbol);
                }
            }
-            WalkEvent::Leave(node) => {
+            WalkEvent::Leave(NodeOrToken::Node(node)) => {
                if structure_node(&node).is_some() {
                    stack.pop().unwrap();
                }
            }
+            WalkEvent::Enter(NodeOrToken::Token(token)) => {
+                if let Some(mut symbol) = structure_token(token) {
+                    symbol.parent = stack.last().copied();
+                    stack.push(res.len());
+                    res.push(symbol);
+                }
+            }
+            WalkEvent::Leave(NodeOrToken::Token(token)) => {
+                if structure_token(token).is_some() {
+                    stack.pop().unwrap();
+                }
+            }
        }
    }
    res
 }
 fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
-    fn decl<N: NameOwner + AttrsOwner>(node: N, kind: SymbolKind) -> Option<StructureNode> {
+    fn decl<N: NameOwner + AttrsOwner>(node: N, kind: StructureNodeKind) -> Option<StructureNode> {
        decl_with_detail(&node, None, kind)
    }
    fn decl_with_type_ref<N: NameOwner + AttrsOwner>(
        node: &N,
        type_ref: Option<ast::Type>,
-        kind: SymbolKind,
+        kind: StructureNodeKind,
    ) -> Option<StructureNode> {
        let detail = type_ref.map(|type_ref| {
            let mut detail = String::new();
@@ -72,7 +91,7 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
    fn decl_with_detail<N: NameOwner + AttrsOwner>(
        node: &N,
        detail: Option<String>,
-        kind: SymbolKind,
+        kind: StructureNodeKind,
    ) -> Option<StructureNode> {
        let name = node.name()?;
@@ -120,18 +139,18 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
                    collapse_ws(ret_type.syntax(), &mut detail);
                }
-                decl_with_detail(&it, Some(detail), SymbolKind::Function)
+                decl_with_detail(&it, Some(detail), StructureNodeKind::SymbolKind(SymbolKind::Function))
            },
-            ast::Struct(it) => decl(it, SymbolKind::Struct),
+            ast::Struct(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Struct)),
-            ast::Union(it) => decl(it, SymbolKind::Union),
+            ast::Union(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Union)),
-            ast::Enum(it) => decl(it, SymbolKind::Enum),
+            ast::Enum(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Enum)),
-            ast::Variant(it) => decl(it, SymbolKind::Variant),
+            ast::Variant(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Variant)),
-            ast::Trait(it) => decl(it, SymbolKind::Trait),
+            ast::Trait(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Trait)),
-            ast::Module(it) => decl(it, SymbolKind::Module),
+            ast::Module(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Module)),
-            ast::TypeAlias(it) => decl_with_type_ref(&it, it.ty(), SymbolKind::TypeAlias),
+            ast::TypeAlias(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::TypeAlias)),
-            ast::RecordField(it) => decl_with_type_ref(&it, it.ty(), SymbolKind::Field),
+            ast::RecordField(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::Field)),
-            ast::Const(it) => decl_with_type_ref(&it, it.ty(), SymbolKind::Const),
+            ast::Const(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::Const)),
-            ast::Static(it) => decl_with_type_ref(&it, it.ty(), SymbolKind::Static),
+            ast::Static(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::Static)),
            ast::Impl(it) => {
                let target_type = it.self_ty()?;
                let target_trait = it.trait_();
@@ -147,18 +166,38 @@ fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
                    label,
                    navigation_range: target_type.syntax().text_range(),
                    node_range: it.syntax().text_range(),
-                    kind: SymbolKind::Impl,
+                    kind: StructureNodeKind::SymbolKind(SymbolKind::Impl),
                    detail: None,
                    deprecated: false,
                };
                Some(node)
            },
-            ast::MacroRules(it) => decl(it, SymbolKind::Macro),
+            ast::MacroRules(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Macro)),
            _ => None,
        }
    }
 }
+fn structure_token(token: SyntaxToken) -> Option<StructureNode> {
+    if let Some(comment) = ast::Comment::cast(token) {
+        let text = comment.text().trim();
+        if let Some(region_name) = text.strip_prefix("// region:").map(str::trim) {
+            return Some(StructureNode {
+                parent: None,
+                label: region_name.to_string(),
+                navigation_range: comment.syntax().text_range(),
+                node_range: comment.syntax().text_range(),
+                kind: StructureNodeKind::Region,
+                detail: None,
+                deprecated: false,
+            });
+        }
+    }
+    None
+}
 #[cfg(test)]
 mod tests {
    use expect_test::{expect, Expect};
@@ -217,6 +256,16 @@ fn obsolete() {}
 #[deprecated(note = "for awhile")]
 fn very_obsolete() {}
+// region: Some region name
+// endregion
+// region: dontpanic
+mod m {
+fn f() {}
+// endregion
+fn g() {}
+}
 "#,
            expect![[r#"
                [
@@ -225,7 +274,9 @@ fn very_obsolete() {}
                        label: "Foo",
                        navigation_range: 8..11,
                        node_range: 1..26,
-                        kind: Struct,
+                        kind: SymbolKind(
+                            Struct,
+                        ),
                        detail: None,
                        deprecated: false,
                    },
@@ -236,7 +287,9 @@ fn very_obsolete() {}
                        label: "x",
                        navigation_range: 18..19,
                        node_range: 18..24,
-                        kind: Field,
+                        kind: SymbolKind(
+                            Field,
+                        ),
                        detail: Some(
                            "i32",
                        ),
@@ -247,7 +300,9 @@ fn very_obsolete() {}
                        label: "m",
                        navigation_range: 32..33,
                        node_range: 28..158,
-                        kind: Module,
+                        kind: SymbolKind(
+                            Module,
+                        ),
                        detail: None,
                        deprecated: false,
                    },
@@ -258,7 +313,9 @@ fn very_obsolete() {}
                        label: "bar1",
                        navigation_range: 43..47,
                        node_range: 40..52,
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                        detail: Some(
                            "fn()",
                        ),
@@ -271,7 +328,9 @@ fn very_obsolete() {}
                        label: "bar2",
                        navigation_range: 60..64,
                        node_range: 57..81,
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                        detail: Some(
                            "fn<T>(t: T) -> T",
                        ),
@@ -284,7 +343,9 @@ fn very_obsolete() {}
                        label: "bar3",
                        navigation_range: 89..93,
                        node_range: 86..156,
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                        detail: Some(
                            "fn<A, B>(a: A, b: B) -> Vec< u32 >",
                        ),
@@ -295,7 +356,9 @@ fn very_obsolete() {}
                        label: "E",
                        navigation_range: 165..166,
                        node_range: 160..180,
-                        kind: Enum,
+                        kind: SymbolKind(
+                            Enum,
+                        ),
                        detail: None,
                        deprecated: false,
                    },
@@ -306,7 +369,9 @@ fn very_obsolete() {}
                        label: "X",
                        navigation_range: 169..170,
                        node_range: 169..170,
-                        kind: Variant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                        detail: None,
                        deprecated: false,
                    },
@@ -317,7 +382,9 @@ fn very_obsolete() {}
                        label: "Y",
                        navigation_range: 172..173,
                        node_range: 172..178,
-                        kind: Variant,
+                        kind: SymbolKind(
+                            Variant,
+                        ),
                        detail: None,
                        deprecated: false,
                    },
@@ -326,7 +393,9 @@ fn very_obsolete() {}
                        label: "T",
                        navigation_range: 186..187,
                        node_range: 181..193,
-                        kind: TypeAlias,
+                        kind: SymbolKind(
+                            TypeAlias,
+                        ),
                        detail: Some(
                            "()",
                        ),
@@ -337,7 +406,9 @@ fn very_obsolete() {}
                        label: "S",
                        navigation_range: 201..202,
                        node_range: 194..213,
-                        kind: Static,
+                        kind: SymbolKind(
+                            Static,
+                        ),
                        detail: Some(
                            "i32",
                        ),
@@ -348,7 +419,9 @@ fn very_obsolete() {}
                        label: "C",
                        navigation_range: 220..221,
                        node_range: 214..232,
-                        kind: Const,
+                        kind: SymbolKind(
+                            Const,
+                        ),
                        detail: Some(
                            "i32",
                        ),
@@ -359,7 +432,9 @@ fn very_obsolete() {}
                        label: "impl E",
                        navigation_range: 239..240,
                        node_range: 234..243,
-                        kind: Impl,
+                        kind: SymbolKind(
+                            Impl,
+                        ),
                        detail: None,
                        deprecated: false,
                    },
@@ -368,7 +443,9 @@ fn very_obsolete() {}
                        label: "impl fmt::Debug for E",
                        navigation_range: 265..266,
                        node_range: 245..269,
-                        kind: Impl,
+                        kind: SymbolKind(
+                            Impl,
+                        ),
                        detail: None,
                        deprecated: false,
                    },
@@ -377,7 +454,9 @@ fn very_obsolete() {}
                        label: "mc",
                        navigation_range: 284..286,
                        node_range: 271..303,
-                        kind: Macro,
+                        kind: SymbolKind(
+                            Macro,
+                        ),
                        detail: None,
                        deprecated: false,
                    },
@@ -386,7 +465,9 @@ fn very_obsolete() {}
                        label: "mcexp",
                        navigation_range: 334..339,
                        node_range: 305..356,
-                        kind: Macro,
+                        kind: SymbolKind(
+                            Macro,
+                        ),
                        detail: None,
                        deprecated: false,
                    },
@@ -395,7 +476,9 @@ fn very_obsolete() {}
                        label: "mcexp",
                        navigation_range: 387..392,
                        node_range: 358..409,
-                        kind: Macro,
+                        kind: SymbolKind(
+                            Macro,
+                        ),
                        detail: None,
                        deprecated: false,
                    },
@@ -404,7 +487,9 @@ fn very_obsolete() {}
                        label: "obsolete",
                        navigation_range: 428..436,
                        node_range: 411..441,
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                        detail: Some(
                            "fn()",
                        ),
@@ -415,12 +500,75 @@ fn very_obsolete() {}
                        label: "very_obsolete",
                        navigation_range: 481..494,
                        node_range: 443..499,
-                        kind: Function,
+                        kind: SymbolKind(
+                            Function,
+                        ),
                        detail: Some(
                            "fn()",
                        ),
                        deprecated: true,
                    },
+                    StructureNode {
+                        parent: None,
+                        label: "Some region name",
+                        navigation_range: 501..528,
+                        node_range: 501..528,
+                        kind: Region,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: None,
+                        label: "m",
+                        navigation_range: 568..569,
+                        node_range: 543..606,
+                        kind: SymbolKind(
+                            Module,
+                        ),
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            20,
+                        ),
+                        label: "dontpanic",
+                        navigation_range: 543..563,
+                        node_range: 543..563,
+                        kind: Region,
+                        detail: None,
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            20,
+                        ),
+                        label: "f",
+                        navigation_range: 575..576,
+                        node_range: 572..581,
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        detail: Some(
+                            "fn()",
+                        ),
+                        deprecated: false,
+                    },
+                    StructureNode {
+                        parent: Some(
+                            20,
+                        ),
+                        label: "g",
+                        navigation_range: 598..599,
+                        node_range: 582..604,
+                        kind: SymbolKind(
+                            Function,
+                        ),
+                        detail: Some(
+                            "fn()",
+                        ),
+                        deprecated: false,
+                    },
                ]
            "#]],
        );
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index abed1969e..e8f31e4b1 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1161,4 +1161,15 @@ struct S;
 "#,
        )
    }
+    #[test]
+    fn goto_incomplete_field() {
+        check(
+            r#"
+struct A { a: u32 }
+         //^
+fn foo() { A { a$0: }; }
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/join_lines.rs b/crates/ide/src/join_lines.rs
index 20a920ddb..d571ed559 100644
--- a/crates/ide/src/join_lines.rs
+++ b/crates/ide/src/join_lines.rs
@@ -218,7 +218,7 @@ mod tests {
        let result = join_lines(&file, range);
        let actual = {
-            let mut actual = before.to_string();
+            let mut actual = before;
            result.apply(&mut actual);
            actual
        };
@@ -622,7 +622,7 @@ fn foo() {
        let parse = SourceFile::parse(&before);
        let result = join_lines(&parse.tree(), sel);
        let actual = {
-            let mut actual = before.to_string();
+            let mut actual = before;
            result.apply(&mut actual);
            actual
        };
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index a8b169e87..662da5a96 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -71,7 +71,7 @@ pub use crate::{
    diagnostics::{Diagnostic, DiagnosticsConfig, Fix, Severity},
    display::navigation_target::NavigationTarget,
    expand_macro::ExpandedMacro,
-    file_structure::StructureNode,
+    file_structure::{StructureNode, StructureNodeKind},
    folding_ranges::{Fold, FoldKind},
    hover::{HoverAction, HoverConfig, HoverGotoTypeData, HoverResult},
    inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
@@ -101,7 +101,7 @@ pub use ide_db::{
    search::{ReferenceAccess, SearchScope},
    source_change::{FileSystemEdit, SourceChange},
    symbol_index::Query,
-    RootDatabase,
+    RootDatabase, SymbolKind,
 };
 pub use ide_ssr::SsrError;
 pub use syntax::{TextRange, TextSize};
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index fef70533d..ec7c7686d 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -29,7 +29,7 @@ use crate::{display::TryToNav, FilePosition, NavigationTarget};
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
-    pub declaration: Declaration,
+    pub declaration: Option<Declaration>,
    pub references: FxHashMap<FileId, Vec<(TextRange, Option<ReferenceAccess>)>>,
 }
@@ -91,10 +91,10 @@ pub(crate) fn find_all_refs(
            _ => {}
        }
    }
-    let nav = def.try_to_nav(sema.db)?;
+    let declaration = def.try_to_nav(sema.db).map(|nav| {
-    let decl_range = nav.focus_or_full_range();
+        let decl_range = nav.focus_or_full_range();
+        Declaration { nav, access: decl_access(&def, &syntax, decl_range) }
-    let declaration = Declaration { nav, access: decl_access(&def, &syntax, decl_range) };
+    });
    let references = usages
        .into_iter()
        .map(|(file_id, refs)| {
@@ -1004,8 +1004,7 @@ impl Foo {
        let refs = analysis.find_all_refs(pos, search_scope).unwrap().unwrap();
        let mut actual = String::new();
-        {
+        if let Some(decl) = refs.declaration {
-            let decl = refs.declaration;
            format_to!(actual, "{}", decl.nav.debug_render());
            if let Some(access) = decl.access {
                format_to!(actual, " {:?}", access)
@@ -1258,4 +1257,17 @@ fn main() {
            "#]],
        );
    }
+    #[test]
+    fn test_primitives() {
+        check(
+            r#"
+fn foo(_: bool) -> bo$0ol { true }
+"#,
+            expect![[r#"
+                FileId(0) 10..14
+                FileId(0) 19..23
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 1e378279d..5340b638a 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -510,7 +510,8 @@ fn source_edit_from_def(
    def: Definition,
    new_name: &str,
 ) -> RenameResult<(FileId, TextEdit)> {
-    let nav = def.try_to_nav(sema.db).unwrap();
+    let nav =
+        def.try_to_nav(sema.db).ok_or_else(|| format_err!("No references found at position"))?;
    let mut replacement_text = String::new();
    let mut repl_range = nav.focus_or_full_range();
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index faa91541e..27d35de5b 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -2,7 +2,7 @@ use std::fmt;
 use ast::NameOwner;
 use cfg::CfgExpr;
-use hir::{AsAssocItem, HasAttrs, HasSource, Semantics};
+use hir::{AsAssocItem, HasAttrs, HasSource, HirDisplay, Semantics};
 use ide_assists::utils::test_related_attribute;
 use ide_db::{
    base_db::{FilePosition, FileRange},
@@ -340,11 +340,21 @@ fn module_def_doctest(sema: &Semantics<RootDatabase>, def: hir::ModuleDef) -> Op
            // FIXME: this also looks very wrong
            if let Some(assoc_def) = assoc_def {
                if let hir::AssocItemContainer::Impl(imp) = assoc_def.container(sema.db) {
-                    if let Some(adt) = imp.target_ty(sema.db).as_adt() {
+                    let ty = imp.target_ty(sema.db);
-                        let name = adt.name(sema.db).to_string();
+                    if let Some(adt) = ty.as_adt() {
+                        let name = adt.name(sema.db);
                        let idx = path.rfind(':').map_or(0, |idx| idx + 1);
                        let (prefix, suffix) = path.split_at(idx);
-                        return format!("{}{}::{}", prefix, name, suffix);
+                        let mut ty_params = ty.type_parameters().peekable();
+                        let params = if ty_params.peek().is_some() {
+                            format!(
+                                "<{}>",
+                                ty_params.format_with(", ", |ty, cb| cb(&ty.display(sema.db)))
+                            )
+                        } else {
+                            String::new()
+                        };
+                        return format!("{}{}{}::{}", prefix, name, params, suffix);
                    }
                }
            }
@@ -1406,4 +1416,41 @@ mod tests {
            "#]],
        );
    }
+    #[test]
+    fn doc_test_type_params() {
+        check(
+            r#"
+//- /lib.rs
+$0
+struct Foo<T, U>;
+impl<T, U> Foo<T, U> {
+    /// ```rust
+    /// ````
+    fn t() {}
+}
+"#,
+            &[&DOCTEST],
+            expect![[r#"
+                [
+                    Runnable {
+                        nav: NavigationTarget {
+                            file_id: FileId(
+                                0,
+                            ),
+                            full_range: 47..85,
+                            name: "t",
+                        },
+                        kind: DocTest {
+                            test_id: Path(
+                                "Foo<T, U>::t",
+                            ),
+                        },
+                        cfg: None,
+                    },
+                ]
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/typing.rs b/crates/ide/src/typing.rs
index e3c3aebac..a718faf63 100644
--- a/crates/ide/src/typing.rs
+++ b/crates/ide/src/typing.rs
@@ -145,9 +145,8 @@ mod tests {
    use super::*;
    fn do_type_char(char_typed: char, before: &str) -> Option<String> {
-        let (offset, before) = extract_offset(before);
+        let (offset, mut before) = extract_offset(before);
        let edit = TextEdit::insert(offset, char_typed.to_string());
-        let mut before = before.to_string();
        edit.apply(&mut before);
        let parse = SourceFile::parse(&before);
        on_char_typed_inner(&parse.tree(), offset, char_typed).map(|it| {
diff --git a/crates/ide_completion/src/completions/postfix/format_like.rs b/crates/ide_completion/src/completions/postfix/format_like.rs
index 3afc63021..cee4eec10 100644
--- a/crates/ide_completion/src/completions/postfix/format_like.rs
+++ b/crates/ide_completion/src/completions/postfix/format_like.rs
@@ -59,7 +59,7 @@ pub(crate) fn add_format_like_completions(
 /// Checks whether provided item is a string literal.
 fn string_literal_contents(item: &ast::String) -> Option<String> {
    let item = item.text();
-    if item.len() >= 2 && item.starts_with("\"") && item.ends_with("\"") {
+    if item.len() >= 2 && item.starts_with('\"') && item.ends_with('\"') {
        return Some(item[1..item.len() - 1].to_owned());
    }
diff --git a/crates/ide_completion/src/item.rs b/crates/ide_completion/src/item.rs
index 3febab32b..9a4b5217a 100644
--- a/crates/ide_completion/src/item.rs
+++ b/crates/ide_completion/src/item.rs
@@ -144,6 +144,21 @@ pub struct CompletionRelevance {
    /// }
    /// ```
    pub exact_type_match: bool,
+    /// This is set in cases like these:
+    ///
+    /// ```
+    /// fn foo(bar: u32) {
+    ///     $0 // `bar` is local
+    /// }
+    /// ```
+    ///
+    /// ```
+    /// fn foo() {
+    ///     let bar = 0;
+    ///     $0 // `bar` is local
+    /// }
+    /// ```
+    pub is_local: bool,
 }
 impl CompletionRelevance {
@@ -163,6 +178,9 @@ impl CompletionRelevance {
            score += 1;
        }
        if self.exact_type_match {
+            score += 3;
+        }
+        if self.is_local {
            score += 1;
        }
@@ -551,9 +569,24 @@ mod tests {
            vec![CompletionRelevance::default()],
            vec![
                CompletionRelevance { exact_name_match: true, ..CompletionRelevance::default() },
-                CompletionRelevance { exact_type_match: true, ..CompletionRelevance::default() },
+                CompletionRelevance { is_local: true, ..CompletionRelevance::default() },
            ],
-            vec![CompletionRelevance { exact_name_match: true, exact_type_match: true }],
+            vec![CompletionRelevance {
+                exact_name_match: true,
+                is_local: true,
+                ..CompletionRelevance::default()
+            }],
+            vec![CompletionRelevance { exact_type_match: true, ..CompletionRelevance::default() }],
+            vec![CompletionRelevance {
+                exact_name_match: true,
+                exact_type_match: true,
+                ..CompletionRelevance::default()
+            }],
+            vec![CompletionRelevance {
+                exact_name_match: true,
+                exact_type_match: true,
+                is_local: true,
+            }],
        ];
        check_relevance_score_ordered(expected_relevance_order);
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index fcb8115fb..905f0b197 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -157,9 +157,7 @@ impl<'a> Render<'a> {
            .set_documentation(field.docs(self.ctx.db()))
            .set_deprecated(is_deprecated);
-        if let Some(relevance) = compute_relevance(&self.ctx, &ty, &name.to_string()) {
+        item.set_relevance(compute_relevance(&self.ctx, &ty, &name.to_string()));
-            item.set_relevance(relevance);
-        }
        item.build()
    }
@@ -254,9 +252,9 @@ impl<'a> Render<'a> {
        if let ScopeDef::Local(local) = resolution {
            let ty = local.ty(self.ctx.db());
-            if let Some(relevance) = compute_relevance(&self.ctx, &ty, &local_name) {
+            let mut relevance = compute_relevance(&self.ctx, &ty, &local_name);
-                item.set_relevance(relevance);
+            relevance.is_local = true;
-            }
+            item.set_relevance(relevance);
            if let Some((_expected_name, expected_type)) = self.ctx.expected_name_and_type() {
                if ty != expected_type {
@@ -328,12 +326,15 @@ impl<'a> Render<'a> {
    }
 }
-fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> Option<CompletionRelevance> {
+fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> CompletionRelevance {
-    let (expected_name, expected_type) = ctx.expected_name_and_type()?;
    let mut res = CompletionRelevance::default();
-    res.exact_type_match = ty == &expected_type;
-    res.exact_name_match = name == &expected_name;
+    if let Some((expected_name, expected_type)) = ctx.expected_name_and_type() {
-    Some(res)
+        res.exact_type_match = ty == &expected_type;
+        res.exact_name_match = name == &expected_name;
+    }
+    res
 }
 fn relevance_type_match(db: &dyn HirDatabase, ty: &Type, expected_type: &Type) -> bool {
@@ -343,6 +344,7 @@ fn relevance_type_match(db: &dyn HirDatabase, ty: &Type, expected_type: &Type) -
 #[cfg(test)]
 mod tests {
    use expect_test::{expect, Expect};
+    use itertools::Itertools;
    use crate::{
        test_utils::{check_edit, do_completion, get_all_items, TEST_CONFIG},
@@ -355,15 +357,17 @@ mod tests {
    }
    fn check_relevance(ra_fixture: &str, expect: Expect) {
-        fn display_relevance(relevance: CompletionRelevance) -> &'static str {
+        fn display_relevance(relevance: CompletionRelevance) -> String {
-            match relevance {
+            let relevance_factors = vec![
-                CompletionRelevance { exact_type_match: true, exact_name_match: true } => {
+                (relevance.exact_type_match, "type"),
-                    "[type+name]"
+                (relevance.exact_name_match, "name"),
-                }
+                (relevance.is_local, "local"),
-                CompletionRelevance { exact_type_match: true, exact_name_match: false } => "[type]",
+            ]
-                CompletionRelevance { exact_type_match: false, exact_name_match: true } => "[name]",
+            .into_iter()
-                CompletionRelevance { exact_type_match: false, exact_name_match: false } => "[]",
+            .filter_map(|(cond, desc)| if cond { Some(desc) } else { None })
-            }
+            .join("+");
+            format!("[{}]", relevance_factors)
        }
        let actual = get_all_items(TEST_CONFIG, ra_fixture)
@@ -918,7 +922,7 @@ struct WorldSnapshot { _f: () };
 fn go(world: &WorldSnapshot) { go(w$0) }
 "#,
            expect![[r#"
-                lc world [type+name]
+                lc world [type+name+local]
                st WorldSnapshot []
                fn go(…) []
            "#]],
@@ -933,7 +937,7 @@ struct Foo;
 fn f(foo: &Foo) { f(foo, w$0) }
 "#,
            expect![[r#"
-                lc foo []
+                lc foo [local]
                st Foo []
                fn f(…) []
            "#]],
@@ -998,6 +1002,7 @@ fn main() {
                        relevance: CompletionRelevance {
                            exact_name_match: true,
                            exact_type_match: false,
+                            is_local: true,
                        },
                        ref_match: "&mut ",
                    },
@@ -1037,9 +1042,9 @@ fn main() {
 }
            "#,
            expect![[r#"
-                lc m []
+                lc m [local]
-                lc t []
+                lc t [local]
-                lc &t [type]
+                lc &t [type+local]
                st T []
                st S []
                fn main() []
@@ -1091,9 +1096,9 @@ fn main() {
 }
            "#,
            expect![[r#"
-                lc m []
+                lc m [local]
-                lc t []
+                lc t [local]
-                lc &mut t [type]
+                lc &mut t [type+local]
                tt DerefMut []
                tt Deref []
                fn foo(…) []
@@ -1103,4 +1108,22 @@ fn main() {
            "#]],
        )
    }
+    #[test]
+    fn locals() {
+        check_relevance(
+            r#"
+fn foo(bar: u32) {
+    let baz = 0;
+    f$0
+}
+"#,
+            expect![[r#"
+                lc baz [local]
+                lc bar [local]
+                fn foo(…) []
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index ff612b7d0..f86e5ce93 100644
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -70,7 +70,7 @@ impl Definition {
                hir::ModuleDef::Static(it) => it.name(db)?,
                hir::ModuleDef::Trait(it) => it.name(db),
                hir::ModuleDef::TypeAlias(it) => it.name(db),
-                hir::ModuleDef::BuiltinType(_) => return None,
+                hir::ModuleDef::BuiltinType(it) => it.name(),
            },
            Definition::SelfType(_) => return None,
            Definition::Local(it) => it.name(db)?,
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index fa18703e1..d00a8b6e7 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -6,7 +6,7 @@
 use std::{convert::TryInto, mem};
-use base_db::{FileId, FileRange, SourceDatabaseExt};
+use base_db::{FileId, FileRange, SourceDatabase, SourceDatabaseExt};
 use hir::{DefWithBody, HasSource, Module, ModuleSource, Semantics, Visibility};
 use once_cell::unsync::Lazy;
 use rustc_hash::FxHashMap;
@@ -138,6 +138,20 @@ impl IntoIterator for SearchScope {
 impl Definition {
    fn search_scope(&self, db: &RootDatabase) -> SearchScope {
        let _p = profile::span("search_scope");
+        if let Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) = self {
+            let mut res = FxHashMap::default();
+            let graph = db.crate_graph();
+            for krate in graph.iter() {
+                let root_file = graph[krate].root_file_id;
+                let source_root_id = db.file_source_root(root_file);
+                let source_root = db.source_root(source_root_id);
+                res.extend(source_root.iter().map(|id| (id, None)));
+            }
+            return SearchScope::new(res);
+        }
        let module = match self.module(db) {
            Some(it) => it,
            None => return SearchScope::empty(),
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index aacae1026..b715ebfc4 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -222,14 +222,10 @@ fn convert_doc_comment(token: &syntax::SyntaxToken) -> Option<Vec<tt::TokenTree>
    let doc = comment.kind().doc?;
    // Make `doc="\" Comments\""
-    let mut meta_tkns = Vec::new();
+    let meta_tkns = vec![mk_ident("doc"), mk_punct('='), mk_doc_literal(&comment)];
-    meta_tkns.push(mk_ident("doc"));
-    meta_tkns.push(mk_punct('='));
-    meta_tkns.push(mk_doc_literal(&comment));
    // Make `#![]`
-    let mut token_trees = Vec::new();
+    let mut token_trees = vec![mk_punct('#')];
-    token_trees.push(mk_punct('#'));
    if let ast::CommentPlacement::Inner = doc {
        token_trees.push(mk_punct('!'));
    }
diff --git a/crates/proc_macro_api/src/version.rs b/crates/proc_macro_api/src/version.rs
index 11a7fb59a..b903658fb 100644
--- a/crates/proc_macro_api/src/version.rs
+++ b/crates/proc_macro_api/src/version.rs
@@ -33,7 +33,7 @@ pub(crate) fn read_info(dylib_path: &Path) -> io::Result<RustCInfo> {
    }
    let version_part = items.next().ok_or(err!("no version string"))?;
-    let mut version_parts = version_part.split("-");
+    let mut version_parts = version_part.split('-');
    let version = version_parts.next().ok_or(err!("no version"))?;
    let channel = version_parts.next().unwrap_or_default().to_string();
@@ -51,7 +51,7 @@ pub(crate) fn read_info(dylib_path: &Path) -> io::Result<RustCInfo> {
    let date = date[0..date.len() - 2].to_string();
    let version_numbers = version
-        .split(".")
+        .split('.')
        .map(|it| it.parse::<usize>())
        .collect::<Result<Vec<_>, _>>()
        .map_err(|_| err!("version number error"))?;
diff --git a/crates/project_model/src/rustc_cfg.rs b/crates/project_model/src/rustc_cfg.rs
index 4a7bd8ae3..312708575 100644
--- a/crates/project_model/src/rustc_cfg.rs
+++ b/crates/project_model/src/rustc_cfg.rs
@@ -6,7 +6,7 @@ use crate::{cfg_flag::CfgFlag, utf8_stdout};
 pub(crate) fn get(target: Option<&str>) -> Vec<CfgFlag> {
    let _p = profile::span("rustc_cfg::get");
-    let mut res = Vec::new();
+    let mut res = Vec::with_capacity(6 * 2 + 1);
    // Some nightly-only cfgs, which are required for stdlib
    res.push(CfgFlag::Atom("target_thread_local".into()));
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 706a39dab..6fb7da79c 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -289,7 +289,7 @@ pub(crate) fn handle_document_symbol(
        let doc_symbol = lsp_types::DocumentSymbol {
            name: symbol.label,
            detail: symbol.detail,
-            kind: to_proto::symbol_kind(symbol.kind),
+            kind: to_proto::structure_node_kind(symbol.kind),
            tags: Some(tags),
            deprecated: Some(symbol.deprecated),
            range: to_proto::range(&line_index, symbol.node_range),
@@ -846,9 +846,9 @@ pub(crate) fn handle_references(
    };
    let decl = if params.context.include_declaration {
-        Some(FileRange {
+        refs.declaration.map(|decl| FileRange {
-            file_id: refs.declaration.nav.file_id,
+            file_id: decl.nav.file_id,
-            range: refs.declaration.nav.focus_or_full_range(),
+            range: decl.nav.focus_or_full_range(),
        })
    } else {
        None
@@ -1153,14 +1153,12 @@ pub(crate) fn handle_document_highlight(
        Some(refs) => refs,
    };
-    let decl = if refs.declaration.nav.file_id == position.file_id {
+    let decl = refs.declaration.filter(|decl| decl.nav.file_id == position.file_id).map(|decl| {
-        Some(DocumentHighlight {
+        DocumentHighlight {
-            range: to_proto::range(&line_index, refs.declaration.nav.focus_or_full_range()),
+            range: to_proto::range(&line_index, decl.nav.focus_or_full_range()),
-            kind: refs.declaration.access.map(to_proto::document_highlight_kind),
+            kind: decl.access.map(to_proto::document_highlight_kind),
-        })
+        }
-    } else {
+    });
-        None
-    };
    let file_refs = refs.references.get(&position.file_id).map_or(&[][..], Vec::as_slice);
    let mut res = Vec::with_capacity(file_refs.len() + 1);
diff --git a/crates/rust-analyzer/src/lsp_utils.rs b/crates/rust-analyzer/src/lsp_utils.rs
index 84f78b5b8..3ca7f8040 100644
--- a/crates/rust-analyzer/src/lsp_utils.rs
+++ b/crates/rust-analyzer/src/lsp_utils.rs
@@ -360,11 +360,11 @@ mod tests {
            "Completion with disjoint edits is valid"
        );
        assert!(
-            !all_edits_are_disjoint(&completion_with_disjoint_edits, &[joint_edit.clone()]),
+            !all_edits_are_disjoint(&completion_with_disjoint_edits, &[joint_edit]),
            "Completion with disjoint edits and joint extra edit is invalid"
        );
        assert!(
-            all_edits_are_disjoint(&completion_with_disjoint_edits, &[disjoint_edit_2.clone()]),
+            all_edits_are_disjoint(&completion_with_disjoint_edits, &[disjoint_edit_2]),
            "Completion with disjoint edits and joint extra edit is valid"
        );
    }
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 5736875d3..70eaae5e8 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -9,9 +9,8 @@ use ide::{
    CompletionRelevance, Documentation, FileId, FileRange, FileSystemEdit, Fold, FoldKind,
    Highlight, HlMod, HlPunct, HlRange, HlTag, Indel, InlayHint, InlayKind, InsertTextFormat,
    Markup, NavigationTarget, ReferenceAccess, RenameError, Runnable, Severity, SourceChange,
-    TextEdit, TextRange, TextSize,
+    StructureNodeKind, SymbolKind, TextEdit, TextRange, TextSize,
 };
-use ide_db::SymbolKind;
 use itertools::Itertools;
 use serde_json::to_value;
@@ -63,6 +62,13 @@ pub(crate) fn symbol_kind(symbol_kind: SymbolKind) -> lsp_types::SymbolKind {
    }
 }
+pub(crate) fn structure_node_kind(kind: StructureNodeKind) -> lsp_types::SymbolKind {
+    match kind {
+        StructureNodeKind::SymbolKind(symbol) => symbol_kind(symbol),
+        StructureNodeKind::Region => lsp_types::SymbolKind::Namespace,
+    }
+}
 pub(crate) fn document_highlight_kind(
    reference_access: ReferenceAccess,
 ) -> lsp_types::DocumentHighlightKind {
@@ -1117,13 +1123,13 @@ mod tests {
                (
                    "&arg",
                    Some(
-                        "fffffffd",
+                        "fffffffa",
                    ),
                ),
                (
                    "arg",
                    Some(
-                        "fffffffe",
+                        "fffffffd",
                    ),
                ),
            ]