+// 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(())

+// }

+// }