Merge pull request #22328 from ChayimFriedman2/variant-name

internal: Remove interning from query_group

Author: Veykril

crates/hir-def/src/db.rs

@@ -7,77 +7,16 @@ use hir_expand::{
 use triomphe::Arc;
 
 use crate::{
-    AssocItemId, AttrDefId, BlockId, BlockLoc, ConstId, ConstLoc, EnumId, EnumLoc, EnumVariantId,
-    EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId, ExternCrateLoc, FunctionId,
-    FunctionLoc, ImplId, ImplLoc, Macro2Id, Macro2Loc, MacroExpander, MacroId, MacroRulesId,
-    MacroRulesLoc, MacroRulesLocFlags, ProcMacroId, ProcMacroLoc, StaticId, StaticLoc, StructId,
-    StructLoc, TraitId, TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc,
+    AssocItemId, AttrDefId, Macro2Loc, MacroExpander, MacroId, MacroRulesLoc, MacroRulesLocFlags,
+    TraitId,
     attrs::AttrFlags,
     item_tree::{ItemTree, file_item_tree},
     nameres::crate_def_map,
     visibility::{self, Visibility},
 };
 
-use salsa::plumbing::AsId;
-
-#[query_group::query_group(InternDatabaseStorage)]
-pub trait InternDatabase: SourceDatabase {
-    // region: items
-    #[salsa::interned]
-    fn intern_use(&self, loc: UseLoc) -> UseId;
-
-    #[salsa::interned]
-    fn intern_extern_crate(&self, loc: ExternCrateLoc) -> ExternCrateId;
-
-    #[salsa::interned]
-    fn intern_function(&self, loc: FunctionLoc) -> FunctionId;
-
-    #[salsa::interned]
-    fn intern_struct(&self, loc: StructLoc) -> StructId;
-
-    #[salsa::interned]
-    fn intern_union(&self, loc: UnionLoc) -> UnionId;
-
-    #[salsa::interned]
-    fn intern_enum(&self, loc: EnumLoc) -> EnumId;
-
-    #[salsa::interned]
-    fn intern_enum_variant(&self, loc: EnumVariantLoc) -> EnumVariantId;
-
-    #[salsa::interned]
-    fn intern_const(&self, loc: ConstLoc) -> ConstId;
-
-    #[salsa::interned]
-    fn intern_static(&self, loc: StaticLoc) -> StaticId;
-
-    #[salsa::interned]
-    fn intern_trait(&self, loc: TraitLoc) -> TraitId;
-
-    #[salsa::interned]
-    fn intern_type_alias(&self, loc: TypeAliasLoc) -> TypeAliasId;
-
-    #[salsa::interned]
-    fn intern_impl(&self, loc: ImplLoc) -> ImplId;
-
-    #[salsa::interned]
-    fn intern_extern_block(&self, loc: ExternBlockLoc) -> ExternBlockId;
-
-    #[salsa::interned]
-    fn intern_macro2(&self, loc: Macro2Loc) -> Macro2Id;
-
-    #[salsa::interned]
-    fn intern_proc_macro(&self, loc: ProcMacroLoc) -> ProcMacroId;
-
-    #[salsa::interned]
-    fn intern_macro_rules(&self, loc: MacroRulesLoc) -> MacroRulesId;
-    // endregion: items
-
-    #[salsa::interned]
-    fn intern_block(&self, loc: BlockLoc) -> BlockId;
-}
-
 #[query_group::query_group]
-pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
+pub trait DefDatabase: ExpandDatabase + SourceDatabase {
     /// Whether to expand procedural macros during name resolution.
     #[salsa::input]
     fn expand_proc_attr_macros(&self) -> bool;
@@ -118,11 +57,7 @@ fn include_macro_invoc(
         .modules
         .values()
         .flat_map(|m| m.scope.iter_macro_invoc())
-        .filter_map(|invoc| {
-            db.lookup_intern_macro_call(*invoc.1)
-                .include_file_id(db, *invoc.1)
-                .map(|x| (*invoc.1, x))
-        })
+        .filter_map(|invoc| invoc.1.loc(db).include_file_id(db, *invoc.1).map(|x| (*invoc.1, x)))
         .collect()
 }
 

crates/hir-def/src/expr_store/lower.rs

@@ -2501,7 +2501,7 @@ impl<'db> ExprCollector<'db> {
     ) -> ExprId {
         let block_id = self.expander.ast_id_map().ast_id_for_block(&block).map(|file_local_id| {
             let ast_id = self.expander.in_file(file_local_id);
-            self.db.intern_block(BlockLoc { ast_id, module: self.module })
+            BlockId::new(self.db, BlockLoc { ast_id, module: self.module })
         });
 
         let (module, def_map) =
@@ -2953,7 +2953,7 @@ impl<'db> ExprCollector<'db> {
             None
         } else {
             hygiene_id.syntax_context().outer_expn(self.db).map(|expansion| {
-                let expansion = self.db.lookup_intern_macro_call(expansion.into());
+                let expansion = hir_expand::MacroCallId::from(expansion).loc(self.db);
                 (hygiene_id.syntax_context().parent(self.db), expansion.def)
             })
         };
@@ -2983,7 +2983,7 @@ impl<'db> ExprCollector<'db> {
 
                         hygiene_id = HygieneId::new(parent_ctx.opaque_and_semiopaque(self.db));
                         hygiene_info = parent_ctx.outer_expn(self.db).map(|expansion| {
-                            let expansion = self.db.lookup_intern_macro_call(expansion.into());
+                            let expansion = hir_expand::MacroCallId::from(expansion).loc(self.db);
                             (parent_ctx.parent(self.db), expansion.def)
                         });
                     }

crates/hir-def/src/expr_store/lower/path.rs

@@ -217,7 +217,7 @@ pub(super) fn lower_path(
     {
         let syn_ctxt = collector.expander.ctx_for_range(path.segment()?.syntax().text_range());
         if let Some(macro_call_id) = syn_ctxt.outer_expn(collector.db)
-            && collector.db.lookup_intern_macro_call(macro_call_id.into()).def.local_inner
+            && hir_expand::MacroCallId::from(macro_call_id).loc(collector.db).def.local_inner
         {
             kind = match resolve_crate_root(collector.db, syn_ctxt) {
                 Some(crate_root) => PathKind::DollarCrate(crate_root),

crates/hir-def/src/lib.rs

@@ -220,9 +220,9 @@ impl<N: AstIdNode> AstIdLoc for AssocItemLoc<N> {
 }
 
 macro_rules! impl_intern {
-    ($id:ident, $loc:ident, $intern:ident, $lookup:ident) => {
+    ($id:ident, $loc:ident) => {
         impl_intern_key!($id, $loc);
-        impl_intern_lookup!(DefDatabase, $id, $loc, $intern, $lookup);
+        impl_intern_lookup!(DefDatabase, $id, $loc);
     };
 }
 
@@ -249,10 +249,10 @@ macro_rules! impl_loc {
 }
 
 type FunctionLoc = AssocItemLoc<ast::Fn>;
-impl_intern!(FunctionId, FunctionLoc, intern_function, lookup_intern_function);
+impl_intern!(FunctionId, FunctionLoc);
 
 type StructLoc = ItemLoc<ast::Struct>;
-impl_intern!(StructId, StructLoc, intern_struct, lookup_intern_struct);
+impl_intern!(StructId, StructLoc);
 
 impl StructId {
     pub fn fields(self, db: &dyn DefDatabase) -> &VariantFields {
@@ -269,7 +269,7 @@ impl StructId {
 }
 
 pub type UnionLoc = ItemLoc<ast::Union>;
-impl_intern!(UnionId, UnionLoc, intern_union, lookup_intern_union);
+impl_intern!(UnionId, UnionLoc);
 
 impl UnionId {
     pub fn fields(self, db: &dyn DefDatabase) -> &VariantFields {
@@ -286,7 +286,7 @@ impl UnionId {
 }
 
 pub type EnumLoc = ItemLoc<ast::Enum>;
-impl_intern!(EnumId, EnumLoc, intern_enum, lookup_intern_enum);
+impl_intern!(EnumId, EnumLoc);
 
 impl EnumId {
     #[inline]
@@ -304,13 +304,13 @@ impl EnumId {
 }
 
 type ConstLoc = AssocItemLoc<ast::Const>;
-impl_intern!(ConstId, ConstLoc, intern_const, lookup_intern_const);
+impl_intern!(ConstId, ConstLoc);
 
 pub type StaticLoc = AssocItemLoc<ast::Static>;
-impl_intern!(StaticId, StaticLoc, intern_static, lookup_intern_static);
+impl_intern!(StaticId, StaticLoc);
 
 pub type TraitLoc = ItemLoc<ast::Trait>;
-impl_intern!(TraitId, TraitLoc, intern_trait, lookup_intern_trait);
+impl_intern!(TraitId, TraitLoc);
 
 impl TraitId {
     #[inline]
@@ -320,10 +320,10 @@ impl TraitId {
 }
 
 type TypeAliasLoc = AssocItemLoc<ast::TypeAlias>;
-impl_intern!(TypeAliasId, TypeAliasLoc, intern_type_alias, lookup_intern_type_alias);
+impl_intern!(TypeAliasId, TypeAliasLoc);
 
 type ImplLoc = ItemLoc<ast::Impl>;
-impl_intern!(ImplId, ImplLoc, intern_impl, lookup_intern_impl);
+impl_intern!(ImplId, ImplLoc);
 
 impl ImplId {
     #[inline]
@@ -353,13 +353,13 @@ pub struct BuiltinDeriveImplId {
 }
 
 type UseLoc = ItemLoc<ast::Use>;
-impl_intern!(UseId, UseLoc, intern_use, lookup_intern_use);
+impl_intern!(UseId, UseLoc);
 
 type ExternCrateLoc = ItemLoc<ast::ExternCrate>;
-impl_intern!(ExternCrateId, ExternCrateLoc, intern_extern_crate, lookup_intern_extern_crate);
+impl_intern!(ExternCrateId, ExternCrateLoc);
 
 type ExternBlockLoc = ItemLoc<ast::ExternBlock>;
-impl_intern!(ExternBlockId, ExternBlockLoc, intern_extern_block, lookup_intern_extern_block);
+impl_intern!(ExternBlockId, ExternBlockLoc);
 
 impl ExternBlockId {
     pub fn abi(self, db: &dyn DefDatabase) -> ExternAbi {
@@ -373,7 +373,7 @@ pub struct EnumVariantLoc {
     pub parent: EnumId,
     pub index: u32,
 }
-impl_intern!(EnumVariantId, EnumVariantLoc, intern_enum_variant, lookup_intern_enum_variant);
+impl_intern!(EnumVariantId, EnumVariantLoc);
 impl_loc!(EnumVariantLoc, id: Variant, parent: EnumId);
 
 impl EnumVariantId {
@@ -398,7 +398,7 @@ pub struct Macro2Loc {
     pub allow_internal_unsafe: bool,
     pub edition: Edition,
 }
-impl_intern!(Macro2Id, Macro2Loc, intern_macro2, lookup_intern_macro2);
+impl_intern!(Macro2Id, Macro2Loc);
 impl_loc!(Macro2Loc, id: MacroDef, container: ModuleId);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -409,7 +409,7 @@ pub struct MacroRulesLoc {
     pub flags: MacroRulesLocFlags,
     pub edition: Edition,
 }
-impl_intern!(MacroRulesId, MacroRulesLoc, intern_macro_rules, lookup_intern_macro_rules);
+impl_intern!(MacroRulesId, MacroRulesLoc);
 impl_loc!(MacroRulesLoc, id: MacroRules, container: ModuleId);
 
 bitflags::bitflags! {
@@ -437,7 +437,7 @@ pub struct ProcMacroLoc {
     pub kind: ProcMacroKind,
     pub edition: Edition,
 }
-impl_intern!(ProcMacroId, ProcMacroLoc, intern_proc_macro, lookup_intern_proc_macro);
+impl_intern!(ProcMacroId, ProcMacroLoc);
 impl_loc!(ProcMacroLoc, id: Fn, container: ModuleId);
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone)]
@@ -446,7 +446,7 @@ pub struct BlockLoc {
     /// The containing module.
     pub module: ModuleId,
 }
-impl_intern!(BlockId, BlockLoc, intern_block, lookup_intern_block);
+impl_intern!(BlockId, BlockLoc);
 
 #[salsa_macros::tracked(debug)]
 #[derive(PartialOrd, Ord)]

crates/hir-def/src/macro_expansion_tests/mod.rs

@@ -64,7 +64,7 @@ fn check_errors(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expect)
         .filter_map(|macro_call| {
             let errors = db.parse_macro_expansion_error(macro_call)?;
             let errors = errors.err.as_ref()?.render_to_string(&db);
-            let macro_loc = db.lookup_intern_macro_call(macro_call);
+            let macro_loc = macro_call.loc(&db);
             let ast_id = match macro_loc.kind {
                 MacroCallKind::FnLike { ast_id, .. } => ast_id.map(|it| it.erase()),
                 MacroCallKind::Derive { ast_id, .. } => ast_id.map(|it| it.erase()),

crates/hir-def/src/nameres/assoc.rs

@@ -217,7 +217,7 @@ impl<'db> AssocItemCollector<'db> {
                 attr_id,
             ) {
                 Ok(ResolvedAttr::Macro(call_id)) => {
-                    let loc = self.db.lookup_intern_macro_call(call_id);
+                    let loc = call_id.loc(self.db);
                     if let MacroDefKind::ProcMacro(_, exp, _) = loc.def.kind {
                         // If there's no expander for the proc macro (e.g. the
                         // proc macro is ignored, or building the proc macro

crates/hir-def/src/resolver.rs

@@ -936,7 +936,7 @@ fn handle_macro_def_scope(
         // and use its parent expansion.
         *hygiene_id = HygieneId::new(parent_ctx.opaque_and_semiopaque(db));
         *hygiene_info = parent_ctx.outer_expn(db).map(|expansion| {
-            let expansion = db.lookup_intern_macro_call(expansion.into());
+            let expansion = hir_expand::MacroCallId::from(expansion).loc(db);
             (parent_ctx.parent(db), expansion.def)
         });
     }
@@ -950,7 +950,7 @@ fn hygiene_info(
     if !hygiene_id.is_root() {
         let ctx = hygiene_id.syntax_context();
         ctx.outer_expn(db).map(|expansion| {
-            let expansion = db.lookup_intern_macro_call(expansion.into());
+            let expansion = hir_expand::MacroCallId::from(expansion).loc(db);
             (ctx.parent(db), expansion.def)
         })
     } else {

crates/hir-expand/src/builtin/attr_macro.rs

@@ -122,7 +122,7 @@ fn derive_expand(
     tt: &tt::TopSubtree,
     span: Span,
 ) -> ExpandResult<tt::TopSubtree> {
-    let loc = db.lookup_intern_macro_call(id);
+    let loc = id.loc(db);
     let derives = match &loc.kind {
         MacroCallKind::Attr { attr_args: Some(attr_args), .. } if loc.def.is_attribute_derive() => {
             attr_args

crates/hir-expand/src/builtin/fn_macro.rs

@@ -357,7 +357,7 @@ fn cfg_select_expand(
     tt: &tt::TopSubtree,
     span: Span,
 ) -> ExpandResult<tt::TopSubtree> {
-    let loc = db.lookup_intern_macro_call(id);
+    let loc = id.loc(db);
     let cfg_options = loc.krate.cfg_options(db);
 
     let mut iter = tt.iter();
@@ -446,7 +446,7 @@ fn cfg_expand(
     tt: &tt::TopSubtree,
     span: Span,
 ) -> ExpandResult<tt::TopSubtree> {
-    let loc = db.lookup_intern_macro_call(id);
+    let loc = id.loc(db);
     let expr = CfgExpr::parse(tt);
     let enabled = loc.krate.cfg_options(db).check(&expr) != Some(false);
     let expanded = if enabled { quote!(span=>true) } else { quote!(span=>false) };
@@ -518,7 +518,7 @@ fn use_panic_2021(db: &dyn ExpandDatabase, span: Span) -> bool {
         let Some(expn) = span.ctx.outer_expn(db) else {
             break false;
         };
-        let expn = db.lookup_intern_macro_call(expn.into());
+        let expn = crate::MacroCallId::from(expn).loc(db);
         // FIXME: Record allow_internal_unstable in the macro def (not been done yet because it
         // would consume quite a bit extra memory for all call locs...)
         // if let Some(features) = expn.def.allow_internal_unstable {
@@ -764,7 +764,7 @@ fn relative_file(
     allow_recursion: bool,
     err_span: Span,
 ) -> Result<EditionedFileId, ExpandError> {
-    let lookup = db.lookup_intern_macro_call(call_id);
+    let lookup = call_id.loc(db);
     let call_site = lookup.kind.file_id().original_file_respecting_includes(db).file_id(db);
     let path = AnchoredPath { anchor: call_site, path: path_str };
     let res: FileId = db
@@ -900,7 +900,7 @@ fn include_str_expand(
 }
 
 fn get_env_inner(db: &dyn ExpandDatabase, arg_id: MacroCallId, key: &Symbol) -> Option<String> {
-    let krate = db.lookup_intern_macro_call(arg_id).krate;
+    let krate = arg_id.loc(db).krate;
     krate.env(db).get(key.as_str())
 }