git.iko.soy/helix
on master help sign in
syntax: Hide the TSParser internally, borrowing when needed.
3445abfBlaž Hrastnik
helix-core/src/syntax.rs+94−79
compare with master
unifiedsplit
@@ -234,7 +234,6 @@ impl Syntax {
234 /// Iterate over the highlighted regions for a given slice of source code.
234 /// Iterate over the highlighted regions for a given slice of source code.
235 pub fn highlight_iter<'a>(
235 pub fn highlight_iter<'a>(
236 &self,
236 &self,
237− ts_parser: &'a mut TSParser,
238 source: &'a [u8],
237 source: &'a [u8],
239 range: Option<std::ops::Range<usize>>,
238 range: Option<std::ops::Range<usize>>,
240 cancellation_flag: Option<&'a AtomicUsize>,
239 cancellation_flag: Option<&'a AtomicUsize>,
@@ -288,7 +287,6 @@ impl Syntax {
288 byte_offset: range.map(|r| r.start).unwrap_or(0), // TODO: simplify
287 byte_offset: range.map(|r| r.start).unwrap_or(0), // TODO: simplify
289 injection_callback,
288 injection_callback,
290 cancellation_flag,
289 cancellation_flag,
291− highlighter: ts_parser,
292 iter_count: 0,
290 iter_count: 0,
293 layers: vec![layer],
291 layers: vec![layer],
294 next_event: None,
292 next_event: None,
@@ -659,7 +657,6 @@ where
659{
657{
660 source: &'a [u8],
658 source: &'a [u8],
661 byte_offset: usize,
659 byte_offset: usize,
662− highlighter: &'a mut TSParser,
663 injection_callback: F,
660 injection_callback: F,
664 cancellation_flag: Option<&'a AtomicUsize>,
661 cancellation_flag: Option<&'a AtomicUsize>,
665 layers: Vec<HighlightIterLayer<'a>>,
662 layers: Vec<HighlightIterLayer<'a>>,
@@ -846,7 +843,6 @@ impl<'a> HighlightIterLayer<'a> {
846 /// added to the returned vector.
843 /// added to the returned vector.
847 fn new<F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a>(
844 fn new<F: FnMut(&str) -> Option<&'a HighlightConfiguration> + 'a>(
848 source: &'a [u8],
845 source: &'a [u8],
849− highlighter: &mut TSParser,
850 cancellation_flag: Option<&'a AtomicUsize>,
846 cancellation_flag: Option<&'a AtomicUsize>,
851 injection_callback: &mut F,
847 injection_callback: &mut F,
852 mut config: &'a HighlightConfiguration,
848 mut config: &'a HighlightConfiguration,
@@ -858,86 +854,103 @@ impl<'a> HighlightIterLayer<'a> {
858 loop {
854 loop {
859 // --> Tree parsing part
855 // --> Tree parsing part
860
856
857+ PARSER.with(|ts_parser| {
858+ let highlighter = &mut ts_parser.borrow_mut();
859+
861− if highlighter.parser.set_included_ranges(&ranges).is_ok() {
860+ if highlighter.parser.set_included_ranges(&ranges).is_ok() {
862− highlighter
861+ highlighter
863− .parser
862+ .parser
864− .set_language(config.language)
863+ .set_language(config.language)
865− .map_err(|_| Error::InvalidLanguage)?;
864+ .map_err(|_| Error::InvalidLanguage)?;
866−
865+
867− unsafe { highlighter.parser.set_cancellation_flag(cancellation_flag) };
866+ unsafe { highlighter.parser.set_cancellation_flag(cancellation_flag) };
868− let tree = highlighter
867+ let tree = highlighter
869− .parser
868+ .parser
870− .parse(source, None)
869+ .parse(source, None)
871− .ok_or(Error::Cancelled)?;
870+ .ok_or(Error::Cancelled)?;
872− unsafe { highlighter.parser.set_cancellation_flag(None) };
871+ unsafe { highlighter.parser.set_cancellation_flag(None) };
873− let mut cursor = highlighter.cursors.pop().unwrap_or_else(QueryCursor::new);
872+ let mut cursor = highlighter.cursors.pop().unwrap_or_else(QueryCursor::new);
874−
873+
875− // Process combined injections.
874+ // Process combined injections.
876− if let Some(combined_injections_query) = &config.combined_injections_query {
875+ if let Some(combined_injections_query) = &config.combined_injections_query {
877− let mut injections_by_pattern_index =
876+ let mut injections_by_pattern_index = vec![
877+ (None, Vec::new(), false);
878− vec![(None, Vec::new(), false); combined_injections_query.pattern_count()];
878+ combined_injections_query
879+ .pattern_count()
880+ ];
879− let matches =
881+ let matches = cursor.matches(
880− cursor.matches(combined_injections_query, tree.root_node(), |n: Node| {
882+ combined_injections_query,
883+ tree.root_node(),
881− &source[n.byte_range()]
884+ |n: Node| &source[n.byte_range()],
882− });
885+ );
883− for mat in matches {
886+ for mat in matches {
884− let entry = &mut injections_by_pattern_index[mat.pattern_index];
887+ let entry = &mut injections_by_pattern_index[mat.pattern_index];
885− let (language_name, content_node, include_children) =
888+ let (language_name, content_node, include_children) =
886− injection_for_match(config, combined_injections_query, &mat, source);
889+ injection_for_match(
887− if language_name.is_some() {
890+ config,
888− entry.0 = language_name;
891+ combined_injections_query,
889− }
892+ &mat,
890− if let Some(content_node) = content_node {
893+ source,
891− entry.1.push(content_node);
892− }
893− entry.2 = include_children;
894− }
895− for (lang_name, content_nodes, includes_children) in injections_by_pattern_index
896− {
897− if let (Some(lang_name), false) = (lang_name, content_nodes.is_empty()) {
898− if let Some(next_config) = (injection_callback)(lang_name) {
899− let ranges = Self::intersect_ranges(
900− &ranges,
901− &content_nodes,
902− includes_children,
903 );
894 );
895+ if language_name.is_some() {
896+ entry.0 = language_name;
897+ }
898+ if let Some(content_node) = content_node {
899+ entry.1.push(content_node);
900+ }
901+ entry.2 = include_children;
902+ }
903+ for (lang_name, content_nodes, includes_children) in
904+ injections_by_pattern_index
905+ {
906+ if let (Some(lang_name), false) = (lang_name, content_nodes.is_empty())
907+ {
908+ if let Some(next_config) = (injection_callback)(lang_name) {
909+ let ranges = Self::intersect_ranges(
910+ &ranges,
911+ &content_nodes,
912+ includes_children,
913+ );
904− if !ranges.is_empty() {
914+ if !ranges.is_empty() {
905− queue.push((next_config, depth + 1, ranges));
915+ queue.push((next_config, depth + 1, ranges));
916+ }
906 }
917 }
907 }
918 }
908 }
919 }
909 }
920 }
921+
922+ // --> Highlighting query part
923+
924+ // The `captures` iterator borrows the `Tree` and the `QueryCursor`, which
925+ // prevents them from being moved. But both of these values are really just
926+ // pointers, so it's actually ok to move them.
927+ let tree_ref = unsafe { mem::transmute::<_, &'static Tree>(&tree) };
928+ let cursor_ref =
929+ unsafe { mem::transmute::<_, &'static mut QueryCursor>(&mut cursor) };
930+ let captures = cursor_ref
931+ .captures(&config.query, tree_ref.root_node(), move |n: Node| {
932+ &source[n.byte_range()]
933+ })
934+ .peekable();
935+
936+ result.push(HighlightIterLayer {
937+ highlight_end_stack: Vec::new(),
938+ scope_stack: vec![LocalScope {
939+ inherits: false,
940+ range: 0..usize::MAX,
941+ local_defs: Vec::new(),
942+ }],
943+ cursor,
944+ depth,
945+ _tree: Some(tree),
946+ captures,
947+ config,
948+ ranges,
949+ });
910 }
950 }
911
951
912− // --> Highlighting query part
952+ Ok(()) // so we can use the try operator
913−
914− // The `captures` iterator borrows the `Tree` and the `QueryCursor`, which
915− // prevents them from being moved. But both of these values are really just
916− // pointers, so it's actually ok to move them.
917− let tree_ref = unsafe { mem::transmute::<_, &'static Tree>(&tree) };
918− let cursor_ref =
919− unsafe { mem::transmute::<_, &'static mut QueryCursor>(&mut cursor) };
920− let captures = cursor_ref
921− .captures(&config.query, tree_ref.root_node(), move |n: Node| {
922− &source[n.byte_range()]
923− })
924− .peekable();
925−
926− result.push(HighlightIterLayer {
927− highlight_end_stack: Vec::new(),
928− scope_stack: vec![LocalScope {
929− inherits: false,
930− range: 0..usize::MAX,
931− local_defs: Vec::new(),
932− }],
933− cursor,
934− depth,
935− _tree: Some(tree),
936− captures,
937− config,
938− ranges,
939− });
940− }
953+ })?;
941
954
942 if queue.is_empty() {
955 if queue.is_empty() {
943 break;
956 break;
@@ -1114,7 +1127,10 @@ where
1114 break;
1127 break;
1115 } else {
1128 } else {
1116 let layer = self.layers.remove(0);
1129 let layer = self.layers.remove(0);
1130+ PARSER.with(|ts_parser| {
1131+ let highlighter = &mut ts_parser.borrow_mut();
1117− self.highlighter.cursors.push(layer.cursor);
1132+ highlighter.cursors.push(layer.cursor);
1133+ });
1118 }
1134 }
1119 }
1135 }
1120 }
1136 }
@@ -1228,7 +1244,6 @@ where
1228 if !ranges.is_empty() {
1244 if !ranges.is_empty() {
1229 match HighlightIterLayer::new(
1245 match HighlightIterLayer::new(
1230 self.source,
1246 self.source,
1231− self.highlighter,
1232 self.cancellation_flag,
1247 self.cancellation_flag,
1233 &mut self.injection_callback,
1248 &mut self.injection_callback,
1234 config,
1249 config,
helix-term/src/ui/editor.rs+4−12
@@ -92,18 +92,10 @@ impl EditorView {
92 // TODO: only recalculate when state.doc is actually modified
92 // TODO: only recalculate when state.doc is actually modified
93 let highlights: Vec<_> = match &view.doc.syntax {
93 let highlights: Vec<_> = match &view.doc.syntax {
94 Some(syntax) => {
94 Some(syntax) => {
95− syntax::PARSER.with(|ts_parser| {
95+ syntax
96− syntax
97− .highlight_iter(
98− &mut ts_parser.borrow_mut(),
99− source_code.as_bytes(),
96+ .highlight_iter(source_code.as_bytes(), Some(range), None, |_| None)
100− Some(range),
101− None,
102− |_| None,
103− )
104− .unwrap()
97+ .unwrap()
105− .collect() // TODO: we collect here to avoid holding the lock, fix later
98+ .collect() // TODO: we collect here to avoid holding the lock, fix later
106− })
107 }
99 }
108 None => vec![Ok(HighlightEvent::Source {
100 None => vec![Ok(HighlightEvent::Source {
109 start: range.start,
101 start: range.start,