Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/ide-completion/src/completions/flyimport.rs')
| -rw-r--r-- | crates/ide-completion/src/completions/flyimport.rs | 268 |
1 files changed, 268 insertions, 0 deletions
diff --git a/crates/ide-completion/src/completions/flyimport.rs b/crates/ide-completion/src/completions/flyimport.rs new file mode 100644 index 0000000000..76d708ae51 --- /dev/null +++ b/crates/ide-completion/src/completions/flyimport.rs @@ -0,0 +1,268 @@ +//! See [`import_on_the_fly`]. +use hir::{ItemInNs, ModuleDef}; +use ide_db::imports::{ + import_assets::{ImportAssets, ImportCandidate, LocatedImport}, + insert_use::ImportScope, +}; +use itertools::Itertools; +use syntax::{AstNode, SyntaxNode, T}; + +use crate::{ + context::{CompletionContext, PathKind}, + patterns::ImmediateLocation, + render::{render_resolution_with_import, RenderContext}, +}; + +use super::Completions; + +// Feature: Completion With Autoimport +// +// When completing names in the current scope, proposes additional imports from other modules or crates, +// if they can be qualified in the scope, and their name contains all symbols from the completion input. +// +// To be considered applicable, the name must contain all input symbols in the given order, not necessarily adjacent. +// If any input symbol is not lowercased, the name must contain all symbols in exact case; otherwise the containing is checked case-insensitively. +// +// ``` +// fn main() { +// pda$0 +// } +// # pub mod std { pub mod marker { pub struct PhantomData { } } } +// ``` +// -> +// ``` +// use std::marker::PhantomData; +// +// fn main() { +// PhantomData +// } +// # pub mod std { pub mod marker { pub struct PhantomData { } } } +// ``` +// +// Also completes associated items, that require trait imports. +// If any unresolved and/or partially-qualified path precedes the input, it will be taken into account. +// Currently, only the imports with their import path ending with the whole qualifier will be proposed +// (no fuzzy matching for qualifier). +// +// ``` +// mod foo { +// pub mod bar { +// pub struct Item; +// +// impl Item { +// pub const TEST_ASSOC: usize = 3; +// } +// } +// } +// +// fn main() { +// bar::Item::TEST_A$0 +// } +// ``` +// -> +// ``` +// use foo::bar; +// +// mod foo { +// pub mod bar { +// pub struct Item; +// +// impl Item { +// pub const TEST_ASSOC: usize = 3; +// } +// } +// } +// +// fn main() { +// bar::Item::TEST_ASSOC +// } +// ``` +// +// NOTE: currently, if an assoc item comes from a trait that's not currently imported, and it also has an unresolved and/or partially-qualified path, +// no imports will be proposed. +// +// .Fuzzy search details +// +// To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only +// (i.e. in `HashMap` in the `std::collections::HashMap` path). +// For the same reasons, avoids searching for any path imports for inputs with their length less than 2 symbols +// (but shows all associated items for any input length). +// +// .Import configuration +// +// It is possible to configure how use-trees are merged with the `importMergeBehavior` setting. +// Mimics the corresponding behavior of the `Auto Import` feature. +// +// .LSP and performance implications +// +// The feature is enabled only if the LSP client supports LSP protocol version 3.16+ and reports the `additionalTextEdits` +// (case-sensitive) resolve client capability in its client capabilities. +// This way the server is able to defer the costly computations, doing them for a selected completion item only. +// For clients with no such support, all edits have to be calculated on the completion request, including the fuzzy search completion ones, +// which might be slow ergo the feature is automatically disabled. +// +// .Feature toggle +// +// The feature can be forcefully turned off in the settings with the `rust-analyzer.completion.autoimport.enable` flag. +// Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corresponding +// capability enabled. +pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> { + if !ctx.config.enable_imports_on_the_fly { + return None; + } + if matches!(ctx.path_kind(), Some(PathKind::Vis { .. } | PathKind::Use)) + || ctx.is_path_disallowed() + || ctx.expects_item() + || ctx.expects_assoc_item() + || ctx.expects_variant() + { + return None; + } + // FIXME: This should be encoded in a different way + if ctx.pattern_ctx.is_none() && ctx.path_context.is_none() && !ctx.has_dot_receiver() { + // completion inside `ast::Name` of a item declaration + return None; + } + let potential_import_name = { + let token_kind = ctx.token.kind(); + if matches!(token_kind, T![.] | T![::]) { + String::new() + } else { + ctx.token.to_string() + } + }; + + let _p = profile::span("import_on_the_fly").detail(|| potential_import_name.clone()); + + let user_input_lowercased = potential_import_name.to_lowercase(); + let import_assets = import_assets(ctx, potential_import_name)?; + let position = position_for_import(ctx, Some(import_assets.import_candidate()))?; + if ImportScope::find_insert_use_container(&position, &ctx.sema).is_none() { + return None; + } + + let path_kind = match ctx.path_kind() { + Some(kind) => Some(kind), + None if ctx.pattern_ctx.is_some() => Some(PathKind::Pat), + None => None, + }; + let ns_filter = |import: &LocatedImport| { + let path_kind = match path_kind { + Some(path_kind) => path_kind, + None => match import.original_item { + ItemInNs::Macros(mac) => return mac.is_fn_like(ctx.db), + _ => return true, + }, + }; + match (path_kind, import.original_item) { + // Aren't handled in flyimport + (PathKind::Vis { .. } | PathKind::Use, _) => false, + // modules are always fair game + (_, ItemInNs::Types(hir::ModuleDef::Module(_))) => true, + // and so are macros(except for attributes) + ( + PathKind::Expr | PathKind::Type | PathKind::Mac | PathKind::Pat, + ItemInNs::Macros(mac), + ) => mac.is_fn_like(ctx.db), + (PathKind::Mac, _) => true, + + (PathKind::Expr, ItemInNs::Types(_) | ItemInNs::Values(_)) => true, + + (PathKind::Pat, ItemInNs::Types(_)) => true, + (PathKind::Pat, ItemInNs::Values(def)) => matches!(def, hir::ModuleDef::Const(_)), + + (PathKind::Type, ItemInNs::Types(ty)) => { + if matches!(ctx.completion_location, Some(ImmediateLocation::TypeBound)) { + matches!(ty, ModuleDef::Trait(_)) + } else { + true + } + } + (PathKind::Type, ItemInNs::Values(_)) => false, + + (PathKind::Attr { .. }, ItemInNs::Macros(mac)) => mac.is_attr(ctx.db), + (PathKind::Attr { .. }, _) => false, + + (PathKind::Derive, ItemInNs::Macros(mac)) => { + mac.is_derive(ctx.db) && !ctx.existing_derives.contains(&mac) + } + (PathKind::Derive, _) => false, + } + }; + + acc.add_all( + import_assets + .search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind) + .into_iter() + .filter(ns_filter) + .filter(|import| { + !ctx.is_item_hidden(&import.item_to_import) + && !ctx.is_item_hidden(&import.original_item) + }) + .sorted_by_key(|located_import| { + compute_fuzzy_completion_order_key( + &located_import.import_path, + &user_input_lowercased, + ) + }) + .filter_map(|import| render_resolution_with_import(RenderContext::new(ctx), import)) + .map(|builder| builder.build()), + ); + Some(()) +} + +pub(crate) fn position_for_import( + ctx: &CompletionContext, + import_candidate: Option<&ImportCandidate>, +) -> Option<SyntaxNode> { + Some( + match import_candidate { + Some(ImportCandidate::Path(_)) => ctx.name_syntax.as_ref()?.syntax(), + Some(ImportCandidate::TraitAssocItem(_)) => ctx.path_qual()?.syntax(), + Some(ImportCandidate::TraitMethod(_)) => ctx.dot_receiver()?.syntax(), + None => return ctx.original_token.parent(), + } + .clone(), + ) +} + +fn import_assets(ctx: &CompletionContext, fuzzy_name: String) -> Option<ImportAssets> { + let current_module = ctx.module; + if let Some(dot_receiver) = ctx.dot_receiver() { + ImportAssets::for_fuzzy_method_call( + current_module, + ctx.sema.type_of_expr(dot_receiver)?.original, + fuzzy_name, + dot_receiver.syntax().clone(), + ) + } else { + let fuzzy_name_length = fuzzy_name.len(); + let mut assets_for_path = ImportAssets::for_fuzzy_path( + current_module, + ctx.path_qual().cloned(), + fuzzy_name, + &ctx.sema, + ctx.token.parent()?, + )?; + if fuzzy_name_length < 3 { + cov_mark::hit!(flyimport_exact_on_short_path); + assets_for_path.path_fuzzy_name_to_exact(false); + } + Some(assets_for_path) + } +} + +pub(crate) fn compute_fuzzy_completion_order_key( + proposed_mod_path: &hir::ModPath, + user_input_lowercased: &str, +) -> usize { + cov_mark::hit!(certain_fuzzy_order_test); + let import_name = match proposed_mod_path.segments().last() { + Some(name) => name.to_smol_str().to_lowercase(), + None => return usize::MAX, + }; + match import_name.match_indices(user_input_lowercased).next() { + Some((first_matching_index, _)) => first_matching_index, + None => usize::MAX, + } +} |