squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Move unprefixed field/method completion to dot

Browse source
This commit is contained in:
Lukas Wirth 2021-05-28 15:09:10 +02:00
parent d346f5bf75
commit 4507382f2e
3 changed files with 101 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
crates/ide_completion/src/completions.rs
View file

@ -18,10 +18,8 @@ pub(crate) mod unqualified_path;
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},
@ -254,44 +252,3 @@ fn complete_enum_variants(
}
}
}
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::<()>
});
}
}

103
crates/ide_completion/src/completions/dot.rs
View file

@ -1,6 +1,8 @@
//! Completes references after dot (fields and method calls).
use either::Either;
use hir::{HasVisibility, ScopeDef};
use rustc_hash::FxHashSet;
use crate::{context::CompletionContext, Completions};
@ -8,7 +10,7 @@ use crate::{context::CompletionContext, Completions};
pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
let dot_receiver = match &ctx.dot_receiver {
Some(expr) => expr,
_ => return,
_ => return complete_undotted_self(acc, ctx),
};
let receiver_ty = match ctx.sema.type_of_expr(&dot_receiver) {
@ -19,12 +21,77 @@ pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
if ctx.is_call {
cov_mark::hit!(test_no_struct_field_completion_for_method_call);
} else {
super::complete_fields(ctx, &receiver_ty, |field, ty| match field {
complete_fields(ctx, &receiver_ty, |field, ty| match field {
Either::Left(field) => acc.add_field(ctx, None, field, &ty),
Either::Right(tuple_idx) => acc.add_tuple_field(ctx, None, tuple_idx, &ty),
});
}
super::complete_methods(ctx, &receiver_ty, |func| acc.add_method(ctx, func, None, None));
complete_methods(ctx, &receiver_ty, |func| acc.add_method(ctx, func, None, None));
}
fn complete_undotted_self(acc: &mut Completions, ctx: &CompletionContext) {
if !ctx.is_trivial_path {
return;
}
ctx.scope.process_all_names(&mut |name, def| {
if let ScopeDef::Local(local) = &def {
if local.is_self(ctx.db) {
let ty = local.ty(ctx.db);
complete_fields(ctx, &ty, |field, ty| match field {
either::Either::Left(field) => {
acc.add_field(ctx, Some(name.clone()), field, &ty)
}
either::Either::Right(tuple_idx) => {
acc.add_tuple_field(ctx, Some(name.clone()), tuple_idx, &ty)
}
});
complete_methods(ctx, &ty, |func| {
acc.add_method(ctx, func, Some(name.clone()), None)
});
}
}
});
}
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::<()>
});
}
}
#[cfg(test)]
@ -453,4 +520,34 @@ impl S {
"#]],
);
}
#[test]
fn completes_bare_fields_and_methods_in_methods() {
check(
r#"
struct Foo { field: i32 }
impl Foo { fn foo(&self) { $0 } }"#,
expect![[r#"
lc self &Foo
sp Self
st Foo
fd self.field i32
me self.foo() fn(&self)
"#]],
);
check(
r#"
struct Foo(i32);
impl Foo { fn foo(&mut self) { $0 } }"#,
expect![[r#"
lc self &mut Foo
sp Self
st Foo
fd self.0 i32
me self.foo() fn(&mut self)
"#]],
);
}
}

46
crates/ide_completion/src/completions/unqualified_path.rs
View file

@ -47,22 +47,6 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
cov_mark::hit!(skip_lifetime_completion);
return;
}
if let ScopeDef::Local(local) = &res {
if local.is_self(ctx.db) {
let ty = local.ty(ctx.db);
super::complete_fields(ctx, &ty, |field, ty| match field {
either::Either::Left(field) => {
acc.add_field(ctx, Some(name.clone()), field, &ty)
}
either::Either::Right(tuple_idx) => {
acc.add_tuple_field(ctx, Some(name.clone()), tuple_idx, &ty)
}
});
super::complete_methods(ctx, &ty, |func| {
acc.add_method(ctx, func, Some(name.clone()), None)
});
}
}
acc.add_resolution(ctx, name, &res);
});
}
@ -393,36 +377,6 @@ fn foo() {
);
}
#[test]
fn completes_qualified_fields_and_methods_in_methods() {
check(
r#"
struct Foo { field: i32 }
impl Foo { fn foo(&self) { $0 } }"#,
expect![[r#"
fd self.field i32
me self.foo() fn(&self)
lc self &Foo
sp Self
st Foo
"#]],
);
check(
r#"
struct Foo(i32);
impl Foo { fn foo(&mut self) { $0 } }"#,
expect![[r#"
fd self.0 i32
me self.foo() fn(&mut self)
lc self &mut Foo
sp Self
st Foo
"#]],
);
}
#[test]
fn completes_prelude() {
check(