Move to Swift Concurrency with Async Streams

Author: thecoolwinter

Sources/CodeEditSourceEditor/Controller/TextViewController+Lifecycle.swift

@@ -26,7 +26,7 @@ extension TextViewController {
             font: font.rulerFont,
             textColor: theme.text.color.withAlphaComponent(0.35),
             selectedTextColor: theme.text.color,
-            textView: textView,
+            controller: self,
             delegate: self
         )
         gutterView.updateWidthIfNeeded()

Sources/CodeEditSourceEditor/Gutter/GutterView.swift

@@ -137,16 +137,16 @@ public class GutterView: NSView {
         font: NSFont,
         textColor: NSColor,
         selectedTextColor: NSColor?,
-        textView: TextView,
+        controller: TextViewController,
         delegate: GutterViewDelegate? = nil
     ) {
         self.font = font
         self.textColor = textColor
         self.selectedLineTextColor = selectedTextColor ?? .secondaryLabelColor
-        self.textView = textView
+        self.textView = controller.textView
         self.delegate = delegate
 
-        foldingRibbon = FoldingRibbonView(textView: textView, foldProvider: nil)
+        foldingRibbon = FoldingRibbonView(controller: controller, foldProvider: nil)
 
         super.init(frame: .zero)
         clipsToBounds = true

Sources/CodeEditSourceEditor/LineFolding/FoldProviders/IndentationLineFoldProvider.swift

@@ -6,8 +6,19 @@
 //
 
 import AppKit
+import TextStory
 import CodeEditTextView
 
+extension NSString: @retroactive TextStoring {
+    public func substring(from range: NSRange) -> String? {
+        self.substring(with: range)
+    }
+    
+    public func applyMutation(_ mutation: TextMutation) {
+        self.replacingCharacters(in: mutation.range, with: mutation.string)
+    }
+}
+
 final class IndentationLineFoldProvider: LineFoldProvider {
     func indentLevelAtLine(substring: NSString) -> Int? {
         for idx in 0..<substring.length {
@@ -23,18 +34,24 @@ final class IndentationLineFoldProvider: LineFoldProvider {
         lineNumber: Int,
         lineRange: NSRange,
         previousDepth: Int,
-        text: NSTextStorage
+        controller: TextViewController
     ) -> [LineFoldProviderLineInfo] {
+        let text = controller.textView.textStorage.string as NSString
         guard let leadingIndent = text.leadingRange(in: lineRange, within: .whitespacesWithoutNewlines)?.length,
               leadingIndent != lineRange.length else {
             return []
         }
-
         var foldIndicators: [LineFoldProviderLineInfo] = []
 
-        if leadingIndent < previousDepth {
+        let leadingDepth = leadingIndent / controller.indentOption.charCount
+        if leadingDepth < previousDepth {
             // End the fold at the start of whitespace
-            foldIndicators.append(.endFold(rangeEnd: lineRange.location + leadingIndent, newDepth: leadingIndent))
+            foldIndicators.append(
+                .endFold(
+                    rangeEnd: lineRange.location + leadingIndent,
+                    newDepth: leadingDepth
+                )
+            )
         }
 
         // Check if the next line has more indent
@@ -45,7 +62,12 @@ final class IndentationLineFoldProvider: LineFoldProvider {
         }
 
         if nextIndent > leadingIndent, let trailingWhitespace = text.trailingWhitespaceRange(in: lineRange) {
-            foldIndicators.append(.startFold(rangeStart: trailingWhitespace.location, newDepth: nextIndent))
+            foldIndicators.append(
+                .startFold(
+                    rangeStart: trailingWhitespace.location,
+                    newDepth: nextIndent / controller.indentOption.charCount
+                )
+            )
         }
 
         return foldIndicators

Sources/CodeEditSourceEditor/LineFolding/FoldProviders/LineFoldProvider.swift

@@ -36,6 +36,6 @@ protocol LineFoldProvider: AnyObject {
         lineNumber: Int,
         lineRange: NSRange,
         previousDepth: Int,
-        text: NSTextStorage
+        controller: TextViewController
     ) -> [LineFoldProviderLineInfo]
 }

Sources/CodeEditSourceEditor/LineFolding/Model/LineFoldCalculator.swift

@@ -14,132 +14,140 @@ import Combine
 /// `LineFoldCalculator` observes text edits and rebuilds fold regions asynchronously.
 /// Fold information is emitted via `rangesPublisher`.
 /// Notify the calculator it should re-calculate
-class LineFoldCalculator {
+actor LineFoldCalculator {
     weak var foldProvider: LineFoldProvider?
-    weak var textView: TextView?
+    weak var controller: TextViewController?
 
-    var rangesPublisher = CurrentValueSubject<LineFoldStorage, Never>(.init(documentLength: 0))
+    var valueStream: AsyncStream<LineFoldStorage>
 
-    private let workQueue = DispatchQueue.global(qos: .default)
+    private var valueStreamContinuation: AsyncStream<LineFoldStorage>.Continuation
+    private var textChangedTask: Task<Void, Never>?
 
-    var textChangedReceiver = PassthroughSubject<(NSRange, Int), Never>()
-    private var textChangedCancellable: AnyCancellable?
-
-    init(foldProvider: LineFoldProvider?, textView: TextView) {
+    init(
+        foldProvider: LineFoldProvider?,
+        controller: TextViewController,
+        textChangedStream: AsyncStream<(NSRange, Int)>
+    ) {
         self.foldProvider = foldProvider
-        self.textView = textView
+        self.controller = controller
+        (valueStream, valueStreamContinuation) = AsyncStream<LineFoldStorage>.makeStream()
+        Task { await listenToTextChanges(textChangedStream: textChangedStream) }
+    }
+
+    deinit {
+        textChangedTask?.cancel()
+    }
 
-        textChangedCancellable = textChangedReceiver
-            .throttle(for: 0.1, scheduler: RunLoop.main, latest: true)
-            .sink { edit in
-                self.buildFoldsForDocument(afterEditIn: edit.0, delta: edit.1)
+    private func listenToTextChanges(textChangedStream: AsyncStream<(NSRange, Int)>) {
+        textChangedTask = Task {
+            for await edit in textChangedStream {
+                await buildFoldsForDocument(afterEditIn: edit.0, delta: edit.1)
             }
+        }
     }
 
     /// Build out the folds for the entire document.
     ///
     /// For each line in the document, find the indentation level using the ``levelProvider``. At each line, if the
     /// indent increases from the previous line, we start a new fold. If it decreases we end the fold we were in.
-    private func buildFoldsForDocument(afterEditIn: NSRange, delta: Int) {
-        workQueue.async {
-            guard let textView = self.textView, let foldProvider = self.foldProvider else { return }
-            var foldCache: [LineFoldStorage.RawFold] = []
-            // Depth: Open range
-            var openFolds: [Int: LineFoldStorage.RawFold] = [:]
-            var currentDepth: Int = 0
-            var iterator = textView.layoutManager.linesInRange(textView.documentRange)
+    private func buildFoldsForDocument(afterEditIn: NSRange, delta: Int) async {
+        guard let controller = self.controller, let foldProvider = self.foldProvider else { return }
+        let documentRange = await controller.textView.documentRange
+        var foldCache: [LineFoldStorage.RawFold] = []
+        // Depth: Open range
+        var openFolds: [Int: LineFoldStorage.RawFold] = [:]
+        var currentDepth: Int = 0
+        var iterator = await controller.textView.layoutManager.linesInRange(documentRange)
+
+        var lines = await self.getMoreLines(
+            controller: controller,
+            iterator: &iterator,
+            previousDepth: currentDepth,
+            foldProvider: foldProvider
+        )
+        while let lineChunk = lines {
+            for lineInfo in lineChunk where lineInfo.depth > 0 {
+                // Start a new fold, going deeper to a new depth.
+                if lineInfo.depth > currentDepth {
+                    let newFold = LineFoldStorage.RawFold(
+                        depth: lineInfo.depth,
+                        range: lineInfo.rangeIndice..<lineInfo.rangeIndice
+                    )
+                    openFolds[newFold.depth] = newFold
+                } else if lineInfo.depth < currentDepth {
+                    // End open folds > received depth
+                    for openFold in openFolds.values.filter({ $0.depth > lineInfo.depth }) {
+                        openFolds.removeValue(forKey: openFold.depth)
+                        foldCache.append(
+                            LineFoldStorage.RawFold(
+                                depth: openFold.depth,
+                                range: openFold.range.lowerBound..<lineInfo.rangeIndice
+                            )
+                        )
+                    }
+                }
 
-            var lines = self.getMoreLines(
-                textView: textView,
+                currentDepth = lineInfo.depth
+            }
+            lines = await self.getMoreLines(
+                controller: controller,
                 iterator: &iterator,
                 previousDepth: currentDepth,
                 foldProvider: foldProvider
             )
-            while let lineChunk = lines {
-                for lineInfo in lineChunk where lineInfo.depth > 0 {
-                    // Start a new fold, going deeper to a new depth.
-                    if lineInfo.depth > currentDepth {
-                        let newFold = LineFoldStorage.RawFold(
-                            depth: lineInfo.depth,
-                            range: lineInfo.rangeIndice..<lineInfo.rangeIndice
-                        )
-                        openFolds[newFold.depth] = newFold
-                    } else if lineInfo.depth < currentDepth {
-                        // End open folds > received depth
-                        for openFold in openFolds.values.filter({ $0.depth > lineInfo.depth }) {
-                            openFolds.removeValue(forKey: openFold.depth)
-                            foldCache.append(
-                                LineFoldStorage.RawFold(
-                                    depth: openFold.depth,
-                                    range: openFold.range.lowerBound..<lineInfo.rangeIndice
-                                )
-                            )
-                        }
-                    }
+        }
 
-                    currentDepth = lineInfo.depth
-                }
-                lines = self.getMoreLines(
-                    textView: textView,
-                    iterator: &iterator,
-                    previousDepth: currentDepth,
-                    foldProvider: foldProvider
+        // Clean up any hanging folds.
+        for fold in openFolds.values {
+            foldCache.append(
+                LineFoldStorage.RawFold(
+                    depth: fold.depth,
+                    range: fold.range.lowerBound..<documentRange.length
                 )
-            }
+            )
+        }
 
-            // Clean up any hanging folds.
-            for fold in openFolds.values {
-                foldCache.append(
-                    LineFoldStorage.RawFold(
-                        depth: fold.depth,
-                        range: fold.range.lowerBound..<textView.length
-                    )
-                )
+        let attachments = await controller.textView.layoutManager.attachments
+            .getAttachmentsOverlapping(documentRange)
+            .compactMap { $0.attachment as? LineFoldPlaceholder }
+            .map {
+                LineFoldStorage.DepthStartPair(depth: $0.fold.depth, start: $0.fold.range.lowerBound)
             }
 
-            let storage = LineFoldStorage(
-                documentLength: textView.length,
-                folds: foldCache.sorted(by: { $0.range.lowerBound < $1.range.lowerBound }),
-                collapsedProvider: {
-                    Set(
-                        textView.layoutManager.attachments
-                            .getAttachmentsOverlapping(textView.documentRange)
-                            .compactMap { $0.attachment as? LineFoldPlaceholder }
-                            .map {
-                                LineFoldStorage.DepthStartPair(depth: $0.fold.depth, start: $0.fold.range.lowerBound)
-                            }
-                    )
-                }
-            )
-            self.rangesPublisher.send(storage)
-        }
+        let storage = LineFoldStorage(
+            documentLength: foldCache.max(
+                by: { $0.range.upperBound < $1.range.upperBound }
+            )?.range.upperBound ?? documentRange.length,
+            folds: foldCache.sorted(by: { $0.range.lowerBound < $1.range.lowerBound }),
+            collapsedProvider: { Set(attachments) }
+        )
+        valueStreamContinuation.yield(storage)
     }
 
+    @MainActor
     private func getMoreLines(
-        textView: TextView,
+        controller: TextViewController,
         iterator: inout TextLayoutManager.RangeIterator,
         previousDepth: Int,
         foldProvider: LineFoldProvider
     ) -> [LineFoldProviderLineInfo]? {
-        DispatchQueue.main.asyncAndWait {
-            var results: [LineFoldProviderLineInfo] = []
-            var count = 0
-            var previousDepth: Int = previousDepth
-            while count < 50, let linePosition = iterator.next() {
-                let foldInfo = foldProvider.foldLevelAtLine(
-                    lineNumber: linePosition.index,
-                    lineRange: linePosition.range,
-                    previousDepth: previousDepth,
-                    text: textView.textStorage
-                )
-                results.append(contentsOf: foldInfo)
-                count += 1
-                previousDepth = foldInfo.max(by: { $0.depth < $1.depth })?.depth ?? previousDepth
-            }
-            if results.isEmpty && count == 0 {
-                return nil
-            }
-            return results
+        var results: [LineFoldProviderLineInfo] = []
+        var count = 0
+        var previousDepth: Int = previousDepth
+        while count < 50, let linePosition = iterator.next() {
+            let foldInfo = foldProvider.foldLevelAtLine(
+                lineNumber: linePosition.index,
+                lineRange: linePosition.range,
+                previousDepth: previousDepth,
+                controller: controller
+            )
+            results.append(contentsOf: foldInfo)
+            count += 1
+            previousDepth = foldInfo.max(by: { $0.depth < $1.depth })?.depth ?? previousDepth
+        }
+        if results.isEmpty && count == 0 {
+            return nil
         }
+        return results
     }
 }

Sources/CodeEditSourceEditor/LineFolding/Model/LineFoldStorage.swift

@@ -8,7 +8,7 @@ import _RopeModule
 import Foundation
 
 /// Represents a single fold region with stable identifier and collapse state
-struct FoldRange: Sendable {
+struct FoldRange: Sendable, Equatable {
     typealias FoldIdentifier = UInt32
 
     let id: FoldIdentifier
@@ -17,6 +17,14 @@ struct FoldRange: Sendable {
     var isCollapsed: Bool
 }
 
+/// Represents a single fold run with stable identifier and collapse state
+struct FoldRun: Sendable {
+    let id: FoldRange.FoldIdentifier
+    let depth: Int
+    let range: Range<Int>
+    let isCollapsed: Bool
+}
+
 /// Sendable data model for code folding using RangeStore
 struct LineFoldStorage: Sendable {
     /// A temporary fold representation without stable ID
@@ -112,6 +120,20 @@ struct LineFoldStorage: Sendable {
         }
 
         return result.sorted { $0.range.lowerBound < $1.range.lowerBound }
+//        let runs = store.runs(in: queryRange.clamped(to: 0..<store.length))
+//        var currentLocation = queryRange.lowerBound
+//        return runs.compactMap { run in
+//            defer {
+//                currentLocation += run.length
+//            }
+//            guard let value = run.value else { return nil }
+//            return FoldRun(
+//                id: value.id,
+//                depth: value.depth,
+//                range: currentLocation..<(currentLocation + run.length),
+//                isCollapsed: foldRanges[value.id]?.isCollapsed ?? false
+//            )
+//        }
     }
 
     /// Given a depth and a location, return the full original fold region