36 files changed, 851 insertions, 352 deletions
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index d13b4d5fd..c5161dadd 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -267,8 +267,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()))
        }
@@ -1634,7 +1633,7 @@ impl Type {
    pub fn remove_ref(&self) -> Option<Type> {
        match &self.ty.value.interned(&Interner) {
-            TyKind::Ref(.., substs) => Some(self.derived(substs[0].clone())),
+            TyKind::Ref(.., ty) => Some(self.derived(ty.clone())),
            _ => None,
        }
    }
@@ -1788,10 +1787,30 @@ impl Type {
        return go(&self.ty.value);
        fn go(ty: &Ty) -> bool {
-            if ty.is_unknown() {
+            match ty.interned(&Interner) {
-                true
+                TyKind::Unknown => true,
-            } else {
-                ty.substs().map_or(false, |substs| substs.iter().any(go))
+                TyKind::Adt(_, substs)
+                | TyKind::AssociatedType(_, substs)
+                | TyKind::Tuple(_, substs)
+                | TyKind::OpaqueType(_, substs)
+                | TyKind::FnDef(_, substs)
+                | TyKind::Closure(_, substs) => substs.iter().any(go),
+                TyKind::Array(ty) | TyKind::Slice(ty) | TyKind::Raw(_, ty) | TyKind::Ref(_, ty) => {
+                    go(ty)
+                }
+                TyKind::Scalar(_)
+                | TyKind::Str
+                | TyKind::Never
+                | TyKind::Placeholder(_)
+                | TyKind::BoundVar(_)
+                | TyKind::InferenceVar(_, _)
+                | TyKind::Dyn(_)
+                | TyKind::Function(_)
+                | TyKind::Alias(_)
+                | TyKind::ForeignType(_) => false,
            }
        }
    }
@@ -2020,6 +2039,10 @@ impl Type {
                    walk_bounds(db, &type_.derived(ty.clone()), bounds.as_ref(), cb);
                }
+                TyKind::Ref(_, ty) | TyKind::Raw(_, ty) | TyKind::Array(ty) | TyKind::Slice(ty) => {
+                    walk_type(db, &type_.derived(ty.clone()), cb);
+                }
                _ => {}
            }
            if let Some(substs) = ty.substs() {
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/display.rs b/crates/hir_ty/src/display.rs
index 378c951c5..c1062387e 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -276,20 +276,17 @@ impl HirDisplay for Ty {
            &TyKind::Scalar(Scalar::Float(t)) => write!(f, "{}", primitive::float_ty_to_string(t))?,
            &TyKind::Scalar(Scalar::Int(t)) => write!(f, "{}", primitive::int_ty_to_string(t))?,
            &TyKind::Scalar(Scalar::Uint(t)) => write!(f, "{}", primitive::uint_ty_to_string(t))?,
-            TyKind::Slice(parameters) => {
+            TyKind::Slice(t) => {
-                let t = parameters.as_single();
                write!(f, "[")?;
                t.hir_fmt(f)?;
                write!(f, "]")?;
            }
-            TyKind::Array(parameters) => {
+            TyKind::Array(t) => {
-                let t = parameters.as_single();
                write!(f, "[")?;
                t.hir_fmt(f)?;
                write!(f, "; _]")?;
            }
-            TyKind::Raw(m, parameters) | TyKind::Ref(m, parameters) => {
+            TyKind::Raw(m, t) | TyKind::Ref(m, t) => {
-                let t = parameters.as_single();
                let ty_display =
                    t.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index fbfedb4e6..9c385b845 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -108,6 +108,17 @@ pub struct TypeMismatch {
    pub actual: Ty,
 }
+#[derive(Clone, PartialEq, Eq, Debug)]
+struct InternedStandardTypes {
+    unknown: Ty,
+}
+impl Default for InternedStandardTypes {
+    fn default() -> Self {
+        InternedStandardTypes { unknown: TyKind::Unknown.intern(&Interner) }
+    }
+}
 /// The result of type inference: A mapping from expressions and patterns to types.
 #[derive(Clone, PartialEq, Eq, Debug, Default)]
 pub struct InferenceResult {
@@ -126,6 +137,8 @@ pub struct InferenceResult {
    pub type_of_expr: ArenaMap<ExprId, Ty>,
    pub type_of_pat: ArenaMap<PatId, Ty>,
    pub(super) type_mismatches: ArenaMap<ExprId, TypeMismatch>,
+    /// Interned Unknown to return references to.
+    standard_types: InternedStandardTypes,
 }
 impl InferenceResult {
@@ -170,7 +183,7 @@ impl Index<ExprId> for InferenceResult {
    type Output = Ty;
    fn index(&self, expr: ExprId) -> &Ty {
-        self.type_of_expr.get(expr).unwrap_or(&Ty(TyKind::Unknown))
+        self.type_of_expr.get(expr).unwrap_or(&self.standard_types.unknown)
    }
 }
@@ -178,7 +191,7 @@ impl Index<PatId> for InferenceResult {
    type Output = Ty;
    fn index(&self, pat: PatId) -> &Ty {
-        self.type_of_pat.get(pat).unwrap_or(&Ty(TyKind::Unknown))
+        self.type_of_pat.get(pat).unwrap_or(&self.standard_types.unknown)
    }
 }
@@ -723,14 +736,19 @@ impl Expectation {
    /// This expresses no expectation on the type.
    fn none() -> Self {
-        Expectation { ty: TyKind::Unknown.intern(&Interner), rvalue_hint: false }
+        Expectation {
+            // FIXME
+            ty: TyKind::Unknown.intern(&Interner),
+            rvalue_hint: false,
+        }
    }
-    fn coercion_target(&self) -> &Ty {
+    fn coercion_target(&self) -> Ty {
        if self.rvalue_hint {
-            &Ty(TyKind::Unknown)
+            // FIXME
+            TyKind::Unknown.intern(&Interner)
        } else {
-            &self.ty
+            self.ty.clone()
        }
    }
 }
@@ -784,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 },
    }
@@ -796,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/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 36670043a..137419264 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -71,7 +71,7 @@ impl<'a> InferenceContext<'a> {
        }
        // Pointer weakening and function to pointer
-        match (&mut from_ty.0, to_ty.interned(&Interner)) {
+        match (from_ty.interned_mut(), to_ty.interned(&Interner)) {
            // `*mut T` -> `*const T`
            // `&mut T` -> `&T`
            (TyKind::Raw(m1, ..), TyKind::Raw(m2 @ Mutability::Not, ..))
@@ -111,9 +111,7 @@ impl<'a> InferenceContext<'a> {
        // Auto Deref if cannot coerce
        match (from_ty.interned(&Interner), to_ty.interned(&Interner)) {
            // FIXME: DerefMut
-            (TyKind::Ref(_, st1), TyKind::Ref(_, st2)) => {
+            (TyKind::Ref(_, st1), TyKind::Ref(_, st2)) => self.unify_autoderef_behind_ref(st1, st2),
-                self.unify_autoderef_behind_ref(&st1[0], &st2[0])
-            }
            // Otherwise, normal unify
            _ => self.unify(&from_ty, to_ty),
@@ -178,11 +176,7 @@ impl<'a> InferenceContext<'a> {
            // Stop when constructor matches.
            if from_ty.equals_ctor(&to_ty) {
                // It will not recurse to `coerce`.
-                return match (from_ty.substs(), to_ty.substs()) {
+                return self.table.unify(&from_ty, &to_ty);
-                    (Some(st1), Some(st2)) => self.table.unify_substs(st1, st2, 0),
-                    (None, None) => true,
-                    _ => false,
-                };
            } else if self.table.unify_inner_trivial(&derefed_ty, &to_ty, 0) {
                return true;
            }
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 55163c963..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
                            }
@@ -504,8 +503,8 @@ impl<'a> InferenceContext<'a> {
                };
                let inner_ty = self.infer_expr_inner(*expr, &expectation);
                match rawness {
-                    Rawness::RawPtr => TyKind::Raw(mutability, Substs::single(inner_ty)),
+                    Rawness::RawPtr => TyKind::Raw(mutability, inner_ty),
-                    Rawness::Ref => TyKind::Ref(mutability, Substs::single(inner_ty)),
+                    Rawness::Ref => TyKind::Ref(mutability, inner_ty),
                }
                .intern(&Interner)
            }
@@ -686,7 +685,7 @@ impl<'a> InferenceContext<'a> {
            }
            Expr::Array(array) => {
                let elem_ty = match expected.ty.interned(&Interner) {
-                    TyKind::Array(st) | TyKind::Slice(st) => st.as_single().clone(),
+                    TyKind::Array(st) | TyKind::Slice(st) => st.clone(),
                    _ => self.table.new_type_var(),
                };
@@ -710,18 +709,17 @@ impl<'a> InferenceContext<'a> {
                    }
                }
-                TyKind::Array(Substs::single(elem_ty)).intern(&Interner)
+                TyKind::Array(elem_ty).intern(&Interner)
            }
            Expr::Literal(lit) => match lit {
                Literal::Bool(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
                Literal::String(..) => {
-                    TyKind::Ref(Mutability::Not, Substs::single(TyKind::Str.intern(&Interner)))
+                    TyKind::Ref(Mutability::Not, TyKind::Str.intern(&Interner)).intern(&Interner)
-                        .intern(&Interner)
                }
                Literal::ByteString(..) => {
                    let byte_type = TyKind::Scalar(Scalar::Uint(UintTy::U8)).intern(&Interner);
-                    let array_type = TyKind::Array(Substs::single(byte_type)).intern(&Interner);
+                    let array_type = TyKind::Array(byte_type).intern(&Interner);
-                    TyKind::Ref(Mutability::Not, Substs::single(array_type)).intern(&Interner)
+                    TyKind::Ref(Mutability::Not, array_type).intern(&Interner)
                }
                Literal::Char(..) => TyKind::Scalar(Scalar::Char).intern(&Interner),
                Literal::Int(_v, ty) => match ty {
@@ -800,7 +798,7 @@ impl<'a> InferenceContext<'a> {
                // we don't even make an attempt at coercion
                self.table.new_maybe_never_var()
            } else {
-                self.coerce(&Ty::unit(), expected.coercion_target());
+                self.coerce(&Ty::unit(), &expected.coercion_target());
                Ty::unit()
            }
        };
@@ -855,9 +853,7 @@ impl<'a> InferenceContext<'a> {
        // Apply autoref so the below unification works correctly
        // FIXME: return correct autorefs from lookup_method
        let actual_receiver_ty = match expected_receiver_ty.as_reference() {
-            Some((_, mutability)) => {
+            Some((_, mutability)) => TyKind::Ref(mutability, derefed_receiver_ty).intern(&Interner),
-                TyKind::Ref(mutability, Substs::single(derefed_receiver_ty)).intern(&Interner)
-            }
            _ => derefed_receiver_ty,
        };
        self.unify(&expected_receiver_ty, &actual_receiver_ty);
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index a16755cda..9e8ca18ef 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -158,12 +158,12 @@ impl<'a> InferenceContext<'a> {
                        if mutability != exp_mut {
                            // FIXME: emit type error?
                        }
-                        inner_ty
+                        inner_ty.clone()
                    }
-                    _ => &Ty(TyKind::Unknown),
+                    _ => self.result.standard_types.unknown.clone(),
                };
-                let subty = self.infer_pat(*pat, expectation, default_bm);
+                let subty = self.infer_pat(*pat, &expectation, default_bm);
-                TyKind::Ref(mutability, Substs::single(subty)).intern(&Interner)
+                TyKind::Ref(mutability, subty).intern(&Interner)
            }
            Pat::TupleStruct { path: p, args: subpats, ellipsis } => self.infer_tuple_struct_pat(
                p.as_ref(),
@@ -196,7 +196,7 @@ impl<'a> InferenceContext<'a> {
                let bound_ty = match mode {
                    BindingMode::Ref(mutability) => {
-                        TyKind::Ref(mutability, Substs::single(inner_ty.clone())).intern(&Interner)
+                        TyKind::Ref(mutability, inner_ty.clone()).intern(&Interner)
                    }
                    BindingMode::Move => inner_ty.clone(),
                };
@@ -206,8 +206,8 @@ impl<'a> InferenceContext<'a> {
            }
            Pat::Slice { prefix, slice, suffix } => {
                let (container_ty, elem_ty): (fn(_) -> _, _) = match expected.interned(&Interner) {
-                    TyKind::Array(st) => (TyKind::Array, st.as_single().clone()),
+                    TyKind::Array(st) => (TyKind::Array, st.clone()),
-                    TyKind::Slice(st) => (TyKind::Slice, st.as_single().clone()),
+                    TyKind::Slice(st) => (TyKind::Slice, st.clone()),
                    _ => (TyKind::Slice, self.err_ty()),
                };
@@ -215,7 +215,7 @@ impl<'a> InferenceContext<'a> {
                    self.infer_pat(*pat_id, &elem_ty, default_bm);
                }
-                let pat_ty = container_ty(Substs::single(elem_ty)).intern(&Interner);
+                let pat_ty = container_ty(elem_ty).intern(&Interner);
                if let Some(slice_pat_id) = slice {
                    self.infer_pat(*slice_pat_id, &pat_ty, default_bm);
                }
@@ -232,11 +232,11 @@ impl<'a> InferenceContext<'a> {
            Pat::Box { inner } => match self.resolve_boxed_box() {
                Some(box_adt) => {
                    let inner_expected = match expected.as_adt() {
-                        Some((adt, substs)) if adt == box_adt => substs.as_single(),
+                        Some((adt, substs)) if adt == box_adt => substs.as_single().clone(),
-                        _ => &Ty(TyKind::Unknown),
+                        _ => self.result.standard_types.unknown.clone(),
                    };
-                    let inner_ty = self.infer_pat(*inner, inner_expected, default_bm);
+                    let inner_ty = self.infer_pat(*inner, &inner_expected, default_bm);
                    Ty::adt_ty(box_adt, Substs::single(inner_ty))
                }
                None => self.err_ty(),
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index ebc612ca9..66f8fe8a3 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -7,8 +7,8 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use super::{InferenceContext, Obligation};
 use crate::{
-    BoundVar, Canonical, DebruijnIndex, GenericPredicate, InEnvironment, InferenceVar, Interner,
+    BoundVar, Canonical, DebruijnIndex, FnPointer, GenericPredicate, InEnvironment, InferenceVar,
-    Scalar, Substs, Ty, TyKind, TypeWalk,
+    Interner, Scalar, Substs, Ty, TyKind, TypeWalk,
 };
 impl<'a> InferenceContext<'a> {
@@ -108,7 +108,7 @@ impl<T> Canonicalized<T> {
    pub(super) fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
        ty.walk_mut_binders(
            &mut |ty, binders| {
-                if let &mut TyKind::BoundVar(bound) = &mut ty.0 {
+                if let &mut TyKind::BoundVar(bound) = ty.interned_mut() {
                    if bound.debruijn >= binders {
                        let (v, k) = self.free_vars[bound.index];
                        *ty = TyKind::InferenceVar(v, k).intern(&Interner);
@@ -283,9 +283,23 @@ impl InferenceTable {
        let ty1 = self.resolve_ty_shallow(ty1);
        let ty2 = self.resolve_ty_shallow(ty2);
        if ty1.equals_ctor(&ty2) {
-            match (ty1.substs(), ty2.substs()) {
+            match (ty1.interned(&Interner), ty2.interned(&Interner)) {
-                (Some(st1), Some(st2)) => self.unify_substs(st1, st2, depth + 1),
+                (TyKind::Adt(_, substs1), TyKind::Adt(_, substs2))
-                (None, None) => true,
+                | (TyKind::FnDef(_, substs1), TyKind::FnDef(_, substs2))
+                | (
+                    TyKind::Function(FnPointer { substs: substs1, .. }),
+                    TyKind::Function(FnPointer { substs: substs2, .. }),
+                )
+                | (TyKind::Tuple(_, substs1), TyKind::Tuple(_, substs2))
+                | (TyKind::OpaqueType(_, substs1), TyKind::OpaqueType(_, substs2))
+                | (TyKind::AssociatedType(_, substs1), TyKind::AssociatedType(_, substs2))
+                | (TyKind::Closure(.., substs1), TyKind::Closure(.., substs2)) => {
+                    self.unify_substs(substs1, substs2, depth + 1)
+                }
+                (TyKind::Ref(_, ty1), TyKind::Ref(_, ty2))
+                | (TyKind::Raw(_, ty1), TyKind::Raw(_, ty2))
+                | (TyKind::Array(ty1), TyKind::Array(ty2))
+                | (TyKind::Slice(ty1), TyKind::Slice(ty2)) => self.unify_inner(ty1, ty2, depth + 1),
                _ => false,
            }
        } else {
@@ -404,7 +418,7 @@ impl InferenceTable {
            if i > 0 {
                cov_mark::hit!(type_var_resolves_to_int_var);
            }
-            match &ty.0 {
+            match ty.interned(&Interner) {
                TyKind::InferenceVar(tv, _) => {
                    let inner = tv.to_inner();
                    match self.var_unification_table.inlined_probe_value(inner).known() {
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 484652073..503910dde 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -151,17 +151,17 @@ pub enum TyKind {
    Tuple(usize, Substs),
    /// An array with the given length. Written as `[T; n]`.
-    Array(Substs),
+    Array(Ty),
    /// The pointee of an array slice.  Written as `[T]`.
-    Slice(Substs),
+    Slice(Ty),
    /// A raw pointer. Written as `*mut T` or `*const T`
-    Raw(Mutability, Substs),
+    Raw(Mutability, Ty),
    /// A reference; a pointer with an associated lifetime. Written as
    /// `&'a mut T` or `&'a T`.
-    Ref(Mutability, Substs),
+    Ref(Mutability, Ty),
    /// This represents a placeholder for an opaque type in situations where we
    /// don't know the hidden type (i.e. currently almost always). This is
@@ -248,11 +248,11 @@ pub enum TyKind {
 }
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct Ty(TyKind);
+pub struct Ty(Arc<TyKind>);
 impl TyKind {
    pub fn intern(self, _interner: &Interner) -> Ty {
-        Ty(self)
+        Ty(Arc::new(self))
    }
 }
@@ -260,6 +260,14 @@ impl Ty {
    pub fn interned(&self, _interner: &Interner) -> &TyKind {
        &self.0
    }
+    pub fn interned_mut(&mut self) -> &mut TyKind {
+        Arc::make_mut(&mut self.0)
+    }
+    pub fn into_inner(self) -> TyKind {
+        Arc::try_unwrap(self.0).unwrap_or_else(|a| (*a).clone())
+    }
 }
 /// A list of substitutions for generic parameters.
@@ -665,19 +673,15 @@ impl Ty {
    pub fn as_reference(&self) -> Option<(&Ty, Mutability)> {
        match self.interned(&Interner) {
-            TyKind::Ref(mutability, parameters) => Some((parameters.as_single(), *mutability)),
+            TyKind::Ref(mutability, ty) => Some((ty, *mutability)),
            _ => None,
        }
    }
    pub fn as_reference_or_ptr(&self) -> Option<(&Ty, Rawness, Mutability)> {
        match self.interned(&Interner) {
-            TyKind::Ref(mutability, parameters) => {
+            TyKind::Ref(mutability, ty) => Some((ty, Rawness::Ref, *mutability)),
-                Some((parameters.as_single(), Rawness::Ref, *mutability))
+            TyKind::Raw(mutability, ty) => Some((ty, Rawness::RawPtr, *mutability)),
-            }
-            TyKind::Raw(mutability, parameters) => {
-                Some((parameters.as_single(), Rawness::RawPtr, *mutability))
-            }
            _ => None,
        }
    }
@@ -685,8 +689,8 @@ impl Ty {
    pub fn strip_references(&self) -> &Ty {
        let mut t: &Ty = self;
-        while let TyKind::Ref(_mutability, parameters) = t.interned(&Interner) {
+        while let TyKind::Ref(_mutability, ty) = t.interned(&Interner) {
-            t = parameters.as_single();
+            t = ty;
        }
        t
@@ -772,8 +776,8 @@ impl Ty {
    fn builtin_deref(&self) -> Option<Ty> {
        match self.interned(&Interner) {
-            TyKind::Ref(.., parameters) => Some(Ty::clone(parameters.as_single())),
+            TyKind::Ref(.., ty) => Some(ty.clone()),
-            TyKind::Raw(.., parameters) => Some(Ty::clone(parameters.as_single())),
+            TyKind::Raw(.., ty) => Some(ty.clone()),
            _ => None,
        }
    }
@@ -809,40 +813,11 @@ impl Ty {
        }
    }
-    /// If this is a type with type parameters (an ADT or function), replaces
-    /// the `Substs` for these type parameters with the given ones. (So e.g. if
-    /// `self` is `Option<_>` and the substs contain `u32`, we'll have
-    /// `Option<u32>` afterwards.)
-    pub fn apply_substs(mut self, new_substs: Substs) -> Ty {
-        match &mut self.0 {
-            TyKind::Adt(_, substs)
-            | TyKind::Slice(substs)
-            | TyKind::Array(substs)
-            | TyKind::Raw(_, substs)
-            | TyKind::Ref(_, substs)
-            | TyKind::FnDef(_, substs)
-            | TyKind::Function(FnPointer { substs, .. })
-            | TyKind::Tuple(_, substs)
-            | TyKind::OpaqueType(_, substs)
-            | TyKind::AssociatedType(_, substs)
-            | TyKind::Closure(.., substs) => {
-                assert_eq!(substs.len(), new_substs.len());
-                *substs = new_substs;
-            }
-            _ => (),
-        }
-        self
-    }
    /// Returns the type parameters of this type if it has some (i.e. is an ADT
    /// or function); so if `self` is `Option<u32>`, this returns the `u32`.
    pub fn substs(&self) -> Option<&Substs> {
        match self.interned(&Interner) {
            TyKind::Adt(_, substs)
-            | TyKind::Slice(substs)
-            | TyKind::Array(substs)
-            | TyKind::Raw(_, substs)
-            | TyKind::Ref(_, substs)
            | TyKind::FnDef(_, substs)
            | TyKind::Function(FnPointer { substs, .. })
            | TyKind::Tuple(_, substs)
@@ -853,13 +828,9 @@ impl Ty {
        }
    }
-    pub fn substs_mut(&mut self) -> Option<&mut Substs> {
+    fn substs_mut(&mut self) -> Option<&mut Substs> {
-        match &mut self.0 {
+        match self.interned_mut() {
            TyKind::Adt(_, substs)
-            | TyKind::Slice(substs)
-            | TyKind::Array(substs)
-            | TyKind::Raw(_, substs)
-            | TyKind::Ref(_, substs)
            | TyKind::FnDef(_, substs)
            | TyKind::Function(FnPointer { substs, .. })
            | TyKind::Tuple(_, substs)
@@ -988,7 +959,7 @@ pub trait TypeWalk {
    {
        self.walk_mut_binders(
            &mut |ty_mut, binders| {
-                let ty = mem::replace(ty_mut, Ty(TyKind::Unknown));
+                let ty = mem::replace(ty_mut, TyKind::Unknown.intern(&Interner));
                *ty_mut = f(ty, binders);
            },
            binders,
@@ -1001,7 +972,7 @@ pub trait TypeWalk {
        Self: Sized,
    {
        self.walk_mut(&mut |ty_mut| {
-            let ty = mem::replace(ty_mut, Ty(TyKind::Unknown));
+            let ty = mem::replace(ty_mut, TyKind::Unknown.intern(&Interner));
            *ty_mut = f(ty);
        });
        self
@@ -1022,7 +993,7 @@ pub trait TypeWalk {
    {
        self.walk_mut_binders(
            &mut |ty, binders| {
-                if let &mut TyKind::BoundVar(bound) = &mut ty.0 {
+                if let &mut TyKind::BoundVar(bound) = ty.interned_mut() {
                    if bound.debruijn >= binders {
                        *ty = substs.0[bound.index].clone().shift_bound_vars(binders);
                    }
@@ -1039,7 +1010,7 @@ pub trait TypeWalk {
        Self: Sized,
    {
        self.fold_binders(
-            &mut |ty, binders| match &ty.0 {
+            &mut |ty, binders| match ty.interned(&Interner) {
                TyKind::BoundVar(bound) if bound.debruijn >= binders => {
                    TyKind::BoundVar(bound.shifted_in_from(n)).intern(&Interner)
                }
@@ -1068,6 +1039,9 @@ impl TypeWalk for Ty {
                    p.walk(f);
                }
            }
+            TyKind::Slice(ty) | TyKind::Array(ty) | TyKind::Ref(_, ty) | TyKind::Raw(_, ty) => {
+                ty.walk(f);
+            }
            _ => {
                if let Some(substs) = self.substs() {
                    for t in substs.iter() {
@@ -1084,7 +1058,7 @@ impl TypeWalk for Ty {
        f: &mut impl FnMut(&mut Ty, DebruijnIndex),
        binders: DebruijnIndex,
    ) {
-        match &mut self.0 {
+        match self.interned_mut() {
            TyKind::Alias(AliasTy::Projection(p_ty)) => {
                p_ty.substitution.walk_mut_binders(f, binders);
            }
@@ -1096,6 +1070,9 @@ impl TypeWalk for Ty {
            TyKind::Alias(AliasTy::Opaque(o_ty)) => {
                o_ty.substitution.walk_mut_binders(f, binders);
            }
+            TyKind::Slice(ty) | TyKind::Array(ty) | TyKind::Ref(_, ty) | TyKind::Raw(_, ty) => {
+                ty.walk_mut_binders(f, binders);
+            }
            _ => {
                if let Some(substs) = self.substs_mut() {
                    substs.walk_mut_binders(f, binders);
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index d026310f4..b4c650fa1 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -160,21 +160,19 @@ impl<'a> TyLoweringContext<'a> {
            }
            TypeRef::RawPtr(inner, mutability) => {
                let inner_ty = self.lower_ty(inner);
-                TyKind::Raw(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty))
+                TyKind::Raw(lower_to_chalk_mutability(*mutability), inner_ty).intern(&Interner)
-                    .intern(&Interner)
            }
            TypeRef::Array(inner) => {
                let inner_ty = self.lower_ty(inner);
-                TyKind::Array(Substs::single(inner_ty)).intern(&Interner)
+                TyKind::Array(inner_ty).intern(&Interner)
            }
            TypeRef::Slice(inner) => {
                let inner_ty = self.lower_ty(inner);
-                TyKind::Slice(Substs::single(inner_ty)).intern(&Interner)
+                TyKind::Slice(inner_ty).intern(&Interner)
            }
            TypeRef::Reference(inner, _, mutability) => {
                let inner_ty = self.lower_ty(inner);
-                TyKind::Ref(lower_to_chalk_mutability(*mutability), Substs::single(inner_ty))
+                TyKind::Ref(lower_to_chalk_mutability(*mutability), inner_ty).intern(&Interner)
-                    .intern(&Interner)
            }
            TypeRef::Placeholder => TyKind::Unknown.intern(&Interner),
            TypeRef::Fn(params, is_varargs) => {
@@ -993,7 +991,7 @@ pub(crate) fn generic_defaults_query(
            // Each default can only refer to previous parameters.
            ty.walk_mut_binders(
-                &mut |ty, binders| match &mut ty.0 {
+                &mut |ty, binders| match ty.interned_mut() {
                    TyKind::BoundVar(BoundVar { debruijn, index }) if *debruijn == binders => {
                        if *index >= idx {
                            // type variable default referring to parameter coming
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index 57f37ef4b..be72c4a1c 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -443,8 +443,7 @@ fn iterate_method_candidates_with_autoref(
    }
    let refed = Canonical {
        kinds: deref_chain[0].kinds.clone(),
-        value: TyKind::Ref(Mutability::Not, Substs::single(deref_chain[0].value.clone()))
+        value: TyKind::Ref(Mutability::Not, deref_chain[0].value.clone()).intern(&Interner),
-            .intern(&Interner),
    };
    if iterate_method_candidates_by_receiver(
        &refed,
@@ -460,8 +459,7 @@ fn iterate_method_candidates_with_autoref(
    }
    let ref_muted = Canonical {
        kinds: deref_chain[0].kinds.clone(),
-        value: TyKind::Ref(Mutability::Mut, Substs::single(deref_chain[0].value.clone()))
+        value: TyKind::Ref(Mutability::Mut, deref_chain[0].value.clone()).intern(&Interner),
-            .intern(&Interner),
    };
    if iterate_method_candidates_by_receiver(
        &ref_muted,
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index 05a4bf0df..6a8b6752e 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -24,9 +24,9 @@ use super::*;
 impl ToChalk for Ty {
    type Chalk = chalk_ir::Ty<Interner>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> {
-        match self.0 {
+        match self.into_inner() {
-            TyKind::Ref(m, parameters) => ref_to_chalk(db, m, parameters),
+            TyKind::Ref(m, ty) => ref_to_chalk(db, m, ty),
-            TyKind::Array(parameters) => array_to_chalk(db, parameters),
+            TyKind::Array(ty) => array_to_chalk(db, ty),
            TyKind::Function(FnPointer { sig, substs, .. }) => {
                let substitution = chalk_ir::FnSubst(substs.to_chalk(db).shifted_in(&Interner));
                chalk_ir::TyKind::Function(chalk_ir::FnPointer {
@@ -54,13 +54,11 @@ impl ToChalk for Ty {
                let substitution = substs.to_chalk(db);
                chalk_ir::TyKind::Tuple(cardinality.into(), substitution).intern(&Interner)
            }
-            TyKind::Raw(mutability, substs) => {
+            TyKind::Raw(mutability, ty) => {
-                let ty = substs[0].clone().to_chalk(db);
+                let ty = ty.to_chalk(db);
                chalk_ir::TyKind::Raw(mutability, ty).intern(&Interner)
            }
-            TyKind::Slice(substs) => {
+            TyKind::Slice(ty) => chalk_ir::TyKind::Slice(ty.to_chalk(db)).intern(&Interner),
-                chalk_ir::TyKind::Slice(substs[0].clone().to_chalk(db)).intern(&Interner)
-            }
            TyKind::Str => chalk_ir::TyKind::Str.intern(&Interner),
            TyKind::FnDef(id, substs) => {
                let substitution = substs.to_chalk(db);
@@ -114,7 +112,7 @@ impl ToChalk for Ty {
    fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self {
        match chalk.data(&Interner).kind.clone() {
            chalk_ir::TyKind::Error => TyKind::Unknown,
-            chalk_ir::TyKind::Array(ty, _size) => TyKind::Array(Substs::single(from_chalk(db, ty))),
+            chalk_ir::TyKind::Array(ty, _size) => TyKind::Array(from_chalk(db, ty)),
            chalk_ir::TyKind::Placeholder(idx) => TyKind::Placeholder(idx),
            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => {
                let associated_ty = proj.associated_ty_id;
@@ -168,12 +166,10 @@ impl ToChalk for Ty {
            chalk_ir::TyKind::Tuple(cardinality, subst) => {
                TyKind::Tuple(cardinality, from_chalk(db, subst))
            }
-            chalk_ir::TyKind::Raw(mutability, ty) => {
+            chalk_ir::TyKind::Raw(mutability, ty) => TyKind::Raw(mutability, from_chalk(db, ty)),
-                TyKind::Raw(mutability, Substs::single(from_chalk(db, ty)))
+            chalk_ir::TyKind::Slice(ty) => TyKind::Slice(from_chalk(db, ty)),
-            }
-            chalk_ir::TyKind::Slice(ty) => TyKind::Slice(Substs::single(from_chalk(db, ty))),
            chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
-                TyKind::Ref(mutability, Substs::single(from_chalk(db, ty)))
+                TyKind::Ref(mutability, from_chalk(db, ty))
            }
            chalk_ir::TyKind::Str => TyKind::Str,
            chalk_ir::TyKind::Never => TyKind::Never,
@@ -197,17 +193,17 @@ impl ToChalk for Ty {
 fn ref_to_chalk(
    db: &dyn HirDatabase,
    mutability: chalk_ir::Mutability,
-    subst: Substs,
+    ty: Ty,
 ) -> chalk_ir::Ty<Interner> {
-    let arg = subst[0].clone().to_chalk(db);
+    let arg = ty.to_chalk(db);
    let lifetime = LifetimeData::Static.intern(&Interner);
    chalk_ir::TyKind::Ref(mutability, lifetime, arg).intern(&Interner)
 }
 /// We currently don't model constants, but Chalk does. So, we have to insert a
 /// fake constant here, because Chalks built-in logic may expect it to be there.
-fn array_to_chalk(db: &dyn HirDatabase, subst: Substs) -> chalk_ir::Ty<Interner> {
+fn array_to_chalk(db: &dyn HirDatabase, ty: Ty) -> chalk_ir::Ty<Interner> {
-    let arg = subst[0].clone().to_chalk(db);
+    let arg = ty.to_chalk(db);
    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner);
    let const_ = chalk_ir::ConstData {
        ty: usize_ty,
diff --git a/crates/ide/src/annotations.rs b/crates/ide/src/annotations.rs
index 2e8e82b70..72492f826 100644
--- a/crates/ide/src/annotations.rs
+++ b/crates/ide/src/annotations.rs
@@ -1,12 +1,13 @@
-use hir::Semantics;
+use either::Either;
+use hir::{HasSource, Semantics};
 use ide_db::{
-    base_db::{FileId, FilePosition, FileRange, SourceDatabase},
+    base_db::{FileId, FilePosition, FileRange},
-    RootDatabase, SymbolKind,
+    helpers::visit_file_defs,
+    RootDatabase,
 };
-use syntax::TextRange;
+use syntax::{ast::NameOwner, AstNode, TextRange, TextSize};
 use crate::{
-    file_structure::file_structure,
    fn_references::find_all_methods,
    goto_implementation::goto_implementation,
    references::find_all_refs,
@@ -75,39 +76,56 @@ pub(crate) fn annotations(
        }
    }
-    file_structure(&db.parse(file_id).tree())
+    visit_file_defs(&Semantics::new(db), file_id, &mut |def| match def {
-        .into_iter()
+        Either::Left(def) => {
-        .filter(|node| {
+            let node = match def {
-            matches!(
+                hir::ModuleDef::Const(konst) => {
-                node.kind,
+                    konst.source(db).and_then(|node| range_and_position_of(&node.value))
-                SymbolKind::Trait
+                }
-                    | SymbolKind::Struct
+                hir::ModuleDef::Trait(trait_) => {
-                    | SymbolKind::Enum
+                    trait_.source(db).and_then(|node| range_and_position_of(&node.value))
-                    | SymbolKind::Union
+                }
-                    | SymbolKind::Const
+                hir::ModuleDef::Adt(hir::Adt::Struct(strukt)) => {
-            )
+                    strukt.source(db).and_then(|node| range_and_position_of(&node.value))
-        })
+                }
-        .for_each(|node| {
+                hir::ModuleDef::Adt(hir::Adt::Enum(enum_)) => {
-            if config.annotate_impls && node.kind != SymbolKind::Const {
+                    enum_.source(db).and_then(|node| range_and_position_of(&node.value))
+                }
+                hir::ModuleDef::Adt(hir::Adt::Union(union)) => {
+                    union.source(db).and_then(|node| range_and_position_of(&node.value))
+                }
+                _ => None,
+            };
+            let (offset, range) = match node {
+                Some(node) => node,
+                None => return,
+            };
+            if config.annotate_impls && !matches!(def, hir::ModuleDef::Const(_)) {
                annotations.push(Annotation {
-                    range: node.node_range,
+                    range,
                    kind: AnnotationKind::HasImpls {
-                        position: FilePosition { file_id, offset: node.navigation_range.start() },
+                        position: FilePosition { file_id, offset },
                        data: None,
                    },
                });
            }
            if config.annotate_references {
                annotations.push(Annotation {
-                    range: node.node_range,
+                    range,
                    kind: AnnotationKind::HasReferences {
-                        position: FilePosition { file_id, offset: node.navigation_range.start() },
+                        position: FilePosition { file_id, offset },
                        data: None,
                    },
                });
            }
-        });
+            fn range_and_position_of(node: &dyn NameOwner) -> Option<(TextSize, TextRange)> {
+                Some((node.name()?.syntax().text_range().start(), node.syntax().text_range()))
+            }
+        }
+        Either::Right(_) => (),
+    });
    if config.annotate_method_references {
        annotations.extend(find_all_methods(db, file_id).into_iter().map(|method| Annotation {
@@ -934,4 +952,19 @@ mod tests {
            "#]],
        );
    }
+    #[test]
+    fn test_no_annotations_outside_module_tree() {
+        check(
+            r#"
+//- /foo.rs
+struct Foo;
+//- /lib.rs
+// this file comes last since `check` checks the first file only
+"#,
+            expect![[r#"
+                []
+            "#]],
+        );
+    }
 }
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 27d35de5b..0c7a8fbf8 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -2,11 +2,13 @@ use std::fmt;
 use ast::NameOwner;
 use cfg::CfgExpr;
+use either::Either;
 use hir::{AsAssocItem, HasAttrs, HasSource, HirDisplay, Semantics};
 use ide_assists::utils::test_related_attribute;
 use ide_db::{
    base_db::{FilePosition, FileRange},
    defs::Definition,
+    helpers::visit_file_defs,
    search::SearchScope,
    RootDatabase, SymbolKind,
 };
@@ -102,13 +104,27 @@ impl Runnable {
 // |===
 pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
    let sema = Semantics::new(db);
-    let module = match sema.to_module_def(file_id) {
-        None => return Vec::new(),
-        Some(it) => it,
-    };
    let mut res = Vec::new();
-    runnables_mod(&sema, &mut res, module);
+    visit_file_defs(&sema, file_id, &mut |def| match def {
+        Either::Left(def) => {
+            let runnable = match def {
+                hir::ModuleDef::Module(it) => runnable_mod(&sema, it),
+                hir::ModuleDef::Function(it) => runnable_fn(&sema, it),
+                _ => None,
+            };
+            res.extend(runnable.or_else(|| module_def_doctest(&sema, def)))
+        }
+        Either::Right(impl_) => {
+            res.extend(impl_.items(db).into_iter().filter_map(|assoc| match assoc {
+                hir::AssocItem::Function(it) => {
+                    runnable_fn(&sema, it).or_else(|| module_def_doctest(&sema, it.into()))
+                }
+                hir::AssocItem::Const(it) => module_def_doctest(&sema, it.into()),
+                hir::AssocItem::TypeAlias(it) => module_def_doctest(&sema, it.into()),
+            }))
+        }
+    });
    res
 }
@@ -211,39 +227,6 @@ fn parent_test_module(sema: &Semantics<RootDatabase>, fn_def: &ast::Fn) -> Optio
    })
 }
-fn runnables_mod(sema: &Semantics<RootDatabase>, acc: &mut Vec<Runnable>, module: hir::Module) {
-    acc.extend(module.declarations(sema.db).into_iter().filter_map(|def| {
-        let runnable = match def {
-            hir::ModuleDef::Module(it) => runnable_mod(&sema, it),
-            hir::ModuleDef::Function(it) => runnable_fn(&sema, it),
-            _ => None,
-        };
-        runnable.or_else(|| module_def_doctest(&sema, def))
-    }));
-    acc.extend(module.impl_defs(sema.db).into_iter().flat_map(|it| it.items(sema.db)).filter_map(
-        |def| match def {
-            hir::AssocItem::Function(it) => {
-                runnable_fn(&sema, it).or_else(|| module_def_doctest(&sema, it.into()))
-            }
-            hir::AssocItem::Const(it) => module_def_doctest(&sema, it.into()),
-            hir::AssocItem::TypeAlias(it) => module_def_doctest(&sema, it.into()),
-        },
-    ));
-    for def in module.declarations(sema.db) {
-        if let hir::ModuleDef::Module(submodule) = def {
-            match submodule.definition_source(sema.db).value {
-                hir::ModuleSource::Module(_) => runnables_mod(sema, acc, submodule),
-                hir::ModuleSource::SourceFile(_) => {
-                    cov_mark::hit!(dont_recurse_in_outline_submodules)
-                }
-                hir::ModuleSource::BlockExpr(_) => {} // inner items aren't runnable
-            }
-        }
-    }
-}
 pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) -> Option<Runnable> {
    let func = def.source(sema.db)?;
    let name_string = def.name(sema.db).to_string();
@@ -1178,7 +1161,6 @@ mod tests {
    #[test]
    fn dont_recurse_in_outline_submodules() {
-        cov_mark::check!(dont_recurse_in_outline_submodules);
        check(
            r#"
 //- /lib.rs
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/context.rs b/crates/ide_completion/src/context.rs
index 17d9a3adf..89e9bda78 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -35,6 +35,7 @@ pub(crate) struct CompletionContext<'a> {
    /// The token before the cursor, in the macro-expanded file.
    pub(super) token: SyntaxToken,
    pub(super) krate: Option<hir::Crate>,
+    pub(super) expected_name: Option<String>,
    pub(super) expected_type: Option<Type>,
    pub(super) name_ref_syntax: Option<ast::NameRef>,
    pub(super) function_syntax: Option<ast::Fn>,
@@ -135,6 +136,7 @@ impl<'a> CompletionContext<'a> {
            original_token,
            token,
            krate,
+            expected_name: None,
            expected_type: None,
            name_ref_syntax: None,
            function_syntax: None,
@@ -290,23 +292,96 @@ impl<'a> CompletionContext<'a> {
        file_with_fake_ident: SyntaxNode,
        offset: TextSize,
    ) {
-        // FIXME: this is wrong in at least two cases:
+        let expected = {
-        //  * when there's no token `foo($0)`
+            let mut node = self.token.parent();
-        //  * when there is a token, but it happens to have type of it's own
+            loop {
-        self.expected_type = self
+                let ret = match_ast! {
-            .token
-            .ancestors()
-            .find_map(|node| {
-                let ty = match_ast! {
                    match node {
-                        ast::Pat(it) => self.sema.type_of_pat(&it),
+                        ast::LetStmt(it) => {
-                        ast::Expr(it) => self.sema.type_of_expr(&it),
+                            cov_mark::hit!(expected_type_let_with_leading_char);
-                        _ => return None,
+                            cov_mark::hit!(expected_type_let_without_leading_char);
+                            let ty = it.pat()
+                                .and_then(|pat| self.sema.type_of_pat(&pat));
+                            let name = if let Some(ast::Pat::IdentPat(ident)) = it.pat() {
+                                Some(ident.syntax().text().to_string())
+                            } else {
+                                None
+                            };
+                            (ty, name)
+                        },
+                        ast::ArgList(it) => {
+                            cov_mark::hit!(expected_type_fn_param_with_leading_char);
+                            cov_mark::hit!(expected_type_fn_param_without_leading_char);
+                            ActiveParameter::at_token(
+                                &self.sema,
+                                self.token.clone(),
+                            ).map(|ap| (Some(ap.ty), Some(ap.name)))
+                            .unwrap_or((None, None))
+                        },
+                        ast::RecordExprFieldList(it) => {
+                            cov_mark::hit!(expected_type_struct_field_without_leading_char);
+                            self.token.prev_sibling_or_token()
+                                .and_then(|se| se.into_node())
+                                .and_then(|node| ast::RecordExprField::cast(node))
+                                .and_then(|rf| self.sema.resolve_record_field(&rf))
+                                .map(|f|(
+                                    Some(f.0.signature_ty(self.db)),
+                                    Some(f.0.name(self.db).to_string()),
+                                ))
+                                .unwrap_or((None, None))
+                        },
+                        ast::RecordExprField(it) => {
+                            cov_mark::hit!(expected_type_struct_field_with_leading_char);
+                            self.sema
+                                .resolve_record_field(&it)
+                                .map(|f|(
+                                    Some(f.0.signature_ty(self.db)),
+                                    Some(f.0.name(self.db).to_string()),
+                                ))
+                                .unwrap_or((None, None))
+                        },
+                        ast::MatchExpr(it) => {
+                            cov_mark::hit!(expected_type_match_arm_without_leading_char);
+                            let ty = it.expr()
+                                .and_then(|e| self.sema.type_of_expr(&e));
+                            (ty, None)
+                        },
+                        ast::IdentPat(it) => {
+                            cov_mark::hit!(expected_type_if_let_with_leading_char);
+                            cov_mark::hit!(expected_type_if_let_without_leading_char);
+                            cov_mark::hit!(expected_type_match_arm_with_leading_char);
+                            let ty = self.sema.type_of_pat(&ast::Pat::from(it));
+                            (ty, None)
+                        },
+                        ast::Fn(it) => {
+                            cov_mark::hit!(expected_type_fn_ret_with_leading_char);
+                            cov_mark::hit!(expected_type_fn_ret_without_leading_char);
+                            let ty = self.token.ancestors()
+                                .find_map(|ancestor| ast::Expr::cast(ancestor))
+                                .and_then(|expr| self.sema.type_of_expr(&expr));
+                            (ty, None)
+                        },
+                        _ => {
+                            match node.parent() {
+                                Some(n) => {
+                                    node = n;
+                                    continue;
+                                },
+                                None => (None, None),
+                            }
+                        },
                    }
                };
-                Some(ty)
-            })
+                break ret;
-            .flatten();
+            }
+        };
+        self.expected_type = expected.0;
+        self.expected_name = expected.1;
        self.attribute_under_caret = find_node_at_offset(&file_with_fake_ident, offset);
        // First, let's try to complete a reference to some declaration.
@@ -535,3 +610,197 @@ fn path_or_use_tree_qualifier(path: &ast::Path) -> Option<ast::Path> {
    let use_tree = use_tree_list.syntax().parent().and_then(ast::UseTree::cast)?;
    use_tree.path()
 }
+#[cfg(test)]
+mod tests {
+    use expect_test::{expect, Expect};
+    use hir::HirDisplay;
+    use crate::test_utils::{position, TEST_CONFIG};
+    use super::CompletionContext;
+    fn check_expected_type_and_name(ra_fixture: &str, expect: Expect) {
+        let (db, pos) = position(ra_fixture);
+        let completion_context = CompletionContext::new(&db, pos, &TEST_CONFIG).unwrap();
+        let ty = completion_context
+            .expected_type
+            .map(|t| t.display_test(&db).to_string())
+            .unwrap_or("?".to_owned());
+        let name = completion_context.expected_name.unwrap_or("?".to_owned());
+        expect.assert_eq(&format!("ty: {}, name: {}", ty, name));
+    }
+    #[test]
+    fn expected_type_let_without_leading_char() {
+        cov_mark::check!(expected_type_let_without_leading_char);
+        check_expected_type_and_name(
+            r#"
+fn foo() {
+    let x: u32 = $0;
+}
+"#,
+            expect![[r#"ty: u32, name: x"#]],
+        );
+    }
+    #[test]
+    fn expected_type_let_with_leading_char() {
+        cov_mark::check!(expected_type_let_with_leading_char);
+        check_expected_type_and_name(
+            r#"
+fn foo() {
+    let x: u32 = c$0;
+}
+"#,
+            expect![[r#"ty: u32, name: x"#]],
+        );
+    }
+    #[test]
+    fn expected_type_fn_param_without_leading_char() {
+        cov_mark::check!(expected_type_fn_param_without_leading_char);
+        check_expected_type_and_name(
+            r#"
+fn foo() {
+    bar($0);
+}
+fn bar(x: u32) {}
+"#,
+            expect![[r#"ty: u32, name: x"#]],
+        );
+    }
+    #[test]
+    fn expected_type_fn_param_with_leading_char() {
+        cov_mark::check!(expected_type_fn_param_with_leading_char);
+        check_expected_type_and_name(
+            r#"
+fn foo() {
+    bar(c$0);
+}
+fn bar(x: u32) {}
+"#,
+            expect![[r#"ty: u32, name: x"#]],
+        );
+    }
+    #[test]
+    fn expected_type_struct_field_without_leading_char() {
+        cov_mark::check!(expected_type_struct_field_without_leading_char);
+        check_expected_type_and_name(
+            r#"
+struct Foo { a: u32 }
+fn foo() {
+    Foo { a: $0 };
+}
+"#,
+            expect![[r#"ty: u32, name: a"#]],
+        )
+    }
+    #[test]
+    fn expected_type_struct_field_with_leading_char() {
+        cov_mark::check!(expected_type_struct_field_with_leading_char);
+        check_expected_type_and_name(
+            r#"
+struct Foo { a: u32 }
+fn foo() {
+    Foo { a: c$0 };
+}
+"#,
+            expect![[r#"ty: u32, name: a"#]],
+        );
+    }
+    #[test]
+    fn expected_type_match_arm_without_leading_char() {
+        cov_mark::check!(expected_type_match_arm_without_leading_char);
+        check_expected_type_and_name(
+            r#"
+enum E { X }
+fn foo() {
+   match E::X { $0 }
+}
+"#,
+            expect![[r#"ty: E, name: ?"#]],
+        );
+    }
+    #[test]
+    fn expected_type_match_arm_with_leading_char() {
+        cov_mark::check!(expected_type_match_arm_with_leading_char);
+        check_expected_type_and_name(
+            r#"
+enum E { X }
+fn foo() {
+   match E::X { c$0 }
+}
+"#,
+            expect![[r#"ty: E, name: ?"#]],
+        );
+    }
+    #[test]
+    fn expected_type_if_let_without_leading_char() {
+        cov_mark::check!(expected_type_if_let_without_leading_char);
+        check_expected_type_and_name(
+            r#"
+enum Foo { Bar, Baz, Quux }
+fn foo() {
+    let f = Foo::Quux;
+    if let $0 = f { }
+}
+"#,
+            expect![[r#"ty: (), name: ?"#]],
+        ) // FIXME should be `ty: u32, name: ?`
+    }
+    #[test]
+    fn expected_type_if_let_with_leading_char() {
+        cov_mark::check!(expected_type_if_let_with_leading_char);
+        check_expected_type_and_name(
+            r#"
+enum Foo { Bar, Baz, Quux }
+fn foo() {
+    let f = Foo::Quux;
+    if let c$0 = f { }
+}
+"#,
+            expect![[r#"ty: Foo, name: ?"#]],
+        )
+    }
+    #[test]
+    fn expected_type_fn_ret_without_leading_char() {
+        cov_mark::check!(expected_type_fn_ret_without_leading_char);
+        check_expected_type_and_name(
+            r#"
+fn foo() -> u32 {
+    $0
+}
+"#,
+            expect![[r#"ty: (), name: ?"#]],
+        ) // FIXME this should be `ty: u32, name: ?`
+    }
+    #[test]
+    fn expected_type_fn_ret_with_leading_char() {
+        cov_mark::check!(expected_type_fn_ret_with_leading_char);
+        check_expected_type_and_name(
+            r#"
+fn foo() -> u32 {
+    c$0
+}
+"#,
+            expect![[r#"ty: u32, name: ?"#]],
+        )
+    }
+}
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index 905f0b197..670563e50 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -118,19 +118,6 @@ impl<'a> RenderContext<'a> {
    fn docs(&self, node: impl HasAttrs) -> Option<Documentation> {
        node.docs(self.db())
    }
-    fn expected_name_and_type(&self) -> Option<(String, Type)> {
-        if let Some(record_field) = &self.completion.record_field_syntax {
-            cov_mark::hit!(record_field_type_match);
-            let (struct_field, _local) = self.completion.sema.resolve_record_field(record_field)?;
-            Some((struct_field.name(self.db()).to_string(), struct_field.signature_ty(self.db())))
-        } else if let Some(active_parameter) = &self.completion.active_parameter {
-            cov_mark::hit!(active_param_type_match);
-            Some((active_parameter.name.clone(), active_parameter.ty.clone()))
-        } else {
-            None
-        }
-    }
 }
 /// Generic renderer for completion items.
@@ -256,8 +243,8 @@ impl<'a> Render<'a> {
            relevance.is_local = true;
            item.set_relevance(relevance);
-            if let Some((_expected_name, expected_type)) = self.ctx.expected_name_and_type() {
+            if let Some(expected_type) = self.ctx.completion.expected_type.as_ref() {
-                if ty != expected_type {
+                if &ty != expected_type {
                    if let Some(ty_without_ref) = expected_type.remove_ref() {
                        if relevance_type_match(self.ctx.db().upcast(), &ty, &ty_without_ref) {
                            cov_mark::hit!(suggest_ref);
@@ -329,10 +316,8 @@ impl<'a> Render<'a> {
 fn compute_relevance(ctx: &RenderContext, ty: &Type, name: &str) -> CompletionRelevance {
    let mut res = CompletionRelevance::default();
-    if let Some((expected_name, expected_type)) = ctx.expected_name_and_type() {
+    res.exact_type_match = Some(ty) == ctx.completion.expected_type.as_ref();
-        res.exact_type_match = ty == &expected_type;
+    res.exact_name_match = Some(name) == ctx.completion.expected_name.as_deref();
-        res.exact_name_match = name == &expected_name;
-    }
    res
 }
@@ -852,7 +837,6 @@ fn foo(xs: Vec<i128>)
    #[test]
    fn active_param_relevance() {
-        cov_mark::check!(active_param_type_match);
        check_relevance(
            r#"
 struct S { foo: i64, bar: u32, baz: u32 }
@@ -869,7 +853,6 @@ fn foo(s: S) { test(s.$0) }
    #[test]
    fn record_field_relevances() {
-        cov_mark::check!(record_field_type_match);
        check_relevance(
            r#"
 struct A { foo: i64, bar: u32, baz: u32 }
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/helpers.rs b/crates/ide_db/src/helpers.rs
index 3c95d3cff..9992a92bd 100644
--- a/crates/ide_db/src/helpers.rs
+++ b/crates/ide_db/src/helpers.rs
@@ -2,6 +2,10 @@
 pub mod insert_use;
 pub mod import_assets;
+use std::collections::VecDeque;
+use base_db::FileId;
+use either::Either;
 use hir::{Crate, Enum, ItemInNs, MacroDef, Module, ModuleDef, Name, ScopeDef, Semantics, Trait};
 use syntax::ast::{self, make};
@@ -39,6 +43,30 @@ pub fn mod_path_to_ast(path: &hir::ModPath) -> ast::Path {
    make::path_from_segments(segments, is_abs)
 }
+/// Iterates all `ModuleDef`s and `Impl` blocks of the given file.
+pub fn visit_file_defs(
+    sema: &Semantics<RootDatabase>,
+    file_id: FileId,
+    cb: &mut dyn FnMut(Either<hir::ModuleDef, hir::Impl>),
+) {
+    let db = sema.db;
+    let module = match sema.to_module_def(file_id) {
+        Some(it) => it,
+        None => return,
+    };
+    let mut defs: VecDeque<_> = module.declarations(db).into();
+    while let Some(def) = defs.pop_front() {
+        if let ModuleDef::Module(submodule) = def {
+            if let hir::ModuleSource::Module(_) = submodule.definition_source(db).value {
+                defs.extend(submodule.declarations(db));
+                submodule.impl_defs(db).into_iter().for_each(|impl_| cb(Either::Right(impl_)));
+            }
+        }
+        cb(Either::Left(def));
+    }
+    module.impl_defs(db).into_iter().for_each(|impl_| cb(Either::Right(impl_)));
+}
 /// Helps with finding well-know things inside the standard library. This is
 /// somewhat similar to the known paths infra inside hir, but it different; We
 /// want to make sure that IDE specific paths don't become interesting inside
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 d415ed4d3..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 {