1 //! This module defines an accumulator for completions which are going to be presented to user.
3 pub(crate) mod attribute;
5 pub(crate) mod flyimport;
6 pub(crate) mod fn_param;
7 pub(crate) mod keyword;
8 pub(crate) mod lifetime;
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 pub(crate) mod format_string;
22 use ide_db::SymbolKind;
28 enum_variant::render_variant,
29 function::{render_fn, render_method},
31 pattern::{render_struct_pat, render_variant_pat},
32 render_field, render_resolution, render_tuple_field,
33 struct_literal::render_struct_literal,
34 type_alias::{render_type_alias, render_type_alias_with_eq},
37 CompletionContext, CompletionItem, CompletionItemKind,
40 /// Represents an in-progress set of completions being built.
41 #[derive(Debug, Default)]
42 pub struct Completions {
43 buf: Vec<CompletionItem>,
46 impl From<Completions> for Vec<CompletionItem> {
47 fn from(val: Completions) -> Self {
53 /// Convenience method, which allows to add a freshly created completion into accumulator
54 /// without binding it to the variable.
55 pub(crate) fn add_to(self, acc: &mut Completions) {
61 fn add(&mut self, item: CompletionItem) {
65 fn add_opt(&mut self, item: Option<CompletionItem>) {
66 if let Some(item) = item {
71 pub(crate) fn add_all<I>(&mut self, items: I)
74 I::Item: Into<CompletionItem>,
76 items.into_iter().for_each(|item| self.add(item.into()))
79 pub(crate) fn add_keyword(&mut self, ctx: &CompletionContext, keyword: &'static str) {
80 let item = CompletionItem::new(CompletionItemKind::Keyword, ctx.source_range(), keyword);
84 pub(crate) fn add_resolution(
86 ctx: &CompletionContext,
87 local_name: hir::Name,
88 resolution: hir::ScopeDef,
90 if ctx.is_scope_def_hidden(resolution) {
91 cov_mark::hit!(qualified_path_doc_hidden);
94 self.add(render_resolution(RenderContext::new(ctx), local_name, resolution));
97 pub(crate) fn add_macro(
99 ctx: &CompletionContext,
100 name: Option<hir::Name>,
101 macro_: hir::MacroDef,
103 let name = match name {
107 self.add(render_macro(RenderContext::new(ctx), None, name, macro_));
110 pub(crate) fn add_function(
112 ctx: &CompletionContext,
114 local_name: Option<hir::Name>,
116 if !ctx.is_visible(&func) {
119 self.add(render_fn(RenderContext::new(ctx), None, local_name, func));
122 pub(crate) fn add_method(
124 ctx: &CompletionContext,
126 receiver: Option<hir::Name>,
127 local_name: Option<hir::Name>,
129 if !ctx.is_visible(&func) {
132 self.add(render_method(RenderContext::new(ctx), None, receiver, local_name, func));
135 pub(crate) fn add_const(&mut self, ctx: &CompletionContext, konst: hir::Const) {
136 if !ctx.is_visible(&konst) {
139 self.add_opt(render_const(RenderContext::new(ctx), konst));
142 pub(crate) fn add_type_alias(&mut self, ctx: &CompletionContext, type_alias: hir::TypeAlias) {
143 if !ctx.is_visible(&type_alias) {
146 self.add_opt(render_type_alias(RenderContext::new(ctx), type_alias));
149 pub(crate) fn add_type_alias_with_eq(
151 ctx: &CompletionContext,
152 type_alias: hir::TypeAlias,
154 self.add_opt(render_type_alias_with_eq(RenderContext::new(ctx), type_alias));
157 pub(crate) fn add_qualified_enum_variant(
159 ctx: &CompletionContext,
160 variant: hir::Variant,
163 let item = render_variant(RenderContext::new(ctx), None, None, variant, Some(path));
167 pub(crate) fn add_enum_variant(
169 ctx: &CompletionContext,
170 variant: hir::Variant,
171 local_name: Option<hir::Name>,
173 let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
177 pub(crate) fn add_field(
179 ctx: &CompletionContext,
180 receiver: Option<hir::Name>,
184 if !ctx.is_visible(&field) {
187 let item = render_field(RenderContext::new(ctx), receiver, field, ty);
191 pub(crate) fn add_struct_literal(
193 ctx: &CompletionContext,
195 path: Option<hir::ModPath>,
196 local_name: Option<hir::Name>,
198 let item = render_struct_literal(RenderContext::new(ctx), strukt, path, local_name);
202 pub(crate) fn add_tuple_field(
204 ctx: &CompletionContext,
205 receiver: Option<hir::Name>,
209 let item = render_tuple_field(RenderContext::new(ctx), receiver, field, ty);
213 pub(crate) fn add_static_lifetime(&mut self, ctx: &CompletionContext) {
214 let item = CompletionItem::new(SymbolKind::LifetimeParam, ctx.source_range(), "'static");
215 self.add(item.build());
218 pub(crate) fn add_variant_pat(
220 ctx: &CompletionContext,
221 variant: hir::Variant,
222 local_name: Option<hir::Name>,
224 self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, local_name, None));
227 pub(crate) fn add_qualified_variant_pat(
229 ctx: &CompletionContext,
230 variant: hir::Variant,
233 self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, None, Some(path)));
236 pub(crate) fn add_struct_pat(
238 ctx: &CompletionContext,
240 local_name: Option<hir::Name>,
242 self.add_opt(render_struct_pat(RenderContext::new(ctx), strukt, local_name));
246 /// Calls the callback for each variant of the provided enum with the path to the variant.
247 /// Skips variants that are visible with single segment paths.
248 fn enum_variants_with_paths(
249 acc: &mut Completions,
250 ctx: &CompletionContext,
252 cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath),
254 let variants = enum_.variants(ctx.db);
256 let module = if let Some(module) = ctx.scope.module() {
257 // Compute path from the completion site if available.
260 // Otherwise fall back to the enum's definition site.
264 if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
265 if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_)) {
266 for &variant in &variants {
267 let self_path = hir::ModPath::from_segments(
268 hir::PathKind::Plain,
269 iter::once(known::SELF_TYPE).chain(iter::once(variant.name(ctx.db))),
271 cb(acc, ctx, variant, self_path);
276 for variant in variants {
277 if let Some(path) = module.find_use_path(ctx.db, hir::ModuleDef::from(variant)) {
278 // Variants with trivial paths are already added by the existing completion logic,
279 // so we should avoid adding these twice
280 if path.segments().len() > 1 {
281 cb(acc, ctx, variant, path);