refactor(editor): single source for the large-document threshold and flatten query equality

Author: datlechin

LocalPackages/CodeEditSourceEditor/Sources/CodeEditSourceEditor/Highlighting/Highlighter.swift

@@ -12,6 +12,14 @@ import SwiftTreeSitter
 import CodeEditLanguages
 import OSLog
 
+/// Thresholds for degrading language services on large documents.
+public enum EditorHighlighting {
+    /// Documents longer than this (UTF-16 character count) are not syntax highlighted by default. Above it the
+    /// per-edit re-parse and re-highlight cost dominates, so the editor stops highlighting to keep typing, scrolling,
+    /// and deleting responsive, the same way DataGrip and VS Code degrade large files.
+    public static let maxHighlightableCharacters = 2_000_000
+}
+
 /// This class manages fetching syntax highlights from providers, and applying those styles to the editor.
 /// Multiple highlight providers can be used to style the editor.
 ///
@@ -81,10 +89,7 @@ class Highlighter: NSObject {
     /// Counts upwards to provide unique IDs for new highlight providers.
     private var providerIdCounter: Int
 
-    /// Documents longer than this are not highlighted. Above this length the per-edit re-parse and re-highlight cost
-    /// dominates, so the editor stops syntax highlighting to keep typing, scrolling, and deleting responsive, the same
-    /// way DataGrip and VS Code degrade large files.
-    public var maxHighlightableLength: Int = 2_000_000
+    public var maxHighlightableLength: Int = EditorHighlighting.maxHighlightableCharacters
 
     // MARK: - Init
 

TablePro/Models/Query/QueryTabState.swift

@@ -322,22 +322,25 @@ struct TabQueryContent: Equatable {
     }
 
     static func == (lhs: TabQueryContent, rhs: TabQueryContent) -> Bool {
-        // The query can be multiple megabytes and is bridged from the editor's NSTextStorage. Same-box comparison is
-        // O(1); otherwise use NSString literal equality, which returns in O(1) when the lengths differ (every keystroke
-        // changes the length) and avoids Swift's canonical Unicode normalization.
-        guard lhs.queryStorage === rhs.queryStorage || (lhs.query as NSString).isEqual(to: rhs.query),
-              lhs.queryParameters == rhs.queryParameters,
-              lhs.isParameterPanelVisible == rhs.isParameterPanelVisible,
-              lhs.sourceFileURL == rhs.sourceFileURL,
-              lhs.loadMtime == rhs.loadMtime,
-              lhs.externalModificationDetected == rhs.externalModificationDetected else {
-            return false
-        }
-        switch (lhs.savedFileContent, rhs.savedFileContent) {
+        // Cheap scalar fields short-circuit first. The query and saved-file text can be multiple megabytes and are
+        // bridged from NSTextStorage, so they are compared last and with `sameText` to avoid Swift's canonical Unicode
+        // comparison (O(n) on the bridged text); the same-box identity check makes an unchanged query O(1).
+        lhs.isParameterPanelVisible == rhs.isParameterPanelVisible
+            && lhs.externalModificationDetected == rhs.externalModificationDetected
+            && lhs.sourceFileURL == rhs.sourceFileURL
+            && lhs.loadMtime == rhs.loadMtime
+            && lhs.queryParameters == rhs.queryParameters
+            && (lhs.queryStorage === rhs.queryStorage || sameText(lhs.query, rhs.query))
+            && sameText(lhs.savedFileContent, rhs.savedFileContent)
+    }
+
+    /// Literal text equality that skips Swift's canonical Unicode comparison, returning in O(1) when the lengths differ.
+    private static func sameText(_ lhs: String?, _ rhs: String?) -> Bool {
+        switch (lhs, rhs) {
         case (nil, nil):
             return true
-        case let (lhsSaved?, rhsSaved?):
-            return (lhsSaved as NSString).isEqual(to: rhsSaved)
+        case let (lhs?, rhs?):
+            return (lhs as NSString).isEqual(to: rhs)
         default:
             return false
         }

TablePro/Views/Editor/SQLEditorCoordinator.swift

@@ -21,9 +21,9 @@ final class SQLEditorCoordinator: TextViewCoordinator, TextViewDelegate {
 
     private static let logger = Logger(subsystem: "com.TablePro", category: "SQLEditorCoordinator")
 
-    /// Above this document length inline AI features are suspended, matching the syntax-highlighting cutoff, so a large
-    /// document does not copy its whole contents to the assistant on every keystroke.
-    private static let languageServiceLengthLimit = 2_000_000
+    /// Above this document length inline AI features are suspended, at the same cutoff where syntax highlighting stops,
+    /// so a large document does not copy its whole contents to the assistant on every keystroke.
+    private static let languageServiceLengthLimit = EditorHighlighting.maxHighlightableCharacters
 
     @ObservationIgnored weak var controller: TextViewController?
     /// Shared schema provider for inline AI suggestions (avoids duplicate schema fetches)