pub(crate) mod fn_param;
pub(crate) mod keyword;
pub(crate) mod lifetime;
-pub(crate) mod macro_in_item_position;
pub(crate) mod mod_;
pub(crate) mod pattern;
pub(crate) mod postfix;
pub(crate) mod snippet;
pub(crate) mod trait_impl;
pub(crate) mod unqualified_path;
+pub(crate) mod format_string;
use std::iter;
-use either::Either;
-use hir::{known, HasVisibility};
+use hir::known;
use ide_db::SymbolKind;
-use rustc_hash::FxHashSet;
use crate::{
- item::{Builder, CompletionKind},
+ item::Builder,
render::{
const_::render_const,
enum_variant::render_variant,
macro_::render_macro,
pattern::{render_struct_pat, render_variant_pat},
render_field, render_resolution, render_tuple_field,
- type_alias::render_type_alias,
+ struct_literal::render_struct_literal,
+ type_alias::{render_type_alias, render_type_alias_with_eq},
RenderContext,
},
CompletionContext, CompletionItem, CompletionItemKind,
buf: Vec<CompletionItem>,
}
-impl Into<Vec<CompletionItem>> for Completions {
- fn into(self) -> Vec<CompletionItem> {
- self.buf
+impl From<Completions> for Vec<CompletionItem> {
+ fn from(val: Completions) -> Self {
+ val.buf
}
}
}
impl Completions {
- pub(crate) fn add(&mut self, item: CompletionItem) {
+ fn add(&mut self, item: CompletionItem) {
self.buf.push(item)
}
+ fn add_opt(&mut self, item: Option<CompletionItem>) {
+ if let Some(item) = item {
+ self.buf.push(item)
+ }
+ }
+
pub(crate) fn add_all<I>(&mut self, items: I)
where
I: IntoIterator,
items.into_iter().for_each(|item| self.add(item.into()))
}
- pub(crate) fn add_field(
- &mut self,
- ctx: &CompletionContext,
- receiver: Option<hir::Name>,
- field: hir::Field,
- ty: &hir::Type,
- ) {
- let item = render_field(RenderContext::new(ctx), receiver, field, ty);
- self.add(item);
- }
-
- pub(crate) fn add_tuple_field(
- &mut self,
- ctx: &CompletionContext,
- receiver: Option<hir::Name>,
- field: usize,
- ty: &hir::Type,
- ) {
- let item = render_tuple_field(RenderContext::new(ctx), receiver, field, ty);
- self.add(item);
- }
-
- pub(crate) fn add_static_lifetime(&mut self, ctx: &CompletionContext) {
- let mut item =
- CompletionItem::new(CompletionKind::Reference, ctx.source_range(), "'static");
- item.kind(CompletionItemKind::SymbolKind(SymbolKind::LifetimeParam));
- self.add(item.build());
+ pub(crate) fn add_keyword(&mut self, ctx: &CompletionContext, keyword: &'static str) {
+ let item = CompletionItem::new(CompletionItemKind::Keyword, ctx.source_range(), keyword);
+ item.add_to(self);
}
pub(crate) fn add_resolution(
&mut self,
ctx: &CompletionContext,
local_name: hir::Name,
- resolution: &hir::ScopeDef,
+ resolution: hir::ScopeDef,
) {
- if let Some(item) = render_resolution(RenderContext::new(ctx), local_name, resolution) {
- self.add(item);
+ if ctx.is_scope_def_hidden(resolution) {
+ cov_mark::hit!(qualified_path_doc_hidden);
+ return;
}
+ self.add(render_resolution(RenderContext::new(ctx), local_name, resolution));
}
pub(crate) fn add_macro(
Some(it) => it,
None => return,
};
- if let Some(item) = render_macro(RenderContext::new(ctx), None, name, macro_) {
- self.add(item);
- }
+ self.add(render_macro(RenderContext::new(ctx), None, name, macro_));
}
pub(crate) fn add_function(
func: hir::Function,
local_name: Option<hir::Name>,
) {
- if let Some(item) = render_fn(RenderContext::new(ctx), None, local_name, func) {
- self.add(item)
+ if !ctx.is_visible(&func) {
+ return;
}
+ self.add(render_fn(RenderContext::new(ctx), None, local_name, func));
}
pub(crate) fn add_method(
receiver: Option<hir::Name>,
local_name: Option<hir::Name>,
) {
- if let Some(item) = render_method(RenderContext::new(ctx), None, receiver, local_name, func)
- {
- self.add(item)
+ if !ctx.is_visible(&func) {
+ return;
}
+ self.add(render_method(RenderContext::new(ctx), None, receiver, local_name, func));
}
- pub(crate) fn add_variant_pat(
+ pub(crate) fn add_const(&mut self, ctx: &CompletionContext, konst: hir::Const) {
+ if !ctx.is_visible(&konst) {
+ return;
+ }
+ self.add_opt(render_const(RenderContext::new(ctx), konst));
+ }
+
+ pub(crate) fn add_type_alias(&mut self, ctx: &CompletionContext, type_alias: hir::TypeAlias) {
+ if !ctx.is_visible(&type_alias) {
+ return;
+ }
+ self.add_opt(render_type_alias(RenderContext::new(ctx), type_alias));
+ }
+
+ pub(crate) fn add_type_alias_with_eq(
&mut self,
ctx: &CompletionContext,
- variant: hir::Variant,
- local_name: Option<hir::Name>,
+ type_alias: hir::TypeAlias,
) {
- if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, local_name, None) {
- self.add(item);
- }
+ self.add_opt(render_type_alias_with_eq(RenderContext::new(ctx), type_alias));
}
- pub(crate) fn add_qualified_variant_pat(
+ pub(crate) fn add_qualified_enum_variant(
&mut self,
ctx: &CompletionContext,
variant: hir::Variant,
path: hir::ModPath,
) {
- if let Some(item) = render_variant_pat(RenderContext::new(ctx), variant, None, Some(path)) {
- self.add(item);
+ let item = render_variant(RenderContext::new(ctx), None, None, variant, Some(path));
+ self.add(item);
+ }
+
+ pub(crate) fn add_enum_variant(
+ &mut self,
+ ctx: &CompletionContext,
+ variant: hir::Variant,
+ local_name: Option<hir::Name>,
+ ) {
+ let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
+ self.add(item);
+ }
+
+ pub(crate) fn add_field(
+ &mut self,
+ ctx: &CompletionContext,
+ receiver: Option<hir::Name>,
+ field: hir::Field,
+ ty: &hir::Type,
+ ) {
+ if !ctx.is_visible(&field) {
+ return;
}
+ let item = render_field(RenderContext::new(ctx), receiver, field, ty);
+ self.add(item);
}
- pub(crate) fn add_struct_pat(
+ pub(crate) fn add_struct_literal(
&mut self,
ctx: &CompletionContext,
strukt: hir::Struct,
+ path: Option<hir::ModPath>,
local_name: Option<hir::Name>,
) {
- if let Some(item) = render_struct_pat(RenderContext::new(ctx), strukt, local_name) {
- self.add(item);
- }
+ let item = render_struct_literal(RenderContext::new(ctx), strukt, path, local_name);
+ self.add_opt(item);
}
- pub(crate) fn add_const(&mut self, ctx: &CompletionContext, constant: hir::Const) {
- if let Some(item) = render_const(RenderContext::new(ctx), constant) {
- self.add(item);
- }
+ pub(crate) fn add_tuple_field(
+ &mut self,
+ ctx: &CompletionContext,
+ receiver: Option<hir::Name>,
+ field: usize,
+ ty: &hir::Type,
+ ) {
+ let item = render_tuple_field(RenderContext::new(ctx), receiver, field, ty);
+ self.add(item);
}
- pub(crate) fn add_type_alias(&mut self, ctx: &CompletionContext, type_alias: hir::TypeAlias) {
- if let Some(item) = render_type_alias(RenderContext::new(ctx), type_alias) {
- self.add(item)
- }
+ pub(crate) fn add_static_lifetime(&mut self, ctx: &CompletionContext) {
+ let item = CompletionItem::new(SymbolKind::LifetimeParam, ctx.source_range(), "'static");
+ self.add(item.build());
}
- pub(crate) fn add_qualified_enum_variant(
+ pub(crate) fn add_variant_pat(
&mut self,
ctx: &CompletionContext,
variant: hir::Variant,
- path: hir::ModPath,
+ local_name: Option<hir::Name>,
) {
- let item = render_variant(RenderContext::new(ctx), None, None, variant, Some(path));
- self.add(item);
+ self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, local_name, None));
}
- pub(crate) fn add_enum_variant(
+ pub(crate) fn add_qualified_variant_pat(
&mut self,
ctx: &CompletionContext,
variant: hir::Variant,
+ path: hir::ModPath,
+ ) {
+ self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, None, Some(path)));
+ }
+
+ pub(crate) fn add_struct_pat(
+ &mut self,
+ ctx: &CompletionContext,
+ strukt: hir::Struct,
local_name: Option<hir::Name>,
) {
- let item = render_variant(RenderContext::new(ctx), None, local_name, variant, None);
- self.add(item);
+ self.add_opt(render_struct_pat(RenderContext::new(ctx), strukt, local_name));
}
}
-fn complete_enum_variants(
+/// Calls the callback for each variant of the provided enum with the path to the variant.
+/// Skips variants that are visible with single segment paths.
+fn enum_variants_with_paths(
acc: &mut Completions,
ctx: &CompletionContext,
- enum_data: hir::Enum,
+ enum_: hir::Enum,
cb: impl Fn(&mut Completions, &CompletionContext, hir::Variant, hir::ModPath),
) {
- let variants = enum_data.variants(ctx.db);
+ let variants = enum_.variants(ctx.db);
- let module = if let Some(module) = ctx.scope.module() {
+ let module = if let Some(module) = ctx.module {
// Compute path from the completion site if available.
module
} else {
// Otherwise fall back to the enum's definition site.
- enum_data.module(ctx.db)
+ enum_.module(ctx.db)
};
if let Some(impl_) = ctx.impl_def.as_ref().and_then(|impl_| ctx.sema.to_def(impl_)) {
- if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_data)) {
+ if impl_.self_ty(ctx.db).as_adt() == Some(hir::Adt::Enum(enum_)) {
for &variant in &variants {
let self_path = hir::ModPath::from_segments(
hir::PathKind::Plain,
}
}
}
-
-fn complete_fields(
- ctx: &CompletionContext,
- receiver: &hir::Type,
- mut f: impl FnMut(Either<hir::Field, usize>, hir::Type),
-) {
- for receiver in receiver.autoderef(ctx.db) {
- for (field, ty) in receiver.fields(ctx.db) {
- if ctx.scope.module().map_or(false, |m| !field.is_visible_from(ctx.db, m)) {
- // Skip private field. FIXME: If the definition location of the
- // field is editable, we should show the completion
- continue;
- }
- f(Either::Left(field), ty);
- }
- for (i, ty) in receiver.tuple_fields(ctx.db).into_iter().enumerate() {
- // FIXME: Handle visibility
- f(Either::Right(i), ty);
- }
- }
-}
-
-fn complete_methods(
- ctx: &CompletionContext,
- receiver: &hir::Type,
- mut f: impl FnMut(hir::Function),
-) {
- if let Some(krate) = ctx.krate {
- let mut seen_methods = FxHashSet::default();
- let traits_in_scope = ctx.scope.traits_in_scope();
- receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
- if func.self_param(ctx.db).is_some()
- && ctx.scope.module().map_or(true, |m| func.is_visible_from(ctx.db, m))
- && seen_methods.insert(func.name(ctx.db))
- {
- f(func);
- }
- None::<()>
- });
- }
-}
projects / rust.git / blobdiff