X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=crates%2Fide%2Fsrc%2Fhover%2Frender.rs;h=ce9055c0909fa02d5f1471f76a8a3db684c58aae;hb=0b53744f2d7e0694cd7207cca632fd6de1dc5bff;hp=5b516de4c64b414ded21b2d194d9487f7cd12ed9;hpb=e60f3d265f74ba410ba52e10143fdbff56eaf342;p=rust.git diff --git a/crates/ide/src/hover/render.rs b/crates/ide/src/hover/render.rs index 5b516de4c64..ce9055c0909 100644 --- a/crates/ide/src/hover/render.rs +++ b/crates/ide/src/hover/render.rs @@ -1,6 +1,8 @@ //! Logic for rendering the different hover messages +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, @@ -16,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, }; @@ -86,8 +88,8 @@ pub(super) fn try_expr( ast::Fn(fn_) => sema.to_def(&fn_)?.ret_type(sema.db), ast::Item(__) => return None, ast::ClosureExpr(closure) => sema.type_of_expr(&closure.body()?)?.original, - ast::EffectExpr(effect) => if matches!(effect.effect(), ast::Effect::Async(_) | ast::Effect::Try(_)| ast::Effect::Const(_)) { - sema.type_of_expr(&effect.block_expr()?.into())?.original + ast::BlockExpr(block_expr) => if matches!(block_expr.modifier(), Some(ast::BlockModifier::Async(_) | ast::BlockModifier::Try(_)| ast::BlockModifier::Const(_))) { + sema.type_of_expr(&block_expr.into())?.original } else { continue; }, @@ -235,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::ModuleDef(doc_owner.into()), - &markup(Some(docs.into()), token.text().into(), None)?, + Definition::Module(doc_owner), + &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 { @@ -311,14 +315,11 @@ fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option match def { Definition::Field(f) => Some(f.parent_def(db).name(db)), Definition::Local(l) => l.parent(db).name(db), - Definition::ModuleDef(md) => match md { - hir::ModuleDef::Function(f) => match f.as_assoc_item(db)?.container(db) { - hir::AssocItemContainer::Trait(t) => Some(t.name(db)), - hir::AssocItemContainer::Impl(i) => i.self_ty(db).as_adt().map(|adt| adt.name(db)), - }, - hir::ModuleDef::Variant(e) => Some(e.parent_enum(db).name(db)), - _ => None, + Definition::Function(f) => match f.as_assoc_item(db)?.container(db) { + hir::AssocItemContainer::Trait(t) => Some(t.name(db)), + hir::AssocItemContainer::Impl(i) => i.self_ty(db).as_adt().map(|adt| adt.name(db)), }, + Definition::Variant(e) => Some(e.parent_enum(db).name(db)), _ => None, } .map(|name| name.to_string()) @@ -351,32 +352,60 @@ pub(super) fn definition( it.attrs(db).docs(), ), Definition::Field(def) => label_and_docs(db, def), - Definition::ModuleDef(it) => match it { - hir::ModuleDef::Module(it) => label_and_docs(db, it), - hir::ModuleDef::Function(it) => label_and_docs(db, it), - hir::ModuleDef::Adt(it) => label_and_docs(db, it), - hir::ModuleDef::Variant(it) => label_and_docs(db, it), - hir::ModuleDef::Const(it) => label_and_docs(db, it), - hir::ModuleDef::Static(it) => label_and_docs(db, it), - hir::ModuleDef::Trait(it) => label_and_docs(db, it), - hir::ModuleDef::TypeAlias(it) => label_and_docs(db, it), - hir::ModuleDef::BuiltinType(it) => { - return famous_defs - .and_then(|fd| builtin(fd, it)) - .or_else(|| Some(Markup::fenced_block(&it.name()))) + Definition::Module(it) => label_and_docs(db, it), + 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| { + 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), + Definition::BuiltinType(it) => { + return famous_defs + .and_then(|fd| builtin(fd, it)) + .or_else(|| Some(Markup::fenced_block(&it.name()))) + } Definition::Local(it) => return local(db, it), Definition::SelfType(impl_def) => { impl_def.self_ty(db).as_adt().map(|adt| label_and_docs(db, adt))? } 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, @@ -386,6 +415,25 @@ fn label_and_docs(db: &RootDatabase, def: D) -> (String, Option( + db: &RootDatabase, + def: D, + value_extractor: E, +) -> (String, Option) +where + D: HasAttrs + HirDisplay, + E: Fn(&D) -> Option, + V: Display, +{ + let label = if let Some(value) = value_extractor(&def) { + format!("{} = {}", def.display(db), value) + } else { + def.display(db).to_string() + }; + let docs = def.attrs(db).docs(); + (label, docs) +} + fn definition_mod_path(db: &RootDatabase, def: &Definition) -> Option { if let Definition::GenericParam(_) = def { return None; @@ -428,7 +476,7 @@ fn find_std_module(famous_defs: &FamousDefs, name: &str) -> Option fn local(db: &RootDatabase, it: hir::Local) -> Option { let ty = it.ty(db); - let ty = ty.display(db); + let ty = ty.display_truncated(db, None); let is_mut = if it.is_mut(db) { "mut " } else { "" }; let desc = match it.source(db).value { Either::Left(ident) => { @@ -436,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 { @@ -448,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())), + } +}