use hir::{HasSource, Semantics};
use ide_db::{
base_db::FileRange,
- defs::Definition,
+ defs::{Definition, IdentClass},
helpers::{pick_best_token, FamousDefs},
- RootDatabase,
+ FxIndexSet, RootDatabase,
};
use itertools::Itertools;
use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxNode, SyntaxToken, T};
use crate::{
- display::TryToNav,
doc_links::token_as_doc_comment,
markup::Markup,
runnables::{runnable_fn, runnable_mod},
- FileId, FilePosition, NavigationTarget, RangeInfo, Runnable,
+ FileId, FilePosition, NavigationTarget, RangeInfo, Runnable, TryToNav,
};
-
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct HoverConfig {
pub links_in_hover: bool,
}
}
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct HoverGotoTypeData {
pub mod_path: String,
pub nav: NavigationTarget,
let file = sema.parse(file_id).syntax().clone();
if !range.is_empty() {
- return hover_ranged(&file, range, &sema, config);
+ return hover_ranged(&file, range, sema, config);
}
let offset = range.start();
let descended = sema.descend_into_macros(original_token.clone());
// FIXME: Definition should include known lints and the like instead of having this special case here
- if let Some(res) = descended.iter().find_map(|token| {
+ let hovered_lint = descended.iter().find_map(|token| {
let attr = token.ancestors().find_map(ast::Attr::cast)?;
- render::try_for_lint(&attr, &token)
- }) {
+ render::try_for_lint(&attr, token)
+ });
+ if let Some(res) = hovered_lint {
return Some(RangeInfo::new(original_token.text_range(), res));
}
.iter()
.filter_map(|token| {
let node = token.parent()?;
- let defs = Definition::from_token(sema, token);
- Some(defs.into_iter().zip(iter::once(node).cycle()))
+ let class = IdentClass::classify_token(sema, token)?;
+ Some(class.definitions().into_iter().zip(iter::once(node).cycle()))
})
.flatten()
.unique_by(|&(def, _)| def)
.filter_map(|(def, node)| hover_for_definition(sema, file_id, def, &node, config))
- .reduce(|mut acc, HoverResult { markup, actions }| {
+ .reduce(|mut acc: HoverResult, HoverResult { markup, actions }| {
acc.actions.extend(actions);
acc.markup = Markup::from(format!("{}\n---\n{}", acc.markup, markup));
acc
});
+
if result.is_none() {
// fallbacks, show keywords or types
- if let Some(res) = render::keyword(sema, config, &original_token) {
+
+ let res = descended.iter().find_map(|token| render::keyword(sema, config, &token));
+ if let Some(res) = res {
return Some(RangeInfo::new(original_token.text_range(), res));
}
- if let res @ Some(_) =
- descended.iter().find_map(|token| hover_type_fallback(sema, config, token))
- {
+ let res = descended
+ .iter()
+ .find_map(|token| hover_type_fallback(sema, config, token, &original_token));
+ if let res @ Some(_) = res {
return res;
}
}
- result.map(|res| RangeInfo::new(original_token.text_range(), res))
+ result.map(|mut res: HoverResult| {
+ res.actions = dedupe_or_merge_hover_actions(res.actions);
+ RangeInfo::new(original_token.text_range(), res)
+ })
}
pub(crate) fn hover_for_definition(
config: &HoverConfig,
) -> Option<HoverResult> {
let famous_defs = match &definition {
- Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => {
- Some(FamousDefs(&sema, sema.scope(&node).krate()))
- }
+ Definition::BuiltinType(_) => Some(FamousDefs(sema, sema.scope(node).krate())),
_ => None,
};
if let Some(markup) = render::definition(sema.db, definition, famous_defs.as_ref(), config) {
res.actions.push(action);
}
- if let Some(action) = runnable_action(&sema, definition, file_id) {
+ if let Some(action) = runnable_action(sema, definition, file_id) {
res.actions.push(action);
}
sema: &Semantics<RootDatabase>,
config: &HoverConfig,
) -> Option<RangeInfo<HoverResult>> {
+ // FIXME: make this work in attributes
let expr_or_pat = file.covering_element(range).ancestors().find_map(|it| {
match_ast! {
match it {
sema: &Semantics<RootDatabase>,
config: &HoverConfig,
token: &SyntaxToken,
+ original_token: &SyntaxToken,
) -> Option<RangeInfo<HoverResult>> {
let node = token
.ancestors()
}
};
- let res = render::type_info(&sema, config, &expr_or_pat)?;
- let range = sema.original_range(&node).range;
+ let res = render::type_info(sema, config, &expr_or_pat)?;
+ let range = sema
+ .original_range_opt(&node)
+ .map(|frange| frange.range)
+ .unwrap_or_else(|| original_token.text_range());
Some(RangeInfo::new(range, res))
}
}
let adt = match def {
- Definition::ModuleDef(hir::ModuleDef::Trait(it)) => {
- return it.try_to_nav(db).map(to_action)
- }
- Definition::ModuleDef(hir::ModuleDef::Adt(it)) => Some(it),
+ Definition::Trait(it) => return it.try_to_nav(db).map(to_action),
+ Definition::Adt(it) => Some(it),
Definition::SelfType(it) => it.self_ty(db).as_adt(),
_ => None,
}?;
fn show_fn_references_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
match def {
- Definition::ModuleDef(hir::ModuleDef::Function(it)) => {
- it.try_to_nav(db).map(|nav_target| {
- HoverAction::Reference(FilePosition {
- file_id: nav_target.file_id,
- offset: nav_target.focus_or_full_range().start(),
- })
+ Definition::Function(it) => it.try_to_nav(db).map(|nav_target| {
+ HoverAction::Reference(FilePosition {
+ file_id: nav_target.file_id,
+ offset: nav_target.focus_or_full_range().start(),
})
- }
+ }),
_ => None,
}
}
file_id: FileId,
) -> Option<HoverAction> {
match def {
- Definition::ModuleDef(it) => match it {
- hir::ModuleDef::Module(it) => runnable_mod(sema, it).map(HoverAction::Runnable),
- hir::ModuleDef::Function(func) => {
- let src = func.source(sema.db)?;
- if src.file_id != file_id.into() {
- cov_mark::hit!(hover_macro_generated_struct_fn_doc_comment);
- cov_mark::hit!(hover_macro_generated_struct_fn_doc_attr);
- return None;
- }
-
- runnable_fn(sema, func).map(HoverAction::Runnable)
+ Definition::Module(it) => runnable_mod(sema, it).map(HoverAction::Runnable),
+ Definition::Function(func) => {
+ let src = func.source(sema.db)?;
+ if src.file_id != file_id.into() {
+ cov_mark::hit!(hover_macro_generated_struct_fn_doc_comment);
+ cov_mark::hit!(hover_macro_generated_struct_fn_doc_attr);
+ return None;
}
- _ => None,
- },
+
+ runnable_fn(sema, func).map(HoverAction::Runnable)
+ }
_ => None,
}
}
Definition::Local(it) => it.ty(db),
Definition::GenericParam(hir::GenericParam::ConstParam(it)) => it.ty(db),
Definition::Field(field) => field.ty(db),
+ Definition::Function(function) => function.ret_type(db),
_ => return None,
};
} else if let Some(trait_) = t.as_dyn_trait() {
push_new_def(trait_.into());
} else if let Some(traits) = t.as_impl_traits(db) {
- traits.into_iter().for_each(|it| push_new_def(it.into()));
+ traits.for_each(|it| push_new_def(it.into()));
} else if let Some(trait_) = t.as_associated_type_parent_trait(db) {
push_new_def(trait_.into());
}
});
}
+
+fn dedupe_or_merge_hover_actions(actions: Vec<HoverAction>) -> Vec<HoverAction> {
+ let mut deduped_actions = Vec::with_capacity(actions.len());
+ let mut go_to_type_targets = FxIndexSet::default();
+
+ let mut seen_implementation = false;
+ let mut seen_reference = false;
+ let mut seen_runnable = false;
+ for action in actions {
+ match action {
+ HoverAction::GoToType(targets) => {
+ go_to_type_targets.extend(targets);
+ }
+ HoverAction::Implementation(..) => {
+ if !seen_implementation {
+ seen_implementation = true;
+ deduped_actions.push(action);
+ }
+ }
+ HoverAction::Reference(..) => {
+ if !seen_reference {
+ seen_reference = true;
+ deduped_actions.push(action);
+ }
+ }
+ HoverAction::Runnable(..) => {
+ if !seen_runnable {
+ seen_runnable = true;
+ deduped_actions.push(action);
+ }
+ }
+ };
+ }
+
+ if !go_to_type_targets.is_empty() {
+ deduped_actions.push(HoverAction::GoToType(go_to_type_targets.into_iter().collect()));
+ }
+
+ deduped_actions
+}
projects / rust.git / blobdiff