-use ra_db::{FileId, Cancelable, SyntaxDatabase};
+use ra_db::{FileId, SourceDatabase};
use ra_syntax::{
- TextRange, AstNode, ast, SyntaxKind::{NAME, MODULE},
- algo::find_node_at_offset,
+ AstNode, ast,
+ algo::{find_node_at_offset, visit::{visitor, Visitor}},
+ SyntaxNode,
};
+use test_utils::tested_by;
+use hir::{Pat, Resolution};
-use crate::{FilePosition, NavigationTarget, db::RootDatabase};
+use crate::{FilePosition, NavigationTarget, db::RootDatabase, RangeInfo};
pub(crate) fn goto_definition(
db: &RootDatabase,
position: FilePosition,
-) -> Cancelable<Option<Vec<NavigationTarget>>> {
- let file = db.source_file(position.file_id);
+) -> Option<RangeInfo<Vec<NavigationTarget>>> {
+ let file = db.parse(position.file_id);
let syntax = file.syntax();
if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
- return Ok(Some(reference_definition(db, position.file_id, name_ref)?));
+ let navs = reference_definition(db, position.file_id, name_ref).to_vec();
+ return Some(RangeInfo::new(name_ref.syntax().range(), navs.to_vec()));
}
if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
- return name_definition(db, position.file_id, name);
+ let navs = name_definition(db, position.file_id, name)?;
+ return Some(RangeInfo::new(name.syntax().range(), navs));
+ }
+ None
+}
+
+pub(crate) enum ReferenceResult {
+ Exact(NavigationTarget),
+ Approximate(Vec<NavigationTarget>),
+}
+
+impl ReferenceResult {
+ fn to_vec(self) -> Vec<NavigationTarget> {
+ use self::ReferenceResult::*;
+ match self {
+ Exact(target) => vec![target],
+ Approximate(vec) => vec,
+ }
}
- Ok(None)
}
pub(crate) fn reference_definition(
db: &RootDatabase,
file_id: FileId,
name_ref: &ast::NameRef,
-) -> Cancelable<Vec<NavigationTarget>> {
- if let Some(fn_descr) =
- hir::source_binder::function_from_child_node(db, file_id, name_ref.syntax())?
- {
- let scope = fn_descr.scopes(db)?;
- // First try to resolve the symbol locally
- if let Some(entry) = scope.resolve_local_name(name_ref) {
- let nav = NavigationTarget {
- file_id,
- name: entry.name().to_string().into(),
- range: entry.ptr().range(),
- kind: NAME,
- ptr: None,
+) -> ReferenceResult {
+ use self::ReferenceResult::*;
+
+ let function = hir::source_binder::function_from_child_node(db, file_id, name_ref.syntax());
+
+ if let Some(function) = function {
+ // Check if it is a method
+ if let Some(method_call) = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast) {
+ tested_by!(goto_definition_works_for_methods);
+ let infer_result = function.infer(db);
+ let source_map = function.body_source_map(db);
+ let expr = ast::Expr::cast(method_call.syntax()).unwrap();
+ if let Some(func) =
+ source_map.node_expr(expr).and_then(|it| infer_result.method_resolution(it))
+ {
+ return Exact(NavigationTarget::from_function(db, func));
+ };
+ }
+ // It could also be a field access
+ if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::FieldExpr::cast) {
+ tested_by!(goto_definition_works_for_fields);
+ let infer_result = function.infer(db);
+ let source_map = function.body_source_map(db);
+ let expr = ast::Expr::cast(field_expr.syntax()).unwrap();
+ if let Some(field) =
+ source_map.node_expr(expr).and_then(|it| infer_result.field_resolution(it))
+ {
+ return Exact(NavigationTarget::from_field(db, field));
};
- return Ok(vec![nav]);
- };
+ }
+
+ // It could also be a named field
+ if let Some(field_expr) = name_ref.syntax().parent().and_then(ast::NamedField::cast) {
+ tested_by!(goto_definition_works_for_named_fields);
+
+ let infer_result = function.infer(db);
+ let source_map = function.body_source_map(db);
+
+ let struct_lit = field_expr.syntax().ancestors().find_map(ast::StructLit::cast);
+
+ if let Some(expr) = struct_lit.and_then(|lit| source_map.node_expr(lit.into())) {
+ let ty = infer_result[expr].clone();
+ if let hir::Ty::Adt { def_id, .. } = ty {
+ if let hir::AdtDef::Struct(s) = def_id {
+ let hir_path = hir::Path::from_name_ref(name_ref);
+ let hir_name = hir_path.as_ident().unwrap();
+
+ if let Some(field) = s.field(db, hir_name) {
+ return Exact(NavigationTarget::from_field(db, field));
+ }
+ }
+ }
+ }
+ }
}
- // Then try module name resolution
- if let Some(module) =
- hir::source_binder::module_from_child_node(db, file_id, name_ref.syntax())?
+
+ // Try name resolution
+ let resolver = hir::source_binder::resolver_for_node(db, file_id, name_ref.syntax());
+ if let Some(path) =
+ name_ref.syntax().ancestors().find_map(ast::Path::cast).and_then(hir::Path::from_ast)
{
- if let Some(path) = name_ref
- .syntax()
- .ancestors()
- .find_map(ast::Path::cast)
- .and_then(hir::Path::from_ast)
- {
- let resolved = module.resolve_path(db, &path)?;
- if let Some(def_id) = resolved.take_types().or(resolved.take_values()) {
- if let Some(target) = NavigationTarget::from_def(db, def_id.resolve(db)?)? {
- return Ok(vec![target]);
+ let resolved = resolver.resolve_path(db, &path);
+ match resolved.clone().take_types().or_else(|| resolved.take_values()) {
+ Some(Resolution::Def(def)) => return Exact(NavigationTarget::from_def(db, def)),
+ Some(Resolution::LocalBinding(pat)) => {
+ let body = resolver.body().expect("no body for local binding");
+ let source_map = body.owner().body_source_map(db);
+ let ptr = source_map.pat_syntax(pat).expect("pattern not found in syntax mapping");
+ let name =
+ path.as_ident().cloned().expect("local binding from a multi-segment path");
+ let nav = NavigationTarget::from_scope_entry(file_id, name, ptr);
+ return Exact(nav);
+ }
+ Some(Resolution::GenericParam(..)) => {
+ // TODO: go to the generic param def
+ }
+ Some(Resolution::SelfType(_impl_block)) => {
+ // TODO: go to the implemented type
+ }
+ None => {
+ // If we failed to resolve then check associated items
+ if let Some(function) = function {
+ // Resolve associated item for path expressions
+ if let Some(path_expr) =
+ name_ref.syntax().ancestors().find_map(ast::PathExpr::cast)
+ {
+ let infer_result = function.infer(db);
+ let source_map = function.body_source_map(db);
+
+ if let Some(expr) = ast::Expr::cast(path_expr.syntax()) {
+ if let Some(res) = source_map
+ .node_expr(expr)
+ .and_then(|it| infer_result.assoc_resolutions_for_expr(it.into()))
+ {
+ return Exact(NavigationTarget::from_impl_item(db, res));
+ }
+ }
+ }
+
+ // Resolve associated item for path patterns
+ if let Some(path_pat) =
+ name_ref.syntax().ancestors().find_map(ast::PathPat::cast)
+ {
+ let infer_result = function.infer(db);
+
+ if let Some(p) = path_pat.path().and_then(hir::Path::from_ast) {
+ if let Some(pat_id) =
+ function.body(db).pats().find_map(|(pat_id, pat)| match pat {
+ Pat::Path(ref path) if *path == p => Some(pat_id),
+ _ => None,
+ })
+ {
+ if let Some(res) =
+ infer_result.assoc_resolutions_for_pat(pat_id.into())
+ {
+ return Exact(NavigationTarget::from_impl_item(db, res));
+ }
+ }
+ }
+ }
}
}
}
}
+
// If that fails try the index based approach.
- let navs = db
- .index_resolve(name_ref)?
+ let navs = crate::symbol_index::index_resolve(db, name_ref)
.into_iter()
.map(NavigationTarget::from_symbol)
.collect();
- Ok(navs)
+ Approximate(navs)
}
-fn name_definition(
+pub(crate) fn name_definition(
db: &RootDatabase,
file_id: FileId,
name: &ast::Name,
-) -> Cancelable<Option<Vec<NavigationTarget>>> {
- if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
+) -> Option<Vec<NavigationTarget>> {
+ let parent = name.syntax().parent()?;
+
+ if let Some(module) = ast::Module::cast(&parent) {
if module.has_semi() {
if let Some(child_module) =
- hir::source_binder::module_from_declaration(db, file_id, module)?
+ hir::source_binder::module_from_declaration(db, file_id, module)
{
- let (file_id, _) = child_module.definition_source(db)?;
- let name = match child_module.name(db)? {
- Some(name) => name.to_string().into(),
- None => "".into(),
- };
- let nav = NavigationTarget {
- file_id,
- name,
- range: TextRange::offset_len(0.into(), 0.into()),
- kind: MODULE,
- ptr: None,
- };
- return Ok(Some(vec![nav]));
+ let nav = NavigationTarget::from_module(db, child_module);
+ return Some(vec![nav]);
}
}
}
- Ok(None)
+
+ if let Some(nav) = named_target(file_id, &parent) {
+ return Some(vec![nav]);
+ }
+
+ None
+}
+
+fn named_target(file_id: FileId, node: &SyntaxNode) -> Option<NavigationTarget> {
+ visitor()
+ .visit(|node: &ast::StructDef| NavigationTarget::from_named(file_id, node))
+ .visit(|node: &ast::EnumDef| NavigationTarget::from_named(file_id, node))
+ .visit(|node: &ast::EnumVariant| NavigationTarget::from_named(file_id, node))
+ .visit(|node: &ast::FnDef| NavigationTarget::from_named(file_id, node))
+ .visit(|node: &ast::TypeAliasDef| NavigationTarget::from_named(file_id, node))
+ .visit(|node: &ast::ConstDef| NavigationTarget::from_named(file_id, node))
+ .visit(|node: &ast::StaticDef| NavigationTarget::from_named(file_id, node))
+ .visit(|node: &ast::TraitDef| NavigationTarget::from_named(file_id, node))
+ .visit(|node: &ast::NamedFieldDef| NavigationTarget::from_named(file_id, node))
+ .visit(|node: &ast::Module| NavigationTarget::from_named(file_id, node))
+ .accept(node)
}
#[cfg(test)]
mod tests {
- use test_utils::assert_eq_dbg;
+ use test_utils::covers;
+
use crate::mock_analysis::analysis_and_position;
+ fn check_goto(fixture: &str, expected: &str) {
+ let (analysis, pos) = analysis_and_position(fixture);
+
+ let mut navs = analysis.goto_definition(pos).unwrap().unwrap().info;
+ assert_eq!(navs.len(), 1);
+ let nav = navs.pop().unwrap();
+ nav.assert_match(expected);
+ }
+
#[test]
fn goto_definition_works_in_items() {
- let (analysis, pos) = analysis_and_position(
+ check_goto(
"
//- /lib.rs
struct Foo;
enum E { X(Foo<|>) }
",
- );
-
- let symbols = analysis.goto_definition(pos).unwrap().unwrap();
- assert_eq_dbg(
- r#"[NavigationTarget { file_id: FileId(1), name: "Foo",
- kind: STRUCT_DEF, range: [0; 11),
- ptr: Some(LocalSyntaxPtr { range: [0; 11), kind: STRUCT_DEF }) }]"#,
- &symbols,
+ "Foo STRUCT_DEF FileId(1) [0; 11) [7; 10)",
);
}
#[test]
fn goto_definition_resolves_correct_name() {
- let (analysis, pos) = analysis_and_position(
+ check_goto(
"
//- /lib.rs
use a::Foo;
//- /b.rs
struct Foo;
",
- );
-
- let symbols = analysis.goto_definition(pos).unwrap().unwrap();
- assert_eq_dbg(
- r#"[NavigationTarget { file_id: FileId(2), name: "Foo",
- kind: STRUCT_DEF, range: [0; 11),
- ptr: Some(LocalSyntaxPtr { range: [0; 11), kind: STRUCT_DEF }) }]"#,
- &symbols,
+ "Foo STRUCT_DEF FileId(2) [0; 11) [7; 10)",
);
}
#[test]
fn goto_definition_works_for_module_declaration() {
- let (analysis, pos) = analysis_and_position(
+ check_goto(
"
//- /lib.rs
mod <|>foo;
//- /foo.rs
// empty
- ",
- );
-
- let symbols = analysis.goto_definition(pos).unwrap().unwrap();
- assert_eq_dbg(
- r#"[NavigationTarget { file_id: FileId(2), name: "foo", kind: MODULE, range: [0; 0), ptr: None }]"#,
- &symbols,
+ ",
+ "foo SOURCE_FILE FileId(2) [0; 10)",
);
- let (analysis, pos) = analysis_and_position(
+ check_goto(
"
//- /lib.rs
mod <|>foo;
//- /foo/mod.rs
// empty
- ",
+ ",
+ "foo SOURCE_FILE FileId(2) [0; 10)",
+ );
+ }
+
+ #[test]
+ fn goto_definition_works_for_methods() {
+ covers!(goto_definition_works_for_methods);
+ check_goto(
+ "
+ //- /lib.rs
+ struct Foo;
+ impl Foo {
+ fn frobnicate(&self) { }
+ }
+
+ fn bar(foo: &Foo) {
+ foo.frobnicate<|>();
+ }
+ ",
+ "frobnicate FN_DEF FileId(1) [27; 52) [30; 40)",
+ );
+ }
+
+ #[test]
+ fn goto_definition_works_for_fields() {
+ covers!(goto_definition_works_for_fields);
+ check_goto(
+ "
+ //- /lib.rs
+ struct Foo {
+ spam: u32,
+ }
+
+ fn bar(foo: &Foo) {
+ foo.spam<|>;
+ }
+ ",
+ "spam NAMED_FIELD_DEF FileId(1) [17; 26) [17; 21)",
+ );
+ }
+
+ #[test]
+ fn goto_definition_works_for_named_fields() {
+ covers!(goto_definition_works_for_named_fields);
+ check_goto(
+ "
+ //- /lib.rs
+ struct Foo {
+ spam: u32,
+ }
+
+ fn bar() -> Foo {
+ Foo {
+ spam<|>: 0,
+ }
+ }
+ ",
+ "spam NAMED_FIELD_DEF FileId(1) [17; 26) [17; 21)",
+ );
+ }
+
+ #[test]
+ fn goto_definition_works_when_used_on_definition_name_itself() {
+ check_goto(
+ "
+ //- /lib.rs
+ struct Foo<|> { value: u32 }
+ ",
+ "Foo STRUCT_DEF FileId(1) [0; 25) [7; 10)",
+ );
+
+ check_goto(
+ r#"
+ //- /lib.rs
+ struct Foo {
+ field<|>: string,
+ }
+ "#,
+ "field NAMED_FIELD_DEF FileId(1) [17; 30) [17; 22)",
+ );
+
+ check_goto(
+ "
+ //- /lib.rs
+ fn foo_test<|>() {
+ }
+ ",
+ "foo_test FN_DEF FileId(1) [0; 17) [3; 11)",
+ );
+
+ check_goto(
+ "
+ //- /lib.rs
+ enum Foo<|> {
+ Variant,
+ }
+ ",
+ "Foo ENUM_DEF FileId(1) [0; 25) [5; 8)",
+ );
+
+ check_goto(
+ "
+ //- /lib.rs
+ enum Foo {
+ Variant1,
+ Variant2<|>,
+ Variant3,
+ }
+ ",
+ "Variant2 ENUM_VARIANT FileId(1) [29; 37) [29; 37)",
);
- let symbols = analysis.goto_definition(pos).unwrap().unwrap();
- assert_eq_dbg(
- r#"[NavigationTarget { file_id: FileId(2), name: "foo", kind: MODULE, range: [0; 0), ptr: None }]"#,
- &symbols,
+ check_goto(
+ r#"
+ //- /lib.rs
+ static inner<|>: &str = "";
+ "#,
+ "inner STATIC_DEF FileId(1) [0; 24) [7; 12)",
+ );
+
+ check_goto(
+ r#"
+ //- /lib.rs
+ const inner<|>: &str = "";
+ "#,
+ "inner CONST_DEF FileId(1) [0; 23) [6; 11)",
+ );
+
+ check_goto(
+ r#"
+ //- /lib.rs
+ type Thing<|> = Option<()>;
+ "#,
+ "Thing TYPE_ALIAS_DEF FileId(1) [0; 24) [5; 10)",
+ );
+
+ check_goto(
+ r#"
+ //- /lib.rs
+ trait Foo<|> {
+ }
+ "#,
+ "Foo TRAIT_DEF FileId(1) [0; 13) [6; 9)",
+ );
+
+ check_goto(
+ r#"
+ //- /lib.rs
+ mod bar<|> {
+ }
+ "#,
+ "bar MODULE FileId(1) [0; 11) [4; 7)",
);
}
}