1 //! This module defines an accumulator for completions which are going to be presented to user.
2 
3 pub(crate) mod attribute;
4 pub(crate) mod dot;
5 pub(crate) mod flyimport;
6 pub(crate) mod fn_param;
7 pub(crate) mod keyword;
8 pub(crate) mod lifetime;
9 pub(crate) mod mod_;
10 pub(crate) mod pattern;
11 pub(crate) mod postfix;
12 pub(crate) mod qualified_path;
13 pub(crate) mod record;
14 pub(crate) mod snippet;
15 pub(crate) mod trait_impl;
16 pub(crate) mod unqualified_path;
17 
18 use std::iter;
19 
20 use hir::known;
21 use ide_db::SymbolKind;
22 
23 use crate::{
24     item::Builder,
25     render::{
26         const_::render_const,
27         enum_variant::render_variant,
28         function::{render_fn, render_method},
29         macro_::render_macro,
30         pattern::{render_struct_pat, render_variant_pat},
31         render_field, render_resolution, render_tuple_field,
32         struct_literal::render_struct_literal,
33         type_alias::{render_type_alias, render_type_alias_with_eq},
34         RenderContext,
35     },
36     CompletionContext, CompletionItem, CompletionItemKind,
37 };
38 
39 /// Represents an in-progress set of completions being built.
40 #[derive(Debug, Default)]
41 pub struct Completions {
42     buf: Vec<CompletionItem>,
43 }
44 
45 impl From<Completions> for Vec<CompletionItem> {
from(val: Completions) -> Self46     fn from(val: Completions) -> Self {
47         val.buf
48     }
49 }
50 
51 impl Builder {
52     /// Convenience method, which allows to add a freshly created completion into accumulator
53     /// without binding it to the variable.
add_to(self, acc: &mut Completions)54     pub(crate) fn add_to(self, acc: &mut Completions) {
55         acc.add(self.build())
56     }
57 }
58 
59 impl Completions {
add(&mut self, item: CompletionItem)60     fn add(&mut self, item: CompletionItem) {
61         self.buf.push(item)
62     }
63 
add_opt(&mut self, item: Option<CompletionItem>)64     fn add_opt(&mut self, item: Option<CompletionItem>) {
65         if let Some(item) = item {
66             self.buf.push(item)
67         }
68     }
69 
add_all<I>(&mut self, items: I) where I: IntoIterator, I::Item: Into<CompletionItem>,70     pub(crate) fn add_all<I>(&mut self, items: I)
71     where
72         I: IntoIterator,
73         I::Item: Into<CompletionItem>,
74     {
75         items.into_iter().for_each(|item| self.add(item.into()))
76     }
77 
add_keyword(&mut self, ctx: &CompletionContext, keyword: &'static str)78     pub(crate) fn add_keyword(&mut self, ctx: &CompletionContext, keyword: &'static str) {
79         let item = CompletionItem::new(CompletionItemKind::Keyword, ctx.source_range(), keyword);
80         item.add_to(self);
81     }
82 
add_resolution( &mut self, ctx: &CompletionContext, local_name: hir::Name, resolution: &hir::ScopeDef, )83     pub(crate) fn add_resolution(
84         &mut self,
85         ctx: &CompletionContext,
86         local_name: hir::Name,
87         resolution: &hir::ScopeDef,
88     ) {
89         if ctx.is_scope_def_hidden(resolution) {
90             cov_mark::hit!(qualified_path_doc_hidden);
91             return;
92         }
93         self.add_opt(render_resolution(RenderContext::new(ctx), local_name, resolution));
94     }
95 
add_macro( &mut self, ctx: &CompletionContext, name: Option<hir::Name>, macro_: hir::MacroDef, )96     pub(crate) fn add_macro(
97         &mut self,
98         ctx: &CompletionContext,
99         name: Option<hir::Name>,
100         macro_: hir::MacroDef,
101     ) {
102         let name = match name {
103             Some(it) => it,
104             None => return,
105         };
106         self.add_opt(render_macro(RenderContext::new(ctx), None, name, macro_));
107     }
108 
add_function( &mut self, ctx: &CompletionContext, func: hir::Function, local_name: Option<hir::Name>, )109     pub(crate) fn add_function(
110         &mut self,
111         ctx: &CompletionContext,
112         func: hir::Function,
113         local_name: Option<hir::Name>,
114     ) {
115         if !ctx.is_visible(&func) {
116             return;
117         }
118         self.add_opt(render_fn(RenderContext::new(ctx), None, local_name, func));
119     }
120 
add_method( &mut self, ctx: &CompletionContext, func: hir::Function, receiver: Option<hir::Name>, local_name: Option<hir::Name>, )121     pub(crate) fn add_method(
122         &mut self,
123         ctx: &CompletionContext,
124         func: hir::Function,
125         receiver: Option<hir::Name>,
126         local_name: Option<hir::Name>,
127     ) {
128         if !ctx.is_visible(&func) {
129             return;
130         }
131         self.add_opt(render_method(RenderContext::new(ctx), None, receiver, local_name, func));
132     }
133 
add_const(&mut self, ctx: &CompletionContext, konst: hir::Const)134     pub(crate) fn add_const(&mut self, ctx: &CompletionContext, konst: hir::Const) {
135         if !ctx.is_visible(&konst) {
136             return;
137         }
138         self.add_opt(render_const(RenderContext::new(ctx), konst));
139     }
140 
add_type_alias(&mut self, ctx: &CompletionContext, type_alias: hir::TypeAlias)141     pub(crate) fn add_type_alias(&mut self, ctx: &CompletionContext, type_alias: hir::TypeAlias) {
142         if !ctx.is_visible(&type_alias) {
143             return;
144         }
145         self.add_opt(render_type_alias(RenderContext::new(ctx), type_alias));
146     }
147 
add_type_alias_with_eq( &mut self, ctx: &CompletionContext, type_alias: hir::TypeAlias, )148     pub(crate) fn add_type_alias_with_eq(
149         &mut self,
150         ctx: &CompletionContext,
151         type_alias: hir::TypeAlias,
152     ) {
153         self.add_opt(render_type_alias_with_eq(RenderContext::new(ctx), type_alias));
154     }
155 
add_qualified_enum_variant( &mut self, ctx: &CompletionContext, variant: hir::Variant, path: hir::ModPath, )156     pub(crate) fn add_qualified_enum_variant(
157         &mut self,
158         ctx: &CompletionContext,
159         variant: hir::Variant,
160         path: hir::ModPath,
161     ) {
162         let item = render_variant(RenderContext::new(ctx), None, None, variant, Some(path));
163         self.add(item);
164     }
165 
add_enum_variant( &mut self, ctx: &CompletionContext, variant: hir::Variant, local_name: Option<hir::Name>, )166     pub(crate) fn add_enum_variant(
167         &mut self,
168         ctx: &CompletionContext,
169         variant: hir::Variant,
170         local_name: Option<hir::Name>,
171     ) {
172         let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
173         self.add(item);
174     }
175 
add_field( &mut self, ctx: &CompletionContext, receiver: Option<hir::Name>, field: hir::Field, ty: &hir::Type, )176     pub(crate) fn add_field(
177         &mut self,
178         ctx: &CompletionContext,
179         receiver: Option<hir::Name>,
180         field: hir::Field,
181         ty: &hir::Type,
182     ) {
183         if !ctx.is_visible(&field) {
184             return;
185         }
186         let item = render_field(RenderContext::new(ctx), receiver, field, ty);
187         self.add(item);
188     }
189 
add_struct_literal( &mut self, ctx: &CompletionContext, strukt: hir::Struct, path: Option<hir::ModPath>, local_name: Option<hir::Name>, )190     pub(crate) fn add_struct_literal(
191         &mut self,
192         ctx: &CompletionContext,
193         strukt: hir::Struct,
194         path: Option<hir::ModPath>,
195         local_name: Option<hir::Name>,
196     ) {
197         let item = render_struct_literal(RenderContext::new(ctx), strukt, path, local_name);
198         self.add_opt(item);
199     }
200 
add_tuple_field( &mut self, ctx: &CompletionContext, receiver: Option<hir::Name>, field: usize, ty: &hir::Type, )201     pub(crate) fn add_tuple_field(
202         &mut self,
203         ctx: &CompletionContext,
204         receiver: Option<hir::Name>,
205         field: usize,
206         ty: &hir::Type,
207     ) {
208         let item = render_tuple_field(RenderContext::new(ctx), receiver, field, ty);
209         self.add(item);
210     }
211 
add_static_lifetime(&mut self, ctx: &CompletionContext)212     pub(crate) fn add_static_lifetime(&mut self, ctx: &CompletionContext) {
213         let item = CompletionItem::new(SymbolKind::LifetimeParam, ctx.source_range(), "'static");
214         self.add(item.build());
215     }
216 
add_variant_pat( &mut self, ctx: &CompletionContext, variant: hir::Variant, local_name: Option<hir::Name>, )217     pub(crate) fn add_variant_pat(
218         &mut self,
219         ctx: &CompletionContext,
220         variant: hir::Variant,
221         local_name: Option<hir::Name>,
222     ) {
223         self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, local_name, None));
224     }
225 
add_qualified_variant_pat( &mut self, ctx: &CompletionContext, variant: hir::Variant, path: hir::ModPath, )226     pub(crate) fn add_qualified_variant_pat(
227         &mut self,
228         ctx: &CompletionContext,
229         variant: hir::Variant,
230         path: hir::ModPath,
231     ) {
232         self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, None, Some(path)));
233     }
234 
add_struct_pat( &mut self, ctx: &CompletionContext, strukt: hir::Struct, local_name: Option<hir::Name>, )235     pub(crate) fn add_struct_pat(
236         &mut self,
237         ctx: &CompletionContext,
238         strukt: hir::Struct,
239         local_name: Option<hir::Name>,
240     ) {
241         self.add_opt(render_struct_pat(RenderContext::new(ctx), strukt, local_name));
242     }
243 }
244 
245 /// Calls the callback for each variant of the provided enum with the path to the variant.
246 /// Skips variants that are visible with single segment paths.
enum_variants_with_paths( acc: &mut Completions, ctx: &CompletionContext, enum_: hir::Enum, cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath), )247 fn enum_variants_with_paths(
248     acc: &mut Completions,
249     ctx: &CompletionContext,
250     enum_: hir::Enum,
251     cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath),
252 ) {
253     let variants = enum_.variants(ctx.db);
254 
255     let module = if let Some(module) = ctx.scope.module() {
256         // Compute path from the completion site if available.
257         module
258     } else {
259         // Otherwise fall back to the enum's definition site.
260         enum_.module(ctx.db)
261     };
262 
263     if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
264         if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_)) {
265             for &variant in &variants {
266                 let self_path = hir::ModPath::from_segments(
267                     hir::PathKind::Plain,
268                     iter::once(known::SELF_TYPE).chain(iter::once(variant.name(ctx.db))),
269                 );
270                 cb(acc, ctx, variant, self_path);
271             }
272         }
273     }
274 
275     for variant in variants {
276         if let Some(path) = module.find_use_path(ctx.db, hir::ModuleDef::from(variant)) {
277             // Variants with trivial paths are already added by the existing completion logic,
278             // so we should avoid adding these twice
279             if path.segments().len() > 1 {
280                 cb(acc, ctx, variant, path);
281             }
282         }
283     }
284 }
285