rust/crates/ra_ide_api/src/hover.rs

696 lines
21 KiB
Rust
Raw Normal View History

2019-01-26 02:20:30 -06:00
use ra_db::SourceDatabase;
2019-01-08 13:33:36 -06:00
use ra_syntax::{
2019-06-11 09:22:14 -05:00
AstNode, TreeArc,
ast::{self, DocCommentsOwner},
2019-06-10 12:18:32 -05:00
algo::{find_covering_element, find_node_at_offset, ancestors_at_offset, visit::{visitor, Visitor}},
2019-01-08 13:33:36 -06:00
};
2019-06-11 09:54:51 -05:00
use hir::{HirDisplay, HasSource};
2019-01-08 13:33:36 -06:00
2019-05-30 12:46:43 -05:00
use crate::{
db::RootDatabase,
RangeInfo, FilePosition, FileRange,
2019-06-10 12:18:32 -05:00
display::{rust_code_markup, rust_code_markup_with_doc, ShortLabel, docs_from_symbol, description_from_symbol},
2019-06-10 11:34:43 -05:00
name_ref_kind::{NameRefKind::*, classify_name_ref},
2019-05-30 12:46:43 -05:00
};
2019-01-08 13:33:36 -06:00
/// Contains the results when hovering over an item
#[derive(Debug, Clone)]
pub struct HoverResult {
results: Vec<String>,
exact: bool,
}
2019-06-04 01:32:02 -05:00
impl Default for HoverResult {
fn default() -> Self {
HoverResult::new()
}
}
impl HoverResult {
pub fn new() -> HoverResult {
HoverResult {
results: Vec::new(),
// We assume exact by default
exact: true,
}
}
pub fn extend(&mut self, item: Option<String>) {
self.results.extend(item);
}
pub fn is_exact(&self) -> bool {
self.exact
}
pub fn is_empty(&self) -> bool {
self.results.is_empty()
}
pub fn len(&self) -> usize {
self.results.len()
}
pub fn first(&self) -> Option<&str> {
self.results.first().map(String::as_str)
}
pub fn results(&self) -> &[String] {
&self.results
}
/// Returns the results converted into markup
/// for displaying in a UI
pub fn to_markup(&self) -> String {
let mut markup = if !self.exact {
let mut msg = String::from("Failed to exactly resolve the symbol. This is probably because rust_analyzer does not yet support traits.");
if !self.results.is_empty() {
msg.push_str(" \nThese items were found instead:");
}
msg.push_str("\n\n---\n");
msg
} else {
String::new()
};
markup.push_str(&self.results.join("\n\n---\n"));
markup
}
}
2019-06-10 11:34:43 -05:00
fn hover_text(docs: Option<String>, desc: Option<String>) -> Option<String> {
match (desc, docs) {
(Some(desc), docs) => Some(rust_code_markup_with_doc(desc, docs)),
(None, Some(docs)) => Some(docs.to_string()),
_ => None,
}
}
pub(crate) fn hover(db: &RootDatabase, position: FilePosition) -> Option<RangeInfo<HoverResult>> {
2019-05-28 10:46:11 -05:00
let file = db.parse(position.file_id).tree;
let mut res = HoverResult::new();
2019-01-08 13:33:36 -06:00
let mut range = None;
if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
2019-06-10 11:34:43 -05:00
let analyzer = hir::SourceAnalyzer::new(db, position.file_id, name_ref.syntax(), None);
2019-06-11 09:32:33 -05:00
let mut no_fallback = false;
2019-06-10 11:34:43 -05:00
match classify_name_ref(db, &analyzer, name_ref) {
2019-06-11 09:22:14 -05:00
Some(Method(it)) => res.extend(from_def_source(db, it)),
2019-06-10 11:34:43 -05:00
Some(Macro(it)) => {
2019-06-11 09:40:18 -05:00
let src = it.source(db);
res.extend(hover_text(src.ast.doc_comment_text(), None));
2019-06-10 11:34:43 -05:00
}
Some(FieldAccess(it)) => {
2019-06-11 09:43:36 -05:00
let src = it.source(db);
if let hir::FieldSource::Named(it) = src.ast {
2019-06-10 11:34:43 -05:00
res.extend(hover_text(it.doc_comment_text(), it.short_label()));
}
}
2019-06-11 09:25:55 -05:00
Some(AssocItem(it)) => res.extend(match it {
hir::ImplItem::Method(it) => from_def_source(db, it),
hir::ImplItem::Const(it) => from_def_source(db, it),
hir::ImplItem::TypeAlias(it) => from_def_source(db, it),
}),
2019-06-10 11:34:43 -05:00
Some(Def(it)) => {
match it {
hir::ModuleDef::Module(it) => {
2019-06-11 09:47:24 -05:00
if let hir::ModuleSource::Module(it) = it.definition_source(db).ast {
2019-06-10 11:34:43 -05:00
res.extend(hover_text(it.doc_comment_text(), it.short_label()))
}
}
2019-06-11 09:22:14 -05:00
hir::ModuleDef::Function(it) => res.extend(from_def_source(db, it)),
hir::ModuleDef::Struct(it) => res.extend(from_def_source(db, it)),
hir::ModuleDef::Union(it) => res.extend(from_def_source(db, it)),
hir::ModuleDef::Enum(it) => res.extend(from_def_source(db, it)),
2019-06-11 09:34:01 -05:00
hir::ModuleDef::EnumVariant(it) => res.extend(from_def_source(db, it)),
2019-06-11 09:22:14 -05:00
hir::ModuleDef::Const(it) => res.extend(from_def_source(db, it)),
hir::ModuleDef::Static(it) => res.extend(from_def_source(db, it)),
2019-06-11 09:34:01 -05:00
hir::ModuleDef::Trait(it) => res.extend(from_def_source(db, it)),
2019-06-11 09:25:55 -05:00
hir::ModuleDef::TypeAlias(it) => res.extend(from_def_source(db, it)),
2019-06-10 11:34:43 -05:00
hir::ModuleDef::BuiltinType(_) => {
// FIXME: hover for builtin Type ?
}
}
}
Some(SelfType(ty)) => {
if let Some((adt_def, _)) = ty.as_adt() {
2019-06-11 09:26:36 -05:00
res.extend(match adt_def {
hir::AdtDef::Struct(it) => from_def_source(db, it),
hir::AdtDef::Union(it) => from_def_source(db, it),
hir::AdtDef::Enum(it) => from_def_source(db, it),
})
2019-06-10 11:34:43 -05:00
}
}
2019-06-11 09:32:33 -05:00
Some(Pat(_)) | Some(SelfParam(_)) => {
// Hover for these shows type names
no_fallback = true;
}
2019-06-10 11:34:43 -05:00
Some(GenericParam(_)) => {
// FIXME: Hover for generic param
}
None => {}
2019-01-08 13:33:36 -06:00
}
2019-06-10 11:34:43 -05:00
2019-06-11 09:32:33 -05:00
if res.is_empty() && !no_fallback {
2019-06-10 11:34:43 -05:00
// Fallback index based approach:
let symbols = crate::symbol_index::index_resolve(db, name_ref);
for sym in symbols {
let docs = docs_from_symbol(db, &sym);
let desc = description_from_symbol(db, &sym);
res.extend(hover_text(docs, desc));
}
}
2019-01-08 13:33:36 -06:00
if !res.is_empty() {
range = Some(name_ref.syntax().range())
}
} else if let Some(name) = find_node_at_offset::<ast::Name>(file.syntax(), position.offset) {
2019-06-10 12:18:32 -05:00
if let Some(parent) = name.syntax().parent() {
let text = visitor()
.visit(|node: &ast::StructDef| {
hover_text(node.doc_comment_text(), node.short_label())
})
.visit(|node: &ast::EnumDef| {
hover_text(node.doc_comment_text(), node.short_label())
})
.visit(|node: &ast::EnumVariant| {
hover_text(node.doc_comment_text(), node.short_label())
})
.visit(|node: &ast::FnDef| hover_text(node.doc_comment_text(), node.short_label()))
.visit(|node: &ast::TypeAliasDef| {
hover_text(node.doc_comment_text(), node.short_label())
})
.visit(|node: &ast::ConstDef| {
hover_text(node.doc_comment_text(), node.short_label())
})
.visit(|node: &ast::StaticDef| {
hover_text(node.doc_comment_text(), node.short_label())
})
.visit(|node: &ast::TraitDef| {
hover_text(node.doc_comment_text(), node.short_label())
})
.visit(|node: &ast::NamedFieldDef| {
hover_text(node.doc_comment_text(), node.short_label())
})
.visit(|node: &ast::Module| hover_text(node.doc_comment_text(), node.short_label()))
.visit(|node: &ast::MacroCall| hover_text(node.doc_comment_text(), None))
.accept(parent);
2019-06-10 12:18:32 -05:00
if let Some(text) = text {
res.extend(text);
}
}
if !res.is_empty() && range.is_none() {
range = Some(name.syntax().range());
}
2019-01-08 13:33:36 -06:00
}
2019-01-08 13:33:36 -06:00
if range.is_none() {
let node = ancestors_at_offset(file.syntax(), position.offset)
.find(|n| ast::Expr::cast(*n).is_some() || ast::Pat::cast(*n).is_some())?;
2019-02-08 05:49:43 -06:00
let frange = FileRange { file_id: position.file_id, range: node.range() };
res.extend(type_of(db, frange).map(rust_code_markup));
2019-01-08 13:33:36 -06:00
range = Some(node.range());
}
2019-01-08 13:33:36 -06:00
2019-01-15 12:02:42 -06:00
let range = range?;
2019-01-08 13:33:36 -06:00
if res.is_empty() {
2019-01-15 12:02:42 -06:00
return None;
2019-01-08 13:33:36 -06:00
}
let res = RangeInfo::new(range, res);
2019-06-11 09:22:14 -05:00
return Some(res);
fn from_def_source<A, D>(db: &RootDatabase, def: D) -> Option<String>
where
2019-06-11 09:54:51 -05:00
D: HasSource<Ast = TreeArc<A>>,
2019-06-11 09:22:14 -05:00
A: ast::DocCommentsOwner + ast::NameOwner + ShortLabel,
{
let src = def.source(db);
hover_text(src.ast.doc_comment_text(), src.ast.short_label())
}
2019-01-08 13:33:36 -06:00
}
2019-01-15 12:02:42 -06:00
pub(crate) fn type_of(db: &RootDatabase, frange: FileRange) -> Option<String> {
2019-05-28 10:46:11 -05:00
let file = db.parse(frange.file_id).tree;
2019-01-08 13:33:36 -06:00
let syntax = file.syntax();
2019-03-30 05:25:53 -05:00
let leaf_node = find_covering_element(syntax, frange.range);
2019-01-08 13:33:36 -06:00
// if we picked identifier, expand to pattern/expression
let node = leaf_node
.ancestors()
.take_while(|it| it.range() == leaf_node.range())
2019-03-30 05:25:53 -05:00
.find(|&it| ast::Expr::cast(it).is_some() || ast::Pat::cast(it).is_some())?;
let analyzer = hir::SourceAnalyzer::new(db, frange.file_id, node, None);
2019-04-10 03:15:55 -05:00
let ty = if let Some(ty) = ast::Expr::cast(node).and_then(|e| analyzer.type_of(db, e)) {
ty
} else if let Some(ty) = ast::Pat::cast(node).and_then(|p| analyzer.type_of_pat(db, p)) {
ty
2019-01-08 13:33:36 -06:00
} else {
2019-04-10 03:15:55 -05:00
return None;
};
Some(ty.display(db).to_string())
2019-01-08 13:33:36 -06:00
}
#[cfg(test)]
mod tests {
use ra_syntax::TextRange;
use crate::mock_analysis::{single_file_with_position, single_file_with_range, analysis_and_position};
fn trim_markup(s: &str) -> &str {
s.trim_start_matches("```rust\n").trim_end_matches("\n```")
}
fn trim_markup_opt(s: Option<&str>) -> Option<&str> {
s.map(trim_markup)
}
fn check_hover_result(fixture: &str, expected: &[&str]) {
let (analysis, position) = analysis_and_position(fixture);
let hover = analysis.hover(position).unwrap().unwrap();
2019-05-30 12:46:43 -05:00
let mut results = Vec::from(hover.info.results());
results.sort();
for (markup, expected) in
2019-05-30 12:46:43 -05:00
results.iter().zip(expected.iter().chain(std::iter::repeat(&"<missing>")))
{
assert_eq!(trim_markup(&markup), *expected);
}
assert_eq!(hover.info.len(), expected.len());
}
2019-01-08 13:33:36 -06:00
#[test]
fn hover_shows_type_of_an_expression() {
let (analysis, position) = single_file_with_position(
"
pub fn foo() -> u32 { 1 }
fn main() {
let foo_test = foo()<|>;
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(hover.range, TextRange::from_to(95.into(), 100.into()));
assert_eq!(trim_markup_opt(hover.info.first()), Some("u32"));
}
#[test]
fn hover_shows_fn_signature() {
// Single file with result
check_hover_result(
r#"
//- /main.rs
pub fn foo() -> u32 { 1 }
fn main() {
let foo_test = fo<|>o();
}
"#,
&["pub fn foo() -> u32"],
);
// Multiple results
check_hover_result(
r#"
//- /a.rs
pub fn foo() -> u32 { 1 }
//- /b.rs
pub fn foo() -> &str { "" }
//- /c.rs
pub fn foo(a: u32, b: u32) {}
//- /main.rs
mod a;
mod b;
mod c;
fn main() {
let foo_test = fo<|>o();
}
"#,
&["pub fn foo() -> &str", "pub fn foo() -> u32", "pub fn foo(a: u32, b: u32)"],
);
}
#[test]
fn hover_shows_fn_signature_with_type_params() {
check_hover_result(
r#"
//- /main.rs
pub fn foo<'a, T: AsRef<str>>(b: &'a T) -> &'a str { }
fn main() {
let foo_test = fo<|>o();
}
"#,
&["pub fn foo<'a, T: AsRef<str>>(b: &'a T) -> &'a str"],
);
2019-01-08 13:33:36 -06:00
}
#[test]
fn hover_shows_fn_signature_on_fn_name() {
check_hover_result(
r#"
//- /main.rs
pub fn foo<|>(a: u32, b: u32) -> u32 {}
fn main() {
}
"#,
&["pub fn foo(a: u32, b: u32) -> u32"],
);
}
#[test]
fn hover_shows_struct_field_info() {
// Hovering over the field when instantiating
check_hover_result(
r#"
//- /main.rs
struct Foo {
field_a: u32,
}
fn main() {
let foo = Foo {
field_a<|>: 0,
};
}
"#,
&["field_a: u32"],
);
// Hovering over the field in the definition
check_hover_result(
r#"
//- /main.rs
struct Foo {
field_a<|>: u32,
}
fn main() {
let foo = Foo {
field_a: 0,
};
}
"#,
&["field_a: u32"],
);
}
#[test]
fn hover_const_static() {
check_hover_result(
r#"
//- /main.rs
fn main() {
const foo<|>: u32 = 0;
}
"#,
&["const foo: u32"],
);
check_hover_result(
r#"
//- /main.rs
fn main() {
static foo<|>: u32 = 0;
}
"#,
&["static foo: u32"],
);
}
#[test]
fn hover_some() {
let (analysis, position) = single_file_with_position(
"
enum Option<T> { Some(T) }
use Option::Some;
fn main() {
So<|>me(12);
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("Some"));
let (analysis, position) = single_file_with_position(
"
enum Option<T> { Some(T) }
use Option::Some;
fn main() {
let b<|>ar = Some(12);
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("Option<i32>"));
}
#[test]
fn hover_enum_variant() {
check_hover_result(
r#"
//- /main.rs
enum Option<T> {
/// The None variant
Non<|>e
}
"#,
&["
None
```
The None variant
"
.trim()],
);
check_hover_result(
r#"
//- /main.rs
enum Option<T> {
/// The Some variant
Some(T)
}
fn main() {
let s = Option::Som<|>e(12);
}
"#,
&["
Some
```
The Some variant
"
.trim()],
);
}
2019-01-08 13:33:36 -06:00
#[test]
fn hover_for_local_variable() {
let (analysis, position) = single_file_with_position("fn func(foo: i32) { fo<|>o; }");
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
2019-01-08 13:33:36 -06:00
}
#[test]
fn hover_for_local_variable_pat() {
let (analysis, position) = single_file_with_position("fn func(fo<|>o: i32) {}");
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
2019-01-08 13:33:36 -06:00
}
#[test]
fn hover_local_var_edge() {
let (analysis, position) = single_file_with_position(
"
fn func(foo: i32) { if true { <|>foo; }; }
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
}
2019-01-08 13:33:36 -06:00
#[test]
fn test_type_of_for_function() {
let (analysis, range) = single_file_with_range(
"
pub fn foo() -> u32 { 1 };
fn main() {
let foo_test = <|>foo()<|>;
}
",
);
let type_name = analysis.type_of(range).unwrap().unwrap();
assert_eq!("u32", &type_name);
}
#[test]
fn test_type_of_for_expr() {
2019-01-08 13:33:36 -06:00
let (analysis, range) = single_file_with_range(
"
fn main() {
let foo: usize = 1;
let bar = <|>1 + foo<|>;
2019-01-08 13:33:36 -06:00
}
",
);
let type_name = analysis.type_of(range).unwrap().unwrap();
assert_eq!("usize", &type_name);
2019-01-08 13:33:36 -06:00
}
#[test]
fn test_hover_infer_associated_method_result() {
let (analysis, position) = single_file_with_position(
"
struct Thing { x: u32 }
impl Thing {
fn new() -> Thing {
Thing { x: 0 }
}
}
fn main() {
let foo_<|>test = Thing::new();
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("Thing"));
}
#[test]
fn test_hover_infer_associated_method_exact() {
let (analysis, position) = single_file_with_position(
"
struct Thing { x: u32 }
impl Thing {
fn new() -> Thing {
Thing { x: 0 }
}
}
fn main() {
let foo_test = Thing::new<|>();
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
2019-03-02 13:05:37 -06:00
assert_eq!(trim_markup_opt(hover.info.first()), Some("fn new() -> Thing"));
assert_eq!(hover.info.is_exact(), true);
}
2019-03-06 10:39:11 -06:00
#[test]
fn test_hover_infer_associated_const_in_pattern() {
let (analysis, position) = single_file_with_position(
"
struct X;
impl X {
const C: u32 = 1;
}
fn main() {
match 1 {
X::C<|> => {},
2 => {},
_ => {}
};
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("const C: u32"));
assert_eq!(hover.info.is_exact(), true);
}
#[test]
fn test_hover_self() {
let (analysis, position) = single_file_with_position(
"
struct Thing { x: u32 }
impl Thing {
fn new() -> Self {
Self<|> { x: 0 }
}
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("struct Thing"));
assert_eq!(hover.info.is_exact(), true);
let (analysis, position) = single_file_with_position(
"
struct Thing { x: u32 }
impl Thing {
fn new() -> Self<|> {
Self { x: 0 }
}
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("struct Thing"));
assert_eq!(hover.info.is_exact(), true);
let (analysis, position) = single_file_with_position(
"
enum Thing { A }
impl Thing {
pub fn new() -> Self<|> {
Thing::A
}
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("enum Thing"));
assert_eq!(hover.info.is_exact(), true);
let (analysis, position) = single_file_with_position(
"
enum Thing { A }
impl Thing {
pub fn thing(a: Self<|>) {
}
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("enum Thing"));
assert_eq!(hover.info.is_exact(), true);
}
2019-06-11 09:32:33 -05:00
#[test]
fn test_hover_shadowing_pat() {
let (analysis, position) = single_file_with_position(
"
fn x() {}
fn y() {
let x = 0i32;
x<|>;
}
",
);
let hover = analysis.hover(position).unwrap().unwrap();
assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
assert_eq!(hover.info.is_exact(), true);
}
2019-01-08 13:33:36 -06:00
}