Make StyledRangeStore Generalized and Sendable

Author: thecoolwinter

Sources/CodeEditSourceEditor/Highlighting/Highlighter.swift

@@ -276,7 +276,7 @@ extension Highlighter: StyledRangeContainerDelegate {
             guard let range = NSRange(location: offset, length: run.length).intersection(range) else {
                 continue
             }
-            storage?.setAttributes(attributeProvider.attributesFor(run.capture), range: range)
+            storage?.setAttributes(attributeProvider.attributesFor(run.value?.capture), range: range)
             offset += range.length
         }
 

Sources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/StyledRangeContainer.swift

@@ -18,7 +18,34 @@ protocol StyledRangeContainerDelegate: AnyObject {
 /// See ``runsIn(range:)`` for more details on how conflicting highlights are handled.
 @MainActor
 class StyledRangeContainer {
-    var _storage: [ProviderID: StyledRangeStore] = [:]
+    struct StyleElement: StyledRangeStoreElement, CustomDebugStringConvertible {
+        var capture: CaptureName?
+        var modifiers: CaptureModifierSet
+
+        var isEmpty: Bool {
+            capture == nil && modifiers.isEmpty
+        }
+
+        func combineLowerPriority(_ other: StyleElement?) -> StyleElement {
+            StyleElement(
+                capture: self.capture ?? other?.capture,
+                modifiers: modifiers.union(other?.modifiers ?? [])
+            )
+        }
+
+        func combineHigherPriority(_ other: StyleElement?) -> StyleElement {
+            StyleElement(
+                capture: other?.capture ?? self.capture,
+                modifiers: modifiers.union(other?.modifiers ?? [])
+            )
+        }
+
+        var debugDescription: String {
+            "\(capture?.stringValue ?? "(empty)"), \(modifiers)"
+        }
+    }
+
+    var _storage: [ProviderID: StyledRangeStore<StyleElement>] = [:]
     weak var delegate: StyledRangeContainerDelegate?
 
     /// Initialize the container with a list of provider identifiers. Each provider is given an id, they should be
@@ -28,13 +55,13 @@ class StyledRangeContainer {
     ///   - providers: An array of identifiers given to providers.
     init(documentLength: Int, providers: [ProviderID]) {
         for provider in providers {
-            _storage[provider] = StyledRangeStore(documentLength: documentLength)
+            _storage[provider] = StyledRangeStore<StyleElement>(documentLength: documentLength)
         }
     }
 
     func addProvider(_ id: ProviderID, documentLength: Int) {
         assert(!_storage.keys.contains(id), "Provider already exists")
-        _storage[id] = StyledRangeStore(documentLength: documentLength)
+        _storage[id] = StyledRangeStore<StyleElement>(documentLength: documentLength)
     }
 
     func removeProvider(_ id: ProviderID) {
@@ -55,10 +82,10 @@ class StyledRangeContainer {
     ///
     /// - Parameter range: The range to query.
     /// - Returns: An array of continuous styled runs.
-    func runsIn(range: NSRange) -> [StyledRangeStoreRun] {
+    func runsIn(range: NSRange) -> [StyledRangeStoreRun<StyleElement>] {
         // Ordered by priority, lower = higher priority.
         var allRuns = _storage.sorted(by: { $0.key < $1.key }).map { $0.value.runs(in: range.intRange) }
-        var runs: [StyledRangeStoreRun] = []
+        var runs: [StyledRangeStoreRun<StyleElement>] = []
 
         var minValue = allRuns.compactMap { $0.last }.enumerated().min(by: { $0.1.length < $1.1.length })
 
@@ -93,8 +120,8 @@ class StyledRangeContainer {
     }
 
     func storageUpdated(replacedContentIn range: Range<Int>, withCount newLength: Int) {
-        _storage.values.forEach {
-            $0.storageUpdated(replacedCharactersIn: range, withCount: newLength)
+        for (key, value) in _storage {
+            _storage[key]?.storageUpdated(replacedCharactersIn: range, withCount: newLength)
         }
     }
 }
@@ -109,11 +136,11 @@ extension StyledRangeContainer: HighlightProviderStateDelegate {
     ///   - rangeToHighlight: The range to apply the highlights to.
     func applyHighlightResult(provider: ProviderID, highlights: [HighlightRange], rangeToHighlight: NSRange) {
         assert(rangeToHighlight != .notFound, "NSNotFound is an invalid highlight range")
-        guard let storage = _storage[provider] else {
+        guard var storage = _storage[provider] else {
             assertionFailure("No storage found for the given provider: \(provider)")
             return
         }
-        var runs: [StyledRangeStoreRun] = []
+        var runs: [StyledRangeStoreRun<StyleElement>] = []
         var lastIndex = rangeToHighlight.lowerBound
 
         for highlight in highlights {
@@ -123,10 +150,9 @@ extension StyledRangeContainer: HighlightProviderStateDelegate {
                 continue // Skip! Overlapping
             }
             runs.append(
-                StyledRangeStoreRun(
+                StyledRangeStoreRun<StyleElement>(
                     length: highlight.range.length,
-                    capture: highlight.capture,
-                    modifiers: highlight.modifiers
+                    value: StyleElement(capture: highlight.capture, modifiers: highlight.modifiers)
                 )
             )
             lastIndex = highlight.range.max
@@ -137,6 +163,7 @@ extension StyledRangeContainer: HighlightProviderStateDelegate {
         }
 
         storage.set(runs: runs, for: rangeToHighlight.intRange)
+        _storage[provider] = storage
         delegate?.styleContainerDidUpdate(in: rangeToHighlight)
     }
 }

Sources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/StyledRangeStore/StyledRangeStoreRun.swift

@@ -16,7 +16,7 @@ extension StyledRangeStore {
     /// rather than the queried one.
     ///
     /// - Parameter range: The range of the item to coalesce around.
-    func coalesceNearby(range: Range<Int>) {
+    mutating func coalesceNearby(range: Range<Int>) {
         var index = findIndex(at: range.lastIndex).index
         if index < _guts.endIndex && _guts.index(after: index) != _guts.endIndex {
             coalesceRunAfter(index: &index)
@@ -30,11 +30,11 @@ extension StyledRangeStore {
     }
 
     /// Check if the run and the run after it are equal, and if so remove the next one and concatenate the two.
-    private func coalesceRunAfter(index: inout Index) {
+    private mutating func coalesceRunAfter(index: inout Index) {
         let thisRun = _guts[index]
         let nextRun = _guts[_guts.index(after: index)]
 
-        if thisRun.styleCompare(nextRun) {
+        if thisRun.compareValue(nextRun) {
             _guts.update(at: &index, by: { $0.length += nextRun.length })
 
             var nextIndex = index

…ngeStore/StyledRangeStore+Coalesce.swift …ngeStore/StyledRangeStore+Coalesce.swiftSources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/StyledRangeStore/StyledRangeStore+Coalesce.swift renamed to Sources/CodeEditSourceEditor/StyledRangeStore/StyledRangeStore+Coalesce.swift Sources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/StyledRangeStore/StyledRangeStore+Coalesce.swift renamed to Sources/CodeEditSourceEditor/StyledRangeStore/StyledRangeStore+Coalesce.swift

@@ -9,18 +9,25 @@ import _RopeModule
 extension StyledRangeStore {
     struct StyledRun {
         var length: Int
-        let capture: CaptureName?
-        let modifiers: CaptureModifierSet
+        let value: Element?
 
         static func empty(length: Int) -> Self {
-            StyledRun(length: length, capture: nil, modifiers: [])
+            StyledRun(length: length, value: nil)
         }
 
         /// Compare two styled ranges by their stored styles.
         /// - Parameter other: The range to compare to.
         /// - Returns: The result of the comparison.
-        func styleCompare(_ other: Self) -> Bool {
-            capture == other.capture && modifiers == other.modifiers
+        func compareValue(_ other: Self) -> Bool {
+            return if let lhs = value, let rhs = other.value {
+                lhs == rhs
+            } else if let lhs = value {
+                lhs.isEmpty
+            } else if let rhs = other.value {
+                rhs.isEmpty
+            } else {
+                true
+            }
         }
     }
 }
@@ -50,7 +57,7 @@ extension StyledRangeStore.StyledRun: RopeElement {
 
     mutating func split(at index: Self.Index) -> Self {
         assert(index >= 0 && index <= length)
-        let tail = Self(length: length - index, capture: capture, modifiers: modifiers)
+        let tail = Self(length: length - index, value: value)
         length = index
         return tail
     }

…geStore/StyledRangeStore+FindIndex.swift …geStore/StyledRangeStore+FindIndex.swiftSources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/StyledRangeStore/StyledRangeStore+FindIndex.swift renamed to Sources/CodeEditSourceEditor/StyledRangeStore/StyledRangeStore+FindIndex.swift Sources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/StyledRangeStore/StyledRangeStore+FindIndex.swift renamed to Sources/CodeEditSourceEditor/StyledRangeStore/StyledRangeStore+FindIndex.swift

@@ -12,10 +12,11 @@ import _RopeModule
 ///
 /// Internally this class uses a `Rope` from the swift-collections package, allowing for efficient updates and
 /// retrievals.
-final class StyledRangeStore {
-    typealias Run = StyledRangeStoreRun
-    typealias Index = Rope<StyledRun>.Index
-    var _guts = Rope<StyledRun>()
+struct StyledRangeStore<Element: StyledRangeStoreElement>: Sendable {
+    typealias Run = StyledRangeStoreRun<Element>
+    typealias RopeType = Rope<StyledRun>
+    typealias Index = RopeType.Index
+    var _guts = RopeType()
 
     var length: Int {
         _guts.count(in: OffsetMetric())
@@ -26,7 +27,7 @@ final class StyledRangeStore {
     private var cache: (range: Range<Int>, runs: [Run])?
 
     init(documentLength: Int) {
-        self._guts = Rope([StyledRun(length: documentLength, capture: nil, modifiers: [])])
+        self._guts = RopeType([StyledRun(length: documentLength, value: nil)])
     }
 
     // MARK: - Core
@@ -48,7 +49,7 @@ final class StyledRangeStore {
 
         while index < _guts.endIndex {
             let run = _guts[index]
-            runs.append(Run(length: run.length - (offset ?? 0), capture: run.capture, modifiers: run.modifiers))
+            runs.append(Run(length: run.length - (offset ?? 0), value: run.value))
 
             index = _guts.index(after: index)
             offset = nil
@@ -57,22 +58,21 @@ final class StyledRangeStore {
         return runs
     }
 
-    /// Sets a capture and modifiers for a range.
+    /// Sets a value for a range.
     /// - Parameters:
-    ///   - capture: The capture to set.
-    ///   - modifiers: The modifiers to set.
+    ///   - value: The value to set for the given range.
     ///   - range: The range to write to.
-    func set(capture: CaptureName, modifiers: CaptureModifierSet, for range: Range<Int>) {
+    mutating func set(value: Element, for range: Range<Int>) {
         assert(range.lowerBound >= 0, "Negative lowerBound")
         assert(range.upperBound <= _guts.count(in: OffsetMetric()), "upperBound outside valid range")
-        set(runs: [Run(length: range.length, capture: capture, modifiers: modifiers)], for: range)
+        set(runs: [Run(length: range.length, value: value)], for: range)
     }
 
     /// Replaces a range in the document with an array of runs.
     /// - Parameters:
     ///   - runs: The runs to insert.
     ///   - range: The range to replace.
-    func set(runs: [Run], for range: Range<Int>) {
+    mutating func set(runs: [Run], for range: Range<Int>) {
         let gutsRange = 0..<_guts.count(in: OffsetMetric())
         if range.clamped(to: gutsRange) != range {
             let upperBound = range.clamped(to: gutsRange).upperBound
@@ -83,7 +83,7 @@ final class StyledRangeStore {
         _guts.replaceSubrange(
             range,
             in: OffsetMetric(),
-            with: runs.map { StyledRun(length: $0.length, capture: $0.capture, modifiers: $0.modifiers) }
+            with: runs.map { StyledRun(length: $0.length, value: $0.value) }
         )
 
         coalesceNearby(range: range)
@@ -95,7 +95,7 @@ final class StyledRangeStore {
 
 extension StyledRangeStore {
     /// Handles keeping the internal storage in sync with the document.
-    func storageUpdated(replacedCharactersIn range: Range<Int>, withCount newLength: Int) {
+    mutating func storageUpdated(replacedCharactersIn range: Range<Int>, withCount newLength: Int) {
         assert(range.lowerBound >= 0, "Negative lowerBound")
         assert(range.upperBound <= _guts.count(in: OffsetMetric()), "upperBound outside valid range")
 

…tore/StyledRangeStore+OffsetMetric.swift …tore/StyledRangeStore+OffsetMetric.swiftSources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/StyledRangeStore/StyledRangeStore+OffsetMetric.swift renamed to Sources/CodeEditSourceEditor/StyledRangeStore/StyledRangeStore+OffsetMetric.swift Sources/CodeEditSourceEditor/Highlighting/StyledRangeContainer/StyledRangeStore/StyledRangeStore+OffsetMetric.swift renamed to Sources/CodeEditSourceEditor/StyledRangeStore/StyledRangeStore+OffsetMetric.swift

@@ -0,0 +1,48 @@
+//
+//  StyledRangeStoreRun.swift
+//  CodeEditSourceEditor
+//
+//  Created by Khan Winter on 11/4/24.
+//
+
+protocol StyledRangeStoreElement: Equatable, Hashable {
+    var isEmpty: Bool { get }
+    func combineLowerPriority(_ other: Self?) -> Self
+    func combineHigherPriority(_ other: Self?) -> Self
+}
+
+/// Consumer-facing value type for the stored values in this container.
+struct StyledRangeStoreRun<Element: StyledRangeStoreElement>: Equatable, Hashable {
+    var length: Int
+    var value: Element?
+
+    static func empty(length: Int) -> Self {
+        StyledRangeStoreRun(length: length, value: nil)
+    }
+
+    var isEmpty: Bool {
+        value?.isEmpty ?? true
+    }
+
+    mutating func combineLowerPriority(_ other: StyledRangeStoreRun) {
+        value = value?.combineLowerPriority(other.value) ?? other.value
+    }
+
+    mutating func combineHigherPriority(_ other: StyledRangeStoreRun) {
+        value = value?.combineHigherPriority(other.value) ?? other.value
+    }
+
+    mutating func subtractLength(_ other: borrowing StyledRangeStoreRun) {
+        self.length -= other.length
+    }
+}
+
+extension StyledRangeStoreRun: CustomDebugStringConvertible {
+    var debugDescription: String {
+        if let value = value as? CustomDebugStringConvertible {
+            "\(length) (\(value.debugDescription))"
+        } else {
+            "\(length) (empty)"
+        }
+    }
+}