2019-12-30 08:12:06 -06:00
|
|
|
//! Entry point for call-hierarchy
|
|
|
|
|
|
|
|
use indexmap::IndexMap;
|
|
|
|
|
2020-02-18 11:35:10 -06:00
|
|
|
use hir::Semantics;
|
2020-02-06 05:52:32 -06:00
|
|
|
use ra_ide_db::RootDatabase;
|
2020-02-25 06:49:34 -06:00
|
|
|
use ra_syntax::{ast, match_ast, AstNode, TextRange};
|
2019-12-30 08:12:06 -06:00
|
|
|
|
|
|
|
use crate::{
|
2020-02-18 11:35:10 -06:00
|
|
|
call_info::FnCallNode, display::ToNav, goto_definition, references, FilePosition,
|
|
|
|
NavigationTarget, RangeInfo,
|
2019-12-30 08:12:06 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
pub struct CallItem {
|
|
|
|
pub target: NavigationTarget,
|
|
|
|
pub ranges: Vec<TextRange>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl CallItem {
|
|
|
|
#[cfg(test)]
|
|
|
|
pub(crate) fn assert_match(&self, expected: &str) {
|
|
|
|
let actual = self.debug_render();
|
|
|
|
test_utils::assert_eq_text!(expected.trim(), actual.trim(),);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
pub(crate) fn debug_render(&self) -> String {
|
|
|
|
format!("{} : {:?}", self.target.debug_render(), self.ranges)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn call_hierarchy(
|
|
|
|
db: &RootDatabase,
|
|
|
|
position: FilePosition,
|
|
|
|
) -> Option<RangeInfo<Vec<NavigationTarget>>> {
|
|
|
|
goto_definition::goto_definition(db, position)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Option<Vec<CallItem>> {
|
2020-02-18 11:35:10 -06:00
|
|
|
let sema = Semantics::new(db);
|
2020-07-01 07:11:34 -05:00
|
|
|
|
2019-12-30 08:12:06 -06:00
|
|
|
// 1. Find all refs
|
|
|
|
// 2. Loop through refs and determine unique fndef. This will become our `from: CallHierarchyItem,` in the reply.
|
|
|
|
// 3. Add ranges relative to the start of the fndef.
|
2020-07-01 07:11:34 -05:00
|
|
|
let refs = references::find_all_refs(&sema, position, None)?;
|
2019-12-30 08:12:06 -06:00
|
|
|
|
|
|
|
let mut calls = CallLocations::default();
|
|
|
|
|
|
|
|
for reference in refs.info.references() {
|
|
|
|
let file_id = reference.file_range.file_id;
|
2020-02-18 11:35:10 -06:00
|
|
|
let file = sema.parse(file_id);
|
|
|
|
let file = file.syntax();
|
2019-12-30 08:12:06 -06:00
|
|
|
let token = file.token_at_offset(reference.file_range.range.start()).next()?;
|
2020-02-18 11:35:10 -06:00
|
|
|
let token = sema.descend_into_macros(token);
|
|
|
|
let syntax = token.parent();
|
2019-12-30 08:12:06 -06:00
|
|
|
|
|
|
|
// This target is the containing function
|
|
|
|
if let Some(nav) = syntax.ancestors().find_map(|node| {
|
|
|
|
match_ast! {
|
|
|
|
match node {
|
2020-07-30 07:51:08 -05:00
|
|
|
ast::Fn(it) => {
|
2020-02-18 11:35:10 -06:00
|
|
|
let def = sema.to_def(&it)?;
|
|
|
|
Some(def.to_nav(sema.db))
|
2019-12-30 08:12:06 -06:00
|
|
|
},
|
2020-02-18 11:35:10 -06:00
|
|
|
_ => None,
|
2019-12-30 08:12:06 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}) {
|
|
|
|
let relative_range = reference.file_range.range;
|
|
|
|
calls.add(&nav, relative_range);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Some(calls.into_items())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Option<Vec<CallItem>> {
|
2020-02-18 11:35:10 -06:00
|
|
|
let sema = Semantics::new(db);
|
2019-12-30 08:12:06 -06:00
|
|
|
let file_id = position.file_id;
|
2020-02-18 11:35:10 -06:00
|
|
|
let file = sema.parse(file_id);
|
|
|
|
let file = file.syntax();
|
2019-12-30 08:12:06 -06:00
|
|
|
let token = file.token_at_offset(position.offset).next()?;
|
2020-02-18 11:35:10 -06:00
|
|
|
let token = sema.descend_into_macros(token);
|
|
|
|
let syntax = token.parent();
|
2019-12-30 08:12:06 -06:00
|
|
|
|
|
|
|
let mut calls = CallLocations::default();
|
|
|
|
|
|
|
|
syntax
|
|
|
|
.descendants()
|
|
|
|
.filter_map(|node| FnCallNode::with_node_exact(&node))
|
|
|
|
.filter_map(|call_node| {
|
|
|
|
let name_ref = call_node.name_ref()?;
|
|
|
|
|
|
|
|
if let Some(func_target) = match &call_node {
|
|
|
|
FnCallNode::CallExpr(expr) => {
|
|
|
|
//FIXME: Type::as_callable is broken
|
2020-07-16 06:00:56 -05:00
|
|
|
let callable = sema.type_of_expr(&expr.expr()?)?.as_callable(db)?;
|
|
|
|
match callable.kind() {
|
|
|
|
hir::CallableKind::Function(it) => {
|
2019-12-30 08:12:06 -06:00
|
|
|
let fn_def: hir::Function = it.into();
|
|
|
|
let nav = fn_def.to_nav(db);
|
|
|
|
Some(nav)
|
|
|
|
}
|
|
|
|
_ => None,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
FnCallNode::MethodCallExpr(expr) => {
|
2020-02-18 11:35:10 -06:00
|
|
|
let function = sema.resolve_method_call(&expr)?;
|
2019-12-30 08:12:06 -06:00
|
|
|
Some(function.to_nav(db))
|
|
|
|
}
|
|
|
|
} {
|
2020-02-18 11:35:10 -06:00
|
|
|
Some((func_target, name_ref.syntax().text_range()))
|
2019-12-30 08:12:06 -06:00
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.for_each(|(nav, range)| calls.add(&nav, range));
|
|
|
|
|
|
|
|
Some(calls.into_items())
|
|
|
|
}
|
|
|
|
|
2020-01-08 10:33:04 -06:00
|
|
|
#[derive(Default)]
|
|
|
|
struct CallLocations {
|
|
|
|
funcs: IndexMap<NavigationTarget, Vec<TextRange>>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl CallLocations {
|
|
|
|
fn add(&mut self, target: &NavigationTarget, range: TextRange) {
|
|
|
|
self.funcs.entry(target.clone()).or_default().push(range);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn into_items(self) -> Vec<CallItem> {
|
|
|
|
self.funcs.into_iter().map(|(target, ranges)| CallItem { target, ranges }).collect()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-30 08:12:06 -06:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use ra_db::FilePosition;
|
|
|
|
|
|
|
|
use crate::mock_analysis::analysis_and_position;
|
|
|
|
|
|
|
|
fn check_hierarchy(
|
2020-06-23 15:27:24 -05:00
|
|
|
ra_fixture: &str,
|
2019-12-30 08:12:06 -06:00
|
|
|
expected: &str,
|
|
|
|
expected_incoming: &[&str],
|
|
|
|
expected_outgoing: &[&str],
|
|
|
|
) {
|
2020-06-23 15:27:24 -05:00
|
|
|
let (analysis, pos) = analysis_and_position(ra_fixture);
|
2019-12-30 08:12:06 -06:00
|
|
|
|
|
|
|
let mut navs = analysis.call_hierarchy(pos).unwrap().unwrap().info;
|
|
|
|
assert_eq!(navs.len(), 1);
|
|
|
|
let nav = navs.pop().unwrap();
|
|
|
|
nav.assert_match(expected);
|
|
|
|
|
2020-07-17 05:42:48 -05:00
|
|
|
let item_pos =
|
|
|
|
FilePosition { file_id: nav.file_id, offset: nav.focus_or_full_range().start() };
|
2019-12-30 08:12:06 -06:00
|
|
|
let incoming_calls = analysis.incoming_calls(item_pos).unwrap().unwrap();
|
|
|
|
assert_eq!(incoming_calls.len(), expected_incoming.len());
|
|
|
|
|
|
|
|
for call in 0..incoming_calls.len() {
|
|
|
|
incoming_calls[call].assert_match(expected_incoming[call]);
|
|
|
|
}
|
|
|
|
|
|
|
|
let outgoing_calls = analysis.outgoing_calls(item_pos).unwrap().unwrap();
|
|
|
|
assert_eq!(outgoing_calls.len(), expected_outgoing.len());
|
|
|
|
|
|
|
|
for call in 0..outgoing_calls.len() {
|
|
|
|
outgoing_calls[call].assert_match(expected_outgoing[call]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_call_hierarchy_on_ref() {
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /lib.rs
|
|
|
|
fn callee() {}
|
|
|
|
fn caller() {
|
|
|
|
call<|>ee();
|
|
|
|
}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"callee FN FileId(1) 0..14 3..9",
|
|
|
|
&["caller FN FileId(1) 15..44 18..24 : [33..39]"],
|
2019-12-30 08:12:06 -06:00
|
|
|
&[],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_call_hierarchy_on_def() {
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /lib.rs
|
|
|
|
fn call<|>ee() {}
|
|
|
|
fn caller() {
|
|
|
|
callee();
|
|
|
|
}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"callee FN FileId(1) 0..14 3..9",
|
|
|
|
&["caller FN FileId(1) 15..44 18..24 : [33..39]"],
|
2019-12-30 08:12:06 -06:00
|
|
|
&[],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_call_hierarchy_in_same_fn() {
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /lib.rs
|
|
|
|
fn callee() {}
|
|
|
|
fn caller() {
|
|
|
|
call<|>ee();
|
|
|
|
callee();
|
|
|
|
}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"callee FN FileId(1) 0..14 3..9",
|
|
|
|
&["caller FN FileId(1) 15..58 18..24 : [33..39, 47..53]"],
|
2019-12-30 08:12:06 -06:00
|
|
|
&[],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_call_hierarchy_in_different_fn() {
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /lib.rs
|
|
|
|
fn callee() {}
|
|
|
|
fn caller1() {
|
|
|
|
call<|>ee();
|
|
|
|
}
|
2019-12-30 08:12:06 -06:00
|
|
|
|
2020-06-23 15:27:24 -05:00
|
|
|
fn caller2() {
|
|
|
|
callee();
|
|
|
|
}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"callee FN FileId(1) 0..14 3..9",
|
2019-12-30 08:12:06 -06:00
|
|
|
&[
|
2020-07-30 07:51:08 -05:00
|
|
|
"caller1 FN FileId(1) 15..45 18..25 : [34..40]",
|
|
|
|
"caller2 FN FileId(1) 47..77 50..57 : [66..72]",
|
2019-12-30 08:12:06 -06:00
|
|
|
],
|
|
|
|
&[],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2020-05-16 07:23:43 -05:00
|
|
|
#[test]
|
|
|
|
fn test_call_hierarchy_in_tests_mod() {
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /lib.rs cfg:test
|
|
|
|
fn callee() {}
|
|
|
|
fn caller1() {
|
|
|
|
call<|>ee();
|
|
|
|
}
|
2020-05-16 07:23:43 -05:00
|
|
|
|
2020-06-23 15:27:24 -05:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2020-05-16 07:23:43 -05:00
|
|
|
|
2020-06-23 15:27:24 -05:00
|
|
|
#[test]
|
|
|
|
fn test_caller() {
|
|
|
|
callee();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"callee FN FileId(1) 0..14 3..9",
|
2020-05-16 07:23:43 -05:00
|
|
|
&[
|
2020-07-30 07:51:08 -05:00
|
|
|
"caller1 FN FileId(1) 15..45 18..25 : [34..40]",
|
|
|
|
"test_caller FN FileId(1) 95..149 110..121 : [134..140]",
|
2020-05-16 07:23:43 -05:00
|
|
|
],
|
|
|
|
&[],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2019-12-30 08:12:06 -06:00
|
|
|
#[test]
|
|
|
|
fn test_call_hierarchy_in_different_files() {
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /lib.rs
|
|
|
|
mod foo;
|
|
|
|
use foo::callee;
|
2019-12-30 08:12:06 -06:00
|
|
|
|
2020-06-23 15:27:24 -05:00
|
|
|
fn caller() {
|
|
|
|
call<|>ee();
|
|
|
|
}
|
2019-12-30 08:12:06 -06:00
|
|
|
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /foo/mod.rs
|
|
|
|
pub fn callee() {}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"callee FN FileId(2) 0..18 7..13",
|
|
|
|
&["caller FN FileId(1) 27..56 30..36 : [45..51]"],
|
2019-12-30 08:12:06 -06:00
|
|
|
&[],
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_call_hierarchy_outgoing() {
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /lib.rs
|
|
|
|
fn callee() {}
|
|
|
|
fn call<|>er() {
|
|
|
|
callee();
|
|
|
|
callee();
|
|
|
|
}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"caller FN FileId(1) 15..58 18..24",
|
2019-12-30 08:12:06 -06:00
|
|
|
&[],
|
2020-07-30 07:51:08 -05:00
|
|
|
&["callee FN FileId(1) 0..14 3..9 : [33..39, 47..53]"],
|
2019-12-30 08:12:06 -06:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_call_hierarchy_outgoing_in_different_files() {
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /lib.rs
|
|
|
|
mod foo;
|
|
|
|
use foo::callee;
|
2019-12-30 08:12:06 -06:00
|
|
|
|
2020-06-23 15:27:24 -05:00
|
|
|
fn call<|>er() {
|
|
|
|
callee();
|
|
|
|
}
|
2019-12-30 08:12:06 -06:00
|
|
|
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /foo/mod.rs
|
|
|
|
pub fn callee() {}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"caller FN FileId(1) 27..56 30..36",
|
2019-12-30 08:12:06 -06:00
|
|
|
&[],
|
2020-07-30 07:51:08 -05:00
|
|
|
&["callee FN FileId(2) 0..18 7..13 : [45..51]"],
|
2019-12-30 08:12:06 -06:00
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_call_hierarchy_incoming_outgoing() {
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
2020-06-23 15:27:24 -05:00
|
|
|
//- /lib.rs
|
|
|
|
fn caller1() {
|
|
|
|
call<|>er2();
|
|
|
|
}
|
2019-12-30 08:12:06 -06:00
|
|
|
|
2020-06-23 15:27:24 -05:00
|
|
|
fn caller2() {
|
|
|
|
caller3();
|
|
|
|
}
|
2019-12-30 08:12:06 -06:00
|
|
|
|
2020-06-23 15:27:24 -05:00
|
|
|
fn caller3() {
|
2019-12-30 08:12:06 -06:00
|
|
|
|
2020-06-23 15:27:24 -05:00
|
|
|
}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"caller2 FN FileId(1) 33..64 36..43",
|
|
|
|
&["caller1 FN FileId(1) 0..31 3..10 : [19..26]"],
|
|
|
|
&["caller3 FN FileId(1) 66..83 69..76 : [52..59]"],
|
2019-12-30 08:12:06 -06:00
|
|
|
);
|
|
|
|
}
|
2020-06-28 13:43:02 -05:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_call_hierarchy_issue_5103() {
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
|
|
|
fn a() {
|
|
|
|
b()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn b() {}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
a<|>()
|
|
|
|
}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"a FN FileId(1) 0..18 3..4",
|
|
|
|
&["main FN FileId(1) 31..52 34..38 : [47..48]"],
|
|
|
|
&["b FN FileId(1) 20..29 23..24 : [13..14]"],
|
2020-06-28 13:43:02 -05:00
|
|
|
);
|
|
|
|
|
|
|
|
check_hierarchy(
|
|
|
|
r#"
|
|
|
|
fn a() {
|
|
|
|
b<|>()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn b() {}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
a()
|
|
|
|
}
|
|
|
|
"#,
|
2020-07-30 07:51:08 -05:00
|
|
|
"b FN FileId(1) 20..29 23..24",
|
|
|
|
&["a FN FileId(1) 0..18 3..4 : [13..14]"],
|
2020-06-28 13:43:02 -05:00
|
|
|
&[],
|
|
|
|
);
|
|
|
|
}
|
2019-12-30 08:12:06 -06:00
|
|
|
}
|