4 files changed, 77 insertions, 104 deletions

diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 8eef51828..2bc34d449 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -117,7 +117,14 @@ fn lower_enum(
     ast: &InFile<ast::EnumDef>,
     module_id: ModuleId,
 ) {
-    for var in ast.value.variant_list().into_iter().flat_map(|it| it.variants()) {
+    let expander = CfgExpander::new(db, ast.file_id, module_id.krate);
+    let variants = ast
+        .value
+        .variant_list()
+        .into_iter()
+        .flat_map(|it| it.variants())
+        .filter(|var| expander.is_cfg_enabled(var));
+    for var in variants {
         trace.alloc(
             || var.clone(),
             || EnumVariantData {
@@ -209,8 +216,7 @@ fn lower_struct(
     match &ast.value {
         ast::StructKind::Tuple(fl) => {
             for (i, fd) in fl.fields().enumerate() {
-                let attrs = expander.parse_attrs(&fd);
-                if !expander.is_cfg_enabled(&attrs) {
+                if !expander.is_cfg_enabled(&fd) {
                     continue;
                 }
 
@@ -227,8 +233,7 @@ fn lower_struct(
         }
         ast::StructKind::Record(fl) => {
             for fd in fl.fields() {
-                let attrs = expander.parse_attrs(&fd);
-                if !expander.is_cfg_enabled(&attrs) {
+                if !expander.is_cfg_enabled(&fd) {
                     continue;
                 }
 
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index 4edaad960..f5a7305dc 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -60,7 +60,8 @@ impl CfgExpander {
         Attrs::new(owner, &self.hygiene)
     }
 
-    pub(crate) fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
+    pub(crate) fn is_cfg_enabled(&self, owner: &dyn ast::AttrsOwner) -> bool {
+        let attrs = self.parse_attrs(owner);
         attrs.is_cfg_enabled(&self.cfg_options)
     }
 }
@@ -141,12 +142,8 @@ impl Expander {
         InFile { file_id: self.current_file_id, value }
     }
 
-    pub(crate) fn parse_attrs(&self, owner: &dyn ast::AttrsOwner) -> Attrs {
-        self.cfg_expander.parse_attrs(owner)
-    }
-
-    pub(crate) fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
-        self.cfg_expander.is_cfg_enabled(attrs)
+    pub(crate) fn is_cfg_enabled(&self, owner: &dyn ast::AttrsOwner) -> bool {
+        self.cfg_expander.is_cfg_enabled(owner)
     }
 
     fn parse_path(&mut self, path: ast::Path) -> Option<Path> {
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 4671b72e9..443b057ab 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -162,8 +162,7 @@ impl ExprCollector<'_> {
 
     fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
         let syntax_ptr = AstPtr::new(&expr);
-        let attrs = self.expander.parse_attrs(&expr);
-        if !self.expander.is_cfg_enabled(&attrs) {
+        if !self.expander.is_cfg_enabled(&expr) {
             return self.missing_expr();
         }
         match expr {
@@ -329,8 +328,7 @@ impl ExprCollector<'_> {
                         .fields()
                         .inspect(|field| field_ptrs.push(AstPtr::new(field)))
                         .filter_map(|field| {
-                            let attrs = self.expander.parse_attrs(&field);
-                            if !self.expander.is_cfg_enabled(&attrs) {
+                            if !self.expander.is_cfg_enabled(&field) {
                                 return None;
                             }
                             let name = field.field_name()?.as_name();
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
index 7a2067e49..2dbae04d3 100644
--- a/crates/ra_hir_def/src/data.rs
+++ b/crates/ra_hir_def/src/data.rs
@@ -150,51 +150,31 @@ pub struct TraitData {
 
 impl TraitData {
     pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
-        let src = tr.lookup(db).source(db);
+        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 ast_id_map = db.ast_id_map(src.file_id);
+        let module_id = tr_loc.container.module(db);
 
         let container = AssocContainerId::TraitId(tr);
-        let items = if let Some(item_list) = src.value.item_list() {
-            item_list
-                .impl_items()
-                .map(|item_node| match item_node {
-                    ast::ImplItem::FnDef(it) => {
-                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                        let def = FunctionLoc {
-                            container,
-                            ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
-                        }
-                        .intern(db)
-                        .into();
-                        (name, def)
-                    }
-                    ast::ImplItem::ConstDef(it) => {
-                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                        let def = ConstLoc {
-                            container,
-                            ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
-                        }
-                        .intern(db)
-                        .into();
-                        (name, def)
-                    }
-                    ast::ImplItem::TypeAliasDef(it) => {
-                        let name = it.name().map_or_else(Name::missing, |it| it.as_name());
-                        let def = TypeAliasLoc {
-                            container,
-                            ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
-                        }
-                        .intern(db)
-                        .into();
-                        (name, def)
-                    }
-                })
-                .collect()
-        } else {
-            Vec::new()
-        };
+        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.impl_items(),
+                src.file_id,
+                container,
+            ));
+            items.extend(collect_items_in_macros(
+                db,
+                &mut expander,
+                &src.with_value(item_list),
+                container,
+            ));
+        }
         Arc::new(TraitData { name, items, auto })
     }
 
@@ -232,24 +212,22 @@ impl ImplData {
         let target_type = TypeRef::from_ast_opt(&lower_ctx, src.value.target_type());
         let is_negative = src.value.excl_token().is_some();
         let module_id = impl_loc.container.module(db);
+        let container = AssocContainerId::ImplId(id);
 
-        let mut items = Vec::new();
+        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_impl_items(
-                db,
-                &mut expander,
-                item_list.impl_items(),
-                src.file_id,
-                id,
-            ));
-            items.extend(collect_impl_items_in_macros(
-                db,
-                &mut expander,
-                &src.with_value(item_list),
-                id,
-            ));
+            items.extend(
+                collect_items(db, &mut expander, item_list.impl_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 res = ImplData { target_trait, target_type, items, is_negative };
@@ -292,49 +270,50 @@ impl ConstData {
     }
 }
 
-fn collect_impl_items_in_macros(
+fn collect_items_in_macros(
     db: &dyn DefDatabase,
     expander: &mut Expander,
     impl_def: &InFile<ast::ItemList>,
-    id: ImplId,
-) -> Vec<AssocItemId> {
+    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_impl_items_in_macro(db, expander, m, id, limit))
+        res.extend(collect_items_in_macro(db, expander, m, container, limit))
     }
 
     res
 }
 
-fn collect_impl_items_in_macro(
+fn collect_items_in_macro(
     db: &dyn DefDatabase,
     expander: &mut Expander,
     m: ast::MacroCall,
-    id: ImplId,
+    container: AssocContainerId,
     limit: usize,
-) -> Vec<AssocItemId> {
+) -> Vec<(Name, AssocItemId)> {
     if limit == 0 {
         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_impl_items(
+        let mut res = collect_items(
             db,
             expander,
             items.value.items().filter_map(|it| ImplItem::cast(it.syntax().clone())),
             items.file_id,
-            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_impl_items_in_macro(db, expander, it, id, limit - 1))
+            res.extend(collect_items_in_macro(db, expander, it, container, limit - 1))
         }
         expander.exit(db, mark);
         res
@@ -343,44 +322,38 @@ fn collect_impl_items_in_macro(
     }
 }
 
-fn collect_impl_items(
+fn collect_items(
     db: &dyn DefDatabase,
     expander: &mut Expander,
     impl_items: impl Iterator<Item = ImplItem>,
     file_id: crate::HirFileId,
-    id: ImplId,
-) -> Vec<AssocItemId> {
+    container: AssocContainerId,
+) -> Vec<(Name, AssocItemId)> {
     let items = db.ast_id_map(file_id);
 
     impl_items
         .filter_map(|item_node| match item_node {
             ast::ImplItem::FnDef(it) => {
-                let attrs = expander.parse_attrs(&it);
-                if !expander.is_cfg_enabled(&attrs) {
+                let name = it.name().map_or_else(Name::missing, |it| it.as_name());
+                if !expander.is_cfg_enabled(&it) {
                     return None;
                 }
-                let def = FunctionLoc {
-                    container: AssocContainerId::ImplId(id),
-                    ast_id: AstId::new(file_id, items.ast_id(&it)),
-                }
-                .intern(db);
-                Some(def.into())
+                let def = FunctionLoc { container, ast_id: AstId::new(file_id, items.ast_id(&it)) }
+                    .intern(db);
+                Some((name, def.into()))
             }
             ast::ImplItem::ConstDef(it) => {
-                let def = ConstLoc {
-                    container: AssocContainerId::ImplId(id),
-                    ast_id: AstId::new(file_id, items.ast_id(&it)),
-                }
-                .intern(db);
-                Some(def.into())
+                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()))
             }
             ast::ImplItem::TypeAliasDef(it) => {
-                let def = TypeAliasLoc {
-                    container: AssocContainerId::ImplId(id),
-                    ast_id: AstId::new(file_id, items.ast_id(&it)),
-                }
-                .intern(db);
-                Some(def.into())
+                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()))
             }
         })
         .collect()