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
|
|
|
|
2019-02-26 10:56:04 -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()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-26 10:56:04 -06:00
|
|
|
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 {
|
2019-02-28 13:48:21 -06:00
|
|
|
let mut msg = String::from("Failed to exactly resolve the symbol. This is probably because rust_analyzer does not yet support traits.");
|
2019-02-26 10:56:04 -06:00
|
|
|
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,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-26 10:56:04 -06:00
|
|
|
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;
|
2019-02-26 10:56:04 -06:00
|
|
|
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-01-13 04:31:37 -06:00
|
|
|
}
|
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())
|
|
|
|
}
|
2019-02-27 01:49:22 -06:00
|
|
|
} 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-02-27 01:49:22 -06:00
|
|
|
|
2019-06-10 12:18:32 -05:00
|
|
|
if let Some(text) = text {
|
|
|
|
res.extend(text);
|
2019-02-27 01:49:22 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !res.is_empty() && range.is_none() {
|
|
|
|
range = Some(name.syntax().range());
|
|
|
|
}
|
2019-01-08 13:33:36 -06:00
|
|
|
}
|
2019-02-26 10:56:04 -06:00
|
|
|
|
2019-01-08 13:33:36 -06:00
|
|
|
if range.is_none() {
|
2019-04-28 08:43:10 -05:00
|
|
|
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() };
|
2019-02-28 01:33:06 -06:00
|
|
|
res.extend(type_of(db, frange).map(rust_code_markup));
|
2019-01-08 13:33:36 -06:00
|
|
|
range = Some(node.range());
|
2019-02-27 01:49:22 -06:00
|
|
|
}
|
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
|
|
|
}
|
2019-02-26 10:56:04 -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())?;
|
2019-04-12 16:44:47 -05:00
|
|
|
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;
|
2019-02-26 10:56:04 -06:00
|
|
|
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```")
|
|
|
|
}
|
|
|
|
|
2019-02-28 01:33:06 -06:00
|
|
|
fn trim_markup_opt(s: Option<&str>) -> Option<&str> {
|
|
|
|
s.map(trim_markup)
|
|
|
|
}
|
|
|
|
|
2019-02-26 10:56:04 -06:00
|
|
|
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();
|
2019-02-26 10:56:04 -06:00
|
|
|
|
|
|
|
for (markup, expected) in
|
2019-05-30 12:46:43 -05:00
|
|
|
results.iter().zip(expected.iter().chain(std::iter::repeat(&"<missing>")))
|
2019-02-26 10:56:04 -06:00
|
|
|
{
|
|
|
|
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()));
|
2019-02-28 01:33:06 -06:00
|
|
|
assert_eq!(trim_markup_opt(hover.info.first()), Some("u32"));
|
2019-02-26 10:56:04 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#[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
|
|
|
}
|
|
|
|
|
2019-02-27 01:49:22 -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"],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-02-27 09:52:37 -06:00
|
|
|
#[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"],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-02-20 15:36:54 -06:00
|
|
|
#[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();
|
2019-03-07 12:28:51 -06:00
|
|
|
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-02-20 15:36:54 -06:00
|
|
|
}
|
|
|
|
|
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();
|
2019-02-28 01:33:06 -06:00
|
|
|
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();
|
2019-02-28 01:33:06 -06:00
|
|
|
assert_eq!(trim_markup_opt(hover.info.first()), Some("i32"));
|
2019-01-08 13:33:36 -06:00
|
|
|
}
|
|
|
|
|
2019-04-28 08:43:10 -05: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]
|
2019-03-17 13:37:09 -05:00
|
|
|
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;
|
2019-01-14 13:56:14 -06:00
|
|
|
let bar = <|>1 + foo<|>;
|
2019-01-08 13:33:36 -06:00
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
|
|
|
|
let type_name = analysis.type_of(range).unwrap().unwrap();
|
2019-01-14 13:56:14 -06:00
|
|
|
assert_eq!("usize", &type_name);
|
2019-01-08 13:33:36 -06:00
|
|
|
}
|
|
|
|
|
2019-02-21 04:04:14 -06:00
|
|
|
#[test]
|
|
|
|
fn test_hover_infer_associated_method_result() {
|
|
|
|
let (analysis, position) = single_file_with_position(
|
|
|
|
"
|
2019-03-08 15:45:26 -06:00
|
|
|
struct Thing { x: u32 }
|
2019-02-21 04:04:14 -06:00
|
|
|
|
|
|
|
impl Thing {
|
|
|
|
fn new() -> Thing {
|
|
|
|
Thing { x: 0 }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
let foo_<|>test = Thing::new();
|
|
|
|
}
|
|
|
|
",
|
|
|
|
);
|
|
|
|
let hover = analysis.hover(position).unwrap().unwrap();
|
2019-02-28 01:33:06 -06:00
|
|
|
assert_eq!(trim_markup_opt(hover.info.first()), Some("Thing"));
|
2019-02-21 04:04:14 -06:00
|
|
|
}
|
2019-03-01 17:26:49 -06:00
|
|
|
|
|
|
|
#[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"));
|
2019-03-01 17:26:49 -06:00
|
|
|
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);
|
|
|
|
}
|
2019-03-07 02:32:39 -06:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_hover_self() {
|
|
|
|
let (analysis, position) = single_file_with_position(
|
|
|
|
"
|
2019-03-08 15:45:26 -06:00
|
|
|
struct Thing { x: u32 }
|
2019-03-07 02:32:39 -06:00
|
|
|
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(
|
|
|
|
"
|
2019-03-08 15:45:26 -06:00
|
|
|
struct Thing { x: u32 }
|
2019-03-07 02:32:39 -06:00
|
|
|
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(
|
|
|
|
"
|
2019-03-08 15:45:26 -06:00
|
|
|
enum Thing { A }
|
2019-03-07 02:32:39 -06:00
|
|
|
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(
|
|
|
|
"
|
2019-03-08 15:45:26 -06:00
|
|
|
enum Thing { A }
|
2019-03-07 02:32:39 -06:00
|
|
|
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
|
|
|
}
|