SyntaxNode,
};
use test_utils::tested_by;
-use hir::Resolution;
+use hir::{Pat, Resolution};
use crate::{FilePosition, NavigationTarget, db::RootDatabase, RangeInfo};
name_ref: &ast::NameRef,
) -> ReferenceResult {
use self::ReferenceResult::*;
- if let Some(function) =
- hir::source_binder::function_from_child_node(db, file_id, name_ref.syntax())
- {
+
+ 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 syntax_mapping = function.body_syntax_mapping(db);
+ let source_map = function.body_source_map(db);
let expr = ast::Expr::cast(method_call.syntax()).unwrap();
if let Some(func) =
- syntax_mapping.node_expr(expr).and_then(|it| infer_result.method_resolution(it))
+ source_map.node_expr(expr).and_then(|it| infer_result.method_resolution(it))
{
return Exact(NavigationTarget::from_function(db, func));
};
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 syntax_mapping = function.body_syntax_mapping(db);
+ let source_map = function.body_source_map(db);
let expr = ast::Expr::cast(field_expr.syntax()).unwrap();
if let Some(field) =
- syntax_mapping.node_expr(expr).and_then(|it| infer_result.field_resolution(it))
+ source_map.node_expr(expr).and_then(|it| infer_result.field_resolution(it))
{
return Exact(NavigationTarget::from_field(db, field));
};
tested_by!(goto_definition_works_for_named_fields);
let infer_result = function.infer(db);
- let syntax_mapping = function.body_syntax_mapping(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| syntax_mapping.node_expr(lit.into())) {
+ 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 {
}
}
}
+
// Try name resolution
let resolver = hir::source_binder::resolver_for_node(db, file_id, name_ref.syntax());
if let Some(path) =
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 syntax_mapping = body.syntax_mapping(db);
- let ptr =
- syntax_mapping.pat_syntax(pat).expect("pattern not found in syntax mapping");
+ 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);
Some(Resolution::SelfType(_impl_block)) => {
// TODO: go to the implemented type
}
- None => {}
+ 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 = crate::symbol_index::index_resolve(db, name_ref)
.into_iter()