Merge pull request #20517 from Veykril/veykril/push-wrurmtqppzus

fix: Only compute unstable paths on nightly toolchains for IDE features

Author: Veykril

src/tools/rust-analyzer/crates/hir-def/src/find_path.rs

@@ -12,7 +12,7 @@ use intern::sym;
 use rustc_hash::FxHashSet;
 
 use crate::{
-    ImportPathConfig, ModuleDefId, ModuleId,
+    FindPathConfig, ModuleDefId, ModuleId,
     db::DefDatabase,
     item_scope::ItemInNs,
     nameres::DefMap,
@@ -27,7 +27,7 @@ pub fn find_path(
     from: ModuleId,
     mut prefix_kind: PrefixKind,
     ignore_local_imports: bool,
-    mut cfg: ImportPathConfig,
+    mut cfg: FindPathConfig,
 ) -> Option<ModPath> {
     let _p = tracing::info_span!("find_path").entered();
 
@@ -96,7 +96,7 @@ impl PrefixKind {
 struct FindPathCtx<'db> {
     db: &'db dyn DefDatabase,
     prefix: PrefixKind,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
     ignore_local_imports: bool,
     is_std_item: bool,
     from: ModuleId,
@@ -718,7 +718,7 @@ mod tests {
                 module,
                 prefix,
                 ignore_local_imports,
-                ImportPathConfig { prefer_no_std, prefer_prelude, prefer_absolute, allow_unstable },
+                FindPathConfig { prefer_no_std, prefer_prelude, prefer_absolute, allow_unstable },
             );
             format_to!(
                 res,

src/tools/rust-analyzer/crates/hir-def/src/lib.rs

@@ -101,7 +101,7 @@ use crate::{
 type FxIndexMap<K, V> = indexmap::IndexMap<K, V, rustc_hash::FxBuildHasher>;
 /// A wrapper around three booleans
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Copy)]
-pub struct ImportPathConfig {
+pub struct FindPathConfig {
     /// If true, prefer to unconditionally use imports of the `core` and `alloc` crate
     /// over the std.
     pub prefer_no_std: bool,

src/tools/rust-analyzer/crates/hir-ty/src/display.rs

@@ -11,7 +11,7 @@ use base_db::Crate;
 use chalk_ir::{BoundVar, Safety, TyKind};
 use either::Either;
 use hir_def::{
-    GeneralConstId, GenericDefId, HasModule, ImportPathConfig, LocalFieldId, Lookup, ModuleDefId,
+    FindPathConfig, GeneralConstId, GenericDefId, HasModule, LocalFieldId, Lookup, ModuleDefId,
     ModuleId, TraitId,
     db::DefDatabase,
     expr_store::{ExpressionStore, path::Path},
@@ -1416,7 +1416,7 @@ impl<'db> HirDisplay for crate::next_solver::Ty<'db> {
                             PrefixKind::Plain,
                             false,
                             // FIXME: no_std Cfg?
-                            ImportPathConfig {
+                            FindPathConfig {
                                 prefer_no_std: false,
                                 prefer_prelude: true,
                                 prefer_absolute: false,

src/tools/rust-analyzer/crates/hir/src/lib.rs

@@ -129,7 +129,7 @@ pub use {
     cfg::{CfgAtom, CfgExpr, CfgOptions},
     hir_def::{
         Complete,
-        ImportPathConfig,
+        FindPathConfig,
         attr::{AttrSourceMap, Attrs, AttrsWithOwner},
         find_path::PrefixKind,
         import_map,
@@ -956,7 +956,7 @@ impl Module {
         self,
         db: &dyn DefDatabase,
         item: impl Into<ItemInNs>,
-        cfg: ImportPathConfig,
+        cfg: FindPathConfig,
     ) -> Option<ModPath> {
         hir_def::find_path::find_path(
             db,
@@ -975,7 +975,7 @@ impl Module {
         db: &dyn DefDatabase,
         item: impl Into<ItemInNs>,
         prefix_kind: PrefixKind,
-        cfg: ImportPathConfig,
+        cfg: FindPathConfig,
     ) -> Option<ModPath> {
         hir_def::find_path::find_path(db, item.into().into(), self.into(), prefix_kind, true, cfg)
     }

src/tools/rust-analyzer/crates/hir/src/semantics.rs

@@ -302,6 +302,13 @@ impl<DB: HirDatabase + ?Sized> Semantics<'_, DB> {
         self.imp.hir_file_to_module_defs(file.into())
     }
 
+    pub fn is_nightly(&self, krate: Crate) -> bool {
+        let toolchain = self.db.toolchain_channel(krate.into());
+        // `toolchain == None` means we're in some detached files. Since we have no information on
+        // the toolchain being used, let's just allow unstable items to be listed.
+        matches!(toolchain, Some(base_db::ReleaseChannel::Nightly) | None)
+    }
+
     pub fn to_adt_def(&self, a: &ast::Adt) -> Option<Adt> {
         self.imp.to_def(a)
     }

src/tools/rust-analyzer/crates/hir/src/term_search/expr.rs

@@ -1,6 +1,6 @@
 //! Type tree for term search
 
-use hir_def::ImportPathConfig;
+use hir_def::FindPathConfig;
 use hir_expand::mod_path::ModPath;
 use hir_ty::{
     db::HirDatabase,
@@ -18,7 +18,7 @@ use crate::{
 fn mod_item_path(
     sema_scope: &SemanticsScope<'_>,
     def: &ModuleDef,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
 ) -> Option<ModPath> {
     let db = sema_scope.db;
     let m = sema_scope.module();
@@ -29,7 +29,7 @@ fn mod_item_path(
 fn mod_item_path_str(
     sema_scope: &SemanticsScope<'_>,
     def: &ModuleDef,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
     edition: Edition,
 ) -> Result<String, DisplaySourceCodeError> {
     let path = mod_item_path(sema_scope, def, cfg);
@@ -103,7 +103,7 @@ impl<'db> Expr<'db> {
         &self,
         sema_scope: &SemanticsScope<'db>,
         many_formatter: &mut dyn FnMut(&Type<'db>) -> String,
-        cfg: ImportPathConfig,
+        cfg: FindPathConfig,
         display_target: DisplayTarget,
     ) -> Result<String, DisplaySourceCodeError> {
         let db = sema_scope.db;
@@ -380,7 +380,7 @@ impl<'db> Expr<'db> {
 fn container_name(
     container: AssocItemContainer,
     sema_scope: &SemanticsScope<'_>,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
     edition: Edition,
     display_target: DisplayTarget,
 ) -> Result<String, DisplaySourceCodeError> {

src/tools/rust-analyzer/crates/ide-assists/src/assist_config.rs

@@ -4,8 +4,12 @@
 //! module, and we use to statically check that we only produce snippet
 //! assists if we are allowed to.
 
-use hir::ImportPathConfig;
-use ide_db::{SnippetCap, assists::ExprFillDefaultMode, imports::insert_use::InsertUseConfig};
+use hir::FindPathConfig;
+use ide_db::{
+    SnippetCap,
+    assists::ExprFillDefaultMode,
+    imports::{import_assets::ImportPathConfig, insert_use::InsertUseConfig},
+};
 
 use crate::AssistKind;
 
@@ -31,7 +35,15 @@ impl AssistConfig {
             prefer_no_std: self.prefer_no_std,
             prefer_prelude: self.prefer_prelude,
             prefer_absolute: self.prefer_absolute,
-            allow_unstable: true,
+        }
+    }
+
+    pub fn find_path_confg(&self, allow_unstable: bool) -> FindPathConfig {
+        FindPathConfig {
+            prefer_no_std: self.prefer_no_std,
+            prefer_prelude: self.prefer_prelude,
+            prefer_absolute: self.prefer_absolute,
+            allow_unstable,
         }
     }
 }

src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_missing_match_arms.rs

@@ -1,7 +1,7 @@
 use std::iter::{self, Peekable};
 
 use either::Either;
-use hir::{Adt, AsAssocItem, Crate, HasAttrs, ImportPathConfig, ModuleDef, Semantics, sym};
+use hir::{Adt, AsAssocItem, Crate, FindPathConfig, HasAttrs, ModuleDef, Semantics, sym};
 use ide_db::RootDatabase;
 use ide_db::assists::ExprFillDefaultMode;
 use ide_db::syntax_helpers::suggest_name;
@@ -76,12 +76,11 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
         .filter(|pat| !matches!(pat, Pat::WildcardPat(_)))
         .collect();
 
-    let cfg = ctx.config.import_path_config();
-
     let make = SyntaxFactory::with_mappings();
 
     let scope = ctx.sema.scope(expr.syntax())?;
     let module = scope.module();
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(scope.krate()));
     let self_ty = if ctx.config.prefer_self_ty {
         scope
             .containing_function()
@@ -498,7 +497,7 @@ fn build_pat(
     make: &SyntaxFactory,
     module: hir::Module,
     var: ExtendedVariant,
-    cfg: ImportPathConfig,
+    cfg: FindPathConfig,
 ) -> Option<ast::Pat> {
     let db = ctx.db();
     match var {

src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_bool_to_enum.rs

@@ -329,8 +329,6 @@ fn augment_references_with_imports(
 ) -> Vec<FileReferenceWithImport> {
     let mut visited_modules = FxHashSet::default();
 
-    let cfg = ctx.config.import_path_config();
-
     let edition = target_module.krate().edition(ctx.db());
     references
         .into_iter()
@@ -345,22 +343,27 @@ fn augment_references_with_imports(
             {
                 visited_modules.insert(ref_module);
 
-                let import_scope = ImportScope::find_insert_use_container(name.syntax(), &ctx.sema);
-                let path = ref_module
-                    .find_use_path(
-                        ctx.sema.db,
-                        ModuleDef::Module(*target_module),
-                        ctx.config.insert_use.prefix_kind,
-                        cfg,
-                    )
-                    .map(|mod_path| {
-                        make::path_concat(
-                            mod_path_to_ast(&mod_path, edition),
-                            make::path_from_text("Bool"),
-                        )
-                    });
+                ImportScope::find_insert_use_container(name.syntax(), &ctx.sema).and_then(
+                    |import_scope| {
+                        let cfg =
+                            ctx.config.find_path_confg(ctx.sema.is_nightly(target_module.krate()));
+                        let path = ref_module
+                            .find_use_path(
+                                ctx.sema.db,
+                                ModuleDef::Module(*target_module),
+                                ctx.config.insert_use.prefix_kind,
+                                cfg,
+                            )
+                            .map(|mod_path| {
+                                make::path_concat(
+                                    mod_path_to_ast(&mod_path, edition),
+                                    make::path_from_text("Bool"),
+                                )
+                            })?;
 
-                import_scope.zip(path)
+                        Some((import_scope, path))
+                    },
+                )
             } else {
                 None
             };

src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_into_to_from.rs

@@ -43,7 +43,7 @@ pub(crate) fn convert_into_to_from(acc: &mut Assists, ctx: &AssistContext<'_>) -
         return None;
     }
 
-    let cfg = ctx.config.import_path_config();
+    let cfg = ctx.config.find_path_confg(ctx.sema.is_nightly(module.krate()));
 
     let src_type_path = {
         let src_type_path = src_type.syntax().descendants().find_map(ast::Path::cast)?;