aboutsummaryrefslogtreecommitdiff
path: root/crates
diff options
context:
space:
mode:
Diffstat (limited to 'crates')
-rw-r--r--crates/assists/src/handlers/auto_import.rs259
-rw-r--r--crates/assists/src/utils.rs1
-rw-r--r--crates/assists/src/utils/import_assets.rs254
3 files changed, 273 insertions, 241 deletions
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index d3ee98e5f..0fd2f94fa 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -1,21 +1,7 @@
1use std::collections::BTreeSet;
2
3use either::Either;
4use hir::{
5 AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution, Semantics, Trait,
6 Type,
7};
8use ide_db::{imports_locator, RootDatabase};
9use insert_use::ImportScope;
10use rustc_hash::FxHashSet;
11use syntax::{
12 ast::{self, AstNode},
13 SyntaxNode,
14};
15
16use crate::{ 1use crate::{
17 utils::insert_use, utils::mod_path_to_ast, AssistContext, AssistId, AssistKind, Assists, 2 utils::import_assets::{ImportAssets, ImportCandidate},
18 GroupLabel, 3 utils::{insert_use, mod_path_to_ast, ImportScope},
4 AssistContext, AssistId, AssistKind, Assists, GroupLabel,
19}; 5};
20 6
21// Assist: auto_import 7// Assist: auto_import
@@ -38,16 +24,16 @@ use crate::{
38// # pub mod std { pub mod collections { pub struct HashMap { } } } 24// # pub mod std { pub mod collections { pub struct HashMap { } } }
39// ``` 25// ```
40pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> { 26pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
41 let auto_import_assets = AutoImportAssets::new(ctx)?; 27 let auto_import_assets = ImportAssets::new(&ctx)?;
42 let proposed_imports = auto_import_assets.search_for_imports(ctx); 28 let proposed_imports = auto_import_assets.search_for_imports(&ctx.sema, &ctx.config.insert_use);
43 if proposed_imports.is_empty() { 29 if proposed_imports.is_empty() {
44 return None; 30 return None;
45 } 31 }
46 32
47 let range = ctx.sema.original_range(&auto_import_assets.syntax_under_caret).range; 33 let range = ctx.sema.original_range(auto_import_assets.syntax_under_caret()).range;
48 let group = auto_import_assets.get_import_group_message(); 34 let group = import_group_message(auto_import_assets.import_candidate());
49 let scope = 35 let scope =
50 ImportScope::find_insert_use_container(&auto_import_assets.syntax_under_caret, ctx)?; 36 ImportScope::find_insert_use_container(auto_import_assets.syntax_under_caret(), ctx)?;
51 let syntax = scope.as_syntax_node(); 37 let syntax = scope.as_syntax_node();
52 for import in proposed_imports { 38 for import in proposed_imports {
53 acc.add_group( 39 acc.add_group(
@@ -65,227 +51,18 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
65 Some(()) 51 Some(())
66} 52}
67 53
68#[derive(Debug)] 54fn import_group_message(import_candidate: &ImportCandidate) -> GroupLabel {
69struct AutoImportAssets { 55 let name = match import_candidate {
70 import_candidate: ImportCandidate, 56 ImportCandidate::UnqualifiedName(name) => format!("Import {}", name),
71 module_with_name_to_import: Module, 57 ImportCandidate::QualifierStart(qualifier_start) => format!("Import {}", qualifier_start),
72 syntax_under_caret: SyntaxNode, 58 ImportCandidate::TraitAssocItem(_, trait_assoc_item_name) => {
73} 59 format!("Import a trait for item {}", trait_assoc_item_name)
74
75impl AutoImportAssets {
76 fn new(ctx: &AssistContext) -> Option<Self> {
77 if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
78 Self::for_regular_path(path_under_caret, &ctx)
79 } else {
80 Self::for_method_call(ctx.find_node_at_offset_with_descend()?, &ctx)
81 } 60 }
82 } 61 ImportCandidate::TraitMethod(_, trait_method_name) => {
83 62 format!("Import a trait for method {}", trait_method_name)
84 fn for_method_call(method_call: ast::MethodCallExpr, ctx: &AssistContext) -> Option<Self> {
85 let syntax_under_caret = method_call.syntax().to_owned();
86 let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?;
87 Some(Self {
88 import_candidate: ImportCandidate::for_method_call(&ctx.sema, &method_call)?,
89 module_with_name_to_import,
90 syntax_under_caret,
91 })
92 }
93
94 fn for_regular_path(path_under_caret: ast::Path, ctx: &AssistContext) -> Option<Self> {
95 let syntax_under_caret = path_under_caret.syntax().to_owned();
96 if syntax_under_caret.ancestors().find_map(ast::Use::cast).is_some() {
97 return None;
98 } 63 }
99 64 };
100 let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?; 65 GroupLabel(name)
101 Some(Self {
102 import_candidate: ImportCandidate::for_regular_path(&ctx.sema, &path_under_caret)?,
103 module_with_name_to_import,
104 syntax_under_caret,
105 })
106 }
107
108 fn get_search_query(&self) -> &str {
109 match &self.import_candidate {
110 ImportCandidate::UnqualifiedName(name) => name,
111 ImportCandidate::QualifierStart(qualifier_start) => qualifier_start,
112 ImportCandidate::TraitAssocItem(_, trait_assoc_item_name) => trait_assoc_item_name,
113 ImportCandidate::TraitMethod(_, trait_method_name) => trait_method_name,
114 }
115 }
116
117 fn get_import_group_message(&self) -> GroupLabel {
118 let name = match &self.import_candidate {
119 ImportCandidate::UnqualifiedName(name) => format!("Import {}", name),
120 ImportCandidate::QualifierStart(qualifier_start) => {
121 format!("Import {}", qualifier_start)
122 }
123 ImportCandidate::TraitAssocItem(_, trait_assoc_item_name) => {
124 format!("Import a trait for item {}", trait_assoc_item_name)
125 }
126 ImportCandidate::TraitMethod(_, trait_method_name) => {
127 format!("Import a trait for method {}", trait_method_name)
128 }
129 };
130 GroupLabel(name)
131 }
132
133 fn search_for_imports(&self, ctx: &AssistContext) -> BTreeSet<ModPath> {
134 let _p = profile::span("auto_import::search_for_imports");
135 let db = ctx.db();
136 let current_crate = self.module_with_name_to_import.krate();
137 imports_locator::find_imports(&ctx.sema, current_crate, &self.get_search_query())
138 .into_iter()
139 .filter_map(|candidate| match &self.import_candidate {
140 ImportCandidate::TraitAssocItem(assoc_item_type, _) => {
141 let located_assoc_item = match candidate {
142 Either::Left(ModuleDef::Function(located_function)) => located_function
143 .as_assoc_item(db)
144 .map(|assoc| assoc.container(db))
145 .and_then(Self::assoc_to_trait),
146 Either::Left(ModuleDef::Const(located_const)) => located_const
147 .as_assoc_item(db)
148 .map(|assoc| assoc.container(db))
149 .and_then(Self::assoc_to_trait),
150 _ => None,
151 }?;
152
153 let mut trait_candidates = FxHashSet::default();
154 trait_candidates.insert(located_assoc_item.into());
155
156 assoc_item_type
157 .iterate_path_candidates(
158 db,
159 current_crate,
160 &trait_candidates,
161 None,
162 |_, assoc| Self::assoc_to_trait(assoc.container(db)),
163 )
164 .map(ModuleDef::from)
165 .map(Either::Left)
166 }
167 ImportCandidate::TraitMethod(function_callee, _) => {
168 let located_assoc_item =
169 if let Either::Left(ModuleDef::Function(located_function)) = candidate {
170 located_function
171 .as_assoc_item(db)
172 .map(|assoc| assoc.container(db))
173 .and_then(Self::assoc_to_trait)
174 } else {
175 None
176 }?;
177
178 let mut trait_candidates = FxHashSet::default();
179 trait_candidates.insert(located_assoc_item.into());
180
181 function_callee
182 .iterate_method_candidates(
183 db,
184 current_crate,
185 &trait_candidates,
186 None,
187 |_, function| {
188 Self::assoc_to_trait(function.as_assoc_item(db)?.container(db))
189 },
190 )
191 .map(ModuleDef::from)
192 .map(Either::Left)
193 }
194 _ => Some(candidate),
195 })
196 .filter_map(|candidate| match candidate {
197 Either::Left(module_def) => self.module_with_name_to_import.find_use_path_prefixed(
198 db,
199 module_def,
200 ctx.config.insert_use.prefix_kind,
201 ),
202 Either::Right(macro_def) => self.module_with_name_to_import.find_use_path_prefixed(
203 db,
204 macro_def,
205 ctx.config.insert_use.prefix_kind,
206 ),
207 })
208 .filter(|use_path| !use_path.segments.is_empty())
209 .take(20)
210 .collect::<BTreeSet<_>>()
211 }
212
213 fn assoc_to_trait(assoc: AssocItemContainer) -> Option<Trait> {
214 if let AssocItemContainer::Trait(extracted_trait) = assoc {
215 Some(extracted_trait)
216 } else {
217 None
218 }
219 }
220}
221
222#[derive(Debug)]
223enum ImportCandidate {
224 /// Simple name like 'HashMap'
225 UnqualifiedName(String),
226 /// First part of the qualified name.
227 /// For 'std::collections::HashMap', that will be 'std'.
228 QualifierStart(String),
229 /// A trait associated function (with no self parameter) or associated constant.
230 /// For 'test_mod::TestEnum::test_function', `Type` is the `test_mod::TestEnum` expression type
231 /// and `String` is the `test_function`
232 TraitAssocItem(Type, String),
233 /// A trait method with self parameter.
234 /// For 'test_enum.test_method()', `Type` is the `test_enum` expression type
235 /// and `String` is the `test_method`
236 TraitMethod(Type, String),
237}
238
239impl ImportCandidate {
240 fn for_method_call(
241 sema: &Semantics<RootDatabase>,
242 method_call: &ast::MethodCallExpr,
243 ) -> Option<Self> {
244 if sema.resolve_method_call(method_call).is_some() {
245 return None;
246 }
247 Some(Self::TraitMethod(
248 sema.type_of_expr(&method_call.receiver()?)?,
249 method_call.name_ref()?.syntax().to_string(),
250 ))
251 }
252
253 fn for_regular_path(
254 sema: &Semantics<RootDatabase>,
255 path_under_caret: &ast::Path,
256 ) -> Option<Self> {
257 if sema.resolve_path(path_under_caret).is_some() {
258 return None;
259 }
260
261 let segment = path_under_caret.segment()?;
262 if let Some(qualifier) = path_under_caret.qualifier() {
263 let qualifier_start = qualifier.syntax().descendants().find_map(ast::NameRef::cast)?;
264 let qualifier_start_path =
265 qualifier_start.syntax().ancestors().find_map(ast::Path::cast)?;
266 if let Some(qualifier_start_resolution) = sema.resolve_path(&qualifier_start_path) {
267 let qualifier_resolution = if qualifier_start_path == qualifier {
268 qualifier_start_resolution
269 } else {
270 sema.resolve_path(&qualifier)?
271 };
272 if let PathResolution::Def(ModuleDef::Adt(assoc_item_path)) = qualifier_resolution {
273 Some(ImportCandidate::TraitAssocItem(
274 assoc_item_path.ty(sema.db),
275 segment.syntax().to_string(),
276 ))
277 } else {
278 None
279 }
280 } else {
281 Some(ImportCandidate::QualifierStart(qualifier_start.syntax().to_string()))
282 }
283 } else {
284 Some(ImportCandidate::UnqualifiedName(
285 segment.syntax().descendants().find_map(ast::NameRef::cast)?.syntax().to_string(),
286 ))
287 }
288 }
289} 66}
290 67
291#[cfg(test)] 68#[cfg(test)]
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index c1847f601..b37b0d2b6 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -1,5 +1,6 @@
1//! Assorted functions shared by several assists. 1//! Assorted functions shared by several assists.
2pub(crate) mod insert_use; 2pub(crate) mod insert_use;
3pub(crate) mod import_assets;
3 4
4use std::{iter, ops}; 5use std::{iter, ops};
5 6
diff --git a/crates/assists/src/utils/import_assets.rs b/crates/assists/src/utils/import_assets.rs
new file mode 100644
index 000000000..ce5986db7
--- /dev/null
+++ b/crates/assists/src/utils/import_assets.rs
@@ -0,0 +1,254 @@
1//! Look up accessible paths for items.
2use std::collections::BTreeSet;
3
4use either::Either;
5use hir::{AsAssocItem, AssocItemContainer, ModuleDef, Semantics};
6use ide_db::{imports_locator, RootDatabase};
7use rustc_hash::FxHashSet;
8use syntax::{ast, AstNode, SyntaxNode};
9
10use crate::assist_config::InsertUseConfig;
11
12#[derive(Debug)]
13pub(crate) struct ImportAssets {
14 import_candidate: ImportCandidate,
15 module_with_name_to_import: hir::Module,
16 syntax_under_caret: SyntaxNode,
17}
18
19impl ImportAssets {
20 pub(crate) fn new(ctx: &crate::assist_context::AssistContext) -> Option<Self> {
21 if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
22 Self::for_regular_path(path_under_caret, &ctx.sema)
23 } else {
24 Self::for_method_call(ctx.find_node_at_offset_with_descend()?, &ctx.sema)
25 }
26 }
27
28 pub(crate) fn syntax_under_caret(&self) -> &SyntaxNode {
29 &self.syntax_under_caret
30 }
31
32 pub(crate) fn import_candidate(&self) -> &ImportCandidate {
33 &self.import_candidate
34 }
35
36 fn for_method_call(
37 method_call: ast::MethodCallExpr,
38 sema: &Semantics<RootDatabase>,
39 ) -> Option<Self> {
40 let syntax_under_caret = method_call.syntax().to_owned();
41 let module_with_name_to_import = sema.scope(&syntax_under_caret).module()?;
42 Some(Self {
43 import_candidate: ImportCandidate::for_method_call(sema, &method_call)?,
44 module_with_name_to_import,
45 syntax_under_caret,
46 })
47 }
48
49 fn for_regular_path(
50 path_under_caret: ast::Path,
51 sema: &Semantics<RootDatabase>,
52 ) -> Option<Self> {
53 let syntax_under_caret = path_under_caret.syntax().to_owned();
54 if syntax_under_caret.ancestors().find_map(ast::Use::cast).is_some() {
55 return None;
56 }
57
58 let module_with_name_to_import = sema.scope(&syntax_under_caret).module()?;
59 Some(Self {
60 import_candidate: ImportCandidate::for_regular_path(sema, &path_under_caret)?,
61 module_with_name_to_import,
62 syntax_under_caret,
63 })
64 }
65
66 fn get_search_query(&self) -> &str {
67 match &self.import_candidate {
68 ImportCandidate::UnqualifiedName(name) => name,
69 ImportCandidate::QualifierStart(qualifier_start) => qualifier_start,
70 ImportCandidate::TraitAssocItem(_, trait_assoc_item_name) => trait_assoc_item_name,
71 ImportCandidate::TraitMethod(_, trait_method_name) => trait_method_name,
72 }
73 }
74
75 pub(crate) fn search_for_imports(
76 &self,
77 sema: &Semantics<RootDatabase>,
78 config: &InsertUseConfig,
79 ) -> BTreeSet<hir::ModPath> {
80 let _p = profile::span("import_assists::search_for_imports");
81 self.search_for(sema, Some(config.prefix_kind))
82 }
83
84 /// This may return non-absolute paths if a part of the returned path is already imported into scope.
85 #[allow(dead_code)]
86 pub(crate) fn search_for_relative_paths(
87 &self,
88 sema: &Semantics<RootDatabase>,
89 ) -> BTreeSet<hir::ModPath> {
90 let _p = profile::span("import_assists::search_for_relative_paths");
91 self.search_for(sema, None)
92 }
93
94 fn search_for(
95 &self,
96 sema: &Semantics<RootDatabase>,
97 prefixed: Option<hir::PrefixKind>,
98 ) -> BTreeSet<hir::ModPath> {
99 let db = sema.db;
100 let current_crate = self.module_with_name_to_import.krate();
101 imports_locator::find_imports(sema, current_crate, &self.get_search_query())
102 .into_iter()
103 .filter_map(|candidate| match &self.import_candidate {
104 ImportCandidate::TraitAssocItem(assoc_item_type, _) => {
105 let located_assoc_item = match candidate {
106 Either::Left(ModuleDef::Function(located_function)) => located_function
107 .as_assoc_item(db)
108 .map(|assoc| assoc.container(db))
109 .and_then(Self::assoc_to_trait),
110 Either::Left(ModuleDef::Const(located_const)) => located_const
111 .as_assoc_item(db)
112 .map(|assoc| assoc.container(db))
113 .and_then(Self::assoc_to_trait),
114 _ => None,
115 }?;
116
117 let mut trait_candidates = FxHashSet::default();
118 trait_candidates.insert(located_assoc_item.into());
119
120 assoc_item_type
121 .iterate_path_candidates(
122 db,
123 current_crate,
124 &trait_candidates,
125 None,
126 |_, assoc| Self::assoc_to_trait(assoc.container(db)),
127 )
128 .map(ModuleDef::from)
129 .map(Either::Left)
130 }
131 ImportCandidate::TraitMethod(function_callee, _) => {
132 let located_assoc_item =
133 if let Either::Left(ModuleDef::Function(located_function)) = candidate {
134 located_function
135 .as_assoc_item(db)
136 .map(|assoc| assoc.container(db))
137 .and_then(Self::assoc_to_trait)
138 } else {
139 None
140 }?;
141
142 let mut trait_candidates = FxHashSet::default();
143 trait_candidates.insert(located_assoc_item.into());
144
145 function_callee
146 .iterate_method_candidates(
147 db,
148 current_crate,
149 &trait_candidates,
150 None,
151 |_, function| {
152 Self::assoc_to_trait(function.as_assoc_item(db)?.container(db))
153 },
154 )
155 .map(ModuleDef::from)
156 .map(Either::Left)
157 }
158 _ => Some(candidate),
159 })
160 .filter_map(|candidate| {
161 let item: hir::ItemInNs = match candidate {
162 Either::Left(module_def) => module_def.into(),
163 Either::Right(macro_def) => macro_def.into(),
164 };
165 if let Some(prefix_kind) = prefixed {
166 self.module_with_name_to_import.find_use_path_prefixed(db, item, prefix_kind)
167 } else {
168 self.module_with_name_to_import.find_use_path(db, item)
169 }
170 })
171 .filter(|use_path| !use_path.segments.is_empty())
172 .take(20)
173 .collect::<BTreeSet<_>>()
174 }
175
176 fn assoc_to_trait(assoc: AssocItemContainer) -> Option<hir::Trait> {
177 if let AssocItemContainer::Trait(extracted_trait) = assoc {
178 Some(extracted_trait)
179 } else {
180 None
181 }
182 }
183}
184
185#[derive(Debug)]
186pub(crate) enum ImportCandidate {
187 /// Simple name like 'HashMap'
188 UnqualifiedName(String),
189 /// First part of the qualified name.
190 /// For 'std::collections::HashMap', that will be 'std'.
191 QualifierStart(String),
192 /// A trait associated function (with no self parameter) or associated constant.
193 /// For 'test_mod::TestEnum::test_function', `Type` is the `test_mod::TestEnum` expression type
194 /// and `String` is the `test_function`
195 TraitAssocItem(hir::Type, String),
196 /// A trait method with self parameter.
197 /// For 'test_enum.test_method()', `Type` is the `test_enum` expression type
198 /// and `String` is the `test_method`
199 TraitMethod(hir::Type, String),
200}
201
202impl ImportCandidate {
203 pub(crate) fn for_method_call(
204 sema: &Semantics<RootDatabase>,
205 method_call: &ast::MethodCallExpr,
206 ) -> Option<Self> {
207 if sema.resolve_method_call(method_call).is_some() {
208 return None;
209 }
210 Some(Self::TraitMethod(
211 sema.type_of_expr(&method_call.receiver()?)?,
212 method_call.name_ref()?.syntax().to_string(),
213 ))
214 }
215
216 pub(crate) fn for_regular_path(
217 sema: &Semantics<RootDatabase>,
218 path_under_caret: &ast::Path,
219 ) -> Option<Self> {
220 if sema.resolve_path(path_under_caret).is_some() {
221 return None;
222 }
223
224 let segment = path_under_caret.segment()?;
225 if let Some(qualifier) = path_under_caret.qualifier() {
226 let qualifier_start = qualifier.syntax().descendants().find_map(ast::NameRef::cast)?;
227 let qualifier_start_path =
228 qualifier_start.syntax().ancestors().find_map(ast::Path::cast)?;
229 if let Some(qualifier_start_resolution) = sema.resolve_path(&qualifier_start_path) {
230 let qualifier_resolution = if qualifier_start_path == qualifier {
231 qualifier_start_resolution
232 } else {
233 sema.resolve_path(&qualifier)?
234 };
235 if let hir::PathResolution::Def(hir::ModuleDef::Adt(assoc_item_path)) =
236 qualifier_resolution
237 {
238 Some(ImportCandidate::TraitAssocItem(
239 assoc_item_path.ty(sema.db),
240 segment.syntax().to_string(),
241 ))
242 } else {
243 None
244 }
245 } else {
246 Some(ImportCandidate::QualifierStart(qualifier_start.syntax().to_string()))
247 }
248 } else {
249 Some(ImportCandidate::UnqualifiedName(
250 segment.syntax().descendants().find_map(ast::NameRef::cast)?.syntax().to_string(),
251 ))
252 }
253 }
254}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 02:08:17 +0000