34 files changed, 4385 insertions, 1438 deletions

diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 2bc34d449..4994a2125 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -8,12 +8,12 @@ use hir_expand::{
     InFile,
 };
 use ra_arena::{map::ArenaMap, Arena};
-use ra_prof::profile;
 use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner};
 
 use crate::{
     body::{CfgExpander, LowerCtx},
     db::DefDatabase,
+    item_tree::{Field, Fields, ItemTree},
     src::HasChildSource,
     src::HasSource,
     trace::Trace,
@@ -22,6 +22,7 @@ use crate::{
     EnumId, HasModule, LocalEnumVariantId, LocalFieldId, Lookup, ModuleId, StructId, UnionId,
     VariantId,
 };
+use ra_cfg::CfgOptions;
 
 /// Note that we use `StructData` for unions as well!
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -59,39 +60,48 @@ pub struct FieldData {
 
 impl StructData {
     pub(crate) fn struct_data_query(db: &dyn DefDatabase, id: StructId) -> Arc<StructData> {
-        let src = id.lookup(db).source(db);
+        let loc = id.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 name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let variant_data =
-            VariantData::new(db, src.map(|s| s.kind()), id.lookup(db).container.module(db));
-        let variant_data = Arc::new(variant_data);
-        Arc::new(StructData { name, variant_data })
+        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) })
     }
     pub(crate) fn union_data_query(db: &dyn DefDatabase, id: UnionId) -> Arc<StructData> {
-        let src = id.lookup(db).source(db);
-        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let variant_data = VariantData::new(
-            db,
-            src.map(|s| {
-                s.record_field_def_list()
-                    .map(ast::StructKind::Record)
-                    .unwrap_or(ast::StructKind::Unit)
-            }),
-            id.lookup(db).container.module(db),
-        );
-        let variant_data = Arc::new(variant_data);
-        Arc::new(StructData { name, variant_data })
+        let loc = id.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 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) })
     }
 }
 
 impl EnumData {
     pub(crate) fn enum_data_query(db: &dyn DefDatabase, e: EnumId) -> Arc<EnumData> {
-        let _p = profile("enum_data_query");
-        let src = e.lookup(db).source(db);
-        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let mut trace = Trace::new_for_arena();
-        lower_enum(db, &mut trace, &src, e.lookup(db).container.module(db));
-        Arc::new(EnumData { name, variants: trace.into_arena() })
+        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> {
@@ -251,3 +261,35 @@ fn lower_struct(
         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/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 8b6c0bede..e228e2145 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -13,7 +13,11 @@ use ra_syntax::{
 use tt::Subtree;
 
 use crate::{
-    db::DefDatabase, nameres::ModuleSource, path::ModPath, src::HasChildSource, src::HasSource,
+    db::DefDatabase,
+    item_tree::{ItemTreeId, ItemTreeNode},
+    nameres::ModuleSource,
+    path::ModPath,
+    src::HasChildSource,
     AdtId, AttrDefId, Lookup,
 };
 
@@ -34,6 +38,8 @@ impl ops::Deref for Attrs {
 }
 
 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) => {
@@ -65,19 +71,19 @@ impl Attrs {
                 Attrs::from_attrs_owner(db, src.map(|it| it as &dyn AttrsOwner))
             }
             AttrDefId::AdtId(it) => match it {
-                AdtId::StructId(it) => attrs_from_loc(it.lookup(db), db),
-                AdtId::EnumId(it) => attrs_from_loc(it.lookup(db), db),
-                AdtId::UnionId(it) => attrs_from_loc(it.lookup(db), db),
+                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_loc(it.lookup(db), 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_loc(it.lookup(db), db),
-            AttrDefId::ConstId(it) => attrs_from_loc(it.lookup(db), db),
-            AttrDefId::StaticId(it) => attrs_from_loc(it.lookup(db), db),
-            AttrDefId::FunctionId(it) => attrs_from_loc(it.lookup(db), db),
-            AttrDefId::TypeAliasId(it) => attrs_from_loc(it.lookup(db), 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),
         }
     }
 
@@ -87,16 +93,34 @@ impl Attrs {
     }
 
     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)).collect())
+            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 }
     }
@@ -181,11 +205,8 @@ where
     Attrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn AttrsOwner))
 }
 
-fn attrs_from_loc<T>(node: T, db: &dyn DefDatabase) -> Attrs
-where
-    T: HasSource,
-    T::Value: ast::AttrsOwner,
-{
-    let src = node.source(db);
-    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/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 273036cee..2fe04db2b 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -14,6 +14,7 @@ use ra_db::CrateId;
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, AstPtr};
 use rustc_hash::FxHashMap;
+use test_utils::mark;
 
 pub(crate) use lower::LowerCtx;
 
@@ -42,9 +43,15 @@ pub(crate) struct Expander {
     current_file_id: HirFileId,
     ast_id_map: Arc<AstIdMap>,
     module: ModuleId,
-    recursive_limit: usize,
+    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,
@@ -81,7 +88,7 @@ impl Expander {
             current_file_id,
             ast_id_map,
             module,
-            recursive_limit: 0,
+            recursion_limit: 0,
         }
     }
 
@@ -91,13 +98,15 @@ impl Expander {
         local_scope: Option<&ItemScope>,
         macro_call: ast::MacroCall,
     ) -> Option<(Mark, T)> {
-        if self.recursive_limit > 1024 {
+        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, |path| {
+        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);
@@ -118,8 +127,6 @@ impl Expander {
                     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);
-                    self.recursive_limit += 1;
-
                     return Some((mark, expr));
                 }
             }
@@ -134,7 +141,7 @@ impl Expander {
         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.recursive_limit -= 1;
+        self.recursion_limit -= 1;
         mark.bomb.defuse();
     }
 
@@ -302,7 +309,53 @@ impl BodySourceMap {
         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::RecordField>> {
         self.field_map[&(expr, field)].clone()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use ra_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/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index f159f80af..c6bc85e2f 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -27,6 +27,7 @@ use crate::{
         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,
@@ -35,6 +36,8 @@ use crate::{
 
 use super::{ExprSource, PatSource};
 use ast::AstChildren;
+use rustc_hash::FxHashMap;
+use std::{any::type_name, sync::Arc};
 
 pub(crate) struct LowerCtx {
     hygiene: Hygiene,
@@ -60,10 +63,10 @@ pub(super) fn lower(
     params: Option<ast::ParamList>,
     body: Option<ast::Expr>,
 ) -> (Body, BodySourceMap) {
+    let item_tree = db.item_tree(expander.current_file_id);
     ExprCollector {
         db,
         def,
-        expander,
         source_map: BodySourceMap::default(),
         body: Body {
             exprs: Arena::default(),
@@ -72,6 +75,12 @@ pub(super) fn lower(
             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)
 }
@@ -82,6 +91,8 @@ struct ExprCollector<'a> {
     expander: Expander,
     body: Body,
     source_map: BodySourceMap,
+
+    item_trees: FxHashMap<HirFileId, Arc<ItemTree>>,
 }
 
 impl ExprCollector<'_> {
@@ -165,6 +176,7 @@ impl ExprCollector<'_> {
         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());
@@ -207,8 +219,12 @@ impl ExprCollector<'_> {
                     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::Async(_) | ast::Effect::Label(_) | ast::Effect::Unsafe(_) => {
+                ast::Effect::Async(_) | ast::Effect::Label(_) => {
                     self.collect_block_opt(e.block_expr())
                 }
             },
@@ -434,7 +450,6 @@ impl ExprCollector<'_> {
                     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) => {
@@ -533,6 +548,9 @@ impl ExprCollector<'_> {
                             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
@@ -547,6 +565,32 @@ impl ExprCollector<'_> {
         }
     }
 
+    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)
@@ -578,56 +622,65 @@ impl ExprCollector<'_> {
 
     fn collect_block_items(&mut self, block: &ast::BlockExpr) {
         let container = ContainerId::DefWithBodyId(self.def);
-        for item in block.items() {
-            let (def, name): (ModuleDefId, Option<ast::Name>) = match item {
-                ast::ModuleItem::FnDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (
-                        FunctionLoc { container: container.into(), ast_id }.intern(self.db).into(),
-                        def.name(),
-                    )
-                }
-                ast::ModuleItem::TypeAliasDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (
-                        TypeAliasLoc { container: container.into(), ast_id }.intern(self.db).into(),
-                        def.name(),
-                    )
-                }
-                ast::ModuleItem::ConstDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (
-                        ConstLoc { container: container.into(), ast_id }.intern(self.db).into(),
-                        def.name(),
-                    )
-                }
-                ast::ModuleItem::StaticDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (StaticLoc { container, ast_id }.intern(self.db).into(), def.name())
-                }
-                ast::ModuleItem::StructDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (StructLoc { container, ast_id }.intern(self.db).into(), def.name())
-                }
-                ast::ModuleItem::EnumDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (EnumLoc { container, ast_id }.intern(self.db).into(), def.name())
-                }
-                ast::ModuleItem::UnionDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (UnionLoc { container, ast_id }.intern(self.db).into(), def.name())
-                }
-                ast::ModuleItem::TraitDef(def) => {
-                    let ast_id = self.expander.ast_id(&def);
-                    (TraitLoc { container, ast_id }.intern(self.db).into(), def.name())
-                }
-                ast::ModuleItem::ExternBlock(_) => continue, // FIXME: collect from extern blocks
-                ast::ModuleItem::ImplDef(_)
-                | ast::ModuleItem::UseItem(_)
-                | ast::ModuleItem::ExternCrateItem(_)
-                | ast::ModuleItem::Module(_)
-                | ast::ModuleItem::MacroCall(_) => continue,
-            };
+
+        let items = block
+            .items()
+            .filter_map(|item| {
+                let (def, name): (ModuleDefId, Option<ast::Name>) = match item {
+                    ast::ModuleItem::FnDef(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (
+                            FunctionLoc { container: container.into(), id }.intern(self.db).into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::TypeAliasDef(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (
+                            TypeAliasLoc { container: container.into(), id }.intern(self.db).into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::ConstDef(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (
+                            ConstLoc { container: container.into(), id }.intern(self.db).into(),
+                            def.name(),
+                        )
+                    }
+                    ast::ModuleItem::StaticDef(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (StaticLoc { container, id }.intern(self.db).into(), def.name())
+                    }
+                    ast::ModuleItem::StructDef(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (StructLoc { container, id }.intern(self.db).into(), def.name())
+                    }
+                    ast::ModuleItem::EnumDef(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (EnumLoc { container, id }.intern(self.db).into(), def.name())
+                    }
+                    ast::ModuleItem::UnionDef(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (UnionLoc { container, id }.intern(self.db).into(), def.name())
+                    }
+                    ast::ModuleItem::TraitDef(def) => {
+                        let id = self.find_inner_item(&def)?;
+                        (TraitLoc { container, id }.intern(self.db).into(), def.name())
+                    }
+                    ast::ModuleItem::ExternBlock(_) => return None, // FIXME: collect from extern blocks
+                    ast::ModuleItem::ImplDef(_)
+                    | ast::ModuleItem::UseItem(_)
+                    | ast::ModuleItem::ExternCrateItem(_)
+                    | ast::ModuleItem::Module(_)
+                    | ast::ModuleItem::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
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs
index e48ff38f9..99e876683 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -87,15 +87,13 @@ impl ExprScopes {
     }
 
     fn add_bindings(&mut self, body: &Body, scope: ScopeId, pat: PatId) {
-        match &body[pat] {
-            Pat::Bind { name, .. } => {
-                // bind can have a sub pattern, but it's actually not allowed
-                // to bind to things in there
-                let entry = ScopeEntry { name: name.clone(), pat };
-                self.scopes[scope].entries.push(entry)
-            }
-            p => p.walk_child_pats(|pat| self.add_bindings(body, scope, pat)),
+        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]) {
@@ -190,21 +188,23 @@ mod tests {
         }
     }
 
-    fn do_check(code: &str, expected: &[&str]) {
-        let (off, code) = extract_offset(code);
+    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 = off.into();
+            let off: usize = offset.into();
             buf.push_str(&code[..off]);
-            buf.push_str("marker");
+            buf.push_str("<|>marker");
             buf.push_str(&code[off..]);
             buf
         };
 
-        let (db, file_id) = TestDB::with_single_file(&code);
+        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, off).unwrap();
+        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());
@@ -300,15 +300,65 @@ mod tests {
         );
     }
 
-    fn do_check_local_name(code: &str, expected_offset: u32) {
-        let (off, code) = extract_offset(code);
+    #[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 {}
+                <|>
+            }
+        ",
+            &[],
+        );
+    }
 
-        let (db, file_id) = TestDB::with_single_file(&code);
+    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(), off).unwrap();
+        let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), offset).unwrap();
 
         let function = find_function(&db, file_id);
 
@@ -336,15 +386,16 @@ mod tests {
     fn test_resolve_local_name() {
         do_check_local_name(
             r#"
-            fn foo(x: i32, y: u32) {
-                {
-                    let z = x * 2;
-                }
-                {
-                    let t = x<|> * 3;
-                }
-            }"#,
-            21,
+fn foo(x: i32, y: u32) {
+    {
+        let z = x * 2;
+    }
+    {
+        let t = x<|> * 3;
+    }
+}
+"#,
+            7,
         );
     }
 
@@ -352,10 +403,11 @@ mod tests {
     fn test_resolve_local_name_declaration() {
         do_check_local_name(
             r#"
-            fn foo(x: String) {
-                let x : &str = &x<|>;
-            }"#,
-            21,
+fn foo(x: String) {
+    let x : &str = &x<|>;
+}
+"#,
+            7,
         );
     }
 
@@ -363,12 +415,12 @@ mod tests {
     fn test_resolve_local_name_shadow() {
         do_check_local_name(
             r"
-            fn foo(x: String) {
-                let x : &str = &x;
-                x<|>
-            }
-            ",
-            53,
+fn foo(x: String) {
+    let x : &str = &x;
+    x<|>
+}
+",
+            28,
         );
     }
 
@@ -376,13 +428,13 @@ mod tests {
     fn ref_patterns_contribute_bindings() {
         do_check_local_name(
             r"
-            fn foo() {
-                if let Some(&from) = bar() {
-                    from<|>;
-                }
-            }
-            ",
-            53,
+fn foo() {
+    if let Some(&from) = bar() {
+        from<|>;
+    }
+}
+",
+            28,
         );
     }
 
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index e2130d931..88a8ef9bf 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -2,27 +2,19 @@
 
 use std::sync::Arc;
 
-use hir_expand::{
-    hygiene::Hygiene,
-    name::{name, AsName, Name},
-    AstId, InFile,
-};
+use hir_expand::{name::Name, InFile};
 use ra_prof::profile;
-use ra_syntax::ast::{
-    self, AssocItem, AstNode, ModuleItemOwner, NameOwner, TypeAscriptionOwner, TypeBoundsOwner,
-    VisibilityOwner,
-};
+use ra_syntax::ast;
 
 use crate::{
     attr::Attrs,
-    body::LowerCtx,
+    body::Expander,
     db::DefDatabase,
-    path::{path, AssociatedTypeBinding, GenericArgs, Path},
-    src::HasSource,
-    type_ref::{Mutability, TypeBound, TypeRef},
+    item_tree::{AssocItem, ItemTreeId, ModItem},
+    type_ref::{TypeBound, TypeRef},
     visibility::RawVisibility,
-    AssocContainerId, AssocItemId, ConstId, ConstLoc, Expander, FunctionId, FunctionLoc, HasModule,
-    ImplId, Intern, Lookup, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
+    AssocContainerId, AssocItemId, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
+    Intern, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -34,85 +26,36 @@ pub struct FunctionData {
     /// 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: &impl DefDatabase, func: FunctionId) -> Arc<FunctionData> {
+    pub(crate) fn fn_data_query(db: &dyn DefDatabase, func: FunctionId) -> Arc<FunctionData> {
         let loc = func.lookup(db);
-        let src = loc.source(db);
-        let ctx = LowerCtx::new(db, src.file_id);
-        let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
-        let mut params = Vec::new();
-        let mut has_self_param = false;
-        if let Some(param_list) = src.value.param_list() {
-            if let Some(self_param) = param_list.self_param() {
-                let self_type = if let Some(type_ref) = self_param.ascribed_type() {
-                    TypeRef::from_ast(&ctx, type_ref)
-                } else {
-                    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(&ctx, param.ascribed_type());
-                params.push(type_ref);
-            }
-        }
-        let attrs = Attrs::new(&src.value, &Hygiene::new(db.upcast(), src.file_id));
-
-        let ret_type = if let Some(type_ref) = src.value.ret_type().and_then(|rt| rt.type_ref()) {
-            TypeRef::from_ast(&ctx, type_ref)
-        } else {
-            TypeRef::unit()
-        };
-
-        let ret_type = if src.value.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 vis_default = RawVisibility::default_for_container(loc.container);
-        let visibility =
-            RawVisibility::from_ast_with_default(db, vis_default, src.map(|s| s.visibility()));
-
-        let sig = FunctionData { name, params, ret_type, has_self_param, visibility, attrs };
-        Arc::new(sig)
+        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(),
+        })
     }
 }
 
-fn desugar_future_path(orig: TypeRef) -> Path {
-    let path = path![std::future::Future];
-    let mut generic_args: Vec<_> = std::iter::repeat(None).take(path.segments.len() - 1).collect();
-    let mut last = GenericArgs::empty();
-    last.bindings.push(AssociatedTypeBinding {
-        name: name![Output],
-        type_ref: Some(orig),
-        bounds: Vec::new(),
-    });
-    generic_args.push(Some(Arc::new(last)));
-
-    Path::from_known_path(path, generic_args)
-}
-
 #[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>,
 }
 
@@ -122,22 +65,15 @@ impl TypeAliasData {
         typ: TypeAliasId,
     ) -> Arc<TypeAliasData> {
         let loc = typ.lookup(db);
-        let node = loc.source(db);
-        let name = node.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let lower_ctx = LowerCtx::new(db, node.file_id);
-        let type_ref = node.value.type_ref().map(|it| TypeRef::from_ast(&lower_ctx, it));
-        let vis_default = RawVisibility::default_for_container(loc.container);
-        let visibility = RawVisibility::from_ast_with_default(
-            db,
-            vis_default,
-            node.as_ref().map(|n| n.visibility()),
-        );
-        let bounds = if let Some(bound_list) = node.value.type_bound_list() {
-            bound_list.bounds().map(|it| TypeBound::from_ast(&lower_ctx, it)).collect()
-        } else {
-            Vec::new()
-        };
-        Arc::new(TypeAliasData { name, type_ref, visibility, bounds })
+        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(),
+        })
     }
 }
 
@@ -151,30 +87,24 @@ pub struct TraitData {
 impl TraitData {
     pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
         let tr_loc = tr.lookup(db);
-        let src = tr_loc.source(db);
-        let name = src.value.name().map_or_else(Name::missing, |n| n.as_name());
-        let auto = src.value.auto_token().is_some();
+        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 items = Vec::new();
-
-        if let Some(item_list) = src.value.item_list() {
-            let mut expander = Expander::new(db, tr_loc.ast_id.file_id, module_id);
-            items.extend(collect_items(
-                db,
-                &mut expander,
-                item_list.assoc_items(),
-                src.file_id,
-                container,
-            ));
-            items.extend(collect_items_in_macros(
-                db,
-                &mut expander,
-                &src.with_value(item_list),
-                container,
-            ));
-        }
+        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 })
     }
 
@@ -205,33 +135,28 @@ impl ImplData {
     pub(crate) fn impl_data_query(db: &dyn DefDatabase, id: ImplId) -> Arc<ImplData> {
         let _p = profile("impl_data_query");
         let impl_loc = id.lookup(db);
-        let src = impl_loc.source(db);
-        let lower_ctx = LowerCtx::new(db, src.file_id);
 
-        let target_trait = src.value.target_trait().map(|it| TypeRef::from_ast(&lower_ctx, it));
-        let target_type = TypeRef::from_ast_opt(&lower_ctx, src.value.target_type());
-        let is_negative = src.value.excl_token().is_some();
+        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 mut items: Vec<AssocItemId> = Vec::new();
-
-        if let Some(item_list) = src.value.item_list() {
-            let mut expander = Expander::new(db, impl_loc.ast_id.file_id, module_id);
-            items.extend(
-                collect_items(db, &mut expander, item_list.assoc_items(), src.file_id, container)
-                    .into_iter()
-                    .map(|(_, item)| item),
-            );
-            items.extend(
-                collect_items_in_macros(db, &mut expander, &src.with_value(item_list), container)
-                    .into_iter()
-                    .map(|(_, item)| item),
-            );
-        }
+        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();
 
-        let res = ImplData { target_trait, target_type, items, is_negative };
-        Arc::new(res)
+        Arc::new(ImplData { target_trait, target_type, items, is_negative })
     }
 }
 
@@ -246,22 +171,14 @@ pub struct ConstData {
 impl ConstData {
     pub(crate) fn const_data_query(db: &dyn DefDatabase, konst: ConstId) -> Arc<ConstData> {
         let loc = konst.lookup(db);
-        let node = loc.source(db);
-        let vis_default = RawVisibility::default_for_container(loc.container);
-        Arc::new(ConstData::new(db, vis_default, node))
-    }
+        let item_tree = db.item_tree(loc.id.file_id);
+        let konst = &item_tree[loc.id.value];
 
-    fn new<N: NameOwner + TypeAscriptionOwner + VisibilityOwner>(
-        db: &dyn DefDatabase,
-        vis_default: RawVisibility,
-        node: InFile<N>,
-    ) -> ConstData {
-        let ctx = LowerCtx::new(db, node.file_id);
-        let name = node.value.name().map(|n| n.as_name());
-        let type_ref = TypeRef::from_ast_opt(&ctx, node.value.ascribed_type());
-        let visibility =
-            RawVisibility::from_ast_with_default(db, vis_default, node.map(|n| n.visibility()));
-        ConstData { name, type_ref, visibility }
+        Arc::new(ConstData {
+            name: konst.name.clone(),
+            type_ref: konst.type_ref.clone(),
+            visibility: item_tree[konst.visibility].clone(),
+        })
     }
 }
 
@@ -275,44 +192,25 @@ pub struct StaticData {
 
 impl StaticData {
     pub(crate) fn static_data_query(db: &dyn DefDatabase, konst: StaticId) -> Arc<StaticData> {
-        let node = konst.lookup(db).source(db);
-        let ctx = LowerCtx::new(db, node.file_id);
-
-        let name = node.value.name().map(|n| n.as_name());
-        let type_ref = TypeRef::from_ast_opt(&ctx, node.value.ascribed_type());
-        let mutable = node.value.mut_token().is_some();
-        let visibility = RawVisibility::from_ast_with_default(
-            db,
-            RawVisibility::private(),
-            node.map(|n| n.visibility()),
-        );
-
-        Arc::new(StaticData { name, type_ref, visibility, mutable })
-    }
-}
-
-fn collect_items_in_macros(
-    db: &dyn DefDatabase,
-    expander: &mut Expander,
-    impl_def: &InFile<ast::ItemList>,
-    container: AssocContainerId,
-) -> Vec<(Name, AssocItemId)> {
-    let mut res = Vec::new();
-
-    // We set a limit to protect against infinite recursion
-    let limit = 100;
-
-    for m in impl_def.value.syntax().children().filter_map(ast::MacroCall::cast) {
-        res.extend(collect_items_in_macro(db, expander, m, container, limit))
+        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,
+        })
     }
-
-    res
 }
 
-fn collect_items_in_macro(
+fn collect_items(
     db: &dyn DefDatabase,
+    module: ModuleId,
     expander: &mut Expander,
-    m: ast::MacroCall,
+    assoc_items: impl Iterator<Item = AssocItem>,
+    file_id: crate::HirFileId,
     container: AssocContainerId,
     limit: usize,
 ) -> Vec<(Name, AssocItemId)> {
@@ -320,62 +218,62 @@ fn collect_items_in_macro(
         return Vec::new();
     }
 
-    if let Some((mark, items)) = expander.enter_expand(db, None, m) {
-        let items: InFile<ast::MacroItems> = expander.to_source(items);
-        let mut res = collect_items(
-            db,
-            expander,
-            items.value.items().filter_map(|it| AssocItem::cast(it.syntax().clone())),
-            items.file_id,
-            container,
-        );
-
-        // Recursive collect macros
-        // Note that ast::ModuleItem do not include ast::MacroCall
-        // We cannot use ModuleItemOwner::items here
-        for it in items.value.syntax().children().filter_map(ast::MacroCall::cast) {
-            res.extend(collect_items_in_macro(db, expander, it, container, limit - 1))
-        }
-        expander.exit(db, mark);
-        res
-    } else {
-        Vec::new()
-    }
-}
-
-fn collect_items(
-    db: &dyn DefDatabase,
-    expander: &mut Expander,
-    assoc_items: impl Iterator<Item = AssocItem>,
-    file_id: crate::HirFileId,
-    container: AssocContainerId,
-) -> Vec<(Name, AssocItemId)> {
-    let items = db.ast_id_map(file_id);
-
-    assoc_items
-        .filter_map(|item_node| match item_node {
-            ast::AssocItem::FnDef(it) => {
-                let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                if !expander.is_cfg_enabled(&it) {
-                    return None;
+    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, ast_id: AstId::new(file_id, items.ast_id(&it)) }
-                    .intern(db);
-                Some((name, def.into()))
+                let def = FunctionLoc { container, id: ItemTreeId::new(file_id, id) }.intern(db);
+                items.push((item.name.clone(), def.into()));
             }
-            ast::AssocItem::ConstDef(it) => {
-                let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                let def = ConstLoc { container, ast_id: AstId::new(file_id, items.ast_id(&it)) }
-                    .intern(db);
-                Some((name, 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()));
             }
-            ast::AssocItem::TypeAliasDef(it) => {
-                let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                let def =
-                    TypeAliasLoc { container, ast_id: AstId::new(file_id, items.ast_id(&it)) }
-                        .intern(db);
-                Some((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()));
             }
-        })
-        .collect()
+            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/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index 945a0025e..9c3ede2d7 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -1,7 +1,7 @@
 //! Defines database & queries for name resolution.
 use std::sync::Arc;
 
-use hir_expand::{db::AstDatabase, name::Name, HirFileId};
+use hir_expand::{db::AstDatabase, HirFileId};
 use ra_db::{salsa, CrateId, SourceDatabase, Upcast};
 use ra_prof::profile;
 use ra_syntax::SmolStr;
@@ -12,13 +12,11 @@ use crate::{
     body::{scope::ExprScopes, Body, BodySourceMap},
     data::{ConstData, FunctionData, ImplData, StaticData, TraitData, TypeAliasData},
     docs::Documentation,
-    find_path,
     generics::GenericParams,
-    item_scope::ItemInNs,
+    import_map::ImportMap,
+    item_tree::ItemTree,
     lang_item::{LangItemTarget, LangItems},
-    nameres::{raw::RawItems, CrateDefMap},
-    path::ModPath,
-    visibility::Visibility,
+    nameres::CrateDefMap,
     AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
     GenericDefId, ImplId, ImplLoc, ModuleId, StaticId, StaticLoc, StructId, StructLoc, TraitId,
     TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
@@ -48,8 +46,8 @@ pub trait InternDatabase: SourceDatabase {
 
 #[salsa::query_group(DefDatabaseStorage)]
 pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
-    #[salsa::invoke(RawItems::raw_items_query)]
-    fn raw_items(&self, file_id: HirFileId) -> Arc<RawItems>;
+    #[salsa::invoke(ItemTree::item_tree_query)]
+    fn item_tree(&self, file_id: HirFileId) -> Arc<ItemTree>;
 
     #[salsa::invoke(crate_def_map_wait)]
     #[salsa::transparent]
@@ -113,15 +111,8 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
     #[salsa::invoke(Documentation::documentation_query)]
     fn documentation(&self, def: AttrDefId) -> Option<Documentation>;
 
-    #[salsa::invoke(find_path::importable_locations_of_query)]
-    fn importable_locations_of(
-        &self,
-        item: ItemInNs,
-        krate: CrateId,
-    ) -> Arc<[(ModuleId, Name, Visibility)]>;
-
-    #[salsa::invoke(find_path::find_path_inner_query)]
-    fn find_path_inner(&self, item: ItemInNs, from: ModuleId, max_len: usize) -> Option<ModPath>;
+    #[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> {
diff --git a/crates/ra_hir_def/src/diagnostics.rs b/crates/ra_hir_def/src/diagnostics.rs
index 510c5e064..30db48f86 100644
--- a/crates/ra_hir_def/src/diagnostics.rs
+++ b/crates/ra_hir_def/src/diagnostics.rs
@@ -3,7 +3,6 @@
 use std::any::Any;
 
 use hir_expand::diagnostics::Diagnostic;
-use ra_db::RelativePathBuf;
 use ra_syntax::{ast, AstPtr, SyntaxNodePtr};
 
 use hir_expand::{HirFileId, InFile};
@@ -12,7 +11,7 @@ use hir_expand::{HirFileId, InFile};
 pub struct UnresolvedModule {
     pub file: HirFileId,
     pub decl: AstPtr<ast::Module>,
-    pub candidate: RelativePathBuf,
+    pub candidate: String,
 }
 
 impl Diagnostic for UnresolvedModule {
diff --git a/crates/ra_hir_def/src/docs.rs b/crates/ra_hir_def/src/docs.rs
index b221ae1ce..2630b3d89 100644
--- a/crates/ra_hir_def/src/docs.rs
+++ b/crates/ra_hir_def/src/docs.rs
@@ -29,6 +29,13 @@ impl 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
     }
@@ -70,6 +77,45 @@ impl Documentation {
     }
 }
 
-pub(crate) fn docs_from_ast(node: &impl ast::DocCommentsOwner) -> Option<Documentation> {
-    node.doc_comment_text().map(|it| Documentation::new(&it))
+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/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs
index ca49b26d1..e41cfc16b 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -150,6 +150,9 @@ pub enum Expr {
     Tuple {
         exprs: Vec<ExprId>,
     },
+    Unsafe {
+        body: ExprId,
+    },
     Array(Array),
     Literal(Literal),
 }
@@ -247,7 +250,7 @@ impl Expr {
                     f(*expr);
                 }
             }
-            Expr::TryBlock { body } => f(*body),
+            Expr::TryBlock { body } | Expr::Unsafe { body } => f(*body),
             Expr::Loop { body, .. } => f(*body),
             Expr::While { condition, body, .. } => {
                 f(*condition);
diff --git a/crates/ra_hir_def/src/find_path.rs b/crates/ra_hir_def/src/find_path.rs
index 4db798473..06701a830 100644
--- a/crates/ra_hir_def/src/find_path.rs
+++ b/crates/ra_hir_def/src/find_path.rs
@@ -1,9 +1,8 @@
 //! An algorithm to find a path to refer to a certain item.
 
-use std::sync::Arc;
-
 use hir_expand::name::{known, AsName, Name};
 use ra_prof::profile;
+use rustc_hash::FxHashSet;
 use test_utils::mark;
 
 use crate::{
@@ -11,7 +10,7 @@ use crate::{
     item_scope::ItemInNs,
     path::{ModPath, PathKind},
     visibility::Visibility,
-    CrateId, ModuleDefId, ModuleId,
+    ModuleDefId, ModuleId,
 };
 
 // FIXME: handle local items
@@ -20,7 +19,7 @@ use crate::{
 /// *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("find_path");
-    db.find_path_inner(item, from, MAX_PATH_LEN)
+    find_path_inner(db, item, from, MAX_PATH_LEN)
 }
 
 const MAX_PATH_LEN: usize = 15;
@@ -36,20 +35,9 @@ impl ModPath {
         let first_segment = self.segments.first();
         first_segment == Some(&known::alloc) || first_segment == Some(&known::core)
     }
-
-    fn len(&self) -> usize {
-        self.segments.len()
-            + match self.kind {
-                PathKind::Plain => 0,
-                PathKind::Super(i) => i as usize,
-                PathKind::Crate => 1,
-                PathKind::Abs => 0,
-                PathKind::DollarCrate(_) => 1,
-            }
-    }
 }
 
-pub(crate) fn find_path_inner_query(
+fn find_path_inner(
     db: &dyn DefDatabase,
     item: ItemInNs,
     from: ModuleId,
@@ -133,31 +121,67 @@ pub(crate) fn find_path_inner_query(
     }
 
     // - 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 importable_locations = find_importable_locations(db, item, from);
     let mut best_path = None;
     let mut best_path_len = max_len;
-    for (module_id, name) in importable_locations {
-        let mut path = match db.find_path_inner(
-            ItemInNs::Types(ModuleDefId::ModuleId(module_id)),
-            from,
-            best_path_len - 1,
-        ) {
-            None => continue,
-            Some(path) => path,
-        };
-        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);
+    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
 }
 
@@ -185,69 +209,86 @@ fn select_best_path(old_path: ModPath, new_path: ModPath, prefer_no_std: bool) -
     }
 }
 
-fn find_importable_locations(
+/// 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 crate_graph = db.crate_graph();
-    let mut result = Vec::new();
-    // We only look in the crate from which we are importing, and the direct
-    // dependencies. We cannot refer to names from transitive dependencies
-    // directly (only through reexports in direct dependencies).
-    for krate in Some(from.krate)
-        .into_iter()
-        .chain(crate_graph[from.krate].dependencies.iter().map(|dep| dep.crate_id))
-    {
-        result.extend(
-            db.importable_locations_of(item, krate)
-                .iter()
-                .filter(|(_, _, vis)| vis.is_visible_from(db, from))
-                .map(|(m, n, _)| (*m, n.clone())),
-        );
-    }
-    result
-}
+    let _p = profile("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]
+        };
 
-/// Collects all locations from which we might import the item in a particular
-/// crate. These include the original definition of the item, and any
-/// non-private `use`s.
-///
-/// Note that the crate doesn't need to be the one in which the item is defined;
-/// it might be re-exported in other crates.
-pub(crate) fn importable_locations_of_query(
-    db: &dyn DefDatabase,
-    item: ItemInNs,
-    krate: CrateId,
-) -> Arc<[(ModuleId, Name, Visibility)]> {
-    let _p = profile("importable_locations_of_query");
-    let def_map = db.crate_def_map(krate);
-    let mut result = Vec::new();
-    for (local_id, data) in def_map.modules.iter() {
         if let Some((name, vis)) = data.scope.name_of(item) {
-            let is_private = if let Visibility::Module(private_to) = vis {
-                private_to.local_id == 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
-            };
-            if is_private && !is_original_def {
+            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.
-                continue;
+                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);
+                }
             }
-            result.push((ModuleId { krate, local_id }, name.clone(), vis));
         }
     }
 
-    Arc::from(result)
+    locations
 }
 
 #[cfg(test)]
@@ -264,8 +305,8 @@ mod tests {
     /// `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(code: &str, path: &str) {
-        let (db, pos) = TestDB::with_position(code);
+    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 = ra_syntax::SourceFile::parse(&format!("use {};", path));
         let ast_path = parsed_path_file
@@ -396,6 +437,44 @@ mod tests {
     }
 
     #[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:ra_syntax
+
+            use ra_syntax::ast;
+            <|>
+
+            //- /lib.rs crate:ra_syntax
+            pub mod ast {
+                pub enum ModuleItem {
+                    A, B, C,
+                }
+            }
+        "#,
+            "ast::ModuleItem",
+        );
+
+        check_found_path(
+            r#"
+            //- /main.rs crate:main deps:ra_syntax
+
+            <|>
+
+            //- /lib.rs crate:ra_syntax
+            pub mod ast {
+                pub enum ModuleItem {
+                    A, B, C,
+                }
+            }
+        "#,
+            "ra_syntax::ast::ModuleItem",
+        );
+    }
+
+    #[test]
     fn same_crate_reexport() {
         let code = r#"
             //- /main.rs
diff --git a/crates/ra_hir_def/src/generics.rs b/crates/ra_hir_def/src/generics.rs
index 09a5241f7..6a0f493a7 100644
--- a/crates/ra_hir_def/src/generics.rs
+++ b/crates/ra_hir_def/src/generics.rs
@@ -42,7 +42,7 @@ pub enum TypeParamProvenance {
 }
 
 /// Data about the generic parameters of a function, struct, impl, etc.
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Clone, PartialEq, Eq, Debug, Default)]
 pub struct GenericParams {
     pub types: Arena<TypeParamData>,
     // lifetimes: Arena<LocalLifetimeParamId, LifetimeParamData>,
@@ -74,8 +74,53 @@ impl GenericParams {
         def: GenericDefId,
     ) -> Arc<GenericParams> {
         let _p = profile("generic_params_query");
-        let (params, _source_map) = GenericParams::new(db, def);
-        Arc::new(params)
+
+        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>) {
@@ -156,7 +201,12 @@ impl GenericParams {
         (generics, InFile::new(file_id, sm))
     }
 
-    fn fill(&mut self, lower_ctx: &LowerCtx, sm: &mut SourceMap, node: &dyn TypeParamsOwner) {
+    pub(crate) fn fill(
+        &mut self,
+        lower_ctx: &LowerCtx,
+        sm: &mut SourceMap,
+        node: &dyn TypeParamsOwner,
+    ) {
         if let Some(params) = node.type_param_list() {
             self.fill_params(lower_ctx, sm, params)
         }
@@ -165,7 +215,7 @@ impl GenericParams {
         }
     }
 
-    fn fill_bounds(
+    pub(crate) fn fill_bounds(
         &mut self,
         lower_ctx: &LowerCtx,
         node: &dyn ast::TypeBoundsOwner,
@@ -229,7 +279,7 @@ impl GenericParams {
             .push(WherePredicate { target: WherePredicateTarget::TypeRef(type_ref), bound });
     }
 
-    fn fill_implicit_impl_trait_args(&mut self, type_ref: &TypeRef) {
+    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 {
diff --git a/crates/ra_hir_def/src/import_map.rs b/crates/ra_hir_def/src/import_map.rs
new file mode 100644
index 000000000..869f3ca5a
--- /dev/null
+++ b/crates/ra_hir_def/src/import_map.rs
@@ -0,0 +1,737 @@
+//! A map of all publicly exported items in a crate.
+
+use std::{cmp::Ordering, fmt, hash::BuildHasherDefault, sync::Arc};
+
+use fst::{self, Streamer};
+use indexmap::{map::Entry, IndexMap};
+use ra_db::CrateId;
+use ra_syntax::SmolStr;
+use rustc_hash::{FxHashMap, FxHasher};
+use smallvec::SmallVec;
+
+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 = ra_prof::profile("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 = ra_prof::profile("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 super::*;
+    use crate::{test_db::TestDB, AssocContainerId, Lookup};
+    use insta::assert_snapshot;
+    use itertools::Itertools;
+    use ra_db::fixture::WithFixture;
+    use ra_db::{SourceDatabase, Upcast};
+
+    fn import_map(ra_fixture: &str) -> String {
+        let db = TestDB::with_files(ra_fixture);
+        let crate_graph = db.crate_graph();
+
+        let s = 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{:?}", name, map))
+            })
+            .join("\n");
+        s
+    }
+
+    fn search_dependencies_of(ra_fixture: &str, krate_name: &str, query: Query) -> String {
+        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();
+
+        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!(
+                        "{}::{} ({})",
+                        crate_graph[krate].display_name.as_ref().unwrap(),
+                        path,
+                        mark
+                    )
+                })
+            })
+            .join("\n")
+    }
+
+    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,
+        }
+    }
+
+    #[test]
+    fn smoke() {
+        let map = import_map(
+            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;
+        ",
+        );
+
+        assert_snapshot!(map, @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() {
+        let map = import_map(
+            r"
+            //- /main.rs crate:main
+
+            pub mod sub {
+                pub mod subsub {
+                    pub struct Def {}
+                }
+
+                pub use super::sub::subsub::Def;
+            }
+        ",
+        );
+
+        assert_snapshot!(map, @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.
+        let map = import_map(
+            r"
+            //- /main.rs crate:main deps:lib
+            pub mod m {
+                pub use lib::S;
+            }
+            //- /lib.rs crate:lib
+            pub struct S;
+        ",
+        );
+
+        assert_snapshot!(map, @r###"
+        main:
+        - m (t)
+        - m::S (t)
+        - m::S (v)
+        lib:
+        - S (t)
+        - S (v)
+        "###);
+    }
+
+    #[test]
+    fn macro_reexport() {
+        let map = import_map(
+            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 {
+                () => {};
+            }
+        ",
+        );
+
+        assert_snapshot!(map, @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.
+        let map = import_map(
+            r"
+            //- /main.rs crate:main deps:lib
+            pub use lib::module as reexported_module;
+            //- /lib.rs crate:lib
+            pub mod module {
+                pub struct S;
+            }
+        ",
+        );
+
+        assert_snapshot!(map, @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.
+        let map = import_map(
+            r"
+            //- /lib.rs crate:lib
+            pub mod module {
+                pub struct S;
+                pub use super::sub::*;
+            }
+
+            pub mod sub {
+                pub use super::module;
+            }
+        ",
+        );
+
+        assert_snapshot!(map, @r###"
+        lib:
+        - module (t)
+        - module::S (t)
+        - module::S (v)
+        - sub (t)
+        "###);
+    }
+
+    #[test]
+    fn private_macro() {
+        let map = import_map(
+            r"
+            //- /lib.rs crate:lib
+            macro_rules! private_macro {
+                () => {};
+            }
+        ",
+        );
+
+        assert_snapshot!(map, @r###"
+        lib:
+        "###);
+    }
+
+    #[test]
+    fn namespacing() {
+        let map = import_map(
+            r"
+            //- /lib.rs crate:lib
+            pub struct Thing;     // t + v
+            #[macro_export]
+            macro_rules! Thing {  // m
+                () => {};
+            }
+        ",
+        );
+
+        assert_snapshot!(map, @r###"
+        lib:
+        - Thing (m)
+        - Thing (t)
+        - Thing (v)
+        "###);
+
+        let map = import_map(
+            r"
+            //- /lib.rs crate:lib
+            pub mod Thing {}      // t
+            #[macro_export]
+            macro_rules! Thing {  // m
+                () => {};
+            }
+        ",
+        );
+
+        assert_snapshot!(map, @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;
+            }
+        "#;
+
+        let res = search_dependencies_of(ra_fixture, "main", Query::new("fmt"));
+        assert_snapshot!(res, @r###"
+        dep::fmt (t)
+        dep::Fmt (t)
+        dep::Fmt (v)
+        dep::Fmt (m)
+        dep::fmt::Display (t)
+        dep::format (v)
+        dep::fmt::Display (t)
+        "###);
+
+        let res = search_dependencies_of(ra_fixture, "main", Query::new("fmt").anchor_end());
+        assert_snapshot!(res, @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;
+        "#;
+
+        let res = search_dependencies_of(ra_fixture, "main", Query::new("FMT"));
+
+        assert_snapshot!(res, @r###"
+        dep::fmt (t)
+        dep::fmt (v)
+        dep::FMT (t)
+        dep::FMT (v)
+        "###);
+
+        let res = search_dependencies_of(ra_fixture, "main", Query::new("FMT").case_sensitive());
+
+        assert_snapshot!(res, @r###"
+        dep::FMT (t)
+        dep::FMT (v)
+        "###);
+    }
+
+    #[test]
+    fn search_limit() {
+        let res = search_dependencies_of(
+            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),
+        );
+        assert_snapshot!(res, @r###"
+        dep::fmt (t)
+        dep::Fmt (t)
+        "###);
+    }
+}
diff --git a/crates/ra_hir_def/src/item_scope.rs b/crates/ra_hir_def/src/item_scope.rs
index fc15948ad..beeb98559 100644
--- a/crates/ra_hir_def/src/item_scope.rs
+++ b/crates/ra_hir_def/src/item_scope.rs
@@ -1,18 +1,39 @@
 //! 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 hir_expand::name::Name;
 use once_cell::sync::Lazy;
-use rustc_hash::FxHashMap;
+use ra_db::CrateId;
+use rustc_hash::{FxHashMap, FxHashSet};
+use test_utils::mark;
 
 use crate::{
-    per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, ImplId, MacroDefId, ModuleDefId,
-    TraitId,
+    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 {
-    visible: FxHashMap<Name, PerNs>,
+    types: FxHashMap<Name, (ModuleDefId, Visibility)>,
+    values: FxHashMap<Name, (ModuleDefId, Visibility)>,
+    macros: FxHashMap<Name, (MacroDefId, Visibility)>,
+    unresolved: FxHashSet<Name>,
+
     defs: Vec<ModuleDefId>,
     impls: Vec<ImplId>,
     /// Macros visible in current module in legacy textual scope
@@ -50,14 +71,16 @@ pub(crate) enum BuiltinShadowMode {
 /// 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
-        self.visible.iter().map(|(n, def)| (n, *def))
-    }
+        // FIXME: shadowing
+        let keys: FxHashSet<_> = self
+            .types
+            .keys()
+            .chain(self.values.keys())
+            .chain(self.macros.keys())
+            .chain(self.unresolved.iter())
+            .collect();
 
-    pub fn entries_without_primitives<'a>(
-        &'a self,
-    ) -> impl Iterator<Item = (&'a Name, PerNs)> + 'a {
-        self.visible.iter().map(|(n, def)| (n, *def))
+        keys.into_iter().map(move |name| (name, self.get(name)))
     }
 
     pub fn declarations(&self) -> impl Iterator<Item = ModuleDefId> + '_ {
@@ -76,7 +99,7 @@ impl ItemScope {
 
     /// Iterate over all module scoped macros
     pub(crate) fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
-        self.visible.iter().filter_map(|(name, def)| def.take_macros().map(|macro_| (name, macro_)))
+        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
@@ -86,12 +109,16 @@ impl ItemScope {
 
     /// Get a name from current module scope, legacy macros are not included
     pub(crate) fn get(&self, name: &Name) -> PerNs {
-        self.visible.get(name).copied().unwrap_or_else(PerNs::none)
+        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.visible {
-            if let Some(vis) = item.match_with(*per_ns) {
+        for (name, per_ns) in self.entries() {
+            if let Some(vis) = item.match_with(per_ns) {
                 return Some((name, vis));
             }
         }
@@ -99,8 +126,8 @@ impl ItemScope {
     }
 
     pub(crate) fn traits<'a>(&'a self) -> impl Iterator<Item = TraitId> + 'a {
-        self.visible.values().filter_map(|def| match def.take_types() {
-            Some(ModuleDefId::TraitId(t)) => Some(t),
+        self.types.values().filter_map(|(def, _)| match def {
+            ModuleDefId::TraitId(t) => Some(*t),
             _ => None,
         })
     }
@@ -123,26 +150,99 @@ impl ItemScope {
 
     pub(crate) fn push_res(&mut self, name: Name, def: PerNs) -> bool {
         let mut changed = false;
-        let existing = self.visible.entry(name).or_default();
 
-        if existing.types.is_none() && def.types.is_some() {
-            existing.types = def.types;
-            changed = true;
+        if let Some(types) = def.types {
+            self.types.entry(name.clone()).or_insert_with(|| {
+                changed = true;
+                types
+            });
         }
-        if existing.values.is_none() && def.values.is_some() {
-            existing.values = def.values;
-            changed = true;
+        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;
+                    }
+                    _ => {}
+                }
+            }};
         }
-        if existing.macros.is_none() && def.macros.is_some() {
-            existing.macros = def.macros;
-            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 = (Name, PerNs)> + 'a {
-        self.visible.iter().map(|(name, res)| (name.clone(), *res))
+        self.entries().map(|(name, res)| (name.clone(), res))
     }
 
     pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, MacroDefId> {
@@ -203,4 +303,22 @@ impl ItemInNs {
             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/ra_hir_def/src/item_tree.rs b/crates/ra_hir_def/src/item_tree.rs
new file mode 100644
index 000000000..da79d8ffd
--- /dev/null
+++ b/crates/ra_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 ast::{AstNode, AttrsOwner, NameOwner, StructKind, TypeAscriptionOwner};
+use either::Either;
+use hir_expand::{
+    ast_id_map::FileAstId,
+    hygiene::Hygiene,
+    name::{name, AsName, Name},
+    HirFileId, InFile,
+};
+use ra_arena::{Arena, Idx, RawId};
+use ra_syntax::{ast, match_ast};
+use rustc_hash::FxHashMap;
+use smallvec::SmallVec;
+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::ModuleItem>, SmallVec<[ModItem; 1]>>,
+
+    data: Option<Box<ItemTreeData>>,
+}
+
+impl ItemTree {
+    pub fn item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
+        let _p = ra_prof::profile("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::ModuleItem>) -> &[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::ModuleItem>;
+
+    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! {