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;
21 use ide_db::SymbolKind;
24 item::{Builder, CompletionKind},
27 enum_variant::render_variant,
28 function::{render_fn, render_method},
30 pattern::{render_struct_pat, render_variant_pat},
31 render_field, render_resolution, render_tuple_field,
32 type_alias::{render_type_alias, render_type_alias_with_eq},
35 CompletionContext, CompletionItem, CompletionItemKind,
38 /// Represents an in-progress set of completions being built.
39 #[derive(Debug, Default)]
40 pub struct Completions {
41 buf: Vec<CompletionItem>,
44 impl From<Completions> for Vec<CompletionItem> {
45 fn from(val: Completions) -> Self {
51 /// Convenience method, which allows to add a freshly created completion into accumulator
52 /// without binding it to the variable.
53 pub(crate) fn add_to(self, acc: &mut Completions) {
59 fn add(&mut self, item: CompletionItem) {
63 fn add_opt(&mut self, item: Option<CompletionItem>) {
64 if let Some(item) = item {
69 pub(crate) fn add_all<I>(&mut self, items: I)
72 I::Item: Into<CompletionItem>,
74 items.into_iter().for_each(|item| self.add(item.into()))
77 pub(crate) fn add_keyword(&mut self, ctx: &CompletionContext, keyword: &'static str) {
78 let mut item = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), keyword);
79 item.kind(CompletionItemKind::Keyword);
83 pub(crate) fn add_resolution(
85 ctx: &CompletionContext,
86 local_name: hir::Name,
87 resolution: &hir::ScopeDef,
89 self.add_opt(render_resolution(RenderContext::new(ctx), local_name, resolution));
92 pub(crate) fn add_macro(
94 ctx: &CompletionContext,
95 name: Option<hir::Name>,
96 macro_: hir::MacroDef,
98 let name = match name {
102 self.add_opt(render_macro(RenderContext::new(ctx), None, name, macro_));
105 pub(crate) fn add_function(
107 ctx: &CompletionContext,
109 local_name: Option<hir::Name>,
111 self.add_opt(render_fn(RenderContext::new(ctx), None, local_name, func));
114 pub(crate) fn add_method(
116 ctx: &CompletionContext,
118 receiver: Option<hir::Name>,
119 local_name: Option<hir::Name>,
121 self.add_opt(render_method(RenderContext::new(ctx), None, receiver, local_name, func));
124 pub(crate) fn add_const(&mut self, ctx: &CompletionContext, constant: hir::Const) {
125 self.add_opt(render_const(RenderContext::new(ctx), constant));
128 pub(crate) fn add_type_alias(&mut self, ctx: &CompletionContext, type_alias: hir::TypeAlias) {
129 self.add_opt(render_type_alias(RenderContext::new(ctx), type_alias));
132 pub(crate) fn add_type_alias_with_eq(
134 ctx: &CompletionContext,
135 type_alias: hir::TypeAlias,
137 self.add_opt(render_type_alias_with_eq(RenderContext::new(ctx), type_alias));
140 pub(crate) fn add_qualified_enum_variant(
142 ctx: &CompletionContext,
143 variant: hir::Variant,
146 let item = render_variant(RenderContext::new(ctx), None, None, variant, Some(path));
150 pub(crate) fn add_enum_variant(
152 ctx: &CompletionContext,
153 variant: hir::Variant,
154 local_name: Option<hir::Name>,
156 let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
160 pub(crate) fn add_field(
162 ctx: &CompletionContext,
163 receiver: Option<hir::Name>,
167 let item = render_field(RenderContext::new(ctx), receiver, field, ty);
171 pub(crate) fn add_tuple_field(
173 ctx: &CompletionContext,
174 receiver: Option<hir::Name>,
178 let item = render_tuple_field(RenderContext::new(ctx), receiver, field, ty);
182 pub(crate) fn add_static_lifetime(&mut self, ctx: &CompletionContext) {
184 CompletionItem::new(CompletionKind::Reference, ctx.source_range(), "'static");
185 item.kind(CompletionItemKind::SymbolKind(SymbolKind::LifetimeParam));
186 self.add(item.build());
189 pub(crate) fn add_variant_pat(
191 ctx: &CompletionContext,
192 variant: hir::Variant,
193 local_name: Option<hir::Name>,
195 self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, local_name, None));
198 pub(crate) fn add_qualified_variant_pat(
200 ctx: &CompletionContext,
201 variant: hir::Variant,
204 self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, None, Some(path)));
207 pub(crate) fn add_struct_pat(
209 ctx: &CompletionContext,
211 local_name: Option<hir::Name>,
213 self.add_opt(render_struct_pat(RenderContext::new(ctx), strukt, local_name));
217 /// Calls the callback for each variant of the provided enum with the path to the variant.
218 /// Skips variants that are visible with single segment paths.
219 fn enum_variants_with_paths(
220 acc: &mut Completions,
221 ctx: &CompletionContext,
223 cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath),
225 let variants = enum_.variants(ctx.db);
227 let module = if let Some(module) = ctx.scope.module() {
228 // Compute path from the completion site if available.
231 // Otherwise fall back to the enum's definition site.
235 if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
236 if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_)) {
237 for &variant in &variants {
238 let self_path = hir::ModPath::from_segments(
239 hir::PathKind::Plain,
240 iter::once(known::SELF_TYPE).chain(iter::once(variant.name(ctx.db))),
242 cb(acc, ctx, variant, self_path);
247 for variant in variants {
248 if let Some(path) = module.find_use_path(ctx.db, hir::ModuleDef::from(variant)) {
249 // Variants with trivial paths are already added by the existing completion logic,
250 // so we should avoid adding these twice
251 if path.segments().len() > 1 {
252 cb(acc, ctx, variant, path);