6 files changed, 165 insertions, 166 deletions

diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 7a9747fc7..849c8f6d0 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -908,12 +908,12 @@ impl MacroDef {
 
     /// Indicate it is a proc-macro
     pub fn is_proc_macro(&self) -> bool {
-        matches!(self.id.kind, MacroDefKind::CustomDerive(_))
+        matches!(self.id.kind, MacroDefKind::ProcMacro(_))
     }
 
     /// Indicate it is a derive macro
     pub fn is_derive_macro(&self) -> bool {
-        matches!(self.id.kind, MacroDefKind::CustomDerive(_) | MacroDefKind::BuiltInDerive(_))
+        matches!(self.id.kind, MacroDefKind::ProcMacro(_) | MacroDefKind::BuiltInDerive(_))
     }
 }
 
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index c1e1d53f6..4c3993ff0 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -273,7 +273,7 @@ impl DefCollector<'_> {
             let macro_id = MacroDefId {
                 ast_id: None,
                 krate: Some(krate),
-                kind: MacroDefKind::CustomDerive(expander),
+                kind: MacroDefKind::ProcMacro(expander),
                 local_inner: false,
             };
 
@@ -874,184 +874,183 @@ impl ModCollector<'_, '_> {
 
         for &item in items {
             let attrs = self.item_tree.attrs(item.into());
-            if self.is_cfg_enabled(attrs) {
-                let module =
-                    ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
-                let container = ContainerId::ModuleId(module);
-
-                let mut def = None;
-                match item {
-                    ModItem::Mod(m) => self.collect_module(&self.item_tree[m], attrs),
-                    ModItem::Import(import_id) => {
-                        self.def_collector.unresolved_imports.push(ImportDirective {
-                            module_id: self.module_id,
-                            import: Import::from_use(
-                                &self.item_tree,
-                                InFile::new(self.file_id, import_id),
-                            ),
-                            status: PartialResolvedImport::Unresolved,
-                        })
-                    }
-                    ModItem::ExternCrate(import_id) => {
-                        self.def_collector.unresolved_imports.push(ImportDirective {
-                            module_id: self.module_id,
-                            import: Import::from_extern_crate(
-                                &self.item_tree,
-                                InFile::new(self.file_id, import_id),
-                            ),
-                            status: PartialResolvedImport::Unresolved,
-                        })
-                    }
-                    ModItem::MacroCall(mac) => self.collect_macro(&self.item_tree[mac]),
-                    ModItem::Impl(imp) => {
-                        let module = ModuleId {
-                            krate: self.def_collector.def_map.krate,
-                            local_id: self.module_id,
-                        };
-                        let container = ContainerId::ModuleId(module);
-                        let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
-                            .intern(self.def_collector.db);
-                        self.def_collector.def_map.modules[self.module_id]
-                            .scope
-                            .define_impl(impl_id)
-                    }
-                    ModItem::Function(id) => {
-                        let func = &self.item_tree[id];
-                        def = Some(DefData {
-                            id: FunctionLoc {
-                                container: container.into(),
-                                id: ItemTreeId::new(self.file_id, id),
-                            }
-                            .intern(self.def_collector.db)
-                            .into(),
-                            name: &func.name,
-                            visibility: &self.item_tree[func.visibility],
-                            has_constructor: false,
-                        });
-                    }
-                    ModItem::Struct(id) => {
-                        let it = &self.item_tree[id];
-
-                        // FIXME: check attrs to see if this is an attribute macro invocation;
-                        // in which case we don't add the invocation, just a single attribute
-                        // macro invocation
-                        self.collect_derives(attrs, it.ast_id.upcast());
-
-                        def = Some(DefData {
-                            id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
-                                .into(),
-                            name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
-                            has_constructor: it.kind != StructDefKind::Record,
-                        });
-                    }
-                    ModItem::Union(id) => {
-                        let it = &self.item_tree[id];
+            if !self.is_cfg_enabled(attrs) {
+                continue;
+            }
+            let module =
+                ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
+            let container = ContainerId::ModuleId(module);
+
+            let mut def = None;
+            match item {
+                ModItem::Mod(m) => self.collect_module(&self.item_tree[m], attrs),
+                ModItem::Import(import_id) => {
+                    self.def_collector.unresolved_imports.push(ImportDirective {
+                        module_id: self.module_id,
+                        import: Import::from_use(
+                            &self.item_tree,
+                            InFile::new(self.file_id, import_id),
+                        ),
+                        status: PartialResolvedImport::Unresolved,
+                    })
+                }
+                ModItem::ExternCrate(import_id) => {
+                    self.def_collector.unresolved_imports.push(ImportDirective {
+                        module_id: self.module_id,
+                        import: Import::from_extern_crate(
+                            &self.item_tree,
+                            InFile::new(self.file_id, import_id),
+                        ),
+                        status: PartialResolvedImport::Unresolved,
+                    })
+                }
+                ModItem::MacroCall(mac) => self.collect_macro(&self.item_tree[mac]),
+                ModItem::Impl(imp) => {
+                    let module = ModuleId {
+                        krate: self.def_collector.def_map.krate,
+                        local_id: self.module_id,
+                    };
+                    let container = ContainerId::ModuleId(module);
+                    let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
+                        .intern(self.def_collector.db);
+                    self.def_collector.def_map.modules[self.module_id].scope.define_impl(impl_id)
+                }
+                ModItem::Function(id) => {
+                    let func = &self.item_tree[id];
+                    def = Some(DefData {
+                        id: FunctionLoc {
+                            container: container.into(),
+                            id: ItemTreeId::new(self.file_id, id),
+                        }
+                        .intern(self.def_collector.db)
+                        .into(),
+                        name: &func.name,
+                        visibility: &self.item_tree[func.visibility],
+                        has_constructor: false,
+                    });
+                }
+                ModItem::Struct(id) => {
+                    let it = &self.item_tree[id];
 
-                        // FIXME: check attrs to see if this is an attribute macro invocation;
-                        // in which case we don't add the invocation, just a single attribute
-                        // macro invocation
-                        self.collect_derives(attrs, it.ast_id.upcast());
+                    // FIXME: check attrs to see if this is an attribute macro invocation;
+                    // in which case we don't add the invocation, just a single attribute
+                    // macro invocation
+                    self.collect_derives(attrs, it.ast_id.upcast());
 
-                        def = Some(DefData {
-                            id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
-                                .into(),
-                            name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
-                        });
-                    }
-                    ModItem::Enum(id) => {
-                        let it = &self.item_tree[id];
+                    def = Some(DefData {
+                        id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                            .intern(self.def_collector.db)
+                            .into(),
+                        name: &it.name,
+                        visibility: &self.item_tree[it.visibility],
+                        has_constructor: it.kind != StructDefKind::Record,
+                    });
+                }
+                ModItem::Union(id) => {
+                    let it = &self.item_tree[id];
 
-                        // FIXME: check attrs to see if this is an attribute macro invocation;
-                        // in which case we don't add the invocation, just a single attribute
-                        // macro invocation
-                        self.collect_derives(attrs, it.ast_id.upcast());
+                    // FIXME: check attrs to see if this is an attribute macro invocation;
+                    // in which case we don't add the invocation, just a single attribute
+                    // macro invocation
+                    self.collect_derives(attrs, it.ast_id.upcast());
 
-                        def = Some(DefData {
-                            id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
-                                .into(),
-                            name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
-                        });
-                    }
-                    ModItem::Const(id) => {
-                        let it = &self.item_tree[id];
-
-                        if let Some(name) = &it.name {
-                            def = Some(DefData {
-                                id: ConstLoc {
-                                    container: container.into(),
-                                    id: ItemTreeId::new(self.file_id, id),
-                                }
-                                .intern(self.def_collector.db)
-                                .into(),
-                                name,
-                                visibility: &self.item_tree[it.visibility],
-                                has_constructor: false,
-                            });
-                        }
-                    }
-                    ModItem::Static(id) => {
-                        let it = &self.item_tree[id];
+                    def = Some(DefData {
+                        id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                            .intern(self.def_collector.db)
+                            .into(),
+                        name: &it.name,
+                        visibility: &self.item_tree[it.visibility],
+                        has_constructor: false,
+                    });
+                }
+                ModItem::Enum(id) => {
+                    let it = &self.item_tree[id];
 
-                        def = Some(DefData {
-                            id: StaticLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
-                                .into(),
-                            name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
-                        });
-                    }
-                    ModItem::Trait(id) => {
-                        let it = &self.item_tree[id];
+                    // FIXME: check attrs to see if this is an attribute macro invocation;
+                    // in which case we don't add the invocation, just a single attribute
+                    // macro invocation
+                    self.collect_derives(attrs, it.ast_id.upcast());
 
-                        def = Some(DefData {
-                            id: TraitLoc { container, id: ItemTreeId::new(self.file_id, id) }
-                                .intern(self.def_collector.db)
-                                .into(),
-                            name: &it.name,
-                            visibility: &self.item_tree[it.visibility],
-                            has_constructor: false,
-                        });
-                    }
-                    ModItem::TypeAlias(id) => {
-                        let it = &self.item_tree[id];
+                    def = Some(DefData {
+                        id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                            .intern(self.def_collector.db)
+                            .into(),
+                        name: &it.name,
+                        visibility: &self.item_tree[it.visibility],
+                        has_constructor: false,
+                    });
+                }
+                ModItem::Const(id) => {
+                    let it = &self.item_tree[id];
 
+                    if let Some(name) = &it.name {
                         def = Some(DefData {
-                            id: TypeAliasLoc {
+                            id: ConstLoc {
                                 container: container.into(),
                                 id: ItemTreeId::new(self.file_id, id),
                             }
                             .intern(self.def_collector.db)
                             .into(),
-                            name: &it.name,
+                            name,
                             visibility: &self.item_tree[it.visibility],
                             has_constructor: false,
                         });
                     }
                 }
+                ModItem::Static(id) => {
+                    let it = &self.item_tree[id];
 
-                if let Some(DefData { id, name, visibility, has_constructor }) = def {
-                    self.def_collector.def_map.modules[self.module_id].scope.define_def(id);
-                    let vis = self
-                        .def_collector
-                        .def_map
-                        .resolve_visibility(self.def_collector.db, self.module_id, visibility)
-                        .unwrap_or(Visibility::Public);
-                    self.def_collector.update(
-                        self.module_id,
-                        &[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor))],
-                        vis,
-                        ImportType::Named,
-                    )
+                    def = Some(DefData {
+                        id: StaticLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                            .intern(self.def_collector.db)
+                            .into(),
+                        name: &it.name,
+                        visibility: &self.item_tree[it.visibility],
+                        has_constructor: false,
+                    });
+                }
+                ModItem::Trait(id) => {
+                    let it = &self.item_tree[id];
+
+                    def = Some(DefData {
+                        id: TraitLoc { container, id: ItemTreeId::new(self.file_id, id) }
+                            .intern(self.def_collector.db)
+                            .into(),
+                        name: &it.name,
+                        visibility: &self.item_tree[it.visibility],
+                        has_constructor: false,
+                    });
                 }
+                ModItem::TypeAlias(id) => {
+                    let it = &self.item_tree[id];
+
+                    def = Some(DefData {
+                        id: TypeAliasLoc {
+                            container: container.into(),
+                            id: ItemTreeId::new(self.file_id, id),
+                        }
+                        .intern(self.def_collector.db)
+                        .into(),
+                        name: &it.name,
+                        visibility: &self.item_tree[it.visibility],
+                        has_constructor: false,
+                    });
+                }
+            }
+
+            if let Some(DefData { id, name, visibility, has_constructor }) = def {
+                self.def_collector.def_map.modules[self.module_id].scope.define_def(id);
+                let vis = self
+                    .def_collector
+                    .def_map
+                    .resolve_visibility(self.def_collector.db, self.module_id, visibility)
+                    .unwrap_or(Visibility::Public);
+                self.def_collector.update(
+                    self.module_id,
+                    &[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor))],
+                    vis,
+                    ImportType::Named,
+                )
             }
         }
     }
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 710694a34..b591130ca 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -143,7 +143,7 @@ pub(crate) fn macro_def(
             Some(Arc::new((TokenExpander::BuiltinDerive(expander), mbe::TokenMap::default())))
         }
         MacroDefKind::BuiltInEager(_) => None,
-        MacroDefKind::CustomDerive(expander) => {
+        MacroDefKind::ProcMacro(expander) => {
             Some(Arc::new((TokenExpander::ProcMacro(expander), mbe::TokenMap::default())))
         }
     }
@@ -249,7 +249,7 @@ pub(crate) fn expand_proc_macro(
     };
 
     let expander = match loc.def.kind {
-        MacroDefKind::CustomDerive(expander) => expander,
+        MacroDefKind::ProcMacro(expander) => expander,
         _ => unreachable!(),
     };
 
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index 10c45646f..2f37d7189 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -129,7 +129,7 @@ fn eager_macro_recur(
             MacroDefKind::Declarative
             | MacroDefKind::BuiltIn(_)
             | MacroDefKind::BuiltInDerive(_)
-            | MacroDefKind::CustomDerive(_) => {
+            | MacroDefKind::ProcMacro(_) => {
                 let expanded = lazy_expand(db, &def, curr.with_value(child.clone()), krate)?;
                 // replace macro inside
                 eager_macro_recur(db, expanded, krate, macro_resolver)?
diff --git a/crates/hir_expand/src/hygiene.rs b/crates/hir_expand/src/hygiene.rs
index 845e9cbc1..d383b968d 100644
--- a/crates/hir_expand/src/hygiene.rs
+++ b/crates/hir_expand/src/hygiene.rs
@@ -33,7 +33,7 @@ impl Hygiene {
                         MacroDefKind::BuiltIn(_) => (None, false),
                         MacroDefKind::BuiltInDerive(_) => (None, false),
                         MacroDefKind::BuiltInEager(_) => (None, false),
-                        MacroDefKind::CustomDerive(_) => (None, false),
+                        MacroDefKind::ProcMacro(_) => (None, false),
                     }
                 }
                 MacroCallId::EagerMacro(_id) => (None, false),
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 2be15e841..17f1178ed 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -246,7 +246,7 @@ pub enum MacroDefKind {
     // FIXME: maybe just Builtin and rename BuiltinFnLikeExpander to BuiltinExpander
     BuiltInDerive(BuiltinDeriveExpander),
     BuiltInEager(EagerExpander),
-    CustomDerive(ProcMacroExpander),
+    ProcMacro(ProcMacroExpander),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]