@@ -459,9 +459,10 @@ impl Syntax {
459459 source: &Rope,
460460 changeset: &ChangeSet,
461461 ) -> Result<(), Error> {
462− use std::collections::VecDeque;
462+ use std::collections::{HashSet, VecDeque};
463463 let mut queue = VecDeque::new();
464− // let source = source.slice(..);
464+ queue.push_back(self.root);
465+
465466 let injection_callback = |language: &str| {
466467 self.loader
467468 .language_configuration_for_injection_string(language)
@@ -470,21 +471,26 @@ impl Syntax {
470471 })
471472 };
472473
473− queue.push_back(self.root);
474−
475474 // HAXX: for now, clear all layers except root so they get re-parsed
476475 self.layers.retain(|id, _| id == self.root);
477476
478− // Workaround for Syntax::new() with empty changeset
479− if !changeset.is_empty() {
480− // TODO: do this in a recursive way
481− // Notify the tree about all the changes
482− let edits = generate_edits(old_source.slice(..), changeset);
483− let tree = self.layers[self.root].tree.as_mut().unwrap();
484− for edit in edits.iter().rev() {
485− // apply the edits in reverse. If we applied them in order then edit 1 would disrupt
486− // the positioning of edit 2
487− tree.edit(edit);
477+ // Convert the changeset into tree sitter edits.
478+ let edits = generate_edits(old_source, changeset);
479+
480+ // TODO: use the edits to update all layers markers
481+ if !edits.is_empty() {
482+ for layer in &mut self.layers.values_mut() {
483+ for range in &mut layer.ranges {
484+ for edit in &edits {
485+ // if edit is after range, skip
486+ if edit.start_byte > range.end_byte {
487+ continue;
488+ }
489+
490+ // if edit is before range, shift entire range by len
491+ if edit.old_end_byte < range.start_byte {}
492+ }
493+ }
488494 }
489495 }
490496
@@ -495,10 +501,26 @@ impl Syntax {
495501
496502 let source_slice = source.slice(..);
497503
504+ let mut touched = HashSet::new();
505+
506+ // TODO: we should be able to avoid editing & parsing layers with ranges earlier in the document before the edit
507+
498508 while let Some(layer_id) = queue.pop_front() {
509+ let layer = &mut self.layers[layer_id];
510+
511+ // If a tree already exists, notify it of changes.
512+ if let Some(tree) = &mut layer.tree {
513+ for edit in edits.iter().rev() {
514+ // Apply the edits in reverse.
515+ // If we applied them in order then edit 1 would disrupt the positioning of edit 2.
516+ tree.edit(edit);
517+ }
518+ }
519+
499520 // Re-parse the tree.
500− self.layers[layer_id].parse(ts_parser, source)?;
521+ layer.parse(ts_parser, source)?;
501522
523+ // Switch to an immutable borrow.
502524 let layer = &self.layers[layer_id];
503525
504526 // Process injections.
@@ -529,7 +551,6 @@ impl Syntax {
529551 intersect_ranges(&layer.ranges, &[content_node], include_children);
530552
531553 if !ranges.is_empty() {
532− log::info!("{} {:?}", language_name, ranges);
533554 injections.push((config, ranges));
534555 }
535556 }
@@ -581,28 +602,46 @@ impl Syntax {
581602 let depth = layer.depth + 1;
582603 // TODO: can't inline this since matches borrows self.layers
583604 for (config, ranges) in injections {
584− let layer_id = self.layers.insert(LanguageLayer {
585− tree: None,
586− config,
587− depth,
588− ranges,
605+ // Find an existing layer
606+ let layer = self
607+ .layers
608+ .iter_mut()
609+ .find(|(_, layer)| {
610+ layer.depth == depth && // TODO: track parent id instead
611+ layer.config.language == config.language && layer.ranges == ranges
612+ })
613+ .map(|(id, _layer)| id);
614+
615+ // ...or insert a new one.
616+ let layer_id = layer.unwrap_or_else(|| {
617+ self.layers.insert(LanguageLayer {
618+ tree: None,
619+ config,
620+ depth,
621+ ranges,
622+ })
589623 });
624+
590625 queue.push_back(layer_id);
591626 }
627+
628+ // Mark the layer as touched
629+ touched.insert(layer_id);
630+
631+ // TODO: pre-process local scopes at this time, rather than highlight?
632+ // would solve problems with locals not working across boundaries
592633 }
593634
594635 // Return the cursor back in the pool.
595636 ts_parser.cursors.push(cursor);
596637
597− Ok(()) // so we can use the try operator
598− })?;
638+ // Remove all untouched layers
639+ self.layers.retain(|id, _| touched.contains(&id));
599640
600− Ok(())
641+ Ok(())
642+ })
601643 }
602644
603− // fn buffer_changed -> call layer.update(range, new_text) on root layer and then all marker layers
604− // call this on transaction.apply() -> buffer_changed(changes)
605−
606645 pub fn tree(&self) -> &Tree {
607646 self.layers[self.root].tree()
608647 }
@@ -619,8 +658,6 @@ impl Syntax {
619658 //
620659 // layer update:
621660 // if range.len = 0 then remove the layer
622− // for change in changes { tree.edit(change) }
623− // tree = parser.parse(.., tree, ..)
624661 // calculate affected range and update injections
625662 // injection update:
626663 // look for existing injections
@@ -776,7 +813,7 @@ impl LanguageLayer {
776813}
777814
778815pub(crate) fn generate_edits(
779− old_text: RopeSlice,
816+ old_text: &Rope,
780817 changeset: &ChangeSet,
781818) -> Vec<tree_sitter::InputEdit> {
782819 use Operation::*;
@@ -784,11 +821,15 @@ pub(crate) fn generate_edits(
784821
785822 let mut edits = Vec::new();
786823
824+ if changeset.changes.is_empty() {
825+ return edits;
826+ }
827+
787828 let mut iter = changeset.changes.iter().peekable();
788829
789830 // TODO; this is a lot easier with Change instead of Operation.
790831
791− fn point_at_pos(text: RopeSlice, pos: usize) -> (usize, Point) {
832+ fn point_at_pos(text: &Rope, pos: usize) -> (usize, Point) {
792833 let byte = text.char_to_byte(pos); // <- attempted to index past end
793834 let line = text.char_to_line(pos);
794835 let line_start_byte = text.line_to_byte(line);
@@ -1816,7 +1857,7 @@ mod test {
18161857 &doc,
18171858 vec![(6, 11, Some("test".into())), (12, 17, None)].into_iter(),
18181859 );
1819− let edits = generate_edits(doc.slice(..), transaction.changes());
1860+ let edits = generate_edits(&doc, transaction.changes());
18201861 // transaction.apply(&mut state);
18211862
18221863 assert_eq!(
@@ -1845,7 +1886,7 @@ mod test {
18451886 let mut doc = Rope::from("fn test() {}");
18461887 let transaction =
18471888 Transaction::change(&doc, vec![(8, 8, Some("a: u32".into()))].into_iter());
1848− let edits = generate_edits(doc.slice(..), transaction.changes());
1889+ let edits = generate_edits(&doc, transaction.changes());
18491890 transaction.apply(&mut doc);
18501891
18511892 assert_eq!(doc, "fn test(a: u32) {}");