Merge pull request rust-lang#19308 from Veykril/push-rnrxutwlvmly

Move loaded project MSRV back to 1.78, show notification for the warning

Author: Veykril

src/tools/rust-analyzer/crates/project-model/src/project_json.rs

@@ -86,7 +86,7 @@ impl ProjectJson {
     /// * `manifest` - The path to the `rust-project.json`.
     /// * `base` - The path to the workspace root (i.e. the folder containing `rust-project.json`)
     /// * `data` - The parsed contents of `rust-project.json`, or project json that's passed via
-    ///            configuration.
+    ///   configuration.
     pub fn new(
         manifest: Option<ManifestPath>,
         base: &AbsPath,

src/tools/rust-analyzer/crates/project-model/src/sysroot.rs

@@ -30,6 +30,7 @@ pub struct Sysroot {
 pub enum RustLibSrcWorkspace {
     Workspace(CargoWorkspace),
     Json(ProjectJson),
+    Stitched(stitched::Stitched),
     Empty,
 }
 
@@ -60,6 +61,7 @@ impl Sysroot {
         match &self.workspace {
             RustLibSrcWorkspace::Workspace(ws) => ws.packages().next().is_none(),
             RustLibSrcWorkspace::Json(project_json) => project_json.n_crates() == 0,
+            RustLibSrcWorkspace::Stitched(stitched) => stitched.crates.is_empty(),
             RustLibSrcWorkspace::Empty => true,
         }
     }
@@ -72,6 +74,7 @@ impl Sysroot {
         match &self.workspace {
             RustLibSrcWorkspace::Workspace(ws) => ws.packages().count(),
             RustLibSrcWorkspace::Json(project_json) => project_json.n_crates(),
+            RustLibSrcWorkspace::Stitched(stitched) => stitched.crates.len(),
             RustLibSrcWorkspace::Empty => 0,
         }
     }
@@ -197,6 +200,51 @@ impl Sysroot {
                     return Some(loaded);
                 }
             }
+            tracing::debug!("Stitching sysroot library: {src_root}");
+
+            let mut stitched = stitched::Stitched { crates: Default::default() };
+
+            for path in stitched::SYSROOT_CRATES.trim().lines() {
+                let name = path.split('/').next_back().unwrap();
+                let root = [format!("{path}/src/lib.rs"), format!("lib{path}/lib.rs")]
+                    .into_iter()
+                    .map(|it| src_root.join(it))
+                    .filter_map(|it| ManifestPath::try_from(it).ok())
+                    .find(|it| fs::metadata(it).is_ok());
+
+                if let Some(root) = root {
+                    stitched.crates.alloc(stitched::RustLibSrcCrateData {
+                        name: name.into(),
+                        root,
+                        deps: Vec::new(),
+                    });
+                }
+            }
+
+            if let Some(std) = stitched.by_name("std") {
+                for dep in stitched::STD_DEPS.trim().lines() {
+                    if let Some(dep) = stitched.by_name(dep) {
+                        stitched.crates[std].deps.push(dep)
+                    }
+                }
+            }
+
+            if let Some(alloc) = stitched.by_name("alloc") {
+                for dep in stitched::ALLOC_DEPS.trim().lines() {
+                    if let Some(dep) = stitched.by_name(dep) {
+                        stitched.crates[alloc].deps.push(dep)
+                    }
+                }
+            }
+
+            if let Some(proc_macro) = stitched.by_name("proc_macro") {
+                for dep in stitched::PROC_MACRO_DEPS.trim().lines() {
+                    if let Some(dep) = stitched.by_name(dep) {
+                        stitched.crates[proc_macro].deps.push(dep)
+                    }
+                }
+            }
+            return Some(RustLibSrcWorkspace::Stitched(stitched));
         } else if let RustSourceWorkspaceConfig::Json(project_json) = sysroot_source_config {
             return Some(RustLibSrcWorkspace::Json(project_json.clone()));
         }
@@ -216,6 +264,7 @@ impl Sysroot {
                         .crates()
                         .filter_map(|(_, krate)| krate.display_name.clone())
                         .any(|name| name.canonical_name().as_str() == "core"),
+                    RustLibSrcWorkspace::Stitched(stitched) => stitched.by_name("core").is_some(),
                     RustLibSrcWorkspace::Empty => true,
                 };
                 if !has_core {
@@ -391,3 +440,91 @@ fn get_rust_lib_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
         None
     }
 }
+
+// FIXME: Remove this, that will bump our project MSRV to 1.82
+pub(crate) mod stitched {
+    use std::ops;
+
+    use base_db::CrateName;
+    use la_arena::{Arena, Idx};
+
+    use crate::ManifestPath;
+
+    #[derive(Debug, Clone, Eq, PartialEq)]
+    pub struct Stitched {
+        pub(super) crates: Arena<RustLibSrcCrateData>,
+    }
+
+    impl ops::Index<RustLibSrcCrate> for Stitched {
+        type Output = RustLibSrcCrateData;
+        fn index(&self, index: RustLibSrcCrate) -> &RustLibSrcCrateData {
+            &self.crates[index]
+        }
+    }
+
+    impl Stitched {
+        pub(crate) fn public_deps(
+            &self,
+        ) -> impl Iterator<Item = (CrateName, RustLibSrcCrate, bool)> + '_ {
+            // core is added as a dependency before std in order to
+            // mimic rustcs dependency order
+            [("core", true), ("alloc", false), ("std", true), ("test", false)]
+                .into_iter()
+                .filter_map(move |(name, prelude)| {
+                    Some((CrateName::new(name).unwrap(), self.by_name(name)?, prelude))
+                })
+        }
+
+        pub(crate) fn proc_macro(&self) -> Option<RustLibSrcCrate> {
+            self.by_name("proc_macro")
+        }
+
+        pub(crate) fn crates(&self) -> impl ExactSizeIterator<Item = RustLibSrcCrate> + '_ {
+            self.crates.iter().map(|(id, _data)| id)
+        }
+
+        pub(super) fn by_name(&self, name: &str) -> Option<RustLibSrcCrate> {
+            let (id, _data) = self.crates.iter().find(|(_id, data)| data.name == name)?;
+            Some(id)
+        }
+    }
+
+    pub(crate) type RustLibSrcCrate = Idx<RustLibSrcCrateData>;
+
+    #[derive(Debug, Clone, Eq, PartialEq)]
+    pub(crate) struct RustLibSrcCrateData {
+        pub(crate) name: String,
+        pub(crate) root: ManifestPath,
+        pub(crate) deps: Vec<RustLibSrcCrate>,
+    }
+
+    pub(super) const SYSROOT_CRATES: &str = "
+alloc
+backtrace
+core
+panic_abort
+panic_unwind
+proc_macro
+profiler_builtins
+std
+stdarch/crates/std_detect
+test
+unwind";
+
+    pub(super) const ALLOC_DEPS: &str = "core";
+
+    pub(super) const STD_DEPS: &str = "
+alloc
+panic_unwind
+panic_abort
+core
+profiler_builtins
+unwind
+std_detect
+test";
+
+    // core is required for our builtin derives to work in the proc_macro lib currently
+    pub(super) const PROC_MACRO_DEPS: &str = "
+std
+core";
+}

src/tools/rust-analyzer/crates/project-model/src/workspace.rs

@@ -692,6 +692,7 @@ impl ProjectWorkspace {
                         exclude: krate.exclude.clone(),
                     })
                     .collect(),
+                RustLibSrcWorkspace::Stitched(_) => vec![],
                 RustLibSrcWorkspace::Empty => vec![],
             };
 
@@ -1630,7 +1631,62 @@ fn sysroot_to_crate_graph(
 
             extend_crate_graph_with_sysroot(crate_graph, cg, pm)
         }
+        RustLibSrcWorkspace::Stitched(stitched) => {
+            let cfg_options = Arc::new({
+                let mut cfg_options = CfgOptions::default();
+                cfg_options.extend(rustc_cfg);
+                cfg_options.insert_atom(sym::debug_assertions.clone());
+                cfg_options.insert_atom(sym::miri.clone());
+                cfg_options
+            });
+            let sysroot_crates: FxHashMap<crate::sysroot::stitched::RustLibSrcCrate, CrateId> =
+                stitched
+                    .crates()
+                    .filter_map(|krate| {
+                        let file_id = load(&stitched[krate].root)?;
+
+                        let display_name =
+                            CrateDisplayName::from_canonical_name(&stitched[krate].name);
+                        let crate_id = crate_graph.add_crate_root(
+                            file_id,
+                            Edition::CURRENT_FIXME,
+                            Some(display_name),
+                            None,
+                            cfg_options.clone(),
+                            None,
+                            Env::default(),
+                            CrateOrigin::Lang(LangCrateOrigin::from(&*stitched[krate].name)),
+                            false,
+                            None,
+                        );
+                        Some((krate, crate_id))
+                    })
+                    .collect();
+
+            for from in stitched.crates() {
+                for &to in stitched[from].deps.iter() {
+                    let name = CrateName::new(&stitched[to].name).unwrap();
+                    if let (Some(&from), Some(&to)) =
+                        (sysroot_crates.get(&from), sysroot_crates.get(&to))
+                    {
+                        add_dep(crate_graph, from, name, to);
+                    }
+                }
+            }
 
+            let public_deps = SysrootPublicDeps {
+                deps: stitched
+                    .public_deps()
+                    .filter_map(|(name, idx, prelude)| {
+                        Some((name, *sysroot_crates.get(&idx)?, prelude))
+                    })
+                    .collect::<Vec<_>>(),
+            };
+
+            let libproc_macro =
+                stitched.proc_macro().and_then(|it| sysroot_crates.get(&it).copied());
+            (public_deps, libproc_macro)
+        }
         RustLibSrcWorkspace::Empty => (SysrootPublicDeps { deps: vec![] }, None),
     }
 }

src/tools/rust-analyzer/crates/project-model/test_data/output/rust_project_cfg_groups.txt

@@ -637,6 +637,25 @@ impl GlobalState {
             }
         });
     }
+
+    pub(crate) fn check_workspaces_msrv(&self) -> impl Iterator<Item = String> + '_ {
+        self.workspaces.iter().filter_map(|ws| {
+            if let Some(toolchain) = &ws.toolchain {
+                if *toolchain < crate::MINIMUM_SUPPORTED_TOOLCHAIN_VERSION {
+                    return Some(format!(
+                        "Workspace `{}` is using an outdated toolchain version `{}` but \
+                        rust-analyzer only supports `{}` and higher.\n\
+                        Consider using the rust-analyzer rustup component for your toolchain or
+                        upgrade your toolchain to a supported version.\n\n",
+                        ws.manifest_or_root(),
+                        toolchain,
+                        crate::MINIMUM_SUPPORTED_TOOLCHAIN_VERSION,
+                    ));
+                }
+            }
+            None
+        })
+    }
 }
 
 impl Drop for GlobalState {

src/tools/rust-analyzer/crates/project-model/test_data/output/rust_project_hello_world_project_model.txt

@@ -12,7 +12,7 @@
 /// Any toolchain less than this version will likely not work with rust-analyzer built from this revision.
 pub const MINIMUM_SUPPORTED_TOOLCHAIN_VERSION: semver::Version = semver::Version {
     major: 1,
-    minor: 82,
+    minor: 78,
     patch: 0,
     pre: semver::Prerelease::EMPTY,
     build: semver::BuildMetadata::EMPTY,

src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs

@@ -178,26 +178,15 @@ impl GlobalState {
         }
 
         if !self.workspaces.is_empty() {
+            self.check_workspaces_msrv().for_each(|e| {
+                status.health |= lsp_ext::Health::Warning;
+                format_to!(message, "{e}");
+            });
+
             let proc_macro_clients =
                 self.proc_macro_clients.iter().map(Some).chain(iter::repeat_with(|| None));
 
             for (ws, proc_macro_client) in self.workspaces.iter().zip(proc_macro_clients) {
-                if let Some(toolchain) = &ws.toolchain {
-                    if *toolchain < crate::MINIMUM_SUPPORTED_TOOLCHAIN_VERSION {
-                        status.health |= lsp_ext::Health::Warning;
-                        format_to!(
-                            message,
-                            "Workspace `{}` is using an outdated toolchain version `{}` but \
-                            rust-analyzer only supports `{}` and higher.\n\
-                            Consider using the rust-analyzer rustup component for your toolchain or
-                            upgrade your toolchain to a supported version.\n\n",
-                            ws.manifest_or_root(),
-                            toolchain,
-                            crate::MINIMUM_SUPPORTED_TOOLCHAIN_VERSION,
-                        );
-                    }
-                }
-
                 if let ProjectWorkspaceKind::Cargo { error: Some(error), .. }
                 | ProjectWorkspaceKind::DetachedFile {
                     cargo: Some((_, _, Some(error))), ..
@@ -529,6 +518,11 @@ impl GlobalState {
             // we don't care about build-script results, they are stale.
             // FIXME: can we abort the build scripts here if they are already running?
             self.workspaces = Arc::new(workspaces);
+            self.check_workspaces_msrv().for_each(|message| {
+                self.send_notification::<lsp_types::notification::ShowMessage>(
+                    lsp_types::ShowMessageParams { typ: lsp_types::MessageType::WARNING, message },
+                );
+            });
 
             if self.config.run_build_scripts(None) {
                 self.build_deps_changed = false;