crates/completion/src/completions/dot.rs

   1 //! Completes references after dot (fields and method calls).
   2
   3 use hir::{HasVisibility, Type};
   4 use rustc_hash::FxHashSet;
   5 use test_utils::mark;
   6
   7 use crate::{context::CompletionContext, Completions};
   8
   9 /// Complete dot accesses, i.e. fields or methods.
  10 pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
  11     let dot_receiver = match &ctx.dot_receiver {
  12         Some(expr) => expr,
  13         _ => return,
  14     };
  15
  16     let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
  17         Some(ty) => ty,
  18         _ => return,
  19     };
  20
  21     if ctx.is_call {
  22         mark::hit!(test_no_struct_field_completion_for_method_call);
  23     } else {
  24         complete_fields(acc, ctx, &receiver_ty);
  25     }
  26     complete_methods(acc, ctx, &receiver_ty);
  27 }
  28
  29 fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
  30     for receiver in receiver.autoderef(ctx.db) {
  31         for (field, ty) in receiver.fields(ctx.db) {
  32             if ctx.scope.module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
  33                 // Skip private field. FIXME: If the definition location of the
  34                 // field is editable, we should show the completion
  35                 continue;
  36             }
  37             acc.add_field(ctx, field, &ty);
  38         }
  39         for (i, ty) in receiver.tuple_fields(ctx.db).into_iter().enumerate() {
  40             // FIXME: Handle visibility
  41             acc.add_tuple_field(ctx, i, &ty);
  42         }
  43     }
  44 }
  45
  46 fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
  47     if let Some(krate) = ctx.krate {
  48         let mut seen_methods = FxHashSet::default();
  49         let traits_in_scope = ctx.scope.traits_in_scope();
  50         receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
  51             if func.self_param(ctx.db).is_some()
  52                 && ctx.scope.module().map_or(true, |m| func.is_visible_from(ctx.db, m))
  53                 && seen_methods.insert(func.name(ctx.db))
  54             {
  55                 acc.add_function(ctx, func, None);
  56             }
  57             None::<()>
  58         });
  59     }
  60 }
  61
  62 #[cfg(test)]
  63 mod tests {
  64     use expect_test::{expect, Expect};
  65     use test_utils::mark;
  66
  67     use crate::{test_utils::completion_list, CompletionKind};
  68
  69     fn check(ra_fixture: &str, expect: Expect) {
  70         let actual = completion_list(ra_fixture, CompletionKind::Reference);
  71         expect.assert_eq(&actual);
  72     }
  73
  74     #[test]
  75     fn test_struct_field_and_method_completion() {
  76         check(
  77             r#"
  78 struct S { foo: u32 }
  79 impl S {
  80     fn bar(&self) {}
  81 }
  82 fn foo(s: S) { s.$0 }
  83 "#,
  84             expect![[r#"
  85                 fd foo   u32
  86                 me bar() -> ()
  87             "#]],
  88         );
  89     }
  90
  91     #[test]
  92     fn test_struct_field_completion_self() {
  93         check(
  94             r#"
  95 struct S { the_field: (u32,) }
  96 impl S {
  97     fn foo(self) { self.$0 }
  98 }
  99 "#,
 100             expect![[r#"
 101                 fd the_field (u32,)
 102                 me foo()     -> ()
 103             "#]],
 104         )
 105     }
 106
 107     #[test]
 108     fn test_struct_field_completion_autoderef() {
 109         check(
 110             r#"
 111 struct A { the_field: (u32, i32) }
 112 impl A {
 113     fn foo(&self) { self.$0 }
 114 }
 115 "#,
 116             expect![[r#"
 117                 fd the_field (u32, i32)
 118                 me foo()     -> ()
 119             "#]],
 120         )
 121     }
 122
 123     #[test]
 124     fn test_no_struct_field_completion_for_method_call() {
 125         mark::check!(test_no_struct_field_completion_for_method_call);
 126         check(
 127             r#"
 128 struct A { the_field: u32 }
 129 fn foo(a: A) { a.$0() }
 130 "#,
 131             expect![[""]],
 132         );
 133     }
 134
 135     #[test]
 136     fn test_visibility_filtering() {
 137         check(
 138             r#"
 139 mod inner {
 140     pub struct A {
 141         private_field: u32,
 142         pub pub_field: u32,
 143         pub(crate) crate_field: u32,
 144         pub(crate) super_field: u32,
 145     }
 146 }
 147 fn foo(a: inner::A) { a.$0 }
 148 "#,
 149             expect![[r#"
 150                 fd pub_field   u32
 151                 fd crate_field u32
 152                 fd super_field u32
 153             "#]],
 154         );
 155
 156         check(
 157             r#"
 158 struct A {}
 159 mod m {
 160     impl super::A {
 161         fn private_method(&self) {}
 162         pub(crate) fn the_method(&self) {}
 163     }
 164 }
 165 fn foo(a: A) { a.$0 }
 166 "#,
 167             expect![[r#"
 168                 me the_method() -> ()
 169             "#]],
 170         );
 171     }
 172
 173     #[test]
 174     fn test_union_field_completion() {
 175         check(
 176             r#"
 177 union U { field: u8, other: u16 }
 178 fn foo(u: U) { u.$0 }
 179 "#,
 180             expect![[r#"
 181                 fd field u8
 182                 fd other u16
 183             "#]],
 184         );
 185     }
 186
 187     #[test]
 188     fn test_method_completion_only_fitting_impls() {
 189         check(
 190             r#"
 191 struct A<T> {}
 192 impl A<u32> {
 193     fn the_method(&self) {}
 194 }
 195 impl A<i32> {
 196     fn the_other_method(&self) {}
 197 }
 198 fn foo(a: A<u32>) { a.$0 }
 199 "#,
 200             expect![[r#"
 201                 me the_method() -> ()
 202             "#]],
 203         )
 204     }
 205
 206     #[test]
 207     fn test_trait_method_completion() {
 208         check(
 209             r#"
 210 struct A {}
 211 trait Trait { fn the_method(&self); }
 212 impl Trait for A {}
 213 fn foo(a: A) { a.$0 }
 214 "#,
 215             expect![[r#"
 216                 me the_method() -> ()
 217             "#]],
 218         );
 219     }
 220
 221     #[test]
 222     fn test_trait_method_completion_deduplicated() {
 223         check(
 224             r"
 225 struct A {}
 226 trait Trait { fn the_method(&self); }
 227 impl<T> Trait for T {}
 228 fn foo(a: &A) { a.$0 }
 229 ",
 230             expect![[r#"
 231                 me the_method() -> ()
 232             "#]],
 233         );
 234     }
 235
 236     #[test]
 237     fn completes_trait_method_from_other_module() {
 238         check(
 239             r"
 240 struct A {}
 241 mod m {
 242     pub trait Trait { fn the_method(&self); }
 243 }
 244 use m::Trait;
 245 impl Trait for A {}
 246 fn foo(a: A) { a.$0 }
 247 ",
 248             expect![[r#"
 249                 me the_method() -> ()
 250             "#]],
 251         );
 252     }
 253
 254     #[test]
 255     fn test_no_non_self_method() {
 256         check(
 257             r#"
 258 struct A {}
 259 impl A {
 260     fn the_method() {}
 261 }
 262 fn foo(a: A) {
 263    a.$0
 264 }
 265 "#,
 266             expect![[""]],
 267         );
 268     }
 269
 270     #[test]
 271     fn test_tuple_field_completion() {
 272         check(
 273             r#"
 274 fn foo() {
 275    let b = (0, 3.14);
 276    b.$0
 277 }
 278 "#,
 279             expect![[r#"
 280                 fd 0 i32
 281                 fd 1 f64
 282             "#]],
 283         )
 284     }
 285
 286     #[test]
 287     fn test_tuple_field_inference() {
 288         check(
 289             r#"
 290 pub struct S;
 291 impl S { pub fn blah(&self) {} }
 292
 293 struct T(S);
 294
 295 impl T {
 296     fn foo(&self) {
 297         // FIXME: This doesn't work without the trailing `a` as `0.` is a float
 298         self.0.a$0
 299     }
 300 }
 301 "#,
 302             expect![[r#"
 303                 me blah() -> ()
 304             "#]],
 305         );
 306     }
 307
 308     #[test]
 309     fn test_completion_works_in_consts() {
 310         check(
 311             r#"
 312 struct A { the_field: u32 }
 313 const X: u32 = {
 314     A { the_field: 92 }.$0
 315 };
 316 "#,
 317             expect![[r#"
 318                 fd the_field u32
 319             "#]],
 320         );
 321     }
 322
 323     #[test]
 324     fn works_in_simple_macro_1() {
 325         check(
 326             r#"
 327 macro_rules! m { ($e:expr) => { $e } }
 328 struct A { the_field: u32 }
 329 fn foo(a: A) {
 330     m!(a.x$0)
 331 }
 332 "#,
 333             expect![[r#"
 334                 fd the_field u32
 335             "#]],
 336         );
 337     }
 338
 339     #[test]
 340     fn works_in_simple_macro_2() {
 341         // this doesn't work yet because the macro doesn't expand without the token -- maybe it can be fixed with better recovery
 342         check(
 343             r#"
 344 macro_rules! m { ($e:expr) => { $e } }
 345 struct A { the_field: u32 }
 346 fn foo(a: A) {
 347     m!(a.$0)
 348 }
 349 "#,
 350             expect![[r#"
 351                 fd the_field u32
 352             "#]],
 353         );
 354     }
 355
 356     #[test]
 357     fn works_in_simple_macro_recursive_1() {
 358         check(
 359             r#"
 360 macro_rules! m { ($e:expr) => { $e } }
 361 struct A { the_field: u32 }
 362 fn foo(a: A) {
 363     m!(m!(m!(a.x$0)))
 364 }
 365 "#,
 366             expect![[r#"
 367                 fd the_field u32
 368             "#]],
 369         );
 370     }
 371
 372     #[test]
 373     fn macro_expansion_resilient() {
 374         check(
 375             r#"
 376 macro_rules! d {
 377     () => {};
 378     ($val:expr) => {
 379         match $val { tmp => { tmp } }
 380     };
 381     // Trailing comma with single argument is ignored
 382     ($val:expr,) => { $crate::d!($val) };
 383     ($($val:expr),+ $(,)?) => {
 384         ($($crate::d!($val)),+,)
 385     };
 386 }
 387 struct A { the_field: u32 }
 388 fn foo(a: A) {
 389     d!(a.$0)
 390 }
 391 "#,
 392             expect![[r#"
 393                 fd the_field u32
 394             "#]],
 395         );
 396     }
 397
 398     #[test]
 399     fn test_method_completion_issue_3547() {
 400         check(
 401             r#"
 402 struct HashSet<T> {}
 403 impl<T> HashSet<T> {
 404     pub fn the_method(&self) {}
 405 }
 406 fn foo() {
 407     let s: HashSet<_>;
 408     s.$0
 409 }
 410 "#,
 411             expect![[r#"
 412                 me the_method() -> ()
 413             "#]],
 414         );
 415     }
 416
 417     #[test]
 418     fn completes_method_call_when_receiver_is_a_macro_call() {
 419         check(
 420             r#"
 421 struct S;
 422 impl S { fn foo(&self) {} }
 423 macro_rules! make_s { () => { S }; }
 424 fn main() { make_s!().f$0; }
 425 "#,
 426             expect![[r#"
 427                 me foo() -> ()
 428             "#]],
 429         )
 430     }
 431 }