// use std::collections::VecDeque;
// use std::mem::replace;
// use std::sync::Arc;
// use ahash::RandomState;
use bitflags::bitflags;
// use hashbrown::raw::RawTable;
// use ropey::RopeSlice;
// use tree_sitter::{Node, Parser, Point, QueryCursor, Range};
// use crate::ropey::RopeProvider;
// use crate::{
// Error, HighlightConfiguration, IncludedChildren, InjectionLanguageMarker, LanguageLayer,
// Syntax, PARSER, TREE_SITTER_MATCH_LIMIT,
// };
bitflags! {
/// Flags that track the status of a layer
/// in the `Sytaxn::update` function
#[derive(Debug)]
pub(crate) struct LayerUpdateFlags : u32{
const MODIFIED = 0b001;
const MOVED = 0b010;
const TOUCHED = 0b100;
}
}
// impl Syntax {
// pub fn update(
// &mut self,
// source: RopeSlice,
// edits: Vec<tree_sitter::InputEdit>,
// injection_callback: impl Fn(&InjectionLanguageMarker) -> Option<Arc<HighlightConfiguration>>,
// ) -> Result<(), Error> {
// let mut queue = VecDeque::new();
// queue.push_back(self.root);
// // This table allows inverse indexing of `layers`.
// // That is by hashing a `Layer` you can find
// // the `LayerId` of an existing equivalent `Layer` in `layers`.
// //
// // It is used to determine if a new layer exists for an injection
// // or if an existing layer needs to be updated.
// let mut layers_table = RawTable::with_capacity(self.layers.len());
// let layers_hasher = RandomState::new();
// // Use the edits to update all layers markers
// fn point_add(a: Point, b: Point) -> Point {
// if b.row > 0 {
// Point::new(a.row.saturating_add(b.row), b.column)
// } else {
// Point::new(0, a.column.saturating_add(b.column))
// }
// }
// fn point_sub(a: Point, b: Point) -> Point {
// if a.row > b.row {
// Point::new(a.row.saturating_sub(b.row), a.column)
// } else {
// Point::new(0, a.column.saturating_sub(b.column))
// }
// }
// for (layer_id, layer) in self.layers.iter_mut() {
// // The root layer always covers the whole range (0..usize::MAX)
// if layer.depth == 0 {
// layer.flags = LayerUpdateFlags::MODIFIED;
// continue;
// }
// if !edits.is_empty() {
// for range in &mut layer.ranges {
// // Roughly based on https://github.com/tree-sitter/tree-sitter/blob/ddeaa0c7f534268b35b4f6cb39b52df082754413/lib/src/subtree.c#L691-L720
// for edit in edits.iter().rev() {
// let is_pure_insertion = edit.old_end_byte == edit.start_byte;
// // if edit is after range, skip
// if edit.start_byte > range.end_byte {
// // TODO: || (is_noop && edit.start_byte == range.end_byte)
// continue;
// }
// // if edit is before range, shift entire range by len
// if edit.old_end_byte < range.start_byte {
// range.start_byte =
// edit.new_end_byte + (range.start_byte - edit.old_end_byte);
// range.start_point = point_add(
// edit.new_end_position,
// point_sub(range.start_point, edit.old_end_position),
// );
// range.end_byte = edit
// .new_end_byte
// .saturating_add(range.end_byte - edit.old_end_byte);
// range.end_point = point_add(
// edit.new_end_position,
// point_sub(range.end_point, edit.old_end_position),
// );
// layer.flags |= LayerUpdateFlags::MOVED;
// }
// // if the edit starts in the space before and extends into the range
// else if edit.start_byte < range.start_byte {
// range.start_byte = edit.new_end_byte;
// range.start_point = edit.new_end_position;
// range.end_byte = range
// .end_byte
// .saturating_sub(edit.old_end_byte)
// .saturating_add(edit.new_end_byte);
// range.end_point = point_add(
// edit.new_end_position,
// point_sub(range.end_point, edit.old_end_position),
// );
// layer.flags = LayerUpdateFlags::MODIFIED;
// }
// // If the edit is an insertion at the start of the tree, shift
// else if edit.start_byte == range.start_byte && is_pure_insertion {
// range.start_byte = edit.new_end_byte;
// range.start_point = edit.new_end_position;
// layer.flags |= LayerUpdateFlags::MOVED;
// } else {
// range.end_byte = range
// .end_byte
// .saturating_sub(edit.old_end_byte)
// .saturating_add(edit.new_end_byte);
// range.end_point = point_add(
// edit.new_end_position,
// point_sub(range.end_point, edit.old_end_position),
// );
// layer.flags = LayerUpdateFlags::MODIFIED;
// }
// }
// }
// }
// let hash = layers_hasher.hash_one(layer);
// // Safety: insert_no_grow is unsafe because it assumes that the table
// // has enough capacity to hold additional elements.
// // This is always the case as we reserved enough capacity above.
// unsafe { layers_table.insert_no_grow(hash, layer_id) };
// }
// PARSER.with(|ts_parser| {
// let ts_parser = &mut ts_parser.borrow_mut();
// ts_parser.parser.set_timeout_micros(1000 * 500); // half a second is pretty generours
// let mut cursor = ts_parser.cursors.pop().unwrap_or_else(QueryCursor::new);
// // TODO: might need to set cursor range
// cursor.set_byte_range(0..usize::MAX);
// cursor.set_match_limit(TREE_SITTER_MATCH_LIMIT);
// let source_slice = source.slice(..);
// while let Some(layer_id) = queue.pop_front() {
// let layer = &mut self.layers[layer_id];
// // Mark the layer as touched
// layer.flags |= LayerUpdateFlags::TOUCHED;
// // If a tree already exists, notify it of changes.
// if let Some(tree) = &mut layer.parse_tree {
// if layer
// .flags
// .intersects(LayerUpdateFlags::MODIFIED | LayerUpdateFlags::MOVED)
// {
// for edit in edits.iter().rev() {
// // Apply the edits in reverse.
// // If we applied them in order then edit 1 would disrupt the positioning of edit 2.
// tree.edit(edit);
// }
// }
// if layer.flags.contains(LayerUpdateFlags::MODIFIED) {
// // Re-parse the tree.
// layer.parse(&mut ts_parser.parser, source)?;
// }
// } else {
// // always parse if this layer has never been parsed before
// layer.parse(&mut ts_parser.parser, source)?;
// }
// // Switch to an immutable borrow.
// let layer = &self.layers[layer_id];
// // Process injections.
// let matches = cursor.matches(
// &layer.config.injections_query,
// layer.tree().root_node(),
// RopeProvider(source_slice),
// );
// let mut combined_injections = vec![
// (None, Vec::new(), IncludedChildren::default());
// layer.config.combined_injections_patterns.len()
// ];
// let mut injections = Vec::new();
// let mut last_injection_end = 0;
// for mat in matches {
// let (injection_capture, content_node, included_children) = layer
// .config
// .injection_for_match(&layer.config.injections_query, &mat, source_slice);
// // in case this is a combined injection save it for more processing later
// if let Some(combined_injection_idx) = layer
// .config
// .combined_injections_patterns
// .iter()
// .position(|&pattern| pattern == mat.pattern_index)
// {
// let entry = &mut combined_injections[combined_injection_idx];
// if injection_capture.is_some() {
// entry.0 = injection_capture;
// }
// if let Some(content_node) = content_node {
// if content_node.start_byte() >= last_injection_end {
// entry.1.push(content_node);
// last_injection_end = content_node.end_byte();
// }
// }
// entry.2 = included_children;
// continue;
// }
// // Explicitly remove this match so that none of its other captures will remain
// // in the stream of captures.
// mat.remove();
// // If a language is found with the given name, then add a new language layer
// // to the highlighted document.
// if let (Some(injection_capture), Some(content_node)) =
// (injection_capture, content_node)
// {
// if let Some(config) = (injection_callback)(&injection_capture) {
// let ranges =
// intersect_ranges(&layer.ranges, &[content_node], included_children);
// if !ranges.is_empty() {
// if content_node.start_byte() < last_injection_end {
// continue;
// }
// last_injection_end = content_node.end_byte();
// injections.push((config, ranges));
// }
// }
// }
// }
// for (lang_name, content_nodes, included_children) in combined_injections {
// if let (Some(lang_name), false) = (lang_name, content_nodes.is_empty()) {
// if let Some(config) = (injection_callback)(&lang_name) {
// let ranges =
// intersect_ranges(&layer.ranges, &content_nodes, included_children);
// if !ranges.is_empty() {
// injections.push((config, ranges));
// }
// }
// }
// }
// let depth = layer.depth + 1;
// // TODO: can't inline this since matches borrows self.layers
// for (config, ranges) in injections {
// let parent = Some(layer_id);
// let new_layer = LanguageLayer {
// parse_tree: None,
// config,
// depth,
// ranges,
// flags: LayerUpdateFlags::empty(),
// parent: None,
// };
// // Find an identical existing layer
// let layer = layers_table
// .get(layers_hasher.hash_one(&new_layer), |&it| {
// self.layers[it] == new_layer
// })
// .copied();
// // ...or insert a new one.
// let layer_id = layer.unwrap_or_else(|| self.layers.insert(new_layer));
// self.layers[layer_id].parent = parent;
// queue.push_back(layer_id);
// }
// // TODO: pre-process local scopes at this time, rather than highlight?
// // would solve problems with locals not working across boundaries
// }
// // Return the cursor back in the pool.
// ts_parser.cursors.push(cursor);
// // Reset all `LayerUpdateFlags` and remove all untouched layers
// self.layers.retain(|_, layer| {
// replace(&mut layer.flags, LayerUpdateFlags::empty())
// .contains(LayerUpdateFlags::TOUCHED)
// });
// Ok(())
// })
// }
// }
// /// Compute the ranges that should be included when parsing an injection.
// /// This takes into account three things:
// /// * `parent_ranges` - The ranges must all fall within the *current* layer's ranges.
// /// * `nodes` - Every injection takes place within a set of nodes. The injection ranges
// /// are the ranges of those nodes.
// /// * `includes_children` - For some injections, the content nodes' children should be
// /// excluded from the nested document, so that only the content nodes' *own* content
// /// is reparsed. For other injections, the content nodes' entire ranges should be
// /// reparsed, including the ranges of their children.
// fn intersect_ranges(
// parent_ranges: &[Range],
// nodes: &[Node],
// included_children: IncludedChildren,
// ) -> Vec<Range> {
// let mut cursor = nodes[0].walk();
// let mut result = Vec::new();
// let mut parent_range_iter = parent_ranges.iter();
// let mut parent_range = parent_range_iter
// .next()
// .expect("Layers should only be constructed with non-empty ranges vectors");
// for node in nodes.iter() {
// let mut preceding_range = Range {
// start_byte: 0,
// start_point: Point::new(0, 0),
// end_byte: node.start_byte(),
// end_point: node.start_position(),
// };
// let following_range = Range {
// start_byte: node.end_byte(),
// start_point: node.end_position(),
// end_byte: usize::MAX,
// end_point: Point::new(usize::MAX, usize::MAX),
// };
// for excluded_range in node
// .children(&mut cursor)
// .filter_map(|child| match included_children {
// IncludedChildren::None => Some(child.range()),
// IncludedChildren::All => None,
// IncludedChildren::Unnamed => {
// if child.is_named() {
// Some(child.range())
// } else {
// None
// }
// }
// })
// .chain([following_range].iter().cloned())
// {
// let mut range = Range {
// start_byte: preceding_range.end_byte,
// start_point: preceding_range.end_point,
// end_byte: excluded_range.start_byte,
// end_point: excluded_range.start_point,
// };
// preceding_range = excluded_range;
// if range.end_byte < parent_range.start_byte {
// continue;
// }
// while parent_range.start_byte <= range.end_byte {
// if parent_range.end_byte > range.start_byte {
// if range.start_byte < parent_range.start_byte {
// range.start_byte = parent_range.start_byte;
// range.start_point = parent_range.start_point;
// }
// if parent_range.end_byte < range.end_byte {
// if range.start_byte < parent_range.end_byte {
// result.push(Range {
// start_byte: range.start_byte,
// start_point: range.start_point,
// end_byte: parent_range.end_byte,
// end_point: parent_range.end_point,
// });
// }
// range.start_byte = parent_range.end_byte;
// range.start_point = parent_range.end_point;
// } else {
// if range.start_byte < range.end_byte {
// result.push(range);
// }
// break;
// }
// }
// if let Some(next_range) = parent_range_iter.next() {
// parent_range = next_range;
// } else {
// return result;
// }
// }
// }
// }
// result
// }
// impl LanguageLayer {
// fn parse(&mut self, parser: &mut Parser, source: RopeSlice) -> Result<(), Error> {
// parser
// .set_included_ranges(&self.ranges)
// .map_err(|_| Error::InvalidRanges)?;
// parser
// .set_language(&self.config.language)
// .map_err(|_| Error::InvalidLanguage)?;
// // unsafe { syntax.parser.set_cancellation_flag(cancellation_flag) };
// let tree = parser
// .parse_with(
// &mut |byte, _| {
// if byte <= source.len_bytes() {
// let (chunk, start_byte, _, _) = source.chunk_at_byte(byte);
// &chunk.as_bytes()[byte - start_byte..]
// } else {
// // out of range
// &[]
// }
// },
// self.parse_tree.as_ref(),
// )
// .ok_or(Error::Cancelled)?;
// // unsafe { ts_parser.parser.set_cancellation_flag(None) };
// self.parse_tree = Some(tree);
// Ok(())
// }
// }