crates/ide_completion/src/tests/expression.rs

   1 //! Completion tests for expressions.
   2 use expect_test::{expect, Expect};
   3
   4 use crate::tests::{completion_list, BASE_ITEMS_FIXTURE};
   5
   6 fn check(ra_fixture: &str, expect: Expect) {
   7     let actual = completion_list(&format!("{}{}", BASE_ITEMS_FIXTURE, ra_fixture));
   8     expect.assert_eq(&actual)
   9 }
  10
  11 fn check_empty(ra_fixture: &str, expect: Expect) {
  12     let actual = completion_list(ra_fixture);
  13     expect.assert_eq(&actual);
  14 }
  15
  16 #[test]
  17 fn complete_literal_struct_with_a_private_field() {
  18     // `FooDesc.bar` is private, the completion should not be triggered.
  19     check(
  20         r#"
  21 mod _69latrick {
  22     pub struct FooDesc { pub six: bool, pub neuf: Vec<String>, bar: bool }
  23     pub fn create_foo(foo_desc: &FooDesc) -> () { () }
  24 }
  25
  26 fn baz() {
  27     use _69latrick::*;
  28
  29     let foo = create_foo(&$0);
  30 }
  31             "#,
  32         // This should not contain `FooDesc {…}`.
  33         expect![[r##"
  34             kw unsafe
  35             kw match
  36             kw while
  37             kw while let
  38             kw loop
  39             kw if
  40             kw if let
  41             kw for
  42             kw true
  43             kw false
  44             kw mut
  45             kw return
  46             kw self
  47             kw super
  48             kw crate
  49             st FooDesc
  50             fn create_foo(…) fn(&FooDesc)
  51             bt u32
  52             tt Trait
  53             en Enum
  54             st Record
  55             st Tuple
  56             md module
  57             fn baz()         fn()
  58             st Unit
  59             md _69latrick
  60             ma makro!(…)     #[macro_export] macro_rules! makro
  61             fn function()    fn()
  62             sc STATIC
  63             un Union
  64             ev TupleV(…)     (u32)
  65             ct CONST
  66         "##]],
  67     )
  68 }
  69
  70 #[test]
  71 fn completes_various_bindings() {
  72     check_empty(
  73         r#"
  74 fn func(param0 @ (param1, param2): (i32, i32)) {
  75     let letlocal = 92;
  76     if let ifletlocal = 100 {
  77         match 0 {
  78             matcharm => 1 + $0,
  79             otherwise => (),
  80         }
  81     }
  82     let letlocal2 = 44;
  83 }
  84 "#,
  85         expect![[r#"
  86             kw unsafe
  87             kw match
  88             kw while
  89             kw while let
  90             kw loop
  91             kw if
  92             kw if let
  93             kw for
  94             kw true
  95             kw false
  96             kw return
  97             kw self
  98             kw super
  99             kw crate
 100             lc matcharm   i32
 101             lc ifletlocal i32
 102             lc letlocal   i32
 103             lc param0     (i32, i32)
 104             lc param1     i32
 105             lc param2     i32
 106             fn func(…)    fn((i32, i32))
 107             bt u32
 108         "#]],
 109     );
 110 }
 111
 112 #[test]
 113 fn completes_all_the_things_in_fn_body() {
 114     cov_mark::check!(unqualified_skip_lifetime_completion);
 115     check(
 116         r#"
 117 use non_existant::Unresolved;
 118 mod qualified { pub enum Enum { Variant } }
 119
 120 impl Unit {
 121     fn foo<'lifetime, TypeParam, const CONST_PARAM: usize>(self) {
 122         fn local_func() {}
 123         $0
 124     }
 125 }
 126 "#,
 127         // `self` is in here twice, once as the module, once as the local
 128         expect![[r##"
 129             kw unsafe
 130             kw fn
 131             kw const
 132             kw type
 133             kw impl
 134             kw extern
 135             kw use
 136             kw trait
 137             kw static
 138             kw mod
 139             kw match
 140             kw while
 141             kw while let
 142             kw loop
 143             kw if
 144             kw if let
 145             kw for
 146             kw true
 147             kw false
 148             kw let
 149             kw return
 150             sn pd
 151             sn ppd
 152             kw self
 153             kw super
 154             kw crate
 155             fn local_func() fn()
 156             bt u32
 157             lc self         Unit
 158             tp TypeParam
 159             cp CONST_PARAM
 160             sp Self
 161             tt Trait
 162             en Enum
 163             st Record
 164             st Tuple
 165             md module
 166             st Unit
 167             md qualified
 168             ma makro!(…)    #[macro_export] macro_rules! makro
 169             ?? Unresolved
 170             fn function()   fn()
 171             sc STATIC
 172             un Union
 173             ev TupleV(…)    (u32)
 174             ct CONST
 175             me self.foo()   fn(self)
 176         "##]],
 177     );
 178     check(
 179         r#"
 180 use non_existant::Unresolved;
 181 mod qualified { pub enum Enum { Variant } }
 182
 183 impl Unit {
 184     fn foo<'lifetime, TypeParam, const CONST_PARAM: usize>(self) {
 185         fn local_func() {}
 186         self::$0
 187     }
 188 }
 189 "#,
 190         expect![[r##"
 191             tt Trait
 192             en Enum
 193             st Record
 194             st Tuple
 195             md module
 196             st Unit
 197             md qualified
 198             ma makro!(…)  #[macro_export] macro_rules! makro
 199             ?? Unresolved
 200             fn function() fn()
 201             sc STATIC
 202             un Union
 203             ev TupleV(…)  (u32)
 204             ct CONST
 205         "##]],
 206     );
 207 }
 208
 209 #[test]
 210 fn complete_in_block() {
 211     check_empty(
 212         r#"
 213     fn foo() {
 214         if true {
 215             $0
 216         }
 217     }
 218 "#,
 219         expect![[r#"
 220             kw unsafe
 221             kw fn
 222             kw const
 223             kw type
 224             kw impl
 225             kw extern
 226             kw use
 227             kw trait
 228             kw static
 229             kw mod
 230             kw match
 231             kw while
 232             kw while let
 233             kw loop
 234             kw if
 235             kw if let
 236             kw for
 237             kw true
 238             kw false
 239             kw let
 240             kw return
 241             sn pd
 242             sn ppd
 243             kw self
 244             kw super
 245             kw crate
 246             fn foo()     fn()
 247             bt u32
 248         "#]],
 249     )
 250 }
 251
 252 #[test]
 253 fn complete_after_if_expr() {
 254     check_empty(
 255         r#"
 256     fn foo() {
 257         if true {}
 258         $0
 259     }
 260 "#,
 261         expect![[r#"
 262             kw unsafe
 263             kw fn
 264             kw const
 265             kw type
 266             kw impl
 267             kw extern
 268             kw use
 269             kw trait
 270             kw static
 271             kw mod
 272             kw match
 273             kw while
 274             kw while let
 275             kw loop
 276             kw if
 277             kw if let
 278             kw for
 279             kw true
 280             kw false
 281             kw let
 282             kw else
 283             kw else if
 284             kw return
 285             sn pd
 286             sn ppd
 287             kw self
 288             kw super
 289             kw crate
 290             fn foo()     fn()
 291             bt u32
 292         "#]],
 293     )
 294 }
 295
 296 #[test]
 297 fn complete_in_match_arm() {
 298     check_empty(
 299         r#"
 300     fn foo() {
 301         match () {
 302             () => $0
 303         }
 304     }
 305 "#,
 306         expect![[r#"
 307             kw unsafe
 308             kw match
 309             kw while
 310             kw while let
 311             kw loop
 312             kw if
 313             kw if let
 314             kw for
 315             kw true
 316             kw false
 317             kw return
 318             kw self
 319             kw super
 320             kw crate
 321             fn foo()     fn()
 322             bt u32
 323         "#]],
 324     )
 325 }
 326
 327 #[test]
 328 fn completes_in_loop_ctx() {
 329     check_empty(
 330         r"fn my() { loop { $0 } }",
 331         expect![[r#"
 332             kw unsafe
 333             kw fn
 334             kw const
 335             kw type
 336             kw impl
 337             kw extern
 338             kw use
 339             kw trait
 340             kw static
 341             kw mod
 342             kw match
 343             kw while
 344             kw while let
 345             kw loop
 346             kw if
 347             kw if let
 348             kw for
 349             kw true
 350             kw false
 351             kw let
 352             kw continue
 353             kw break
 354             kw return
 355             sn pd
 356             sn ppd
 357             kw self
 358             kw super
 359             kw crate
 360             fn my()      fn()
 361             bt u32
 362         "#]],
 363     );
 364 }
 365
 366 #[test]
 367 fn completes_in_let_initializer() {
 368     check_empty(
 369         r#"fn main() { let _ = $0 }"#,
 370         expect![[r#"
 371             kw unsafe
 372             kw match
 373             kw while
 374             kw while let
 375             kw loop
 376             kw if
 377             kw if let
 378             kw for
 379             kw true
 380             kw false
 381             kw return
 382             kw self
 383             kw super
 384             kw crate
 385             fn main()    fn()
 386             bt u32
 387         "#]],
 388     )
 389 }
 390
 391 #[test]
 392 fn struct_initializer_field_expr() {
 393     check_empty(
 394         r#"
 395 struct Foo {
 396     pub f: i32,
 397 }
 398 fn foo() {
 399     Foo {
 400         f: $0
 401     }
 402 }
 403 "#,
 404         expect![[r#"
 405             kw unsafe
 406             kw match
 407             kw while
 408             kw while let
 409             kw loop
 410             kw if
 411             kw if let
 412             kw for
 413             kw true
 414             kw false
 415             kw return
 416             kw self
 417             kw super
 418             kw crate
 419             st Foo
 420             fn foo()     fn()
 421             bt u32
 422         "#]],
 423     );
 424 }
 425
 426 #[test]
 427 fn shadowing_shows_single_completion() {
 428     cov_mark::check!(shadowing_shows_single_completion);
 429
 430     check_empty(
 431         r#"
 432 fn foo() {
 433     let bar = 92;
 434     {
 435         let bar = 62;
 436         drop($0)
 437     }
 438 }
 439 "#,
 440         expect![[r#"
 441             kw unsafe
 442             kw match
 443             kw while
 444             kw while let
 445             kw loop
 446             kw if
 447             kw if let
 448             kw for
 449             kw true
 450             kw false
 451             kw return
 452             kw self
 453             kw super
 454             kw crate
 455             lc bar       i32
 456             fn foo()     fn()
 457             bt u32
 458         "#]],
 459     );
 460 }
 461
 462 #[test]
 463 fn in_macro_expr_frag() {
 464     check_empty(
 465         r#"
 466 macro_rules! m { ($e:expr) => { $e } }
 467 fn quux(x: i32) {
 468     m!($0);
 469 }
 470 "#,
 471         expect![[r#"
 472             kw unsafe
 473             kw match
 474             kw while
 475             kw while let
 476             kw loop
 477             kw if
 478             kw if let
 479             kw for
 480             kw true
 481             kw false
 482             kw return
 483             kw self
 484             kw super
 485             kw crate
 486             bt u32
 487             lc x         i32
 488             fn quux(…)   fn(i32)
 489             ma m!(…)     macro_rules! m
 490         "#]],
 491     );
 492     check_empty(
 493         r"
 494 macro_rules! m { ($e:expr) => { $e } }
 495 fn quux(x: i32) {
 496     m!(x$0);
 497 }
 498 ",
 499         expect![[r#"
 500             kw unsafe
 501             kw match
 502             kw while
 503             kw while let
 504             kw loop
 505             kw if
 506             kw if let
 507             kw for
 508             kw true
 509             kw false
 510             kw return
 511             kw self
 512             kw super
 513             kw crate
 514             bt u32
 515             lc x         i32
 516             fn quux(…)   fn(i32)
 517             ma m!(…)     macro_rules! m
 518         "#]],
 519     );
 520     check_empty(
 521         r#"
 522 macro_rules! m { ($e:expr) => { $e } }
 523 fn quux(x: i32) {
 524     let y = 92;
 525     m!(x$0
 526 }
 527 "#,
 528         expect![[r#""#]],
 529     );
 530 }
 531
 532 #[test]
 533 fn enum_qualified() {
 534     check(
 535         r#"
 536 impl Enum {
 537     type AssocType = ();
 538     const ASSOC_CONST: () = ();
 539     fn assoc_fn() {}
 540 }
 541 fn func() {
 542     Enum::$0
 543 }
 544 "#,
 545         expect![[r#"
 546             ev TupleV(…)   (u32)
 547             ev RecordV     {field: u32}
 548             ev UnitV       ()
 549             ct ASSOC_CONST const ASSOC_CONST: ()
 550             fn assoc_fn()  fn()
 551             ta AssocType   type AssocType;
 552         "#]],
 553     );
 554 }