]>
Commit | Line | Data |
---|---|---|
064997fb FG |
1 | //! Logic for rendering the different hover messages |
2 | use std::fmt::Display; | |
3 | ||
4 | use either::Either; | |
f2b60f7d | 5 | use hir::{AsAssocItem, AttributeTemplate, HasAttrs, HasSource, HirDisplay, Semantics, TypeInfo}; |
064997fb FG |
6 | use ide_db::{ |
7 | base_db::SourceDatabase, | |
8 | defs::Definition, | |
9 | famous_defs::FamousDefs, | |
10 | generated::lints::{CLIPPY_LINTS, DEFAULT_LINTS, FEATURES}, | |
f2b60f7d | 11 | syntax_helpers::insert_whitespace_into_node, |
064997fb FG |
12 | RootDatabase, |
13 | }; | |
14 | use itertools::Itertools; | |
15 | use stdx::format_to; | |
16 | use syntax::{ | |
17 | algo, ast, match_ast, AstNode, Direction, | |
18 | SyntaxKind::{LET_EXPR, LET_STMT}, | |
19 | SyntaxToken, T, | |
20 | }; | |
21 | ||
22 | use crate::{ | |
23 | doc_links::{remove_links, rewrite_links}, | |
24 | hover::walk_and_push_ty, | |
25 | markdown_remove::remove_markdown, | |
26 | HoverAction, HoverConfig, HoverResult, Markup, | |
27 | }; | |
28 | ||
29 | pub(super) fn type_info( | |
30 | sema: &Semantics<'_, RootDatabase>, | |
31 | config: &HoverConfig, | |
32 | expr_or_pat: &Either<ast::Expr, ast::Pat>, | |
33 | ) -> Option<HoverResult> { | |
34 | let TypeInfo { original, adjusted } = match expr_or_pat { | |
35 | Either::Left(expr) => sema.type_of_expr(expr)?, | |
36 | Either::Right(pat) => sema.type_of_pat(pat)?, | |
37 | }; | |
38 | ||
39 | let mut res = HoverResult::default(); | |
40 | let mut targets: Vec<hir::ModuleDef> = Vec::new(); | |
41 | let mut push_new_def = |item: hir::ModuleDef| { | |
42 | if !targets.contains(&item) { | |
43 | targets.push(item); | |
44 | } | |
45 | }; | |
46 | walk_and_push_ty(sema.db, &original, &mut push_new_def); | |
47 | ||
48 | res.markup = if let Some(adjusted_ty) = adjusted { | |
49 | walk_and_push_ty(sema.db, &adjusted_ty, &mut push_new_def); | |
50 | let original = original.display(sema.db).to_string(); | |
51 | let adjusted = adjusted_ty.display(sema.db).to_string(); | |
52 | let static_text_diff_len = "Coerced to: ".len() - "Type: ".len(); | |
53 | format!( | |
54 | "{bt_start}Type: {:>apad$}\nCoerced to: {:>opad$}\n{bt_end}", | |
55 | original, | |
56 | adjusted, | |
57 | apad = static_text_diff_len + adjusted.len().max(original.len()), | |
58 | opad = original.len(), | |
59 | bt_start = if config.markdown() { "```text\n" } else { "" }, | |
60 | bt_end = if config.markdown() { "```\n" } else { "" } | |
61 | ) | |
62 | .into() | |
63 | } else { | |
64 | if config.markdown() { | |
65 | Markup::fenced_block(&original.display(sema.db)) | |
66 | } else { | |
67 | original.display(sema.db).to_string().into() | |
68 | } | |
69 | }; | |
70 | res.actions.push(HoverAction::goto_type_from_targets(sema.db, targets)); | |
71 | Some(res) | |
72 | } | |
73 | ||
74 | pub(super) fn try_expr( | |
75 | sema: &Semantics<'_, RootDatabase>, | |
76 | config: &HoverConfig, | |
77 | try_expr: &ast::TryExpr, | |
78 | ) -> Option<HoverResult> { | |
79 | let inner_ty = sema.type_of_expr(&try_expr.expr()?)?.original; | |
80 | let mut ancestors = try_expr.syntax().ancestors(); | |
81 | let mut body_ty = loop { | |
82 | let next = ancestors.next()?; | |
83 | break match_ast! { | |
84 | match next { | |
85 | ast::Fn(fn_) => sema.to_def(&fn_)?.ret_type(sema.db), | |
86 | ast::Item(__) => return None, | |
87 | ast::ClosureExpr(closure) => sema.type_of_expr(&closure.body()?)?.original, | |
88 | ast::BlockExpr(block_expr) => if matches!(block_expr.modifier(), Some(ast::BlockModifier::Async(_) | ast::BlockModifier::Try(_)| ast::BlockModifier::Const(_))) { | |
89 | sema.type_of_expr(&block_expr.into())?.original | |
90 | } else { | |
91 | continue; | |
92 | }, | |
93 | _ => continue, | |
94 | } | |
95 | }; | |
96 | }; | |
97 | ||
98 | if inner_ty == body_ty { | |
99 | return None; | |
100 | } | |
101 | ||
102 | let mut inner_ty = inner_ty; | |
103 | let mut s = "Try Target".to_owned(); | |
104 | ||
105 | let adts = inner_ty.as_adt().zip(body_ty.as_adt()); | |
106 | if let Some((hir::Adt::Enum(inner), hir::Adt::Enum(body))) = adts { | |
107 | let famous_defs = FamousDefs(sema, sema.scope(try_expr.syntax())?.krate()); | |
108 | // special case for two options, there is no value in showing them | |
109 | if let Some(option_enum) = famous_defs.core_option_Option() { | |
110 | if inner == option_enum && body == option_enum { | |
111 | cov_mark::hit!(hover_try_expr_opt_opt); | |
112 | return None; | |
113 | } | |
114 | } | |
115 | ||
116 | // special case two results to show the error variants only | |
117 | if let Some(result_enum) = famous_defs.core_result_Result() { | |
118 | if inner == result_enum && body == result_enum { | |
119 | let error_type_args = | |
120 | inner_ty.type_arguments().nth(1).zip(body_ty.type_arguments().nth(1)); | |
121 | if let Some((inner, body)) = error_type_args { | |
122 | inner_ty = inner; | |
123 | body_ty = body; | |
124 | s = "Try Error".to_owned(); | |
125 | } | |
126 | } | |
127 | } | |
128 | } | |
129 | ||
130 | let mut res = HoverResult::default(); | |
131 | ||
132 | let mut targets: Vec<hir::ModuleDef> = Vec::new(); | |
133 | let mut push_new_def = |item: hir::ModuleDef| { | |
134 | if !targets.contains(&item) { | |
135 | targets.push(item); | |
136 | } | |
137 | }; | |
138 | walk_and_push_ty(sema.db, &inner_ty, &mut push_new_def); | |
139 | walk_and_push_ty(sema.db, &body_ty, &mut push_new_def); | |
140 | res.actions.push(HoverAction::goto_type_from_targets(sema.db, targets)); | |
141 | ||
142 | let inner_ty = inner_ty.display(sema.db).to_string(); | |
143 | let body_ty = body_ty.display(sema.db).to_string(); | |
144 | let ty_len_max = inner_ty.len().max(body_ty.len()); | |
145 | ||
146 | let l = "Propagated as: ".len() - " Type: ".len(); | |
147 | let static_text_len_diff = l as isize - s.len() as isize; | |
148 | let tpad = static_text_len_diff.max(0) as usize; | |
149 | let ppad = static_text_len_diff.min(0).abs() as usize; | |
150 | ||
151 | res.markup = format!( | |
152 | "{bt_start}{} Type: {:>pad0$}\nPropagated as: {:>pad1$}\n{bt_end}", | |
153 | s, | |
154 | inner_ty, | |
155 | body_ty, | |
156 | pad0 = ty_len_max + tpad, | |
157 | pad1 = ty_len_max + ppad, | |
158 | bt_start = if config.markdown() { "```text\n" } else { "" }, | |
159 | bt_end = if config.markdown() { "```\n" } else { "" } | |
160 | ) | |
161 | .into(); | |
162 | Some(res) | |
163 | } | |
164 | ||
165 | pub(super) fn deref_expr( | |
166 | sema: &Semantics<'_, RootDatabase>, | |
167 | config: &HoverConfig, | |
168 | deref_expr: &ast::PrefixExpr, | |
169 | ) -> Option<HoverResult> { | |
170 | let inner_ty = sema.type_of_expr(&deref_expr.expr()?)?.original; | |
171 | let TypeInfo { original, adjusted } = | |
172 | sema.type_of_expr(&ast::Expr::from(deref_expr.clone()))?; | |
173 | ||
174 | let mut res = HoverResult::default(); | |
175 | let mut targets: Vec<hir::ModuleDef> = Vec::new(); | |
176 | let mut push_new_def = |item: hir::ModuleDef| { | |
177 | if !targets.contains(&item) { | |
178 | targets.push(item); | |
179 | } | |
180 | }; | |
181 | walk_and_push_ty(sema.db, &inner_ty, &mut push_new_def); | |
182 | walk_and_push_ty(sema.db, &original, &mut push_new_def); | |
183 | ||
184 | res.markup = if let Some(adjusted_ty) = adjusted { | |
185 | walk_and_push_ty(sema.db, &adjusted_ty, &mut push_new_def); | |
186 | let original = original.display(sema.db).to_string(); | |
187 | let adjusted = adjusted_ty.display(sema.db).to_string(); | |
188 | let inner = inner_ty.display(sema.db).to_string(); | |
189 | let type_len = "To type: ".len(); | |
190 | let coerced_len = "Coerced to: ".len(); | |
191 | let deref_len = "Dereferenced from: ".len(); | |
192 | let max_len = (original.len() + type_len) | |
193 | .max(adjusted.len() + coerced_len) | |
194 | .max(inner.len() + deref_len); | |
195 | format!( | |
196 | "{bt_start}Dereferenced from: {:>ipad$}\nTo type: {:>apad$}\nCoerced to: {:>opad$}\n{bt_end}", | |
197 | inner, | |
198 | original, | |
199 | adjusted, | |
200 | ipad = max_len - deref_len, | |
201 | apad = max_len - type_len, | |
202 | opad = max_len - coerced_len, | |
203 | bt_start = if config.markdown() { "```text\n" } else { "" }, | |
204 | bt_end = if config.markdown() { "```\n" } else { "" } | |
205 | ) | |
206 | .into() | |
207 | } else { | |
208 | let original = original.display(sema.db).to_string(); | |
209 | let inner = inner_ty.display(sema.db).to_string(); | |
210 | let type_len = "To type: ".len(); | |
211 | let deref_len = "Dereferenced from: ".len(); | |
212 | let max_len = (original.len() + type_len).max(inner.len() + deref_len); | |
213 | format!( | |
214 | "{bt_start}Dereferenced from: {:>ipad$}\nTo type: {:>apad$}\n{bt_end}", | |
215 | inner, | |
216 | original, | |
217 | ipad = max_len - deref_len, | |
218 | apad = max_len - type_len, | |
219 | bt_start = if config.markdown() { "```text\n" } else { "" }, | |
220 | bt_end = if config.markdown() { "```\n" } else { "" } | |
221 | ) | |
222 | .into() | |
223 | }; | |
224 | res.actions.push(HoverAction::goto_type_from_targets(sema.db, targets)); | |
225 | ||
226 | Some(res) | |
227 | } | |
228 | ||
229 | pub(super) fn keyword( | |
230 | sema: &Semantics<'_, RootDatabase>, | |
231 | config: &HoverConfig, | |
232 | token: &SyntaxToken, | |
233 | ) -> Option<HoverResult> { | |
f2b60f7d | 234 | if !token.kind().is_keyword() || !config.documentation.is_some() || !config.keywords { |
064997fb FG |
235 | return None; |
236 | } | |
237 | let parent = token.parent()?; | |
238 | let famous_defs = FamousDefs(sema, sema.scope(&parent)?.krate()); | |
239 | ||
240 | let KeywordHint { description, keyword_mod, actions } = keyword_hints(sema, token, parent); | |
241 | ||
242 | let doc_owner = find_std_module(&famous_defs, &keyword_mod)?; | |
243 | let docs = doc_owner.attrs(sema.db).docs()?; | |
244 | let markup = process_markup( | |
245 | sema.db, | |
246 | Definition::Module(doc_owner), | |
247 | &markup(Some(docs.into()), description, None)?, | |
248 | config, | |
249 | ); | |
250 | Some(HoverResult { markup, actions }) | |
251 | } | |
252 | ||
253 | pub(super) fn try_for_lint(attr: &ast::Attr, token: &SyntaxToken) -> Option<HoverResult> { | |
254 | let (path, tt) = attr.as_simple_call()?; | |
255 | if !tt.syntax().text_range().contains(token.text_range().start()) { | |
256 | return None; | |
257 | } | |
258 | let (is_clippy, lints) = match &*path { | |
259 | "feature" => (false, FEATURES), | |
260 | "allow" | "deny" | "forbid" | "warn" => { | |
261 | let is_clippy = algo::non_trivia_sibling(token.clone().into(), Direction::Prev) | |
262 | .filter(|t| t.kind() == T![:]) | |
263 | .and_then(|t| algo::non_trivia_sibling(t, Direction::Prev)) | |
264 | .filter(|t| t.kind() == T![:]) | |
265 | .and_then(|t| algo::non_trivia_sibling(t, Direction::Prev)) | |
266 | .map_or(false, |t| { | |
267 | t.kind() == T![ident] && t.into_token().map_or(false, |t| t.text() == "clippy") | |
268 | }); | |
269 | if is_clippy { | |
270 | (true, CLIPPY_LINTS) | |
271 | } else { | |
272 | (false, DEFAULT_LINTS) | |
273 | } | |
274 | } | |
275 | _ => return None, | |
276 | }; | |
277 | ||
278 | let tmp; | |
279 | let needle = if is_clippy { | |
280 | tmp = format!("clippy::{}", token.text()); | |
281 | &tmp | |
282 | } else { | |
283 | &*token.text() | |
284 | }; | |
285 | ||
286 | let lint = | |
287 | lints.binary_search_by_key(&needle, |lint| lint.label).ok().map(|idx| &lints[idx])?; | |
288 | Some(HoverResult { | |
289 | markup: Markup::from(format!("```\n{}\n```\n___\n\n{}", lint.label, lint.description)), | |
290 | ..Default::default() | |
291 | }) | |
292 | } | |
293 | ||
294 | pub(super) fn process_markup( | |
295 | db: &RootDatabase, | |
296 | def: Definition, | |
297 | markup: &Markup, | |
298 | config: &HoverConfig, | |
299 | ) -> Markup { | |
300 | let markup = markup.as_str(); | |
301 | let markup = if !config.markdown() { | |
302 | remove_markdown(markup) | |
303 | } else if config.links_in_hover { | |
304 | rewrite_links(db, markup, def) | |
305 | } else { | |
306 | remove_links(markup) | |
307 | }; | |
308 | Markup::from(markup) | |
309 | } | |
310 | ||
311 | fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option<String> { | |
312 | match def { | |
313 | Definition::Field(f) => Some(f.parent_def(db).name(db)), | |
314 | Definition::Local(l) => l.parent(db).name(db), | |
315 | Definition::Function(f) => match f.as_assoc_item(db)?.container(db) { | |
316 | hir::AssocItemContainer::Trait(t) => Some(t.name(db)), | |
317 | hir::AssocItemContainer::Impl(i) => i.self_ty(db).as_adt().map(|adt| adt.name(db)), | |
318 | }, | |
319 | Definition::Variant(e) => Some(e.parent_enum(db).name(db)), | |
320 | _ => None, | |
321 | } | |
322 | .map(|name| name.to_string()) | |
323 | } | |
324 | ||
325 | pub(super) fn path(db: &RootDatabase, module: hir::Module, item_name: Option<String>) -> String { | |
326 | let crate_name = | |
327 | db.crate_graph()[module.krate().into()].display_name.as_ref().map(|it| it.to_string()); | |
328 | let module_path = module | |
329 | .path_to_root(db) | |
330 | .into_iter() | |
331 | .rev() | |
332 | .flat_map(|it| it.name(db).map(|name| name.to_string())); | |
333 | crate_name.into_iter().chain(module_path).chain(item_name).join("::") | |
334 | } | |
335 | ||
336 | pub(super) fn definition( | |
337 | db: &RootDatabase, | |
338 | def: Definition, | |
339 | famous_defs: Option<&FamousDefs<'_, '_>>, | |
340 | config: &HoverConfig, | |
341 | ) -> Option<Markup> { | |
342 | let mod_path = definition_mod_path(db, &def); | |
343 | let (label, docs) = match def { | |
344 | Definition::Macro(it) => label_and_docs(db, it), | |
345 | Definition::Field(it) => label_and_docs(db, it), | |
346 | Definition::Module(it) => label_and_docs(db, it), | |
347 | Definition::Function(it) => label_and_docs(db, it), | |
348 | Definition::Adt(it) => label_and_docs(db, it), | |
349 | Definition::Variant(it) => label_and_docs(db, it), | |
350 | Definition::Const(it) => label_value_and_docs(db, it, |it| { | |
351 | let body = it.eval(db); | |
352 | match body { | |
353 | Ok(x) => Some(format!("{}", x)), | |
f2b60f7d FG |
354 | Err(_) => { |
355 | let source = it.source(db)?; | |
356 | let mut body = source.value.body()?.syntax().clone(); | |
357 | if source.file_id.is_macro() { | |
358 | body = insert_whitespace_into_node::insert_ws_into(body); | |
359 | } | |
360 | Some(body.to_string()) | |
361 | } | |
362 | } | |
363 | }), | |
364 | Definition::Static(it) => label_value_and_docs(db, it, |it| { | |
365 | let source = it.source(db)?; | |
366 | let mut body = source.value.body()?.syntax().clone(); | |
367 | if source.file_id.is_macro() { | |
368 | body = insert_whitespace_into_node::insert_ws_into(body); | |
064997fb | 369 | } |
f2b60f7d | 370 | Some(body.to_string()) |
064997fb | 371 | }), |
064997fb FG |
372 | Definition::Trait(it) => label_and_docs(db, it), |
373 | Definition::TypeAlias(it) => label_and_docs(db, it), | |
374 | Definition::BuiltinType(it) => { | |
375 | return famous_defs | |
376 | .and_then(|fd| builtin(fd, it)) | |
377 | .or_else(|| Some(Markup::fenced_block(&it.name()))) | |
378 | } | |
379 | Definition::Local(it) => return local(db, it), | |
380 | Definition::SelfType(impl_def) => { | |
381 | impl_def.self_ty(db).as_adt().map(|adt| label_and_docs(db, adt))? | |
382 | } | |
383 | Definition::GenericParam(it) => label_and_docs(db, it), | |
384 | Definition::Label(it) => return Some(Markup::fenced_block(&it.name(db))), | |
385 | // FIXME: We should be able to show more info about these | |
386 | Definition::BuiltinAttr(it) => return render_builtin_attr(db, it), | |
387 | Definition::ToolModule(it) => return Some(Markup::fenced_block(&it.name(db))), | |
388 | Definition::DeriveHelper(it) => (format!("derive_helper {}", it.name(db)), None), | |
389 | }; | |
390 | ||
391 | let docs = match config.documentation { | |
392 | Some(_) => docs.or_else(|| { | |
393 | // docs are missing, for assoc items of trait impls try to fall back to the docs of the | |
394 | // original item of the trait | |
395 | let assoc = def.as_assoc_item(db)?; | |
396 | let trait_ = assoc.containing_trait_impl(db)?; | |
397 | let name = Some(assoc.name(db)?); | |
398 | let item = trait_.items(db).into_iter().find(|it| it.name(db) == name)?; | |
399 | item.docs(db) | |
400 | }), | |
401 | None => None, | |
402 | }; | |
403 | let docs = docs.filter(|_| config.documentation.is_some()).map(Into::into); | |
404 | markup(docs, label, mod_path) | |
405 | } | |
406 | ||
407 | fn render_builtin_attr(db: &RootDatabase, attr: hir::BuiltinAttr) -> Option<Markup> { | |
408 | let name = attr.name(db); | |
409 | let desc = format!("#[{}]", name); | |
410 | ||
411 | let AttributeTemplate { word, list, name_value_str } = match attr.template(db) { | |
412 | Some(template) => template, | |
413 | None => return Some(Markup::fenced_block(&attr.name(db))), | |
414 | }; | |
415 | let mut docs = "Valid forms are:".to_owned(); | |
416 | if word { | |
417 | format_to!(docs, "\n - #\\[{}]", name); | |
418 | } | |
419 | if let Some(list) = list { | |
420 | format_to!(docs, "\n - #\\[{}({})]", name, list); | |
421 | } | |
422 | if let Some(name_value_str) = name_value_str { | |
423 | format_to!(docs, "\n - #\\[{} = {}]", name, name_value_str); | |
424 | } | |
425 | markup(Some(docs.replace('*', "\\*")), desc, None) | |
426 | } | |
427 | ||
428 | fn label_and_docs<D>(db: &RootDatabase, def: D) -> (String, Option<hir::Documentation>) | |
429 | where | |
430 | D: HasAttrs + HirDisplay, | |
431 | { | |
432 | let label = def.display(db).to_string(); | |
433 | let docs = def.attrs(db).docs(); | |
434 | (label, docs) | |
435 | } | |
436 | ||
437 | fn label_value_and_docs<D, E, V>( | |
438 | db: &RootDatabase, | |
439 | def: D, | |
440 | value_extractor: E, | |
441 | ) -> (String, Option<hir::Documentation>) | |
442 | where | |
443 | D: HasAttrs + HirDisplay, | |
444 | E: Fn(&D) -> Option<V>, | |
445 | V: Display, | |
446 | { | |
447 | let label = if let Some(value) = value_extractor(&def) { | |
448 | format!("{} = {}", def.display(db), value) | |
449 | } else { | |
450 | def.display(db).to_string() | |
451 | }; | |
452 | let docs = def.attrs(db).docs(); | |
453 | (label, docs) | |
454 | } | |
455 | ||
456 | fn definition_mod_path(db: &RootDatabase, def: &Definition) -> Option<String> { | |
457 | if let Definition::GenericParam(_) = def { | |
458 | return None; | |
459 | } | |
460 | def.module(db).map(|module| path(db, module, definition_owner_name(db, def))) | |
461 | } | |
462 | ||
463 | fn markup(docs: Option<String>, desc: String, mod_path: Option<String>) -> Option<Markup> { | |
464 | let mut buf = String::new(); | |
465 | ||
466 | if let Some(mod_path) = mod_path { | |
467 | if !mod_path.is_empty() { | |
468 | format_to!(buf, "```rust\n{}\n```\n\n", mod_path); | |
469 | } | |
470 | } | |
471 | format_to!(buf, "```rust\n{}\n```", desc); | |
472 | ||
473 | if let Some(doc) = docs { | |
474 | format_to!(buf, "\n___\n\n{}", doc); | |
475 | } | |
476 | Some(buf.into()) | |
477 | } | |
478 | ||
479 | fn builtin(famous_defs: &FamousDefs<'_, '_>, builtin: hir::BuiltinType) -> Option<Markup> { | |
480 | // std exposes prim_{} modules with docstrings on the root to document the builtins | |
481 | let primitive_mod = format!("prim_{}", builtin.name()); | |
482 | let doc_owner = find_std_module(famous_defs, &primitive_mod)?; | |
483 | let docs = doc_owner.attrs(famous_defs.0.db).docs()?; | |
484 | markup(Some(docs.into()), builtin.name().to_string(), None) | |
485 | } | |
486 | ||
487 | fn find_std_module(famous_defs: &FamousDefs<'_, '_>, name: &str) -> Option<hir::Module> { | |
488 | let db = famous_defs.0.db; | |
489 | let std_crate = famous_defs.std()?; | |
490 | let std_root_module = std_crate.root_module(db); | |
491 | std_root_module | |
492 | .children(db) | |
493 | .find(|module| module.name(db).map_or(false, |module| module.to_string() == name)) | |
494 | } | |
495 | ||
496 | fn local(db: &RootDatabase, it: hir::Local) -> Option<Markup> { | |
497 | let ty = it.ty(db); | |
498 | let ty = ty.display_truncated(db, None); | |
499 | let is_mut = if it.is_mut(db) { "mut " } else { "" }; | |
500 | let desc = match it.source(db).value { | |
501 | Either::Left(ident) => { | |
502 | let name = it.name(db); | |
503 | let let_kw = if ident | |
504 | .syntax() | |
505 | .parent() | |
506 | .map_or(false, |p| p.kind() == LET_STMT || p.kind() == LET_EXPR) | |
507 | { | |
508 | "let " | |
509 | } else { | |
510 | "" | |
511 | }; | |
512 | format!("{}{}{}: {}", let_kw, is_mut, name, ty) | |
513 | } | |
514 | Either::Right(_) => format!("{}self: {}", is_mut, ty), | |
515 | }; | |
516 | markup(None, desc, None) | |
517 | } | |
518 | ||
519 | struct KeywordHint { | |
520 | description: String, | |
521 | keyword_mod: String, | |
522 | actions: Vec<HoverAction>, | |
523 | } | |
524 | ||
525 | impl KeywordHint { | |
526 | fn new(description: String, keyword_mod: String) -> Self { | |
527 | Self { description, keyword_mod, actions: Vec::default() } | |
528 | } | |
529 | } | |
530 | ||
531 | fn keyword_hints( | |
532 | sema: &Semantics<'_, RootDatabase>, | |
533 | token: &SyntaxToken, | |
534 | parent: syntax::SyntaxNode, | |
535 | ) -> KeywordHint { | |
536 | match token.kind() { | |
537 | T![await] | T![loop] | T![match] | T![unsafe] | T![as] | T![try] | T![if] | T![else] => { | |
538 | let keyword_mod = format!("{}_keyword", token.text()); | |
539 | ||
540 | match ast::Expr::cast(parent).and_then(|site| sema.type_of_expr(&site)) { | |
541 | // ignore the unit type () | |
542 | Some(ty) if !ty.adjusted.as_ref().unwrap_or(&ty.original).is_unit() => { | |
543 | let mut targets: Vec<hir::ModuleDef> = Vec::new(); | |
544 | let mut push_new_def = |item: hir::ModuleDef| { | |
545 | if !targets.contains(&item) { | |
546 | targets.push(item); | |
547 | } | |
548 | }; | |
549 | walk_and_push_ty(sema.db, &ty.original, &mut push_new_def); | |
550 | ||
551 | let ty = ty.adjusted(); | |
552 | let description = format!("{}: {}", token.text(), ty.display(sema.db)); | |
553 | ||
554 | KeywordHint { | |
555 | description, | |
556 | keyword_mod, | |
557 | actions: vec![HoverAction::goto_type_from_targets(sema.db, targets)], | |
558 | } | |
559 | } | |
560 | _ => KeywordHint { | |
561 | description: token.text().to_string(), | |
562 | keyword_mod, | |
563 | actions: Vec::new(), | |
564 | }, | |
565 | } | |
566 | } | |
567 | T![fn] => { | |
568 | let module = match ast::FnPtrType::cast(parent) { | |
569 | // treat fn keyword inside function pointer type as primitive | |
570 | Some(_) => format!("prim_{}", token.text()), | |
571 | None => format!("{}_keyword", token.text()), | |
572 | }; | |
573 | KeywordHint::new(token.text().to_string(), module) | |
574 | } | |
575 | T![Self] => KeywordHint::new(token.text().to_string(), "self_upper_keyword".into()), | |
576 | _ => KeywordHint::new(token.text().to_string(), format!("{}_keyword", token.text())), | |
577 | } | |
578 | } |