fix(editor): stop large SQL paste from freezing the editor

Author: datlechin

CHANGELOG.md

@@ -22,6 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Exports no longer fail mid-table on servers that enforce a statement time limit; the export session disables the limit and restores it afterwards, the same way mysqldump does. (#1633)
 - Refreshing a table now reloads its data even when the previous load is still running; before, the refresh was silently dropped and the grid kept stale rows. (#1637)
 - SQL autocomplete now suggests tables after JOIN. It detects the clause at the cursor across multi-join and multi-clause queries, so columns no longer appear where a table is expected, and tables lead the list. (#1646)
+- Pasting a large SQL script no longer freezes the editor. The line index rebuild stops allocating per line, and a big paste parses off the main thread. (#1652)
 
 ### Security
 

LocalPackages/CodeEditSourceEditor/Sources/CodeEditSourceEditor/TreeSitter/TreeSitterClient.swift

@@ -138,6 +138,21 @@ public final class TreeSitterClient: HighlightProviding {
 
     // MARK: - HighlightProviding
 
+    /// Decides whether an edit must be parsed asynchronously to keep the main thread responsive.
+    ///
+    /// The magnitude of an edit is the larger of the replaced range and the inserted length. Keying only on the
+    /// replaced range misses a large paste at the caret, where the replaced range is empty but `delta` is huge, so a
+    /// multi-megabyte insertion into a small document would otherwise run a full re-parse synchronously.
+    /// - Parameters:
+    ///   - editLength: The length of the range being replaced.
+    ///   - delta: The change in length, negative for deletions.
+    ///   - documentLength: The length of the document after the edit.
+    /// - Returns: `true` when the edit should be parsed off the main thread.
+    static func shouldExecuteAsync(editLength: Int, delta: Int, documentLength: Int) -> Bool {
+        let editMagnitude = max(editLength, abs(delta))
+        return editMagnitude > Constants.maxSyncEditLength || documentLength > Constants.maxSyncContentLength
+    }
+
     /// Notifies the highlighter of an edit and in exchange gets a set of indices that need to be re-highlighted.
     /// The returned `IndexSet` should include all indexes that need to be highlighted, including any inserted text.
     /// - Parameters:
@@ -161,9 +176,11 @@ public final class TreeSitterClient: HighlightProviding {
             return self?.applyEdit(edit: edit) ?? IndexSet()
         }
 
-        let longEdit = range.length > Constants.maxSyncEditLength
-        let longDocument = textView.documentRange.length > Constants.maxSyncContentLength
-        let execAsync = longEdit || longDocument
+        let execAsync = Self.shouldExecuteAsync(
+            editLength: range.length,
+            delta: delta,
+            documentLength: textView.documentRange.length
+        )
 
         if !execAsync || forceSyncOperation {
             let result = executor.execSync(operation)

LocalPackages/CodeEditSourceEditor/Tests/CodeEditSourceEditorTests/TreeSitterClientTests.swift

@@ -194,4 +194,38 @@ final class TreeSitterClientTests: XCTestCase {
         wait(for: editExpectations + [finalEditExpectation], timeout: 5.0)
     }
 }
+
+final class TreeSitterClientAsyncGateTests: XCTestCase {
+    private var savedEditLength = 0
+    private var savedContentLength = 0
+
+    override func setUp() {
+        savedEditLength = TreeSitterClient.Constants.maxSyncEditLength
+        savedContentLength = TreeSitterClient.Constants.maxSyncContentLength
+        TreeSitterClient.Constants.maxSyncEditLength = 1024
+        TreeSitterClient.Constants.maxSyncContentLength = 1_000_000
+    }
+
+    override func tearDown() {
+        TreeSitterClient.Constants.maxSyncEditLength = savedEditLength
+        TreeSitterClient.Constants.maxSyncContentLength = savedContentLength
+    }
+
+    func test_largePasteAtCaretRunsAsync() {
+        // The replaced range is empty for a caret paste; the inserted length must still force the async path.
+        XCTAssertTrue(TreeSitterClient.shouldExecuteAsync(editLength: 0, delta: 500_000, documentLength: 500_000))
+    }
+
+    func test_smallEditInSmallDocumentRunsSync() {
+        XCTAssertFalse(TreeSitterClient.shouldExecuteAsync(editLength: 4, delta: 4, documentLength: 1_000))
+    }
+
+    func test_largeDocumentRunsAsync() {
+        XCTAssertTrue(TreeSitterClient.shouldExecuteAsync(editLength: 1, delta: 1, documentLength: 2_000_000))
+    }
+
+    func test_largeDeletionRunsAsync() {
+        XCTAssertTrue(TreeSitterClient.shouldExecuteAsync(editLength: 0, delta: -500_000, documentLength: 10))
+    }
+}
 // swiftlint:enable all

LocalPackages/CodeEditTextView/Sources/CodeEditTextView/TextLayoutManager/TextLayoutManager+Edits.swift

@@ -80,42 +80,44 @@ extension TextLayoutManager: NSTextStorageDelegate {
     /// - Parameter range: The range of the string that was inserted into the text storage.
     private func insertNewLines(for range: NSRange) {
         guard !range.isEmpty, let string = textStorage?.substring(from: range) as? NSString else { return }
-        // Loop through each line being inserted, inserting & splitting where necessary
+        // Loop through each line being inserted, inserting & splitting where necessary. Each line is described by its
+        // length and whether it ends in a line break rather than a materialized substring, so a large paste does not
+        // allocate one bridged `String` per line just to test its terminator.
         var index = 0
         while let nextLine = string.getNextLine(startingAt: index) {
-            let lineRange = NSRange(start: index, end: nextLine.max)
-            applyLineInsert(string.substring(with: lineRange) as NSString, at: range.location + index)
+            applyLineInsert(length: nextLine.max - index, endsInLineBreak: true, at: range.location + index)
             index = nextLine.max
         }
 
         if index < string.length {
             // Get the last line.
-            applyLineInsert(string.substring(from: index) as NSString, at: range.location + index)
+            applyLineInsert(length: string.length - index, endsInLineBreak: false, at: range.location + index)
         }
     }
 
     /// Applies a line insert to the internal line storage tree.
     /// - Parameters:
-    ///   - insertedString: The string being inserted.
+    ///   - length: The length of the line being inserted.
+    ///   - endsInLineBreak: Whether the inserted line is terminated by a line break.
     ///   - location: The location the string is being inserted into.
-    private func applyLineInsert(_ insertedString: NSString, at location: Int) {
-        if LineEnding(line: insertedString as String) != nil {
+    private func applyLineInsert(length: Int, endsInLineBreak: Bool, at location: Int) {
+        if endsInLineBreak {
             if location == lineStorage.length {
                 // Insert a new line at the end of the document, need to insert a new line 'cause there's nothing to
                 // split. Also, append the new text to the last line.
-                lineStorage.update(atOffset: location, delta: insertedString.length, deltaHeight: 0.0)
+                lineStorage.update(atOffset: location, delta: length, deltaHeight: 0.0)
                 lineStorage.insert(
                     line: TextLine(),
-                    atOffset: location + insertedString.length,
+                    atOffset: location + length,
                     length: 0,
                     height: estimateLineHeight()
                 )
             } else {
                 // Need to split the line inserting into and create a new line with the split section of the line
                 guard let linePosition = lineStorage.getLine(atOffset: location) else { return }
-                let splitLocation = location + insertedString.length
+                let splitLocation = location + length
                 let splitLength = linePosition.range.max - location
-                let lineDelta = insertedString.length - splitLength // The difference in the line being edited
+                let lineDelta = length - splitLength // The difference in the line being edited
                 if lineDelta != 0 {
                     lineStorage.update(atOffset: location, delta: lineDelta, deltaHeight: 0.0)
                 }
@@ -128,7 +130,7 @@ extension TextLayoutManager: NSTextStorageDelegate {
                 )
             }
         } else {
-            lineStorage.update(atOffset: location, delta: insertedString.length, deltaHeight: 0.0)
+            lineStorage.update(atOffset: location, delta: length, deltaHeight: 0.0)
         }
     }
 }

LocalPackages/CodeEditTextView/Tests/CodeEditTextViewTests/LayoutManager/TextLayoutManagerTests.swift

@@ -269,4 +269,52 @@ struct TextLayoutManagerTests {
 
         #expect(invalidatedLineIds.isSuperset(of: Set(expectedLineIds)))
     }
+
+    private func makeLaidOutTextView(string: String) -> TextView {
+        let view = TextView(string: string)
+        view.frame = NSRect(x: 0, y: 0, width: 1000, height: 1000)
+        view.updateFrameIfNeeded()
+        return view
+    }
+
+    /// Pasting a large block of text into a document takes the incremental edit path, while opening a document takes
+    /// the bulk build path. Both must produce the same line index. This is the scenario behind the editor freezing on
+    /// a large SQL paste: the incremental path must stay correct after dropping its per-line allocations.
+    @Test(
+        arguments: [
+            ("\n", false),
+            ("\n", true),
+            ("\r\n", false),
+            ("\r\n", true),
+            ("\r", false)
+        ]
+    )
+    func largePasteMatchesFullRebuild(_ testItem: (String, Bool)) throws {
+        let (lineBreak, hasTrailingBreak) = testItem
+
+        var pasted = (0..<3_000)
+            .map { "SELECT * FROM table_\($0) WHERE id = \($0);" }
+            .joined(separator: lineBreak)
+        if hasTrailingBreak {
+            pasted += lineBreak
+        }
+
+        let pasteView = makeLaidOutTextView(string: "")
+        let pasteManager = try #require(pasteView.layoutManager)
+        pasteView.textStorage.replaceCharacters(in: NSRange(location: 0, length: 0), with: pasted)
+        pasteManager.lineStorage.validateInternalState()
+
+        let oracle = try #require(makeLaidOutTextView(string: pasted).layoutManager)
+
+        #expect(pasteManager.lineCount == oracle.lineCount)
+        #expect(pasteManager.lineStorage.length == oracle.lineStorage.length)
+
+        let pastedRanges = (0..<pasteManager.lineCount).compactMap {
+            pasteManager.lineStorage.getLine(atIndex: $0)?.range
+        }
+        let oracleRanges = (0..<oracle.lineCount).compactMap {
+            oracle.lineStorage.getLine(atIndex: $0)?.range
+        }
+        #expect(pastedRanges == oracleRanges)
+    }
 }