1 files changed, 137 insertions, 245 deletions

diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 53599e74a..f9e5701db 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)]
@@ -41,82 +33,27 @@ pub struct FunctionData {
 impl FunctionData {
     pub(crate) fn fn_data_query(db: &impl 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 is_unsafe = src.value.unsafe_token().is_some();
-
-        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, is_unsafe, 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(loc.id.value.into()).clone(),
+            has_self_param: func.has_self_param,
+            is_unsafe: func.is_unsafe,
+            visibility: item_tree[func.visibility].clone(),
+        })
     }
 }
 
-fn desugar_future_path(orig: TypeRef) -> Path {
-    let path = path![core::future::Future];
-    let mut generic_args: Vec<_> = std::iter::repeat(None).take(path.segments.len() - 1).collect();
-    let mut last = GenericArgs::empty();
-    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>,
 }
 
@@ -126,22 +63,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(),
+        })
     }
 }
 
@@ -155,30 +85,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 })
     }
 
@@ -209,33 +133,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 })
     }
 }
 
@@ -250,22 +169,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(),
+        })
     }
 }
 
@@ -279,44 +190,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)> {
@@ -324,62 +216,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(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
 }