Merge pull request #19617 from ChayimFriedman2/more-actual

internal: Make `HirFileId`, `EditionedFileId` and macro files Salsa struct

Author: ChayimFriedman2

crates/base-db/src/input.rs

@@ -16,11 +16,11 @@ use intern::Symbol;
 use la_arena::{Arena, Idx, RawIdx};
 use rustc_hash::{FxHashMap, FxHashSet, FxHasher};
 use salsa::{Durability, Setter};
-use span::{Edition, EditionedFileId};
+use span::Edition;
 use triomphe::Arc;
 use vfs::{AbsPathBuf, AnchoredPath, FileId, VfsPath, file_set::FileSet};
 
-use crate::{CrateWorkspaceData, RootQueryDb};
+use crate::{CrateWorkspaceData, EditionedFileId, RootQueryDb};
 
 pub type ProcMacroPaths = FxHashMap<CrateBuilderId, Result<(String, AbsPathBuf), String>>;
 
@@ -773,8 +773,8 @@ pub(crate) fn transitive_rev_deps(db: &dyn RootQueryDb, of: Crate) -> FxHashSet<
 }
 
 impl BuiltCrateData {
-    pub fn root_file_id(&self) -> EditionedFileId {
-        EditionedFileId::new(self.root_file_id, self.edition)
+    pub fn root_file_id(&self, db: &dyn salsa::Database) -> EditionedFileId {
+        EditionedFileId::new(db, self.root_file_id, self.edition)
     }
 }
 

crates/base-db/src/lib.rs

@@ -20,6 +20,7 @@ use rustc_hash::{FxHashSet, FxHasher};
 pub use salsa::{self};
 use salsa::{Durability, Setter};
 pub use semver::{BuildMetadata, Prerelease, Version, VersionReq};
+use span::Edition;
 use syntax::{Parse, SyntaxError, ast};
 use triomphe::Arc;
 pub use vfs::{AnchoredPath, AnchoredPathBuf, FileId, VfsPath, file_set::FileSet};
@@ -151,21 +152,39 @@ impl Files {
     }
 }
 
-#[salsa::interned(no_lifetime)]
+#[salsa::interned(no_lifetime, constructor=from_span)]
 pub struct EditionedFileId {
     pub editioned_file_id: span::EditionedFileId,
 }
 
 impl EditionedFileId {
-    pub fn file_id(&self, db: &dyn salsa::Database) -> vfs::FileId {
+    // Salsa already uses the name `new`...
+    #[inline]
+    pub fn new(db: &dyn salsa::Database, file_id: FileId, edition: Edition) -> Self {
+        EditionedFileId::from_span(db, span::EditionedFileId::new(file_id, edition))
+    }
+
+    #[inline]
+    pub fn current_edition(db: &dyn salsa::Database, file_id: FileId) -> Self {
+        EditionedFileId::new(db, file_id, Edition::CURRENT)
+    }
+
+    #[inline]
+    pub fn file_id(self, db: &dyn salsa::Database) -> vfs::FileId {
         let id = self.editioned_file_id(db);
         id.file_id()
     }
 
-    fn unpack(&self, db: &dyn salsa::Database) -> (vfs::FileId, span::Edition) {
+    #[inline]
+    pub fn unpack(self, db: &dyn salsa::Database) -> (vfs::FileId, span::Edition) {
         let id = self.editioned_file_id(db);
         (id.file_id(), id.edition())
     }
+
+    #[inline]
+    pub fn edition(self, db: &dyn SourceDatabase) -> Edition {
+        self.editioned_file_id(db).edition()
+    }
 }
 
 #[salsa::input]
@@ -189,7 +208,7 @@ pub struct SourceRootInput {
 #[query_group::query_group]
 pub trait RootQueryDb: SourceDatabase + salsa::Database {
     /// Parses the file into the syntax tree.
-    #[salsa::invoke_actual(parse)]
+    #[salsa::invoke(parse)]
     #[salsa::lru(128)]
     fn parse(&self, file_id: EditionedFileId) -> Parse<ast::SourceFile>;
 
@@ -201,6 +220,7 @@ pub trait RootQueryDb: SourceDatabase + salsa::Database {
     fn toolchain_channel(&self, krate: Crate) -> Option<ReleaseChannel>;
 
     /// Crates whose root file is in `id`.
+    #[salsa::invoke_interned(source_root_crates)]
     fn source_root_crates(&self, id: SourceRootId) -> Arc<[Crate]>;
 
     #[salsa::transparent]

crates/hir-def/src/db.rs

@@ -1,10 +1,9 @@
 //! Defines database & queries for name resolution.
 use base_db::{Crate, RootQueryDb, SourceDatabase};
 use either::Either;
-use hir_expand::{HirFileId, MacroDefId, db::ExpandDatabase};
+use hir_expand::{EditionedFileId, HirFileId, MacroCallId, MacroDefId, db::ExpandDatabase};
 use intern::sym;
 use la_arena::ArenaMap;
-use span::{EditionedFileId, MacroCallId};
 use syntax::{AstPtr, ast};
 use thin_vec::ThinVec;
 use triomphe::Arc;
@@ -109,26 +108,26 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
     #[salsa::invoke(ItemTree::file_item_tree_query)]
     fn file_item_tree(&self, file_id: HirFileId) -> Arc<ItemTree>;
 
-    #[salsa::invoke_actual(ItemTree::block_item_tree_query)]
+    #[salsa::invoke(ItemTree::block_item_tree_query)]
     fn block_item_tree(&self, block_id: BlockId) -> Arc<ItemTree>;
 
-    #[salsa::invoke_actual(DefMap::crate_local_def_map_query)]
+    #[salsa::invoke(DefMap::crate_local_def_map_query)]
     fn crate_local_def_map(&self, krate: Crate) -> (Arc<DefMap>, Arc<LocalDefMap>);
 
-    #[salsa::invoke_actual(DefMap::crate_def_map_query)]
+    #[salsa::invoke(DefMap::crate_def_map_query)]
     fn crate_def_map(&self, krate: Crate) -> Arc<DefMap>;
 
     /// Computes the block-level `DefMap`.
-    #[salsa::invoke_actual(DefMap::block_def_map_query)]
+    #[salsa::invoke(DefMap::block_def_map_query)]
     fn block_def_map(&self, block: BlockId) -> Arc<DefMap>;
 
     /// Turns a MacroId into a MacroDefId, describing the macro's definition post name resolution.
-    #[salsa::invoke_actual(macro_def)]
+    #[salsa::invoke(macro_def)]
     fn macro_def(&self, m: MacroId) -> MacroDefId;
 
     // region:data
 
-    #[salsa::invoke_actual(VariantFields::query)]
+    #[salsa::invoke(VariantFields::query)]
     fn variant_fields_with_source_map(
         &self,
         id: VariantId,
@@ -139,24 +138,24 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
         self.enum_variants_with_diagnostics(id).0
     }
 
-    #[salsa::invoke_actual(EnumVariants::enum_variants_query)]
+    #[salsa::invoke(EnumVariants::enum_variants_query)]
     fn enum_variants_with_diagnostics(
         &self,
         id: EnumId,
     ) -> (Arc<EnumVariants>, Option<Arc<ThinVec<InactiveEnumVariantCode>>>);
 
     #[salsa::transparent]
-    #[salsa::invoke_actual(ImplItems::impl_items_query)]
+    #[salsa::invoke(ImplItems::impl_items_query)]
     fn impl_items(&self, e: ImplId) -> Arc<ImplItems>;
 
-    #[salsa::invoke_actual(ImplItems::impl_items_with_diagnostics_query)]
+    #[salsa::invoke(ImplItems::impl_items_with_diagnostics_query)]
     fn impl_items_with_diagnostics(&self, e: ImplId) -> (Arc<ImplItems>, DefDiagnostics);
 
     #[salsa::transparent]
-    #[salsa::invoke_actual(TraitItems::trait_items_query)]
+    #[salsa::invoke(TraitItems::trait_items_query)]
     fn trait_items(&self, e: TraitId) -> Arc<TraitItems>;
 
-    #[salsa::invoke_actual(TraitItems::trait_items_with_diagnostics_query)]
+    #[salsa::invoke(TraitItems::trait_items_with_diagnostics_query)]
     fn trait_items_with_diagnostics(&self, tr: TraitId) -> (Arc<TraitItems>, DefDiagnostics);
 
     #[salsa::tracked]
@@ -214,61 +213,61 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
         self.type_alias_signature_with_source_map(e).0
     }
 
-    #[salsa::invoke_actual(TraitSignature::query)]
+    #[salsa::invoke(TraitSignature::query)]
     fn trait_signature_with_source_map(
         &self,
         trait_: TraitId,
     ) -> (Arc<TraitSignature>, Arc<ExpressionStoreSourceMap>);
 
-    #[salsa::invoke_actual(ImplSignature::query)]
+    #[salsa::invoke(ImplSignature::query)]
     fn impl_signature_with_source_map(
         &self,
         impl_: ImplId,
     ) -> (Arc<ImplSignature>, Arc<ExpressionStoreSourceMap>);
 
-    #[salsa::invoke_actual(StructSignature::query)]
+    #[salsa::invoke(StructSignature::query)]
     fn struct_signature_with_source_map(
         &self,
         struct_: StructId,
     ) -> (Arc<StructSignature>, Arc<ExpressionStoreSourceMap>);
 
-    #[salsa::invoke_actual(UnionSignature::query)]
+    #[salsa::invoke(UnionSignature::query)]
     fn union_signature_with_source_map(
         &self,
         union_: UnionId,
     ) -> (Arc<UnionSignature>, Arc<ExpressionStoreSourceMap>);
 
-    #[salsa::invoke_actual(EnumSignature::query)]
+    #[salsa::invoke(EnumSignature::query)]
     fn enum_signature_with_source_map(
         &self,
         e: EnumId,
     ) -> (Arc<EnumSignature>, Arc<ExpressionStoreSourceMap>);
 
-    #[salsa::invoke_actual(ConstSignature::query)]
+    #[salsa::invoke(ConstSignature::query)]
     fn const_signature_with_source_map(
         &self,
         e: ConstId,
     ) -> (Arc<ConstSignature>, Arc<ExpressionStoreSourceMap>);
 
-    #[salsa::invoke_actual(StaticSignature::query)]
+    #[salsa::invoke(StaticSignature::query)]
     fn static_signature_with_source_map(
         &self,
         e: StaticId,
     ) -> (Arc<StaticSignature>, Arc<ExpressionStoreSourceMap>);
 
-    #[salsa::invoke_actual(FunctionSignature::query)]
+    #[salsa::invoke(FunctionSignature::query)]
     fn function_signature_with_source_map(
         &self,
         e: FunctionId,
     ) -> (Arc<FunctionSignature>, Arc<ExpressionStoreSourceMap>);
 
-    #[salsa::invoke_actual(TraitAliasSignature::query)]
+    #[salsa::invoke(TraitAliasSignature::query)]
     fn trait_alias_signature_with_source_map(
         &self,
         e: TraitAliasId,
     ) -> (Arc<TraitAliasSignature>, Arc<ExpressionStoreSourceMap>);
 
-    #[salsa::invoke_actual(TypeAliasSignature::query)]
+    #[salsa::invoke(TypeAliasSignature::query)]
     fn type_alias_signature_with_source_map(
         &self,
         e: TypeAliasId,
@@ -283,7 +282,7 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
     #[salsa::invoke(Body::body_query)]
     fn body(&self, def: DefWithBodyId) -> Arc<Body>;
 
-    #[salsa::invoke_actual(ExprScopes::expr_scopes_query)]
+    #[salsa::invoke(ExprScopes::expr_scopes_query)]
     fn expr_scopes(&self, def: DefWithBodyId) -> Arc<ExprScopes>;
 
     #[salsa::transparent]
@@ -306,17 +305,18 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
 
     // region:attrs
 
-    #[salsa::invoke_actual(Attrs::fields_attrs_query)]
+    #[salsa::invoke(Attrs::fields_attrs_query)]
     fn fields_attrs(&self, def: VariantId) -> Arc<ArenaMap<LocalFieldId, Attrs>>;
 
     // should this really be a query?
-    #[salsa::invoke_actual(crate::attr::fields_attrs_source_map)]
+    #[salsa::invoke(crate::attr::fields_attrs_source_map)]
     fn fields_attrs_source_map(
         &self,
         def: VariantId,
     ) -> Arc<ArenaMap<LocalFieldId, AstPtr<Either<ast::TupleField, ast::RecordField>>>>;
 
-    #[salsa::invoke(AttrsWithOwner::attrs_query)]
+    // FIXME: Make this a non-interned query.
+    #[salsa::invoke_interned(AttrsWithOwner::attrs_query)]
     fn attrs(&self, def: AttrDefId) -> Attrs;
 
     #[salsa::transparent]
@@ -328,39 +328,39 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
     #[salsa::invoke(LangItems::lang_item_query)]
     fn lang_item(&self, start_crate: Crate, item: LangItem) -> Option<LangItemTarget>;
 
-    #[salsa::invoke_actual(ImportMap::import_map_query)]
+    #[salsa::invoke(ImportMap::import_map_query)]
     fn import_map(&self, krate: Crate) -> Arc<ImportMap>;
 
     // region:visibilities
 
-    #[salsa::invoke_actual(visibility::field_visibilities_query)]
+    #[salsa::invoke(visibility::field_visibilities_query)]
     fn field_visibilities(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Visibility>>;
 
     // FIXME: unify function_visibility and const_visibility?
 
-    #[salsa::invoke_actual(visibility::function_visibility_query)]
+    #[salsa::invoke(visibility::function_visibility_query)]
     fn function_visibility(&self, def: FunctionId) -> Visibility;
 
-    #[salsa::invoke_actual(visibility::const_visibility_query)]
+    #[salsa::invoke(visibility::const_visibility_query)]
     fn const_visibility(&self, def: ConstId) -> Visibility;
 
-    #[salsa::invoke_actual(visibility::type_alias_visibility_query)]
+    #[salsa::invoke(visibility::type_alias_visibility_query)]
     fn type_alias_visibility(&self, def: TypeAliasId) -> Visibility;
 
     // endregion:visibilities
 
-    #[salsa::invoke_actual(LangItems::crate_lang_items_query)]
+    #[salsa::invoke(LangItems::crate_lang_items_query)]
     fn crate_lang_items(&self, krate: Crate) -> Option<Arc<LangItems>>;
 
-    #[salsa::invoke_actual(crate::lang_item::notable_traits_in_deps)]
+    #[salsa::invoke(crate::lang_item::notable_traits_in_deps)]
     fn notable_traits_in_deps(&self, krate: Crate) -> Arc<[Arc<[TraitId]>]>;
-    #[salsa::invoke_actual(crate::lang_item::crate_notable_traits)]
+    #[salsa::invoke(crate::lang_item::crate_notable_traits)]
     fn crate_notable_traits(&self, krate: Crate) -> Option<Arc<[TraitId]>>;
 
-    #[salsa::invoke_actual(crate_supports_no_std)]
+    #[salsa::invoke(crate_supports_no_std)]
     fn crate_supports_no_std(&self, crate_id: Crate) -> bool;
 
-    #[salsa::invoke_actual(include_macro_invoc)]
+    #[salsa::invoke(include_macro_invoc)]
     fn include_macro_invoc(&self, crate_id: Crate) -> Arc<[(MacroCallId, EditionedFileId)]>;
 }
 
@@ -382,7 +382,7 @@ fn include_macro_invoc(
 }
 
 fn crate_supports_no_std(db: &dyn DefDatabase, crate_id: Crate) -> bool {
-    let file = crate_id.data(db).root_file_id();
+    let file = crate_id.data(db).root_file_id(db);
     let item_tree = db.file_item_tree(file.into());
     let attrs = item_tree.raw_attrs(AttrOwner::TopLevel);
     for attr in &**attrs {

crates/hir-def/src/expr_store.rs

@@ -13,11 +13,11 @@ use std::ops::{Deref, Index};
 
 use cfg::{CfgExpr, CfgOptions};
 use either::Either;
-use hir_expand::{ExpandError, InFile, mod_path::ModPath, name::Name};
+use hir_expand::{ExpandError, InFile, MacroCallId, mod_path::ModPath, name::Name};
 use la_arena::{Arena, ArenaMap};
 use rustc_hash::FxHashMap;
 use smallvec::SmallVec;
-use span::{Edition, MacroFileId, SyntaxContext};
+use span::{Edition, SyntaxContext};
 use syntax::{AstPtr, SyntaxNodePtr, ast};
 use triomphe::Arc;
 use tt::TextRange;
@@ -138,7 +138,7 @@ pub struct ExpressionStoreSourceMap {
 
     template_map: Option<Box<FormatTemplate>>,
 
-    pub expansions: FxHashMap<InFile<MacroCallPtr>, MacroFileId>,
+    pub expansions: FxHashMap<InFile<MacroCallPtr>, MacroCallId>,
 
     /// Diagnostics accumulated during lowering. These contain `AstPtr`s and so are stored in
     /// the source map (since they're just as volatile).
@@ -645,12 +645,12 @@ impl ExpressionStoreSourceMap {
         self.expr_map.get(&src).cloned()
     }
 
-    pub fn node_macro_file(&self, node: InFile<&ast::MacroCall>) -> Option<MacroFileId> {
+    pub fn node_macro_file(&self, node: InFile<&ast::MacroCall>) -> Option<MacroCallId> {
         let src = node.map(AstPtr::new);
         self.expansions.get(&src).cloned()
     }
 
-    pub fn macro_calls(&self) -> impl Iterator<Item = (InFile<MacroCallPtr>, MacroFileId)> + '_ {
+    pub fn macro_calls(&self) -> impl Iterator<Item = (InFile<MacroCallPtr>, MacroCallId)> + '_ {
         self.expansions.iter().map(|(&a, &b)| (a, b))
     }
 
@@ -696,11 +696,11 @@ impl ExpressionStoreSourceMap {
         self.expr_map.get(&src).copied()
     }
 
-    pub fn expansions(&self) -> impl Iterator<Item = (&InFile<MacroCallPtr>, &MacroFileId)> {
+    pub fn expansions(&self) -> impl Iterator<Item = (&InFile<MacroCallPtr>, &MacroCallId)> {
         self.expansions.iter()
     }
 
-    pub fn expansion(&self, node: InFile<&ast::MacroCall>) -> Option<MacroFileId> {
+    pub fn expansion(&self, node: InFile<&ast::MacroCall>) -> Option<MacroCallId> {
         self.expansions.get(&node.map(AstPtr::new)).copied()
     }