language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-02 06:41:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Merge #9195

Browse source 
9195: minor: Simplify r=Veykril a=Veykril

bors r+

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>
This commit is contained in:
bors[bot] 2021-06-09 21:45:35 +00:00 • committed by GitHub
commit c6133fe51c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 181 additions and 211 deletions
Download patch file Download diff file Expand all files Collapse all files

160
crates/ide_completion/src/render.rs
View file

@ -24,34 +24,34 @@ use crate::{
CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance, CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance,
}; };
pub(crate) fn render_field<'a>( pub(crate) fn render_field(
ctx: RenderContext<'a>, ctx: RenderContext<'_>,
receiver: Option<hir::Name>, receiver: Option<hir::Name>,
field: hir::Field, field: hir::Field,
ty: &hir::Type, ty: &hir::Type,
) -> CompletionItem { ) -> CompletionItem {
Render::new(ctx).render_field(receiver, field, ty) render_field_(ctx, receiver, field, ty)
} }
pub(crate) fn render_tuple_field<'a>( pub(crate) fn render_tuple_field(
ctx: RenderContext<'a>, ctx: RenderContext<'_>,
receiver: Option<hir::Name>, receiver: Option<hir::Name>,
field: usize, field: usize,
ty: &hir::Type, ty: &hir::Type,
) -> CompletionItem { ) -> CompletionItem {
Render::new(ctx).render_tuple_field(receiver, field, ty) render_tuple_field_(ctx, receiver, field, ty)
} }
pub(crate) fn render_resolution<'a>( pub(crate) fn render_resolution(
ctx: RenderContext<'a>, ctx: RenderContext<'_>,
local_name: hir::Name, local_name: hir::Name,
resolution: &hir::ScopeDef, resolution: &hir::ScopeDef,
) -> Option<CompletionItem> { ) -> Option<CompletionItem> {
Render::new(ctx).render_resolution(local_name, None, resolution) render_resolution_(ctx, local_name, None, resolution)
} }
pub(crate) fn render_resolution_with_import<'a>( pub(crate) fn render_resolution_with_import(
ctx: RenderContext<'a>, ctx: RenderContext<'_>,
import_edit: ImportEdit, import_edit: ImportEdit,
) -> Option<CompletionItem> { ) -> Option<CompletionItem> {
let resolution = hir::ScopeDef::from(import_edit.import.original_item); let resolution = hir::ScopeDef::from(import_edit.import.original_item);
@ -64,12 +64,10 @@ pub(crate) fn render_resolution_with_import<'a>(
hir::ScopeDef::ModuleDef(hir::ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db), hir::ScopeDef::ModuleDef(hir::ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db),
_ => item_name(ctx.db(), import_edit.import.original_item)?, _ => item_name(ctx.db(), import_edit.import.original_item)?,
}; };
Render::new(ctx).render_resolution(local_name, Some(import_edit), &resolution).map( render_resolution_(ctx, local_name, Some(import_edit), &resolution).map(|mut item| {
|mut item| {
item.completion_kind = CompletionKind::Magic; item.completion_kind = CompletionKind::Magic;
item item
}, })
)
} }
/// Interface for data and methods required for items rendering. /// Interface for data and methods required for items rendering.
@ -121,42 +119,31 @@ impl<'a> RenderContext<'a> {
} }
} }
/// Generic renderer for completion items. fn render_field_(
#[derive(Debug)] ctx: RenderContext<'_>,
struct Render<'a> {
ctx: RenderContext<'a>,
}
impl<'a> Render<'a> {
fn new(ctx: RenderContext<'a>) -> Render<'a> {
Render { ctx }
}
fn render_field(
&self,
receiver: Option<hir::Name>, receiver: Option<hir::Name>,
field: hir::Field, field: hir::Field,
ty: &hir::Type, ty: &hir::Type,
) -> CompletionItem { ) -> CompletionItem {
let is_deprecated = self.ctx.is_deprecated(field); let is_deprecated = ctx.is_deprecated(field);
let name = field.name(self.ctx.db()).to_string(); let name = field.name(ctx.db()).to_string();
let mut item = CompletionItem::new( let mut item = CompletionItem::new(
CompletionKind::Reference, CompletionKind::Reference,
self.ctx.source_range(), ctx.source_range(),
receiver.map_or_else(|| name.clone(), |receiver| format!("{}.{}", receiver, name)), receiver.map_or_else(|| name.clone(), |receiver| format!("{}.{}", receiver, name)),
); );
item.kind(SymbolKind::Field) item.kind(SymbolKind::Field)
.detail(ty.display(self.ctx.db()).to_string()) .detail(ty.display(ctx.db()).to_string())
.set_documentation(field.docs(self.ctx.db())) .set_documentation(field.docs(ctx.db()))
.set_deprecated(is_deprecated); .set_deprecated(is_deprecated);
item.set_relevance(CompletionRelevance { item.set_relevance(CompletionRelevance {
type_match: compute_type_match(self.ctx.completion, ty), type_match: compute_type_match(ctx.completion, ty),
exact_name_match: compute_exact_name_match(self.ctx.completion, &name), exact_name_match: compute_exact_name_match(ctx.completion, &name),
..CompletionRelevance::default() ..CompletionRelevance::default()
}); });
if let Some(_ref_match) = compute_ref_match(self.ctx.completion, ty) { if let Some(_ref_match) = compute_ref_match(ctx.completion, ty) {
// FIXME // FIXME
// For now we don't properly calculate the edits for ref match // For now we don't properly calculate the edits for ref match
// completions on struct fields, so we've disabled them. See #8058. // completions on struct fields, so we've disabled them. See #8058.
@ -165,26 +152,25 @@ impl<'a> Render<'a> {
item.build() item.build()
} }
fn render_tuple_field( fn render_tuple_field_(
&self, ctx: RenderContext<'_>,
receiver: Option<hir::Name>, receiver: Option<hir::Name>,
field: usize, field: usize,
ty: &hir::Type, ty: &hir::Type,
) -> CompletionItem { ) -> CompletionItem {
let mut item = CompletionItem::new( let mut item = CompletionItem::new(
CompletionKind::Reference, CompletionKind::Reference,
self.ctx.source_range(), ctx.source_range(),
receiver receiver.map_or_else(|| field.to_string(), |receiver| format!("{}.{}", receiver, field)),
.map_or_else(|| field.to_string(), |receiver| format!("{}.{}", receiver, field)),
); );
item.kind(SymbolKind::Field).detail(ty.display(self.ctx.db()).to_string()); item.kind(SymbolKind::Field).detail(ty.display(ctx.db()).to_string());
item.build() item.build()
} }
fn render_resolution( fn render_resolution_(
self, ctx: RenderContext<'_>,
local_name: hir::Name, local_name: hir::Name,
import_to_add: Option<ImportEdit>, import_to_add: Option<ImportEdit>,
resolution: &hir::ScopeDef, resolution: &hir::ScopeDef,
@ -199,39 +185,29 @@ impl<'a> Render<'a> {
let kind = match resolution { let kind = match resolution {
hir::ScopeDef::ModuleDef(Function(func)) => { hir::ScopeDef::ModuleDef(Function(func)) => {
return render_fn(self.ctx, import_to_add, Some(local_name), *func); return render_fn(ctx, import_to_add, Some(local_name), *func);
} }
hir::ScopeDef::ModuleDef(Variant(_)) hir::ScopeDef::ModuleDef(Variant(_)) if ctx.completion.is_pat_or_const.is_some() => {
if self.ctx.completion.is_pat_or_const.is_some() =>
{
CompletionItemKind::SymbolKind(SymbolKind::Variant) CompletionItemKind::SymbolKind(SymbolKind::Variant)
} }
hir::ScopeDef::ModuleDef(Variant(var)) => { hir::ScopeDef::ModuleDef(Variant(var)) => {
let item = render_variant(self.ctx, import_to_add, Some(local_name), *var, None); let item = render_variant(ctx, import_to_add, Some(local_name), *var, None);
return Some(item); return Some(item);
} }
hir::ScopeDef::MacroDef(mac) => { hir::ScopeDef::MacroDef(mac) => {
let item = render_macro(self.ctx, import_to_add, local_name, *mac); let item = render_macro(ctx, import_to_add, local_name, *mac);
return item; return item;
} }
hir::ScopeDef::ModuleDef(Module(..)) => { hir::ScopeDef::ModuleDef(Module(..)) => CompletionItemKind::SymbolKind(SymbolKind::Module),
CompletionItemKind::SymbolKind(SymbolKind::Module)
}
hir::ScopeDef::ModuleDef(Adt(adt)) => CompletionItemKind::SymbolKind(match adt { hir::ScopeDef::ModuleDef(Adt(adt)) => CompletionItemKind::SymbolKind(match adt {
hir::Adt::Struct(_) => SymbolKind::Struct, hir::Adt::Struct(_) => SymbolKind::Struct,
hir::Adt::Union(_) => SymbolKind::Union, hir::Adt::Union(_) => SymbolKind::Union,
hir::Adt::Enum(_) => SymbolKind::Enum, hir::Adt::Enum(_) => SymbolKind::Enum,
}), }),
hir::ScopeDef::ModuleDef(Const(..)) => { hir::ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::SymbolKind(SymbolKind::Const),
CompletionItemKind::SymbolKind(SymbolKind::Const) hir::ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::SymbolKind(SymbolKind::Static),
} hir::ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::SymbolKind(SymbolKind::Trait),
hir::ScopeDef::ModuleDef(Static(..)) => {
CompletionItemKind::SymbolKind(SymbolKind::Static)
}
hir::ScopeDef::ModuleDef(Trait(..)) => {
CompletionItemKind::SymbolKind(SymbolKind::Trait)
}
hir::ScopeDef::ModuleDef(TypeAlias(..)) => { hir::ScopeDef::ModuleDef(TypeAlias(..)) => {
CompletionItemKind::SymbolKind(SymbolKind::TypeAlias) CompletionItemKind::SymbolKind(SymbolKind::TypeAlias)
} }
@ -249,7 +225,7 @@ impl<'a> Render<'a> {
hir::ScopeDef::Unknown => { hir::ScopeDef::Unknown => {
let mut item = CompletionItem::new( let mut item = CompletionItem::new(
CompletionKind::Reference, CompletionKind::Reference,
self.ctx.source_range(), ctx.source_range(),
local_name.to_string(), local_name.to_string(),
); );
item.kind(CompletionItemKind::UnresolvedReference).add_import(import_to_add); item.kind(CompletionItemKind::UnresolvedReference).add_import(import_to_add);
@ -258,40 +234,35 @@ impl<'a> Render<'a> {
}; };
let local_name = local_name.to_string(); let local_name = local_name.to_string();
let mut item = let mut item = CompletionItem::new(completion_kind, ctx.source_range(), local_name.clone());
CompletionItem::new(completion_kind, self.ctx.source_range(), local_name.clone());
if let hir::ScopeDef::Local(local) = resolution { if let hir::ScopeDef::Local(local) = resolution {
let ty = local.ty(self.ctx.db()); let ty = local.ty(ctx.db());
if !ty.is_unknown() { if !ty.is_unknown() {
item.detail(ty.display(self.ctx.db()).to_string()); item.detail(ty.display(ctx.db()).to_string());
} }
item.set_relevance(CompletionRelevance { item.set_relevance(CompletionRelevance {
type_match: compute_type_match(self.ctx.completion, &ty), type_match: compute_type_match(ctx.completion, &ty),
exact_name_match: compute_exact_name_match(self.ctx.completion, &local_name), exact_name_match: compute_exact_name_match(ctx.completion, &local_name),
is_local: true, is_local: true,
..CompletionRelevance::default() ..CompletionRelevance::default()
}); });
if let Some(ref_match) = compute_ref_match(self.ctx.completion, &ty) { if let Some(ref_match) = compute_ref_match(ctx.completion, &ty) {
item.ref_match(ref_match); item.ref_match(ref_match);
} }
}; };
// Add `<>` for generic types // Add `<>` for generic types
if matches!( if matches!(
self.ctx.completion.path_context, ctx.completion.path_context,
Some(PathCompletionContext { kind: Some(PathKind::Type), has_type_args: false, .. }) Some(PathCompletionContext { kind: Some(PathKind::Type), has_type_args: false, .. })
) && self.ctx.completion.config.add_call_parenthesis ) && ctx.completion.config.add_call_parenthesis
{ {
if let Some(cap) = self.ctx.snippet_cap() { if let Some(cap) = ctx.snippet_cap() {
let has_non_default_type_params = match resolution { let has_non_default_type_params = match resolution {
hir::ScopeDef::ModuleDef(Adt(it)) => { hir::ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(ctx.db()),
it.has_non_default_type_params(self.ctx.db()) hir::ScopeDef::ModuleDef(TypeAlias(it)) => it.has_non_default_type_params(ctx.db()),
}
hir::ScopeDef::ModuleDef(TypeAlias(it)) => {
it.has_non_default_type_params(self.ctx.db())
}
_ => false, _ => false,
}; };
if has_non_default_type_params { if has_non_default_type_params {
@ -304,35 +275,34 @@ impl<'a> Render<'a> {
} }
item.kind(kind) item.kind(kind)
.add_import(import_to_add) .add_import(import_to_add)
.set_documentation(self.docs(resolution)) .set_documentation(scope_def_docs(ctx.db(), resolution))
.set_deprecated(self.is_deprecated(resolution)); .set_deprecated(scope_def_is_deprecated(&ctx, resolution));
Some(item.build()) Some(item.build())
} }
fn docs(&self, resolution: &hir::ScopeDef) -> Option<hir::Documentation> { fn scope_def_docs(db: &RootDatabase, resolution: &hir::ScopeDef) -> Option<hir::Documentation> {
use hir::ModuleDef::*; use hir::ModuleDef::*;
match resolution { match resolution {
hir::ScopeDef::ModuleDef(Module(it)) => it.docs(self.ctx.db()), hir::ScopeDef::ModuleDef(Module(it)) => it.docs(db),
hir::ScopeDef::ModuleDef(Adt(it)) => it.docs(self.ctx.db()), hir::ScopeDef::ModuleDef(Adt(it)) => it.docs(db),
hir::ScopeDef::ModuleDef(Variant(it)) => it.docs(self.ctx.db()), hir::ScopeDef::ModuleDef(Variant(it)) => it.docs(db),
hir::ScopeDef::ModuleDef(Const(it)) => it.docs(self.ctx.db()), hir::ScopeDef::ModuleDef(Const(it)) => it.docs(db),
hir::ScopeDef::ModuleDef(Static(it)) => it.docs(self.ctx.db()), hir::ScopeDef::ModuleDef(Static(it)) => it.docs(db),
hir::ScopeDef::ModuleDef(Trait(it)) => it.docs(self.ctx.db()), hir::ScopeDef::ModuleDef(Trait(it)) => it.docs(db),
hir::ScopeDef::ModuleDef(TypeAlias(it)) => it.docs(self.ctx.db()), hir::ScopeDef::ModuleDef(TypeAlias(it)) => it.docs(db),
_ => None, _ => None,
} }
} }
fn is_deprecated(&self, resolution: &hir::ScopeDef) -> bool { fn scope_def_is_deprecated(ctx: &RenderContext<'_>, resolution: &hir::ScopeDef) -> bool {
match resolution { match resolution {
hir::ScopeDef::ModuleDef(it) => self.ctx.is_deprecated_assoc_item(*it), hir::ScopeDef::ModuleDef(it) => ctx.is_deprecated_assoc_item(*it),
hir::ScopeDef::MacroDef(it) => self.ctx.is_deprecated(*it), hir::ScopeDef::MacroDef(it) => ctx.is_deprecated(*it),
hir::ScopeDef::GenericParam(it) => self.ctx.is_deprecated(*it), hir::ScopeDef::GenericParam(it) => ctx.is_deprecated(*it),
hir::ScopeDef::AdtSelfType(it) => self.ctx.is_deprecated(*it), hir::ScopeDef::AdtSelfType(it) => ctx.is_deprecated(*it),
_ => false, _ => false,
} }
} }
}
fn compute_type_match( fn compute_type_match(
ctx: &CompletionContext, ctx: &CompletionContext,