#3467 lsp: fix performance problems on large notes

Signed-off-by: Patrizio Bekerle <patrizio@bekerle.com>

Author: pbek

CHANGELOG.md

@@ -1,5 +1,25 @@
 # QOwnNotes Changelog
 
+## 26.4.25
+
+- Major performance improvement for the Markdown LSP integration on large notes
+  (for [#3467](https://github.com/pbek/QOwnNotes/issues/3467))
+  - Added a new `MarkdownLspDocumentTracker` class that uses Qt's
+    `QTextDocument::contentsChange` signal to track edits incrementally instead
+    of calling `toPlainText()` on every keystroke; the per-keystroke cost drops
+    from O(n) (full-document copy) to O(log n + delta)
+  - The client now reads the server's `textDocumentSync` capability from the
+    initialize response and sends **incremental** `didChange` payloads
+    (`TextDocumentSyncKind=2`) when the server supports it (e.g. `marksman`),
+    falling back to full-text sync for servers like `rumdl`
+  - Optimized the LSP diagnostic wave-underline painter in the highlighter to
+    batch contiguous characters with the same base format into single
+    `setFormat()` calls, reducing format-range fragmentation from O(characters)
+    to O(format-runs)
+  - When the Markdown LSP feature is disabled, **zero additional work** is
+    performed on the text-change hot path — no `toPlainText()`, no timer
+    restarts, no signal connections fire
+
 ## 26.4.24
 
 - Fixed a URI percent-encoding mismatch that prevented Markdown LSP diagnostics

src/CMakeLists.txt

@@ -393,6 +393,8 @@ set(SOURCE_FILES
     services/harpertypes.h
     services/markdownlspclient.cpp
     services/markdownlspclient.h
+    services/markdownlspdocumenttracker.cpp
+    services/markdownlspdocumenttracker.h
     services/settingsservice.cpp
     services/settingsservice.h
     libraries/piwiktracker/piwiktracker.h

src/QOwnNotes.pro

@@ -187,6 +187,7 @@ SOURCES += main.cpp\
     services/webappclientservice.cpp \
      services/openaiservice.cpp \
     services/markdownlspclient.cpp \
+    services/markdownlspdocumenttracker.cpp \
     services/mcpservice.cpp \
     services/settingsservice.cpp \
     dialogs/masterdialog.cpp \
@@ -351,6 +352,7 @@ HEADERS  += mainwindow.h \
     services/cryptoservice.h \
      services/openaiservice.h \
     services/markdownlspclient.h \
+    services/markdownlspdocumenttracker.h \
     services/mcpservice.h \
     services/settingsservice.h \
     dialogs/masterdialog.h \

src/helpers/qownnotesmarkdownhighlighter.cpp

@@ -712,16 +712,49 @@ void QOwnNotesMarkdownHighlighter::highlightMarkdownLsp(const QString &text) {
 /**
  * Applies a wave underline to a character range in the current block, merging
  * with the existing per-character format to preserve syntax highlighting colors.
+ *
+ * Batches runs of characters that share the same base format into single
+ * setFormat() calls so the text layout sees O(runs) format ranges instead
+ * of O(characters), which matters for long diagnostic ranges.
  */
 void QOwnNotesMarkdownHighlighter::setMarkdownLspUnderline(int start, int count,
                                                            const QColor &color,
                                                            const QString &toolTip) {
-    for (int i = start; i < start + count; ++i) {
-        QTextCharFormat format = QSyntaxHighlighter::format(i);
-        format.setFontUnderline(true);
-        format.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);
-        format.setUnderlineColor(color);
-        format.setToolTip(toolTip);
-        setFormat(i, 1, format);
+    if (count <= 0) {
+        return;
+    }
+
+    const int end = start + count;
+    int runStart = start;
+
+    // Read the base format at the first character and build the merged format
+    QTextCharFormat baseFormat = QSyntaxHighlighter::format(runStart);
+    QTextCharFormat merged = baseFormat;
+    merged.setFontUnderline(true);
+    merged.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);
+    merged.setUnderlineColor(color);
+    merged.setToolTip(toolTip);
+
+    for (int i = start + 1; i < end; ++i) {
+        const QTextCharFormat fmt = QSyntaxHighlighter::format(i);
+        if (fmt == baseFormat) {
+            // Same base format — extend the current run
+            continue;
+        }
+
+        // Flush the current run
+        setFormat(runStart, i - runStart, merged);
+
+        // Start a new run with the new base format
+        runStart = i;
+        baseFormat = fmt;
+        merged = baseFormat;
+        merged.setFontUnderline(true);
+        merged.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);
+        merged.setUnderlineColor(color);
+        merged.setToolTip(toolTip);
     }
+
+    // Flush the last run
+    setFormat(runStart, end - runStart, merged);
 }

src/services/markdownlspclient.cpp

@@ -166,6 +166,52 @@ void MarkdownLspClient::didOpen(const QString &uri, const QString &languageId, c
     sendMessage(obj);
 }
 
+MarkdownLspClient::TextDocumentSyncKind MarkdownLspClient::serverSyncKind() const {
+    return _serverSyncKind;
+}
+
+void MarkdownLspClient::didChangeIncremental(const QString &uri,
+                                             const QVector<IncrementalChange> &changes,
+                                             int version) {
+    if (!_initialized || changes.isEmpty()) {
+        return;
+    }
+
+    QJsonObject doc;
+    doc.insert(QStringLiteral("uri"), uri);
+    doc.insert(QStringLiteral("version"), version);
+
+    QJsonArray changesArray;
+    for (const IncrementalChange &change : changes) {
+        QJsonObject start;
+        start.insert(QStringLiteral("line"), change.startLine);
+        start.insert(QStringLiteral("character"), change.startCharacter);
+
+        QJsonObject end;
+        end.insert(QStringLiteral("line"), change.endLine);
+        end.insert(QStringLiteral("character"), change.endCharacter);
+
+        QJsonObject range;
+        range.insert(QStringLiteral("start"), start);
+        range.insert(QStringLiteral("end"), end);
+
+        QJsonObject changeObj;
+        changeObj.insert(QStringLiteral("range"), range);
+        changeObj.insert(QStringLiteral("text"), change.text);
+        changesArray.append(changeObj);
+    }
+
+    QJsonObject params;
+    params.insert(QStringLiteral("textDocument"), doc);
+    params.insert(QStringLiteral("contentChanges"), changesArray);
+
+    QJsonObject obj;
+    obj.insert(QStringLiteral("jsonrpc"), QStringLiteral("2.0"));
+    obj.insert(QStringLiteral("method"), QStringLiteral("textDocument/didChange"));
+    obj.insert(QStringLiteral("params"), params);
+    sendMessage(obj);
+}
+
 void MarkdownLspClient::didChange(const QString &uri, const QString &text, int version) {
     if (!_initialized) {
         _pendingDocument.uri = uri;
@@ -498,6 +544,34 @@ void MarkdownLspClient::handleResponse(const QJsonObject &object) {
     if (id == _initializeRequestId) {
         _initialized = true;
         _initializeRequestId = -1;
+
+        // Extract textDocumentSync capability from the server response.
+        // The sync kind can appear as a bare integer or inside an options object.
+        _serverSyncKind = SyncFull;
+        const QJsonObject result = object.value(QStringLiteral("result")).toObject();
+        const QJsonObject capabilities = result.value(QStringLiteral("capabilities")).toObject();
+        const QJsonValue syncValue = capabilities.value(QStringLiteral("textDocumentSync"));
+        if (syncValue.isDouble()) {
+            const int kind = syncValue.toInt(1);
+            if (kind == 2) {
+                _serverSyncKind = SyncIncremental;
+            } else if (kind == 0) {
+                _serverSyncKind = SyncNone;
+            }
+        } else if (syncValue.isObject()) {
+            const QJsonObject syncObj = syncValue.toObject();
+            const int kind = syncObj.value(QStringLiteral("change")).toInt(1);
+            if (kind == 2) {
+                _serverSyncKind = SyncIncremental;
+            } else if (kind == 0) {
+                _serverSyncKind = SyncNone;
+            }
+        }
+
+        if (_verboseLogging) {
+            qDebug() << "Markdown LSP server sync kind:" << static_cast<int>(_serverSyncKind);
+        }
+
         emit serverInitialized();
         sendInitializedNotification();
         flushPendingDocument();

src/services/markdownlspclient.h

@@ -10,10 +10,15 @@
 #include <QStringList>
 #include <QVector>
 
+class MarkdownLspDocumentTracker;
+
 class MarkdownLspClient : public QObject {
     Q_OBJECT
 
    public:
+    /// LSP TextDocumentSyncKind advertised by the server.
+    enum TextDocumentSyncKind { SyncNone = 0, SyncFull = 1, SyncIncremental = 2 };
+
     struct DiagnosticRange {
         int startLine = 0;
         int startCharacter = 0;
@@ -41,6 +46,15 @@ class MarkdownLspClient : public QObject {
         QString message;
     };
 
+    /// Incremental content change used by MarkdownLspDocumentTracker.
+    struct IncrementalChange {
+        int startLine = 0;
+        int startCharacter = 0;
+        int endLine = 0;
+        int endCharacter = 0;
+        QString text;
+    };
+
     explicit MarkdownLspClient(QObject *parent = nullptr);
     ~MarkdownLspClient() override;
 
@@ -50,11 +64,16 @@ class MarkdownLspClient : public QObject {
     void shutdown();
     bool isRunning() const;
 
+    /// Returns the sync kind advertised by the server after initialization.
+    TextDocumentSyncKind serverSyncKind() const;
+
     void initialize(const QString &rootPath, const QString &clientName,
                     const QString &clientVersion);
 
     void didOpen(const QString &uri, const QString &languageId, const QString &text, int version);
     void didChange(const QString &uri, const QString &text, int version);
+    void didChangeIncremental(const QString &uri, const QVector<IncrementalChange> &changes,
+                              int version);
     void didClose(const QString &uri);
 
     int requestCompletion(const QString &uri, int line, int character);
@@ -104,6 +123,7 @@ class MarkdownLspClient : public QObject {
     int _nextRequestId = 1;
     int _initializeRequestId = -1;
     bool _initialized = false;
+    TextDocumentSyncKind _serverSyncKind = SyncFull;
     PendingDocument _pendingDocument;
     QSet<int> _completionRequestIds;
     QHash<int, QString> _codeActionUriByRequest;