#3467 lsp: fix protocol bugs and marker issues

pbek · pbek · commit d5e140cb3980 · 2026-04-27T15:33:01.000+02:00
Signed-off-by: Patrizio Bekerle &lt;patrizio@bekerle.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -16,6 +16,16 @@
   context menus; the old standalone **Code actions** menu item in the
   **Markdown LSP** submenu has been removed in favour of this inline approach
   (for [#3467](https://github.com/pbek/QOwnNotes/issues/3467))
+- Fixed a protocol bug where the Markdown LSP client did not respond to
+  server-initiated requests (e.g. `client/registerCapability`), causing the
+  LSP server to stall after the initial `didOpen`; subsequent `didChange`
+  notifications were silently ignored by the server so diagnostics never
+  refreshed after the first note load (for [#3467](https://github.com/pbek/QOwnNotes/issues/3467))
+- Fixed stale Markdown LSP wave underlines remaining visible after applying
+  a quick-fix or manually editing the text to resolve a diagnostic; when fresh
+  diagnostics arrive from the server, blocks that previously had diagnostics
+  are now also rehighlighted so their old underlines are cleared
+  (for [#3467](https://github.com/pbek/QOwnNotes/issues/3467))
 
 ## 26.4.23
 
diff --git a/src/helpers/qownnotesmarkdownhighlighter.cpp b/src/helpers/qownnotesmarkdownhighlighter.cpp
@@ -697,8 +697,6 @@ void QOwnNotesMarkdownHighlighter::highlightMarkdownLsp(const QString &text) {
         return;
     }
 
-    qDebug() << "LSP highlightMarkdownLsp: block" << blockNumber << "entries:" << it->size()
-             << "text:" << text.left(40);
     for (const LspBlockDiagnostic &entry : *it) {
         const int start = entry.startCharacter;
         const int end = (entry.endCharacter == INT_MAX) ? text.length() : entry.endCharacter;
diff --git a/src/services/markdownlspclient.cpp b/src/services/markdownlspclient.cpp
@@ -472,7 +472,20 @@ void MarkdownLspClient::parseMessages() {
         }
 
         const QJsonObject object = doc.object();
-        if (object.contains(QStringLiteral("id"))) {
+        const bool hasId = object.contains(QStringLiteral("id"));
+        const bool hasMethod = object.contains(QStringLiteral("method"));
+
+        if (hasId && hasMethod) {
+            // Server-to-client request (e.g. client/registerCapability,
+            // window/workDoneProgress/create). Acknowledge with an empty
+            // success response so the server doesn't stall waiting for it.
+            const QJsonValue requestId = object.value(QStringLiteral("id"));
+            QJsonObject response;
+            response.insert(QStringLiteral("jsonrpc"), QStringLiteral("2.0"));
+            response.insert(QStringLiteral("id"), requestId);
+            response.insert(QStringLiteral("result"), QJsonValue());
+            sendMessage(response);
+        } else if (hasId) {
             handleResponse(object);
         } else {
             handleNotification(object);
@@ -631,7 +644,6 @@ void MarkdownLspClient::handleNotification(const QJsonObject &object) {
         diagnostics.push_back(diagnostic);
     }
 
-    qDebug() << "Markdown LSP diagnostics received for" << uri << "- count:" << diagnostics.size();
     emit diagnosticsReceived(uri, diagnostics);
 }
 
@@ -692,14 +704,22 @@ QVector<MarkdownLspClient::TextEdit> MarkdownLspClient::parseWorkspaceEdits(
         return edits;
     }
 
+    const QString normalizedUri = QUrl::fromPercentEncoding(uri.toUtf8());
+
     const QJsonValue changesValue = workspaceEdit.value(QStringLiteral("changes"));
     if (changesValue.isObject()) {
         const QJsonObject changesObject = changesValue.toObject();
-        const QJsonValue uriEdits = changesObject.value(uri);
-        if (uriEdits.isArray()) {
-            edits = parseTextEdits(uriEdits);
-            if (!edits.isEmpty()) {
-                return edits;
+        for (auto it = changesObject.constBegin(); it != changesObject.constEnd(); ++it) {
+            const QString changeUri = it.key();
+            if (QUrl::fromPercentEncoding(changeUri.toUtf8()) != normalizedUri) {
+                continue;
+            }
+
+            if (it.value().isArray()) {
+                edits = parseTextEdits(it.value());
+                if (!edits.isEmpty()) {
+                    return edits;
+                }
             }
         }
     }
@@ -716,7 +736,7 @@ QVector<MarkdownLspClient::TextEdit> MarkdownLspClient::parseWorkspaceEdits(
             const QJsonObject textDocument =
                 docChange.value(QStringLiteral("textDocument")).toObject();
             const QString changeUri = textDocument.value(QStringLiteral("uri")).toString();
-            if (changeUri != uri) {
+            if (QUrl::fromPercentEncoding(changeUri.toUtf8()) != normalizedUri) {
                 continue;
             }
 
diff --git a/src/widgets/qownnotesmarkdowntextedit.cpp b/src/widgets/qownnotesmarkdowntextedit.cpp
@@ -2446,9 +2446,14 @@ void QOwnNotesMarkdownTextEdit::updateSettings() {
 
 void QOwnNotesMarkdownTextEdit::onContextMenu(QPoint pos) {
     auto *spellCheckMenu = spellCheckContextMenu(pos);
+    const QTextCursor cursorAtMouse = cursorForPosition(pos);
+    auto *lspMenu = markdownLspContextMenu(cursorAtMouse);
 
     const QPoint globalPos = this->viewport()->mapToGlobal(pos);
     QMenu *menu = this->createStandardContextMenu();
+    if (lspMenu) {
+        menu->insertMenu(menu->actions().constFirst(), lspMenu);
+    }
     if (spellCheckMenu) {
         // insert spell check at the top if available
         menu->insertMenu(menu->actions().constFirst(), spellCheckMenu);
@@ -2690,8 +2695,6 @@ QMenu *QOwnNotesMarkdownTextEdit::spellCheckContextMenu(QPoint pos) {
     addHarperMenuSection(menu, cursorAtMouse, cursor, hasEntries);
 #endif
 
-    addMarkdownLspMenuSection(menu, cursorAtMouse, hasEntries);
-
     if (!spellchecker || !spellchecker->isActive() || _isSpellCheckingDisabled) {
         if (!hasEntries) {
             delete menu;
@@ -2798,11 +2801,9 @@ QMenu *QOwnNotesMarkdownTextEdit::spellCheckContextMenu(QPoint pos) {
     return menu;
 }
 
-void QOwnNotesMarkdownTextEdit::addMarkdownLspMenuSection(QMenu *menu,
-                                                          const QTextCursor &cursorAtMouse,
-                                                          bool &hasEntries) {
+QMenu *QOwnNotesMarkdownTextEdit::markdownLspContextMenu(const QTextCursor &cursorAtMouse) {
     if (!_markdownLspEnabled || !_markdownLspClient || _markdownLspDiagnostics.isEmpty()) {
-        return;
+        return nullptr;
     }
 
     // Find a diagnostic whose range covers the cursor position
@@ -2826,25 +2827,15 @@ void QOwnNotesMarkdownTextEdit::addMarkdownLspMenuSection(QMenu *menu,
     }
 
     if (!match) {
-        return;
-    }
-
-    // Add separator before LSP section if other entries already exist
-    if (hasEntries) {
-        menu->addSeparator();
+        return nullptr;
     }
 
-    // Show the diagnostic message as a disabled header
-    const QString header = tr("Markdown LSP: %1").arg(match->message);
-    QAction *headerAction = menu->addAction(header);
-    headerAction->setEnabled(false);
+    auto *lspMenu = new QMenu(match->message, this);
 
     // Request code actions for this diagnostic and wait briefly for the response
     // using a local event loop (same pattern as QDialog::exec)
-    MarkdownLspClient::DiagnosticRange range = match->range;
-    _markdownLspLastCodeActions.clear();
     _markdownLspCodeActionRequestId =
-        _markdownLspClient->requestCodeActions(_markdownLspUri, range, {*match});
+        _markdownLspClient->requestCodeActions(_markdownLspUri, match->range, {*match});
 
     if (_markdownLspCodeActionRequestId >= 0) {
         QVector<MarkdownLspClient::CodeAction> receivedActions;
@@ -2867,24 +2858,19 @@ void QOwnNotesMarkdownTextEdit::addMarkdownLspMenuSection(QMenu *menu,
 
         if (receivedId == _markdownLspCodeActionRequestId) {
             _markdownLspCodeActionRequestId = -1;
-            if (receivedActions.isEmpty()) {
-                QAction *noFixAction = menu->addAction(tr("No fixes available"));
-                noFixAction->setEnabled(false);
-            } else {
-                for (const auto &action : qAsConst(receivedActions)) {
-                    menu->addAction(action.title, this, [this, action]() {
-                        if (action.hasEdits()) {
-                            applyMarkdownLspTextEdits(action.edits);
-                        } else if (action.hasCommand()) {
-                            _markdownLspClient->executeCommand(action.command);
-                        }
-                    });
-                }
+            for (const auto &action : qAsConst(receivedActions)) {
+                lspMenu->addAction(action.title, this, [this, action]() {
+                    if (action.hasEdits()) {
+                        applyMarkdownLspTextEdits(action.edits);
+                    } else if (action.hasCommand()) {
+                        _markdownLspClient->executeCommand(action.command);
+                    }
+                });
             }
         }
     }
 
-    hasEntries = true;
+    return lspMenu;
 }
 
 #ifdef LANGUAGETOOL_ENABLED
@@ -3515,10 +3501,8 @@ void QOwnNotesMarkdownTextEdit::closeMarkdownLspDocument() {
     _markdownLspVersion = 0;
     _markdownLspDiagnostics.clear();
 
-    auto *h = dynamic_cast<QOwnNotesMarkdownHighlighter *>(highlighter());
-    if (h) {
+    if (auto *h = dynamic_cast<QOwnNotesMarkdownHighlighter *>(highlighter())) {
         h->clearMarkdownLspDiagnostics();
-        h->rehighlight();
     }
 }
 
@@ -3549,8 +3533,6 @@ void QOwnNotesMarkdownTextEdit::applyMarkdownLspSettings() {
                 &QOwnNotesMarkdownTextEdit::showMarkdownLspCompletions);
         connect(_markdownLspClient, &MarkdownLspClient::formattingReceived, this,
                 &QOwnNotesMarkdownTextEdit::applyMarkdownLspFormatting);
-        connect(_markdownLspClient, &MarkdownLspClient::codeActionsReceived, this,
-                &QOwnNotesMarkdownTextEdit::showMarkdownLspCodeActions);
         connect(_markdownLspClient, &MarkdownLspClient::diagnosticsReceived, this,
                 &QOwnNotesMarkdownTextEdit::showMarkdownLspDiagnostics);
         connect(_markdownLspClient, &MarkdownLspClient::errorMessage, this,
@@ -3697,38 +3679,34 @@ void QOwnNotesMarkdownTextEdit::showMarkdownLspDiagnostics(
     const QString normalizedUri = QUrl::fromPercentEncoding(uri.toUtf8());
     const QString normalizedCurrentUri = QUrl::fromPercentEncoding(_markdownLspUri.toUtf8());
     if (normalizedUri != normalizedCurrentUri) {
-        qDebug() << "Markdown LSP: ignoring diagnostics for" << uri
-                 << "(current:" << _markdownLspUri << ")";
         return;
     }
 
-    qDebug() << "Markdown LSP: applying" << diagnostics.size() << "diagnostics for" << uri;
-    for (const auto &d : diagnostics) {
-        qDebug() << "  diagnostic: severity" << d.severity << "line" << d.range.startLine << "chars"
-                 << d.range.startCharacter << "-" << d.range.endCharacter << "msg:" << d.message;
-    }
-    _markdownLspDiagnostics = diagnostics;
-
     auto *h = dynamic_cast<QOwnNotesMarkdownHighlighter *>(highlighter());
-    qDebug() << "Markdown LSP: highlighter cast:" << (h ? "OK" : "FAILED")
-             << "document:" << (document() ? "OK" : "NULL");
     if (!h || !document()) {
+        _markdownLspDiagnostics = diagnostics;
         return;
     }
 
+    // Collect blocks that had old diagnostics so we can clear their underlines
+    QSet<int> dirtyLines;
+    for (const MarkdownLspClient::Diagnostic &diag : _markdownLspDiagnostics) {
+        for (int line = diag.range.startLine; line <= diag.range.endLine; ++line) {
+            dirtyLines.insert(line);
+        }
+    }
+
+    _markdownLspDiagnostics = diagnostics;
     h->setMarkdownLspDiagnostics(diagnostics);
 
-    // Rehighlight every block touched by a diagnostic so the underlines appear
-    // via QSyntaxHighlighter::setFormat() — identical to LanguageTool/Harper
-    QSet<int> dirtyLines;
+    // Also collect blocks that have new diagnostics
     for (const MarkdownLspClient::Diagnostic &diag : diagnostics) {
         for (int line = diag.range.startLine; line <= diag.range.endLine; ++line) {
             dirtyLines.insert(line);
         }
     }
 
     if (dirtyLines.isEmpty()) {
-        h->rehighlight();
         return;
     }
 
@@ -3785,6 +3763,14 @@ void QOwnNotesMarkdownTextEdit::applyMarkdownLspTextEdits(
                   return left.start > right.start;
               });
 
+    // Clear the diagnostic cache before applying edits so that the rehighlight
+    // triggered by endEditBlock() will not re-apply the old LSP underlines.
+    _markdownLspDiagnostics.clear();
+
+    if (auto *h = dynamic_cast<QOwnNotesMarkdownHighlighter *>(highlighter())) {
+        h->clearMarkdownLspDiagnostics();
+    }
+
     QTextCursor cursor(document());
     cursor.beginEditBlock();
     for (const ResolvedEdit &edit : resolved) {
@@ -3797,7 +3783,11 @@ void QOwnNotesMarkdownTextEdit::applyMarkdownLspTextEdits(
     _markdownLspApplyingEdits = false;
 
     if (_markdownLspEnabled && !_markdownLspApplyingEdits) {
-        scheduleMarkdownLspChange();
+        // Quick-fixes invalidate the current diagnostics immediately, so refresh
+        // the LSP state right away instead of waiting for the debounce timer.
+        _markdownLspPendingText = toPlainText();
+        _markdownLspChangeTimer->stop();
+        sendMarkdownLspChange();
     }
 }
 
@@ -3855,86 +3845,3 @@ void QOwnNotesMarkdownTextEdit::requestMarkdownLspFormatting(bool useSelection)
     _markdownLspFormattingRequestId =
         _markdownLspClient->requestDocumentFormatting(_markdownLspUri, tabSize, insertSpaces);
 }
-
-void QOwnNotesMarkdownTextEdit::requestMarkdownLspCodeActions(const QTextCursor &cursor) {
-    if (!_markdownLspEnabled || !_markdownLspClient || _markdownLspUri.isEmpty()) {
-        return;
-    }
-
-    if (_markdownLspDiagnostics.isEmpty()) {
-        return;
-    }
-
-    _markdownLspLastCodeActions.clear();
-
-    MarkdownLspClient::DiagnosticRange range;
-    if (cursor.hasSelection()) {
-        const int startPos = cursor.selectionStart();
-        const int endPos = cursor.selectionEnd();
-        const QTextBlock startBlock = document()->findBlock(startPos);
-        const QTextBlock endBlock = document()->findBlock(endPos);
-        if (!startBlock.isValid() || !endBlock.isValid()) {
-            return;
-        }
-        range.startLine = startBlock.blockNumber();
-        range.startCharacter = startPos - startBlock.position();
-        range.endLine = endBlock.blockNumber();
-        range.endCharacter = endPos - endBlock.position();
-    } else {
-        range.startLine = cursor.blockNumber();
-        range.startCharacter = cursor.positionInBlock();
-        range.endLine = range.startLine;
-        range.endCharacter = range.startCharacter;
-    }
-
-    _markdownLspCodeActionRequestId =
-        _markdownLspClient->requestCodeActions(_markdownLspUri, range, _markdownLspDiagnostics);
-}
-
-void QOwnNotesMarkdownTextEdit::showMarkdownLspCodeActions(
-    int requestId, const QVector<MarkdownLspClient::CodeAction> &actions) {
-    if (requestId != _markdownLspCodeActionRequestId || _markdownLspCodeActionRequestId == -1) {
-        return;
-    }
-
-    _markdownLspCodeActionRequestId = -1;
-
-    if (actions.isEmpty()) {
-        return;
-    }
-
-    _markdownLspLastCodeActions = actions;
-
-    QMenu menu;
-    for (int i = 0; i < actions.size(); ++i) {
-        const MarkdownLspClient::CodeAction &action = actions.at(i);
-        auto *menuAction = menu.addAction(action.title);
-        menuAction->setData(i);
-        menuAction->setWhatsThis(QStringLiteral("markdownLspCodeAction"));
-    }
-
-    if (menu.actions().isEmpty()) {
-        return;
-    }
-
-    QPoint globalPos = mapToGlobal(cursorRect().bottomRight());
-    globalPos.setY(globalPos.y() + viewportMargins().top());
-    globalPos.setX(globalPos.x() + viewportMargins().left());
-
-    QAction *selectedItem = menu.exec(globalPos);
-    if (!selectedItem) {
-        return;
-    }
-
-    const int index = selectedItem->data().toInt();
-    if (index < 0 || index >= _markdownLspLastCodeActions.size()) {
-        return;
-    }
-
-    const MarkdownLspClient::CodeAction &action = _markdownLspLastCodeActions.at(index);
-    if (action.hasEdits()) {
-        applyMarkdownLspTextEdits(action.edits);
-    } else if (action.hasCommand()) {
-        _markdownLspClient->executeCommand(action.command);
-    }
-}
diff --git a/src/widgets/qownnotesmarkdowntextedit.h b/src/widgets/qownnotesmarkdowntextedit.h

Original file line number	Diff line number	Diff line change
`@@ -697,8 +697,6 @@ void QOwnNotesMarkdownHighlighter::highlightMarkdownLsp(const QString &text) {`
`697`	`697`	`return;`
`698`	`698`	`}`
`699`	`699`
`700`		`- qDebug() << "LSP highlightMarkdownLsp: block" << blockNumber << "entries:" << it->size()`
`701`		`- << "text:" << text.left(40);`
`702`	`700`	`for (const LspBlockDiagnostic &entry : *it) {`
`703`	`701`	`const int start = entry.startCharacter;`
`704`	`702`	`const int end = (entry.endCharacter == INT_MAX) ? text.length() : entry.endCharacter;`