diff options
Diffstat (limited to 'crates')
-rw-r--r-- | crates/ra_hir/src/source_binder.rs | 8 | ||||
-rw-r--r-- | crates/ra_ide/src/references.rs | 6 | ||||
-rw-r--r-- | crates/ra_ide/src/references/classify.rs | 109 | ||||
-rw-r--r-- | crates/ra_ide/src/syntax_highlighting.rs | 12 |
4 files changed, 78 insertions, 57 deletions
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs index ca003576a..00541dbe1 100644 --- a/crates/ra_hir/src/source_binder.rs +++ b/crates/ra_hir/src/source_binder.rs | |||
@@ -8,8 +8,8 @@ use hir_def::{ | |||
8 | dyn_map::DynMap, | 8 | dyn_map::DynMap, |
9 | keys::{self, Key}, | 9 | keys::{self, Key}, |
10 | resolver::{HasResolver, Resolver}, | 10 | resolver::{HasResolver, Resolver}, |
11 | ConstId, DefWithBodyId, EnumId, FunctionId, ImplId, ModuleId, StaticId, StructId, TraitId, | 11 | ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, ImplId, ModuleId, StaticId, |
12 | UnionId, VariantId, | 12 | StructFieldId, StructId, TraitId, TypeAliasId, UnionId, VariantId, |
13 | }; | 13 | }; |
14 | use hir_expand::InFile; | 14 | use hir_expand::InFile; |
15 | use ra_prof::profile; | 15 | use ra_prof::profile; |
@@ -166,6 +166,8 @@ to_id_impls![ | |||
166 | (FunctionId, ast::FnDef, keys::FUNCTION), | 166 | (FunctionId, ast::FnDef, keys::FUNCTION), |
167 | (StaticId, ast::StaticDef, keys::STATIC), | 167 | (StaticId, ast::StaticDef, keys::STATIC), |
168 | (ConstId, ast::ConstDef, keys::CONST), | 168 | (ConstId, ast::ConstDef, keys::CONST), |
169 | // (TypeAlias, TypeAliasId, ast::TypeAliasDef, keys::TYPE_ALIAS), | 169 | (TypeAliasId, ast::TypeAliasDef, keys::TYPE_ALIAS), |
170 | (ImplId, ast::ImplBlock, keys::IMPL), | 170 | (ImplId, ast::ImplBlock, keys::IMPL), |
171 | (StructFieldId, ast::RecordFieldDef, keys::RECORD_FIELD), | ||
172 | (EnumVariantId, ast::EnumVariant, keys::ENUM_VARIANT), | ||
171 | ]; | 173 | ]; |
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs index 2c753dade..2b74d7653 100644 --- a/crates/ra_ide/src/references.rs +++ b/crates/ra_ide/src/references.rs | |||
@@ -29,7 +29,7 @@ use crate::{ | |||
29 | }; | 29 | }; |
30 | 30 | ||
31 | pub(crate) use self::{ | 31 | pub(crate) use self::{ |
32 | classify::{classify_name, classify_name_ref}, | 32 | classify::{classify_name, classify_name2, classify_name_ref, classify_name_ref2}, |
33 | name_definition::{NameDefinition, NameKind}, | 33 | name_definition::{NameDefinition, NameKind}, |
34 | rename::rename, | 34 | rename::rename, |
35 | }; | 35 | }; |
@@ -309,7 +309,7 @@ mod tests { | |||
309 | } | 309 | } |
310 | impl Foo { | 310 | impl Foo { |
311 | fn f() -> i32 { 42 } | 311 | fn f() -> i32 { 42 } |
312 | } | 312 | } |
313 | fn main() { | 313 | fn main() { |
314 | let f: Foo; | 314 | let f: Foo; |
315 | f = Foo {a: Foo::f()}; | 315 | f = Foo {a: Foo::f()}; |
@@ -319,7 +319,7 @@ mod tests { | |||
319 | check_result( | 319 | check_result( |
320 | refs, | 320 | refs, |
321 | "Foo STRUCT_DEF FileId(1) [5; 39) [12; 15) Other", | 321 | "Foo STRUCT_DEF FileId(1) [5; 39) [12; 15) Other", |
322 | &["FileId(1) [142; 145) StructLiteral"], | 322 | &["FileId(1) [138; 141) StructLiteral"], |
323 | ); | 323 | ); |
324 | } | 324 | } |
325 | 325 | ||
diff --git a/crates/ra_ide/src/references/classify.rs b/crates/ra_ide/src/references/classify.rs index 3483a7176..9778ca536 100644 --- a/crates/ra_ide/src/references/classify.rs +++ b/crates/ra_ide/src/references/classify.rs | |||
@@ -1,6 +1,6 @@ | |||
1 | //! Functions that are used to classify an element from its definition or reference. | 1 | //! Functions that are used to classify an element from its definition or reference. |
2 | 2 | ||
3 | use hir::{FromSource, InFile, Module, ModuleSource, PathResolution, SourceAnalyzer}; | 3 | use hir::{FromSource, InFile, Module, ModuleSource, PathResolution, SourceBinder}; |
4 | use ra_prof::profile; | 4 | use ra_prof::profile; |
5 | use ra_syntax::{ast, match_ast, AstNode}; | 5 | use ra_syntax::{ast, match_ast, AstNode}; |
6 | use test_utils::tested_by; | 6 | use test_utils::tested_by; |
@@ -12,6 +12,14 @@ use super::{ | |||
12 | use crate::db::RootDatabase; | 12 | use crate::db::RootDatabase; |
13 | 13 | ||
14 | pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Option<NameDefinition> { | 14 | pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Option<NameDefinition> { |
15 | let mut sb = SourceBinder::new(db); | ||
16 | classify_name2(&mut sb, name) | ||
17 | } | ||
18 | |||
19 | pub(crate) fn classify_name2( | ||
20 | sb: &mut SourceBinder<RootDatabase>, | ||
21 | name: InFile<&ast::Name>, | ||
22 | ) -> Option<NameDefinition> { | ||
15 | let _p = profile("classify_name"); | 23 | let _p = profile("classify_name"); |
16 | let parent = name.value.syntax().parent()?; | 24 | let parent = name.value.syntax().parent()?; |
17 | 25 | ||
@@ -19,90 +27,89 @@ pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Opti | |||
19 | match parent { | 27 | match parent { |
20 | ast::BindPat(it) => { | 28 | ast::BindPat(it) => { |
21 | let src = name.with_value(it); | 29 | let src = name.with_value(it); |
22 | let local = hir::Local::from_source(db, src)?; | 30 | let local = hir::Local::from_source(sb.db, src)?; |
23 | Some(NameDefinition { | 31 | Some(NameDefinition { |
24 | visibility: None, | 32 | visibility: None, |
25 | container: local.module(db), | 33 | container: local.module(sb.db), |
26 | kind: NameKind::Local(local), | 34 | kind: NameKind::Local(local), |
27 | }) | 35 | }) |
28 | }, | 36 | }, |
29 | ast::RecordFieldDef(it) => { | 37 | ast::RecordFieldDef(it) => { |
30 | let ast = hir::FieldSource::Named(it); | 38 | let src = name.with_value(it); |
31 | let src = name.with_value(ast); | 39 | let field: hir::StructField = sb.to_def(src)?; |
32 | let field = hir::StructField::from_source(db, src)?; | 40 | Some(from_struct_field(sb.db, field)) |
33 | Some(from_struct_field(db, field)) | ||
34 | }, | 41 | }, |
35 | ast::Module(it) => { | 42 | ast::Module(it) => { |
36 | let def = { | 43 | let def = { |
37 | if !it.has_semi() { | 44 | if !it.has_semi() { |
38 | let ast = hir::ModuleSource::Module(it); | 45 | let ast = hir::ModuleSource::Module(it); |
39 | let src = name.with_value(ast); | 46 | let src = name.with_value(ast); |
40 | hir::Module::from_definition(db, src) | 47 | hir::Module::from_definition(sb.db, src) |
41 | } else { | 48 | } else { |
42 | let src = name.with_value(it); | 49 | let src = name.with_value(it); |
43 | hir::Module::from_declaration(db, src) | 50 | hir::Module::from_declaration(sb.db, src) |
44 | } | 51 | } |
45 | }?; | 52 | }?; |
46 | Some(from_module_def(db, def.into(), None)) | 53 | Some(from_module_def(sb.db, def.into(), None)) |
47 | }, | 54 | }, |
48 | ast::StructDef(it) => { | 55 | ast::StructDef(it) => { |
49 | let src = name.with_value(it); | 56 | let src = name.with_value(it); |
50 | let def = hir::Struct::from_source(db, src)?; | 57 | let def: hir::Struct = sb.to_def(src)?; |
51 | Some(from_module_def(db, def.into(), None)) | 58 | Some(from_module_def(sb.db, def.into(), None)) |
52 | }, | 59 | }, |
53 | ast::EnumDef(it) => { | 60 | ast::EnumDef(it) => { |
54 | let src = name.with_value(it); | 61 | let src = name.with_value(it); |
55 | let def = hir::Enum::from_source(db, src)?; | 62 | let def: hir::Enum = sb.to_def(src)?; |
56 | Some(from_module_def(db, def.into(), None)) | 63 | Some(from_module_def(sb.db, def.into(), None)) |
57 | }, | 64 | }, |
58 | ast::TraitDef(it) => { | 65 | ast::TraitDef(it) => { |
59 | let src = name.with_value(it); | 66 | let src = name.with_value(it); |
60 | let def = hir::Trait::from_source(db, src)?; | 67 | let def: hir::Trait = sb.to_def(src)?; |
61 | Some(from_module_def(db, def.into(), None)) | 68 | Some(from_module_def(sb.db, def.into(), None)) |
62 | }, | 69 | }, |
63 | ast::StaticDef(it) => { | 70 | ast::StaticDef(it) => { |
64 | let src = name.with_value(it); | 71 | let src = name.with_value(it); |
65 | let def = hir::Static::from_source(db, src)?; | 72 | let def: hir::Static = sb.to_def(src)?; |
66 | Some(from_module_def(db, def.into(), None)) | 73 | Some(from_module_def(sb.db, def.into(), None)) |
67 | }, | 74 | }, |
68 | ast::EnumVariant(it) => { | 75 | ast::EnumVariant(it) => { |
69 | let src = name.with_value(it); | 76 | let src = name.with_value(it); |
70 | let def = hir::EnumVariant::from_source(db, src)?; | 77 | let def: hir::EnumVariant = sb.to_def(src)?; |
71 | Some(from_module_def(db, def.into(), None)) | 78 | Some(from_module_def(sb.db, def.into(), None)) |
72 | }, | 79 | }, |
73 | ast::FnDef(it) => { | 80 | ast::FnDef(it) => { |
74 | let src = name.with_value(it); | 81 | let src = name.with_value(it); |
75 | let def = hir::Function::from_source(db, src)?; | 82 | let def: hir::Function = sb.to_def(src)?; |
76 | if parent.parent().and_then(ast::ItemList::cast).is_some() { | 83 | if parent.parent().and_then(ast::ItemList::cast).is_some() { |
77 | Some(from_assoc_item(db, def.into())) | 84 | Some(from_assoc_item(sb.db, def.into())) |
78 | } else { | 85 | } else { |
79 | Some(from_module_def(db, def.into(), None)) | 86 | Some(from_module_def(sb.db, def.into(), None)) |
80 | } | 87 | } |
81 | }, | 88 | }, |
82 | ast::ConstDef(it) => { | 89 | ast::ConstDef(it) => { |
83 | let src = name.with_value(it); | 90 | let src = name.with_value(it); |
84 | let def = hir::Const::from_source(db, src)?; | 91 | let def: hir::Const = sb.to_def(src)?; |
85 | if parent.parent().and_then(ast::ItemList::cast).is_some() { | 92 | if parent.parent().and_then(ast::ItemList::cast).is_some() { |
86 | Some(from_assoc_item(db, def.into())) | 93 | Some(from_assoc_item(sb.db, def.into())) |
87 | } else { | 94 | } else { |
88 | Some(from_module_def(db, def.into(), None)) | 95 | Some(from_module_def(sb.db, def.into(), None)) |
89 | } | 96 | } |
90 | }, | 97 | }, |
91 | ast::TypeAliasDef(it) => { | 98 | ast::TypeAliasDef(it) => { |
92 | let src = name.with_value(it); | 99 | let src = name.with_value(it); |
93 | let def = hir::TypeAlias::from_source(db, src)?; | 100 | let def: hir::TypeAlias = sb.to_def(src)?; |
94 | if parent.parent().and_then(ast::ItemList::cast).is_some() { | 101 | if parent.parent().and_then(ast::ItemList::cast).is_some() { |
95 | Some(from_assoc_item(db, def.into())) | 102 | Some(from_assoc_item(sb.db, def.into())) |
96 | } else { | 103 | } else { |
97 | Some(from_module_def(db, def.into(), None)) | 104 | Some(from_module_def(sb.db, def.into(), None)) |
98 | } | 105 | } |
99 | }, | 106 | }, |
100 | ast::MacroCall(it) => { | 107 | ast::MacroCall(it) => { |
101 | let src = name.with_value(it); | 108 | let src = name.with_value(it); |
102 | let def = hir::MacroDef::from_source(db, src.clone())?; | 109 | let def = hir::MacroDef::from_source(sb.db, src.clone())?; |
103 | 110 | ||
104 | let module_src = ModuleSource::from_child_node(db, src.as_ref().map(|it| it.syntax())); | 111 | let module_src = ModuleSource::from_child_node(sb.db, src.as_ref().map(|it| it.syntax())); |
105 | let module = Module::from_definition(db, src.with_value(module_src))?; | 112 | let module = Module::from_definition(sb.db, src.with_value(module_src))?; |
106 | 113 | ||
107 | Some(NameDefinition { | 114 | Some(NameDefinition { |
108 | visibility: None, | 115 | visibility: None, |
@@ -112,10 +119,10 @@ pub(crate) fn classify_name(db: &RootDatabase, name: InFile<&ast::Name>) -> Opti | |||
112 | }, | 119 | }, |
113 | ast::TypeParam(it) => { | 120 | ast::TypeParam(it) => { |
114 | let src = name.with_value(it); | 121 | let src = name.with_value(it); |
115 | let def = hir::TypeParam::from_source(db, src)?; | 122 | let def = hir::TypeParam::from_source(sb.db, src)?; |
116 | Some(NameDefinition { | 123 | Some(NameDefinition { |
117 | visibility: None, | 124 | visibility: None, |
118 | container: def.module(db), | 125 | container: def.module(sb.db), |
119 | kind: NameKind::TypeParam(def), | 126 | kind: NameKind::TypeParam(def), |
120 | }) | 127 | }) |
121 | }, | 128 | }, |
@@ -128,22 +135,30 @@ pub(crate) fn classify_name_ref( | |||
128 | db: &RootDatabase, | 135 | db: &RootDatabase, |
129 | name_ref: InFile<&ast::NameRef>, | 136 | name_ref: InFile<&ast::NameRef>, |
130 | ) -> Option<NameDefinition> { | 137 | ) -> Option<NameDefinition> { |
138 | let mut sb = SourceBinder::new(db); | ||
139 | classify_name_ref2(&mut sb, name_ref) | ||
140 | } | ||
141 | |||
142 | pub(crate) fn classify_name_ref2( | ||
143 | sb: &mut SourceBinder<RootDatabase>, | ||
144 | name_ref: InFile<&ast::NameRef>, | ||
145 | ) -> Option<NameDefinition> { | ||
131 | let _p = profile("classify_name_ref"); | 146 | let _p = profile("classify_name_ref"); |
132 | 147 | ||
133 | let parent = name_ref.value.syntax().parent()?; | 148 | let parent = name_ref.value.syntax().parent()?; |
134 | let analyzer = SourceAnalyzer::new(db, name_ref.map(|it| it.syntax()), None); | 149 | let analyzer = sb.analyze(name_ref.map(|it| it.syntax()), None); |
135 | 150 | ||
136 | if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) { | 151 | if let Some(method_call) = ast::MethodCallExpr::cast(parent.clone()) { |
137 | tested_by!(goto_def_for_methods); | 152 | tested_by!(goto_def_for_methods); |
138 | if let Some(func) = analyzer.resolve_method_call(&method_call) { | 153 | if let Some(func) = analyzer.resolve_method_call(&method_call) { |
139 | return Some(from_assoc_item(db, func.into())); | 154 | return Some(from_assoc_item(sb.db, func.into())); |
140 | } | 155 | } |
141 | } | 156 | } |
142 | 157 | ||
143 | if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) { | 158 | if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) { |
144 | tested_by!(goto_def_for_fields); | 159 | tested_by!(goto_def_for_fields); |
145 | if let Some(field) = analyzer.resolve_field(&field_expr) { | 160 | if let Some(field) = analyzer.resolve_field(&field_expr) { |
146 | return Some(from_struct_field(db, field)); | 161 | return Some(from_struct_field(sb.db, field)); |
147 | } | 162 | } |
148 | } | 163 | } |
149 | 164 | ||
@@ -151,30 +166,32 @@ pub(crate) fn classify_name_ref( | |||
151 | tested_by!(goto_def_for_record_fields); | 166 | tested_by!(goto_def_for_record_fields); |
152 | tested_by!(goto_def_for_field_init_shorthand); | 167 | tested_by!(goto_def_for_field_init_shorthand); |
153 | if let Some(field_def) = analyzer.resolve_record_field(&record_field) { | 168 | if let Some(field_def) = analyzer.resolve_record_field(&record_field) { |
154 | return Some(from_struct_field(db, field_def)); | 169 | return Some(from_struct_field(sb.db, field_def)); |
155 | } | 170 | } |
156 | } | 171 | } |
157 | 172 | ||
158 | let ast = ModuleSource::from_child_node(db, name_ref.with_value(&parent)); | 173 | let ast = ModuleSource::from_child_node(sb.db, name_ref.with_value(&parent)); |
159 | // FIXME: find correct container and visibility for each case | 174 | // FIXME: find correct container and visibility for each case |
160 | let container = Module::from_definition(db, name_ref.with_value(ast))?; | 175 | let container = Module::from_definition(sb.db, name_ref.with_value(ast))?; |
161 | let visibility = None; | 176 | let visibility = None; |
162 | 177 | ||
163 | if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) { | 178 | if let Some(macro_call) = parent.ancestors().find_map(ast::MacroCall::cast) { |
164 | tested_by!(goto_def_for_macros); | 179 | tested_by!(goto_def_for_macros); |
165 | if let Some(macro_def) = analyzer.resolve_macro_call(db, name_ref.with_value(¯o_call)) { | 180 | if let Some(macro_def) = |
181 | analyzer.resolve_macro_call(sb.db, name_ref.with_value(¯o_call)) | ||
182 | { | ||
166 | let kind = NameKind::Macro(macro_def); | 183 | let kind = NameKind::Macro(macro_def); |
167 | return Some(NameDefinition { kind, container, visibility }); | 184 | return Some(NameDefinition { kind, container, visibility }); |
168 | } | 185 | } |
169 | } | 186 | } |
170 | 187 | ||
171 | let path = name_ref.value.syntax().ancestors().find_map(ast::Path::cast)?; | 188 | let path = name_ref.value.syntax().ancestors().find_map(ast::Path::cast)?; |
172 | let resolved = analyzer.resolve_path(db, &path)?; | 189 | let resolved = analyzer.resolve_path(sb.db, &path)?; |
173 | match resolved { | 190 | match resolved { |
174 | PathResolution::Def(def) => Some(from_module_def(db, def, Some(container))), | 191 | PathResolution::Def(def) => Some(from_module_def(sb.db, def, Some(container))), |
175 | PathResolution::AssocItem(item) => Some(from_assoc_item(db, item)), | 192 | PathResolution::AssocItem(item) => Some(from_assoc_item(sb.db, item)), |
176 | PathResolution::Local(local) => { | 193 | PathResolution::Local(local) => { |
177 | let container = local.module(db); | 194 | let container = local.module(sb.db); |
178 | let kind = NameKind::Local(local); | 195 | let kind = NameKind::Local(local); |
179 | Some(NameDefinition { kind, container, visibility: None }) | 196 | Some(NameDefinition { kind, container, visibility: None }) |
180 | } | 197 | } |
@@ -188,7 +205,7 @@ pub(crate) fn classify_name_ref( | |||
188 | } | 205 | } |
189 | PathResolution::SelfType(impl_block) => { | 206 | PathResolution::SelfType(impl_block) => { |
190 | let kind = NameKind::SelfType(impl_block); | 207 | let kind = NameKind::SelfType(impl_block); |
191 | let container = impl_block.module(db); | 208 | let container = impl_block.module(sb.db); |
192 | Some(NameDefinition { kind, container, visibility }) | 209 | Some(NameDefinition { kind, container, visibility }) |
193 | } | 210 | } |
194 | } | 211 | } |
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs index f06a8933e..fd422d07c 100644 --- a/crates/ra_ide/src/syntax_highlighting.rs +++ b/crates/ra_ide/src/syntax_highlighting.rs | |||
@@ -2,7 +2,7 @@ | |||
2 | 2 | ||
3 | use rustc_hash::{FxHashMap, FxHashSet}; | 3 | use rustc_hash::{FxHashMap, FxHashSet}; |
4 | 4 | ||
5 | use hir::{InFile, Name}; | 5 | use hir::{InFile, Name, SourceBinder}; |
6 | use ra_db::SourceDatabase; | 6 | use ra_db::SourceDatabase; |
7 | use ra_prof::profile; | 7 | use ra_prof::profile; |
8 | use ra_syntax::{ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, TextRange, T}; | 8 | use ra_syntax::{ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, TextRange, T}; |
@@ -10,7 +10,7 @@ use ra_syntax::{ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind:: | |||
10 | use crate::{ | 10 | use crate::{ |
11 | db::RootDatabase, | 11 | db::RootDatabase, |
12 | references::{ | 12 | references::{ |
13 | classify_name, classify_name_ref, | 13 | classify_name2, classify_name_ref2, |
14 | NameKind::{self, *}, | 14 | NameKind::{self, *}, |
15 | }, | 15 | }, |
16 | FileId, | 16 | FileId, |
@@ -84,6 +84,8 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa | |||
84 | hash((file_id, name, shadow_count)) | 84 | hash((file_id, name, shadow_count)) |
85 | } | 85 | } |
86 | 86 | ||
87 | let mut sb = SourceBinder::new(db); | ||
88 | |||
87 | // Visited nodes to handle highlighting priorities | 89 | // Visited nodes to handle highlighting priorities |
88 | // FIXME: retain only ranges here | 90 | // FIXME: retain only ranges here |
89 | let mut highlighted: FxHashSet<SyntaxElement> = FxHashSet::default(); | 91 | let mut highlighted: FxHashSet<SyntaxElement> = FxHashSet::default(); |
@@ -108,8 +110,8 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa | |||
108 | NAME_REF if node.ancestors().any(|it| it.kind() == ATTR) => continue, | 110 | NAME_REF if node.ancestors().any(|it| it.kind() == ATTR) => continue, |
109 | NAME_REF => { | 111 | NAME_REF => { |
110 | let name_ref = node.as_node().cloned().and_then(ast::NameRef::cast).unwrap(); | 112 | let name_ref = node.as_node().cloned().and_then(ast::NameRef::cast).unwrap(); |
111 | let name_kind = | 113 | let name_kind = classify_name_ref2(&mut sb, InFile::new(file_id.into(), &name_ref)) |
112 | classify_name_ref(db, InFile::new(file_id.into(), &name_ref)).map(|d| d.kind); | 114 | .map(|d| d.kind); |
113 | match name_kind { | 115 | match name_kind { |
114 | Some(name_kind) => { | 116 | Some(name_kind) => { |
115 | if let Local(local) = &name_kind { | 117 | if let Local(local) = &name_kind { |
@@ -129,7 +131,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa | |||
129 | NAME => { | 131 | NAME => { |
130 | let name = node.as_node().cloned().and_then(ast::Name::cast).unwrap(); | 132 | let name = node.as_node().cloned().and_then(ast::Name::cast).unwrap(); |
131 | let name_kind = | 133 | let name_kind = |
132 | classify_name(db, InFile::new(file_id.into(), &name)).map(|d| d.kind); | 134 | classify_name2(&mut sb, InFile::new(file_id.into(), &name)).map(|d| d.kind); |
133 | 135 | ||
134 | if let Some(Local(local)) = &name_kind { | 136 | if let Some(Local(local)) = &name_kind { |
135 | if let Some(name) = local.name(db) { | 137 | if let Some(name) = local.name(db) { |