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
use ast::with_error_checking_parse;
use core::{Match, Session};
use typeinf::get_function_declaration;
use syntax::ast::ImplItemKind;
pub fn snippet_for_match(m: &Match, session: &Session) -> String {
if m.mtype.is_function() {
let method = get_function_declaration(m, session);
if let Some(m) = MethodInfo::from_source_str(&method) {
m.snippet()
} else {
"".into()
}
} else {
m.matchstr.clone()
}
}
struct MethodInfo {
name: String,
args: Vec<String>,
}
impl MethodInfo {
fn from_source_str(source: &str) -> Option<MethodInfo> {
let trim: &[_] = &['\n', '\r', '{', ' '];
let decorated = format!("{} {{}}()", source.trim_end_matches(trim));
trace!("MethodInfo::from_source_str: {:?}", decorated);
with_error_checking_parse(decorated, |p| {
let mut at_end = false;
if let Ok(method) = p.parse_impl_item(&mut at_end) {
if let ImplItemKind::Method(ref msig, _) = method.node {
let decl = &msig.decl;
return Some(MethodInfo {
name: method.ident.name.to_string(),
args: decl
.inputs
.iter()
.map(|arg| {
let source_map = &p.sess.source_map();
let var_name = match source_map.span_to_snippet(arg.pat.span) {
Ok(name) => name,
_ => "".into(),
};
match source_map.span_to_snippet(arg.ty.span) {
Ok(ref type_name) if !type_name.is_empty() => {
format!("{}: {}", var_name, type_name)
}
_ => var_name,
}
})
.collect(),
});
}
}
debug!("Unable to parse method declaration. |{}|", source);
None
})
}
fn snippet(&self) -> String {
format!(
"{}({})",
self.name,
&self
.args
.iter()
.filter(|&s| !s.ends_with("self"))
.enumerate()
.fold(String::new(), |cur, (i, ref s)| {
let arg = format!("${{{}:{}}}", i + 1, s);
let delim = if i > 0 { ", " } else { "" };
cur + delim + &arg
})
)
}
}
#[test]
fn method_info_test() {
let info = MethodInfo::from_source_str("pub fn new() -> Vec<T>").unwrap();
assert_eq!(info.name, "new");
assert_eq!(info.args.len(), 0);
assert_eq!(info.snippet(), "new()");
let info = MethodInfo::from_source_str("pub fn reserve(&mut self, additional: usize)").unwrap();
assert_eq!(info.name, "reserve");
assert_eq!(info.args.len(), 2);
assert_eq!(info.args[0], "&mut self: &mut self");
assert_eq!(info.snippet(), "reserve(${1:additional: usize})");
}