aboutsummaryrefslogtreecommitdiff
path: root/crates
diff options
context:
space:
mode:
authorbors[bot] <26634292+bors[bot]@users.noreply.github.com>2020-04-08 13:00:08 +0100
committerGitHub <[email protected]>2020-04-08 13:00:08 +0100
commit8ea7c9cb62aaef468c9ff1483e109329d2d5fccd (patch)
treec5de9cc1c1b941651454a9c67757da9eb0e754e8 /crates
parent9aa3bca53626a76657ecf5f59c431dcd3f7a8085 (diff)
parentbf96d46fee1242ad701cb037a03c9575e84221b1 (diff)
Merge #3826
3826: Flatten nested highlight ranges during DFS traversal r=matklad a=ltentrup Implements the flattening of nested highlights from #3447. There is a caveat: I needed to add `Clone` to `HighlightedRange` to split highlight ranges ~and the nesting does not appear in the syntax highlighting test (it does appear in the accidental-quadratic test but there it is not checked against a ground-truth)~. I have added a test case for the example mentioned in #3447. Co-authored-by: Leander Tentrup <[email protected]>
Diffstat (limited to 'crates')
-rw-r--r--crates/ra_ide/src/snapshots/highlight_injection.html39
-rw-r--r--crates/ra_ide/src/snapshots/highlighting.html10
-rw-r--r--crates/ra_ide/src/syntax_highlighting.rs59
-rw-r--r--crates/ra_ide/src/syntax_highlighting/html.rs66
-rw-r--r--crates/ra_ide/src/syntax_highlighting/tests.rs25
5 files changed, 148 insertions, 51 deletions
diff --git a/crates/ra_ide/src/snapshots/highlight_injection.html b/crates/ra_ide/src/snapshots/highlight_injection.html
new file mode 100644
index 000000000..6ec13bd80
--- /dev/null
+++ b/crates/ra_ide/src/snapshots/highlight_injection.html
@@ -0,0 +1,39 @@
1
2<style>
3body { margin: 0; }
4pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
5
6.lifetime { color: #DFAF8F; font-style: italic; }
7.comment { color: #7F9F7F; }
8.struct, .enum { color: #7CB8BB; }
9.enum_variant { color: #BDE0F3; }
10.string_literal { color: #CC9393; }
11.field { color: #94BFF3; }
12.function { color: #93E0E3; }
13.parameter { color: #94BFF3; }
14.text { color: #DCDCCC; }
15.type { color: #7CB8BB; }
16.builtin_type { color: #8CD0D3; }
17.type_param { color: #DFAF8F; }
18.attribute { color: #94BFF3; }
19.numeric_literal { color: #BFEBBF; }
20.macro { color: #94BFF3; }
21.module { color: #AFD8AF; }
22.variable { color: #DCDCCC; }
23.mutable { text-decoration: underline; }
24
25.keyword { color: #F0DFAF; font-weight: bold; }
26.keyword.unsafe { color: #BC8383; font-weight: bold; }
27.control { font-style: italic; }
28</style>
29<pre><code><span class="keyword">fn</span> <span class="function declaration">fixture</span>(<span class="variable declaration">ra_fixture</span>: &<span class="builtin_type">str</span>) {}
30
31<span class="keyword">fn</span> <span class="function declaration">main</span>() {
32 <span class="function">fixture</span>(<span class="string_literal">r#"</span>
33 <span class="keyword">trait</span> <span class="trait declaration">Foo</span> {
34 <span class="keyword">fn</span> <span class="function declaration">foo</span>() {
35 <span class="macro">println!</span>(<span class="string_literal">"2 + 2 = {}"</span>, <span class="numeric_literal">4</span>);
36 }
37 }<span class="string_literal">"#</span>
38 );
39}</code></pre> \ No newline at end of file
diff --git a/crates/ra_ide/src/snapshots/highlighting.html b/crates/ra_ide/src/snapshots/highlighting.html
index 495b07f69..214dcbb62 100644
--- a/crates/ra_ide/src/snapshots/highlighting.html
+++ b/crates/ra_ide/src/snapshots/highlighting.html
@@ -26,7 +26,7 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
26.keyword.unsafe { color: #BC8383; font-weight: bold; } 26.keyword.unsafe { color: #BC8383; font-weight: bold; }
27.control { font-style: italic; } 27.control { font-style: italic; }
28</style> 28</style>
29<pre><code><span class="attribute">#</span><span class="attribute">[</span><span class="attribute">derive</span><span class="attribute">(</span><span class="attribute">Clone</span><span class="attribute">,</span><span class="attribute"> </span><span class="attribute">Debug</span><span class="attribute">)</span><span class="attribute">]</span> 29<pre><code><span class="attribute">#[derive(Clone, Debug)]</span>
30<span class="keyword">struct</span> <span class="struct declaration">Foo</span> { 30<span class="keyword">struct</span> <span class="struct declaration">Foo</span> {
31 <span class="keyword">pub</span> <span class="field declaration">x</span>: <span class="builtin_type">i32</span>, 31 <span class="keyword">pub</span> <span class="field declaration">x</span>: <span class="builtin_type">i32</span>,
32 <span class="keyword">pub</span> <span class="field declaration">y</span>: <span class="builtin_type">i32</span>, 32 <span class="keyword">pub</span> <span class="field declaration">y</span>: <span class="builtin_type">i32</span>,
@@ -36,11 +36,11 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
36 <span class="function">foo</span>::&lt;<span class="lifetime">'a</span>, <span class="builtin_type">i32</span>&gt;() 36 <span class="function">foo</span>::&lt;<span class="lifetime">'a</span>, <span class="builtin_type">i32</span>&gt;()
37} 37}
38 38
39<span class="macro">macro_rules</span><span class="macro">!</span> def_fn { 39<span class="macro">macro_rules!</span> def_fn {
40 ($($tt:tt)*) =&gt; {$($tt)*} 40 ($($tt:tt)*) =&gt; {$($tt)*}
41} 41}
42 42
43<span class="macro">def_fn</span><span class="macro">!</span> { 43<span class="macro">def_fn!</span> {
44 <span class="keyword">fn</span> <span class="function declaration">bar</span>() -&gt; <span class="builtin_type">u32</span> { 44 <span class="keyword">fn</span> <span class="function declaration">bar</span>() -&gt; <span class="builtin_type">u32</span> {
45 <span class="numeric_literal">100</span> 45 <span class="numeric_literal">100</span>
46 } 46 }
@@ -48,7 +48,7 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
48 48
49<span class="comment">// comment</span> 49<span class="comment">// comment</span>
50<span class="keyword">fn</span> <span class="function declaration">main</span>() { 50<span class="keyword">fn</span> <span class="function declaration">main</span>() {
51 <span class="macro">println</span><span class="macro">!</span>(<span class="string_literal">"Hello, {}!"</span>, <span class="numeric_literal">92</span>); 51 <span class="macro">println!</span>(<span class="string_literal">"Hello, {}!"</span>, <span class="numeric_literal">92</span>);
52 52
53 <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">vec</span> = Vec::new(); 53 <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">vec</span> = Vec::new();
54 <span class="keyword control">if</span> <span class="keyword">true</span> { 54 <span class="keyword control">if</span> <span class="keyword">true</span> {
@@ -73,7 +73,7 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
73<span class="keyword">impl</span>&lt;<span class="type_param declaration">T</span>&gt; <span class="enum">Option</span>&lt;<span class="type_param">T</span>&gt; { 73<span class="keyword">impl</span>&lt;<span class="type_param declaration">T</span>&gt; <span class="enum">Option</span>&lt;<span class="type_param">T</span>&gt; {
74 <span class="keyword">fn</span> <span class="function declaration">and</span>&lt;<span class="type_param declaration">U</span>&gt;(<span class="keyword">self</span>, <span class="variable declaration">other</span>: <span class="enum">Option</span>&lt;<span class="type_param">U</span>&gt;) -&gt; <span class="enum">Option</span>&lt;(<span class="type_param">T</span>, <span class="type_param">U</span>)&gt; { 74 <span class="keyword">fn</span> <span class="function declaration">and</span>&lt;<span class="type_param declaration">U</span>&gt;(<span class="keyword">self</span>, <span class="variable declaration">other</span>: <span class="enum">Option</span>&lt;<span class="type_param">U</span>&gt;) -&gt; <span class="enum">Option</span>&lt;(<span class="type_param">T</span>, <span class="type_param">U</span>)&gt; {
75 <span class="keyword control">match</span> <span class="variable">other</span> { 75 <span class="keyword control">match</span> <span class="variable">other</span> {
76 <span class="enum_variant">None</span> =&gt; <span class="macro">unimplemented</span><span class="macro">!</span>(), 76 <span class="enum_variant">None</span> =&gt; <span class="macro">unimplemented!</span>(),
77 <span class="variable declaration">Nope</span> =&gt; <span class="variable">Nope</span>, 77 <span class="variable declaration">Nope</span> =&gt; <span class="variable">Nope</span>,
78 } 78 }
79 } 79 }
diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index d833a816b..83d161f45 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -24,7 +24,7 @@ use crate::{call_info::call_info_for_token, Analysis, FileId};
24pub(crate) use html::highlight_as_html; 24pub(crate) use html::highlight_as_html;
25pub use tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag}; 25pub use tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag};
26 26
27#[derive(Debug)] 27#[derive(Debug, Clone)]
28pub struct HighlightedRange { 28pub struct HighlightedRange {
29 pub range: TextRange, 29 pub range: TextRange,
30 pub highlight: Highlight, 30 pub highlight: Highlight,
@@ -55,13 +55,55 @@ pub(crate) fn highlight(
55 }; 55 };
56 56
57 let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default(); 57 let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
58 let mut res = Vec::new(); 58 // We use a stack for the DFS traversal below.
59 // When we leave a node, the we use it to flatten the highlighted ranges.
60 let mut res: Vec<Vec<HighlightedRange>> = vec![Vec::new()];
59 61
60 let mut current_macro_call: Option<ast::MacroCall> = None; 62 let mut current_macro_call: Option<ast::MacroCall> = None;
61 63
62 // Walk all nodes, keeping track of whether we are inside a macro or not. 64 // Walk all nodes, keeping track of whether we are inside a macro or not.
63 // If in macro, expand it first and highlight the expanded code. 65 // If in macro, expand it first and highlight the expanded code.
64 for event in root.preorder_with_tokens() { 66 for event in root.preorder_with_tokens() {
67 match &event {
68 WalkEvent::Enter(_) => res.push(Vec::new()),
69 WalkEvent::Leave(_) => {
70 /* Flattens the highlighted ranges.
71 *
72 * For example `#[cfg(feature = "foo")]` contains the nested ranges:
73 * 1) parent-range: Attribute [0, 23)
74 * 2) child-range: String [16, 21)
75 *
76 * The following code implements the flattening, for our example this results to:
77 * `[Attribute [0, 16), String [16, 21), Attribute [21, 23)]`
78 */
79 let children = res.pop().unwrap();
80 let prev = res.last_mut().unwrap();
81 let needs_flattening = !children.is_empty()
82 && !prev.is_empty()
83 && children.first().unwrap().range.is_subrange(&prev.last().unwrap().range);
84 if !needs_flattening {
85 prev.extend(children);
86 } else {
87 let mut parent = prev.pop().unwrap();
88 for ele in children {
89 assert!(ele.range.is_subrange(&parent.range));
90 let mut cloned = parent.clone();
91 parent.range = TextRange::from_to(parent.range.start(), ele.range.start());
92 cloned.range = TextRange::from_to(ele.range.end(), cloned.range.end());
93 if !parent.range.is_empty() {
94 prev.push(parent);
95 }
96 prev.push(ele);
97 parent = cloned;
98 }
99 if !parent.range.is_empty() {
100 prev.push(parent);
101 }
102 }
103 }
104 };
105 let current = res.last_mut().expect("during DFS traversal, the stack must not be empty");
106
65 let event_range = match &event { 107 let event_range = match &event {
66 WalkEvent::Enter(it) => it.text_range(), 108 WalkEvent::Enter(it) => it.text_range(),
67 WalkEvent::Leave(it) => it.text_range(), 109 WalkEvent::Leave(it) => it.text_range(),
@@ -77,7 +119,7 @@ pub(crate) fn highlight(
77 WalkEvent::Enter(Some(mc)) => { 119 WalkEvent::Enter(Some(mc)) => {
78 current_macro_call = Some(mc.clone()); 120 current_macro_call = Some(mc.clone());
79 if let Some(range) = macro_call_range(&mc) { 121 if let Some(range) = macro_call_range(&mc) {
80 res.push(HighlightedRange { 122 current.push(HighlightedRange {
81 range, 123 range,
82 highlight: HighlightTag::Macro.into(), 124 highlight: HighlightTag::Macro.into(),
83 binding_hash: None, 125 binding_hash: None,
@@ -119,7 +161,7 @@ pub(crate) fn highlight(
119 161
120 if let Some(token) = element.as_token().cloned().and_then(ast::RawString::cast) { 162 if let Some(token) = element.as_token().cloned().and_then(ast::RawString::cast) {
121 let expanded = element_to_highlight.as_token().unwrap().clone(); 163 let expanded = element_to_highlight.as_token().unwrap().clone();
122 if highlight_injection(&mut res, &sema, token, expanded).is_some() { 164 if highlight_injection(current, &sema, token, expanded).is_some() {
123 continue; 165 continue;
124 } 166 }
125 } 167 }
@@ -127,10 +169,17 @@ pub(crate) fn highlight(
127 if let Some((highlight, binding_hash)) = 169 if let Some((highlight, binding_hash)) =
128 highlight_element(&sema, &mut bindings_shadow_count, element_to_highlight) 170 highlight_element(&sema, &mut bindings_shadow_count, element_to_highlight)
129 { 171 {
130 res.push(HighlightedRange { range, highlight, binding_hash }); 172 current.push(HighlightedRange { range, highlight, binding_hash });
131 } 173 }
132 } 174 }
133 175
176 assert_eq!(res.len(), 1, "after DFS traversal, the stack should only contain a single element");
177 let res = res.pop().unwrap();
178 // Check that ranges are sorted and disjoint
179 assert!(res
180 .iter()
181 .zip(res.iter().skip(1))
182 .all(|(left, right)| left.range.end() <= right.range.start()));
134 res 183 res
135} 184}
136 185
diff --git a/crates/ra_ide/src/syntax_highlighting/html.rs b/crates/ra_ide/src/syntax_highlighting/html.rs
index e13766c9d..4496529a1 100644
--- a/crates/ra_ide/src/syntax_highlighting/html.rs
+++ b/crates/ra_ide/src/syntax_highlighting/html.rs
@@ -1,9 +1,9 @@
1//! Renders a bit of code as HTML. 1//! Renders a bit of code as HTML.
2 2
3use ra_db::SourceDatabase; 3use ra_db::SourceDatabase;
4use ra_syntax::AstNode; 4use ra_syntax::{AstNode, TextUnit};
5 5
6use crate::{FileId, HighlightedRange, RootDatabase}; 6use crate::{FileId, RootDatabase};
7 7
8use super::highlight; 8use super::highlight;
9 9
@@ -21,51 +21,35 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
21 ) 21 )
22 } 22 }
23 23
24 let mut ranges = highlight(db, file_id, None); 24 let ranges = highlight(db, file_id, None);
25 ranges.sort_by_key(|it| it.range.start()); 25 let text = parse.tree().syntax().to_string();
26 // quick non-optimal heuristic to intersect token ranges and highlighted ranges 26 let mut prev_pos = TextUnit::from(0);
27 let mut frontier = 0;
28 let mut could_intersect: Vec<&HighlightedRange> = Vec::new();
29
30 let mut buf = String::new(); 27 let mut buf = String::new();
31 buf.push_str(&STYLE); 28 buf.push_str(&STYLE);
32 buf.push_str("<pre><code>"); 29 buf.push_str("<pre><code>");
33 let tokens = parse.tree().syntax().descendants_with_tokens().filter_map(|it| it.into_token()); 30 for range in &ranges {
34 for token in tokens { 31 if range.range.start() > prev_pos {
35 could_intersect.retain(|it| token.text_range().start() <= it.range.end()); 32 let curr = &text[prev_pos.to_usize()..range.range.start().to_usize()];
36 while let Some(r) = ranges.get(frontier) { 33 let text = html_escape(curr);
37 if r.range.start() <= token.text_range().end() {
38 could_intersect.push(r);
39 frontier += 1;
40 } else {
41 break;
42 }
43 }
44 let text = html_escape(&token.text());
45 let ranges = could_intersect
46 .iter()
47 .filter(|it| token.text_range().is_subrange(&it.range))
48 .collect::<Vec<_>>();
49 if ranges.is_empty() {
50 buf.push_str(&text); 34 buf.push_str(&text);
51 } else {
52 let classes = ranges
53 .iter()
54 .map(|it| it.highlight.to_string().replace('.', " "))
55 .collect::<Vec<_>>()
56 .join(" ");
57 let binding_hash = ranges.first().and_then(|x| x.binding_hash);
58 let color = match (rainbow, binding_hash) {
59 (true, Some(hash)) => format!(
60 " data-binding-hash=\"{}\" style=\"color: {};\"",
61 hash,
62 rainbowify(hash)
63 ),
64 _ => "".into(),
65 };
66 buf.push_str(&format!("<span class=\"{}\"{}>{}</span>", classes, color, text));
67 } 35 }
36 let curr = &text[range.range.start().to_usize()..range.range.end().to_usize()];
37
38 let class = range.highlight.to_string().replace('.', " ");
39 let color = match (rainbow, range.binding_hash) {
40 (true, Some(hash)) => {
41 format!(" data-binding-hash=\"{}\" style=\"color: {};\"", hash, rainbowify(hash))
42 }
43 _ => "".into(),
44 };
45 buf.push_str(&format!("<span class=\"{}\"{}>{}</span>", class, color, html_escape(curr)));
46
47 prev_pos = range.range.end();
68 } 48 }
49 // Add the remaining (non-highlighted) text
50 let curr = &text[prev_pos.to_usize()..];
51 let text = html_escape(curr);
52 buf.push_str(&text);
69 buf.push_str("</code></pre>"); 53 buf.push_str("</code></pre>");
70 buf 54 buf
71} 55}
diff --git a/crates/ra_ide/src/syntax_highlighting/tests.rs b/crates/ra_ide/src/syntax_highlighting/tests.rs
index 98c030791..110887c2a 100644
--- a/crates/ra_ide/src/syntax_highlighting/tests.rs
+++ b/crates/ra_ide/src/syntax_highlighting/tests.rs
@@ -131,3 +131,28 @@ fn test_ranges() {
131 131
132 assert_eq!(&highlights[0].highlight.to_string(), "field.declaration"); 132 assert_eq!(&highlights[0].highlight.to_string(), "field.declaration");
133} 133}
134
135#[test]
136fn test_flattening() {
137 let (analysis, file_id) = single_file(
138 r##"
139fn fixture(ra_fixture: &str) {}
140
141fn main() {
142 fixture(r#"
143 trait Foo {
144 fn foo() {
145 println!("2 + 2 = {}", 4);
146 }
147 }"#
148 );
149}"##
150 .trim(),
151 );
152
153 let dst_file = project_dir().join("crates/ra_ide/src/snapshots/highlight_injection.html");
154 let actual_html = &analysis.highlight_as_html(file_id, false).unwrap();
155 let expected_html = &read_text(&dst_file);
156 fs::write(dst_file, &actual_html).unwrap();
157 assert_eq_text!(expected_html, actual_html);
158}