11 files changed, 465 insertions, 158 deletions

diff --git a/crates/ra_ide/Cargo.toml b/crates/ra_ide/Cargo.toml
index 2c9f9dce0..53817d1f7 100644
--- a/crates/ra_ide/Cargo.toml
+++ b/crates/ra_ide/Cargo.toml
@@ -39,7 +39,7 @@ ra_assists = { path = "../ra_assists" }
 hir = { path = "../ra_hir", package = "ra_hir" }
 
 [dev-dependencies]
-insta = "0.12.0"
+insta = "0.13.0"
 
 [dev-dependencies.proptest]
 version = "0.9.0"
diff --git a/crates/ra_ide/src/assists.rs b/crates/ra_ide/src/assists.rs
index a936900da..c43c45c65 100644
--- a/crates/ra_ide/src/assists.rs
+++ b/crates/ra_ide/src/assists.rs
@@ -2,8 +2,9 @@
 
 use ra_db::{FilePosition, FileRange};
 
-use crate::{db::RootDatabase, FileId, SourceChange, SourceFileEdit};
-
+use crate::{
+    db::RootDatabase, imports_locator::ImportsLocatorIde, FileId, SourceChange, SourceFileEdit,
+};
 use either::Either;
 pub use ra_assists::AssistId;
 use ra_assists::{AssistAction, AssistLabel};
@@ -16,7 +17,7 @@ pub struct Assist {
 }
 
 pub(crate) fn assists(db: &RootDatabase, frange: FileRange) -> Vec<Assist> {
-    ra_assists::assists(db, frange)
+    ra_assists::assists_with_imports_locator(db, frange, ImportsLocatorIde::new(db))
         .into_iter()
         .map(|assist| {
             let file_id = frange.file_id;
diff --git a/crates/ra_ide/src/change.rs b/crates/ra_ide/src/change.rs
index b0aa2c8e0..45a58690b 100644
--- a/crates/ra_ide/src/change.rs
+++ b/crates/ra_ide/src/change.rs
@@ -166,13 +166,15 @@ impl LibraryData {
 const GC_COOLDOWN: time::Duration = time::Duration::from_millis(100);
 
 impl RootDatabase {
+    pub(crate) fn request_cancellation(&mut self) {
+        let _p = profile("RootDatabase::request_cancellation");
+        self.salsa_runtime_mut().synthetic_write(Durability::LOW);
+    }
+
     pub(crate) fn apply_change(&mut self, change: AnalysisChange) {
         let _p = profile("RootDatabase::apply_change");
+        self.request_cancellation();
         log::info!("apply_change {:?}", change);
-        {
-            let _p = profile("RootDatabase::apply_change/cancellation");
-            self.salsa_runtime_mut().synthetic_write(Durability::LOW);
-        }
         if !change.new_roots.is_empty() {
             let mut local_roots = Vec::clone(&self.local_roots());
             for (root_id, is_local) in change.new_roots {
@@ -299,45 +301,74 @@ impl RootDatabase {
             )*}
         }
         sweep_each_query![
+            // SourceDatabase
             ra_db::ParseQuery
             ra_db::SourceRootCratesQuery
+
+            // AstDatabase
             hir::db::AstIdMapQuery
-            hir::db::ParseMacroQuery
-            hir::db::MacroDefQuery
+            hir::db::InternMacroQuery
             hir::db::MacroArgQuery
+            hir::db::MacroDefQuery
+            hir::db::ParseMacroQuery
             hir::db::MacroExpandQuery
+
+            // DefDatabase
+            hir::db::RawItemsQuery
+            hir::db::ComputeCrateDefMapQuery
             hir::db::StructDataQuery
+            hir::db::UnionDataQuery
             hir::db::EnumDataQuery
+            hir::db::ImplDataQuery
             hir::db::TraitDataQuery
-            hir::db::RawItemsQuery
-            hir::db::ComputeCrateDefMapQuery
-            hir::db::GenericParamsQuery
-            hir::db::FunctionDataQuery
             hir::db::TypeAliasDataQuery
+            hir::db::FunctionDataQuery
             hir::db::ConstDataQuery
             hir::db::StaticDataQuery
+            hir::db::BodyWithSourceMapQuery
+            hir::db::BodyQuery
+            hir::db::ExprScopesQuery
+            hir::db::GenericParamsQuery
+            hir::db::AttrsQuery
             hir::db::ModuleLangItemsQuery
             hir::db::CrateLangItemsQuery
             hir::db::LangItemQuery
             hir::db::DocumentationQuery
-            hir::db::ExprScopesQuery
+
+            // InternDatabase
+            hir::db::InternFunctionQuery
+            hir::db::InternStructQuery
+            hir::db::InternUnionQuery
+            hir::db::InternEnumQuery
+            hir::db::InternConstQuery
+            hir::db::InternStaticQuery
+            hir::db::InternTraitQuery
+            hir::db::InternTypeAliasQuery
+            hir::db::InternImplQuery
+
+            // HirDatabase
             hir::db::DoInferQuery
             hir::db::TyQuery
             hir::db::ValueTyQuery
+            hir::db::ImplSelfTyQuery
+            hir::db::ImplTraitQuery
             hir::db::FieldTypesQuery
             hir::db::CallableItemSignatureQuery
+            hir::db::GenericPredicatesForParamQuery
             hir::db::GenericPredicatesQuery
             hir::db::GenericDefaultsQuery
-            hir::db::BodyWithSourceMapQuery
-            hir::db::BodyQuery
             hir::db::ImplsInCrateQuery
             hir::db::ImplsForTraitQuery
+            hir::db::TraitSolverQuery
+            hir::db::InternTypeCtorQuery
+            hir::db::InternChalkImplQuery
+            hir::db::InternAssocTyValueQuery
             hir::db::AssociatedTyDataQuery
+            hir::db::AssociatedTyValueQuery
+            hir::db::TraitSolveQuery
             hir::db::TraitDatumQuery
             hir::db::StructDatumQuery
             hir::db::ImplDatumQuery
-            hir::db::ImplDataQuery
-            hir::db::TraitSolveQuery
         ];
         acc.sort_by_key(|it| std::cmp::Reverse(it.1));
         acc
diff --git a/crates/ra_ide/src/expand.rs b/crates/ra_ide/src/expand.rs
index b82259a3d..831438c09 100644
--- a/crates/ra_ide/src/expand.rs
+++ b/crates/ra_ide/src/expand.rs
@@ -79,6 +79,14 @@ pub(crate) fn descend_into_macros(
     let source_analyzer =
         hir::SourceAnalyzer::new(db, src.with_value(src.value.parent()).as_ref(), None);
 
+    descend_into_macros_with_analyzer(db, &source_analyzer, src)
+}
+
+pub(crate) fn descend_into_macros_with_analyzer(
+    db: &RootDatabase,
+    source_analyzer: &hir::SourceAnalyzer,
+    src: InFile<SyntaxToken>,
+) -> InFile<SyntaxToken> {
     successors(Some(src), |token| {
         let macro_call = token.value.ancestors().find_map(ast::MacroCall::cast)?;
         let tt = macro_call.token_tree()?;
diff --git a/crates/ra_ide/src/imports_locator.rs b/crates/ra_ide/src/imports_locator.rs
new file mode 100644
index 000000000..48b014c7d
--- /dev/null
+++ b/crates/ra_ide/src/imports_locator.rs
@@ -0,0 +1,76 @@
+//! This module contains an import search funcionality that is provided to the ra_assists module.
+//! Later, this should be moved away to a separate crate that is accessible from the ra_assists module.
+
+use crate::{
+    db::RootDatabase,
+    references::{classify_name, NameDefinition, NameKind},
+    symbol_index::{self, FileSymbol},
+    Query,
+};
+use hir::{db::HirDatabase, ModuleDef, SourceBinder};
+use ra_assists::ImportsLocator;
+use ra_prof::profile;
+use ra_syntax::{ast, AstNode, SyntaxKind::NAME};
+
+pub(crate) struct ImportsLocatorIde<'a> {
+    source_binder: SourceBinder<'a, RootDatabase>,
+}
+
+impl<'a> ImportsLocatorIde<'a> {
+    pub(crate) fn new(db: &'a RootDatabase) -> Self {
+        Self { source_binder: SourceBinder::new(db) }
+    }
+
+    fn get_name_definition(
+        &mut self,
+        db: &impl HirDatabase,
+        import_candidate: &FileSymbol,
+    ) -> Option<NameDefinition> {
+        let _p = profile("get_name_definition");
+        let file_id = import_candidate.file_id.into();
+        let candidate_node = import_candidate.ptr.to_node(&db.parse_or_expand(file_id)?);
+        let candidate_name_node = if candidate_node.kind() != NAME {
+            candidate_node.children().find(|it| it.kind() == NAME)?
+        } else {
+            candidate_node
+        };
+        classify_name(
+            &mut self.source_binder,
+            hir::InFile { file_id, value: &ast::Name::cast(candidate_name_node)? },
+        )
+    }
+}
+
+impl ImportsLocator for ImportsLocatorIde<'_> {
+    fn find_imports(&mut self, name_to_import: &str) -> Vec<ModuleDef> {
+        let _p = profile("search_for_imports");
+        let db = self.source_binder.db;
+
+        let project_results = {
+            let mut query = Query::new(name_to_import.to_string());
+            query.exact();
+            query.limit(40);
+            symbol_index::world_symbols(db, query)
+        };
+        let lib_results = {
+            let mut query = Query::new(name_to_import.to_string());
+            query.libs();
+            query.exact();
+            query.limit(40);
+            symbol_index::world_symbols(db, query)
+        };
+
+        project_results
+            .into_iter()
+            .chain(lib_results.into_iter())
+            .filter_map(|import_candidate| self.get_name_definition(db, &import_candidate))
+            .filter_map(|name_definition_to_import| {
+                if let NameKind::Def(module_def) = name_definition_to_import.kind {
+                    Some(module_def)
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+}
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 4d8deb21c..03ad6b2c1 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -30,6 +30,7 @@ mod syntax_highlighting;
 mod parent_module;
 mod references;
 mod impls;
+mod imports_locator;
 mod assists;
 mod diagnostics;
 mod syntax_tree;
@@ -202,6 +203,9 @@ impl AnalysisHost {
     pub fn per_query_memory_usage(&mut self) -> Vec<(String, ra_prof::Bytes)> {
         self.db.per_query_memory_usage()
     }
+    pub fn request_cancellation(&mut self) {
+        self.db.request_cancellation();
+    }
     pub fn raw_database(
         &self,
     ) -> &(impl hir::db::HirDatabase + salsa::Database + ra_db::SourceDatabaseExt) {
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index 5e2fe1905..ebded715d 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -112,25 +112,20 @@ impl IntoIterator for ReferenceSearchResult {
 
 pub(crate) fn find_all_refs(
     db: &RootDatabase,
-    mut position: FilePosition,
+    position: FilePosition,
     search_scope: Option<SearchScope>,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
     let parse = db.parse(position.file_id);
     let syntax = parse.tree().syntax().clone();
 
-    let token = syntax.token_at_offset(position.offset);
-    let mut search_kind = ReferenceKind::Other;
+    let (opt_name, search_kind) =
+        if let Some(name) = get_struct_def_name_for_struc_litetal_search(&syntax, position) {
+            (Some(name), ReferenceKind::StructLiteral)
+        } else {
+            (find_node_at_offset::<ast::Name>(&syntax, position.offset), ReferenceKind::Other)
+        };
 
-    if let TokenAtOffset::Between(ref left, ref right) = token {
-        if (right.kind() == SyntaxKind::L_CURLY || right.kind() == SyntaxKind::L_PAREN)
-            && left.kind() != SyntaxKind::IDENT
-        {
-            position = FilePosition { offset: left.text_range().start(), ..position };
-            search_kind = ReferenceKind::StructLiteral;
-        }
-    }
-
-    let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position)?;
+    let RangeInfo { range, info: (name, def) } = find_name(db, &syntax, position, opt_name)?;
 
     let declaration = match def.kind {
         NameKind::Macro(mac) => mac.to_nav(db),
@@ -170,9 +165,10 @@ fn find_name(
     db: &RootDatabase,
     syntax: &SyntaxNode,
     position: FilePosition,
+    opt_name: Option<ast::Name>,
 ) -> Option<RangeInfo<(String, NameDefinition)>> {
     let mut sb = SourceBinder::new(db);
-    if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, position.offset) {
+    if let Some(name) = opt_name {
         let def = classify_name(&mut sb, InFile::new(position.file_id.into(), &name))?;
         let range = name.syntax().text_range();
         return Some(RangeInfo::new(range, (name.text().to_string(), def)));
@@ -218,15 +214,8 @@ fn process_definition(
                 if let Some(d) = classify_name_ref(&mut sb, InFile::new(file_id.into(), &name_ref))
                 {
                     if d == def {
-                        let kind = if name_ref
-                            .syntax()
-                            .ancestors()
-                            .find_map(ast::RecordLit::cast)
-                            .and_then(|l| l.path())
-                            .and_then(|p| p.segment())
-                            .and_then(|p| p.name_ref())
-                            .map(|n| n == name_ref)
-                            .unwrap_or(false)
+                        let kind = if is_record_lit_name_ref(&name_ref)
+                            || is_call_expr_name_ref(&name_ref)
                         {
                             ReferenceKind::StructLiteral
                         } else {
@@ -301,6 +290,49 @@ fn reference_access(kind: &NameKind, name_ref: &ast::NameRef) -> Option<Referenc
     mode.or(Some(ReferenceAccess::Read))
 }
 
+fn is_record_lit_name_ref(name_ref: &ast::NameRef) -> bool {
+    name_ref
+        .syntax()
+        .ancestors()
+        .find_map(ast::RecordLit::cast)
+        .and_then(|l| l.path())
+        .and_then(|p| p.segment())
+        .map(|p| p.name_ref().as_ref() == Some(name_ref))
+        .unwrap_or(false)
+}
+
+fn get_struct_def_name_for_struc_litetal_search(
+    syntax: &SyntaxNode,
+    position: FilePosition,
+) -> Option<ast::Name> {
+    if let TokenAtOffset::Between(ref left, ref right) = syntax.token_at_offset(position.offset) {
+        if right.kind() != SyntaxKind::L_CURLY && right.kind() != SyntaxKind::L_PAREN {
+            return None;
+        }
+        if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, left.text_range().start()) {
+            return name.syntax().ancestors().find_map(ast::StructDef::cast).and_then(|l| l.name());
+        }
+        if find_node_at_offset::<ast::TypeParamList>(&syntax, left.text_range().start()).is_some() {
+            return left.ancestors().find_map(ast::StructDef::cast).and_then(|l| l.name());
+        }
+    }
+    None
+}
+
+fn is_call_expr_name_ref(name_ref: &ast::NameRef) -> bool {
+    name_ref
+        .syntax()
+        .ancestors()
+        .find_map(ast::CallExpr::cast)
+        .and_then(|c| match c.expr()? {
+            ast::Expr::PathExpr(p) => {
+                Some(p.path()?.segment()?.name_ref().as_ref() == Some(name_ref))
+            }
+            _ => None,
+        })
+        .unwrap_or(false)
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{
@@ -309,7 +341,7 @@ mod tests {
     };
 
     #[test]
-    fn test_struct_literal() {
+    fn test_struct_literal_after_space() {
         let code = r#"
     struct Foo <|>{
         a: i32,
@@ -331,6 +363,58 @@ mod tests {
     }
 
     #[test]
+    fn test_struct_literal_befor_space() {
+        let code = r#"
+    struct Foo<|> {}
+        fn main() {
+        let f: Foo;
+        f = Foo {};
+    }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(1) [5; 18) [12; 15) Other",
+            &["FileId(1) [54; 57) Other", "FileId(1) [71; 74) StructLiteral"],
+        );
+    }
+
+    #[test]
+    fn test_struct_literal_with_generic_type() {
+        let code = r#"
+    struct Foo<T> <|>{}
+        fn main() {
+        let f: Foo::<i32>;
+        f = Foo {};
+    }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(1) [5; 21) [12; 15) Other",
+            &["FileId(1) [81; 84) StructLiteral"],
+        );
+    }
+
+    #[test]
+    fn test_struct_literal_for_tuple() {
+        let code = r#"
+    struct Foo<|>(i32);
+
+    fn main() {
+        let f: Foo;
+        f = Foo(1);
+    }"#;
+
+        let refs = get_all_refs(code);
+        check_result(
+            refs,
+            "Foo STRUCT_DEF FileId(1) [5; 21) [12; 15) Other",
+            &["FileId(1) [71; 74) StructLiteral"],
+        );
+    }
+
+    #[test]
     fn test_find_all_refs_for_local() {
         let code = r#"
     fn main() {
@@ -564,7 +648,7 @@ mod tests {
         check_result(
             refs,
             "quux FN_DEF FileId(1) [18; 34) [25; 29) Other",
-            &["FileId(2) [16; 20) Other", "FileId(3) [16; 20) Other"],
+            &["FileId(2) [16; 20) StructLiteral", "FileId(3) [16; 20) StructLiteral"],
         );
 
         let refs =
@@ -572,7 +656,7 @@ mod tests {
         check_result(
             refs,
             "quux FN_DEF FileId(1) [18; 34) [25; 29) Other",
-            &["FileId(3) [16; 20) Other"],
+            &["FileId(3) [16; 20) StructLiteral"],
         );
     }
 
@@ -591,7 +675,7 @@ mod tests {
         check_result(
             refs,
             "m1 MACRO_CALL FileId(1) [9; 63) [46; 48) Other",
-            &["FileId(1) [96; 98) Other", "FileId(1) [114; 116) Other"],
+            &["FileId(1) [96; 98) StructLiteral", "FileId(1) [114; 116) StructLiteral"],
         );
     }
 
diff --git a/crates/ra_ide/src/runnables.rs b/crates/ra_ide/src/runnables.rs
index 7533692f6..8622dd956 100644
--- a/crates/ra_ide/src/runnables.rs
+++ b/crates/ra_ide/src/runnables.rs
@@ -43,7 +43,7 @@ fn runnable_fn(fn_def: ast::FnDef) -> Option<Runnable> {
     let name = fn_def.name()?.text().clone();
     let kind = if name == "main" {
         RunnableKind::Bin
-    } else if fn_def.has_atom_attr("test") {
+    } else if has_test_related_attribute(&fn_def) {
         RunnableKind::Test { name: name.to_string() }
     } else if fn_def.has_atom_attr("bench") {
         RunnableKind::Bench { name: name.to_string() }
@@ -53,6 +53,20 @@ fn runnable_fn(fn_def: ast::FnDef) -> Option<Runnable> {
     Some(Runnable { range: fn_def.syntax().text_range(), kind })
 }
 
+/// This is a method with a heuristics to support test methods annotated with custom test annotations, such as
+/// `#[test_case(...)]`, `#[tokio::test]` and similar.
+/// Also a regular `#[test]` annotation is supported.
+///
+/// It may produce false positives, for example, `#[wasm_bindgen_test]` requires a different command to run the test,
+/// but it's better than not to have the runnables for the tests at all.
+fn has_test_related_attribute(fn_def: &ast::FnDef) -> bool {
+    fn_def
+        .attrs()
+        .filter_map(|attr| attr.path())
+        .map(|path| path.syntax().to_string().to_lowercase())
+        .any(|attribute_text| attribute_text.contains("test"))
+}
+
 fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Option<Runnable> {
     let has_test_function = module
         .item_list()?
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 1d130544f..1cc55e78b 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -34,6 +34,16 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     <span class="function">foo</span>::&lt;<span class="type.builtin">i32</span>&gt;();
 }
 
+<span class="macro">macro_rules</span><span class="macro">!</span> def_fn {
+    ($($tt:tt)*) =&gt; {$($tt)*}
+}
+
+<span class="macro">def_fn</span><span class="macro">!</span>{
+    <span class="keyword">fn</span> <span class="function">bar</span>() -&gt; <span class="type.builtin">u32</span> {
+        <span class="literal.numeric">100</span>
+    }
+}
+
 <span class="comment">// comment</span>
 <span class="keyword">fn</span> <span class="function">main</span>() {
     <span class="macro">println</span><span class="macro">!</span>(<span class="string">"Hello, {}!"</span>, <span class="literal.numeric">92</span>);
diff --git a/crates/ra_ide/src/snapshots/rainbow_highlighting.html b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
index d90ee8540..918fd4b97 100644
--- a/crates/ra_ide/src/snapshots/rainbow_highlighting.html
+++ b/crates/ra_ide/src/snapshots/rainbow_highlighting.html
@@ -24,14 +24,14 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .keyword\.control  { color: #F0DFAF; font-weight: bold; }
 </style>
 <pre><code><span class="keyword">fn</span> <span class="function">main</span>() {
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span> = <span class="string">"hello"</span>;
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="14702933417323009544" style="color: hsl(108,90%,49%);">x</span> = <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span>.to_string();
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="5443150872754369068" style="color: hsl(215,43%,43%);">y</span> = <span class="variable" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span> = <span class="string">"hello"</span>;
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="4303609361109701698" style="color: hsl(242,75%,88%);">x</span> = <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="13865792086344377029" style="color: hsl(340,64%,86%);">y</span> = <span class="variable" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span>.to_string();
 
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="17358108296605513516" style="color: hsl(331,46%,60%);">x</span> = <span class="string">"other color please!"</span>;
-    <span class="keyword">let</span> <span class="variable" data-binding-hash="2073121142529774969" style="color: hsl(320,43%,74%);">y</span> = <span class="variable" data-binding-hash="17358108296605513516" style="color: hsl(331,46%,60%);">x</span>.to_string();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="7011301204224269512" style="color: hsl(198,45%,40%);">x</span> = <span class="string">"other color please!"</span>;
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="12461245066629867975" style="color: hsl(132,91%,68%);">y</span> = <span class="variable" data-binding-hash="7011301204224269512" style="color: hsl(198,45%,40%);">x</span>.to_string();
 }
 
 <span class="keyword">fn</span> <span class="function">bar</span>() {
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut" data-binding-hash="8723171760279909834" style="color: hsl(307,91%,75%);">hello</span> = <span class="string">"hello"</span>;
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable.mut" data-binding-hash="2217585909179791122" style="color: hsl(280,74%,48%);">hello</span> = <span class="string">"hello"</span>;
 }</code></pre>
\ No newline at end of file
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 0411977b9..530b984fc 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -1,14 +1,18 @@
 //! FIXME: write short doc here
 
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashMap;
 
-use hir::{InFile, Name, SourceBinder};
+use hir::{HirFileId, InFile, Name, SourceAnalyzer, SourceBinder};
 use ra_db::SourceDatabase;
 use ra_prof::profile;
-use ra_syntax::{ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, TextRange, T};
+use ra_syntax::{
+    ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, SyntaxToken, TextRange,
+    WalkEvent, T,
+};
 
 use crate::{
     db::RootDatabase,
+    expand::descend_into_macros_with_analyzer,
     references::{
         classify_name, classify_name_ref,
         NameKind::{self, *},
@@ -72,121 +76,186 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
     let parse = db.parse(file_id);
     let root = parse.tree().syntax().clone();
 
-    fn calc_binding_hash(file_id: FileId, name: &Name, shadow_count: u32) -> u64 {
-        fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
-            use std::{collections::hash_map::DefaultHasher, hash::Hasher};
+    let mut sb = SourceBinder::new(db);
+    let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
+    let mut res = Vec::new();
+    let analyzer = sb.analyze(InFile::new(file_id.into(), &root), None);
 
-            let mut hasher = DefaultHasher::new();
-            x.hash(&mut hasher);
-            hasher.finish()
+    let mut in_macro_call = None;
+
+    for event in root.preorder_with_tokens() {
+        match event {
+            WalkEvent::Enter(node) => match node.kind() {
+                MACRO_CALL => {
+                    in_macro_call = Some(node.clone());
+                    if let Some(range) = highlight_macro(InFile::new(file_id.into(), node)) {
+                        res.push(HighlightedRange { range, tag: tags::MACRO, binding_hash: None });
+                    }
+                }
+                _ if in_macro_call.is_some() => {
+                    if let Some(token) = node.as_token() {
+                        if let Some((tag, binding_hash)) = highlight_token_tree(
+                            db,
+                            &mut sb,
+                            &analyzer,
+                            &mut bindings_shadow_count,
+                            InFile::new(file_id.into(), token.clone()),
+                        ) {
+                            res.push(HighlightedRange {
+                                range: node.text_range(),
+                                tag,
+                                binding_hash,
+                            });
+                        }
+                    }
+                }
+                _ => {
+                    if let Some((tag, binding_hash)) = highlight_node(
+                        db,
+                        &mut sb,
+                        &mut bindings_shadow_count,
+                        InFile::new(file_id.into(), node.clone()),
+                    ) {
+                        res.push(HighlightedRange { range: node.text_range(), tag, binding_hash });
+                    }
+                }
+            },
+            WalkEvent::Leave(node) => {
+                if let Some(m) = in_macro_call.as_ref() {
+                    if *m == node {
+                        in_macro_call = None;
+                    }
+                }
+            }
         }
+    }
 
-        hash((file_id, name, shadow_count))
+    res
+}
+
+fn highlight_macro(node: InFile<SyntaxElement>) -> Option<TextRange> {
+    let macro_call = ast::MacroCall::cast(node.value.as_node()?.clone())?;
+    let path = macro_call.path()?;
+    let name_ref = path.segment()?.name_ref()?;
+
+    let range_start = name_ref.syntax().text_range().start();
+    let mut range_end = name_ref.syntax().text_range().end();
+    for sibling in path.syntax().siblings_with_tokens(Direction::Next) {
+        match sibling.kind() {
+            T![!] | IDENT => range_end = sibling.text_range().end(),
+            _ => (),
+        }
     }
 
-    let mut sb = SourceBinder::new(db);
+    Some(TextRange::from_to(range_start, range_end))
+}
 
-    // Visited nodes to handle highlighting priorities
-    // FIXME: retain only ranges here
-    let mut highlighted: FxHashSet<SyntaxElement> = FxHashSet::default();
-    let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
+fn highlight_token_tree(
+    db: &RootDatabase,
+    sb: &mut SourceBinder<RootDatabase>,
+    analyzer: &SourceAnalyzer,
+    bindings_shadow_count: &mut FxHashMap<Name, u32>,
+    token: InFile<SyntaxToken>,
+) -> Option<(&'static str, Option<u64>)> {
+    if token.value.parent().kind() != TOKEN_TREE {
+        return None;
+    }
+    let token = descend_into_macros_with_analyzer(db, analyzer, token);
+    let expanded = {
+        let parent = token.value.parent();
+        // We only care Name and Name_ref
+        match (token.value.kind(), parent.kind()) {
+            (IDENT, NAME) | (IDENT, NAME_REF) => token.with_value(parent.into()),
+            _ => token.map(|it| it.into()),
+        }
+    };
 
-    let mut res = Vec::new();
-    for node in root.descendants_with_tokens() {
-        if highlighted.contains(&node) {
-            continue;
+    highlight_node(db, sb, bindings_shadow_count, expanded)
+}
+
+fn highlight_node(
+    db: &RootDatabase,
+    sb: &mut SourceBinder<RootDatabase>,
+    bindings_shadow_count: &mut FxHashMap<Name, u32>,
+    node: InFile<SyntaxElement>,
+) -> Option<(&'static str, Option<u64>)> {
+    let mut binding_hash = None;
+    let tag = match node.value.kind() {
+        FN_DEF => {
+            bindings_shadow_count.clear();
+            return None;
         }
-        let mut binding_hash = None;
-        let tag = match node.kind() {
-            FN_DEF => {
-                bindings_shadow_count.clear();
-                continue;
-            }
-            COMMENT => tags::LITERAL_COMMENT,
-            STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => tags::LITERAL_STRING,
-            ATTR => tags::LITERAL_ATTRIBUTE,
-            // Special-case field init shorthand
-            NAME_REF if node.parent().and_then(ast::RecordField::cast).is_some() => tags::FIELD,
-            NAME_REF if node.ancestors().any(|it| it.kind() == ATTR) => continue,
-            NAME_REF => {
-                let name_ref = node.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
-                let name_kind = classify_name_ref(&mut sb, InFile::new(file_id.into(), &name_ref))
-                    .map(|d| d.kind);
-                match name_kind {
-                    Some(name_kind) => {
-                        if let Local(local) = &name_kind {
-                            if let Some(name) = local.name(db) {
-                                let shadow_count =
-                                    bindings_shadow_count.entry(name.clone()).or_default();
-                                binding_hash =
-                                    Some(calc_binding_hash(file_id, &name, *shadow_count))
-                            }
-                        };
-
-                        highlight_name(db, name_kind)
-                    }
-                    _ => continue,
-                }
-            }
-            NAME => {
-                let name = node.as_node().cloned().and_then(ast::Name::cast).unwrap();
-                let name_kind =
-                    classify_name(&mut sb, InFile::new(file_id.into(), &name)).map(|d| d.kind);
-
-                if let Some(Local(local)) = &name_kind {
-                    if let Some(name) = local.name(db) {
-                        let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
-                        *shadow_count += 1;
-                        binding_hash = Some(calc_binding_hash(file_id, &name, *shadow_count))
-                    }
-                };
-
-                match name_kind {
-                    Some(name_kind) => highlight_name(db, name_kind),
-                    None => name.syntax().parent().map_or(tags::FUNCTION, |x| match x.kind() {
-                        STRUCT_DEF | ENUM_DEF | TRAIT_DEF | TYPE_ALIAS_DEF => tags::TYPE,
-                        TYPE_PARAM => tags::TYPE_PARAM,
-                        RECORD_FIELD_DEF => tags::FIELD,
-                        _ => tags::FUNCTION,
-                    }),
+        COMMENT => tags::LITERAL_COMMENT,
+        STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => tags::LITERAL_STRING,
+        ATTR => tags::LITERAL_ATTRIBUTE,
+        // Special-case field init shorthand
+        NAME_REF if node.value.parent().and_then(ast::RecordField::cast).is_some() => tags::FIELD,
+        NAME_REF if node.value.ancestors().any(|it| it.kind() == ATTR) => return None,
+        NAME_REF => {
+            let name_ref = node.value.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
+            let name_kind = classify_name_ref(sb, node.with_value(&name_ref)).map(|d| d.kind);
+            match name_kind {
+                Some(name_kind) => {
+                    if let Local(local) = &name_kind {
+                        if let Some(name) = local.name(db) {
+                            let shadow_count =
+                                bindings_shadow_count.entry(name.clone()).or_default();
+                            binding_hash =
+                                Some(calc_binding_hash(node.file_id, &name, *shadow_count))
+                        }
+                    };
+
+                    highlight_name(db, name_kind)
                 }
+                _ => return None,
             }
-            INT_NUMBER | FLOAT_NUMBER => tags::LITERAL_NUMERIC,
-            BYTE => tags::LITERAL_BYTE,
-            CHAR => tags::LITERAL_CHAR,
-            LIFETIME => tags::TYPE_LIFETIME,
-            T![unsafe] => tags::KEYWORD_UNSAFE,
-            k if is_control_keyword(k) => tags::KEYWORD_CONTROL,
-            k if k.is_keyword() => tags::KEYWORD,
-            _ => {
-                if let Some(macro_call) = node.as_node().cloned().and_then(ast::MacroCall::cast) {
-                    if let Some(path) = macro_call.path() {
-                        if let Some(segment) = path.segment() {
-                            if let Some(name_ref) = segment.name_ref() {
-                                highlighted.insert(name_ref.syntax().clone().into());
-                                let range_start = name_ref.syntax().text_range().start();
-                                let mut range_end = name_ref.syntax().text_range().end();
-                                for sibling in path.syntax().siblings_with_tokens(Direction::Next) {
-                                    match sibling.kind() {
-                                        T![!] | IDENT => range_end = sibling.text_range().end(),
-                                        _ => (),
-                                    }
-                                }
-                                res.push(HighlightedRange {
-                                    range: TextRange::from_to(range_start, range_end),
-                                    tag: tags::MACRO,
-                                    binding_hash: None,
-                                })
-                            }
-                        }
-                    }
+        }
+        NAME => {
+            let name = node.value.as_node().cloned().and_then(ast::Name::cast).unwrap();
+            let name_kind = classify_name(sb, node.with_value(&name)).map(|d| d.kind);
+
+            if let Some(Local(local)) = &name_kind {
+                if let Some(name) = local.name(db) {
+                    let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
+                    *shadow_count += 1;
+                    binding_hash = Some(calc_binding_hash(node.file_id, &name, *shadow_count))
                 }
-                continue;
+            };
+
+            match name_kind {
+                Some(name_kind) => highlight_name(db, name_kind),
+                None => name.syntax().parent().map_or(tags::FUNCTION, |x| match x.kind() {
+                    STRUCT_DEF | ENUM_DEF | TRAIT_DEF | TYPE_ALIAS_DEF => tags::TYPE,
+                    TYPE_PARAM => tags::TYPE_PARAM,
+                    RECORD_FIELD_DEF => tags::FIELD,
+                    _ => tags::FUNCTION,
+                }),
             }
-        };
-        res.push(HighlightedRange { range: node.text_range(), tag, binding_hash })
+        }
+        INT_NUMBER | FLOAT_NUMBER => tags::LITERAL_NUMERIC,
+        BYTE => tags::LITERAL_BYTE,
+        CHAR => tags::LITERAL_CHAR,
+        LIFETIME => tags::TYPE_LIFETIME,
+        T![unsafe] => tags::KEYWORD_UNSAFE,
+        k if is_control_keyword(k) => tags::KEYWORD_CONTROL,
+        k if k.is_keyword() => tags::KEYWORD,
+
+        _ => return None,
+    };
+
+    return Some((tag, binding_hash));
+
+    fn calc_binding_hash(file_id: HirFileId, name: &Name, shadow_count: u32) -> u64 {
+        fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
+            use std::{collections::hash_map::DefaultHasher, hash::Hasher};
+
+            let mut hasher = DefaultHasher::new();
+            x.hash(&mut hasher);
+            hasher.finish()
+        }
+
+        hash((file_id, name, shadow_count))
     }
-    res
 }
 
 pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: bool) -> String {
@@ -331,6 +400,16 @@ fn foo<T>() -> T {
     foo::<i32>();
 }
 
+macro_rules! def_fn {
+    ($($tt:tt)*) => {$($tt)*}
+}
+
+def_fn!{
+    fn bar() -> u32 {
+        100
+    }
+}
+
 // comment
 fn main() {
     println!("Hello, {}!", 92);