1 //! `completions` crate provides utilities for generating completions of user input.
8 mod generated_lint_completions;
14 use ide_db::base_db::FilePosition;
15 use ide_db::RootDatabase;
17 use crate::{completions::Completions, context::CompletionContext, item::CompletionKind};
20 config::CompletionConfig,
21 item::{CompletionItem, CompletionItemKind, CompletionScore, InsertTextFormat},
24 //FIXME: split the following feature into fine-grained features.
26 // Feature: Magic Completions
28 // In addition to usual reference completion, rust-analyzer provides some ✨magic✨
29 // completions as well:
31 // Keywords like `if`, `else` `while`, `loop` are completed with braces, and cursor
32 // is placed at the appropriate position. Even though `if` is easy to type, you
33 // still want to complete it, to get ` { }` for free! `return` is inserted with a
34 // space or `;` depending on the return type of the function.
36 // When completing a function call, `()` are automatically inserted. If a function
37 // takes arguments, the cursor is positioned inside the parenthesis.
39 // There are postfix completions, which can be triggered by typing something like
40 // `foo().if`. The word after `.` determines postfix completion. Possible variants are:
42 // - `expr.if` -> `if expr {}` or `if let ... {}` for `Option` or `Result`
43 // - `expr.match` -> `match expr {}`
44 // - `expr.while` -> `while expr {}` or `while let ... {}` for `Option` or `Result`
45 // - `expr.ref` -> `&expr`
46 // - `expr.refm` -> `&mut expr`
47 // - `expr.not` -> `!expr`
48 // - `expr.dbg` -> `dbg!(expr)`
49 // - `expr.dbgr` -> `dbg!(&expr)`
50 // - `expr.call` -> `(expr)`
52 // There also snippet completions:
55 // - `pd` -> `eprintln!(" = {:?}", );`
56 // - `ppd` -> `eprintln!(" = {:#?}", );`
59 // - `tfn` -> `#[test] fn feature(){}`
71 /// Main entry point for completion. We run completion as a two-phase process.
73 /// First, we look at the position and collect a so-called `CompletionContext.
74 /// This is a somewhat messy process, because, during completion, syntax tree is
75 /// incomplete and can look really weird.
77 /// Once the context is collected, we run a series of completion routines which
78 /// look at the context and produce completion items. One subtlety about this
79 /// phase is that completion engine should not filter by the substring which is
80 /// already present, it should give all possible variants for the identifier at
81 /// the caret. In other words, for
90 /// `foo` *should* be present among the completion variants. Filtering by
91 /// identifier prefix/fuzzy match should be done higher in the stack, together
92 /// with ordering of completions (currently this is done by the client).
95 config: &CompletionConfig,
96 position: FilePosition,
97 ) -> Option<Completions> {
98 let ctx = CompletionContext::new(db, position, config)?;
100 if ctx.no_completion_required() {
101 // No work required here.
105 let mut acc = Completions::default();
106 completions::attribute::complete_attribute(&mut acc, &ctx);
107 completions::fn_param::complete_fn_param(&mut acc, &ctx);
108 completions::keyword::complete_expr_keyword(&mut acc, &ctx);
109 completions::keyword::complete_use_tree_keyword(&mut acc, &ctx);
110 completions::snippet::complete_expr_snippet(&mut acc, &ctx);
111 completions::snippet::complete_item_snippet(&mut acc, &ctx);
112 completions::qualified_path::complete_qualified_path(&mut acc, &ctx);
113 completions::unqualified_path::complete_unqualified_path(&mut acc, &ctx);
114 completions::dot::complete_dot(&mut acc, &ctx);
115 completions::record::complete_record(&mut acc, &ctx);
116 completions::pattern::complete_pattern(&mut acc, &ctx);
117 completions::postfix::complete_postfix(&mut acc, &ctx);
118 completions::macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
119 completions::trait_impl::complete_trait_impl(&mut acc, &ctx);
120 completions::mod_::complete_mod(&mut acc, &ctx);
127 use crate::config::CompletionConfig;
128 use crate::test_utils;
130 struct DetailAndDocumentation<'a> {
132 documentation: &'a str,
135 fn check_detail_and_documentation(ra_fixture: &str, expected: DetailAndDocumentation) {
136 let (db, position) = test_utils::position(ra_fixture);
137 let config = CompletionConfig::default();
138 let completions: Vec<_> = crate::completions(&db, &config, position).unwrap().into();
139 for item in completions {
140 if item.detail() == Some(expected.detail) {
141 let opt = item.documentation();
142 let doc = opt.as_ref().map(|it| it.as_str());
143 assert_eq!(doc, Some(expected.documentation));
147 panic!("completion detail not found: {}", expected.detail)
150 fn check_no_completion(ra_fixture: &str) {
151 let (db, position) = test_utils::position(ra_fixture);
152 let config = CompletionConfig::default();
154 let completions: Option<Vec<String>> = crate::completions(&db, &config, position)
155 .and_then(|completions| {
156 let completions: Vec<_> = completions.into();
157 if completions.is_empty() {
164 completions.into_iter().map(|completion| format!("{:?}", completion)).collect()
167 // `assert_eq` instead of `assert!(completions.is_none())` to get the list of completions if test will panic.
168 assert_eq!(completions, None, "Completions were generated, but weren't expected");
172 fn test_completion_detail_from_macro_generated_struct_fn_doc_attr() {
173 check_detail_and_documentation(
180 #[doc = "Do the foo"]
193 DetailAndDocumentation { detail: "fn foo(&self)", documentation: "Do the foo" },
198 fn test_completion_detail_from_macro_generated_struct_fn_doc_comment() {
199 check_detail_and_documentation(
219 DetailAndDocumentation { detail: "fn foo(&self)", documentation: " Do the foo" },
224 fn test_no_completions_required() {
225 // There must be no hint for 'in' keyword.
233 // After 'in' keyword hints may be spawned.
234 check_detail_and_documentation(
237 fn foo() -> &'static str { "foo" }
243 DetailAndDocumentation {
244 detail: "fn foo() -> &'static str",
245 documentation: "Do the foo",