use slices instead of Rc for virtual text

3 files changed, 29 insertions, 23 deletions

diff --git a/helix-core/src/doc_formatter.rs b/helix-core/src/doc_formatter.rs
index c7dc9081..cbe2da3b 100644
--- a/helix-core/src/doc_formatter.rs
+++ b/helix-core/src/doc_formatter.rs
@@ -116,7 +116,7 @@ impl Default for TextFormat {
 #[derive(Debug)]
 pub struct DocumentFormatter<'t> {
     text_fmt: &'t TextFormat,
-    annotations: &'t TextAnnotations,
+    annotations: &'t TextAnnotations<'t>,
 
     /// The visual position at the end of the last yielded word boundary
     visual_pos: Position,
diff --git a/helix-core/src/doc_formatter/test.rs b/helix-core/src/doc_formatter/test.rs
index ac8918bb..d2b6ddc7 100644
--- a/helix-core/src/doc_formatter/test.rs
+++ b/helix-core/src/doc_formatter/test.rs
@@ -1,5 +1,3 @@
-use std::rc::Rc;
-
 use crate::doc_formatter::{DocumentFormatter, TextFormat};
 use crate::text_annotations::{InlineAnnotation, Overlay, TextAnnotations};
 
@@ -105,7 +103,7 @@ fn overlay_text(text: &str, char_pos: usize, softwrap: bool, overlays: &[Overlay
     DocumentFormatter::new_at_prev_checkpoint(
         text.into(),
         &TextFormat::new_test(softwrap),
-        TextAnnotations::default().add_overlay(overlays.into(), None),
+        TextAnnotations::default().add_overlay(overlays, None),
         char_pos,
     )
     .0
@@ -142,7 +140,7 @@ fn annotate_text(text: &str, softwrap: bool, annotations: &[InlineAnnotation]) -
     DocumentFormatter::new_at_prev_checkpoint(
         text.into(),
         &TextFormat::new_test(softwrap),
-        TextAnnotations::default().add_inline_annotations(annotations.into(), None),
+        TextAnnotations::default().add_inline_annotations(annotations, None),
         0,
     )
     .0
@@ -164,15 +162,24 @@ fn annotation() {
         "foo foo foo foo \n.foo foo foo foo \n.foo foo foo  "
     );
 }
+
 #[test]
 fn annotation_and_overlay() {
+    let annotations = [InlineAnnotation {
+        char_idx: 0,
+        text: "fooo".into(),
+    }];
+    let overlay = [Overlay {
+        char_idx: 0,
+        grapheme: "\t".into(),
+    }];
     assert_eq!(
         DocumentFormatter::new_at_prev_checkpoint(
             "bbar".into(),
             &TextFormat::new_test(false),
             TextAnnotations::default()
-                .add_inline_annotations(Rc::new([InlineAnnotation::new(0, "fooo")]), None)
-                .add_overlay(Rc::new([Overlay::new(0, "\t")]), None),
+                .add_inline_annotations(annotations.as_slice(), None)
+                .add_overlay(overlay.as_slice(), None),
             0,
         )
         .0
diff --git a/helix-core/src/text_annotations.rs b/helix-core/src/text_annotations.rs
index 11d19d48..1576914e 100644
--- a/helix-core/src/text_annotations.rs
+++ b/helix-core/src/text_annotations.rs
@@ -1,6 +1,5 @@
 use std::cell::Cell;
 use std::ops::Range;
-use std::rc::Rc;
 
 use crate::syntax::Highlight;
 use crate::Tendril;
@@ -92,23 +91,23 @@ pub struct LineAnnotation {
 }
 
 #[derive(Debug)]
-struct Layer<A, M> {
-    annotations: Rc<[A]>,
+struct Layer<'a, A, M> {
+    annotations: &'a [A],
     current_index: Cell<usize>,
     metadata: M,
 }
 
-impl<A, M: Clone> Clone for Layer<A, M> {
+impl<A, M: Clone> Clone for Layer<'_, A, M> {
     fn clone(&self) -> Self {
         Layer {
-            annotations: self.annotations.clone(),
+            annotations: self.annotations,
             current_index: self.current_index.clone(),
             metadata: self.metadata.clone(),
         }
     }
 }
 
-impl<A, M> Layer<A, M> {
+impl<A, M> Layer<'_, A, M> {
     pub fn reset_pos(&self, char_idx: usize, get_char_idx: impl Fn(&A) -> usize) {
         let new_index = self
             .annotations
@@ -128,8 +127,8 @@ impl<A, M> Layer<A, M> {
     }
 }
 
-impl<A, M> From<(Rc<[A]>, M)> for Layer<A, M> {
-    fn from((annotations, metadata): (Rc<[A]>, M)) -> Layer<A, M> {
+impl<'a, A, M> From<(&'a [A], M)> for Layer<'a, A, M> {
+    fn from((annotations, metadata): (&'a [A], M)) -> Layer<A, M> {
         Layer {
             annotations,
             current_index: Cell::new(0),
@@ -147,13 +146,13 @@ fn reset_pos<A, M>(layers: &[Layer<A, M>], pos: usize, get_pos: impl Fn(&A) -> u
 /// Annotations that change that is displayed when the document is render.
 /// Also commonly called virtual text.
 #[derive(Default, Debug, Clone)]
-pub struct TextAnnotations {
-    inline_annotations: Vec<Layer<InlineAnnotation, Option<Highlight>>>,
-    overlays: Vec<Layer<Overlay, Option<Highlight>>>,
-    line_annotations: Vec<Layer<LineAnnotation, ()>>,
+pub struct TextAnnotations<'a> {
+    inline_annotations: Vec<Layer<'a, InlineAnnotation, Option<Highlight>>>,
+    overlays: Vec<Layer<'a, Overlay, Option<Highlight>>>,
+    line_annotations: Vec<Layer<'a, LineAnnotation, ()>>,
 }
 
-impl TextAnnotations {
+impl<'a> TextAnnotations<'a> {
     /// Prepare the TextAnnotations for iteration starting at char_idx
     pub fn reset_pos(&self, char_idx: usize) {
         reset_pos(&self.inline_annotations, char_idx, |annot| annot.char_idx);
@@ -194,7 +193,7 @@ impl TextAnnotations {
     /// the annotations that belong to the layers added first will be shown first.
     pub fn add_inline_annotations(
         &mut self,
-        layer: Rc<[InlineAnnotation]>,
+        layer: &'a [InlineAnnotation],
         highlight: Option<Highlight>,
     ) -> &mut Self {
         self.inline_annotations.push((layer, highlight).into());
@@ -211,7 +210,7 @@ impl TextAnnotations {
     ///
     /// If multiple layers contain overlay at the same position
     /// the overlay from the layer added last will be show.
-    pub fn add_overlay(&mut self, layer: Rc<[Overlay]>, highlight: Option<Highlight>) -> &mut Self {
+    pub fn add_overlay(&mut self, layer: &'a [Overlay], highlight: Option<Highlight>) -> &mut Self {
         self.overlays.push((layer, highlight).into());
         self
     }
@@ -220,7 +219,7 @@ impl TextAnnotations {
     ///
     /// The line annotations **must be sorted** by their `char_idx`.
     /// Multiple line annotations with the same `char_idx` **are not allowed**.
-    pub fn add_line_annotation(&mut self, layer: Rc<[LineAnnotation]>) -> &mut Self {
+    pub fn add_line_annotation(&mut self, layer: &'a [LineAnnotation]) -> &mut Self {
         self.line_annotations.push((layer, ()).into());
         self
     }