Auto merge of #150546 - JonathanBrouwer:rollup-jkqji1j, r=JonathanBrouwer

Rollup of 5 pull requests

Successful merges:

 - rust-lang/rust#146798 (RISC-V: Implement (Zkne or Zknd) intrinsics correctly)
 - rust-lang/rust#150337 (docs: fix typo in std::io::buffered)
 - rust-lang/rust#150530 (Remove `feature(string_deref_patterns)`)
 - rust-lang/rust#150543 (`rust-analyzer` subtree update)
 - rust-lang/rust#150544 (Use --print target-libdir in run-make tests)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

.github/workflows/ci.yaml

@@ -122,6 +122,12 @@ jobs:
       - name: Run tests
         run: cargo nextest run --no-fail-fast --hide-progress-bar --status-level fail
 
+      - name: Install cargo-machete
+        uses: taiki-e/install-action@cargo-machete
+
+      - name: Run cargo-machete
+        run: cargo machete
+
       - name: Run Clippy
         if: matrix.os == 'macos-latest'
         run: cargo clippy --all-targets -- -D clippy::disallowed_macros -D clippy::dbg_macro -D clippy::todo -D clippy::print_stdout -D clippy::print_stderr

CONTRIBUTING.md

@@ -38,6 +38,6 @@ considered accepted feel free to just drop a comment and ask!
 
 AI tool use is not discouraged on the rust-analyzer codebase, as long as it meets our quality standards.
 We kindly ask you to disclose usage of AI tools in your contributions.
-If you used them without disclosing it, we may reject your contribution on that basis alone due to the assumption that you likely not reviewed your own submission (so why should we?).
+If you used them without disclosing it, we may reject your contribution on that basis alone due to the assumption that you have, most likely, not reviewed your own submission (so why should we?).
 
 We may still reject AI-assisted contributions if we deem the quality of the contribution to be unsatisfactory as to reduce impact on the team's review budget.

Cargo.lock

@@ -3,11 +3,14 @@
 
 use std::fmt;
 
-use salsa::Durability;
+use rustc_hash::FxHashSet;
+use salsa::{Durability, Setter as _};
 use triomphe::Arc;
 use vfs::FileId;
 
-use crate::{CrateGraphBuilder, CratesIdMap, RootQueryDb, SourceRoot, SourceRootId};
+use crate::{
+    CrateGraphBuilder, CratesIdMap, LibraryRoots, LocalRoots, RootQueryDb, SourceRoot, SourceRootId,
+};
 
 /// Encapsulate a bunch of raw `.set` calls on the database.
 #[derive(Default)]
@@ -49,15 +52,24 @@ impl FileChange {
     pub fn apply(self, db: &mut dyn RootQueryDb) -> Option<CratesIdMap> {
         let _p = tracing::info_span!("FileChange::apply").entered();
         if let Some(roots) = self.roots {
+            let mut local_roots = FxHashSet::default();
+            let mut library_roots = FxHashSet::default();
             for (idx, root) in roots.into_iter().enumerate() {
                 let root_id = SourceRootId(idx as u32);
+                if root.is_library {
+                    library_roots.insert(root_id);
+                } else {
+                    local_roots.insert(root_id);
+                }
                 let durability = source_root_durability(&root);
                 for file_id in root.iter() {
                     db.set_file_source_root_with_durability(file_id, root_id, durability);
                 }
 
                 db.set_source_root_with_durability(root_id, Arc::new(root), durability);
             }
+            LocalRoots::get(db).set_roots(db).to(local_roots);
+            LibraryRoots::get(db).set_roots(db).to(library_roots);
         }
 
         for (file_id, text) in self.files_changed {

crates/base-db/src/change.rs

@@ -33,7 +33,7 @@ pub use crate::{
 };
 use dashmap::{DashMap, mapref::entry::Entry};
 pub use query_group::{self};
-use rustc_hash::FxHasher;
+use rustc_hash::{FxHashSet, FxHasher};
 use salsa::{Durability, Setter};
 pub use semver::{BuildMetadata, Prerelease, Version, VersionReq};
 use syntax::{Parse, SyntaxError, ast};
@@ -203,6 +203,22 @@ impl Files {
     }
 }
 
+/// The set of roots for crates.io libraries.
+/// Files in libraries are assumed to never change.
+#[salsa::input(singleton, debug)]
+pub struct LibraryRoots {
+    #[returns(ref)]
+    pub roots: FxHashSet<SourceRootId>,
+}
+
+/// The set of "local" (that is, from the current workspace) roots.
+/// Files in local roots are assumed to change frequently.
+#[salsa::input(singleton, debug)]
+pub struct LocalRoots {
+    #[returns(ref)]
+    pub roots: FxHashSet<SourceRootId>,
+}
+
 #[salsa_macros::input(debug)]
 pub struct FileText {
     #[returns(ref)]

crates/base-db/src/lib.rs

@@ -19,6 +19,7 @@ tracing.workspace = true
 # locals deps
 tt = { workspace = true, optional = true }
 syntax = { workspace = true, optional = true }
+span = { path = "../span", version = "0.0", optional = true }
 intern.workspace = true
 
 [dev-dependencies]
@@ -35,6 +36,8 @@ cfg = { path = ".", default-features = false, features = ["tt"] }
 
 [features]
 default = []
+syntax = ["dep:syntax", "dep:span"]
+tt = ["dep:tt"]
 in-rust-tree = []
 
 [lints]

crates/cfg/Cargo.toml

@@ -96,12 +96,12 @@ impl CfgExpr {
     // FIXME: Parsing from `tt` is only used in a handful of places, reconsider
     // if we should switch them to AST.
     #[cfg(feature = "tt")]
-    pub fn parse<S: Copy>(tt: &tt::TopSubtree<S>) -> CfgExpr {
+    pub fn parse(tt: &tt::TopSubtree) -> CfgExpr {
         next_cfg_expr(&mut tt.iter()).unwrap_or(CfgExpr::Invalid)
     }
 
     #[cfg(feature = "tt")]
-    pub fn parse_from_iter<S: Copy>(tt: &mut tt::iter::TtIter<'_, S>) -> CfgExpr {
+    pub fn parse_from_iter(tt: &mut tt::iter::TtIter<'_>) -> CfgExpr {
         next_cfg_expr(tt).unwrap_or(CfgExpr::Invalid)
     }
 
@@ -149,7 +149,16 @@ fn next_cfg_expr_from_ast(
             if let Some(NodeOrToken::Token(literal)) = it.peek()
                 && matches!(literal.kind(), SyntaxKind::STRING)
             {
-                let literal = tt::token_to_literal(literal.text(), ()).symbol;
+                let dummy_span = span::Span {
+                    range: span::TextRange::empty(span::TextSize::new(0)),
+                    anchor: span::SpanAnchor {
+                        file_id: span::EditionedFileId::from_raw(0),
+                        ast_id: span::FIXUP_ERASED_FILE_AST_ID_MARKER,
+                    },
+                    ctx: span::SyntaxContext::root(span::Edition::Edition2015),
+                };
+                let literal =
+                    Symbol::intern(tt::token_to_literal(literal.text(), dummy_span).text());
                 it.next();
                 CfgAtom::KeyValue { key: name, value: literal.clone() }.into()
             } else {
@@ -179,7 +188,7 @@ fn next_cfg_expr_from_ast(
 }
 
 #[cfg(feature = "tt")]
-fn next_cfg_expr<S: Copy>(it: &mut tt::iter::TtIter<'_, S>) -> Option<CfgExpr> {
+fn next_cfg_expr(it: &mut tt::iter::TtIter<'_>) -> Option<CfgExpr> {
     use intern::sym;
     use tt::iter::TtElement;
 
@@ -189,20 +198,21 @@ fn next_cfg_expr<S: Copy>(it: &mut tt::iter::TtIter<'_, S>) -> Option<CfgExpr> {
         Some(_) => return Some(CfgExpr::Invalid),
     };
 
-    let ret = match it.peek() {
+    let mut it_clone = it.clone();
+    let ret = match it_clone.next() {
         Some(TtElement::Leaf(tt::Leaf::Punct(punct)))
             // Don't consume on e.g. `=>`.
             if punct.char == '='
                 && (punct.spacing == tt::Spacing::Alone
-                    || it.remaining().flat_tokens().get(1).is_none_or(|peek2| {
-                        !matches!(peek2, tt::TokenTree::Leaf(tt::Leaf::Punct(_)))
+                    || it_clone.peek().is_none_or(|peek2| {
+                        !matches!(peek2, tt::TtElement::Leaf(tt::Leaf::Punct(_)))
                     })) =>
         {
-            match it.remaining().flat_tokens().get(1) {
-                Some(tt::TokenTree::Leaf(tt::Leaf::Literal(literal))) => {
+            match it_clone.next() {
+                Some(tt::TtElement::Leaf(tt::Leaf::Literal(literal))) => {
                     it.next();
                     it.next();
-                    CfgAtom::KeyValue { key: name, value: literal.symbol.clone() }.into()
+                    CfgAtom::KeyValue { key: name, value: Symbol::intern(literal.text()) }.into()
                 }
                 _ => return Some(CfgExpr::Invalid),
             }

crates/cfg/src/cfg_expr.rs

@@ -40,7 +40,6 @@ intern.workspace = true
 base-db.workspace = true
 syntax.workspace = true
 hir-expand.workspace = true
-mbe.workspace = true
 cfg.workspace = true
 tt.workspace = true
 span.workspace = true

crates/hir-def/Cargo.toml

@@ -99,6 +99,20 @@ fn extract_ra_completions(attr_flags: &mut AttrFlags, tt: ast::TokenTree) {
     }
 }
 
+fn extract_ra_macro_style(attr_flags: &mut AttrFlags, tt: ast::TokenTree) {
+    let tt = TokenTreeChildren::new(&tt);
+    if let Ok(NodeOrToken::Token(option)) = Itertools::exactly_one(tt)
+        && option.kind().is_any_identifier()
+    {
+        match option.text() {
+            "braces" => attr_flags.insert(AttrFlags::MACRO_STYLE_BRACES),
+            "brackets" => attr_flags.insert(AttrFlags::MACRO_STYLE_BRACKETS),
+            "parentheses" => attr_flags.insert(AttrFlags::MACRO_STYLE_PARENTHESES),
+            _ => {}
+        }
+    }
+}
+
 fn extract_rustc_skip_during_method_dispatch(attr_flags: &mut AttrFlags, tt: ast::TokenTree) {
     let iter = TokenTreeChildren::new(&tt);
     for kind in iter {
@@ -163,6 +177,7 @@ fn match_attr_flags(attr_flags: &mut AttrFlags, attr: Meta) -> ControlFlow<Infal
             2 => match path.segments[0].text() {
                 "rust_analyzer" => match path.segments[1].text() {
                     "completions" => extract_ra_completions(attr_flags, tt),
+                    "macro_style" => extract_ra_macro_style(attr_flags, tt),
                     _ => {}
                 },
                 _ => {}
@@ -188,6 +203,7 @@ fn match_attr_flags(attr_flags: &mut AttrFlags, attr: Meta) -> ControlFlow<Infal
                     "deprecated" => attr_flags.insert(AttrFlags::IS_DEPRECATED),
                     "macro_export" => attr_flags.insert(AttrFlags::IS_MACRO_EXPORT),
                     "no_mangle" => attr_flags.insert(AttrFlags::NO_MANGLE),
+                    "pointee" => attr_flags.insert(AttrFlags::IS_POINTEE),
                     "non_exhaustive" => attr_flags.insert(AttrFlags::NON_EXHAUSTIVE),
                     "ignore" => attr_flags.insert(AttrFlags::IS_IGNORE),
                     "bench" => attr_flags.insert(AttrFlags::IS_BENCH),
@@ -289,6 +305,11 @@ bitflags::bitflags! {
         const RUSTC_PAREN_SUGAR = 1 << 42;
         const RUSTC_COINDUCTIVE = 1 << 43;
         const RUSTC_FORCE_INLINE = 1 << 44;
+        const IS_POINTEE = 1 << 45;
+
+        const MACRO_STYLE_BRACES = 1 << 46;
+        const MACRO_STYLE_BRACKETS = 1 << 47;
+        const MACRO_STYLE_PARENTHESES = 1 << 48;
     }
 }