crates/ide/src/syntax_highlighting.rs

   1 mod highlights;
   2 mod injector;
   3
   4 mod format;
   5 mod html;
   6 mod injection;
   7 mod macro_rules;
   8 pub(crate) mod tags;
   9 #[cfg(test)]
  10 mod tests;
  11
  12 use hir::{AsAssocItem, Local, Name, Semantics, VariantDef};
  13 use ide_db::{
  14     defs::{Definition, NameClass, NameRefClass},
  15     RootDatabase,
  16 };
  17 use rustc_hash::FxHashMap;
  18 use syntax::{
  19     ast::{self, HasFormatSpecifier},
  20     AstNode, AstToken, Direction, NodeOrToken, SyntaxElement,
  21     SyntaxKind::{self, *},
  22     SyntaxNode, SyntaxToken, TextRange, WalkEvent, T,
  23 };
  24
  25 use crate::{
  26     syntax_highlighting::{
  27         format::FormatStringHighlighter, macro_rules::MacroRulesHighlighter, tags::Highlight,
  28     },
  29     FileId, HlMod, HlTag, SymbolKind,
  30 };
  31
  32 pub(crate) use html::highlight_as_html;
  33
  34 #[derive(Debug, Clone)]
  35 pub struct HighlightedRange {
  36     pub range: TextRange,
  37     pub highlight: Highlight,
  38     pub binding_hash: Option<u64>,
  39 }
  40
  41 // Feature: Semantic Syntax Highlighting
  42 //
  43 // rust-analyzer highlights the code semantically.
  44 // For example, `bar` in `foo::Bar` might be colored differently depending on whether `Bar` is an enum or a trait.
  45 // rust-analyzer does not specify colors directly, instead it assigns tag (like `struct`) and a set of modifiers (like `declaration`) to each token.
  46 // It's up to the client to map those to specific colors.
  47 //
  48 // The general rule is that a reference to an entity gets colored the same way as the entity itself.
  49 // We also give special modifier for `mut` and `&mut` local variables.
  50 pub(crate) fn highlight(
  51     db: &RootDatabase,
  52     file_id: FileId,
  53     range_to_highlight: Option<TextRange>,
  54     syntactic_name_ref_highlighting: bool,
  55 ) -> Vec<HighlightedRange> {
  56     let _p = profile::span("highlight");
  57     let sema = Semantics::new(db);
  58
  59     // Determine the root based on the given range.
  60     let (root, range_to_highlight) = {
  61         let source_file = sema.parse(file_id);
  62         match range_to_highlight {
  63             Some(range) => {
  64                 let node = match source_file.syntax().covering_element(range) {
  65                     NodeOrToken::Node(it) => it,
  66                     NodeOrToken::Token(it) => it.parent(),
  67                 };
  68                 (node, range)
  69             }
  70             None => (source_file.syntax().clone(), source_file.syntax().text_range()),
  71         }
  72     };
  73
  74     let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
  75     let mut stack = highlights::Highlights::new(range_to_highlight);
  76
  77     let mut current_macro_call: Option<ast::MacroCall> = None;
  78     let mut current_macro_rules: Option<ast::MacroRules> = None;
  79     let mut format_string_highlighter = FormatStringHighlighter::default();
  80     let mut macro_rules_highlighter = MacroRulesHighlighter::default();
  81     let mut inside_attribute = false;
  82
  83     // Walk all nodes, keeping track of whether we are inside a macro or not.
  84     // If in macro, expand it first and highlight the expanded code.
  85     for event in root.preorder_with_tokens() {
  86         let event_range = match &event {
  87             WalkEvent::Enter(it) | WalkEvent::Leave(it) => it.text_range(),
  88         };
  89
  90         // Element outside of the viewport, no need to highlight
  91         if range_to_highlight.intersect(event_range).is_none() {
  92             continue;
  93         }
  94
  95         // Track "inside macro" state
  96         match event.clone().map(|it| it.into_node().and_then(ast::MacroCall::cast)) {
  97             WalkEvent::Enter(Some(mc)) => {
  98                 if let Some(range) = macro_call_range(&mc) {
  99                     stack.add(HighlightedRange {
 100                         range,
 101                         highlight: HlTag::Symbol(SymbolKind::Macro).into(),
 102                         binding_hash: None,
 103                     });
 104                 }
 105                 current_macro_call = Some(mc.clone());
 106                 continue;
 107             }
 108             WalkEvent::Leave(Some(mc)) => {
 109                 assert_eq!(current_macro_call, Some(mc));
 110                 current_macro_call = None;
 111                 format_string_highlighter = FormatStringHighlighter::default();
 112             }
 113             _ => (),
 114         }
 115
 116         match event.clone().map(|it| it.into_node().and_then(ast::MacroRules::cast)) {
 117             WalkEvent::Enter(Some(mac)) => {
 118                 macro_rules_highlighter.init();
 119                 current_macro_rules = Some(mac);
 120                 continue;
 121             }
 122             WalkEvent::Leave(Some(mac)) => {
 123                 assert_eq!(current_macro_rules, Some(mac));
 124                 current_macro_rules = None;
 125                 macro_rules_highlighter = MacroRulesHighlighter::default();
 126             }
 127             _ => (),
 128         }
 129
 130         match &event {
 131             // Check for Rust code in documentation
 132             WalkEvent::Leave(NodeOrToken::Node(node)) => {
 133                 if ast::Attr::can_cast(node.kind()) {
 134                     inside_attribute = false
 135                 }
 136                 if let Some((new_comments, inj)) = injection::extract_doc_comments(node) {
 137                     injection::highlight_doc_comment(new_comments, inj, &mut stack);
 138                 }
 139             }
 140             WalkEvent::Enter(NodeOrToken::Node(node)) if ast::Attr::can_cast(node.kind()) => {
 141                 inside_attribute = true
 142             }
 143             _ => (),
 144         }
 145
 146         let element = match event {
 147             WalkEvent::Enter(it) => it,
 148             WalkEvent::Leave(_) => continue,
 149         };
 150
 151         let range = element.text_range();
 152
 153         if current_macro_rules.is_some() {
 154             if let Some(tok) = element.as_token() {
 155                 macro_rules_highlighter.advance(tok);
 156             }
 157         }
 158
 159         let element_to_highlight = if current_macro_call.is_some() && element.kind() != COMMENT {
 160             // Inside a macro -- expand it first
 161             let token = match element.clone().into_token() {
 162                 Some(it) if it.parent().kind() == TOKEN_TREE => it,
 163                 _ => continue,
 164             };
 165             let token = sema.descend_into_macros(token.clone());
 166             let parent = token.parent();
 167
 168             format_string_highlighter.check_for_format_string(&parent);
 169
 170             // We only care Name and Name_ref
 171             match (token.kind(), parent.kind()) {
 172                 (IDENT, NAME) | (IDENT, NAME_REF) => parent.into(),
 173                 _ => token.into(),
 174             }
 175         } else {
 176             element.clone()
 177         };
 178
 179         if let Some(token) = element.as_token().cloned().and_then(ast::String::cast) {
 180             if token.is_raw() {
 181                 let expanded = element_to_highlight.as_token().unwrap().clone();
 182                 if injection::highlight_injection(&mut stack, &sema, token, expanded).is_some() {
 183                     continue;
 184                 }
 185             }
 186         }
 187
 188         if let Some((mut highlight, binding_hash)) = highlight_element(
 189             &sema,
 190             &mut bindings_shadow_count,
 191             syntactic_name_ref_highlighting,
 192             element_to_highlight.clone(),
 193         ) {
 194             if inside_attribute {
 195                 highlight = highlight | HlMod::Attribute;
 196             }
 197
 198             if macro_rules_highlighter.highlight(element_to_highlight.clone()).is_none() {
 199                 stack.add(HighlightedRange { range, highlight, binding_hash });
 200             }
 201
 202             if let Some(string) =
 203                 element_to_highlight.as_token().cloned().and_then(ast::String::cast)
 204             {
 205                 format_string_highlighter.highlight_format_string(&mut stack, &string, range);
 206                 // Highlight escape sequences
 207                 if let Some(char_ranges) = string.char_ranges() {
 208                     for (piece_range, _) in char_ranges.iter().filter(|(_, char)| char.is_ok()) {
 209                         if string.text()[piece_range.start().into()..].starts_with('\\') {
 210                             stack.add(HighlightedRange {
 211                                 range: piece_range + range.start(),
 212                                 highlight: HlTag::EscapeSequence.into(),
 213                                 binding_hash: None,
 214                             });
 215                         }
 216                     }
 217                 }
 218             }
 219         }
 220     }
 221
 222     stack.to_vec()
 223 }
 224
 225 fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
 226     let path = macro_call.path()?;
 227     let name_ref = path.segment()?.name_ref()?;
 228
 229     let range_start = name_ref.syntax().text_range().start();
 230     let mut range_end = name_ref.syntax().text_range().end();
 231     for sibling in path.syntax().siblings_with_tokens(Direction::Next) {
 232         match sibling.kind() {
 233             T![!] | IDENT => range_end = sibling.text_range().end(),
 234             _ => (),
 235         }
 236     }
 237
 238     Some(TextRange::new(range_start, range_end))
 239 }
 240
 241 /// Returns true if the parent nodes of `node` all match the `SyntaxKind`s in `kinds` exactly.
 242 fn parents_match(mut node: NodeOrToken<SyntaxNode, SyntaxToken>, mut kinds: &[SyntaxKind]) -> bool {
 243     while let (Some(parent), [kind, rest @ ..]) = (&node.parent(), kinds) {
 244         if parent.kind() != *kind {
 245             return false;
 246         }
 247
 248         // FIXME: Would be nice to get parent out of the match, but binding by-move and by-value
 249         // in the same pattern is unstable: rust-lang/rust#68354.
 250         node = node.parent().unwrap().into();
 251         kinds = rest;
 252     }
 253
 254     // Only true if we matched all expected kinds
 255     kinds.len() == 0
 256 }
 257
 258 fn is_consumed_lvalue(
 259     node: NodeOrToken<SyntaxNode, SyntaxToken>,
 260     local: &Local,
 261     db: &RootDatabase,
 262 ) -> bool {
 263     // When lvalues are passed as arguments and they're not Copy, then mark them as Consuming.
 264     parents_match(node, &[PATH_SEGMENT, PATH, PATH_EXPR, ARG_LIST]) && !local.ty(db).is_copy(db)
 265 }
 266
 267 fn highlight_element(
 268     sema: &Semantics<RootDatabase>,
 269     bindings_shadow_count: &mut FxHashMap<Name, u32>,
 270     syntactic_name_ref_highlighting: bool,
 271     element: SyntaxElement,
 272 ) -> Option<(Highlight, Option<u64>)> {
 273     let db = sema.db;
 274     let mut binding_hash = None;
 275     let highlight: Highlight = match element.kind() {
 276         FN => {
 277             bindings_shadow_count.clear();
 278             return None;
 279         }
 280
 281         // Highlight definitions depending on the "type" of the definition.
 282         NAME => {
 283             let name = element.into_node().and_then(ast::Name::cast).unwrap();
 284             let name_kind = NameClass::classify(sema, &name);
 285
 286             if let Some(NameClass::Definition(Definition::Local(local))) = &name_kind {
 287                 if let Some(name) = local.name(db) {
 288                     let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
 289                     *shadow_count += 1;
 290                     binding_hash = Some(calc_binding_hash(&name, *shadow_count))
 291                 }
 292             };
 293
 294             match name_kind {
 295                 Some(NameClass::ExternCrate(_)) => HlTag::Symbol(SymbolKind::Module).into(),
 296                 Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
 297                 Some(NameClass::ConstReference(def)) => highlight_def(db, def),
 298                 Some(NameClass::PatFieldShorthand { field_ref, .. }) => {
 299                     let mut h = HlTag::Symbol(SymbolKind::Field).into();
 300                     if let Definition::Field(field) = field_ref {
 301                         if let VariantDef::Union(_) = field.parent_def(db) {
 302                             h |= HlMod::Unsafe;
 303                         }
 304                     }
 305
 306                     h
 307                 }
 308                 None => highlight_name_by_syntax(name) | HlMod::Definition,
 309             }
 310         }
 311
 312         // Highlight references like the definitions they resolve to
 313         NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => {
 314             // even though we track whether we are in an attribute or not we still need this special case
 315             // as otherwise we would emit unresolved references for name refs inside attributes
 316             Highlight::from(HlTag::Symbol(SymbolKind::Function))
 317         }
 318         NAME_REF => {
 319             let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
 320             highlight_func_by_name_ref(sema, &name_ref).unwrap_or_else(|| {
 321                 match NameRefClass::classify(sema, &name_ref) {
 322                     Some(name_kind) => match name_kind {
 323                         NameRefClass::ExternCrate(_) => HlTag::Symbol(SymbolKind::Module).into(),
 324                         NameRefClass::Definition(def) => {
 325                             if let Definition::Local(local) = &def {
 326                                 if let Some(name) = local.name(db) {
 327                                     let shadow_count =
 328                                         bindings_shadow_count.entry(name.clone()).or_default();
 329                                     binding_hash = Some(calc_binding_hash(&name, *shadow_count))
 330                                 }
 331                             };
 332
 333                             let mut h = highlight_def(db, def);
 334
 335                             if let Definition::Local(local) = &def {
 336                                 if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
 337                                     h |= HlMod::Consuming;
 338                                 }
 339                             }
 340
 341                             if let Some(parent) = name_ref.syntax().parent() {
 342                                 if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
 343                                     if let Definition::Field(field) = def {
 344                                         if let VariantDef::Union(_) = field.parent_def(db) {
 345                                             h |= HlMod::Unsafe;
 346                                         }
 347                                     }
 348                                 }
 349                             }
 350
 351                             h
 352                         }
 353                         NameRefClass::FieldShorthand { .. } => {
 354                             HlTag::Symbol(SymbolKind::Field).into()
 355                         }
 356                     },
 357                     None if syntactic_name_ref_highlighting => {
 358                         highlight_name_ref_by_syntax(name_ref, sema)
 359                     }
 360                     None => HlTag::UnresolvedReference.into(),
 361                 }
 362             })
 363         }
 364
 365         // Simple token-based highlighting
 366         COMMENT => {
 367             let comment = element.into_token().and_then(ast::Comment::cast)?;
 368             let h = HlTag::Comment;
 369             match comment.kind().doc {
 370                 Some(_) => h | HlMod::Documentation,
 371                 None => h.into(),
 372             }
 373         }
 374         STRING | BYTE_STRING => HlTag::StringLiteral.into(),
 375         ATTR => HlTag::Attribute.into(),
 376         INT_NUMBER | FLOAT_NUMBER => HlTag::NumericLiteral.into(),
 377         BYTE => HlTag::ByteLiteral.into(),
 378         CHAR => HlTag::CharLiteral.into(),
 379         QUESTION => Highlight::new(HlTag::Operator) | HlMod::ControlFlow,
 380         LIFETIME => {
 381             let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
 382
 383             match NameClass::classify_lifetime(sema, &lifetime) {
 384                 Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
 385                 None => match NameRefClass::classify_lifetime(sema, &lifetime) {
 386                     Some(NameRefClass::Definition(def)) => highlight_def(db, def),
 387                     _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)),
 388                 },
 389                 _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)) | HlMod::Definition,
 390             }
 391         }
 392         p if p.is_punct() => match p {
 393             T![&] => {
 394                 let h = HlTag::Operator.into();
 395                 let is_unsafe = element
 396                     .parent()
 397                     .and_then(ast::RefExpr::cast)
 398                     .map(|ref_expr| sema.is_unsafe_ref_expr(&ref_expr))
 399                     .unwrap_or(false);
 400                 if is_unsafe {
 401                     h | HlMod::Unsafe
 402                 } else {
 403                     h
 404                 }
 405             }
 406             T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => HlTag::Operator.into(),
 407             T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
 408                 HlTag::Symbol(SymbolKind::Macro).into()
 409             }
 410             T![!] if element.parent().and_then(ast::NeverType::cast).is_some() => {
 411                 HlTag::BuiltinType.into()
 412             }
 413             T![*] if element.parent().and_then(ast::PtrType::cast).is_some() => {
 414                 HlTag::Keyword.into()
 415             }
 416             T![*] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
 417                 let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
 418
 419                 let expr = prefix_expr.expr()?;
 420                 let ty = sema.type_of_expr(&expr)?;
 421                 if ty.is_raw_ptr() {
 422                     HlTag::Operator | HlMod::Unsafe
 423                 } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
 424                     HlTag::Operator.into()
 425                 } else {
 426                     HlTag::Punctuation.into()
 427                 }
 428             }
 429             T![-] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
 430                 let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
 431
 432                 let expr = prefix_expr.expr()?;
 433                 match expr {
 434                     ast::Expr::Literal(_) => HlTag::NumericLiteral,
 435                     _ => HlTag::Operator,
 436                 }
 437                 .into()
 438             }
 439             _ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
 440                 HlTag::Operator.into()
 441             }
 442             _ if element.parent().and_then(ast::BinExpr::cast).is_some() => HlTag::Operator.into(),
 443             _ if element.parent().and_then(ast::RangeExpr::cast).is_some() => {
 444                 HlTag::Operator.into()
 445             }
 446             _ if element.parent().and_then(ast::RangePat::cast).is_some() => HlTag::Operator.into(),
 447             _ if element.parent().and_then(ast::RestPat::cast).is_some() => HlTag::Operator.into(),
 448             _ if element.parent().and_then(ast::Attr::cast).is_some() => HlTag::Attribute.into(),
 449             _ => HlTag::Punctuation.into(),
 450         },
 451
 452         k if k.is_keyword() => {
 453             let h = Highlight::new(HlTag::Keyword);
 454             match k {
 455                 T![break]
 456                 | T![continue]
 457                 | T![else]
 458                 | T![if]
 459                 | T![loop]
 460                 | T![match]
 461                 | T![return]
 462                 | T![while]
 463                 | T![in] => h | HlMod::ControlFlow,
 464                 T![for] if !is_child_of_impl(&element) => h | HlMod::ControlFlow,
 465                 T![unsafe] => h | HlMod::Unsafe,
 466                 T![true] | T![false] => HlTag::BoolLiteral.into(),
 467                 T![self] => {
 468                     let self_param_is_mut = element
 469                         .parent()
 470                         .and_then(ast::SelfParam::cast)
 471                         .and_then(|p| p.mut_token())
 472                         .is_some();
 473                     let self_path = &element
 474                         .parent()
 475                         .as_ref()
 476                         .and_then(SyntaxNode::parent)
 477                         .and_then(ast::Path::cast)
 478                         .and_then(|p| sema.resolve_path(&p));
 479                     let mut h = HlTag::Symbol(SymbolKind::SelfParam).into();
 480                     if self_param_is_mut
 481                         || matches!(self_path,
 482                             Some(hir::PathResolution::Local(local))
 483                                 if local.is_self(db)
 484                                     && (local.is_mut(db) || local.ty(db).is_mutable_reference())
 485                         )
 486                     {
 487                         h |= HlMod::Mutable
 488                     }
 489
 490                     if let Some(hir::PathResolution::Local(local)) = self_path {
 491                         if is_consumed_lvalue(element, &local, db) {
 492                             h |= HlMod::Consuming;
 493                         }
 494                     }
 495
 496                     h
 497                 }
 498                 T![ref] => element
 499                     .parent()
 500                     .and_then(ast::IdentPat::cast)
 501                     .and_then(|ident_pat| {
 502                         if sema.is_unsafe_ident_pat(&ident_pat) {
 503                             Some(HlMod::Unsafe)
 504                         } else {
 505                             None
 506                         }
 507                     })
 508                     .map(|modifier| h | modifier)
 509                     .unwrap_or(h),
 510                 _ => h,
 511             }
 512         }
 513
 514         _ => return None,
 515     };
 516
 517     return Some((highlight, binding_hash));
 518
 519     fn calc_binding_hash(name: &Name, shadow_count: u32) -> u64 {
 520         fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
 521             use std::{collections::hash_map::DefaultHasher, hash::Hasher};
 522
 523             let mut hasher = DefaultHasher::new();
 524             x.hash(&mut hasher);
 525             hasher.finish()
 526         }
 527
 528         hash((name, shadow_count))
 529     }
 530 }
 531
 532 fn is_child_of_impl(element: &SyntaxElement) -> bool {
 533     match element.parent() {
 534         Some(e) => e.kind() == IMPL,
 535         _ => false,
 536     }
 537 }
 538
 539 fn highlight_func_by_name_ref(
 540     sema: &Semantics<RootDatabase>,
 541     name_ref: &ast::NameRef,
 542 ) -> Option<Highlight> {
 543     let method_call = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast)?;
 544     highlight_method_call(sema, &method_call)
 545 }
 546
 547 fn highlight_method_call(
 548     sema: &Semantics<RootDatabase>,
 549     method_call: &ast::MethodCallExpr,
 550 ) -> Option<Highlight> {
 551     let func = sema.resolve_method_call(&method_call)?;
 552     let mut h = HlTag::Symbol(SymbolKind::Function).into();
 553     h |= HlMod::Associated;
 554     if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(&method_call) {
 555         h |= HlMod::Unsafe;
 556     }
 557     if let Some(self_param) = func.self_param(sema.db) {
 558         match self_param.access(sema.db) {
 559             hir::Access::Shared => (),
 560             hir::Access::Exclusive => h |= HlMod::Mutable,
 561             hir::Access::Owned => {
 562                 if let Some(receiver_ty) =
 563                     method_call.receiver().and_then(|it| sema.type_of_expr(&it))
 564                 {
 565                     if !receiver_ty.is_copy(sema.db) {
 566                         h |= HlMod::Consuming
 567                     }
 568                 }
 569             }
 570         }
 571     }
 572     Some(h)
 573 }
 574
 575 fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
 576     match def {
 577         Definition::Macro(_) => HlTag::Symbol(SymbolKind::Macro),
 578         Definition::Field(_) => HlTag::Symbol(SymbolKind::Field),
 579         Definition::ModuleDef(def) => match def {
 580             hir::ModuleDef::Module(_) => HlTag::Symbol(SymbolKind::Module),
 581             hir::ModuleDef::Function(func) => {
 582                 let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Function));
 583                 if func.as_assoc_item(db).is_some() {
 584                     h |= HlMod::Associated;
 585                     if func.self_param(db).is_none() {
 586                         h |= HlMod::Static
 587                     }
 588                 }
 589                 if func.is_unsafe(db) {
 590                     h |= HlMod::Unsafe;
 591                 }
 592                 return h;
 593             }
 594             hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HlTag::Symbol(SymbolKind::Struct),
 595             hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HlTag::Symbol(SymbolKind::Enum),
 596             hir::ModuleDef::Adt(hir::Adt::Union(_)) => HlTag::Symbol(SymbolKind::Union),
 597             hir::ModuleDef::Variant(_) => HlTag::Symbol(SymbolKind::Variant),
 598             hir::ModuleDef::Const(konst) => {
 599                 let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Const));
 600                 if konst.as_assoc_item(db).is_some() {
 601                     h |= HlMod::Associated
 602                 }
 603                 return h;
 604             }
 605             hir::ModuleDef::Trait(_) => HlTag::Symbol(SymbolKind::Trait),
 606             hir::ModuleDef::TypeAlias(type_) => {
 607                 let mut h = Highlight::new(HlTag::Symbol(SymbolKind::TypeAlias));
 608                 if type_.as_assoc_item(db).is_some() {
 609                     h |= HlMod::Associated
 610                 }
 611                 return h;
 612             }
 613             hir::ModuleDef::BuiltinType(_) => HlTag::BuiltinType,
 614             hir::ModuleDef::Static(s) => {
 615                 let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Static));
 616                 if s.is_mut(db) {
 617                     h |= HlMod::Mutable;
 618                     h |= HlMod::Unsafe;
 619                 }
 620                 return h;
 621             }
 622         },
 623         Definition::SelfType(_) => HlTag::Symbol(SymbolKind::Impl),
 624         Definition::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),
 625         Definition::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),
 626         Definition::Local(local) => {
 627             let tag = if local.is_param(db) {
 628                 HlTag::Symbol(SymbolKind::ValueParam)
 629             } else {
 630                 HlTag::Symbol(SymbolKind::Local)
 631             };
 632             let mut h = Highlight::new(tag);
 633             if local.is_mut(db) || local.ty(db).is_mutable_reference() {
 634                 h |= HlMod::Mutable;
 635             }
 636             if local.ty(db).as_callable(db).is_some() || local.ty(db).impls_fnonce(db) {
 637                 h |= HlMod::Callable;
 638             }
 639             return h;
 640         }
 641         Definition::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
 642         Definition::Label(_) => HlTag::Symbol(SymbolKind::Label),
 643     }
 644     .into()
 645 }
 646
 647 fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
 648     let default = HlTag::UnresolvedReference;
 649
 650     let parent = match name.syntax().parent() {
 651         Some(it) => it,
 652         _ => return default.into(),
 653     };
 654
 655     let tag = match parent.kind() {
 656         STRUCT => HlTag::Symbol(SymbolKind::Struct),
 657         ENUM => HlTag::Symbol(SymbolKind::Enum),
 658         VARIANT => HlTag::Symbol(SymbolKind::Variant),
 659         UNION => HlTag::Symbol(SymbolKind::Union),
 660         TRAIT => HlTag::Symbol(SymbolKind::Trait),
 661         TYPE_ALIAS => HlTag::Symbol(SymbolKind::TypeAlias),
 662         TYPE_PARAM => HlTag::Symbol(SymbolKind::TypeParam),
 663         RECORD_FIELD => HlTag::Symbol(SymbolKind::Field),
 664         MODULE => HlTag::Symbol(SymbolKind::Module),
 665         FN => HlTag::Symbol(SymbolKind::Function),
 666         CONST => HlTag::Symbol(SymbolKind::Const),
 667         STATIC => HlTag::Symbol(SymbolKind::Static),
 668         IDENT_PAT => HlTag::Symbol(SymbolKind::Local),
 669         _ => default,
 670     };
 671
 672     tag.into()
 673 }
 674
 675 fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabase>) -> Highlight {
 676     let default = HlTag::UnresolvedReference;
 677
 678     let parent = match name.syntax().parent() {
 679         Some(it) => it,
 680         _ => return default.into(),
 681     };
 682
 683     match parent.kind() {
 684         METHOD_CALL_EXPR => {
 685             return ast::MethodCallExpr::cast(parent)
 686                 .and_then(|method_call| highlight_method_call(sema, &method_call))
 687                 .unwrap_or_else(|| HlTag::Symbol(SymbolKind::Function).into());
 688         }
 689         FIELD_EXPR => {
 690             let h = HlTag::Symbol(SymbolKind::Field);
 691             let is_union = ast::FieldExpr::cast(parent)
 692                 .and_then(|field_expr| {
 693                     let field = sema.resolve_field(&field_expr)?;
 694                     Some(if let VariantDef::Union(_) = field.parent_def(sema.db) {
 695                         true
 696                     } else {
 697                         false
 698                     })
 699                 })
 700                 .unwrap_or(false);
 701             if is_union {
 702                 h | HlMod::Unsafe
 703             } else {
 704                 h.into()
 705             }
 706         }
 707         PATH_SEGMENT => {
 708             let path = match parent.parent().and_then(ast::Path::cast) {
 709                 Some(it) => it,
 710                 _ => return default.into(),
 711             };
 712             let expr = match path.syntax().parent().and_then(ast::PathExpr::cast) {
 713                 Some(it) => it,
 714                 _ => {
 715                     // within path, decide whether it is module or adt by checking for uppercase name
 716                     return if name.text().chars().next().unwrap_or_default().is_uppercase() {
 717                         HlTag::Symbol(SymbolKind::Struct)
 718                     } else {
 719                         HlTag::Symbol(SymbolKind::Module)
 720                     }
 721                     .into();
 722                 }
 723             };
 724             let parent = match expr.syntax().parent() {
 725                 Some(it) => it,
 726                 None => return default.into(),
 727             };
 728
 729             match parent.kind() {
 730                 CALL_EXPR => HlTag::Symbol(SymbolKind::Function).into(),
 731                 _ => if name.text().chars().next().unwrap_or_default().is_uppercase() {
 732                     HlTag::Symbol(SymbolKind::Struct)
 733                 } else {
 734                     HlTag::Symbol(SymbolKind::Const)
 735                 }
 736                 .into(),
 737             }
 738         }
 739         _ => default.into(),
 740     }
 741 }