Auto merge of #155046 - lnicola:sync-from-ra, r=lnicola

`rust-analyzer` subtree update

Subtree update of `rust-analyzer` to 64ddb54.

Created using https://github.com/rust-lang/josh-sync.

r? @ghost

Author: bors

.github/workflows/gen-lints.yml

@@ -0,0 +1,35 @@
+name: Generate lints and feature flags
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '50 23 * * 6'
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  lints-gen:
+    name: Generate lints
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Install nightly
+        run: rustup default nightly
+
+      - name: Generate lints/feature flags
+        run: cargo codegen lint-definitions
+
+      - name: Submit PR
+        uses: peter-evans/create-pull-request@c0f553fe549906ede9cf27b5156039d195d2ece0 # v8.1.0
+        with:
+          commit-message: "internal: update generated lints"
+          branch: "ci/gen-lints"
+          delete-branch: true
+          sign-commits: true
+          title: "Update generated lints"
+          body: "Weekly lint updates for `crates/ide-db/src/generated/lints.rs`."
+          labels: "A-infra"

.github/workflows/release.yaml

@@ -264,8 +264,6 @@ jobs:
           name: ${{ env.TAG }}
           token: ${{ secrets.GITHUB_TOKEN }}
 
-      - run: rm dist/rust-analyzer-no-server.vsix
-
       - run: npm ci
         working-directory: ./editors/code
 

.github/workflows/rustc-pull.yml

@@ -12,6 +12,7 @@ jobs:
     uses: rust-lang/josh-sync/.github/workflows/rustc-pull.yml@main
     with:
       github-app-id: ${{ vars.APP_CLIENT_ID }}
+      pr-author: "workflows-rust-analyzer[bot]"
       zulip-stream-id: 185405
       zulip-bot-email:  "rust-analyzer-ci-bot@rust-lang.zulipchat.com"
       pr-base-branch: master

Cargo.lock

@@ -132,7 +132,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.17"
+rowan = "=0.15.18"
 # Ideally we'd not enable the macros feature but unfortunately the `tracked` attribute does not work
 # on impls without it
 salsa = { version = "0.25.2", default-features = false, features = [

Cargo.toml

@@ -9,7 +9,8 @@ use triomphe::Arc;
 use vfs::FileId;
 
 use crate::{
-    CrateGraphBuilder, CratesIdMap, LibraryRoots, LocalRoots, RootQueryDb, SourceRoot, SourceRootId,
+    CrateGraphBuilder, CratesIdMap, LibraryRoots, LocalRoots, SourceDatabase, SourceRoot,
+    SourceRootId,
 };
 
 /// Encapsulate a bunch of raw `.set` calls on the database.
@@ -49,7 +50,7 @@ impl FileChange {
         self.crate_graph = Some(graph);
     }
 
-    pub fn apply(self, db: &mut dyn RootQueryDb) -> Option<CratesIdMap> {
+    pub fn apply(self, db: &mut dyn SourceDatabase) -> Option<CratesIdMap> {
         let _p = tracing::info_span!("FileChange::apply").entered();
         if let Some(roots) = self.roots {
             let mut local_roots = FxHashSet::default();

crates/base-db/src/change.rs

@@ -5,14 +5,71 @@ use std::hash::Hash;
 
 use salsa::Database;
 use span::Edition;
+use syntax::{SyntaxError, ast};
 use vfs::FileId;
 
+use crate::SourceDatabase;
+
 #[salsa::interned(debug, constructor = from_span_file_id, no_lifetime)]
 #[derive(PartialOrd, Ord)]
 pub struct EditionedFileId {
     field: span::EditionedFileId,
 }
 
+// Currently does not work due to a salsa bug
+// #[salsa::tracked]
+// impl EditionedFileId {
+//     #[salsa::tracked(lru = 128)]
+//     pub fn parse(self, db: &dyn SourceDatabase) -> syntax::Parse<ast::SourceFile> {
+//         let _p = tracing::info_span!("parse", ?self).entered();
+//         let (file_id, edition) = self.unpack(db);
+//         let text = db.file_text(file_id).text(db);
+//         ast::SourceFile::parse(text, edition)
+//     }
+
+//     // firewall query
+//     #[salsa::tracked(returns(as_deref))]
+//     pub fn parse_errors(self, db: &dyn SourceDatabase) -> Option<Box<[SyntaxError]>> {
+//         let errors = self.parse(db).errors();
+//         match &*errors {
+//             [] => None,
+//             [..] => Some(errors.into()),
+//         }
+//     }
+// }
+
+impl EditionedFileId {
+    pub fn parse(self, db: &dyn SourceDatabase) -> syntax::Parse<ast::SourceFile> {
+        #[salsa::tracked(lru = 128)]
+        pub fn parse(
+            db: &dyn SourceDatabase,
+            file_id: EditionedFileId,
+        ) -> syntax::Parse<ast::SourceFile> {
+            let _p = tracing::info_span!("parse", ?file_id).entered();
+            let (file_id, edition) = file_id.unpack(db);
+            let text = db.file_text(file_id).text(db);
+            ast::SourceFile::parse(text, edition)
+        }
+        parse(db, self)
+    }
+
+    // firewall query
+    pub fn parse_errors(self, db: &dyn SourceDatabase) -> Option<&[SyntaxError]> {
+        #[salsa::tracked(returns(as_deref))]
+        pub fn parse_errors(
+            db: &dyn SourceDatabase,
+            file_id: EditionedFileId,
+        ) -> Option<Box<[SyntaxError]>> {
+            let errors = file_id.parse(db).errors();
+            match &*errors {
+                [] => None,
+                [..] => Some(errors.into()),
+            }
+        }
+        parse_errors(db, self)
+    }
+}
+
 impl EditionedFileId {
     #[inline]
     pub fn new(db: &dyn Database, file_id: FileId, edition: Edition) -> Self {

crates/base-db/src/editioned_file_id.rs

@@ -21,7 +21,10 @@ use span::Edition;
 use triomphe::Arc;
 use vfs::{AbsPathBuf, AnchoredPath, FileId, VfsPath, file_set::FileSet};
 
-use crate::{CrateWorkspaceData, EditionedFileId, FxIndexSet, RootQueryDb};
+use crate::{
+    CrateWorkspaceData, EditionedFileId, FxIndexSet, SourceDatabase, all_crates,
+    set_all_crates_with_durability,
+};
 
 pub type ProcMacroPaths =
     FxHashMap<CrateBuilderId, Result<(String, AbsPathBuf), ProcMacroLoadingError>>;
@@ -490,13 +493,13 @@ impl Crate {
     /// including the crate itself.
     ///
     /// **Warning**: do not use this query in `hir-*` crates! It kills incrementality across crate metadata modifications.
-    pub fn transitive_rev_deps(self, db: &dyn RootQueryDb) -> Box<[Crate]> {
+    pub fn transitive_rev_deps(self, db: &dyn SourceDatabase) -> Box<[Crate]> {
         let mut worklist = vec![self];
         let mut rev_deps = FxHashSet::default();
         rev_deps.insert(self);
 
         let mut inverted_graph = FxHashMap::<_, Vec<_>>::default();
-        db.all_crates().iter().for_each(|&krate| {
+        all_crates(db).iter().for_each(|&krate| {
             krate
                 .data(db)
                 .dependencies
@@ -586,15 +589,15 @@ impl CrateGraphBuilder {
         Ok(())
     }
 
-    pub fn set_in_db(self, db: &mut dyn RootQueryDb) -> CratesIdMap {
+    pub fn set_in_db(self, db: &mut dyn SourceDatabase) -> CratesIdMap {
+        let old_all_crates = all_crates(db);
+
         // For some reason in some repositories we have duplicate crates, so we use a set and not `Vec`.
         // We use an `IndexSet` because the list needs to be topologically sorted.
         let mut all_crates = FxIndexSet::with_capacity_and_hasher(self.arena.len(), FxBuildHasher);
         let mut visited = FxHashMap::default();
         let mut visited_root_files = FxHashSet::default();
 
-        let old_all_crates = db.all_crates();
-
         let crates_map = db.crates_map();
         // salsa doesn't compare new input to old input to see if they are the same, so here we are doing all the work ourselves.
         for krate in self.iter() {
@@ -612,17 +615,14 @@ impl CrateGraphBuilder {
         if old_all_crates.len() != all_crates.len()
             || old_all_crates.iter().any(|&krate| !all_crates.contains(&krate))
         {
-            db.set_all_crates_with_durability(
-                Arc::new(Vec::from_iter(all_crates).into_boxed_slice()),
-                Durability::MEDIUM,
-            );
+            set_all_crates_with_durability(db, all_crates, Durability::MEDIUM);
         }
 
         return visited;
 
         fn go(
             graph: &CrateGraphBuilder,
-            db: &mut dyn RootQueryDb,
+            db: &mut dyn SourceDatabase,
             crates_map: &CratesMap,
             visited: &mut FxHashMap<CrateBuilderId, Crate>,
             visited_root_files: &mut FxHashSet<FileId>,
@@ -929,6 +929,27 @@ impl<'a> IntoIterator for &'a Env {
     }
 }
 
+/// The crate graph had a cycle. This is typically a bug, and
+/// rust-analyzer logs a warning when it encounters a cycle. Generally
+/// rust-analyzer will continue working OK in the presence of cycle,
+/// but it's better to have an accurate crate graph.
+///
+/// ## dev-dependencies
+///
+/// Note that it's actually legal for a cargo package (i.e. a thing
+/// with a Cargo.toml) to depend on itself in dev-dependencies. This
+/// can enable additional features, and is typically used when a
+/// project wants features to be enabled in tests. Dev-dependencies
+/// are not propagated, so they aren't visible to package that depend
+/// on this one.
+///
+/// <https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#development-dependencies>
+///
+/// However, rust-analyzer constructs its crate graph from Cargo
+/// metadata, so it can end up producing a cyclic crate graph from a
+/// well-formed package graph.
+///
+/// <https://github.com/rust-lang/rust-analyzer/issues/14167>
 #[derive(Debug)]
 pub struct CyclicDependenciesError {
     path: Vec<(CrateBuilderId, Option<CrateDisplayName>)>,