split completion mod
This commit is contained in:
Aleksey Kladov
parent
af17fc9697
commit
9b88ec488b
@ -1,20 +1,17 @@
|
||||
mod reference_completion;
|
||||
|
||||
use ra_editor::find_node_at_offset;
|
||||
use ra_syntax::{
|
||||
algo::visit::{visitor, visitor_ctx, Visitor, VisitorCtx},
|
||||
ast::{self, AstChildren, LoopBodyOwner, ModuleItemOwner},
|
||||
AstNode, AtomEdit, SourceFileNode,
|
||||
SyntaxKind::*,
|
||||
algo::visit::{visitor_ctx, VisitorCtx},
|
||||
ast,
|
||||
AstNode, AtomEdit,
|
||||
SyntaxNodeRef,
|
||||
};
|
||||
use rustc_hash::{FxHashMap, FxHashSet};
|
||||
use rustc_hash::{FxHashMap};
|
||||
|
||||
use crate::{
|
||||
db::{self, SyntaxDatabase},
|
||||
descriptors::function::FnScopes,
|
||||
descriptors::module::{ModuleId, ModuleScope, ModuleTree, ModuleSource},
|
||||
descriptors::DescriptorDatabase,
|
||||
input::FilesDatabase,
|
||||
Cancelable, FilePosition, FileId,
|
||||
Cancelable, FilePosition
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
@ -43,27 +40,11 @@ pub(crate) fn completions(
|
||||
// First, let's try to complete a reference to some declaration.
|
||||
if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
|
||||
has_completions = true;
|
||||
// completion from lexical scope
|
||||
complete_name_ref(&file, name_ref, &mut res);
|
||||
reference_completion::completions(&mut res, db, position.file_id, &file, name_ref)?;
|
||||
// special case, `trait T { fn foo(i_am_a_name_ref) {} }`
|
||||
if is_node::<ast::Param>(name_ref.syntax()) {
|
||||
param_completions(name_ref.syntax(), &mut res);
|
||||
}
|
||||
// snippet completions
|
||||
{
|
||||
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) => complete_mod_item_snippets(&mut res),
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
complete_path(db, position.file_id, name_ref, &mut res)?;
|
||||
}
|
||||
|
||||
// Otherwise, if this is a declaration, use heuristics to suggest a name.
|
||||
@ -77,117 +58,6 @@ pub(crate) fn completions(
|
||||
Ok(res)
|
||||
}
|
||||
|
||||
fn complete_path(
|
||||
db: &db::RootDatabase,
|
||||
file_id: FileId,
|
||||
name_ref: ast::NameRef,
|
||||
acc: &mut Vec<CompletionItem>,
|
||||
) -> Cancelable<()> {
|
||||
let source_root_id = db.file_source_root(file_id);
|
||||
let module_tree = db.module_tree(source_root_id)?;
|
||||
let module_id = match module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) {
|
||||
None => return Ok(()),
|
||||
Some(it) => it,
|
||||
};
|
||||
let target_module_id = match find_target_module(&module_tree, module_id, name_ref) {
|
||||
None => return Ok(()),
|
||||
Some(it) => it,
|
||||
};
|
||||
let module_scope = db.module_scope(source_root_id, target_module_id)?;
|
||||
let completions = module_scope.entries().iter().map(|entry| CompletionItem {
|
||||
label: entry.name().to_string(),
|
||||
lookup: None,
|
||||
snippet: None,
|
||||
});
|
||||
acc.extend(completions);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn find_target_module(
|
||||
module_tree: &ModuleTree,
|
||||
module_id: ModuleId,
|
||||
name_ref: ast::NameRef,
|
||||
) -> Option<ModuleId> {
|
||||
let mut crate_path = crate_path(name_ref)?;
|
||||
|
||||
crate_path.pop();
|
||||
let mut target_module = module_id.root(&module_tree);
|
||||
for name in crate_path {
|
||||
target_module = target_module.child(module_tree, name.text().as_str())?;
|
||||
}
|
||||
Some(target_module)
|
||||
}
|
||||
|
||||
fn crate_path(name_ref: ast::NameRef) -> Option<Vec<ast::NameRef>> {
|
||||
let mut path = name_ref
|
||||
.syntax()
|
||||
.parent()
|
||||
.and_then(ast::PathSegment::cast)?
|
||||
.parent_path();
|
||||
let mut res = Vec::new();
|
||||
loop {
|
||||
let segment = path.segment()?;
|
||||
match segment.kind()? {
|
||||
ast::PathSegmentKind::Name(name) => res.push(name),
|
||||
ast::PathSegmentKind::CrateKw => break,
|
||||
ast::PathSegmentKind::SelfKw | ast::PathSegmentKind::SuperKw => return None,
|
||||
}
|
||||
path = path.qualifier()?;
|
||||
}
|
||||
res.reverse();
|
||||
Some(res)
|
||||
}
|
||||
|
||||
fn complete_module_items(
|
||||
file: &SourceFileNode,
|
||||
items: AstChildren<ast::ModuleItem>,
|
||||
this_item: Option<ast::NameRef>,
|
||||
acc: &mut Vec<CompletionItem>,
|
||||
) {
|
||||
let scope = ModuleScope::new(items); // FIXME
|
||||
acc.extend(
|
||||
scope
|
||||
.entries()
|
||||
.iter()
|
||||
.filter(|entry| {
|
||||
let syntax = entry.ptr().resolve(file);
|
||||
Some(syntax.borrowed()) != this_item.map(|it| it.syntax())
|
||||
})
|
||||
.map(|entry| CompletionItem {
|
||||
label: entry.name().to_string(),
|
||||
lookup: None,
|
||||
snippet: None,
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
fn complete_name_ref(file: &SourceFileNode, name_ref: ast::NameRef, acc: &mut Vec<CompletionItem>) {
|
||||
if !is_node::<ast::Path>(name_ref.syntax()) {
|
||||
return;
|
||||
}
|
||||
let mut visited_fn = false;
|
||||
for node in name_ref.syntax().ancestors() {
|
||||
if let Some(items) = visitor()
|
||||
.visit::<ast::SourceFile, _>(|it| Some(it.items()))
|
||||
.visit::<ast::Module, _>(|it| Some(it.item_list()?.items()))
|
||||
.accept(node)
|
||||
{
|
||||
if let Some(items) = items {
|
||||
complete_module_items(file, items, Some(name_ref), acc);
|
||||
}
|
||||
break;
|
||||
} else if !visited_fn {
|
||||
if let Some(fn_def) = ast::FnDef::cast(node) {
|
||||
visited_fn = true;
|
||||
complete_expr_keywords(&file, fn_def, name_ref, acc);
|
||||
complete_expr_snippets(acc);
|
||||
let scopes = FnScopes::new(fn_def);
|
||||
complete_fn(name_ref, &scopes, acc);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn param_completions(ctx: SyntaxNodeRef, acc: &mut Vec<CompletionItem>) {
|
||||
let mut params = FxHashMap::default();
|
||||
for node in ctx.ancestors() {
|
||||
@ -235,140 +105,6 @@ fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
fn complete_expr_keywords(
|
||||
file: &SourceFileNode,
|
||||
fn_def: ast::FnDef,
|
||||
name_ref: ast::NameRef,
|
||||
acc: &mut Vec<CompletionItem>,
|
||||
) {
|
||||
acc.push(keyword("if", "if $0 {}"));
|
||||
acc.push(keyword("match", "match $0 {}"));
|
||||
acc.push(keyword("while", "while $0 {}"));
|
||||
acc.push(keyword("loop", "loop {$0}"));
|
||||
|
||||
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() {
|
||||
acc.push(keyword("else", "else {$0}"));
|
||||
acc.push(keyword("else if", "else if $0 {}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
if is_in_loop_body(name_ref) {
|
||||
acc.push(keyword("continue", "continue"));
|
||||
acc.push(keyword("break", "break"));
|
||||
}
|
||||
acc.extend(complete_return(fn_def, name_ref));
|
||||
}
|
||||
|
||||
fn is_in_loop_body(name_ref: ast::NameRef) -> bool {
|
||||
for node in name_ref.syntax().ancestors() {
|
||||
if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
|
||||
break;
|
||||
}
|
||||
let loop_body = visitor()
|
||||
.visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
|
||||
.visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
|
||||
.visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
|
||||
.accept(node);
|
||||
if let Some(Some(body)) = loop_body {
|
||||
if name_ref
|
||||
.syntax()
|
||||
.range()
|
||||
.is_subrange(&body.syntax().range())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn complete_return(fn_def: ast::FnDef, name_ref: ast::NameRef) -> Option<CompletionItem> {
|
||||
// let is_last_in_block = name_ref.syntax().ancestors().filter_map(ast::Expr::cast)
|
||||
// .next()
|
||||
// .and_then(|it| it.syntax().parent())
|
||||
// .and_then(ast::Block::cast)
|
||||
// .is_some();
|
||||
|
||||
// if is_last_in_block {
|
||||
// return None;
|
||||
// }
|
||||
|
||||
let 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(),
|
||||
};
|
||||
let snip = match (is_stmt, fn_def.ret_type().is_some()) {
|
||||
(true, true) => "return $0;",
|
||||
(true, false) => "return;",
|
||||
(false, true) => "return $0",
|
||||
(false, false) => "return",
|
||||
};
|
||||
Some(keyword("return", snip))
|
||||
}
|
||||
|
||||
fn keyword(kw: &str, snip: &str) -> CompletionItem {
|
||||
CompletionItem {
|
||||
label: kw.to_string(),
|
||||
lookup: None,
|
||||
snippet: Some(snip.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
fn complete_expr_snippets(acc: &mut Vec<CompletionItem>) {
|
||||
acc.push(CompletionItem {
|
||||
label: "pd".to_string(),
|
||||
lookup: None,
|
||||
snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()),
|
||||
});
|
||||
acc.push(CompletionItem {
|
||||
label: "ppd".to_string(),
|
||||
lookup: None,
|
||||
snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()),
|
||||
});
|
||||
}
|
||||
|
||||
fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
|
||||
acc.push(CompletionItem {
|
||||
label: "tfn".to_string(),
|
||||
lookup: None,
|
||||
snippet: Some("#[test]\nfn $1() {\n $0\n}".to_string()),
|
||||
});
|
||||
acc.push(CompletionItem {
|
||||
label: "pub(crate)".to_string(),
|
||||
lookup: None,
|
||||
snippet: Some("pub(crate) $0".to_string()),
|
||||
})
|
||||
}
|
||||
|
||||
fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
|
||||
let mut shadowed = FxHashSet::default();
|
||||
acc.extend(
|
||||
scopes
|
||||
.scope_chain(name_ref.syntax())
|
||||
.flat_map(|scope| scopes.entries(scope).iter())
|
||||
.filter(|entry| shadowed.insert(entry.name()))
|
||||
.map(|entry| CompletionItem {
|
||||
label: entry.name().to_string(),
|
||||
lookup: None,
|
||||
snippet: None,
|
||||
}),
|
||||
);
|
||||
if scopes.self_param.is_some() {
|
||||
acc.push(CompletionItem {
|
||||
label: "self".to_string(),
|
||||
lookup: None,
|
||||
snippet: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use test_utils::assert_eq_dbg;
|
||||
331
crates/ra_analysis/src/completion/reference_completion.rs
Normal file
331
crates/ra_analysis/src/completion/reference_completion.rs
Normal file
@ -0,0 +1,331 @@
|
||||
use rustc_hash::{FxHashSet};
|
||||
use ra_editor::find_node_at_offset;
|
||||
use ra_syntax::{
|
||||
algo::visit::{visitor, Visitor},
|
||||
SourceFileNode, AstNode,
|
||||
ast::{self, AstChildren, ModuleItemOwner, LoopBodyOwner},
|
||||
SyntaxKind::*,
|
||||
};
|
||||
|
||||
use crate::{
|
||||
db::RootDatabase,
|
||||
input::FilesDatabase,
|
||||
completion::CompletionItem,
|
||||
descriptors::module::{ModuleId, ModuleScope, ModuleTree, ModuleSource},
|
||||
descriptors::function::FnScopes,
|
||||
descriptors::DescriptorDatabase,
|
||||
FileId, Cancelable
|
||||
};
|
||||
|
||||
pub(super) fn completions(
|
||||
acc: &mut Vec<CompletionItem>,
|
||||
db: &RootDatabase,
|
||||
file_id: FileId,
|
||||
file: &SourceFileNode,
|
||||
name_ref: ast::NameRef,
|
||||
) -> Cancelable<()> {
|
||||
let kind = match classify_name_ref(name_ref) {
|
||||
Some(it) => it,
|
||||
None => return Ok(()),
|
||||
};
|
||||
match kind {
|
||||
NameRefKind::LocalRef => {
|
||||
if let Some(fn_def) = complete_local_name(acc, &file, name_ref) {
|
||||
complete_expr_keywords(&file, fn_def, name_ref, acc);
|
||||
complete_expr_snippets(acc);
|
||||
}
|
||||
}
|
||||
NameRefKind::CratePath(path) => complete_path(acc, db, file_id, path)?,
|
||||
NameRefKind::BareIdentInMod => {
|
||||
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) => complete_mod_item_snippets(acc),
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
enum NameRefKind<'a> {
|
||||
/// NameRef is a part of single-segment path, for example, a refernece to a
|
||||
/// local variable.
|
||||
LocalRef,
|
||||
/// NameRef is the last segment in crate:: path
|
||||
CratePath(Vec<ast::NameRef<'a>>),
|
||||
/// NameRef is bare identifier at the module's root.
|
||||
/// Used for keyword completion
|
||||
BareIdentInMod,
|
||||
}
|
||||
|
||||
fn classify_name_ref(name_ref: ast::NameRef) -> Option<NameRefKind> {
|
||||
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) => return Some(NameRefKind::BareIdentInMod),
|
||||
_ => (),
|
||||
}
|
||||
|
||||
let parent = name_ref.syntax().parent()?;
|
||||
if let Some(segment) = ast::PathSegment::cast(parent) {
|
||||
let path = segment.parent_path();
|
||||
if path.qualifier().is_none() {
|
||||
return Some(NameRefKind::LocalRef);
|
||||
}
|
||||
if let Some(crate_path) = crate_path(path) {
|
||||
return Some(NameRefKind::CratePath(crate_path));
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn crate_path(mut path: ast::Path) -> Option<Vec<ast::NameRef>> {
|
||||
let mut res = Vec::new();
|
||||
loop {
|
||||
let segment = path.segment()?;
|
||||
match segment.kind()? {
|
||||
ast::PathSegmentKind::Name(name) => res.push(name),
|
||||
ast::PathSegmentKind::CrateKw => break,
|
||||
ast::PathSegmentKind::SelfKw | ast::PathSegmentKind::SuperKw => return None,
|
||||
}
|
||||
path = path.qualifier()?;
|
||||
}
|
||||
res.reverse();
|
||||
Some(res)
|
||||
}
|
||||
|
||||
fn complete_local_name<'a>(
|
||||
acc: &mut Vec<CompletionItem>,
|
||||
file: &SourceFileNode,
|
||||
name_ref: ast::NameRef<'a>,
|
||||
) -> Option<ast::FnDef<'a>> {
|
||||
let mut enclosing_fn = None;
|
||||
for node in name_ref.syntax().ancestors() {
|
||||
if let Some(items) = visitor()
|
||||
.visit::<ast::SourceFile, _>(|it| Some(it.items()))
|
||||
.visit::<ast::Module, _>(|it| Some(it.item_list()?.items()))
|
||||
.accept(node)
|
||||
{
|
||||
if let Some(items) = items {
|
||||
complete_module_items(file, items, Some(name_ref), acc);
|
||||
}
|
||||
break;
|
||||
} else if enclosing_fn.is_none() {
|
||||
if let Some(fn_def) = ast::FnDef::cast(node) {
|
||||
enclosing_fn = Some(fn_def);
|
||||
let scopes = FnScopes::new(fn_def);
|
||||
complete_fn(name_ref, &scopes, acc);
|
||||
}
|
||||
}
|
||||
}
|
||||
enclosing_fn
|
||||
}
|
||||
|
||||
fn complete_module_items(
|
||||
file: &SourceFileNode,
|
||||
items: AstChildren<ast::ModuleItem>,
|
||||
this_item: Option<ast::NameRef>,
|
||||
acc: &mut Vec<CompletionItem>,
|
||||
) {
|
||||
let scope = ModuleScope::new(items); // FIXME
|
||||
acc.extend(
|
||||
scope
|
||||
.entries()
|
||||
.iter()
|
||||
.filter(|entry| {
|
||||
let syntax = entry.ptr().resolve(file);
|
||||
Some(syntax.borrowed()) != this_item.map(|it| it.syntax())
|
||||
})
|
||||
.map(|entry| CompletionItem {
|
||||
label: entry.name().to_string(),
|
||||
lookup: None,
|
||||
snippet: None,
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
|
||||
let mut shadowed = FxHashSet::default();
|
||||
acc.extend(
|
||||
scopes
|
||||
.scope_chain(name_ref.syntax())
|
||||
.flat_map(|scope| scopes.entries(scope).iter())
|
||||
.filter(|entry| shadowed.insert(entry.name()))
|
||||
.map(|entry| CompletionItem {
|
||||
label: entry.name().to_string(),
|
||||
lookup: None,
|
||||
snippet: None,
|
||||
}),
|
||||
);
|
||||
if scopes.self_param.is_some() {
|
||||
acc.push(CompletionItem {
|
||||
label: "self".to_string(),
|
||||
lookup: None,
|
||||
snippet: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn complete_path(
|
||||
acc: &mut Vec<CompletionItem>,
|
||||
db: &RootDatabase,
|
||||
file_id: FileId,
|
||||
crate_path: Vec<ast::NameRef>,
|
||||
) -> Cancelable<()> {
|
||||
let source_root_id = db.file_source_root(file_id);
|
||||
let module_tree = db.module_tree(source_root_id)?;
|
||||
let module_id = match module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) {
|
||||
None => return Ok(()),
|
||||
Some(it) => it,
|
||||
};
|
||||
let target_module_id = match find_target_module(&module_tree, module_id, crate_path) {
|
||||
None => return Ok(()),
|
||||
Some(it) => it,
|
||||
};
|
||||
let module_scope = db.module_scope(source_root_id, target_module_id)?;
|
||||
let completions = module_scope.entries().iter().map(|entry| CompletionItem {
|
||||
label: entry.name().to_string(),
|
||||
lookup: None,
|
||||
snippet: None,
|
||||
});
|
||||
acc.extend(completions);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn find_target_module(
|
||||
module_tree: &ModuleTree,
|
||||
module_id: ModuleId,
|
||||
mut crate_path: Vec<ast::NameRef>,
|
||||
) -> Option<ModuleId> {
|
||||
crate_path.pop();
|
||||
let mut target_module = module_id.root(&module_tree);
|
||||
for name in crate_path {
|
||||
target_module = target_module.child(module_tree, name.text().as_str())?;
|
||||
}
|
||||
Some(target_module)
|
||||
}
|
||||
|
||||
fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
|
||||
acc.push(CompletionItem {
|
||||
label: "tfn".to_string(),
|
||||
lookup: None,
|
||||
snippet: Some("#[test]\nfn $1() {\n $0\n}".to_string()),
|
||||
});
|
||||
acc.push(CompletionItem {
|
||||
label: "pub(crate)".to_string(),
|
||||
lookup: None,
|
||||
snippet: Some("pub(crate) $0".to_string()),
|
||||
})
|
||||
}
|
||||
|
||||
fn complete_expr_keywords(
|
||||
file: &SourceFileNode,
|
||||
fn_def: ast::FnDef,
|
||||
name_ref: ast::NameRef,
|
||||
acc: &mut Vec<CompletionItem>,
|
||||
) {
|
||||
acc.push(keyword("if", "if $0 {}"));
|
||||
acc.push(keyword("match", "match $0 {}"));
|
||||
acc.push(keyword("while", "while $0 {}"));
|
||||
acc.push(keyword("loop", "loop {$0}"));
|
||||
|
||||
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() {
|
||||
acc.push(keyword("else", "else {$0}"));
|
||||
acc.push(keyword("else if", "else if $0 {}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
if is_in_loop_body(name_ref) {
|
||||
acc.push(keyword("continue", "continue"));
|
||||
acc.push(keyword("break", "break"));
|
||||
}
|
||||
acc.extend(complete_return(fn_def, name_ref));
|
||||
}
|
||||
|
||||
fn is_in_loop_body(name_ref: ast::NameRef) -> bool {
|
||||
for node in name_ref.syntax().ancestors() {
|
||||
if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
|
||||
break;
|
||||
}
|
||||
let loop_body = visitor()
|
||||
.visit::<ast::ForExpr, _>(LoopBodyOwner::loop_body)
|
||||
.visit::<ast::WhileExpr, _>(LoopBodyOwner::loop_body)
|
||||
.visit::<ast::LoopExpr, _>(LoopBodyOwner::loop_body)
|
||||
.accept(node);
|
||||
if let Some(Some(body)) = loop_body {
|
||||
if name_ref
|
||||
.syntax()
|
||||
.range()
|
||||
.is_subrange(&body.syntax().range())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn complete_return(fn_def: ast::FnDef, name_ref: ast::NameRef) -> Option<CompletionItem> {
|
||||
// let is_last_in_block = name_ref.syntax().ancestors().filter_map(ast::Expr::cast)
|
||||
// .next()
|
||||
// .and_then(|it| it.syntax().parent())
|
||||
// .and_then(ast::Block::cast)
|
||||
// .is_some();
|
||||
|
||||
// if is_last_in_block {
|
||||
// return None;
|
||||
// }
|
||||
|
||||
let 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(),
|
||||
};
|
||||
let snip = match (is_stmt, fn_def.ret_type().is_some()) {
|
||||
(true, true) => "return $0;",
|
||||
(true, false) => "return;",
|
||||
(false, true) => "return $0",
|
||||
(false, false) => "return",
|
||||
};
|
||||
Some(keyword("return", snip))
|
||||
}
|
||||
|
||||
fn keyword(kw: &str, snip: &str) -> CompletionItem {
|
||||
CompletionItem {
|
||||
label: kw.to_string(),
|
||||
lookup: None,
|
||||
snippet: Some(snip.to_string()),
|
||||
}
|
||||
}
|
||||
|
||||
fn complete_expr_snippets(acc: &mut Vec<CompletionItem>) {
|
||||
acc.push(CompletionItem {
|
||||
label: "pd".to_string(),
|
||||
lookup: None,
|
||||
snippet: Some("eprintln!(\"$0 = {:?}\", $0);".to_string()),
|
||||
});
|
||||
acc.push(CompletionItem {
|
||||
label: "ppd".to_string(),
|
||||
lookup: None,
|
||||
snippet: Some("eprintln!(\"$0 = {:#?}\", $0);".to_string()),
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user