mod completion_item;
+mod completion_context;
mod complete_fn_param;
mod complete_keyword;
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<Option<Completions>> {
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();
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<hir::Module>,
- enclosing_fn: Option<ast::FnDef<'a>>,
- is_param: bool,
- /// A single-indent path, like `foo`.
- is_trivial_path: bool,
- /// If not a trivial, path, the prefix (qualifier).
- path_prefix: Option<hir::Path>,
- 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<Option<SyntaxContext<'a>>> {
- 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::<ast::NameRef>(file.syntax(), offset) {
- // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`.
- // See RFC#1685.
- if is_node::<ast::Param>(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::<ast::Name>(file.syntax(), offset) {
- if is_node::<ast::Param>(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::<ast::IfExpr>(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};
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;
}
};
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;
}
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(()),
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(());
}
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;
}
.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;
}
--- /dev/null
+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<hir::Module>,
+ pub(super) enclosing_fn: Option<ast::FnDef<'a>>,
+ 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<hir::Path>,
+ 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<Option<CompletionContext<'a>>> {
+ 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::<ast::NameRef>(file.syntax(), offset) {
+ // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`.
+ // See RFC#1685.
+ if is_node::<ast::Param>(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::<ast::Name>(file.syntax(), offset) {
+ if is_node::<ast::Param>(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::<ast::IfExpr>(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(),
+ }
+}
projects / rust.git / commitdiff