expect.assert_eq(&actual);
}
- #[test]
- fn dont_complete_values_in_type_pos() {
- check(
- r#"
-const FOO: () = ();
-static BAR: () = ();
-struct Baz;
-fn foo() {
- let _: self::$0;
-}
-"#,
- expect![[r#"
- st Baz
- "#]],
- );
- }
-
- #[test]
- fn dont_complete_enum_variants_in_type_pos() {
- check(
- r#"
-enum Foo { Bar }
-fn foo() {
- let _: Foo::$0;
-}
-"#,
- expect![[r#""#]],
- );
- }
-
#[test]
fn dont_complete_primitive_in_use() {
check_builtin(r#"use self::$0;"#, expect![[""]]);
check_builtin(r#"fn foo() { self::$0 }"#, expect![[""]]);
}
- #[test]
- fn completes_primitives() {
- check_builtin(
- r#"fn main() { let _: $0 = 92; }"#,
- expect![[r#"
- bt u32
- bt bool
- bt u8
- bt isize
- bt u16
- bt u64
- bt u128
- bt f32
- bt i128
- bt i16
- bt str
- bt i64
- bt char
- bt f64
- bt i32
- bt i8
- bt usize
- "#]],
- );
- }
-
#[test]
fn completes_enum_variant() {
check(
"#]],
);
}
-
- #[test]
- fn completes_types_and_const_in_arg_list() {
- check(
- r#"
-mod foo {
- pub const CONST: () = ();
- pub type Type = ();
-}
-
-struct Foo<T>(t);
-
-fn foo(_: Foo<foo::$0>) {}
-"#,
- expect![[r#"
- ta Type
- ct CONST
- "#]],
- );
- }
}
expect.assert_eq(&actual)
}
- #[test]
- fn dont_complete_values_in_type_pos() {
- check(
- r#"
-const FOO: () = ();
-static BAR: () = ();
-enum Foo {
- Bar
-}
-struct Baz;
-fn foo() {
- let local = ();
- let _: $0;
-}
-"#,
- expect![[r#"
- en Foo
- st Baz
- "#]],
- );
- }
-
#[test]
fn completes_bindings_from_let() {
check(
);
}
- #[test]
- fn completes_generic_params_in_struct() {
- check(
- r#"struct S<T> { x: $0}"#,
- expect![[r#"
- sp Self
- tp T
- st S<…>
- "#]],
- );
- }
-
- #[test]
- fn completes_self_in_enum() {
- check(
- r#"enum X { Y($0) }"#,
- expect![[r#"
- sp Self
- en X
- "#]],
- );
- }
-
#[test]
fn completes_module_items() {
check(
);
}
- #[test]
- fn completes_return_type() {
- check(
- r#"
-struct Foo;
-fn x() -> $0
-"#,
- expect![[r#"
- st Foo
- "#]],
- );
- }
-
#[test]
fn dont_show_both_completions_for_shadowing() {
check(
);
}
- #[test]
- fn completes_macros_as_type() {
- check(
- r#"
-macro_rules! foo { () => {} }
-fn main() { let x: $0 }
-"#,
- expect![[r#"
- ma foo!(…) macro_rules! foo
- "#]],
- );
- }
-
#[test]
fn completes_macros_as_stmt() {
check(
expect![[""]],
)
}
-
- #[test]
- fn completes_types_and_const_in_arg_list() {
- check(
- r#"
-enum Bar {
- Baz
-}
-trait Foo {
- type Bar;
-}
-
-const CONST: () = ();
-
-fn foo<T: Foo<$0>, const CONST_PARAM: usize>(_: T) {}
-"#,
- expect![[r#"
- ta Bar = type Bar;
- tp T
- cp CONST_PARAM
- tt Foo
- en Bar
- ct CONST
- "#]],
- );
- }
}
mod use_tree;
mod items;
mod pattern;
+mod type_pos;
+
+use std::mem;
use hir::{PrefixKind, Semantics};
use ide_db::{
}
fn completion_list_with_config(config: CompletionConfig, code: &str) -> String {
- render_completion_list(get_all_items(config, code))
+ // filter out all but one builtintype completion for smaller test outputs
+ let items = get_all_items(config, code);
+ let mut bt_seen = false;
+ let items = items
+ .into_iter()
+ .filter(|it| {
+ it.completion_kind != CompletionKind::BuiltinType || !mem::replace(&mut bt_seen, true)
+ })
+ .collect();
+ render_completion_list(items)
}
/// Creates analysis from a multi-file fixture, returns positions marked with $0.
ma foo!(…) #[macro_export] macro_rules! foo
ma foo!(…) #[macro_export] macro_rules! foo
bt u32
- bt bool
- bt u8
- bt isize
- bt u16
- bt u64
- bt u128
- bt f32
- bt i128
- bt i16
- bt str
- bt i64
- bt char
- bt f64
- bt i32
- bt i8
- bt usize
"##]],
)
}
ma foo!(…) #[macro_export] macro_rules! foo
ma foo!(…) #[macro_export] macro_rules! foo
bt u32
- bt bool
- bt u8
- bt isize
- bt u16
- bt u64
- bt u128
- bt f32
- bt i128
- bt i16
- bt str
- bt i64
- bt char
- bt f64
- bt i32
- bt i8
- bt usize
"##]],
)
}
--- /dev/null
+//! Completions tests for type position.
+use expect_test::{expect, Expect};
+
+use crate::tests::completion_list;
+
+fn check_with(ra_fixture: &str, expect: Expect) {
+ let base = r#"
+enum Enum { TupleV(u32), RecordV { field: u32 }, UnitV }
+use self::Enum::TupleV;
+mod module {}
+
+trait Trait {}
+static STATIC: Unit = Unit;
+const CONST: Unit = Unit;
+struct Record { field: u32 }
+struct Tuple(u32);
+struct Unit
+macro_rules! makro {}
+"#;
+ let actual = completion_list(&format!("{}\n{}", base, ra_fixture));
+ expect.assert_eq(&actual)
+}
+
+#[test]
+fn record_field_ty() {
+ // FIXME: pub shouldnt show up here
+ check_with(
+ r#"
+struct Foo<'lt, T, const C: usize> {
+ f: $0
+}
+"#,
+ expect![[r#"
+ kw pub(crate)
+ kw pub
+ sp Self
+ tp T
+ tt Trait
+ en Enum
+ st Record
+ st Tuple
+ md module
+ st Foo<…>
+ st Unit
+ ma makro!(…) macro_rules! makro
+ bt u32
+ "#]],
+ )
+}
+
+#[test]
+fn tuple_struct_field() {
+ // FIXME: pub should show up here
+ check_with(
+ r#"
+struct Foo<'lt, T, const C: usize>(f$0);
+"#,
+ expect![[r#"
+ sp Self
+ tp T
+ tt Trait
+ en Enum
+ st Record
+ st Tuple
+ md module
+ st Foo<…>
+ st Unit
+ ma makro!(…) macro_rules! makro
+ bt u32
+ "#]],
+ )
+}
+
+#[test]
+fn fn_return_type() {
+ // FIXME: return shouldnt show up here
+ check_with(
+ r#"
+fn x<'lt, T, const C: usize>() -> $0
+"#,
+ expect![[r#"
+ kw return
+ tp T
+ tt Trait
+ en Enum
+ st Record
+ st Tuple
+ md module
+ st Unit
+ ma makro!(…) macro_rules! makro
+ bt u32
+ "#]],
+ );
+}
+
+#[test]
+fn body_type_pos() {
+ // FIXME: return shouldnt show up here
+ check_with(
+ r#"
+fn foo<'lt, T, const C: usize>() {
+ let local = ();
+ let _: $0;
+}
+"#,
+ expect![[r#"
+ kw return
+ tp T
+ tt Trait
+ en Enum
+ st Record
+ st Tuple
+ md module
+ st Unit
+ ma makro!(…) macro_rules! makro
+ bt u32
+ "#]],
+ );
+ check_with(
+ r#"
+fn foo<'lt, T, const C: usize>() {
+ let local = ();
+ let _: self::$0;
+}
+"#,
+ expect![[r#"
+ tt Trait
+ en Enum
+ st Record
+ st Tuple
+ md module
+ st Unit
+ "#]],
+ );
+}
+
+#[test]
+fn completes_types_and_const_in_arg_list() {
+ // FIXME: return shouldnt show up here
+ // FIXME: we should complete the lifetime here for now
+ check_with(
+ r#"
+trait Trait2 {
+ type Foo;
+}
+
+fn foo<'lt, T: Trait2<$0>, const CONST_PARAM: usize>(_: T) {}
+"#,
+ expect![[r#"
+ kw return
+ ta Foo = type Foo;
+ tp T
+ cp CONST_PARAM
+ tt Trait
+ en Enum
+ st Record
+ st Tuple
+ tt Trait2
+ md module
+ st Unit
+ ct CONST
+ ma makro!(…) macro_rules! makro
+ bt u32
+ "#]],
+ );
+ check_with(
+ r#"
+trait Trait2 {
+ type Foo;
+}
+
+fn foo<'lt, T: Trait2<self::$0>, const CONST_PARAM: usize>(_: T) {}
+ "#,
+ expect![[r#"
+ tt Trait
+ en Enum
+ st Record
+ st Tuple
+ tt Trait2
+ md module
+ st Unit
+ ct CONST
+ "#]],
+ );
+}