Rename back to highlight and check event's again highlight range

crates/ra_ide/src/lib.rs

@@ -425,16 +425,14 @@ impl Analysis {
         self.with_db(|db| runnables::runnables(db, file_id))
     }
 
-    /// Computes syntax highlighting for the given file.
+    /// Computes syntax highlighting for the given file
     pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
-        self.with_db(|db| syntax_highlighting::highlight(db, file_id))
+        self.with_db(|db| syntax_highlighting::highlight(db, file_id, None))
     }
 
     /// Computes syntax highlighting for the given file range.
     pub fn highlight_range(&self, frange: FileRange) -> Cancelable<Vec<HighlightedRange>> {
-        self.with_db(|db| {
+        self.with_db(|db| syntax_highlighting::highlight(db, frange.file_id, Some(frange.range)))
-            syntax_highlighting::highlight_range(db, frange.file_id, Some(frange.range))
-        })
     }
 
     /// Computes syntax highlighting for the given file.

crates/ra_ide/src/syntax_highlighting.rs

@@ -67,17 +67,12 @@ fn is_control_keyword(kind: SyntaxKind) -> bool {
     }
 }
 
-pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRange> {
+pub(crate) fn highlight(
-    let _p = profile("highlight");
-    highlight_range(db, file_id, None)
-}
-
-pub(crate) fn highlight_range(
     db: &RootDatabase,
     file_id: FileId,
     range: Option<TextRange>,
 ) -> Vec<HighlightedRange> {
-    let _p = profile("highlight_range");
+    let _p = profile("highlight");
 
     let parse = db.parse(file_id);
     let root = parse.tree().syntax().clone();
@@ -89,31 +84,56 @@ pub(crate) fn highlight_range(
 
     let mut in_macro_call = None;
 
-    // Determine the root based on the range
+    // Determine the root based on the given range.
-    let root = match range {
+    let (root, highlight_range) = if let Some(range) = range {
-        Some(range) => match root.covering_element(range) {
+        let root = match root.covering_element(range) {
             NodeOrToken::Node(node) => node,
             NodeOrToken::Token(token) => token.parent(),
-        },
+        };
-        None => root,
+        (root, range)
+    } else {
+        (root.clone(), root.text_range())
     };
 
     for event in root.preorder_with_tokens() {
         match event {
-            WalkEvent::Enter(node) => match node.kind() {
+            WalkEvent::Enter(node) => {
-                MACRO_CALL => {
+                if node.text_range().intersection(&highlight_range).is_none() {
-                    in_macro_call = Some(node.clone());
+                    continue;
-                    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() {
+                match node.kind() {
-                        if let Some((tag, binding_hash)) = highlight_token_tree(
+                    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(
+                                &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(
                             &mut sb,
-                            &analyzer,
                             &mut bindings_shadow_count,
-                            InFile::new(file_id.into(), token.clone()),
+                            InFile::new(file_id.into(), node.clone()),
                         ) {
                             res.push(HighlightedRange {
                                 range: node.text_range(),
@@ -123,17 +143,12 @@ pub(crate) fn highlight_range(
                         }
                     }
                 }
-                _ => {
+            }
-                    if let Some((tag, binding_hash)) = highlight_node(
-                        &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 node.text_range().intersection(&highlight_range).is_none() {
+                    continue;
+                }
+
                 if let Some(m) = in_macro_call.as_ref() {
                     if *m == node {
                         in_macro_call = None;
@@ -284,7 +299,7 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
         )
     }
 
-    let mut ranges = highlight(db, file_id);
+    let mut ranges = highlight(db, file_id, None);
     ranges.sort_by_key(|it| it.range.start());
     // quick non-optimal heuristic to intersect token ranges and highlighted ranges
     let mut frontier = 0;
@@ -509,10 +524,11 @@ fn bar() {
             }"#,
         );
 
+        // The "x"
         let highlights = &analysis
             .highlight_range(FileRange {
                 file_id,
-                range: TextRange::offset_len(82.into(), 1.into()), // "x"
+                range: TextRange::offset_len(82.into(), 1.into()),
             })
             .unwrap();