feat: introduce crate_attrs field in rust-project.json

Since the commit 5038446
("Rewrite method resolution to follow rustc more closely"), the method
resolution logic has changed: rust-analyzer only looks up inherent
methods for primitive types in sysroot crates.

Unfortunately, this change broke at least one project that relies on
`rust-project.json`: Rust-for-Linux. Its auto-generated
`rust-project.json` directly embeds `core`, `alloc`, and `std` in the
`crates` list without defining `sysroot_src`. Consequently,
rust-analyzer fails to identify them as sysroot crates, breaking IDE
support for primitive methods (e.g., `0_i32.rotate_left(0)`).

However, specifying `sysroot_src` creates a new issue: it implicitly
adds `std` as a dependency to all kernel module crates, which are
actually compiled with `-Zcrate-attr=no_std`. Since rust-analyzer cannot
see compiler flags passed outside of the project definition, we need a
method to explicitly specify `#![no_std]` or, more generally,
crate-level attributes through the project configuration.

To resolve this, extend the `rust-project.json` format with a new
`crate_attrs` field. This allows users to specify crate-level attributes
such as `#![no_std]` directly into the configuration, enabling
rust-analyzer to respect them when analyzing crates.

References:
- The original Zulip discussion:
  https://rust-lang.zulipchat.com/#narrow/channel/185405-t-compiler.2Frust-analyzer/topic/Primitive.20type.20inherent.20method.20lookup.20fails/with/562983853

Author: J3m3

crates/base-db/src/input.rs

@@ -351,6 +351,8 @@ pub struct CrateData<Id> {
     /// declared in source via `extern crate test`.
     pub dependencies: Vec<Dependency<Id>>,
     pub origin: CrateOrigin,
+    /// Extra crate-level attributes, including the surrounding `#![]`.
+    pub crate_attrs: Vec<String>,
     pub is_proc_macro: bool,
     /// The working directory to run proc-macros in invoked in the context of this crate.
     /// This is the workspace root of the cargo workspace for workspace members, the crate manifest
@@ -530,12 +532,16 @@ impl CrateGraphBuilder {
         mut potential_cfg_options: Option<CfgOptions>,
         mut env: Env,
         origin: CrateOrigin,
+        crate_attrs: Vec<String>,
         is_proc_macro: bool,
         proc_macro_cwd: Arc<AbsPathBuf>,
         ws_data: Arc<CrateWorkspaceData>,
     ) -> CrateBuilderId {
         env.entries.shrink_to_fit();
         cfg_options.shrink_to_fit();
+        let mut crate_attrs: Vec<_> =
+            crate_attrs.into_iter().map(|raw_attr| format!("#![{raw_attr}]")).collect();
+        crate_attrs.shrink_to_fit();
         if let Some(potential_cfg_options) = &mut potential_cfg_options {
             potential_cfg_options.shrink_to_fit();
         }
@@ -545,6 +551,7 @@ impl CrateGraphBuilder {
                 edition,
                 dependencies: Vec::new(),
                 origin,
+                crate_attrs,
                 is_proc_macro,
                 proc_macro_cwd,
             },
@@ -648,6 +655,7 @@ impl CrateGraphBuilder {
                 edition: krate.basic.edition,
                 is_proc_macro: krate.basic.is_proc_macro,
                 origin: krate.basic.origin.clone(),
+                crate_attrs: krate.basic.crate_attrs.clone(),
                 root_file_id: krate.basic.root_file_id,
                 proc_macro_cwd: krate.basic.proc_macro_cwd.clone(),
             };
@@ -975,6 +983,7 @@ mod tests {
             Default::default(),
             Env::default(),
             CrateOrigin::Local { repo: None, name: None },
+            Vec::new(),
             false,
             Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap())),
             empty_ws_data(),
@@ -988,6 +997,7 @@ mod tests {
             Default::default(),
             Env::default(),
             CrateOrigin::Local { repo: None, name: None },
+            Vec::new(),
             false,
             Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap())),
             empty_ws_data(),
@@ -1001,6 +1011,7 @@ mod tests {
             Default::default(),
             Env::default(),
             CrateOrigin::Local { repo: None, name: None },
+            Vec::new(),
             false,
             Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap())),
             empty_ws_data(),
@@ -1034,6 +1045,7 @@ mod tests {
             Default::default(),
             Env::default(),
             CrateOrigin::Local { repo: None, name: None },
+            Vec::new(),
             false,
             Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap())),
             empty_ws_data(),
@@ -1047,6 +1059,7 @@ mod tests {
             Default::default(),
             Env::default(),
             CrateOrigin::Local { repo: None, name: None },
+            Vec::new(),
             false,
             Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap())),
             empty_ws_data(),
@@ -1075,6 +1088,7 @@ mod tests {
             Default::default(),
             Env::default(),
             CrateOrigin::Local { repo: None, name: None },
+            Vec::new(),
             false,
             Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap())),
             empty_ws_data(),
@@ -1088,6 +1102,7 @@ mod tests {
             Default::default(),
             Env::default(),
             CrateOrigin::Local { repo: None, name: None },
+            Vec::new(),
             false,
             Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap())),
             empty_ws_data(),
@@ -1101,6 +1116,7 @@ mod tests {
             Default::default(),
             Env::default(),
             CrateOrigin::Local { repo: None, name: None },
+            Vec::new(),
             false,
             Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap())),
             empty_ws_data(),
@@ -1129,6 +1145,7 @@ mod tests {
             Default::default(),
             Env::default(),
             CrateOrigin::Local { repo: None, name: None },
+            Vec::new(),
             false,
             Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap())),
             empty_ws_data(),
@@ -1142,6 +1159,7 @@ mod tests {
             Default::default(),
             Env::default(),
             CrateOrigin::Local { repo: None, name: None },
+            Vec::new(),
             false,
             Arc::new(AbsPathBuf::assert_utf8(std::env::current_dir().unwrap())),
             empty_ws_data(),

crates/hir-def/src/attrs.rs

@@ -38,8 +38,9 @@ use la_arena::ArenaMap;
 use rustc_abi::ReprOptions;
 use rustc_hash::FxHashSet;
 use smallvec::SmallVec;
+use span::Edition;
 use syntax::{
-    AstNode, AstToken, NodeOrToken, SmolStr, SyntaxNode, SyntaxToken, T,
+    AstNode, AstToken, NodeOrToken, SmolStr, SourceFile, SyntaxNode, SyntaxToken, T,
     ast::{self, AttrDocCommentIter, HasAttrs, IsString, TokenTreeChildren},
 };
 use tt::{TextRange, TextSize};
@@ -292,6 +293,37 @@ bitflags::bitflags! {
     }
 }
 
+pub fn parse_extra_crate_attrs(
+    crate_attrs: &[String],
+    edition: Edition,
+    crate_name: &str,
+) -> impl Iterator<Item = SourceFile> {
+    use std::sync::{LazyLock, Mutex};
+    static SEEN_MSGS: LazyLock<Mutex<FxHashSet<String>>> =
+        LazyLock::new(|| Mutex::new(FxHashSet::default()));
+    macro_rules! error_once {
+        ($msg_set:ident, $($arg:tt)+) => {{
+            let mut seen_msgs = $msg_set.lock().expect("Mutex should not be poisoned");
+            if seen_msgs.insert(format!($($arg)+)) {
+                tracing::error!($($arg)+);
+            }
+        }};
+    }
+
+    crate_attrs.iter().filter_map(move |raw_attr| {
+        // All attributes are already enclosed in `#![]`.
+        let p = syntax::SourceFile::parse(raw_attr, edition);
+        let errors = p.errors();
+        if !errors.is_empty() {
+            let base_msg = "Failed to parse extra crate-level attribute";
+            error_once!(SEEN_MSGS, "{base_msg} `{raw_attr}` for crate `{crate_name}`");
+            None
+        } else {
+            Some(p.tree())
+        }
+    })
+}
+
 fn attrs_source(
     db: &dyn DefDatabase,
     owner: AttrDefId,
@@ -349,12 +381,29 @@ fn collect_attrs<BreakValue>(
 ) -> Option<BreakValue> {
     let (source, outer_mod_decl, krate) = attrs_source(db, owner);
 
+    let file_id = source.file_id;
+    let crate_attrs = (file_id == krate.root_file_id(db))
+        .then(|| {
+            let crate_name = krate
+                .extra_data(db)
+                .display_name
+                .as_ref()
+                .map_or("{unknown}", |name| name.as_str());
+            parse_extra_crate_attrs(&krate.data(db).crate_attrs, file_id.edition(db), crate_name)
+                .flat_map(|src| src.attrs())
+        })
+        .into_iter()
+        .flatten()
+        .chain(
+            outer_mod_decl
+                .into_iter()
+                .flat_map(|it| it.value.attrs())
+                .chain(ast::attrs_including_inner(&source.value)),
+        );
+
     let mut cfg_options = None;
     expand_cfg_attr(
-        outer_mod_decl
-            .into_iter()
-            .flat_map(|it| it.value.attrs())
-            .chain(ast::attrs_including_inner(&source.value)),
+        crate_attrs,
         || cfg_options.get_or_insert_with(|| krate.cfg_options(db)),
         move |meta, _, _, _| callback(meta),
     )
@@ -1480,8 +1529,9 @@ mod tests {
     use test_fixture::WithFixture;
     use tt::{TextRange, TextSize};
 
-    use crate::attrs::IsInnerDoc;
-    use crate::{attrs::Docs, test_db::TestDB};
+    use crate::AttrDefId;
+    use crate::attrs::{AttrFlags, Docs, IsInnerDoc};
+    use crate::test_db::TestDB;
 
     #[test]
     fn docs() {
@@ -1617,4 +1667,15 @@ mod tests {
             Some((in_file(range(263, 265)), IsInnerDoc::Yes))
         );
     }
+
+    #[test]
+    fn crate_attrs() {
+        let fixture = r#"
+//- /lib.rs crate:foo crate-attrs:no_std,cfg(target_arch="x86")
+        "#;
+        let (db, file_id) = TestDB::with_single_file(fixture);
+        let module = db.module_for_file(file_id.file_id(&db));
+        let attrs = AttrFlags::query(&db, AttrDefId::ModuleId(module));
+        assert!(attrs.contains(AttrFlags::IS_NO_STD | AttrFlags::HAS_CFG));
+    }
 }

crates/hir-def/src/item_tree.rs

@@ -44,6 +44,7 @@ use std::{
 };
 
 use ast::{AstNode, StructKind};
+use cfg::CfgOptions;
 use hir_expand::{
     ExpandTo, HirFileId,
     mod_path::{ModPath, PathKind},
@@ -52,13 +53,17 @@ use hir_expand::{
 use intern::Interned;
 use la_arena::{Idx, RawIdx};
 use rustc_hash::FxHashMap;
-use span::{AstIdNode, Edition, FileAstId, SyntaxContext};
+use span::{
+    AstIdNode, Edition, FileAstId, NO_DOWNMAP_ERASED_FILE_AST_ID_MARKER, Span, SpanAnchor,
+    SyntaxContext,
+};
 use stdx::never;
-use syntax::{SyntaxKind, ast, match_ast};
+use syntax::{SourceFile, SyntaxKind, ast, match_ast};
 use thin_vec::ThinVec;
 use triomphe::Arc;
+use tt::TextRange;
 
-use crate::{BlockId, Lookup, db::DefDatabase};
+use crate::{BlockId, Lookup, attrs::parse_extra_crate_attrs, db::DefDatabase};
 
 pub(crate) use crate::item_tree::{
     attrs::*,
@@ -88,6 +93,35 @@ impl fmt::Debug for RawVisibilityId {
     }
 }
 
+fn lower_extra_crate_attrs<'a>(
+    db: &dyn DefDatabase,
+    parsed_attr_srcs: impl Iterator<Item = SourceFile>,
+    file_id: span::EditionedFileId,
+    cfg_options: &dyn Fn() -> &'a CfgOptions,
+) -> AttrsOrCfg {
+    #[derive(Copy, Clone)]
+    struct FakeSpanMap {
+        file_id: span::EditionedFileId,
+    }
+    impl syntax_bridge::SpanMapper<Span> for FakeSpanMap {
+        fn span_for(&self, range: TextRange) -> Span {
+            Span {
+                range,
+                anchor: SpanAnchor {
+                    file_id: self.file_id,
+                    ast_id: NO_DOWNMAP_ERASED_FILE_AST_ID_MARKER,
+                },
+                ctx: SyntaxContext::root(self.file_id.edition()),
+            }
+        }
+    }
+
+    let span_map = FakeSpanMap { file_id };
+    parsed_attr_srcs.fold(AttrsOrCfg::empty(), |acc, src| {
+        acc.merge(AttrsOrCfg::lower(db, &src, cfg_options, span_map))
+    })
+}
+
 #[salsa_macros::tracked(returns(deref))]
 pub(crate) fn file_item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) -> Arc<ItemTree> {
     let _p = tracing::info_span!("file_item_tree_query", ?file_id).entered();
@@ -98,7 +132,27 @@ pub(crate) fn file_item_tree_query(db: &dyn DefDatabase, file_id: HirFileId) ->
     let mut item_tree = match_ast! {
         match syntax {
             ast::SourceFile(file) => {
-                let top_attrs = ctx.lower_attrs(&file);
+                let krate = file_id.krate(db);
+                let root_file_id = krate.root_file_id(db);
+                let extra_top_attrs = (file_id == root_file_id)
+                    .then(|| &krate.data(db).crate_attrs)
+                    .and_then(|crate_attrs| {
+                        (!crate_attrs.is_empty()).then(|| {
+                            let file_id = root_file_id.editioned_file_id(db);
+                            let crate_name = krate
+                                .extra_data(db)
+                                .display_name
+                                .as_ref()
+                                .map_or("{unknown}", |name| name.as_str());
+                            let crate_attrs = parse_extra_crate_attrs(crate_attrs, file_id.edition(), crate_name);
+                            lower_extra_crate_attrs(db, crate_attrs, file_id, &|| ctx.cfg_options())
+                        })
+                    });
+                let top_attrs = match extra_top_attrs {
+                    Some(attrs @ AttrsOrCfg::Enabled { .. }) => attrs.merge(ctx.lower_attrs(&file)),
+                    Some(attrs @ AttrsOrCfg::CfgDisabled(_)) => attrs,
+                    None => ctx.lower_attrs(&file)
+                };
                 let mut item_tree = ctx.lower_module_items(&file);
                 item_tree.top_attrs = top_attrs;
                 item_tree