From e475bcdcc671161cf97d86d116a834c540f75f7c Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Sun, 6 Jun 2021 20:02:26 +0200 Subject: Simplify CompletionContext by introducing a path CallKind enum --- crates/ide_completion/src/completions/dot.rs | 4 +- crates/ide_completion/src/completions/postfix.rs | 2 +- crates/ide_completion/src/context.rs | 55 ++++++++++++++---------- crates/ide_completion/src/patterns.rs | 4 +- crates/ide_completion/src/render/builder_ext.rs | 12 +++--- crates/ide_completion/src/render/macro_.rs | 4 +- 6 files changed, 49 insertions(+), 32 deletions(-) (limited to 'crates/ide_completion') diff --git a/crates/ide_completion/src/completions/dot.rs b/crates/ide_completion/src/completions/dot.rs index e0a7021fd..22844c2ae 100644 --- a/crates/ide_completion/src/completions/dot.rs +++ b/crates/ide_completion/src/completions/dot.rs @@ -4,7 +4,7 @@ use either::Either; use hir::{HasVisibility, ScopeDef}; use rustc_hash::FxHashSet; -use crate::{context::CompletionContext, Completions}; +use crate::{context::CompletionContext, patterns::ImmediateLocation, Completions}; /// Complete dot accesses, i.e. fields or methods. pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) { @@ -18,7 +18,7 @@ pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) { _ => return, }; - if ctx.is_call { + if matches!(ctx.completion_location, Some(ImmediateLocation::MethodCall { .. })) { cov_mark::hit!(test_no_struct_field_completion_for_method_call); } else { complete_fields(ctx, &receiver_ty, |field, ty| match field { diff --git a/crates/ide_completion/src/completions/postfix.rs b/crates/ide_completion/src/completions/postfix.rs index 86bbb58e2..86eb21714 100644 --- a/crates/ide_completion/src/completions/postfix.rs +++ b/crates/ide_completion/src/completions/postfix.rs @@ -24,7 +24,7 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) { } let (dot_receiver, receiver_is_ambiguous_float_literal) = match &ctx.completion_location { - Some(ImmediateLocation::MethodCall { receiver: Some(it) }) => (it, false), + Some(ImmediateLocation::MethodCall { receiver: Some(it), .. }) => (it, false), Some(ImmediateLocation::FieldAccess { receiver: Some(it), receiver_is_ambiguous_float_literal, diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs index cb4f08e53..6bd67c123 100644 --- a/crates/ide_completion/src/context.rs +++ b/crates/ide_completion/src/context.rs @@ -29,6 +29,18 @@ pub(crate) enum PatternRefutability { Irrefutable, } +#[derive(Debug)] +pub(crate) struct PathCompletionContext { + /// If this is a call with () already there + call_kind: Option, +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub(crate) enum CallKind { + Pat, + Mac, + Expr, +} /// `CompletionContext` is created early during completion to figure out, where /// exactly is the cursor, syntax-wise. #[derive(Debug)] @@ -68,6 +80,7 @@ pub(crate) struct CompletionContext<'a> { pub(super) prev_sibling: Option, pub(super) attribute_under_caret: Option, + pub(super) path_context: Option, /// FIXME: `ActiveParameter` is string-based, which is very very wrong pub(super) active_parameter: Option, /// A single-indent path, like `foo`. `::foo` should not be considered a trivial path. @@ -78,12 +91,6 @@ pub(crate) struct CompletionContext<'a> { pub(super) can_be_stmt: bool, /// `true` if we expect an expression at the cursor position. pub(super) is_expr: bool, - /// If this is a call (method or function) in particular, i.e. the () are already there. - pub(super) is_call: bool, - /// Like `is_call`, but for tuple patterns. - pub(super) is_pattern_call: bool, - /// If this is a macro call, i.e. the () are already there. - pub(super) is_macro_call: bool, pub(super) is_path_type: bool, pub(super) has_type_args: bool, pub(super) locals: Vec<(String, Local)>, @@ -153,9 +160,7 @@ impl<'a> CompletionContext<'a> { path_qual: None, can_be_stmt: false, is_expr: false, - is_call: false, - is_pattern_call: false, - is_macro_call: false, + path_context: None, is_path_type: false, has_type_args: false, previous_token: None, @@ -250,14 +255,14 @@ impl<'a> CompletionContext<'a> { pub(crate) fn has_dot_receiver(&self) -> bool { matches!( &self.completion_location, - Some(ImmediateLocation::FieldAccess { receiver, .. }) | Some(ImmediateLocation::MethodCall { receiver }) + Some(ImmediateLocation::FieldAccess { receiver, .. }) | Some(ImmediateLocation::MethodCall { receiver,.. }) if receiver.is_some() ) } pub(crate) fn dot_receiver(&self) -> Option<&ast::Expr> { match &self.completion_location { - Some(ImmediateLocation::MethodCall { receiver }) + Some(ImmediateLocation::MethodCall { receiver, .. }) | Some(ImmediateLocation::FieldAccess { receiver, .. }) => receiver.as_ref(), _ => None, } @@ -316,6 +321,10 @@ impl<'a> CompletionContext<'a> { ) || self.attribute_under_caret.is_some() } + pub(crate) fn path_call_kind(&self) -> Option { + self.path_context.as_ref().and_then(|it| it.call_kind) + } + fn fill_impl_def(&mut self) { self.impl_def = self .sema @@ -568,17 +577,21 @@ impl<'a> CompletionContext<'a> { }; if let Some(segment) = ast::PathSegment::cast(parent) { + let mut path_ctx = PathCompletionContext { call_kind: None }; let path = segment.parent_path(); - self.is_call = path - .syntax() - .parent() - .and_then(ast::PathExpr::cast) - .and_then(|it| it.syntax().parent().and_then(ast::CallExpr::cast)) - .is_some(); - self.is_macro_call = path.syntax().parent().and_then(ast::MacroCall::cast).is_some(); - self.is_pattern_call = - path.syntax().parent().and_then(ast::TupleStructPat::cast).is_some(); + if let Some(p) = path.syntax().parent() { + path_ctx.call_kind = match_ast! { + match p { + ast::PathExpr(it) => it.syntax().parent().and_then(ast::CallExpr::cast).map(|_| CallKind::Expr), + ast::MacroCall(_it) => Some(CallKind::Mac), + ast::TupleStructPat(_it) => Some(CallKind::Pat), + _ => None + } + }; + } + 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(); @@ -623,8 +636,6 @@ impl<'a> CompletionContext<'a> { .unwrap_or(false); self.is_expr = path.syntax().parent().and_then(ast::PathExpr::cast).is_some(); } - self.is_call |= - matches!(self.completion_location, Some(ImmediateLocation::MethodCall { .. })); } } diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs index 080898aef..251d76fe9 100644 --- a/crates/ide_completion/src/patterns.rs +++ b/crates/ide_completion/src/patterns.rs @@ -4,7 +4,7 @@ use hir::Semantics; use ide_db::RootDatabase; use syntax::{ algo::non_trivia_sibling, - ast::{self, LoopBodyOwner}, + ast::{self, ArgListOwner, LoopBodyOwner}, match_ast, AstNode, Direction, SyntaxElement, SyntaxKind::*, SyntaxNode, SyntaxToken, TextRange, TextSize, T, @@ -39,6 +39,7 @@ pub(crate) enum ImmediateLocation { // Original file ast node MethodCall { receiver: Option, + has_parens: bool, }, // Original file ast node FieldAccess { @@ -204,6 +205,7 @@ pub(crate) fn determine_location( .receiver() .map(|e| e.syntax().text_range()) .and_then(|r| find_node_with_range(original_file, r)), + has_parens: it.arg_list().map_or(false, |it| it.l_paren_token().is_some()) }, _ => return None, } diff --git a/crates/ide_completion/src/render/builder_ext.rs b/crates/ide_completion/src/render/builder_ext.rs index 6d062b3b9..c54752d30 100644 --- a/crates/ide_completion/src/render/builder_ext.rs +++ b/crates/ide_completion/src/render/builder_ext.rs @@ -2,7 +2,7 @@ use itertools::Itertools; -use crate::{item::Builder, CompletionContext}; +use crate::{context::CallKind, item::Builder, patterns::ImmediateLocation, CompletionContext}; #[derive(Debug)] pub(super) enum Params { @@ -32,10 +32,12 @@ impl Builder { cov_mark::hit!(no_parens_in_use_item); return false; } - if ctx.is_pattern_call { - return false; - } - if ctx.is_call { + if matches!(ctx.path_call_kind(), Some(CallKind::Expr) | Some(CallKind::Pat)) + | matches!( + ctx.completion_location, + Some(ImmediateLocation::MethodCall { has_parens: true, .. }) + ) + { return false; } diff --git a/crates/ide_completion/src/render/macro_.rs b/crates/ide_completion/src/render/macro_.rs index 0dfba8acc..429d937c8 100644 --- a/crates/ide_completion/src/render/macro_.rs +++ b/crates/ide_completion/src/render/macro_.rs @@ -5,6 +5,7 @@ use ide_db::SymbolKind; use syntax::display::macro_label; use crate::{ + context::CallKind, item::{CompletionItem, CompletionKind, ImportEdit}, render::RenderContext, }; @@ -68,7 +69,8 @@ impl<'a> MacroRender<'a> { } fn needs_bang(&self) -> bool { - self.ctx.completion.use_item_syntax.is_none() && !self.ctx.completion.is_macro_call + self.ctx.completion.use_item_syntax.is_none() + && !matches!(self.ctx.completion.path_call_kind(), Some(CallKind::Mac)) } fn label(&self) -> String { -- cgit v1.2.3