internal: Rewrite attribute handling

Cargo.toml

@@ -55,7 +55,7 @@ debug = 2
 [workspace.dependencies]
 # local crates
 base-db = { path = "./crates/base-db", version = "0.0.0" }
-cfg = { path = "./crates/cfg", version = "0.0.0", features = ["tt"] }
+cfg = { path = "./crates/cfg", version = "0.0.0", features = ["tt", "syntax"] }
 hir = { path = "./crates/hir", version = "0.0.0" }
 hir-def = { path = "./crates/hir-def", version = "0.0.0" }
 hir-expand = { path = "./crates/hir-expand", version = "0.0.0" }
@@ -138,7 +138,7 @@ process-wrap = { version = "8.2.1", features = ["std"] }
 pulldown-cmark-to-cmark = "10.0.4"
 pulldown-cmark = { version = "0.9.6", default-features = false }
 rayon = "1.10.0"
-rowan = "=0.15.15"
+rowan = "=0.15.17"
 # Ideally we'd not enable the macros feature but unfortunately the `tracked` attribute does not work
 # on impls without it
 salsa = { version = "0.23.0", default-features = true, features = [
@@ -174,6 +174,7 @@ tracing-subscriber = { version = "0.3.19", default-features = false, features =
 triomphe = { version = "0.1.14", default-features = false, features = ["std"] }
 url = "2.5.4"
 xshell = "0.2.7"
+thin-vec = "0.2.14"
 
 # We need to freeze the version of the crate, as the raw-api feature is considered unstable
 dashmap = { version = "=6.1.0", features = ["raw-api", "inline"] }

crates/base-db/src/editioned_file_id.rs

@@ -0,0 +1,233 @@
+//! Defines [`EditionedFileId`], an interned wrapper around [`span::EditionedFileId`] that
+//! is interned (so queries can take it) and remembers its crate.
+
+use ::core::num::NonZeroUsize;
+use core::fmt;
+use std::hash::{Hash, Hasher};
+
+use span::Edition;
+use vfs::FileId;
+
+use crate::{Crate, RootQueryDb};
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct EditionedFileId(
+    salsa::Id,
+    std::marker::PhantomData<&'static salsa::plumbing::interned::Value<EditionedFileId>>,
+);
+
+const _: () = {
+    use salsa::plumbing as zalsa_;
+    use zalsa_::interned as zalsa_struct_;
+    type Configuration_ = EditionedFileId;
+
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct EditionedFileIdData {
+        editioned_file_id: span::EditionedFileId,
+        krate: Crate,
+    }
+
+    /// We like to include the origin crate in an `EditionedFileId` (for use in the item tree),
+    /// but this poses us a problem.
+    ///
+    /// Spans contain `EditionedFileId`s, and we don't want to make them store the crate too
+    /// because that will increase their size, which will increase memory usage significantly.
+    /// Furthermore, things using spans do not generally need the crate: they are using the
+    /// file id for queries like `ast_id_map` or `parse`, which do not care about the crate.
+    ///
+    /// To solve this, we hash **only the `span::EditionedFileId`**, but on still compare
+    /// the crate in equality check. This preserves the invariant of `Hash` and `Eq` -
+    /// although same hashes can be used for different items, same file ids used for multiple
+    /// crates is a rare thing, and different items always have different hashes. Then,
+    /// when we only have a `span::EditionedFileId`, we use the `intern()` method to
+    /// reuse existing file ids, and create new one only if needed. See [`from_span_guess_origin`].
+    ///
+    /// See this for more info: https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/Letting.20EditionedFileId.20know.20its.20crate/near/530189401
+    ///
+    /// [`from_span_guess_origin`]: EditionedFileId::from_span_guess_origin
+    #[derive(Hash, PartialEq, Eq)]
+    struct WithoutCrate {
+        editioned_file_id: span::EditionedFileId,
+    }
+
+    impl Hash for EditionedFileIdData {
+        #[inline]
+        fn hash<H: Hasher>(&self, state: &mut H) {
+            let EditionedFileIdData { editioned_file_id, krate: _ } = *self;
+            editioned_file_id.hash(state);
+        }
+    }
+
+    impl zalsa_struct_::HashEqLike<WithoutCrate> for EditionedFileIdData {
+        #[inline]
+        fn hash<H: Hasher>(&self, state: &mut H) {
+            Hash::hash(self, state);
+        }
+
+        #[inline]
+        fn eq(&self, data: &WithoutCrate) -> bool {
+            let EditionedFileIdData { editioned_file_id, krate: _ } = *self;
+            editioned_file_id == data.editioned_file_id
+        }
+    }
+
+    impl zalsa_struct_::Configuration for EditionedFileId {
+        const LOCATION: zalsa_::Location = zalsa_::Location { file: file!(), line: 0u32 };
+        const DEBUG_NAME: &'static str = "EditionedFileId";
+        const REVISIONS: NonZeroUsize = NonZeroUsize::new(usize::MAX).unwrap();
+        type Fields<'a> = EditionedFileIdData;
+        type Struct<'db> = EditionedFileId;
+    }
+
+    impl Configuration_ {
+        pub fn ingredient(db: &dyn salsa::Database) -> &zalsa_struct_::IngredientImpl<Self> {
+            static CACHE: zalsa_::IngredientCache<zalsa_struct_::IngredientImpl<Configuration_>> =
+                zalsa_::IngredientCache::new();
+            let zalsa = db.zalsa();
+            CACHE.get_or_create(zalsa, || {
+                zalsa.lookup_jar_by_type::<zalsa_struct_::JarImpl<Configuration_>>().get_or_create()
+            })
+        }
+    }
+
+    impl zalsa_::AsId for EditionedFileId {
+        fn as_id(&self) -> salsa::Id {
+            self.0.as_id()
+        }
+    }
+    impl zalsa_::FromId for EditionedFileId {
+        fn from_id(id: salsa::Id) -> Self {
+            Self(<salsa::Id>::from_id(id), std::marker::PhantomData)
+        }
+    }
+
+    unsafe impl Send for EditionedFileId {}
+    unsafe impl Sync for EditionedFileId {}
+
+    impl std::fmt::Debug for EditionedFileId {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            Self::default_debug_fmt(*self, f)
+        }
+    }
+
+    impl zalsa_::SalsaStructInDb for EditionedFileId {
+        type MemoIngredientMap = zalsa_::MemoIngredientSingletonIndex;
+        fn lookup_or_create_ingredient_index(aux: &zalsa_::Zalsa) -> zalsa_::IngredientIndices {
+            aux.lookup_jar_by_type::<zalsa_struct_::JarImpl<Configuration_>>()
+                .get_or_create()
+                .into()
+        }
+        #[inline]
+        fn cast(id: zalsa_::Id, type_id: zalsa_::TypeId) -> zalsa_::Option<Self> {
+            if type_id == zalsa_::TypeId::of::<EditionedFileId>() {
+                zalsa_::Some(<EditionedFileId as zalsa_::FromId>::from_id(id))
+            } else {
+                zalsa_::None
+            }
+        }
+    }
+
+    unsafe impl zalsa_::Update for EditionedFileId {
+        unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {
+            if unsafe { *old_pointer } != new_value {
+                unsafe { *old_pointer = new_value };
+                true
+            } else {
+                false
+            }
+        }
+    }
+
+    impl EditionedFileId {
+        pub fn from_span(
+            db: &dyn salsa::Database,
+            editioned_file_id: span::EditionedFileId,
+            krate: Crate,
+        ) -> Self {
+            Configuration_::ingredient(db).intern(
+                db,
+                EditionedFileIdData { editioned_file_id, krate },
+                |_, data| data,
+            )
+        }
+
+        /// Guesses the crate for the file.
+        ///
+        /// Only use this if you cannot precisely determine the origin. This can happen in one of two cases:
+        ///
+        ///  1. The file is not in the module tree.
+        ///  2. You are latency sensitive and cannot afford calling the def map to precisely compute the origin
+        ///     (e.g. on enter feature, folding, etc.).
+        pub fn from_span_guess_origin(
+            db: &dyn RootQueryDb,
+            editioned_file_id: span::EditionedFileId,
+        ) -> Self {
+            Configuration_::ingredient(db).intern(db, WithoutCrate { editioned_file_id }, |_, _| {
+                // FileId not in the database.
+                let krate = db
+                    .relevant_crates(editioned_file_id.file_id())
+                    .first()
+                    .copied()
+                    .unwrap_or_else(|| db.all_crates()[0]);
+                EditionedFileIdData { editioned_file_id, krate }
+            })
+        }
+
+        pub fn editioned_file_id(self, db: &dyn salsa::Database) -> span::EditionedFileId {
+            let fields = Configuration_::ingredient(db).fields(db, self);
+            fields.editioned_file_id
+        }
+
+        pub fn krate(self, db: &dyn salsa::Database) -> Crate {
+            let fields = Configuration_::ingredient(db).fields(db, self);
+            fields.krate
+        }
+
+        /// Default debug formatting for this struct (may be useful if you define your own `Debug` impl)
+        pub fn default_debug_fmt(this: Self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            zalsa_::with_attached_database(|db| {
+                let fields = Configuration_::ingredient(db).fields(db, this);
+                fmt::Debug::fmt(fields, f)
+            })
+            .unwrap_or_else(|| {
+                f.debug_tuple("EditionedFileId").field(&zalsa_::AsId::as_id(&this)).finish()
+            })
+        }
+    }
+};
+
+impl EditionedFileId {
+    #[inline]
+    pub fn new(db: &dyn salsa::Database, file_id: FileId, edition: Edition, krate: Crate) -> Self {
+        EditionedFileId::from_span(db, span::EditionedFileId::new(file_id, edition), krate)
+    }
+
+    /// Attaches the current edition and guesses the crate for the file.
+    ///
+    /// Only use this if you cannot precisely determine the origin. This can happen in one of two cases:
+    ///
+    ///  1. The file is not in the module tree.
+    ///  2. You are latency sensitive and cannot afford calling the def map to precisely compute the origin
+    ///     (e.g. on enter feature, folding, etc.).
+    #[inline]
+    pub fn current_edition_guess_origin(db: &dyn RootQueryDb, file_id: FileId) -> Self {
+        Self::from_span_guess_origin(db, span::EditionedFileId::current_edition(file_id))
+    }
+
+    #[inline]
+    pub fn file_id(self, db: &dyn salsa::Database) -> vfs::FileId {
+        let id = self.editioned_file_id(db);
+        id.file_id()
+    }
+
+    #[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 salsa::Database) -> Edition {
+        self.editioned_file_id(db).edition()
+    }
+}

crates/base-db/src/input.rs

@@ -831,9 +831,10 @@ pub(crate) fn transitive_rev_deps(db: &dyn RootQueryDb, of: Crate) -> FxHashSet<
     rev_deps
 }
 
-impl BuiltCrateData {
-    pub fn root_file_id(&self, db: &dyn salsa::Database) -> EditionedFileId {
-        EditionedFileId::new(db, self.root_file_id, self.edition)
+impl Crate {
+    pub fn root_file_id(self, db: &dyn salsa::Database) -> EditionedFileId {
+        let data = self.data(db);
+        EditionedFileId::new(db, data.root_file_id, data.edition, self)
     }
 }
 

crates/base-db/src/lib.rs

@@ -5,12 +5,14 @@ pub use salsa_macros;
 
 // FIXME: Rename this crate, base db is non descriptive
 mod change;
+mod editioned_file_id;
 mod input;
 
 use std::{cell::RefCell, hash::BuildHasherDefault, panic, sync::Once};
 
 pub use crate::{
     change::FileChange,
+    editioned_file_id::EditionedFileId,
     input::{
         BuiltCrateData, BuiltDependency, Crate, CrateBuilder, CrateBuilderId, CrateDataBuilder,
         CrateDisplayName, CrateGraphBuilder, CrateName, CrateOrigin, CratesIdMap, CratesMap,
@@ -24,7 +26,6 @@ pub use query_group::{self};
 use rustc_hash::{FxHashSet, FxHasher};
 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};
@@ -168,42 +169,6 @@ impl Files {
     }
 }
 
-#[salsa_macros::interned(no_lifetime, debug, constructor=from_span, revisions = usize::MAX)]
-#[derive(PartialOrd, Ord)]
-pub struct EditionedFileId {
-    pub editioned_file_id: span::EditionedFileId,
-}
-
-impl EditionedFileId {
-    // 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()
-    }
-
-    #[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_macros::input(debug)]
 pub struct FileText {
     #[returns(ref)]

crates/cfg/Cargo.toml

@@ -18,6 +18,7 @@ tracing.workspace = true
 
 # locals deps
 tt = { workspace = true, optional = true }
+syntax = { workspace = true, optional = true }
 intern.workspace = true
 
 [dev-dependencies]