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;
9 pub(crate) mod macro_in_item_position;
11 pub(crate) mod pattern;
12 pub(crate) mod postfix;
13 pub(crate) mod qualified_path;
14 pub(crate) mod record;
15 pub(crate) mod snippet;
16 pub(crate) mod trait_impl;
17 pub(crate) mod unqualified_path;
22 use ide_db::SymbolKind;
25 item::{Builder, CompletionKind},
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 type_alias::render_type_alias,
36 CompletionContext, CompletionItem, CompletionItemKind,
39 /// Represents an in-progress set of completions being built.
40 #[derive(Debug, Default)]
41 pub struct Completions {
42 buf: Vec<CompletionItem>,
45 impl Into<Vec<CompletionItem>> for Completions {
46 fn into(self) -> Vec<CompletionItem> {
52 /// Convenience method, which allows to add a freshly created completion into accumulator
53 /// without binding it to the variable.
54 pub(crate) fn add_to(self, acc: &mut Completions) {
60 pub(crate) fn add(&mut self, item: CompletionItem) {
64 pub(crate) fn add_all<I>(&mut self, items: I)
67 I::Item: Into<CompletionItem>,
69 items.into_iter().for_each(|item| self.add(item.into()))
72 pub(crate) fn add_field(
74 ctx: &CompletionContext,
75 receiver: Option<hir::Name>,
79 let item = render_field(RenderContext::new(ctx), receiver, field, ty);
83 pub(crate) fn add_tuple_field(
85 ctx: &CompletionContext,
86 receiver: Option<hir::Name>,
90 let item = render_tuple_field(RenderContext::new(ctx), receiver, field, ty);
94 pub(crate) fn add_static_lifetime(&mut self, ctx: &CompletionContext) {
96 CompletionItem::new(CompletionKind::Reference, ctx.source_range(), "'static");
97 item.kind(CompletionItemKind::SymbolKind(SymbolKind::LifetimeParam));
98 self.add(item.build());
101 pub(crate) fn add_resolution(
103 ctx: &CompletionContext,
104 local_name: hir::Name,
105 resolution: &hir::ScopeDef,
107 if let Some(item) = render_resolution(RenderContext::new(ctx), local_name, resolution) {
112 pub(crate) fn add_macro(
114 ctx: &CompletionContext,
115 name: Option<hir::Name>,
116 macro_: hir::MacroDef,
118 let name = match name {
122 if let Some(item) = render_macro(RenderContext::new(ctx), None, name, macro_) {
127 pub(crate) fn add_function(
129 ctx: &CompletionContext,
131 local_name: Option<hir::Name>,
133 if let Some(item) = render_fn(RenderContext::new(ctx), None, local_name, func) {
138 pub(crate) fn add_method(
140 ctx: &CompletionContext,
142 receiver: Option<hir::Name>,
143 local_name: Option<hir::Name>,
145 if let Some(item) = render_method(RenderContext::new(ctx), None, receiver, local_name, func)
151 pub(crate) fn add_variant_pat(
153 ctx: &CompletionContext,
154 variant: hir::Variant,
155 local_name: Option<hir::Name>,
157 if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, local_name, None) {
162 pub(crate) fn add_qualified_variant_pat(
164 ctx: &CompletionContext,
165 variant: hir::Variant,
168 if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, None, Some(path)) {
173 pub(crate) fn add_struct_pat(
175 ctx: &CompletionContext,
177 local_name: Option<hir::Name>,
179 if let Some(item) = render_struct_pat(RenderContext::new(ctx), strukt, local_name) {
184 pub(crate) fn add_const(&mut self, ctx: &CompletionContext, constant: hir::Const) {
185 if let Some(item) = render_const(RenderContext::new(ctx), constant) {
190 pub(crate) fn add_type_alias(&mut self, ctx: &CompletionContext, type_alias: hir::TypeAlias) {
191 if let Some(item) = render_type_alias(RenderContext::new(ctx), type_alias) {
196 pub(crate) fn add_qualified_enum_variant(
198 ctx: &CompletionContext,
199 variant: hir::Variant,
202 let item = render_variant(RenderContext::new(ctx), None, None, variant, Some(path));
206 pub(crate) fn add_enum_variant(
208 ctx: &CompletionContext,
209 variant: hir::Variant,
210 local_name: Option<hir::Name>,
212 let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
217 fn complete_enum_variants(
218 acc: &mut Completions,
219 ctx: &CompletionContext,
220 enum_data: hir::Enum,
221 cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath),
223 let variants = enum_data.variants(ctx.db);
225 let module = if let Some(module) = ctx.scope.module() {
226 // Compute path from the completion site if available.
229 // Otherwise fall back to the enum's definition site.
230 enum_data.module(ctx.db)
233 if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
234 if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_data)) {
235 for &variant in &variants {
236 let self_path = hir::ModPath::from_segments(
237 hir::PathKind::Plain,
238 iter::once(known::SELF_TYPE).chain(iter::once(variant.name(ctx.db))),
240 cb(acc, ctx, variant, self_path);
245 for variant in variants {
246 if let Some(path) = module.find_use_path(ctx.db, hir::ModuleDef::from(variant)) {
247 // Variants with trivial paths are already added by the existing completion logic,
248 // so we should avoid adding these twice
249 if path.segments().len() > 1 {
250 cb(acc, ctx, variant, path);