Code blocks with tilde also works like code block

[rust.git] / crates / ide / src / syntax_highlighting / highlight.rs

diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index 8ad27b1fdcd04b8827e97329b8bfed46cbb8d264..7ac6775685319907089f46bd9dc924e11fdc0e34 100644 (file)
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -2,8 +2,8 @@
 
 use hir::{AsAssocItem, HasVisibility, Semantics};
 use ide_db::{
-    defs::{Definition, NameClass, NameRefClass},
-    helpers::FamousDefs,
+    defs::{Definition, IdentClass, NameClass, NameRefClass},
+    famous_defs::FamousDefs,
     RootDatabase, SymbolKind,
 };
 use rustc_hash::FxHashMap;
@@ -47,52 +47,36 @@ pub(super) fn token(sema: &Semantics<RootDatabase>, token: SyntaxToken) -> Optio
     Some(highlight)
 }
 
-pub(super) fn node(
+pub(super) fn name_like(
     sema: &Semantics<RootDatabase>,
     krate: Option<hir::Crate>,
     bindings_shadow_count: &mut FxHashMap<hir::Name, u32>,
     syntactic_name_ref_highlighting: bool,
-    node: SyntaxNode,
+    name_like: ast::NameLike,
 ) -> Option<(Highlight, Option<u64>)> {
     let mut binding_hash = None;
-    let highlight = match_ast! {
-        match node {
-            ast::NameRef(name_ref) => {
-                highlight_name_ref(
-                    sema,
-                    krate,
-                    bindings_shadow_count,
-                    &mut binding_hash,
-                    syntactic_name_ref_highlighting,
-                    name_ref,
-                )
-            },
-            ast::Name(name) => {
-                highlight_name(sema, bindings_shadow_count, &mut binding_hash, krate, name)
-            },
-            ast::Lifetime(lifetime) => {
-                match NameClass::classify_lifetime(sema, &lifetime) {
-                    Some(NameClass::Definition(def)) => {
-                        highlight_def(sema, krate, def) | HlMod::Definition
-                    }
-                    None => match NameRefClass::classify_lifetime(sema, &lifetime) {
-                        Some(NameRefClass::Definition(def)) => highlight_def(sema, krate, def),
-                        _ => SymbolKind::LifetimeParam.into(),
-                    },
-                    _ => Highlight::from(SymbolKind::LifetimeParam) | HlMod::Definition,
-                }
-            },
-            ast::Fn(_) => {
-                bindings_shadow_count.clear();
-                return None;
-            },
-            _ => {
-                if [FN, CONST, STATIC].contains(&node.kind()) {
-                    bindings_shadow_count.clear();
-                }
-                return None
-            },
+    let highlight = match name_like {
+        ast::NameLike::NameRef(name_ref) => highlight_name_ref(
+            sema,
+            krate,
+            bindings_shadow_count,
+            &mut binding_hash,
+            syntactic_name_ref_highlighting,
+            name_ref,
+        ),
+        ast::NameLike::Name(name) => {
+            highlight_name(sema, bindings_shadow_count, &mut binding_hash, krate, name)
         }
+        ast::NameLike::Lifetime(lifetime) => match IdentClass::classify_lifetime(sema, &lifetime) {
+            Some(IdentClass::NameClass(NameClass::Definition(def))) => {
+                highlight_def(sema, krate, def) | HlMod::Definition
+            }
+            Some(IdentClass::NameRefClass(NameRefClass::Definition(def))) => {
+                highlight_def(sema, krate, def)
+            }
+            // FIXME: Fallback for 'static and '_, as we do not resolve these yet
+            _ => SymbolKind::LifetimeParam.into(),
+        },
     };
     Some((highlight, binding_hash))
 }
@@ -139,12 +123,12 @@ fn punctuation(sema: &Semantics<RootDatabase>, token: SyntaxToken, kind: SyntaxK
             }
             .into()
         }
-        (T![+] | T![-] | T![*] | T![/], BIN_EXPR) => HlOperator::Arithmetic.into(),
-        (T![+=] | T![-=] | T![*=] | T![/=], BIN_EXPR) => {
+        (T![+] | T![-] | T![*] | T![/] | T![%], BIN_EXPR) => HlOperator::Arithmetic.into(),
+        (T![+=] | T![-=] | T![*=] | T![/=] | T![%=], BIN_EXPR) => {
             Highlight::from(HlOperator::Arithmetic) | HlMod::Mutable
         }
-        (T![|] | T![&] | T![!] | T![^], BIN_EXPR) => HlOperator::Bitwise.into(),
-        (T![|=] | T![&=] | T![^=], BIN_EXPR) => {
+        (T![|] | T![&] | T![!] | T![^] | T![>>] | T![<<], BIN_EXPR) => HlOperator::Bitwise.into(),
+        (T![|=] | T![&=] | T![^=] | T![>>=] | T![<<=], BIN_EXPR) => {
             Highlight::from(HlOperator::Bitwise) | HlMod::Mutable
         }
         (T![&&] | T![||], BIN_EXPR) => HlOperator::Logical.into(),
@@ -192,9 +176,11 @@ fn keyword(
         T![true] | T![false] => HlTag::BoolLiteral.into(),
         // crate is handled just as a token if it's in an `extern crate`
         T![crate] if parent_matches::<ast::ExternCrate>(&token) => h,
-        // self, crate and super are handled as either a Name or NameRef already, unless they
+        // self, crate, super and `Self` are handled as either a Name or NameRef already, unless they
         // are inside unmapped token trees
-        T![self] | T![crate] | T![super] if parent_matches::<ast::NameRef>(&token) => return None,
+        T![self] | T![crate] | T![super] | T![Self] if parent_matches::<ast::NameRef>(&token) => {
+            return None
+        }
         T![self] if parent_matches::<ast::Name>(&token) => return None,
         T![ref] => match token.parent().and_then(ast::IdentPat::cast) {
             Some(ident) if sema.is_unsafe_ident_pat(&ident) => h | HlMod::Unsafe,
@@ -262,6 +248,16 @@ fn highlight_name_ref(
                         }
                     }
                 }
+                Definition::Macro(_) => {
+                    if let Some(macro_call) =
+                        ide_db::syntax_helpers::node_ext::full_path_of_name_ref(&name_ref)
+                            .and_then(|it| it.syntax().parent().and_then(ast::MacroCall::cast))
+                    {
+                        if sema.is_unsafe_macro_call(&macro_call) {
+                            h |= HlMod::Unsafe;
+                        }
+                    }
+                }
                 _ => (),
             }
 
@@ -269,12 +265,13 @@ fn highlight_name_ref(
         }
         NameRefClass::FieldShorthand { .. } => SymbolKind::Field.into(),
     };
-    if name_ref.self_token().is_some() {
-        h.tag = HlTag::Symbol(SymbolKind::SelfParam);
-    }
-    if name_ref.crate_token().is_some() || name_ref.super_token().is_some() {
-        h.tag = HlTag::Keyword;
-    }
+
+    h.tag = match name_ref.token_kind() {
+        T![Self] => HlTag::Symbol(SymbolKind::SelfType),
+        T![self] => HlTag::Symbol(SymbolKind::SelfParam),
+        T![super] | T![crate] => HlTag::Keyword,
+        _ => h.tag,
+    };
     h
 }
 
@@ -333,7 +330,7 @@ fn highlight_def(
 ) -> Highlight {
     let db = sema.db;
     let mut h = match def {
-        Definition::Macro(m) => Highlight::new(HlTag::Symbol(m.kind().into())),
+        Definition::Macro(m) => Highlight::new(HlTag::Symbol(m.kind(sema.db).into())),
         Definition::Field(_) => Highlight::new(HlTag::Symbol(SymbolKind::Field)),
         Definition::Module(module) => {
             let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Module));