From a8e04a702827c454f5336c82262b0963df7fe484 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sat, 22 Dec 2018 01:01:40 +0300 Subject: docs --- crates/ra_analysis/src/completion.rs | 170 ++------------------- .../src/completion/complete_fn_param.rs | 4 +- .../ra_analysis/src/completion/complete_keyword.rs | 4 +- crates/ra_analysis/src/completion/complete_path.rs | 4 +- .../ra_analysis/src/completion/complete_scope.rs | 4 +- .../ra_analysis/src/completion/complete_snippet.rs | 6 +- .../src/completion/completion_context.rs | 156 +++++++++++++++++++ 7 files changed, 181 insertions(+), 167 deletions(-) create mode 100644 crates/ra_analysis/src/completion/completion_context.rs (limited to 'crates/ra_analysis') diff --git a/crates/ra_analysis/src/completion.rs b/crates/ra_analysis/src/completion.rs index 93edcc4c2..2d61a3aef 100644 --- a/crates/ra_analysis/src/completion.rs +++ b/crates/ra_analysis/src/completion.rs @@ -1,4 +1,5 @@ mod completion_item; +mod completion_context; mod complete_fn_param; mod complete_keyword; @@ -6,34 +7,33 @@ mod complete_snippet; mod complete_path; mod complete_scope; -use ra_editor::find_node_at_offset; -use ra_text_edit::AtomTextEdit; -use ra_syntax::{ - algo::find_leaf_at_offset, - ast, - AstNode, - SyntaxNodeRef, - SourceFileNode, - TextUnit, - SyntaxKind::*, -}; use ra_db::SyntaxDatabase; -use hir::source_binder; use crate::{ db, Cancelable, FilePosition, - completion::completion_item::{Completions, CompletionKind}, + completion::{ + completion_item::{Completions, CompletionKind}, + completion_context::CompletionContext, + }, }; pub use crate::completion::completion_item::{CompletionItem, InsertText}; +/// Main entry point for copmletion. We run comletion as a two-phase process. +/// +/// First, we look at the position and collect a so-called `CompletionContext. +/// This is a somewhat messy process, because, during completion, syntax tree is +/// incomplete and can look readlly weired. +/// +/// Once the context is collected, we run a series of completion routines whihc +/// look at the context and produce completion items. pub(crate) fn completions( db: &db::RootDatabase, position: FilePosition, ) -> Cancelable> { let original_file = db.source_file(position.file_id); - let ctx = ctry!(SyntaxContext::new(db, &original_file, position)?); + let ctx = ctry!(CompletionContext::new(db, &original_file, position)?); let mut acc = Completions::default(); @@ -47,148 +47,6 @@ pub(crate) fn completions( Ok(Some(acc)) } -/// `SyntaxContext` is created early during completion to figure out, where -/// exactly is the cursor, syntax-wise. -#[derive(Debug)] -pub(super) struct SyntaxContext<'a> { - db: &'a db::RootDatabase, - offset: TextUnit, - leaf: SyntaxNodeRef<'a>, - module: Option, - enclosing_fn: Option>, - is_param: bool, - /// A single-indent path, like `foo`. - is_trivial_path: bool, - /// If not a trivial, path, the prefix (qualifier). - path_prefix: Option, - after_if: bool, - is_stmt: bool, - /// Something is typed at the "top" level, in module or impl/trait. - is_new_item: bool, -} - -impl<'a> SyntaxContext<'a> { - pub(super) fn new( - db: &'a db::RootDatabase, - original_file: &'a SourceFileNode, - position: FilePosition, - ) -> Cancelable>> { - let module = source_binder::module_from_position(db, position)?; - let leaf = - ctry!(find_leaf_at_offset(original_file.syntax(), position.offset).left_biased()); - let mut ctx = SyntaxContext { - db, - leaf, - offset: position.offset, - module, - enclosing_fn: None, - is_param: false, - is_trivial_path: false, - path_prefix: None, - after_if: false, - is_stmt: false, - is_new_item: false, - }; - ctx.fill(original_file, position.offset); - Ok(Some(ctx)) - } - - fn fill(&mut self, original_file: &SourceFileNode, offset: TextUnit) { - // Insert a fake ident to get a valid parse tree. We will use this file - // to determine context, though the original_file will be used for - // actual completion. - let file = { - let edit = AtomTextEdit::insert(offset, "intellijRulezz".to_string()); - original_file.reparse(&edit) - }; - - // First, let's try to complete a reference to some declaration. - if let Some(name_ref) = find_node_at_offset::(file.syntax(), offset) { - // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`. - // See RFC#1685. - if is_node::(name_ref.syntax()) { - self.is_param = true; - return; - } - self.classify_name_ref(&file, name_ref); - } - - // Otherwise, see if this is a declaration. We can use heuristics to - // suggest declaration names, see `CompletionKind::Magic`. - if let Some(name) = find_node_at_offset::(file.syntax(), offset) { - if is_node::(name.syntax()) { - self.is_param = true; - return; - } - } - } - fn classify_name_ref(&mut self, file: &SourceFileNode, name_ref: ast::NameRef) { - let name_range = name_ref.syntax().range(); - let top_node = name_ref - .syntax() - .ancestors() - .take_while(|it| it.range() == name_range) - .last() - .unwrap(); - - match top_node.parent().map(|it| it.kind()) { - Some(SOURCE_FILE) | Some(ITEM_LIST) => { - self.is_new_item = true; - return; - } - _ => (), - } - - let parent = match name_ref.syntax().parent() { - Some(it) => it, - None => return, - }; - if let Some(segment) = ast::PathSegment::cast(parent) { - let path = segment.parent_path(); - if let Some(mut path) = hir::Path::from_ast(path) { - if !path.is_ident() { - path.segments.pop().unwrap(); - self.path_prefix = Some(path); - return; - } - } - if path.qualifier().is_none() { - self.is_trivial_path = true; - self.enclosing_fn = self - .leaf - .ancestors() - .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE) - .find_map(ast::FnDef::cast); - - self.is_stmt = match name_ref - .syntax() - .ancestors() - .filter_map(ast::ExprStmt::cast) - .next() - { - None => false, - Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(), - }; - - if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) { - if let Some(if_expr) = find_node_at_offset::(file.syntax(), off) { - if if_expr.syntax().range().end() < name_ref.syntax().range().start() { - self.after_if = true; - } - } - } - } - } - } -} - -fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool { - match node.ancestors().filter_map(N::cast).next() { - None => false, - Some(n) => n.syntax().range() == node.range(), - } -} - #[cfg(test)] fn check_completion(code: &str, expected_completions: &str, kind: CompletionKind) { use crate::mock_analysis::{single_file_with_position, analysis_and_position}; diff --git a/crates/ra_analysis/src/completion/complete_fn_param.rs b/crates/ra_analysis/src/completion/complete_fn_param.rs index d05a5e3cf..3ec507fdf 100644 --- a/crates/ra_analysis/src/completion/complete_fn_param.rs +++ b/crates/ra_analysis/src/completion/complete_fn_param.rs @@ -8,14 +8,14 @@ use ra_syntax::{ use rustc_hash::{FxHashMap}; use crate::{ - completion::{SyntaxContext, Completions, CompletionKind, CompletionItem}, + completion::{CompletionContext, Completions, CompletionKind, CompletionItem}, }; /// Complete repeated parametes, both name and type. For example, if all /// functions in a file have a `spam: &mut Spam` parameter, a completion with /// `spam: &mut Spam` insert text/label and `spam` lookup string will be /// suggested. -pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &SyntaxContext) { +pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) { if !ctx.is_param { return; } diff --git a/crates/ra_analysis/src/completion/complete_keyword.rs b/crates/ra_analysis/src/completion/complete_keyword.rs index d0a6ec19e..2ee36430e 100644 --- a/crates/ra_analysis/src/completion/complete_keyword.rs +++ b/crates/ra_analysis/src/completion/complete_keyword.rs @@ -6,10 +6,10 @@ use ra_syntax::{ }; use crate::{ - completion::{SyntaxContext, CompletionItem, Completions, CompletionKind::*}, + completion::{CompletionContext, CompletionItem, Completions, CompletionKind::*}, }; -pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &SyntaxContext) { +pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) { if !ctx.is_trivial_path { return; } diff --git a/crates/ra_analysis/src/completion/complete_path.rs b/crates/ra_analysis/src/completion/complete_path.rs index 8374ec346..41e439b1b 100644 --- a/crates/ra_analysis/src/completion/complete_path.rs +++ b/crates/ra_analysis/src/completion/complete_path.rs @@ -1,9 +1,9 @@ use crate::{ - completion::{CompletionItem, Completions, CompletionKind::*, SyntaxContext}, + completion::{CompletionItem, Completions, CompletionKind::*, CompletionContext}, Cancelable, }; -pub(super) fn complete_path(acc: &mut Completions, ctx: &SyntaxContext) -> Cancelable<()> { +pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> { let (path, module) = match (&ctx.path_prefix, &ctx.module) { (Some(path), Some(module)) => (path.clone(), module), _ => return Ok(()), diff --git a/crates/ra_analysis/src/completion/complete_scope.rs b/crates/ra_analysis/src/completion/complete_scope.rs index ddaf13b88..c1ab19d5b 100644 --- a/crates/ra_analysis/src/completion/complete_scope.rs +++ b/crates/ra_analysis/src/completion/complete_scope.rs @@ -2,11 +2,11 @@ use rustc_hash::FxHashSet; use ra_syntax::TextUnit; use crate::{ - completion::{CompletionItem, Completions, CompletionKind::*, SyntaxContext}, + completion::{CompletionItem, Completions, CompletionKind::*, CompletionContext}, Cancelable }; -pub(super) fn complete_scope(acc: &mut Completions, ctx: &SyntaxContext) -> Cancelable<()> { +pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) -> Cancelable<()> { if !ctx.is_trivial_path { return Ok(()); } diff --git a/crates/ra_analysis/src/completion/complete_snippet.rs b/crates/ra_analysis/src/completion/complete_snippet.rs index 5d6cc5dc9..6816ae695 100644 --- a/crates/ra_analysis/src/completion/complete_snippet.rs +++ b/crates/ra_analysis/src/completion/complete_snippet.rs @@ -1,8 +1,8 @@ use crate::{ - completion::{CompletionItem, Completions, CompletionKind::*, SyntaxContext}, + completion::{CompletionItem, Completions, CompletionKind::*, CompletionContext}, }; -pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &SyntaxContext) { +pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) { if !(ctx.is_trivial_path && ctx.enclosing_fn.is_some()) { return; } @@ -16,7 +16,7 @@ pub(super) fn complete_expr_snippet(acc: &mut Completions, ctx: &SyntaxContext) .add_to(acc); } -pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &SyntaxContext) { +pub(super) fn complete_item_snippet(acc: &mut Completions, ctx: &CompletionContext) { if !ctx.is_new_item { return; } diff --git a/crates/ra_analysis/src/completion/completion_context.rs b/crates/ra_analysis/src/completion/completion_context.rs new file mode 100644 index 000000000..064fbc6f7 --- /dev/null +++ b/crates/ra_analysis/src/completion/completion_context.rs @@ -0,0 +1,156 @@ +use ra_editor::find_node_at_offset; +use ra_text_edit::AtomTextEdit; +use ra_syntax::{ + algo::find_leaf_at_offset, + ast, + AstNode, + SyntaxNodeRef, + SourceFileNode, + TextUnit, + SyntaxKind::*, +}; +use hir::source_binder; + +use crate::{db, FilePosition, Cancelable}; + +/// `CompletionContext` is created early during completion to figure out, where +/// exactly is the cursor, syntax-wise. +#[derive(Debug)] +pub(super) struct CompletionContext<'a> { + pub(super) db: &'a db::RootDatabase, + pub(super) offset: TextUnit, + pub(super) leaf: SyntaxNodeRef<'a>, + pub(super) module: Option, + pub(super) enclosing_fn: Option>, + pub(super) is_param: bool, + /// A single-indent path, like `foo`. + pub(super) is_trivial_path: bool, + /// If not a trivial, path, the prefix (qualifier). + pub(super) path_prefix: Option, + pub(super) after_if: bool, + pub(super) is_stmt: bool, + /// Something is typed at the "top" level, in module or impl/trait. + pub(super) is_new_item: bool, +} + +impl<'a> CompletionContext<'a> { + pub(super) fn new( + db: &'a db::RootDatabase, + original_file: &'a SourceFileNode, + position: FilePosition, + ) -> Cancelable>> { + let module = source_binder::module_from_position(db, position)?; + let leaf = + ctry!(find_leaf_at_offset(original_file.syntax(), position.offset).left_biased()); + let mut ctx = CompletionContext { + db, + leaf, + offset: position.offset, + module, + enclosing_fn: None, + is_param: false, + is_trivial_path: false, + path_prefix: None, + after_if: false, + is_stmt: false, + is_new_item: false, + }; + ctx.fill(original_file, position.offset); + Ok(Some(ctx)) + } + + fn fill(&mut self, original_file: &SourceFileNode, offset: TextUnit) { + // Insert a fake ident to get a valid parse tree. We will use this file + // to determine context, though the original_file will be used for + // actual completion. + let file = { + let edit = AtomTextEdit::insert(offset, "intellijRulezz".to_string()); + original_file.reparse(&edit) + }; + + // First, let's try to complete a reference to some declaration. + if let Some(name_ref) = find_node_at_offset::(file.syntax(), offset) { + // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`. + // See RFC#1685. + if is_node::(name_ref.syntax()) { + self.is_param = true; + return; + } + self.classify_name_ref(&file, name_ref); + } + + // Otherwise, see if this is a declaration. We can use heuristics to + // suggest declaration names, see `CompletionKind::Magic`. + if let Some(name) = find_node_at_offset::(file.syntax(), offset) { + if is_node::(name.syntax()) { + self.is_param = true; + return; + } + } + } + fn classify_name_ref(&mut self, file: &SourceFileNode, name_ref: ast::NameRef) { + let name_range = name_ref.syntax().range(); + let top_node = name_ref + .syntax() + .ancestors() + .take_while(|it| it.range() == name_range) + .last() + .unwrap(); + + match top_node.parent().map(|it| it.kind()) { + Some(SOURCE_FILE) | Some(ITEM_LIST) => { + self.is_new_item = true; + return; + } + _ => (), + } + + let parent = match name_ref.syntax().parent() { + Some(it) => it, + None => return, + }; + if let Some(segment) = ast::PathSegment::cast(parent) { + let path = segment.parent_path(); + if let Some(mut path) = hir::Path::from_ast(path) { + if !path.is_ident() { + path.segments.pop().unwrap(); + self.path_prefix = Some(path); + return; + } + } + if path.qualifier().is_none() { + self.is_trivial_path = true; + self.enclosing_fn = self + .leaf + .ancestors() + .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE) + .find_map(ast::FnDef::cast); + + self.is_stmt = match name_ref + .syntax() + .ancestors() + .filter_map(ast::ExprStmt::cast) + .next() + { + None => false, + Some(expr_stmt) => expr_stmt.syntax().range() == name_ref.syntax().range(), + }; + + if let Some(off) = name_ref.syntax().range().start().checked_sub(2.into()) { + if let Some(if_expr) = find_node_at_offset::(file.syntax(), off) { + if if_expr.syntax().range().end() < name_ref.syntax().range().start() { + self.after_if = true; + } + } + } + } + } + } +} + +fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool { + match node.ancestors().filter_map(N::cast).next() { + None => false, + Some(n) => n.syntax().range() == node.range(), + } +} -- cgit v1.2.3