optimize some stuff

Veykril · Veykril · commit caefec57e941 · 2025-06-14T15:01:40.000+02:00
diff --git a/crates/hir-def/src/attr.rs b/crates/hir-def/src/attr.rs
@@ -2,7 +2,6 @@
 
 use std::{borrow::Cow, convert::identity, hash::Hash, ops};
 
-use base_db::Crate;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
 use hir_expand::{
@@ -56,12 +55,12 @@ impl Attrs {
         (**self).iter().find(|attr| attr.id == id)
     }
 
-    pub(crate) fn expand_cfg_attr(
-        db: &dyn DefDatabase,
-        krate: Crate,
+    pub(crate) fn expand_cfg_attr<'db>(
+        db: &'db dyn DefDatabase,
+        cfg_options: impl FnOnce() -> &'db CfgOptions,
         raw_attrs: RawAttrs,
     ) -> Attrs {
-        Attrs(raw_attrs.expand_cfg_attr(db, krate))
+        Attrs(raw_attrs.expand_cfg_attr(db, cfg_options))
     }
 
     pub(crate) fn is_cfg_enabled_for(
@@ -105,35 +104,32 @@ impl Attrs {
     ) -> Arc<ArenaMap<LocalFieldId, Attrs>> {
         let _p = tracing::info_span!("fields_attrs_query").entered();
         let mut res = ArenaMap::default();
-        let (fields, file_id, krate) = match v {
+        let (fields, file_id, module) = match v {
             VariantId::EnumVariantId(it) => {
                 let loc = it.lookup(db);
-                let krate = loc.parent.lookup(db).container.krate(db);
                 let source = loc.source(db);
-                (source.value.field_list(), source.file_id, krate)
+                (source.value.field_list(), source.file_id, loc.parent.lookup(db).container)
             }
             VariantId::StructId(it) => {
                 let loc = it.lookup(db);
-                let krate = loc.container.krate(db);
                 let source = loc.source(db);
-                (source.value.field_list(), source.file_id, krate)
+                (source.value.field_list(), source.file_id, loc.container)
             }
             VariantId::UnionId(it) => {
                 let loc = it.lookup(db);
-                let krate = loc.container.krate(db);
                 let source = loc.source(db);
                 (
                     source.value.record_field_list().map(ast::FieldList::RecordFieldList),
                     source.file_id,
-                    krate,
+                    loc.container,
                 )
             }
         };
         let Some(fields) = fields else {
             return Arc::new(res);
         };
 
-        let cfg_options = krate.cfg_options(db);
+        let cfg_options = module.krate(db).cfg_options(db);
         let span_map = db.span_map(file_id);
 
         match fields {
@@ -544,7 +540,7 @@ impl AttrsWithOwner {
                         tree.top_level_raw_attrs().clone()
                     }
                 };
-                Attrs::expand_cfg_attr(db, module.krate(db), raw_attrs)
+                Attrs::expand_cfg_attr(db, || module.krate(db).cfg_options(db), raw_attrs)
             }
             AttrDefId::FieldId(it) => db.fields_attrs(it.parent)[it.local_id].clone(),
             AttrDefId::EnumVariantId(it) => attrs_from_ast_id_loc(db, it),
diff --git a/crates/hir-def/src/expr_store/lower.rs b/crates/hir-def/src/expr_store/lower.rs
@@ -546,9 +546,10 @@ impl ExprCollector<'_> {
     ) -> ExprCollector<'_> {
         let (def_map, local_def_map) = module.local_def_map(db);
         let expander = Expander::new(db, current_file_id, def_map);
+        let krate = module.krate(db);
         ExprCollector {
             db,
-            cfg_options: module.krate(db).cfg_options(db),
+            cfg_options: krate.cfg_options(db),
             module,
             def_map,
             local_def_map,
@@ -562,7 +563,7 @@ impl ExprCollector<'_> {
             awaitable_context: None,
             current_block_legacy_macro_defs_count: FxHashMap::default(),
             outer_impl_trait: false,
-            krate: module.krate(db),
+            krate,
         }
     }
 
diff --git a/crates/hir-def/src/import_map.rs b/crates/hir-def/src/import_map.rs
@@ -141,13 +141,11 @@ impl ImportMap {
             if !visited.insert(module) {
                 continue;
             }
-            let ext_def_map;
             let mod_data = if module.krate(db) == krate {
                 &def_map[module]
             } else {
                 // The crate might reexport a module defined in another crate.
-                ext_def_map = module.def_map(db);
-                &ext_def_map[module]
+                &module.def_map(db)[module]
             };
 
             let visible_items = mod_data.scope.entries().filter_map(|(name, per_ns)| {
diff --git a/crates/hir-def/src/item_scope.rs b/crates/hir-def/src/item_scope.rs
@@ -261,14 +261,12 @@ impl ItemScope {
     pub fn fully_resolve_import(&self, db: &dyn DefDatabase, mut import: ImportId) -> PerNs {
         let mut res = PerNs::none();
 
-        let mut def_map;
         let mut scope = self;
         while let Some(&m) = scope.use_imports_macros.get(&ImportOrExternCrate::Import(import)) {
             match m {
                 ImportOrDef::Import(i) => {
                     let module_id = i.use_.lookup(db).container;
-                    def_map = module_id.def_map(db);
-                    scope = &def_map[module_id].scope;
+                    scope = &module_id.def_map(db)[module_id].scope;
                     import = i;
                 }
                 ImportOrDef::Def(ModuleDefId::MacroId(def)) => {
@@ -283,8 +281,7 @@ impl ItemScope {
             match m {
                 ImportOrDef::Import(i) => {
                     let module_id = i.use_.lookup(db).container;
-                    def_map = module_id.def_map(db);
-                    scope = &def_map[module_id].scope;
+                    scope = &module_id.def_map(db)[module_id].scope;
                     import = i;
                 }
                 ImportOrDef::Def(def) => {
@@ -299,8 +296,7 @@ impl ItemScope {
             match m {
                 ImportOrDef::Import(i) => {
                     let module_id = i.use_.lookup(db).container;
-                    def_map = module_id.def_map(db);
-                    scope = &def_map[module_id].scope;
+                    scope = &module_id.def_map(db)[module_id].scope;
                     import = i;
                 }
                 ImportOrDef::Def(def) => {
@@ -912,10 +908,7 @@ impl ItemInNs {
 
     /// Returns the crate defining this item (or `None` if `self` is built-in).
     pub fn krate(&self, db: &dyn DefDatabase) -> Option<Crate> {
-        match self {
-            ItemInNs::Types(id) | ItemInNs::Values(id) => id.module(db).map(|m| m.krate(db)),
-            ItemInNs::Macros(id) => Some(id.module(db).krate(db)),
-        }
+        self.module(db).map(|module_id| module_id.krate(db))
     }
 
     pub fn module(&self, db: &dyn DefDatabase) -> Option<ModuleId> {
diff --git a/crates/hir-def/src/item_tree.rs b/crates/hir-def/src/item_tree.rs
@@ -203,7 +203,7 @@ impl ItemTree {
 
     /// Returns the inner attributes of the source file.
     pub(crate) fn top_level_attrs(&self, db: &dyn DefDatabase, krate: Crate) -> Attrs {
-        Attrs::expand_cfg_attr(db, krate, self.top_attrs.clone())
+        Attrs::expand_cfg_attr(db, || krate.cfg_options(db), self.top_attrs.clone())
     }
 
     pub(crate) fn raw_attrs(&self, of: FileAstId<ast::Item>) -> &RawAttrs {
@@ -216,7 +216,7 @@ impl ItemTree {
         krate: Crate,
         of: FileAstId<ast::Item>,
     ) -> Attrs {
-        Attrs::expand_cfg_attr(db, krate, self.raw_attrs(of).clone())
+        Attrs::expand_cfg_attr(db, || krate.cfg_options(db), self.raw_attrs(of).clone())
     }
 
     /// Returns a count of a few, expensive items.
diff --git a/crates/hir-def/src/nameres.rs b/crates/hir-def/src/nameres.rs
@@ -420,10 +420,11 @@ pub fn block_def_map(db: &dyn DefDatabase, block_id: BlockId) -> DefMap {
     let module_data =
         ModuleData::new(ModuleOrigin::BlockExpr { block: ast_id, id: block_id }, visibility, None);
 
-    let local_def_map = crate_local_def_map(db, module.krate(db));
+    let krate = module.krate(db);
+    let local_def_map = crate_local_def_map(db, krate);
     let def_map = DefMap::empty(
         db,
-        module.krate(db),
+        krate,
         local_def_map.def_map(db).data.clone(),
         module_data,
         Some(BlockInfo { block: block_id, parent: module }),
diff --git a/crates/hir-def/src/nameres/collector.rs b/crates/hir-def/src/nameres/collector.rs
@@ -1074,7 +1074,6 @@ impl<'db> DefCollector<'db> {
         vis: Visibility,
         import: Option<ImportOrExternCrate>,
     ) {
-        self.db.unwind_if_revision_cancelled();
         self.update_recursive(module_id, resolutions, vis, import, 0)
     }
 
@@ -1706,7 +1705,7 @@ impl ModCollector<'_, '_> {
         // Prelude module is always considered to be `#[macro_use]`.
         if let Some((prelude_module, _use)) = self.def_collector.def_map.prelude {
             // Don't insert macros from the prelude into blocks, as they can be shadowed by other macros.
-            if prelude_module.krate(self.def_collector.db) != krate && is_crate_root {
+            if is_crate_root && prelude_module.krate(self.def_collector.db) != krate {
                 cov_mark::hit!(prelude_is_macro_use);
                 self.def_collector.import_macros_from_extern_crate(
                     prelude_module.krate(self.def_collector.db),
diff --git a/crates/hir-def/src/resolver.rs b/crates/hir-def/src/resolver.rs
@@ -1282,8 +1282,7 @@ impl HasResolver for ModuleId {
     fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
         let (mut def_map, local_def_map) = self.local_def_map(db);
         let mut module_id = self;
-
-        if !self.is_block_module(db) {
+        if def_map.parent().is_none() || module_id != def_map.root_module_id() {
             return Resolver {
                 scopes: vec![],
                 module_scope: ModuleItemMap { def_map, local_def_map, module_id },
@@ -1292,10 +1291,10 @@ impl HasResolver for ModuleId {
 
         let mut modules: SmallVec<[_; 1]> = smallvec![];
         while let Some(parent) = def_map.parent() {
-            let block_def_map = mem::replace(&mut def_map, parent.def_map(db));
-            modules.push(block_def_map);
-            if !parent.is_block_module(db) {
-                module_id = parent;
+            modules.push(def_map);
+            def_map = parent.def_map(db);
+            module_id = parent;
+            if module_id != def_map.root_module_id() {
                 break;
             }
         }
diff --git a/crates/hir-expand/src/attrs.rs b/crates/hir-expand/src/attrs.rs
@@ -2,7 +2,6 @@
 use std::iter;
 use std::{borrow::Cow, fmt, ops};
 
-use base_db::Crate;
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
 use intern::{Interned, Symbol, sym};
@@ -141,14 +140,18 @@ impl RawAttrs {
     }
 
     /// Processes `cfg_attr`s
-    pub fn expand_cfg_attr(self, db: &dyn ExpandDatabase, krate: Crate) -> RawAttrs {
+    pub fn expand_cfg_attr<'db>(
+        self,
+        db: &'db dyn ExpandDatabase,
+        cfg_options: impl FnOnce() -> &'db CfgOptions,
+    ) -> RawAttrs {
         let has_cfg_attrs =
             self.iter().any(|attr| attr.path.as_ident().is_some_and(|name| *name == sym::cfg_attr));
         if !has_cfg_attrs {
             return self;
         }
 
-        let cfg_options = krate.cfg_options(db);
+        let cfg_options = cfg_options();
         let new_attrs = self
             .iter()
             .cloned()

Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ impl ItemTree {`
`203`	`203`
`204`	`204`	`/// Returns the inner attributes of the source file.`
`205`	`205`	`pub(crate) fn top_level_attrs(&self, db: &dyn DefDatabase, krate: Crate) -> Attrs {`
`206`		`- Attrs::expand_cfg_attr(db, krate, self.top_attrs.clone())`
	`206`	`+ Attrs::expand_cfg_attr(db, \|\| krate.cfg_options(db), self.top_attrs.clone())`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`pub(crate) fn raw_attrs(&self, of: FileAstId<ast::Item>) -> &RawAttrs {`
`@@ -216,7 +216,7 @@ impl ItemTree {`
`216`	`216`	`krate: Crate,`
`217`	`217`	`of: FileAstId<ast::Item>,`
`218`	`218`	`) -> Attrs {`
`219`		`- Attrs::expand_cfg_attr(db, krate, self.raw_attrs(of).clone())`
	`219`	`+ Attrs::expand_cfg_attr(db, \|\| krate.cfg_options(db), self.raw_attrs(of).clone())`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`/// Returns a count of a few, expensive items.`