nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 16:24:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge #5292

Browse Source 
5292: Goto type definition improvements r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>
This commit is contained in:
bors[bot] 2020-07-10 12:47:23 +00:00 committed by GitHub
commit 0f7770ae43
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 105 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
crates/ra_hir/src/semantics.rs
View File

@ -25,7 +25,7 @@ use crate::{
semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
source_analyzer::{resolve_hir_path, resolve_hir_path_qualifier, SourceAnalyzer},
AssocItem, Field, Function, HirFileId, ImplDef, InFile, Local, MacroDef, Module, ModuleDef,
Name, Origin, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam,
Name, Origin, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam, VariantDef,
};
use resolver::TypeNs;
@ -192,6 +192,10 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
self.imp.type_of_pat(pat)
}
pub fn type_of_self(&self, param: &ast::SelfParam) -> Option<Type> {
self.imp.type_of_self(param)
}
pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
self.imp.resolve_method_call(call)
}
@ -216,8 +220,8 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
self.imp.resolve_path(path)
}
pub fn resolve_variant(&self, record_lit: ast::RecordLit) -> Option<VariantId> {
self.imp.resolve_variant(record_lit)
pub fn resolve_variant(&self, record_lit: ast::RecordLit) -> Option<VariantDef> {
self.imp.resolve_variant(record_lit).map(VariantDef::from)
}
pub fn lower_path(&self, path: &ast::Path) -> Option<Path> {
@ -370,13 +374,17 @@ impl<'db> SemanticsImpl<'db> {
}
pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
self.analyze(expr.syntax()).type_of(self.db, &expr)
self.analyze(expr.syntax()).type_of_expr(self.db, &expr)
}
pub fn type_of_pat(&self, pat: &ast::Pat) -> Option<Type> {
self.analyze(pat.syntax()).type_of_pat(self.db, &pat)
}
pub fn type_of_self(&self, param: &ast::SelfParam) -> Option<Type> {
self.analyze(param.syntax()).type_of_self(self.db, &param)
}
pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
self.analyze(call.syntax()).resolve_method_call(self.db, call)
}

13
crates/ra_hir/src/source_analyzer.rs
View File

@ -115,7 +115,7 @@ impl SourceAnalyzer {
Some(res)
}
pub(crate) fn type_of(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<Type> {
pub(crate) fn type_of_expr(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<Type> {
let expr_id = self.expr_id(db, expr)?;
let ty = self.infer.as_ref()?[expr_id].clone();
Type::new_with_resolver(db, &self.resolver, ty)
@ -127,6 +127,17 @@ impl SourceAnalyzer {
Type::new_with_resolver(db, &self.resolver, ty)
}
pub(crate) fn type_of_self(
&self,
db: &dyn HirDatabase,
param: &ast::SelfParam,
) -> Option<Type> {
let src = InFile { file_id: self.file_id, value: param };
let pat_id = self.body_source_map.as_ref()?.node_self_param(src)?;
let ty = self.infer.as_ref()?[pat_id].clone();
Type::new_with_resolver(db, &self.resolver, ty)
}
pub(crate) fn resolve_method_call(
&self,
db: &dyn HirDatabase,

5
crates/ra_hir_def/src/body.rs
View File

@ -302,6 +302,11 @@ impl BodySourceMap {
self.pat_map.get(&src).cloned()
}
pub fn node_self_param(&self, node: InFile<&ast::SelfParam>) -> Option<PatId> {
let src = node.map(|it| Either::Right(AstPtr::new(it)));
self.pat_map.get(&src).cloned()
}
pub fn field_syntax(&self, expr: ExprId, field: usize) -> InFile<AstPtr<ast::RecordField>> {
self.field_map[&(expr, field)].clone()
}

10
crates/ra_ide/src/goto_definition.rs
View File

@ -7,7 +7,7 @@ use ra_syntax::{
ast::{self},
match_ast, AstNode,
SyntaxKind::*,
SyntaxToken, TokenAtOffset,
SyntaxToken, TokenAtOffset, T,
};
use crate::{
@ -32,9 +32,10 @@ pub(crate) fn goto_definition(
let file = sema.parse(position.file_id).syntax().clone();
let original_token = pick_best(file.token_at_offset(position.offset))?;
let token = sema.descend_into_macros(original_token.clone());
let parent = token.parent();
let nav_targets = match_ast! {
match (token.parent()) {
match parent {
ast::NameRef(name_ref) => {
reference_definition(&sema, &name_ref).to_vec()
},
@ -57,7 +58,7 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
return tokens.max_by_key(priority);
fn priority(n: &SyntaxToken) -> usize {
match n.kind() {
IDENT | INT_NUMBER => 2,
IDENT | INT_NUMBER | T![self] => 2,
kind if kind.is_trivia() => 0,
_ => 1,
}
@ -121,7 +122,8 @@ mod tests {
data => panic!("bad data: {}", data),
}
let mut navs = analysis.goto_definition(position).unwrap().unwrap().info;
let mut navs =
analysis.goto_definition(position).unwrap().expect("no definition found").info;
if navs.len() == 0 {
panic!("unresolved reference")
}

132
crates/ra_ide/src/goto_type_definition.rs
View File

@ -1,5 +1,5 @@
use ra_ide_db::RootDatabase;
use ra_syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset};
use ra_syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
use crate::{display::ToNav, FilePosition, NavigationTarget, RangeInfo};
@ -25,8 +25,9 @@ pub(crate) fn goto_type_definition(
let (ty, node) = sema.ancestors_with_macros(token.parent()).find_map(|node| {
let ty = match_ast! {
match node {
ast::Expr(expr) => sema.type_of_expr(&expr)?,
ast::Pat(pat) => sema.type_of_pat(&pat)?,
ast::Expr(it) => sema.type_of_expr(&it)?,
ast::Pat(it) => sema.type_of_pat(&it)?,
ast::SelfParam(it) => sema.type_of_self(&it)?,
_ => return None,
}
};
@ -34,7 +35,7 @@ pub(crate) fn goto_type_definition(
Some((ty, node))
})?;
let adt_def = ty.autoderef(db).find_map(|ty| ty.as_adt())?;
let adt_def = ty.autoderef(db).filter_map(|ty| ty.as_adt()).last()?;
let nav = adt_def.to_nav(db);
Some(RangeInfo::new(node.text_range(), vec![nav]))
@ -44,7 +45,7 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
return tokens.max_by_key(priority);
fn priority(n: &SyntaxToken) -> usize {
match n.kind() {
IDENT | INT_NUMBER => 2,
IDENT | INT_NUMBER | T![self] => 2,
kind if kind.is_trivia() => 0,
_ => 1,
}
@ -53,91 +54,98 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
#[cfg(test)]
mod tests {
use crate::mock_analysis::analysis_and_position;
use ra_db::FileRange;
fn check_goto(ra_fixture: &str, expected: &str) {
let (analysis, pos) = analysis_and_position(ra_fixture);
use crate::mock_analysis::MockAnalysis;
let mut navs = analysis.goto_type_definition(pos).unwrap().unwrap().info;
fn check(ra_fixture: &str) {
let (mock, position) = MockAnalysis::with_files_and_position(ra_fixture);
let (expected, data) = mock.annotation();
assert!(data.is_empty());
let analysis = mock.analysis();
let mut navs = analysis.goto_type_definition(position).unwrap().unwrap().info;
assert_eq!(navs.len(), 1);
let nav = navs.pop().unwrap();
nav.assert_match(expected);
assert_eq!(expected, FileRange { file_id: nav.file_id(), range: nav.range() });
}
#[test]
fn goto_type_definition_works_simple() {
check_goto(
r"
//- /lib.rs
struct Foo;
fn foo() {
let f: Foo;
f<|>
}
",
"Foo STRUCT_DEF FileId(1) 0..11 7..10",
check(
r#"
struct Foo;
//^^^
fn foo() {
let f: Foo; f<|>
}
"#,
);
}
#[test]
fn goto_type_definition_works_simple_ref() {
check_goto(
r"
//- /lib.rs
struct Foo;
fn foo() {
let f: &Foo;
f<|>
}
",
"Foo STRUCT_DEF FileId(1) 0..11 7..10",
check(
r#"
struct Foo;
//^^^
fn foo() {
let f: &Foo; f<|>
}
"#,
);
}
#[test]
fn goto_type_definition_works_through_macro() {
check_goto(
r"
//- /lib.rs
macro_rules! id {
($($tt:tt)*) => { $($tt)* }
}
struct Foo {}
id! {
fn bar() {
let f<|> = Foo {};
}
}
",
"Foo STRUCT_DEF FileId(1) 52..65 59..62",
check(
r#"
macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
struct Foo {}
//^^^
id! {
fn bar() { let f<|> = Foo {}; }
}
"#,
);
}
#[test]
fn goto_type_definition_for_param() {
check_goto(
r"
//- /lib.rs
struct Foo;
fn foo(<|>f: Foo) {}
",
"Foo STRUCT_DEF FileId(1) 0..11 7..10",
check(
r#"
struct Foo;
//^^^
fn foo(<|>f: Foo) {}
"#,
);
}
#[test]
fn goto_type_definition_for_tuple_field() {
check_goto(
r"
//- /lib.rs
struct Foo;
struct Bar(Foo);
fn foo() {
let bar = Bar(Foo);
bar.<|>0;
}
",
"Foo STRUCT_DEF FileId(1) 0..11 7..10",
check(
r#"
struct Foo;
//^^^
struct Bar(Foo);
fn foo() {
let bar = Bar(Foo);
bar.<|>0;
}
"#,
);
}
#[test]
fn goto_def_for_self_param() {
check(
r#"
struct Foo;
//^^^
impl Foo {
fn f(&self<|>) {}
}
"#,
)
}
}