diff options
Diffstat (limited to 'crates/ra_ide/src/completion/complete_qualified_path.rs')
-rw-r--r-- | crates/ra_ide/src/completion/complete_qualified_path.rs | 1506 |
1 files changed, 432 insertions, 1074 deletions
diff --git a/crates/ra_ide/src/completion/complete_qualified_path.rs b/crates/ra_ide/src/completion/complete_qualified_path.rs index f133ce3ce..b08f5b9b4 100644 --- a/crates/ra_ide/src/completion/complete_qualified_path.rs +++ b/crates/ra_ide/src/completion/complete_qualified_path.rs | |||
@@ -17,21 +17,20 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon | |||
17 | return; | 17 | return; |
18 | } | 18 | } |
19 | 19 | ||
20 | let scope = ctx.scope(); | 20 | let context_module = ctx.scope.module(); |
21 | let context_module = scope.module(); | ||
22 | 21 | ||
23 | let res = match scope.resolve_hir_path_qualifier(&path) { | 22 | let resolution = match ctx.scope.resolve_hir_path_qualifier(&path) { |
24 | Some(res) => res, | 23 | Some(res) => res, |
25 | None => return, | 24 | None => return, |
26 | }; | 25 | }; |
27 | 26 | ||
28 | // Add associated types on type parameters and `Self`. | 27 | // Add associated types on type parameters and `Self`. |
29 | res.assoc_type_shorthand_candidates(ctx.db, |alias| { | 28 | resolution.assoc_type_shorthand_candidates(ctx.db, |alias| { |
30 | acc.add_type_alias(ctx, alias); | 29 | acc.add_type_alias(ctx, alias); |
31 | None::<()> | 30 | None::<()> |
32 | }); | 31 | }); |
33 | 32 | ||
34 | match res { | 33 | match resolution { |
35 | PathResolution::Def(hir::ModuleDef::Module(module)) => { | 34 | PathResolution::Def(hir::ModuleDef::Module(module)) => { |
36 | let module_scope = module.scope(ctx.db, context_module); | 35 | let module_scope = module.scope(ctx.db, context_module); |
37 | for (name, def) in module_scope { | 36 | for (name, def) in module_scope { |
@@ -68,7 +67,7 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon | |||
68 | 67 | ||
69 | let krate = ctx.krate; | 68 | let krate = ctx.krate; |
70 | if let Some(krate) = krate { | 69 | if let Some(krate) = krate { |
71 | let traits_in_scope = ctx.scope().traits_in_scope(); | 70 | let traits_in_scope = ctx.scope.traits_in_scope(); |
72 | ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| { | 71 | ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| { |
73 | if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) { | 72 | if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) { |
74 | return None; | 73 | return None; |
@@ -113,13 +112,13 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon | |||
113 | } | 112 | } |
114 | PathResolution::TypeParam(_) | PathResolution::SelfType(_) => { | 113 | PathResolution::TypeParam(_) | PathResolution::SelfType(_) => { |
115 | if let Some(krate) = ctx.krate { | 114 | if let Some(krate) = ctx.krate { |
116 | let ty = match res { | 115 | let ty = match resolution { |
117 | PathResolution::TypeParam(param) => param.ty(ctx.db), | 116 | PathResolution::TypeParam(param) => param.ty(ctx.db), |
118 | PathResolution::SelfType(impl_def) => impl_def.target_ty(ctx.db), | 117 | PathResolution::SelfType(impl_def) => impl_def.target_ty(ctx.db), |
119 | _ => return, | 118 | _ => return, |
120 | }; | 119 | }; |
121 | 120 | ||
122 | let traits_in_scope = ctx.scope().traits_in_scope(); | 121 | let traits_in_scope = ctx.scope.traits_in_scope(); |
123 | let mut seen = FxHashSet::default(); | 122 | let mut seen = FxHashSet::default(); |
124 | ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| { | 123 | ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| { |
125 | if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) { | 124 | if context_module.map_or(false, |m| !item.is_visible_from(ctx.db, m)) { |
@@ -147,1229 +146,588 @@ pub(super) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon | |||
147 | 146 | ||
148 | #[cfg(test)] | 147 | #[cfg(test)] |
149 | mod tests { | 148 | mod tests { |
149 | use expect::{expect, Expect}; | ||
150 | use test_utils::mark; | 150 | use test_utils::mark; |
151 | 151 | ||
152 | use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind}; | 152 | use crate::completion::{ |
153 | use insta::assert_debug_snapshot; | 153 | test_utils::{check_edit, completion_list}, |
154 | CompletionKind, | ||
155 | }; | ||
156 | |||
157 | fn check(ra_fixture: &str, expect: Expect) { | ||
158 | let actual = completion_list(ra_fixture, CompletionKind::Reference); | ||
159 | expect.assert_eq(&actual); | ||
160 | } | ||
154 | 161 | ||
155 | fn do_reference_completion(code: &str) -> Vec<CompletionItem> { | 162 | fn check_builtin(ra_fixture: &str, expect: Expect) { |
156 | do_completion(code, CompletionKind::Reference) | 163 | let actual = completion_list(ra_fixture, CompletionKind::BuiltinType); |
164 | expect.assert_eq(&actual); | ||
157 | } | 165 | } |
158 | 166 | ||
159 | #[test] | 167 | #[test] |
160 | fn dont_complete_current_use() { | 168 | fn dont_complete_current_use() { |
161 | mark::check!(dont_complete_current_use); | 169 | mark::check!(dont_complete_current_use); |
162 | let completions = do_completion(r"use self::foo<|>;", CompletionKind::Reference); | 170 | check(r#"use self::foo<|>;"#, expect![[""]]); |
163 | assert!(completions.is_empty()); | ||
164 | } | 171 | } |
165 | 172 | ||
166 | #[test] | 173 | #[test] |
167 | fn dont_complete_current_use_in_braces_with_glob() { | 174 | fn dont_complete_current_use_in_braces_with_glob() { |
168 | let completions = do_completion( | 175 | check( |
169 | r" | 176 | r#" |
170 | mod foo { pub struct S; } | 177 | mod foo { pub struct S; } |
171 | use self::{foo::*, bar<|>}; | 178 | use self::{foo::*, bar<|>}; |
172 | ", | 179 | "#, |
173 | CompletionKind::Reference, | 180 | expect![[r#" |
181 | st S | ||
182 | md foo | ||
183 | "#]], | ||
174 | ); | 184 | ); |
175 | assert_eq!(completions.len(), 2); | ||
176 | } | 185 | } |
177 | 186 | ||
178 | #[test] | 187 | #[test] |
179 | fn dont_complete_primitive_in_use() { | 188 | fn dont_complete_primitive_in_use() { |
180 | let completions = do_completion(r"use self::<|>;", CompletionKind::BuiltinType); | 189 | check_builtin(r#"use self::<|>;"#, expect![[""]]); |
181 | assert!(completions.is_empty()); | ||
182 | } | 190 | } |
183 | 191 | ||
184 | #[test] | 192 | #[test] |
185 | fn dont_complete_primitive_in_module_scope() { | 193 | fn dont_complete_primitive_in_module_scope() { |
186 | let completions = do_completion(r"fn foo() { self::<|> }", CompletionKind::BuiltinType); | 194 | check_builtin(r#"fn foo() { self::<|> }"#, expect![[""]]); |
187 | assert!(completions.is_empty()); | ||
188 | } | 195 | } |
189 | 196 | ||
190 | #[test] | 197 | #[test] |
191 | fn completes_primitives() { | 198 | fn completes_primitives() { |
192 | let completions = | 199 | check_builtin( |
193 | do_completion(r"fn main() { let _: <|> = 92; }", CompletionKind::BuiltinType); | 200 | r#"fn main() { let _: <|> = 92; }"#, |
194 | assert_eq!(completions.len(), 17); | 201 | expect![[r#" |
195 | } | 202 | bt bool |
196 | 203 | bt char | |
197 | #[test] | 204 | bt f32 |
198 | fn completes_mod_with_docs() { | 205 | bt f64 |
199 | assert_debug_snapshot!( | 206 | bt i128 |
200 | do_reference_completion( | 207 | bt i16 |
201 | r" | 208 | bt i32 |
202 | use self::my<|>; | 209 | bt i64 |
203 | 210 | bt i8 | |
204 | /// Some simple | 211 | bt isize |
205 | /// docs describing `mod my`. | 212 | bt str |
206 | mod my { | 213 | bt u128 |
207 | struct Bar; | 214 | bt u16 |
208 | } | 215 | bt u32 |
209 | " | 216 | bt u64 |
210 | ), | 217 | bt u8 |
211 | @r###" | 218 | bt usize |
212 | [ | 219 | "#]], |
213 | CompletionItem { | ||
214 | label: "my", | ||
215 | source_range: 10..12, | ||
216 | delete: 10..12, | ||
217 | insert: "my", | ||
218 | kind: Module, | ||
219 | documentation: Documentation( | ||
220 | "Some simple\ndocs describing `mod my`.", | ||
221 | ), | ||
222 | }, | ||
223 | ] | ||
224 | "### | ||
225 | ); | 220 | ); |
226 | } | 221 | } |
227 | 222 | ||
228 | #[test] | 223 | #[test] |
229 | fn completes_mod_with_same_name_as_function() { | 224 | fn completes_mod_with_same_name_as_function() { |
230 | assert_debug_snapshot!( | 225 | check( |
231 | do_reference_completion( | 226 | r#" |
232 | r" | 227 | use self::my::<|>; |
233 | use self::my::<|>; | 228 | |
234 | 229 | mod my { pub struct Bar; } | |
235 | mod my { | 230 | fn my() {} |
236 | pub struct Bar; | 231 | "#, |
237 | } | 232 | expect![[r#" |
238 | 233 | st Bar | |
239 | fn my() {} | 234 | "#]], |
240 | " | ||
241 | ), | ||
242 | @r###" | ||
243 | [ | ||
244 | CompletionItem { | ||
245 | label: "Bar", | ||
246 | source_range: 14..14, | ||
247 | delete: 14..14, | ||
248 | insert: "Bar", | ||
249 | kind: Struct, | ||
250 | }, | ||
251 | ] | ||
252 | "### | ||
253 | ); | 235 | ); |
254 | } | 236 | } |
255 | 237 | ||
256 | #[test] | 238 | #[test] |
257 | fn path_visibility() { | 239 | fn filters_visibility() { |
258 | assert_debug_snapshot!( | 240 | check( |
259 | do_reference_completion( | 241 | r#" |
260 | r" | 242 | use self::my::<|>; |
261 | use self::my::<|>; | 243 | |
262 | 244 | mod my { | |
263 | mod my { | 245 | struct Bar; |
264 | struct Bar; | 246 | pub struct Foo; |
265 | pub struct Foo; | 247 | pub use Bar as PublicBar; |
266 | pub use Bar as PublicBar; | 248 | } |
267 | } | 249 | "#, |
268 | " | 250 | expect![[r#" |
269 | ), | 251 | st Foo |
270 | @r###" | 252 | st PublicBar |
271 | [ | 253 | "#]], |
272 | CompletionItem { | ||
273 | label: "Foo", | ||
274 | source_range: 14..14, | ||
275 | delete: 14..14, | ||
276 | insert: "Foo", | ||
277 | kind: Struct, | ||
278 | }, | ||
279 | CompletionItem { | ||
280 | label: "PublicBar", | ||
281 | source_range: 14..14, | ||
282 | delete: 14..14, | ||
283 | insert: "PublicBar", | ||
284 | kind: Struct, | ||
285 | }, | ||
286 | ] | ||
287 | "### | ||
288 | ); | 254 | ); |
289 | } | 255 | } |
290 | 256 | ||
291 | #[test] | 257 | #[test] |
292 | fn completes_use_item_starting_with_self() { | 258 | fn completes_use_item_starting_with_self() { |
293 | assert_debug_snapshot!( | 259 | check( |
294 | do_reference_completion( | 260 | r#" |
295 | r" | 261 | use self::m::<|>; |
296 | use self::m::<|>; | ||
297 | 262 | ||
298 | mod m { | 263 | mod m { pub struct Bar; } |
299 | pub struct Bar; | 264 | "#, |
300 | } | 265 | expect![[r#" |
301 | " | 266 | st Bar |
302 | ), | 267 | "#]], |
303 | @r###" | ||
304 | [ | ||
305 | CompletionItem { | ||
306 | label: "Bar", | ||
307 | source_range: 13..13, | ||
308 | delete: 13..13, | ||
309 | insert: "Bar", | ||
310 | kind: Struct, | ||
311 | }, | ||
312 | ] | ||
313 | "### | ||
314 | ); | 268 | ); |
315 | } | 269 | } |
316 | 270 | ||
317 | #[test] | 271 | #[test] |
318 | fn completes_use_item_starting_with_crate() { | 272 | fn completes_use_item_starting_with_crate() { |
319 | assert_debug_snapshot!( | 273 | check( |
320 | do_reference_completion( | 274 | r#" |
321 | " | 275 | //- /lib.rs |
322 | //- /lib.rs | 276 | mod foo; |
323 | mod foo; | 277 | struct Spam; |
324 | struct Spam; | 278 | //- /foo.rs |
325 | //- /foo.rs | 279 | use crate::Sp<|> |
326 | use crate::Sp<|> | 280 | "#, |
327 | " | 281 | expect![[r#" |
328 | ), | 282 | st Spam |
329 | @r###" | 283 | md foo |
330 | [ | 284 | "#]], |
331 | CompletionItem { | ||
332 | label: "Spam", | ||
333 | source_range: 11..13, | ||
334 | delete: 11..13, | ||
335 | insert: "Spam", | ||
336 | kind: Struct, | ||
337 | }, | ||
338 | CompletionItem { | ||
339 | label: "foo", | ||
340 | source_range: 11..13, | ||
341 | delete: 11..13, | ||
342 | insert: "foo", | ||
343 | kind: Module, | ||
344 | }, | ||
345 | ] | ||
346 | "### | ||
347 | ); | 285 | ); |
348 | } | 286 | } |
349 | 287 | ||
350 | #[test] | 288 | #[test] |
351 | fn completes_nested_use_tree() { | 289 | fn completes_nested_use_tree() { |
352 | assert_debug_snapshot!( | 290 | check( |
353 | do_reference_completion( | 291 | r#" |
354 | " | 292 | //- /lib.rs |
355 | //- /lib.rs | 293 | mod foo; |
356 | mod foo; | 294 | struct Spam; |
357 | struct Spam; | 295 | //- /foo.rs |
358 | //- /foo.rs | 296 | use crate::{Sp<|>}; |
359 | use crate::{Sp<|>}; | 297 | "#, |
360 | " | 298 | expect![[r#" |
361 | ), | 299 | st Spam |
362 | @r###" | 300 | md foo |
363 | [ | 301 | "#]], |
364 | CompletionItem { | ||
365 | label: "Spam", | ||
366 | source_range: 12..14, | ||
367 | delete: 12..14, | ||
368 | insert: "Spam", | ||
369 | kind: Struct, | ||
370 | }, | ||
371 | CompletionItem { | ||
372 | label: "foo", | ||
373 | source_range: 12..14, | ||
374 | delete: 12..14, | ||
375 | insert: "foo", | ||
376 | kind: Module, | ||
377 | }, | ||
378 | ] | ||
379 | "### | ||
380 | ); | 302 | ); |
381 | } | 303 | } |
382 | 304 | ||
383 | #[test] | 305 | #[test] |
384 | fn completes_deeply_nested_use_tree() { | 306 | fn completes_deeply_nested_use_tree() { |
385 | assert_debug_snapshot!( | 307 | check( |
386 | do_reference_completion( | 308 | r#" |
387 | " | 309 | //- /lib.rs |
388 | //- /lib.rs | 310 | mod foo; |
389 | mod foo; | 311 | pub mod bar { |
390 | pub mod bar { | 312 | pub mod baz { |
391 | pub mod baz { | 313 | pub struct Spam; |
392 | pub struct Spam; | ||
393 | } | ||
394 | } | ||
395 | //- /foo.rs | ||
396 | use crate::{bar::{baz::Sp<|>}}; | ||
397 | " | ||
398 | ), | ||
399 | @r###" | ||
400 | [ | ||
401 | CompletionItem { | ||
402 | label: "Spam", | ||
403 | source_range: 23..25, | ||
404 | delete: 23..25, | ||
405 | insert: "Spam", | ||
406 | kind: Struct, | ||
407 | }, | ||
408 | ] | ||
409 | "### | ||
410 | ); | ||
411 | } | ||
412 | |||
413 | #[test] | ||
414 | fn completes_enum_variant() { | ||
415 | assert_debug_snapshot!( | ||
416 | do_reference_completion( | ||
417 | " | ||
418 | //- /lib.rs | ||
419 | /// An enum | ||
420 | enum E { | ||
421 | /// Foo Variant | ||
422 | Foo, | ||
423 | /// Bar Variant with i32 | ||
424 | Bar(i32) | ||
425 | } | ||
426 | fn foo() { let _ = E::<|> } | ||
427 | " | ||
428 | ), | ||
429 | @r###" | ||
430 | [ | ||
431 | CompletionItem { | ||
432 | label: "Bar(…)", | ||
433 | source_range: 116..116, | ||
434 | delete: 116..116, | ||
435 | insert: "Bar($0)", | ||
436 | kind: EnumVariant, | ||
437 | lookup: "Bar", | ||
438 | detail: "(i32)", | ||
439 | documentation: Documentation( | ||
440 | "Bar Variant with i32", | ||
441 | ), | ||
442 | trigger_call_info: true, | ||
443 | }, | ||
444 | CompletionItem { | ||
445 | label: "Foo", | ||
446 | source_range: 116..116, | ||
447 | delete: 116..116, | ||
448 | insert: "Foo", | ||
449 | kind: EnumVariant, | ||
450 | detail: "()", | ||
451 | documentation: Documentation( | ||
452 | "Foo Variant", | ||
453 | ), | ||
454 | }, | ||
455 | ] | ||
456 | "### | ||
457 | ); | ||
458 | } | ||
459 | |||
460 | #[test] | ||
461 | fn completes_enum_variant_with_details() { | ||
462 | assert_debug_snapshot!( | ||
463 | do_reference_completion( | ||
464 | " | ||
465 | //- /lib.rs | ||
466 | struct S { field: u32 } | ||
467 | /// An enum | ||
468 | enum E { | ||
469 | /// Foo Variant (empty) | ||
470 | Foo, | ||
471 | /// Bar Variant with i32 and u32 | ||
472 | Bar(i32, u32), | ||
473 | /// | ||
474 | S(S), | ||
475 | } | ||
476 | fn foo() { let _ = E::<|> } | ||
477 | " | ||
478 | ), | ||
479 | @r###" | ||
480 | [ | ||
481 | CompletionItem { | ||
482 | label: "Bar(…)", | ||
483 | source_range: 180..180, | ||
484 | delete: 180..180, | ||
485 | insert: "Bar($0)", | ||
486 | kind: EnumVariant, | ||
487 | lookup: "Bar", | ||
488 | detail: "(i32, u32)", | ||
489 | documentation: Documentation( | ||
490 | "Bar Variant with i32 and u32", | ||
491 | ), | ||
492 | trigger_call_info: true, | ||
493 | }, | ||
494 | CompletionItem { | ||
495 | label: "Foo", | ||
496 | source_range: 180..180, | ||
497 | delete: 180..180, | ||
498 | insert: "Foo", | ||
499 | kind: EnumVariant, | ||
500 | detail: "()", | ||
501 | documentation: Documentation( | ||
502 | "Foo Variant (empty)", | ||
503 | ), | ||
504 | }, | ||
505 | CompletionItem { | ||
506 | label: "S(…)", | ||
507 | source_range: 180..180, | ||
508 | delete: 180..180, | ||
509 | insert: "S($0)", | ||
510 | kind: EnumVariant, | ||
511 | lookup: "S", | ||
512 | detail: "(S)", | ||
513 | documentation: Documentation( | ||
514 | "", | ||
515 | ), | ||
516 | trigger_call_info: true, | ||
517 | }, | ||
518 | ] | ||
519 | "### | ||
520 | ); | ||
521 | } | 314 | } |
522 | 315 | } | |
523 | #[test] | 316 | //- /foo.rs |
524 | fn completes_struct_associated_method() { | 317 | use crate::{bar::{baz::Sp<|>}}; |
525 | assert_debug_snapshot!( | 318 | "#, |
526 | do_reference_completion( | 319 | expect![[r#" |
527 | " | 320 | st Spam |
528 | //- /lib.rs | 321 | "#]], |
529 | /// A Struct | ||
530 | struct S; | ||
531 | |||
532 | impl S { | ||
533 | /// An associated method | ||
534 | fn m() { } | ||
535 | } | ||
536 | |||
537 | fn foo() { let _ = S::<|> } | ||
538 | " | ||
539 | ), | ||
540 | @r###" | ||
541 | [ | ||
542 | CompletionItem { | ||
543 | label: "m()", | ||
544 | source_range: 102..102, | ||
545 | delete: 102..102, | ||
546 | insert: "m()$0", | ||
547 | kind: Function, | ||
548 | lookup: "m", | ||
549 | detail: "fn m()", | ||
550 | documentation: Documentation( | ||
551 | "An associated method", | ||
552 | ), | ||
553 | }, | ||
554 | ] | ||
555 | "### | ||
556 | ); | 322 | ); |
557 | } | 323 | } |
558 | 324 | ||
559 | #[test] | 325 | #[test] |
560 | fn completes_struct_associated_method_with_self() { | 326 | fn completes_enum_variant() { |
561 | assert_debug_snapshot!( | 327 | check( |
562 | do_reference_completion( | 328 | r#" |
563 | " | 329 | enum E { Foo, Bar(i32) } |
564 | //- /lib.rs | 330 | fn foo() { let _ = E::<|> } |
565 | /// A Struct | 331 | "#, |
566 | struct S; | 332 | expect![[r#" |
567 | 333 | ev Bar(…) (i32) | |
568 | impl S { | 334 | ev Foo () |
569 | /// An associated method | 335 | "#]], |
570 | fn m(&self) { } | ||
571 | } | ||
572 | |||
573 | fn foo() { let _ = S::<|> } | ||
574 | " | ||
575 | ), | ||
576 | @r###" | ||
577 | [ | ||
578 | CompletionItem { | ||
579 | label: "m()", | ||
580 | source_range: 107..107, | ||
581 | delete: 107..107, | ||
582 | insert: "m()$0", | ||
583 | kind: Method, | ||
584 | lookup: "m", | ||
585 | detail: "fn m(&self)", | ||
586 | documentation: Documentation( | ||
587 | "An associated method", | ||
588 | ), | ||
589 | }, | ||
590 | ] | ||
591 | "### | ||
592 | ); | 336 | ); |
593 | } | 337 | } |
594 | 338 | ||
595 | #[test] | 339 | #[test] |
596 | fn completes_struct_associated_const() { | 340 | fn completes_struct_associated_items() { |
597 | assert_debug_snapshot!( | 341 | check( |
598 | do_reference_completion( | 342 | r#" |
599 | " | 343 | //- /lib.rs |
600 | //- /lib.rs | 344 | struct S; |
601 | /// A Struct | 345 | |
602 | struct S; | 346 | impl S { |
603 | 347 | fn a() {} | |
604 | impl S { | 348 | fn b(&self) {} |
605 | /// An associated const | 349 | const C: i32 = 42; |
606 | const C: i32 = 42; | 350 | type T = i32; |
607 | } | 351 | } |
608 | 352 | ||
609 | fn foo() { let _ = S::<|> } | 353 | fn foo() { let _ = S::<|> } |
610 | " | 354 | "#, |
611 | ), | 355 | expect![[r#" |
612 | @r###" | 356 | ct C const C: i32 = 42; |
613 | [ | 357 | ta T type T = i32; |
614 | CompletionItem { | 358 | fn a() fn a() |
615 | label: "C", | 359 | me b() fn b(&self) |
616 | source_range: 109..109, | 360 | "#]], |
617 | delete: 109..109, | ||
618 | insert: "C", | ||
619 | kind: Const, | ||
620 | detail: "const C: i32 = 42;", | ||
621 | documentation: Documentation( | ||
622 | "An associated const", | ||
623 | ), | ||
624 | }, | ||
625 | ] | ||
626 | "### | ||
627 | ); | 361 | ); |
628 | } | 362 | } |
629 | 363 | ||
630 | #[test] | 364 | #[test] |
631 | fn completes_struct_associated_type() { | 365 | fn associated_item_visibility() { |
632 | assert_debug_snapshot!( | 366 | check( |
633 | do_reference_completion( | 367 | r#" |
634 | " | 368 | struct S; |
635 | //- /lib.rs | ||
636 | /// A Struct | ||
637 | struct S; | ||
638 | |||
639 | impl S { | ||
640 | /// An associated type | ||
641 | type T = i32; | ||
642 | } | ||
643 | 369 | ||
644 | fn foo() { let _ = S::<|> } | 370 | mod m { |
645 | " | 371 | impl super::S { |
646 | ), | 372 | pub(super) fn public_method() { } |
647 | @r###" | 373 | fn private_method() { } |
648 | [ | 374 | pub(super) type PublicType = u32; |
649 | CompletionItem { | 375 | type PrivateType = u32; |
650 | label: "T", | 376 | pub(super) const PUBLIC_CONST: u32 = 1; |
651 | source_range: 103..103, | 377 | const PRIVATE_CONST: u32 = 1; |
652 | delete: 103..103, | ||
653 | insert: "T", | ||
654 | kind: TypeAlias, | ||
655 | detail: "type T = i32;", | ||
656 | documentation: Documentation( | ||
657 | "An associated type", | ||
658 | ), | ||
659 | }, | ||
660 | ] | ||
661 | "### | ||
662 | ); | ||
663 | } | 378 | } |
379 | } | ||
664 | 380 | ||
665 | #[test] | 381 | fn foo() { let _ = S::<|> } |
666 | fn associated_item_visibility() { | 382 | "#, |
667 | assert_debug_snapshot!( | 383 | expect![[r#" |
668 | do_reference_completion( | 384 | ct PUBLIC_CONST pub(super) const PUBLIC_CONST: u32 = 1; |
669 | " | 385 | ta PublicType pub(super) type PublicType = u32; |
670 | //- /lib.rs | 386 | fn public_method() pub(super) fn public_method() |
671 | struct S; | 387 | "#]], |
672 | |||
673 | mod m { | ||
674 | impl super::S { | ||
675 | pub(super) fn public_method() { } | ||
676 | fn private_method() { } | ||
677 | pub(super) type PublicType = u32; | ||
678 | type PrivateType = u32; | ||
679 | pub(super) const PUBLIC_CONST: u32 = 1; | ||
680 | const PRIVATE_CONST: u32 = 1; | ||
681 | } | ||
682 | } | ||
683 | |||
684 | fn foo() { let _ = S::<|> } | ||
685 | " | ||
686 | ), | ||
687 | @r###" | ||
688 | [ | ||
689 | CompletionItem { | ||
690 | label: "PUBLIC_CONST", | ||
691 | source_range: 304..304, | ||
692 | delete: 304..304, | ||
693 | insert: "PUBLIC_CONST", | ||
694 | kind: Const, | ||
695 | detail: "pub(super) const PUBLIC_CONST: u32 = 1;", | ||
696 | }, | ||
697 | CompletionItem { | ||
698 | label: "PublicType", | ||
699 | source_range: 304..304, | ||
700 | delete: 304..304, | ||
701 | insert: "PublicType", | ||
702 | kind: TypeAlias, | ||
703 | detail: "pub(super) type PublicType = u32;", | ||
704 | }, | ||
705 | CompletionItem { | ||
706 | label: "public_method()", | ||
707 | source_range: 304..304, | ||
708 | delete: 304..304, | ||
709 | insert: "public_method()$0", | ||
710 | kind: Function, | ||
711 | lookup: "public_method", | ||
712 | detail: "pub(super) fn public_method()", | ||
713 | }, | ||
714 | ] | ||
715 | "### | ||
716 | ); | 388 | ); |
717 | } | 389 | } |
718 | 390 | ||
719 | #[test] | 391 | #[test] |
720 | fn completes_enum_associated_method() { | 392 | fn completes_enum_associated_method() { |
721 | assert_debug_snapshot!( | 393 | check( |
722 | do_reference_completion( | 394 | r#" |
723 | " | 395 | enum E {}; |
724 | //- /lib.rs | 396 | impl E { fn m() { } } |
725 | /// An enum | 397 | |
726 | enum S {}; | 398 | fn foo() { let _ = E::<|> } |
727 | 399 | "#, | |
728 | impl S { | 400 | expect![[r#" |
729 | /// An associated method | 401 | fn m() fn m() |
730 | fn m() { } | 402 | "#]], |
731 | } | ||
732 | |||
733 | fn foo() { let _ = S::<|> } | ||
734 | " | ||
735 | ), | ||
736 | @r###" | ||
737 | [ | ||
738 | CompletionItem { | ||
739 | label: "m()", | ||
740 | source_range: 102..102, | ||
741 | delete: 102..102, | ||
742 | insert: "m()$0", | ||
743 | kind: Function, | ||
744 | lookup: "m", | ||
745 | detail: "fn m()", | ||
746 | documentation: Documentation( | ||
747 | "An associated method", | ||
748 | ), | ||
749 | }, | ||
750 | ] | ||
751 | "### | ||
752 | ); | 403 | ); |
753 | } | 404 | } |
754 | 405 | ||
755 | #[test] | 406 | #[test] |
756 | fn completes_union_associated_method() { | 407 | fn completes_union_associated_method() { |
757 | assert_debug_snapshot!( | 408 | check( |
758 | do_reference_completion( | 409 | r#" |
759 | " | 410 | union U {}; |
760 | //- /lib.rs | 411 | impl U { fn m() { } } |
761 | /// A union | 412 | |
762 | union U {}; | 413 | fn foo() { let _ = U::<|> } |
763 | 414 | "#, | |
764 | impl U { | 415 | expect![[r#" |
765 | /// An associated method | 416 | fn m() fn m() |
766 | fn m() { } | 417 | "#]], |
767 | } | ||
768 | |||
769 | fn foo() { let _ = U::<|> } | ||
770 | " | ||
771 | ), | ||
772 | @r###" | ||
773 | [ | ||
774 | CompletionItem { | ||
775 | label: "m()", | ||
776 | source_range: 103..103, | ||
777 | delete: 103..103, | ||
778 | insert: "m()$0", | ||
779 | kind: Function, | ||
780 | lookup: "m", | ||
781 | detail: "fn m()", | ||
782 | documentation: Documentation( | ||
783 | "An associated method", | ||
784 | ), | ||
785 | }, | ||
786 | ] | ||
787 | "### | ||
788 | ); | 418 | ); |
789 | } | 419 | } |
790 | 420 | ||
791 | #[test] | 421 | #[test] |
792 | fn completes_use_paths_across_crates() { | 422 | fn completes_use_paths_across_crates() { |
793 | assert_debug_snapshot!( | 423 | check( |
794 | do_reference_completion( | 424 | r#" |
795 | " | 425 | //- /main.rs |
796 | //- /main.rs | 426 | use foo::<|>; |
797 | use foo::<|>; | 427 | |
798 | 428 | //- /foo/lib.rs | |
799 | //- /foo/lib.rs | 429 | pub mod bar { pub struct S; } |
800 | pub mod bar { | 430 | "#, |
801 | pub struct S; | 431 | expect![[r#" |
802 | } | 432 | md bar |
803 | " | 433 | "#]], |
804 | ), | ||
805 | @r###" | ||
806 | [ | ||
807 | CompletionItem { | ||
808 | label: "bar", | ||
809 | source_range: 9..9, | ||
810 | delete: 9..9, | ||
811 | insert: "bar", | ||
812 | kind: Module, | ||
813 | }, | ||
814 | ] | ||
815 | "### | ||
816 | ); | 434 | ); |
817 | } | 435 | } |
818 | 436 | ||
819 | #[test] | 437 | #[test] |
820 | fn completes_trait_associated_method_1() { | 438 | fn completes_trait_associated_method_1() { |
821 | assert_debug_snapshot!( | 439 | check( |
822 | do_reference_completion( | 440 | r#" |
823 | " | 441 | trait Trait { fn m(); } |
824 | //- /lib.rs | ||
825 | trait Trait { | ||
826 | /// A trait method | ||
827 | fn m(); | ||
828 | } | ||
829 | 442 | ||
830 | fn foo() { let _ = Trait::<|> } | 443 | fn foo() { let _ = Trait::<|> } |
831 | " | 444 | "#, |
832 | ), | 445 | expect![[r#" |
833 | @r###" | 446 | fn m() fn m() |
834 | [ | 447 | "#]], |
835 | CompletionItem { | ||
836 | label: "m()", | ||
837 | source_range: 74..74, | ||
838 | delete: 74..74, | ||
839 | insert: "m()$0", | ||
840 | kind: Function, | ||
841 | lookup: "m", | ||
842 | detail: "fn m()", | ||
843 | documentation: Documentation( | ||
844 | "A trait method", | ||
845 | ), | ||
846 | }, | ||
847 | ] | ||
848 | "### | ||
849 | ); | 448 | ); |
850 | } | 449 | } |
851 | 450 | ||
852 | #[test] | 451 | #[test] |
853 | fn completes_trait_associated_method_2() { | 452 | fn completes_trait_associated_method_2() { |
854 | assert_debug_snapshot!( | 453 | check( |
855 | do_reference_completion( | 454 | r#" |
856 | " | 455 | trait Trait { fn m(); } |
857 | //- /lib.rs | 456 | |
858 | trait Trait { | 457 | struct S; |
859 | /// A trait method | 458 | impl Trait for S {} |
860 | fn m(); | ||
861 | } | ||
862 | 459 | ||
863 | struct S; | 460 | fn foo() { let _ = S::<|> } |
864 | impl Trait for S {} | 461 | "#, |
865 | 462 | expect![[r#" | |
866 | fn foo() { let _ = S::<|> } | 463 | fn m() fn m() |
867 | " | 464 | "#]], |
868 | ), | ||
869 | @r###" | ||
870 | [ | ||
871 | CompletionItem { | ||
872 | label: "m()", | ||
873 | source_range: 101..101, | ||
874 | delete: 101..101, | ||
875 | insert: "m()$0", | ||
876 | kind: Function, | ||
877 | lookup: "m", | ||
878 | detail: "fn m()", | ||
879 | documentation: Documentation( | ||
880 | "A trait method", | ||
881 | ), | ||
882 | }, | ||
883 | ] | ||
884 | "### | ||
885 | ); | 465 | ); |
886 | } | 466 | } |
887 | 467 | ||
888 | #[test] | 468 | #[test] |
889 | fn completes_trait_associated_method_3() { | 469 | fn completes_trait_associated_method_3() { |
890 | assert_debug_snapshot!( | 470 | check( |
891 | do_reference_completion( | 471 | r#" |
892 | " | 472 | trait Trait { fn m(); } |
893 | //- /lib.rs | ||
894 | trait Trait { | ||
895 | /// A trait method | ||
896 | fn m(); | ||
897 | } | ||
898 | 473 | ||
899 | struct S; | 474 | struct S; |
900 | impl Trait for S {} | 475 | impl Trait for S {} |
901 | 476 | ||
902 | fn foo() { let _ = <S as Trait>::<|> } | 477 | fn foo() { let _ = <S as Trait>::<|> } |
903 | " | 478 | "#, |
904 | ), | 479 | expect![[r#" |
905 | @r###" | 480 | fn m() fn m() |
906 | [ | 481 | "#]], |
907 | CompletionItem { | ||
908 | label: "m()", | ||
909 | source_range: 112..112, | ||
910 | delete: 112..112, | ||
911 | insert: "m()$0", | ||
912 | kind: Function, | ||
913 | lookup: "m", | ||
914 | detail: "fn m()", | ||
915 | documentation: Documentation( | ||
916 | "A trait method", | ||
917 | ), | ||
918 | }, | ||
919 | ] | ||
920 | "### | ||
921 | ); | 482 | ); |
922 | } | 483 | } |
923 | 484 | ||
924 | #[test] | 485 | #[test] |
925 | fn completes_ty_param_assoc_ty() { | 486 | fn completes_ty_param_assoc_ty() { |
926 | assert_debug_snapshot!( | 487 | check( |
927 | do_reference_completion( | 488 | r#" |
928 | " | 489 | trait Super { |
929 | //- /lib.rs | 490 | type Ty; |
930 | trait Super { | 491 | const CONST: u8; |
931 | type Ty; | 492 | fn func() {} |
932 | const CONST: u8; | 493 | fn method(&self) {} |
933 | fn func() {} | 494 | } |
934 | fn method(&self) {} | ||
935 | } | ||
936 | 495 | ||
937 | trait Sub: Super { | 496 | trait Sub: Super { |
938 | type SubTy; | 497 | type SubTy; |
939 | const C2: (); | 498 | const C2: (); |
940 | fn subfunc() {} | 499 | fn subfunc() {} |
941 | fn submethod(&self) {} | 500 | fn submethod(&self) {} |
942 | } | 501 | } |
943 | 502 | ||
944 | fn foo<T: Sub>() { | 503 | fn foo<T: Sub>() { T::<|> } |
945 | T::<|> | 504 | "#, |
946 | } | 505 | expect![[r#" |
947 | " | 506 | ct C2 const C2: (); |
948 | ), | 507 | ct CONST const CONST: u8; |
949 | @r###" | 508 | ta SubTy type SubTy; |
950 | [ | 509 | ta Ty type Ty; |
951 | CompletionItem { | 510 | fn func() fn func() |
952 | label: "C2", | 511 | me method() fn method(&self) |
953 | source_range: 221..221, | 512 | fn subfunc() fn subfunc() |
954 | delete: 221..221, | 513 | me submethod() fn submethod(&self) |
955 | insert: "C2", | 514 | "#]], |
956 | kind: Const, | ||
957 | detail: "const C2: ();", | ||
958 | }, | ||
959 | CompletionItem { | ||
960 | label: "CONST", | ||
961 | source_range: 221..221, | ||
962 | delete: 221..221, | ||
963 | insert: "CONST", | ||
964 | kind: Const, | ||
965 | detail: "const CONST: u8;", | ||
966 | }, | ||
967 | CompletionItem { | ||
968 | label: "SubTy", | ||
969 | source_range: 221..221, | ||
970 | delete: 221..221, | ||
971 | insert: "SubTy", | ||
972 | kind: TypeAlias, | ||
973 | detail: "type SubTy;", | ||
974 | }, | ||
975 | CompletionItem { | ||
976 | label: "Ty", | ||
977 | source_range: 221..221, | ||
978 | delete: 221..221, | ||
979 | insert: "Ty", | ||
980 | kind: TypeAlias, | ||
981 | detail: "type Ty;", | ||
982 | }, | ||
983 | CompletionItem { | ||
984 | label: "func()", | ||
985 | source_range: 221..221, | ||
986 | delete: 221..221, | ||
987 | insert: "func()$0", | ||
988 | kind: Function, | ||
989 | lookup: "func", | ||
990 | detail: "fn func()", | ||
991 | }, | ||
992 | CompletionItem { | ||
993 | label: "method()", | ||
994 | source_range: 221..221, | ||
995 | delete: 221..221, | ||
996 | insert: "method()$0", | ||
997 | kind: Method, | ||
998 | lookup: "method", | ||
999 | detail: "fn method(&self)", | ||
1000 | }, | ||
1001 | CompletionItem { | ||
1002 | label: "subfunc()", | ||
1003 | source_range: 221..221, | ||
1004 | delete: 221..221, | ||
1005 | insert: "subfunc()$0", | ||
1006 | kind: Function, | ||
1007 | lookup: "subfunc", | ||
1008 | detail: "fn subfunc()", | ||
1009 | }, | ||
1010 | CompletionItem { | ||
1011 | label: "submethod()", | ||
1012 | source_range: 221..221, | ||
1013 | delete: 221..221, | ||
1014 | insert: "submethod()$0", | ||
1015 | kind: Method, | ||
1016 | lookup: "submethod", | ||
1017 | detail: "fn submethod(&self)", | ||
1018 | }, | ||
1019 | ] | ||
1020 | "### | ||
1021 | ); | 515 | ); |
1022 | } | 516 | } |
1023 | 517 | ||
1024 | #[test] | 518 | #[test] |
1025 | fn completes_self_param_assoc_ty() { | 519 | fn completes_self_param_assoc_ty() { |
1026 | assert_debug_snapshot!( | 520 | check( |
1027 | do_reference_completion( | 521 | r#" |
1028 | " | 522 | trait Super { |
1029 | //- /lib.rs | 523 | type Ty; |
1030 | trait Super { | 524 | const CONST: u8 = 0; |
1031 | type Ty; | 525 | fn func() {} |
1032 | const CONST: u8 = 0; | 526 | fn method(&self) {} |
1033 | fn func() {} | 527 | } |
1034 | fn method(&self) {} | ||
1035 | } | ||
1036 | 528 | ||
1037 | trait Sub: Super { | 529 | trait Sub: Super { |
1038 | type SubTy; | 530 | type SubTy; |
1039 | const C2: () = (); | 531 | const C2: () = (); |
1040 | fn subfunc() {} | 532 | fn subfunc() {} |
1041 | fn submethod(&self) {} | 533 | fn submethod(&self) {} |
1042 | } | 534 | } |
1043 | 535 | ||
1044 | struct Wrap<T>(T); | 536 | struct Wrap<T>(T); |
1045 | impl<T> Super for Wrap<T> {} | 537 | impl<T> Super for Wrap<T> {} |
1046 | impl<T> Sub for Wrap<T> { | 538 | impl<T> Sub for Wrap<T> { |
1047 | fn subfunc() { | 539 | fn subfunc() { |
1048 | // Should be able to assume `Self: Sub + Super` | 540 | // Should be able to assume `Self: Sub + Super` |
1049 | Self::<|> | 541 | Self::<|> |
1050 | } | 542 | } |
1051 | } | 543 | } |
1052 | " | 544 | "#, |
1053 | ), | 545 | expect![[r#" |
1054 | @r###" | 546 | ct C2 const C2: () = (); |
1055 | [ | 547 | ct CONST const CONST: u8 = 0; |
1056 | CompletionItem { | 548 | ta SubTy type SubTy; |
1057 | label: "C2", | 549 | ta Ty type Ty; |
1058 | source_range: 367..367, | 550 | fn func() fn func() |
1059 | delete: 367..367, | 551 | me method() fn method(&self) |
1060 | insert: "C2", | 552 | fn subfunc() fn subfunc() |
1061 | kind: Const, | 553 | me submethod() fn submethod(&self) |
1062 | detail: "const C2: () = ();", | 554 | "#]], |
1063 | }, | ||
1064 | CompletionItem { | ||
1065 | label: "CONST", | ||
1066 | source_range: 367..367, | ||
1067 | delete: 367..367, | ||
1068 | insert: "CONST", | ||
1069 | kind: Const, | ||
1070 | detail: "const CONST: u8 = 0;", | ||
1071 | }, | ||
1072 | CompletionItem { | ||
1073 | label: "SubTy", | ||
1074 | source_range: 367..367, | ||
1075 | delete: 367..367, | ||
1076 | insert: "SubTy", | ||
1077 | kind: TypeAlias, | ||
1078 | detail: "type SubTy;", | ||
1079 | }, | ||
1080 | CompletionItem { | ||
1081 | label: "Ty", | ||
1082 | source_range: 367..367, | ||
1083 | delete: 367..367, | ||
1084 | insert: "Ty", | ||
1085 | kind: TypeAlias, | ||
1086 | detail: "type Ty;", | ||
1087 | }, | ||
1088 | CompletionItem { | ||
1089 | label: "func()", | ||
1090 | source_range: 367..367, | ||
1091 | delete: 367..367, | ||
1092 | insert: "func()$0", | ||
1093 | kind: Function, | ||
1094 | lookup: "func", | ||
1095 | detail: "fn func()", | ||
1096 | }, | ||
1097 | CompletionItem { | ||
1098 | label: "method()", | ||
1099 | source_range: 367..367, | ||
1100 | delete: 367..367, | ||
1101 | insert: "method()$0", | ||
1102 | kind: Method, | ||
1103 | lookup: "method", | ||
1104 | detail: "fn method(&self)", | ||
1105 | }, | ||
1106 | CompletionItem { | ||
1107 | label: "subfunc()", | ||
1108 | source_range: 367..367, | ||
1109 | delete: 367..367, | ||
1110 | insert: "subfunc()$0", | ||
1111 | kind: Function, | ||
1112 | lookup: "subfunc", | ||
1113 | detail: "fn subfunc()", | ||
1114 | }, | ||
1115 | CompletionItem { | ||
1116 | label: "submethod()", | ||
1117 | source_range: 367..367, | ||
1118 | delete: 367..367, | ||
1119 | insert: "submethod()$0", | ||
1120 | kind: Method, | ||
1121 | lookup: "submethod", | ||
1122 | detail: "fn submethod(&self)", | ||
1123 | }, | ||
1124 | ] | ||
1125 | "### | ||
1126 | ); | 555 | ); |
1127 | } | 556 | } |
1128 | 557 | ||
1129 | #[test] | 558 | #[test] |
1130 | fn completes_type_alias() { | 559 | fn completes_type_alias() { |
1131 | assert_debug_snapshot!( | 560 | check( |
1132 | do_reference_completion( | 561 | r#" |
1133 | " | 562 | struct S; |
1134 | struct S; | 563 | impl S { fn foo() {} } |
1135 | impl S { fn foo() {} } | 564 | type T = S; |
1136 | type T = S; | 565 | impl T { fn bar() {} } |
1137 | impl T { fn bar() {} } | 566 | |
1138 | 567 | fn main() { T::<|>; } | |
1139 | fn main() { | 568 | "#, |
1140 | T::<|>; | 569 | expect![[r#" |
1141 | } | 570 | fn bar() fn bar() |
1142 | " | 571 | fn foo() fn foo() |
1143 | ), | 572 | "#]], |
1144 | @r###" | ||
1145 | [ | ||
1146 | CompletionItem { | ||
1147 | label: "bar()", | ||
1148 | source_range: 88..88, | ||
1149 | delete: 88..88, | ||
1150 | insert: "bar()$0", | ||
1151 | kind: Function, | ||
1152 | lookup: "bar", | ||
1153 | detail: "fn bar()", | ||
1154 | }, | ||
1155 | CompletionItem { | ||
1156 | label: "foo()", | ||
1157 | source_range: 88..88, | ||
1158 | delete: 88..88, | ||
1159 | insert: "foo()$0", | ||
1160 | kind: Function, | ||
1161 | lookup: "foo", | ||
1162 | detail: "fn foo()", | ||
1163 | }, | ||
1164 | ] | ||
1165 | "### | ||
1166 | ); | 573 | ); |
1167 | } | 574 | } |
1168 | 575 | ||
1169 | #[test] | 576 | #[test] |
1170 | fn completes_qualified_macros() { | 577 | fn completes_qualified_macros() { |
1171 | assert_debug_snapshot!( | 578 | check( |
1172 | do_reference_completion( | 579 | r#" |
1173 | " | 580 | #[macro_export] |
1174 | #[macro_export] | 581 | macro_rules! foo { () => {} } |
1175 | macro_rules! foo { | 582 | |
1176 | () => {} | 583 | fn main() { let _ = crate::<|> } |
1177 | } | 584 | "#, |
585 | expect![[r##" | ||
586 | ma foo!(…) #[macro_export] | ||
587 | macro_rules! foo | ||
588 | fn main() fn main() | ||
589 | "##]], | ||
590 | ); | ||
591 | } | ||
1178 | 592 | ||
1179 | fn main() { | 593 | #[test] |
1180 | let _ = crate::<|> | 594 | fn test_super_super_completion() { |
1181 | } | 595 | check( |
1182 | " | 596 | r#" |
1183 | ), | 597 | mod a { |
1184 | @r###" | 598 | const A: usize = 0; |
1185 | [ | 599 | mod b { |
1186 | CompletionItem { | 600 | const B: usize = 0; |
1187 | label: "foo!(…)", | 601 | mod c { use super::super::<|> } |
1188 | source_range: 82..82, | 602 | } |
1189 | delete: 82..82, | 603 | } |
1190 | insert: "foo!($0)", | 604 | "#, |
1191 | kind: Macro, | 605 | expect![[r#" |
1192 | detail: "#[macro_export]\nmacro_rules! foo", | 606 | ct A |
1193 | }, | 607 | md b |
1194 | CompletionItem { | 608 | "#]], |
1195 | label: "main()", | ||
1196 | source_range: 82..82, | ||
1197 | delete: 82..82, | ||
1198 | insert: "main()$0", | ||
1199 | kind: Function, | ||
1200 | lookup: "main", | ||
1201 | detail: "fn main()", | ||
1202 | }, | ||
1203 | ] | ||
1204 | "### | ||
1205 | ); | 609 | ); |
1206 | } | 610 | } |
1207 | 611 | ||
1208 | #[test] | 612 | #[test] |
1209 | fn completes_reexported_items_under_correct_name() { | 613 | fn completes_reexported_items_under_correct_name() { |
1210 | assert_debug_snapshot!( | 614 | check( |
1211 | do_reference_completion( | 615 | r#" |
1212 | r" | 616 | fn foo() { self::m::<|> } |
1213 | fn foo() { | ||
1214 | self::m::<|> | ||
1215 | } | ||
1216 | 617 | ||
1217 | mod m { | 618 | mod m { |
1218 | pub use super::p::wrong_fn as right_fn; | 619 | pub use super::p::wrong_fn as right_fn; |
1219 | pub use super::p::WRONG_CONST as RIGHT_CONST; | 620 | pub use super::p::WRONG_CONST as RIGHT_CONST; |
1220 | pub use super::p::WrongType as RightType; | 621 | pub use super::p::WrongType as RightType; |
1221 | } | 622 | } |
1222 | mod p { | 623 | mod p { |
1223 | fn wrong_fn() {} | 624 | fn wrong_fn() {} |
1224 | const WRONG_CONST: u32 = 1; | 625 | const WRONG_CONST: u32 = 1; |
1225 | struct WrongType {}; | 626 | struct WrongType {}; |
1226 | } | 627 | } |
1227 | " | 628 | "#, |
1228 | ), | 629 | expect![[r#" |
1229 | @r###" | 630 | ct RIGHT_CONST |
1230 | [ | 631 | st RightType |
1231 | CompletionItem { | 632 | fn right_fn() fn wrong_fn() |
1232 | label: "RIGHT_CONST", | 633 | "#]], |
1233 | source_range: 24..24, | 634 | ); |
1234 | delete: 24..24, | 635 | |
1235 | insert: "RIGHT_CONST", | 636 | check_edit( |
1236 | kind: Const, | 637 | "RightType", |
1237 | }, | 638 | r#" |
1238 | CompletionItem { | 639 | fn foo() { self::m::<|> } |
1239 | label: "RightType", | 640 | |
1240 | source_range: 24..24, | 641 | mod m { |
1241 | delete: 24..24, | 642 | pub use super::p::wrong_fn as right_fn; |
1242 | insert: "RightType", | 643 | pub use super::p::WRONG_CONST as RIGHT_CONST; |
1243 | kind: Struct, | 644 | pub use super::p::WrongType as RightType; |
1244 | }, | 645 | } |
1245 | CompletionItem { | 646 | mod p { |
1246 | label: "right_fn()", | 647 | fn wrong_fn() {} |
1247 | source_range: 24..24, | 648 | const WRONG_CONST: u32 = 1; |
1248 | delete: 24..24, | 649 | struct WrongType {}; |
1249 | insert: "right_fn()$0", | 650 | } |
1250 | kind: Function, | 651 | "#, |
1251 | lookup: "right_fn", | 652 | r#" |
1252 | detail: "fn wrong_fn()", | 653 | fn foo() { self::m::RightType } |
1253 | }, | 654 | |
1254 | ] | 655 | mod m { |
1255 | "### | 656 | pub use super::p::wrong_fn as right_fn; |
657 | pub use super::p::WRONG_CONST as RIGHT_CONST; | ||
658 | pub use super::p::WrongType as RightType; | ||
659 | } | ||
660 | mod p { | ||
661 | fn wrong_fn() {} | ||
662 | const WRONG_CONST: u32 = 1; | ||
663 | struct WrongType {}; | ||
664 | } | ||
665 | "#, | ||
1256 | ); | 666 | ); |
1257 | } | 667 | } |
1258 | 668 | ||
1259 | #[test] | 669 | #[test] |
1260 | fn completes_in_simple_macro_call() { | 670 | fn completes_in_simple_macro_call() { |
1261 | let completions = do_reference_completion( | 671 | check( |
1262 | r#" | 672 | r#" |
1263 | macro_rules! m { ($e:expr) => { $e } } | 673 | macro_rules! m { ($e:expr) => { $e } } |
1264 | fn main() { m!(self::f<|>); } | 674 | fn main() { m!(self::f<|>); } |
1265 | fn foo() {} | 675 | fn foo() {} |
1266 | "#, | 676 | "#, |
677 | expect![[r#" | ||
678 | fn foo() fn foo() | ||
679 | fn main() fn main() | ||
680 | "#]], | ||
1267 | ); | 681 | ); |
1268 | assert_debug_snapshot!(completions, @r###" | ||
1269 | [ | ||
1270 | CompletionItem { | ||
1271 | label: "foo()", | ||
1272 | source_range: 60..61, | ||
1273 | delete: 60..61, | ||
1274 | insert: "foo()$0", | ||
1275 | kind: Function, | ||
1276 | lookup: "foo", | ||
1277 | detail: "fn foo()", | ||
1278 | }, | ||
1279 | CompletionItem { | ||
1280 | label: "main()", | ||
1281 | source_range: 60..61, | ||
1282 | delete: 60..61, | ||
1283 | insert: "main()$0", | ||
1284 | kind: Function, | ||
1285 | lookup: "main", | ||
1286 | detail: "fn main()", | ||
1287 | }, | ||
1288 | ] | ||
1289 | "###); | ||
1290 | } | 682 | } |
1291 | 683 | ||
1292 | #[test] | 684 | #[test] |
1293 | fn function_mod_share_name() { | 685 | fn function_mod_share_name() { |
1294 | assert_debug_snapshot!( | 686 | check( |
1295 | do_reference_completion( | 687 | r#" |
1296 | r" | 688 | fn foo() { self::m::<|> } |
1297 | fn foo() { | ||
1298 | self::m::<|> | ||
1299 | } | ||
1300 | 689 | ||
1301 | mod m { | 690 | mod m { |
1302 | pub mod z {} | 691 | pub mod z {} |
1303 | pub fn z() {} | 692 | pub fn z() {} |
1304 | } | 693 | } |
1305 | ", | 694 | "#, |
1306 | ), | 695 | expect![[r#" |
1307 | @r###" | 696 | md z |
1308 | [ | 697 | fn z() pub fn z() |
1309 | CompletionItem { | 698 | "#]], |
1310 | label: "z", | ||
1311 | source_range: 24..24, | ||
1312 | delete: 24..24, | ||
1313 | insert: "z", | ||
1314 | kind: Module, | ||
1315 | }, | ||
1316 | CompletionItem { | ||
1317 | label: "z()", | ||
1318 | source_range: 24..24, | ||
1319 | delete: 24..24, | ||
1320 | insert: "z()$0", | ||
1321 | kind: Function, | ||
1322 | lookup: "z", | ||
1323 | detail: "pub fn z()", | ||
1324 | }, | ||
1325 | ] | ||
1326 | "### | ||
1327 | ); | 699 | ); |
1328 | } | 700 | } |
1329 | 701 | ||
1330 | #[test] | 702 | #[test] |
1331 | fn completes_hashmap_new() { | 703 | fn completes_hashmap_new() { |
1332 | assert_debug_snapshot!( | 704 | check( |
1333 | do_reference_completion( | 705 | r#" |
1334 | r" | 706 | struct RandomState; |
1335 | struct RandomState; | 707 | struct HashMap<K, V, S = RandomState> {} |
1336 | struct HashMap<K, V, S = RandomState> {} | 708 | |
1337 | 709 | impl<K, V> HashMap<K, V, RandomState> { | |
1338 | impl<K, V> HashMap<K, V, RandomState> { | 710 | pub fn new() -> HashMap<K, V, RandomState> { } |
1339 | pub fn new() -> HashMap<K, V, RandomState> { } | 711 | } |
1340 | } | 712 | fn foo() { |
1341 | fn foo() { | 713 | HashMap::<|> |
1342 | HashMap::<|> | 714 | } |
1343 | } | 715 | "#, |
1344 | " | 716 | expect![[r#" |
1345 | ), | 717 | fn new() pub fn new() -> HashMap<K, V, RandomState> |
1346 | @r###" | 718 | "#]], |
1347 | [ | ||
1348 | CompletionItem { | ||
1349 | label: "new()", | ||
1350 | source_range: 179..179, | ||
1351 | delete: 179..179, | ||
1352 | insert: "new()$0", | ||
1353 | kind: Function, | ||
1354 | lookup: "new", | ||
1355 | detail: "pub fn new() -> HashMap<K, V, RandomState>", | ||
1356 | }, | ||
1357 | ] | ||
1358 | "### | ||
1359 | ); | 719 | ); |
1360 | } | 720 | } |
1361 | 721 | ||
1362 | #[test] | 722 | #[test] |
1363 | fn dont_complete_attr() { | 723 | fn dont_complete_attr() { |
1364 | assert_debug_snapshot!( | 724 | check( |
1365 | do_reference_completion( | 725 | r#" |
1366 | r" | 726 | mod foo { pub struct Foo; } |
1367 | mod foo { pub struct Foo; } | 727 | #[foo::<|>] |
1368 | #[foo::<|>] | 728 | fn f() {} |
1369 | fn f() {} | 729 | "#, |
1370 | " | 730 | expect![[""]], |
1371 | ), | 731 | ); |
1372 | @r###"[]"### | ||
1373 | ) | ||
1374 | } | 732 | } |
1375 | } | 733 | } |