Merge branch 'master' into add-disable-diagnostics

43 files changed, 15287 insertions, 0 deletions

diff --git a/crates/hir_def/src/adt.rs b/crates/hir_def/src/adt.rs
new file mode 100644
index 000000000..d69ff2fc7
--- /dev/null
+++ b/crates/hir_def/src/adt.rs
@@ -0,0 +1,329 @@
+//! Defines hir-level representation of structs, enums and unions
+
+use std::sync::Arc;
+
+use arena::{map::ArenaMap, Arena};
+use either::Either;
+use hir_expand::{
+    name::{AsName, Name},
+    InFile,
+};
+use syntax::ast::{self, NameOwner, VisibilityOwner};
+use tt::{Delimiter, DelimiterKind, Leaf, Subtree, TokenTree};
+
+use crate::{
+    body::{CfgExpander, LowerCtx},
+    db::DefDatabase,
+    item_tree::{AttrOwner, Field, Fields, ItemTree, ModItem},
+    src::HasChildSource,
+    src::HasSource,
+    trace::Trace,
+    type_ref::TypeRef,
+    visibility::RawVisibility,
+    EnumId, HasModule, LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StructId, UnionId,
+    VariantId,
+};
+use cfg::CfgOptions;
+
+/// Note that we use `StructData` for unions as well!
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct StructData {
+    pub name: Name,
+    pub variant_data: Arc<VariantData>,
+    pub repr: Option<ReprKind>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EnumData {
+    pub name: Name,
+    pub variants: Arena<EnumVariantData>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EnumVariantData {
+    pub name: Name,
+    pub variant_data: Arc<VariantData>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum VariantData {
+    Record(Arena<FieldData>),
+    Tuple(Arena<FieldData>),
+    Unit,
+}
+
+/// A single field of an enum variant or struct
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FieldData {
+    pub name: Name,
+    pub type_ref: TypeRef,
+    pub visibility: RawVisibility,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ReprKind {
+    Packed,
+    Other,
+}
+
+fn repr_from_value(item_tree: &ItemTree, of: AttrOwner) -> Option<ReprKind> {
+    item_tree.attrs(of).by_key("repr").tt_values().find_map(parse_repr_tt)
+}
+
+fn parse_repr_tt(tt: &Subtree) -> Option<ReprKind> {
+    match tt.delimiter {
+        Some(Delimiter { kind: DelimiterKind::Parenthesis, .. }) => {}
+        _ => return None,
+    }
+
+    let mut it = tt.token_trees.iter();
+    match it.next()? {
+        TokenTree::Leaf(Leaf::Ident(ident)) if ident.text == "packed" => Some(ReprKind::Packed),
+        _ => Some(ReprKind::Other),
+    }
+}
+
+impl StructData {
+    pub(crate) fn struct_data_query(db: &dyn DefDatabase, id: StructId) -> Arc<StructData> {
+        let loc = id.lookup(db);
+        let item_tree = db.item_tree(loc.id.file_id);
+        let repr = repr_from_value(&item_tree, ModItem::from(loc.id.value).into());
+        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
+
+        let strukt = &item_tree[loc.id.value];
+        let variant_data = lower_fields(&item_tree, &cfg_options, &strukt.fields);
+        Arc::new(StructData {
+            name: strukt.name.clone(),
+            variant_data: Arc::new(variant_data),
+            repr,
+        })
+    }
+    pub(crate) fn union_data_query(db: &dyn DefDatabase, id: UnionId) -> Arc<StructData> {
+        let loc = id.lookup(db);
+        let item_tree = db.item_tree(loc.id.file_id);
+        let repr = repr_from_value(&item_tree, ModItem::from(loc.id.value).into());
+        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
+
+        let union = &item_tree[loc.id.value];
+        let variant_data = lower_fields(&item_tree, &cfg_options, &union.fields);
+
+        Arc::new(StructData {
+            name: union.name.clone(),
+            variant_data: Arc::new(variant_data),
+            repr,
+        })
+    }
+}
+
+impl EnumData {
+    pub(crate) fn enum_data_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumData> {
+        let loc = e.lookup(db);
+        let item_tree = db.item_tree(loc.id.file_id);
+        let cfg_options = db.crate_graph()[loc.container.module(db).krate].cfg_options.clone();
+
+        let enum_ = &item_tree[loc.id.value];
+        let mut variants = Arena::new();
+        for var_id in enum_.variants.clone() {
+            if item_tree.attrs(var_id.into()).is_cfg_enabled(&cfg_options) {
+                let var = &item_tree[var_id];
+                let var_data = lower_fields(&item_tree, &cfg_options, &var.fields);
+
+                variants.alloc(EnumVariantData {
+                    name: var.name.clone(),
+                    variant_data: Arc::new(var_data),
+                });
+            }
+        }
+
+        Arc::new(EnumData { name: enum_.name.clone(), variants })
+    }
+
+    pub fn variant(&self, name: &Name) -> Option<LocalEnumVariantId> {
+        let (id, _) = self.variants.iter().find(|(_id, data)| &data.name == name)?;
+        Some(id)
+    }
+}
+
+impl HasChildSource for EnumId {
+    type ChildId = LocalEnumVariantId;
+    type Value = ast::Variant;
+    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
+        let src = self.lookup(db).source(db);
+        let mut trace = Trace::new_for_map();
+        lower_enum(db, &mut trace, &src, self.lookup(db).container.module(db));
+        src.with_value(trace.into_map())
+    }
+}
+
+fn lower_enum(
+    db: &dyn DefDatabase,
+    trace: &mut Trace<EnumVariantData, ast::Variant>,
+    ast: &InFile<ast::Enum>,
+    module_id: ModuleId,
+) {
+    let expander = CfgExpander::new(db, ast.file_id, module_id.krate);
+    let variants = ast
+        .value
+        .variant_list()
+        .into_iter()
+        .flat_map(|it| it.variants())
+        .filter(|var| expander.is_cfg_enabled(var));
+    for var in variants {
+        trace.alloc(
+            || var.clone(),
+            || EnumVariantData {
+                name: var.name().map_or_else(Name::missing, |it| it.as_name()),
+                variant_data: Arc::new(VariantData::new(db, ast.with_value(var.kind()), module_id)),
+            },
+        );
+    }
+}
+
+impl VariantData {
+    fn new(db: &dyn DefDatabase, flavor: InFile<ast::StructKind>, module_id: ModuleId) -> Self {
+        let mut expander = CfgExpander::new(db, flavor.file_id, module_id.krate);
+        let mut trace = Trace::new_for_arena();
+        match lower_struct(db, &mut expander, &mut trace, &flavor) {
+            StructKind::Tuple => VariantData::Tuple(trace.into_arena()),
+            StructKind::Record => VariantData::Record(trace.into_arena()),
+            StructKind::Unit => VariantData::Unit,
+        }
+    }
+
+    pub fn fields(&self) -> &Arena<FieldData> {
+        const EMPTY: &Arena<FieldData> = &Arena::new();
+        match &self {
+            VariantData::Record(fields) | VariantData::Tuple(fields) => fields,
+            _ => EMPTY,
+        }
+    }
+
+    pub fn field(&self, name: &Name) -> Option<LocalFieldId> {
+        self.fields().iter().find_map(|(id, data)| if &data.name == name { Some(id) } else { None })
+    }
+
+    pub fn kind(&self) -> StructKind {
+        match self {
+            VariantData::Record(_) => StructKind::Record,
+            VariantData::Tuple(_) => StructKind::Tuple,
+            VariantData::Unit => StructKind::Unit,
+        }
+    }
+}
+
+impl HasChildSource for VariantId {
+    type ChildId = LocalFieldId;
+    type Value = Either<ast::TupleField, ast::RecordField>;
+
+    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
+        let (src, module_id) = match self {
+            VariantId::EnumVariantId(it) => {
+                // I don't really like the fact that we call into parent source
+                // here, this might add to more queries then necessary.
+                let src = it.parent.child_source(db);
+                (src.map(|map| map[it.local_id].kind()), it.parent.lookup(db).container.module(db))
+            }
+            VariantId::StructId(it) => {
+                (it.lookup(db).source(db).map(|it| it.kind()), it.lookup(db).container.module(db))
+            }
+            VariantId::UnionId(it) => (
+                it.lookup(db).source(db).map(|it| {
+                    it.record_field_list()
+                        .map(ast::StructKind::Record)
+                        .unwrap_or(ast::StructKind::Unit)
+                }),
+                it.lookup(db).container.module(db),
+            ),
+        };
+        let mut expander = CfgExpander::new(db, src.file_id, module_id.krate);
+        let mut trace = Trace::new_for_map();
+        lower_struct(db, &mut expander, &mut trace, &src);
+        src.with_value(trace.into_map())
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum StructKind {
+    Tuple,
+    Record,
+    Unit,
+}
+
+fn lower_struct(
+    db: &dyn DefDatabase,
+    expander: &mut CfgExpander,
+    trace: &mut Trace<FieldData, Either<ast::TupleField, ast::RecordField>>,
+    ast: &InFile<ast::StructKind>,
+) -> StructKind {
+    let ctx = LowerCtx::new(db, ast.file_id);
+
+    match &ast.value {
+        ast::StructKind::Tuple(fl) => {
+            for (i, fd) in fl.fields().enumerate() {
+                if !expander.is_cfg_enabled(&fd) {
+                    continue;
+                }
+
+                trace.alloc(
+                    || Either::Left(fd.clone()),
+                    || FieldData {
+                        name: Name::new_tuple_field(i),
+                        type_ref: TypeRef::from_ast_opt(&ctx, fd.ty()),
+                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
+                    },
+                );
+            }
+            StructKind::Tuple
+        }
+        ast::StructKind::Record(fl) => {
+            for fd in fl.fields() {
+                if !expander.is_cfg_enabled(&fd) {
+                    continue;
+                }
+
+                trace.alloc(
+                    || Either::Right(fd.clone()),
+                    || FieldData {
+                        name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing),
+                        type_ref: TypeRef::from_ast_opt(&ctx, fd.ty()),
+                        visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())),
+                    },
+                );
+            }
+            StructKind::Record
+        }
+        ast::StructKind::Unit => StructKind::Unit,
+    }
+}
+
+fn lower_fields(item_tree: &ItemTree, cfg_options: &CfgOptions, fields: &Fields) -> VariantData {
+    match fields {
+        Fields::Record(flds) => {
+            let mut arena = Arena::new();
+            for field_id in flds.clone() {
+                if item_tree.attrs(field_id.into()).is_cfg_enabled(cfg_options) {
+                    arena.alloc(lower_field(item_tree, &item_tree[field_id]));
+                }
+            }
+            VariantData::Record(arena)
+        }
+        Fields::Tuple(flds) => {
+            let mut arena = Arena::new();
+            for field_id in flds.clone() {
+                if item_tree.attrs(field_id.into()).is_cfg_enabled(cfg_options) {
+                    arena.alloc(lower_field(item_tree, &item_tree[field_id]));
+                }
+            }
+            VariantData::Tuple(arena)
+        }
+        Fields::Unit => VariantData::Unit,
+    }
+}
+
+fn lower_field(item_tree: &ItemTree, field: &Field) -> FieldData {
+    FieldData {
+        name: field.name.clone(),
+        type_ref: field.type_ref.clone(),
+        visibility: item_tree[field.visibility].clone(),
+    }
+}
diff --git a/crates/hir_def/src/attr.rs b/crates/hir_def/src/attr.rs
new file mode 100644
index 000000000..dea552a60
--- /dev/null
+++ b/crates/hir_def/src/attr.rs
@@ -0,0 +1,212 @@
+//! A higher level attributes based on TokenTree, with also some shortcuts.
+
+use std::{ops, sync::Arc};
+
+use cfg::{CfgExpr, CfgOptions};
+use either::Either;
+use hir_expand::{hygiene::Hygiene, AstId, InFile};
+use mbe::ast_to_token_tree;
+use syntax::{
+    ast::{self, AstNode, AttrsOwner},
+    SmolStr,
+};
+use tt::Subtree;
+
+use crate::{
+    db::DefDatabase,
+    item_tree::{ItemTreeId, ItemTreeNode},
+    nameres::ModuleSource,
+    path::ModPath,
+    src::HasChildSource,
+    AdtId, AttrDefId, Lookup,
+};
+
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct Attrs {
+    entries: Option<Arc<[Attr]>>,
+}
+
+impl ops::Deref for Attrs {
+    type Target = [Attr];
+
+    fn deref(&self) -> &[Attr] {
+        match &self.entries {
+            Some(it) => &*it,
+            None => &[],
+        }
+    }
+}
+
+impl Attrs {
+    pub const EMPTY: Attrs = Attrs { entries: None };
+
+    pub(crate) fn attrs_query(db: &dyn DefDatabase, def: AttrDefId) -> Attrs {
+        match def {
+            AttrDefId::ModuleId(module) => {
+                let def_map = db.crate_def_map(module.krate);
+                let mod_data = &def_map[module.local_id];
+                match mod_data.declaration_source(db) {
+                    Some(it) => {
+                        Attrs::from_attrs_owner(db, it.as_ref().map(|it| it as &dyn AttrsOwner))
+                    }
+                    None => Attrs::from_attrs_owner(
+                        db,
+                        mod_data.definition_source(db).as_ref().map(|src| match src {
+                            ModuleSource::SourceFile(file) => file as &dyn AttrsOwner,
+                            ModuleSource::Module(module) => module as &dyn AttrsOwner,
+                        }),
+                    ),
+                }
+            }
+            AttrDefId::FieldId(it) => {
+                let src = it.parent.child_source(db);
+                match &src.value[it.local_id] {
+                    Either::Left(_tuple) => Attrs::default(),
+                    Either::Right(record) => Attrs::from_attrs_owner(db, src.with_value(record)),
+                }
+            }
+            AttrDefId::EnumVariantId(var_id) => {
+                let src = var_id.parent.child_source(db);
+                let src = src.as_ref().map(|it| &it[var_id.local_id]);
+                Attrs::from_attrs_owner(db, src.map(|it| it as &dyn AttrsOwner))
+            }
+            AttrDefId::AdtId(it) => match it {
+                AdtId::StructId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+                AdtId::EnumId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+                AdtId::UnionId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            },
+            AttrDefId::TraitId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::MacroDefId(it) => {
+                it.ast_id.map_or_else(Default::default, |ast_id| attrs_from_ast(ast_id, db))
+            }
+            AttrDefId::ImplId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::ConstId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::StaticId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::FunctionId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+            AttrDefId::TypeAliasId(it) => attrs_from_item_tree(it.lookup(db).id, db),
+        }
+    }
+
+    pub fn from_attrs_owner(db: &dyn DefDatabase, owner: InFile<&dyn AttrsOwner>) -> Attrs {
+        let hygiene = Hygiene::new(db.upcast(), owner.file_id);
+        Attrs::new(owner.value, &hygiene)
+    }
+
+    pub(crate) fn new(owner: &dyn AttrsOwner, hygiene: &Hygiene) -> Attrs {
+        let docs = ast::CommentIter::from_syntax_node(owner.syntax()).doc_comment_text().map(
+            |docs_text| Attr {
+                input: Some(AttrInput::Literal(SmolStr::new(docs_text))),
+                path: ModPath::from(hir_expand::name!(doc)),
+            },
+        );
+        let mut attrs = owner.attrs().peekable();
+        let entries = if attrs.peek().is_none() {
+            // Avoid heap allocation
+            None
+        } else {
+            Some(attrs.flat_map(|ast| Attr::from_src(ast, hygiene)).chain(docs).collect())
+        };
+        Attrs { entries }
+    }
+
+    pub fn merge(&self, other: Attrs) -> Attrs {
+        match (&self.entries, &other.entries) {
+            (None, None) => Attrs { entries: None },
+            (Some(entries), None) | (None, Some(entries)) => {
+                Attrs { entries: Some(entries.clone()) }
+            }
+            (Some(a), Some(b)) => {
+                Attrs { entries: Some(a.iter().chain(b.iter()).cloned().collect()) }
+            }
+        }
+    }
+
+    pub fn by_key(&self, key: &'static str) -> AttrQuery<'_> {
+        AttrQuery { attrs: self, key }
+    }
+
+    pub fn cfg(&self) -> impl Iterator<Item = CfgExpr> + '_ {
+        // FIXME: handle cfg_attr :-)
+        self.by_key("cfg").tt_values().map(CfgExpr::parse)
+    }
+    pub(crate) fn is_cfg_enabled(&self, cfg_options: &CfgOptions) -> bool {
+        self.cfg().all(|cfg| cfg_options.check(&cfg) != Some(false))
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Attr {
+    pub(crate) path: ModPath,
+    pub(crate) input: Option<AttrInput>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AttrInput {
+    /// `#[attr = "string"]`
+    Literal(SmolStr),
+    /// `#[attr(subtree)]`
+    TokenTree(Subtree),
+}
+
+impl Attr {
+    fn from_src(ast: ast::Attr, hygiene: &Hygiene) -> Option<Attr> {
+        let path = ModPath::from_src(ast.path()?, hygiene)?;
+        let input = if let Some(lit) = ast.literal() {
+            // FIXME: escape? raw string?
+            let value = lit.syntax().first_token()?.text().trim_matches('"').into();
+            Some(AttrInput::Literal(value))
+        } else if let Some(tt) = ast.token_tree() {
+            Some(AttrInput::TokenTree(ast_to_token_tree(&tt)?.0))
+        } else {
+            None
+        };
+        Some(Attr { path, input })
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct AttrQuery<'a> {
+    attrs: &'a Attrs,
+    key: &'static str,
+}
+
+impl<'a> AttrQuery<'a> {
+    pub fn tt_values(self) -> impl Iterator<Item = &'a Subtree> {
+        self.attrs().filter_map(|attr| match attr.input.as_ref()? {
+            AttrInput::TokenTree(it) => Some(it),
+            _ => None,
+        })
+    }
+
+    pub fn string_value(self) -> Option<&'a SmolStr> {
+        self.attrs().find_map(|attr| match attr.input.as_ref()? {
+            AttrInput::Literal(it) => Some(it),
+            _ => None,
+        })
+    }
+
+    pub fn exists(self) -> bool {
+        self.attrs().next().is_some()
+    }
+
+    fn attrs(self) -> impl Iterator<Item = &'a Attr> {
+        let key = self.key;
+        self.attrs
+            .iter()
+            .filter(move |attr| attr.path.as_ident().map_or(false, |s| s.to_string() == key))
+    }
+}
+
+fn attrs_from_ast<N>(src: AstId<N>, db: &dyn DefDatabase) -> Attrs
+where
+    N: ast::AttrsOwner,
+{
+    let src = InFile::new(src.file_id, src.to_node(db.upcast()));
+    Attrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn AttrsOwner))
+}
+
+fn attrs_from_item_tree<N: ItemTreeNode>(id: ItemTreeId<N>, db: &dyn DefDatabase) -> Attrs {
+    let tree = db.item_tree(id.file_id);
+    let mod_item = N::id_to_mod_item(id.value);
+    tree.attrs(mod_item.into()).clone()
+}
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
new file mode 100644
index 000000000..9a9a605dd
--- /dev/null
+++ b/crates/hir_def/src/body.rs
@@ -0,0 +1,360 @@
+//! Defines `Body`: a lowered representation of bodies of functions, statics and
+//! consts.
+mod lower;
+pub mod scope;
+
+use std::{mem, ops::Index, sync::Arc};
+
+use arena::{map::ArenaMap, Arena};
+use base_db::CrateId;
+use cfg::CfgOptions;
+use drop_bomb::DropBomb;
+use either::Either;
+use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, AstId, HirFileId, InFile, MacroDefId};
+use rustc_hash::FxHashMap;
+use syntax::{ast, AstNode, AstPtr};
+use test_utils::mark;
+
+pub(crate) use lower::LowerCtx;
+
+use crate::{
+    attr::Attrs,
+    db::DefDatabase,
+    expr::{Expr, ExprId, Pat, PatId},
+    item_scope::BuiltinShadowMode,
+    item_scope::ItemScope,
+    nameres::CrateDefMap,
+    path::{ModPath, Path},
+    src::HasSource,
+    AsMacroCall, DefWithBodyId, HasModule, Lookup, ModuleId,
+};
+
+/// A subset of Expander that only deals with cfg attributes. We only need it to
+/// avoid cyclic queries in crate def map during enum processing.
+pub(crate) struct CfgExpander {
+    cfg_options: CfgOptions,
+    hygiene: Hygiene,
+}
+
+pub(crate) struct Expander {
+    cfg_expander: CfgExpander,
+    crate_def_map: Arc<CrateDefMap>,
+    current_file_id: HirFileId,
+    ast_id_map: Arc<AstIdMap>,
+    module: ModuleId,
+    recursion_limit: usize,
+}
+
+#[cfg(test)]
+const EXPANSION_RECURSION_LIMIT: usize = 32;
+
+#[cfg(not(test))]
+const EXPANSION_RECURSION_LIMIT: usize = 128;
+
+impl CfgExpander {
+    pub(crate) fn new(
+        db: &dyn DefDatabase,
+        current_file_id: HirFileId,
+        krate: CrateId,
+    ) -> CfgExpander {
+        let hygiene = Hygiene::new(db.upcast(), current_file_id);
+        let cfg_options = db.crate_graph()[krate].cfg_options.clone();
+        CfgExpander { cfg_options, hygiene }
+    }
+
+    pub(crate) fn parse_attrs(&self, owner: &dyn ast::AttrsOwner) -> Attrs {
+        Attrs::new(owner, &self.hygiene)
+    }
+
+    pub(crate) fn is_cfg_enabled(&self, owner: &dyn ast::AttrsOwner) -> bool {
+        let attrs = self.parse_attrs(owner);
+        attrs.is_cfg_enabled(&self.cfg_options)
+    }
+}
+
+impl Expander {
+    pub(crate) fn new(
+        db: &dyn DefDatabase,
+        current_file_id: HirFileId,
+        module: ModuleId,
+    ) -> Expander {
+        let cfg_expander = CfgExpander::new(db, current_file_id, module.krate);
+        let crate_def_map = db.crate_def_map(module.krate);
+        let ast_id_map = db.ast_id_map(current_file_id);
+        Expander {
+            cfg_expander,
+            crate_def_map,
+            current_file_id,
+            ast_id_map,
+            module,
+            recursion_limit: 0,
+        }
+    }
+
+    pub(crate) fn enter_expand<T: ast::AstNode>(
+        &mut self,
+        db: &dyn DefDatabase,
+        local_scope: Option<&ItemScope>,
+        macro_call: ast::MacroCall,
+    ) -> Option<(Mark, T)> {
+        self.recursion_limit += 1;
+        if self.recursion_limit > EXPANSION_RECURSION_LIMIT {
+            mark::hit!(your_stack_belongs_to_me);
+            return None;
+        }
+
+        let macro_call = InFile::new(self.current_file_id, &macro_call);
+
+        if let Some(call_id) = macro_call.as_call_id(db, self.crate_def_map.krate, |path| {
+            if let Some(local_scope) = local_scope {
+                if let Some(def) = path.as_ident().and_then(|n| local_scope.get_legacy_macro(n)) {
+                    return Some(def);
+                }
+            }
+            self.resolve_path_as_macro(db, &path)
+        }) {
+            let file_id = call_id.as_file();
+            if let Some(node) = db.parse_or_expand(file_id) {
+                if let Some(expr) = T::cast(node) {
+                    log::debug!("macro expansion {:#?}", expr.syntax());
+
+                    let mark = Mark {
+                        file_id: self.current_file_id,
+                        ast_id_map: mem::take(&mut self.ast_id_map),
+                        bomb: DropBomb::new("expansion mark dropped"),
+                    };
+                    self.cfg_expander.hygiene = Hygiene::new(db.upcast(), file_id);
+                    self.current_file_id = file_id;
+                    self.ast_id_map = db.ast_id_map(file_id);
+                    return Some((mark, expr));
+                }
+            }
+        }
+
+        // FIXME: Instead of just dropping the error from expansion
+        // report it
+        None
+    }
+
+    pub(crate) fn exit(&mut self, db: &dyn DefDatabase, mut mark: Mark) {
+        self.cfg_expander.hygiene = Hygiene::new(db.upcast(), mark.file_id);
+        self.current_file_id = mark.file_id;
+        self.ast_id_map = mem::take(&mut mark.ast_id_map);
+        self.recursion_limit -= 1;
+        mark.bomb.defuse();
+    }
+
+    pub(crate) fn to_source<T>(&self, value: T) -> InFile<T> {
+        InFile { file_id: self.current_file_id, value }
+    }
+
+    pub(crate) fn is_cfg_enabled(&self, owner: &dyn ast::AttrsOwner) -> bool {
+        self.cfg_expander.is_cfg_enabled(owner)
+    }
+
+    fn parse_path(&mut self, path: ast::Path) -> Option<Path> {
+        Path::from_src(path, &self.cfg_expander.hygiene)
+    }
+
+    fn resolve_path_as_macro(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<MacroDefId> {
+        self.crate_def_map
+            .resolve_path(db, self.module.local_id, path, BuiltinShadowMode::Other)
+            .0
+            .take_macros()
+    }
+
+    fn ast_id<N: AstNode>(&self, item: &N) -> AstId<N> {
+        let file_local_id = self.ast_id_map.ast_id(item);
+        AstId::new(self.current_file_id, file_local_id)
+    }
+}
+
+pub(crate) struct Mark {
+    file_id: HirFileId,
+    ast_id_map: Arc<AstIdMap>,
+    bomb: DropBomb,
+}
+
+/// The body of an item (function, const etc.).
+#[derive(Debug, Eq, PartialEq)]
+pub struct Body {
+    pub exprs: Arena<Expr>,
+    pub pats: Arena<Pat>,
+    /// The patterns for the function's parameters. While the parameter types are
+    /// part of the function signature, the patterns are not (they don't change
+    /// the external type of the function).
+    ///
+    /// If this `Body` is for the body of a constant, this will just be
+    /// empty.
+    pub params: Vec<PatId>,
+    /// The `ExprId` of the actual body expression.
+    pub body_expr: ExprId,
+    pub item_scope: ItemScope,
+}
+
+pub type ExprPtr = AstPtr<ast::Expr>;
+pub type ExprSource = InFile<ExprPtr>;
+
+pub type PatPtr = Either<AstPtr<ast::Pat>, AstPtr<ast::SelfParam>>;
+pub type PatSource = InFile<PatPtr>;
+
+/// An item body together with the mapping from syntax nodes to HIR expression
+/// IDs. This is needed to go from e.g. a position in a file to the HIR
+/// expression containing it; but for type inference etc., we want to operate on
+/// a structure that is agnostic to the actual positions of expressions in the
+/// file, so that we don't recompute types whenever some whitespace is typed.
+///
+/// One complication here is that, due to macro expansion, a single `Body` might
+/// be spread across several files. So, for each ExprId and PatId, we record
+/// both the HirFileId and the position inside the file. However, we only store
+/// AST -> ExprId mapping for non-macro files, as it is not clear how to handle
+/// this properly for macros.
+#[derive(Default, Debug, Eq, PartialEq)]
+pub struct BodySourceMap {
+    expr_map: FxHashMap<ExprSource, ExprId>,
+    expr_map_back: ArenaMap<ExprId, Result<ExprSource, SyntheticSyntax>>,
+    pat_map: FxHashMap<PatSource, PatId>,
+    pat_map_back: ArenaMap<PatId, Result<PatSource, SyntheticSyntax>>,
+    field_map: FxHashMap<(ExprId, usize), InFile<AstPtr<ast::RecordExprField>>>,
+    expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
+}
+
+#[derive(Default, Debug, Eq, PartialEq, Clone, Copy)]
+pub struct SyntheticSyntax;
+
+impl Body {
+    pub(crate) fn body_with_source_map_query(
+        db: &dyn DefDatabase,
+        def: DefWithBodyId,
+    ) -> (Arc<Body>, Arc<BodySourceMap>) {
+        let _p = profile::span("body_with_source_map_query");
+        let mut params = None;
+
+        let (file_id, module, body) = match def {
+            DefWithBodyId::FunctionId(f) => {
+                let f = f.lookup(db);
+                let src = f.source(db);
+                params = src.value.param_list();
+                (src.file_id, f.module(db), src.value.body().map(ast::Expr::from))
+            }
+            DefWithBodyId::ConstId(c) => {
+                let c = c.lookup(db);
+                let src = c.source(db);
+                (src.file_id, c.module(db), src.value.body())
+            }
+            DefWithBodyId::StaticId(s) => {
+                let s = s.lookup(db);
+                let src = s.source(db);
+                (src.file_id, s.module(db), src.value.body())
+            }
+        };
+        let expander = Expander::new(db, file_id, module);
+        let (body, source_map) = Body::new(db, def, expander, params, body);
+        (Arc::new(body), Arc::new(source_map))
+    }
+
+    pub(crate) fn body_query(db: &dyn DefDatabase, def: DefWithBodyId) -> Arc<Body> {
+        db.body_with_source_map(def).0
+    }
+
+    fn new(
+        db: &dyn DefDatabase,
+        def: DefWithBodyId,
+        expander: Expander,
+        params: Option<ast::ParamList>,
+        body: Option<ast::Expr>,
+    ) -> (Body, BodySourceMap) {
+        lower::lower(db, def, expander, params, body)
+    }
+}
+
+impl Index<ExprId> for Body {
+    type Output = Expr;
+
+    fn index(&self, expr: ExprId) -> &Expr {
+        &self.exprs[expr]
+    }
+}
+
+impl Index<PatId> for Body {
+    type Output = Pat;
+
+    fn index(&self, pat: PatId) -> &Pat {
+        &self.pats[pat]
+    }
+}
+
+impl BodySourceMap {
+    pub fn expr_syntax(&self, expr: ExprId) -> Result<ExprSource, SyntheticSyntax> {
+        self.expr_map_back[expr].clone()
+    }
+
+    pub fn node_expr(&self, node: InFile<&ast::Expr>) -> Option<ExprId> {
+        let src = node.map(|it| AstPtr::new(it));
+        self.expr_map.get(&src).cloned()
+    }
+
+    pub fn node_macro_file(&self, node: InFile<&ast::MacroCall>) -> Option<HirFileId> {
+        let src = node.map(|it| AstPtr::new(it));
+        self.expansions.get(&src).cloned()
+    }
+
+    pub fn pat_syntax(&self, pat: PatId) -> Result<PatSource, SyntheticSyntax> {
+        self.pat_map_back[pat].clone()
+    }
+
+    pub fn node_pat(&self, node: InFile<&ast::Pat>) -> Option<PatId> {
+        let src = node.map(|it| Either::Left(AstPtr::new(it)));
+        self.pat_map.get(&src).cloned()
+    }
+
+    pub fn node_self_param(&self, node: InFile<&ast::SelfParam>) -> Option<PatId> {
+        let src = node.map(|it| Either::Right(AstPtr::new(it)));
+        self.pat_map.get(&src).cloned()
+    }
+
+    pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordExprField>> {
+        self.field_map[&(expr, field)].clone()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use base_db::{fixture::WithFixture, SourceDatabase};
+    use test_utils::mark;
+
+    use crate::ModuleDefId;
+
+    use super::*;
+
+    fn lower(ra_fixture: &str) -> Arc<Body> {
+        let (db, file_id) = crate::test_db::TestDB::with_single_file(ra_fixture);
+
+        let krate = db.crate_graph().iter().next().unwrap();
+        let def_map = db.crate_def_map(krate);
+        let module = def_map.modules_for_file(file_id).next().unwrap();
+        let module = &def_map[module];
+        let fn_def = match module.scope.declarations().next().unwrap() {
+            ModuleDefId::FunctionId(it) => it,
+            _ => panic!(),
+        };
+
+        db.body(fn_def.into())
+    }
+
+    #[test]
+    fn your_stack_belongs_to_me() {
+        mark::check!(your_stack_belongs_to_me);
+        lower(
+            "
+macro_rules! n_nuple {
+    ($e:tt) => ();
+    ($($rest:tt)*) => {{
+        (n_nuple!($($rest)*)None,)
+    }};
+}
+fn main() { n_nuple!(1,2,3); }
+",
+        );
+    }
+}
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
new file mode 100644
index 000000000..a26251cde
--- /dev/null
+++ b/crates/hir_def/src/body/lower.rs
@@ -0,0 +1,931 @@
+//! Transforms `ast::Expr` into an equivalent `hir_def::expr::Expr`
+//! representation.
+
+use std::{any::type_name, sync::Arc};
+
+use arena::Arena;
+use either::Either;
+use hir_expand::{
+    hygiene::Hygiene,
+    name::{name, AsName, Name},
+    HirFileId, MacroDefId, MacroDefKind,
+};
+use rustc_hash::FxHashMap;
+use syntax::{
+    ast::{
+        self, ArgListOwner, ArrayExprKind, AstChildren, LiteralKind, LoopBodyOwner, NameOwner,
+        SlicePatComponents,
+    },
+    AstNode, AstPtr,
+};
+use test_utils::mark;
+
+use crate::{
+    adt::StructKind,
+    body::{Body, BodySourceMap, Expander, PatPtr, SyntheticSyntax},
+    builtin_type::{BuiltinFloat, BuiltinInt},
+    db::DefDatabase,
+    expr::{
+        dummy_expr_id, ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal,
+        LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
+    },
+    item_scope::BuiltinShadowMode,
+    item_tree::{ItemTree, ItemTreeId, ItemTreeNode},
+    path::{GenericArgs, Path},
+    type_ref::{Mutability, Rawness, TypeRef},
+    AdtId, ConstLoc, ContainerId, DefWithBodyId, EnumLoc, FunctionLoc, Intern, ModuleDefId,
+    StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
+};
+
+use super::{ExprSource, PatSource};
+
+pub(crate) struct LowerCtx {
+    hygiene: Hygiene,
+}
+
+impl LowerCtx {
+    pub fn new(db: &dyn DefDatabase, file_id: HirFileId) -> Self {
+        LowerCtx { hygiene: Hygiene::new(db.upcast(), file_id) }
+    }
+    pub fn with_hygiene(hygiene: &Hygiene) -> Self {
+        LowerCtx { hygiene: hygiene.clone() }
+    }
+
+    pub fn lower_path(&self, ast: ast::Path) -> Option<Path> {
+        Path::from_src(ast, &self.hygiene)
+    }
+}
+
+pub(super) fn lower(
+    db: &dyn DefDatabase,
+    def: DefWithBodyId,
+    expander: Expander,
+    params: Option<ast::ParamList>,
+    body: Option<ast::Expr>,
+) -> (Body, BodySourceMap) {
+    let item_tree = db.item_tree(expander.current_file_id);
+    ExprCollector {
+        db,
+        def,
+        source_map: BodySourceMap::default(),
+        body: Body {
+            exprs: Arena::default(),
+            pats: Arena::default(),
+            params: Vec::new(),
+            body_expr: dummy_expr_id(),
+            item_scope: Default::default(),
+        },
+        item_trees: {
+            let mut map = FxHashMap::default();
+            map.insert(expander.current_file_id, item_tree);
+            map
+        },
+        expander,
+    }
+    .collect(params, body)
+}
+
+struct ExprCollector<'a> {
+    db: &'a dyn DefDatabase,
+    def: DefWithBodyId,
+    expander: Expander,
+    body: Body,
+    source_map: BodySourceMap,
+
+    item_trees: FxHashMap<HirFileId, Arc<ItemTree>>,
+}
+
+impl ExprCollector<'_> {
+    fn collect(
+        mut self,
+        param_list: Option<ast::ParamList>,
+        body: Option<ast::Expr>,
+    ) -> (Body, BodySourceMap) {
+        if let Some(param_list) = param_list {
+            if let Some(self_param) = param_list.self_param() {
+                let ptr = AstPtr::new(&self_param);
+                let param_pat = self.alloc_pat(
+                    Pat::Bind {
+                        name: name![self],
+                        mode: BindingAnnotation::Unannotated,
+                        subpat: None,
+                    },
+                    Either::Right(ptr),
+                );
+                self.body.params.push(param_pat);
+            }
+
+            for param in param_list.params() {
+                let pat = match param.pat() {
+                    None => continue,
+                    Some(pat) => pat,
+                };
+                let param_pat = self.collect_pat(pat);
+                self.body.params.push(param_pat);
+            }
+        };
+
+        self.body.body_expr = self.collect_expr_opt(body);
+        (self.body, self.source_map)
+    }
+
+    fn ctx(&self) -> LowerCtx {
+        LowerCtx::new(self.db, self.expander.current_file_id)
+    }
+
+    fn alloc_expr(&mut self, expr: Expr, ptr: AstPtr<ast::Expr>) -> ExprId {
+        let src = self.expander.to_source(ptr);
+        let id = self.make_expr(expr, Ok(src.clone()));
+        self.source_map.expr_map.insert(src, id);
+        id
+    }
+    // desugared exprs don't have ptr, that's wrong and should be fixed
+    // somehow.
+    fn alloc_expr_desugared(&mut self, expr: Expr) -> ExprId {
+        self.make_expr(expr, Err(SyntheticSyntax))
+    }
+    fn empty_block(&mut self) -> ExprId {
+        self.alloc_expr_desugared(Expr::Block { statements: Vec::new(), tail: None, label: None })
+    }
+    fn missing_expr(&mut self) -> ExprId {
+        self.alloc_expr_desugared(Expr::Missing)
+    }
+    fn make_expr(&mut self, expr: Expr, src: Result<ExprSource, SyntheticSyntax>) -> ExprId {
+        let id = self.body.exprs.alloc(expr);
+        self.source_map.expr_map_back.insert(id, src);
+        id
+    }
+
+    fn alloc_pat(&mut self, pat: Pat, ptr: PatPtr) -> PatId {
+        let src = self.expander.to_source(ptr);
+        let id = self.make_pat(pat, Ok(src.clone()));
+        self.source_map.pat_map.insert(src, id);
+        id
+    }
+    fn missing_pat(&mut self) -> PatId {
+        self.make_pat(Pat::Missing, Err(SyntheticSyntax))
+    }
+    fn make_pat(&mut self, pat: Pat, src: Result<PatSource, SyntheticSyntax>) -> PatId {
+        let id = self.body.pats.alloc(pat);
+        self.source_map.pat_map_back.insert(id, src);
+        id
+    }
+
+    fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
+        let syntax_ptr = AstPtr::new(&expr);
+        if !self.expander.is_cfg_enabled(&expr) {
+            return self.missing_expr();
+        }
+
+        match expr {
+            ast::Expr::IfExpr(e) => {
+                let then_branch = self.collect_block_opt(e.then_branch());
+
+                let else_branch = e.else_branch().map(|b| match b {
+                    ast::ElseBranch::Block(it) => self.collect_block(it),
+                    ast::ElseBranch::IfExpr(elif) => {
+                        let expr: ast::Expr = ast::Expr::cast(elif.syntax().clone()).unwrap();
+                        self.collect_expr(expr)
+                    }
+                });
+
+                let condition = match e.condition() {
+                    None => self.missing_expr(),
+                    Some(condition) => match condition.pat() {
+                        None => self.collect_expr_opt(condition.expr()),
+                        // if let -- desugar to match
+                        Some(pat) => {
+                            let pat = self.collect_pat(pat);
+                            let match_expr = self.collect_expr_opt(condition.expr());
+                            let placeholder_pat = self.missing_pat();
+                            let arms = vec![
+                                MatchArm { pat, expr: then_branch, guard: None },
+                                MatchArm {
+                                    pat: placeholder_pat,
+                                    expr: else_branch.unwrap_or_else(|| self.empty_block()),
+                                    guard: None,
+                                },
+                            ];
+                            return self
+                                .alloc_expr(Expr::Match { expr: match_expr, arms }, syntax_ptr);
+                        }
+                    },
+                };
+
+                self.alloc_expr(Expr::If { condition, then_branch, else_branch }, syntax_ptr)
+            }
+            ast::Expr::EffectExpr(e) => match e.effect() {
+                ast::Effect::Try(_) => {
+                    let body = self.collect_block_opt(e.block_expr());
+                    self.alloc_expr(Expr::TryBlock { body }, syntax_ptr)
+                }
+                ast::Effect::Unsafe(_) => {
+                    let body = self.collect_block_opt(e.block_expr());
+                    self.alloc_expr(Expr::Unsafe { body }, syntax_ptr)
+                }
+                // FIXME: we need to record these effects somewhere...
+                ast::Effect::Label(label) => match e.block_expr() {
+                    Some(block) => {
+                        let res = self.collect_block(block);
+                        match &mut self.body.exprs[res] {
+                            Expr::Block { label: block_label, .. } => {
+                                *block_label =
+                                    label.lifetime_token().map(|t| Name::new_lifetime(&t))
+                            }
+                            _ => unreachable!(),
+                        }
+                        res
+                    }
+                    None => self.missing_expr(),
+                },
+                // FIXME: we need to record these effects somewhere...
+                ast::Effect::Async(_) => self.collect_block_opt(e.block_expr()),
+            },
+            ast::Expr::BlockExpr(e) => self.collect_block(e),
+            ast::Expr::LoopExpr(e) => {
+                let body = self.collect_block_opt(e.loop_body());
+                self.alloc_expr(
+                    Expr::Loop {
+                        body,
+                        label: e
+                            .label()
+                            .and_then(|l| l.lifetime_token())
+                            .map(|l| Name::new_lifetime(&l)),
+                    },
+                    syntax_ptr,
+                )
+            }
+            ast::Expr::WhileExpr(e) => {
+                let body = self.collect_block_opt(e.loop_body());
+
+                let condition = match e.condition() {
+                    None => self.missing_expr(),
+                    Some(condition) => match condition.pat() {
+                        None => self.collect_expr_opt(condition.expr()),
+                        // if let -- desugar to match
+                        Some(pat) => {
+                            mark::hit!(infer_resolve_while_let);
+                            let pat = self.collect_pat(pat);
+                            let match_expr = self.collect_expr_opt(condition.expr());
+                            let placeholder_pat = self.missing_pat();
+                            let break_ =
+                                self.alloc_expr_desugared(Expr::Break { expr: None, label: None });
+                            let arms = vec![
+                                MatchArm { pat, expr: body, guard: None },
+                                MatchArm { pat: placeholder_pat, expr: break_, guard: None },
+                            ];
+                            let match_expr =
+                                self.alloc_expr_desugared(Expr::Match { expr: match_expr, arms });
+                            return self.alloc_expr(
+                                Expr::Loop {
+                                    body: match_expr,
+                                    label: e
+                                        .label()
+                                        .and_then(|l| l.lifetime_token())
+                                        .map(|l| Name::new_lifetime(&l)),
+                                },
+                                syntax_ptr,
+                            );
+                        }
+                    },
+                };
+
+                self.alloc_expr(
+                    Expr::While {
+                        condition,
+                        body,
+                        label: e
+                            .label()
+                            .and_then(|l| l.lifetime_token())
+                            .map(|l| Name::new_lifetime(&l)),
+                    },
+                    syntax_ptr,
+                )
+            }
+            ast::Expr::ForExpr(e) => {
+                let iterable = self.collect_expr_opt(e.iterable());
+                let pat = self.collect_pat_opt(e.pat());
+                let body = self.collect_block_opt(e.loop_body());
+                self.alloc_expr(
+                    Expr::For {
+                        iterable,
+                        pat,
+                        body,
+                        label: e
+                            .label()
+                            .and_then(|l| l.lifetime_token())
+                            .map(|l| Name::new_lifetime(&l)),
+                    },
+                    syntax_ptr,
+                )
+            }
+            ast::Expr::CallExpr(e) => {
+                let callee = self.collect_expr_opt(e.expr());
+                let args = if let Some(arg_list) = e.arg_list() {
+                    arg_list.args().map(|e| self.collect_expr(e)).collect()
+                } else {
+                    Vec::new()
+                };
+                self.alloc_expr(Expr::Call { callee, args }, syntax_ptr)
+            }
+            ast::Expr::MethodCallExpr(e) => {
+                let receiver = self.collect_expr_opt(e.expr());
+                let args = if let Some(arg_list) = e.arg_list() {
+                    arg_list.args().map(|e| self.collect_expr(e)).collect()
+                } else {
+                    Vec::new()
+                };
+                let method_name = e.name_ref().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
+                let generic_args =
+                    e.generic_arg_list().and_then(|it| GenericArgs::from_ast(&self.ctx(), it));
+                self.alloc_expr(
+                    Expr::MethodCall { receiver, method_name, args, generic_args },
+                    syntax_ptr,
+                )
+            }
+            ast::Expr::MatchExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                let arms = if let Some(match_arm_list) = e.match_arm_list() {
+                    match_arm_list
+                        .arms()
+                        .map(|arm| MatchArm {
+                            pat: self.collect_pat_opt(arm.pat()),
+                            expr: self.collect_expr_opt(arm.expr()),
+                            guard: arm
+                                .guard()
+                                .and_then(|guard| guard.expr())
+                                .map(|e| self.collect_expr(e)),
+                        })
+                        .collect()
+                } else {
+                    Vec::new()
+                };
+                self.alloc_expr(Expr::Match { expr, arms }, syntax_ptr)
+            }
+            ast::Expr::PathExpr(e) => {
+                let path = e
+                    .path()
+                    .and_then(|path| self.expander.parse_path(path))
+                    .map(Expr::Path)
+                    .unwrap_or(Expr::Missing);
+                self.alloc_expr(path, syntax_ptr)
+            }
+            ast::Expr::ContinueExpr(e) => self.alloc_expr(
+                Expr::Continue { label: e.lifetime_token().map(|l| Name::new_lifetime(&l)) },
+                syntax_ptr,
+            ),
+            ast::Expr::BreakExpr(e) => {
+                let expr = e.expr().map(|e| self.collect_expr(e));
+                self.alloc_expr(
+                    Expr::Break { expr, label: e.lifetime_token().map(|l| Name::new_lifetime(&l)) },
+                    syntax_ptr,
+                )
+            }
+            ast::Expr::ParenExpr(e) => {
+                let inner = self.collect_expr_opt(e.expr());
+                // make the paren expr point to the inner expression as well
+                let src = self.expander.to_source(syntax_ptr);
+                self.source_map.expr_map.insert(src, inner);
+                inner
+            }
+            ast::Expr::ReturnExpr(e) => {
+                let expr = e.expr().map(|e| self.collect_expr(e));
+                self.alloc_expr(Expr::Return { expr }, syntax_ptr)
+            }
+            ast::Expr::RecordExpr(e) => {
+                let path = e.path().and_then(|path| self.expander.parse_path(path));
+                let mut field_ptrs = Vec::new();
+                let record_lit = if let Some(nfl) = e.record_expr_field_list() {
+                    let fields = nfl
+                        .fields()
+                        .inspect(|field| field_ptrs.push(AstPtr::new(field)))
+                        .filter_map(|field| {
+                            if !self.expander.is_cfg_enabled(&field) {
+                                return None;
+                            }
+                            let name = field.field_name()?.as_name();
+
+                            Some(RecordLitField {
+                                name,
+                                expr: match field.expr() {
+                                    Some(e) => self.collect_expr(e),
+                                    None => self.missing_expr(),
+                                },
+                            })
+                        })
+                        .collect();
+                    let spread = nfl.spread().map(|s| self.collect_expr(s));
+                    Expr::RecordLit { path, fields, spread }
+                } else {
+                    Expr::RecordLit { path, fields: Vec::new(), spread: None }
+                };
+
+                let res = self.alloc_expr(record_lit, syntax_ptr);
+                for (i, ptr) in field_ptrs.into_iter().enumerate() {
+                    let src = self.expander.to_source(ptr);
+                    self.source_map.field_map.insert((res, i), src);
+                }
+                res
+            }
+            ast::Expr::FieldExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                let name = match e.field_access() {
+                    Some(kind) => kind.as_name(),
+                    _ => Name::missing(),
+                };
+                self.alloc_expr(Expr::Field { expr, name }, syntax_ptr)
+            }
+            ast::Expr::AwaitExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                self.alloc_expr(Expr::Await { expr }, syntax_ptr)
+            }
+            ast::Expr::TryExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                self.alloc_expr(Expr::Try { expr }, syntax_ptr)
+            }
+            ast::Expr::CastExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                let type_ref = TypeRef::from_ast_opt(&self.ctx(), e.ty());
+                self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
+            }
+            ast::Expr::RefExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                let raw_tok = e.raw_token().is_some();
+                let mutability = if raw_tok {
+                    if e.mut_token().is_some() {
+                        Mutability::Mut
+                    } else if e.const_token().is_some() {
+                        Mutability::Shared
+                    } else {
+                        unreachable!("parser only remaps to raw_token() if matching mutability token follows")
+                    }
+                } else {
+                    Mutability::from_mutable(e.mut_token().is_some())
+                };
+                let rawness = Rawness::from_raw(raw_tok);
+                self.alloc_expr(Expr::Ref { expr, rawness, mutability }, syntax_ptr)
+            }
+            ast::Expr::PrefixExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                if let Some(op) = e.op_kind() {
+                    self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
+                } else {
+                    self.alloc_expr(Expr::Missing, syntax_ptr)
+                }
+            }
+            ast::Expr::ClosureExpr(e) => {
+                let mut args = Vec::new();
+                let mut arg_types = Vec::new();
+                if let Some(pl) = e.param_list() {
+                    for param in pl.params() {
+                        let pat = self.collect_pat_opt(param.pat());
+                        let type_ref = param.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
+                        args.push(pat);
+                        arg_types.push(type_ref);
+                    }
+                }
+                let ret_type =
+                    e.ret_type().and_then(|r| r.ty()).map(|it| TypeRef::from_ast(&self.ctx(), it));
+                let body = self.collect_expr_opt(e.body());
+                self.alloc_expr(Expr::Lambda { args, arg_types, ret_type, body }, syntax_ptr)
+            }
+            ast::Expr::BinExpr(e) => {
+                let lhs = self.collect_expr_opt(e.lhs());
+                let rhs = self.collect_expr_opt(e.rhs());
+                let op = e.op_kind().map(BinaryOp::from);
+                self.alloc_expr(Expr::BinaryOp { lhs, rhs, op }, syntax_ptr)
+            }
+            ast::Expr::TupleExpr(e) => {
+                let exprs = e.fields().map(|expr| self.collect_expr(expr)).collect();
+                self.alloc_expr(Expr::Tuple { exprs }, syntax_ptr)
+            }
+            ast::Expr::BoxExpr(e) => {
+                let expr = self.collect_expr_opt(e.expr());
+                self.alloc_expr(Expr::Box { expr }, syntax_ptr)
+            }
+
+            ast::Expr::ArrayExpr(e) => {
+                let kind = e.kind();
+
+                match kind {
+                    ArrayExprKind::ElementList(e) => {
+                        let exprs = e.map(|expr| self.collect_expr(expr)).collect();
+                        self.alloc_expr(Expr::Array(Array::ElementList(exprs)), syntax_ptr)
+                    }
+                    ArrayExprKind::Repeat { initializer, repeat } => {
+                        let initializer = self.collect_expr_opt(initializer);
+                        let repeat = self.collect_expr_opt(repeat);
+                        self.alloc_expr(
+                            Expr::Array(Array::Repeat { initializer, repeat }),
+                            syntax_ptr,
+                        )
+                    }
+                }
+            }
+
+            ast::Expr::Literal(e) => self.alloc_expr(Expr::Literal(e.kind().into()), syntax_ptr),
+            ast::Expr::IndexExpr(e) => {
+                let base = self.collect_expr_opt(e.base());
+                let index = self.collect_expr_opt(e.index());
+                self.alloc_expr(Expr::Index { base, index }, syntax_ptr)
+            }
+            ast::Expr::RangeExpr(e) => {
+                let lhs = e.start().map(|lhs| self.collect_expr(lhs));
+                let rhs = e.end().map(|rhs| self.collect_expr(rhs));
+                match e.op_kind() {
+                    Some(range_type) => {
+                        self.alloc_expr(Expr::Range { lhs, rhs, range_type }, syntax_ptr)
+                    }
+                    None => self.alloc_expr(Expr::Missing, syntax_ptr),
+                }
+            }
+            ast::Expr::MacroCall(e) => {
+                if let Some(name) = e.is_macro_rules().map(|it| it.as_name()) {
+                    let mac = MacroDefId {
+                        krate: Some(self.expander.module.krate),
+                        ast_id: Some(self.expander.ast_id(&e)),
+                        kind: MacroDefKind::Declarative,
+                        local_inner: false,
+                    };
+                    self.body.item_scope.define_legacy_macro(name, mac);
+
+                    // FIXME: do we still need to allocate this as missing ?
+                    self.alloc_expr(Expr::Missing, syntax_ptr)
+                } else {
+                    let macro_call = self.expander.to_source(AstPtr::new(&e));
+                    match self.expander.enter_expand(self.db, Some(&self.body.item_scope), e) {
+                        Some((mark, expansion)) => {
+                            self.source_map
+                                .expansions
+                                .insert(macro_call, self.expander.current_file_id);
+
+                            let item_tree = self.db.item_tree(self.expander.current_file_id);
+                            self.item_trees.insert(self.expander.current_file_id, item_tree);
+                            let id = self.collect_expr(expansion);
+                            self.expander.exit(self.db, mark);
+                            id
+                        }
+                        None => self.alloc_expr(Expr::Missing, syntax_ptr),
+                    }
+                }
+            }
+        }
+    }
+
+    fn find_inner_item<N: ItemTreeNode>(&self, ast: &N::Source) -> Option<ItemTreeId<N>> {
+        let id = self.expander.ast_id(ast);
+        let tree = &self.item_trees[&id.file_id];
+
+        // FIXME: This probably breaks with `use` items, since they produce multiple item tree nodes
+
+        // Root file (non-macro).
+        let item_tree_id = tree
+            .all_inner_items()
+            .chain(tree.top_level_items().iter().copied())
+            .filter_map(|mod_item| mod_item.downcast::<N>())
+            .find(|tree_id| tree[*tree_id].ast_id().upcast() == id.value.upcast())
+            .or_else(|| {
+                log::debug!(
+                    "couldn't find inner {} item for {:?} (AST: `{}` - {:?})",
+                    type_name::<N>(),
+                    id,
+                    ast.syntax(),
+                    ast.syntax(),
+                );
+                None
+            })?;
+
+        Some(ItemTreeId::new(id.file_id, item_tree_id))
+    }
+
+    fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
+        if let Some(expr) = expr {
+            self.collect_expr(expr)
+        } else {
+            self.missing_expr()
+        }
+    }
+
+    fn collect_block(&mut self, block: ast::BlockExpr) -> ExprId {
+        let syntax_node_ptr = AstPtr::new(&block.clone().into());
+        self.collect_block_items(&block);
+        let statements = block
+            .statements()
+            .filter_map(|s| {
+                let stmt = match s {
+                    ast::Stmt::LetStmt(stmt) => {
+                        let pat = self.collect_pat_opt(stmt.pat());
+                        let type_ref = stmt.ty().map(|it| TypeRef::from_ast(&self.ctx(), it));
+                        let initializer = stmt.initializer().map(|e| self.collect_expr(e));
+                        Statement::Let { pat, type_ref, initializer }
+                    }
+                    ast::Stmt::ExprStmt(stmt) => {
+                        Statement::Expr(self.collect_expr_opt(stmt.expr()))
+                    }
+                    ast::Stmt::Item(_) => return None,
+                };
+                Some(stmt)
+            })
+            .collect();
+        let tail = block.expr().map(|e| self.collect_expr(e));
+        self.alloc_expr(Expr::Block { statements, tail, label: None }, syntax_node_ptr)
+    }
+
+    fn collect_block_items(&mut self, block: &ast::BlockExpr) {
+        let container = ContainerId::DefWithBodyId(self.def);
+
+        let items = block
+            .statements()
+            .filter_map(|stmt| match stmt {
+                ast::Stmt::Item(it) => Some(it),
+                ast::Stmt::LetStmt(_) | ast::Stmt::ExprStmt(_) => None,
+            })
+            .filter_map(|item| {
+                let (def, name): (ModuleDefId, Option<ast::Name>) = match item {
+                    ast::Item::Fn(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (
+                            FunctionLoc { container: container.into(), id }.intern(self.db).into(),
+                            def.name(),
+                        )
+                    }
+                    ast::Item::TypeAlias(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (
+                            TypeAliasLoc { container: container.into(), id }.intern(self.db).into(),
+                            def.name(),
+                        )
+                    }
+                    ast::Item::Const(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (
+                            ConstLoc { container: container.into(), id }.intern(self.db).into(),
+                            def.name(),
+                        )
+                    }
+                    ast::Item::Static(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (StaticLoc { container, id }.intern(self.db).into(), def.name())
+                    }
+                    ast::Item::Struct(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (StructLoc { container, id }.intern(self.db).into(), def.name())
+                    }
+                    ast::Item::Enum(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (EnumLoc { container, id }.intern(self.db).into(), def.name())
+                    }
+                    ast::Item::Union(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (UnionLoc { container, id }.intern(self.db).into(), def.name())
+                    }
+                    ast::Item::Trait(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (TraitLoc { container, id }.intern(self.db).into(), def.name())
+                    }
+                    ast::Item::ExternBlock(_) => return None, // FIXME: collect from extern blocks
+                    ast::Item::Impl(_)
+                    | ast::Item::Use(_)
+                    | ast::Item::ExternCrate(_)
+                    | ast::Item::Module(_)
+                    | ast::Item::MacroCall(_) => return None,
+                };
+
+                Some((def, name))
+            })
+            .collect::<Vec<_>>();
+
+        for (def, name) in items {
+            self.body.item_scope.define_def(def);
+            if let Some(name) = name {
+                let vis = crate::visibility::Visibility::Public; // FIXME determine correctly
+                let has_constructor = match def {
+                    ModuleDefId::AdtId(AdtId::StructId(s)) => {
+                        self.db.struct_data(s).variant_data.kind() != StructKind::Record
+                    }
+                    _ => true,
+                };
+                self.body.item_scope.push_res(
+                    name.as_name(),
+                    crate::per_ns::PerNs::from_def(def, vis, has_constructor),
+                );
+            }
+        }
+    }
+
+    fn collect_block_opt(&mut self, expr: Option<ast::BlockExpr>) -> ExprId {
+        if let Some(block) = expr {
+            self.collect_block(block)
+        } else {
+            self.missing_expr()
+        }
+    }
+
+    fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
+        let pattern = match &pat {
+            ast::Pat::IdentPat(bp) => {
+                let name = bp.name().map(|nr| nr.as_name()).unwrap_or_else(Name::missing);
+                let annotation =
+                    BindingAnnotation::new(bp.mut_token().is_some(), bp.ref_token().is_some());
+                let subpat = bp.pat().map(|subpat| self.collect_pat(subpat));
+                if annotation == BindingAnnotation::Unannotated && subpat.is_none() {
+                    // This could also be a single-segment path pattern. To
+                    // decide that, we need to try resolving the name.
+                    let (resolved, _) = self.expander.crate_def_map.resolve_path(
+                        self.db,
+                        self.expander.module.local_id,
+                        &name.clone().into(),
+                        BuiltinShadowMode::Other,
+                    );
+                    match resolved.take_values() {
+                        Some(ModuleDefId::ConstId(_)) => Pat::Path(name.into()),
+                        Some(ModuleDefId::EnumVariantId(_)) => {
+                            // this is only really valid for unit variants, but
+                            // shadowing other enum variants with a pattern is
+                            // an error anyway
+                            Pat::Path(name.into())
+                        }
+                        Some(ModuleDefId::AdtId(AdtId::StructId(s)))
+                            if self.db.struct_data(s).variant_data.kind() != StructKind::Record =>
+                        {
+                            // Funnily enough, record structs *can* be shadowed
+                            // by pattern bindings (but unit or tuple structs
+                            // can't).
+                            Pat::Path(name.into())
+                        }
+                        // shadowing statics is an error as well, so we just ignore that case here
+                        _ => Pat::Bind { name, mode: annotation, subpat },
+                    }
+                } else {
+                    Pat::Bind { name, mode: annotation, subpat }
+                }
+            }
+            ast::Pat::TupleStructPat(p) => {
+                let path = p.path().and_then(|path| self.expander.parse_path(path));
+                let (args, ellipsis) = self.collect_tuple_pat(p.fields());
+                Pat::TupleStruct { path, args, ellipsis }
+            }
+            ast::Pat::RefPat(p) => {
+                let pat = self.collect_pat_opt(p.pat());
+                let mutability = Mutability::from_mutable(p.mut_token().is_some());
+                Pat::Ref { pat, mutability }
+            }
+            ast::Pat::PathPat(p) => {
+                let path = p.path().and_then(|path| self.expander.parse_path(path));
+                path.map(Pat::Path).unwrap_or(Pat::Missing)
+            }
+            ast::Pat::OrPat(p) => {
+                let pats = p.pats().map(|p| self.collect_pat(p)).collect();
+                Pat::Or(pats)
+            }
+            ast::Pat::ParenPat(p) => return self.collect_pat_opt(p.pat()),
+            ast::Pat::TuplePat(p) => {
+                let (args, ellipsis) = self.collect_tuple_pat(p.fields());
+                Pat::Tuple { args, ellipsis }
+            }
+            ast::Pat::WildcardPat(_) => Pat::Wild,
+            ast::Pat::RecordPat(p) => {
+                let path = p.path().and_then(|path| self.expander.parse_path(path));
+                let args: Vec<_> = p
+                    .record_pat_field_list()
+                    .expect("every struct should have a field list")
+                    .fields()
+                    .filter_map(|f| {
+                        let ast_pat = f.pat()?;
+                        let pat = self.collect_pat(ast_pat);
+                        let name = f.field_name()?.as_name();
+                        Some(RecordFieldPat { name, pat })
+                    })
+                    .collect();
+
+                let ellipsis = p
+                    .record_pat_field_list()
+                    .expect("every struct should have a field list")
+                    .dotdot_token()
+                    .is_some();
+
+                Pat::Record { path, args, ellipsis }
+            }
+            ast::Pat::SlicePat(p) => {
+                let SlicePatComponents { prefix, slice, suffix } = p.components();
+
+                // FIXME properly handle `RestPat`
+                Pat::Slice {
+                    prefix: prefix.into_iter().map(|p| self.collect_pat(p)).collect(),
+                    slice: slice.map(|p| self.collect_pat(p)),
+                    suffix: suffix.into_iter().map(|p| self.collect_pat(p)).collect(),
+                }
+            }
+            ast::Pat::LiteralPat(lit) => {
+                if let Some(ast_lit) = lit.literal() {
+                    let expr = Expr::Literal(ast_lit.kind().into());
+                    let expr_ptr = AstPtr::new(&ast::Expr::Literal(ast_lit));
+                    let expr_id = self.alloc_expr(expr, expr_ptr);
+                    Pat::Lit(expr_id)
+                } else {
+                    Pat::Missing
+                }
+            }
+            ast::Pat::RestPat(_) => {
+                // `RestPat` requires special handling and should not be mapped
+                // to a Pat. Here we are using `Pat::Missing` as a fallback for
+                // when `RestPat` is mapped to `Pat`, which can easily happen
+                // when the source code being analyzed has a malformed pattern
+                // which includes `..` in a place where it isn't valid.
+
+                Pat::Missing
+            }
+            // FIXME: implement
+            ast::Pat::BoxPat(_) | ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
+        };
+        let ptr = AstPtr::new(&pat);
+        self.alloc_pat(pattern, Either::Left(ptr))
+    }
+
+    fn collect_pat_opt(&mut self, pat: Option<ast::Pat>) -> PatId {
+        if let Some(pat) = pat {
+            self.collect_pat(pat)
+        } else {
+            self.missing_pat()
+        }
+    }
+
+    fn collect_tuple_pat(&mut self, args: AstChildren<ast::Pat>) -> (Vec<PatId>, Option<usize>) {
+        // Find the location of the `..`, if there is one. Note that we do not
+        // consider the possiblity of there being multiple `..` here.
+        let ellipsis = args.clone().position(|p| matches!(p, ast::Pat::RestPat(_)));
+        // We want to skip the `..` pattern here, since we account for it above.
+        let args = args
+            .filter(|p| !matches!(p, ast::Pat::RestPat(_)))
+            .map(|p| self.collect_pat(p))
+            .collect();
+
+        (args, ellipsis)
+    }
+}
+
+impl From<ast::BinOp> for BinaryOp {
+    fn from(ast_op: ast::BinOp) -> Self {
+        match ast_op {
+            ast::BinOp::BooleanOr => BinaryOp::LogicOp(LogicOp::Or),
+            ast::BinOp::BooleanAnd => BinaryOp::LogicOp(LogicOp::And),
+            ast::BinOp::EqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: false }),
+            ast::BinOp::NegatedEqualityTest => BinaryOp::CmpOp(CmpOp::Eq { negated: true }),
+            ast::BinOp::LesserEqualTest => {
+                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: false })
+            }
+            ast::BinOp::GreaterEqualTest => {
+                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: false })
+            }
+            ast::BinOp::LesserTest => {
+                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Less, strict: true })
+            }
+            ast::BinOp::GreaterTest => {
+                BinaryOp::CmpOp(CmpOp::Ord { ordering: Ordering::Greater, strict: true })
+            }
+            ast::BinOp::Addition => BinaryOp::ArithOp(ArithOp::Add),
+            ast::BinOp::Multiplication => BinaryOp::ArithOp(ArithOp::Mul),
+            ast::BinOp::Subtraction => BinaryOp::ArithOp(ArithOp::Sub),
+            ast::BinOp::Division => BinaryOp::ArithOp(ArithOp::Div),
+            ast::BinOp::Remainder => BinaryOp::ArithOp(ArithOp::Rem),
+            ast::BinOp::LeftShift => BinaryOp::ArithOp(ArithOp::Shl),
+            ast::BinOp::RightShift => BinaryOp::ArithOp(ArithOp::Shr),
+            ast::BinOp::BitwiseXor => BinaryOp::ArithOp(ArithOp::BitXor),
+            ast::BinOp::BitwiseOr => BinaryOp::ArithOp(ArithOp::BitOr),
+            ast::BinOp::BitwiseAnd => BinaryOp::ArithOp(ArithOp::BitAnd),
+            ast::BinOp::Assignment => BinaryOp::Assignment { op: None },
+            ast::BinOp::AddAssign => BinaryOp::Assignment { op: Some(ArithOp::Add) },
+            ast::BinOp::DivAssign => BinaryOp::Assignment { op: Some(ArithOp::Div) },
+            ast::BinOp::MulAssign => BinaryOp::Assignment { op: Some(ArithOp::Mul) },
+            ast::BinOp::RemAssign => BinaryOp::Assignment { op: Some(ArithOp::Rem) },
+            ast::BinOp::ShlAssign => BinaryOp::Assignment { op: Some(ArithOp::Shl) },
+            ast::BinOp::ShrAssign => BinaryOp::Assignment { op: Some(ArithOp::Shr) },
+            ast::BinOp::SubAssign => BinaryOp::Assignment { op: Some(ArithOp::Sub) },
+            ast::BinOp::BitOrAssign => BinaryOp::Assignment { op: Some(ArithOp::BitOr) },
+            ast::BinOp::BitAndAssign => BinaryOp::Assignment { op: Some(ArithOp::BitAnd) },
+            ast::BinOp::BitXorAssign => BinaryOp::Assignment { op: Some(ArithOp::BitXor) },
+        }
+    }
+}
+
+impl From<ast::LiteralKind> for Literal {
+    fn from(ast_lit_kind: ast::LiteralKind) -> Self {
+        match ast_lit_kind {
+            LiteralKind::IntNumber { suffix } => {
+                let known_name = suffix.and_then(|it| BuiltinInt::from_suffix(&it));
+
+                Literal::Int(Default::default(), known_name)
+            }
+            LiteralKind::FloatNumber { suffix } => {
+                let known_name = suffix.and_then(|it| BuiltinFloat::from_suffix(&it));
+
+                Literal::Float(Default::default(), known_name)
+            }
+            LiteralKind::ByteString => Literal::ByteString(Default::default()),
+            LiteralKind::String => Literal::String(Default::default()),
+            LiteralKind::Byte => Literal::Int(Default::default(), Some(BuiltinInt::U8)),
+            LiteralKind::Bool(val) => Literal::Bool(val),
+            LiteralKind::Char => Literal::Char(Default::default()),
+        }
+    }
+}
diff --git a/crates/hir_def/src/body/scope.rs b/crates/hir_def/src/body/scope.rs
new file mode 100644
index 000000000..9142bc05b
--- /dev/null
+++ b/crates/hir_def/src/body/scope.rs
@@ -0,0 +1,456 @@
+//! Name resolution for expressions.
+use std::sync::Arc;
+
+use arena::{Arena, Idx};
+use hir_expand::name::Name;
+use rustc_hash::FxHashMap;
+
+use crate::{
+    body::Body,
+    db::DefDatabase,
+    expr::{Expr, ExprId, Pat, PatId, Statement},
+    DefWithBodyId,
+};
+
+pub type ScopeId = Idx<ScopeData>;
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct ExprScopes {
+    scopes: Arena<ScopeData>,
+    scope_by_expr: FxHashMap<ExprId, ScopeId>,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct ScopeEntry {
+    name: Name,
+    pat: PatId,
+}
+
+impl ScopeEntry {
+    pub fn name(&self) -> &Name {
+        &self.name
+    }
+
+    pub fn pat(&self) -> PatId {
+        self.pat
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct ScopeData {
+    parent: Option<ScopeId>,
+    entries: Vec<ScopeEntry>,
+}
+
+impl ExprScopes {
+    pub(crate) fn expr_scopes_query(db: &dyn DefDatabase, def: DefWithBodyId) -> Arc<ExprScopes> {
+        let body = db.body(def);
+        Arc::new(ExprScopes::new(&*body))
+    }
+
+    fn new(body: &Body) -> ExprScopes {
+        let mut scopes =
+            ExprScopes { scopes: Arena::default(), scope_by_expr: FxHashMap::default() };
+        let root = scopes.root_scope();
+        scopes.add_params_bindings(body, root, &body.params);
+        compute_expr_scopes(body.body_expr, body, &mut scopes, root);
+        scopes
+    }
+
+    pub fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
+        &self.scopes[scope].entries
+    }
+
+    pub fn scope_chain(&self, scope: Option<ScopeId>) -> impl Iterator<Item = ScopeId> + '_ {
+        std::iter::successors(scope, move |&scope| self.scopes[scope].parent)
+    }
+
+    pub fn resolve_name_in_scope(&self, scope: ScopeId, name: &Name) -> Option<&ScopeEntry> {
+        self.scope_chain(Some(scope))
+            .find_map(|scope| self.entries(scope).iter().find(|it| it.name == *name))
+    }
+
+    pub fn scope_for(&self, expr: ExprId) -> Option<ScopeId> {
+        self.scope_by_expr.get(&expr).copied()
+    }
+
+    pub fn scope_by_expr(&self) -> &FxHashMap<ExprId, ScopeId> {
+        &self.scope_by_expr
+    }
+
+    fn root_scope(&mut self) -> ScopeId {
+        self.scopes.alloc(ScopeData { parent: None, entries: vec![] })
+    }
+
+    fn new_scope(&mut self, parent: ScopeId) -> ScopeId {
+        self.scopes.alloc(ScopeData { parent: Some(parent), entries: vec![] })
+    }
+
+    fn add_bindings(&mut self, body: &Body, scope: ScopeId, pat: PatId) {
+        let pattern = &body[pat];
+        if let Pat::Bind { name, .. } = pattern {
+            let entry = ScopeEntry { name: name.clone(), pat };
+            self.scopes[scope].entries.push(entry);
+        }
+
+        pattern.walk_child_pats(|pat| self.add_bindings(body, scope, pat));
+    }
+
+    fn add_params_bindings(&mut self, body: &Body, scope: ScopeId, params: &[PatId]) {
+        params.iter().for_each(|pat| self.add_bindings(body, scope, *pat));
+    }
+
+    fn set_scope(&mut self, node: ExprId, scope: ScopeId) {
+        self.scope_by_expr.insert(node, scope);
+    }
+}
+
+fn compute_block_scopes(
+    statements: &[Statement],
+    tail: Option<ExprId>,
+    body: &Body,
+    scopes: &mut ExprScopes,
+    mut scope: ScopeId,
+) {
+    for stmt in statements {
+        match stmt {
+            Statement::Let { pat, initializer, .. } => {
+                if let Some(expr) = initializer {
+                    scopes.set_scope(*expr, scope);
+                    compute_expr_scopes(*expr, body, scopes, scope);
+                }
+                scope = scopes.new_scope(scope);
+                scopes.add_bindings(body, scope, *pat);
+            }
+            Statement::Expr(expr) => {
+                scopes.set_scope(*expr, scope);
+                compute_expr_scopes(*expr, body, scopes, scope);
+            }
+        }
+    }
+    if let Some(expr) = tail {
+        compute_expr_scopes(expr, body, scopes, scope);
+    }
+}
+
+fn compute_expr_scopes(expr: ExprId, body: &Body, scopes: &mut ExprScopes, scope: ScopeId) {
+    scopes.set_scope(expr, scope);
+    match &body[expr] {
+        Expr::Block { statements, tail, .. } => {
+            compute_block_scopes(&statements, *tail, body, scopes, scope);
+        }
+        Expr::For { iterable, pat, body: body_expr, .. } => {
+            compute_expr_scopes(*iterable, body, scopes, scope);
+            let scope = scopes.new_scope(scope);
+            scopes.add_bindings(body, scope, *pat);
+            compute_expr_scopes(*body_expr, body, scopes, scope);
+        }
+        Expr::Lambda { args, body: body_expr, .. } => {
+            let scope = scopes.new_scope(scope);
+            scopes.add_params_bindings(body, scope, &args);
+            compute_expr_scopes(*body_expr, body, scopes, scope);
+        }
+        Expr::Match { expr, arms } => {
+            compute_expr_scopes(*expr, body, scopes, scope);
+            for arm in arms {
+                let scope = scopes.new_scope(scope);
+                scopes.add_bindings(body, scope, arm.pat);
+                if let Some(guard) = arm.guard {
+                    scopes.set_scope(guard, scope);
+                    compute_expr_scopes(guard, body, scopes, scope);
+                }
+                scopes.set_scope(arm.expr, scope);
+                compute_expr_scopes(arm.expr, body, scopes, scope);
+            }
+        }
+        e => e.walk_child_exprs(|e| compute_expr_scopes(e, body, scopes, scope)),
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use base_db::{fixture::WithFixture, FileId, SourceDatabase};
+    use hir_expand::{name::AsName, InFile};
+    use syntax::{algo::find_node_at_offset, ast, AstNode};
+    use test_utils::{assert_eq_text, extract_offset, mark};
+
+    use crate::{db::DefDatabase, test_db::TestDB, FunctionId, ModuleDefId};
+
+    fn find_function(db: &TestDB, file_id: FileId) -> FunctionId {
+        let krate = db.test_crate();
+        let crate_def_map = db.crate_def_map(krate);
+
+        let module = crate_def_map.modules_for_file(file_id).next().unwrap();
+        let (_, def) = crate_def_map[module].scope.entries().next().unwrap();
+        match def.take_values().unwrap() {
+            ModuleDefId::FunctionId(it) => it,
+            _ => panic!(),
+        }
+    }
+
+    fn do_check(ra_fixture: &str, expected: &[&str]) {
+        let (offset, code) = extract_offset(ra_fixture);
+        let code = {
+            let mut buf = String::new();
+            let off: usize = offset.into();
+            buf.push_str(&code[..off]);
+            buf.push_str("<|>marker");
+            buf.push_str(&code[off..]);
+            buf
+        };
+
+        let (db, position) = TestDB::with_position(&code);
+        let file_id = position.file_id;
+        let offset = position.offset;
+
+        let file_syntax = db.parse(file_id).syntax_node();
+        let marker: ast::PathExpr = find_node_at_offset(&file_syntax, offset).unwrap();
+        let function = find_function(&db, file_id);
+
+        let scopes = db.expr_scopes(function.into());
+        let (_body, source_map) = db.body_with_source_map(function.into());
+
+        let expr_id = source_map
+            .node_expr(InFile { file_id: file_id.into(), value: &marker.into() })
+            .unwrap();
+        let scope = scopes.scope_for(expr_id);
+
+        let actual = scopes
+            .scope_chain(scope)
+            .flat_map(|scope| scopes.entries(scope))
+            .map(|it| it.name().to_string())
+            .collect::<Vec<_>>()
+            .join("\n");
+        let expected = expected.join("\n");
+        assert_eq_text!(&expected, &actual);
+    }
+
+    #[test]
+    fn test_lambda_scope() {
+        do_check(
+            r"
+            fn quux(foo: i32) {
+                let f = |bar, baz: i32| {
+                    <|>
+                };
+            }",
+            &["bar", "baz", "foo"],
+        );
+    }
+
+    #[test]
+    fn test_call_scope() {
+        do_check(
+            r"
+            fn quux() {
+                f(|x| <|> );
+            }",
+            &["x"],
+        );
+    }
+
+    #[test]
+    fn test_method_call_scope() {
+        do_check(
+            r"
+            fn quux() {
+                z.f(|x| <|> );
+            }",
+            &["x"],
+        );
+    }
+
+    #[test]
+    fn test_loop_scope() {
+        do_check(
+            r"
+            fn quux() {
+                loop {
+                    let x = ();
+                    <|>
+                };
+            }",
+            &["x"],
+        );
+    }
+
+    #[test]
+    fn test_match() {
+        do_check(
+            r"
+            fn quux() {
+                match () {
+                    Some(x) => {
+                        <|>
+                    }
+                };
+            }",
+            &["x"],
+        );
+    }
+
+    #[test]
+    fn test_shadow_variable() {
+        do_check(
+            r"
+            fn foo(x: String) {
+                let x : &str = &x<|>;
+            }",
+            &["x"],
+        );
+    }
+
+    #[test]
+    fn test_bindings_after_at() {
+        do_check(
+            r"
+fn foo() {
+    match Some(()) {
+        opt @ Some(unit) => {
+            <|>
+        }
+        _ => {}
+    }
+}
+",
+            &["opt", "unit"],
+        );
+    }
+
+    #[test]
+    fn macro_inner_item() {
+        do_check(
+            r"
+            macro_rules! mac {
+                () => {{
+                    fn inner() {}
+                    inner();
+                }};
+            }
+
+            fn foo() {
+                mac!();
+                <|>
+            }
+        ",
+            &[],
+        );
+    }
+
+    #[test]
+    fn broken_inner_item() {
+        do_check(
+            r"
+            fn foo() {
+                trait {}
+                <|>
+            }
+        ",
+            &[],
+        );
+    }
+
+    fn do_check_local_name(ra_fixture: &str, expected_offset: u32) {
+        let (db, position) = TestDB::with_position(ra_fixture);
+        let file_id = position.file_id;
+        let offset = position.offset;
+
+        let file = db.parse(file_id).ok().unwrap();
+        let expected_name = find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into())
+            .expect("failed to find a name at the target offset");
+        let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), offset).unwrap();
+
+        let function = find_function(&db, file_id);
+
+        let scopes = db.expr_scopes(function.into());
+        let (_body, source_map) = db.body_with_source_map(function.into());
+
+        let expr_scope = {
+            let expr_ast = name_ref.syntax().ancestors().find_map(ast::Expr::cast).unwrap();
+            let expr_id =
+                source_map.node_expr(InFile { file_id: file_id.into(), value: &expr_ast }).unwrap();
+            scopes.scope_for(expr_id).unwrap()
+        };
+
+        let resolved = scopes.resolve_name_in_scope(expr_scope, &name_ref.as_name()).unwrap();
+        let pat_src = source_map.pat_syntax(resolved.pat()).unwrap();
+
+        let local_name = pat_src.value.either(
+            |it| it.syntax_node_ptr().to_node(file.syntax()),
+            |it| it.syntax_node_ptr().to_node(file.syntax()),
+        );
+        assert_eq!(local_name.text_range(), expected_name.syntax().text_range());
+    }
+
+    #[test]
+    fn test_resolve_local_name() {
+        do_check_local_name(
+            r#"
+fn foo(x: i32, y: u32) {
+    {
+        let z = x * 2;
+    }
+    {
+        let t = x<|> * 3;
+    }
+}
+"#,
+            7,
+        );
+    }
+
+    #[test]
+    fn test_resolve_local_name_declaration() {
+        do_check_local_name(
+            r#"
+fn foo(x: String) {
+    let x : &str = &x<|>;
+}
+"#,
+            7,
+        );
+    }
+
+    #[test]
+    fn test_resolve_local_name_shadow() {
+        do_check_local_name(
+            r"
+fn foo(x: String) {
+    let x : &str = &x;
+    x<|>
+}
+",
+            28,
+        );
+    }
+
+    #[test]
+    fn ref_patterns_contribute_bindings() {
+        do_check_local_name(
+            r"
+fn foo() {
+    if let Some(&from) = bar() {
+        from<|>;
+    }
+}
+",
+            28,
+        );
+    }
+
+    #[test]
+    fn while_let_desugaring() {
+        mark::check!(infer_resolve_while_let);
+        do_check_local_name(
+            r#"
+fn test() {
+    let foo: Option<f32> = None;
+    while let Option::Some(spam) = foo {
+        spam<|>
+    }
+}
+"#,
+            75,
+        );
+    }
+}
diff --git a/crates/hir_def/src/builtin_type.rs b/crates/hir_def/src/builtin_type.rs
new file mode 100644
index 000000000..0f872b5c0
--- /dev/null
+++ b/crates/hir_def/src/builtin_type.rs
@@ -0,0 +1,166 @@
+//! This module defines built-in types.
+//!
+//! A peculiarity of built-in types is that they are always available and are
+//! not associated with any particular crate.
+
+use std::fmt;
+
+use hir_expand::name::{name, AsName, Name};
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum Signedness {
+    Signed,
+    Unsigned,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum IntBitness {
+    Xsize,
+    X8,
+    X16,
+    X32,
+    X64,
+    X128,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum FloatBitness {
+    X32,
+    X64,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct BuiltinInt {
+    pub signedness: Signedness,
+    pub bitness: IntBitness,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct BuiltinFloat {
+    pub bitness: FloatBitness,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum BuiltinType {
+    Char,
+    Bool,
+    Str,
+    Int(BuiltinInt),
+    Float(BuiltinFloat),
+}
+
+impl BuiltinType {
+    #[rustfmt::skip]
+    pub const ALL: &'static [(Name, BuiltinType)] = &[
+        (name![char], BuiltinType::Char),
+        (name![bool], BuiltinType::Bool),
+        (name![str],  BuiltinType::Str),
+
+        (name![isize], BuiltinType::Int(BuiltinInt::ISIZE)),
+        (name![i8],    BuiltinType::Int(BuiltinInt::I8)),
+        (name![i16],   BuiltinType::Int(BuiltinInt::I16)),
+        (name![i32],   BuiltinType::Int(BuiltinInt::I32)),
+        (name![i64],   BuiltinType::Int(BuiltinInt::I64)),
+        (name![i128],  BuiltinType::Int(BuiltinInt::I128)),
+
+        (name![usize], BuiltinType::Int(BuiltinInt::USIZE)),
+        (name![u8],    BuiltinType::Int(BuiltinInt::U8)),
+        (name![u16],   BuiltinType::Int(BuiltinInt::U16)),
+        (name![u32],   BuiltinType::Int(BuiltinInt::U32)),
+        (name![u64],   BuiltinType::Int(BuiltinInt::U64)),
+        (name![u128],  BuiltinType::Int(BuiltinInt::U128)),
+
+        (name![f32], BuiltinType::Float(BuiltinFloat::F32)),
+        (name![f64], BuiltinType::Float(BuiltinFloat::F64)),
+    ];
+}
+
+impl AsName for BuiltinType {
+    fn as_name(&self) -> Name {
+        match self {
+            BuiltinType::Char => name![char],
+            BuiltinType::Bool => name![bool],
+            BuiltinType::Str => name![str],
+            BuiltinType::Int(BuiltinInt { signedness, bitness }) => match (signedness, bitness) {
+                (Signedness::Signed, IntBitness::Xsize) => name![isize],
+                (Signedness::Signed, IntBitness::X8) => name![i8],
+                (Signedness::Signed, IntBitness::X16) => name![i16],
+                (Signedness::Signed, IntBitness::X32) => name![i32],
+                (Signedness::Signed, IntBitness::X64) => name![i64],
+                (Signedness::Signed, IntBitness::X128) => name![i128],
+
+                (Signedness::Unsigned, IntBitness::Xsize) => name![usize],
+                (Signedness::Unsigned, IntBitness::X8) => name![u8],
+                (Signedness::Unsigned, IntBitness::X16) => name![u16],
+                (Signedness::Unsigned, IntBitness::X32) => name![u32],
+                (Signedness::Unsigned, IntBitness::X64) => name![u64],
+                (Signedness::Unsigned, IntBitness::X128) => name![u128],
+            },
+            BuiltinType::Float(BuiltinFloat { bitness }) => match bitness {
+                FloatBitness::X32 => name![f32],
+                FloatBitness::X64 => name![f64],
+            },
+        }
+    }
+}
+
+impl fmt::Display for BuiltinType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let type_name = self.as_name();
+        type_name.fmt(f)
+    }
+}
+
+#[rustfmt::skip]
+impl BuiltinInt {
+    pub const ISIZE: BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::Xsize   };
+    pub const I8   : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X8      };
+    pub const I16  : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X16     };
+    pub const I32  : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X32     };
+    pub const I64  : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X64     };
+    pub const I128 : BuiltinInt = BuiltinInt { signedness: Signedness::Signed, bitness: IntBitness::X128    };
+
+    pub const USIZE: BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::Xsize };
+    pub const U8   : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X8    };
+    pub const U16  : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X16   };
+    pub const U32  : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X32   };
+    pub const U64  : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X64   };
+    pub const U128 : BuiltinInt = BuiltinInt { signedness: Signedness::Unsigned, bitness: IntBitness::X128  };
+
+
+    pub fn from_suffix(suffix: &str) -> Option<BuiltinInt> {
+        let res = match suffix {
+            "isize" => Self::ISIZE,
+            "i8"    => Self::I8,
+            "i16"   => Self::I16,
+            "i32"   => Self::I32,
+            "i64"   => Self::I64,
+            "i128"  => Self::I128,
+
+            "usize" => Self::USIZE,
+            "u8"    => Self::U8,
+            "u16"   => Self::U16,
+            "u32"   => Self::U32,
+            "u64"   => Self::U64,
+            "u128"  => Self::U128,
+
+            _ => return None,
+        };
+        Some(res)
+    }
+}
+
+#[rustfmt::skip]
+impl BuiltinFloat {
+    pub const F32: BuiltinFloat = BuiltinFloat { bitness: FloatBitness::X32 };
+    pub const F64: BuiltinFloat = BuiltinFloat { bitness: FloatBitness::X64 };
+
+    pub fn from_suffix(suffix: &str) -> Option<BuiltinFloat> {
+        let res = match suffix {
+            "f32" => BuiltinFloat::F32,
+            "f64" => BuiltinFloat::F64,
+            _ => return None,
+        };
+        Some(res)
+    }
+}
diff --git a/crates/hir_def/src/child_by_source.rs b/crates/hir_def/src/child_by_source.rs
new file mode 100644
index 000000000..dcb00a1d9
--- /dev/null
+++ b/crates/hir_def/src/child_by_source.rs
@@ -0,0 +1,177 @@
+//! When *constructing* `hir`, we start at some parent syntax node and recursively
+//! lower the children.
+//!
+//! This modules allows one to go in the opposite direction: start with a syntax
+//! node for a *child*, and get its hir.
+
+use either::Either;
+
+use crate::{
+    db::DefDatabase,
+    dyn_map::DynMap,
+    item_scope::ItemScope,
+    keys,
+    src::{HasChildSource, HasSource},
+    AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, FieldId, ImplId, Lookup, ModuleDefId,
+    ModuleId, TraitId, VariantId,
+};
+
+pub trait ChildBySource {
+    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap;
+}
+
+impl ChildBySource for TraitId {
+    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+        let mut res = DynMap::default();
+
+        let data = db.trait_data(*self);
+        for (_name, item) in data.items.iter() {
+            match *item {
+                AssocItemId::FunctionId(func) => {
+                    let src = func.lookup(db).source(db);
+                    res[keys::FUNCTION].insert(src, func)
+                }
+                AssocItemId::ConstId(konst) => {
+                    let src = konst.lookup(db).source(db);
+                    res[keys::CONST].insert(src, konst)
+                }
+                AssocItemId::TypeAliasId(ty) => {
+                    let src = ty.lookup(db).source(db);
+                    res[keys::TYPE_ALIAS].insert(src, ty)
+                }
+            }
+        }
+
+        res
+    }
+}
+
+impl ChildBySource for ImplId {
+    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+        let mut res = DynMap::default();
+
+        let data = db.impl_data(*self);
+        for &item in data.items.iter() {
+            match item {
+                AssocItemId::FunctionId(func) => {
+                    let src = func.lookup(db).source(db);
+                    res[keys::FUNCTION].insert(src, func)
+                }
+                AssocItemId::ConstId(konst) => {
+                    let src = konst.lookup(db).source(db);
+                    res[keys::CONST].insert(src, konst)
+                }
+                AssocItemId::TypeAliasId(ty) => {
+                    let src = ty.lookup(db).source(db);
+                    res[keys::TYPE_ALIAS].insert(src, ty)
+                }
+            }
+        }
+
+        res
+    }
+}
+
+impl ChildBySource for ModuleId {
+    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+        let crate_def_map = db.crate_def_map(self.krate);
+        let module_data = &crate_def_map[self.local_id];
+        module_data.scope.child_by_source(db)
+    }
+}
+
+impl ChildBySource for ItemScope {
+    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+        let mut res = DynMap::default();
+        self.declarations().for_each(|item| add_module_def(db, &mut res, item));
+        self.impls().for_each(|imp| add_impl(db, &mut res, imp));
+        return res;
+
+        fn add_module_def(db: &dyn DefDatabase, map: &mut DynMap, item: ModuleDefId) {
+            match item {
+                ModuleDefId::FunctionId(func) => {
+                    let src = func.lookup(db).source(db);
+                    map[keys::FUNCTION].insert(src, func)
+                }
+                ModuleDefId::ConstId(konst) => {
+                    let src = konst.lookup(db).source(db);
+                    map[keys::CONST].insert(src, konst)
+                }
+                ModuleDefId::StaticId(statik) => {
+                    let src = statik.lookup(db).source(db);
+                    map[keys::STATIC].insert(src, statik)
+                }
+                ModuleDefId::TypeAliasId(ty) => {
+                    let src = ty.lookup(db).source(db);
+                    map[keys::TYPE_ALIAS].insert(src, ty)
+                }
+                ModuleDefId::TraitId(trait_) => {
+                    let src = trait_.lookup(db).source(db);
+                    map[keys::TRAIT].insert(src, trait_)
+                }
+                ModuleDefId::AdtId(adt) => match adt {
+                    AdtId::StructId(strukt) => {
+                        let src = strukt.lookup(db).source(db);
+                        map[keys::STRUCT].insert(src, strukt)
+                    }
+                    AdtId::UnionId(union_) => {
+                        let src = union_.lookup(db).source(db);
+                        map[keys::UNION].insert(src, union_)
+                    }
+                    AdtId::EnumId(enum_) => {
+                        let src = enum_.lookup(db).source(db);
+                        map[keys::ENUM].insert(src, enum_)
+                    }
+                },
+                _ => (),
+            }
+        }
+        fn add_impl(db: &dyn DefDatabase, map: &mut DynMap, imp: ImplId) {
+            let src = imp.lookup(db).source(db);
+            map[keys::IMPL].insert(src, imp)
+        }
+    }
+}
+
+impl ChildBySource for VariantId {
+    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+        let mut res = DynMap::default();
+
+        let arena_map = self.child_source(db);
+        let arena_map = arena_map.as_ref();
+        for (local_id, source) in arena_map.value.iter() {
+            let id = FieldId { parent: *self, local_id };
+            match source {
+                Either::Left(source) => {
+                    res[keys::TUPLE_FIELD].insert(arena_map.with_value(source.clone()), id)
+                }
+                Either::Right(source) => {
+                    res[keys::RECORD_FIELD].insert(arena_map.with_value(source.clone()), id)
+                }
+            }
+        }
+        res
+    }
+}
+
+impl ChildBySource for EnumId {
+    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+        let mut res = DynMap::default();
+
+        let arena_map = self.child_source(db);
+        let arena_map = arena_map.as_ref();
+        for (local_id, source) in arena_map.value.iter() {
+            let id = EnumVariantId { parent: *self, local_id };
+            res[keys::VARIANT].insert(arena_map.with_value(source.clone()), id)
+        }
+
+        res
+    }
+}
+
+impl ChildBySource for DefWithBodyId {
+    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+        let body = db.body(*self);
+        body.item_scope.child_by_source(db)
+    }
+}
diff --git a/crates/hir_def/src/data.rs b/crates/hir_def/src/data.rs
new file mode 100644
index 000000000..9a8eb4ede
--- /dev/null
+++ b/crates/hir_def/src/data.rs
@@ -0,0 +1,278 @@
+//! Contains basic data about various HIR declarations.
+
+use std::sync::Arc;
+
+use hir_expand::{name::Name, InFile};
+use syntax::ast;
+
+use crate::{
+    attr::Attrs,
+    body::Expander,
+    db::DefDatabase,
+    item_tree::{AssocItem, ItemTreeId, ModItem},
+    type_ref::{TypeBound, TypeRef},
+    visibility::RawVisibility,
+    AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
+    Intern, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FunctionData {
+    pub name: Name,
+    pub params: Vec<TypeRef>,
+    pub ret_type: TypeRef,
+    pub attrs: Attrs,
+    /// True if the first param is `self`. This is relevant to decide whether this
+    /// can be called as a method.
+    pub has_self_param: bool,
+    pub is_unsafe: bool,
+    pub is_varargs: bool,
+    pub visibility: RawVisibility,
+}
+
+impl FunctionData {
+    pub(crate) fn fn_data_query(db: &dyn DefDatabase, func: FunctionId) -> Arc<FunctionData> {
+        let loc = func.lookup(db);
+        let item_tree = db.item_tree(loc.id.file_id);
+        let func = &item_tree[loc.id.value];
+
+        Arc::new(FunctionData {
+            name: func.name.clone(),
+            params: func.params.to_vec(),
+            ret_type: func.ret_type.clone(),
+            attrs: item_tree.attrs(ModItem::from(loc.id.value).into()).clone(),
+            has_self_param: func.has_self_param,
+            is_unsafe: func.is_unsafe,
+            is_varargs: func.is_varargs,
+            visibility: item_tree[func.visibility].clone(),
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TypeAliasData {
+    pub name: Name,
+    pub type_ref: Option<TypeRef>,
+    pub visibility: RawVisibility,
+    /// Bounds restricting the type alias itself (eg. `type Ty: Bound;` in a trait or impl).
+    pub bounds: Vec<TypeBound>,
+}
+
+impl TypeAliasData {
+    pub(crate) fn type_alias_data_query(
+        db: &dyn DefDatabase,
+        typ: TypeAliasId,
+    ) -> Arc<TypeAliasData> {
+        let loc = typ.lookup(db);
+        let item_tree = db.item_tree(loc.id.file_id);
+        let typ = &item_tree[loc.id.value];
+
+        Arc::new(TypeAliasData {
+            name: typ.name.clone(),
+            type_ref: typ.type_ref.clone(),
+            visibility: item_tree[typ.visibility].clone(),
+            bounds: typ.bounds.to_vec(),
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TraitData {
+    pub name: Name,
+    pub items: Vec<(Name, AssocItemId)>,
+    pub auto: bool,
+}
+
+impl TraitData {
+    pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
+        let tr_loc = tr.lookup(db);
+        let item_tree = db.item_tree(tr_loc.id.file_id);
+        let tr_def = &item_tree[tr_loc.id.value];
+        let name = tr_def.name.clone();
+        let auto = tr_def.auto;
+        let module_id = tr_loc.container.module(db);
+        let container = AssocContainerId::TraitId(tr);
+        let mut expander = Expander::new(db, tr_loc.id.file_id, module_id);
+
+        let items = collect_items(
+            db,
+            module_id,
+            &mut expander,
+            tr_def.items.iter().copied(),
+            tr_loc.id.file_id,
+            container,
+            100,
+        );
+
+        Arc::new(TraitData { name, items, auto })
+    }
+
+    pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
+        self.items.iter().filter_map(|(_name, item)| match item {
+            AssocItemId::TypeAliasId(t) => Some(*t),
+            _ => None,
+        })
+    }
+
+    pub fn associated_type_by_name(&self, name: &Name) -> Option<TypeAliasId> {
+        self.items.iter().find_map(|(item_name, item)| match item {
+            AssocItemId::TypeAliasId(t) if item_name == name => Some(*t),
+            _ => None,
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImplData {
+    pub target_trait: Option<TypeRef>,
+    pub target_type: TypeRef,
+    pub items: Vec<AssocItemId>,
+    pub is_negative: bool,
+}
+
+impl ImplData {
+    pub(crate) fn impl_data_query(db: &dyn DefDatabase, id: ImplId) -> Arc<ImplData> {
+        let _p = profile::span("impl_data_query");
+        let impl_loc = id.lookup(db);
+
+        let item_tree = db.item_tree(impl_loc.id.file_id);
+        let impl_def = &item_tree[impl_loc.id.value];
+        let target_trait = impl_def.target_trait.clone();
+        let target_type = impl_def.target_type.clone();
+        let is_negative = impl_def.is_negative;
+        let module_id = impl_loc.container.module(db);
+        let container = AssocContainerId::ImplId(id);
+        let mut expander = Expander::new(db, impl_loc.id.file_id, module_id);
+
+        let items = collect_items(
+            db,
+            module_id,
+            &mut expander,
+            impl_def.items.iter().copied(),
+            impl_loc.id.file_id,
+            container,
+            100,
+        );
+        let items = items.into_iter().map(|(_, item)| item).collect();
+
+        Arc::new(ImplData { target_trait, target_type, items, is_negative })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConstData {
+    /// const _: () = ();
+    pub name: Option<Name>,
+    pub type_ref: TypeRef,
+    pub visibility: RawVisibility,
+}
+
+impl ConstData {
+    pub(crate) fn const_data_query(db: &dyn DefDatabase, konst: ConstId) -> Arc<ConstData> {
+        let loc = konst.lookup(db);
+        let item_tree = db.item_tree(loc.id.file_id);
+        let konst = &item_tree[loc.id.value];
+
+        Arc::new(ConstData {
+            name: konst.name.clone(),
+            type_ref: konst.type_ref.clone(),
+            visibility: item_tree[konst.visibility].clone(),
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct StaticData {
+    pub name: Option<Name>,
+    pub type_ref: TypeRef,
+    pub visibility: RawVisibility,
+    pub mutable: bool,
+}
+
+impl StaticData {
+    pub(crate) fn static_data_query(db: &dyn DefDatabase, konst: StaticId) -> Arc<StaticData> {
+        let node = konst.lookup(db);
+        let item_tree = db.item_tree(node.id.file_id);
+        let statik = &item_tree[node.id.value];
+
+        Arc::new(StaticData {
+            name: Some(statik.name.clone()),
+            type_ref: statik.type_ref.clone(),
+            visibility: item_tree[statik.visibility].clone(),
+            mutable: statik.mutable,
+        })
+    }
+}
+
+fn collect_items(
+    db: &dyn DefDatabase,
+    module: ModuleId,
+    expander: &mut Expander,
+    assoc_items: impl Iterator<Item = AssocItem>,
+    file_id: crate::HirFileId,
+    container: AssocContainerId,
+    limit: usize,
+) -> Vec<(Name, AssocItemId)> {
+    if limit == 0 {
+        return Vec::new();
+    }
+
+    let item_tree = db.item_tree(file_id);
+    let cfg_options = db.crate_graph()[module.krate].cfg_options.clone();
+
+    let mut items = Vec::new();
+    for item in assoc_items {
+        match item {
+            AssocItem::Function(id) => {
+                let item = &item_tree[id];
+                let attrs = item_tree.attrs(ModItem::from(id).into());
+                if !attrs.is_cfg_enabled(&cfg_options) {
+                    continue;
+                }
+                let def = FunctionLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
+                items.push((item.name.clone(), def.into()));
+            }
+            // FIXME: cfg?
+            AssocItem::Const(id) => {
+                let item = &item_tree[id];
+                let name = match item.name.clone() {
+                    Some(name) => name,
+                    None => continue,
+                };
+                let def = ConstLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
+                items.push((name, def.into()));
+            }
+            AssocItem::TypeAlias(id) => {
+                let item = &item_tree[id];
+                let def = TypeAliasLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
+                items.push((item.name.clone(), def.into()));
+            }
+            AssocItem::MacroCall(call) => {
+                let call = &item_tree[call];
+                let ast_id_map = db.ast_id_map(file_id);
+                let root = db.parse_or_expand(file_id).unwrap();
+                let call = ast_id_map.get(call.ast_id).to_node(&root);
+
+                if let Some((mark, mac)) = expander.enter_expand(db, None, call) {
+                    let src: InFile<ast::MacroItems> = expander.to_source(mac);
+                    let item_tree = db.item_tree(src.file_id);
+                    let iter =
+                        item_tree.top_level_items().iter().filter_map(ModItem::as_assoc_item);
+                    items.extend(collect_items(
+                        db,
+                        module,
+                        expander,
+                        iter,
+                        src.file_id,
+                        container,
+                        limit - 1,
+                    ));
+
+                    expander.exit(db, mark);
+                }
+            }
+        }
+    }
+
+    items
+}
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
new file mode 100644
index 000000000..6d694de11
--- /dev/null
+++ b/crates/hir_def/src/db.rs
@@ -0,0 +1,120 @@
+//! Defines database & queries for name resolution.
+use std::sync::Arc;
+
+use base_db::{salsa, CrateId, SourceDatabase, Upcast};
+use hir_expand::{db::AstDatabase, HirFileId};
+use syntax::SmolStr;
+
+use crate::{
+    adt::{EnumData, StructData},
+    attr::Attrs,
+    body::{scope::ExprScopes, Body, BodySourceMap},
+    data::{ConstData, FunctionData, ImplData, StaticData, TraitData, TypeAliasData},
+    docs::Documentation,
+    generics::GenericParams,
+    import_map::ImportMap,
+    item_tree::ItemTree,
+    lang_item::{LangItemTarget, LangItems},
+    nameres::CrateDefMap,
+    AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
+    GenericDefId, ImplId, ImplLoc, ModuleId, StaticId, StaticLoc, StructId, StructLoc, TraitId,
+    TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
+};
+
+#[salsa::query_group(InternDatabaseStorage)]
+pub trait InternDatabase: SourceDatabase {
+    #[salsa::interned]
+    fn intern_function(&self, loc: FunctionLoc) -> FunctionId;
+    #[salsa::interned]
+    fn intern_struct(&self, loc: StructLoc) -> StructId;
+    #[salsa::interned]
+    fn intern_union(&self, loc: UnionLoc) -> UnionId;
+    #[salsa::interned]
+    fn intern_enum(&self, loc: EnumLoc) -> EnumId;
+    #[salsa::interned]
+    fn intern_const(&self, loc: ConstLoc) -> ConstId;
+    #[salsa::interned]
+    fn intern_static(&self, loc: StaticLoc) -> StaticId;
+    #[salsa::interned]
+    fn intern_trait(&self, loc: TraitLoc) -> TraitId;
+    #[salsa::interned]
+    fn intern_type_alias(&self, loc: TypeAliasLoc) -> TypeAliasId;
+    #[salsa::interned]
+    fn intern_impl(&self, loc: ImplLoc) -> ImplId;
+}
+
+#[salsa::query_group(DefDatabaseStorage)]
+pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
+    #[salsa::invoke(ItemTree::item_tree_query)]
+    fn item_tree(&self, file_id: HirFileId) -> Arc<ItemTree>;
+
+    #[salsa::invoke(crate_def_map_wait)]
+    #[salsa::transparent]
+    fn crate_def_map(&self, krate: CrateId) -> Arc<CrateDefMap>;
+
+    #[salsa::invoke(CrateDefMap::crate_def_map_query)]
+    fn crate_def_map_query(&self, krate: CrateId) -> Arc<CrateDefMap>;
+
+    #[salsa::invoke(StructData::struct_data_query)]
+    fn struct_data(&self, id: StructId) -> Arc<StructData>;
+    #[salsa::invoke(StructData::union_data_query)]
+    fn union_data(&self, id: UnionId) -> Arc<StructData>;
+
+    #[salsa::invoke(EnumData::enum_data_query)]
+    fn enum_data(&self, e: EnumId) -> Arc<EnumData>;
+
+    #[salsa::invoke(ImplData::impl_data_query)]
+    fn impl_data(&self, e: ImplId) -> Arc<ImplData>;
+
+    #[salsa::invoke(TraitData::trait_data_query)]
+    fn trait_data(&self, e: TraitId) -> Arc<TraitData>;
+
+    #[salsa::invoke(TypeAliasData::type_alias_data_query)]
+    fn type_alias_data(&self, e: TypeAliasId) -> Arc<TypeAliasData>;
+
+    #[salsa::invoke(FunctionData::fn_data_query)]
+    fn function_data(&self, func: FunctionId) -> Arc<FunctionData>;
+
+    #[salsa::invoke(ConstData::const_data_query)]
+    fn const_data(&self, konst: ConstId) -> Arc<ConstData>;
+
+    #[salsa::invoke(StaticData::static_data_query)]
+    fn static_data(&self, konst: StaticId) -> Arc<StaticData>;
+
+    #[salsa::invoke(Body::body_with_source_map_query)]
+    fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);
+
+    #[salsa::invoke(Body::body_query)]
+    fn body(&self, def: DefWithBodyId) -> Arc<Body>;
+
+    #[salsa::invoke(ExprScopes::expr_scopes_query)]
+    fn expr_scopes(&self, def: DefWithBodyId) -> Arc<ExprScopes>;
+
+    #[salsa::invoke(GenericParams::generic_params_query)]
+    fn generic_params(&self, def: GenericDefId) -> Arc<GenericParams>;
+
+    #[salsa::invoke(Attrs::attrs_query)]
+    fn attrs(&self, def: AttrDefId) -> Attrs;
+
+    #[salsa::invoke(LangItems::module_lang_items_query)]
+    fn module_lang_items(&self, module: ModuleId) -> Option<Arc<LangItems>>;
+
+    #[salsa::invoke(LangItems::crate_lang_items_query)]
+    fn crate_lang_items(&self, krate: CrateId) -> Arc<LangItems>;
+
+    #[salsa::invoke(LangItems::lang_item_query)]
+    fn lang_item(&self, start_crate: CrateId, item: SmolStr) -> Option<LangItemTarget>;
+
+    // FIXME(https://github.com/rust-analyzer/rust-analyzer/issues/2148#issuecomment-550519102)
+    // Remove this query completely, in favor of `Attrs::docs` method
+    #[salsa::invoke(Documentation::documentation_query)]
+    fn documentation(&self, def: AttrDefId) -> Option<Documentation>;
+
+    #[salsa::invoke(ImportMap::import_map_query)]
+    fn import_map(&self, krate: CrateId) -> Arc<ImportMap>;
+}
+
+fn crate_def_map_wait(db: &impl DefDatabase, krate: CrateId) -> Arc<CrateDefMap> {
+    let _p = profile::span("crate_def_map:wait");
+    db.crate_def_map_query(krate)
+}
diff --git a/crates/hir_def/src/diagnostics.rs b/crates/hir_def/src/diagnostics.rs
new file mode 100644
index 000000000..c7723de00
--- /dev/null
+++ b/crates/hir_def/src/diagnostics.rs
@@ -0,0 +1,30 @@
+//! Diagnostics produced by `hir_def`.
+
+use std::any::Any;
+
+use hir_expand::diagnostics::Diagnostic;
+use syntax::{ast, AstPtr, SyntaxNodePtr};
+
+use hir_expand::{HirFileId, InFile};
+
+#[derive(Debug)]
+pub struct UnresolvedModule {
+    pub file: HirFileId,
+    pub decl: AstPtr<ast::Module>,
+    pub candidate: String,
+}
+
+impl Diagnostic for UnresolvedModule {
+    fn name(&self) -> &'static str {
+        "unresolved-module"
+    }
+    fn message(&self) -> String {
+        "unresolved module".to_string()
+    }
+    fn display_source(&self) -> InFile<SyntaxNodePtr> {
+        InFile::new(self.file, self.decl.clone().into())
+    }
+    fn as_any(&self) -> &(dyn Any + Send + 'static) {
+        self
+    }
+}
diff --git a/crates/hir_def/src/docs.rs b/crates/hir_def/src/docs.rs
new file mode 100644
index 000000000..e9a02b11b
--- /dev/null
+++ b/crates/hir_def/src/docs.rs
@@ -0,0 +1,121 @@
+//! Defines hir documentation.
+//!
+//! This really shouldn't exist, instead, we should deshugar doc comments into attributes, see
+//! https://github.com/rust-analyzer/rust-analyzer/issues/2148#issuecomment-550519102
+
+use std::sync::Arc;
+
+use either::Either;
+use syntax::ast;
+
+use crate::{
+    db::DefDatabase,
+    src::{HasChildSource, HasSource},
+    AdtId, AttrDefId, Lookup,
+};
+
+/// Holds documentation
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Documentation(Arc<str>);
+
+impl Into<String> for Documentation {
+    fn into(self) -> String {
+        self.as_str().to_owned()
+    }
+}
+
+impl Documentation {
+    fn new(s: &str) -> Documentation {
+        Documentation(s.into())
+    }
+
+    pub fn from_ast<N>(node: &N) -> Option<Documentation>
+    where
+        N: ast::DocCommentsOwner + ast::AttrsOwner,
+    {
+        docs_from_ast(node)
+    }
+
+    pub fn as_str(&self) -> &str {
+        &*self.0
+    }
+
+    pub(crate) fn documentation_query(
+        db: &dyn DefDatabase,
+        def: AttrDefId,
+    ) -> Option<Documentation> {
+        match def {
+            AttrDefId::ModuleId(module) => {
+                let def_map = db.crate_def_map(module.krate);
+                let src = def_map[module.local_id].declaration_source(db)?;
+                docs_from_ast(&src.value)
+            }
+            AttrDefId::FieldId(it) => {
+                let src = it.parent.child_source(db);
+                match &src.value[it.local_id] {
+                    Either::Left(_tuple) => None,
+                    Either::Right(record) => docs_from_ast(record),
+                }
+            }
+            AttrDefId::AdtId(it) => match it {
+                AdtId::StructId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+                AdtId::EnumId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+                AdtId::UnionId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+            },
+            AttrDefId::EnumVariantId(it) => {
+                let src = it.parent.child_source(db);
+                docs_from_ast(&src.value[it.local_id])
+            }
+            AttrDefId::TraitId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+            AttrDefId::MacroDefId(it) => docs_from_ast(&it.ast_id?.to_node(db.upcast())),
+            AttrDefId::ConstId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+            AttrDefId::StaticId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+            AttrDefId::FunctionId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+            AttrDefId::TypeAliasId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+            AttrDefId::ImplId(_) => None,
+        }
+    }
+}
+
+pub(crate) fn docs_from_ast<N>(node: &N) -> Option<Documentation>
+where
+    N: ast::DocCommentsOwner + ast::AttrsOwner,
+{
+    let doc_comment_text = node.doc_comment_text();
+    let doc_attr_text = expand_doc_attrs(node);
+    let docs = merge_doc_comments_and_attrs(doc_comment_text, doc_attr_text);
+    docs.map(|it| Documentation::new(&it))
+}
+
+fn merge_doc_comments_and_attrs(
+    doc_comment_text: Option<String>,
+    doc_attr_text: Option<String>,
+) -> Option<String> {
+    match (doc_comment_text, doc_attr_text) {
+        (Some(mut comment_text), Some(attr_text)) => {
+            comment_text.push_str("\n\n");
+            comment_text.push_str(&attr_text);
+            Some(comment_text)
+        }
+        (Some(comment_text), None) => Some(comment_text),
+        (None, Some(attr_text)) => Some(attr_text),
+        (None, None) => None,
+    }
+}
+
+fn expand_doc_attrs(owner: &dyn ast::AttrsOwner) -> Option<String> {
+    let mut docs = String::new();
+    for attr in owner.attrs() {
+        if let Some(("doc", value)) =
+            attr.as_simple_key_value().as_ref().map(|(k, v)| (k.as_str(), v.as_str()))
+        {
+            docs.push_str(value);
+            docs.push_str("\n\n");
+        }
+    }
+    if docs.is_empty() {
+        None
+    } else {
+        Some(docs.trim_end_matches("\n\n").to_owned())
+    }
+}
diff --git a/crates/hir_def/src/dyn_map.rs b/crates/hir_def/src/dyn_map.rs
new file mode 100644
index 000000000..6f269d7b0
--- /dev/null
+++ b/crates/hir_def/src/dyn_map.rs
@@ -0,0 +1,108 @@
+//! This module defines a `DynMap` -- a container for heterogeneous maps.
+//!
+//! This means that `DynMap` stores a bunch of hash maps inside, and those maps
+//! can be of different types.
+//!
+//! It is used like this:
+//!
+//! ```
+//! // keys define submaps of a `DynMap`
+//! const STRING_TO_U32: Key<String, u32> = Key::new();
+//! const U32_TO_VEC: Key<u32, Vec<bool>> = Key::new();
+//!
+//! // Note: concrete type, no type params!
+//! let mut map = DynMap::new();
+//!
+//! // To access a specific map, index the `DynMap` by `Key`:
+//! map[STRING_TO_U32].insert("hello".to_string(), 92);
+//! let value = map[U32_TO_VEC].get(92);
+//! assert!(value.is_none());
+//! ```
+//!
+//! This is a work of fiction. Any similarities to Kotlin's `BindingContext` are
+//! a coincidence.
+use std::{
+    hash::Hash,
+    marker::PhantomData,
+    ops::{Index, IndexMut},
+};
+
+use anymap::Map;
+use rustc_hash::FxHashMap;
+
+pub struct Key<K, V, P = (K, V)> {
+    _phantom: PhantomData<(K, V, P)>,
+}
+
+impl<K, V, P> Key<K, V, P> {
+    pub(crate) const fn new() -> Key<K, V, P> {
+        Key { _phantom: PhantomData }
+    }
+}
+
+impl<K, V, P> Copy for Key<K, V, P> {}
+
+impl<K, V, P> Clone for Key<K, V, P> {
+    fn clone(&self) -> Key<K, V, P> {
+        *self
+    }
+}
+
+pub trait Policy {
+    type K;
+    type V;
+
+    fn insert(map: &mut DynMap, key: Self::K, value: Self::V);
+    fn get<'a>(map: &'a DynMap, key: &Self::K) -> Option<&'a Self::V>;
+}
+
+impl<K: Hash + Eq + 'static, V: 'static> Policy for (K, V) {
+    type K = K;
+    type V = V;
+    fn insert(map: &mut DynMap, key: K, value: V) {
+        map.map.entry::<FxHashMap<K, V>>().or_insert_with(Default::default).insert(key, value);
+    }
+    fn get<'a>(map: &'a DynMap, key: &K) -> Option<&'a V> {
+        map.map.get::<FxHashMap<K, V>>()?.get(key)
+    }
+}
+
+pub struct DynMap {
+    pub(crate) map: Map,
+}
+
+impl Default for DynMap {
+    fn default() -> Self {
+        DynMap { map: Map::new() }
+    }
+}
+
+#[repr(transparent)]
+pub struct KeyMap<KEY> {
+    map: DynMap,
+    _phantom: PhantomData<KEY>,
+}
+
+impl<P: Policy> KeyMap<Key<P::K, P::V, P>> {
+    pub fn insert(&mut self, key: P::K, value: P::V) {
+        P::insert(&mut self.map, key, value)
+    }
+    pub fn get(&self, key: &P::K) -> Option<&P::V> {
+        P::get(&self.map, key)
+    }
+}
+
+impl<P: Policy> Index<Key<P::K, P::V, P>> for DynMap {
+    type Output = KeyMap<Key<P::K, P::V, P>>;
+    fn index(&self, _key: Key<P::K, P::V, P>) -> &Self::Output {
+        // Safe due to `#[repr(transparent)]`.
+        unsafe { std::mem::transmute::<&DynMap, &KeyMap<Key<P::K, P::V, P>>>(self) }
+    }
+}
+
+impl<P: Policy> IndexMut<Key<P::K, P::V, P>> for DynMap {
+    fn index_mut(&mut self, _key: Key<P::K, P::V, P>) -> &mut Self::Output {
+        // Safe due to `#[repr(transparent)]`.
+        unsafe { std::mem::transmute::<&mut DynMap, &mut KeyMap<Key<P::K, P::V, P>>>(self) }
+    }
+}
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
new file mode 100644
index 000000000..c94b3a36f
--- /dev/null
+++ b/crates/hir_def/src/expr.rs
@@ -0,0 +1,420 @@
+//! This module describes hir-level representation of expressions.
+//!
+//! This representaion is:
+//!
+//! 1. Identity-based. Each expression has an `id`, so we can distinguish
+//!    between different `1` in `1 + 1`.
+//! 2. Independent of syntax. Though syntactic provenance information can be
+//!    attached separately via id-based side map.
+//! 3. Unresolved. Paths are stored as sequences of names, and not as defs the
+//!    names refer to.
+//! 4. Desugared. There's no `if let`.
+//!
+//! See also a neighboring `body` module.
+
+use arena::{Idx, RawId};
+use hir_expand::name::Name;
+use syntax::ast::RangeOp;
+
+use crate::{
+    builtin_type::{BuiltinFloat, BuiltinInt},
+    path::{GenericArgs, Path},
+    type_ref::{Mutability, Rawness, TypeRef},
+};
+
+pub type ExprId = Idx<Expr>;
+pub(crate) fn dummy_expr_id() -> ExprId {
+    ExprId::from_raw(RawId::from(!0))
+}
+
+pub type PatId = Idx<Pat>;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Literal {
+    String(String),
+    ByteString(Vec<u8>),
+    Char(char),
+    Bool(bool),
+    Int(u64, Option<BuiltinInt>),
+    Float(u64, Option<BuiltinFloat>), // FIXME: f64 is not Eq
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Expr {
+    /// This is produced if the syntax tree does not have a required expression piece.
+    Missing,
+    Path(Path),
+    If {
+        condition: ExprId,
+        then_branch: ExprId,
+        else_branch: Option<ExprId>,
+    },
+    Block {
+        statements: Vec<Statement>,
+        tail: Option<ExprId>,
+        label: Option<Name>,
+    },
+    Loop {
+        body: ExprId,
+        label: Option<Name>,
+    },
+    While {
+        condition: ExprId,
+        body: ExprId,
+        label: Option<Name>,
+    },
+    For {
+        iterable: ExprId,
+        pat: PatId,
+        body: ExprId,
+        label: Option<Name>,
+    },
+    Call {
+        callee: ExprId,
+        args: Vec<ExprId>,
+    },
+    MethodCall {
+        receiver: ExprId,
+        method_name: Name,
+        args: Vec<ExprId>,
+        generic_args: Option<GenericArgs>,
+    },
+    Match {
+        expr: ExprId,
+        arms: Vec<MatchArm>,
+    },
+    Continue {
+        label: Option<Name>,
+    },
+    Break {
+        expr: Option<ExprId>,
+        label: Option<Name>,
+    },
+    Return {
+        expr: Option<ExprId>,
+    },
+    RecordLit {
+        path: Option<Path>,
+        fields: Vec<RecordLitField>,
+        spread: Option<ExprId>,
+    },
+    Field {
+        expr: ExprId,
+        name: Name,
+    },
+    Await {
+        expr: ExprId,
+    },
+    Try {
+        expr: ExprId,
+    },
+    TryBlock {
+        body: ExprId,
+    },
+    Cast {
+        expr: ExprId,
+        type_ref: TypeRef,
+    },
+    Ref {
+        expr: ExprId,
+        rawness: Rawness,
+        mutability: Mutability,
+    },
+    Box {
+        expr: ExprId,
+    },
+    UnaryOp {
+        expr: ExprId,
+        op: UnaryOp,
+    },
+    BinaryOp {
+        lhs: ExprId,
+        rhs: ExprId,
+        op: Option<BinaryOp>,
+    },
+    Range {
+        lhs: Option<ExprId>,
+        rhs: Option<ExprId>,
+        range_type: RangeOp,
+    },
+    Index {
+        base: ExprId,
+        index: ExprId,
+    },
+    Lambda {
+        args: Vec<PatId>,
+        arg_types: Vec<Option<TypeRef>>,
+        ret_type: Option<TypeRef>,
+        body: ExprId,
+    },
+    Tuple {
+        exprs: Vec<ExprId>,
+    },
+    Unsafe {
+        body: ExprId,
+    },
+    Array(Array),
+    Literal(Literal),
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum BinaryOp {
+    LogicOp(LogicOp),
+    ArithOp(ArithOp),
+    CmpOp(CmpOp),
+    Assignment { op: Option<ArithOp> },
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum LogicOp {
+    And,
+    Or,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum CmpOp {
+    Eq { negated: bool },
+    Ord { ordering: Ordering, strict: bool },
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Ordering {
+    Less,
+    Greater,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum ArithOp {
+    Add,
+    Mul,
+    Sub,
+    Div,
+    Rem,
+    Shl,
+    Shr,
+    BitXor,
+    BitOr,
+    BitAnd,
+}
+
+pub use syntax::ast::PrefixOp as UnaryOp;
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Array {
+    ElementList(Vec<ExprId>),
+    Repeat { initializer: ExprId, repeat: ExprId },
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct MatchArm {
+    pub pat: PatId,
+    pub guard: Option<ExprId>,
+    pub expr: ExprId,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct RecordLitField {
+    pub name: Name,
+    pub expr: ExprId,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Statement {
+    Let { pat: PatId, type_ref: Option<TypeRef>, initializer: Option<ExprId> },
+    Expr(ExprId),
+}
+
+impl Expr {
+    pub fn walk_child_exprs(&self, mut f: impl FnMut(ExprId)) {
+        match self {
+            Expr::Missing => {}
+            Expr::Path(_) => {}
+            Expr::If { condition, then_branch, else_branch } => {
+                f(*condition);
+                f(*then_branch);
+                if let Some(else_branch) = else_branch {
+                    f(*else_branch);
+                }
+            }
+            Expr::Block { statements, tail, .. } => {
+                for stmt in statements {
+                    match stmt {
+                        Statement::Let { initializer, .. } => {
+                            if let Some(expr) = initializer {
+                                f(*expr);
+                            }
+                        }
+                        Statement::Expr(e) => f(*e),
+                    }
+                }
+                if let Some(expr) = tail {
+                    f(*expr);
+                }
+            }
+            Expr::TryBlock { body } | Expr::Unsafe { body } => f(*body),
+            Expr::Loop { body, .. } => f(*body),
+            Expr::While { condition, body, .. } => {
+                f(*condition);
+                f(*body);
+            }
+            Expr::For { iterable, body, .. } => {
+                f(*iterable);
+                f(*body);
+            }
+            Expr::Call { callee, args } => {
+                f(*callee);
+                for arg in args {
+                    f(*arg);
+                }
+            }
+            Expr::MethodCall { receiver, args, .. } => {
+                f(*receiver);
+                for arg in args {
+                    f(*arg);
+                }
+            }
+            Expr::Match { expr, arms } => {
+                f(*expr);
+                for arm in arms {
+                    f(arm.expr);
+                }
+            }
+            Expr::Continue { .. } => {}
+            Expr::Break { expr, .. } | Expr::Return { expr } => {
+                if let Some(expr) = expr {
+                    f(*expr);
+                }
+            }
+            Expr::RecordLit { fields, spread, .. } => {
+                for field in fields {
+                    f(field.expr);
+                }
+                if let Some(expr) = spread {
+                    f(*expr);
+                }
+            }
+            Expr::Lambda { body, .. } => {
+                f(*body);
+            }
+            Expr::BinaryOp { lhs, rhs, .. } => {
+                f(*lhs);
+                f(*rhs);
+            }
+            Expr::Range { lhs, rhs, .. } => {
+                if let Some(lhs) = rhs {
+                    f(*lhs);
+                }
+                if let Some(rhs) = lhs {
+                    f(*rhs);
+                }
+            }
+            Expr::Index { base, index } => {
+                f(*base);
+                f(*index);
+            }
+            Expr::Field { expr, .. }
+            | Expr::Await { expr }
+            | Expr::Try { expr }
+            | Expr::Cast { expr, .. }
+            | Expr::Ref { expr, .. }
+            | Expr::UnaryOp { expr, .. }
+            | Expr::Box { expr } => {
+                f(*expr);
+            }
+            Expr::Tuple { exprs } => {
+                for expr in exprs {
+                    f(*expr);
+                }
+            }
+            Expr::Array(a) => match a {
+                Array::ElementList(exprs) => {
+                    for expr in exprs {
+                        f(*expr);
+                    }
+                }
+                Array::Repeat { initializer, repeat } => {
+                    f(*initializer);
+                    f(*repeat)
+                }
+            },
+            Expr::Literal(_) => {}
+        }
+    }
+}
+
+/// Explicit binding annotations given in the HIR for a binding. Note
+/// that this is not the final binding *mode* that we infer after type
+/// inference.
+#[derive(Clone, PartialEq, Eq, Debug, Copy)]
+pub enum BindingAnnotation {
+    /// No binding annotation given: this means that the final binding mode
+    /// will depend on whether we have skipped through a `&` reference
+    /// when matching. For example, the `x` in `Some(x)` will have binding
+    /// mode `None`; if you do `let Some(x) = &Some(22)`, it will
+    /// ultimately be inferred to be by-reference.
+    Unannotated,
+
+    /// Annotated with `mut x` -- could be either ref or not, similar to `None`.
+    Mutable,
+
+    /// Annotated as `ref`, like `ref x`
+    Ref,
+
+    /// Annotated as `ref mut x`.
+    RefMut,
+}
+
+impl BindingAnnotation {
+    pub fn new(is_mutable: bool, is_ref: bool) -> Self {
+        match (is_mutable, is_ref) {
+            (true, true) => BindingAnnotation::RefMut,
+            (false, true) => BindingAnnotation::Ref,
+            (true, false) => BindingAnnotation::Mutable,
+            (false, false) => BindingAnnotation::Unannotated,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct RecordFieldPat {
+    pub name: Name,
+    pub pat: PatId,
+}
+
+/// Close relative to rustc's hir::PatKind
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Pat {
+    Missing,
+    Wild,
+    Tuple { args: Vec<PatId>, ellipsis: Option<usize> },
+    Or(Vec<PatId>),
+    Record { path: Option<Path>, args: Vec<RecordFieldPat>, ellipsis: bool },
+    Range { start: ExprId, end: ExprId },
+    Slice { prefix: Vec<PatId>, slice: Option<PatId>, suffix: Vec<PatId> },
+    Path(Path),
+    Lit(ExprId),
+    Bind { mode: BindingAnnotation, name: Name, subpat: Option<PatId> },
+    TupleStruct { path: Option<Path>, args: Vec<PatId>, ellipsis: Option<usize> },
+    Ref { pat: PatId, mutability: Mutability },
+}
+
+impl Pat {
+    pub fn walk_child_pats(&self, mut f: impl FnMut(PatId)) {
+        match self {
+            Pat::Range { .. } | Pat::Lit(..) | Pat::Path(..) | Pat::Wild | Pat::Missing => {}
+            Pat::Bind { subpat, .. } => {
+                subpat.iter().copied().for_each(f);
+            }
+            Pat::Or(args) | Pat::Tuple { args, .. } | Pat::TupleStruct { args, .. } => {
+                args.iter().copied().for_each(f);
+            }
+            Pat::Ref { pat, .. } => f(*pat),
+            Pat::Slice { prefix, slice, suffix } => {
+                let total_iter = prefix.iter().chain(slice.iter()).chain(suffix.iter());
+                total_iter.copied().for_each(f);
+            }
+            Pat::Record { args, .. } => {
+                args.iter().map(|f| f.pat).for_each(f);
+            }
+        }
+    }
+}
diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs
new file mode 100644
index 000000000..ac2c54ac5
--- /dev/null
+++ b/crates/hir_def/src/find_path.rs
@@ -0,0 +1,687 @@
+//! An algorithm to find a path to refer to a certain item.
+
+use hir_expand::name::{known, AsName, Name};
+use rustc_hash::FxHashSet;
+use test_utils::mark;
+
+use crate::{
+    db::DefDatabase,
+    item_scope::ItemInNs,
+    path::{ModPath, PathKind},
+    visibility::Visibility,
+    ModuleDefId, ModuleId,
+};
+
+// FIXME: handle local items
+
+/// Find a path that can be used to refer to a certain item. This can depend on
+/// *from where* you're referring to the item, hence the `from` parameter.
+pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
+    let _p = profile::span("find_path");
+    find_path_inner(db, item, from, MAX_PATH_LEN)
+}
+
+const MAX_PATH_LEN: usize = 15;
+
+impl ModPath {
+    fn starts_with_std(&self) -> bool {
+        self.segments.first() == Some(&known::std)
+    }
+
+    // When std library is present, paths starting with `std::`
+    // should be preferred over paths starting with `core::` and `alloc::`
+    fn can_start_with_std(&self) -> bool {
+        let first_segment = self.segments.first();
+        first_segment == Some(&known::alloc) || first_segment == Some(&known::core)
+    }
+}
+
+fn find_path_inner(
+    db: &dyn DefDatabase,
+    item: ItemInNs,
+    from: ModuleId,
+    max_len: usize,
+) -> Option<ModPath> {
+    if max_len == 0 {
+        return None;
+    }
+
+    // Base cases:
+
+    // - if the item is already in scope, return the name under which it is
+    let def_map = db.crate_def_map(from.krate);
+    let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope;
+    if let Some((name, _)) = from_scope.name_of(item) {
+        return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
+    }
+
+    // - if the item is the crate root, return `crate`
+    if item
+        == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
+            krate: from.krate,
+            local_id: def_map.root,
+        }))
+    {
+        return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
+    }
+
+    // - if the item is the module we're in, use `self`
+    if item == ItemInNs::Types(from.into()) {
+        return Some(ModPath::from_segments(PathKind::Super(0), Vec::new()));
+    }
+
+    // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
+    if let Some(parent_id) = def_map.modules[from.local_id].parent {
+        if item
+            == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
+                krate: from.krate,
+                local_id: parent_id,
+            }))
+        {
+            return Some(ModPath::from_segments(PathKind::Super(1), Vec::new()));
+        }
+    }
+
+    // - if the item is the crate root of a dependency crate, return the name from the extern prelude
+    for (name, def_id) in &def_map.extern_prelude {
+        if item == ItemInNs::Types(*def_id) {
+            return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
+        }
+    }
+
+    // - if the item is in the prelude, return the name from there
+    if let Some(prelude_module) = def_map.prelude {
+        let prelude_def_map = db.crate_def_map(prelude_module.krate);
+        let prelude_scope: &crate::item_scope::ItemScope =
+            &prelude_def_map.modules[prelude_module.local_id].scope;
+        if let Some((name, vis)) = prelude_scope.name_of(item) {
+            if vis.is_visible_from(db, from) {
+                return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
+            }
+        }
+    }
+
+    // - if the item is a builtin, it's in scope
+    if let ItemInNs::Types(ModuleDefId::BuiltinType(builtin)) = item {
+        return Some(ModPath::from_segments(PathKind::Plain, vec![builtin.as_name()]));
+    }
+
+    // Recursive case:
+    // - if the item is an enum variant, refer to it via the enum
+    if let Some(ModuleDefId::EnumVariantId(variant)) = item.as_module_def_id() {
+        if let Some(mut path) = find_path(db, ItemInNs::Types(variant.parent.into()), from) {
+            let data = db.enum_data(variant.parent);
+            path.segments.push(data.variants[variant.local_id].name.clone());
+            return Some(path);
+        }
+        // If this doesn't work, it seems we have no way of referring to the
+        // enum; that's very weird, but there might still be a reexport of the
+        // variant somewhere
+    }
+
+    // - otherwise, look for modules containing (reexporting) it and import it from one of those
+
+    let crate_root = ModuleId { local_id: def_map.root, krate: from.krate };
+    let crate_attrs = db.attrs(crate_root.into());
+    let prefer_no_std = crate_attrs.by_key("no_std").exists();
+    let mut best_path = None;
+    let mut best_path_len = max_len;
+
+    if item.krate(db) == Some(from.krate) {
+        // Item was defined in the same crate that wants to import it. It cannot be found in any
+        // dependency in this case.
+
+        let local_imports = find_local_import_locations(db, item, from);
+        for (module_id, name) in local_imports {
+            if let Some(mut path) = find_path_inner(
+                db,
+                ItemInNs::Types(ModuleDefId::ModuleId(module_id)),
+                from,
+                best_path_len - 1,
+            ) {
+                path.segments.push(name);
+
+                let new_path = if let Some(best_path) = best_path {
+                    select_best_path(best_path, path, prefer_no_std)
+                } else {
+                    path
+                };
+                best_path_len = new_path.len();
+                best_path = Some(new_path);
+            }
+        }
+    } else {
+        // Item was defined in some upstream crate. This means that it must be exported from one,
+        // too (unless we can't name it at all). It could *also* be (re)exported by the same crate
+        // that wants to import it here, but we always prefer to use the external path here.
+
+        let crate_graph = db.crate_graph();
+        let extern_paths = crate_graph[from.krate].dependencies.iter().filter_map(|dep| {
+            let import_map = db.import_map(dep.crate_id);
+            import_map.import_info_for(item).and_then(|info| {
+                // Determine best path for containing module and append last segment from `info`.
+                let mut path = find_path_inner(
+                    db,
+                    ItemInNs::Types(ModuleDefId::ModuleId(info.container)),
+                    from,
+                    best_path_len - 1,
+                )?;
+                path.segments.push(info.path.segments.last().unwrap().clone());
+                Some(path)
+            })
+        });
+
+        for path in extern_paths {
+            let new_path = if let Some(best_path) = best_path {
+                select_best_path(best_path, path, prefer_no_std)
+            } else {
+                path
+            };
+            best_path = Some(new_path);
+        }
+    }
+
+    best_path
+}
+
+fn select_best_path(old_path: ModPath, new_path: ModPath, prefer_no_std: bool) -> ModPath {
+    if old_path.starts_with_std() && new_path.can_start_with_std() {
+        if prefer_no_std {
+            mark::hit!(prefer_no_std_paths);
+            new_path
+        } else {
+            mark::hit!(prefer_std_paths);
+            old_path
+        }
+    } else if new_path.starts_with_std() && old_path.can_start_with_std() {
+        if prefer_no_std {
+            mark::hit!(prefer_no_std_paths);
+            old_path
+        } else {
+            mark::hit!(prefer_std_paths);
+            new_path
+        }
+    } else if new_path.len() < old_path.len() {
+        new_path
+    } else {
+        old_path
+    }
+}
+
+/// Finds locations in `from.krate` from which `item` can be imported by `from`.
+fn find_local_import_locations(
+    db: &dyn DefDatabase,
+    item: ItemInNs,
+    from: ModuleId,
+) -> Vec<(ModuleId, Name)> {
+    let _p = profile::span("find_local_import_locations");
+
+    // `from` can import anything below `from` with visibility of at least `from`, and anything
+    // above `from` with any visibility. That means we do not need to descend into private siblings
+    // of `from` (and similar).
+
+    let def_map = db.crate_def_map(from.krate);
+
+    // Compute the initial worklist. We start with all direct child modules of `from` as well as all
+    // of its (recursive) parent modules.
+    let data = &def_map.modules[from.local_id];
+    let mut worklist = data
+        .children
+        .values()
+        .map(|child| ModuleId { krate: from.krate, local_id: *child })
+        .collect::<Vec<_>>();
+    let mut parent = data.parent;
+    while let Some(p) = parent {
+        worklist.push(ModuleId { krate: from.krate, local_id: p });
+        parent = def_map.modules[p].parent;
+    }
+
+    let mut seen: FxHashSet<_> = FxHashSet::default();
+
+    let mut locations = Vec::new();
+    while let Some(module) = worklist.pop() {
+        if !seen.insert(module) {
+            continue; // already processed this module
+        }
+
+        let ext_def_map;
+        let data = if module.krate == from.krate {
+            &def_map[module.local_id]
+        } else {
+            // The crate might reexport a module defined in another crate.
+            ext_def_map = db.crate_def_map(module.krate);
+            &ext_def_map[module.local_id]
+        };
+
+        if let Some((name, vis)) = data.scope.name_of(item) {
+            if vis.is_visible_from(db, from) {
+                let is_private = if let Visibility::Module(private_to) = vis {
+                    private_to.local_id == module.local_id
+                } else {
+                    false
+                };
+                let is_original_def = if let Some(module_def_id) = item.as_module_def_id() {
+                    data.scope.declarations().any(|it| it == module_def_id)
+                } else {
+                    false
+                };
+
+                // Ignore private imports. these could be used if we are
+                // in a submodule of this module, but that's usually not
+                // what the user wants; and if this module can import
+                // the item and we're a submodule of it, so can we.
+                // Also this keeps the cached data smaller.
+                if !is_private || is_original_def {
+                    locations.push((module, name.clone()));
+                }
+            }
+        }
+
+        // Descend into all modules visible from `from`.
+        for (_, per_ns) in data.scope.entries() {
+            if let Some((ModuleDefId::ModuleId(module), vis)) = per_ns.take_types_vis() {
+                if vis.is_visible_from(db, from) {
+                    worklist.push(module);
+                }
+            }
+        }
+    }
+
+    locations
+}
+
+#[cfg(test)]
+mod tests {
+    use base_db::fixture::WithFixture;
+    use hir_expand::hygiene::Hygiene;
+    use syntax::ast::AstNode;
+    use test_utils::mark;
+
+    use crate::test_db::TestDB;
+
+    use super::*;
+
+    /// `code` needs to contain a cursor marker; checks that `find_path` for the
+    /// item the `path` refers to returns that same path when called from the
+    /// module the cursor is in.
+    fn check_found_path(ra_fixture: &str, path: &str) {
+        let (db, pos) = TestDB::with_position(ra_fixture);
+        let module = db.module_for_file(pos.file_id);
+        let parsed_path_file = syntax::SourceFile::parse(&format!("use {};", path));
+        let ast_path =
+            parsed_path_file.syntax_node().descendants().find_map(syntax::ast::Path::cast).unwrap();
+        let mod_path = ModPath::from_src(ast_path, &Hygiene::new_unhygienic()).unwrap();
+
+        let crate_def_map = db.crate_def_map(module.krate);
+        let resolved = crate_def_map
+            .resolve_path(
+                &db,
+                module.local_id,
+                &mod_path,
+                crate::item_scope::BuiltinShadowMode::Module,
+            )
+            .0
+            .take_types()
+            .unwrap();
+
+        let found_path = find_path(&db, ItemInNs::Types(resolved), module);
+
+        assert_eq!(found_path, Some(mod_path));
+    }
+
+    #[test]
+    fn same_module() {
+        let code = r#"
+            //- /main.rs
+            struct S;
+            <|>
+        "#;
+        check_found_path(code, "S");
+    }
+
+    #[test]
+    fn enum_variant() {
+        let code = r#"
+            //- /main.rs
+            enum E { A }
+            <|>
+        "#;
+        check_found_path(code, "E::A");
+    }
+
+    #[test]
+    fn sub_module() {
+        let code = r#"
+            //- /main.rs
+            mod foo {
+                pub struct S;
+            }
+            <|>
+        "#;
+        check_found_path(code, "foo::S");
+    }
+
+    #[test]
+    fn super_module() {
+        let code = r#"
+            //- /main.rs
+            mod foo;
+            //- /foo.rs
+            mod bar;
+            struct S;
+            //- /foo/bar.rs
+            <|>
+        "#;
+        check_found_path(code, "super::S");
+    }
+
+    #[test]
+    fn self_module() {
+        let code = r#"
+            //- /main.rs
+            mod foo;
+            //- /foo.rs
+            <|>
+        "#;
+        check_found_path(code, "self");
+    }
+
+    #[test]
+    fn crate_root() {
+        let code = r#"
+            //- /main.rs
+            mod foo;
+            //- /foo.rs
+            <|>
+        "#;
+        check_found_path(code, "crate");
+    }
+
+    #[test]
+    fn same_crate() {
+        let code = r#"
+            //- /main.rs
+            mod foo;
+            struct S;
+            //- /foo.rs
+            <|>
+        "#;
+        check_found_path(code, "crate::S");
+    }
+
+    #[test]
+    fn different_crate() {
+        let code = r#"
+            //- /main.rs crate:main deps:std
+            <|>
+            //- /std.rs crate:std
+            pub struct S;
+        "#;
+        check_found_path(code, "std::S");
+    }
+
+    #[test]
+    fn different_crate_renamed() {
+        let code = r#"
+            //- /main.rs crate:main deps:std
+            extern crate std as std_renamed;
+            <|>
+            //- /std.rs crate:std
+            pub struct S;
+        "#;
+        check_found_path(code, "std_renamed::S");
+    }
+
+    #[test]
+    fn partially_imported() {
+        // Tests that short paths are used even for external items, when parts of the path are
+        // already in scope.
+        check_found_path(
+            r#"
+            //- /main.rs crate:main deps:syntax
+
+            use syntax::ast;
+            <|>
+
+            //- /lib.rs crate:syntax
+            pub mod ast {
+                pub enum ModuleItem {
+                    A, B, C,
+                }
+            }
+        "#,
+            "ast::ModuleItem",
+        );
+
+        check_found_path(
+            r#"
+            //- /main.rs crate:main deps:syntax
+
+            <|>
+
+            //- /lib.rs crate:syntax
+            pub mod ast {
+                pub enum ModuleItem {
+                    A, B, C,
+                }
+            }
+        "#,
+            "syntax::ast::ModuleItem",
+        );
+    }
+
+    #[test]
+    fn same_crate_reexport() {
+        let code = r#"
+            //- /main.rs
+            mod bar {
+                mod foo { pub(super) struct S; }
+                pub(crate) use foo::*;
+            }
+            <|>
+        "#;
+        check_found_path(code, "bar::S");
+    }
+
+    #[test]
+    fn same_crate_reexport_rename() {
+        let code = r#"
+            //- /main.rs
+            mod bar {
+                mod foo { pub(super) struct S; }
+                pub(crate) use foo::S as U;
+            }
+            <|>
+        "#;
+        check_found_path(code, "bar::U");
+    }
+
+    #[test]
+    fn different_crate_reexport() {
+        let code = r#"
+            //- /main.rs crate:main deps:std
+            <|>
+            //- /std.rs crate:std deps:core
+            pub use core::S;
+            //- /core.rs crate:core
+            pub struct S;
+        "#;
+        check_found_path(code, "std::S");
+    }
+
+    #[test]
+    fn prelude() {
+        let code = r#"
+            //- /main.rs crate:main deps:std
+            <|>
+            //- /std.rs crate:std
+            pub mod prelude { pub struct S; }
+            #[prelude_import]
+            pub use prelude::*;
+        "#;
+        check_found_path(code, "S");
+    }
+
+    #[test]
+    fn enum_variant_from_prelude() {
+        let code = r#"
+            //- /main.rs crate:main deps:std
+            <|>
+            //- /std.rs crate:std
+            pub mod prelude {
+                pub enum Option<T> { Some(T), None }
+                pub use Option::*;
+            }
+            #[prelude_import]
+            pub use prelude::*;
+        "#;
+        check_found_path(code, "None");
+        check_found_path(code, "Some");
+    }
+
+    #[test]
+    fn shortest_path() {
+        let code = r#"
+            //- /main.rs
+            pub mod foo;
+            pub mod baz;
+            struct S;
+            <|>
+            //- /foo.rs
+            pub mod bar { pub struct S; }
+            //- /baz.rs
+            pub use crate::foo::bar::S;
+        "#;
+        check_found_path(code, "baz::S");
+    }
+
+    #[test]
+    fn discount_private_imports() {
+        let code = r#"
+            //- /main.rs
+            mod foo;
+            pub mod bar { pub struct S; }
+            use bar::S;
+            //- /foo.rs
+            <|>
+        "#;
+        // crate::S would be shorter, but using private imports seems wrong
+        check_found_path(code, "crate::bar::S");
+    }
+
+    #[test]
+    fn import_cycle() {
+        let code = r#"
+            //- /main.rs
+            pub mod foo;
+            pub mod bar;
+            pub mod baz;
+            //- /bar.rs
+            <|>
+            //- /foo.rs
+            pub use super::baz;
+            pub struct S;
+            //- /baz.rs
+            pub use super::foo;
+        "#;
+        check_found_path(code, "crate::foo::S");
+    }
+
+    #[test]
+    fn prefer_std_paths_over_alloc() {
+        mark::check!(prefer_std_paths);
+        let code = r#"
+        //- /main.rs crate:main deps:alloc,std
+        <|>
+
+        //- /std.rs crate:std deps:alloc
+        pub mod sync {
+            pub use alloc::sync::Arc;
+        }
+
+        //- /zzz.rs crate:alloc
+        pub mod sync {
+            pub struct Arc;
+        }
+        "#;
+        check_found_path(code, "std::sync::Arc");
+    }
+
+    #[test]
+    fn prefer_core_paths_over_std() {
+        mark::check!(prefer_no_std_paths);
+        let code = r#"
+        //- /main.rs crate:main deps:core,std
+        #![no_std]
+
+        <|>
+
+        //- /std.rs crate:std deps:core
+
+        pub mod fmt {
+            pub use core::fmt::Error;
+        }
+
+        //- /zzz.rs crate:core
+
+        pub mod fmt {
+            pub struct Error;
+        }
+        "#;
+        check_found_path(code, "core::fmt::Error");
+    }
+
+    #[test]
+    fn prefer_alloc_paths_over_std() {
+        let code = r#"
+        //- /main.rs crate:main deps:alloc,std
+        #![no_std]
+
+        <|>
+
+        //- /std.rs crate:std deps:alloc
+
+        pub mod sync {
+            pub use alloc::sync::Arc;
+        }
+
+        //- /zzz.rs crate:alloc
+
+        pub mod sync {
+            pub struct Arc;
+        }
+        "#;
+        check_found_path(code, "alloc::sync::Arc");
+    }
+
+    #[test]
+    fn prefer_shorter_paths_if_not_alloc() {
+        let code = r#"
+        //- /main.rs crate:main deps:megaalloc,std
+        <|>
+
+        //- /std.rs crate:std deps:megaalloc
+        pub mod sync {
+            pub use megaalloc::sync::Arc;
+        }
+
+        //- /zzz.rs crate:megaalloc
+        pub struct Arc;
+        "#;
+        check_found_path(code, "megaalloc::Arc");
+    }
+
+    #[test]
+    fn builtins_are_in_scope() {
+        let code = r#"
+        //- /main.rs
+        <|>
+
+        pub mod primitive {
+            pub use u8;
+        }
+        "#;
+        check_found_path(code, "u8");
+        check_found_path(code, "u16");
+    }
+}
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
new file mode 100644
index 000000000..835fe3fbd
--- /dev/null
+++ b/crates/hir_def/src/generics.rs
@@ -0,0 +1,339 @@
+//! Many kinds of items or constructs can have generic parameters: functions,
+//! structs, impls, traits, etc. This module provides a common HIR for these
+//! generic parameters. See also the `Generics` type and the `generics_of` query
+//! in rustc.
+use std::sync::Arc;
+
+use arena::{map::ArenaMap, Arena};
+use base_db::FileId;
+use either::Either;
+use hir_expand::{
+    name::{name, AsName, Name},
+    InFile,
+};
+use syntax::ast::{self, GenericParamsOwner, NameOwner, TypeBoundsOwner};
+
+use crate::{
+    body::LowerCtx,
+    child_by_source::ChildBySource,
+    db::DefDatabase,
+    dyn_map::DynMap,
+    keys,
+    src::HasChildSource,
+    src::HasSource,
+    type_ref::{TypeBound, TypeRef},
+    AdtId, GenericDefId, LocalTypeParamId, Lookup, TypeParamId,
+};
+
+/// Data about a generic parameter (to a function, struct, impl, ...).
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct TypeParamData {
+    pub name: Option<Name>,
+    pub default: Option<TypeRef>,
+    pub provenance: TypeParamProvenance,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum TypeParamProvenance {
+    TypeParamList,
+    TraitSelf,
+    ArgumentImplTrait,
+}
+
+/// Data about the generic parameters of a function, struct, impl, etc.
+#[derive(Clone, PartialEq, Eq, Debug, Default)]
+pub struct GenericParams {
+    pub types: Arena<TypeParamData>,
+    // lifetimes: Arena<LocalLifetimeParamId, LifetimeParamData>,
+    pub where_predicates: Vec<WherePredicate>,
+}
+
+/// A single predicate from a where clause, i.e. `where Type: Trait`. Combined
+/// where clauses like `where T: Foo + Bar` are turned into multiple of these.
+/// It might still result in multiple actual predicates though, because of
+/// associated type bindings like `Iterator<Item = u32>`.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct WherePredicate {
+    pub target: WherePredicateTarget,
+    pub bound: TypeBound,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum WherePredicateTarget {
+    TypeRef(TypeRef),
+    /// For desugared where predicates that can directly refer to a type param.
+    TypeParam(LocalTypeParamId),
+}
+
+type SourceMap = ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>;
+
+impl GenericParams {
+    pub(crate) fn generic_params_query(
+        db: &dyn DefDatabase,
+        def: GenericDefId,
+    ) -> Arc<GenericParams> {
+        let _p = profile::span("generic_params_query");
+
+        let generics = match def {
+            GenericDefId::FunctionId(id) => {
+                let id = id.lookup(db).id;
+                let tree = db.item_tree(id.file_id);
+                let item = &tree[id.value];
+                tree[item.generic_params].clone()
+            }
+            GenericDefId::AdtId(AdtId::StructId(id)) => {
+                let id = id.lookup(db).id;
+                let tree = db.item_tree(id.file_id);
+                let item = &tree[id.value];
+                tree[item.generic_params].clone()
+            }
+            GenericDefId::AdtId(AdtId::EnumId(id)) => {
+                let id = id.lookup(db).id;
+                let tree = db.item_tree(id.file_id);
+                let item = &tree[id.value];
+                tree[item.generic_params].clone()
+            }
+            GenericDefId::AdtId(AdtId::UnionId(id)) => {
+                let id = id.lookup(db).id;
+                let tree = db.item_tree(id.file_id);
+                let item = &tree[id.value];
+                tree[item.generic_params].clone()
+            }
+            GenericDefId::TraitId(id) => {
+                let id = id.lookup(db).id;
+                let tree = db.item_tree(id.file_id);
+                let item = &tree[id.value];
+                tree[item.generic_params].clone()
+            }
+            GenericDefId::TypeAliasId(id) => {
+                let id = id.lookup(db).id;
+                let tree = db.item_tree(id.file_id);
+                let item = &tree[id.value];
+                tree[item.generic_params].clone()
+            }
+            GenericDefId::ImplId(id) => {
+                let id = id.lookup(db).id;
+                let tree = db.item_tree(id.file_id);
+                let item = &tree[id.value];
+                tree[item.generic_params].clone()
+            }
+            GenericDefId::EnumVariantId(_) | GenericDefId::ConstId(_) => GenericParams::default(),
+        };
+        Arc::new(generics)
+    }
+
+    fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMap>) {
+        let mut generics = GenericParams { types: Arena::default(), where_predicates: Vec::new() };
+        let mut sm = ArenaMap::default();
+
+        // FIXME: add `: Sized` bound for everything except for `Self` in traits
+        let file_id = match def {
+            GenericDefId::FunctionId(it) => {
+                let src = it.lookup(db).source(db);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
+                // lower `impl Trait` in arguments
+                let data = db.function_data(it);
+                for param in &data.params {
+                    generics.fill_implicit_impl_trait_args(param);
+                }
+                src.file_id
+            }
+            GenericDefId::AdtId(AdtId::StructId(it)) => {
+                let src = it.lookup(db).source(db);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
+                src.file_id
+            }
+            GenericDefId::AdtId(AdtId::UnionId(it)) => {
+                let src = it.lookup(db).source(db);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
+                src.file_id
+            }
+            GenericDefId::AdtId(AdtId::EnumId(it)) => {
+                let src = it.lookup(db).source(db);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+                generics.fill(&lower_ctx, &mut sm, &src.value);
+                src.file_id
+            }
+            GenericDefId::TraitId(it) => {
+                let src = it.lookup(db).source(db);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+
+                // traits get the Self type as an implicit first type parameter
+                let self_param_id = generics.types.alloc(TypeParamData {
+                    name: Some(name![Self]),
+                    default: None,
+                    provenance: TypeParamProvenance::TraitSelf,
+                });
+                sm.insert(self_param_id, Either::Left(src.value.clone()));
+                // add super traits as bounds on Self
+                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
+                let self_param = TypeRef::Path(name![Self].into());
+                generics.fill_bounds(&lower_ctx, &src.value, self_param);
+
+                generics.fill(&lower_ctx, &mut sm, &src.value);
+                src.file_id
+            }
+            GenericDefId::TypeAliasId(it) => {
+                let src = it.lookup(db).source(db);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+
+                generics.fill(&lower_ctx, &mut sm, &src.value);
+                src.file_id
+            }
+            // Note that we don't add `Self` here: in `impl`s, `Self` is not a
+            // type-parameter, but rather is a type-alias for impl's target
+            // type, so this is handled by the resolver.
+            GenericDefId::ImplId(it) => {
+                let src = it.lookup(db).source(db);
+                let lower_ctx = LowerCtx::new(db, src.file_id);
+
+                generics.fill(&lower_ctx, &mut sm, &src.value);
+                src.file_id
+            }
+            // We won't be using this ID anyway
+            GenericDefId::EnumVariantId(_) | GenericDefId::ConstId(_) => FileId(!0).into(),
+        };
+
+        (generics, InFile::new(file_id, sm))
+    }
+
+    pub(crate) fn fill(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        sm: &mut SourceMap,
+        node: &dyn GenericParamsOwner,
+    ) {
+        if let Some(params) = node.generic_param_list() {
+            self.fill_params(lower_ctx, sm, params)
+        }
+        if let Some(where_clause) = node.where_clause() {
+            self.fill_where_predicates(lower_ctx, where_clause);
+        }
+    }
+
+    pub(crate) fn fill_bounds(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        node: &dyn ast::TypeBoundsOwner,
+        type_ref: TypeRef,
+    ) {
+        for bound in
+            node.type_bound_list().iter().flat_map(|type_bound_list| type_bound_list.bounds())
+        {
+            self.add_where_predicate_from_bound(lower_ctx, bound, type_ref.clone());
+        }
+    }
+
+    fn fill_params(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        sm: &mut SourceMap,
+        params: ast::GenericParamList,
+    ) {
+        for type_param in params.type_params() {
+            let name = type_param.name().map_or_else(Name::missing, |it| it.as_name());
+            // FIXME: Use `Path::from_src`
+            let default = type_param.default_type().map(|it| TypeRef::from_ast(lower_ctx, it));
+            let param = TypeParamData {
+                name: Some(name.clone()),
+                default,
+                provenance: TypeParamProvenance::TypeParamList,
+            };
+            let param_id = self.types.alloc(param);
+            sm.insert(param_id, Either::Right(type_param.clone()));
+
+            let type_ref = TypeRef::Path(name.into());
+            self.fill_bounds(&lower_ctx, &type_param, type_ref);
+        }
+    }
+
+    fn fill_where_predicates(&mut self, lower_ctx: &LowerCtx, where_clause: ast::WhereClause) {
+        for pred in where_clause.predicates() {
+            let type_ref = match pred.ty() {
+                Some(type_ref) => type_ref,
+                None => continue,
+            };
+            let type_ref = TypeRef::from_ast(lower_ctx, type_ref);
+            for bound in pred.type_bound_list().iter().flat_map(|l| l.bounds()) {
+                self.add_where_predicate_from_bound(lower_ctx, bound, type_ref.clone());
+            }
+        }
+    }
+
+    fn add_where_predicate_from_bound(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        bound: ast::TypeBound,
+        type_ref: TypeRef,
+    ) {
+        if bound.question_mark_token().is_some() {
+            // FIXME: remove this bound
+            return;
+        }
+        let bound = TypeBound::from_ast(lower_ctx, bound);
+        self.where_predicates
+            .push(WherePredicate { target: WherePredicateTarget::TypeRef(type_ref), bound });
+    }
+
+    pub(crate) fn fill_implicit_impl_trait_args(&mut self, type_ref: &TypeRef) {
+        type_ref.walk(&mut |type_ref| {
+            if let TypeRef::ImplTrait(bounds) = type_ref {
+                let param = TypeParamData {
+                    name: None,
+                    default: None,
+                    provenance: TypeParamProvenance::ArgumentImplTrait,
+                };
+                let param_id = self.types.alloc(param);
+                for bound in bounds {
+                    self.where_predicates.push(WherePredicate {
+                        target: WherePredicateTarget::TypeParam(param_id),
+                        bound: bound.clone(),
+                    });
+                }
+            }
+        });
+    }
+
+    pub fn find_by_name(&self, name: &Name) -> Option<LocalTypeParamId> {
+        self.types
+            .iter()
+            .find_map(|(id, p)| if p.name.as_ref() == Some(name) { Some(id) } else { None })
+    }
+
+    pub fn find_trait_self_param(&self) -> Option<LocalTypeParamId> {
+        self.types.iter().find_map(|(id, p)| {
+            if p.provenance == TypeParamProvenance::TraitSelf {
+                Some(id)
+            } else {
+                None
+            }
+        })
+    }
+}
+
+impl HasChildSource for GenericDefId {
+    type ChildId = LocalTypeParamId;
+    type Value = Either<ast::Trait, ast::TypeParam>;
+    fn child_source(&self, db: &dyn DefDatabase) -> InFile<SourceMap> {
+        let (_, sm) = GenericParams::new(db, *self);
+        sm
+    }
+}
+
+impl ChildBySource for GenericDefId {
+    fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
+        let mut res = DynMap::default();
+        let arena_map = self.child_source(db);
+        let arena_map = arena_map.as_ref();
+        for (local_id, src) in arena_map.value.iter() {
+            let id = TypeParamId { parent: *self, local_id };
+            if let Either::Right(type_param) = src {
+                res[keys::TYPE_PARAM].insert(arena_map.with_value(type_param.clone()), id)
+            }
+        }
+        res
+    }
+}
diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs
new file mode 100644
index 000000000..d32a0bdaf
--- /dev/null
+++ b/crates/hir_def/src/import_map.rs
@@ -0,0 +1,745 @@
+//! A map of all publicly exported items in a crate.
+
+use std::{cmp::Ordering, fmt, hash::BuildHasherDefault, sync::Arc};
+
+use base_db::CrateId;
+use fst::{self, Streamer};
+use indexmap::{map::Entry, IndexMap};
+use rustc_hash::{FxHashMap, FxHasher};
+use smallvec::SmallVec;
+use syntax::SmolStr;
+
+use crate::{
+    db::DefDatabase,
+    item_scope::ItemInNs,
+    path::{ModPath, PathKind},
+    visibility::Visibility,
+    AssocItemId, ModuleDefId, ModuleId, TraitId,
+};
+
+type FxIndexMap<K, V> = IndexMap<K, V, BuildHasherDefault<FxHasher>>;
+
+/// Item import details stored in the `ImportMap`.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ImportInfo {
+    /// A path that can be used to import the item, relative to the crate's root.
+    pub path: ModPath,
+    /// The module containing this item.
+    pub container: ModuleId,
+}
+
+/// A map from publicly exported items to the path needed to import/name them from a downstream
+/// crate.
+///
+/// Reexports of items are taken into account, ie. if something is exported under multiple
+/// names, the one with the shortest import path will be used.
+///
+/// Note that all paths are relative to the containing crate's root, so the crate name still needs
+/// to be prepended to the `ModPath` before the path is valid.
+#[derive(Default)]
+pub struct ImportMap {
+    map: FxIndexMap<ItemInNs, ImportInfo>,
+
+    /// List of keys stored in `map`, sorted lexicographically by their `ModPath`. Indexed by the
+    /// values returned by running `fst`.
+    ///
+    /// Since a path can refer to multiple items due to namespacing, we store all items with the
+    /// same path right after each other. This allows us to find all items after the FST gives us
+    /// the index of the first one.
+    importables: Vec<ItemInNs>,
+    fst: fst::Map<Vec<u8>>,
+
+    /// Maps names of associated items to the item's ID. Only includes items whose defining trait is
+    /// exported.
+    assoc_map: FxHashMap<SmolStr, SmallVec<[AssocItemId; 1]>>,
+}
+
+impl ImportMap {
+    pub fn import_map_query(db: &dyn DefDatabase, krate: CrateId) -> Arc<Self> {
+        let _p = profile::span("import_map_query");
+        let def_map = db.crate_def_map(krate);
+        let mut import_map = Self::default();
+
+        // We look only into modules that are public(ly reexported), starting with the crate root.
+        let empty = ModPath { kind: PathKind::Plain, segments: vec![] };
+        let root = ModuleId { krate, local_id: def_map.root };
+        let mut worklist = vec![(root, empty)];
+        while let Some((module, mod_path)) = worklist.pop() {
+            let ext_def_map;
+            let mod_data = if module.krate == krate {
+                &def_map[module.local_id]
+            } else {
+                // The crate might reexport a module defined in another crate.
+                ext_def_map = db.crate_def_map(module.krate);
+                &ext_def_map[module.local_id]
+            };
+
+            let visible_items = mod_data.scope.entries().filter_map(|(name, per_ns)| {
+                let per_ns = per_ns.filter_visibility(|vis| vis == Visibility::Public);
+                if per_ns.is_none() {
+                    None
+                } else {
+                    Some((name, per_ns))
+                }
+            });
+
+            for (name, per_ns) in visible_items {
+                let mk_path = || {
+                    let mut path = mod_path.clone();
+                    path.segments.push(name.clone());
+                    path
+                };
+
+                for item in per_ns.iter_items() {
+                    let path = mk_path();
+                    match import_map.map.entry(item) {
+                        Entry::Vacant(entry) => {
+                            entry.insert(ImportInfo { path, container: module });
+                        }
+                        Entry::Occupied(mut entry) => {
+                            // If the new path is shorter, prefer that one.
+                            if path.len() < entry.get().path.len() {
+                                *entry.get_mut() = ImportInfo { path, container: module };
+                            } else {
+                                continue;
+                            }
+                        }
+                    }
+
+                    // If we've just added a path to a module, descend into it. We might traverse
+                    // modules multiple times, but only if the new path to it is shorter than the
+                    // first (else we `continue` above).
+                    if let Some(ModuleDefId::ModuleId(mod_id)) = item.as_module_def_id() {
+                        worklist.push((mod_id, mk_path()));
+                    }
+
+                    // If we've added a path to a trait, add the trait's methods to the method map.
+                    if let Some(ModuleDefId::TraitId(tr)) = item.as_module_def_id() {
+                        import_map.collect_trait_methods(db, tr);
+                    }
+                }
+            }
+        }
+
+        let mut importables = import_map.map.iter().collect::<Vec<_>>();
+
+        importables.sort_by(cmp);
+
+        // Build the FST, taking care not to insert duplicate values.
+
+        let mut builder = fst::MapBuilder::memory();
+        let mut last_batch_start = 0;
+
+        for idx in 0..importables.len() {
+            if let Some(next_item) = importables.get(idx + 1) {
+                if cmp(&importables[last_batch_start], next_item) == Ordering::Equal {
+                    continue;
+                }
+            }
+
+            let start = last_batch_start;
+            last_batch_start = idx + 1;
+
+            let key = fst_path(&importables[start].1.path);
+
+            builder.insert(key, start as u64).unwrap();
+        }
+
+        import_map.fst = fst::Map::new(builder.into_inner().unwrap()).unwrap();
+        import_map.importables = importables.iter().map(|(item, _)| **item).collect();
+
+        Arc::new(import_map)
+    }
+
+    /// Returns the `ModPath` needed to import/mention `item`, relative to this crate's root.
+    pub fn path_of(&self, item: ItemInNs) -> Option<&ModPath> {
+        Some(&self.map.get(&item)?.path)
+    }
+
+    pub fn import_info_for(&self, item: ItemInNs) -> Option<&ImportInfo> {
+        self.map.get(&item)
+    }
+
+    fn collect_trait_methods(&mut self, db: &dyn DefDatabase, tr: TraitId) {
+        let data = db.trait_data(tr);
+        for (name, item) in data.items.iter() {
+            self.assoc_map.entry(name.to_string().into()).or_default().push(*item);
+        }
+    }
+}
+
+impl PartialEq for ImportMap {
+    fn eq(&self, other: &Self) -> bool {
+        // `fst` and `importables` are built from `map`, so we don't need to compare them.
+        self.map == other.map
+    }
+}
+
+impl Eq for ImportMap {}
+
+impl fmt::Debug for ImportMap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut importable_paths: Vec<_> = self
+            .map
+            .iter()
+            .map(|(item, info)| {
+                let ns = match item {
+                    ItemInNs::Types(_) => "t",
+                    ItemInNs::Values(_) => "v",
+                    ItemInNs::Macros(_) => "m",
+                };
+                format!("- {} ({})", info.path, ns)
+            })
+            .collect();
+
+        importable_paths.sort();
+        f.write_str(&importable_paths.join("\n"))
+    }
+}
+
+fn fst_path(path: &ModPath) -> String {
+    let mut s = path.to_string();
+    s.make_ascii_lowercase();
+    s
+}
+
+fn cmp((_, lhs): &(&ItemInNs, &ImportInfo), (_, rhs): &(&ItemInNs, &ImportInfo)) -> Ordering {
+    let lhs_str = fst_path(&lhs.path);
+    let rhs_str = fst_path(&rhs.path);
+    lhs_str.cmp(&rhs_str)
+}
+
+#[derive(Debug)]
+pub struct Query {
+    query: String,
+    lowercased: String,
+    anchor_end: bool,
+    case_sensitive: bool,
+    limit: usize,
+}
+
+impl Query {
+    pub fn new(query: &str) -> Self {
+        Self {
+            lowercased: query.to_lowercase(),
+            query: query.to_string(),
+            anchor_end: false,
+            case_sensitive: false,
+            limit: usize::max_value(),
+        }
+    }
+
+    /// Only returns items whose paths end with the (case-insensitive) query string as their last
+    /// segment.
+    pub fn anchor_end(self) -> Self {
+        Self { anchor_end: true, ..self }
+    }
+
+    /// Limits the returned number of items to `limit`.
+    pub fn limit(self, limit: usize) -> Self {
+        Self { limit, ..self }
+    }
+
+    /// Respect casing of the query string when matching.
+    pub fn case_sensitive(self) -> Self {
+        Self { case_sensitive: true, ..self }
+    }
+}
+
+/// Searches dependencies of `krate` for an importable path matching `query`.
+///
+/// This returns a list of items that could be imported from dependencies of `krate`.
+pub fn search_dependencies<'a>(
+    db: &'a dyn DefDatabase,
+    krate: CrateId,
+    query: Query,
+) -> Vec<ItemInNs> {
+    let _p = profile::span("search_dependencies").detail(|| format!("{:?}", query));
+
+    let graph = db.crate_graph();
+    let import_maps: Vec<_> =
+        graph[krate].dependencies.iter().map(|dep| db.import_map(dep.crate_id)).collect();
+
+    let automaton = fst::automaton::Subsequence::new(&query.lowercased);
+
+    let mut op = fst::map::OpBuilder::new();
+    for map in &import_maps {
+        op = op.add(map.fst.search(&automaton));
+    }
+
+    let mut stream = op.union();
+    let mut res = Vec::new();
+    while let Some((_, indexed_values)) = stream.next() {
+        for indexed_value in indexed_values {
+            let import_map = &import_maps[indexed_value.index];
+            let importables = &import_map.importables[indexed_value.value as usize..];
+
+            // Path shared by the importable items in this group.
+            let path = &import_map.map[&importables[0]].path;
+
+            if query.anchor_end {
+                // Last segment must match query.
+                let last = path.segments.last().unwrap().to_string();
+                if last.to_lowercase() != query.lowercased {
+                    continue;
+                }
+            }
+
+            // Add the items from this `ModPath` group. Those are all subsequent items in
+            // `importables` whose paths match `path`.
+            let iter = importables.iter().copied().take_while(|item| {
+                let item_path = &import_map.map[item].path;
+                fst_path(item_path) == fst_path(path)
+            });
+
+            if query.case_sensitive {
+                // FIXME: This does not do a subsequence match.
+                res.extend(iter.filter(|item| {
+                    let item_path = &import_map.map[item].path;
+                    item_path.to_string().contains(&query.query)
+                }));
+            } else {
+                res.extend(iter);
+            }
+
+            if res.len() >= query.limit {
+                res.truncate(query.limit);
+                return res;
+            }
+        }
+    }
+
+    // Add all exported associated items whose names match the query (exactly).
+    for map in &import_maps {
+        if let Some(v) = map.assoc_map.get(&*query.query) {
+            res.extend(v.iter().map(|&assoc| {
+                ItemInNs::Types(match assoc {
+                    AssocItemId::FunctionId(it) => it.into(),
+                    AssocItemId::ConstId(it) => it.into(),
+                    AssocItemId::TypeAliasId(it) => it.into(),
+                })
+            }));
+        }
+    }
+
+    res
+}
+
+#[cfg(test)]
+mod tests {
+    use base_db::{fixture::WithFixture, SourceDatabase, Upcast};
+    use expect::{expect, Expect};
+
+    use crate::{test_db::TestDB, AssocContainerId, Lookup};
+
+    use super::*;
+
+    fn check_search(ra_fixture: &str, krate_name: &str, query: Query, expect: Expect) {
+        let db = TestDB::with_files(ra_fixture);
+        let crate_graph = db.crate_graph();
+        let krate = crate_graph
+            .iter()
+            .find(|krate| {
+                crate_graph[*krate].display_name.as_ref().map(|n| n.to_string())
+                    == Some(krate_name.to_string())
+            })
+            .unwrap();
+
+        let actual = search_dependencies(db.upcast(), krate, query)
+            .into_iter()
+            .filter_map(|item| {
+                let mark = match item {
+                    ItemInNs::Types(_) => "t",
+                    ItemInNs::Values(_) => "v",
+                    ItemInNs::Macros(_) => "m",
+                };
+                let item = assoc_to_trait(&db, item);
+                item.krate(db.upcast()).map(|krate| {
+                    let map = db.import_map(krate);
+                    let path = map.path_of(item).unwrap();
+                    format!(
+                        "{}::{} ({})\n",
+                        crate_graph[krate].display_name.as_ref().unwrap(),
+                        path,
+                        mark
+                    )
+                })
+            })
+            .collect::<String>();
+        expect.assert_eq(&actual)
+    }
+
+    fn assoc_to_trait(db: &dyn DefDatabase, item: ItemInNs) -> ItemInNs {
+        let assoc: AssocItemId = match item {
+            ItemInNs::Types(it) | ItemInNs::Values(it) => match it {
+                ModuleDefId::TypeAliasId(it) => it.into(),
+                ModuleDefId::FunctionId(it) => it.into(),
+                ModuleDefId::ConstId(it) => it.into(),
+                _ => return item,
+            },
+            _ => return item,
+        };
+
+        let container = match assoc {
+            AssocItemId::FunctionId(it) => it.lookup(db).container,
+            AssocItemId::ConstId(it) => it.lookup(db).container,
+            AssocItemId::TypeAliasId(it) => it.lookup(db).container,
+        };
+
+        match container {
+            AssocContainerId::TraitId(it) => ItemInNs::Types(it.into()),
+            _ => item,
+        }
+    }
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let db = TestDB::with_files(ra_fixture);
+        let crate_graph = db.crate_graph();
+
+        let actual = crate_graph
+            .iter()
+            .filter_map(|krate| {
+                let cdata = &crate_graph[krate];
+                let name = cdata.display_name.as_ref()?;
+
+                let map = db.import_map(krate);
+
+                Some(format!("{}:\n{:?}\n", name, map))
+            })
+            .collect::<String>();
+
+        expect.assert_eq(&actual)
+    }
+
+    #[test]
+    fn smoke() {
+        check(
+            r"
+            //- /main.rs crate:main deps:lib
+
+            mod private {
+                pub use lib::Pub;
+                pub struct InPrivateModule;
+            }
+
+            pub mod publ1 {
+                use lib::Pub;
+            }
+
+            pub mod real_pub {
+                pub use lib::Pub;
+            }
+            pub mod real_pu2 { // same path length as above
+                pub use lib::Pub;
+            }
+
+            //- /lib.rs crate:lib
+            pub struct Pub {}
+            pub struct Pub2; // t + v
+            struct Priv;
+        ",
+            expect![[r#"
+                main:
+                - publ1 (t)
+                - real_pu2 (t)
+                - real_pub (t)
+                - real_pub::Pub (t)
+                lib:
+                - Pub (t)
+                - Pub2 (t)
+                - Pub2 (v)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn prefers_shortest_path() {
+        check(
+            r"
+            //- /main.rs crate:main
+
+            pub mod sub {
+                pub mod subsub {
+                    pub struct Def {}
+                }
+
+                pub use super::sub::subsub::Def;
+            }
+        ",
+            expect![[r#"
+                main:
+                - sub (t)
+                - sub::Def (t)
+                - sub::subsub (t)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn type_reexport_cross_crate() {
+        // Reexports need to be visible from a crate, even if the original crate exports the item
+        // at a shorter path.
+        check(
+            r"
+            //- /main.rs crate:main deps:lib
+            pub mod m {
+                pub use lib::S;
+            }
+            //- /lib.rs crate:lib
+            pub struct S;
+        ",
+            expect![[r#"
+                main:
+                - m (t)
+                - m::S (t)
+                - m::S (v)
+                lib:
+                - S (t)
+                - S (v)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn macro_reexport() {
+        check(
+            r"
+            //- /main.rs crate:main deps:lib
+            pub mod m {
+                pub use lib::pub_macro;
+            }
+            //- /lib.rs crate:lib
+            #[macro_export]
+            macro_rules! pub_macro {
+                () => {};
+            }
+        ",
+            expect![[r#"
+                main:
+                - m (t)
+                - m::pub_macro (m)
+                lib:
+                - pub_macro (m)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn module_reexport() {
+        // Reexporting modules from a dependency adds all contents to the import map.
+        check(
+            r"
+            //- /main.rs crate:main deps:lib
+            pub use lib::module as reexported_module;
+            //- /lib.rs crate:lib
+            pub mod module {
+                pub struct S;
+            }
+        ",
+            expect![[r#"
+                main:
+                - reexported_module (t)
+                - reexported_module::S (t)
+                - reexported_module::S (v)
+                lib:
+                - module (t)
+                - module::S (t)
+                - module::S (v)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn cyclic_module_reexport() {
+        // A cyclic reexport does not hang.
+        check(
+            r"
+            //- /lib.rs crate:lib
+            pub mod module {
+                pub struct S;
+                pub use super::sub::*;
+            }
+
+            pub mod sub {
+                pub use super::module;
+            }
+        ",
+            expect![[r#"
+                lib:
+                - module (t)
+                - module::S (t)
+                - module::S (v)
+                - sub (t)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn private_macro() {
+        check(
+            r"
+            //- /lib.rs crate:lib
+            macro_rules! private_macro {
+                () => {};
+            }
+        ",
+            expect![[r#"
+                lib:
+
+            "#]],
+        );
+    }
+
+    #[test]
+    fn namespacing() {
+        check(
+            r"
+            //- /lib.rs crate:lib
+            pub struct Thing;     // t + v
+            #[macro_export]
+            macro_rules! Thing {  // m
+                () => {};
+            }
+        ",
+            expect![[r#"
+                lib:
+                - Thing (m)
+                - Thing (t)
+                - Thing (v)
+            "#]],
+        );
+
+        check(
+            r"
+            //- /lib.rs crate:lib
+            pub mod Thing {}      // t
+            #[macro_export]
+            macro_rules! Thing {  // m
+                () => {};
+            }
+        ",
+            expect![[r#"
+                lib:
+                - Thing (m)
+                - Thing (t)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn search() {
+        let ra_fixture = r#"
+            //- /main.rs crate:main deps:dep
+            //- /dep.rs crate:dep deps:tdep
+            use tdep::fmt as fmt_dep;
+            pub mod fmt {
+                pub trait Display {
+                    fn fmt();
+                }
+            }
+            #[macro_export]
+            macro_rules! Fmt {
+                () => {};
+            }
+            pub struct Fmt;
+
+            pub fn format() {}
+            pub fn no() {}
+
+            //- /tdep.rs crate:tdep
+            pub mod fmt {
+                pub struct NotImportableFromMain;
+            }
+        "#;
+
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt"),
+            expect![[r#"
+                dep::fmt (t)
+                dep::Fmt (t)
+                dep::Fmt (v)
+                dep::Fmt (m)
+                dep::fmt::Display (t)
+                dep::format (v)
+                dep::fmt::Display (t)
+            "#]],
+        );
+
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("fmt").anchor_end(),
+            expect![[r#"
+                dep::fmt (t)
+                dep::Fmt (t)
+                dep::Fmt (v)
+                dep::Fmt (m)
+                dep::fmt::Display (t)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn search_casing() {
+        let ra_fixture = r#"
+            //- /main.rs crate:main deps:dep
+            //- /dep.rs crate:dep
+
+            pub struct fmt;
+            pub struct FMT;
+        "#;
+
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("FMT"),
+            expect![[r#"
+                dep::fmt (t)
+                dep::fmt (v)
+                dep::FMT (t)
+                dep::FMT (v)
+            "#]],
+        );
+
+        check_search(
+            ra_fixture,
+            "main",
+            Query::new("FMT").case_sensitive(),
+            expect![[r#"
+                dep::FMT (t)
+                dep::FMT (v)
+            "#]],
+        );
+    }
+
+    #[test]
+    fn search_limit() {
+        check_search(
+            r#"
+        //- /main.rs crate:main deps:dep
+        //- /dep.rs crate:dep
+        pub mod fmt {
+            pub trait Display {
+                fn fmt();
+            }
+        }
+        #[macro_export]
+        macro_rules! Fmt {
+            () => {};
+        }
+        pub struct Fmt;
+
+        pub fn format() {}
+        pub fn no() {}
+    "#,
+            "main",
+            Query::new("").limit(2),
+            expect![[r#"
+                dep::fmt (t)
+                dep::Fmt (t)
+            "#]],
+        );
+    }
+}
diff --git a/crates/hir_def/src/item_scope.rs b/crates/hir_def/src/item_scope.rs
new file mode 100644
index 000000000..f1e9dfd5b
--- /dev/null
+++ b/crates/hir_def/src/item_scope.rs
@@ -0,0 +1,341 @@
+//! Describes items defined or visible (ie, imported) in a certain scope.
+//! This is shared between modules and blocks.
+
+use std::collections::hash_map::Entry;
+
+use base_db::CrateId;
+use hir_expand::name::Name;
+use once_cell::sync::Lazy;
+use rustc_hash::{FxHashMap, FxHashSet};
+use test_utils::mark;
+
+use crate::{
+    db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, HasModule, ImplId,
+    LocalModuleId, Lookup, MacroDefId, ModuleDefId, TraitId,
+};
+
+#[derive(Copy, Clone)]
+pub(crate) enum ImportType {
+    Glob,
+    Named,
+}
+
+#[derive(Debug, Default)]
+pub struct PerNsGlobImports {
+    types: FxHashSet<(LocalModuleId, Name)>,
+    values: FxHashSet<(LocalModuleId, Name)>,
+    macros: FxHashSet<(LocalModuleId, Name)>,
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct ItemScope {
+    types: FxHashMap<Name, (ModuleDefId, Visibility)>,
+    values: FxHashMap<Name, (ModuleDefId, Visibility)>,
+    macros: FxHashMap<Name, (MacroDefId, Visibility)>,
+    unresolved: FxHashSet<Name>,
+
+    defs: Vec<ModuleDefId>,
+    impls: Vec<ImplId>,
+    /// Traits imported via `use Trait as _;`.
+    unnamed_trait_imports: FxHashMap<TraitId, Visibility>,
+    /// Macros visible in current module in legacy textual scope
+    ///
+    /// For macros invoked by an unqualified identifier like `bar!()`, `legacy_macros` will be searched in first.
+    /// If it yields no result, then it turns to module scoped `macros`.
+    /// It macros with name qualified with a path like `crate::foo::bar!()`, `legacy_macros` will be skipped,
+    /// and only normal scoped `macros` will be searched in.
+    ///
+    /// Note that this automatically inherit macros defined textually before the definition of module itself.
+    ///
+    /// Module scoped macros will be inserted into `items` instead of here.
+    // FIXME: Macro shadowing in one module is not properly handled. Non-item place macros will
+    // be all resolved to the last one defined if shadowing happens.
+    legacy_macros: FxHashMap<Name, MacroDefId>,
+}
+
+pub(crate) static BUILTIN_SCOPE: Lazy<FxHashMap<Name, PerNs>> = Lazy::new(|| {
+    BuiltinType::ALL
+        .iter()
+        .map(|(name, ty)| (name.clone(), PerNs::types(ty.clone().into(), Visibility::Public)))
+        .collect()
+});
+
+/// Shadow mode for builtin type which can be shadowed by module.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub(crate) enum BuiltinShadowMode {
+    /// Prefer user-defined modules (or other types) over builtins.
+    Module,
+    /// Prefer builtins over user-defined modules (but not other types).
+    Other,
+}
+
+/// Legacy macros can only be accessed through special methods like `get_legacy_macros`.
+/// Other methods will only resolve values, types and module scoped macros only.
+impl ItemScope {
+    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a Name, PerNs)> + 'a {
+        // FIXME: shadowing
+        let keys: FxHashSet<_> = self
+            .types
+            .keys()
+            .chain(self.values.keys())
+            .chain(self.macros.keys())
+            .chain(self.unresolved.iter())
+            .collect();
+
+        keys.into_iter().map(move |name| (name, self.get(name)))
+    }
+
+    pub fn declarations(&self) -> impl Iterator<Item = ModuleDefId> + '_ {
+        self.defs.iter().copied()
+    }
+
+    pub fn impls(&self) -> impl Iterator<Item = ImplId> + ExactSizeIterator + '_ {
+        self.impls.iter().copied()
+    }
+
+    pub fn visibility_of(&self, def: ModuleDefId) -> Option<Visibility> {
+        self.name_of(ItemInNs::Types(def))
+            .or_else(|| self.name_of(ItemInNs::Values(def)))
+            .map(|(_, v)| v)
+    }
+
+    /// 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_)))
+    }
+
+    /// Iterate over all legacy textual scoped macros visible at the end of the module
+    pub(crate) fn legacy_macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
+        self.legacy_macros.iter().map(|(name, def)| (name, *def))
+    }
+
+    /// Get a name from current module scope, legacy macros are not included
+    pub(crate) fn get(&self, name: &Name) -> PerNs {
+        PerNs {
+            types: self.types.get(name).copied(),
+            values: self.values.get(name).copied(),
+            macros: self.macros.get(name).copied(),
+        }
+    }
+
+    pub(crate) fn name_of(&self, item: ItemInNs) -> Option<(&Name, Visibility)> {
+        for (name, per_ns) in self.entries() {
+            if let Some(vis) = item.match_with(per_ns) {
+                return Some((name, vis));
+            }
+        }
+        None
+    }
+
+    pub(crate) fn traits<'a>(&'a self) -> impl Iterator<Item = TraitId> + 'a {
+        self.types
+            .values()
+            .filter_map(|(def, _)| match def {
+                ModuleDefId::TraitId(t) => Some(*t),
+                _ => None,
+            })
+            .chain(self.unnamed_trait_imports.keys().copied())
+    }
+
+    pub(crate) fn define_def(&mut self, def: ModuleDefId) {
+        self.defs.push(def)
+    }
+
+    pub(crate) fn get_legacy_macro(&self, name: &Name) -> Option<MacroDefId> {
+        self.legacy_macros.get(name).copied()
+    }
+
+    pub(crate) fn define_impl(&mut self, imp: ImplId) {
+        self.impls.push(imp)
+    }
+
+    pub(crate) fn define_legacy_macro(&mut self, name: Name, mac: MacroDefId) {
+        self.legacy_macros.insert(name, mac);
+    }
+
+    pub(crate) fn unnamed_trait_vis(&self, tr: TraitId) -> Option<Visibility> {
+        self.unnamed_trait_imports.get(&tr).copied()
+    }
+
+    pub(crate) fn push_unnamed_trait(&mut self, tr: TraitId, vis: Visibility) {
+        self.unnamed_trait_imports.insert(tr, vis);
+    }
+
+    pub(crate) fn push_res(&mut self, name: Name, def: PerNs) -> bool {
+        let mut changed = false;
+
+        if let Some(types) = def.types {
+            self.types.entry(name.clone()).or_insert_with(|| {
+                changed = true;
+                types
+            });
+        }
+        if let Some(values) = def.values {
+            self.values.entry(name.clone()).or_insert_with(|| {
+                changed = true;
+                values
+            });
+        }
+        if let Some(macros) = def.macros {
+            self.macros.entry(name.clone()).or_insert_with(|| {
+                changed = true;
+                macros
+            });
+        }
+
+        if def.is_none() {
+            if self.unresolved.insert(name) {
+                changed = true;
+            }
+        }
+
+        changed
+    }
+
+    pub(crate) fn push_res_with_import(
+        &mut self,
+        glob_imports: &mut PerNsGlobImports,
+        lookup: (LocalModuleId, Name),
+        def: PerNs,
+        def_import_type: ImportType,
+    ) -> bool {
+        let mut changed = false;
+
+        macro_rules! check_changed {
+            (
+                $changed:ident,
+                ( $this:ident / $def:ident ) . $field:ident,
+                $glob_imports:ident [ $lookup:ident ],
+                $def_import_type:ident
+            ) => {{
+                let existing = $this.$field.entry($lookup.1.clone());
+                match (existing, $def.$field) {
+                    (Entry::Vacant(entry), Some(_)) => {
+                        match $def_import_type {
+                            ImportType::Glob => {
+                                $glob_imports.$field.insert($lookup.clone());
+                            }
+                            ImportType::Named => {
+                                $glob_imports.$field.remove(&$lookup);
+                            }
+                        }
+
+                        if let Some(fld) = $def.$field {
+                            entry.insert(fld);
+                        }
+                        $changed = true;
+                    }
+                    (Entry::Occupied(mut entry), Some(_))
+                        if $glob_imports.$field.contains(&$lookup)
+                            && matches!($def_import_type, ImportType::Named) =>
+                    {
+                        mark::hit!(import_shadowed);
+                        $glob_imports.$field.remove(&$lookup);
+                        if let Some(fld) = $def.$field {
+                            entry.insert(fld);
+                        }
+                        $changed = true;
+                    }
+                    _ => {}
+                }
+            }};
+        }
+
+        check_changed!(changed, (self / def).types, glob_imports[lookup], def_import_type);
+        check_changed!(changed, (self / def).values, glob_imports[lookup], def_import_type);
+        check_changed!(changed, (self / def).macros, glob_imports[lookup], def_import_type);
+
+        if def.is_none() {
+            if self.unresolved.insert(lookup.1) {
+                changed = true;
+            }
+        }
+
+        changed
+    }
+
+    pub(crate) fn resolutions<'a>(&'a self) -> impl Iterator<Item = (Option<Name>, PerNs)> + 'a {
+        self.entries().map(|(name, res)| (Some(name.clone()), res)).chain(
+            self.unnamed_trait_imports
+                .iter()
+                .map(|(tr, vis)| (None, PerNs::types(ModuleDefId::TraitId(*tr), *vis))),
+        )
+    }
+
+    pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, MacroDefId> {
+        self.legacy_macros.clone()
+    }
+}
+
+impl PerNs {
+    pub(crate) fn from_def(def: ModuleDefId, v: Visibility, has_constructor: bool) -> PerNs {
+        match def {
+            ModuleDefId::ModuleId(_) => PerNs::types(def, v),
+            ModuleDefId::FunctionId(_) => PerNs::values(def, v),
+            ModuleDefId::AdtId(adt) => match adt {
+                AdtId::UnionId(_) => PerNs::types(def, v),
+                AdtId::EnumId(_) => PerNs::types(def, v),
+                AdtId::StructId(_) => {
+                    if has_constructor {
+                        PerNs::both(def, def, v)
+                    } else {
+                        PerNs::types(def, v)
+                    }
+                }
+            },
+            ModuleDefId::EnumVariantId(_) => PerNs::both(def, def, v),
+            ModuleDefId::ConstId(_) | ModuleDefId::StaticId(_) => PerNs::values(def, v),
+            ModuleDefId::TraitId(_) => PerNs::types(def, v),
+            ModuleDefId::TypeAliasId(_) => PerNs::types(def, v),
+            ModuleDefId::BuiltinType(_) => PerNs::types(def, v),
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+pub enum ItemInNs {
+    Types(ModuleDefId),
+    Values(ModuleDefId),
+    Macros(MacroDefId),
+}
+
+impl ItemInNs {
+    fn match_with(self, per_ns: PerNs) -> Option<Visibility> {
+        match self {
+            ItemInNs::Types(def) => {
+                per_ns.types.filter(|(other_def, _)| *other_def == def).map(|(_, vis)| vis)
+            }
+            ItemInNs::Values(def) => {
+                per_ns.values.filter(|(other_def, _)| *other_def == def).map(|(_, vis)| vis)
+            }
+            ItemInNs::Macros(def) => {
+                per_ns.macros.filter(|(other_def, _)| *other_def == def).map(|(_, vis)| vis)
+            }
+        }
+    }
+
+    pub fn as_module_def_id(self) -> Option<ModuleDefId> {
+        match self {
+            ItemInNs::Types(id) | ItemInNs::Values(id) => Some(id),
+            ItemInNs::Macros(_) => None,
+        }
+    }
+
+    /// Returns the crate defining this item (or `None` if `self` is built-in).
+    pub fn krate(&self, db: &dyn DefDatabase) -> Option<CrateId> {
+        Some(match self {
+            ItemInNs::Types(did) | ItemInNs::Values(did) => match did {
+                ModuleDefId::ModuleId(id) => id.krate,
+                ModuleDefId::FunctionId(id) => id.lookup(db).module(db).krate,
+                ModuleDefId::AdtId(id) => id.module(db).krate,
+                ModuleDefId::EnumVariantId(id) => id.parent.lookup(db).container.module(db).krate,
+                ModuleDefId::ConstId(id) => id.lookup(db).container.module(db).krate,
+                ModuleDefId::StaticId(id) => id.lookup(db).container.module(db).krate,
+                ModuleDefId::TraitId(id) => id.lookup(db).container.module(db).krate,
+                ModuleDefId::TypeAliasId(id) => id.lookup(db).module(db).krate,
+                ModuleDefId::BuiltinType(_) => return None,
+            },
+            ItemInNs::Macros(id) => return id.krate,
+        })
+    }
+}
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
new file mode 100644
index 000000000..e14722cae
--- /dev/null
+++ b/crates/hir_def/src/item_tree.rs
@@ -0,0 +1,754 @@
+//! A simplified AST that only contains items.
+
+mod lower;
+#[cfg(test)]
+mod tests;
+
+use std::{
+    any::type_name,
+    fmt::{self, Debug},
+    hash::{Hash, Hasher},
+    marker::PhantomData,
+    ops::{Index, Range},
+    sync::Arc,
+};
+
+use arena::{Arena, Idx, RawId};
+use ast::{AstNode, AttrsOwner, NameOwner, StructKind};
+use either::Either;
+use hir_expand::{
+    ast_id_map::FileAstId,
+    hygiene::Hygiene,
+    name::{name, AsName, Name},
+    HirFileId, InFile,
+};
+use rustc_hash::FxHashMap;
+use smallvec::SmallVec;
+use syntax::{ast, match_ast};
+use test_utils::mark;
+
+use crate::{
+    attr::Attrs,
+    db::DefDatabase,
+    generics::GenericParams,
+    path::{path, AssociatedTypeBinding, GenericArgs, ImportAlias, ModPath, Path, PathKind},
+    type_ref::{Mutability, TypeBound, TypeRef},
+    visibility::RawVisibility,
+};
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub struct RawVisibilityId(u32);
+
+impl RawVisibilityId {
+    pub const PUB: Self = RawVisibilityId(u32::max_value());
+    pub const PRIV: Self = RawVisibilityId(u32::max_value() - 1);
+    pub const PUB_CRATE: Self = RawVisibilityId(u32::max_value() - 2);
+}
+
+impl fmt::Debug for RawVisibilityId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut f = f.debug_tuple("RawVisibilityId");
+        match *self {
+            Self::PUB => f.field(&"pub"),
+            Self::PRIV => f.field(&"pub(self)"),
+            Self::PUB_CRATE => f.field(&"pub(crate)"),
+            _ => f.field(&self.0),
+        };
+        f.finish()
+    }
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct GenericParamsId(u32);
+
+impl GenericParamsId {
+    pub const EMPTY: Self = GenericParamsId(u32::max_value());
+}
+
+/// The item tree of a source file.
+#[derive(Debug, Eq, PartialEq)]
+pub struct ItemTree {
+    top_level: SmallVec<[ModItem; 1]>,
+    attrs: FxHashMap<AttrOwner, Attrs>,
+    inner_items: FxHashMap<FileAstId<ast::Item>, SmallVec<[ModItem; 1]>>,
+
+    data: Option<Box<ItemTreeData>>,
+}
+
+impl ItemTree {
+    pub fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
+        let _p = profile::span("item_tree_query").detail(|| format!("{:?}", file_id));
+        let syntax = if let Some(node) = db.parse_or_expand(file_id) {
+            node
+        } else {
+            return Arc::new(Self::empty());
+        };
+
+        let hygiene = Hygiene::new(db.upcast(), file_id);
+        let ctx = lower::Ctx::new(db, hygiene.clone(), file_id);
+        let mut top_attrs = None;
+        let mut item_tree = match_ast! {
+            match syntax {
+                ast::SourceFile(file) => {
+                    top_attrs = Some(Attrs::new(&file, &hygiene));
+                    ctx.lower_module_items(&file)
+                },
+                ast::MacroItems(items) => {
+                    ctx.lower_module_items(&items)
+                },
+                // Macros can expand to expressions. We return an empty item tree in this case, but
+                // still need to collect inner items.
+                ast::Expr(e) => {
+                    ctx.lower_inner_items(e.syntax())
+                },
+                _ => {
+                    panic!("cannot create item tree from {:?}", syntax);
+                },
+            }
+        };
+
+        if let Some(attrs) = top_attrs {
+            item_tree.attrs.insert(AttrOwner::TopLevel, attrs);
+        }
+        item_tree.shrink_to_fit();
+        Arc::new(item_tree)
+    }
+
+    fn empty() -> Self {
+        Self {
+            top_level: Default::default(),
+            attrs: Default::default(),
+            inner_items: Default::default(),
+            data: Default::default(),
+        }
+    }
+
+    fn shrink_to_fit(&mut self) {
+        if let Some(data) = &mut self.data {
+            let ItemTreeData {
+                imports,
+                extern_crates,
+                functions,
+                structs,
+                fields,
+                unions,
+                enums,
+                variants,
+                consts,
+                statics,
+                traits,
+                impls,
+                type_aliases,
+                mods,
+                macro_calls,
+                exprs,
+                vis,
+                generics,
+            } = &mut **data;
+
+            imports.shrink_to_fit();
+            extern_crates.shrink_to_fit();
+            functions.shrink_to_fit();
+            structs.shrink_to_fit();
+            fields.shrink_to_fit();
+            unions.shrink_to_fit();
+            enums.shrink_to_fit();
+            variants.shrink_to_fit();
+            consts.shrink_to_fit();
+            statics.shrink_to_fit();
+            traits.shrink_to_fit();
+            impls.shrink_to_fit();
+            type_aliases.shrink_to_fit();
+            mods.shrink_to_fit();
+            macro_calls.shrink_to_fit();
+            exprs.shrink_to_fit();
+
+            vis.arena.shrink_to_fit();
+            generics.arena.shrink_to_fit();
+        }
+    }
+
+    /// Returns an iterator over all items located at the top level of the `HirFileId` this
+    /// `ItemTree` was created from.
+    pub fn top_level_items(&self) -> &[ModItem] {
+        &self.top_level
+    }
+
+    /// Returns the inner attributes of the source file.
+    pub fn top_level_attrs(&self) -> &Attrs {
+        self.attrs.get(&AttrOwner::TopLevel).unwrap_or(&Attrs::EMPTY)
+    }
+
+    pub fn attrs(&self, of: AttrOwner) -> &Attrs {
+        self.attrs.get(&of).unwrap_or(&Attrs::EMPTY)
+    }
+
+    /// Returns the lowered inner items that `ast` corresponds to.
+    ///
+    /// Most AST items are lowered to a single `ModItem`, but some (eg. `use` items) may be lowered
+    /// to multiple items in the `ItemTree`.
+    pub fn inner_items(&self, ast: FileAstId<ast::Item>) -> &[ModItem] {
+        &self.inner_items[&ast]
+    }
+
+    pub fn all_inner_items(&self) -> impl Iterator<Item = ModItem> + '_ {
+        self.inner_items.values().flatten().copied()
+    }
+
+    pub fn source<S: ItemTreeNode>(&self, db: &dyn DefDatabase, of: ItemTreeId<S>) -> S::Source {
+        // This unwrap cannot fail, since it has either succeeded above, or resulted in an empty
+        // ItemTree (in which case there is no valid `FileItemTreeId` to call this method with).
+        let root =
+            db.parse_or_expand(of.file_id).expect("parse_or_expand failed on constructed ItemTree");
+
+        let id = self[of.value].ast_id();
+        let map = db.ast_id_map(of.file_id);
+        let ptr = map.get(id);
+        ptr.to_node(&root)
+    }
+
+    fn data(&self) -> &ItemTreeData {
+        self.data.as_ref().expect("attempted to access data of empty ItemTree")
+    }
+
+    fn data_mut(&mut self) -> &mut ItemTreeData {
+        self.data.get_or_insert_with(Box::default)
+    }
+}
+
+#[derive(Default, Debug, Eq, PartialEq)]
+struct ItemVisibilities {
+    arena: Arena<RawVisibility>,
+}
+
+impl ItemVisibilities {
+    fn alloc(&mut self, vis: RawVisibility) -> RawVisibilityId {
+        match &vis {
+            RawVisibility::Public => RawVisibilityId::PUB,
+            RawVisibility::Module(path) if path.segments.is_empty() => match &path.kind {
+                PathKind::Super(0) => RawVisibilityId::PRIV,
+                PathKind::Crate => RawVisibilityId::PUB_CRATE,
+                _ => RawVisibilityId(self.arena.alloc(vis).into_raw().into()),
+            },
+            _ => RawVisibilityId(self.arena.alloc(vis).into_raw().into()),
+        }
+    }
+}
+
+static VIS_PUB: RawVisibility = RawVisibility::Public;
+static VIS_PRIV: RawVisibility =
+    RawVisibility::Module(ModPath { kind: PathKind::Super(0), segments: Vec::new() });
+static VIS_PUB_CRATE: RawVisibility =
+    RawVisibility::Module(ModPath { kind: PathKind::Crate, segments: Vec::new() });
+
+#[derive(Default, Debug, Eq, PartialEq)]
+struct GenericParamsStorage {
+    arena: Arena<GenericParams>,
+}
+
+impl GenericParamsStorage {
+    fn alloc(&mut self, params: GenericParams) -> GenericParamsId {
+        if params.types.is_empty() && params.where_predicates.is_empty() {
+            return GenericParamsId::EMPTY;
+        }
+
+        GenericParamsId(self.arena.alloc(params).into_raw().into())
+    }
+}
+
+static EMPTY_GENERICS: GenericParams =
+    GenericParams { types: Arena::new(), where_predicates: Vec::new() };
+
+#[derive(Default, Debug, Eq, PartialEq)]
+struct ItemTreeData {
+    imports: Arena<Import>,
+    extern_crates: Arena<ExternCrate>,
+    functions: Arena<Function>,
+    structs: Arena<Struct>,
+    fields: Arena<Field>,
+    unions: Arena<Union>,
+    enums: Arena<Enum>,
+    variants: Arena<Variant>,
+    consts: Arena<Const>,
+    statics: Arena<Static>,
+    traits: Arena<Trait>,
+    impls: Arena<Impl>,
+    type_aliases: Arena<TypeAlias>,
+    mods: Arena<Mod>,
+    macro_calls: Arena<MacroCall>,
+    exprs: Arena<Expr>,
+
+    vis: ItemVisibilities,
+    generics: GenericParamsStorage,
+}
+
+#[derive(Debug, Eq, PartialEq, Hash)]
+pub enum AttrOwner {
+    /// Attributes on an item.
+    ModItem(ModItem),
+    /// Inner attributes of the source file.
+    TopLevel,
+
+    Variant(Idx<Variant>),
+    Field(Idx<Field>),
+    // FIXME: Store variant and field attrs, and stop reparsing them in `attrs_query`.
+}
+
+macro_rules! from_attrs {
+    ( $( $var:ident($t:ty) ),+ ) => {
+        $(
+            impl From<$t> for AttrOwner {
+                fn from(t: $t) -> AttrOwner {
+                    AttrOwner::$var(t)
+                }
+            }
+        )+
+    };
+}
+
+from_attrs!(ModItem(ModItem), Variant(Idx<Variant>), Field(Idx<Field>));
+
+/// Trait implemented by all item nodes in the item tree.
+pub trait ItemTreeNode: Clone {
+    type Source: AstNode + Into<ast::Item>;
+
+    fn ast_id(&self) -> FileAstId<Self::Source>;
+
+    /// Looks up an instance of `Self` in an item tree.
+    fn lookup(tree: &ItemTree, index: Idx<Self>) -> &Self;
+
+    /// Downcasts a `ModItem` to a `FileItemTreeId` specific to this type.
+    fn id_from_mod_item(mod_item: ModItem) -> Option<FileItemTreeId<Self>>;
+
+    /// Upcasts a `FileItemTreeId` to a generic `ModItem`.
+    fn id_to_mod_item(id: FileItemTreeId<Self>) -> ModItem;
+}
+
+pub struct FileItemTreeId<N: ItemTreeNode> {
+    index: Idx<N>,
+    _p: PhantomData<N>,
+}
+
+impl<N: ItemTreeNode> Clone for FileItemTreeId<N> {
+    fn clone(&self) -> Self {
+        Self { index: self.index, _p: PhantomData }
+    }
+}
+impl<N: ItemTreeNode> Copy for FileItemTreeId<N> {}
+
+impl<N: ItemTreeNode> PartialEq for FileItemTreeId<N> {
+    fn eq(&self, other: &FileItemTreeId<N>) -> bool {
+        self.index == other.index
+    }
+}
+impl<N: ItemTreeNode> Eq for FileItemTreeId<N> {}
+
+impl<N: ItemTreeNode> Hash for FileItemTreeId<N> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.index.hash(state)
+    }
+}
+
+impl<N: ItemTreeNode> fmt::Debug for FileItemTreeId<N> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.index.fmt(f)
+    }
+}
+
+pub type ItemTreeId<N> = InFile<FileItemTreeId<N>>;
+
+macro_rules! mod_items {
+    ( $( $typ:ident in $fld:ident -> $ast:ty ),+ $(,)? ) => {
+        #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+        pub enum ModItem {
+            $(
+                $typ(FileItemTreeId<$typ>),
+            )+
+        }
+
+        $(
+            impl From<FileItemTreeId<$typ>> for ModItem {
+                fn from(id: FileItemTreeId<$typ>) -> ModItem {
+                    ModItem::$typ(id)
+                }
+            }
+        )+
+
+        $(
+            impl ItemTreeNode for $typ {
+                type Source = $ast;
+
+                fn ast_id(&self) -> FileAstId<Self::Source> {
+                    self.ast_id
+                }
+
+                fn lookup(tree: &ItemTree, index: Idx<Self>) -> &Self {
+                    &tree.data().$fld[index]
+                }
+
+                fn id_from_mod_item(mod_item: ModItem) -> Option<FileItemTreeId<Self>> {
+                    if let ModItem::$typ(id) = mod_item {
+                        Some(id)
+                    } else {
+                        None
+                    }
+                }
+
+                fn id_to_mod_item(id: FileItemTreeId<Self>) -> ModItem {
+                    ModItem::$typ(id)
+                }
+            }
+
+            impl Index<Idx<$typ>> for ItemTree {
+                type Output = $typ;
+
+                fn index(&self, index: Idx<$typ>) -> &Self::Output {
+                    &self.data().$fld[index]
+                }
+            }
+        )+
+    };
+}
+
+mod_items! {
+    Import in imports -> ast::Use,
+    ExternCrate in extern_crates -> ast::ExternCrate,
+    Function in functions -> ast::Fn,
+    Struct in structs -> ast::Struct,
+    Union in unions -> ast::Union,
+    Enum in enums -> ast::Enum,
+    Const in consts -> ast::Const,
+    Static in statics -> ast::Static,
+    Trait in traits -> ast::Trait,
+    Impl in impls -> ast::Impl,
+    TypeAlias in type_aliases -> ast::TypeAlias,
+    Mod in mods -> ast::Module,
+    MacroCall in macro_calls -> ast::MacroCall,
+}
+
+macro_rules! impl_index {
+    ( $($fld:ident: $t:ty),+ $(,)? ) => {
+        $(
+            impl Index<Idx<$t>> for ItemTree {
+                type Output = $t;
+
+                fn index(&self, index: Idx<$t>) -> &Self::Output {
+                    &self.data().$fld[index]
+                }
+            }
+        )+
+    };
+}
+
+impl_index!(fields: Field, variants: Variant, exprs: Expr);
+
+impl Index<RawVisibilityId> for ItemTree {
+    type Output = RawVisibility;
+    fn index(&self, index: RawVisibilityId) -> &Self::Output {
+        match index {
+            RawVisibilityId::PRIV => &VIS_PRIV,
+            RawVisibilityId::PUB => &VIS_PUB,
+            RawVisibilityId::PUB_CRATE => &VIS_PUB_CRATE,
+            _ => &self.data().vis.arena[Idx::from_raw(index.0.into())],
+        }
+    }
+}
+
+impl Index<GenericParamsId> for ItemTree {
+    type Output = GenericParams;
+
+    fn index(&self, index: GenericParamsId) -> &Self::Output {
+        match index {
+            GenericParamsId::EMPTY => &EMPTY_GENERICS,
+            _ => &self.data().generics.arena[Idx::from_raw(index.0.into())],
+        }
+    }
+}
+
+impl<N: ItemTreeNode> Index<FileItemTreeId<N>> for ItemTree {
+    type Output = N;
+    fn index(&self, id: FileItemTreeId<N>) -> &N {
+        N::lookup(self, id.index)
+    }
+}
+
+/// A desugared `use` import.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Import {
+    pub path: ModPath,
+    pub alias: Option<ImportAlias>,
+    pub visibility: RawVisibilityId,
+    pub is_glob: bool,
+    pub is_prelude: bool,
+    /// AST ID of the `use` or `extern crate` item this import was derived from. Note that many
+    /// `Import`s can map to the same `use` item.
+    pub ast_id: FileAstId<ast::Use>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ExternCrate {
+    pub path: ModPath,
+    pub alias: Option<ImportAlias>,
+    pub visibility: RawVisibilityId,
+    /// Whether this is a `#[macro_use] extern crate ...`.
+    pub is_macro_use: bool,
+    pub ast_id: FileAstId<ast::ExternCrate>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Function {
+    pub name: Name,
+    pub visibility: RawVisibilityId,
+    pub generic_params: GenericParamsId,
+    pub has_self_param: bool,
+    pub is_unsafe: bool,
+    pub params: Box<[TypeRef]>,
+    pub is_varargs: bool,
+    pub ret_type: TypeRef,
+    pub ast_id: FileAstId<ast::Fn>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Struct {
+    pub name: Name,
+    pub visibility: RawVisibilityId,
+    pub generic_params: GenericParamsId,
+    pub fields: Fields,
+    pub ast_id: FileAstId<ast::Struct>,
+    pub kind: StructDefKind,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum StructDefKind {
+    /// `struct S { ... }` - type namespace only.
+    Record,
+    /// `struct S(...);`
+    Tuple,
+    /// `struct S;`
+    Unit,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Union {
+    pub name: Name,
+    pub visibility: RawVisibilityId,
+    pub generic_params: GenericParamsId,
+    pub fields: Fields,
+    pub ast_id: FileAstId<ast::Union>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Enum {
+    pub name: Name,
+    pub visibility: RawVisibilityId,
+    pub generic_params: GenericParamsId,
+    pub variants: IdRange<Variant>,
+    pub ast_id: FileAstId<ast::Enum>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Const {
+    /// const _: () = ();
+    pub name: Option<Name>,
+    pub visibility: RawVisibilityId,
+    pub type_ref: TypeRef,
+    pub ast_id: FileAstId<ast::Const>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Static {
+    pub name: Name,
+    pub visibility: RawVisibilityId,
+    pub mutable: bool,
+    pub type_ref: TypeRef,
+    pub ast_id: FileAstId<ast::Static>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Trait {
+    pub name: Name,
+    pub visibility: RawVisibilityId,
+    pub generic_params: GenericParamsId,
+    pub auto: bool,
+    pub items: Box<[AssocItem]>,
+    pub ast_id: FileAstId<ast::Trait>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Impl {
+    pub generic_params: GenericParamsId,
+    pub target_trait: Option<TypeRef>,
+    pub target_type: TypeRef,
+    pub is_negative: bool,
+    pub items: Box<[AssocItem]>,
+    pub ast_id: FileAstId<ast::Impl>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+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 generic_params: GenericParamsId,
+    pub type_ref: Option<TypeRef>,
+    pub ast_id: FileAstId<ast::TypeAlias>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Mod {
+    pub name: Name,
+    pub visibility: RawVisibilityId,
+    pub kind: ModKind,
+    pub ast_id: FileAstId<ast::Module>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum ModKind {
+    /// `mod m { ... }`
+    Inline { items: Box<[ModItem]> },
+
+    /// `mod m;`
+    Outline {},
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct MacroCall {
+    /// For `macro_rules!` declarations, this is the name of the declared macro.
+    pub name: Option<Name>,
+    /// Path to the called macro.
+    pub path: ModPath,
+    /// Has `#[macro_export]`.
+    pub is_export: bool,
+    /// Has `#[macro_export(local_inner_macros)]`.
+    pub is_local_inner: bool,
+    /// Has `#[rustc_builtin_macro]`.
+    pub is_builtin: bool,
+    pub ast_id: FileAstId<ast::MacroCall>,
+}
+
+// NB: There's no `FileAstId` for `Expr`. The only case where this would be useful is for array
+// lengths, but we don't do much with them yet.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Expr;
+
+macro_rules! impl_froms {
+    ($e:ident { $($v:ident ($t:ty)),* $(,)? }) => {
+        $(
+            impl From<$t> for $e {
+                fn from(it: $t) -> $e {
+                    $e::$v(it)
+                }
+            }
+        )*
+    }
+}
+
+impl ModItem {
+    pub fn as_assoc_item(&self) -> Option<AssocItem> {
+        match self {
+            ModItem::Import(_)
+            | ModItem::ExternCrate(_)
+            | ModItem::Struct(_)
+            | ModItem::Union(_)
+            | ModItem::Enum(_)
+            | ModItem::Static(_)
+            | ModItem::Trait(_)
+            | ModItem::Impl(_)
+            | ModItem::Mod(_) => None,
+            ModItem::MacroCall(call) => Some(AssocItem::MacroCall(*call)),
+            ModItem::Const(konst) => Some(AssocItem::Const(*konst)),
+            ModItem::TypeAlias(alias) => Some(AssocItem::TypeAlias(*alias)),
+            ModItem::Function(func) => Some(AssocItem::Function(*func)),
+        }
+    }
+
+    pub fn downcast<N: ItemTreeNode>(self) -> Option<FileItemTreeId<N>> {
+        N::id_from_mod_item(self)
+    }
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum AssocItem {
+    Function(FileItemTreeId<Function>),
+    TypeAlias(FileItemTreeId<TypeAlias>),
+    Const(FileItemTreeId<Const>),
+    MacroCall(FileItemTreeId<MacroCall>),
+}
+
+impl_froms!(AssocItem {
+    Function(FileItemTreeId<Function>),
+    TypeAlias(FileItemTreeId<TypeAlias>),
+    Const(FileItemTreeId<Const>),
+    MacroCall(FileItemTreeId<MacroCall>),
+});
+
+impl From<AssocItem> for ModItem {
+    fn from(item: AssocItem) -> Self {
+        match item {
+            AssocItem::Function(it) => it.into(),
+            AssocItem::TypeAlias(it) => it.into(),
+            AssocItem::Const(it) => it.into(),
+            AssocItem::MacroCall(it) => it.into(),
+        }
+    }
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct Variant {
+    pub name: Name,
+    pub fields: Fields,
+}
+
+pub struct IdRange<T> {
+    range: Range<u32>,
+    _p: PhantomData<T>,
+}
+
+impl<T> IdRange<T> {
+    fn new(range: Range<Idx<T>>) -> Self {
+        Self { range: range.start.into_raw().into()..range.end.into_raw().into(), _p: PhantomData }
+    }
+}
+
+impl<T> Iterator for IdRange<T> {
+    type Item = Idx<T>;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.range.next().map(|raw| Idx::from_raw(raw.into()))
+    }
+}
+
+impl<T> fmt::Debug for IdRange<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple(&format!("IdRange::<{}>", type_name::<T>())).field(&self.range).finish()
+    }
+}
+
+impl<T> Clone for IdRange<T> {
+    fn clone(&self) -> Self {
+        Self { range: self.range.clone(), _p: PhantomData }
+    }
+}
+
+impl<T> PartialEq for IdRange<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.range == other.range
+    }
+}
+
+impl<T> Eq for IdRange<T> {}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Fields {
+    Record(IdRange<Field>),
+    Tuple(IdRange<Field>),
+    Unit,
+}
+
+/// A single field of an enum variant or struct
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Field {
+    pub name: Name,
+    pub type_ref: TypeRef,
+    pub visibility: RawVisibilityId,
+}
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
new file mode 100644
index 000000000..391ab5d39
--- /dev/null
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -0,0 +1,705 @@
+//! AST -> `ItemTree` lowering code.
+
+use std::{collections::hash_map::Entry, mem, sync::Arc};
+
+use arena::map::ArenaMap;
+use hir_expand::{ast_id_map::AstIdMap, hygiene::Hygiene, HirFileId};
+use smallvec::SmallVec;
+use syntax::{
+    ast::{self, ModuleItemOwner},
+    SyntaxNode,
+};
+
+use crate::{
+    attr::Attrs,
+    generics::{GenericParams, TypeParamData, TypeParamProvenance},
+};
+
+use super::*;
+
+fn id<N: ItemTreeNode>(index: Idx<N>) -> FileItemTreeId<N> {
+    FileItemTreeId { index, _p: PhantomData }
+}
+
+struct ModItems(SmallVec<[ModItem; 1]>);
+
+impl<T> From<T> for ModItems
+where
+    T: Into<ModItem>,
+{
+    fn from(t: T) -> Self {
+        ModItems(SmallVec::from_buf([t.into(); 1]))
+    }
+}
+
+pub(super) struct Ctx {
+    tree: ItemTree,
+    hygiene: Hygiene,
+    file: HirFileId,
+    source_ast_id_map: Arc<AstIdMap>,
+    body_ctx: crate::body::LowerCtx,
+    inner_items: Vec<ModItem>,
+    forced_visibility: Option<RawVisibilityId>,
+}
+
+impl Ctx {
+    pub(super) fn new(db: &dyn DefDatabase, hygiene: Hygiene, file: HirFileId) -> Self {
+        Self {
+            tree: ItemTree::empty(),
+            hygiene,
+            file,
+            source_ast_id_map: db.ast_id_map(file),
+            body_ctx: crate::body::LowerCtx::new(db, file),
+            inner_items: Vec::new(),
+            forced_visibility: None,
+        }
+    }
+
+    pub(super) fn lower_module_items(mut self, item_owner: &dyn ModuleItemOwner) -> ItemTree {
+        self.tree.top_level = item_owner
+            .items()
+            .flat_map(|item| self.lower_mod_item(&item, false))
+            .flat_map(|items| items.0)
+            .collect();
+        self.tree
+    }
+
+    pub(super) fn lower_inner_items(mut self, within: &SyntaxNode) -> ItemTree {
+        self.collect_inner_items(within);
+        self.tree
+    }
+
+    fn data(&mut self) -> &mut ItemTreeData {
+        self.tree.data_mut()
+    }
+
+    fn lower_mod_item(&mut self, item: &ast::Item, inner: bool) -> Option<ModItems> {
+        assert!(inner || self.inner_items.is_empty());
+
+        // Collect inner items for 1-to-1-lowered items.
+        match item {
+            ast::Item::Struct(_)
+            | ast::Item::Union(_)
+            | ast::Item::Enum(_)
+            | ast::Item::Fn(_)
+            | ast::Item::TypeAlias(_)
+            | ast::Item::Const(_)
+            | ast::Item::Static(_)
+            | ast::Item::MacroCall(_) => {
+                // Skip this if we're already collecting inner items. We'll descend into all nodes
+                // already.
+                if !inner {
+                    self.collect_inner_items(item.syntax());
+                }
+            }
+
+            // These are handled in their respective `lower_X` method (since we can't just blindly
+            // walk them).
+            ast::Item::Trait(_) | ast::Item::Impl(_) | ast::Item::ExternBlock(_) => {}
+
+            // These don't have inner items.
+            ast::Item::Module(_) | ast::Item::ExternCrate(_) | ast::Item::Use(_) => {}
+        };
+
+        let attrs = Attrs::new(item, &self.hygiene);
+        let items = match item {
+            ast::Item::Struct(ast) => self.lower_struct(ast).map(Into::into),
+            ast::Item::Union(ast) => self.lower_union(ast).map(Into::into),
+            ast::Item::Enum(ast) => self.lower_enum(ast).map(Into::into),
+            ast::Item::Fn(ast) => self.lower_function(ast).map(Into::into),
+            ast::Item::TypeAlias(ast) => self.lower_type_alias(ast).map(Into::into),
+            ast::Item::Static(ast) => self.lower_static(ast).map(Into::into),
+            ast::Item::Const(ast) => Some(self.lower_const(ast).into()),
+            ast::Item::Module(ast) => self.lower_module(ast).map(Into::into),
+            ast::Item::Trait(ast) => self.lower_trait(ast).map(Into::into),
+            ast::Item::Impl(ast) => self.lower_impl(ast).map(Into::into),
+            ast::Item::Use(ast) => Some(ModItems(
+                self.lower_use(ast).into_iter().map(Into::into).collect::<SmallVec<_>>(),
+            )),
+            ast::Item::ExternCrate(ast) => self.lower_extern_crate(ast).map(Into::into),
+            ast::Item::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into),
+            ast::Item::ExternBlock(ast) => {
+                Some(ModItems(self.lower_extern_block(ast).into_iter().collect::<SmallVec<_>>()))
+            }
+        };
+
+        if !attrs.is_empty() {
+            for item in items.iter().flat_map(|items| &items.0) {
+                self.add_attrs((*item).into(), attrs.clone());
+            }
+        }
+
+        items
+    }
+
+    fn add_attrs(&mut self, item: AttrOwner, attrs: Attrs) {
+        match self.tree.attrs.entry(item) {
+            Entry::Occupied(mut entry) => {
+                *entry.get_mut() = entry.get().merge(attrs);
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(attrs);
+            }
+        }
+    }
+
+    fn collect_inner_items(&mut self, container: &SyntaxNode) {
+        let forced_vis = self.forced_visibility.take();
+        let mut inner_items = mem::take(&mut self.tree.inner_items);
+        inner_items.extend(container.descendants().skip(1).filter_map(ast::Item::cast).filter_map(
+            |item| {
+                let ast_id = self.source_ast_id_map.ast_id(&item);
+                Some((ast_id, self.lower_mod_item(&item, true)?.0))
+            },
+        ));
+        self.tree.inner_items = inner_items;
+        self.forced_visibility = forced_vis;
+    }
+
+    fn lower_assoc_item(&mut self, item: &ast::AssocItem) -> Option<AssocItem> {
+        match item {
+            ast::AssocItem::Fn(ast) => self.lower_function(ast).map(Into::into),
+            ast::AssocItem::TypeAlias(ast) => self.lower_type_alias(ast).map(Into::into),
+            ast::AssocItem::Const(ast) => Some(self.lower_const(ast).into()),
+            ast::AssocItem::MacroCall(ast) => self.lower_macro_call(ast).map(Into::into),
+        }
+    }
+
+    fn lower_struct(&mut self, strukt: &ast::Struct) -> Option<FileItemTreeId<Struct>> {
+        let visibility = self.lower_visibility(strukt);
+        let name = strukt.name()?.as_name();
+        let generic_params = self.lower_generic_params(GenericsOwner::Struct, strukt);
+        let fields = self.lower_fields(&strukt.kind());
+        let ast_id = self.source_ast_id_map.ast_id(strukt);
+        let kind = match strukt.kind() {
+            ast::StructKind::Record(_) => StructDefKind::Record,
+            ast::StructKind::Tuple(_) => StructDefKind::Tuple,
+            ast::StructKind::Unit => StructDefKind::Unit,
+        };
+        let res = Struct { name, visibility, generic_params, fields, ast_id, kind };
+        Some(id(self.data().structs.alloc(res)))
+    }
+
+    fn lower_fields(&mut self, strukt_kind: &ast::StructKind) -> Fields {
+        match strukt_kind {
+            ast::StructKind::Record(it) => {
+                let range = self.lower_record_fields(it);
+                Fields::Record(range)
+            }
+            ast::StructKind::Tuple(it) => {
+                let range = self.lower_tuple_fields(it);
+                Fields::Tuple(range)
+            }
+            ast::StructKind::Unit => Fields::Unit,
+        }
+    }
+
+    fn lower_record_fields(&mut self, fields: &ast::RecordFieldList) -> IdRange<Field> {
+        let start = self.next_field_idx();
+        for field in fields.fields() {
+            if let Some(data) = self.lower_record_field(&field) {
+                let idx = self.data().fields.alloc(data);
+                self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene));
+            }
+        }
+        let end = self.next_field_idx();
+        IdRange::new(start..end)
+    }
+
+    fn lower_record_field(&mut self, field: &ast::RecordField) -> Option<Field> {
+        let name = field.name()?.as_name();
+        let visibility = self.lower_visibility(field);
+        let type_ref = self.lower_type_ref_opt(field.ty());
+        let res = Field { name, type_ref, visibility };
+        Some(res)
+    }
+
+    fn lower_tuple_fields(&mut self, fields: &ast::TupleFieldList) -> IdRange<Field> {
+        let start = self.next_field_idx();
+        for (i, field) in fields.fields().enumerate() {
+            let data = self.lower_tuple_field(i, &field);
+            let idx = self.data().fields.alloc(data);
+            self.add_attrs(idx.into(), Attrs::new(&field, &self.hygiene));
+        }
+        let end = self.next_field_idx();
+        IdRange::new(start..end)
+    }
+
+    fn lower_tuple_field(&mut self, idx: usize, field: &ast::TupleField) -> Field {
+        let name = Name::new_tuple_field(idx);
+        let visibility = self.lower_visibility(field);
+        let type_ref = self.lower_type_ref_opt(field.ty());
+        let res = Field { name, type_ref, visibility };
+        res
+    }
+
+    fn lower_union(&mut self, union: &ast::Union) -> Option<FileItemTreeId<Union>> {
+        let visibility = self.lower_visibility(union);
+        let name = union.name()?.as_name();
+        let generic_params = self.lower_generic_params(GenericsOwner::Union, union);
+        let fields = match union.record_field_list() {
+            Some(record_field_list) => self.lower_fields(&StructKind::Record(record_field_list)),
+            None => Fields::Record(IdRange::new(self.next_field_idx()..self.next_field_idx())),
+        };
+        let ast_id = self.source_ast_id_map.ast_id(union);
+        let res = Union { name, visibility, generic_params, fields, ast_id };
+        Some(id(self.data().unions.alloc(res)))
+    }
+
+    fn lower_enum(&mut self, enum_: &ast::Enum) -> Option<FileItemTreeId<Enum>> {
+        let visibility = self.lower_visibility(enum_);
+        let name = enum_.name()?.as_name();
+        let generic_params = self.lower_generic_params(GenericsOwner::Enum, enum_);
+        let variants = match &enum_.variant_list() {
+            Some(variant_list) => self.lower_variants(variant_list),
+            None => IdRange::new(self.next_variant_idx()..self.next_variant_idx()),
+        };
+        let ast_id = self.source_ast_id_map.ast_id(enum_);
+        let res = Enum { name, visibility, generic_params, variants, ast_id };
+        Some(id(self.data().enums.alloc(res)))
+    }
+
+    fn lower_variants(&mut self, variants: &ast::VariantList) -> IdRange<Variant> {
+        let start = self.next_variant_idx();
+        for variant in variants.variants() {
+            if let Some(data) = self.lower_variant(&variant) {
+                let idx = self.data().variants.alloc(data);
+                self.add_attrs(idx.into(), Attrs::new(&variant, &self.hygiene));
+            }
+        }
+        let end = self.next_variant_idx();
+        IdRange::new(start..end)
+    }
+
+    fn lower_variant(&mut self, variant: &ast::Variant) -> Option<Variant> {
+        let name = variant.name()?.as_name();
+        let fields = self.lower_fields(&variant.kind());
+        let res = Variant { name, fields };
+        Some(res)
+    }
+
+    fn lower_function(&mut self, func: &ast::Fn) -> Option<FileItemTreeId<Function>> {
+        let visibility = self.lower_visibility(func);
+        let name = func.name()?.as_name();
+
+        let mut params = Vec::new();
+        let mut has_self_param = false;
+        if let Some(param_list) = func.param_list() {
+            if let Some(self_param) = param_list.self_param() {
+                let self_type = match self_param.ty() {
+                    Some(type_ref) => TypeRef::from_ast(&self.body_ctx, type_ref),
+                    None => {
+                        let self_type = TypeRef::Path(name![Self].into());
+                        match self_param.kind() {
+                            ast::SelfParamKind::Owned => self_type,
+                            ast::SelfParamKind::Ref => {
+                                TypeRef::Reference(Box::new(self_type), Mutability::Shared)
+                            }
+                            ast::SelfParamKind::MutRef => {
+                                TypeRef::Reference(Box::new(self_type), Mutability::Mut)
+                            }
+                        }
+                    }
+                };
+                params.push(self_type);
+                has_self_param = true;
+            }
+            for param in param_list.params() {
+                let type_ref = TypeRef::from_ast_opt(&self.body_ctx, param.ty());
+                params.push(type_ref);
+            }
+        }
+
+        let mut is_varargs = false;
+        if let Some(params) = func.param_list() {
+            if let Some(last) = params.params().last() {
+                is_varargs = last.dotdotdot_token().is_some();
+            }
+        }
+
+        let ret_type = match func.ret_type().and_then(|rt| rt.ty()) {
+            Some(type_ref) => TypeRef::from_ast(&self.body_ctx, type_ref),
+            _ => TypeRef::unit(),
+        };
+
+        let ret_type = if func.async_token().is_some() {
+            let future_impl = desugar_future_path(ret_type);
+            let ty_bound = TypeBound::Path(future_impl);
+            TypeRef::ImplTrait(vec![ty_bound])
+        } else {
+            ret_type
+        };
+
+        let ast_id = self.source_ast_id_map.ast_id(func);
+        let mut res = Function {
+            name,
+            visibility,
+            generic_params: GenericParamsId::EMPTY,
+            has_self_param,
+            is_unsafe: func.unsafe_token().is_some(),
+            params: params.into_boxed_slice(),
+            is_varargs,
+            ret_type,
+            ast_id,
+        };
+        res.generic_params = self.lower_generic_params(GenericsOwner::Function(&res), func);
+
+        Some(id(self.data().functions.alloc(res)))
+    }
+
+    fn lower_type_alias(
+        &mut self,
+        type_alias: &ast::TypeAlias,
+    ) -> Option<FileItemTreeId<TypeAlias>> {
+        let name = type_alias.name()?.as_name();
+        let type_ref = type_alias.ty().map(|it| self.lower_type_ref(&it));
+        let visibility = self.lower_visibility(type_alias);
+        let bounds = self.lower_type_bounds(type_alias);
+        let generic_params = self.lower_generic_params(GenericsOwner::TypeAlias, type_alias);
+        let ast_id = self.source_ast_id_map.ast_id(type_alias);
+        let res = TypeAlias {
+            name,
+            visibility,
+            bounds: bounds.into_boxed_slice(),
+            generic_params,
+            type_ref,
+            ast_id,
+        };
+        Some(id(self.data().type_aliases.alloc(res)))
+    }
+
+    fn lower_static(&mut self, static_: &ast::Static) -> Option<FileItemTreeId<Static>> {
+        let name = static_.name()?.as_name();
+        let type_ref = self.lower_type_ref_opt(static_.ty());
+        let visibility = self.lower_visibility(static_);
+        let mutable = static_.mut_token().is_some();
+        let ast_id = self.source_ast_id_map.ast_id(static_);
+        let res = Static { name, visibility, mutable, type_ref, ast_id };
+        Some(id(self.data().statics.alloc(res)))
+    }
+
+    fn lower_const(&mut self, konst: &ast::Const) -> FileItemTreeId<Const> {
+        let name = konst.name().map(|it| it.as_name());
+        let type_ref = self.lower_type_ref_opt(konst.ty());
+        let visibility = self.lower_visibility(konst);
+        let ast_id = self.source_ast_id_map.ast_id(konst);
+        let res = Const { name, visibility, type_ref, ast_id };
+        id(self.data().consts.alloc(res))
+    }
+
+    fn lower_module(&mut self, module: &ast::Module) -> Option<FileItemTreeId<Mod>> {
+        let name = module.name()?.as_name();
+        let visibility = self.lower_visibility(module);
+        let kind = if module.semicolon_token().is_some() {
+            ModKind::Outline {}
+        } else {
+            ModKind::Inline {
+                items: module
+                    .item_list()
+                    .map(|list| {
+                        list.items()
+                            .flat_map(|item| self.lower_mod_item(&item, false))
+                            .flat_map(|items| items.0)
+                            .collect()
+                    })
+                    .unwrap_or_else(|| {
+                        mark::hit!(name_res_works_for_broken_modules);
+                        Box::new([]) as Box<[_]>
+                    }),
+            }
+        };
+        let ast_id = self.source_ast_id_map.ast_id(module);
+        let res = Mod { name, visibility, kind, ast_id };
+        Some(id(self.data().mods.alloc(res)))
+    }
+
+    fn lower_trait(&mut self, trait_def: &ast::Trait) -> Option<FileItemTreeId<Trait>> {
+        let name = trait_def.name()?.as_name();
+        let visibility = self.lower_visibility(trait_def);
+        let generic_params =
+            self.lower_generic_params_and_inner_items(GenericsOwner::Trait(trait_def), trait_def);
+        let auto = trait_def.auto_token().is_some();
+        let items = trait_def.assoc_item_list().map(|list| {
+            self.with_inherited_visibility(visibility, |this| {
+                list.assoc_items()
+                    .filter_map(|item| {
+                        let attrs = Attrs::new(&item, &this.hygiene);
+                        this.collect_inner_items(item.syntax());
+                        this.lower_assoc_item(&item).map(|item| {
+                            this.add_attrs(ModItem::from(item).into(), attrs);
+                            item
+                        })
+                    })
+                    .collect()
+            })
+        });
+        let ast_id = self.source_ast_id_map.ast_id(trait_def);
+        let res = Trait {
+            name,
+            visibility,
+            generic_params,
+            auto,
+            items: items.unwrap_or_default(),
+            ast_id,
+        };
+        Some(id(self.data().traits.alloc(res)))
+    }
+
+    fn lower_impl(&mut self, impl_def: &ast::Impl) -> Option<FileItemTreeId<Impl>> {
+        let generic_params =
+            self.lower_generic_params_and_inner_items(GenericsOwner::Impl, impl_def);
+        let target_trait = impl_def.trait_().map(|tr| self.lower_type_ref(&tr));
+        let target_type = self.lower_type_ref(&impl_def.self_ty()?);
+        let is_negative = impl_def.excl_token().is_some();
+
+        // We cannot use `assoc_items()` here as that does not include macro calls.
+        let items = impl_def
+            .assoc_item_list()
+            .into_iter()
+            .flat_map(|it| it.assoc_items())
+            .filter_map(|item| {
+                self.collect_inner_items(item.syntax());
+                let assoc = self.lower_assoc_item(&item)?;
+                let attrs = Attrs::new(&item, &self.hygiene);
+                self.add_attrs(ModItem::from(assoc).into(), attrs);
+                Some(assoc)
+            })
+            .collect();
+        let ast_id = self.source_ast_id_map.ast_id(impl_def);
+        let res = Impl { generic_params, target_trait, target_type, is_negative, items, ast_id };
+        Some(id(self.data().impls.alloc(res)))
+    }
+
+    fn lower_use(&mut self, use_item: &ast::Use) -> Vec<FileItemTreeId<Import>> {
+        // FIXME: cfg_attr
+        let is_prelude = use_item.has_atom_attr("prelude_import");
+        let visibility = self.lower_visibility(use_item);
+        let ast_id = self.source_ast_id_map.ast_id(use_item);
+
+        // Every use item can expand to many `Import`s.
+        let mut imports = Vec::new();
+        let tree = self.tree.data_mut();
+        ModPath::expand_use_item(
+            InFile::new(self.file, use_item.clone()),
+            &self.hygiene,
+            |path, _tree, is_glob, alias| {
+                imports.push(id(tree.imports.alloc(Import {
+                    path,
+                    alias,
+                    visibility,
+                    is_glob,
+                    is_prelude,
+                    ast_id,
+                })));
+            },
+        );
+
+        imports
+    }
+
+    fn lower_extern_crate(
+        &mut self,
+        extern_crate: &ast::ExternCrate,
+    ) -> Option<FileItemTreeId<ExternCrate>> {
+        let path = ModPath::from_name_ref(&extern_crate.name_ref()?);
+        let alias = extern_crate.rename().map(|a| {
+            a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias)
+        });
+        let visibility = self.lower_visibility(extern_crate);
+        let ast_id = self.source_ast_id_map.ast_id(extern_crate);
+        // FIXME: cfg_attr
+        let is_macro_use = extern_crate.has_atom_attr("macro_use");
+
+        let res = ExternCrate { path, alias, visibility, is_macro_use, ast_id };
+        Some(id(self.data().extern_crates.alloc(res)))
+    }
+
+    fn lower_macro_call(&mut self, m: &ast::MacroCall) -> Option<FileItemTreeId<MacroCall>> {
+        let name = m.name().map(|it| it.as_name());
+        let attrs = Attrs::new(m, &self.hygiene);
+        let path = ModPath::from_src(m.path()?, &self.hygiene)?;
+
+        let ast_id = self.source_ast_id_map.ast_id(m);
+
+        // FIXME: cfg_attr
+        let export_attr = attrs.by_key("macro_export");
+
+        let is_export = export_attr.exists();
+        let is_local_inner = if is_export {
+            export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it {
+                tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
+                    ident.text.contains("local_inner_macros")
+                }
+                _ => false,
+            })
+        } else {
+            false
+        };
+
+        let is_builtin = attrs.by_key("rustc_builtin_macro").exists();
+        let res = MacroCall { name, path, is_export, is_builtin, is_local_inner, ast_id };
+        Some(id(self.data().macro_calls.alloc(res)))
+    }
+
+    fn lower_extern_block(&mut self, block: &ast::ExternBlock) -> Vec<ModItem> {
+        block.extern_item_list().map_or(Vec::new(), |list| {
+            list.extern_items()
+                .filter_map(|item| {
+                    self.collect_inner_items(item.syntax());
+                    let attrs = Attrs::new(&item, &self.hygiene);
+                    let id: ModItem = match item {
+                        ast::ExternItem::Fn(ast) => {
+                            let func = self.lower_function(&ast)?;
+                            self.data().functions[func.index].is_unsafe = true;
+                            func.into()
+                        }
+                        ast::ExternItem::Static(ast) => {
+                            let statik = self.lower_static(&ast)?;
+                            statik.into()
+                        }
+                        ast::ExternItem::MacroCall(_) => return None,
+                    };
+                    self.add_attrs(id.into(), attrs);
+                    Some(id)
+                })
+                .collect()
+        })
+    }
+
+    /// Lowers generics defined on `node` and collects inner items defined within.
+    fn lower_generic_params_and_inner_items(
+        &mut self,
+        owner: GenericsOwner<'_>,
+        node: &impl ast::GenericParamsOwner,
+    ) -> GenericParamsId {
+        // Generics are part of item headers and may contain inner items we need to collect.
+        if let Some(params) = node.generic_param_list() {
+            self.collect_inner_items(params.syntax());
+        }
+        if let Some(clause) = node.where_clause() {
+            self.collect_inner_items(clause.syntax());
+        }
+
+        self.lower_generic_params(owner, node)
+    }
+
+    fn lower_generic_params(
+        &mut self,
+        owner: GenericsOwner<'_>,
+        node: &impl ast::GenericParamsOwner,
+    ) -> GenericParamsId {
+        let mut sm = &mut ArenaMap::default();
+        let mut generics = GenericParams::default();
+        match owner {
+            GenericsOwner::Function(func) => {
+                generics.fill(&self.body_ctx, sm, node);
+                // lower `impl Trait` in arguments
+                for param in &*func.params {
+                    generics.fill_implicit_impl_trait_args(param);
+                }
+            }
+            GenericsOwner::Struct
+            | GenericsOwner::Enum
+            | GenericsOwner::Union
+            | GenericsOwner::TypeAlias => {
+                generics.fill(&self.body_ctx, sm, node);
+            }
+            GenericsOwner::Trait(trait_def) => {
+                // traits get the Self type as an implicit first type parameter
+                let self_param_id = generics.types.alloc(TypeParamData {
+                    name: Some(name![Self]),
+                    default: None,
+                    provenance: TypeParamProvenance::TraitSelf,
+                });
+                sm.insert(self_param_id, Either::Left(trait_def.clone()));
+                // add super traits as bounds on Self
+                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
+                let self_param = TypeRef::Path(name![Self].into());
+                generics.fill_bounds(&self.body_ctx, trait_def, self_param);
+
+                generics.fill(&self.body_ctx, &mut sm, node);
+            }
+            GenericsOwner::Impl => {
+                // Note that we don't add `Self` here: in `impl`s, `Self` is not a
+                // type-parameter, but rather is a type-alias for impl's target
+                // type, so this is handled by the resolver.
+                generics.fill(&self.body_ctx, &mut sm, node);
+            }
+        }
+
+        self.data().generics.alloc(generics)
+    }
+
+    fn lower_type_bounds(&mut self, node: &impl ast::TypeBoundsOwner) -> Vec<TypeBound> {
+        match node.type_bound_list() {
+            Some(bound_list) => {
+                bound_list.bounds().map(|it| TypeBound::from_ast(&self.body_ctx, it)).collect()
+            }
+            None => Vec::new(),
+        }
+    }
+
+    fn lower_visibility(&mut self, item: &impl ast::VisibilityOwner) -> RawVisibilityId {
+        let vis = match self.forced_visibility {
+            Some(vis) => return vis,
+            None => RawVisibility::from_ast_with_hygiene(item.visibility(), &self.hygiene),
+        };
+
+        self.data().vis.alloc(vis)
+    }
+
+    fn lower_type_ref(&self, type_ref: &ast::Type) -> TypeRef {
+        TypeRef::from_ast(&self.body_ctx, type_ref.clone())
+    }
+    fn lower_type_ref_opt(&self, type_ref: Option<ast::Type>) -> TypeRef {
+        type_ref.map(|ty| self.lower_type_ref(&ty)).unwrap_or(TypeRef::Error)
+    }
+
+    /// Forces the visibility `vis` to be used for all items lowered during execution of `f`.
+    fn with_inherited_visibility<R>(
+        &mut self,
+        vis: RawVisibilityId,
+        f: impl FnOnce(&mut Self) -> R,
+    ) -> R {
+        let old = mem::replace(&mut self.forced_visibility, Some(vis));
+        let res = f(self);
+        self.forced_visibility = old;
+        res
+    }
+
+    fn next_field_idx(&self) -> Idx<Field> {
+        Idx::from_raw(RawId::from(
+            self.tree.data.as_ref().map_or(0, |data| data.fields.len() as u32),
+        ))
+    }
+    fn next_variant_idx(&self) -> Idx<Variant> {
+        Idx::from_raw(RawId::from(
+            self.tree.data.as_ref().map_or(0, |data| data.variants.len() as u32),
+        ))
+    }
+}
+
+fn desugar_future_path(orig: TypeRef) -> Path {
+    let path = path![core::future::Future];
+    let mut generic_args: Vec<_> = std::iter::repeat(None).take(path.segments.len() - 1).collect();
+    let mut last = GenericArgs::empty();
+    let binding =
+        AssociatedTypeBinding { name: name![Output], type_ref: Some(orig), bounds: Vec::new() };
+    last.bindings.push(binding);
+    generic_args.push(Some(Arc::new(last)));
+
+    Path::from_known_path(path, generic_args)
+}
+
+enum GenericsOwner<'a> {
+    /// We need access to the partially-lowered `Function` for lowering `impl Trait` in argument
+    /// position.
+    Function(&'a Function),
+    Struct,
+    Enum,
+    Union,
+    /// The `TraitDef` is needed to fill the source map for the implicit `Self` parameter.
+    Trait(&'a ast::Trait),
+    TypeAlias,
+    Impl,
+}
diff --git a/crates/hir_def/src/item_tree/tests.rs b/crates/hir_def/src/item_tree/tests.rs
new file mode 100644
index 000000000..9c5bf72bd
--- /dev/null
+++ b/crates/hir_def/src/item_tree/tests.rs
@@ -0,0 +1,439 @@
+use base_db::fixture::WithFixture;
+use expect::{expect, Expect};
+use hir_expand::{db::AstDatabase, HirFileId, InFile};
+use rustc_hash::FxHashSet;
+use std::sync::Arc;
+use stdx::format_to;
+use syntax::{ast, AstNode};
+
+use crate::{db::DefDatabase, test_db::TestDB};
+
+use super::{ItemTree, ModItem, ModKind};
+
+fn test_inner_items(ra_fixture: &str) {
+    let (db, file_id) = TestDB::with_single_file(ra_fixture);
+    let file_id = HirFileId::from(file_id);
+    let tree = db.item_tree(file_id);
+    let root = db.parse_or_expand(file_id).unwrap();
+    let ast_id_map = db.ast_id_map(file_id);
+
+    // Traverse the item tree and collect all module/impl/trait-level items as AST nodes.
+    let mut outer_items = FxHashSet::default();
+    let mut worklist = tree.top_level_items().to_vec();
+    while let Some(item) = worklist.pop() {
+        let node: ast::Item = match item {
+            ModItem::Import(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::ExternCrate(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Function(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Struct(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Union(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Enum(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Const(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Static(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::TypeAlias(it) => tree.source(&db, InFile::new(file_id, it)).into(),
+            ModItem::Mod(it) => {
+                if let ModKind::Inline { items } = &tree[it].kind {
+                    worklist.extend(&**items);
+                }
+                tree.source(&db, InFile::new(file_id, it)).into()
+            }
+            ModItem::Trait(it) => {
+                worklist.extend(tree[it].items.iter().map(|item| ModItem::from(*item)));
+                tree.source(&db, InFile::new(file_id, it)).into()
+            }
+            ModItem::Impl(it) => {
+                worklist.extend(tree[it].items.iter().map(|item| ModItem::from(*item)));
+                tree.source(&db, InFile::new(file_id, it)).into()
+            }
+            ModItem::MacroCall(_) => continue,
+        };
+
+        outer_items.insert(node);
+    }
+
+    // Now descend the root node and check that all `ast::ModuleItem`s are either recorded above, or
+    // registered as inner items.
+    for item in root.descendants().skip(1).filter_map(ast::Item::cast) {
+        if outer_items.contains(&item) {
+            continue;
+        }
+
+        let ast_id = ast_id_map.ast_id(&item);
+        assert!(!tree.inner_items(ast_id).is_empty());
+    }
+}
+
+fn item_tree(ra_fixture: &str) -> Arc<ItemTree> {
+    let (db, file_id) = TestDB::with_single_file(ra_fixture);
+    db.item_tree(file_id.into())
+}
+
+fn print_item_tree(ra_fixture: &str) -> String {
+    let tree = item_tree(ra_fixture);
+    let mut out = String::new();
+
+    format_to!(out, "inner attrs: {:?}\n\n", tree.top_level_attrs());
+    format_to!(out, "top-level items:\n");
+    for item in tree.top_level_items() {
+        fmt_mod_item(&mut out, &tree, *item);
+        format_to!(out, "\n");
+    }
+
+    if !tree.inner_items.is_empty() {
+        format_to!(out, "\ninner items:\n\n");
+        for (ast_id, items) in &tree.inner_items {
+            format_to!(out, "for AST {:?}:\n", ast_id);
+            for inner in items {
+                fmt_mod_item(&mut out, &tree, *inner);
+                format_to!(out, "\n\n");
+            }
+        }
+    }
+
+    out
+}
+
+fn fmt_mod_item(out: &mut String, tree: &ItemTree, item: ModItem) {
+    let attrs = tree.attrs(item.into());
+    if !attrs.is_empty() {
+        format_to!(out, "#[{:?}]\n", attrs);
+    }
+
+    let mut children = String::new();
+    match item {
+        ModItem::ExternCrate(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Import(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Function(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Struct(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Union(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Enum(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Const(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Static(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Trait(it) => {
+            format_to!(out, "{:?}", tree[it]);
+            for item in &*tree[it].items {
+                fmt_mod_item(&mut children, tree, ModItem::from(*item));
+                format_to!(children, "\n");
+            }
+        }
+        ModItem::Impl(it) => {
+            format_to!(out, "{:?}", tree[it]);
+            for item in &*tree[it].items {
+                fmt_mod_item(&mut children, tree, ModItem::from(*item));
+                format_to!(children, "\n");
+            }
+        }
+        ModItem::TypeAlias(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+        ModItem::Mod(it) => {
+            format_to!(out, "{:?}", tree[it]);
+            match &tree[it].kind {
+                ModKind::Inline { items } => {
+                    for item in &**items {
+                        fmt_mod_item(&mut children, tree, *item);
+                        format_to!(children, "\n");
+                    }
+                }
+                ModKind::Outline {} => {}
+            }
+        }
+        ModItem::MacroCall(it) => {
+            format_to!(out, "{:?}", tree[it]);
+        }
+    }
+
+    for line in children.lines() {
+        format_to!(out, "\n> {}", line);
+    }
+}
+
+fn check(ra_fixture: &str, expect: Expect) {
+    let actual = print_item_tree(ra_fixture);
+    expect.assert_eq(&actual);
+