23 files changed, 421 insertions, 257 deletions
diff --git a/crates/base_db/src/fixture.rs b/crates/base_db/src/fixture.rs
index 8d4641355..04e2be390 100644
--- a/crates/base_db/src/fixture.rs
+++ b/crates/base_db/src/fixture.rs
@@ -1,62 +1,4 @@
-//! Fixtures are strings containing rust source code with optional metadata.
+//! A set of high-level utility fixture methods to use in tests.
-//! A fixture without metadata is parsed into a single source file.
-//! Use this to test functionality local to one file.
-//!
-//! Simple Example:
-//! ```
-//! r#"
-//! fn main() {
-//!     println!("Hello World")
-//! }
-//! "#
-//! ```
-//!
-//! Metadata can be added to a fixture after a `//-` comment.
-//! The basic form is specifying filenames,
-//! which is also how to define multiple files in a single test fixture
-//!
-//! Example using two files in the same crate:
-//! ```
-//! "
-//! //- /main.rs
-//! mod foo;
-//! fn main() {
-//!     foo::bar();
-//! }
-//!
-//! //- /foo.rs
-//! pub fn bar() {}
-//! "
-//! ```
-//!
-//! Example using two crates with one file each, with one crate depending on the other:
-//! ```
-//! r#"
-//! //- /main.rs crate:a deps:b
-//! fn main() {
-//!     b::foo();
-//! }
-//! //- /lib.rs crate:b
-//! pub fn b() {
-//!     println!("Hello World")
-//! }
-//! "#
-//! ```
-//!
-//! Metadata allows specifying all settings and variables
-//! that are available in a real rust project:
-//! - crate names via `crate:cratename`
-//! - dependencies via `deps:dep1,dep2`
-//! - configuration settings via `cfg:dbg=false,opt_level=2`
-//! - environment variables via `env:PATH=/bin,RUST_LOG=debug`
-//!
-//! Example using all available metadata:
-//! ```
-//! "
-//! //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
-//! fn insert_source_code_here() {}
-//! "
-//! ```
 use std::{mem, str::FromStr, sync::Arc};
 use cfg::CfgOptions;
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 8d00f7401..caa22dace 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -58,9 +58,8 @@ use hir_ty::{
    subst_prefix,
    traits::FnTrait,
    AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, CanonicalVarKinds, Cast,
-    DebruijnIndex, InEnvironment, Interner, QuantifiedWhereClause, Scalar, Solution,
+    DebruijnIndex, InEnvironment, Interner, QuantifiedWhereClause, Scalar, Solution, Substitution,
-    SolutionVariables, Substitution, TraitEnvironment, Ty, TyBuilder, TyDefId, TyExt, TyKind,
+    TraitEnvironment, Ty, TyBuilder, TyDefId, TyExt, TyKind, TyVariableKind, WhereClause,
-    TyVariableKind, WhereClause,
 };
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
@@ -1822,8 +1821,9 @@ impl Type {
        );
        match db.trait_solve(self.krate, goal)? {
-            Solution::Unique(SolutionVariables(subst)) => subst
+            Solution::Unique(s) => s
                .value
+                .subst
                .interned()
                .first()
                .map(|ty| self.derived(ty.assert_ty_ref(&Interner).clone())),
diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index c013e78d9..ce6f3c008 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -185,12 +185,16 @@ impl SourceAnalyzer {
    pub(crate) fn resolve_record_pat_field(
        &self,
-        _db: &dyn HirDatabase,
+        db: &dyn HirDatabase,
        field: &ast::RecordPatField,
    ) -> Option<Field> {
-        let pat_id = self.pat_id(&field.pat()?)?;
+        let field_name = field.field_name()?.as_name();
-        let struct_field = self.infer.as_ref()?.record_pat_field_resolution(pat_id)?;
+        let record_pat = ast::RecordPat::cast(field.syntax().parent().and_then(|p| p.parent())?)?;
-        Some(struct_field.into())
+        let pat_id = self.pat_id(&record_pat.into())?;
+        let variant = self.infer.as_ref()?.variant_resolution_for_pat(pat_id)?;
+        let variant_data = variant.variant_data(db.upcast());
+        let field = FieldId { parent: variant, local_id: variant_data.field(&field_name)? };
+        Some(field.into())
    }
    pub(crate) fn resolve_macro_call(
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
index ab77d924a..d9df7564d 100644
--- a/crates/hir_def/src/attr.rs
+++ b/crates/hir_def/src/attr.rs
@@ -16,7 +16,7 @@ use mbe::ast_to_token_tree;
 use smallvec::{smallvec, SmallVec};
 use syntax::{
    ast::{self, AstNode, AttrsOwner},
-    match_ast, AstToken, SmolStr, SyntaxNode, TextRange, TextSize,
+    match_ast, AstPtr, AstToken, SmolStr, SyntaxNode, TextRange, TextSize,
 };
 use tt::Subtree;
@@ -215,12 +215,11 @@ impl Attrs {
        let mut res = ArenaMap::default();
        for (id, fld) in src.value.iter() {
-            let attrs = match fld {
+            let owner: &dyn AttrsOwner = match fld {
-                Either::Left(_tuple) => Attrs::default(),
+                Either::Left(tuple) => tuple,
-                Either::Right(record) => {
+                Either::Right(record) => record,
-                    RawAttrs::from_attrs_owner(db, src.with_value(record)).filter(db, krate)
-                }
            };
+            let attrs = RawAttrs::from_attrs_owner(db, src.with_value(owner)).filter(db, krate);
            res.insert(id, attrs);
        }
@@ -404,10 +403,14 @@ impl AttrsWithOwner {
                return AttrSourceMap { attrs };
            }
            AttrDefId::FieldId(id) => {
-                id.parent.child_source(db).map(|source| match &source[id.local_id] {
+                let map = db.fields_attrs_source_map(id.parent);
-                    Either::Left(field) => ast::AttrsOwnerNode::new(field.clone()),
+                let file_id = id.parent.file_id(db);
-                    Either::Right(field) => ast::AttrsOwnerNode::new(field.clone()),
+                let root = db.parse_or_expand(file_id).unwrap();
-                })
+                let owner = match &map[id.local_id] {
+                    Either::Left(it) => ast::AttrsOwnerNode::new(it.to_node(&root)),
+                    Either::Right(it) => ast::AttrsOwnerNode::new(it.to_node(&root)),
+                };
+                InFile::new(file_id, owner)
            }
            AttrDefId::AdtId(adt) => match adt {
                AdtId::StructId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
@@ -415,10 +418,12 @@ impl AttrsWithOwner {
                AdtId::EnumId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
            },
            AttrDefId::FunctionId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
-            AttrDefId::EnumVariantId(id) => id
+            AttrDefId::EnumVariantId(id) => {
-                .parent
+                let map = db.variants_attrs_source_map(id.parent);
-                .child_source(db)
+                let file_id = id.parent.lookup(db).id.file_id();
-                .map(|source| ast::AttrsOwnerNode::new(source[id.local_id].clone())),
+                let root = db.parse_or_expand(file_id).unwrap();
+                InFile::new(file_id, ast::AttrsOwnerNode::new(map[id.local_id].to_node(&root)))
+            }
            AttrDefId::StaticId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
            AttrDefId::ConstId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
            AttrDefId::TraitId(id) => id.lookup(db).source(db).map(ast::AttrsOwnerNode::new),
@@ -747,3 +752,36 @@ fn collect_attrs(
    attrs.into_iter().map(|(_, attr)| attr)
 }
+pub(crate) fn variants_attrs_source_map(
+    db: &dyn DefDatabase,
+    def: EnumId,
+) -> Arc<ArenaMap<LocalEnumVariantId, AstPtr<ast::Variant>>> {
+    let mut res = ArenaMap::default();
+    let child_source = def.child_source(db);
+    for (idx, variant) in child_source.value.iter() {
+        res.insert(idx, AstPtr::new(variant));
+    }
+    Arc::new(res)
+}
+pub(crate) fn fields_attrs_source_map(
+    db: &dyn DefDatabase,
+    def: VariantId,
+) -> Arc<ArenaMap<LocalFieldId, Either<AstPtr<ast::TupleField>, AstPtr<ast::RecordField>>>> {
+    let mut res = ArenaMap::default();
+    let child_source = def.child_source(db);
+    for (idx, variant) in child_source.value.iter() {
+        res.insert(
+            idx,
+            variant
+                .as_ref()
+                .either(|l| Either::Left(AstPtr::new(l)), |r| Either::Right(AstPtr::new(r))),
+        );
+    }
+    Arc::new(res)
+}
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index 9b7a213a1..7eadc8e0d 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -2,9 +2,10 @@
 use std::sync::Arc;
 use base_db::{salsa, CrateId, SourceDatabase, Upcast};
+use either::Either;
 use hir_expand::{db::AstDatabase, HirFileId};
 use la_arena::ArenaMap;
-use syntax::SmolStr;
+use syntax::{ast, AstPtr, SmolStr};
 use crate::{
    adt::{EnumData, StructData},
@@ -122,6 +123,18 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
    #[salsa::invoke(Attrs::fields_attrs_query)]
    fn fields_attrs(&self, def: VariantId) -> Arc<ArenaMap<LocalFieldId, Attrs>>;
+    #[salsa::invoke(crate::attr::variants_attrs_source_map)]
+    fn variants_attrs_source_map(
+        &self,
+        def: EnumId,
+    ) -> Arc<ArenaMap<LocalEnumVariantId, AstPtr<ast::Variant>>>;
+    #[salsa::invoke(crate::attr::fields_attrs_source_map)]
+    fn fields_attrs_source_map(
+        &self,
+        def: VariantId,
+    ) -> Arc<ArenaMap<LocalFieldId, Either<AstPtr<ast::TupleField>, AstPtr<ast::RecordField>>>>;
    #[salsa::invoke(AttrsWithOwner::attrs_query)]
    fn attrs(&self, def: AttrDefId) -> AttrsWithOwner;
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
index a8ee5eeac..9014468ea 100644
--- a/crates/hir_def/src/item_scope.rs
+++ b/crates/hir_def/src/item_scope.rs
@@ -11,7 +11,7 @@ use rustc_hash::{FxHashMap, FxHashSet};
 use stdx::format_to;
 use crate::{
-    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ImplId,
+    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ConstId, ImplId,
    LocalModuleId, MacroDefId, ModuleDefId, ModuleId, TraitId,
 };
@@ -37,6 +37,7 @@ pub struct ItemScope {
    defs: Vec<ModuleDefId>,
    impls: Vec<ImplId>,
+    unnamed_consts: Vec<ConstId>,
    /// Traits imported via `use Trait as _;`.
    unnamed_trait_imports: FxHashMap<TraitId, Visibility>,
    /// Macros visible in current module in legacy textual scope
@@ -106,6 +107,10 @@ impl ItemScope {
            .map(|(_, v)| v)
    }
+    pub fn unnamed_consts(&self) -> impl Iterator<Item = ConstId> + '_ {
+        self.unnamed_consts.iter().copied()
+    }
    /// Iterate over all module scoped macros
    pub(crate) fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
        self.entries().filter_map(|(name, def)| def.take_macros().map(|macro_| (name, macro_)))
@@ -156,6 +161,10 @@ impl ItemScope {
        self.impls.push(imp)
    }
+    pub(crate) fn define_unnamed_const(&mut self, konst: ConstId) {
+        self.unnamed_consts.push(konst);
+    }
    pub(crate) fn define_legacy_macro(&mut self, name: Name, mac: MacroDefId) {
        self.legacy_macros.insert(name, mac);
    }
@@ -295,6 +304,7 @@ impl ItemScope {
            unresolved,
            defs,
            impls,
+            unnamed_consts,
            unnamed_trait_imports,
            legacy_macros,
        } = self;
@@ -304,6 +314,7 @@ impl ItemScope {
        unresolved.shrink_to_fit();
        defs.shrink_to_fit();
        impls.shrink_to_fit();
+        unnamed_consts.shrink_to_fit();
        unnamed_trait_imports.shrink_to_fit();
        legacy_macros.shrink_to_fit();
    }
diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index abd6c553f..e2af0e514 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs
@@ -453,6 +453,14 @@ impl VariantId {
            }
        }
    }
+    pub fn file_id(self, db: &dyn db::DefDatabase) -> HirFileId {
+        match self {
+            VariantId::EnumVariantId(it) => it.parent.lookup(db).id.file_id(),
+            VariantId::StructId(it) => it.lookup(db).id.file_id(),
+            VariantId::UnionId(it) => it.lookup(db).id.file_id(),
+        }
+    }
 }
 trait Intern {
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index f42f92702..492d8c71f 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -1163,19 +1163,27 @@ impl ModCollector<'_, '_> {
                }
                ModItem::Const(id) => {
                    let it = &self.item_tree[id];
+                    let const_id = ConstLoc {
-                    if let Some(name) = &it.name {
+                        container: module.into(),
-                        def = Some(DefData {
+                        id: ItemTreeId::new(self.file_id, id),
-                            id: ConstLoc {
+                    }
-                                container: module.into(),
+                    .intern(self.def_collector.db);
-                                id: ItemTreeId::new(self.file_id, id),
-                            }
+                    match &it.name {
-                            .intern(self.def_collector.db)
+                        Some(name) => {
-                            .into(),
+                            def = Some(DefData {
-                            name,
+                                id: const_id.into(),
-                            visibility: &self.item_tree[it.visibility],
+                                name,
-                            has_constructor: false,
+                                visibility: &self.item_tree[it.visibility],
-                        });
+                                has_constructor: false,
+                            });
+                        }
+                        None => {
+                            // const _: T = ...;
+                            self.def_collector.def_map.modules[self.module_id]
+                                .scope
+                                .define_unnamed_const(const_id);
+                        }
                    }
                }
                ModItem::Static(id) => {
diff --git a/crates/hir_ty/src/autoderef.rs b/crates/hir_ty/src/autoderef.rs
index c5890e24d..80e192a57 100644
--- a/crates/hir_ty/src/autoderef.rs
+++ b/crates/hir_ty/src/autoderef.rs
@@ -120,8 +120,8 @@ fn deref_by_trait(
            // assumptions will be broken. We would need to properly introduce
            // new variables in that case
-            for i in 1..vars.0.binders.len(&Interner) {
+            for i in 1..vars.binders.len(&Interner) {
-                if vars.0.value.at(&Interner, i - 1).assert_ty_ref(&Interner).kind(&Interner)
+                if vars.value.subst.at(&Interner, i - 1).assert_ty_ref(&Interner).kind(&Interner)
                    != &TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, i - 1))
                {
                    warn!("complex solution for derefing {:?}: {:?}, ignoring", ty.goal, solution);
@@ -130,12 +130,12 @@ fn deref_by_trait(
            }
            Some(Canonical {
                value: vars
-                    .0
                    .value
-                    .at(&Interner, vars.0.value.len(&Interner) - 1)
+                    .subst
+                    .at(&Interner, vars.value.subst.len(&Interner) - 1)
                    .assert_ty_ref(&Interner)
                    .clone(),
-                binders: vars.0.binders.clone(),
+                binders: vars.binders.clone(),
            })
        }
        Solution::Ambig(_) => {
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 796f77ab0..6af0c59b8 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -42,7 +42,7 @@ use super::{
 };
 use crate::{
    db::HirDatabase, infer::diagnostics::InferenceDiagnostic, lower::ImplTraitLoweringMode,
-    to_assoc_type_id, AliasEq, AliasTy, Interner, TyBuilder, TyExt, TyKind,
+    to_assoc_type_id, AliasEq, AliasTy, Canonical, Interner, TyBuilder, TyExt, TyKind,
 };
 // This lint has a false positive here. See the link below for details.
@@ -131,8 +131,7 @@ pub struct InferenceResult {
    method_resolutions: FxHashMap<ExprId, FunctionId>,
    /// For each field access expr, records the field it resolves to.
    field_resolutions: FxHashMap<ExprId, FieldId>,
-    record_pat_field_resolutions: FxHashMap<PatId, FieldId>,
+    /// For each struct literal or pattern, records the variant it resolves to.
-    /// For each struct literal, records the variant it resolves to.
    variant_resolutions: FxHashMap<ExprOrPatId, VariantId>,
    /// For each associated item record what it resolves to
    assoc_resolutions: FxHashMap<ExprOrPatId, AssocItemId>,
@@ -151,9 +150,6 @@ impl InferenceResult {
    pub fn field_resolution(&self, expr: ExprId) -> Option<FieldId> {
        self.field_resolutions.get(&expr).copied()
    }
-    pub fn record_pat_field_resolution(&self, pat: PatId) -> Option<FieldId> {
-        self.record_pat_field_resolutions.get(&pat).copied()
-    }
    pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantId> {
        self.variant_resolutions.get(&id.into()).copied()
    }
@@ -346,11 +342,18 @@ impl<'a> InferenceContext<'a> {
                self.db.trait_solve(self.resolver.krate().unwrap(), canonicalized.value.clone());
            match solution {
-                Some(Solution::Unique(substs)) => {
+                Some(Solution::Unique(canonical_subst)) => {
-                    canonicalized.apply_solution(self, substs.0);
+                    canonicalized.apply_solution(
+                        self,
+                        Canonical {
+                            binders: canonical_subst.binders,
+                            // FIXME: handle constraints
+                            value: canonical_subst.value.subst,
+                        },
+                    );
                }
                Some(Solution::Ambig(Guidance::Definite(substs))) => {
-                    canonicalized.apply_solution(self, substs.0);
+                    canonicalized.apply_solution(self, substs);
                    self.obligations.push(obligation);
                }
                Some(_) => {
@@ -691,25 +694,6 @@ impl<'a> InferenceContext<'a> {
    }
 }
-/// The kinds of placeholders we need during type inference. There's separate
-/// values for general types, and for integer and float variables. The latter
-/// two are used for inference of literal values (e.g. `100` could be one of
-/// several integer types).
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub struct InferenceVar {
-    index: u32,
-}
-impl InferenceVar {
-    fn to_inner(self) -> unify::TypeVarId {
-        unify::TypeVarId(self.index)
-    }
-    fn from_inner(unify::TypeVarId(index): unify::TypeVarId) -> Self {
-        InferenceVar { index }
-    }
-}
 /// When inferring an expression, we propagate downward whatever type hint we
 /// are able in the form of an `Expectation`.
 #[derive(Clone, PartialEq, Eq, Debug)]
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 159a53a63..f1af2a0bd 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -7,7 +7,7 @@
 use chalk_ir::{cast::Cast, Mutability, TyVariableKind};
 use hir_def::lang_item::LangItemTarget;
-use crate::{autoderef, Interner, Solution, Ty, TyBuilder, TyExt, TyKind};
+use crate::{autoderef, Canonical, Interner, Solution, Ty, TyBuilder, TyExt, TyKind};
 use super::{InEnvironment, InferenceContext};
@@ -148,7 +148,14 @@ impl<'a> InferenceContext<'a> {
        match solution {
            Solution::Unique(v) => {
-                canonicalized.apply_solution(self, v.0);
+                canonicalized.apply_solution(
+                    self,
+                    Canonical {
+                        binders: v.binders,
+                        // FIXME handle constraints
+                        value: v.value.subst,
+                    },
+                );
            }
            _ => return None,
        };
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 942f70edf..e4813c87c 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -7,7 +7,6 @@ use chalk_ir::Mutability;
 use hir_def::{
    expr::{BindingAnnotation, Expr, Literal, Pat, PatId, RecordFieldPat},
    path::Path,
-    FieldId,
 };
 use hir_expand::name::Name;
@@ -80,11 +79,6 @@ impl<'a> InferenceContext<'a> {
        let field_tys = def.map(|it| self.db.field_types(it)).unwrap_or_default();
        for subpat in subpats {
            let matching_field = var_data.as_ref().and_then(|it| it.field(&subpat.name));
-            if let Some(local_id) = matching_field {
-                let field_def = FieldId { parent: def.unwrap(), local_id };
-                self.result.record_pat_field_resolutions.insert(subpat.pat, field_def);
-            }
            let expected_ty = matching_field.map_or(self.err_ty(), |field| {
                field_tys[field].clone().substitute(&Interner, &substs)
            });
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 7d76cda68..d717e3375 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -51,7 +51,7 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
        t.fold_binders(
            &mut |ty, binders| match ty.kind(&Interner) {
                &TyKind::InferenceVar(var, kind) => {
-                    let inner = var.to_inner();
+                    let inner = from_inference_var(var);
                    if self.var_stack.contains(&inner) {
                        // recursive type
                        return self.ctx.table.type_variable_table.fallback_value(var, kind);
@@ -65,7 +65,7 @@ impl<'a, 'b> Canonicalizer<'a, 'b> {
                        result
                    } else {
                        let root = self.ctx.table.var_unification_table.find(inner);
-                        let position = self.add(InferenceVar::from_inner(root), kind);
+                        let position = self.add(to_inference_var(root), kind);
                        TyKind::BoundVar(BoundVar::new(binders, position)).intern(&Interner)
                    }
                }
@@ -207,16 +207,16 @@ impl TypeVariableTable {
    }
    pub(super) fn set_diverging(&mut self, iv: InferenceVar, diverging: bool) {
-        self.inner[iv.to_inner().0 as usize].diverging = diverging;
+        self.inner[from_inference_var(iv).0 as usize].diverging = diverging;
    }
    fn is_diverging(&mut self, iv: InferenceVar) -> bool {
-        self.inner[iv.to_inner().0 as usize].diverging
+        self.inner[from_inference_var(iv).0 as usize].diverging
    }
    fn fallback_value(&self, iv: InferenceVar, kind: TyVariableKind) -> Ty {
        match kind {
-            _ if self.inner[iv.to_inner().0 as usize].diverging => TyKind::Never,
+            _ if self.inner[from_inference_var(iv).0 as usize].diverging => TyKind::Never,
            TyVariableKind::General => TyKind::Error,
            TyVariableKind::Integer => TyKind::Scalar(Scalar::Int(IntTy::I32)),
            TyVariableKind::Float => TyKind::Scalar(Scalar::Float(FloatTy::F64)),
@@ -250,7 +250,7 @@ impl InferenceTable {
        self.type_variable_table.push(TypeVariableData { diverging });
        let key = self.var_unification_table.new_key(TypeVarValue::Unknown);
        assert_eq!(key.0 as usize, self.type_variable_table.inner.len() - 1);
-        TyKind::InferenceVar(InferenceVar::from_inner(key), kind).intern(&Interner)
+        TyKind::InferenceVar(to_inference_var(key), kind).intern(&Interner)
    }
    pub(crate) fn new_type_var(&mut self) -> Ty {
@@ -369,8 +369,12 @@ impl InferenceTable {
                == self.type_variable_table.is_diverging(*tv2) =>
            {
                // both type vars are unknown since we tried to resolve them
-                if !self.var_unification_table.unioned(tv1.to_inner(), tv2.to_inner()) {
+                if !self
-                    self.var_unification_table.union(tv1.to_inner(), tv2.to_inner());
+                    .var_unification_table
+                    .unioned(from_inference_var(*tv1), from_inference_var(*tv2))
+                {
+                    self.var_unification_table
+                        .union(from_inference_var(*tv1), from_inference_var(*tv2));
                    self.revision += 1;
                }
                true
@@ -407,7 +411,7 @@ impl InferenceTable {
            ) => {
                // the type var is unknown since we tried to resolve it
                self.var_unification_table.union_value(
-                    tv.to_inner(),
+                    from_inference_var(*tv),
                    TypeVarValue::Known(other.clone().intern(&Interner)),
                );
                self.revision += 1;
@@ -462,7 +466,7 @@ impl InferenceTable {
            }
            match ty.kind(&Interner) {
                TyKind::InferenceVar(tv, _) => {
-                    let inner = tv.to_inner();
+                    let inner = from_inference_var(*tv);
                    match self.var_unification_table.inlined_probe_value(inner).known() {
                        Some(known_ty) => {
                            // The known_ty can't be a type var itself
@@ -485,7 +489,7 @@ impl InferenceTable {
    fn resolve_ty_as_possible_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
        ty.fold(&mut |ty| match ty.kind(&Interner) {
            &TyKind::InferenceVar(tv, kind) => {
-                let inner = tv.to_inner();
+                let inner = from_inference_var(tv);
                if tv_stack.contains(&inner) {
                    cov_mark::hit!(type_var_cycles_resolve_as_possible);
                    // recursive type
@@ -512,7 +516,7 @@ impl InferenceTable {
    fn resolve_ty_completely_inner(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
        ty.fold(&mut |ty| match ty.kind(&Interner) {
            &TyKind::InferenceVar(tv, kind) => {
-                let inner = tv.to_inner();
+                let inner = from_inference_var(tv);
                if tv_stack.contains(&inner) {
                    cov_mark::hit!(type_var_cycles_resolve_completely);
                    // recursive type
@@ -555,6 +559,14 @@ impl UnifyKey for TypeVarId {
    }
 }
+fn from_inference_var(var: InferenceVar) -> TypeVarId {
+    TypeVarId(var.index())
+}
+fn to_inference_var(TypeVarId(index): TypeVarId) -> InferenceVar {
+    index.into()
+}
 /// The value of a type variable: either we already know the type, or we don't
 /// know it yet.
 #[derive(Clone, PartialEq, Eq, Debug)]
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index f5b658cba..5c83a508d 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -42,7 +42,7 @@ use crate::{db::HirDatabase, display::HirDisplay, utils::generics};
 pub use autoderef::autoderef;
 pub use builder::TyBuilder;
 pub use chalk_ext::{ProjectionTyExt, TyExt};
-pub use infer::{could_unify, InferenceResult, InferenceVar};
+pub use infer::{could_unify, InferenceResult};
 pub use lower::{
    associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
    TyDefId, TyLoweringContext, ValueTyDefId,
diff --git a/crates/hir_ty/src/method_resolution.rs b/crates/hir_ty/src/method_resolution.rs
index ee725fd46..f29319f20 100644
--- a/crates/hir_ty/src/method_resolution.rs
+++ b/crates/hir_ty/src/method_resolution.rs
@@ -8,8 +8,8 @@ use arrayvec::ArrayVec;
 use base_db::CrateId;
 use chalk_ir::{cast::Cast, Mutability, UniverseIndex};
 use hir_def::{
-    lang_item::LangItemTarget, AssocContainerId, AssocItemId, FunctionId, GenericDefId, HasModule,
+    lang_item::LangItemTarget, nameres::DefMap, AssocContainerId, AssocItemId, FunctionId,
-    ImplId, Lookup, ModuleId, TraitId,
+    GenericDefId, HasModule, ImplId, Lookup, ModuleId, TraitId,
 };
 use hir_expand::name::Name;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -100,25 +100,38 @@ impl TraitImpls {
        let mut impls = Self { map: FxHashMap::default() };
        let crate_def_map = db.crate_def_map(krate);
-        for (_module_id, module_data) in crate_def_map.modules() {
+        collect_def_map(db, &crate_def_map, &mut impls);
-            for impl_id in module_data.scope.impls() {
-                let target_trait = match db.impl_trait(impl_id) {
+        return Arc::new(impls);
-                    Some(tr) => tr.skip_binders().hir_trait_id(),
-                    None => continue,
+        fn collect_def_map(db: &dyn HirDatabase, def_map: &DefMap, impls: &mut TraitImpls) {
-                };
+            for (_module_id, module_data) in def_map.modules() {
-                let self_ty = db.impl_self_ty(impl_id);
+                for impl_id in module_data.scope.impls() {
-                let self_ty_fp = TyFingerprint::for_impl(self_ty.skip_binders());
+                    let target_trait = match db.impl_trait(impl_id) {
-                impls
+                        Some(tr) => tr.skip_binders().hir_trait_id(),
-                    .map
+                        None => continue,
-                    .entry(target_trait)
+                    };
-                    .or_default()
+                    let self_ty = db.impl_self_ty(impl_id);
-                    .entry(self_ty_fp)
+                    let self_ty_fp = TyFingerprint::for_impl(self_ty.skip_binders());
-                    .or_default()
+                    impls
-                    .push(impl_id);
+                        .map
+                        .entry(target_trait)
+                        .or_default()
+                        .entry(self_ty_fp)
+                        .or_default()
+                        .push(impl_id);
+                }
+                // To better support custom derives, collect impls in all unnamed const items.
+                // const _: () = { ... };
+                for konst in module_data.scope.unnamed_consts() {
+                    let body = db.body(konst.into());
+                    for (_, block_def_map) in body.blocks(db.upcast()) {
+                        collect_def_map(db, &block_def_map, impls);
+                    }
+                }
            }
        }
-        Arc::new(impls)
    }
    pub(crate) fn trait_impls_in_deps_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
@@ -208,6 +221,9 @@ impl InherentImpls {
            }
        }
+        // NOTE: We're not collecting inherent impls from unnamed consts here, we intentionally only
+        // support trait impls there.
        Arc::new(Self { map })
    }
diff --git a/crates/hir_ty/src/tests/method_resolution.rs b/crates/hir_ty/src/tests/method_resolution.rs
index 61f18b0d2..4b2c82b41 100644
--- a/crates/hir_ty/src/tests/method_resolution.rs
+++ b/crates/hir_ty/src/tests/method_resolution.rs
@@ -1292,3 +1292,25 @@ mod b {
        "#]],
    )
 }
+#[test]
+fn impl_in_unnamed_const() {
+    check_types(
+        r#"
+struct S;
+trait Tr {
+    fn method(&self) -> u16;
+}
+const _: () = {
+    impl Tr for S {}
+};
+fn f() {
+    S.method();
+  //^^^^^^^^^^ u16
+}
+    "#,
+    );
+}
diff --git a/crates/hir_ty/src/traits.rs b/crates/hir_ty/src/traits.rs
index c8883485c..3374532c3 100644
--- a/crates/hir_ty/src/traits.rs
+++ b/crates/hir_ty/src/traits.rs
@@ -9,7 +9,7 @@ use stdx::panic_context;
 use crate::{
    db::HirDatabase, AliasEq, AliasTy, Canonical, DomainGoal, Guidance, HirDisplay, InEnvironment,
-    Solution, SolutionVariables, Ty, TyKind, WhereClause,
+    Solution, Ty, TyKind, WhereClause,
 };
 use self::chalk::{from_chalk, Interner, ToChalk};
@@ -173,23 +173,15 @@ fn solution_from_chalk(
    db: &dyn HirDatabase,
    solution: chalk_solve::Solution<Interner>,
 ) -> Solution {
-    let convert_subst = |subst: chalk_ir::Canonical<chalk_ir::Substitution<Interner>>| {
-        let result = from_chalk(db, subst);
-        SolutionVariables(result)
-    };
    match solution {
        chalk_solve::Solution::Unique(constr_subst) => {
-            let subst = chalk_ir::Canonical {
+            Solution::Unique(from_chalk(db, constr_subst))
-                value: constr_subst.value.subst,
-                binders: constr_subst.binders,
-            };
-            Solution::Unique(convert_subst(subst))
        }
        chalk_solve::Solution::Ambig(chalk_solve::Guidance::Definite(subst)) => {
-            Solution::Ambig(Guidance::Definite(convert_subst(subst)))
+            Solution::Ambig(Guidance::Definite(from_chalk(db, subst)))
        }
        chalk_solve::Solution::Ambig(chalk_solve::Guidance::Suggested(subst)) => {
-            Solution::Ambig(Guidance::Suggested(convert_subst(subst)))
+            Solution::Ambig(Guidance::Suggested(from_chalk(db, subst)))
        }
        chalk_solve::Solution::Ambig(chalk_solve::Guidance::Unknown) => {
            Solution::Ambig(Guidance::Unknown)
diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index cf73cb078..84abd99b2 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -10,10 +10,9 @@ use base_db::salsa::InternKey;
 use hir_def::{GenericDefId, TypeAliasId};
 use crate::{
-    chalk_ext::ProjectionTyExt, db::HirDatabase, dummy_usize_const, static_lifetime, AliasTy,
+    chalk_ext::ProjectionTyExt, db::HirDatabase, static_lifetime, AliasTy, CallableDefId,
-    CallableDefId, Canonical, Const, DomainGoal, FnPointer, GenericArg, InEnvironment, Lifetime,
+    Canonical, ConstrainedSubst, DomainGoal, FnPointer, GenericArg, InEnvironment, OpaqueTy,
-    OpaqueTy, ProjectionTy, QuantifiedWhereClause, Substitution, TraitRef, Ty, TypeWalk,
+    ProjectionTy, QuantifiedWhereClause, Substitution, TraitRef, Ty, TypeWalk, WhereClause,
-    WhereClause,
 };
 use super::interner::*;
@@ -23,16 +22,16 @@ impl ToChalk for Ty {
    type Chalk = chalk_ir::Ty<Interner>;
    fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> {
        match self.into_inner() {
-            TyKind::Ref(m, lt, ty) => ref_to_chalk(db, m, lt, ty),
+            TyKind::Ref(m, lt, ty) => {
-            TyKind::Array(ty, size) => array_to_chalk(db, ty, size),
+                chalk_ir::TyKind::Ref(m, lt, ty.to_chalk(db)).intern(&Interner)
-            TyKind::Function(FnPointer { sig, substitution: substs, .. }) => {
+            }
+            TyKind::Array(ty, size) => {
+                chalk_ir::TyKind::Array(ty.to_chalk(db), size).intern(&Interner)
+            }
+            TyKind::Function(FnPointer { sig, substitution: substs, num_binders }) => {
                let substitution = chalk_ir::FnSubst(substs.0.to_chalk(db));
-                chalk_ir::TyKind::Function(chalk_ir::FnPointer {
+                chalk_ir::TyKind::Function(chalk_ir::FnPointer { num_binders, sig, substitution })
-                    num_binders: 0,
+                    .intern(&Interner)
-                    sig,
-                    substitution,
-                })
-                .intern(&Interner)
            }
            TyKind::AssociatedType(assoc_type_id, substs) => {
                let substitution = substs.to_chalk(db);
@@ -74,22 +73,13 @@ impl ToChalk for Ty {
                chalk_ir::TyKind::Adt(adt_id, substitution).intern(&Interner)
            }
            TyKind::Alias(AliasTy::Projection(proj_ty)) => {
-                let associated_ty_id = proj_ty.associated_ty_id;
+                chalk_ir::AliasTy::Projection(proj_ty.to_chalk(db))
-                let substitution = proj_ty.substitution.to_chalk(db);
-                chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
-                    associated_ty_id,
-                    substitution,
-                })
-                .cast(&Interner)
-                .intern(&Interner)
-            }
-            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
-                let opaque_ty_id = opaque_ty.opaque_ty_id;
-                let substitution = opaque_ty.substitution.to_chalk(db);
-                chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy { opaque_ty_id, substitution })
                    .cast(&Interner)
                    .intern(&Interner)
            }
+            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
+                chalk_ir::AliasTy::Opaque(opaque_ty.to_chalk(db)).cast(&Interner).intern(&Interner)
+            }
            TyKind::Placeholder(idx) => idx.to_ty::<Interner>(&Interner),
            TyKind::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
            TyKind::InferenceVar(..) => panic!("uncanonicalized infer ty"),
@@ -101,7 +91,7 @@ impl ToChalk for Ty {
                );
                let bounded_ty = chalk_ir::DynTy {
                    bounds: chalk_ir::Binders::new(binders, where_clauses),
-                    lifetime: static_lifetime(),
+                    lifetime: dyn_ty.lifetime,
                };
                chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner)
            }
@@ -114,17 +104,10 @@ impl ToChalk for Ty {
            chalk_ir::TyKind::Array(ty, size) => TyKind::Array(from_chalk(db, ty), size),
            chalk_ir::TyKind::Placeholder(idx) => TyKind::Placeholder(idx),
            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => {
-                let associated_ty = proj.associated_ty_id;
+                TyKind::Alias(AliasTy::Projection(from_chalk(db, proj)))
-                let parameters = from_chalk(db, proj.substitution);
-                TyKind::Alias(AliasTy::Projection(ProjectionTy {
-                    associated_ty_id: associated_ty,
-                    substitution: parameters,
-                }))
            }
            chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => {
-                let opaque_ty_id = opaque_ty.opaque_ty_id;
+                TyKind::Alias(AliasTy::Opaque(from_chalk(db, opaque_ty)))
-                let parameters = from_chalk(db, opaque_ty.substitution);
-                TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, substitution: parameters }))
            }
            chalk_ir::TyKind::Function(chalk_ir::FnPointer {
                num_binders,
@@ -138,18 +121,19 @@ impl ToChalk for Ty {
            }
            chalk_ir::TyKind::BoundVar(idx) => TyKind::BoundVar(idx),
            chalk_ir::TyKind::InferenceVar(_iv, _kind) => TyKind::Error,
-            chalk_ir::TyKind::Dyn(where_clauses) => {
+            chalk_ir::TyKind::Dyn(dyn_ty) => {
-                assert_eq!(where_clauses.bounds.binders.len(&Interner), 1);
+                assert_eq!(dyn_ty.bounds.binders.len(&Interner), 1);
-                let bounds = where_clauses
+                let (bounds, binders) = dyn_ty.bounds.into_value_and_skipped_binders();
-                    .bounds
+                let where_clauses = crate::QuantifiedWhereClauses::from_iter(
-                    .skip_binders()
+                    &Interner,
-                    .iter(&Interner)
+                    bounds.interned().iter().cloned().map(|p| from_chalk(db, p)),
-                    .map(|c| from_chalk(db, c.clone()));
+                );
                TyKind::Dyn(crate::DynTy {
-                    bounds: crate::Binders::new(
+                    bounds: crate::Binders::new(binders, where_clauses),
-                        where_clauses.bounds.binders.clone(),
+                    // HACK: we sometimes get lifetime variables back in solutions
-                        crate::QuantifiedWhereClauses::from_iter(&Interner, bounds),
+                    // from Chalk, and don't have the infrastructure to substitute
-                    ),
+                    // them yet. So for now we just turn them into 'static right
+                    // when we get them
                    lifetime: static_lifetime(),
                })
            }
@@ -169,8 +153,12 @@ impl ToChalk for Ty {
            }
            chalk_ir::TyKind::Raw(mutability, ty) => TyKind::Raw(mutability, from_chalk(db, ty)),
            chalk_ir::TyKind::Slice(ty) => TyKind::Slice(from_chalk(db, ty)),
-            chalk_ir::TyKind::Ref(mutability, lifetime, ty) => {
+            chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
-                TyKind::Ref(mutability, lifetime, from_chalk(db, ty))
+                // HACK: we sometimes get lifetime variables back in solutions
+                // from Chalk, and don't have the infrastructure to substitute
+                // them yet. So for now we just turn them into 'static right
+                // when we get them
+                TyKind::Ref(mutability, static_lifetime(), from_chalk(db, ty))
            }
            chalk_ir::TyKind::Str => TyKind::Str,
            chalk_ir::TyKind::Never => TyKind::Never,
@@ -189,26 +177,6 @@ impl ToChalk for Ty {
    }
 }
-/// We currently don't model lifetimes, but Chalk does. So, we have to insert a
-/// fake lifetime here, because Chalks built-in logic may expect it to be there.
-fn ref_to_chalk(
-    db: &dyn HirDatabase,
-    mutability: chalk_ir::Mutability,
-    _lifetime: Lifetime,
-    ty: Ty,
-) -> chalk_ir::Ty<Interner> {
-    let arg = ty.to_chalk(db);
-    let lifetime = static_lifetime();
-    chalk_ir::TyKind::Ref(mutability, lifetime, arg).intern(&Interner)
-}
-/// We currently don't model constants, but Chalk does. So, we have to insert a
-/// fake constant here, because Chalks built-in logic may expect it to be there.
-fn array_to_chalk(db: &dyn HirDatabase, ty: Ty, _: Const) -> chalk_ir::Ty<Interner> {
-    let arg = ty.to_chalk(db);
-    chalk_ir::TyKind::Array(arg, dummy_usize_const()).intern(&Interner)
-}
 impl ToChalk for GenericArg {
    type Chalk = chalk_ir::GenericArg<Interner>;
@@ -491,6 +459,18 @@ where
    }
 }
+impl ToChalk for crate::ConstrainedSubst {
+    type Chalk = chalk_ir::ConstrainedSubst<Interner>;
+    fn to_chalk(self, _db: &dyn HirDatabase) -> Self::Chalk {
+        unimplemented!()
+    }
+    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
+        ConstrainedSubst { subst: from_chalk(db, chalk.subst) }
+    }
+}
 pub(super) fn make_binders<T>(value: T, num_vars: usize) -> chalk_ir::Binders<T>
 where
    T: HasInterner<Interner = Interner>,
diff --git a/crates/hir_ty/src/types.rs b/crates/hir_ty/src/types.rs
index 89c0ddd1a..c25bc2d6a 100644
--- a/crates/hir_ty/src/types.rs
+++ b/crates/hir_ty/src/types.rs
@@ -11,8 +11,7 @@ use smallvec::SmallVec;
 use crate::{
    AssocTypeId, CanonicalVarKinds, ChalkTraitId, ClosureId, Const, FnDefId, FnSig, ForeignDefId,
-    InferenceVar, Interner, Lifetime, OpaqueTyId, PlaceholderIndex, TypeWalk, VariableKind,
+    Interner, Lifetime, OpaqueTyId, PlaceholderIndex, TypeWalk, VariableKind, VariableKinds,
-    VariableKinds,
 };
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -491,14 +490,16 @@ pub struct AliasEq {
 }
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct SolutionVariables(pub Canonical<Substitution>);
+pub struct ConstrainedSubst {
+    pub subst: Substitution,
+}
 #[derive(Clone, Debug, PartialEq, Eq)]
 /// A (possible) solution for a proposed goal.
 pub enum Solution {
    /// The goal indeed holds, and there is a unique value for all existential
    /// variables.
-    Unique(SolutionVariables),
+    Unique(Canonical<ConstrainedSubst>),
    /// The goal may be provable in multiple ways, but regardless we may have some guidance
    /// for type inference. In this case, we don't return any lifetime
@@ -514,13 +515,35 @@ pub enum Guidance {
    /// The existential variables *must* have the given values if the goal is
    /// ever to hold, but that alone isn't enough to guarantee the goal will
    /// actually hold.
-    Definite(SolutionVariables),
+    Definite(Canonical<Substitution>),
    /// There are multiple plausible values for the existentials, but the ones
    /// here are suggested as the preferred choice heuristically. These should
    /// be used for inference fallback only.
-    Suggested(SolutionVariables),
+    Suggested(Canonical<Substitution>),
    /// There's no useful information to feed back to type inference
    Unknown,
 }
+/// The kinds of placeholders we need during type inference. There's separate
+/// values for general types, and for integer and float variables. The latter
+/// two are used for inference of literal values (e.g. `100` could be one of
+/// several integer types).
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+pub struct InferenceVar {
+    index: u32,
+}
+impl From<u32> for InferenceVar {
+    fn from(index: u32) -> InferenceVar {
+        InferenceVar { index }
+    }
+}
+impl InferenceVar {
+    /// Gets the underlying index value.
+    pub fn index(self) -> u32 {
+        self.index
+    }
+}
diff --git a/crates/ide/src/expand_macro.rs b/crates/ide/src/expand_macro.rs
index 9eeabbeda..d5628e3df 100644
--- a/crates/ide/src/expand_macro.rs
+++ b/crates/ide/src/expand_macro.rs
@@ -103,6 +103,9 @@ fn insert_whitespaces(syn: SyntaxNode) -> String {
                format!("\n{}}}", "  ".repeat(indent))
            }
            R_CURLY => format!("}}\n{}", "  ".repeat(indent)),
+            LIFETIME_IDENT if is_next(|it| it == IDENT, true) => {
+                format!("{} ", token.text().to_string())
+            }
            T![;] => format!(";\n{}", "  ".repeat(indent)),
            T![->] => " -> ".to_string(),
            T![=] => " = ".to_string(),
diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index 1ad017198..9ace13e41 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -113,6 +113,7 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
    if ctx.use_item_syntax.is_some()
        || ctx.attribute_under_caret.is_some()
        || ctx.mod_declaration_under_caret.is_some()
+        || ctx.record_lit_syntax.is_some()
    {
        return None;
    }
@@ -1034,4 +1035,46 @@ fn main() {
            expect![[]],
        );
    }
+    #[test]
+    fn no_fuzzy_during_fields_of_record_lit_syntax() {
+        check(
+            r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+struct Foo {
+    some_field: i32,
+}
+fn main() {
+    let _ = Foo { so$0 };
+}
+"#,
+            expect![[]],
+        );
+    }
+    #[test]
+    fn fuzzy_after_fields_of_record_lit_syntax() {
+        check(
+            r#"
+mod m {
+    pub fn some_fn() -> i32 {
+        42
+    }
+}
+struct Foo {
+    some_field: i32,
+}
+fn main() {
+    let _ = Foo { some_field: so$0 };
+}
+"#,
+            expect![[r#"
+                fn some_fn() (m::some_fn) fn() -> i32
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide_db/src/apply_change.rs b/crates/ide_db/src/apply_change.rs
index 111e9325a..6c67425d7 100644
--- a/crates/ide_db/src/apply_change.rs
+++ b/crates/ide_db/src/apply_change.rs
@@ -152,6 +152,10 @@ impl RootDatabase {
            hir::db::FileItemTreeQuery
            hir::db::BlockDefMapQuery
            hir::db::CrateDefMapQueryQuery
+            hir::db::FieldsAttrsQuery
+            hir::db::VariantsAttrsQuery
+            hir::db::FieldsAttrsSourceMapQuery
+            hir::db::VariantsAttrsSourceMapQuery
            hir::db::StructDataQuery
            hir::db::UnionDataQuery
            hir::db::EnumDataQuery
diff --git a/crates/test_utils/src/fixture.rs b/crates/test_utils/src/fixture.rs
index 6bc824e94..099baeca2 100644
--- a/crates/test_utils/src/fixture.rs
+++ b/crates/test_utils/src/fixture.rs
@@ -1,5 +1,65 @@
 //! Defines `Fixture` -- a convenient way to describe the initial state of
 //! rust-analyzer database from a single string.
+//!
+//! Fixtures are strings containing rust source code with optional metadata.
+//! A fixture without metadata is parsed into a single source file.
+//! Use this to test functionality local to one file.
+//!
+//! Simple Example:
+//! ```
+//! r#"
+//! fn main() {
+//!     println!("Hello World")
+//! }
+//! "#
+//! ```
+//!
+//! Metadata can be added to a fixture after a `//-` comment.
+//! The basic form is specifying filenames,
+//! which is also how to define multiple files in a single test fixture
+//!
+//! Example using two files in the same crate:
+//! ```
+//! "
+//! //- /main.rs
+//! mod foo;
+//! fn main() {
+//!     foo::bar();
+//! }
+//!
+//! //- /foo.rs
+//! pub fn bar() {}
+//! "
+//! ```
+//!
+//! Example using two crates with one file each, with one crate depending on the other:
+//! ```
+//! r#"
+//! //- /main.rs crate:a deps:b
+//! fn main() {
+//!     b::foo();
+//! }
+//! //- /lib.rs crate:b
+//! pub fn b() {
+//!     println!("Hello World")
+//! }
+//! "#
+//! ```
+//!
+//! Metadata allows specifying all settings and variables
+//! that are available in a real rust project:
+//! - crate names via `crate:cratename`
+//! - dependencies via `deps:dep1,dep2`
+//! - configuration settings via `cfg:dbg=false,opt_level=2`
+//! - environment variables via `env:PATH=/bin,RUST_LOG=debug`
+//!
+//! Example using all available metadata:
+//! ```
+//! "
+//! //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
+//! fn insert_source_code_here() {}
+//! "
+//! ```
 use rustc_hash::FxHashMap;
 use stdx::{lines_with_ends, split_once, trim_indent};
@@ -24,7 +84,7 @@ impl Fixture {
    ///  //- some meta
    ///  line 1
    ///  line 2
-    ///  // - other meta
+    ///  //- other meta
    ///  ```
    pub fn parse(ra_fixture: &str) -> Vec<Fixture> {
        let fixture = trim_indent(ra_fixture);