82 files changed, 1255 insertions, 677 deletions
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index 0ef77ef5d..64ccd11ee 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -53,11 +53,15 @@ impl SourceRoot {
 }
 /// `CrateGraph` is a bit of information which turns a set of text files into a
-/// number of Rust crates. Each crate is defined by the `FileId` of its root module,
+/// number of Rust crates.
-/// the set of cfg flags (not yet implemented) and the set of dependencies. Note
+///
-/// that, due to cfg's, there might be several crates for a single `FileId`! As
+/// Each crate is defined by the `FileId` of its root module, the set of enabled
-/// in the rust-lang proper, a crate does not have a name. Instead, names are
+/// `cfg` flags and the set of dependencies.
-/// specified on dependency edges. That is, a crate might be known under
+///
+/// Note that, due to cfg's, there might be several crates for a single `FileId`!
+///
+/// For the purposes of analysis, a crate does not have a name. Instead, names
+/// are specified on dependency edges. That is, a crate might be known under
 /// different names in different dependent crates.
 ///
 /// Note that `CrateGraph` is build-system agnostic: it's a concept of the Rust
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs
index 508ac37c2..c5cf803fd 100644
--- a/crates/hir/src/display.rs
+++ b/crates/hir/src/display.rs
@@ -92,7 +92,7 @@ impl HirDisplay for Function {
            &data.ret_type
        } else {
            match &*data.ret_type {
-                TypeRef::ImplTrait(bounds) => match &bounds[0] {
+                TypeRef::ImplTrait(bounds) => match bounds[0].as_ref() {
                    TypeBound::Path(path) => {
                        path.segments().iter().last().unwrap().args_and_bindings.unwrap().bindings
                            [0]
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index a7c42ca1e..cdf65a044 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -513,9 +513,8 @@ impl Field {
    }
    /// Returns the type as in the signature of the struct (i.e., with
-    /// placeholder types for type parameters). This is good for showing
+    /// placeholder types for type parameters). Only use this in the context of
-    /// signature help, but not so good to actually get the type of the field
+    /// the field definition.
-    /// when you actually have a variable of the struct.
    pub fn ty(&self, db: &dyn HirDatabase) -> Type {
        let var_id = self.parent.into();
        let generic_def_id: GenericDefId = match self.parent {
@@ -552,10 +551,6 @@ impl Struct {
        Module { id: self.id.lookup(db.upcast()).container }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
-        Some(self.module(db).krate())
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
        db.struct_data(self.id).name.clone()
    }
@@ -640,10 +635,6 @@ impl Enum {
        Module { id: self.id.lookup(db.upcast()).container }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
-        Some(self.module(db).krate())
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
        db.enum_data(self.id).name.clone()
    }
@@ -673,6 +664,7 @@ impl Variant {
    pub fn module(self, db: &dyn HirDatabase) -> Module {
        self.parent.module(db)
    }
    pub fn parent_enum(self, _db: &dyn HirDatabase) -> Enum {
        self.parent
    }
@@ -729,10 +721,6 @@ impl Adt {
        }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
        match self {
            Adt::Struct(s) => s.name(db),
@@ -821,10 +809,6 @@ impl Function {
        self.id.lookup(db.upcast()).module(db.upcast()).into()
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
-        Some(self.module(db).krate())
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Name {
        db.function_data(self.id).name.clone()
    }
@@ -1014,10 +998,6 @@ impl Const {
        Module { id: self.id.lookup(db.upcast()).module(db.upcast()) }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
-        Some(self.module(db).krate())
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
        db.const_data(self.id).name.clone()
    }
@@ -1045,10 +1025,6 @@ impl Static {
        Module { id: self.id.lookup(db.upcast()).module(db.upcast()) }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
-        Some(self.module(db).krate())
-    }
    pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
        db.static_data(self.id).name.clone()
    }
@@ -1112,10 +1088,6 @@ impl TypeAlias {
        Module { id: self.id.lookup(db.upcast()).module(db.upcast()) }
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
-        self.module(db).krate()
-    }
    pub fn type_ref(self, db: &dyn HirDatabase) -> Option<TypeRef> {
        db.type_alias_data(self.id).type_ref.as_deref().cloned()
    }
@@ -1667,10 +1639,6 @@ impl Impl {
        self.id.lookup(db.upcast()).container.into()
    }
-    pub fn krate(self, db: &dyn HirDatabase) -> Crate {
-        Crate { id: self.module(db).id.krate() }
-    }
    pub fn is_builtin_derive(self, db: &dyn HirDatabase) -> Option<InFile<ast::Attr>> {
        let src = self.source(db)?;
        let item = src.file_id.is_builtin_derive(db.upcast())?;
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index 1b5064b5a..8d3c43d08 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -11,7 +11,7 @@ use hir_def::{
    AsMacroCall, FunctionId, TraitId, VariantId,
 };
 use hir_expand::{name::AsName, ExpansionInfo};
-use hir_ty::associated_type_shorthand_candidates;
+use hir_ty::{associated_type_shorthand_candidates, Interner};
 use itertools::Itertools;
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::{
@@ -120,10 +120,10 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    pub fn speculative_expand(
        &self,
        actual_macro_call: &ast::MacroCall,
-        hypothetical_args: &ast::TokenTree,
+        speculative_args: &ast::TokenTree,
        token_to_map: SyntaxToken,
    ) -> Option<(SyntaxNode, SyntaxToken)> {
-        self.imp.speculative_expand(actual_macro_call, hypothetical_args, token_to_map)
+        self.imp.speculative_expand(actual_macro_call, speculative_args, token_to_map)
    }
    pub fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
@@ -227,7 +227,7 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
    pub fn resolve_record_field(
        &self,
        field: &ast::RecordExprField,
-    ) -> Option<(Field, Option<Local>)> {
+    ) -> Option<(Field, Option<Local>, Type)> {
        self.imp.resolve_record_field(field)
    }
@@ -335,7 +335,7 @@ impl<'db> SemanticsImpl<'db> {
    fn speculative_expand(
        &self,
        actual_macro_call: &ast::MacroCall,
-        hypothetical_args: &ast::TokenTree,
+        speculative_args: &ast::TokenTree,
        token_to_map: SyntaxToken,
    ) -> Option<(SyntaxNode, SyntaxToken)> {
        let sa = self.analyze(actual_macro_call.syntax());
@@ -344,10 +344,10 @@ impl<'db> SemanticsImpl<'db> {
        let macro_call_id = macro_call.as_call_id(self.db.upcast(), krate, |path| {
            sa.resolver.resolve_path_as_macro(self.db.upcast(), &path)
        })?;
-        hir_expand::db::expand_hypothetical(
+        hir_expand::db::expand_speculative(
            self.db.upcast(),
            macro_call_id,
-            hypothetical_args,
+            speculative_args,
            token_to_map,
        )
    }
@@ -501,14 +501,12 @@ impl<'db> SemanticsImpl<'db> {
    }
    fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<FunctionId> {
-        self.analyze(call.syntax()).resolve_method_call(self.db, call)
+        self.analyze(call.syntax()).resolve_method_call(self.db, call).map(|(id, _)| id)
    }
    fn resolve_method_call_as_callable(&self, call: &ast::MethodCallExpr) -> Option<Callable> {
-        // FIXME: this erases Substs, we should instead record the correct
+        let (func, subst) = self.analyze(call.syntax()).resolve_method_call(self.db, call)?;
-        // substitution during inference and use that
+        let ty = self.db.value_ty(func.into()).substitute(&Interner, &subst);
-        let func = self.resolve_method_call(call)?;
-        let ty = hir_ty::TyBuilder::value_ty(self.db, func.into()).fill_with_unknown().build();
        let resolver = self.analyze(call.syntax()).resolver;
        let ty = Type::new_with_resolver(self.db, &resolver, ty)?;
        let mut res = ty.as_callable(self.db)?;
@@ -520,7 +518,10 @@ impl<'db> SemanticsImpl<'db> {
        self.analyze(field.syntax()).resolve_field(self.db, field)
    }
-    fn resolve_record_field(&self, field: &ast::RecordExprField) -> Option<(Field, Option<Local>)> {
+    fn resolve_record_field(
+        &self,
+        field: &ast::RecordExprField,
+    ) -> Option<(Field, Option<Local>, Type)> {
        self.analyze(field.syntax()).resolve_record_field(self.db, field)
    }
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 20753314d..3f940124c 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -143,7 +143,7 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        call: &ast::MethodCallExpr,
-    ) -> Option<FunctionId> {
+    ) -> Option<(FunctionId, Substitution)> {
        let expr_id = self.expr_id(db, &call.clone().into())?;
        self.infer.as_ref()?.method_resolution(expr_id)
    }
@@ -161,7 +161,7 @@ impl SourceAnalyzer {
        &self,
        db: &dyn HirDatabase,
        field: &ast::RecordExprField,
-    ) -> Option<(Field, Option<Local>)> {
+    ) -> Option<(Field, Option<Local>, Type)> {
        let record_expr = ast::RecordExpr::cast(field.syntax().parent().and_then(|p| p.parent())?)?;
        let expr = ast::Expr::from(record_expr);
        let expr_id = self.body_source_map.as_ref()?.node_expr(InFile::new(self.file_id, &expr))?;
@@ -178,10 +178,13 @@ impl SourceAnalyzer {
                _ => None,
            }
        };
+        let (_, subst) = self.infer.as_ref()?.type_of_expr.get(expr_id)?.as_adt()?;
        let variant = self.infer.as_ref()?.variant_resolution_for_expr(expr_id)?;
        let variant_data = variant.variant_data(db.upcast());
        let field = FieldId { parent: variant, local_id: variant_data.field(&local_name)? };
-        Some((field.into(), local))
+        let field_ty =
+            db.field_types(variant).get(field.local_id)?.clone().substitute(&Interner, subst);
+        Some((field.into(), local, Type::new_with_resolver(db, &self.resolver, field_ty)?))
    }
    pub(crate) fn resolve_record_pat_field(
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index 89a1ea770..385ba8c80 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -105,7 +105,7 @@ impl RawAttrs {
                Either::Left(attr) => Attr::from_src(db, attr, hygiene, id),
                Either::Right(comment) => comment.doc_comment().map(|doc| Attr {
                    id,
-                    input: Some(AttrInput::Literal(SmolStr::new(doc))),
+                    input: Some(Interned::new(AttrInput::Literal(SmolStr::new(doc)))),
                    path: Interned::new(ModPath::from(hir_expand::name!(doc))),
                }),
            })
@@ -151,7 +151,7 @@ impl RawAttrs {
                    return smallvec![attr.clone()];
                }
-                let subtree = match &attr.input {
+                let subtree = match attr.input.as_deref() {
                    Some(AttrInput::TokenTree(it)) => it,
                    _ => return smallvec![attr.clone()],
                };
@@ -251,7 +251,7 @@ impl Attrs {
    }
    pub fn docs(&self) -> Option<Documentation> {
-        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_ref()? {
+        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_deref()? {
            AttrInput::Literal(s) => Some(s),
            AttrInput::TokenTree(_) => None,
        });
@@ -454,7 +454,7 @@ impl AttrsWithOwner {
        db: &dyn DefDatabase,
    ) -> Option<(Documentation, DocsRangeMap)> {
        // FIXME: code duplication in `docs` above
-        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_ref()? {
+        let docs = self.by_key("doc").attrs().flat_map(|attr| match attr.input.as_deref()? {
            AttrInput::Literal(s) => Some((s, attr.id)),
            AttrInput::TokenTree(_) => None,
        });
@@ -637,10 +637,10 @@ pub(crate) struct AttrId {
 pub struct Attr {
    pub(crate) id: AttrId,
    pub(crate) path: Interned<ModPath>,
-    pub(crate) input: Option<AttrInput>,
+    pub(crate) input: Option<Interned<AttrInput>>,
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum AttrInput {
    /// `#[attr = "string"]`
    Literal(SmolStr),
@@ -670,9 +670,9 @@ impl Attr {
                ast::LiteralKind::String(string) => string.value()?.into(),
                _ => lit.syntax().first_token()?.text().trim_matches('"').into(),
            };
-            Some(AttrInput::Literal(value))
+            Some(Interned::new(AttrInput::Literal(value)))
        } else if let Some(tt) = ast.token_tree() {
-            Some(AttrInput::TokenTree(ast_to_token_tree(&tt).0))
+            Some(Interned::new(AttrInput::TokenTree(ast_to_token_tree(&tt).0)))
        } else {
            None
        };
@@ -688,7 +688,7 @@ impl Attr {
            return None;
        }
-        match &self.input {
+        match self.input.as_deref() {
            Some(AttrInput::TokenTree(args)) => {
                let mut counter = 0;
                let paths = args
@@ -720,7 +720,7 @@ impl Attr {
    }
    pub fn string_value(&self) -> Option<&SmolStr> {
-        match self.input.as_ref()? {
+        match self.input.as_deref()? {
            AttrInput::Literal(it) => Some(it),
            _ => None,
        }
@@ -735,14 +735,14 @@ pub struct AttrQuery<'a> {
 impl<'a> AttrQuery<'a> {
    pub fn tt_values(self) -> impl Iterator<Item = &'a Subtree> {
-        self.attrs().filter_map(|attr| match attr.input.as_ref()? {
+        self.attrs().filter_map(|attr| match attr.input.as_deref()? {
            AttrInput::TokenTree(it) => Some(it),
            _ => None,
        })
    }
    pub fn string_value(self) -> Option<&'a SmolStr> {
-        self.attrs().find_map(|attr| match attr.input.as_ref()? {
+        self.attrs().find_map(|attr| match attr.input.as_deref()? {
            AttrInput::Literal(it) => Some(it),
            _ => None,
        })
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
index 135a6698e..8bcac60ef 100644
--- a/crates/hir_def/src/data.rs
+++ b/crates/hir_def/src/data.rs
@@ -112,7 +112,7 @@ pub struct TypeAliasData {
    pub visibility: RawVisibility,
    pub is_extern: bool,
    /// Bounds restricting the type alias itself (eg. `type Ty: Bound;` in a trait or impl).
-    pub bounds: Vec<TypeBound>,
+    pub bounds: Vec<Interned<TypeBound>>,
 }
 impl TypeAliasData {
@@ -141,7 +141,7 @@ pub struct TraitData {
    pub is_auto: bool,
    pub is_unsafe: bool,
    pub visibility: RawVisibility,
-    pub bounds: Box<[TypeBound]>,
+    pub bounds: Box<[Interned<TypeBound>]>,
 }
 impl TraitData {
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index de5acced8..44d22b918 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -68,9 +68,19 @@ pub struct GenericParams {
 /// associated type bindings like `Iterator<Item = u32>`.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub enum WherePredicate {
-    TypeBound { target: WherePredicateTypeTarget, bound: TypeBound },
+    TypeBound {
-    Lifetime { target: LifetimeRef, bound: LifetimeRef },
+        target: WherePredicateTypeTarget,
-    ForLifetime { lifetimes: Box<[Name]>, target: WherePredicateTypeTarget, bound: TypeBound },
+        bound: Interned<TypeBound>,
+    },
+    Lifetime {
+        target: LifetimeRef,
+        bound: LifetimeRef,
+    },
+    ForLifetime {
+        lifetimes: Box<[Name]>,
+        target: WherePredicateTypeTarget,
+        bound: Interned<TypeBound>,
+    },
 }
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -339,11 +349,11 @@ impl GenericParams {
                Some(hrtb_lifetimes) => WherePredicate::ForLifetime {
                    lifetimes: hrtb_lifetimes.clone(),
                    target: WherePredicateTypeTarget::TypeRef(Interned::new(type_ref)),
-                    bound,
+                    bound: Interned::new(bound),
                },
                None => WherePredicate::TypeBound {
                    target: WherePredicateTypeTarget::TypeRef(Interned::new(type_ref)),
-                    bound,
+                    bound: Interned::new(bound),
                },
            },
            (Either::Right(lifetime), TypeBound::Lifetime(bound)) => {
diff --git a/crates/hir_def/src/intern.rs b/crates/hir_def/src/intern.rs
index 5cc7f2df6..79ba970e7 100644
--- a/crates/hir_def/src/intern.rs
+++ b/crates/hir_def/src/intern.rs
@@ -216,7 +216,10 @@ pub use crate::_impl_internable as impl_internable;
 impl_internable!(
    crate::type_ref::TypeRef,
    crate::type_ref::TraitRef,
+    crate::type_ref::TypeBound,
    crate::path::ModPath,
+    crate::path::GenericArgs,
+    crate::attr::AttrInput,
    GenericParams,
    str,
 );
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 528270d49..11767d100 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -1,4 +1,34 @@
 //! A simplified AST that only contains items.
+//!
+//! This is the primary IR used throughout `hir_def`. It is the input to the name resolution
+//! algorithm, as well as to the queries defined in `adt.rs`, `data.rs`, and most things in
+//! `attr.rs`.
+//!
+//! `ItemTree`s are built per `HirFileId`, from the syntax tree of the parsed file. This means that
+//! they are crate-independent: they don't know which `#[cfg]`s are active or which module they
+//! belong to, since those concepts don't exist at this level (a single `ItemTree` might be part of
+//! multiple crates, or might be included into the same crate twice via `#[path]`).
+//!
+//! One important purpose of this layer is to provide an "invalidation barrier" for incremental
+//! computations: when typing inside an item body, the `ItemTree` of the modified file is typically
+//! unaffected, so we don't have to recompute name resolution results or item data (see `data.rs`).
+//!
+//! The `ItemTree` for the currently open file can be displayed by using the VS Code command
+//! "Rust Analyzer: Debug ItemTree".
+//!
+//! Compared to rustc's architecture, `ItemTree` has properties from both rustc's AST and HIR: many
+//! syntax-level Rust features are already desugared to simpler forms in the `ItemTree`, but name
+//! resolution has not yet been performed. `ItemTree`s are per-file, while rustc's AST and HIR are
+//! per-crate, because we are interested in incrementally computing it.
+//!
+//! The representation of items in the `ItemTree` should generally mirror the surface syntax: it is
+//! usually a bad idea to desugar a syntax-level construct to something that is structurally
+//! different here. Name resolution needs to be able to process attributes and expand macros
+//! (including attribute macros), and having a 1-to-1 mapping between syntax and the `ItemTree`
+//! avoids introducing subtle bugs.
+//!
+//! In general, any item in the `ItemTree` stores its `AstId`, which allows mapping it back to its
+//! surface syntax.
 mod lower;
 mod pretty;
@@ -500,8 +530,8 @@ pub struct Import {
    pub alias: Option<ImportAlias>,
    pub visibility: RawVisibilityId,
    pub is_glob: bool,
-    /// AST ID of the `use` or `extern crate` item this import was derived from. Note that many
+    /// AST ID of the `use` item this import was derived from. Note that many `Import`s can map to
-    /// `Import`s can map to the same `use` item.
+    /// the same `use` item.
    pub ast_id: FileAstId<ast::Use>,
    /// Index of this `Import` when the containing `Use` is visited via `ModPath::expand_use_item`.
    ///
@@ -614,7 +644,7 @@ pub struct Trait {
    pub generic_params: Interned<GenericParams>,
    pub is_auto: bool,
    pub is_unsafe: bool,
-    pub bounds: Box<[TypeBound]>,
+    pub bounds: Box<[Interned<TypeBound>]>,
    pub items: Box<[AssocItem]>,
    pub ast_id: FileAstId<ast::Trait>,
 }
@@ -634,7 +664,7 @@ pub struct TypeAlias {
    pub name: Name,
    pub visibility: RawVisibilityId,
    /// Bounds on the type alias itself. Only valid in trait declarations, eg. `type Assoc: Copy;`.
-    pub bounds: Box<[TypeBound]>,
+    pub bounds: Box<[Interned<TypeBound>]>,
    pub generic_params: Interned<GenericParams>,
    pub type_ref: Option<Interned<TypeRef>>,
    pub is_extern: bool,
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index 91cf75371..b4389371f 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -384,7 +384,7 @@ impl<'a> Ctx<'a> {
        let ret_type = if func.async_token().is_some() {
            let future_impl = desugar_future_path(ret_type);
-            let ty_bound = TypeBound::Path(future_impl);
+            let ty_bound = Interned::new(TypeBound::Path(future_impl));
            TypeRef::ImplTrait(vec![ty_bound])
        } else {
            ret_type
@@ -738,11 +738,12 @@ impl<'a> Ctx<'a> {
        Interned::new(generics)
    }
-    fn lower_type_bounds(&mut self, node: &impl ast::TypeBoundsOwner) -> Vec<TypeBound> {
+    fn lower_type_bounds(&mut self, node: &impl ast::TypeBoundsOwner) -> Vec<Interned<TypeBound>> {
        match node.type_bound_list() {
-            Some(bound_list) => {
+            Some(bound_list) => bound_list
-                bound_list.bounds().map(|it| TypeBound::from_ast(&self.body_ctx, it)).collect()
+                .bounds()
-            }
+                .map(|it| Interned::new(TypeBound::from_ast(&self.body_ctx, it)))
+                .collect(),
            None => Vec::new(),
        }
    }
@@ -810,7 +811,7 @@ fn desugar_future_path(orig: TypeRef) -> Path {
    let binding =
        AssociatedTypeBinding { name: name![Output], type_ref: Some(orig), bounds: Vec::new() };
    last.bindings.push(binding);
-    generic_args.push(Some(Arc::new(last)));
+    generic_args.push(Some(Interned::new(last)));
    Path::from_known_path(path, generic_args)
 }
diff --git a/crates/hir_def/src/item_tree/pretty.rs b/crates/hir_def/src/item_tree/pretty.rs
index 4bc87a0e2..9394a5de6 100644
--- a/crates/hir_def/src/item_tree/pretty.rs
+++ b/crates/hir_def/src/item_tree/pretty.rs
@@ -513,13 +513,13 @@ impl<'a> Printer<'a> {
        }
    }
-    fn print_type_bounds(&mut self, bounds: &[TypeBound]) {
+    fn print_type_bounds(&mut self, bounds: &[Interned<TypeBound>]) {
        for (i, bound) in bounds.iter().enumerate() {
            if i != 0 {
                w!(self, " + ");
            }
-            match bound {
+            match bound.as_ref() {
                TypeBound::Path(path) => self.print_path(path),
                TypeBound::Lifetime(lt) => w!(self, "{}", lt.name),
                TypeBound::Error => w!(self, "{{unknown}}"),
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index a82ea5957..70001cac8 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -485,6 +485,14 @@ impl VariantId {
            VariantId::UnionId(it) => it.lookup(db).id.file_id(),
        }
    }
+    pub fn adt_id(self) -> AdtId {
+        match self {
+            VariantId::EnumVariantId(it) => it.parent.into(),
+            VariantId::StructId(it) => it.into(),
+            VariantId::UnionId(it) => it.into(),
+        }
+    }
 }
 trait Intern {
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 014ea4de4..2ae740d0e 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -285,7 +285,7 @@ impl DefCollector<'_> {
                let registered_name = if *attr_name == hir_expand::name![register_attr]
                    || *attr_name == hir_expand::name![register_tool]
                {
-                    match &attr.input {
+                    match attr.input.as_deref() {
                        Some(AttrInput::TokenTree(subtree)) => match &*subtree.token_trees {
                            [tt::TokenTree::Leaf(tt::Leaf::Ident(name))] => name.as_name(),
                            _ => continue,
diff --git a/crates/hir_def/src/path.rs b/crates/hir_def/src/path.rs
index 9b8873fd2..45ab9d0ff 100644
--- a/crates/hir_def/src/path.rs
+++ b/crates/hir_def/src/path.rs
@@ -4,7 +4,6 @@ mod lower;
 use std::{
    fmt::{self, Display},
    iter,
-    sync::Arc,
 };
 use crate::{body::LowerCtx, db::DefDatabase, intern::Interned, type_ref::LifetimeRef};
@@ -136,7 +135,7 @@ pub struct Path {
    type_anchor: Option<Interned<TypeRef>>,
    mod_path: Interned<ModPath>,
    /// Invariant: the same len as `self.mod_path.segments`
-    generic_args: Vec<Option<Arc<GenericArgs>>>,
+    generic_args: Vec<Option<Interned<GenericArgs>>>,
 }
 /// Generic arguments to a path segment (e.g. the `i32` in `Option<i32>`). This
@@ -165,7 +164,7 @@ pub struct AssociatedTypeBinding {
    /// Bounds for the associated type, like in `Iterator<Item:
    /// SomeOtherTrait>`. (This is the unstable `associated_type_bounds`
    /// feature.)
-    pub bounds: Vec<TypeBound>,
+    pub bounds: Vec<Interned<TypeBound>>,
 }
 /// A single generic argument.
@@ -185,7 +184,7 @@ impl Path {
    /// Converts a known mod path to `Path`.
    pub(crate) fn from_known_path(
        path: ModPath,
-        generic_args: Vec<Option<Arc<GenericArgs>>>,
+        generic_args: Vec<Option<Interned<GenericArgs>>>,
    ) -> Path {
        Path { type_anchor: None, mod_path: Interned::new(path), generic_args }
    }
@@ -239,7 +238,7 @@ pub struct PathSegment<'a> {
 pub struct PathSegments<'a> {
    segments: &'a [Name],
-    generic_args: &'a [Option<Arc<GenericArgs>>],
+    generic_args: &'a [Option<Interned<GenericArgs>>],
 }
 impl<'a> PathSegments<'a> {
diff --git a/crates/hir_def/src/path/lower.rs b/crates/hir_def/src/path/lower.rs
index a873325b2..5d5dd9c8f 100644
--- a/crates/hir_def/src/path/lower.rs
+++ b/crates/hir_def/src/path/lower.rs
@@ -3,7 +3,6 @@
 mod lower_use;
 use crate::intern::Interned;
-use std::sync::Arc;
 use either::Either;
 use hir_expand::name::{name, AsName};
@@ -48,7 +47,7 @@ pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx) -> Option<Path> {
                                    segment.ret_type(),
                                )
                            })
-                            .map(Arc::new);
+                            .map(Interned::new);
                        segments.push(name);
                        generic_args.push(args)
                    }
@@ -87,13 +86,13 @@ pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx) -> Option<Path> {
                        // Insert the type reference (T in the above example) as Self parameter for the trait
                        let last_segment =
                            generic_args.iter_mut().rev().nth(num_segments.saturating_sub(1))?;
-                        if last_segment.is_none() {
+                        let mut args_inner = match last_segment {
-                            *last_segment = Some(Arc::new(GenericArgs::empty()));
+                            Some(it) => it.as_ref().clone(),
+                            None => GenericArgs::empty(),
                        };
-                        let args = last_segment.as_mut().unwrap();
-                        let mut args_inner = Arc::make_mut(args);
                        args_inner.has_self_type = true;
                        args_inner.args.insert(0, GenericArg::Type(self_type));
+                        *last_segment = Some(Interned::new(args_inner));
                    }
                }
            }
@@ -171,7 +170,9 @@ pub(super) fn lower_generic_args(
                    let name = name_ref.as_name();
                    let type_ref = assoc_type_arg.ty().map(|it| TypeRef::from_ast(lower_ctx, it));
                    let bounds = if let Some(l) = assoc_type_arg.type_bound_list() {
-                        l.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect()
+                        l.bounds()
+                            .map(|it| Interned::new(TypeBound::from_ast(lower_ctx, it)))
+                            .collect()
                    } else {
                        Vec::new()
                    };
diff --git a/crates/hir_def/src/type_ref.rs b/crates/hir_def/src/type_ref.rs
index cdcab7110..cbde6b940 100644
--- a/crates/hir_def/src/type_ref.rs
+++ b/crates/hir_def/src/type_ref.rs
@@ -5,7 +5,7 @@ use hir_expand::{name::Name, AstId, InFile};
 use std::convert::TryInto;
 use syntax::ast;
-use crate::{body::LowerCtx, path::Path};
+use crate::{body::LowerCtx, intern::Interned, path::Path};
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub enum Mutability {
@@ -91,8 +91,8 @@ pub enum TypeRef {
    /// A fn pointer. Last element of the vector is the return type.
    Fn(Vec<TypeRef>, bool /*varargs*/),
    // For
-    ImplTrait(Vec<TypeBound>),
+    ImplTrait(Vec<Interned<TypeBound>>),
-    DynTrait(Vec<TypeBound>),
+    DynTrait(Vec<Interned<TypeBound>>),
    Macro(AstId<ast::MacroCall>),
    Error,
 }
@@ -232,7 +232,7 @@ impl TypeRef {
                | TypeRef::Slice(type_ref) => go(&type_ref, f),
                TypeRef::ImplTrait(bounds) | TypeRef::DynTrait(bounds) => {
                    for bound in bounds {
-                        match bound {
+                        match bound.as_ref() {
                            TypeBound::Path(path) => go_path(path, f),
                            TypeBound::Lifetime(_) | TypeBound::Error => (),
                        }
@@ -262,7 +262,7 @@ impl TypeRef {
                            go(type_ref, f);
                        }
                        for bound in &binding.bounds {
-                            match bound {
+                            match bound.as_ref() {
                                TypeBound::Path(path) => go_path(path, f),
                                TypeBound::Lifetime(_) | TypeBound::Error => (),
                            }
@@ -277,9 +277,9 @@ impl TypeRef {
 pub(crate) fn type_bounds_from_ast(
    lower_ctx: &LowerCtx,
    type_bounds_opt: Option<ast::TypeBoundList>,
-) -> Vec<TypeBound> {
+) -> Vec<Interned<TypeBound>> {
    if let Some(type_bounds) = type_bounds_opt {
-        type_bounds.bounds().map(|it| TypeBound::from_ast(lower_ctx, it)).collect()
+        type_bounds.bounds().map(|it| Interned::new(TypeBound::from_ast(lower_ctx, it))).collect()
    } else {
        vec![]
    }
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 5c769c1bf..625c26f0a 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -131,15 +131,15 @@ pub trait AstDatabase: SourceDatabase {
 /// used for completion, where we want to see what 'would happen' if we insert a
 /// token. The `token_to_map` mapped down into the expansion, with the mapped
 /// token returned.
-pub fn expand_hypothetical(
+pub fn expand_speculative(
    db: &dyn AstDatabase,
    actual_macro_call: MacroCallId,
-    hypothetical_args: &ast::TokenTree,
+    speculative_args: &ast::TokenTree,
    token_to_map: SyntaxToken,
 ) -> Option<(SyntaxNode, SyntaxToken)> {
-    let (tt, tmap_1) = mbe::syntax_node_to_token_tree(hypothetical_args.syntax());
+    let (tt, tmap_1) = mbe::syntax_node_to_token_tree(speculative_args.syntax());
    let range =
-        token_to_map.text_range().checked_sub(hypothetical_args.syntax().text_range().start())?;
+        token_to_map.text_range().checked_sub(speculative_args.syntax().text_range().start())?;
    let token_id = tmap_1.token_by_range(range)?;
    let macro_def = {
@@ -147,15 +147,15 @@ pub fn expand_hypothetical(
        db.macro_def(loc.def)?
    };
-    let hypothetical_expansion = macro_def.expand(db, actual_macro_call, &tt);
+    let speculative_expansion = macro_def.expand(db, actual_macro_call, &tt);
    let fragment_kind = macro_fragment_kind(db, actual_macro_call);
    let (node, tmap_2) =
-        mbe::token_tree_to_syntax_node(&hypothetical_expansion.value, fragment_kind).ok()?;
+        mbe::token_tree_to_syntax_node(&speculative_expansion.value, fragment_kind).ok()?;
    let token_id = macro_def.map_id_down(token_id);
-    let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
+    let range = tmap_2.range_by_token(token_id, token_to_map.kind())?;
    let token = node.syntax_node().covering_element(range).into_token()?;
    Some((node.syntax_node(), token))
 }
@@ -325,7 +325,7 @@ fn macro_expand_with_arg(
    if let Some(eager) = &loc.eager {
        if arg.is_some() {
            return ExpandResult::str_err(
-                "hypothetical macro expansion not implemented for eager macro".to_owned(),
+                "speculative macro expansion not implemented for eager macro".to_owned(),
            );
        } else {
            return ExpandResult {
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index 38e09fdd4..d98913907 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -154,7 +154,7 @@ impl HygieneInfo {
            },
        };
-        let range = token_map.range_by_token(token_id)?.by_kind(SyntaxKind::IDENT)?;
+        let range = token_map.range_by_token(token_id, SyntaxKind::IDENT)?;
        Some((tt.with_value(range + tt.value), origin))
    }
 }
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 92c679dd2..6be4516a3 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -329,7 +329,7 @@ impl ExpansionInfo {
        let token_id = self.macro_arg.1.token_by_range(range)?;
        let token_id = self.macro_def.map_id_down(token_id);
-        let range = self.exp_map.range_by_token(token_id)?.by_kind(token.value.kind())?;
+        let range = self.exp_map.range_by_token(token_id, token.value.kind())?;
        let token = self.expanded.value.covering_element(range).into_token()?;
@@ -354,7 +354,7 @@ impl ExpansionInfo {
            },
        };
-        let range = token_map.range_by_token(token_id)?.by_kind(token.value.kind())?;
+        let range = token_map.range_by_token(token_id, token.value.kind())?;
        let token =
            tt.value.covering_element(range + tt.value.text_range().start()).into_token()?;
        Some((tt.with_value(token), origin))
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index 66b3418f2..a9994082a 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -18,9 +18,9 @@ ena = "0.14.0"
 log = "0.4.8"
 rustc-hash = "1.1.0"
 scoped-tls = "1"
-chalk-solve = { version = "0.64", default-features = false }
+chalk-solve = { version = "0.67", default-features = false }
-chalk-ir = "0.64"
+chalk-ir = "0.67"
-chalk-recursive = "0.64"
+chalk-recursive = "0.67"
 la-arena = { version = "0.2.0", path = "../../lib/arena" }
 stdx = { path = "../stdx", version = "0.0.0" }
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 53c4ee9da..d1f113e7f 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -181,7 +181,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
        for (id, expr) in body.exprs.iter() {
            if let Expr::MethodCall { receiver, .. } = expr {
                let function_id = match self.infer.method_resolution(id) {
-                    Some(id) => id,
+                    Some((id, _)) => id,
                    None => continue,
                };
@@ -239,15 +239,11 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
                    return;
                }
-                // FIXME: note that we erase information about substs here. This
+                let (callee, subst) = match self.infer.method_resolution(call_id) {
-                // is not right, but, luckily, doesn't matter as we care only
+                    Some(it) => it,
-                // about the number of params
-                let callee = match self.infer.method_resolution(call_id) {
-                    Some(callee) => callee,
                    None => return,
                };
-                let sig =
+                let sig = db.callable_item_signature(callee.into()).substitute(&Interner, &subst);
-                    db.callable_item_signature(callee.into()).into_value_and_skipped_binders().0;
                (sig, args)
            }
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index ed97dc0e3..5d13bddea 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -105,7 +105,7 @@ fn walk_unsafe(
        Expr::MethodCall { .. } => {
            if infer
                .method_resolution(current)
-                .map(|func| db.function_data(func).is_unsafe())
+                .map(|(func, _)| db.function_data(func).is_unsafe())
                .unwrap_or(false)
            {
                unsafe_exprs.push(UnsafeExpr { expr: current, inside_unsafe_block });
diff --git a/crates/hir_ty/src/display.rs b/crates/hir_ty/src/display.rs
index 7bbd1a1f7..637bbc634 100644
--- a/crates/hir_ty/src/display.rs
+++ b/crates/hir_ty/src/display.rs
@@ -13,6 +13,7 @@ use hir_def::{
    db::DefDatabase,
    find_path,
    generics::TypeParamProvenance,
+    intern::{Internable, Interned},
    item_scope::ItemInNs,
    path::{Path, PathKind},
    type_ref::{TypeBound, TypeRef},
@@ -256,6 +257,12 @@ impl<T: HirDisplay> HirDisplay for &'_ T {
    }
 }
+impl<T: HirDisplay + Internable> HirDisplay for Interned<T> {
+    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
+        HirDisplay::hir_fmt(self.as_ref(), f)
+    }
+}
 impl HirDisplay for ProjectionTy {
    fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
        if f.should_truncate() {
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index f1cebbdb9..db3c937ff 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -37,8 +37,8 @@ use syntax::SmolStr;
 use super::{DomainGoal, InEnvironment, ProjectionTy, TraitEnvironment, TraitRef, Ty};
 use crate::{
    db::HirDatabase, fold_tys, infer::diagnostics::InferenceDiagnostic,
-    lower::ImplTraitLoweringMode, to_assoc_type_id, AliasEq, AliasTy, Goal, Interner, TyBuilder,
+    lower::ImplTraitLoweringMode, to_assoc_type_id, AliasEq, AliasTy, Goal, Interner, Substitution,
-    TyExt, TyKind,
+    TyBuilder, TyExt, TyKind,
 };
 // This lint has a false positive here. See the link below for details.
@@ -132,7 +132,7 @@ impl Default for InternedStandardTypes {
 #[derive(Clone, PartialEq, Eq, Debug, Default)]
 pub struct InferenceResult {
    /// For each method call expr, records the function it resolves to.
-    method_resolutions: FxHashMap<ExprId, FunctionId>,
+    method_resolutions: FxHashMap<ExprId, (FunctionId, Substitution)>,
    /// For each field access expr, records the field it resolves to.
    field_resolutions: FxHashMap<ExprId, FieldId>,
    /// For each struct literal or pattern, records the variant it resolves to.
@@ -152,8 +152,8 @@ pub struct InferenceResult {
 }
 impl InferenceResult {
-    pub fn method_resolution(&self, expr: ExprId) -> Option<FunctionId> {
+    pub fn method_resolution(&self, expr: ExprId) -> Option<(FunctionId, Substitution)> {
-        self.method_resolutions.get(&expr).copied()
+        self.method_resolutions.get(&expr).cloned()
    }
    pub fn field_resolution(&self, expr: ExprId) -> Option<FieldId> {
        self.field_resolutions.get(&expr).copied()
@@ -284,14 +284,17 @@ impl<'a> InferenceContext<'a> {
        self.table.propagate_diverging_flag();
        let mut result = std::mem::take(&mut self.result);
        for ty in result.type_of_expr.values_mut() {
-            *ty = self.table.resolve_ty_completely(ty.clone());
+            *ty = self.table.resolve_completely(ty.clone());
        }
        for ty in result.type_of_pat.values_mut() {
-            *ty = self.table.resolve_ty_completely(ty.clone());
+            *ty = self.table.resolve_completely(ty.clone());
        }
        for mismatch in result.type_mismatches.values_mut() {
-            mismatch.expected = self.table.resolve_ty_completely(mismatch.expected.clone());
+            mismatch.expected = self.table.resolve_completely(mismatch.expected.clone());
-            mismatch.actual = self.table.resolve_ty_completely(mismatch.actual.clone());
+            mismatch.actual = self.table.resolve_completely(mismatch.actual.clone());
+        }
+        for (_, subst) in result.method_resolutions.values_mut() {
+            *subst = self.table.resolve_completely(subst.clone());
        }
        result
    }
@@ -300,8 +303,8 @@ impl<'a> InferenceContext<'a> {
        self.result.type_of_expr.insert(expr, ty);
    }
-    fn write_method_resolution(&mut self, expr: ExprId, func: FunctionId) {
+    fn write_method_resolution(&mut self, expr: ExprId, func: FunctionId, subst: Substitution) {
-        self.result.method_resolutions.insert(expr, func);
+        self.result.method_resolutions.insert(expr, (func, subst));
    }
    fn write_field_resolution(&mut self, expr: ExprId, field: FieldId) {
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 08c05c67c..79a732106 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -805,7 +805,7 @@ impl<'a> InferenceContext<'a> {
                    None => self.table.new_float_var(),
                },
            },
-            Expr::MacroStmts { tail } => self.infer_expr(*tail, expected),
+            Expr::MacroStmts { tail } => self.infer_expr_inner(*tail, expected),
        };
        // use a new type variable if we got unknown here
        let ty = self.insert_type_vars_shallow(ty);
@@ -891,17 +891,21 @@ impl<'a> InferenceContext<'a> {
                method_name,
            )
        });
-        let (derefed_receiver_ty, method_ty, def_generics) = match resolved {
+        let (derefed_receiver_ty, method_ty, substs) = match resolved {
            Some((ty, func)) => {
                let ty = canonicalized_receiver.decanonicalize_ty(ty);
-                self.write_method_resolution(tgt_expr, func);
+                let generics = generics(self.db.upcast(), func.into());
-                (ty, self.db.value_ty(func.into()), Some(generics(self.db.upcast(), func.into())))
+                let substs = self.substs_for_method_call(generics, generic_args, &ty);
+                self.write_method_resolution(tgt_expr, func, substs.clone());
+                (ty, self.db.value_ty(func.into()), substs)
            }
-            None => (receiver_ty, Binders::empty(&Interner, self.err_ty()), None),
+            None => (
+                receiver_ty,
+                Binders::empty(&Interner, self.err_ty()),
+                Substitution::empty(&Interner),
+            ),
        };
-        let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty);
        let method_ty = method_ty.substitute(&Interner, &substs);
-        let method_ty = self.insert_type_vars(method_ty);
        self.register_obligations_for_call(&method_ty);
        let (expected_receiver_ty, param_tys, ret_ty) = match method_ty.callable_sig(self.db) {
            Some(sig) => {
@@ -950,23 +954,21 @@ impl<'a> InferenceContext<'a> {
    fn substs_for_method_call(
        &mut self,
-        def_generics: Option<Generics>,
+        def_generics: Generics,
        generic_args: Option<&GenericArgs>,
        receiver_ty: &Ty,
    ) -> Substitution {
        let (parent_params, self_params, type_params, impl_trait_params) =
-            def_generics.as_ref().map_or((0, 0, 0, 0), |g| g.provenance_split());
+            def_generics.provenance_split();
        assert_eq!(self_params, 0); // method shouldn't have another Self param
        let total_len = parent_params + type_params + impl_trait_params;
        let mut substs = Vec::with_capacity(total_len);
        // Parent arguments are unknown, except for the receiver type
-        if let Some(parent_generics) = def_generics.as_ref().map(|p| p.iter_parent()) {
+        for (_id, param) in def_generics.iter_parent() {
-            for (_id, param) in parent_generics {
+            if param.provenance == hir_def::generics::TypeParamProvenance::TraitSelf {
-                if param.provenance == hir_def::generics::TypeParamProvenance::TraitSelf {
+                substs.push(receiver_ty.clone());
-                    substs.push(receiver_ty.clone());
+            } else {
-                } else {
+                substs.push(self.table.new_type_var());
-                    substs.push(self.err_ty());
-                }
            }
        }
        // handle provided type arguments
@@ -989,7 +991,7 @@ impl<'a> InferenceContext<'a> {
        };
        let supplied_params = substs.len();
        for _ in supplied_params..total_len {
-            substs.push(self.err_ty());
+            substs.push(self.table.new_type_var());
        }
        assert_eq!(substs.len(), total_len);
        Substitution::from_iter(&Interner, substs)
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index f8233cac3..ea5684229 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -295,8 +295,11 @@ impl<'a> InferenceTable<'a> {
        .expect("fold failed unexpectedly")
    }
-    pub(crate) fn resolve_ty_completely(&mut self, ty: Ty) -> Ty {
+    pub(crate) fn resolve_completely<T>(&mut self, t: T) -> T::Result
-        self.resolve_with_fallback(ty, |_, _, d, _| d)
+    where
+        T: HasInterner<Interner = Interner> + Fold<Interner>,
+    {
+        self.resolve_with_fallback(t, |_, _, d, _| d)
    }
    /// Unify two types and register new trait goals that arise from that.
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 8a375b973..c83933c73 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -10,6 +10,7 @@ use std::{iter, sync::Arc};
 use base_db::CrateId;
 use chalk_ir::{cast::Cast, fold::Shift, interner::HasInterner, Mutability, Safety};
+use hir_def::intern::Interned;
 use hir_def::{
    adt::StructKind,
    body::{Expander, LowerCtx},
@@ -843,7 +844,7 @@ impl<'a> TyLoweringContext<'a> {
            })
    }
-    fn lower_impl_trait(&self, bounds: &[TypeBound]) -> ReturnTypeImplTrait {
+    fn lower_impl_trait(&self, bounds: &[Interned<TypeBound>]) -> ReturnTypeImplTrait {
        cov_mark::hit!(lower_rpit);
        let self_ty =
            TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0)).intern(&Interner);
@@ -1025,7 +1026,7 @@ pub(crate) fn trait_environment_query(
    };
    if let Some(AssocContainerId::TraitId(trait_id)) = container {
        // add `Self: Trait<T1, T2, ...>` to the environment in trait
-        // function default implementations (and hypothetical code
+        // function default implementations (and speculative code
        // inside consts or type aliases)
        cov_mark::hit!(trait_self_implements_self);
        let substs = TyBuilder::type_params_subst(db, trait_id);
diff --git a/crates/hir_ty/src/tests/coercion.rs b/crates/hir_ty/src/tests/coercion.rs
index bb568ea37..6dac7e103 100644
--- a/crates/hir_ty/src/tests/coercion.rs
+++ b/crates/hir_ty/src/tests/coercion.rs
@@ -832,11 +832,9 @@ fn coerce_unsize_super_trait_cycle() {
    );
 }
-#[ignore]
 #[test]
 fn coerce_unsize_generic() {
-    // FIXME: Implement this
+    // FIXME: fix the type mismatches here
-    // https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions
    check_infer_with_mismatches(
        r#"
        #[lang = "unsize"]
@@ -854,8 +852,58 @@ fn coerce_unsize_generic() {
            let _: &Bar<[usize]> = &Bar(Foo { t: [1, 2, 3] });
        }
        "#,
-        expect![[r"
+        expect![[r#"
-        "]],
+            209..317 '{     ... }); }': ()
+            219..220 '_': &Foo<[usize]>
+            238..259 '&Foo {..., 3] }': &Foo<[usize]>
+            239..259 'Foo { ..., 3] }': Foo<[usize]>
+            248..257 '[1, 2, 3]': [usize; 3]
+            249..250 '1': usize
+            252..253 '2': usize
+            255..256 '3': usize
+            269..270 '_': &Bar<[usize]>
+            288..314 '&Bar(F... 3] })': &Bar<[i32; 3]>
+            289..292 'Bar': Bar<[i32; 3]>(Foo<[i32; 3]>) -> Bar<[i32; 3]>
+            289..314 'Bar(Fo... 3] })': Bar<[i32; 3]>
+            293..313 'Foo { ..., 3] }': Foo<[i32; 3]>
+            302..311 '[1, 2, 3]': [i32; 3]
+            303..304 '1': i32
+            306..307 '2': i32
+            309..310 '3': i32
+            248..257: expected [usize], got [usize; 3]
+            288..314: expected &Bar<[usize]>, got &Bar<[i32; 3]>
+        "#]],
+    );
+}
+#[test]
+fn coerce_unsize_apit() {
+    // FIXME: #8984
+    check_infer_with_mismatches(
+        r#"
+#[lang = "sized"]
+pub trait Sized {}
+#[lang = "unsize"]
+pub trait Unsize<T> {}
+#[lang = "coerce_unsized"]
+pub trait CoerceUnsized<T> {}
+impl<T: Unsize<U>, U> CoerceUnsized<&U> for &T {}
+trait Foo {}
+fn test(f: impl Foo) {
+    let _: &dyn Foo = &f;
+}
+        "#,
+        expect![[r#"
+            210..211 'f': impl Foo
+            223..252 '{     ... &f; }': ()
+            233..234 '_': &dyn Foo
+            247..249 '&f': &impl Foo
+            248..249 'f': impl Foo
+            247..249: expected &dyn Foo, got &impl Foo
+        "#]],
    );
 }
@@ -912,3 +960,46 @@ fn test() -> i32 {
        "#,
    )
 }
+#[test]
+fn panic_macro() {
+    check_infer_with_mismatches(
+        r#"
+mod panic {
+    #[macro_export]
+    pub macro panic_2015 {
+        () => (
+            $crate::panicking::panic()
+        ),
+    }
+}
+mod panicking {
+    pub fn panic() -> ! { loop {} }
+}
+#[rustc_builtin_macro = "core_panic"]
+macro_rules! panic {
+    // Expands to either `$crate::panic::panic_2015` or `$crate::panic::panic_2021`
+    // depending on the edition of the caller.
+    ($($arg:tt)*) => {
+        /* compiler built-in */
+    };
+}
+fn main() {
+    panic!()
+}
+        "#,
+        expect![[r#"
+            174..185 '{ loop {} }': !
+            176..183 'loop {}': !
+            181..183 '{}': ()
+            !0..24 '$crate...:panic': fn panic() -> !
+            !0..26 '$crate...anic()': !
+            !0..26 '$crate...anic()': !
+            !0..28 '$crate...015!()': !
+            454..470 '{     ...c!() }': ()
+        "#]],
+    );
+}
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index 320694a17..ec3828ab2 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -286,7 +286,7 @@ fn get_doc_link(db: &RootDatabase, definition: Definition) -> Option<String> {
        .and_then(
            |url| if let Some(fragment) = fragment { url.join(&fragment).ok() } else { Some(url) },
        )
-        .map(|url| url.into_string())
+        .map(|url| url.into())
 }
 fn rewrite_intra_doc_link(
@@ -325,7 +325,7 @@ fn rewrite_intra_doc_link(
        };
    }
-    Some((new_url.into_string(), strip_prefixes_suffixes(title).to_string()))
+    Some((new_url.into(), strip_prefixes_suffixes(title).to_string()))
 }
 /// Try to resolve path to local documentation via path-based links (i.e. `../gateway/struct.Shard.html`).
@@ -345,7 +345,7 @@ fn rewrite_url_link(db: &RootDatabase, def: ModuleDef, target: &str) -> Option<S
            get_symbol_filename(db, &def).as_deref().map(|f| url.join(f).ok()).flatten()
        })
        .and_then(|url| url.join(target).ok())
-        .map(|url| url.into_string())
+        .map(|url| url.into())
 }
 /// Rewrites a markdown document, applying 'callback' to each link.
diff --git a/crates/ide/src/goto_type_definition.rs b/crates/ide/src/goto_type_definition.rs
index f3284bb96..004d9cb68 100644
--- a/crates/ide/src/goto_type_definition.rs
+++ b/crates/ide/src/goto_type_definition.rs
@@ -1,3 +1,4 @@
+use ide_db::base_db::Upcast;
 use ide_db::RootDatabase;
 use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
@@ -31,6 +32,7 @@ pub(crate) fn goto_type_definition(
                ast::Pat(it) => sema.type_of_pat(&it)?,
                ast::SelfParam(it) => sema.type_of_self(&it)?,
                ast::Type(it) => sema.resolve_type(&it)?,
+                ast::RecordField(it) => sema.to_def(&it).map(|d| d.ty(db.upcast()))?,
                _ => return None,
            }
        };
@@ -161,4 +163,34 @@ impl Foo$0 {}
 "#,
        )
    }
+    #[test]
+    fn goto_def_for_struct_field() {
+        check(
+            r#"
+struct Bar;
+     //^^^
+struct Foo {
+    bar$0: Bar,
+}
+"#,
+        );
+    }
+    #[test]
+    fn goto_def_for_enum_struct_field() {
+        check(
+            r#"
+struct Bar;
+     //^^^
+enum Foo {
+    Bar {
+        bar$0: Bar
+    },
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 8f490e922..85f887737 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -219,7 +219,7 @@ fn hint_iterator(
 ) -> Option<SmolStr> {
    let db = sema.db;
    let strukt = ty.strip_references().as_adt()?;
-    let krate = strukt.krate(db);
+    let krate = strukt.module(db).krate();
    if krate != famous_defs.core()? {
        return None;
    }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index f76715d84..ce1c76f37 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -227,7 +227,7 @@ pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) ->
    let func = def.source(sema.db)?;
    let name_string = def.name(sema.db).to_string();
-    let root = def.krate(sema.db)?.root_module(sema.db);
+    let root = def.module(sema.db).krate().root_module(sema.db);
    let kind = if name_string == "main" && def.module(sema.db) == root {
        RunnableKind::Bin
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 9df8d21af..cf1a8bad7 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -80,6 +80,7 @@ pub(crate) fn highlight(
        &mut hl,
        &sema,
        InFile::new(file_id.into(), &root),
+        sema.scope(&root).krate(),
        range_to_highlight,
        syntactic_name_ref_highlighting,
    );
@@ -90,6 +91,7 @@ fn traverse(
    hl: &mut Highlights,
    sema: &Semantics<RootDatabase>,
    root: InFile<&SyntaxNode>,
+    krate: Option<hir::Crate>,
    range_to_highlight: TextRange,
    syntactic_name_ref_highlighting: bool,
 ) {
@@ -209,6 +211,7 @@ fn traverse(
        if let Some((mut highlight, binding_hash)) = highlight::element(
            &sema,
+            krate,
            &mut bindings_shadow_count,
            syntactic_name_ref_highlighting,
            element_to_highlight.clone(),
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 058e37ff0..b4a3d39c9 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -19,6 +19,7 @@ use crate::{
 pub(super) fn element(
    sema: &Semantics<RootDatabase>,
+    krate: Option<hir::Crate>,
    bindings_shadow_count: &mut FxHashMap<hir::Name, u32>,
    syntactic_name_ref_highlighting: bool,
    element: SyntaxElement,
@@ -46,8 +47,10 @@ pub(super) fn element(
            match name_kind {
                Some(NameClass::ExternCrate(_)) => SymbolKind::Module.into(),
-                Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
+                Some(NameClass::Definition(def)) => {
-                Some(NameClass::ConstReference(def)) => highlight_def(db, def),
+                    highlight_def(db, krate, def) | HlMod::Definition
+                }
+                Some(NameClass::ConstReference(def)) => highlight_def(db, krate, def),
                Some(NameClass::PatFieldShorthand { field_ref, .. }) => {
                    let mut h = HlTag::Symbol(SymbolKind::Field).into();
                    if let Definition::Field(field) = field_ref {
@@ -82,7 +85,7 @@ pub(super) fn element(
                                }
                            };
-                            let mut h = highlight_def(db, def);
+                            let mut h = highlight_def(db, krate, def);
                            if let Definition::Local(local) = &def {
                                if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
@@ -136,9 +139,11 @@ pub(super) fn element(
            let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
            match NameClass::classify_lifetime(sema, &lifetime) {
-                Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
+                Some(NameClass::Definition(def)) => {
+                    highlight_def(db, krate, def) | HlMod::Definition
+                }
                None => match NameRefClass::classify_lifetime(sema, &lifetime) {
-                    Some(NameRefClass::Definition(def)) => highlight_def(db, def),
+                    Some(NameRefClass::Definition(def)) => highlight_def(db, krate, def),
                    _ => SymbolKind::LifetimeParam.into(),
                },
                _ => Highlight::from(SymbolKind::LifetimeParam) | HlMod::Definition,
@@ -277,12 +282,12 @@ pub(super) fn element(
        hash((name, shadow_count))
    }
 }
-fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
+fn highlight_def(db: &RootDatabase, krate: Option<hir::Crate>, def: Definition) -> Highlight {
-    match def {
+    let mut h = match def {
-        Definition::Macro(_) => HlTag::Symbol(SymbolKind::Macro),
+        Definition::Macro(_) => Highlight::new(HlTag::Symbol(SymbolKind::Macro)),
-        Definition::Field(_) => HlTag::Symbol(SymbolKind::Field),
+        Definition::Field(_) => Highlight::new(HlTag::Symbol(SymbolKind::Field)),
        Definition::ModuleDef(def) => match def {
-            hir::ModuleDef::Module(_) => HlTag::Symbol(SymbolKind::Module),
+            hir::ModuleDef::Module(_) => Highlight::new(HlTag::Symbol(SymbolKind::Module)),
            hir::ModuleDef::Function(func) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Function));
                if let Some(item) = func.as_assoc_item(db) {
@@ -314,14 +319,22 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                if func.is_async(db) {
                    h |= HlMod::Async;
                }
-                return h;
+                h
            }
-            hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HlTag::Symbol(SymbolKind::Struct),
+            hir::ModuleDef::Adt(adt) => {
-            hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HlTag::Symbol(SymbolKind::Enum),
+                let h = match adt {
-            hir::ModuleDef::Adt(hir::Adt::Union(_)) => HlTag::Symbol(SymbolKind::Union),
+                    hir::Adt::Struct(_) => HlTag::Symbol(SymbolKind::Struct),
-            hir::ModuleDef::Variant(_) => HlTag::Symbol(SymbolKind::Variant),
+                    hir::Adt::Enum(_) => HlTag::Symbol(SymbolKind::Enum),
+                    hir::Adt::Union(_) => HlTag::Symbol(SymbolKind::Union),
+                };
+                Highlight::new(h)
+            }
+            hir::ModuleDef::Variant(_) => Highlight::new(HlTag::Symbol(SymbolKind::Variant)),
            hir::ModuleDef::Const(konst) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Const));
                if let Some(item) = konst.as_assoc_item(db) {
                    h |= HlMod::Associated;
                    match item.container(db) {
@@ -336,7 +349,7 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                    }
                }
-                return h;
+                h
            }
            hir::ModuleDef::Trait(trait_) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Trait));
@@ -344,10 +357,12 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                if trait_.is_unsafe(db) {
                    h |= HlMod::Unsafe;
                }
-                return h;
+                h
            }
            hir::ModuleDef::TypeAlias(type_) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::TypeAlias));
                if let Some(item) = type_.as_assoc_item(db) {
                    h |= HlMod::Associated;
                    match item.container(db) {
@@ -361,23 +376,30 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
                        }
                    }
                }
-                return h;
+                h
            }
-            hir::ModuleDef::BuiltinType(_) => HlTag::BuiltinType,
+            hir::ModuleDef::BuiltinType(_) => Highlight::new(HlTag::BuiltinType),
            hir::ModuleDef::Static(s) => {
                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Static));
                if s.is_mut(db) {
                    h |= HlMod::Mutable;
                    h |= HlMod::Unsafe;
                }
-                return h;
+                h
            }
        },
-        Definition::SelfType(_) => HlTag::Symbol(SymbolKind::Impl),
+        Definition::SelfType(_) => Highlight::new(HlTag::Symbol(SymbolKind::Impl)),
        Definition::GenericParam(it) => match it {
-            hir::GenericParam::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),
+            hir::GenericParam::TypeParam(_) => Highlight::new(HlTag::Symbol(SymbolKind::TypeParam)),
-            hir::GenericParam::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),
+            hir::GenericParam::ConstParam(_) => {
-            hir::GenericParam::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
+                Highlight::new(HlTag::Symbol(SymbolKind::ConstParam))
+            }
+            hir::GenericParam::LifetimeParam(_) => {
+                Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam))
+            }
        },
        Definition::Local(local) => {
            let tag = if local.is_self(db) {
@@ -395,11 +417,19 @@ fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
            if ty.as_callable(db).is_some() || ty.impls_fnonce(db) {
                h |= HlMod::Callable;
            }
-            return h;
+            h
        }
-        Definition::Label(_) => HlTag::Symbol(SymbolKind::Label),
+        Definition::Label(_) => Highlight::new(HlTag::Symbol(SymbolKind::Label)),
+    };
+    let is_from_other_crate = def.module(db).map(hir::Module::krate) != krate;
+    let is_builtin_type = matches!(def, Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)));
+    if is_from_other_crate && !is_builtin_type {
+        h |= HlMod::Library;
    }
-    .into()
+    h
 }
 fn highlight_func_by_name_ref(
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index 27473a2f9..e94f17cd9 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -67,6 +67,8 @@ pub enum HlMod {
    Trait,
    /// Used with keywords like `async` and `await`.
    Async,
+    /// Used for items from other crates.
+    Library,
    // Keep this last!
    /// Used for unsafe functions, unsafe traits, mutable statics, union accesses and unsafe operations.
    Unsafe,
@@ -189,6 +191,7 @@ impl HlMod {
        HlMod::Static,
        HlMod::Trait,
        HlMod::Async,
+        HlMod::Library,
        HlMod::Unsafe,
    ];
@@ -207,6 +210,7 @@ impl HlMod {
            HlMod::Static => "static",
            HlMod::Trait => "trait",
            HlMod::Async => "async",
+            HlMod::Library => "library",
            HlMod::Unsafe => "unsafe",
        }
    }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 878431b56..055d21109 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -248,4 +248,20 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="brace">}</span>
 <span class="keyword unsafe">unsafe</span> <span class="keyword">trait</span> <span class="trait declaration unsafe">Dangerous</span> <span class="brace">{</span><span class="brace">}</span>
-<span class="keyword">impl</span> <span class="trait unsafe">Dangerous</span> <span class="keyword">for</span> <span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span></code></pre>
-\ No newline at end of file
+<span class="keyword">impl</span> <span class="trait unsafe">Dangerous</span> <span class="keyword">for</span> <span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="keyword">fn</span> <span class="function declaration">use_foo_items</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="keyword">let</span> <span class="variable declaration">bob</span> <span class="operator">=</span> <span class="module library">foo</span><span class="operator">::</span><span class="struct library">Person</span> <span class="brace">{</span>
+        <span class="field library">name</span><span class="colon">:</span> <span class="string_literal">"Bob"</span><span class="comma">,</span>
+        <span class="field library">age</span><span class="colon">:</span> <span class="module library">foo</span><span class="operator">::</span><span class="module library">consts</span><span class="operator">::</span><span class="constant library">NUMBER</span><span class="comma">,</span>
+    <span class="brace">}</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">control_flow</span> <span class="operator">=</span> <span class="module library">foo</span><span class="operator">::</span><span class="function library">identity</span><span class="parenthesis">(</span><span class="module library">foo</span><span class="operator">::</span><span class="enum library">ControlFlow</span><span class="operator">::</span><span class="enum_variant library">Continue</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="keyword control">if</span> <span class="keyword">let</span> <span class="module library">foo</span><span class="operator">::</span><span class="enum library">ControlFlow</span><span class="operator">::</span><span class="enum_variant library">Die</span> <span class="operator">=</span> <span class="variable">control_flow</span> <span class="brace">{</span>
+        foo::<span class="macro">die!</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="brace">}</span>
+<span class="brace">}</span>
+</code></pre>
+\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 9ce26e930..be4447ebb 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -10,6 +10,7 @@ use crate::{fixture, FileRange, HlTag, TextRange};
 fn test_highlighting() {
    check_highlighting(
        r#"
+//- /main.rs crate:main deps:foo
 use inner::{self as inner_mod};
 mod inner {}
@@ -222,6 +223,43 @@ async fn async_main() {
 unsafe trait Dangerous {}
 impl Dangerous for () {}
+fn use_foo_items() {
+    let bob = foo::Person {
+        name: "Bob",
+        age: foo::consts::NUMBER,
+    };
+    let control_flow = foo::identity(foo::ControlFlow::Continue);
+    if let foo::ControlFlow::Die = control_flow {
+        foo::die!();
+    }
+}
+//- /foo.rs crate:foo
+pub struct Person {
+    pub name: &'static str,
+    pub age: u8,
+}
+pub enum ControlFlow {
+    Continue,
+    Die,
+}
+pub fn identity<T>(x: T) -> T { x }
+pub mod consts {
+    pub const NUMBER: i64 = 92;
+}
+macro_rules! die {
+    () => {
+        panic!();
+    };
+}
 "#
        .trim(),
        expect_file!["./test_data/highlighting.html"],
diff --git a/crates/ide_assists/src/handlers/fill_match_arms.rs b/crates/ide_assists/src/handlers/fill_match_arms.rs
index 97435f021..3d2cd739a 100644
--- a/crates/ide_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ide_assists/src/handlers/fill_match_arms.rs
@@ -31,8 +31,8 @@ use crate::{
 //
 // fn handle(action: Action) {
 //     match action {
-//         $0Action::Move { distance } => {}
+//         $0Action::Move { distance } => todo!(),
-//         Action::Stop => {}
+//         Action::Stop => todo!(),
 //     }
 // }
 // ```
@@ -129,7 +129,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
        |builder| {
            let new_match_arm_list = match_arm_list.clone_for_update();
            let missing_arms = missing_pats
-                .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
+                .map(|pat| make::match_arm(iter::once(pat), make::ext::expr_todo()))
                .map(|it| it.clone_for_update());
            let catch_all_arm = new_match_arm_list
@@ -350,8 +350,8 @@ fn foo(a: bool) {
            r#"
 fn foo(a: bool) {
    match a {
-        $0true => {}
+        $0true => todo!(),
-        false => {}
+        false => todo!(),
    }
 }
 "#,
@@ -373,7 +373,7 @@ fn foo(a: bool) {
 fn foo(a: bool) {
    match a {
        true => {}
-        $0false => {}
+        $0false => todo!(),
    }
 }
 "#,
@@ -410,10 +410,10 @@ fn foo(a: bool) {
            r#"
 fn foo(a: bool) {
    match (a, a) {
-        $0(true, true) => {}
+        $0(true, true) => todo!(),
-        (true, false) => {}
+        (true, false) => todo!(),
-        (false, true) => {}
+        (false, true) => todo!(),
-        (false, false) => {}
+        (false, false) => todo!(),
    }
 }
 "#,
@@ -435,9 +435,9 @@ fn foo(a: bool) {
 fn foo(a: bool) {
    match (a, a) {
        (false, true) => {}
-        $0(true, true) => {}
+        $0(true, true) => todo!(),
-        (true, false) => {}
+        (true, false) => todo!(),
-        (false, false) => {}
+        (false, false) => todo!(),
    }
 }
 "#,
@@ -471,7 +471,7 @@ fn main() {
    match A::As {
        A::Bs { x, y: Some(_) } => {}
        A::Cs(_, Some(_)) => {}
-        $0A::As => {}
+        $0A::As => todo!(),
    }
 }
 "#,
@@ -499,7 +499,7 @@ use Option::*;
 fn main() {
    match None {
        None => {}
-        Some(${0:_}) => {}
+        Some(${0:_}) => todo!(),
    }
 }
            "#,
@@ -523,7 +523,7 @@ enum A { As, Bs, Cs(Option<i32>) }
 fn main() {
    match A::As {
        A::Cs(_) | A::Bs => {}
-        $0A::As => {}
+        $0A::As => todo!(),
    }
 }
 "#,
@@ -553,8 +553,8 @@ fn main() {
        A::Bs if 0 < 1 => {}
        A::Ds(_value) => { let x = 1; }
        A::Es(B::Xs) => (),
-        $0A::As => {}
+        $0A::As => todo!(),
-        A::Cs => {}
+        A::Cs => todo!(),
    }
 }
 "#,
@@ -580,7 +580,7 @@ fn main() {
    match A::As {
        A::As(_) => {}
        a @ A::Bs(_) => {}
-        A::Cs(${0:_}) => {}
+        A::Cs(${0:_}) => todo!(),
    }
 }
 "#,
@@ -605,11 +605,11 @@ enum A { As, Bs, Cs(String), Ds(String, String), Es { x: usize, y: usize } }
 fn main() {
    let a = A::As;
    match a {
-        $0A::As => {}
+        $0A::As => todo!(),
-        A::Bs => {}
+        A::Bs => todo!(),
-        A::Cs(_) => {}
+        A::Cs(_) => todo!(),
-        A::Ds(_, _) => {}
+        A::Ds(_, _) => todo!(),
-        A::Es { x, y } => {}
+        A::Es { x, y } => todo!(),
    }
 }
 "#,
@@ -638,10 +638,10 @@ fn main() {
    let a = A::One;
    let b = B::One;
    match (a, b) {
-        $0(A::One, B::One) => {}
+        $0(A::One, B::One) => todo!(),
-        (A::One, B::Two) => {}
+        (A::One, B::Two) => todo!(),
-        (A::Two, B::One) => {}
+        (A::Two, B::One) => todo!(),
-        (A::Two, B::Two) => {}
+        (A::Two, B::Two) => todo!(),
    }
 }
 "#,
@@ -670,10 +670,10 @@ fn main() {
    let a = A::One;
    let b = B::One;
    match (&a, &b) {
-        $0(A::One, B::One) => {}
+        $0(A::One, B::One) => todo!(),
-        (A::One, B::Two) => {}
+        (A::One, B::Two) => todo!(),
-        (A::Two, B::One) => {}
+        (A::Two, B::One) => todo!(),
-        (A::Two, B::Two) => {}
+        (A::Two, B::Two) => todo!(),
    }
 }
 "#,
@@ -705,9 +705,9 @@ fn main() {
    let b = B::One;
    match (a, b) {
        (A::Two, B::One) => {}
-        $0(A::One, B::One) => {}
+        $0(A::One, B::One) => todo!(),
-        (A::One, B::Two) => {}
+        (A::One, B::Two) => todo!(),
-        (A::Two, B::Two) => {}
+        (A::Two, B::Two) => todo!(),
    }
 }
 "#,
@@ -736,7 +736,7 @@ fn main() {
    match (a, b) {
        (Some(_), _) => {}
        (None, Some(_)) => {}
-        $0(None, None) => {}
+        $0(None, None) => todo!(),
    }
 }
 "#,
@@ -801,8 +801,8 @@ enum A { One, Two }
 fn main() {
    let a = A::One;
    match (a, ) {
-        $0(A::One,) => {}
+        $0(A::One,) => todo!(),
-        (A::Two,) => {}
+        (A::Two,) => todo!(),
    }
 }
 "#,
@@ -826,7 +826,7 @@ enum A { As }
 fn foo(a: &A) {
    match a {
-        $0A::As => {}
+        $0A::As => todo!(),
    }
 }
 "#,
@@ -851,7 +851,7 @@ enum A {
 fn foo(a: &mut A) {
    match a {
-        $0A::Es { x, y } => {}
+        $0A::Es { x, y } => todo!(),
    }
 }
 "#,
@@ -891,8 +891,8 @@ enum E { X, Y }
 fn main() {
    match E::X {
-        $0E::X => {}
+        $0E::X => todo!(),
-        E::Y => {}
+        E::Y => todo!(),
    }
 }
 "#,
@@ -919,8 +919,8 @@ use foo::E::X;
 fn main() {
    match X {
-        $0X => {}
+        $0X => todo!(),
-        foo::E::Y => {}
+        foo::E::Y => todo!(),
    }
 }
 "#,
@@ -947,7 +947,7 @@ fn foo(a: A) {
    match a {
        // foo bar baz
        A::One => {}
-        $0A::Two => {}
+        $0A::Two => todo!(),
        // This is where the rest should be
    }
 }
@@ -971,8 +971,8 @@ fn foo(a: A) {
 enum A { One, Two }
 fn foo(a: A) {
    match a {
-        $0A::One => {}
+        $0A::One => todo!(),
-        A::Two => {}
+        A::Two => todo!(),
        // foo bar baz
    }
 }
@@ -996,8 +996,8 @@ fn foo(a: A) {
 enum A { One, Two, }
 fn foo(a: A) {
    match a {
-        $0A::One => {}
+        $0A::One => todo!(),
-        A::Two => {}
+        A::Two => todo!(),
    }
 }
 "#,
@@ -1021,8 +1021,8 @@ fn foo(opt: Option<i32>) {
            r#"
 fn foo(opt: Option<i32>) {
    match opt {
-        Some(${0:_}) => {}
+        Some(${0:_}) => todo!(),
-        None => {}
+        None => todo!(),
    }
 }
 "#,
@@ -1054,9 +1054,9 @@ enum Test {
 fn foo(t: Test) {
    m!(match t {
-    $0Test::A => {}
+    $0Test::A => todo!(),
-    Test::B => {}
+    Test::B => todo!(),
-    Test::C => {}
+    Test::C => todo!(),
 });
 }"#,
        );
@@ -1076,4 +1076,44 @@ fn foo(tuple: (A, A)) {
 "#,
        );
    }
+    #[test]
+    fn adds_comma_before_new_arms() {
+        check_assist(
+            fill_match_arms,
+            r#"
+fn foo(t: bool) {
+    match $0t {
+        true => 1 + 2
+    }
+}"#,
+            r#"
+fn foo(t: bool) {
+    match t {
+        true => 1 + 2,
+        $0false => todo!(),
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn does_not_add_extra_comma() {
+        check_assist(
+            fill_match_arms,
+            r#"
+fn foo(t: bool) {
+    match $0t {
+        true => 1 + 2,
+    }
+}"#,
+            r#"
+fn foo(t: bool) {
+    match t {
+        true => 1 + 2,
+        $0false => todo!(),
+    }
+}"#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/fix_visibility.rs b/crates/ide_assists/src/handlers/fix_visibility.rs
index 6c7824e55..89f7b2c2c 100644
--- a/crates/ide_assists/src/handlers/fix_visibility.rs
+++ b/crates/ide_assists/src/handlers/fix_visibility.rs
@@ -85,7 +85,7 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> O
 fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let record_field: ast::RecordExprField = ctx.find_node_at_offset()?;
-    let (record_field_def, _) = ctx.sema.resolve_record_field(&record_field)?;
+    let (record_field_def, _, _) = ctx.sema.resolve_record_field(&record_field)?;
    let current_module = ctx.sema.scope(record_field.syntax()).module()?;
    let visibility = record_field_def.visibility(ctx.db());
diff --git a/crates/ide_assists/src/handlers/generate_getter.rs b/crates/ide_assists/src/handlers/generate_getter.rs
index df7d1bb95..09971226e 100644
--- a/crates/ide_assists/src/handlers/generate_getter.rs
+++ b/crates/ide_assists/src/handlers/generate_getter.rs
@@ -23,12 +23,46 @@ use crate::{
 //
 // impl Person {
 //     /// Get a reference to the person's name.
-//     fn name(&self) -> &String {
+//     fn $0name(&self) -> &str {
-//         &self.name
+//         self.name.as_str()
 //     }
 // }
 // ```
 pub(crate) fn generate_getter(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    generate_getter_impl(acc, ctx, false)
+}
+// Assist: generate_getter_mut
+//
+// Generate a mut getter method.
+//
+// ```
+// struct Person {
+//     nam$0e: String,
+// }
+// ```
+// ->
+// ```
+// struct Person {
+//     name: String,
+// }
+//
+// impl Person {
+//     /// Get a mutable reference to the person's name.
+//     fn $0name_mut(&mut self) -> &mut String {
+//         &mut self.name
+//     }
+// }
+// ```
+pub(crate) fn generate_getter_mut(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    generate_getter_impl(acc, ctx, true)
+}
+pub(crate) fn generate_getter_impl(
+    acc: &mut Assists,
+    ctx: &AssistContext,
+    mutable: bool,
+) -> Option<()> {
    let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
    let field = ctx.find_node_at_offset::<ast::RecordField>()?;
@@ -37,39 +71,52 @@ pub(crate) fn generate_getter(acc: &mut Assists, ctx: &AssistContext) -> Option<
    let field_ty = field.ty()?;
    // Return early if we've found an existing fn
-    let fn_name = to_lower_snake_case(&field_name.to_string());
+    let mut fn_name = to_lower_snake_case(&field_name.to_string());
+    if mutable {
+        format_to!(fn_name, "_mut");
+    }
    let impl_def = find_struct_impl(&ctx, &ast::Adt::Struct(strukt.clone()), fn_name.as_str())?;
+    let (id, label) = if mutable {
+        ("generate_getter_mut", "Generate a mut getter method")
+    } else {
+        ("generate_getter", "Generate a getter method")
+    };
    let target = field.syntax().text_range();
    acc.add_group(
        &GroupLabel("Generate getter/setter".to_owned()),
-        AssistId("generate_getter", AssistKind::Generate),
+        AssistId(id, AssistKind::Generate),
-        "Generate a getter method",
+        label,
        target,
        |builder| {
            let mut buf = String::with_capacity(512);
-            let fn_name_spaced = fn_name.replace('_', " ");
-            let strukt_name_spaced =
-                to_lower_snake_case(&strukt_name.to_string()).replace('_', " ");
            if impl_def.is_some() {
                buf.push('\n');
            }
            let vis = strukt.visibility().map_or(String::new(), |v| format!("{} ", v));
+            let (ty, body) = if mutable {
+                (format!("&mut {}", field_ty), format!("&mut self.{}", field_name))
+            } else {
+                useless_type_special_case(&field_name.to_string(), &field_ty)
+                    .unwrap_or_else(|| (format!("&{}", field_ty), format!("&self.{}", field_name)))
+            };
            format_to!(
                buf,
-                "    /// Get a reference to the {}'s {}.
+                "    /// Get a {}reference to the {}'s {}.
-    {}fn {}(&self) -> &{} {{
+    {}fn {}(&{}self) -> {} {{
-        &self.{}
+        {}
    }}",
-                strukt_name_spaced,
+                mutable.then(|| "mutable ").unwrap_or_default(),
-                fn_name_spaced,
+                to_lower_snake_case(&strukt_name.to_string()).replace('_', " "),
+                fn_name.trim_end_matches("_mut").replace('_', " "),
                vis,
                fn_name,
-                field_ty,
+                mutable.then(|| "mut ").unwrap_or_default(),
-                fn_name,
+                ty,
+                body,
            );
            let start_offset = impl_def
@@ -79,56 +126,120 @@ pub(crate) fn generate_getter(acc: &mut Assists, ctx: &AssistContext) -> Option<
                    strukt.syntax().text_range().end()
                });
-            builder.insert(start_offset, buf);
+            match ctx.config.snippet_cap {
+                Some(cap) => {
+                    builder.insert_snippet(cap, start_offset, buf.replacen("fn ", "fn $0", 1))
+                }
+                None => builder.insert(start_offset, buf),
+            }
        },
    )
 }
+fn useless_type_special_case(field_name: &str, field_ty: &ast::Type) -> Option<(String, String)> {
+    if field_ty.to_string() == "String" {
+        cov_mark::hit!(useless_type_special_case);
+        return Some(("&str".to_string(), format!("self.{}.as_str()", field_name)));
+    }
+    if let Some(arg) = ty_ctor(field_ty, "Vec") {
+        return Some((format!("&[{}]", arg), format!("self.{}.as_slice()", field_name)));
+    }
+    if let Some(arg) = ty_ctor(field_ty, "Box") {
+        return Some((format!("&{}", arg), format!("self.{}.as_ref()", field_name)));
+    }
+    if let Some(arg) = ty_ctor(field_ty, "Option") {
+        return Some((format!("Option<&{}>", arg), format!("self.{}.as_ref()", field_name)));
+    }
+    None
+}
+// FIXME: This should rely on semantic info.
+fn ty_ctor(ty: &ast::Type, ctor: &str) -> Option<String> {
+    let res = ty.to_string().strip_prefix(ctor)?.strip_prefix('<')?.strip_suffix('>')?.to_string();
+    Some(res)
+}
 #[cfg(test)]
 mod tests {
    use crate::tests::{check_assist, check_assist_not_applicable};
    use super::*;
-    fn check_not_applicable(ra_fixture: &str) {
-        check_assist_not_applicable(generate_getter, ra_fixture)
-    }
    #[test]
    fn test_generate_getter_from_field() {
        check_assist(
            generate_getter,
            r#"
-struct Context<T: Clone> {
+struct Context {
-    dat$0a: T,
+    dat$0a: Data,
-}"#,
+}
+"#,
            r#"
-struct Context<T: Clone> {
+struct Context {
-    data: T,
+    data: Data,
 }
-impl<T: Clone> Context<T> {
+impl Context {
    /// Get a reference to the context's data.
-    fn data(&self) -> &T {
+    fn $0data(&self) -> &Data {
        &self.data
    }
-}"#,
+}
+"#,
+        );
+        check_assist(
+            generate_getter_mut,
+            r#"
+struct Context {
+    dat$0a: Data,
+}
+"#,
+            r#"
+struct Context {
+    data: Data,
+}
+impl Context {
+    /// Get a mutable reference to the context's data.
+    fn $0data_mut(&mut self) -> &mut Data {
+        &mut self.data
+    }
+}
+"#,
        );
    }
    #[test]
    fn test_generate_getter_already_implemented() {
-        check_not_applicable(
+        check_assist_not_applicable(
+            generate_getter,
            r#"
-struct Context<T: Clone> {
+struct Context {
-    dat$0a: T,
+    dat$0a: Data,
 }
-impl<T: Clone> Context<T> {
+impl Context {
-    fn data(&self) -> &T {
+    fn data(&self) -> &Data {
        &self.data
    }
-}"#,
+}
+"#,
+        );
+        check_assist_not_applicable(
+            generate_getter_mut,
+            r#"
+struct Context {
+    dat$0a: Data,
+}
+impl Context {
+    fn data_mut(&mut self) -> &mut Data {
+        &mut self.data
+    }
+}
+"#,
        );
    }
@@ -137,20 +248,22 @@ impl<T: Clone> Context<T> {
        check_assist(
            generate_getter,
            r#"
-pub(crate) struct Context<T: Clone> {
+pub(crate) struct Context {
-    dat$0a: T,
+    dat$0a: Data,
-}"#,
+}
+"#,
            r#"
-pub(crate) struct Context<T: Clone> {
+pub(crate) struct Context {
-    data: T,
+    data: Data,
 }
-impl<T: Clone> Context<T> {
+impl Context {
    /// Get a reference to the context's data.
-    pub(crate) fn data(&self) -> &T {
+    pub(crate) fn $0data(&self) -> &Data {
        &self.data
    }
-}"#,
+}
+"#,
        );
    }
@@ -159,34 +272,105 @@ impl<T: Clone> Context<T> {
        check_assist(
            generate_getter,
            r#"
-struct Context<T: Clone> {
+struct Context {
-    data: T,
+    data: Data,
    cou$0nt: usize,
 }
-impl<T: Clone> Context<T> {
+impl Context {
    /// Get a reference to the context's data.
-    fn data(&self) -> &T {
+    fn data(&self) -> &Data {
        &self.data
    }
-}"#,
+}
+"#,
            r#"
-struct Context<T: Clone> {
+struct Context {
-    data: T,
+    data: Data,
    count: usize,
 }
-impl<T: Clone> Context<T> {
+impl Context {
    /// Get a reference to the context's data.
-    fn data(&self) -> &T {
+    fn data(&self) -> &Data {
        &self.data
    }
    /// Get a reference to the context's count.
-    fn count(&self) -> &usize {
+    fn $0count(&self) -> &usize {
        &self.count
    }
-}"#,
+}
+"#,
+        );
+    }
+    #[test]
+    fn test_special_cases() {
+        cov_mark::check!(useless_type_special_case);
+        check_assist(
+            generate_getter,
+            r#"
+struct S { foo: $0String }
+"#,
+            r#"
+struct S { foo: String }
+impl S {
+    /// Get a reference to the s's foo.
+    fn $0foo(&self) -> &str {
+        self.foo.as_str()
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_getter,
+            r#"
+struct S { foo: $0Box<Sweets> }
+"#,
+            r#"
+struct S { foo: Box<Sweets> }
+impl S {
+    /// Get a reference to the s's foo.
+    fn $0foo(&self) -> &Sweets {
+        self.foo.as_ref()
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_getter,
+            r#"
+struct S { foo: $0Vec<()> }
+"#,
+            r#"
+struct S { foo: Vec<()> }
+impl S {
+    /// Get a reference to the s's foo.
+    fn $0foo(&self) -> &[()] {
+        self.foo.as_slice()
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_getter,
+            r#"
+struct S { foo: $0Option<Failure> }
+"#,
+            r#"
+struct S { foo: Option<Failure> }
+impl S {
+    /// Get a reference to the s's foo.
+    fn $0foo(&self) -> Option<&Failure> {
+        self.foo.as_ref()
+    }
+}
+"#,
        );
    }
 }
diff --git a/crates/ide_assists/src/handlers/generate_getter_mut.rs b/crates/ide_assists/src/handlers/generate_getter_mut.rs
deleted file mode 100644
index 821c2eed5..000000000
--- a/crates/ide_assists/src/handlers/generate_getter_mut.rs
+++ /dev/null
@@ -1,195 +0,0 @@
-use stdx::{format_to, to_lower_snake_case};
-use syntax::ast::{self, AstNode, NameOwner, VisibilityOwner};
-use crate::{
-    utils::{find_impl_block_end, find_struct_impl, generate_impl_text},
-    AssistContext, AssistId, AssistKind, Assists, GroupLabel,
-};
-// Assist: generate_getter_mut
-//
-// Generate a mut getter method.
-//
-// ```
-// struct Person {
-//     nam$0e: String,
-// }
-// ```
-// ->
-// ```
-// struct Person {
-//     name: String,
-// }
-//
-// impl Person {
-//     /// Get a mutable reference to the person's name.
-//     fn name_mut(&mut self) -> &mut String {
-//         &mut self.name
-//     }
-// }
-// ```
-pub(crate) fn generate_getter_mut(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
-    let field = ctx.find_node_at_offset::<ast::RecordField>()?;
-    let strukt_name = strukt.name()?;
-    let field_name = field.name()?;
-    let field_ty = field.ty()?;
-    // Return early if we've found an existing fn
-    let fn_name = to_lower_snake_case(&field_name.to_string());
-    let impl_def = find_struct_impl(
-        &ctx,
-        &ast::Adt::Struct(strukt.clone()),
-        format!("{}_mut", fn_name).as_str(),
-    )?;
-    let target = field.syntax().text_range();
-    acc.add_group(
-        &GroupLabel("Generate getter/setter".to_owned()),
-        AssistId("generate_getter_mut", AssistKind::Generate),
-        "Generate a mut getter method",
-        target,
-        |builder| {
-            let mut buf = String::with_capacity(512);
-            let fn_name_spaced = fn_name.replace('_', " ");
-            let strukt_name_spaced =
-                to_lower_snake_case(&strukt_name.to_string()).replace('_', " ");
-            if impl_def.is_some() {
-                buf.push('\n');
-            }
-            let vis = strukt.visibility().map_or(String::new(), |v| format!("{} ", v));
-            format_to!(
-                buf,
-                "    /// Get a mutable reference to the {}'s {}.
-    {}fn {}_mut(&mut self) -> &mut {} {{
-        &mut self.{}
-    }}",
-                strukt_name_spaced,
-                fn_name_spaced,
-                vis,
-                fn_name,
-                field_ty,
-                fn_name,
-            );
-            let start_offset = impl_def
-                .and_then(|impl_def| find_impl_block_end(impl_def, &mut buf))
-                .unwrap_or_else(|| {
-                    buf = generate_impl_text(&ast::Adt::Struct(strukt.clone()), &buf);
-                    strukt.syntax().text_range().end()
-                });
-            builder.insert(start_offset, buf);
-        },
-    )
-}
-#[cfg(test)]
-mod tests {
-    use crate::tests::{check_assist, check_assist_not_applicable};
-    use super::*;
-    fn check_not_applicable(ra_fixture: &str) {
-        check_assist_not_applicable(generate_getter_mut, ra_fixture)
-    }
-    #[test]
-    fn test_generate_getter_mut_from_field() {
-        check_assist(
-            generate_getter_mut,
-            r#"
-struct Context<T: Clone> {
-    dat$0a: T,
-}"#,
-            r#"
-struct Context<T: Clone> {
-    data: T,
-}
-impl<T: Clone> Context<T> {
-    /// Get a mutable reference to the context's data.
-    fn data_mut(&mut self) -> &mut T {
-        &mut self.data
-    }
-}"#,
-        );
-    }
-    #[test]
-    fn test_generate_getter_mut_already_implemented() {
-        check_not_applicable(
-            r#"
-struct Context<T: Clone> {
-    dat$0a: T,
-}
-impl<T: Clone> Context<T> {
-    fn data_mut(&mut self) -> &mut T {
-        &mut self.data
-    }
-}"#,
-        );
-    }
-    #[test]
-    fn test_generate_getter_mut_from_field_with_visibility_marker() {
-        check_assist(
-            generate_getter_mut,
-            r#"
-pub(crate) struct Context<T: Clone> {
-    dat$0a: T,
-}"#,
-            r#"
-pub(crate) struct Context<T: Clone> {
-    data: T,
-}
-impl<T: Clone> Context<T> {
-    /// Get a mutable reference to the context's data.
-    pub(crate) fn data_mut(&mut self) -> &mut T {
-        &mut self.data
-    }
-}"#,
-        );
-    }
-    #[test]
-    fn test_multiple_generate_getter_mut() {
-        check_assist(
-            generate_getter_mut,
-            r#"
-struct Context<T: Clone> {
-    data: T,
-    cou$0nt: usize,
-}
-impl<T: Clone> Context<T> {
-    /// Get a mutable reference to the context's data.
-    fn data_mut(&mut self) -> &mut T {
-        &mut self.data
-    }
-}"#,
-            r#"
-struct Context<T: Clone> {
-    data: T,
-    count: usize,
-}
-impl<T: Clone> Context<T> {
-    /// Get a mutable reference to the context's data.
-    fn data_mut(&mut self) -> &mut T {
-        &mut self.data
-    }
-    /// Get a mutable reference to the context's count.
-    fn count_mut(&mut self) -> &mut usize {
-        &mut self.count
-    }
-}"#,
-        );
-    }
-}
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 4cd82f8c1..16af72927 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -206,7 +206,6 @@ mod handlers {
    mod generate_enum_projection_method;
    mod generate_from_impl_for_enum;
    mod generate_function;
-    mod generate_getter_mut;
    mod generate_getter;
    mod generate_impl;
    mod generate_new;
@@ -276,8 +275,8 @@ mod handlers {
            generate_enum_projection_method::generate_enum_try_into_method,
            generate_from_impl_for_enum::generate_from_impl_for_enum,
            generate_function::generate_function,
-            generate_getter_mut::generate_getter_mut,
            generate_getter::generate_getter,
+            generate_getter::generate_getter_mut,
            generate_impl::generate_impl,
            generate_new::generate_new,
            generate_setter::generate_setter,
diff --git a/crates/ide_assists/src/tests.rs b/crates/ide_assists/src/tests.rs
index 6a9231e07..2b7c2d581 100644
--- a/crates/ide_assists/src/tests.rs
+++ b/crates/ide_assists/src/tests.rs
@@ -215,8 +215,8 @@ fn assist_order_field_struct() {
    assert_eq!(assists.next().expect("expected assist").label, "Change visibility to pub(crate)");
    assert_eq!(assists.next().expect("expected assist").label, "Generate `Deref` impl using `bar`");
-    assert_eq!(assists.next().expect("expected assist").label, "Generate a mut getter method");
    assert_eq!(assists.next().expect("expected assist").label, "Generate a getter method");
+    assert_eq!(assists.next().expect("expected assist").label, "Generate a mut getter method");
    assert_eq!(assists.next().expect("expected assist").label, "Generate a setter method");
    assert_eq!(assists.next().expect("expected assist").label, "Add `#[derive]`");
 }
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 4406406a2..de5d9e55a 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -455,8 +455,8 @@ enum Action { Move { distance: u32 }, Stop }
 fn handle(action: Action) {
    match action {
-        $0Action::Move { distance } => {}
+        $0Action::Move { distance } => todo!(),
-        Action::Stop => {}
+        Action::Stop => todo!(),
    }
 }
 "#####,
@@ -786,8 +786,8 @@ struct Person {
 impl Person {
    /// Get a reference to the person's name.
-    fn name(&self) -> &String {
+    fn $0name(&self) -> &str {
-        &self.name
+        self.name.as_str()
    }
 }
 "#####,
@@ -810,7 +810,7 @@ struct Person {
 impl Person {
    /// Get a mutable reference to the person's name.
-    fn name_mut(&mut self) -> &mut String {
+    fn $0name_mut(&mut self) -> &mut String {
        &mut self.name
    }
 }
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 787eb2fd3..2f3fb1710 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -196,46 +196,46 @@ impl<'a> CompletionContext<'a> {
        };
        let mut original_file = original_file.syntax().clone();
-        let mut hypothetical_file = file_with_fake_ident.syntax().clone();
+        let mut speculative_file = file_with_fake_ident.syntax().clone();
        let mut offset = position.offset;
        let mut fake_ident_token = fake_ident_token;
        // Are we inside a macro call?
        while let (Some(actual_macro_call), Some(macro_call_with_fake_ident)) = (
            find_node_at_offset::<ast::MacroCall>(&original_file, offset),
-            find_node_at_offset::<ast::MacroCall>(&hypothetical_file, offset),
+            find_node_at_offset::<ast::MacroCall>(&speculative_file, offset),
        ) {
            if actual_macro_call.path().as_ref().map(|s| s.syntax().text())
                != macro_call_with_fake_ident.path().as_ref().map(|s| s.syntax().text())
            {
                break;
            }
-            let hypothetical_args = match macro_call_with_fake_ident.token_tree() {
+            let speculative_args = match macro_call_with_fake_ident.token_tree() {
                Some(tt) => tt,
                None => break,
            };
-            if let (Some(actual_expansion), Some(hypothetical_expansion)) = (
+            if let (Some(actual_expansion), Some(speculative_expansion)) = (
                ctx.sema.expand(&actual_macro_call),
                ctx.sema.speculative_expand(
                    &actual_macro_call,
-                    &hypothetical_args,
+                    &speculative_args,
                    fake_ident_token,
                ),
            ) {
-                let new_offset = hypothetical_expansion.1.text_range().start();
+                let new_offset = speculative_expansion.1.text_range().start();
                if new_offset > actual_expansion.text_range().end() {
                    break;
                }
                original_file = actual_expansion;
-                hypothetical_file = hypothetical_expansion.0;
+                speculative_file = speculative_expansion.0;
-                fake_ident_token = hypothetical_expansion.1;
+                fake_ident_token = speculative_expansion.1;
                offset = new_offset;
            } else {
                break;
            }
        }
-        ctx.fill_keyword_patterns(&hypothetical_file, offset);
+        ctx.fill_keyword_patterns(&speculative_file, offset);
-        ctx.fill(&original_file, hypothetical_file, offset);
+        ctx.fill(&original_file, speculative_file, offset);
        Some(ctx)
    }
@@ -337,25 +337,24 @@ impl<'a> CompletionContext<'a> {
                    },
                    ast::RecordExprFieldList(_it) => {
                        cov_mark::hit!(expected_type_struct_field_without_leading_char);
-                        self.token.prev_sibling_or_token()
+                        // wouldn't try {} be nice...
-                            .and_then(|se| se.into_node())
+                        (|| {
-                            .and_then(|node| ast::RecordExprField::cast(node))
+                            let expr_field = self.token.prev_sibling_or_token()?
-                            .and_then(|rf| self.sema.resolve_record_field(&rf).zip(Some(rf)))
+                                      .into_node()
-                            .map(|(f, rf)|(
+                                      .and_then(|node| ast::RecordExprField::cast(node))?;
-                                Some(f.0.ty(self.db)),
+                            let (_, _, ty) = self.sema.resolve_record_field(&expr_field)?;
-                                rf.field_name().map(NameOrNameRef::NameRef),
+                            Some((
+                                Some(ty),
+                                expr_field.field_name().map(NameOrNameRef::NameRef),
                            ))
-                            .unwrap_or((None, None))
+                        })().unwrap_or((None, None))
                    },
                    ast::RecordExprField(it) => {
                        cov_mark::hit!(expected_type_struct_field_with_leading_char);
-                        self.sema
+                        (
-                            .resolve_record_field(&it)
+                            it.expr().as_ref().and_then(|e| self.sema.type_of_expr(e)),
-                            .map(|f|(
+                            it.field_name().map(NameOrNameRef::NameRef),
-                                Some(f.0.ty(self.db)),
+                        )
-                                it.field_name().map(NameOrNameRef::NameRef),
-                            ))
-                            .unwrap_or((None, None))
                    },
                    ast::MatchExpr(it) => {
                        cov_mark::hit!(expected_type_match_arm_without_leading_char);
@@ -382,6 +381,12 @@ impl<'a> CompletionContext<'a> {
                        let def = self.sema.to_def(&it);
                        (def.map(|def| def.ret_type(self.db)), None)
                    },
+                    ast::ClosureExpr(it) => {
+                        let ty = self.sema.type_of_expr(&it.into());
+                        ty.and_then(|ty| ty.as_callable(self.db))
+                            .map(|c| (Some(c.return_type()), None))
+                            .unwrap_or((None, None))
+                    },
                    ast::Stmt(_it) => (None, None),
                    _ => {
                        match node.parent() {
@@ -785,6 +790,19 @@ fn foo() {
    }
    #[test]
+    fn expected_type_generic_struct_field() {
+        check_expected_type_and_name(
+            r#"
+struct Foo<T> { a: T }
+fn foo() -> Foo<u32> {
+    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(
@@ -895,4 +913,52 @@ fn foo() -> u32 {
            expect![[r#"ty: u32, name: ?"#]],
        )
    }
+    #[test]
+    fn expected_type_closure_param_return() {
+        // FIXME: make this work with `|| $0`
+        check_expected_type_and_name(
+            r#"
+fn foo() {
+    bar(|| a$0);
+}
+fn bar(f: impl FnOnce() -> u32) {}
+#[lang = "fn_once"]
+trait FnOnce { type Output; }
+"#,
+            expect![[r#"ty: u32, name: ?"#]],
+        );
+    }
+    #[test]
+    fn expected_type_generic_function() {
+        check_expected_type_and_name(
+            r#"
+fn foo() {
+    bar::<u32>($0);
+}
+fn bar<T>(t: T) {}
+"#,
+            expect![[r#"ty: u32, name: t"#]],
+        );
+    }
+    #[test]
+    fn expected_type_generic_method() {
+        check_expected_type_and_name(
+            r#"
+fn foo() {
+    S(1u32).bar($0);
+}
+struct S<T>(T);
+impl<T> S<T> {
+    fn bar(self, t: T) {}
+}
+"#,
+            expect![[r#"ty: u32, name: t"#]],
+        );
+    }
 }
diff --git a/crates/ide_completion/src/lib.rs b/crates/ide_completion/src/lib.rs
index 645349215..1152a9850 100644
--- a/crates/ide_completion/src/lib.rs
+++ b/crates/ide_completion/src/lib.rs
@@ -107,7 +107,7 @@ pub use crate::{
 /// identifier prefix/fuzzy match should be done higher in the stack, together
 /// with ordering of completions (currently this is done by the client).
 ///
-/// # Hypothetical Completion Problem
+/// # Speculative Completion Problem
 ///
 /// There's a curious unsolved problem in the current implementation. Often, you
 /// want to compute completions on a *slightly different* text document.
@@ -121,7 +121,7 @@ pub use crate::{
 /// doesn't allow such "phantom" inputs.
 ///
 /// Another case where this would be instrumental is macro expansion. We want to
-/// insert a fake ident and re-expand code. There's `expand_hypothetical` as a
+/// insert a fake ident and re-expand code. There's `expand_speculative` as a
 /// work-around for this.
 ///
 /// A different use-case is completion of injection (examples and links in doc
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index 6b04ee164..d7f96b864 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -667,6 +667,13 @@ fn foo() { A { the$0 } }
                        ),
                        detail: "u32",
                        deprecated: true,
+                        relevance: CompletionRelevance {
+                            exact_name_match: false,
+                            type_match: Some(
+                                CouldUnify,
+                            ),
+                            is_local: false,
+                        },
                    },
                ]
            "#]],
diff --git a/crates/ide_db/src/call_info/tests.rs b/crates/ide_db/src/call_info/tests.rs
index be1cc12de..1aeda08e5 100644
--- a/crates/ide_db/src/call_info/tests.rs
+++ b/crates/ide_db/src/call_info/tests.rs
@@ -189,6 +189,24 @@ fn main() { S.foo($0); }
 }
 #[test]
+fn test_fn_signature_for_generic_method() {
+    check(
+        r#"
+struct S<T>(T);
+impl<T> S<T> {
+    fn foo(&self, x: T) {}
+}
+fn main() { S(1u32).foo($0); }
+"#,
+        expect![[r#"
+                fn foo(&self, x: u32)
+                (<x: u32>)
+            "#]],
+    );
+}
+#[test]
 fn test_fn_signature_for_method_with_arg_as_assoc_fn() {
    check(
        r#"
diff --git a/crates/ide_db/src/defs.rs b/crates/ide_db/src/defs.rs
index de0dc2a40..1dcccbb8b 100644
--- a/crates/ide_db/src/defs.rs
+++ b/crates/ide_db/src/defs.rs
@@ -311,7 +311,7 @@ impl NameRefClass {
        }
        if let Some(record_field) = ast::RecordExprField::for_field_name(name_ref) {
-            if let Some((field, local)) = sema.resolve_record_field(&record_field) {
+            if let Some((field, local, _)) = sema.resolve_record_field(&record_field) {
                let field = Definition::Field(field);
                let res = match local {
                    None => NameRefClass::Definition(field),
diff --git a/crates/ide_db/src/ty_filter.rs b/crates/ide_db/src/ty_filter.rs
index 00678bf3e..766d8c628 100644
--- a/crates/ide_db/src/ty_filter.rs
+++ b/crates/ide_db/src/ty_filter.rs
@@ -4,7 +4,7 @@
 use std::iter;
-use hir::{Adt, Semantics, Type};
+use hir::Semantics;
 use syntax::ast::{self, make};
 use crate::RootDatabase;
@@ -20,9 +20,9 @@ impl TryEnum {
    const ALL: [TryEnum; 2] = [TryEnum::Option, TryEnum::Result];
    /// Returns `Some(..)` if the provided type is an enum that implements `std::ops::Try`.
-    pub fn from_ty(sema: &Semantics<RootDatabase>, ty: &Type) -> Option<TryEnum> {
+    pub fn from_ty(sema: &Semantics<RootDatabase>, ty: &hir::Type) -> Option<TryEnum> {
        let enum_ = match ty.as_adt() {
-            Some(Adt::Enum(it)) => it,
+            Some(hir::Adt::Enum(it)) => it,
            _ => return None,
        };
        TryEnum::ALL.iter().find_map(|&var| {
diff --git a/crates/mbe/src/lib.rs b/crates/mbe/src/lib.rs
index 3af5bc18b..b95374b76 100644
--- a/crates/mbe/src/lib.rs
+++ b/crates/mbe/src/lib.rs
@@ -14,6 +14,7 @@ mod tests;
 #[cfg(test)]
 mod benchmark;
+mod token_map;
 use std::fmt;
@@ -63,9 +64,12 @@ impl fmt::Display for ExpandError {
    }
 }
-pub use crate::syntax_bridge::{
+pub use crate::{
-    ast_to_token_tree, parse_exprs_with_sep, parse_to_token_tree, syntax_node_to_token_tree,
+    syntax_bridge::{
-    token_tree_to_syntax_node, TokenMap,
+        ast_to_token_tree, parse_exprs_with_sep, parse_to_token_tree, syntax_node_to_token_tree,
+        token_tree_to_syntax_node,
+    },
+    token_map::TokenMap,
 };
 /// This struct contains AST for a single `macro_rules` definition. What might
diff --git a/crates/mbe/src/syntax_bridge.rs b/crates/mbe/src/syntax_bridge.rs
index b13168bd3..b11172caf 100644
--- a/crates/mbe/src/syntax_bridge.rs
+++ b/crates/mbe/src/syntax_bridge.rs
@@ -10,36 +10,8 @@ use syntax::{
 };
 use tt::buffer::{Cursor, TokenBuffer};
-use crate::ExpandError;
 use crate::{subtree_source::SubtreeTokenSource, tt_iter::TtIter};
+use crate::{ExpandError, TokenMap};
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub enum TokenTextRange {
-    Token(TextRange),
-    Delimiter(TextRange),
-}
-impl TokenTextRange {
-    pub fn by_kind(self, kind: SyntaxKind) -> Option<TextRange> {
-        match self {
-            TokenTextRange::Token(it) => Some(it),
-            TokenTextRange::Delimiter(it) => match kind {
-                T!['{'] | T!['('] | T!['['] => Some(TextRange::at(it.start(), 1.into())),
-                T!['}'] | T![')'] | T![']'] => {
-                    Some(TextRange::at(it.end() - TextSize::of('}'), 1.into()))
-                }
-                _ => None,
-            },
-        }
-    }
-}
-/// Maps `tt::TokenId` to the relative range of the original token.
-#[derive(Debug, PartialEq, Eq, Clone, Default)]
-pub struct TokenMap {
-    /// Maps `tt::TokenId` to the *relative* source range.
-    entries: Vec<(tt::TokenId, TokenTextRange)>,
-}
 /// Convert the syntax tree (what user has written) to a `TokenTree` (what macro
 /// will consume).
@@ -53,7 +25,7 @@ pub fn syntax_node_to_token_tree(node: &SyntaxNode) -> (tt::Subtree, TokenMap) {
    let global_offset = node.text_range().start();
    let mut c = Convertor::new(node, global_offset);
    let subtree = c.go();
-    c.id_alloc.map.entries.shrink_to_fit();
+    c.id_alloc.map.shrink_to_fit();
    (subtree, c.id_alloc.map)
 }
@@ -149,55 +121,6 @@ pub fn parse_exprs_with_sep(tt: &tt::Subtree, sep: char) -> Vec<tt::Subtree> {
    res
 }
-impl TokenMap {
-    pub fn token_by_range(&self, relative_range: TextRange) -> Option<tt::TokenId> {
-        let &(token_id, _) = self.entries.iter().find(|(_, range)| match range {
-            TokenTextRange::Token(it) => *it == relative_range,
-            TokenTextRange::Delimiter(it) => {
-                let open = TextRange::at(it.start(), 1.into());
-                let close = TextRange::at(it.end() - TextSize::of('}'), 1.into());
-                open == relative_range || close == relative_range
-            }
-        })?;
-        Some(token_id)
-    }
-    pub fn range_by_token(&self, token_id: tt::TokenId) -> Option<TokenTextRange> {
-        let &(_, range) = self.entries.iter().find(|(tid, _)| *tid == token_id)?;
-        Some(range)
-    }
-    fn insert(&mut self, token_id: tt::TokenId, relative_range: TextRange) {
-        self.entries.push((token_id, TokenTextRange::Token(relative_range)));
-    }
-    fn insert_delim(
-        &mut self,
-        token_id: tt::TokenId,
-        open_relative_range: TextRange,
-        close_relative_range: TextRange,
-    ) -> usize {
-        let res = self.entries.len();
-        let cover = open_relative_range.cover(close_relative_range);
-        self.entries.push((token_id, TokenTextRange::Delimiter(cover)));
-        res
-    }
-    fn update_close_delim(&mut self, idx: usize, close_relative_range: TextRange) {
-        let (_, token_text_range) = &mut self.entries[idx];
-        if let TokenTextRange::Delimiter(dim) = token_text_range {
-            let cover = dim.cover(close_relative_range);
-            *token_text_range = TokenTextRange::Delimiter(cover);
-        }
-    }
-    fn remove_delim(&mut self, idx: usize) {
-        // FIXME: This could be accidentally quadratic
-        self.entries.remove(idx);
-    }
-}
 /// Returns the textual content of a doc comment block as a quoted string
 /// That is, strips leading `///` (or `/**`, etc)
 /// and strips the ending `*/`
@@ -634,7 +557,7 @@ impl<'a> TtTreeSink<'a> {
    }
    fn finish(mut self) -> (Parse<SyntaxNode>, TokenMap) {
-        self.token_map.entries.shrink_to_fit();
+        self.token_map.shrink_to_fit();
        (self.inner.finish(), self.token_map)
    }
 }
diff --git a/crates/mbe/src/tests/expand.rs b/crates/mbe/src/tests/expand.rs
index 3a1d840ea..5f173f513 100644
--- a/crates/mbe/src/tests/expand.rs
+++ b/crates/mbe/src/tests/expand.rs
@@ -58,9 +58,8 @@ macro_rules! foobar {
    let (node, token_map) = token_tree_to_syntax_node(&expanded, FragmentKind::Items).unwrap();
    let content = node.syntax_node().to_string();
-    let get_text = |id, kind| -> String {
+    let get_text =
-        content[token_map.range_by_token(id).unwrap().by_kind(kind).unwrap()].to_string()
+        |id, kind| -> String { content[token_map.range_by_token(id, kind).unwrap()].to_string() };
-    };
    assert_eq!(expanded.token_trees.len(), 4);
    // {($e:ident) => { fn $e() {} }}
diff --git a/crates/mbe/src/token_map.rs b/crates/mbe/src/token_map.rs
new file mode 100644
index 000000000..6df3de3b3
--- /dev/null
+++ b/crates/mbe/src/token_map.rs
@@ -0,0 +1,85 @@
+//! Mapping between `TokenId`s and the token's position in macro definitions or inputs.
+use parser::{SyntaxKind, T};
+use syntax::{TextRange, TextSize};
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum TokenTextRange {
+    Token(TextRange),
+    Delimiter(TextRange),
+}
+impl TokenTextRange {
+    fn by_kind(self, kind: SyntaxKind) -> Option<TextRange> {
+        match self {
+            TokenTextRange::Token(it) => Some(it),
+            TokenTextRange::Delimiter(it) => match kind {
+                T!['{'] | T!['('] | T!['['] => Some(TextRange::at(it.start(), 1.into())),
+                T!['}'] | T![')'] | T![']'] => {
+                    Some(TextRange::at(it.end() - TextSize::of('}'), 1.into()))
+                }
+                _ => None,
+            },
+        }
+    }
+}
+/// Maps `tt::TokenId` to the relative range of the original token.
+#[derive(Debug, PartialEq, Eq, Clone, Default)]
+pub struct TokenMap {
+    /// Maps `tt::TokenId` to the *relative* source range.
+    entries: Vec<(tt::TokenId, TokenTextRange)>,
+}
+impl TokenMap {
+    pub fn token_by_range(&self, relative_range: TextRange) -> Option<tt::TokenId> {
+        let &(token_id, _) = self.entries.iter().find(|(_, range)| match range {
+            TokenTextRange::Token(it) => *it == relative_range,
+            TokenTextRange::Delimiter(it) => {
+                let open = TextRange::at(it.start(), 1.into());
+                let close = TextRange::at(it.end() - TextSize::of('}'), 1.into());
+                open == relative_range || close == relative_range
+            }
+        })?;
+        Some(token_id)
+    }
+    pub fn range_by_token(&self, token_id: tt::TokenId, kind: SyntaxKind) -> Option<TextRange> {
+        let &(_, range) = self.entries.iter().find(|(tid, _)| *tid == token_id)?;
+        range.by_kind(kind)
+    }
+    pub(crate) fn shrink_to_fit(&mut self) {
+        self.entries.shrink_to_fit();
+    }
+    pub(crate) fn insert(&mut self, token_id: tt::TokenId, relative_range: TextRange) {
+        self.entries.push((token_id, TokenTextRange::Token(relative_range)));
+    }
+    pub(crate) fn insert_delim(
+        &mut self,
+        token_id: tt::TokenId,
+        open_relative_range: TextRange,
+        close_relative_range: TextRange,
+    ) -> usize {
+        let res = self.entries.len();
+        let cover = open_relative_range.cover(close_relative_range);
+        self.entries.push((token_id, TokenTextRange::Delimiter(cover)));
+        res
+    }
+    pub(crate) fn update_close_delim(&mut self, idx: usize, close_relative_range: TextRange) {
+        let (_, token_text_range) = &mut self.entries[idx];
+        if let TokenTextRange::Delimiter(dim) = token_text_range {
+            let cover = dim.cover(close_relative_range);
+            *token_text_range = TokenTextRange::Delimiter(cover);
+        }
+    }
+    pub(crate) fn remove_delim(&mut self, idx: usize) {
+        // FIXME: This could be accidentally quadratic
+        self.entries.remove(idx);
+    }
+}
diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml
index 2ce5eeedd..2c4da394b 100644
--- a/crates/proc_macro_api/Cargo.toml
+++ b/crates/proc_macro_api/Cargo.toml
@@ -16,7 +16,7 @@ log = "0.4.8"
 crossbeam-channel = "0.5.0"
 jod-thread = "0.1.1"
 memmap2 = "0.2.0"
-object = { version = "0.23.0", default-features = false, features = ["std", "read_core", "elf", "macho", "pe", "unaligned"] }
+object = { version = "0.24", default-features = false, features = ["std", "read_core", "elf", "macho", "pe"] }
 snap = "1.0"
 tt = { path = "../tt", version = "0.0.0" }
diff --git a/crates/proc_macro_srv/Cargo.toml b/crates/proc_macro_srv/Cargo.toml
index 63b3f1532..4ea41175e 100644
--- a/crates/proc_macro_srv/Cargo.toml
+++ b/crates/proc_macro_srv/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 [dependencies]
-object = { version = "0.23", default-features = false, features = ["std", "read_core", "elf", "macho", "pe"] }
+object = { version = "0.24", default-features = false, features = ["std", "read_core", "elf", "macho", "pe"] }
 libloading = "0.7.0"
 memmap2 = "0.2.0"
diff --git a/crates/proc_macro_srv/src/dylib.rs b/crates/proc_macro_srv/src/dylib.rs
index baf10fea9..cccc53220 100644
--- a/crates/proc_macro_srv/src/dylib.rs
+++ b/crates/proc_macro_srv/src/dylib.rs
@@ -27,7 +27,7 @@ fn find_registrar_symbol(file: &Path) -> io::Result<Option<String>> {
    let file = File::open(file)?;
    let buffer = unsafe { Mmap::map(&file)? };
-    Ok(object::File::parse(&buffer)
+    Ok(object::File::parse(&*buffer)
        .map_err(invalid_data_err)?
        .exports()
        .map_err(invalid_data_err)?
diff --git a/crates/proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt b/crates/proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
index fa581f110..eb67c7134 100644
--- a/crates/proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
+++ b/crates/proc_macro_srv/src/tests/fixtures/test_serialize_proc_macro.txt
@@ -23,7 +23,7 @@ SUBTREE $
    SUBTREE [] 4294967295
      IDENT   allow 4294967295
      SUBTREE () 4294967295
-        IDENT   rust_2018_idioms 4294967295
+        IDENT   unused_extern_crates 4294967295
        PUNCH   , [alone] 4294967295
        IDENT   clippy 4294967295
        PUNCH   : [joint] 4294967295
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index ad705c752..a8fee4f08 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -121,7 +121,7 @@ pub struct PackageDependency {
    pub kind: DepKind,
 }
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord)]
 pub enum DepKind {
    /// Available to the library, binary, and dev targets in the package (but not the build script).
    Normal,
@@ -132,17 +132,23 @@ pub enum DepKind {
 }
 impl DepKind {
-    fn new(list: &[cargo_metadata::DepKindInfo]) -> Self {
+    fn iter(list: &[cargo_metadata::DepKindInfo]) -> impl Iterator<Item = Self> + '_ {
+        let mut dep_kinds = Vec::new();
+        if list.is_empty() {
+            dep_kinds.push(Self::Normal);
+        }
        for info in list {
-            match info.kind {
+            let kind = match info.kind {
-                cargo_metadata::DependencyKind::Normal => return Self::Normal,
+                cargo_metadata::DependencyKind::Normal => Self::Normal,
-                cargo_metadata::DependencyKind::Development => return Self::Dev,
+                cargo_metadata::DependencyKind::Development => Self::Dev,
-                cargo_metadata::DependencyKind::Build => return Self::Build,
+                cargo_metadata::DependencyKind::Build => Self::Build,
                cargo_metadata::DependencyKind::Unknown => continue,
-            }
+            };
+            dep_kinds.push(kind);
        }
+        dep_kinds.sort_unstable();
-        Self::Normal
+        dep_kinds.dedup();
+        dep_kinds.into_iter()
    }
 }
@@ -317,7 +323,11 @@ impl CargoWorkspace {
                }
            };
            node.deps.sort_by(|a, b| a.pkg.cmp(&b.pkg));
-            for dep_node in node.deps {
+            for (dep_node, kind) in node
+                .deps
+                .iter()
+                .flat_map(|dep| DepKind::iter(&dep.dep_kinds).map(move |kind| (dep, kind)))
+            {
                let pkg = match pkg_by_id.get(&dep_node.pkg) {
                    Some(&pkg) => pkg,
                    None => {
@@ -328,11 +338,7 @@ impl CargoWorkspace {
                        continue;
                    }
                };
-                let dep = PackageDependency {
+                let dep = PackageDependency { name: dep_node.name.clone(), pkg, kind };
-                    name: dep_node.name,
-                    pkg,
-                    kind: DepKind::new(&dep_node.dep_kinds),
-                };
                packages[source].dependencies.push(dep);
            }
            packages[source].active_features.extend(node.features);
diff --git a/crates/project_model/src/sysroot.rs b/crates/project_model/src/sysroot.rs
index 3b0ff506d..4e39d6dd3 100644
--- a/crates/project_model/src/sysroot.rs
+++ b/crates/project_model/src/sysroot.rs
@@ -50,7 +50,9 @@ impl Sysroot {
    pub fn discover(cargo_toml: &AbsPath) -> Result<Sysroot> {
        log::debug!("Discovering sysroot for {}", cargo_toml.display());
-        let current_dir = cargo_toml.parent().unwrap();
+        let current_dir = cargo_toml.parent().ok_or_else(|| {
+            format_err!("Failed to find the parent directory for {}", cargo_toml.display())
+        })?;
        let sysroot_dir = discover_sysroot_dir(current_dir)?;
        let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir, current_dir)?;
        let res = Sysroot::load(&sysroot_src_dir)?;
diff --git a/crates/project_model/src/workspace.rs b/crates/project_model/src/workspace.rs
index 607e62ea5..84990075f 100644
--- a/crates/project_model/src/workspace.rs
+++ b/crates/project_model/src/workspace.rs
@@ -4,7 +4,7 @@
 use std::{collections::VecDeque, fmt, fs, path::Path, process::Command};
-use anyhow::{Context, Result};
+use anyhow::{format_err, Context, Result};
 use base_db::{CrateDisplayName, CrateGraph, CrateId, CrateName, Edition, Env, FileId, ProcMacro};
 use cargo_workspace::DepKind;
 use cfg::CfgOptions;
@@ -49,6 +49,18 @@ pub enum ProjectWorkspace {
    },
    /// Project workspace was manually specified using a `rust-project.json` file.
    Json { project: ProjectJson, sysroot: Option<Sysroot>, rustc_cfg: Vec<CfgFlag> },
+    // FIXME: The primary limitation of this approach is that the set of detached files needs to be fixed at the beginning.
+    // That's not the end user experience we should strive for.
+    // Ideally, you should be able to just open a random detached file in existing cargo projects, and get the basic features working.
+    // That needs some changes on the salsa-level though.
+    // In particular, we should split the unified CrateGraph (which currently has maximal durability) into proper crate graph, and a set of ad hoc roots (with minimal durability).
+    // Then, we need to hide the graph behind the queries such that most queries look only at the proper crate graph, and fall back to ad hoc roots only if there's no results.
+    // After this, we should be able to tweak the logic in reload.rs to add newly opened files, which don't belong to any existing crates, to the set of the detached files.
+    // //
+    /// Project with a set of disjoint files, not belonging to any particular workspace.
+    /// Backed by basic sysroot crates for basic completion and highlighting.
+    DetachedFiles { files: Vec<AbsPathBuf>, sysroot: Sysroot, rustc_cfg: Vec<CfgFlag> },
 }
 impl fmt::Debug for ProjectWorkspace {
@@ -75,6 +87,12 @@ impl fmt::Debug for ProjectWorkspace {
                debug_struct.field("n_rustc_cfg", &rustc_cfg.len());
                debug_struct.finish()
            }
+            ProjectWorkspace::DetachedFiles { files, sysroot, rustc_cfg } => f
+                .debug_struct("DetachedFiles")
+                .field("n_files", &files.len())
+                .field("n_sysroot_crates", &sysroot.crates().len())
+                .field("n_rustc_cfg", &rustc_cfg.len())
+                .finish(),
        }
    }
 }
@@ -165,6 +183,14 @@ impl ProjectWorkspace {
        Ok(ProjectWorkspace::Json { project: project_json, sysroot, rustc_cfg })
    }
+    pub fn load_detached_files(detached_files: Vec<AbsPathBuf>) -> Result<ProjectWorkspace> {
+        let sysroot = Sysroot::discover(
+            &detached_files.first().ok_or_else(|| format_err!("No detached files to load"))?,
+        )?;
+        let rustc_cfg = rustc_cfg::get(None, None);
+        Ok(ProjectWorkspace::DetachedFiles { files: detached_files, sysroot, rustc_cfg })
+    }
    /// Returns the roots for the current `ProjectWorkspace`
    /// The return type contains the path and whether or not
    /// the root is a member of the current workspace
@@ -224,6 +250,19 @@ impl ProjectWorkspace {
                    })
                }))
                .collect(),
+            ProjectWorkspace::DetachedFiles { files, sysroot, .. } => files
+                .into_iter()
+                .map(|detached_file| PackageRoot {
+                    is_member: true,
+                    include: vec![detached_file.clone()],
+                    exclude: Vec::new(),
+                })
+                .chain(sysroot.crates().map(|krate| PackageRoot {
+                    is_member: false,
+                    include: vec![sysroot[krate].root_dir().to_path_buf()],
+                    exclude: Vec::new(),
+                }))
+                .collect(),
        }
    }
@@ -234,6 +273,9 @@ impl ProjectWorkspace {
                let rustc_package_len = rustc.as_ref().map_or(0, |rc| rc.packages().len());
                cargo.packages().len() + sysroot.crates().len() + rustc_package_len
            }
+            ProjectWorkspace::DetachedFiles { sysroot, files, .. } => {
+                sysroot.crates().len() + files.len()
+            }
        }
    }
@@ -267,6 +309,9 @@ impl ProjectWorkspace {
                rustc,
                rustc.as_ref().zip(build_data).and_then(|(it, map)| map.get(it.workspace_root())),
            ),
+            ProjectWorkspace::DetachedFiles { files, sysroot, rustc_cfg } => {
+                detached_files_to_crate_graph(rustc_cfg.clone(), load, files, sysroot)
+            }
        };
        if crate_graph.patch_cfg_if() {
            log::debug!("Patched std to depend on cfg-if")
@@ -474,6 +519,48 @@ fn cargo_to_crate_graph(
    crate_graph
 }
+fn detached_files_to_crate_graph(
+    rustc_cfg: Vec<CfgFlag>,
+    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
+    detached_files: &[AbsPathBuf],
+    sysroot: &Sysroot,
+) -> CrateGraph {
+    let _p = profile::span("detached_files_to_crate_graph");
+    let mut crate_graph = CrateGraph::default();
+    let (public_deps, _libproc_macro) =
+        sysroot_to_crate_graph(&mut crate_graph, sysroot, rustc_cfg.clone(), load);
+    let mut cfg_options = CfgOptions::default();
+    cfg_options.extend(rustc_cfg);
+    for detached_file in detached_files {
+        let file_id = match load(&detached_file) {
+            Some(file_id) => file_id,
+            None => {
+                log::error!("Failed to load detached file {:?}", detached_file);
+                continue;
+            }
+        };
+        let display_name = detached_file
+            .file_stem()
+            .and_then(|os_str| os_str.to_str())
+            .map(|file_stem| CrateDisplayName::from_canonical_name(file_stem.to_string()));
+        let detached_file_crate = crate_graph.add_crate_root(
+            file_id,
+            Edition::Edition2018,
+            display_name,
+            cfg_options.clone(),
+            Env::default(),
+            Vec::new(),
+        );
+        for (name, krate) in public_deps.iter() {
+            add_dep(&mut crate_graph, detached_file_crate, name.clone(), *krate);
+        }
+    }
+    crate_graph
+}
 fn handle_rustc_crates(
    rustc_workspace: &CargoWorkspace,
    load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
diff --git a/crates/rust-analyzer/src/bin/main.rs b/crates/rust-analyzer/src/bin/main.rs
index f0abb5b15..6c883dd58 100644
--- a/crates/rust-analyzer/src/bin/main.rs
+++ b/crates/rust-analyzer/src/bin/main.rs
@@ -199,7 +199,7 @@ fn run_server() -> Result<()> {
            config.update(json);
        }
-        if config.linked_projects().is_empty() {
+        if config.linked_projects().is_empty() && config.detached_files().is_empty() {
            let workspace_roots = initialize_params
                .workspace_folders
                .map(|workspaces| {
@@ -217,7 +217,6 @@ fn run_server() -> Result<()> {
            if discovered.is_empty() {
                log::error!("failed to find any projects in {:?}", workspace_roots);
            }
            config.discovered_projects = Some(discovered);
        }
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 2e99db36c..7620a2fe1 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -240,6 +240,7 @@ impl Default for ConfigData {
 pub struct Config {
    caps: lsp_types::ClientCapabilities,
    data: ConfigData,
+    detached_files: Vec<AbsPathBuf>,
    pub discovered_projects: Option<Vec<ProjectManifest>>,
    pub root_path: AbsPathBuf,
 }
@@ -332,13 +333,23 @@ pub struct WorkspaceSymbolConfig {
 impl Config {
    pub fn new(root_path: AbsPathBuf, caps: ClientCapabilities) -> Self {
-        Config { caps, data: ConfigData::default(), discovered_projects: None, root_path }
+        Config {
+            caps,
+            data: ConfigData::default(),
+            detached_files: Vec::new(),
+            discovered_projects: None,
+            root_path,
+        }
    }
-    pub fn update(&mut self, json: serde_json::Value) {
+    pub fn update(&mut self, mut json: serde_json::Value) {
        log::info!("updating config from JSON: {:#}", json);
        if json.is_null() || json.as_object().map_or(false, |it| it.is_empty()) {
            return;
        }
+        self.detached_files = get_field::<Vec<PathBuf>>(&mut json, "detachedFiles", None, "[]")
+            .into_iter()
+            .map(AbsPathBuf::assert)
+            .collect();
        self.data = ConfigData::from_json(json);
    }
@@ -391,6 +402,10 @@ impl Config {
        }
    }
+    pub fn detached_files(&self) -> &[AbsPathBuf] {
+        &self.detached_files
+    }
    pub fn did_save_text_document_dynamic_registration(&self) -> bool {
        let caps =
            try_or!(self.caps.text_document.as_ref()?.synchronization.clone()?, Default::default());
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/clippy_pass_by_ref.txt b/crates/rust-analyzer/src/diagnostics/test_data/clippy_pass_by_ref.txt
index 227d96d51..bcc889681 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/clippy_pass_by_ref.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/clippy_pass_by_ref.txt
@@ -2,6 +2,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -33,6 +34,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
@@ -59,6 +61,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -84,6 +87,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -115,6 +119,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -146,6 +151,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
@@ -172,6 +178,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -203,6 +210,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -234,6 +242,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
@@ -260,6 +269,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -301,6 +311,7 @@
                            {
                                Url {
                                    scheme: "file",
+                                    cannot_be_a_base: false,
                                    username: "",
                                    password: None,
                                    host: None,
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/handles_macro_location.txt b/crates/rust-analyzer/src/diagnostics/test_data/handles_macro_location.txt
index e5f01fb33..d5ab03576 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/handles_macro_location.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/handles_macro_location.txt
@@ -2,6 +2,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -33,6 +34,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/macro_compiler_error.txt b/crates/rust-analyzer/src/diagnostics/test_data/macro_compiler_error.txt
index c847bbb35..8bee4cfe1 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/macro_compiler_error.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/macro_compiler_error.txt
@@ -2,6 +2,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -36,6 +37,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -67,6 +69,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -101,6 +104,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -132,6 +136,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -166,6 +171,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -191,6 +197,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/rustc_incompatible_type_for_trait.txt b/crates/rust-analyzer/src/diagnostics/test_data/rustc_incompatible_type_for_trait.txt
index 0d16af232..ada540ea6 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/rustc_incompatible_type_for_trait.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/rustc_incompatible_type_for_trait.txt
@@ -2,6 +2,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -33,6 +34,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/rustc_mismatched_type.txt b/crates/rust-analyzer/src/diagnostics/test_data/rustc_mismatched_type.txt
index 31b6a12ce..05074a914 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/rustc_mismatched_type.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/rustc_mismatched_type.txt
@@ -2,6 +2,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -33,6 +34,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable.txt b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable.txt
index f8adfad3b..749f49438 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable.txt
@@ -2,6 +2,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -40,6 +41,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -75,6 +77,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -113,6 +116,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -154,6 +158,7 @@
                            {
                                Url {
                                    scheme: "file",
+                                    cannot_be_a_base: false,
                                    username: "",
                                    password: None,
                                    host: None,
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_hint.txt b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_hint.txt
index 5a70d2ed7..d20a91b39 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_hint.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_hint.txt
@@ -2,6 +2,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -40,6 +41,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -75,6 +77,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -113,6 +116,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -154,6 +158,7 @@
                            {
                                Url {
                                    scheme: "file",
+                                    cannot_be_a_base: false,
                                    username: "",
                                    password: None,
                                    host: None,
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_info.txt b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_info.txt
index 04ca0c9c2..2a9c3a9af 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_info.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/rustc_unused_variable_as_info.txt
@@ -2,6 +2,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -40,6 +41,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -75,6 +77,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -113,6 +116,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -154,6 +158,7 @@
                            {
                                Url {
                                    scheme: "file",
+                                    cannot_be_a_base: false,
                                    username: "",
                                    password: None,
                                    host: None,
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/rustc_wrong_number_of_parameters.txt b/crates/rust-analyzer/src/diagnostics/test_data/rustc_wrong_number_of_parameters.txt
index f7a313cf1..5ea27a152 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/rustc_wrong_number_of_parameters.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/rustc_wrong_number_of_parameters.txt
@@ -2,6 +2,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -33,6 +34,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
@@ -59,6 +61,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -90,6 +93,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -121,6 +125,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
@@ -147,6 +152,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
diff --git a/crates/rust-analyzer/src/diagnostics/test_data/snap_multi_line_fix.txt b/crates/rust-analyzer/src/diagnostics/test_data/snap_multi_line_fix.txt
index 57d2f1ae3..43b1ea765 100644
--- a/crates/rust-analyzer/src/diagnostics/test_data/snap_multi_line_fix.txt
+++ b/crates/rust-analyzer/src/diagnostics/test_data/snap_multi_line_fix.txt
@@ -2,6 +2,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -33,6 +34,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
@@ -59,6 +61,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -84,6 +87,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -115,6 +119,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -146,6 +151,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
@@ -172,6 +178,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -203,6 +210,7 @@
    MappedRustDiagnostic {
        url: Url {
            scheme: "file",
+            cannot_be_a_base: false,
            username: "",
            password: None,
            host: None,
@@ -234,6 +242,7 @@
                CodeDescription {
                    href: Url {
                        scheme: "https",
+                        cannot_be_a_base: false,
                        username: "",
                        password: None,
                        host: Some(
@@ -260,6 +269,7 @@
                        location: Location {
                            uri: Url {
                                scheme: "file",
+                                cannot_be_a_base: false,
                                username: "",
                                password: None,
                                host: None,
@@ -301,6 +311,7 @@
                            {
                                Url {
                                    scheme: "file",
+                                    cannot_be_a_base: false,
                                    username: "",
                                    password: None,
                                    host: None,
diff --git a/crates/rust-analyzer/src/global_state.rs b/crates/rust-analyzer/src/global_state.rs
index 6f2f482c1..6a36d29d4 100644
--- a/crates/rust-analyzer/src/global_state.rs
+++ b/crates/rust-analyzer/src/global_state.rs
@@ -312,6 +312,7 @@ impl GlobalStateSnapshot {
                cargo.target_by_root(&path).map(|it| (cargo, it))
            }
            ProjectWorkspace::Json { .. } => None,
+            ProjectWorkspace::DetachedFiles { .. } => None,
        })
    }
 }
diff --git a/crates/rust-analyzer/src/handlers.rs b/crates/rust-analyzer/src/handlers.rs
index 53161eb3e..456744603 100644
--- a/crates/rust-analyzer/src/handlers.rs
+++ b/crates/rust-analyzer/src/handlers.rs
@@ -661,19 +661,28 @@ pub(crate) fn handle_runnables(
            }
        }
        None => {
-            res.push(lsp_ext::Runnable {
+            if !snap.config.linked_projects().is_empty()
-                label: "cargo check --workspace".to_string(),
+                || !snap
-                location: None,
+                    .config
-                kind: lsp_ext::RunnableKind::Cargo,
+                    .discovered_projects
-                args: lsp_ext::CargoRunnable {
+                    .as_ref()
-                    workspace_root: None,
+                    .map(|projects| projects.is_empty())
-                    override_cargo: config.override_cargo,
+                    .unwrap_or(true)
-                    cargo_args: vec!["check".to_string(), "--workspace".to_string()],
+            {
-                    cargo_extra_args: config.cargo_extra_args,
+                res.push(lsp_ext::Runnable {
-                    executable_args: Vec::new(),
+                    label: "cargo check --workspace".to_string(),
-                    expect_test: None,
+                    location: None,
-                },
+                    kind: lsp_ext::RunnableKind::Cargo,
-            });
+                    args: lsp_ext::CargoRunnable {
+                        workspace_root: None,
+                        override_cargo: config.override_cargo,
+                        cargo_args: vec!["check".to_string(), "--workspace".to_string()],
+                        cargo_extra_args: config.cargo_extra_args,
+                        executable_args: Vec::new(),
+                        expect_test: None,
+                    },
+                });
+            }
        }
    }
    Ok(res)
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index e202da621..008758ea0 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -103,6 +103,7 @@ impl fmt::Debug for Event {
 impl GlobalState {
    fn run(mut self, inbox: Receiver<lsp_server::Message>) -> Result<()> {
        if self.config.linked_projects().is_empty()
+            && self.config.detached_files().is_empty()
            && self.config.notifications().cargo_toml_not_found
        {
            self.show_message(
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index 0ae2758cc..7a53e4a8b 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -147,6 +147,7 @@ impl GlobalState {
        self.task_pool.handle.spawn_with_sender({
            let linked_projects = self.config.linked_projects();
+            let detached_files = self.config.detached_files().to_vec();
            let cargo_config = self.config.cargo();
            move |sender| {
@@ -161,7 +162,7 @@ impl GlobalState {
                sender.send(Task::FetchWorkspace(ProjectWorkspaceProgress::Begin)).unwrap();
-                let workspaces = linked_projects
+                let mut workspaces = linked_projects
                    .iter()
                    .map(|project| match project {
                        LinkedProject::ProjectManifest(manifest) => {
@@ -180,6 +181,11 @@ impl GlobalState {
                    })
                    .collect::<Vec<_>>();
+                if !detached_files.is_empty() {
+                    workspaces
+                        .push(project_model::ProjectWorkspace::load_detached_files(detached_files));
+                }
                log::info!("did fetch workspaces {:?}", workspaces);
                sender
                    .send(Task::FetchWorkspace(ProjectWorkspaceProgress::End(workspaces)))
@@ -407,6 +413,7 @@ impl GlobalState {
                        _ => None,
                    }
                }
+                ProjectWorkspace::DetachedFiles { .. } => None,
            })
            .map(|(id, root)| {
                let sender = sender.clone();
diff --git a/crates/rust-analyzer/src/semantic_tokens.rs b/crates/rust-analyzer/src/semantic_tokens.rs
index 4fd576adb..6129af95f 100644
--- a/crates/rust-analyzer/src/semantic_tokens.rs
+++ b/crates/rust-analyzer/src/semantic_tokens.rs
@@ -92,6 +92,7 @@ define_semantic_token_modifiers![
    (MUTABLE, "mutable"),
    (CONSUMING, "consuming"),
    (ASYNC, "async"),
+    (LIBRARY, "library"),
    (UNSAFE, "unsafe"),
    (ATTRIBUTE_MODIFIER, "attribute"),
    (TRAIT_MODIFIER, "trait"),
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 0a3a56773..ca9513928 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -504,6 +504,7 @@ fn semantic_token_type_and_modifiers(
            HlMod::Mutable => semantic_tokens::MUTABLE,
            HlMod::Consuming => semantic_tokens::CONSUMING,
            HlMod::Async => semantic_tokens::ASYNC,
+            HlMod::Library => semantic_tokens::LIBRARY,
            HlMod::Unsafe => semantic_tokens::UNSAFE,
            HlMod::Callable => semantic_tokens::CALLABLE,
            HlMod::Static => lsp_types::SemanticTokenModifier::STATIC,
@@ -604,7 +605,7 @@ pub(crate) fn url_from_abs_path(path: &Path) -> lsp_types::Url {
    // Note: lowercasing the `path` itself doesn't help, the `Url::parse`
    // machinery *also* canonicalizes the drive letter. So, just massage the
    // string in place.
-    let mut url = url.into_string();
+    let mut url: String = url.into();
    url[driver_letter_range].make_ascii_lowercase();
    lsp_types::Url::parse(&url).unwrap()
 }
diff --git a/crates/syntax/Cargo.toml b/crates/syntax/Cargo.toml
index 747f0b9eb..a6c294245 100644
--- a/crates/syntax/Cargo.toml
+++ b/crates/syntax/Cargo.toml
@@ -14,7 +14,7 @@ doctest = false
 cov-mark = { version = "1.1", features = ["thread-local"] }
 itertools = "0.10.0"
 rowan = "=0.13.0-pre.6"
-rustc_lexer = { version = "716.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "720.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.7"
 once_cell = "1.3.1"
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index ca8103668..f7ee29d14 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -356,13 +356,17 @@ impl ast::MatchArm {
 impl ast::MatchArmList {
    pub fn add_arm(&self, arm: ast::MatchArm) {
        normalize_ws_between_braces(self.syntax());
+        let mut elements = Vec::new();
        let position = match self.arms().last() {
            Some(last_arm) => {
-                let curly = last_arm
+                let comma = last_arm
                    .syntax()
                    .siblings_with_tokens(Direction::Next)
                    .find(|it| it.kind() == T![,]);
-                Position::after(curly.unwrap_or_else(|| last_arm.syntax().clone().into()))
+                if needs_comma(&last_arm) && comma.is_none() {
+                    elements.push(make::token(SyntaxKind::COMMA).into());
+                }
+                Position::after(comma.unwrap_or_else(|| last_arm.syntax().clone().into()))
            }
            None => match self.l_curly_token() {
                Some(it) => Position::after(it),
@@ -370,11 +374,16 @@ impl ast::MatchArmList {
            },
        };
        let indent = IndentLevel::from_node(self.syntax()) + 1;
-        let elements = vec![
+        elements.push(make::tokens::whitespace(&format!("\n{}", indent)).into());
-            make::tokens::whitespace(&format!("\n{}", indent)).into(),
+        elements.push(arm.syntax().clone().into());
-            arm.syntax().clone().into(),
+        if needs_comma(&arm) {
-        ];
+            elements.push(make::token(SyntaxKind::COMMA).into());
+        }
        ted::insert_all(position, elements);
+        fn needs_comma(arm: &ast::MatchArm) -> bool {
+            arm.expr().map_or(false, |e| !e.is_block_like())
+        }
    }
 }