Remove DescendPreference::SameKind

crates/ide/src/syntax_highlighting.rs

@@ -13,7 +13,9 @@ mod html;
 #[cfg(test)]
 mod tests;
 
-use hir::{DescendPreference, Name, Semantics};
+use std::ops::ControlFlow;
+
+use hir::{Name, Semantics};
 use ide_db::{FxHashMap, RootDatabase, SymbolKind};
 use span::EditionedFileId;
 use syntax::{
@@ -399,20 +401,53 @@ fn traverse(
             // Attempt to descend tokens into macro-calls.
             let res = match element {
                 NodeOrToken::Token(token) if token.kind() != COMMENT => {
-                    let token = if token.kind() == STRING {
-                        // for strings, try to prefer a string that has not been lost in a token
-                        // tree
-                        // FIXME: This should be done for everything, but check perf first
-                        sema.descend_into_macros(DescendPreference::SameKind, token)
-                            .into_iter()
-                            .max_by_key(|it| {
-                                it.parent().map_or(false, |it| it.kind() != TOKEN_TREE)
-                            })
-                            .unwrap()
-                    } else {
-                        // FIXME: We should probably rank the tokens and find the most suitable?
-                        sema.descend_into_macros_single_exact(token)
-                    };
+                    let kind = token.kind();
+                    let text = token.text();
+                    let ident_kind = kind.is_any_identifier();
+
+                    let mut t = None;
+                    let mut r = 0;
+                    // FIXME: Add an extra API that takes the file id of this. That is a simple way
+                    // to prevent us constantly walking up the tree to fetch the file
+                    sema.descend_into_macros_ng_b(token.clone(), |tok| {
+                        let tok = tok.value;
+                        let tok_kind = tok.kind();
+
+                        let exact_same_kind = tok_kind == kind;
+                        let both_idents =
+                            exact_same_kind || (tok_kind.is_any_identifier() && ident_kind);
+                        let same_text = tok.text() == text;
+                        // anything that mapped into a token tree has likely no semantic information
+                        let no_tt_parent = tok.parent().map_or(false, |it| it.kind() != TOKEN_TREE);
+                        let my_rank = (both_idents as usize)
+                            | ((exact_same_kind as usize) << 1)
+                            | ((same_text as usize) << 2)
+                            | ((no_tt_parent as usize) << 3);
+
+                        if my_rank > 0b1110 {
+                            // a rank of 0b1110 means that we have found a maximally interesting
+                            // token so stop early.
+                            t = Some(tok);
+                            return ControlFlow::Break(());
+                        }
+
+                        // r = r.max(my_rank);
+                        // t = Some(t.take_if(|_| r < my_rank).unwrap_or(tok));
+                        match &mut t {
+                            Some(prev) if r < my_rank => {
+                                *prev = tok;
+                                r = my_rank;
+                            }
+                            Some(_) => (),
+                            None => {
+                                r = my_rank;
+                                t = Some(tok)
+                            }
+                        }
+                        ControlFlow::Continue(())
+                    });
+
+                    let token = t.unwrap_or(token);
                     match token.parent().and_then(ast::NameLike::cast) {
                         // Remap the token into the wrapping single token nodes
                         Some(parent) => match (token.kind(), parent.syntax().kind()) {