pub use super::highlighter2::*;
// use std::borrow::Cow;
// use std::cell::RefCell;
// use std::sync::atomic::{self, AtomicUsize};
// use std::{fmt, iter, mem, ops};
// use ropey::RopeSlice;
// use tree_sitter::{QueryCaptures, QueryCursor, Tree};
// use crate::{byte_range_to_str, Error, HighlightConfiguration, Syntax, TREE_SITTER_MATCH_LIMIT};
// const CANCELLATION_CHECK_INTERVAL: usize = 100;
// /// Indicates which highlight should be applied to a region of source code.
// #[derive(Copy, Clone, Debug, PartialEq, Eq)]
// pub struct Highlight(pub usize);
// /// Represents a single step in rendering a syntax-highlighted document.
// #[derive(Copy, Clone, Debug)]
// pub enum HighlightEvent {
// Source { start: usize, end: usize },
// HighlightStart(Highlight),
// HighlightEnd,
// }
// #[derive(Debug)]
// struct LocalDef<'a> {
// name: Cow<'a, str>,
// value_range: ops::Range<usize>,
// highlight: Option<Highlight>,
// }
// #[derive(Debug)]
// struct LocalScope<'a> {
// inherits: bool,
// range: ops::Range<usize>,
// local_defs: Vec<LocalDef<'a>>,
// }
// #[derive(Debug)]
// struct HighlightIter<'a> {
// source: RopeSlice<'a>,
// byte_offset: usize,
// cancellation_flag: Option<&'a AtomicUsize>,
// layers: Vec<HighlightIterLayer<'a>>,
// iter_count: usize,
// next_event: Option<HighlightEvent>,
// last_highlight_range: Option<(usize, usize, u32)>,
// }
// struct HighlightIterLayer<'a> {
// _tree: Option<Tree>,
// cursor: QueryCursor,
// captures: RefCell<iter::Peekable<QueryCaptures<'a, 'a, RopeProvider<'a>, &'a [u8]>>>,
// config: &'a HighlightConfiguration,
// highlight_end_stack: Vec<usize>,
// scope_stack: Vec<LocalScope<'a>>,
// depth: u32,
// }
// impl<'a> fmt::Debug for HighlightIterLayer<'a> {
// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// f.debug_struct("HighlightIterLayer").finish()
// }
// }
// impl<'a> HighlightIterLayer<'a> {
// // First, sort scope boundaries by their byte offset in the document. At a
// // given position, emit scope endings before scope beginnings. Finally, emit
// // scope boundaries from deeper layers first.
// fn sort_key(&self) -> Option<(usize, bool, isize)> {
// let depth = -(self.depth as isize);
// let next_start = self
// .captures
// .borrow_mut()
// .peek()
// .map(|(m, i)| m.captures[*i].node.start_byte());
// let next_end = self.highlight_end_stack.last().cloned();
// match (next_start, next_end) {
// (Some(start), Some(end)) => {
// if start < end {
// Some((start, true, depth))
// } else {
// Some((end, false, depth))
// }
// }
// (Some(i), None) => Some((i, true, depth)),
// (None, Some(j)) => Some((j, false, depth)),
// _ => None,
// }
// }
// }
// impl<'a> HighlightIter<'a> {
// fn emit_event(
// &mut self,
// offset: usize,
// event: Option<HighlightEvent>,
// ) -> Option<Result<HighlightEvent, Error>> {
// let result;
// if self.byte_offset < offset {
// result = Some(Ok(HighlightEvent::Source {
// start: self.byte_offset,
// end: offset,
// }));
// self.byte_offset = offset;
// self.next_event = event;
// } else {
// result = event.map(Ok);
// }
// self.sort_layers();
// result
// }
// fn sort_layers(&mut self) {
// while !self.layers.is_empty() {
// if let Some(sort_key) = self.layers[0].sort_key() {
// let mut i = 0;
// while i + 1 < self.layers.len() {
// if let Some(next_offset) = self.layers[i + 1].sort_key() {
// if next_offset < sort_key {
// i += 1;
// continue;
// }
// } else {
// let layer = self.layers.remove(i + 1);
// PARSER.with(|ts_parser| {
// let highlighter = &mut ts_parser.borrow_mut();
// highlighter.cursors.push(layer.cursor);
// });
// }
// break;
// }
// if i > 0 {
// self.layers[0..(i + 1)].rotate_left(1);
// }
// break;
// } else {
// let layer = self.layers.remove(0);
// PARSER.with(|ts_parser| {
// let highlighter = &mut ts_parser.borrow_mut();
// highlighter.cursors.push(layer.cursor);
// });
// }
// }
// }
// }
// impl<'a> Iterator for HighlightIter<'a> {
// type Item = Result<HighlightEvent, Error>;
// fn next(&mut self) -> Option<Self::Item> {
// 'main: loop {
// // If we've already determined the next highlight boundary, just return it.
// if let Some(e) = self.next_event.take() {
// return Some(Ok(e));
// }
// // Periodically check for cancellation, returning `Cancelled` error if the
// // cancellation flag was flipped.
// if let Some(cancellation_flag) = self.cancellation_flag {
// self.iter_count += 1;
// if self.iter_count >= CANCELLATION_CHECK_INTERVAL {
// self.iter_count = 0;
// if cancellation_flag.load(atomic::Ordering::Relaxed) != 0 {
// return Some(Err(Error::Cancelled));
// }
// }
// }
// // If none of the layers have any more highlight boundaries, terminate.
// if self.layers.is_empty() {
// let len = self.source.len_bytes();
// return if self.byte_offset < len {
// let result = Some(Ok(HighlightEvent::Source {
// start: self.byte_offset,
// end: len,
// }));
// self.byte_offset = len;
// result
// } else {
// None
// };
// }
// // Get the next capture from whichever layer has the earliest highlight boundary.
// let range;
// let layer = &mut self.layers[0];
// let captures = layer.captures.get_mut();
// if let Some((next_match, capture_index)) = captures.peek() {
// let next_capture = next_match.captures[*capture_index];
// range = next_capture.node.byte_range();
// // If any previous highlight ends before this node starts, then before
// // processing this capture, emit the source code up until the end of the
// // previous highlight, and an end event for that highlight.
// if let Some(end_byte) = layer.highlight_end_stack.last().cloned() {
// if end_byte <= range.start {
// layer.highlight_end_stack.pop();
// return self.emit_event(end_byte, Some(HighlightEvent::HighlightEnd));
// }
// }
// }
// // If there are no more captures, then emit any remaining highlight end events.
// // And if there are none of those, then just advance to the end of the document.
// else if let Some(end_byte) = layer.highlight_end_stack.last().cloned() {
// layer.highlight_end_stack.pop();
// return self.emit_event(end_byte, Some(HighlightEvent::HighlightEnd));
// } else {
// return self.emit_event(self.source.len_bytes(), None);
// };
// let (mut match_, capture_index) = captures.next().unwrap();
// let mut capture = match_.captures[capture_index];
// // Remove from the local scope stack any local scopes that have already ended.
// while range.start > layer.scope_stack.last().unwrap().range.end {
// layer.scope_stack.pop();
// }
// // If this capture is for tracking local variables, then process the
// // local variable info.
// let mut reference_highlight = None;
// let mut definition_highlight = None;
// while match_.pattern_index < layer.config.highlights_pattern_index {
// // If the node represents a local scope, push a new local scope onto
// // the scope stack.
// if Some(capture.index) == layer.config.local_scope_capture_index {
// definition_highlight = None;
// let mut scope = LocalScope {
// inherits: true,
// range: range.clone(),
// local_defs: Vec::new(),
// };
// for prop in layer.config.query.property_settings(match_.pattern_index) {
// if let "local.scope-inherits" = prop.key.as_ref() {
// scope.inherits =
// prop.value.as_ref().map_or(true, |r| r.as_ref() == "true");
// }
// }
// layer.scope_stack.push(scope);
// }
// // If the node represents a definition, add a new definition to the
// // local scope at the top of the scope stack.
// else if Some(capture.index) == layer.config.local_def_capture_index {
// reference_highlight = None;
// let scope = layer.scope_stack.last_mut().unwrap();
// let mut value_range = 0..0;
// for capture in match_.captures {
// if Some(capture.index) == layer.config.local_def_value_capture_index {
// value_range = capture.node.byte_range();
// }
// }
// let name = byte_range_to_str(range.clone(), self.source);
// scope.local_defs.push(LocalDef {
// name,
// value_range,
// highlight: None,
// });
// definition_highlight = scope.local_defs.last_mut().map(|s| &mut s.highlight);
// }
// // If the node represents a reference, then try to find the corresponding
// // definition in the scope stack.
// else if Some(capture.index) == layer.config.local_ref_capture_index
// && definition_highlight.is_none()
// {
// definition_highlight = None;
// let name = byte_range_to_str(range.clone(), self.source);
// for scope in layer.scope_stack.iter().rev() {
// if let Some(highlight) = scope.local_defs.iter().rev().find_map(|def| {
// if def.name == name && range.start >= def.value_range.end {
// Some(def.highlight)
// } else {
// None
// }
// }) {
// reference_highlight = highlight;
// break;
// }
// if !scope.inherits {
// break;
// }
// }
// }
// // Continue processing any additional matches for the same node.
// if let Some((next_match, next_capture_index)) = captures.peek() {
// let next_capture = next_match.captures[*next_capture_index];
// if next_capture.node == capture.node {
// capture = next_capture;
// match_ = captures.next().unwrap().0;
// continue;
// }
// }
// self.sort_layers();
// continue 'main;
// }
// // Otherwise, this capture must represent a highlight.
// // If this exact range has already been highlighted by an earlier pattern, or by
// // a different layer, then skip over this one.
// if let Some((last_start, last_end, last_depth)) = self.last_highlight_range {
// if range.start == last_start && range.end == last_end && layer.depth < last_depth {
// self.sort_layers();
// continue 'main;
// }
// }
// // If the current node was found to be a local variable, then skip over any
// // highlighting patterns that are disabled for local variables.
// if definition_highlight.is_some() || reference_highlight.is_some() {
// while layer.config.non_local_variable_patterns[match_.pattern_index] {
// match_.remove();
// if let Some((next_match, next_capture_index)) = captures.peek() {
// let next_capture = next_match.captures[*next_capture_index];
// if next_capture.node == capture.node {
// capture = next_capture;
// match_ = captures.next().unwrap().0;
// continue;
// }
// }
// self.sort_layers();
// continue 'main;
// }
// }
// // Once a highlighting pattern is found for the current node, skip over
// // any later highlighting patterns that also match this node. Captures
// // for a given node are ordered by pattern index, so these subsequent
// // captures are guaranteed to be for highlighting, not injections or
// // local variables.
// while let Some((next_match, next_capture_index)) = captures.peek() {
// let next_capture = next_match.captures[*next_capture_index];
// if next_capture.node == capture.node {
// captures.next();
// } else {
// break;
// }
// }
// let current_highlight = layer.config.highlight_indices.load()[capture.index as usize];
// // If this node represents a local definition, then store the current
// // highlight value on the local scope entry representing this node.
// if let Some(definition_highlight) = definition_highlight {
// *definition_highlight = current_highlight;
// }
// // Emit a scope start event and push the node's end position to the stack.
// if let Some(highlight) = reference_highlight.or(current_highlight) {
// self.last_highlight_range = Some((range.start, range.end, layer.depth));
// layer.highlight_end_stack.push(range.end);
// return self
// .emit_event(range.start, Some(HighlightEvent::HighlightStart(highlight)));
// }
// self.sort_layers();
// }
// }
// }
// impl Syntax {
// /// Iterate over the highlighted regions for a given slice of source code.
// pub fn highlight_iter<'a>(
// &'a self,
// source: RopeSlice<'a>,
// range: Option<std::ops::Range<usize>>,
// cancellation_flag: Option<&'a AtomicUsize>,
// ) -> impl Iterator<Item = Result<HighlightEvent, Error>> + 'a {
// let mut layers = self
// .layers
// .iter()
// .filter_map(|(_, layer)| {
// // TODO: if range doesn't overlap layer range, skip it
// // Reuse a cursor from the pool if available.
// let mut cursor = PARSER.with(|ts_parser| {
// let highlighter = &mut ts_parser.borrow_mut();
// highlighter.cursors.pop().unwrap_or_else(QueryCursor::new)
// });
// // The `captures` iterator borrows the `Tree` and the `QueryCursor`, which
// // prevents them from being moved. But both of these values are really just
// // pointers, so it's actually ok to move them.
// let cursor_ref =
// unsafe { mem::transmute::<_, &'static mut QueryCursor>(&mut cursor) };
// // if reusing cursors & no range this resets to whole range
// cursor_ref.set_byte_range(range.clone().unwrap_or(0..usize::MAX));
// cursor_ref.set_match_limit(TREE_SITTER_MATCH_LIMIT);
// let mut captures = cursor_ref
// .captures(
// &layer.config.query,
// layer.tree().root_node(),
// RopeProvider(source),
// )
// .peekable();
// // If there's no captures, skip the layer
// captures.peek()?;
// Some(HighlightIterLayer {
// highlight_end_stack: Vec::new(),
// scope_stack: vec![LocalScope {
// inherits: false,
// range: 0..usize::MAX,
// local_defs: Vec::new(),
// }],
// cursor,
// _tree: None,
// captures: RefCell::new(captures),
// config: layer.config.as_ref(), // TODO: just reuse `layer`
// depth: layer.depth, // TODO: just reuse `layer`
// })
// })
// .collect::<Vec<_>>();
// layers.sort_unstable_by_key(|layer| layer.sort_key());
// let mut result = HighlightIter {
// source,
// byte_offset: range.map_or(0, |r| r.start),
// cancellation_flag,
// iter_count: 0,
// layers,
// next_event: None,
// last_highlight_range: None,
// };
// result.sort_layers();
// result
// }
// }