2020-03-19 06:36:33 -05:00
|
|
|
use std::collections::BTreeSet;
|
|
|
|
|
2020-02-11 07:21:12 -06:00
|
|
|
use hir::{
|
2020-02-18 11:35:10 -06:00
|
|
|
AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution, Semantics, Trait,
|
|
|
|
Type,
|
2020-02-11 07:21:12 -06:00
|
|
|
};
|
2020-03-23 06:34:56 -05:00
|
|
|
use ra_ide_db::{imports_locator::ImportsLocator, RootDatabase};
|
2020-02-12 05:16:05 -06:00
|
|
|
use ra_prof::profile;
|
2020-02-12 05:21:12 -06:00
|
|
|
use ra_syntax::{
|
|
|
|
ast::{self, AstNode},
|
|
|
|
SyntaxNode,
|
|
|
|
};
|
2020-02-11 07:21:12 -06:00
|
|
|
use rustc_hash::FxHashSet;
|
2020-03-19 06:36:33 -05:00
|
|
|
|
|
|
|
use crate::{
|
|
|
|
assist_ctx::{Assist, AssistCtx},
|
|
|
|
utils::insert_use_statement,
|
|
|
|
AssistId,
|
|
|
|
};
|
2020-03-23 06:34:56 -05:00
|
|
|
use either::Either;
|
2019-12-23 18:19:09 -06:00
|
|
|
|
|
|
|
// Assist: auto_import
|
|
|
|
//
|
|
|
|
// If the name is unresolved, provides all possible imports for it.
|
|
|
|
//
|
|
|
|
// ```
|
|
|
|
// fn main() {
|
|
|
|
// let map = HashMap<|>::new();
|
|
|
|
// }
|
2020-02-06 11:10:25 -06:00
|
|
|
// # pub mod std { pub mod collections { pub struct HashMap { } } }
|
2019-12-23 18:19:09 -06:00
|
|
|
// ```
|
|
|
|
// ->
|
|
|
|
// ```
|
|
|
|
// use std::collections::HashMap;
|
|
|
|
//
|
|
|
|
// fn main() {
|
2020-02-06 11:10:25 -06:00
|
|
|
// let map = HashMap::new();
|
2019-12-23 18:19:09 -06:00
|
|
|
// }
|
2020-02-06 11:10:25 -06:00
|
|
|
// # pub mod std { pub mod collections { pub struct HashMap { } } }
|
2019-12-23 18:19:09 -06:00
|
|
|
// ```
|
2020-02-06 10:17:51 -06:00
|
|
|
pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
|
2020-02-12 06:41:34 -06:00
|
|
|
let auto_import_assets = AutoImportAssets::new(&ctx)?;
|
|
|
|
let proposed_imports = auto_import_assets.search_for_imports(ctx.db);
|
2019-12-23 18:19:09 -06:00
|
|
|
if proposed_imports.is_empty() {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
2020-05-02 14:24:55 -05:00
|
|
|
let range = ctx.sema.original_range(&auto_import_assets.syntax_under_caret).range;
|
2020-02-26 04:24:00 -06:00
|
|
|
let mut group = ctx.add_assist_group(auto_import_assets.get_import_group_message());
|
2020-02-09 07:30:27 -06:00
|
|
|
for import in proposed_imports {
|
|
|
|
group.add_assist(AssistId("auto_import"), format!("Import `{}`", &import), |edit| {
|
2020-05-02 14:24:55 -05:00
|
|
|
edit.target(range);
|
|
|
|
insert_use_statement(&auto_import_assets.syntax_under_caret, &import, edit);
|
2020-02-09 07:30:27 -06:00
|
|
|
});
|
|
|
|
}
|
|
|
|
group.finish()
|
2019-12-23 18:19:09 -06:00
|
|
|
}
|
|
|
|
|
2020-03-23 16:23:26 -05:00
|
|
|
#[derive(Debug)]
|
2020-02-11 10:24:43 -06:00
|
|
|
struct AutoImportAssets {
|
|
|
|
import_candidate: ImportCandidate,
|
|
|
|
module_with_name_to_import: Module,
|
|
|
|
syntax_under_caret: SyntaxNode,
|
2020-02-10 08:55:20 -06:00
|
|
|
}
|
|
|
|
|
2020-02-11 10:24:43 -06:00
|
|
|
impl AutoImportAssets {
|
2020-02-12 06:41:34 -06:00
|
|
|
fn new(ctx: &AssistCtx) -> Option<Self> {
|
2020-05-02 14:24:55 -05:00
|
|
|
if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
|
2020-02-12 06:41:34 -06:00
|
|
|
Self::for_regular_path(path_under_caret, &ctx)
|
|
|
|
} else {
|
2020-05-02 14:24:55 -05:00
|
|
|
Self::for_method_call(ctx.find_node_at_offset_with_descend()?, &ctx)
|
2020-02-12 06:41:34 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-11 10:24:43 -06:00
|
|
|
fn for_method_call(method_call: ast::MethodCallExpr, ctx: &AssistCtx) -> Option<Self> {
|
|
|
|
let syntax_under_caret = method_call.syntax().to_owned();
|
2020-02-18 11:35:10 -06:00
|
|
|
let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?;
|
2020-02-11 10:24:43 -06:00
|
|
|
Some(Self {
|
2020-02-18 11:35:10 -06:00
|
|
|
import_candidate: ImportCandidate::for_method_call(&ctx.sema, &method_call)?,
|
2020-02-11 10:24:43 -06:00
|
|
|
module_with_name_to_import,
|
|
|
|
syntax_under_caret,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
fn for_regular_path(path_under_caret: ast::Path, ctx: &AssistCtx) -> Option<Self> {
|
|
|
|
let syntax_under_caret = path_under_caret.syntax().to_owned();
|
|
|
|
if syntax_under_caret.ancestors().find_map(ast::UseItem::cast).is_some() {
|
2020-02-10 08:55:20 -06:00
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
2020-02-18 11:35:10 -06:00
|
|
|
let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?;
|
2020-02-11 10:24:43 -06:00
|
|
|
Some(Self {
|
2020-02-18 11:35:10 -06:00
|
|
|
import_candidate: ImportCandidate::for_regular_path(&ctx.sema, &path_under_caret)?,
|
2020-02-11 10:24:43 -06:00
|
|
|
module_with_name_to_import,
|
|
|
|
syntax_under_caret,
|
|
|
|
})
|
2020-02-10 08:55:20 -06:00
|
|
|
}
|
|
|
|
|
2020-02-12 06:41:34 -06:00
|
|
|
fn get_search_query(&self) -> &str {
|
2020-02-11 10:24:43 -06:00
|
|
|
match &self.import_candidate {
|
2020-02-12 06:41:34 -06:00
|
|
|
ImportCandidate::UnqualifiedName(name) => name,
|
|
|
|
ImportCandidate::QualifierStart(qualifier_start) => qualifier_start,
|
2020-02-12 14:38:19 -06:00
|
|
|
ImportCandidate::TraitAssocItem(_, trait_assoc_item_name) => trait_assoc_item_name,
|
2020-02-12 06:41:34 -06:00
|
|
|
ImportCandidate::TraitMethod(_, trait_method_name) => trait_method_name,
|
2020-02-10 08:55:20 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-12 05:21:12 -06:00
|
|
|
fn get_import_group_message(&self) -> String {
|
|
|
|
match &self.import_candidate {
|
2020-02-12 06:41:34 -06:00
|
|
|
ImportCandidate::UnqualifiedName(name) => format!("Import {}", name),
|
|
|
|
ImportCandidate::QualifierStart(qualifier_start) => {
|
|
|
|
format!("Import {}", qualifier_start)
|
2020-02-12 05:21:12 -06:00
|
|
|
}
|
2020-02-12 14:38:19 -06:00
|
|
|
ImportCandidate::TraitAssocItem(_, trait_assoc_item_name) => {
|
|
|
|
format!("Import a trait for item {}", trait_assoc_item_name)
|
2020-02-12 06:41:34 -06:00
|
|
|
}
|
|
|
|
ImportCandidate::TraitMethod(_, trait_method_name) => {
|
|
|
|
format!("Import a trait for method {}", trait_method_name)
|
2020-02-12 05:21:12 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-12 06:41:34 -06:00
|
|
|
fn search_for_imports(&self, db: &RootDatabase) -> BTreeSet<ModPath> {
|
2020-02-12 05:16:05 -06:00
|
|
|
let _p = profile("auto_import::search_for_imports");
|
2020-02-12 06:41:34 -06:00
|
|
|
let current_crate = self.module_with_name_to_import.krate();
|
2020-02-10 08:55:20 -06:00
|
|
|
ImportsLocator::new(db)
|
|
|
|
.find_imports(&self.get_search_query())
|
|
|
|
.into_iter()
|
2020-03-23 06:34:56 -05:00
|
|
|
.filter_map(|candidate| match &self.import_candidate {
|
2020-02-12 14:38:19 -06:00
|
|
|
ImportCandidate::TraitAssocItem(assoc_item_type, _) => {
|
2020-03-23 06:34:56 -05:00
|
|
|
let located_assoc_item = match candidate {
|
|
|
|
Either::Left(ModuleDef::Function(located_function)) => located_function
|
|
|
|
.as_assoc_item(db)
|
|
|
|
.map(|assoc| assoc.container(db))
|
|
|
|
.and_then(Self::assoc_to_trait),
|
|
|
|
Either::Left(ModuleDef::Const(located_const)) => located_const
|
2020-02-12 15:27:19 -06:00
|
|
|
.as_assoc_item(db)
|
|
|
|
.map(|assoc| assoc.container(db))
|
|
|
|
.and_then(Self::assoc_to_trait),
|
2020-02-12 14:38:19 -06:00
|
|
|
_ => None,
|
2020-02-12 15:27:19 -06:00
|
|
|
}?;
|
2020-02-12 14:38:19 -06:00
|
|
|
|
2020-02-12 15:27:19 -06:00
|
|
|
let mut trait_candidates = FxHashSet::default();
|
|
|
|
trait_candidates.insert(located_assoc_item.into());
|
|
|
|
|
|
|
|
assoc_item_type
|
|
|
|
.iterate_path_candidates(
|
|
|
|
db,
|
|
|
|
current_crate,
|
|
|
|
&trait_candidates,
|
|
|
|
None,
|
|
|
|
|_, assoc| Self::assoc_to_trait(assoc.container(db)),
|
|
|
|
)
|
2020-03-23 06:34:56 -05:00
|
|
|
.map(ModuleDef::from)
|
|
|
|
.map(Either::Left)
|
2020-02-10 08:55:20 -06:00
|
|
|
}
|
2020-02-11 10:24:43 -06:00
|
|
|
ImportCandidate::TraitMethod(function_callee, _) => {
|
2020-02-12 15:27:19 -06:00
|
|
|
let located_assoc_item =
|
2020-03-23 06:34:56 -05:00
|
|
|
if let Either::Left(ModuleDef::Function(located_function)) = candidate {
|
2020-02-12 15:27:19 -06:00
|
|
|
located_function
|
|
|
|
.as_assoc_item(db)
|
|
|
|
.map(|assoc| assoc.container(db))
|
|
|
|
.and_then(Self::assoc_to_trait)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}?;
|
|
|
|
|
|
|
|
let mut trait_candidates = FxHashSet::default();
|
|
|
|
trait_candidates.insert(located_assoc_item.into());
|
|
|
|
|
|
|
|
function_callee
|
|
|
|
.iterate_method_candidates(
|
2020-02-12 14:38:19 -06:00
|
|
|
db,
|
|
|
|
current_crate,
|
2020-02-12 15:27:19 -06:00
|
|
|
&trait_candidates,
|
|
|
|
None,
|
|
|
|
|_, function| {
|
|
|
|
Self::assoc_to_trait(function.as_assoc_item(db)?.container(db))
|
|
|
|
},
|
2020-02-12 14:38:19 -06:00
|
|
|
)
|
2020-03-23 06:34:56 -05:00
|
|
|
.map(ModuleDef::from)
|
|
|
|
.map(Either::Left)
|
|
|
|
}
|
|
|
|
_ => Some(candidate),
|
|
|
|
})
|
|
|
|
.filter_map(|candidate| match candidate {
|
|
|
|
Either::Left(module_def) => {
|
|
|
|
self.module_with_name_to_import.find_use_path(db, module_def)
|
|
|
|
}
|
|
|
|
Either::Right(macro_def) => {
|
|
|
|
self.module_with_name_to_import.find_use_path(db, macro_def)
|
2020-02-11 10:24:43 -06:00
|
|
|
}
|
2020-02-10 08:55:20 -06:00
|
|
|
})
|
|
|
|
.filter(|use_path| !use_path.segments.is_empty())
|
|
|
|
.take(20)
|
|
|
|
.collect::<BTreeSet<_>>()
|
|
|
|
}
|
2020-02-11 07:21:12 -06:00
|
|
|
|
2020-02-12 15:27:19 -06:00
|
|
|
fn assoc_to_trait(assoc: AssocItemContainer) -> Option<Trait> {
|
|
|
|
if let AssocItemContainer::Trait(extracted_trait) = assoc {
|
|
|
|
Some(extracted_trait)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
2020-02-11 07:21:12 -06:00
|
|
|
}
|
2020-02-10 08:55:20 -06:00
|
|
|
}
|
|
|
|
|
2020-02-11 10:24:43 -06:00
|
|
|
#[derive(Debug)]
|
|
|
|
enum ImportCandidate {
|
2020-02-12 06:41:34 -06:00
|
|
|
/// Simple name like 'HashMap'
|
|
|
|
UnqualifiedName(String),
|
|
|
|
/// First part of the qualified name.
|
|
|
|
/// For 'std::collections::HashMap', that will be 'std'.
|
|
|
|
QualifierStart(String),
|
2020-02-12 10:52:29 -06:00
|
|
|
/// A trait associated function (with no self parameter) or associated constant.
|
2020-02-12 06:41:34 -06:00
|
|
|
/// For 'test_mod::TestEnum::test_function', `Type` is the `test_mod::TestEnum` expression type
|
2020-02-12 10:52:29 -06:00
|
|
|
/// and `String` is the `test_function`
|
|
|
|
TraitAssocItem(Type, String),
|
2020-02-12 06:41:34 -06:00
|
|
|
/// A trait method with self parameter.
|
|
|
|
/// For 'test_enum.test_method()', `Type` is the `test_enum` expression type
|
|
|
|
/// and `String` is the `test_method`
|
|
|
|
TraitMethod(Type, String),
|
2020-02-11 10:24:43 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl ImportCandidate {
|
|
|
|
fn for_method_call(
|
2020-02-18 11:35:10 -06:00
|
|
|
sema: &Semantics<RootDatabase>,
|
2020-02-11 10:24:43 -06:00
|
|
|
method_call: &ast::MethodCallExpr,
|
|
|
|
) -> Option<Self> {
|
2020-02-18 11:35:10 -06:00
|
|
|
if sema.resolve_method_call(method_call).is_some() {
|
2020-02-11 10:24:43 -06:00
|
|
|
return None;
|
|
|
|
}
|
|
|
|
Some(Self::TraitMethod(
|
2020-02-18 11:35:10 -06:00
|
|
|
sema.type_of_expr(&method_call.expr()?)?,
|
2020-02-12 06:41:34 -06:00
|
|
|
method_call.name_ref()?.syntax().to_string(),
|
2020-02-11 10:24:43 -06:00
|
|
|
))
|
|
|
|
}
|
|
|
|
|
|
|
|
fn for_regular_path(
|
2020-02-18 11:35:10 -06:00
|
|
|
sema: &Semantics<RootDatabase>,
|
2020-02-11 10:24:43 -06:00
|
|
|
path_under_caret: &ast::Path,
|
|
|
|
) -> Option<Self> {
|
2020-02-18 11:35:10 -06:00
|
|
|
if sema.resolve_path(path_under_caret).is_some() {
|
2020-02-11 10:24:43 -06:00
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
let segment = path_under_caret.segment()?;
|
|
|
|
if let Some(qualifier) = path_under_caret.qualifier() {
|
|
|
|
let qualifier_start = qualifier.syntax().descendants().find_map(ast::NameRef::cast)?;
|
|
|
|
let qualifier_start_path =
|
|
|
|
qualifier_start.syntax().ancestors().find_map(ast::Path::cast)?;
|
2020-02-18 11:35:10 -06:00
|
|
|
if let Some(qualifier_start_resolution) = sema.resolve_path(&qualifier_start_path) {
|
2020-02-12 06:41:34 -06:00
|
|
|
let qualifier_resolution = if qualifier_start_path == qualifier {
|
2020-02-11 10:24:43 -06:00
|
|
|
qualifier_start_resolution
|
|
|
|
} else {
|
2020-02-18 11:35:10 -06:00
|
|
|
sema.resolve_path(&qualifier)?
|
2020-02-11 10:24:43 -06:00
|
|
|
};
|
2020-02-12 14:38:19 -06:00
|
|
|
if let PathResolution::Def(ModuleDef::Adt(assoc_item_path)) = qualifier_resolution {
|
2020-02-12 10:52:29 -06:00
|
|
|
Some(ImportCandidate::TraitAssocItem(
|
2020-02-18 11:35:10 -06:00
|
|
|
assoc_item_path.ty(sema.db),
|
2020-02-12 06:41:34 -06:00
|
|
|
segment.syntax().to_string(),
|
|
|
|
))
|
2020-02-11 10:24:43 -06:00
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
} else {
|
2020-02-12 06:41:34 -06:00
|
|
|
Some(ImportCandidate::QualifierStart(qualifier_start.syntax().to_string()))
|
2020-02-11 10:24:43 -06:00
|
|
|
}
|
|
|
|
} else {
|
2020-02-12 06:41:34 -06:00
|
|
|
Some(ImportCandidate::UnqualifiedName(
|
|
|
|
segment.syntax().descendants().find_map(ast::NameRef::cast)?.syntax().to_string(),
|
|
|
|
))
|
2020-02-11 10:24:43 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-23 18:19:09 -06:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2020-02-07 08:12:51 -06:00
|
|
|
use super::*;
|
2020-05-06 03:16:55 -05:00
|
|
|
use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
|
2020-02-07 08:12:51 -06:00
|
|
|
|
2020-01-26 16:16:18 -06:00
|
|
|
#[test]
|
|
|
|
fn applicable_when_found_an_import() {
|
2020-02-06 10:17:51 -06:00
|
|
|
check_assist(
|
2020-01-26 16:16:18 -06:00
|
|
|
auto_import,
|
|
|
|
r"
|
2020-01-29 06:57:44 -06:00
|
|
|
<|>PubStruct
|
2019-12-23 18:19:09 -06:00
|
|
|
|
2020-01-26 16:16:18 -06:00
|
|
|
pub mod PubMod {
|
|
|
|
pub struct PubStruct;
|
|
|
|
}
|
|
|
|
",
|
|
|
|
r"
|
2020-01-29 06:57:44 -06:00
|
|
|
<|>use PubMod::PubStruct;
|
2019-12-23 18:19:09 -06:00
|
|
|
|
2020-01-29 06:57:44 -06:00
|
|
|
PubStruct
|
2020-01-26 16:16:18 -06:00
|
|
|
|
|
|
|
pub mod PubMod {
|
|
|
|
pub struct PubStruct;
|
2019-12-23 18:19:09 -06:00
|
|
|
}
|
2020-01-26 16:16:18 -06:00
|
|
|
",
|
|
|
|
);
|
2019-12-23 18:19:09 -06:00
|
|
|
}
|
|
|
|
|
2020-05-02 14:24:55 -05:00
|
|
|
#[test]
|
|
|
|
fn applicable_when_found_an_import_in_macros() {
|
|
|
|
check_assist(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
macro_rules! foo {
|
|
|
|
($i:ident) => { fn foo(a: $i) {} }
|
|
|
|
}
|
|
|
|
foo!(Pub<|>Struct);
|
|
|
|
|
|
|
|
pub mod PubMod {
|
|
|
|
pub struct PubStruct;
|
|
|
|
}
|
|
|
|
",
|
|
|
|
r"
|
|
|
|
use PubMod::PubStruct;
|
|
|
|
|
|
|
|
macro_rules! foo {
|
|
|
|
($i:ident) => { fn foo(a: $i) {} }
|
|
|
|
}
|
|
|
|
foo!(Pub<|>Struct);
|
|
|
|
|
|
|
|
pub mod PubMod {
|
|
|
|
pub struct PubStruct;
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2020-02-02 02:28:16 -06:00
|
|
|
#[test]
|
|
|
|
fn auto_imports_are_merged() {
|
2020-02-06 10:17:51 -06:00
|
|
|
check_assist(
|
2020-02-02 02:28:16 -06:00
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
use PubMod::PubStruct1;
|
|
|
|
|
2020-02-02 15:24:43 -06:00
|
|
|
struct Test {
|
|
|
|
test: Pub<|>Struct2<u8>,
|
|
|
|
}
|
2020-02-02 02:28:16 -06:00
|
|
|
|
|
|
|
pub mod PubMod {
|
|
|
|
pub struct PubStruct1;
|
2020-02-02 15:24:43 -06:00
|
|
|
pub struct PubStruct2<T> {
|
|
|
|
_t: T,
|
|
|
|
}
|
2020-02-02 02:28:16 -06:00
|
|
|
}
|
|
|
|
",
|
|
|
|
r"
|
|
|
|
use PubMod::{PubStruct2, PubStruct1};
|
|
|
|
|
2020-02-02 15:24:43 -06:00
|
|
|
struct Test {
|
|
|
|
test: Pub<|>Struct2<u8>,
|
|
|
|
}
|
2020-02-02 02:28:16 -06:00
|
|
|
|
|
|
|
pub mod PubMod {
|
|
|
|
pub struct PubStruct1;
|
2020-02-02 15:24:43 -06:00
|
|
|
pub struct PubStruct2<T> {
|
|
|
|
_t: T,
|
|
|
|
}
|
2020-02-02 02:28:16 -06:00
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-12-23 18:19:09 -06:00
|
|
|
#[test]
|
2020-01-26 16:16:18 -06:00
|
|
|
fn applicable_when_found_multiple_imports() {
|
2020-02-06 10:17:51 -06:00
|
|
|
check_assist(
|
2019-12-23 18:19:09 -06:00
|
|
|
auto_import,
|
2020-01-26 16:16:18 -06:00
|
|
|
r"
|
2020-01-29 06:57:44 -06:00
|
|
|
PubSt<|>ruct
|
2020-01-26 16:16:18 -06:00
|
|
|
|
|
|
|
pub mod PubMod1 {
|
|
|
|
pub struct PubStruct;
|
|
|
|
}
|
|
|
|
pub mod PubMod2 {
|
|
|
|
pub struct PubStruct;
|
|
|
|
}
|
|
|
|
pub mod PubMod3 {
|
|
|
|
pub struct PubStruct;
|
|
|
|
}
|
|
|
|
",
|
|
|
|
r"
|
|
|
|
use PubMod1::PubStruct;
|
|
|
|
|
2020-01-29 06:57:44 -06:00
|
|
|
PubSt<|>ruct
|
2020-01-26 16:16:18 -06:00
|
|
|
|
|
|
|
pub mod PubMod1 {
|
|
|
|
pub struct PubStruct;
|
|
|
|
}
|
|
|
|
pub mod PubMod2 {
|
|
|
|
pub struct PubStruct;
|
2019-12-23 18:19:09 -06:00
|
|
|
}
|
2020-01-26 16:16:18 -06:00
|
|
|
pub mod PubMod3 {
|
|
|
|
pub struct PubStruct;
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn not_applicable_for_already_imported_types() {
|
2020-02-06 10:17:51 -06:00
|
|
|
check_assist_not_applicable(
|
2020-01-26 16:16:18 -06:00
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
use PubMod::PubStruct;
|
|
|
|
|
|
|
|
PubStruct<|>
|
2019-12-23 18:19:09 -06:00
|
|
|
|
2020-01-26 16:16:18 -06:00
|
|
|
pub mod PubMod {
|
|
|
|
pub struct PubStruct;
|
|
|
|
}
|
|
|
|
",
|
2019-12-23 18:19:09 -06:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2020-01-26 16:16:18 -06:00
|
|
|
fn not_applicable_for_types_with_private_paths() {
|
2020-02-06 10:17:51 -06:00
|
|
|
check_assist_not_applicable(
|
2019-12-23 18:19:09 -06:00
|
|
|
auto_import,
|
2020-01-26 16:16:18 -06:00
|
|
|
r"
|
|
|
|
PrivateStruct<|>
|
|
|
|
|
|
|
|
pub mod PubMod {
|
|
|
|
struct PrivateStruct;
|
2019-12-23 18:19:09 -06:00
|
|
|
}
|
2020-01-26 16:16:18 -06:00
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
2019-12-23 18:19:09 -06:00
|
|
|
|
2020-01-26 16:16:18 -06:00
|
|
|
#[test]
|
|
|
|
fn not_applicable_when_no_imports_found() {
|
2020-02-06 10:17:51 -06:00
|
|
|
check_assist_not_applicable(
|
2020-01-26 16:16:18 -06:00
|
|
|
auto_import,
|
|
|
|
"
|
|
|
|
PubStruct<|>",
|
2019-12-23 18:19:09 -06:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn not_applicable_in_import_statements() {
|
2020-02-06 10:17:51 -06:00
|
|
|
check_assist_not_applicable(
|
2019-12-23 18:19:09 -06:00
|
|
|
auto_import,
|
2020-01-26 16:16:18 -06:00
|
|
|
r"
|
|
|
|
use PubStruct<|>;
|
|
|
|
|
|
|
|
pub mod PubMod {
|
|
|
|
pub struct PubStruct;
|
|
|
|
}",
|
2019-12-23 18:19:09 -06:00
|
|
|
);
|
|
|
|
}
|
2020-02-01 14:13:02 -06:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn function_import() {
|
2020-02-06 10:17:51 -06:00
|
|
|
check_assist(
|
2020-02-01 14:13:02 -06:00
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
test_function<|>
|
|
|
|
|
|
|
|
pub mod PubMod {
|
|
|
|
pub fn test_function() {};
|
|
|
|
}
|
|
|
|
",
|
|
|
|
r"
|
|
|
|
use PubMod::test_function;
|
|
|
|
|
|
|
|
test_function<|>
|
|
|
|
|
|
|
|
pub mod PubMod {
|
|
|
|
pub fn test_function() {};
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
2020-02-09 09:13:29 -06:00
|
|
|
|
2020-03-23 16:23:26 -05:00
|
|
|
#[test]
|
|
|
|
fn macro_import() {
|
|
|
|
check_assist(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
//- /lib.rs crate:crate_with_macro
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! foo {
|
|
|
|
() => ()
|
|
|
|
}
|
|
|
|
|
|
|
|
//- /main.rs crate:main deps:crate_with_macro
|
|
|
|
fn main() {
|
|
|
|
foo<|>
|
|
|
|
}",
|
|
|
|
r"use crate_with_macro::foo;
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
foo<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2020-02-09 09:13:29 -06:00
|
|
|
#[test]
|
|
|
|
fn auto_import_target() {
|
|
|
|
check_assist_target(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
struct AssistInfo {
|
|
|
|
group_label: Option<<|>GroupLabel>,
|
|
|
|
}
|
|
|
|
|
|
|
|
mod m { pub struct GroupLabel; }
|
|
|
|
",
|
|
|
|
"GroupLabel",
|
|
|
|
)
|
|
|
|
}
|
2020-02-08 17:56:17 -06:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn not_applicable_when_path_start_is_imported() {
|
|
|
|
check_assist_not_applicable(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
pub mod mod1 {
|
|
|
|
pub mod mod2 {
|
|
|
|
pub mod mod3 {
|
|
|
|
pub struct TestStruct;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
use mod1::mod2;
|
|
|
|
fn main() {
|
|
|
|
mod2::mod3::TestStruct<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
2020-02-09 16:22:12 -06:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn not_applicable_for_imported_function() {
|
|
|
|
check_assist_not_applicable(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
pub mod test_mod {
|
|
|
|
pub fn test_function() {}
|
|
|
|
}
|
|
|
|
|
|
|
|
use test_mod::test_function;
|
|
|
|
fn main() {
|
|
|
|
test_function<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
2020-02-09 16:30:00 -06:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn associated_struct_function() {
|
|
|
|
check_assist(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
mod test_mod {
|
|
|
|
pub struct TestStruct {}
|
|
|
|
impl TestStruct {
|
|
|
|
pub fn test_function() {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
TestStruct::test_function<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
r"
|
|
|
|
use test_mod::TestStruct;
|
|
|
|
|
|
|
|
mod test_mod {
|
|
|
|
pub struct TestStruct {}
|
|
|
|
impl TestStruct {
|
|
|
|
pub fn test_function() {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
TestStruct::test_function<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2020-02-12 14:38:19 -06:00
|
|
|
#[test]
|
|
|
|
fn associated_struct_const() {
|
|
|
|
check_assist(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
mod test_mod {
|
|
|
|
pub struct TestStruct {}
|
|
|
|
impl TestStruct {
|
|
|
|
const TEST_CONST: u8 = 42;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
TestStruct::TEST_CONST<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
r"
|
|
|
|
use test_mod::TestStruct;
|
|
|
|
|
|
|
|
mod test_mod {
|
|
|
|
pub struct TestStruct {}
|
|
|
|
impl TestStruct {
|
|
|
|
const TEST_CONST: u8 = 42;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
TestStruct::TEST_CONST<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2020-02-09 16:30:00 -06:00
|
|
|
#[test]
|
|
|
|
fn associated_trait_function() {
|
|
|
|
check_assist(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
mod test_mod {
|
|
|
|
pub trait TestTrait {
|
|
|
|
fn test_function();
|
|
|
|
}
|
|
|
|
pub struct TestStruct {}
|
|
|
|
impl TestTrait for TestStruct {
|
|
|
|
fn test_function() {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
test_mod::TestStruct::test_function<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
r"
|
|
|
|
use test_mod::TestTrait;
|
|
|
|
|
|
|
|
mod test_mod {
|
|
|
|
pub trait TestTrait {
|
|
|
|
fn test_function();
|
|
|
|
}
|
|
|
|
pub struct TestStruct {}
|
|
|
|
impl TestTrait for TestStruct {
|
|
|
|
fn test_function() {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
test_mod::TestStruct::test_function<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2020-02-11 10:24:43 -06:00
|
|
|
fn not_applicable_for_imported_trait_for_function() {
|
2020-02-11 07:21:12 -06:00
|
|
|
check_assist_not_applicable(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
mod test_mod {
|
|
|
|
pub trait TestTrait {
|
|
|
|
fn test_function();
|
|
|
|
}
|
|
|
|
pub trait TestTrait2 {
|
|
|
|
fn test_function();
|
|
|
|
}
|
|
|
|
pub enum TestEnum {
|
|
|
|
One,
|
|
|
|
Two,
|
|
|
|
}
|
|
|
|
impl TestTrait2 for TestEnum {
|
|
|
|
fn test_function() {}
|
|
|
|
}
|
|
|
|
impl TestTrait for TestEnum {
|
|
|
|
fn test_function() {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
use test_mod::TestTrait2;
|
|
|
|
fn main() {
|
|
|
|
test_mod::TestEnum::test_function<|>;
|
|
|
|
}
|
|
|
|
",
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2020-02-12 14:38:19 -06:00
|
|
|
#[test]
|
|
|
|
fn associated_trait_const() {
|
|
|
|
check_assist(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
mod test_mod {
|
|
|
|
pub trait TestTrait {
|
|
|
|
const TEST_CONST: u8;
|
|
|
|
}
|
|
|
|
pub struct TestStruct {}
|
|
|
|
impl TestTrait for TestStruct {
|
|
|
|
const TEST_CONST: u8 = 42;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
test_mod::TestStruct::TEST_CONST<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
r"
|
|
|
|
use test_mod::TestTrait;
|
|
|
|
|
|
|
|
mod test_mod {
|
|
|
|
pub trait TestTrait {
|
|
|
|
const TEST_CONST: u8;
|
|
|
|
}
|
|
|
|
pub struct TestStruct {}
|
|
|
|
impl TestTrait for TestStruct {
|
|
|
|
const TEST_CONST: u8 = 42;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
test_mod::TestStruct::TEST_CONST<|>
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn not_applicable_for_imported_trait_for_const() {
|
|
|
|
check_assist_not_applicable(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
mod test_mod {
|
|
|
|
pub trait TestTrait {
|
|
|
|
const TEST_CONST: u8;
|
|
|
|
}
|
|
|
|
pub trait TestTrait2 {
|
|
|
|
const TEST_CONST: f64;
|
|
|
|
}
|
|
|
|
pub enum TestEnum {
|
|
|
|
One,
|
|
|
|
Two,
|
|
|
|
}
|
|
|
|
impl TestTrait2 for TestEnum {
|
|
|
|
const TEST_CONST: f64 = 42.0;
|
|
|
|
}
|
|
|
|
impl TestTrait for TestEnum {
|
|
|
|
const TEST_CONST: u8 = 42;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
use test_mod::TestTrait2;
|
|
|
|
fn main() {
|
|
|
|
test_mod::TestEnum::TEST_CONST<|>;
|
|
|
|
}
|
|
|
|
",
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2020-02-11 07:21:12 -06:00
|
|
|
#[test]
|
2020-02-09 16:30:00 -06:00
|
|
|
fn trait_method() {
|
|
|
|
check_assist(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
mod test_mod {
|
|
|
|
pub trait TestTrait {
|
|
|
|
fn test_method(&self);
|
|
|
|
}
|
|
|
|
pub struct TestStruct {}
|
|
|
|
impl TestTrait for TestStruct {
|
|
|
|
fn test_method(&self) {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
let test_struct = test_mod::TestStruct {};
|
2020-02-11 10:24:43 -06:00
|
|
|
test_struct.test_meth<|>od()
|
2020-02-09 16:30:00 -06:00
|
|
|
}
|
|
|
|
",
|
|
|
|
r"
|
|
|
|
use test_mod::TestTrait;
|
|
|
|
|
|
|
|
mod test_mod {
|
|
|
|
pub trait TestTrait {
|
|
|
|
fn test_method(&self);
|
|
|
|
}
|
|
|
|
pub struct TestStruct {}
|
|
|
|
impl TestTrait for TestStruct {
|
|
|
|
fn test_method(&self) {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
let test_struct = test_mod::TestStruct {};
|
2020-02-11 10:24:43 -06:00
|
|
|
test_struct.test_meth<|>od()
|
2020-02-09 16:30:00 -06:00
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
}
|
2020-02-11 10:24:43 -06:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn not_applicable_for_imported_trait_for_method() {
|
|
|
|
check_assist_not_applicable(
|
|
|
|
auto_import,
|
|
|
|
r"
|
|
|
|
mod test_mod {
|
|
|
|
pub trait TestTrait {
|
|
|
|
fn test_method(&self);
|
|
|
|
}
|
|
|
|
pub trait TestTrait2 {
|
|
|
|
fn test_method(&self);
|
|
|
|
}
|
|
|
|
pub enum TestEnum {
|
|
|
|
One,
|
|
|
|
Two,
|
|
|
|
}
|
|
|
|
impl TestTrait2 for TestEnum {
|
|
|
|
fn test_method(&self) {}
|
|
|
|
}
|
|
|
|
impl TestTrait for TestEnum {
|
|
|
|
fn test_method(&self) {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
use test_mod::TestTrait2;
|
|
|
|
fn main() {
|
|
|
|
let one = test_mod::TestEnum::One;
|
|
|
|
one.test<|>_method();
|
|
|
|
}
|
|
|
|
",
|
|
|
|
)
|
|
|
|
}
|
2019-12-23 18:19:09 -06:00
|
|
|
}
|