X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=crates%2Fide%2Fsrc%2Fhover%2Frender.rs;h=ce9055c0909fa02d5f1471f76a8a3db684c58aae;hb=0b53744f2d7e0694cd7207cca632fd6de1dc5bff;hp=dd4a961d31c30b79684665185c4f7a20312692f6;hpb=393cbd0982707a20b0ef40277385737f8de1833e;p=rust.git diff --git a/crates/ide/src/hover/render.rs b/crates/ide/src/hover/render.rs index dd4a961d31c..ce9055c0909 100644 --- a/crates/ide/src/hover/render.rs +++ b/crates/ide/src/hover/render.rs @@ -2,7 +2,7 @@ use std::fmt::Display; use either::Either; -use hir::{AsAssocItem, HasAttrs, HasSource, HirDisplay, Semantics, TypeInfo}; +use hir::{AsAssocItem, AttributeTemplate, HasAttrs, HasSource, HirDisplay, Semantics, TypeInfo}; use ide_db::{ base_db::SourceDatabase, defs::Definition, @@ -18,7 +18,7 @@ algo, ast, display::{fn_as_proc_macro_label, macro_label}, match_ast, AstNode, Direction, - SyntaxKind::{CONDITION, LET_STMT}, + SyntaxKind::{LET_EXPR, LET_STMT}, SyntaxToken, T, }; @@ -237,18 +237,20 @@ pub(super) fn keyword( if !token.kind().is_keyword() || !config.documentation.is_some() { return None; } - let famous_defs = FamousDefs(sema, sema.scope(&token.parent()?).krate()); - // std exposes {}_keyword modules with docstrings on the root to document keywords - let keyword_mod = format!("{}_keyword", token.text()); + let parent = token.parent()?; + let famous_defs = FamousDefs(sema, sema.scope(&parent).krate()); + + let KeywordHint { description, keyword_mod, actions } = keyword_hints(sema, token, parent); + let doc_owner = find_std_module(&famous_defs, &keyword_mod)?; let docs = doc_owner.attrs(sema.db).docs()?; let markup = process_markup( sema.db, Definition::Module(doc_owner), - &markup(Some(docs.into()), token.text().into(), None)?, + &markup(Some(docs.into()), description, None)?, config, ); - Some(HoverResult { markup, actions: Default::default() }) + Some(HoverResult { markup, actions }) } pub(super) fn try_for_lint(attr: &ast::Attr, token: &SyntaxToken) -> Option { @@ -354,7 +356,13 @@ pub(super) fn definition( Definition::Function(it) => label_and_docs(db, it), Definition::Adt(it) => label_and_docs(db, it), Definition::Variant(it) => label_and_docs(db, it), - Definition::Const(it) => label_value_and_docs(db, it, |it| it.value(db)), + Definition::Const(it) => label_value_and_docs(db, it, |it| { + let body = it.eval(db); + match body { + Ok(x) => Some(format!("{}", x)), + Err(_) => it.value(db).map(|x| format!("{}", x)), + } + }), Definition::Static(it) => label_value_and_docs(db, it, |it| it.value(db)), Definition::Trait(it) => label_and_docs(db, it), Definition::TypeAlias(it) => label_and_docs(db, it), @@ -369,11 +377,35 @@ pub(super) fn definition( } Definition::GenericParam(it) => label_and_docs(db, it), Definition::Label(it) => return Some(Markup::fenced_block(&it.name(db))), + // FIXME: We should be able to show more info about these + Definition::BuiltinAttr(it) => return render_builtin_attr(db, it), + Definition::ToolModule(it) => return Some(Markup::fenced_block(&it.name(db))), }; markup(docs.filter(|_| config.documentation.is_some()).map(Into::into), label, mod_path) } +fn render_builtin_attr(db: &RootDatabase, attr: hir::BuiltinAttr) -> Option { + let name = attr.name(db); + let desc = format!("#[{}]", name); + + let AttributeTemplate { word, list, name_value_str } = match attr.template(db) { + Some(template) => template, + None => return Some(Markup::fenced_block(&attr.name(db))), + }; + let mut docs = "Valid forms are:".to_owned(); + if word { + format_to!(docs, "\n - #\\[{}]", name); + } + if let Some(list) = list { + format_to!(docs, "\n - #\\[{}({})]", name, list); + } + if let Some(name_value_str) = name_value_str { + format_to!(docs, "\n - #\\[{} = {}]", name, name_value_str); + } + markup(Some(docs.replace('*', "\\*")), desc, None) +} + fn label_and_docs(db: &RootDatabase, def: D) -> (String, Option) where D: HasAttrs + HirDisplay, @@ -393,7 +425,7 @@ fn label_value_and_docs( E: Fn(&D) -> Option, V: Display, { - let label = if let Some(value) = (value_extractor)(&def) { + let label = if let Some(value) = value_extractor(&def) { format!("{} = {}", def.display(db), value) } else { def.display(db).to_string() @@ -452,7 +484,7 @@ fn local(db: &RootDatabase, it: hir::Local) -> Option { let let_kw = if ident .syntax() .parent() - .map_or(false, |p| p.kind() == LET_STMT || p.kind() == CONDITION) + .map_or(false, |p| p.kind() == LET_STMT || p.kind() == LET_EXPR) { "let " } else { @@ -464,3 +496,65 @@ fn local(db: &RootDatabase, it: hir::Local) -> Option { }; markup(None, desc, None) } + +struct KeywordHint { + description: String, + keyword_mod: String, + actions: Vec, +} + +impl KeywordHint { + fn new(description: String, keyword_mod: String) -> Self { + Self { description, keyword_mod, actions: Vec::default() } + } +} + +fn keyword_hints( + sema: &Semantics, + token: &SyntaxToken, + parent: syntax::SyntaxNode, +) -> KeywordHint { + match token.kind() { + T![await] | T![loop] | T![match] | T![unsafe] | T![as] | T![try] | T![if] | T![else] => { + let keyword_mod = format!("{}_keyword", token.text()); + + match ast::Expr::cast(parent).and_then(|site| sema.type_of_expr(&site)) { + // ignore the unit type () + Some(ty) if !ty.adjusted.as_ref().unwrap_or(&ty.original).is_unit() => { + let mut targets: Vec = Vec::new(); + let mut push_new_def = |item: hir::ModuleDef| { + if !targets.contains(&item) { + targets.push(item); + } + }; + walk_and_push_ty(sema.db, &ty.original, &mut push_new_def); + + let ty = ty.adjusted(); + let description = format!("{}: {}", token.text(), ty.display(sema.db)); + + KeywordHint { + description, + keyword_mod, + actions: vec![HoverAction::goto_type_from_targets(sema.db, targets)], + } + } + _ => KeywordHint { + description: token.text().to_string(), + keyword_mod, + actions: Vec::new(), + }, + } + } + + T![fn] => { + let module = match ast::FnPtrType::cast(parent) { + // treat fn keyword inside function pointer type as primitive + Some(_) => format!("prim_{}", token.text()), + None => format!("{}_keyword", token.text()), + }; + KeywordHint::new(token.text().to_string(), module) + } + + _ => KeywordHint::new(token.text().to_string(), format!("{}_keyword", token.text())), + } +}