Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2025-01-25 19:35:06 +00:00
Code Issues Projects Releases Packages Wiki Activity

Allow excluding specific traits from completion

Browse source 
To be accurate, only their methods are excluded, the trait themselves are still available.

I also excluded a bunch of std traits by default. Some less opinionated, like `AsRef`, which should never be used directly except in generic scenarios (and won't be excluded there), some more opinionated, like the ops traits, which I know some users sometimes want to use directly. Either way it's configurable.

It should be pretty easy to extend support to excluding only specific methods, but I didn't do that currently.

Traits configured to be excluded are resolved in each completion request from scratch. If this proves too expensive, it is easy enough to cache them in the DB.
This commit is contained in:
Chayim Refael Friedman 2024-09-24 19:24:15 +03:00 committed by Lukas Wirth
parent c86dd17cb3
commit 7e6ade117c
18 changed files with 1012 additions and 83 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
crates/hir-def/src/item_scope.rs
View file

@ -354,6 +354,13 @@ impl ItemScope {
.chain(self.unnamed_trait_imports.keys().copied())
}
pub fn trait_by_name(&self, name: &Name) -> Option<TraitId> {
self.types.get(name).and_then(|def| match def.def {
ModuleDefId::TraitId(it) => Some(it),
_ => None,
})
}
pub(crate) fn resolutions(&self) -> impl Iterator<Item = (Option<Name>, PerNs)> + '_ {
self.entries().map(|(name, res)| (Some(name.clone()), res)).chain(
self.unnamed_trait_imports.iter().map(|(tr, trait_)| {

69
crates/hir-ty/src/method_resolution.rs
View file

@ -913,7 +913,7 @@ pub fn iterate_path_candidates(
traits_in_scope: &FxHashSet<TraitId>,
visible_from_module: VisibleFromModule,
name: Option<&Name>,
callback: &mut dyn FnMut(AssocItemId) -> ControlFlow<()>,
callback: &mut dyn MethodCandidateCallback,
) -> ControlFlow<()> {
iterate_method_candidates_dyn(
ty,
@ -924,7 +924,7 @@ pub fn iterate_path_candidates(
name,
LookupMode::Path,
// the adjustments are not relevant for path lookup
&mut |_, id, _| callback(id),
callback,
)
}
@ -936,7 +936,7 @@ pub fn iterate_method_candidates_dyn(
visible_from_module: VisibleFromModule,
name: Option<&Name>,
mode: LookupMode,
callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
callback: &mut dyn MethodCandidateCallback,
) -> ControlFlow<()> {
let _p = tracing::info_span!(
"iterate_method_candidates_dyn",
@ -1006,7 +1006,7 @@ fn iterate_method_candidates_with_autoref(
traits_in_scope: &FxHashSet<TraitId>,
visible_from_module: VisibleFromModule,
name: Option<&Name>,
mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
callback: &mut dyn MethodCandidateCallback,
) -> ControlFlow<()> {
if receiver_ty.value.is_general_var(Interner, &receiver_ty.binders) {
// don't try to resolve methods on unknown types
@ -1021,7 +1021,7 @@ fn iterate_method_candidates_with_autoref(
traits_in_scope,
visible_from_module,
name,
&mut callback,
callback,
)
};
@ -1051,6 +1051,45 @@ fn iterate_method_candidates_with_autoref(
iterate_method_candidates_by_receiver(ref_muted, first_adjustment.with_autoref(Mutability::Mut))
}
pub trait MethodCandidateCallback {
fn on_inherent_method(
&mut self,
adjustments: ReceiverAdjustments,
item: AssocItemId,
is_visible: bool,
) -> ControlFlow<()>;
fn on_trait_method(
&mut self,
adjustments: ReceiverAdjustments,
item: AssocItemId,
is_visible: bool,
) -> ControlFlow<()>;
}
impl<F> MethodCandidateCallback for F
where
F: FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
{
fn on_inherent_method(
&mut self,
adjustments: ReceiverAdjustments,
item: AssocItemId,
is_visible: bool,
) -> ControlFlow<()> {
self(adjustments, item, is_visible)
}
fn on_trait_method(
&mut self,
adjustments: ReceiverAdjustments,
item: AssocItemId,
is_visible: bool,
) -> ControlFlow<()> {
self(adjustments, item, is_visible)
}
}
#[tracing::instrument(skip_all, fields(name = ?name))]
fn iterate_method_candidates_by_receiver(
table: &mut InferenceTable<'_>,
@ -1059,7 +1098,7 @@ fn iterate_method_candidates_by_receiver(
traits_in_scope: &FxHashSet<TraitId>,
visible_from_module: VisibleFromModule,
name: Option<&Name>,
mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
callback: &mut dyn MethodCandidateCallback,
) -> ControlFlow<()> {
let receiver_ty = table.instantiate_canonical(receiver_ty);
// We're looking for methods with *receiver* type receiver_ty. These could
@ -1075,7 +1114,9 @@ fn iterate_method_candidates_by_receiver(
Some(&receiver_ty),
Some(receiver_adjustments.clone()),
visible_from_module,
&mut callback,
&mut |adjustments, item, is_visible| {
callback.on_inherent_method(adjustments, item, is_visible)
},
)?
}
ControlFlow::Continue(())
@ -1095,7 +1136,9 @@ fn iterate_method_candidates_by_receiver(
name,
Some(&receiver_ty),
Some(receiver_adjustments.clone()),
&mut callback,
&mut |adjustments, item, is_visible| {
callback.on_trait_method(adjustments, item, is_visible)
},
)?
}
ControlFlow::Continue(())
@ -1110,7 +1153,7 @@ fn iterate_method_candidates_for_self_ty(
traits_in_scope: &FxHashSet<TraitId>,
visible_from_module: VisibleFromModule,
name: Option<&Name>,
mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
callback: &mut dyn MethodCandidateCallback,
) -> ControlFlow<()> {
let mut table = InferenceTable::new(db, env);
let self_ty = table.instantiate_canonical(self_ty.clone());
@ -1121,7 +1164,9 @@ fn iterate_method_candidates_for_self_ty(
None,
None,
visible_from_module,
&mut callback,
&mut |adjustments, item, is_visible| {
callback.on_inherent_method(adjustments, item, is_visible)
},
)?;
iterate_trait_method_candidates(
&self_ty,
@ -1130,7 +1175,9 @@ fn iterate_method_candidates_for_self_ty(
name,
None,
None,
callback,
&mut |adjustments, item, is_visible| {
callback.on_trait_method(adjustments, item, is_visible)
},
)
}

2
crates/hir/src/attrs.rs
View file

@ -258,7 +258,7 @@ fn resolve_impl_trait_item(
&traits_in_scope,
method_resolution::VisibleFromModule::None,
Some(name),
&mut |assoc_item_id| {
&mut |_, assoc_item_id: AssocItemId, _| {
// If two traits in scope define the same item, Rustdoc links to no specific trait (for
// instance, given two methods `a`, Rustdoc simply links to `method.a` with no
// disambiguation) so we just pick the first one we find as well.

180
crates/hir/src/lib.rs
View file

@ -5219,28 +5219,49 @@ impl Type {
traits_in_scope: &FxHashSet<TraitId>,
with_local_impls: Option<Module>,
name: Option<&Name>,
mut callback: impl FnMut(Function) -> Option<T>,
callback: impl FnMut(Function) -> Option<T>,
) -> Option<T> {
let _p = tracing::info_span!("iterate_method_candidates_with_traits").entered();
let mut slot = None;
struct Callback<T, F> {
f: F,
slot: Option<T>,
}
impl<T, F> MethodCandidateCallback for &'_ mut Callback<T, F>
where
F: FnMut(Function) -> Option<T>,
{
fn on_inherent_method(&mut self, f: Function) -> ControlFlow<()> {
match (self.f)(f) {
it @ Some(_) => {
self.slot = it;
ControlFlow::Break(())
}
None => ControlFlow::Continue(()),
}
}
self.iterate_method_candidates_dyn(
fn on_trait_method(&mut self, f: Function) -> ControlFlow<()> {
match (self.f)(f) {
it @ Some(_) => {
self.slot = it;
ControlFlow::Break(())
}
None => ControlFlow::Continue(()),
}
}
}
let _p = tracing::info_span!("iterate_method_candidates_with_traits").entered();
let mut callback = Callback { slot: None, f: callback };
self.iterate_method_candidates_split_inherent(
db,
scope,
traits_in_scope,
with_local_impls,
name,
&mut |assoc_item_id| {
if let AssocItemId::FunctionId(func) = assoc_item_id {
if let Some(res) = callback(func.into()) {
slot = Some(res);
return ControlFlow::Break(());
}
}
ControlFlow::Continue(())
},
&mut callback,
);
slot
callback.slot
}
pub fn iterate_method_candidates<T>(
@ -5261,15 +5282,49 @@ impl Type {
)
}
fn iterate_method_candidates_dyn(
/// Allows you to treat inherent and non-inherent methods differently.
///
/// Note that inherent methods may actually be trait methods! For example, in `dyn Trait`, the trait's methods
/// are considered inherent methods.
pub fn iterate_method_candidates_split_inherent(
&self,
db: &dyn HirDatabase,
scope: &SemanticsScope<'_>,
traits_in_scope: &FxHashSet<TraitId>,
with_local_impls: Option<Module>,
name: Option<&Name>,
callback: &mut dyn FnMut(AssocItemId) -> ControlFlow<()>,
callback: impl MethodCandidateCallback,
) {
struct Callback<T>(T);
impl<T: MethodCandidateCallback> method_resolution::MethodCandidateCallback for Callback<T> {
fn on_inherent_method(
&mut self,
_adjustments: method_resolution::ReceiverAdjustments,
item: AssocItemId,
_is_visible: bool,
) -> ControlFlow<()> {
if let AssocItemId::FunctionId(func) = item {
self.0.on_inherent_method(func.into())
} else {
ControlFlow::Continue(())
}
}
fn on_trait_method(
&mut self,
_adjustments: method_resolution::ReceiverAdjustments,
item: AssocItemId,
_is_visible: bool,
) -> ControlFlow<()> {
if let AssocItemId::FunctionId(func) = item {
self.0.on_trait_method(func.into())
} else {
ControlFlow::Continue(())
}
}
}
let _p = tracing::info_span!(
"iterate_method_candidates_dyn",
with_local_impls = traits_in_scope.len(),
@ -5294,7 +5349,7 @@ impl Type {
with_local_impls.and_then(|b| b.id.containing_block()).into(),
name,
method_resolution::LookupMode::MethodCall,
&mut |_adj, id, _| callback(id),
&mut Callback(callback),
);
}
@ -5306,37 +5361,88 @@ impl Type {
traits_in_scope: &FxHashSet<TraitId>,
with_local_impls: Option<Module>,
name: Option<&Name>,
mut callback: impl FnMut(AssocItem) -> Option<T>,
callback: impl FnMut(AssocItem) -> Option<T>,
) -> Option<T> {
struct Callback<T, F> {
f: F,
slot: Option<T>,
}
impl<T, F> PathCandidateCallback for &'_ mut Callback<T, F>
where
F: FnMut(AssocItem) -> Option<T>,
{
fn on_inherent_item(&mut self, item: AssocItem) -> ControlFlow<()> {
match (self.f)(item) {
it @ Some(_) => {
self.slot = it;
ControlFlow::Break(())
}
None => ControlFlow::Continue(()),
}
}
fn on_trait_item(&mut self, item: AssocItem) -> ControlFlow<()> {
match (self.f)(item) {
it @ Some(_) => {
self.slot = it;
ControlFlow::Break(())
}
None => ControlFlow::Continue(()),
}
}
}
let _p = tracing::info_span!("iterate_path_candidates").entered();
let mut slot = None;
self.iterate_path_candidates_dyn(
let mut callback = Callback { slot: None, f: callback };
self.iterate_path_candidates_split_inherent(
db,
scope,
traits_in_scope,
with_local_impls,
name,
&mut |assoc_item_id| {
if let Some(res) = callback(assoc_item_id.into()) {
slot = Some(res);
return ControlFlow::Break(());
}
ControlFlow::Continue(())
},
&mut callback,
);
slot
callback.slot
}
/// Iterates over inherent methods.
///
/// In some circumstances, inherent methods methods may actually be trait methods!
/// For example, when `dyn Trait` is a receiver, _trait_'s methods would be considered
/// to be inherent methods.
#[tracing::instrument(skip_all, fields(name = ?name))]
fn iterate_path_candidates_dyn(
pub fn iterate_path_candidates_split_inherent(
&self,
db: &dyn HirDatabase,
scope: &SemanticsScope<'_>,
traits_in_scope: &FxHashSet<TraitId>,
with_local_impls: Option<Module>,
name: Option<&Name>,
callback: &mut dyn FnMut(AssocItemId) -> ControlFlow<()>,
callback: impl PathCandidateCallback,
) {
struct Callback<T>(T);
impl<T: PathCandidateCallback> method_resolution::MethodCandidateCallback for Callback<T> {
fn on_inherent_method(
&mut self,
_adjustments: method_resolution::ReceiverAdjustments,
item: AssocItemId,
_is_visible: bool,
) -> ControlFlow<()> {
self.0.on_inherent_item(item.into())
}
fn on_trait_method(
&mut self,
_adjustments: method_resolution::ReceiverAdjustments,
item: AssocItemId,
_is_visible: bool,
) -> ControlFlow<()> {
self.0.on_trait_item(item.into())
}
}
let canonical = hir_ty::replace_errors_with_variables(&self.ty);
let krate = scope.krate();
@ -5352,7 +5458,7 @@ impl Type {
traits_in_scope,
with_local_impls.and_then(|b| b.id.containing_block()).into(),
name,
callback,
&mut Callback(callback),
);
}
@ -6054,3 +6160,15 @@ fn push_ty_diagnostics(
);
}
}
pub trait MethodCandidateCallback {
fn on_inherent_method(&mut self, f: Function) -> ControlFlow<()>;
fn on_trait_method(&mut self, f: Function) -> ControlFlow<()>;
}
pub trait PathCandidateCallback {
fn on_inherent_item(&mut self, item: AssocItem) -> ControlFlow<()>;
fn on_trait_item(&mut self, item: AssocItem) -> ControlFlow<()>;
}

56
crates/ide-completion/src/completions/dot.rs
View file

@ -1,6 +1,8 @@
//! Completes references after dot (fields and method calls).
use hir::{sym, Name};
use std::ops::ControlFlow;
use hir::{sym, HasContainer, ItemContainer, MethodCandidateCallback, Name};
use ide_db::FxHashSet;
use syntax::SmolStr;
@ -158,21 +160,55 @@ fn complete_fields(
fn complete_methods(
ctx: &CompletionContext<'_>,
receiver: &hir::Type,
mut f: impl FnMut(hir::Function),
f: impl FnMut(hir::Function),
) {
let mut seen_methods = FxHashSet::default();
receiver.iterate_method_candidates_with_traits(
struct Callback<'a, F> {
ctx: &'a CompletionContext<'a>,
f: F,
seen_methods: FxHashSet<Name>,
}
impl<F> MethodCandidateCallback for Callback<'_, F>
where
F: FnMut(hir::Function),
{
// We don't want to exclude inherent trait methods - that is, methods of traits available from
// `where` clauses or `dyn Trait`.
fn on_inherent_method(&mut self, func: hir::Function) -> ControlFlow<()> {
if func.self_param(self.ctx.db).is_some()
&& self.seen_methods.insert(func.name(self.ctx.db))
{
(self.f)(func);
}
ControlFlow::Continue(())
}
fn on_trait_method(&mut self, func: hir::Function) -> ControlFlow<()> {
// This needs to come before the `seen_methods` test, so that if we see the same method twice,
// once as inherent and once not, we will include it.
if let ItemContainer::Trait(trait_) = func.container(self.ctx.db) {
if self.ctx.exclude_traits.contains(&trait_) {
return ControlFlow::Continue(());
}
}
if func.self_param(self.ctx.db).is_some()
&& self.seen_methods.insert(func.name(self.ctx.db))
{
(self.f)(func);
}
ControlFlow::Continue(())
}
}
receiver.iterate_method_candidates_split_inherent(
ctx.db,
&ctx.scope,
&ctx.traits_in_scope(),
Some(ctx.module),
None,
|func| {
if func.self_param(ctx.db).is_some() && seen_methods.insert(func.name(ctx.db)) {
f(func);
}
None::<()>
},
Callback { ctx, f, seen_methods: FxHashSet::default() },
);
}

80
crates/ide-completion/src/completions/expr.rs
View file

@ -1,6 +1,9 @@
//! Completion of names from the current scope in expression position.
use hir::{sym, Name, ScopeDef};
use std::ops::ControlFlow;
use hir::{sym, Name, PathCandidateCallback, ScopeDef};
use ide_db::FxHashSet;
use syntax::ast;
use crate::{
@ -9,6 +12,39 @@ use crate::{
CompletionContext, Completions,
};
struct PathCallback<'a, F> {
ctx: &'a CompletionContext<'a>,
acc: &'a mut Completions,
add_assoc_item: F,
seen: FxHashSet<hir::AssocItem>,
}
impl<F> PathCandidateCallback for PathCallback<'_, F>
where
F: FnMut(&mut Completions, hir::AssocItem),
{
fn on_inherent_item(&mut self, item: hir::AssocItem) -> ControlFlow<()> {
if self.seen.insert(item) {
(self.add_assoc_item)(self.acc, item);
}
ControlFlow::Continue(())
}
#[allow(unstable_name_collisions)] // FIXME: Remove this when `is_none_or()` reaches stable.
fn on_trait_item(&mut self, item: hir::AssocItem) -> ControlFlow<()> {
// The excluded check needs to come before the `seen` test, so that if we see the same method twice,
// once as inherent and once not, we will include it.
if item
.container_trait(self.ctx.db)
.is_none_or(|trait_| !self.ctx.exclude_traits.contains(&trait_))
&& self.seen.insert(item)
{
(self.add_assoc_item)(self.acc, item);
}
ControlFlow::Continue(())
}
}
pub(crate) fn complete_expr_path(
acc: &mut Completions,
ctx: &CompletionContext<'_>,
@ -50,12 +86,18 @@ pub(crate) fn complete_expr_path(
};
match qualified {
// We exclude associated types/consts of excluded traits here together with methods,
// even though we don't exclude them when completing in type position, because it's easier.
Qualified::TypeAnchor { ty: None, trait_: None } => ctx
.traits_in_scope()
.iter()
.flat_map(|&it| hir::Trait::from(it).items(ctx.sema.db))
.copied()
.map(hir::Trait::from)
.filter(|it| !ctx.exclude_traits.contains(it))
.flat_map(|it| it.items(ctx.sema.db))
.for_each(|item| add_assoc_item(acc, item)),
Qualified::TypeAnchor { trait_: Some(trait_), .. } => {
// Don't filter excluded traits here, user requested this specific trait.
trait_.items(ctx.sema.db).into_iter().for_each(|item| add_assoc_item(acc, item))
}
Qualified::TypeAnchor { ty: Some(ty), trait_: None } => {
@ -64,9 +106,14 @@ pub(crate) fn complete_expr_path(
acc.add_enum_variants(ctx, path_ctx, e);
}
ctx.iterate_path_candidates(ty, |item| {
add_assoc_item(acc, item);
});
ty.iterate_path_candidates_split_inherent(
ctx.db,
&ctx.scope,
&ctx.traits_in_scope(),
Some(ctx.module),
None,
PathCallback { ctx, acc, add_assoc_item, seen: FxHashSet::default() },
);
// Iterate assoc types separately
ty.iterate_assoc_items(ctx.db, ctx.krate, |item| {
@ -121,9 +168,14 @@ pub(crate) fn complete_expr_path(
// XXX: For parity with Rust bug #22519, this does not complete Ty::AssocType.
// (where AssocType is defined on a trait, not an inherent impl)
ctx.iterate_path_candidates(&ty, |item| {
add_assoc_item(acc, item);
});
ty.iterate_path_candidates_split_inherent(
ctx.db,
&ctx.scope,
&ctx.traits_in_scope(),
Some(ctx.module),
None,
PathCallback { ctx, acc, add_assoc_item, seen: FxHashSet::default() },
);
// Iterate assoc types separately
ty.iterate_assoc_items(ctx.db, ctx.krate, |item| {
@ -134,6 +186,7 @@ pub(crate) fn complete_expr_path(
});
}
hir::PathResolution::Def(hir::ModuleDef::Trait(t)) => {
// Don't filter excluded traits here, user requested this specific trait.
// Handles `Trait::assoc` as well as `<Ty as Trait>::assoc`.
for item in t.items(ctx.db) {
add_assoc_item(acc, item);
@ -151,9 +204,14 @@ pub(crate) fn complete_expr_path(
acc.add_enum_variants(ctx, path_ctx, e);
}
ctx.iterate_path_candidates(&ty, |item| {
add_assoc_item(acc, item);
});
ty.iterate_path_candidates_split_inherent(
ctx.db,
&ctx.scope,
&ctx.traits_in_scope(),
Some(ctx.module),
None,
PathCallback { ctx, acc, add_assoc_item, seen: FxHashSet::default() },
);
}
_ => (),
}

16
crates/ide-completion/src/completions/flyimport.rs
View file

@ -267,6 +267,15 @@ fn import_on_the_fly(
&& !ctx.is_item_hidden(original_item)
&& ctx.check_stability(original_item.attrs(ctx.db).as_deref())
})
.filter(|import| {
if let ModuleDef::Trait(trait_) = import.item_to_import.into_module_def() {
let excluded = ctx.exclude_flyimport_traits.contains(&trait_);
let trait_itself_imported = import.item_to_import == import.original_item;
!excluded || trait_itself_imported
} else {
true
}
})
.sorted_by(|a, b| {
let key = |import_path| {
(
@ -352,6 +361,13 @@ fn import_on_the_fly_method(
!ctx.is_item_hidden(&import.item_to_import)
&& !ctx.is_item_hidden(&import.original_item)
})
.filter(|import| {
if let ModuleDef::Trait(trait_) = import.item_to_import.into_module_def() {
!ctx.exclude_flyimport_traits.contains(&trait_)
} else {
true
}
})
.sorted_by(|a, b| {
let key = |import_path| {
(

6
crates/ide-completion/src/config.rs
View file

@ -10,7 +10,7 @@ use ide_db::{imports::insert_use::InsertUseConfig, SnippetCap};
use crate::{snippet::Snippet, CompletionFieldsToResolve};
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct CompletionConfig {
pub struct CompletionConfig<'a> {
pub enable_postfix_completions: bool,
pub enable_imports_on_the_fly: bool,
pub enable_self_on_the_fly: bool,
@ -28,6 +28,8 @@ pub struct CompletionConfig {
pub snippets: Vec<Snippet>,
pub limit: Option<usize>,
pub fields_to_resolve: CompletionFieldsToResolve,
pub exclude_flyimport_traits: &'a [String],
pub exclude_traits: &'a [String],
}
#[derive(Clone, Debug, PartialEq, Eq)]
@ -36,7 +38,7 @@ pub enum CallableSnippets {
AddParentheses,
}
impl CompletionConfig {
impl CompletionConfig<'_> {
pub fn postfix_snippets(&self) -> impl Iterator<Item = (&str, &Snippet)> {
self.snippets
.iter()

91
crates/ide-completion/src/context.rs
View file

@ -7,8 +7,8 @@ mod tests;
use std::{iter, ops::ControlFlow};
use hir::{
HasAttrs, Local, ModuleSource, Name, PathResolution, ScopeDef, Semantics, SemanticsScope,
Symbol, Type, TypeInfo,
db::DefDatabase, HasAttrs, Local, ModuleSource, Name, PathResolution, ScopeDef, Semantics,
SemanticsScope, Symbol, Type, TypeInfo,
};
use ide_db::{
base_db::SourceDatabase, famous_defs::FamousDefs, helpers::is_editable_crate, FilePosition,
@ -429,7 +429,7 @@ pub(crate) struct CompletionContext<'a> {
pub(crate) sema: Semantics<'a, RootDatabase>,
pub(crate) scope: SemanticsScope<'a>,
pub(crate) db: &'a RootDatabase,
pub(crate) config: &'a CompletionConfig,
pub(crate) config: &'a CompletionConfig<'a>,
pub(crate) position: FilePosition,
/// The token before the cursor, in the original file.
@ -462,6 +462,17 @@ pub(crate) struct CompletionContext<'a> {
/// Here depth will be 2
pub(crate) depth_from_crate_root: usize,
/// Traits whose methods will be excluded from flyimport. Flyimport should not suggest
/// importing those traits.
///
/// Note the trait *themselves* are not excluded, only their methods are.
pub(crate) exclude_flyimport_traits: FxHashSet<hir::Trait>,
/// Traits whose methods should always be excluded, even when in scope (compare `exclude_flyimport_traits`).
/// They will *not* be excluded, however, if they are available as a generic bound.
///
/// Note the trait *themselves* are not excluded, only their methods are.
pub(crate) exclude_traits: FxHashSet<hir::Trait>,
/// Whether and how to complete semicolon for unit-returning functions.
pub(crate) complete_semicolon: CompleteSemicolon,
}
@ -670,7 +681,7 @@ impl<'a> CompletionContext<'a> {
pub(crate) fn new(
db: &'a RootDatabase,
position @ FilePosition { file_id, offset }: FilePosition,
config: &'a CompletionConfig,
config: &'a CompletionConfig<'a>,
) -> Option<(CompletionContext<'a>, CompletionAnalysis)> {
let _p = tracing::info_span!("CompletionContext::new").entered();
let sema = Semantics::new(db);
@ -753,6 +764,11 @@ impl<'a> CompletionContext<'a> {
// exclude `m` itself
.saturating_sub(1);
let exclude_traits = resolve_exclude_traits_list(db, config.exclude_traits);
let mut exclude_flyimport_traits =
resolve_exclude_traits_list(db, config.exclude_flyimport_traits);
exclude_flyimport_traits.extend(exclude_traits.iter().copied());
let complete_semicolon = if config.add_semicolon_to_unit {
let inside_closure_ret = token.parent_ancestors().try_for_each(|ancestor| {
match_ast! {
@ -817,12 +833,79 @@ impl<'a> CompletionContext<'a> {
qualifier_ctx,
locals,
depth_from_crate_root,
exclude_flyimport_traits,
exclude_traits,
complete_semicolon,
};
Some((ctx, analysis))
}
}
fn resolve_exclude_traits_list(db: &RootDatabase, traits: &[String]) -> FxHashSet<hir::Trait> {
let _g = tracing::debug_span!("resolve_exclude_trait_list", ?traits).entered();
let crate_graph = db.crate_graph();
let mut crate_name_to_def_map = FxHashMap::default();
let mut result = FxHashSet::default();
'process_traits: for trait_ in traits {
let mut segments = trait_.split("::").peekable();
let Some(crate_name) = segments.next() else {
tracing::error!(
?trait_,
"error resolving trait from traits exclude list: invalid path"
);
continue;
};
let Some(def_map) = crate_name_to_def_map.entry(crate_name).or_insert_with(|| {
let krate = crate_graph
.iter()
.find(|&krate| crate_graph[krate].display_name.as_deref() == Some(crate_name));
let def_map = krate.map(|krate| db.crate_def_map(krate));
if def_map.is_none() {
tracing::error!(
"error resolving `{trait_}` from trait exclude lists: crate could not be found"
);
}
def_map
}) else {
// Do not report more than one error for the same crate.
continue;
};
let mut module = &def_map[hir::DefMap::ROOT];
let trait_name = 'lookup_mods: {
while let Some(segment) = segments.next() {
if segments.peek().is_none() {
break 'lookup_mods segment;
}
let Some(&inner) =
module.children.get(&Name::new_symbol_root(hir::Symbol::intern(segment)))
else {
tracing::error!(
"error resolving `{trait_}` from trait exclude lists: could not find module `{segment}`"
);
continue 'process_traits;
};
module = &def_map[inner];
}
tracing::error!("error resolving `{trait_}` from trait exclude lists: invalid path");
continue 'process_traits;
};
let resolved_trait = module
.scope
.trait_by_name(&Name::new_symbol_root(hir::Symbol::intern(trait_name)))
.map(hir::Trait::from);
let Some(resolved_trait) = resolved_trait else {
tracing::error!(
"error resolving `{trait_}` from trait exclude lists: trait could not be found"
);
continue;
};
result.insert(resolved_trait);
}
result
}
const OP_TRAIT_LANG_NAMES: &[&str] = &[
"add_assign",
"add",

4
crates/ide-completion/src/lib.rs
View file

@ -184,7 +184,7 @@ impl CompletionFieldsToResolve {
/// analysis.
pub fn completions(
db: &RootDatabase,
config: &CompletionConfig,
config: &CompletionConfig<'_>,
position: FilePosition,
trigger_character: Option<char>,
) -> Option<Vec<CompletionItem>> {
@ -269,7 +269,7 @@ pub fn completions(
/// This is used for import insertion done via completions like flyimport and custom user snippets.
pub fn resolve_completion_edits(
db: &RootDatabase,
config: &CompletionConfig,
config: &CompletionConfig<'_>,
FilePosition { file_id, offset }: FilePosition,
imports: impl IntoIterator<Item = (String, String)>,
) -> Option<Vec<TextEdit>> {

14
crates/ide-completion/src/tests.rs
View file

@ -61,7 +61,7 @@ fn function() {}
union Union { field: i32 }
"#;
pub(crate) const TEST_CONFIG: CompletionConfig = CompletionConfig {
pub(crate) const TEST_CONFIG: CompletionConfig<'_> = CompletionConfig {
enable_postfix_completions: true,
enable_imports_on_the_fly: true,
enable_self_on_the_fly: true,
@ -85,6 +85,8 @@ pub(crate) const TEST_CONFIG: CompletionConfig = CompletionConfig {
snippets: Vec::new(),
limit: None,
fields_to_resolve: CompletionFieldsToResolve::empty(),
exclude_flyimport_traits: &[],
exclude_traits: &[],
};
pub(crate) fn completion_list(ra_fixture: &str) -> String {
@ -109,7 +111,7 @@ pub(crate) fn completion_list_with_trigger_character(
}
fn completion_list_with_config_raw(
config: CompletionConfig,
config: CompletionConfig<'_>,
ra_fixture: &str,
include_keywords: bool,
trigger_character: Option<char>,
@ -132,7 +134,7 @@ fn completion_list_with_config_raw(
}
fn completion_list_with_config(
config: CompletionConfig,
config: CompletionConfig<'_>,
ra_fixture: &str,
include_keywords: bool,
trigger_character: Option<char>,
@ -161,7 +163,7 @@ pub(crate) fn do_completion(code: &str, kind: CompletionItemKind) -> Vec<Complet
}
pub(crate) fn do_completion_with_config(
config: CompletionConfig,
config: CompletionConfig<'_>,
code: &str,
kind: CompletionItemKind,
) -> Vec<CompletionItem> {
@ -220,7 +222,7 @@ pub(crate) fn check_edit(what: &str, ra_fixture_before: &str, ra_fixture_after:
#[track_caller]
pub(crate) fn check_edit_with_config(
config: CompletionConfig,
config: CompletionConfig<'_>,
what: &str,
ra_fixture_before: &str,
ra_fixture_after: &str,
@ -257,7 +259,7 @@ fn check_empty(ra_fixture: &str, expect: Expect) {
}
pub(crate) fn get_all_items(
config: CompletionConfig,
config: CompletionConfig<'_>,
code: &str,
trigger_character: Option<char>,
) -> Vec<CompletionItem> {

381
crates/ide-completion/src/tests/expression.rs
View file

@ -1,13 +1,29 @@
//! Completion tests for expressions.
use expect_test::{expect, Expect};
use crate::tests::{check_edit, check_empty, completion_list, BASE_ITEMS_FIXTURE};
use crate::{
tests::{
check_edit, check_empty, completion_list, completion_list_with_config, BASE_ITEMS_FIXTURE,
TEST_CONFIG,
},
CompletionConfig,
};
fn check(ra_fixture: &str, expect: Expect) {
let actual = completion_list(&format!("{BASE_ITEMS_FIXTURE}{ra_fixture}"));
expect.assert_eq(&actual)
}
fn check_with_config(config: CompletionConfig<'_>, ra_fixture: &str, expect: Expect) {
let actual = completion_list_with_config(
config,
&format!("{BASE_ITEMS_FIXTURE}{ra_fixture}"),
true,
None,
);
expect.assert_eq(&actual)
}
#[test]
fn complete_literal_struct_with_a_private_field() {
// `FooDesc.bar` is private, the completion should not be triggered.
@ -1390,3 +1406,366 @@ fn main() {
"#]],
);
}
#[test]
fn excluded_trait_method_is_excluded() {
check_with_config(
CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
r#"
trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
struct Foo;
impl Foo {
fn inherent(&self) {}
}
fn foo() {
Foo.$0
}
"#,
expect![[r#"
me inherent() fn(&self)
sn box Box::new(expr)
sn call function(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn deref *expr
sn let let
sn letm let mut
sn match match expr {}
sn ref &expr
sn refm &mut expr
sn return return expr
sn unsafe unsafe {}
"#]],
);
}
#[test]
fn excluded_trait_not_excluded_when_inherent() {
check_with_config(
CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
r#"
trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
fn foo(v: &dyn ExcludedTrait) {
v.$0
}
"#,
expect![[r#"
me bar() (as ExcludedTrait) fn(&self)
me baz() (as ExcludedTrait) fn(&self)
me foo() (as ExcludedTrait) fn(&self)
sn box Box::new(expr)
sn call function(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn deref *expr
sn let let
sn letm let mut
sn match match expr {}
sn ref &expr
sn refm &mut expr
sn return return expr
sn unsafe unsafe {}
"#]],
);
check_with_config(
CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
r#"
trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
fn foo(v: impl ExcludedTrait) {
v.$0
}
"#,
expect![[r#"
me bar() (as ExcludedTrait) fn(&self)
me baz() (as ExcludedTrait) fn(&self)
me foo() (as ExcludedTrait) fn(&self)
sn box Box::new(expr)
sn call function(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn deref *expr
sn let let
sn letm let mut
sn match match expr {}
sn ref &expr
sn refm &mut expr
sn return return expr
sn unsafe unsafe {}
"#]],
);
check_with_config(
CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
r#"
trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
fn foo<T: ExcludedTrait>(v: T) {
v.$0
}
"#,
expect![[r#"
me bar() (as ExcludedTrait) fn(&self)
me baz() (as ExcludedTrait) fn(&self)
me foo() (as ExcludedTrait) fn(&self)
sn box Box::new(expr)
sn call function(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn deref *expr
sn let let
sn letm let mut
sn match match expr {}
sn ref &expr
sn refm &mut expr
sn return return expr
sn unsafe unsafe {}
"#]],
);
}
#[test]
fn excluded_trait_method_is_excluded_from_flyimport() {
check_with_config(
CompletionConfig {
exclude_traits: &["test::module2::ExcludedTrait".to_owned()],
..TEST_CONFIG
},
r#"
mod module2 {
pub trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
}
struct Foo;
impl Foo {
fn inherent(&self) {}
}
fn foo() {
Foo.$0
}
"#,
expect![[r#"
me inherent() fn(&self)
sn box Box::new(expr)
sn call function(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn deref *expr
sn let let
sn letm let mut
sn match match expr {}
sn ref &expr
sn refm &mut expr
sn return return expr
sn unsafe unsafe {}
"#]],
);
}
#[test]
fn flyimport_excluded_trait_method_is_excluded_from_flyimport() {
check_with_config(
CompletionConfig {
exclude_flyimport_traits: &["test::module2::ExcludedTrait".to_owned()],
..TEST_CONFIG
},
r#"
mod module2 {
pub trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
}
struct Foo;
impl Foo {
fn inherent(&self) {}
}
fn foo() {
Foo.$0
}
"#,
expect![[r#"
me inherent() fn(&self)
sn box Box::new(expr)
sn call function(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn deref *expr
sn let let
sn letm let mut
sn match match expr {}
sn ref &expr
sn refm &mut expr
sn return return expr
sn unsafe unsafe {}
"#]],
);
}
#[test]
fn excluded_trait_method_is_excluded_from_path_completion() {
check_with_config(
CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
r#"
pub trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
struct Foo;
impl Foo {
fn inherent(&self) {}
}
fn foo() {
Foo::$0
}
"#,
expect![[r#"
me inherent(…) fn(&self)
"#]],
);
}
#[test]
fn excluded_trait_method_is_not_excluded_when_trait_is_specified() {
check_with_config(
CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
r#"
pub trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
struct Foo;
impl Foo {
fn inherent(&self) {}
}
fn foo() {
ExcludedTrait::$0
}
"#,
expect![[r#"
me bar(…) (as ExcludedTrait) fn(&self)
me baz(…) (as ExcludedTrait) fn(&self)
me foo(…) (as ExcludedTrait) fn(&self)
"#]],
);
check_with_config(
CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
r#"
pub trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
struct Foo;
impl Foo {
fn inherent(&self) {}
}
fn foo() {
<Foo as ExcludedTrait>::$0
}
"#,
expect![[r#"
me bar(…) (as ExcludedTrait) fn(&self)
me baz(…) (as ExcludedTrait) fn(&self)
me foo(…) (as ExcludedTrait) fn(&self)
"#]],
);
}
#[test]
fn excluded_trait_not_excluded_when_inherent_path() {
check_with_config(
CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
r#"
trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
fn foo() {
<dyn ExcludedTrait>::$0
}
"#,
expect![[r#"
me bar(…) (as ExcludedTrait) fn(&self)
me baz(…) (as ExcludedTrait) fn(&self)
me foo(…) (as ExcludedTrait) fn(&self)
"#]],
);
check_with_config(
CompletionConfig { exclude_traits: &["test::ExcludedTrait".to_owned()], ..TEST_CONFIG },
r#"
trait ExcludedTrait {
fn foo(&self) {}
fn bar(&self) {}
fn baz(&self) {}
}
impl<T> ExcludedTrait for T {}
fn foo<T: ExcludedTrait>() {
T::$0
}
"#,
expect![[r#"
me bar(…) (as ExcludedTrait) fn(&self)
me baz(…) (as ExcludedTrait) fn(&self)
me foo(…) (as ExcludedTrait) fn(&self)
"#]],
);
}

2
crates/ide-completion/src/tests/special.rs
View file

@ -1345,7 +1345,7 @@ struct Foo<T: PartialOrd
}
fn check_signatures(src: &str, kind: CompletionItemKind, reduced: Expect, full: Expect) {
const FULL_SIGNATURES_CONFIG: crate::CompletionConfig = {
const FULL_SIGNATURES_CONFIG: crate::CompletionConfig<'_> = {
let mut x = TEST_CONFIG;
x.full_function_signatures = true;
x

4
crates/ide/src/lib.rs
View file

@ -671,7 +671,7 @@ impl Analysis {
/// Computes completions at the given position.
pub fn completions(
&self,
config: &CompletionConfig,
config: &CompletionConfig<'_>,
position: FilePosition,
trigger_character: Option<char>,
) -> Cancellable<Option<Vec<CompletionItem>>> {
@ -683,7 +683,7 @@ impl Analysis {
/// Resolves additional completion data at the position given.
pub fn resolve_completion_edits(
&self,
config: &CompletionConfig,
config: &CompletionConfig<'_>,
position: FilePosition,
imports: impl IntoIterator<Item = (String, String)> + std::panic::UnwindSafe,
) -> Cancellable<Vec<TextEdit>> {

57
crates/rust-analyzer/src/config.rs
View file

@ -440,11 +440,64 @@ config_data! {
/// Toggles the additional completions that automatically add imports when completed.
/// Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
completion_autoimport_enable: bool = true,
/// A list of full paths to traits to exclude from flyimport.
///
/// Traits in this list won't be suggested to be imported by flyimport for their methods. Methods from them won't be available in flyimport completion. They will still be available if in scope.
///
/// Note that the trait themselves can still be suggested by flyimport.
///
/// This setting also inherits `#rust-analyzer.completion.excludeTraits#`.
///
/// This setting defaults to:
///
/// - [`core::borrow::Borrow`](https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html)
/// - [`core::borrow::BorrowMut`](https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html)
/// - [`core::cmp::PartialEq`](https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html)
/// - All operator traits (in [`core::ops`](https://doc.rust-lang.org/nightly/core/ops))
///
/// Note that if you override this setting, those traits won't be automatically inserted, so you may want to insert them manually.
completion_autoimport_excludeTraits: Vec<String> = vec![
"core::borrow::Borrow".to_owned(),
"core::borrow::BorrowMut".to_owned(),
"core::cmp::PartialEq".to_owned(),
"core::ops::Add".to_owned(),
"core::ops::AddAssign".to_owned(),
"core::ops::BitAnd".to_owned(),
"core::ops::BitAndAssign".to_owned(),
"core::ops::BitOr".to_owned(),
"core::ops::BitOrAssign".to_owned(),
"core::ops::BitXor".to_owned(),
"core::ops::BitXorAssign".to_owned(),
"core::ops::Div".to_owned(),
"core::ops::DivAssign".to_owned(),
"core::ops::Mul".to_owned(),
"core::ops::MulAssign".to_owned(),
"core::ops::Rem".to_owned(),
"core::ops::RemAssign".to_owned(),
"core::ops::Shl".to_owned(),
"core::ops::ShlAssign".to_owned(),
"core::ops::Shr".to_owned(),
"core::ops::ShrAssign".to_owned(),
"core::ops::Sub".to_owned(),
"core::ops::SubAssign".to_owned(),
"core::ops::Neg".to_owned(),
"core::ops::Not".to_owned(),
"core::ops::Index".to_owned(),
"core::ops::IndexMut".to_owned(),
"core::ops::Deref".to_owned(),
"core::ops::DerefMut".to_owned(),
],
/// Toggles the additional completions that automatically show method calls and field accesses
/// with `self` prefixed to them when inside a method.
completion_autoself_enable: bool = true,
/// Whether to add parenthesis and argument snippets when completing function.
completion_callable_snippets: CallableCompletionDef = CallableCompletionDef::FillArguments,
/// A list of full paths to traits to exclude from completion.
///
/// Methods from these traits won't be completed, even if the trait is in scope. However, they will still be suggested on expressions whose type is `dyn Trait`, `impl Trait` or `T where T: Trait`.
///
/// Note that the trait themselves can still be completed.
completion_excludeTraits: Vec<String> = Vec::new(),
/// Whether to show full function/method signatures in completion docs.
completion_fullFunctionSignatures_enable: bool = false,
/// Whether to omit deprecated items from autocompletion. By default they are marked as deprecated but not hidden.
@ -1431,7 +1484,7 @@ impl Config {
CallHierarchyConfig { exclude_tests: self.references_excludeTests().to_owned() }
}
pub fn completion(&self, source_root: Option<SourceRootId>) -> CompletionConfig {
pub fn completion(&self, source_root: Option<SourceRootId>) -> CompletionConfig<'_> {
let client_capability_fields = self.completion_resolve_support_properties();
CompletionConfig {
enable_postfix_completions: self.completion_postfix_enable(source_root).to_owned(),
@ -1462,6 +1515,8 @@ impl Config {
} else {
CompletionFieldsToResolve::from_client_capabilities(&client_capability_fields)
},
exclude_flyimport_traits: self.completion_autoimport_excludeTraits(source_root),
exclude_traits: self.completion_excludeTraits(source_root),
}
}

6
crates/rust-analyzer/src/integrated_benchmarks.rs
View file

@ -174,6 +174,8 @@ fn integrated_completion_benchmark() {
limit: None,
add_semicolon_to_unit: true,
fields_to_resolve: CompletionFieldsToResolve::empty(),
exclude_flyimport_traits: &[],
exclude_traits: &[],
};
let position =
FilePosition { file_id, offset: TextSize::try_from(completion_offset).unwrap() };
@ -222,6 +224,8 @@ fn integrated_completion_benchmark() {
limit: None,
add_semicolon_to_unit: true,
fields_to_resolve: CompletionFieldsToResolve::empty(),
exclude_flyimport_traits: &[],
exclude_traits: &[],
};
let position =
FilePosition { file_id, offset: TextSize::try_from(completion_offset).unwrap() };
@ -268,6 +272,8 @@ fn integrated_completion_benchmark() {
limit: None,
add_semicolon_to_unit: true,
fields_to_resolve: CompletionFieldsToResolve::empty(),
exclude_flyimport_traits: &[],
exclude_traits: &[],
};
let position =
FilePosition { file_id, offset: TextSize::try_from(completion_offset).unwrap() };

64
docs/user/generated_config.adoc
View file

@ -285,6 +285,61 @@ In `match` arms it completes a comma instead.
--
Toggles the additional completions that automatically add imports when completed.
Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.
--
[[rust-analyzer.completion.autoimport.excludeTraits]]rust-analyzer.completion.autoimport.excludeTraits::
+
--
Default:
----
[
"core::borrow::Borrow",
"core::borrow::BorrowMut",
"core::cmp::PartialEq",
"core::ops::Add",
"core::ops::AddAssign",
"core::ops::BitAnd",
"core::ops::BitAndAssign",
"core::ops::BitOr",
"core::ops::BitOrAssign",
"core::ops::BitXor",
"core::ops::BitXorAssign",
"core::ops::Div",
"core::ops::DivAssign",
"core::ops::Mul",
"core::ops::MulAssign",
"core::ops::Rem",
"core::ops::RemAssign",
"core::ops::Shl",
"core::ops::ShlAssign",
"core::ops::Shr",
"core::ops::ShrAssign",
"core::ops::Sub",
"core::ops::SubAssign",
"core::ops::Neg",
"core::ops::Not",
"core::ops::Index",
"core::ops::IndexMut",
"core::ops::Deref",
"core::ops::DerefMut"
]
----
A list of full paths to traits to exclude from flyimport.
Traits in this list won't be suggested to be imported by flyimport for their methods. Methods from them won't be available in flyimport completion. They will still be available if in scope.
Note that the trait themselves can still be suggested by flyimport.
This setting also inherits `#rust-analyzer.completion.excludeTraits#`.
This setting defaults to:
- [`core::borrow::Borrow`](https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html)
- [`core::borrow::BorrowMut`](https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html)
- [`core::cmp::PartialEq`](https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html)
- All operator traits (in [`core::ops`](https://doc.rust-lang.org/nightly/core/ops))
Note that if you override this setting, those traits won't be automatically inserted, so you may want to insert them manually.
--
[[rust-analyzer.completion.autoself.enable]]rust-analyzer.completion.autoself.enable (default: `true`)::
+
@ -297,6 +352,15 @@ with `self` prefixed to them when inside a method.
--
Whether to add parenthesis and argument snippets when completing function.
--
[[rust-analyzer.completion.excludeTraits]]rust-analyzer.completion.excludeTraits (default: `[]`)::
+
--
A list of full paths to traits to exclude from completion.
Methods from these traits won't be completed, even if the trait is in scope. However, they will still be suggested on expressions whose type is `dyn Trait`, `impl Trait` or `T where T: Trait`.
Note that the trait themselves can still be completed.
--
[[rust-analyzer.completion.fullFunctionSignatures.enable]]rust-analyzer.completion.fullFunctionSignatures.enable (default: `false`)::
+
--

56
editors/code/package.json
View file

@ -1139,6 +1139,49 @@
}
}
},
{
"title": "completion",
"properties": {
"rust-analyzer.completion.autoimport.excludeTraits": {
"markdownDescription": "A list of full paths to traits to exclude from flyimport.\n\nTraits in this list won't be suggested to be imported by flyimport for their methods. Methods from them won't be available in flyimport completion. They will still be available if in scope.\n\nNote that the trait themselves can still be suggested by flyimport.\n\nThis setting also inherits `#rust-analyzer.completion.excludeTraits#`.\n\nThis setting defaults to:\n\n - [`core::borrow::Borrow`](https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html)\n - [`core::borrow::BorrowMut`](https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html)\n - [`core::cmp::PartialEq`](https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html)\n - All operator traits (in [`core::ops`](https://doc.rust-lang.org/nightly/core/ops))\n\nNote that if you override this setting, those traits won't be automatically inserted, so you may want to insert them manually.",
"default": [
"core::borrow::Borrow",
"core::borrow::BorrowMut",
"core::cmp::PartialEq",
"core::ops::Add",
"core::ops::AddAssign",
"core::ops::BitAnd",
"core::ops::BitAndAssign",
"core::ops::BitOr",
"core::ops::BitOrAssign",
"core::ops::BitXor",
"core::ops::BitXorAssign",
"core::ops::Div",
"core::ops::DivAssign",
"core::ops::Mul",
"core::ops::MulAssign",
"core::ops::Rem",
"core::ops::RemAssign",
"core::ops::Shl",
"core::ops::ShlAssign",
"core::ops::Shr",
"core::ops::ShrAssign",
"core::ops::Sub",
"core::ops::SubAssign",
"core::ops::Neg",
"core::ops::Not",
"core::ops::Index",
"core::ops::IndexMut",
"core::ops::Deref",
"core::ops::DerefMut"
],
"type": "array",
"items": {
"type": "string"
}
}
}
},
{
"title": "completion",
"properties": {
@ -1169,6 +1212,19 @@
}
}
},
{
"title": "completion",
"properties": {
"rust-analyzer.completion.excludeTraits": {
"markdownDescription": "A list of full paths to traits to exclude from completion.\n\nMethods from these traits won't be completed, even if the trait is in scope. However, they will still be suggested on expressions whose type is `dyn Trait`, `impl Trait` or `T where T: Trait`.\n\nNote that the trait themselves can still be completed.",
"default": [],
"type": "array",
"items": {
"type": "string"
}
}
}
},
{
"title": "completion",
"properties": {