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, local_name: Option<hir::Name>, )190 pub(crate) fn add_struct_literal(
191 &mut self,
192 ctx: &CompletionContext,
193 strukt: hir::Struct,
194 local_name: Option<hir::Name>,
195 ) {
196 let item = render_struct_literal(RenderContext::new(ctx), strukt, local_name);
197 self.add_opt(item);
198 }
199
add_tuple_field( &mut self, ctx: &CompletionContext, receiver: Option<hir::Name>, field: usize, ty: &hir::Type, )200 pub(crate) fn add_tuple_field(
201 &mut self,
202 ctx: &CompletionContext,
203 receiver: Option<hir::Name>,
204 field: usize,
205 ty: &hir::Type,
206 ) {
207 let item = render_tuple_field(RenderContext::new(ctx), receiver, field, ty);
208 self.add(item);
209 }
210
add_static_lifetime(&mut self, ctx: &CompletionContext)211 pub(crate) fn add_static_lifetime(&mut self, ctx: &CompletionContext) {
212 let item = CompletionItem::new(SymbolKind::LifetimeParam, ctx.source_range(), "'static");
213 self.add(item.build());
214 }
215
add_variant_pat( &mut self, ctx: &CompletionContext, variant: hir::Variant, local_name: Option<hir::Name>, )216 pub(crate) fn add_variant_pat(
217 &mut self,
218 ctx: &CompletionContext,
219 variant: hir::Variant,
220 local_name: Option<hir::Name>,
221 ) {
222 self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, local_name, None));
223 }
224
add_qualified_variant_pat( &mut self, ctx: &CompletionContext, variant: hir::Variant, path: hir::ModPath, )225 pub(crate) fn add_qualified_variant_pat(
226 &mut self,
227 ctx: &CompletionContext,
228 variant: hir::Variant,
229 path: hir::ModPath,
230 ) {
231 self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, None, Some(path)));
232 }
233
add_struct_pat( &mut self, ctx: &CompletionContext, strukt: hir::Struct, local_name: Option<hir::Name>, )234 pub(crate) fn add_struct_pat(
235 &mut self,
236 ctx: &CompletionContext,
237 strukt: hir::Struct,
238 local_name: Option<hir::Name>,
239 ) {
240 self.add_opt(render_struct_pat(RenderContext::new(ctx), strukt, local_name));
241 }
242 }
243
244 /// Calls the callback for each variant of the provided enum with the path to the variant.
245 /// 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), )246 fn enum_variants_with_paths(
247 acc: &mut Completions,
248 ctx: &CompletionContext,
249 enum_: hir::Enum,
250 cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath),
251 ) {
252 let variants = enum_.variants(ctx.db);
253
254 let module = if let Some(module) = ctx.scope.module() {
255 // Compute path from the completion site if available.
256 module
257 } else {
258 // Otherwise fall back to the enum's definition site.
259 enum_.module(ctx.db)
260 };
261
262 if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
263 if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_)) {
264 for &variant in &variants {
265 let self_path = hir::ModPath::from_segments(
266 hir::PathKind::Plain,
267 iter::once(known::SELF_TYPE).chain(iter::once(variant.name(ctx.db))),
268 );
269 cb(acc, ctx, variant, self_path);
270 }
271 }
272 }
273
274 for variant in variants {
275 if let Some(path) = module.find_use_path(ctx.db, hir::ModuleDef::from(variant)) {
276 // Variants with trivial paths are already added by the existing completion logic,
277 // so we should avoid adding these twice
278 if path.segments().len() > 1 {
279 cb(acc, ctx, variant, path);
280 }
281 }
282 }
283 }
284