2021-07-22 12:38:49 -05:00
|
|
|
use expect_test::{expect, Expect};
|
|
|
|
|
2021-07-22 12:59:01 -05:00
|
|
|
use crate::tests::completion_list;
|
2021-07-22 12:38:49 -05:00
|
|
|
|
|
|
|
fn check(ra_fixture: &str, expect: Expect) {
|
|
|
|
let actual = completion_list(ra_fixture);
|
|
|
|
expect.assert_eq(&actual);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn without_default_impl() {
|
2021-10-27 09:24:42 -05:00
|
|
|
cov_mark::check!(no_keyword_completion_in_record_lit);
|
2021-07-22 12:38:49 -05:00
|
|
|
check(
|
|
|
|
r#"
|
|
|
|
struct Struct { foo: u32, bar: usize }
|
|
|
|
|
|
|
|
fn foo() {
|
|
|
|
let other = Struct {
|
|
|
|
foo: 5,
|
|
|
|
$0
|
|
|
|
};
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
expect![[r#"
|
|
|
|
fd bar usize
|
|
|
|
"#]],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn record_pattern_field() {
|
|
|
|
check(
|
|
|
|
r#"
|
|
|
|
struct Struct { foo: u32, bar: u32 }
|
|
|
|
|
|
|
|
fn foo(s: Struct) {
|
|
|
|
match s {
|
|
|
|
Struct { foo, $0: 92 } => (),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
expect![[r#"
|
|
|
|
fd bar u32
|
2022-05-24 06:24:36 -05:00
|
|
|
kw mut
|
|
|
|
kw ref
|
2021-07-22 12:38:49 -05:00
|
|
|
"#]],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn pattern_enum_variant() {
|
|
|
|
check(
|
|
|
|
r#"
|
|
|
|
enum Enum { Variant { foo: u32, bar: u32 } }
|
|
|
|
fn foo(e: Enum) {
|
|
|
|
match e {
|
|
|
|
Enum::Variant { foo, $0 } => (),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
expect![[r#"
|
|
|
|
fd bar u32
|
2022-05-24 06:24:36 -05:00
|
|
|
kw mut
|
|
|
|
kw ref
|
2021-07-22 12:38:49 -05:00
|
|
|
"#]],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn record_literal_field_in_macro() {
|
|
|
|
check(
|
|
|
|
r#"
|
|
|
|
macro_rules! m { ($e:expr) => { $e } }
|
|
|
|
struct Struct { field: u32 }
|
|
|
|
fn foo() {
|
|
|
|
m!(Struct { fie$0 })
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
expect![[r#"
|
|
|
|
fd field u32
|
|
|
|
"#]],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn record_pattern_field_in_macro() {
|
|
|
|
check(
|
|
|
|
r"
|
|
|
|
macro_rules! m { ($e:expr) => { $e } }
|
|
|
|
struct Struct { field: u32 }
|
|
|
|
|
|
|
|
fn foo(f: Struct) {
|
|
|
|
m!(match f {
|
|
|
|
Struct { f$0: 92 } => (),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
",
|
|
|
|
expect![[r#"
|
|
|
|
fd field u32
|
2022-05-24 06:24:36 -05:00
|
|
|
kw mut
|
|
|
|
kw ref
|
2021-07-22 12:38:49 -05:00
|
|
|
"#]],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn functional_update() {
|
|
|
|
// FIXME: This should filter out all completions that do not have the type `Foo`
|
2021-08-10 07:58:14 -05:00
|
|
|
// FIXME: Fields should not show up after `.`
|
2021-07-22 12:38:49 -05:00
|
|
|
check(
|
|
|
|
r#"
|
2021-08-10 07:58:14 -05:00
|
|
|
//- minicore:default
|
2021-07-22 12:38:49 -05:00
|
|
|
struct Foo { foo1: u32, foo2: u32 }
|
2021-08-10 07:58:14 -05:00
|
|
|
impl Default for Foo {
|
|
|
|
fn default() -> Self { loop {} }
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
let thing = 1;
|
|
|
|
let foo = Foo { foo1: 0, foo2: 0 };
|
|
|
|
let foo2 = Foo { thing, $0 }
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
expect![[r#"
|
|
|
|
fd ..Default::default()
|
|
|
|
fd foo1 u32
|
|
|
|
fd foo2 u32
|
|
|
|
"#]],
|
|
|
|
);
|
|
|
|
check(
|
|
|
|
r#"
|
|
|
|
//- minicore:default
|
|
|
|
struct Foo { foo1: u32, foo2: u32 }
|
|
|
|
impl Default for Foo {
|
|
|
|
fn default() -> Self { loop {} }
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
let thing = 1;
|
|
|
|
let foo = Foo { foo1: 0, foo2: 0 };
|
|
|
|
let foo2 = Foo { thing, .$0 }
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
expect![[r#"
|
|
|
|
fd ..Default::default()
|
2021-08-10 10:03:38 -05:00
|
|
|
sn ..
|
2021-08-10 07:58:14 -05:00
|
|
|
"#]],
|
|
|
|
);
|
|
|
|
check(
|
|
|
|
r#"
|
|
|
|
//- minicore:default
|
|
|
|
struct Foo { foo1: u32, foo2: u32 }
|
|
|
|
impl Default for Foo {
|
|
|
|
fn default() -> Self { loop {} }
|
|
|
|
}
|
2021-07-22 12:38:49 -05:00
|
|
|
|
|
|
|
fn main() {
|
|
|
|
let thing = 1;
|
|
|
|
let foo = Foo { foo1: 0, foo2: 0 };
|
|
|
|
let foo2 = Foo { thing, ..$0 }
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
expect![[r#"
|
2022-02-03 09:05:21 -06:00
|
|
|
fd ..Default::default()
|
|
|
|
fd foo1 u32
|
|
|
|
fd foo2 u32
|
2022-05-05 03:49:43 -05:00
|
|
|
fn main() fn()
|
2021-08-10 10:03:38 -05:00
|
|
|
lc foo Foo
|
|
|
|
lc thing i32
|
|
|
|
md core
|
2022-05-05 03:49:43 -05:00
|
|
|
st Foo
|
|
|
|
st Foo {…} Foo { foo1: u32, foo2: u32 }
|
2021-08-10 10:03:38 -05:00
|
|
|
tt Default
|
2022-05-05 03:49:43 -05:00
|
|
|
tt Sized
|
|
|
|
bt u32
|
2022-05-05 08:49:03 -05:00
|
|
|
kw crate::
|
|
|
|
kw self::
|
|
|
|
kw super::
|
2021-07-22 12:38:49 -05:00
|
|
|
"#]],
|
|
|
|
);
|
2021-08-21 13:45:15 -05:00
|
|
|
check(
|
|
|
|
r#"
|
|
|
|
//- minicore:default
|
|
|
|
struct Foo { foo1: u32, foo2: u32 }
|
|
|
|
impl Default for Foo {
|
|
|
|
fn default() -> Self { loop {} }
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
let thing = 1;
|
|
|
|
let foo = Foo { foo1: 0, foo2: 0 };
|
|
|
|
let foo2 = Foo { thing, ..Default::$0 }
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
expect![[r#"
|
|
|
|
fd foo1 u32
|
|
|
|
fd foo2 u32
|
2022-05-05 03:49:43 -05:00
|
|
|
fn default() (as Default) fn() -> Self
|
2021-08-21 13:45:15 -05:00
|
|
|
"#]],
|
|
|
|
);
|
2021-07-22 12:38:49 -05:00
|
|
|
}
|
2022-03-12 08:58:43 -06:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn empty_union_literal() {
|
|
|
|
check(
|
|
|
|
r#"
|
|
|
|
union Union { foo: u32, bar: f32 }
|
|
|
|
|
|
|
|
fn foo() {
|
|
|
|
let other = Union {
|
|
|
|
$0
|
|
|
|
};
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
expect![[r#"
|
|
|
|
fd bar f32
|
2022-05-05 03:49:43 -05:00
|
|
|
fd foo u32
|
2022-03-12 08:58:43 -06:00
|
|
|
"#]],
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn dont_suggest_additional_union_fields() {
|
|
|
|
check(
|
|
|
|
r#"
|
|
|
|
union Union { foo: u32, bar: f32 }
|
|
|
|
|
|
|
|
fn foo() {
|
|
|
|
let other = Union {
|
|
|
|
foo: 1,
|
|
|
|
$0
|
|
|
|
};
|
|
|
|
}
|
|
|
|
"#,
|
|
|
|
expect![[r#""#]],
|
|
|
|
)
|
|
|
|
}
|