aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_ide/src/syntax_highlighting.rs
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_ide/src/syntax_highlighting.rs')
-rw-r--r--crates/ra_ide/src/syntax_highlighting.rs873
1 files changed, 0 insertions, 873 deletions
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
deleted file mode 100644
index c10e15db8..000000000
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ /dev/null
@@ -1,873 +0,0 @@
1mod tags;
2mod html;
3mod injection;
4#[cfg(test)]
5mod tests;
6
7use hir::{Name, Semantics, VariantDef};
8use ra_ide_db::{
9 defs::{classify_name, classify_name_ref, Definition, NameClass, NameRefClass},
10 RootDatabase,
11};
12use ra_prof::profile;
13use ra_syntax::{
14 ast::{self, HasFormatSpecifier},
15 AstNode, AstToken, Direction, NodeOrToken, SyntaxElement,
16 SyntaxKind::*,
17 TextRange, WalkEvent, T,
18};
19use rustc_hash::FxHashMap;
20
21use crate::FileId;
22
23use ast::FormatSpecifier;
24pub(crate) use html::highlight_as_html;
25pub use tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag};
26
27#[derive(Debug, Clone)]
28pub struct HighlightedRange {
29 pub range: TextRange,
30 pub highlight: Highlight,
31 pub binding_hash: Option<u64>,
32}
33
34// Feature: Semantic Syntax Highlighting
35//
36// rust-analyzer highlights the code semantically.
37// For example, `bar` in `foo::Bar` might be colored differently depending on whether `Bar` is an enum or a trait.
38// rust-analyzer does not specify colors directly, instead it assigns tag (like `struct`) and a set of modifiers (like `declaration`) to each token.
39// It's up to the client to map those to specific colors.
40//
41// The general rule is that a reference to an entity gets colored the same way as the entity itself.
42// We also give special modifier for `mut` and `&mut` local variables.
43pub(crate) fn highlight(
44 db: &RootDatabase,
45 file_id: FileId,
46 range_to_highlight: Option<TextRange>,
47 syntactic_name_ref_highlighting: bool,
48) -> Vec<HighlightedRange> {
49 let _p = profile("highlight");
50 let sema = Semantics::new(db);
51
52 // Determine the root based on the given range.
53 let (root, range_to_highlight) = {
54 let source_file = sema.parse(file_id);
55 match range_to_highlight {
56 Some(range) => {
57 let node = match source_file.syntax().covering_element(range) {
58 NodeOrToken::Node(it) => it,
59 NodeOrToken::Token(it) => it.parent(),
60 };
61 (node, range)
62 }
63 None => (source_file.syntax().clone(), source_file.syntax().text_range()),
64 }
65 };
66
67 let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
68 // We use a stack for the DFS traversal below.
69 // When we leave a node, the we use it to flatten the highlighted ranges.
70 let mut stack = HighlightedRangeStack::new();
71
72 let mut current_macro_call: Option<ast::MacroCall> = None;
73 let mut format_string: Option<SyntaxElement> = None;
74
75 // Walk all nodes, keeping track of whether we are inside a macro or not.
76 // If in macro, expand it first and highlight the expanded code.
77 for event in root.preorder_with_tokens() {
78 match &event {
79 WalkEvent::Enter(_) => stack.push(),
80 WalkEvent::Leave(_) => stack.pop(),
81 };
82
83 let event_range = match &event {
84 WalkEvent::Enter(it) => it.text_range(),
85 WalkEvent::Leave(it) => it.text_range(),
86 };
87
88 // Element outside of the viewport, no need to highlight
89 if range_to_highlight.intersect(event_range).is_none() {
90 continue;
91 }
92
93 // Track "inside macro" state
94 match event.clone().map(|it| it.into_node().and_then(ast::MacroCall::cast)) {
95 WalkEvent::Enter(Some(mc)) => {
96 current_macro_call = Some(mc.clone());
97 if let Some(range) = macro_call_range(&mc) {
98 stack.add(HighlightedRange {
99 range,
100 highlight: HighlightTag::Macro.into(),
101 binding_hash: None,
102 });
103 }
104 if let Some(name) = mc.is_macro_rules() {
105 if let Some((highlight, binding_hash)) = highlight_element(
106 &sema,
107 &mut bindings_shadow_count,
108 syntactic_name_ref_highlighting,
109 name.syntax().clone().into(),
110 ) {
111 stack.add(HighlightedRange {
112 range: name.syntax().text_range(),
113 highlight,
114 binding_hash,
115 });
116 }
117 }
118 continue;
119 }
120 WalkEvent::Leave(Some(mc)) => {
121 assert!(current_macro_call == Some(mc));
122 current_macro_call = None;
123 format_string = None;
124 }
125 _ => (),
126 }
127
128 // Check for Rust code in documentation
129 match &event {
130 WalkEvent::Leave(NodeOrToken::Node(node)) => {
131 if let Some((doctest, range_mapping, new_comments)) =
132 injection::extract_doc_comments(node)
133 {
134 injection::highlight_doc_comment(
135 doctest,
136 range_mapping,
137 new_comments,
138 &mut stack,
139 );
140 }
141 }
142 _ => (),
143 }
144
145 let element = match event {
146 WalkEvent::Enter(it) => it,
147 WalkEvent::Leave(_) => continue,
148 };
149
150 let range = element.text_range();
151
152 let element_to_highlight = if current_macro_call.is_some() && element.kind() != COMMENT {
153 // Inside a macro -- expand it first
154 let token = match element.clone().into_token() {
155 Some(it) if it.parent().kind() == TOKEN_TREE => it,
156 _ => continue,
157 };
158 let token = sema.descend_into_macros(token.clone());
159 let parent = token.parent();
160
161 // Check if macro takes a format string and remember it for highlighting later.
162 // The macros that accept a format string expand to a compiler builtin macros
163 // `format_args` and `format_args_nl`.
164 if let Some(name) = parent
165 .parent()
166 .and_then(ast::MacroCall::cast)
167 .and_then(|mc| mc.path())
168 .and_then(|p| p.segment())
169 .and_then(|s| s.name_ref())
170 {
171 match name.text().as_str() {
172 "format_args" | "format_args_nl" => {
173 format_string = parent
174 .children_with_tokens()
175 .filter(|t| t.kind() != WHITESPACE)
176 .nth(1)
177 .filter(|e| {
178 ast::String::can_cast(e.kind())
179 || ast::RawString::can_cast(e.kind())
180 })
181 }
182 _ => {}
183 }
184 }
185
186 // We only care Name and Name_ref
187 match (token.kind(), parent.kind()) {
188 (IDENT, NAME) | (IDENT, NAME_REF) => parent.into(),
189 _ => token.into(),
190 }
191 } else {
192 element.clone()
193 };
194
195 if let Some(token) = element.as_token().cloned().and_then(ast::RawString::cast) {
196 let expanded = element_to_highlight.as_token().unwrap().clone();
197 if injection::highlight_injection(&mut stack, &sema, token, expanded).is_some() {
198 continue;
199 }
200 }
201
202 let is_format_string = format_string.as_ref() == Some(&element_to_highlight);
203
204 if let Some((highlight, binding_hash)) = highlight_element(
205 &sema,
206 &mut bindings_shadow_count,
207 syntactic_name_ref_highlighting,
208 element_to_highlight.clone(),
209 ) {
210 stack.add(HighlightedRange { range, highlight, binding_hash });
211 if let Some(string) =
212 element_to_highlight.as_token().cloned().and_then(ast::String::cast)
213 {
214 if is_format_string {
215 stack.push();
216 string.lex_format_specifier(|piece_range, kind| {
217 if let Some(highlight) = highlight_format_specifier(kind) {
218 stack.add(HighlightedRange {
219 range: piece_range + range.start(),
220 highlight: highlight.into(),
221 binding_hash: None,
222 });
223 }
224 });
225 stack.pop();
226 }
227 // Highlight escape sequences
228 if let Some(char_ranges) = string.char_ranges() {
229 stack.push();
230 for (piece_range, _) in char_ranges.iter().filter(|(_, char)| char.is_ok()) {
231 if string.text()[piece_range.start().into()..].starts_with('\\') {
232 stack.add(HighlightedRange {
233 range: piece_range + range.start(),
234 highlight: HighlightTag::EscapeSequence.into(),
235 binding_hash: None,
236 });
237 }
238 }
239 stack.pop_and_inject(None);
240 }
241 } else if let Some(string) =
242 element_to_highlight.as_token().cloned().and_then(ast::RawString::cast)
243 {
244 if is_format_string {
245 stack.push();
246 string.lex_format_specifier(|piece_range, kind| {
247 if let Some(highlight) = highlight_format_specifier(kind) {
248 stack.add(HighlightedRange {
249 range: piece_range + range.start(),
250 highlight: highlight.into(),
251 binding_hash: None,
252 });
253 }
254 });
255 stack.pop();
256 }
257 }
258 }
259 }
260
261 stack.flattened()
262}
263
264#[derive(Debug)]
265struct HighlightedRangeStack {
266 stack: Vec<Vec<HighlightedRange>>,
267}
268
269/// We use a stack to implement the flattening logic for the highlighted
270/// syntax ranges.
271impl HighlightedRangeStack {
272 fn new() -> Self {
273 Self { stack: vec![Vec::new()] }
274 }
275
276 fn push(&mut self) {
277 self.stack.push(Vec::new());
278 }
279
280 /// Flattens the highlighted ranges.
281 ///
282 /// For example `#[cfg(feature = "foo")]` contains the nested ranges:
283 /// 1) parent-range: Attribute [0, 23)
284 /// 2) child-range: String [16, 21)
285 ///
286 /// The following code implements the flattening, for our example this results to:
287 /// `[Attribute [0, 16), String [16, 21), Attribute [21, 23)]`
288 fn pop(&mut self) {
289 let children = self.stack.pop().unwrap();
290 let prev = self.stack.last_mut().unwrap();
291 let needs_flattening = !children.is_empty()
292 && !prev.is_empty()
293 && prev.last().unwrap().range.contains_range(children.first().unwrap().range);
294 if !needs_flattening {
295 prev.extend(children);
296 } else {
297 let mut parent = prev.pop().unwrap();
298 for ele in children {
299 assert!(parent.range.contains_range(ele.range));
300
301 let cloned = Self::intersect(&mut parent, &ele);
302 if !parent.range.is_empty() {
303 prev.push(parent);
304 }
305 prev.push(ele);
306 parent = cloned;
307 }
308 if !parent.range.is_empty() {
309 prev.push(parent);
310 }
311 }
312 }
313
314 /// Intersects the `HighlightedRange` `parent` with `child`.
315 /// `parent` is mutated in place, becoming the range before `child`.
316 /// Returns the range (of the same type as `parent`) *after* `child`.
317 fn intersect(parent: &mut HighlightedRange, child: &HighlightedRange) -> HighlightedRange {
318 assert!(parent.range.contains_range(child.range));
319
320 let mut cloned = parent.clone();
321 parent.range = TextRange::new(parent.range.start(), child.range.start());
322 cloned.range = TextRange::new(child.range.end(), cloned.range.end());
323
324 cloned
325 }
326
327 /// Remove the `HighlightRange` of `parent` that's currently covered by `child`.
328 fn intersect_partial(parent: &mut HighlightedRange, child: &HighlightedRange) {
329 assert!(
330 parent.range.start() <= child.range.start()
331 && parent.range.end() >= child.range.start()
332 && child.range.end() > parent.range.end()
333 );
334
335 parent.range = TextRange::new(parent.range.start(), child.range.start());
336 }
337
338 /// Similar to `pop`, but can modify arbitrary prior ranges (where `pop`)
339 /// can only modify the last range currently on the stack.
340 /// Can be used to do injections that span multiple ranges, like the
341 /// doctest injection below.
342 /// If `overwrite_parent` is non-optional, the highlighting of the parent range
343 /// is overwritten with the argument.
344 ///
345 /// Note that `pop` can be simulated by `pop_and_inject(false)` but the
346 /// latter is computationally more expensive.
347 fn pop_and_inject(&mut self, overwrite_parent: Option<Highlight>) {
348 let mut children = self.stack.pop().unwrap();
349 let prev = self.stack.last_mut().unwrap();
350 children.sort_by_key(|range| range.range.start());
351 prev.sort_by_key(|range| range.range.start());
352
353 for child in children {
354 if let Some(idx) =
355 prev.iter().position(|parent| parent.range.contains_range(child.range))
356 {
357 if let Some(tag) = overwrite_parent {
358 prev[idx].highlight = tag;
359 }
360
361 let cloned = Self::intersect(&mut prev[idx], &child);
362 let insert_idx = if prev[idx].range.is_empty() {
363 prev.remove(idx);
364 idx
365 } else {
366 idx + 1
367 };
368 prev.insert(insert_idx, child);
369 if !cloned.range.is_empty() {
370 prev.insert(insert_idx + 1, cloned);
371 }
372 } else {
373 let maybe_idx =
374 prev.iter().position(|parent| parent.range.contains(child.range.start()));
375 match (overwrite_parent, maybe_idx) {
376 (Some(_), Some(idx)) => {
377 Self::intersect_partial(&mut prev[idx], &child);
378 let insert_idx = if prev[idx].range.is_empty() {
379 prev.remove(idx);
380 idx
381 } else {
382 idx + 1
383 };
384 prev.insert(insert_idx, child);
385 }
386 (_, None) => {
387 let idx = prev
388 .binary_search_by_key(&child.range.start(), |range| range.range.start())
389 .unwrap_or_else(|x| x);
390 prev.insert(idx, child);
391 }
392 _ => {
393 unreachable!("child range should be completely contained in parent range");
394 }
395 }
396 }
397 }
398 }
399
400 fn add(&mut self, range: HighlightedRange) {
401 self.stack
402 .last_mut()
403 .expect("during DFS traversal, the stack must not be empty")
404 .push(range)
405 }
406
407 fn flattened(mut self) -> Vec<HighlightedRange> {
408 assert_eq!(
409 self.stack.len(),
410 1,
411 "after DFS traversal, the stack should only contain a single element"
412 );
413 let mut res = self.stack.pop().unwrap();
414 res.sort_by_key(|range| range.range.start());
415 // Check that ranges are sorted and disjoint
416 assert!(res
417 .iter()
418 .zip(res.iter().skip(1))
419 .all(|(left, right)| left.range.end() <= right.range.start()));
420 res
421 }
422}
423
424fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HighlightTag> {
425 Some(match kind {
426 FormatSpecifier::Open
427 | FormatSpecifier::Close
428 | FormatSpecifier::Colon
429 | FormatSpecifier::Fill
430 | FormatSpecifier::Align
431 | FormatSpecifier::Sign
432 | FormatSpecifier::NumberSign
433 | FormatSpecifier::DollarSign
434 | FormatSpecifier::Dot
435 | FormatSpecifier::Asterisk
436 | FormatSpecifier::QuestionMark => HighlightTag::FormatSpecifier,
437 FormatSpecifier::Integer | FormatSpecifier::Zero => HighlightTag::NumericLiteral,
438 FormatSpecifier::Identifier => HighlightTag::Local,
439 })
440}
441
442fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
443 let path = macro_call.path()?;
444 let name_ref = path.segment()?.name_ref()?;
445
446 let range_start = name_ref.syntax().text_range().start();
447 let mut range_end = name_ref.syntax().text_range().end();
448 for sibling in path.syntax().siblings_with_tokens(Direction::Next) {
449 match sibling.kind() {
450 T![!] | IDENT => range_end = sibling.text_range().end(),
451 _ => (),
452 }
453 }
454
455 Some(TextRange::new(range_start, range_end))
456}
457
458fn is_possibly_unsafe(name_ref: &ast::NameRef) -> bool {
459 name_ref
460 .syntax()
461 .parent()
462 .and_then(|parent| {
463 ast::FieldExpr::cast(parent.clone())
464 .map(|_| true)
465 .or_else(|| ast::RecordPatField::cast(parent).map(|_| true))
466 })
467 .unwrap_or(false)
468}
469
470fn highlight_element(
471 sema: &Semantics<RootDatabase>,
472 bindings_shadow_count: &mut FxHashMap<Name, u32>,
473 syntactic_name_ref_highlighting: bool,
474 element: SyntaxElement,
475) -> Option<(Highlight, Option<u64>)> {
476 let db = sema.db;
477 let mut binding_hash = None;
478 let highlight: Highlight = match element.kind() {
479 FN => {
480 bindings_shadow_count.clear();
481 return None;
482 }
483
484 // Highlight definitions depending on the "type" of the definition.
485 NAME => {
486 let name = element.into_node().and_then(ast::Name::cast).unwrap();
487 let name_kind = classify_name(sema, &name);
488
489 if let Some(NameClass::Definition(Definition::Local(local))) = &name_kind {
490 if let Some(name) = local.name(db) {
491 let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
492 *shadow_count += 1;
493 binding_hash = Some(calc_binding_hash(&name, *shadow_count))
494 }
495 };
496
497 match name_kind {
498 Some(NameClass::ExternCrate(_)) => HighlightTag::Module.into(),
499 Some(NameClass::Definition(def)) => {
500 highlight_name(sema, db, def, None, false) | HighlightModifier::Definition
501 }
502 Some(NameClass::ConstReference(def)) => highlight_name(sema, db, def, None, false),
503 Some(NameClass::FieldShorthand { field, .. }) => {
504 let mut h = HighlightTag::Field.into();
505 if let Definition::Field(field) = field {
506 if let VariantDef::Union(_) = field.parent_def(db) {
507 h |= HighlightModifier::Unsafe;
508 }
509 }
510
511 h
512 }
513 None => highlight_name_by_syntax(name) | HighlightModifier::Definition,
514 }
515 }
516
517 // Highlight references like the definitions they resolve to
518 NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => {
519 Highlight::from(HighlightTag::Function) | HighlightModifier::Attribute
520 }
521 NAME_REF => {
522 let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
523 let possibly_unsafe = is_possibly_unsafe(&name_ref);
524 match classify_name_ref(sema, &name_ref) {
525 Some(name_kind) => match name_kind {
526 NameRefClass::ExternCrate(_) => HighlightTag::Module.into(),
527 NameRefClass::Definition(def) => {
528 if let Definition::Local(local) = &def {
529 if let Some(name) = local.name(db) {
530 let shadow_count =
531 bindings_shadow_count.entry(name.clone()).or_default();
532 binding_hash = Some(calc_binding_hash(&name, *shadow_count))
533 }
534 };
535 highlight_name(sema, db, def, Some(name_ref), possibly_unsafe)
536 }
537 NameRefClass::FieldShorthand { .. } => HighlightTag::Field.into(),
538 },
539 None if syntactic_name_ref_highlighting => {
540 highlight_name_ref_by_syntax(name_ref, sema)
541 }
542 None => HighlightTag::UnresolvedReference.into(),
543 }
544 }
545
546 // Simple token-based highlighting
547 COMMENT => {
548 let comment = element.into_token().and_then(ast::Comment::cast)?;
549 let h = HighlightTag::Comment;
550 match comment.kind().doc {
551 Some(_) => h | HighlightModifier::Documentation,
552 None => h.into(),
553 }
554 }
555 STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => HighlightTag::StringLiteral.into(),
556 ATTR => HighlightTag::Attribute.into(),
557 INT_NUMBER | FLOAT_NUMBER => HighlightTag::NumericLiteral.into(),
558 BYTE => HighlightTag::ByteLiteral.into(),
559 CHAR => HighlightTag::CharLiteral.into(),
560 QUESTION => Highlight::new(HighlightTag::Operator) | HighlightModifier::ControlFlow,
561 LIFETIME => {
562 let h = Highlight::new(HighlightTag::Lifetime);
563 match element.parent().map(|it| it.kind()) {
564 Some(LIFETIME_PARAM) | Some(LABEL) => h | HighlightModifier::Definition,
565 _ => h,
566 }
567 }
568 p if p.is_punct() => match p {
569 T![&] => {
570 let h = HighlightTag::Operator.into();
571 let is_unsafe = element
572 .parent()
573 .and_then(ast::RefExpr::cast)
574 .map(|ref_expr| sema.is_unsafe_ref_expr(&ref_expr))
575 .unwrap_or(false);
576 if is_unsafe {
577 h | HighlightModifier::Unsafe
578 } else {
579 h
580 }
581 }
582 T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] => HighlightTag::Operator.into(),
583 T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
584 HighlightTag::Macro.into()
585 }
586 T![*] if element.parent().and_then(ast::PtrType::cast).is_some() => {
587 HighlightTag::Keyword.into()
588 }
589 T![*] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
590 let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
591
592 let expr = prefix_expr.expr()?;
593 let ty = sema.type_of_expr(&expr)?;
594 if ty.is_raw_ptr() {
595 HighlightTag::Operator | HighlightModifier::Unsafe
596 } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
597 HighlightTag::Operator.into()
598 } else {
599 HighlightTag::Punctuation.into()
600 }
601 }
602 T![-] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
603 HighlightTag::NumericLiteral.into()
604 }
605 _ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
606 HighlightTag::Operator.into()
607 }
608 _ if element.parent().and_then(ast::BinExpr::cast).is_some() => {
609 HighlightTag::Operator.into()
610 }
611 _ if element.parent().and_then(ast::RangeExpr::cast).is_some() => {
612 HighlightTag::Operator.into()
613 }
614 _ if element.parent().and_then(ast::RangePat::cast).is_some() => {
615 HighlightTag::Operator.into()
616 }
617 _ if element.parent().and_then(ast::RestPat::cast).is_some() => {
618 HighlightTag::Operator.into()
619 }
620 _ if element.parent().and_then(ast::Attr::cast).is_some() => {
621 HighlightTag::Attribute.into()
622 }
623 _ => HighlightTag::Punctuation.into(),
624 },
625
626 k if k.is_keyword() => {
627 let h = Highlight::new(HighlightTag::Keyword);
628 match k {
629 T![break]
630 | T![continue]
631 | T![else]
632 | T![if]
633 | T![loop]
634 | T![match]
635 | T![return]
636 | T![while]
637 | T![in] => h | HighlightModifier::ControlFlow,
638 T![for] if !is_child_of_impl(&element) => h | HighlightModifier::ControlFlow,
639 T![unsafe] => h | HighlightModifier::Unsafe,
640 T![true] | T![false] => HighlightTag::BoolLiteral.into(),
641 T![self] => {
642 let self_param_is_mut = element
643 .parent()
644 .and_then(ast::SelfParam::cast)
645 .and_then(|p| p.mut_token())
646 .is_some();
647 // closure to enforce lazyness
648 let self_path = || {
649 sema.resolve_path(&element.parent()?.parent().and_then(ast::Path::cast)?)
650 };
651 if self_param_is_mut
652 || matches!(self_path(),
653 Some(hir::PathResolution::Local(local))
654 if local.is_self(db)
655 && (local.is_mut(db) || local.ty(db).is_mutable_reference())
656 )
657 {
658 HighlightTag::SelfKeyword | HighlightModifier::Mutable
659 } else {
660 HighlightTag::SelfKeyword.into()
661 }
662 }
663 T![ref] => element
664 .parent()
665 .and_then(ast::IdentPat::cast)
666 .and_then(|ident_pat| {
667 if sema.is_unsafe_ident_pat(&ident_pat) {
668 Some(HighlightModifier::Unsafe)
669 } else {
670 None
671 }
672 })
673 .map(|modifier| h | modifier)
674 .unwrap_or(h),
675 _ => h,
676 }
677 }
678
679 _ => return None,
680 };
681
682 return Some((highlight, binding_hash));
683
684 fn calc_binding_hash(name: &Name, shadow_count: u32) -> u64 {
685 fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
686 use std::{collections::hash_map::DefaultHasher, hash::Hasher};
687
688 let mut hasher = DefaultHasher::new();
689 x.hash(&mut hasher);
690 hasher.finish()
691 }
692
693 hash((name, shadow_count))
694 }
695}
696
697fn is_child_of_impl(element: &SyntaxElement) -> bool {
698 match element.parent() {
699 Some(e) => e.kind() == IMPL,
700 _ => false,
701 }
702}
703
704fn highlight_name(
705 sema: &Semantics<RootDatabase>,
706 db: &RootDatabase,
707 def: Definition,
708 name_ref: Option<ast::NameRef>,
709 possibly_unsafe: bool,
710) -> Highlight {
711 match def {
712 Definition::Macro(_) => HighlightTag::Macro,
713 Definition::Field(field) => {
714 let mut h = HighlightTag::Field.into();
715 if possibly_unsafe {
716 if let VariantDef::Union(_) = field.parent_def(db) {
717 h |= HighlightModifier::Unsafe;
718 }
719 }
720
721 return h;
722 }
723 Definition::ModuleDef(def) => match def {
724 hir::ModuleDef::Module(_) => HighlightTag::Module,
725 hir::ModuleDef::Function(func) => {
726 let mut h = HighlightTag::Function.into();
727 if func.is_unsafe(db) {
728 h |= HighlightModifier::Unsafe;
729 } else {
730 let is_unsafe = name_ref
731 .and_then(|name_ref| name_ref.syntax().parent())
732 .and_then(ast::MethodCallExpr::cast)
733 .map(|method_call_expr| sema.is_unsafe_method_call(method_call_expr))
734 .unwrap_or(false);
735 if is_unsafe {
736 h |= HighlightModifier::Unsafe;
737 }
738 }
739 return h;
740 }
741 hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HighlightTag::Struct,
742 hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HighlightTag::Enum,
743 hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Union,
744 hir::ModuleDef::EnumVariant(_) => HighlightTag::EnumVariant,
745 hir::ModuleDef::Const(_) => HighlightTag::Constant,
746 hir::ModuleDef::Trait(_) => HighlightTag::Trait,
747 hir::ModuleDef::TypeAlias(_) => HighlightTag::TypeAlias,
748 hir::ModuleDef::BuiltinType(_) => HighlightTag::BuiltinType,
749 hir::ModuleDef::Static(s) => {
750 let mut h = Highlight::new(HighlightTag::Static);
751 if s.is_mut(db) {
752 h |= HighlightModifier::Mutable;
753 h |= HighlightModifier::Unsafe;
754 }
755 return h;
756 }
757 },
758 Definition::SelfType(_) => HighlightTag::SelfType,
759 Definition::TypeParam(_) => HighlightTag::TypeParam,
760 Definition::Local(local) => {
761 let tag =
762 if local.is_param(db) { HighlightTag::ValueParam } else { HighlightTag::Local };
763 let mut h = Highlight::new(tag);
764 if local.is_mut(db) || local.ty(db).is_mutable_reference() {
765 h |= HighlightModifier::Mutable;
766 }
767 return h;
768 }
769 }
770 .into()
771}
772
773fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
774 let default = HighlightTag::UnresolvedReference;
775
776 let parent = match name.syntax().parent() {
777 Some(it) => it,
778 _ => return default.into(),
779 };
780
781 let tag = match parent.kind() {
782 STRUCT => HighlightTag::Struct,
783 ENUM => HighlightTag::Enum,
784 UNION => HighlightTag::Union,
785 TRAIT => HighlightTag::Trait,
786 TYPE_ALIAS => HighlightTag::TypeAlias,
787 TYPE_PARAM => HighlightTag::TypeParam,
788 RECORD_FIELD => HighlightTag::Field,
789 MODULE => HighlightTag::Module,
790 FN => HighlightTag::Function,
791 CONST => HighlightTag::Constant,
792 STATIC => HighlightTag::Static,
793 VARIANT => HighlightTag::EnumVariant,
794 IDENT_PAT => HighlightTag::Local,
795 _ => default,
796 };
797
798 tag.into()
799}
800
801fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabase>) -> Highlight {
802 let default = HighlightTag::UnresolvedReference;
803
804 let parent = match name.syntax().parent() {
805 Some(it) => it,
806 _ => return default.into(),
807 };
808
809 match parent.kind() {
810 METHOD_CALL_EXPR => {
811 let mut h = Highlight::new(HighlightTag::Function);
812 let is_unsafe = ast::MethodCallExpr::cast(parent)
813 .map(|method_call_expr| sema.is_unsafe_method_call(method_call_expr))
814 .unwrap_or(false);
815 if is_unsafe {
816 h |= HighlightModifier::Unsafe;
817 }
818
819 h
820 }
821 FIELD_EXPR => {
822 let h = HighlightTag::Field;
823 let is_union = ast::FieldExpr::cast(parent)
824 .and_then(|field_expr| {
825 let field = sema.resolve_field(&field_expr)?;
826 Some(if let VariantDef::Union(_) = field.parent_def(sema.db) {
827 true
828 } else {
829 false
830 })
831 })
832 .unwrap_or(false);
833 if is_union {
834 h | HighlightModifier::Unsafe
835 } else {
836 h.into()
837 }
838 }
839 PATH_SEGMENT => {
840 let path = match parent.parent().and_then(ast::Path::cast) {
841 Some(it) => it,
842 _ => return default.into(),
843 };
844 let expr = match path.syntax().parent().and_then(ast::PathExpr::cast) {
845 Some(it) => it,
846 _ => {
847 // within path, decide whether it is module or adt by checking for uppercase name
848 return if name.text().chars().next().unwrap_or_default().is_uppercase() {
849 HighlightTag::Struct
850 } else {
851 HighlightTag::Module
852 }
853 .into();
854 }
855 };
856 let parent = match expr.syntax().parent() {
857 Some(it) => it,
858 None => return default.into(),
859 };
860
861 match parent.kind() {
862 CALL_EXPR => HighlightTag::Function.into(),
863 _ => if name.text().chars().next().unwrap_or_default().is_uppercase() {
864 HighlightTag::Struct.into()
865 } else {
866 HighlightTag::Constant
867 }
868 .into(),
869 }
870 }
871 _ => default.into(),
872 }
873}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-19 11:15:01 +0100