diff options
author | Ekaterina Babshukova <[email protected]> | 2019-10-12 16:47:17 +0100 |
---|---|---|
committer | Ekaterina Babshukova <[email protected]> | 2019-10-22 21:47:31 +0100 |
commit | d26d0ada50fd0063c03e28bc2673f9f63fd23d95 (patch) | |
tree | 1292e2a6352b2bf886baed12cc69dab04dd82462 /crates/ra_ide_api/src/references/classify.rs | |
parent | 0dd08b8023eba053725d5032149808b8733be263 (diff) |
restructure a bit
Diffstat (limited to 'crates/ra_ide_api/src/references/classify.rs')
-rw-r--r-- | crates/ra_ide_api/src/references/classify.rs | 143 |
1 files changed, 143 insertions, 0 deletions
diff --git a/crates/ra_ide_api/src/references/classify.rs b/crates/ra_ide_api/src/references/classify.rs new file mode 100644 index 000000000..0b604a5cf --- /dev/null +++ b/crates/ra_ide_api/src/references/classify.rs | |||
@@ -0,0 +1,143 @@ | |||
1 | use hir::{ | ||
2 | AssocItem, Either, EnumVariant, FromSource, Module, ModuleDef, ModuleSource, Path, | ||
3 | PathResolution, Source, SourceAnalyzer, StructField, | ||
4 | }; | ||
5 | use ra_db::FileId; | ||
6 | use ra_syntax::{ast, match_ast, AstNode, AstPtr}; | ||
7 | |||
8 | use super::{definition::HasDefinition, Definition, NameKind}; | ||
9 | use crate::db::RootDatabase; | ||
10 | |||
11 | use hir::{db::AstDatabase, HirFileId}; | ||
12 | |||
13 | pub(crate) fn classify_name( | ||
14 | db: &RootDatabase, | ||
15 | file_id: FileId, | ||
16 | name: &ast::Name, | ||
17 | ) -> Option<Definition> { | ||
18 | let parent = name.syntax().parent()?; | ||
19 | let file_id = file_id.into(); | ||
20 | |||
21 | match_ast! { | ||
22 | match parent { | ||
23 | ast::BindPat(it) => { | ||
24 | decl_from_pat(db, file_id, AstPtr::new(&it)) | ||
25 | }, | ||
26 | ast::RecordFieldDef(it) => { | ||
27 | StructField::from_def(db, file_id, it) | ||
28 | }, | ||
29 | ast::ImplItem(it) => { | ||
30 | AssocItem::from_def(db, file_id, it.clone()).or_else(|| { | ||
31 | match it { | ||
32 | ast::ImplItem::FnDef(f) => ModuleDef::from_def(db, file_id, f.into()), | ||
33 | ast::ImplItem::ConstDef(c) => ModuleDef::from_def(db, file_id, c.into()), | ||
34 | ast::ImplItem::TypeAliasDef(a) => ModuleDef::from_def(db, file_id, a.into()), | ||
35 | } | ||
36 | }) | ||
37 | }, | ||
38 | ast::EnumVariant(it) => { | ||
39 | let src = hir::Source { file_id, ast: it.clone() }; | ||
40 | let def: ModuleDef = EnumVariant::from_source(db, src)?.into(); | ||
41 | Some(def.definition(db)) | ||
42 | }, | ||
43 | ast::ModuleItem(it) => { | ||
44 | ModuleDef::from_def(db, file_id, it) | ||
45 | }, | ||
46 | _ => None, | ||
47 | } | ||
48 | } | ||
49 | } | ||
50 | |||
51 | pub(crate) fn classify_name_ref( | ||
52 | db: &RootDatabase, | ||
53 | file_id: FileId, | ||
54 | name_ref: &ast::NameRef, | ||
55 | ) -> Option<Definition> { | ||
56 | let analyzer = SourceAnalyzer::new(db, file_id, name_ref.syntax(), None); | ||
57 | let parent = name_ref.syntax().parent()?; | ||
58 | match_ast! { | ||
59 | match parent { | ||
60 | ast::MethodCallExpr(it) => { | ||
61 | return AssocItem::from_ref(db, &analyzer, it); | ||
62 | }, | ||
63 | ast::FieldExpr(it) => { | ||
64 | if let Some(field) = analyzer.resolve_field(&it) { | ||
65 | return Some(field.definition(db)); | ||
66 | } | ||
67 | }, | ||
68 | ast::RecordField(it) => { | ||
69 | if let Some(record_lit) = it.syntax().ancestors().find_map(ast::RecordLit::cast) { | ||
70 | let variant_def = analyzer.resolve_record_literal(&record_lit)?; | ||
71 | let hir_path = Path::from_name_ref(name_ref); | ||
72 | let hir_name = hir_path.as_ident()?; | ||
73 | let field = variant_def.field(db, hir_name)?; | ||
74 | return Some(field.definition(db)); | ||
75 | } | ||
76 | }, | ||
77 | _ => (), | ||
78 | } | ||
79 | } | ||
80 | |||
81 | let ast = ModuleSource::from_child_node(db, file_id, &parent); | ||
82 | let file_id = file_id.into(); | ||
83 | let container = Module::from_definition(db, Source { file_id, ast })?; | ||
84 | let visibility = None; | ||
85 | |||
86 | if let Some(macro_call) = | ||
87 | parent.parent().and_then(|node| node.parent()).and_then(ast::MacroCall::cast) | ||
88 | { | ||
89 | if let Some(mac) = analyzer.resolve_macro_call(db, ¯o_call) { | ||
90 | return Some(Definition { item: NameKind::Macro(mac), container, visibility }); | ||
91 | } | ||
92 | } | ||
93 | |||
94 | // General case, a path or a local: | ||
95 | let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?; | ||
96 | let resolved = analyzer.resolve_path(db, &path)?; | ||
97 | match resolved { | ||
98 | PathResolution::Def(def) => Some(def.definition(db)), | ||
99 | PathResolution::LocalBinding(Either::A(pat)) => decl_from_pat(db, file_id, pat), | ||
100 | PathResolution::LocalBinding(Either::B(par)) => { | ||
101 | Some(Definition { item: NameKind::SelfParam(par), container, visibility }) | ||
102 | } | ||
103 | PathResolution::GenericParam(par) => { | ||
104 | // FIXME: get generic param def | ||
105 | Some(Definition { item: NameKind::GenericParam(par), container, visibility }) | ||
106 | } | ||
107 | PathResolution::Macro(def) => { | ||
108 | Some(Definition { item: NameKind::Macro(def), container, visibility }) | ||
109 | } | ||
110 | PathResolution::SelfType(impl_block) => { | ||
111 | let ty = impl_block.target_ty(db); | ||
112 | let container = impl_block.module(); | ||
113 | Some(Definition { item: NameKind::SelfType(ty), container, visibility }) | ||
114 | } | ||
115 | PathResolution::AssocItem(assoc) => Some(assoc.definition(db)), | ||
116 | } | ||
117 | } | ||
118 | |||
119 | fn decl_from_pat( | ||
120 | db: &RootDatabase, | ||
121 | file_id: HirFileId, | ||
122 | pat: AstPtr<ast::BindPat>, | ||
123 | ) -> Option<Definition> { | ||
124 | let root = db.parse_or_expand(file_id)?; | ||
125 | // FIXME: use match_ast! | ||
126 | let def = pat.to_node(&root).syntax().ancestors().find_map(|node| { | ||
127 | if let Some(it) = ast::FnDef::cast(node.clone()) { | ||
128 | let src = hir::Source { file_id, ast: it }; | ||
129 | Some(hir::Function::from_source(db, src)?.into()) | ||
130 | } else if let Some(it) = ast::ConstDef::cast(node.clone()) { | ||
131 | let src = hir::Source { file_id, ast: it }; | ||
132 | Some(hir::Const::from_source(db, src)?.into()) | ||
133 | } else if let Some(it) = ast::StaticDef::cast(node.clone()) { | ||
134 | let src = hir::Source { file_id, ast: it }; | ||
135 | Some(hir::Static::from_source(db, src)?.into()) | ||
136 | } else { | ||
137 | None | ||
138 | } | ||
139 | })?; | ||
140 | let item = NameKind::Pat((def, pat)); | ||
141 | let container = def.module(db); | ||
142 | Some(Definition { item, container, visibility: None }) | ||
143 | } | ||