1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
use std::collections::HashSet;
use crate::{Assist, AssistId, AssistCtx};
use hir::Resolver;
use hir::db::HirDatabase;
use ra_syntax::{SmolStr, SyntaxKind, SyntaxNode, TextUnit, TreeArc};
use ra_syntax::ast::{self, AstNode, FnDef, ImplItem, ImplItemKind, NameOwner};
use ra_db::FilePosition;
use ra_fmt::{leading_indent, reindent};
use itertools::Itertools;
/// Given an `ast::ImplBlock`, resolves the target trait (the one being
/// implemented) to a `ast::TraitDef`.
pub(crate) fn resolve_target_trait_def(
db: &impl HirDatabase,
resolver: &Resolver,
impl_block: &ast::ImplBlock,
) -> Option<TreeArc<ast::TraitDef>> {
let ast_path = impl_block.target_trait().map(AstNode::syntax).and_then(ast::PathType::cast)?;
let hir_path = ast_path.path().and_then(hir::Path::from_ast)?;
match resolver.resolve_path(db, &hir_path).take_types() {
Some(hir::Resolution::Def(hir::ModuleDef::Trait(def))) => Some(def.source(db).1),
_ => None,
}
}
pub(crate) fn build_func_body(def: &ast::FnDef) -> String {
let mut buf = String::new();
for child in def.syntax().children() {
if child.kind() == SyntaxKind::SEMI {
buf.push_str(" { unimplemented!() }")
} else {
child.text().push_to(&mut buf);
}
}
buf.trim_end().to_string()
}
pub(crate) fn add_missing_impl_members(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
use SyntaxKind::{IMPL_BLOCK, ITEM_LIST, WHITESPACE};
let node = ctx.covering_node();
let kinds = node.ancestors().take(3).map(SyntaxNode::kind);
// Only suggest this in `impl Foo for S { [Item...] <|> }` cursor position
if !Iterator::eq(kinds, [WHITESPACE, ITEM_LIST, IMPL_BLOCK].iter().cloned()) {
return None;
}
let impl_node = node.ancestors().find_map(ast::ImplBlock::cast)?;
let impl_item_list = impl_node.item_list()?;
let trait_def = {
let db = ctx.db;
// TODO: Can we get the position of cursor itself rather than supplied range?
let range = ctx.frange;
let position = FilePosition { file_id: range.file_id, offset: range.range.start() };
let resolver = hir::source_binder::resolver_for_position(db, position);
resolve_target_trait_def(db, &resolver, impl_node)?
};
let fn_def_opt = |kind| if let ImplItemKind::FnDef(def) = kind { Some(def) } else { None };
let def_name = |def| -> Option<&SmolStr> { FnDef::name(def).map(ast::Name::text) };
let trait_items = trait_def.syntax().descendants().find_map(ast::ItemList::cast)?.impl_items();
let impl_items = impl_item_list.impl_items();
let trait_fns = trait_items.map(ImplItem::kind).filter_map(fn_def_opt).collect::<Vec<_>>();
let impl_fns = impl_items.map(ImplItem::kind).filter_map(fn_def_opt).collect::<Vec<_>>();
let trait_fn_names = trait_fns.iter().cloned().filter_map(def_name).collect::<HashSet<_>>();
let impl_fn_names = impl_fns.iter().cloned().filter_map(def_name).collect::<HashSet<_>>();
let missing_fn_names = trait_fn_names.difference(&impl_fn_names).collect::<HashSet<_>>();
let missing_fns: Vec<_> = trait_fns
.iter()
.cloned()
.filter(|t| def_name(t).map(|n| missing_fn_names.contains(&n)).unwrap_or(false))
.collect();
if missing_fns.is_empty() {
return None;
}
let last_whitespace_node =
impl_item_list.syntax().children().filter_map(ast::Whitespace::cast).last()?.syntax();
ctx.add_action(AssistId("add_impl_missing_members"), "add impl missing members", |edit| {
let func_bodies = missing_fns.into_iter().map(build_func_body).join("\n");
let func_bodies = String::from("\n") + &func_bodies;
let first_impl_item = impl_item_list.impl_items().next();
// FIXME: We should respect the indent of the first item from the item list or the indent of leading block + some default indent (4?)
// Another approach is to not indent at all if there are no items here
let indent = first_impl_item.and_then(|i| leading_indent(i.syntax())).unwrap_or_default();
let func_bodies = reindent(&func_bodies, indent) + "\n";
let changed_range = last_whitespace_node.range();
let replaced_text_range = TextUnit::of_str(&func_bodies);
edit.replace(changed_range, func_bodies);
edit.set_cursor(changed_range.start() + replaced_text_range - TextUnit::of_str("\n"));
});
ctx.build()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::helpers::{ check_assist };
#[test]
fn test_add_missing_impl_members() {
check_assist(
add_missing_impl_members,
"
trait Foo {
fn foo(&self);
fn bar(&self);
}
struct S;
impl Foo for S {
fn bar(&self) {}
<|>
}",
"
trait Foo {
fn foo(&self);
fn bar(&self);
}
struct S;
impl Foo for S {
fn bar(&self) {}
fn foo(&self) { unimplemented!() }<|>
}",
);
}
}
|
