diff options
Diffstat (limited to 'crates/ra_analysis/src/completion.rs')
-rw-r--r-- | crates/ra_analysis/src/completion.rs | 689 |
1 files changed, 0 insertions, 689 deletions
diff --git a/crates/ra_analysis/src/completion.rs b/crates/ra_analysis/src/completion.rs deleted file mode 100644 index 27566a8a1..000000000 --- a/crates/ra_analysis/src/completion.rs +++ /dev/null | |||
@@ -1,689 +0,0 @@ | |||
1 | use ra_editor::find_node_at_offset; | ||
2 | use ra_syntax::{ | ||
3 | algo::visit::{visitor, visitor_ctx, Visitor, VisitorCtx}, | ||
4 | ast::{self, AstChildren, LoopBodyOwner, ModuleItemOwner}, | ||
5 | AstNode, AtomEdit, SourceFileNode, | ||
6 | SyntaxKind::*, | ||
7 | SyntaxNodeRef, | ||
8 | }; | ||
9 | use rustc_hash::{FxHashMap, FxHashSet}; | ||
10 | |||
11 | use crate::{ | ||
12 | db::{self, SyntaxDatabase}, | ||
13 | descriptors::function::FnScopes, | ||
14 | descriptors::module::{ModuleId, ModuleScope, ModuleTree, ModuleSource}, | ||
15 | descriptors::DescriptorDatabase, | ||
16 | input::FilesDatabase, | ||
17 | Cancelable, FilePosition, FileId, | ||
18 | }; | ||
19 | |||
20 | #[derive(Debug)] | ||
21 | pub struct CompletionItem { | ||
22 | /// What user sees in pop-up | ||
23 | pub label: String, | ||
24 | /// What string is used for filtering, defaults to label | ||
25 | pub lookup: Option<String>, | ||
26 | /// What is inserted, defaults to label | ||
27 | pub snippet: Option<String>, | ||
28 | } | ||
29 | |||
30 | pub(crate) fn completions( | ||
31 | db: &db::RootDatabase, | ||
32 | position: FilePosition, | ||
33 | ) -> Cancelable<Option<Vec<CompletionItem>>> { | ||
34 | let original_file = db.file_syntax(position.file_id); | ||
35 | // Insert a fake ident to get a valid parse tree | ||
36 | let file = { | ||
37 | let edit = AtomEdit::insert(position.offset, "intellijRulezz".to_string()); | ||
38 | original_file.reparse(&edit) | ||
39 | }; | ||
40 | |||
41 | let mut res = Vec::new(); | ||
42 | let mut has_completions = false; | ||
43 | // First, let's try to complete a reference to some declaration. | ||
44 | if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) { | ||
45 | has_completions = true; | ||
46 | // completion from lexical scope | ||
47 | complete_name_ref(&file, name_ref, &mut res); | ||
48 | // special case, `trait T { fn foo(i_am_a_name_ref) {} }` | ||
49 | if is_node::<ast::Param>(name_ref.syntax()) { | ||
50 | param_completions(name_ref.syntax(), &mut res); | ||
51 | } | ||
52 | // snippet completions | ||
53 | { | ||
54 | let name_range = name_ref.syntax().range(); | ||
55 | let top_node = name_ref | ||
56 | .syntax() | ||
57 | .ancestors() | ||
58 | .take_while(|it| it.range() == name_range) | ||
59 | .last() | ||
60 | .unwrap(); | ||
61 | match top_node.parent().map(|it| it.kind()) { | ||
62 | Some(SOURCE_FILE) | Some(ITEM_LIST) => complete_mod_item_snippets(&mut res), | ||
63 | _ => (), | ||
64 | } | ||
65 | } | ||
66 | complete_path(db, position.file_id, name_ref, &mut res)?; | ||
67 | } | ||
68 | |||
69 | // Otherwise, if this is a declaration, use heuristics to suggest a name. | ||
70 | if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), position.offset) { | ||
71 | if is_node::<ast::Param>(name.syntax()) { | ||
72 | has_completions = true; | ||
73 | param_completions(name.syntax(), &mut res); | ||
74 | } | ||
75 | } | ||
76 | let res = if has_completions { Some(res) } else { None }; | ||
77 | Ok(res) | ||
78 | } | ||
79 | |||
80 | fn complete_path( | ||
81 | db: &db::RootDatabase, | ||
82 | file_id: FileId, | ||
83 | name_ref: ast::NameRef, | ||
84 | acc: &mut Vec<CompletionItem>, | ||
85 | ) -> Cancelable<()> { | ||
86 | let source_root_id = db.file_source_root(file_id); | ||
87 | let module_tree = db.module_tree(source_root_id)?; | ||
88 | let module_id = match module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) { | ||
89 | None => return Ok(()), | ||
90 | Some(it) => it, | ||
91 | }; | ||
92 | let target_module_id = match find_target_module(&module_tree, module_id, name_ref) { | ||
93 | None => return Ok(()), | ||
94 | Some(it) => it, | ||
95 | }; | ||
96 | let module_scope = db.module_scope(source_root_id, target_module_id)?; | ||
97 | let completions = module_scope.entries().iter().map(|entry| CompletionItem { | ||
98 | label: entry.name().to_string(), | ||
99 | lookup: None, | ||
100 | snippet: None, | ||
101 | }); | ||
102 | acc.extend(completions); | ||
103 | Ok(()) | ||
104 | } | ||
105 | |||
106 | fn find_target_module( | ||
107 | module_tree: &ModuleTree, | ||
108 | module_id: ModuleId, | ||
109 | name_ref: ast::NameRef, | ||
110 | ) -> Option<ModuleId> { | ||
111 | let mut crate_path = crate_path(name_ref)?; | ||
112 | |||
113 | crate_path.pop(); | ||
114 | let mut target_module = module_id.root(&module_tree); | ||
115 | for name in crate_path { | ||
116 | target_module = target_module.child(module_tree, name.text().as_str())?; | ||
117 | } | ||
118 | Some(target_module) | ||
119 | } | ||
120 | |||
121 | fn crate_path(name_ref: ast::NameRef) -> Option<Vec<ast::NameRef>> { | ||
122 | let mut path = name_ref | ||
123 | .syntax() | ||
124 | .parent() | ||
125 | .and_then(ast::PathSegment::cast)? | ||
126 | .parent_path(); | ||
127 | let mut res = Vec::new(); | ||
128 | loop { | ||
129 | let segment = path.segment()?; | ||
130 | match segment.kind()? { | ||
131 | ast::PathSegmentKind::Name(name) => res.push(name), | ||
132 | ast::PathSegmentKind::CrateKw => break, | ||
133 | ast::PathSegmentKind::SelfKw | ast::PathSegmentKind::SuperKw => return None, | ||
134 | } | ||
135 | path = path.qualifier()?; | ||
136 | } | ||
137 | res.reverse(); | ||
138 | Some(res) | ||
139 | } | ||
140 | |||
141 | fn complete_module_items( | ||
142 | file: &SourceFileNode, | ||
143 | items: AstChildren<ast::ModuleItem>, | ||
144 | this_item: Option<ast::NameRef>, | ||
145 | acc: &mut Vec<CompletionItem>, | ||
146 | ) { | ||
147 | let scope = ModuleScope::new(items); // FIXME | ||
148 | acc.extend( | ||
149 | scope | ||
150 | .entries() | ||
151 | .iter() | ||
152 | .filter(|entry| { | ||
153 | let syntax = entry.ptr().resolve(file); | ||
154 | Some(syntax.borrowed()) != this_item.map(|it| it.syntax()) | ||
155 | }) | ||
156 | .map(|entry| CompletionItem { | ||
157 | label: entry.name().to_string(), | ||
158 | lookup: None, | ||
159 | snippet: None, | ||
160 | }), | ||
161 | ); | ||
162 | } | ||
163 | |||
164 | fn complete_name_ref(file: &SourceFileNode, name_ref: ast::NameRef, acc: &mut Vec<CompletionItem>) { | ||
165 | if !is_node::<ast::Path>(name_ref.syntax()) { | ||
166 | return; | ||
167 | } | ||
168 | let mut visited_fn = false; | ||
169 | for node in name_ref.syntax().ancestors() { | ||
170 | if let Some(items) = visitor() | ||
171 | .visit::<ast::SourceFile, _>(|it| Some(it.items())) | ||
172 | .visit::<ast::Module, _>(|it| Some(it.item_list()?.items())) | ||
173 | .accept(node) | ||
174 | { | ||
175 | if let Some(items) = items { | ||
176 | complete_module_items(file, items, Some(name_ref), acc); | ||
177 | } | ||
178 | break; | ||
179 | } else if !visited_fn { | ||
180 | if let Some(fn_def) = ast::FnDef::cast(node) { | ||
181 | visited_fn = true; | ||
182 | complete_expr_keywords(&file, fn_def, name_ref, acc); | ||
183 | complete_expr_snippets(acc); | ||
184 | let scopes = FnScopes::new(fn_def); | ||
185 | complete_fn(name_ref, &scopes, acc); | ||
186 | } | ||
187 | } | ||
188 | } | ||
189 | } | ||
190 | |||
191 | fn param_completions(ctx: SyntaxNodeRef, acc: &mut Vec<CompletionItem>) { | ||
192 | let mut params = FxHashMap::default(); | ||
193 | for node in ctx.ancestors() { | ||
194 | let _ = visitor_ctx(&mut params) | ||
195 | .visit::<ast::SourceFile, _>(process) | ||
196 | .visit::<ast::ItemList, _>(process) | ||
197 | .accept(node); | ||
198 | } | ||
199 | params | ||
200 | .into_iter() | ||
201 | .filter_map(|(label, (count, param))| { | ||
202 | let lookup = param.pat()?.syntax().text().to_string(); | ||
203 | if count < 2 { | ||
204 | None | ||
205 | } else { | ||
206 | Some((label, lookup)) | ||
207 | } | ||
208 | }) | ||
209 | .for_each(|(label, lookup)| { | ||
210 | acc.push(CompletionItem { | ||
211 | label, | ||
212 | lookup: Some(lookup), | ||
213 | snippet: None, | ||
214 | }) | ||
215 | }); | ||
216 | |||
217 | fn process<'a, N: ast::FnDefOwner<'a>>( | ||
218 | node: N, | ||
219 | params: &mut FxHashMap<String, (u32, ast::Param<'a>)>, | ||
220 | ) { | ||
221 | node.functions() | ||
222 | .filter_map(|it| it.param_list()) | ||
223 | .flat_map(|it| it.params()) | ||
224 | .for_each(|param| { | ||
225 | let text = param.syntax().text().to_string(); | ||
226 | params.entry(text).or_insert((0, param)).0 += 1; | ||
227 | }) | ||
228 | } | ||
229 | } | ||
230 | |||
231 | fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool { | ||
232 | match node.ancestors().filter_map(N::cast).next() { | ||
233 | None => false, | ||
234 | Some(n) => n.syntax().range() == node.range(), | ||
235 | } | ||
236 | } | ||
237 | |||
238 | fn complete_expr_keywords( | ||
239 | file: &SourceFileNode, | ||
240 | fn_def: ast::FnDef, | ||
241 | name_ref: ast::NameRef, | ||
242 | acc: &mut Vec<CompletionItem>, | ||
243 | ) { | ||
244 | acc.push(keyword("if", "if $0 {}")); | ||
245 | acc.push(keyword("match", "match $0 {}")); | ||
246 | acc.push(keyword("while", "while $0 {}")); | ||
247 | acc.push(keyword("loop", "loop {$0}")); | ||
248 | |||
249 | if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) { | ||
250 | if let Some(if_expr) = find_node_at_offset::<ast::IfExpr>(file.syntax(), off) { | ||
251 | if if_expr.syntax().range().end() < name_ref.syntax().range().start() { | ||
252 | acc.push(keyword("else", "else {$0}")); | ||
253 | acc.push(keyword("else if", "else if $0 {}")); | ||
254 | } | ||
255 | } | ||
256 | } | ||
257 | if is_in_loop_body(name_ref) { | ||
258 | acc.push(keyword("continue", "continue")); | ||
259 | acc.push(keyword("break", "break")); | ||
260 | } | ||
261 | acc.extend(complete_return(fn_def, name_ref)); | ||
262 | } | ||
263 | |||
264 | fn is_in_loop_body(name_ref: ast::NameRef) -> bool { | ||
265 | for node in name_ref.syntax().ancestors() { | ||
266 | if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR { | ||
267 | break; | ||
268 | } | ||
269 | let loop_body = visitor() | ||
270 | .visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body) | ||
271 | .visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body) | ||
272 | .visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body) | ||
273 | .accept(node); | ||
274 | if let Some(Some(body)) = loop_body { | ||
275 | if name_ref | ||
276 | .syntax() | ||
277 | .range() | ||
278 | .is_subrange(&body.syntax().range()) | ||
279 | { | ||
280 | return true; | ||
281 | } | ||
282 | } | ||
283 | } | ||
284 | false | ||
285 | } | ||
286 | |||
287 | fn complete_return(fn_def: ast::FnDef, name_ref: ast::NameRef) -> Option<CompletionItem> { | ||
288 | // let is_last_in_block = name_ref.syntax().ancestors().filter_map(ast::Expr::cast) | ||
289 | // .next() | ||
290 | // .and_then(|it| it.syntax().parent()) | ||
291 | // .and_then(ast::Block::cast) | ||
292 | // .is_some(); | ||
293 | |||
294 | // if is_last_in_block { | ||
295 | // return None; | ||
296 | // } | ||
297 | |||
298 | let is_stmt = match name_ref | ||
299 | .syntax() | ||
300 | .ancestors() | ||
301 | .filter_map(ast::ExprStmt::cast) | ||
302 | .next() | ||
303 | { | ||
304 | None => false, | ||
305 | Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(), | ||
306 | }; | ||
307 | let snip = match (is_stmt, fn_def.ret_type().is_some()) { | ||
308 | (true, true) => "return $0;", | ||
309 | (true, false) => "return;", | ||
310 | (false, true) => "return $0", | ||
311 | (false, false) => "return", | ||
312 | }; | ||
313 | Some(keyword("return", snip)) | ||
314 | } | ||
315 | |||
316 | fn keyword(kw: &str, snip: &str) -> CompletionItem { | ||
317 | CompletionItem { | ||
318 | label: kw.to_string(), | ||
319 | lookup: None, | ||
320 | snippet: Some(snip.to_string()), | ||
321 | } | ||
322 | } | ||
323 | |||
324 | fn complete_expr_snippets(acc: &mut Vec<CompletionItem>) { | ||
325 | acc.push(CompletionItem { | ||
326 | label: "pd".to_string(), | ||
327 | lookup: None, | ||
328 | snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()), | ||
329 | }); | ||
330 | acc.push(CompletionItem { | ||
331 | label: "ppd".to_string(), | ||
332 | lookup: None, | ||
333 | snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()), | ||
334 | }); | ||
335 | } | ||
336 | |||
337 | fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) { | ||
338 | acc.push(CompletionItem { | ||
339 | label: "tfn".to_string(), | ||
340 | lookup: None, | ||
341 | snippet: Some("#[test]\nfn $1() {\n $0\n}".to_string()), | ||
342 | }); | ||
343 | acc.push(CompletionItem { | ||
344 | label: "pub(crate)".to_string(), | ||
345 | lookup: None, | ||
346 | snippet: Some("pub(crate) $0".to_string()), | ||
347 | }) | ||
348 | } | ||
349 | |||
350 | fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) { | ||
351 | let mut shadowed = FxHashSet::default(); | ||
352 | acc.extend( | ||
353 | scopes | ||
354 | .scope_chain(name_ref.syntax()) | ||
355 | .flat_map(|scope| scopes.entries(scope).iter()) | ||
356 | .filter(|entry| shadowed.insert(entry.name())) | ||
357 | .map(|entry| CompletionItem { | ||
358 | label: entry.name().to_string(), | ||
359 | lookup: None, | ||
360 | snippet: None, | ||
361 | }), | ||
362 | ); | ||
363 | if scopes.self_param.is_some() { | ||
364 | acc.push(CompletionItem { | ||
365 | label: "self".to_string(), | ||
366 | lookup: None, | ||
367 | snippet: None, | ||
368 | }) | ||
369 | } | ||
370 | } | ||
371 | |||
372 | #[cfg(test)] | ||
373 | mod tests { | ||
374 | use test_utils::assert_eq_dbg; | ||
375 | |||
376 | use crate::mock_analysis::single_file_with_position; | ||
377 | |||
378 | use super::*; | ||
379 | |||
380 | fn check_scope_completion(code: &str, expected_completions: &str) { | ||
381 | let (analysis, position) = single_file_with_position(code); | ||
382 | let completions = completions(&analysis.imp.db, position) | ||
383 | .unwrap() | ||
384 | .unwrap() | ||
385 | .into_iter() | ||
386 | .filter(|c| c.snippet.is_none()) | ||
387 | .collect::<Vec<_>>(); | ||
388 | assert_eq_dbg(expected_completions, &completions); | ||
389 | } | ||
390 | |||
391 | fn check_snippet_completion(code: &str, expected_completions: &str) { | ||
392 | let (analysis, position) = single_file_with_position(code); | ||
393 | let completions = completions(&analysis.imp.db, position) | ||
394 | .unwrap() | ||
395 | .unwrap() | ||
396 | .into_iter() | ||
397 | .filter(|c| c.snippet.is_some()) | ||
398 | .collect::<Vec<_>>(); | ||
399 | assert_eq_dbg(expected_completions, &completions); | ||
400 | } | ||
401 | |||
402 | #[test] | ||
403 | fn test_completion_let_scope() { | ||
404 | check_scope_completion( | ||
405 | r" | ||
406 | fn quux(x: i32) { | ||
407 | let y = 92; | ||
408 | 1 + <|>; | ||
409 | let z = (); | ||
410 | } | ||
411 | ", | ||
412 | r#"[CompletionItem { label: "y", lookup: None, snippet: None }, | ||
413 | CompletionItem { label: "x", lookup: None, snippet: None }, | ||
414 | CompletionItem { label: "quux", lookup: None, snippet: None }]"#, | ||
415 | ); | ||
416 | } | ||
417 | |||
418 | #[test] | ||
419 | fn test_completion_if_let_scope() { | ||
420 | check_scope_completion( | ||
421 | r" | ||
422 | fn quux() { | ||
423 | if let Some(x) = foo() { | ||
424 | let y = 92; | ||
425 | }; | ||
426 | if let Some(a) = bar() { | ||
427 | let b = 62; | ||
428 | 1 + <|> | ||
429 | } | ||
430 | } | ||
431 | ", | ||
432 | r#"[CompletionItem { label: "b", lookup: None, snippet: None }, | ||
433 | CompletionItem { label: "a", lookup: None, snippet: None }, | ||
434 | CompletionItem { label: "quux", lookup: None, snippet: None }]"#, | ||
435 | ); | ||
436 | } | ||
437 | |||
438 | #[test] | ||
439 | fn test_completion_for_scope() { | ||
440 | check_scope_completion( | ||
441 | r" | ||
442 | fn quux() { | ||
443 | for x in &[1, 2, 3] { | ||
444 | <|> | ||
445 | } | ||
446 | } | ||
447 | ", | ||
448 | r#"[CompletionItem { label: "x", lookup: None, snippet: None }, | ||
449 | CompletionItem { label: "quux", lookup: None, snippet: None }]"#, | ||
450 | ); | ||
451 | } | ||
452 | |||
453 | #[test] | ||
454 | fn test_completion_mod_scope() { | ||
455 | check_scope_completion( | ||
456 | r" | ||
457 | struct Foo; | ||
458 | enum Baz {} | ||
459 | fn quux() { | ||
460 | <|> | ||
461 | } | ||
462 | ", | ||
463 | r#"[CompletionItem { label: "Foo", lookup: None, snippet: None }, | ||
464 | CompletionItem { label: "Baz", lookup: None, snippet: None }, | ||
465 | CompletionItem { label: "quux", lookup: None, snippet: None }]"#, | ||
466 | ); | ||
467 | } | ||
468 | |||
469 | #[test] | ||
470 | fn test_completion_mod_scope_no_self_use() { | ||
471 | check_scope_completion( | ||
472 | r" | ||
473 | use foo<|>; | ||
474 | ", | ||
475 | r#"[]"#, | ||
476 | ); | ||
477 | } | ||
478 | |||
479 | #[test] | ||
480 | fn test_completion_mod_scope_nested() { | ||
481 | check_scope_completion( | ||
482 | r" | ||
483 | struct Foo; | ||
484 | mod m { | ||
485 | struct Bar; | ||
486 | fn quux() { <|> } | ||
487 | } | ||
488 | ", | ||
489 | r#"[CompletionItem { label: "Bar", lookup: None, snippet: None }, | ||
490 | CompletionItem { label: "quux", lookup: None, snippet: None }]"#, | ||
491 | ); | ||
492 | } | ||
493 | |||
494 | #[test] | ||
495 | fn test_complete_type() { | ||
496 | check_scope_completion( | ||
497 | r" | ||
498 | struct Foo; | ||
499 | fn x() -> <|> | ||
500 | ", | ||
501 | r#"[CompletionItem { label: "Foo", lookup: None, snippet: None }, | ||
502 | CompletionItem { label: "x", lookup: None, snippet: None }]"#, | ||
503 | ) | ||
504 | } | ||
505 | |||
506 | #[test] | ||
507 | fn test_complete_shadowing() { | ||
508 | check_scope_completion( | ||
509 | r" | ||
510 | fn foo() -> { | ||
511 | let bar = 92; | ||
512 | { | ||
513 | let bar = 62; | ||
514 | <|> | ||
515 | } | ||
516 | } | ||
517 | ", | ||
518 | r#"[CompletionItem { label: "bar", lookup: None, snippet: None }, | ||
519 | CompletionItem { label: "foo", lookup: None, snippet: None }]"#, | ||
520 | ) | ||
521 | } | ||
522 | |||
523 | #[test] | ||
524 | fn test_complete_self() { | ||
525 | check_scope_completion( | ||
526 | r" | ||
527 | impl S { fn foo(&self) { <|> } } | ||
528 | ", | ||
529 | r#"[CompletionItem { label: "self", lookup: None, snippet: None }]"#, | ||
530 | ) | ||
531 | } | ||
532 | |||
533 | #[test] | ||
534 | fn test_completion_kewords() { | ||
535 | check_snippet_completion(r" | ||
536 | fn quux() { | ||
537 | <|> | ||
538 | } | ||
539 | ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") }, | ||
540 | CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") }, | ||
541 | CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") }, | ||
542 | CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") }, | ||
543 | CompletionItem { label: "return", lookup: None, snippet: Some("return") }, | ||
544 | CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") }, | ||
545 | CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#); | ||
546 | } | ||
547 | |||
548 | #[test] | ||
549 | fn test_completion_else() { | ||
550 | check_snippet_completion(r" | ||
551 | fn quux() { | ||
552 | if true { | ||
553 | () | ||
554 | } <|> | ||
555 | } | ||
556 | ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") }, | ||
557 | CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") }, | ||
558 | CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") }, | ||
559 | CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") }, | ||
560 | CompletionItem { label: "else", lookup: None, snippet: Some("else {$0}") }, | ||
561 | CompletionItem { label: "else if", lookup: None, snippet: Some("else if $0 {}") }, | ||
562 | CompletionItem { label: "return", lookup: None, snippet: Some("return") }, | ||
563 | CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") }, | ||
564 | CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#); | ||
565 | } | ||
566 | |||
567 | #[test] | ||
568 | fn test_completion_return_value() { | ||
569 | check_snippet_completion(r" | ||
570 | fn quux() -> i32 { | ||
571 | <|> | ||
572 | 92 | ||
573 | } | ||
574 | ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") }, | ||
575 | CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") }, | ||
576 | CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") }, | ||
577 | CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") }, | ||
578 | CompletionItem { label: "return", lookup: None, snippet: Some("return $0;") }, | ||
579 | CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") }, | ||
580 | CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#); | ||
581 | check_snippet_completion(r" | ||
582 | fn quux() { | ||
583 | <|> | ||
584 | 92 | ||
585 | } | ||
586 | ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") }, | ||
587 | CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") }, | ||
588 | CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") }, | ||
589 | CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") }, | ||
590 | CompletionItem { label: "return", lookup: None, snippet: Some("return;") }, | ||
591 | CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") }, | ||
592 | CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#); | ||
593 | } | ||
594 | |||
595 | #[test] | ||
596 | fn test_completion_return_no_stmt() { | ||
597 | check_snippet_completion(r" | ||
598 | fn quux() -> i32 { | ||
599 | match () { | ||
600 | () => <|> | ||
601 | } | ||
602 | } | ||
603 | ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") }, | ||
604 | CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") }, | ||
605 | CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") }, | ||
606 | CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") }, | ||
607 | CompletionItem { label: "return", lookup: None, snippet: Some("return $0") }, | ||
608 | CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") }, | ||
609 | CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#); | ||
610 | } | ||
611 | |||
612 | #[test] | ||
613 | fn test_continue_break_completion() { | ||
614 | check_snippet_completion(r" | ||
615 | fn quux() -> i32 { | ||
616 | loop { <|> } | ||
617 | } | ||
618 | ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") }, | ||
619 | CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") }, | ||
620 | CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") }, | ||
621 | CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") }, | ||
622 | CompletionItem { label: "continue", lookup: None, snippet: Some("continue") }, | ||
623 | CompletionItem { label: "break", lookup: None, snippet: Some("break") }, | ||
624 | CompletionItem { label: "return", lookup: None, snippet: Some("return $0") }, | ||
625 | CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") }, | ||
626 | CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#); | ||
627 | check_snippet_completion(r" | ||
628 | fn quux() -> i32 { | ||
629 | loop { || { <|> } } | ||
630 | } | ||
631 | ", r#"[CompletionItem { label: "if", lookup: None, snippet: Some("if $0 {}") }, | ||
632 | CompletionItem { label: "match", lookup: None, snippet: Some("match $0 {}") }, | ||
633 | CompletionItem { label: "while", lookup: None, snippet: Some("while $0 {}") }, | ||
634 | CompletionItem { label: "loop", lookup: None, snippet: Some("loop {$0}") }, | ||
635 | CompletionItem { label: "return", lookup: None, snippet: Some("return $0") }, | ||
636 | CompletionItem { label: "pd", lookup: None, snippet: Some("eprintln!(\"$0 = {:?}\", $0);") }, | ||
637 | CompletionItem { label: "ppd", lookup: None, snippet: Some("eprintln!(\"$0 = {:#?}\", $0);") }]"#); | ||
638 | } | ||
639 | |||
640 | #[test] | ||
641 | fn test_param_completion_last_param() { | ||
642 | check_scope_completion(r" | ||
643 | fn foo(file_id: FileId) {} | ||
644 | fn bar(file_id: FileId) {} | ||
645 | fn baz(file<|>) {} | ||
646 | ", r#"[CompletionItem { label: "file_id: FileId", lookup: Some("file_id"), snippet: None }]"#); | ||
647 | } | ||
648 | |||
649 | #[test] | ||
650 | fn test_param_completion_nth_param() { | ||
651 | check_scope_completion(r" | ||
652 | fn foo(file_id: FileId) {} | ||
653 | fn bar(file_id: FileId) {} | ||
654 | fn baz(file<|>, x: i32) {} | ||
655 | ", r#"[CompletionItem { label: "file_id: FileId", lookup: Some("file_id"), snippet: None }]"#); | ||
656 | } | ||
657 | |||
658 | #[test] | ||
659 | fn test_param_completion_trait_param() { | ||
660 | check_scope_completion(r" | ||
661 | pub(crate) trait SourceRoot { | ||
662 | pub fn contains(&self, file_id: FileId) -> bool; | ||
663 | pub fn module_map(&self) -> &ModuleMap; | ||
664 | pub fn lines(&self, file_id: FileId) -> &LineIndex; | ||
665 | pub fn syntax(&self, file<|>) | ||
666 | } | ||
667 | ", r#"[CompletionItem { label: "self", lookup: None, snippet: None }, | ||
668 | CompletionItem { label: "SourceRoot", lookup: None, snippet: None }, | ||
669 | CompletionItem { label: "file_id: FileId", lookup: Some("file_id"), snippet: None }]"#); | ||
670 | } | ||
671 | |||
672 | #[test] | ||
673 | fn test_item_snippets() { | ||
674 | // check_snippet_completion(r" | ||
675 | // <|> | ||
676 | // ", | ||
677 | // r##"[CompletionItem { label: "tfn", lookup: None, snippet: Some("#[test]\nfn $1() {\n $0\n}") }]"##, | ||
678 | // ); | ||
679 | check_snippet_completion(r" | ||
680 | #[cfg(test)] | ||
681 | mod tests { | ||
682 | <|> | ||
683 | } | ||
684 | ", | ||
685 | r##"[CompletionItem { label: "tfn", lookup: None, snippet: Some("#[test]\nfn $1() {\n $0\n}") }, | ||
686 | CompletionItem { label: "pub(crate)", lookup: None, snippet: Some("pub(crate) $0") }]"##, | ||
687 | ); | ||
688 | } | ||
689 | } | ||