10 files changed, 128 insertions, 155 deletions

diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 9bfcd215a..b1a1bc337 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -267,7 +267,12 @@ impl ModuleDef {
             _ => return,
         };
 
-        hir_ty::diagnostics::validate_module_item(db, id, sink)
+        let module = match self.module(db) {
+            Some(it) => it,
+            None => return,
+        };
+
+        hir_ty::diagnostics::validate_module_item(db, module.id.krate, id, sink)
     }
 }
 
@@ -780,8 +785,9 @@ impl Function {
     }
 
     pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
+        let krate = self.module(db).id.krate;
         hir_def::diagnostics::validate_body(db.upcast(), self.id.into(), sink);
-        hir_ty::diagnostics::validate_module_item(db, self.id.into(), sink);
+        hir_ty::diagnostics::validate_module_item(db, krate, self.id.into(), sink);
         hir_ty::diagnostics::validate_body(db, self.id.into(), sink);
     }
 
diff --git a/crates/hir/src/db.rs b/crates/hir/src/db.rs
index 8d949b264..d01e1b33d 100644
--- a/crates/hir/src/db.rs
+++ b/crates/hir/src/db.rs
@@ -6,8 +6,8 @@ pub use hir_def::db::{
     FunctionDataQuery, GenericParamsQuery, ImplDataQuery, ImportMapQuery, InternConstQuery,
     InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery, InternImplQuery,
     InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery, InternUnionQuery,
-    ItemTreeQuery, LangItemQuery, ModuleLangItemsQuery, StaticDataQuery, StructDataQuery,
-    TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
+    ItemTreeQuery, LangItemQuery, StaticDataQuery, StructDataQuery, TraitDataQuery,
+    TypeAliasDataQuery, UnionDataQuery,
 };
 pub use hir_expand::db::{
     AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,
diff --git a/crates/hir_def/src/db.rs b/crates/hir_def/src/db.rs
index 7f250da33..d1a459066 100644
--- a/crates/hir_def/src/db.rs
+++ b/crates/hir_def/src/db.rs
@@ -16,8 +16,8 @@ use crate::{
     lang_item::{LangItemTarget, LangItems},
     nameres::CrateDefMap,
     AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, EnumLoc, FunctionId, FunctionLoc,
-    GenericDefId, ImplId, ImplLoc, ModuleId, StaticId, StaticLoc, StructId, StructLoc, TraitId,
-    TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
+    GenericDefId, ImplId, ImplLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc,
+    TypeAliasId, TypeAliasLoc, UnionId, UnionLoc,
 };
 
 #[salsa::query_group(InternDatabaseStorage)]
@@ -95,9 +95,6 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast<dyn AstDatabase> {
     #[salsa::invoke(Attrs::attrs_query)]
     fn attrs(&self, def: AttrDefId) -> Attrs;
 
-    #[salsa::invoke(LangItems::module_lang_items_query)]
-    fn module_lang_items(&self, module: ModuleId) -> Option<Arc<LangItems>>;
-
     #[salsa::invoke(LangItems::crate_lang_items_query)]
     fn crate_lang_items(&self, krate: CrateId) -> Arc<LangItems>;
 
diff --git a/crates/hir_def/src/item_tree.rs b/crates/hir_def/src/item_tree.rs
index 8cd0b18cc..b8e09e3af 100644
--- a/crates/hir_def/src/item_tree.rs
+++ b/crates/hir_def/src/item_tree.rs
@@ -646,12 +646,6 @@ pub struct MacroCall {
 pub struct MacroRules {
     /// The name of the declared macro.
     pub name: Name,
-    /// Has `#[macro_export]`.
-    pub is_export: bool,
-    /// Has `#[macro_export(local_inner_macros)]`.
-    pub is_local_inner: bool,
-    /// Has `#[rustc_builtin_macro]`.
-    pub is_builtin: bool,
     pub ast_id: FileAstId<ast::MacroRules>,
 }
 
@@ -660,8 +654,6 @@ pub struct MacroRules {
 pub struct MacroDef {
     pub name: Name,
     pub visibility: RawVisibilityId,
-    /// Has `#[rustc_builtin_macro]`.
-    pub is_builtin: bool,
     pub ast_id: FileAstId<ast::MacroDef>,
 }
 
diff --git a/crates/hir_def/src/item_tree/lower.rs b/crates/hir_def/src/item_tree/lower.rs
index dd3409762..7de385ee8 100644
--- a/crates/hir_def/src/item_tree/lower.rs
+++ b/crates/hir_def/src/item_tree/lower.rs
@@ -539,39 +539,19 @@ impl Ctx {
 
     fn lower_macro_rules(&mut self, m: &ast::MacroRules) -> Option<FileItemTreeId<MacroRules>> {
         let name = m.name().map(|it| it.as_name())?;
-        let attrs = Attrs::new(m, &self.hygiene);
-
         let ast_id = self.source_ast_id_map.ast_id(m);
 
-        // FIXME: cfg_attr
-        let export_attr = attrs.by_key("macro_export");
-
-        let is_export = export_attr.exists();
-        let is_local_inner = if is_export {
-            export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it {
-                tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
-                    ident.text.contains("local_inner_macros")
-                }
-                _ => false,
-            })
-        } else {
-            false
-        };
-
-        let is_builtin = attrs.by_key("rustc_builtin_macro").exists();
-        let res = MacroRules { name, is_export, is_builtin, is_local_inner, ast_id };
+        let res = MacroRules { name, ast_id };
         Some(id(self.data().macro_rules.alloc(res)))
     }
 
     fn lower_macro_def(&mut self, m: &ast::MacroDef) -> Option<FileItemTreeId<MacroDef>> {
         let name = m.name().map(|it| it.as_name())?;
-        let attrs = Attrs::new(m, &self.hygiene);
 
         let ast_id = self.source_ast_id_map.ast_id(m);
         let visibility = self.lower_visibility(m);
 
-        let is_builtin = attrs.by_key("rustc_builtin_macro").exists();
-        let res = MacroDef { name, is_builtin, ast_id, visibility };
+        let res = MacroDef { name, ast_id, visibility };
         Some(id(self.data().macro_defs.alloc(res)))
     }
 
diff --git a/crates/hir_def/src/lang_item.rs b/crates/hir_def/src/lang_item.rs
index 063eadccb..30188b740 100644
--- a/crates/hir_def/src/lang_item.rs
+++ b/crates/hir_def/src/lang_item.rs
@@ -8,8 +8,8 @@ use rustc_hash::FxHashMap;
 use syntax::SmolStr;
 
 use crate::{
-    db::DefDatabase, AdtId, AttrDefId, CrateId, EnumId, FunctionId, ImplId, ModuleDefId, ModuleId,
-    StaticId, StructId, TraitId,
+    db::DefDatabase, AdtId, AttrDefId, CrateId, EnumId, FunctionId, ImplId, ModuleDefId, StaticId,
+    StructId, TraitId,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -84,27 +84,34 @@ impl LangItems {
 
         let crate_def_map = db.crate_def_map(krate);
 
-        crate_def_map
-            .modules
-            .iter()
-            .filter_map(|(local_id, _)| db.module_lang_items(ModuleId { krate, local_id }))
-            .for_each(|it| lang_items.items.extend(it.items.iter().map(|(k, v)| (k.clone(), *v))));
-
-        Arc::new(lang_items)
-    }
+        for (_, module_data) in crate_def_map.modules.iter() {
+            for impl_def in module_data.scope.impls() {
+                lang_items.collect_lang_item(db, impl_def, LangItemTarget::ImplDefId)
+            }
 
-    pub(crate) fn module_lang_items_query(
-        db: &dyn DefDatabase,
-        module: ModuleId,
-    ) -> Option<Arc<LangItems>> {
-        let _p = profile::span("module_lang_items_query");
-        let mut lang_items = LangItems::default();
-        lang_items.collect_lang_items(db, module);
-        if lang_items.items.is_empty() {
-            None
-        } else {
-            Some(Arc::new(lang_items))
+            for def in module_data.scope.declarations() {
+                match def {
+                    ModuleDefId::TraitId(trait_) => {
+                        lang_items.collect_lang_item(db, trait_, LangItemTarget::TraitId)
+                    }
+                    ModuleDefId::AdtId(AdtId::EnumId(e)) => {
+                        lang_items.collect_lang_item(db, e, LangItemTarget::EnumId)
+                    }
+                    ModuleDefId::AdtId(AdtId::StructId(s)) => {
+                        lang_items.collect_lang_item(db, s, LangItemTarget::StructId)
+                    }
+                    ModuleDefId::FunctionId(f) => {
+                        lang_items.collect_lang_item(db, f, LangItemTarget::FunctionId)
+                    }
+                    ModuleDefId::StaticId(s) => {
+                        lang_items.collect_lang_item(db, s, LangItemTarget::StaticId)
+                    }
+                    _ => {}
+                }
+            }
         }
+
+        Arc::new(lang_items)
     }
 
     /// Salsa query. Look for a lang item, starting from the specified crate and recursively
@@ -126,34 +133,6 @@ impl LangItems {
             .find_map(|dep| db.lang_item(dep.crate_id, item.clone()))
     }
 
-    fn collect_lang_items(&mut self, db: &dyn DefDatabase, module: ModuleId) {
-        // Look for impl targets
-        let def_map = db.crate_def_map(module.krate);
-        let module_data = &def_map[module.local_id];
-        for impl_def in module_data.scope.impls() {
-            self.collect_lang_item(db, impl_def, LangItemTarget::ImplDefId)
-        }
-
-        for def in module_data.scope.declarations() {
-            match def {
-                ModuleDefId::TraitId(trait_) => {
-                    self.collect_lang_item(db, trait_, LangItemTarget::TraitId)
-                }
-                ModuleDefId::AdtId(AdtId::EnumId(e)) => {
-                    self.collect_lang_item(db, e, LangItemTarget::EnumId)
-                }
-                ModuleDefId::AdtId(AdtId::StructId(s)) => {
-                    self.collect_lang_item(db, s, LangItemTarget::StructId)
-                }
-                ModuleDefId::FunctionId(f) => {
-                    self.collect_lang_item(db, f, LangItemTarget::FunctionId)
-                }
-                ModuleDefId::StaticId(s) => self.collect_lang_item(db, s, LangItemTarget::StaticId),
-                _ => {}
-            }
-        }
-    }
-
     fn collect_lang_item<T>(
         &mut self,
         db: &dyn DefDatabase,
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 785895277..1936348fb 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -26,7 +26,8 @@ use crate::{
     db::DefDatabase,
     item_scope::{ImportType, PerNsGlobImports},
     item_tree::{
-        self, ItemTree, ItemTreeId, MacroCall, MacroRules, Mod, ModItem, ModKind, StructDefKind,
+        self, FileItemTreeId, ItemTree, ItemTreeId, MacroCall, MacroRules, Mod, ModItem, ModKind,
+        StructDefKind,
     },
     nameres::{
         diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
@@ -967,14 +968,15 @@ impl ModCollector<'_, '_> {
                     })
                 }
                 ModItem::MacroCall(mac) => self.collect_macro_call(&self.item_tree[mac]),
-                ModItem::MacroRules(mac) => self.collect_macro_rules(&self.item_tree[mac]),
+                ModItem::MacroRules(id) => self.collect_macro_rules(id),
                 ModItem::MacroDef(id) => {
                     let mac = &self.item_tree[id];
                     let ast_id = InFile::new(self.file_id, mac.ast_id.upcast());
 
                     // "Macro 2.0" is not currently supported by rust-analyzer, but libcore uses it
                     // to define builtin macros, so we support at least that part.
-                    if mac.is_builtin {
+                    let attrs = self.item_tree.attrs(ModItem::from(id).into());
+                    if attrs.by_key("rustc_builtin_macro").exists() {
                         let krate = self.def_collector.def_map.krate;
                         let macro_id = find_builtin_macro(&mac.name, krate, ast_id)
                             .or_else(|| find_builtin_derive(&mac.name, krate, ast_id));
@@ -1300,18 +1302,34 @@ impl ModCollector<'_, '_> {
         self.def_collector.resolve_proc_macro(&macro_name);
     }
 
-    fn collect_macro_rules(&mut self, mac: &MacroRules) {
+    fn collect_macro_rules(&mut self, id: FileItemTreeId<MacroRules>) {
+        let mac = &self.item_tree[id];
+        let attrs = self.item_tree.attrs(ModItem::from(id).into());
         let ast_id = InFile::new(self.file_id, mac.ast_id.upcast());
 
+        let export_attr = attrs.by_key("macro_export");
+
+        let is_export = export_attr.exists();
+        let is_local_inner = if is_export {
+            export_attr.tt_values().map(|it| &it.token_trees).flatten().any(|it| match it {
+                tt::TokenTree::Leaf(tt::Leaf::Ident(ident)) => {
+                    ident.text.contains("local_inner_macros")
+                }
+                _ => false,
+            })
+        } else {
+            false
+        };
+
         // Case 1: builtin macros
-        if mac.is_builtin {
+        if attrs.by_key("rustc_builtin_macro").exists() {
             let krate = self.def_collector.def_map.krate;
             if let Some(macro_id) = find_builtin_macro(&mac.name, krate, ast_id) {
                 self.def_collector.define_macro(
                     self.module_id,
                     mac.name.clone(),
                     macro_id,
-                    mac.is_export,
+                    is_export,
                 );
                 return;
             }
@@ -1322,9 +1340,9 @@ impl ModCollector<'_, '_> {
             ast_id: Some(ast_id),
             krate: self.def_collector.def_map.krate,
             kind: MacroDefKind::Declarative,
-            local_inner: mac.is_local_inner,
+            local_inner: is_local_inner,
         };
-        self.def_collector.define_macro(self.module_id, mac.name.clone(), macro_id, mac.is_export);
+        self.def_collector.define_macro(self.module_id, mac.name.clone(), macro_id, is_export);
     }
 
     fn collect_macro_call(&mut self, mac: &MacroCall) {
diff --git a/crates/hir_ty/src/diagnostics.rs b/crates/hir_ty/src/diagnostics.rs
index 1c72f766e..14e18f5a1 100644
--- a/crates/hir_ty/src/diagnostics.rs
+++ b/crates/hir_ty/src/diagnostics.rs
@@ -6,6 +6,7 @@ mod decl_check;
 
 use std::{any::Any, fmt};
 
+use base_db::CrateId;
 use hir_def::{DefWithBodyId, ModuleDefId};
 use hir_expand::diagnostics::{Diagnostic, DiagnosticCode, DiagnosticSink};
 use hir_expand::{name::Name, HirFileId, InFile};
@@ -18,12 +19,13 @@ pub use crate::diagnostics::expr::{record_literal_missing_fields, record_pattern
 
 pub fn validate_module_item(
     db: &dyn HirDatabase,
+    krate: CrateId,
     owner: ModuleDefId,
     sink: &mut DiagnosticSink<'_>,
 ) {
     let _p = profile::span("validate_module_item");
-    let mut validator = decl_check::DeclValidator::new(owner, sink);
-    validator.validate_item(db);
+    let mut validator = decl_check::DeclValidator::new(db, krate, sink);
+    validator.validate_item(owner);
 }
 
 pub fn validate_body(db: &dyn HirDatabase, owner: DefWithBodyId, sink: &mut DiagnosticSink<'_>) {
@@ -407,7 +409,7 @@ mod tests {
                 for (module_id, _) in crate_def_map.modules.iter() {
                     for decl in crate_def_map[module_id].scope.declarations() {
                         let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
-                        validate_module_item(self, decl, &mut sink);
+                        validate_module_item(self, krate, decl, &mut sink);
 
                         if let ModuleDefId::FunctionId(f) = decl {
                             fns.push(f)
@@ -419,7 +421,12 @@ mod tests {
                         for item in impl_data.items.iter() {
                             if let AssocItemId::FunctionId(f) = item {
                                 let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
-                                validate_module_item(self, ModuleDefId::FunctionId(*f), &mut sink);
+                                validate_module_item(
+                                    self,
+                                    krate,
+                                    ModuleDefId::FunctionId(*f),
+                                    &mut sink,
+                                );
                                 fns.push(*f)
                             }
                         }
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
index 25587e116..eaeb6899f 100644
--- a/crates/hir_ty/src/diagnostics/decl_check.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -12,6 +12,7 @@
 
 mod case_conv;
 
+use base_db::CrateId;
 use hir_def::{
     adt::VariantData,
     expr::{Pat, PatId},
@@ -40,7 +41,8 @@ mod allow {
 }
 
 pub(super) struct DeclValidator<'a, 'b: 'a> {
-    owner: ModuleDefId,
+    db: &'a dyn HirDatabase,
+    krate: CrateId,
     sink: &'a mut DiagnosticSink<'b>,
 }
 
@@ -53,26 +55,27 @@ struct Replacement {
 
 impl<'a, 'b> DeclValidator<'a, 'b> {
     pub(super) fn new(
-        owner: ModuleDefId,
+        db: &'a dyn HirDatabase,
+        krate: CrateId,
         sink: &'a mut DiagnosticSink<'b>,
     ) -> DeclValidator<'a, 'b> {
-        DeclValidator { owner, sink }
+        DeclValidator { db, krate, sink }
     }
 
-    pub(super) fn validate_item(&mut self, db: &dyn HirDatabase) {
-        match self.owner {
-            ModuleDefId::FunctionId(func) => self.validate_func(db, func),
-            ModuleDefId::AdtId(adt) => self.validate_adt(db, adt),
-            ModuleDefId::ConstId(const_id) => self.validate_const(db, const_id),
-            ModuleDefId::StaticId(static_id) => self.validate_static(db, static_id),
+    pub(super) fn validate_item(&mut self, item: ModuleDefId) {
+        match item {
+            ModuleDefId::FunctionId(func) => self.validate_func(func),
+            ModuleDefId::AdtId(adt) => self.validate_adt(adt),
+            ModuleDefId::ConstId(const_id) => self.validate_const(const_id),
+            ModuleDefId::StaticId(static_id) => self.validate_static(static_id),
             _ => return,
         }
     }
 
-    fn validate_adt(&mut self, db: &dyn HirDatabase, adt: AdtId) {
+    fn validate_adt(&mut self, adt: AdtId) {
         match adt {
-            AdtId::StructId(struct_id) => self.validate_struct(db, struct_id),
-            AdtId::EnumId(enum_id) => self.validate_enum(db, enum_id),
+            AdtId::StructId(struct_id) => self.validate_struct(struct_id),
+            AdtId::EnumId(enum_id) => self.validate_enum(enum_id),
             AdtId::UnionId(_) => {
                 // Unions aren't yet supported by this validator.
             }
@@ -82,27 +85,27 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
     /// Checks whether not following the convention is allowed for this item.
     ///
     /// Currently this method doesn't check parent attributes.
-    fn allowed(&self, db: &dyn HirDatabase, id: AttrDefId, allow_name: &str) -> bool {
-        db.attrs(id).by_key("allow").tt_values().any(|tt| tt.to_string().contains(allow_name))
+    fn allowed(&self, id: AttrDefId, allow_name: &str) -> bool {
+        self.db.attrs(id).by_key("allow").tt_values().any(|tt| tt.to_string().contains(allow_name))
     }
 
-    fn validate_func(&mut self, db: &dyn HirDatabase, func: FunctionId) {
-        let data = db.function_data(func);
+    fn validate_func(&mut self, func: FunctionId) {
+        let data = self.db.function_data(func);
         if data.is_extern {
             mark::hit!(extern_func_incorrect_case_ignored);
             return;
         }
 
-        let body = db.body(func.into());
+        let body = self.db.body(func.into());
 
         // Recursively validate inner scope items, such as static variables and constants.
         for (item_id, _) in body.item_scope.values() {
-            let mut validator = DeclValidator::new(item_id, self.sink);
-            validator.validate_item(db);
+            let mut validator = DeclValidator::new(self.db, self.krate, self.sink);
+            validator.validate_item(item_id);
         }
 
         // Check whether non-snake case identifiers are allowed for this function.
-        if self.allowed(db, func.into(), allow::NON_SNAKE_CASE) {
+        if self.allowed(func.into(), allow::NON_SNAKE_CASE) {
             return;
         }
 
@@ -169,11 +172,10 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
         // If there is at least one element to spawn a warning on, go to the source map and generate a warning.
         self.create_incorrect_case_diagnostic_for_func(
             func,
-            db,
             fn_name_replacement,
             fn_param_replacements,
         );
-        self.create_incorrect_case_diagnostic_for_variables(func, db, pats_replacements);
+        self.create_incorrect_case_diagnostic_for_variables(func, pats_replacements);
     }
 
     /// Given the information about incorrect names in the function declaration, looks up into the source code
@@ -181,7 +183,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
     fn create_incorrect_case_diagnostic_for_func(
         &mut self,
         func: FunctionId,
-        db: &dyn HirDatabase,
         fn_name_replacement: Option<Replacement>,
         fn_param_replacements: Vec<Replacement>,
     ) {
@@ -190,8 +191,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
             return;
         }
 
-        let fn_loc = func.lookup(db.upcast());
-        let fn_src = fn_loc.source(db.upcast());
+        let fn_loc = func.lookup(self.db.upcast());
+        let fn_src = fn_loc.source(self.db.upcast());
 
         // Diagnostic for function name.
         if let Some(replacement) = fn_name_replacement {
@@ -282,7 +283,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
     fn create_incorrect_case_diagnostic_for_variables(
         &mut self,
         func: FunctionId,
-        db: &dyn HirDatabase,
         pats_replacements: Vec<(PatId, Replacement)>,
     ) {
         // XXX: only look at source_map if we do have missing fields
@@ -290,12 +290,12 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
             return;
         }
 
-        let (_, source_map) = db.body_with_source_map(func.into());
+        let (_, source_map) = self.db.body_with_source_map(func.into());
 
         for (id, replacement) in pats_replacements {
             if let Ok(source_ptr) = source_map.pat_syntax(id) {
                 if let Some(expr) = source_ptr.value.as_ref().left() {
-                    let root = source_ptr.file_syntax(db.upcast());
+                    let root = source_ptr.file_syntax(self.db.upcast());
                     if let ast::Pat::IdentPat(ident_pat) = expr.to_node(&root) {
                         let parent = match ident_pat.syntax().parent() {
                             Some(parent) => parent,
@@ -333,12 +333,11 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
         }
     }
 
-    fn validate_struct(&mut self, db: &dyn HirDatabase, struct_id: StructId) {
-        let data = db.struct_data(struct_id);
+    fn validate_struct(&mut self, struct_id: StructId) {
+        let data = self.db.struct_data(struct_id);
 
-        let non_camel_case_allowed =
-            self.allowed(db, struct_id.into(), allow::NON_CAMEL_CASE_TYPES);
-        let non_snake_case_allowed = self.allowed(db, struct_id.into(), allow::NON_SNAKE_CASE);
+        let non_camel_case_allowed = self.allowed(struct_id.into(), allow::NON_CAMEL_CASE_TYPES);
+        let non_snake_case_allowed = self.allowed(struct_id.into(), allow::NON_SNAKE_CASE);
 
         // Check the structure name.
         let struct_name = data.name.to_string();
@@ -379,7 +378,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
         // If there is at least one element to spawn a warning on, go to the source map and generate a warning.
         self.create_incorrect_case_diagnostic_for_struct(
             struct_id,
-            db,
             struct_name_replacement,
             struct_fields_replacements,
         );
@@ -390,7 +388,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
     fn create_incorrect_case_diagnostic_for_struct(
         &mut self,
         struct_id: StructId,
-        db: &dyn HirDatabase,
         struct_name_replacement: Option<Replacement>,
         struct_fields_replacements: Vec<Replacement>,
     ) {
@@ -399,8 +396,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
             return;
         }
 
-        let struct_loc = struct_id.lookup(db.upcast());
-        let struct_src = struct_loc.source(db.upcast());
+        let struct_loc = struct_id.lookup(self.db.upcast());
+        let struct_src = struct_loc.source(self.db.upcast());
 
         if let Some(replacement) = struct_name_replacement {
             let ast_ptr = match struct_src.value.name() {
@@ -473,11 +470,11 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
         }
     }
 
-    fn validate_enum(&mut self, db: &dyn HirDatabase, enum_id: EnumId) {
-        let data = db.enum_data(enum_id);
+    fn validate_enum(&mut self, enum_id: EnumId) {
+        let data = self.db.enum_data(enum_id);
 
         // Check whether non-camel case names are allowed for this enum.
-        if self.allowed(db, enum_id.into(), allow::NON_CAMEL_CASE_TYPES) {
+        if self.allowed(enum_id.into(), allow::NON_CAMEL_CASE_TYPES) {
             return;
         }
 
@@ -512,7 +509,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
         // If there is at least one element to spawn a warning on, go to the source map and generate a warning.
         self.create_incorrect_case_diagnostic_for_enum(
             enum_id,
-            db,
             enum_name_replacement,
             enum_fields_replacements,
         )
@@ -523,7 +519,6 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
     fn create_incorrect_case_diagnostic_for_enum(
         &mut self,
         enum_id: EnumId,
-        db: &dyn HirDatabase,
         enum_name_replacement: Option<Replacement>,
         enum_variants_replacements: Vec<Replacement>,
     ) {
@@ -532,8 +527,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
             return;
         }
 
-        let enum_loc = enum_id.lookup(db.upcast());
-        let enum_src = enum_loc.source(db.upcast());
+        let enum_loc = enum_id.lookup(self.db.upcast());
+        let enum_src = enum_loc.source(self.db.upcast());
 
         if let Some(replacement) = enum_name_replacement {
             let ast_ptr = match enum_src.value.name() {
@@ -608,10 +603,10 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
         }
     }
 
-    fn validate_const(&mut self, db: &dyn HirDatabase, const_id: ConstId) {
-        let data = db.const_data(const_id);
+    fn validate_const(&mut self, const_id: ConstId) {
+        let data = self.db.const_data(const_id);
 
-        if self.allowed(db, const_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
+        if self.allowed(const_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
             return;
         }
 
@@ -632,8 +627,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
             return;
         };
 
-        let const_loc = const_id.lookup(db.upcast());
-        let const_src = const_loc.source(db.upcast());
+        let const_loc = const_id.lookup(self.db.upcast());
+        let const_src = const_loc.source(self.db.upcast());
 
         let ast_ptr = match const_src.value.name() {
             Some(name) => name,
@@ -652,14 +647,14 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
         self.sink.push(diagnostic);
     }
 
-    fn validate_static(&mut self, db: &dyn HirDatabase, static_id: StaticId) {
-        let data = db.static_data(static_id);
+    fn validate_static(&mut self, static_id: StaticId) {
+        let data = self.db.static_data(static_id);
         if data.is_extern {
             mark::hit!(extern_static_incorrect_case_ignored);
             return;
         }
 
-        if self.allowed(db, static_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
+        if self.allowed(static_id.into(), allow::NON_UPPER_CASE_GLOBAL) {
             return;
         }
 
@@ -680,8 +675,8 @@ impl<'a, 'b> DeclValidator<'a, 'b> {
             return;
         };
 
-        let static_loc = static_id.lookup(db.upcast());
-        let static_src = static_loc.source(db.upcast());
+        let static_loc = static_id.lookup(self.db.upcast());
+        let static_src = static_loc.source(self.db.upcast());
 
         let ast_ptr = match static_src.value.name() {
             Some(name) => name,
diff --git a/crates/ide_db/src/apply_change.rs b/crates/ide_db/src/apply_change.rs
index e2251f2b7..71c19ed13 100644
--- a/crates/ide_db/src/apply_change.rs
+++ b/crates/ide_db/src/apply_change.rs
@@ -163,7 +163,6 @@ impl RootDatabase {
             hir::db::ExprScopesQuery
             hir::db::GenericParamsQuery
             hir::db::AttrsQuery
-            hir::db::ModuleLangItemsQuery
             hir::db::CrateLangItemsQuery
             hir::db::LangItemQuery
             hir::db::ImportMapQuery