Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-26 04:53:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

Move more things into PathCompletionContext

Browse source
This commit is contained in:
Lukas Wirth 2021-06-07 12:29:46 +02:00
parent e475bcdcc6
commit 4eabcb2c01
8 changed files with 62 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -33,7 +33,7 @@ fn complete_undotted_self(acc: &mut Completions, ctx: &CompletionContext) {
if !ctx.config.enable_self_on_the_fly {
return;
}
if !ctx.is_trivial_path || ctx.is_path_disallowed() {
if !ctx.is_trivial_path() || ctx.is_path_disallowed() {
return;
}
ctx.scope.process_all_names(&mut |name, def| {

6
crates/ide_completion/src/completions/flyimport.rs
View file

@ -161,13 +161,13 @@ pub(crate) fn position_for_import<'a>(
) -> Option<&'a SyntaxNode> {
Some(match import_candidate {
Some(ImportCandidate::Path(_)) => ctx.name_ref_syntax.as_ref()?.syntax(),
Some(ImportCandidate::TraitAssocItem(_)) => ctx.path_qual.as_ref()?.syntax(),
Some(ImportCandidate::TraitAssocItem(_)) => ctx.path_qual()?.syntax(),
Some(ImportCandidate::TraitMethod(_)) => ctx.dot_receiver()?.syntax(),
None => ctx
.name_ref_syntax
.as_ref()
.map(|name_ref| name_ref.syntax())
.or_else(|| ctx.path_qual.as_ref().map(|path| path.syntax()))
.or_else(|| ctx.path_qual().map(|path| path.syntax()))
.or_else(|| ctx.dot_receiver().map(|expr| expr.syntax()))?,
})
}
@ -190,7 +190,7 @@ fn import_assets(ctx: &CompletionContext, fuzzy_name: String) -> Option<ImportAs
};
let assets_for_path = ImportAssets::for_fuzzy_path(
current_module,
ctx.path_qual.clone(),
ctx.path_qual().cloned(),
fuzzy_name,
&ctx.sema,
approximate_node,

11
crates/ide_completion/src/completions/keyword.rs
View file

@ -19,11 +19,12 @@ pub(crate) fn complete_use_tree_keyword(acc: &mut Completions, ctx: &CompletionC
};
if ctx.use_item_syntax.is_some() {
if ctx.path_qual.is_none() {
let qual = ctx.path_qual();
if qual.is_none() {
kw_completion("crate::").add_to(acc);
}
kw_completion("self").add_to(acc);
if iter::successors(ctx.path_qual.clone(), |p| p.qualifier())
if iter::successors(qual.cloned(), |p| p.qualifier())
.all(|p| p.segment().and_then(|s| s.super_token()).is_some())
{
kw_completion("super::").add_to(acc);
@ -128,7 +129,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
}
if ctx.in_loop_body {
if ctx.can_be_stmt {
if ctx.can_be_stmt() {
add_keyword("continue", "continue;");
add_keyword("break", "break;");
} else {
@ -137,7 +138,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
}
}
if !ctx.is_trivial_path {
if !ctx.is_trivial_path() {
return;
}
let fn_def = match &ctx.function_def {
@ -147,7 +148,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
add_keyword(
"return",
match (ctx.can_be_stmt, fn_def.ret_type().is_some()) {
match (ctx.can_be_stmt(), fn_def.ret_type().is_some()) {
(true, true) => "return $0;",
(true, false) => "return;",
(false, true) => "return $0",

4
crates/ide_completion/src/completions/qualified_path.rs
View file

@ -10,8 +10,8 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
if ctx.is_path_disallowed() || ctx.expects_item() {
return;
}
let path = match &ctx.path_qual {
Some(path) => path.clone(),
let path = match ctx.path_qual() {
Some(path) => path,
None => return,
};

4
crates/ide_completion/src/completions/snippet.rs
View file

@ -14,7 +14,7 @@ fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str)
}
pub(crate) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
if !(ctx.is_trivial_path && ctx.function_def.is_some()) {
if !(ctx.is_trivial_path() && ctx.function_def.is_some()) {
return;
}
let cap = match ctx.config.snippet_cap {
@ -22,7 +22,7 @@ pub(crate) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionConte
None => return,
};
if ctx.can_be_stmt {
if ctx.can_be_stmt() {
snippet(ctx, cap, "pd", "eprintln!(\"$0 = {:?}\", $0);").add_to(acc);
snippet(ctx, cap, "ppd", "eprintln!(\"$0 = {:#?}\", $0);").add_to(acc);
}

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

@ -5,7 +5,7 @@ use hir::ScopeDef;
use crate::{CompletionContext, Completions};
pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
if !ctx.is_trivial_path {
if !ctx.is_trivial_path() {
return;
}
if ctx.is_path_disallowed() || ctx.expects_item() {

71
crates/ide_completion/src/context.rs
View file

@ -33,6 +33,16 @@ pub(crate) enum PatternRefutability {
pub(crate) struct PathCompletionContext {
/// If this is a call with () already there
call_kind: Option<CallKind>,
/// A single-indent path, like `foo`. `::foo` should not be considered a trivial path.
pub(super) is_trivial_path: bool,
/// If not a trivial path, the prefix (qualifier).
pub(super) path_qual: Option<ast::Path>,
pub(super) is_path_type: bool,
pub(super) has_type_args: bool,
/// `true` if we are a statement or a last expr in the block.
pub(super) can_be_stmt: bool,
/// `true` if we expect an expression at the cursor position.
pub(super) is_expr: bool,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
@ -83,16 +93,6 @@ pub(crate) struct CompletionContext<'a> {
pub(super) path_context: Option<PathCompletionContext>,
/// FIXME: `ActiveParameter` is string-based, which is very very wrong
pub(super) active_parameter: Option<ActiveParameter>,
/// A single-indent path, like `foo`. `::foo` should not be considered a trivial path.
pub(super) is_trivial_path: bool,
/// If not a trivial path, the prefix (qualifier).
pub(super) path_qual: Option<ast::Path>,
/// `true` if we are a statement or a last expr in the block.
pub(super) can_be_stmt: bool,
/// `true` if we expect an expression at the cursor position.
pub(super) is_expr: bool,
pub(super) is_path_type: bool,
pub(super) has_type_args: bool,
pub(super) locals: Vec<(String, Local)>,
pub(super) previous_token: Option<SyntaxToken>,
@ -156,13 +156,7 @@ impl<'a> CompletionContext<'a> {
is_label_ref: false,
is_param: false,
is_pat_or_const: None,
is_trivial_path: false,
path_qual: None,
can_be_stmt: false,
is_expr: false,
path_context: None,
is_path_type: false,
has_type_args: false,
previous_token: None,
in_loop_body: false,
completion_location: None,
@ -280,11 +274,6 @@ impl<'a> CompletionContext<'a> {
matches!(self.completion_location, Some(ImmediateLocation::ItemList))
}
// fn expects_value(&self) -> bool {
pub(crate) fn expects_expression(&self) -> bool {
self.is_expr
}
pub(crate) fn has_block_expr_parent(&self) -> bool {
matches!(self.completion_location, Some(ImmediateLocation::BlockExpr))
}
@ -321,10 +310,26 @@ impl<'a> CompletionContext<'a> {
) || self.attribute_under_caret.is_some()
}
pub(crate) fn expects_expression(&self) -> bool {
self.path_context.as_ref().map_or(false, |it| it.is_expr)
}
pub(crate) fn path_call_kind(&self) -> Option<CallKind> {
self.path_context.as_ref().and_then(|it| it.call_kind)
}
pub(crate) fn is_trivial_path(&self) -> bool {
self.path_context.as_ref().map_or(false, |it| it.is_trivial_path)
}
pub(crate) fn path_qual(&self) -> Option<&ast::Path> {
self.path_context.as_ref().and_then(|it| it.path_qual.as_ref())
}
pub(crate) fn can_be_stmt(&self) -> bool {
self.path_context.as_ref().map_or(false, |it| it.can_be_stmt)
}
fn fill_impl_def(&mut self) {
self.impl_def = self
.sema
@ -577,7 +582,15 @@ impl<'a> CompletionContext<'a> {
};
if let Some(segment) = ast::PathSegment::cast(parent) {
let mut path_ctx = PathCompletionContext { call_kind: None };
let path_ctx = self.path_context.get_or_insert(PathCompletionContext {
call_kind: None,
is_trivial_path: false,
path_qual: None,
has_type_args: false,
is_path_type: false,
can_be_stmt: false,
is_expr: false,
});
let path = segment.parent_path();
if let Some(p) = path.syntax().parent() {
@ -590,13 +603,11 @@ impl<'a> CompletionContext<'a> {
}
};
}
self.path_context = Some(path_ctx);
dbg!(&self.path_context);
self.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
self.has_type_args = segment.generic_arg_list().is_some();
path_ctx.is_path_type = path.syntax().parent().and_then(ast::PathType::cast).is_some();
path_ctx.has_type_args = segment.generic_arg_list().is_some();
if let Some(path) = path_or_use_tree_qualifier(&path) {
self.path_qual = path
path_ctx.path_qual = path
.segment()
.and_then(|it| {
find_node_with_range::<ast::PathSegment>(
@ -614,11 +625,11 @@ impl<'a> CompletionContext<'a> {
}
}
self.is_trivial_path = true;
path_ctx.is_trivial_path = true;
// Find either enclosing expr statement (thing with `;`) or a
// block. If block, check that we are the last expr.
self.can_be_stmt = name_ref
path_ctx.can_be_stmt = name_ref
.syntax()
.ancestors()
.find_map(|node| {
@ -634,7 +645,7 @@ impl<'a> CompletionContext<'a> {
None
})
.unwrap_or(false);
self.is_expr = path.syntax().parent().and_then(ast::PathExpr::cast).is_some();
path_ctx.is_expr = path.syntax().parent().and_then(ast::PathExpr::cast).is_some();
}
}
}

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

@ -275,8 +275,12 @@ impl<'a> Render<'a> {
};
// Add `<>` for generic types
if self.ctx.completion.is_path_type
&& !self.ctx.completion.has_type_args
if self
.ctx
.completion
.path_context
.as_ref()
.map_or(false, |it| it.is_path_type && !it.has_type_args)
&& self.ctx.completion.config.add_call_parenthesis
{
if let Some(cap) = self.ctx.snippet_cap() {