Auto merge of #13212 - Veykril:no-std-config, r=Veykril

Add config to unconditionally prefer core imports over std

Fixes #12979

crates/hir-def/src/find_path.rs

@@ -16,19 +16,25 @@ use crate::{
 
 /// Find a path that can be used to refer to a certain item. This can depend on
 /// *from where* you're referring to the item, hence the `from` parameter.
-pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
+pub fn find_path(
+    db: &dyn DefDatabase,
+    item: ItemInNs,
+    from: ModuleId,
+    prefer_core: bool,
+) -> Option<ModPath> {
     let _p = profile::span("find_path");
-    find_path_inner(db, item, from, None)
+    find_path_inner(db, item, from, None, prefer_core)
 }
 
 pub fn find_path_prefixed(
     db: &dyn DefDatabase,
     item: ItemInNs,
     from: ModuleId,
     prefix_kind: PrefixKind,
+    prefer_core: bool,
 ) -> Option<ModPath> {
     let _p = profile::span("find_path_prefixed");
-    find_path_inner(db, item, from, Some(prefix_kind))
+    find_path_inner(db, item, from, Some(prefix_kind), prefer_core)
 }
 
 const MAX_PATH_LEN: usize = 15;
@@ -100,12 +106,22 @@ fn find_path_inner(
     item: ItemInNs,
     from: ModuleId,
     prefixed: Option<PrefixKind>,
+    prefer_core: bool,
 ) -> Option<ModPath> {
     // FIXME: Do fast path for std/core libs?
 
     let mut visited_modules = FxHashSet::default();
     let def_map = from.def_map(db);
-    find_path_inner_(db, &def_map, from, item, MAX_PATH_LEN, prefixed, &mut visited_modules)
+    find_path_inner_(
+        db,
+        &def_map,
+        from,
+        item,
+        MAX_PATH_LEN,
+        prefixed,
+        &mut visited_modules,
+        prefer_core,
+    )
 }
 
 fn find_path_inner_(
@@ -116,6 +132,7 @@ fn find_path_inner_(
     max_len: usize,
     mut prefixed: Option<PrefixKind>,
     visited_modules: &mut FxHashSet<ModuleId>,
+    prefer_core: bool,
 ) -> Option<ModPath> {
     if max_len == 0 {
         return None;
@@ -191,7 +208,9 @@ fn find_path_inner_(
     // Recursive case:
     // - if the item is an enum variant, refer to it via the enum
     if let Some(ModuleDefId::EnumVariantId(variant)) = item.as_module_def_id() {
-        if let Some(mut path) = find_path(db, ItemInNs::Types(variant.parent.into()), from) {
+        if let Some(mut path) =
+            find_path(db, ItemInNs::Types(variant.parent.into()), from, prefer_core)
+        {
             let data = db.enum_data(variant.parent);
             path.push_segment(data.variants[variant.local_id].name.clone());
             return Some(path);
@@ -202,7 +221,7 @@ fn find_path_inner_(
     }
 
     // - otherwise, look for modules containing (reexporting) it and import it from one of those
-    let prefer_no_std = db.crate_supports_no_std(crate_root.krate);
+    let prefer_no_std = prefer_core || db.crate_supports_no_std(crate_root.krate);
     let mut best_path = None;
     let mut best_path_len = max_len;
 
@@ -223,6 +242,7 @@ fn find_path_inner_(
                 best_path_len - 1,
                 prefixed,
                 visited_modules,
+                prefer_core,
             ) {
                 path.push_segment(name);
 
@@ -253,6 +273,7 @@ fn find_path_inner_(
                     best_path_len - 1,
                     prefixed,
                     visited_modules,
+                    prefer_core,
                 )?;
                 cov_mark::hit!(partially_imported);
                 path.push_segment(info.path.segments.last()?.clone());
@@ -428,7 +449,8 @@ mod tests {
             .take_types()
             .unwrap();
 
-        let found_path = find_path_inner(&db, ItemInNs::Types(resolved), module, prefix_kind);
+        let found_path =
+            find_path_inner(&db, ItemInNs::Types(resolved), module, prefix_kind, false);
         assert_eq!(found_path, Some(mod_path), "{:?}", prefix_kind);
     }
 

crates/hir-ty/src/display.rs

@@ -533,6 +533,7 @@ impl HirDisplay for Ty {
                             f.db.upcast(),
                             ItemInNs::Types((*def_id).into()),
                             module_id,
+                            false,
                         ) {
                             write!(f, "{}", path)?;
                         } else {

crates/hir/src/lib.rs

@@ -582,8 +582,13 @@ impl Module {
 
     /// Finds a path that can be used to refer to the given item from within
     /// this module, if possible.
-    pub fn find_use_path(self, db: &dyn DefDatabase, item: impl Into<ItemInNs>) -> Option<ModPath> {
-        hir_def::find_path::find_path(db, item.into().into(), self.into())
+    pub fn find_use_path(
+        self,
+        db: &dyn DefDatabase,
+        item: impl Into<ItemInNs>,
+        prefer_core: bool,
+    ) -> Option<ModPath> {
+        hir_def::find_path::find_path(db, item.into().into(), self.into(), prefer_core)
     }
 
     /// Finds a path that can be used to refer to the given item from within
@@ -593,8 +598,15 @@ impl Module {
         db: &dyn DefDatabase,
         item: impl Into<ItemInNs>,
         prefix_kind: PrefixKind,
+        prefer_core: bool,
     ) -> Option<ModPath> {
-        hir_def::find_path::find_path_prefixed(db, item.into().into(), self.into(), prefix_kind)
+        hir_def::find_path::find_path_prefixed(
+            db,
+            item.into().into(),
+            self.into(),
+            prefix_kind,
+            prefer_core,
+        )
     }
 }
 

crates/ide-assists/src/assist_config.rs

@@ -13,4 +13,5 @@ pub struct AssistConfig {
     pub snippet_cap: Option<SnippetCap>,
     pub allowed: Option<Vec<AssistKind>>,
     pub insert_use: InsertUseConfig,
+    pub prefer_core: bool,
 }

crates/ide-assists/src/handlers/add_missing_match_arms.rs

@@ -87,7 +87,7 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
             .into_iter()
             .filter_map(|variant| {
                 Some((
-                    build_pat(ctx.db(), module, variant)?,
+                    build_pat(ctx.db(), module, variant, ctx.config.prefer_core)?,
                     variant.should_be_hidden(ctx.db(), module.krate()),
                 ))
             })
@@ -132,8 +132,9 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
                 let is_hidden = variants
                     .iter()
                     .any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));
-                let patterns =
-                    variants.into_iter().filter_map(|variant| build_pat(ctx.db(), module, variant));
+                let patterns = variants.into_iter().filter_map(|variant| {
+                    build_pat(ctx.db(), module, variant, ctx.config.prefer_core)
+                });
 
                 (ast::Pat::from(make::tuple_pat(patterns)), is_hidden)
             })
@@ -349,10 +350,16 @@ fn resolve_tuple_of_enum_def(
         .collect()
 }
 
-fn build_pat(db: &RootDatabase, module: hir::Module, var: ExtendedVariant) -> Option<ast::Pat> {
+fn build_pat(
+    db: &RootDatabase,
+    module: hir::Module,
+    var: ExtendedVariant,
+    prefer_core: bool,
+) -> Option<ast::Pat> {
     match var {
         ExtendedVariant::Variant(var) => {
-            let path = mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var))?);
+            let path =
+                mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var), prefer_core)?);
 
             // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
             let pat: ast::Pat = match var.source(db)?.value.kind() {

crates/ide-assists/src/handlers/auto_import.rs

@@ -89,8 +89,11 @@ use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel};
 // ```
 pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
     let (import_assets, syntax_under_caret) = find_importable_node(ctx)?;
-    let mut proposed_imports =
-        import_assets.search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind);
+    let mut proposed_imports = import_assets.search_for_imports(
+        &ctx.sema,
+        ctx.config.insert_use.prefix_kind,
+        ctx.config.prefer_core,
+    );
     if proposed_imports.is_empty() {
         return None;
     }

crates/ide-assists/src/handlers/convert_into_to_from.rs

@@ -50,7 +50,7 @@ pub(crate) fn convert_into_to_from(acc: &mut Assists, ctx: &AssistContext<'_>) -
             _ => return None,
         };
 
-        mod_path_to_ast(&module.find_use_path(ctx.db(), src_type_def)?)
+        mod_path_to_ast(&module.find_use_path(ctx.db(), src_type_def, ctx.config.prefer_core)?)
     };
 
     let dest_type = match &ast_trait {

crates/ide-assists/src/handlers/extract_function.rs

@@ -152,6 +152,7 @@ pub(crate) fn extract_function(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                         ctx.sema.db,
                         ModuleDef::from(control_flow_enum),
                         ctx.config.insert_use.prefix_kind,
+                        ctx.config.prefer_core,
                     );
 
                     if let Some(mod_path) = mod_path {

crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs

@@ -409,6 +409,7 @@ fn process_references(
                     ctx.sema.db,
                     *enum_module_def,
                     ctx.config.insert_use.prefix_kind,
+                    ctx.config.prefer_core,
                 );
                 if let Some(mut mod_path) = mod_path {
                     mod_path.pop_segment();

crates/ide-assists/src/handlers/generate_deref.rs

@@ -58,7 +58,8 @@ fn generate_record_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
 
     let module = ctx.sema.to_def(&strukt)?.module(ctx.db());
     let trait_ = deref_type_to_generate.to_trait(&ctx.sema, module.krate())?;
-    let trait_path = module.find_use_path(ctx.db(), ModuleDef::Trait(trait_))?;
+    let trait_path =
+        module.find_use_path(ctx.db(), ModuleDef::Trait(trait_), ctx.config.prefer_core)?;
 
     let field_type = field.ty()?;
     let field_name = field.name()?;
@@ -98,7 +99,8 @@ fn generate_tuple_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()
 
     let module = ctx.sema.to_def(&strukt)?.module(ctx.db());
     let trait_ = deref_type_to_generate.to_trait(&ctx.sema, module.krate())?;
-    let trait_path = module.find_use_path(ctx.db(), ModuleDef::Trait(trait_))?;
+    let trait_path =
+        module.find_use_path(ctx.db(), ModuleDef::Trait(trait_), ctx.config.prefer_core)?;
 
     let field_type = field.ty()?;
     let target = field.syntax().text_range();

crates/ide-assists/src/handlers/generate_new.rs

@@ -60,8 +60,11 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
 
                 let item_in_ns = hir::ItemInNs::from(hir::ModuleDef::from(ty.as_adt()?));
 
-                let type_path = current_module
-                    .find_use_path(ctx.sema.db, item_for_path_search(ctx.sema.db, item_in_ns)?)?;
+                let type_path = current_module.find_use_path(
+                    ctx.sema.db,
+                    item_for_path_search(ctx.sema.db, item_in_ns)?,
+                    ctx.config.prefer_core,
+                )?;
 
                 let expr = use_trivial_constructor(
                     &ctx.sema.db,

crates/ide-assists/src/handlers/qualify_method_call.rs

@@ -44,8 +44,11 @@ pub(crate) fn qualify_method_call(acc: &mut Assists, ctx: &AssistContext<'_>) ->
     let current_module = ctx.sema.scope(call.syntax())?.module();
     let target_module_def = ModuleDef::from(resolved_call);
     let item_in_ns = ItemInNs::from(target_module_def);
-    let receiver_path = current_module
-        .find_use_path(ctx.sema.db, item_for_path_search(ctx.sema.db, item_in_ns)?)?;
+    let receiver_path = current_module.find_use_path(
+        ctx.sema.db,
+        item_for_path_search(ctx.sema.db, item_in_ns)?,
+        ctx.config.prefer_core,
+    )?;
 
     let qualify_candidate = QualifyCandidate::ImplMethod(ctx.sema.db, call, resolved_call);
 

crates/ide-assists/src/handlers/qualify_path.rs

@@ -37,7 +37,8 @@ use crate::{
 // ```
 pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
     let (import_assets, syntax_under_caret) = find_importable_node(ctx)?;
-    let mut proposed_imports = import_assets.search_for_relative_paths(&ctx.sema);
+    let mut proposed_imports =
+        import_assets.search_for_relative_paths(&ctx.sema, ctx.config.prefer_core);
     if proposed_imports.is_empty() {
         return None;
     }

crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs

@@ -85,7 +85,7 @@ pub(crate) fn replace_derive_with_manual_impl(
     })
     .flat_map(|trait_| {
         current_module
-            .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_))
+            .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_), ctx.config.prefer_core)
             .as_ref()
             .map(mod_path_to_ast)
             .zip(Some(trait_))

crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs

@@ -67,6 +67,7 @@ pub(crate) fn replace_qualified_name_with_use(
                 ctx.sema.db,
                 module,
                 ctx.config.insert_use.prefix_kind,
+                ctx.config.prefer_core,
             )
         })
         .flatten();

crates/ide-assists/src/tests.rs

@@ -29,6 +29,7 @@ pub(crate) const TEST_CONFIG: AssistConfig = AssistConfig {
         group: true,
         skip_glob_imports: true,
     },
+    prefer_core: false,
 };
 
 pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {

crates/ide-completion/src/completions.rs

@@ -551,7 +551,9 @@ fn enum_variants_with_paths(
     }
 
     for variant in variants {
-        if let Some(path) = ctx.module.find_use_path(ctx.db, hir::ModuleDef::from(variant)) {
+        if let Some(path) =
+            ctx.module.find_use_path(ctx.db, hir::ModuleDef::from(variant), ctx.config.prefer_core)
+        {
             // Variants with trivial paths are already added by the existing completion logic,
             // so we should avoid adding these twice
             if path.segments().len() > 1 {

crates/ide-completion/src/completions/expr.rs

@@ -165,7 +165,11 @@ pub(crate) fn complete_expr_path(
                     hir::Adt::Struct(strukt) => {
                         let path = ctx
                             .module
-                            .find_use_path(ctx.db, hir::ModuleDef::from(strukt))
+                            .find_use_path(
+                                ctx.db,
+                                hir::ModuleDef::from(strukt),
+                                ctx.config.prefer_core,
+                            )
                             .filter(|it| it.len() > 1);
 
                         acc.add_struct_literal(ctx, path_ctx, strukt, path, None);
@@ -183,7 +187,7 @@ pub(crate) fn complete_expr_path(
                     hir::Adt::Union(un) => {
                         let path = ctx
                             .module
-                            .find_use_path(ctx.db, hir::ModuleDef::from(un))
+                            .find_use_path(ctx.db, hir::ModuleDef::from(un), ctx.config.prefer_core)
                             .filter(|it| it.len() > 1);
 
                         acc.add_union_literal(ctx, un, path, None);

crates/ide-completion/src/completions/flyimport.rs

@@ -262,7 +262,11 @@ fn import_on_the_fly(
 
     acc.add_all(
         import_assets
-            .search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind)
+            .search_for_imports(
+                &ctx.sema,
+                ctx.config.insert_use.prefix_kind,
+                ctx.config.prefer_core,
+            )
             .into_iter()
             .filter(ns_filter)
             .filter(|import| {
@@ -306,7 +310,11 @@ fn import_on_the_fly_pat_(
 
     acc.add_all(
         import_assets
-            .search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind)
+            .search_for_imports(
+                &ctx.sema,
+                ctx.config.insert_use.prefix_kind,
+                ctx.config.prefer_core,
+            )
             .into_iter()
             .filter(ns_filter)
             .filter(|import| {
@@ -344,7 +352,7 @@ fn import_on_the_fly_method(
     let user_input_lowercased = potential_import_name.to_lowercase();
 
     import_assets
-        .search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind)
+        .search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind, ctx.config.prefer_core)
         .into_iter()
         .filter(|import| {
             !ctx.is_item_hidden(&import.item_to_import)

crates/ide-completion/src/config.rs

@@ -17,6 +17,7 @@ pub struct CompletionConfig {
     pub callable: Option<CallableSnippets>,
     pub snippet_cap: Option<SnippetCap>,
     pub insert_use: InsertUseConfig,
+    pub prefer_core: bool,
     pub snippets: Vec<Snippet>,
 }