language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-30 13:51:31 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

docs

Browse source
This commit is contained in:
Aleksey Kladov 2018-12-22 01:01:40 +03:00
parent 200cc0a1e3
commit a8e04a7028
7 changed files with 181 additions and 167 deletions
Download patch file Download diff file Expand all files Collapse all files

170
crates/ra_analysis/src/completion.rs
View file

@ -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<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();
@ -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<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};

4
crates/ra_analysis/src/completion/complete_fn_param.rs
View file

@ -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;
}

4
crates/ra_analysis/src/completion/complete_keyword.rs
View file

@ -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;
}

4
crates/ra_analysis/src/completion/complete_path.rs
View file

@ -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(()),

4
crates/ra_analysis/src/completion/complete_scope.rs
View file

@ -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(());
}

6
crates/ra_analysis/src/completion/complete_snippet.rs
View file

@ -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;
}

156
crates/ra_analysis/src/completion/completion_context.rs Normal file
View file

@ -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<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(),
}
}