diff --git a/addons/filetree/katefiletreeplugin.cpp b/addons/filetree/katefiletreeplugin.cpp
index 0bb3f5426..32d69fb9b 100644
--- a/addons/filetree/katefiletreeplugin.cpp
+++ b/addons/filetree/katefiletreeplugin.cpp
@@ -1,460 +1,460 @@
 /* This file is part of the KDE project
    Copyright (C) 2010 Thomas Fjellstrom <thomas@fjellstrom.ca>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 //BEGIN Includes
 
 #include "katefiletreeplugin.h"
 #include "katefiletree.h"
 #include "katefiletreemodel.h"
 #include "katefiletreeproxymodel.h"
 #include "katefiletreeconfigpage.h"
 
 #include <ktexteditor/view.h>
 #include <ktexteditor/application.h>
 
 #include <KAboutData>
 #include <KPluginFactory>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KXMLGUIFactory>
 #include <KXmlGuiWindow>
 #include <KToolBar>
 
 #include <QAction>
 #include <QApplication>
 #include <QVBoxLayout>
 
 #include "katefiletreedebug.h"
 
 //END Includes
 
 K_PLUGIN_FACTORY_WITH_JSON(KateFileTreeFactory, "katefiletreeplugin.json", registerPlugin<KateFileTreePlugin>();)
 
 Q_LOGGING_CATEGORY(FILETREE, "kate-filetree", QtWarningMsg)
 
 //BEGIN KateFileTreePlugin
 KateFileTreePlugin::KateFileTreePlugin(QObject *parent, const QList<QVariant> &)
     : KTextEditor::Plugin(parent)
 {
 }
 
 KateFileTreePlugin::~KateFileTreePlugin()
 {
     m_settings.save();
 }
 
 QObject *KateFileTreePlugin::createView(KTextEditor::MainWindow *mainWindow)
 {
     KateFileTreePluginView *view = new KateFileTreePluginView(mainWindow, this);
     connect(view, &KateFileTreePluginView::destroyed, this, &KateFileTreePlugin::viewDestroyed);
     m_views.append(view);
 
     return view;
 }
 
 void KateFileTreePlugin::viewDestroyed(QObject *view)
 {
     // do not access the view pointer, since it is partially destroyed already
     m_views.removeAll(static_cast<KateFileTreePluginView *>(view));
 }
 
 int KateFileTreePlugin::configPages() const
 {
     return 1;
 }
 
 KTextEditor::ConfigPage *KateFileTreePlugin::configPage(int number, QWidget *parent)
 {
     if (number != 0) {
         return nullptr;
     }
 
     KateFileTreeConfigPage *page = new KateFileTreeConfigPage(parent, this);
     return page;
 }
 
 const KateFileTreePluginSettings &KateFileTreePlugin::settings()
 {
     return m_settings;
 }
 
-void KateFileTreePlugin::applyConfig(bool shadingEnabled, QColor viewShade, QColor editShade, bool listMode, int sortRole, bool showFullPath)
+void KateFileTreePlugin::applyConfig(bool shadingEnabled, const QColor& viewShade, const QColor& editShade, bool listMode, int sortRole, bool showFullPath)
 {
     // save to settings
     m_settings.setShadingEnabled(shadingEnabled);
     m_settings.setViewShade(viewShade);
     m_settings.setEditShade(editShade);
 
     m_settings.setListMode(listMode);
     m_settings.setSortRole(sortRole);
     m_settings.setShowFullPathOnRoots(showFullPath);
     m_settings.save();
 
     // update views
     foreach(KateFileTreePluginView * view, m_views) {
         view->setHasLocalPrefs(false);
         view->model()->setShadingEnabled(shadingEnabled);
         view->model()->setViewShade(viewShade);
         view->model()->setEditShade(editShade);
         view->setListMode(listMode);
         view->proxy()->setSortRole(sortRole);
         view->model()->setShowFullPathOnRoots(showFullPath);
     }
 }
 
 //END KateFileTreePlugin
 
 //BEGIN KateFileTreePluginView
 KateFileTreePluginView::KateFileTreePluginView(KTextEditor::MainWindow *mainWindow, KateFileTreePlugin *plug)
     : QObject(mainWindow)
     , m_loadingDocuments(false)
     , m_plug(plug)
     , m_mainWindow(mainWindow)
 {
     KXMLGUIClient::setComponentName(QStringLiteral("katefiletree"), i18n("Kate File Tree"));
     setXMLFile(QStringLiteral("ui.rc"));
 
     m_toolView = mainWindow->createToolView(plug, QStringLiteral("kate_private_plugin_katefiletreeplugin"), KTextEditor::MainWindow::Left, QIcon::fromTheme(QStringLiteral("document-open")), i18n("Documents"));
 
     Q_ASSERT(m_toolView->layout());
     m_toolView->layout()->setContentsMargins(0, 0, 0, 0);
     m_toolView->layout()->setSpacing(0);
     auto mainLayout = m_toolView->layout();
 
     // create toolbar
     m_toolbar = new KToolBar(m_toolView);
     m_toolbar->setMovable(false);
     m_toolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);
     m_toolbar->setContextMenuPolicy(Qt::NoContextMenu);
     mainLayout->addWidget(m_toolbar);
 
     // create filetree
     m_fileTree = new KateFileTree(m_toolView);
     m_fileTree->setSortingEnabled(true);
     mainLayout->addWidget(m_fileTree);
 
     connect(m_fileTree, &KateFileTree::activateDocument, this, &KateFileTreePluginView::activateDocument);
     connect(m_fileTree, &KateFileTree::viewModeChanged, this, &KateFileTreePluginView::viewModeChanged);
     connect(m_fileTree, &KateFileTree::sortRoleChanged, this, &KateFileTreePluginView::sortRoleChanged);
 
     m_documentModel = new KateFileTreeModel(this);
     m_proxyModel = new KateFileTreeProxyModel(this);
     m_proxyModel->setSourceModel(m_documentModel);
     m_proxyModel->setDynamicSortFilter(true);
 
     m_documentModel->setShowFullPathOnRoots(m_plug->settings().showFullPathOnRoots());
     m_documentModel->setShadingEnabled(m_plug->settings().shadingEnabled());
     m_documentModel->setViewShade(m_plug->settings().viewShade());
     m_documentModel->setEditShade(m_plug->settings().editShade());
 
     connect(KTextEditor::Editor::instance()->application(), &KTextEditor::Application::documentWillBeDeleted,
             m_documentModel, &KateFileTreeModel::documentClosed);
     connect(KTextEditor::Editor::instance()->application(), &KTextEditor::Application::documentCreated,
             this, &KateFileTreePluginView::documentOpened);
     connect(KTextEditor::Editor::instance()->application(), &KTextEditor::Application::documentWillBeDeleted,
             this, &KateFileTreePluginView::documentClosed);
     connect(KTextEditor::Editor::instance()->application(), &KTextEditor::Application::aboutToCreateDocuments,
             this, &KateFileTreePluginView::slotAboutToCreateDocuments);
 
     connect(KTextEditor::Editor::instance()->application(), &KTextEditor::Application::documentsCreated,
             this, &KateFileTreePluginView::slotDocumentsCreated);
 
     connect(KTextEditor::Editor::instance()->application(), &KTextEditor::Application::aboutToDeleteDocuments,
             m_documentModel, &KateFileTreeModel::slotAboutToDeleteDocuments);
     connect(KTextEditor::Editor::instance()->application(), &KTextEditor::Application::documentsDeleted,
             m_documentModel, &KateFileTreeModel::slotDocumentsDeleted);
 
     connect(m_documentModel, &KateFileTreeModel::triggerViewChangeAfterNameChange, [=] {
                 KateFileTreePluginView::viewChanged();
             });
 
     m_fileTree->setModel(m_proxyModel);
 
     m_fileTree->setDragEnabled(false);
     m_fileTree->setDragDropMode(QAbstractItemView::InternalMove);
     m_fileTree->setDropIndicatorShown(false);
 
     m_fileTree->setSelectionMode(QAbstractItemView::SingleSelection);
 
     connect(m_fileTree->selectionModel(), &QItemSelectionModel::currentChanged,
             m_fileTree, &KateFileTree::slotCurrentChanged);
 
     connect(mainWindow, &KTextEditor::MainWindow::viewChanged, this, &KateFileTreePluginView::viewChanged);
 
     //
     // actions
     //
     setupActions();
 
     mainWindow->guiFactory()->addClient(this);
 
     m_proxyModel->setSortRole(Qt::DisplayRole);
 
     m_proxyModel->sort(0, Qt::AscendingOrder);
     m_proxyModel->invalidate();
 }
 
 KateFileTreePluginView::~KateFileTreePluginView()
 {
     m_mainWindow->guiFactory()->removeClient(this);
 
     // clean up tree and toolview
     delete m_fileTree->parentWidget();
     // delete m_toolView;
     // and TreeModel
     delete m_documentModel;
 }
 
 void KateFileTreePluginView::setupActions()
 {
     auto aPrev = actionCollection()->addAction(QStringLiteral("filetree_prev_document"));
     aPrev->setText(i18n("Previous Document"));
     aPrev->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
     actionCollection()->setDefaultShortcut(aPrev, Qt::ALT + Qt::Key_Up);
     connect(aPrev, &QAction::triggered, m_fileTree, &KateFileTree::slotDocumentPrev);
 
     auto aNext = actionCollection()->addAction(QStringLiteral("filetree_next_document"));
     aNext->setText(i18n("Next Document"));
     aNext->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
     actionCollection()->setDefaultShortcut(aNext, Qt::ALT + Qt::Key_Down);
     connect(aNext, &QAction::triggered, m_fileTree, &KateFileTree::slotDocumentNext);
 
     auto aShowActive = actionCollection()->addAction(QStringLiteral("filetree_show_active_document"));
     aShowActive->setText(i18n("&Show Active"));
     aShowActive->setIcon(QIcon::fromTheme(QStringLiteral("folder-sync")));
     connect(aShowActive, &QAction::triggered, this, &KateFileTreePluginView::showActiveDocument);
 
     auto aSave = actionCollection()->addAction(QStringLiteral("filetree_save"), this, SLOT(slotDocumentSave()));
     aSave->setText(i18n("Save Current Document"));
     aSave->setToolTip(i18n("Save the current document"));
     aSave->setIcon(QIcon::fromTheme(QStringLiteral("document-save")));
 
     auto aSaveAs = actionCollection()->addAction(QStringLiteral("filetree_save_as"), this, SLOT(slotDocumentSaveAs()));
     aSaveAs->setText(i18n("Save Current Document As"));
     aSaveAs->setToolTip(i18n("Save current document under new name"));
     aSaveAs->setIcon(QIcon::fromTheme(QStringLiteral("document-save-as")));
 
     /**
      * add new & open, if hosting application has it
      */
     if (KXmlGuiWindow *parentClient = qobject_cast<KXmlGuiWindow *>(m_mainWindow->window())) {
         bool newOrOpen = false;
         if (auto a = parentClient->action("file_new")) {
             m_toolbar->addAction(a);
             newOrOpen = true;
         }
         if (auto a = parentClient->action("file_open")) {
             m_toolbar->addAction(a);
             newOrOpen = true;
         }
         if (newOrOpen) {
             m_toolbar->addSeparator();
         }
     }
 
     /**
      * add own actions
      */
     m_toolbar->addAction(aPrev);
     m_toolbar->addAction(aNext);
     m_toolbar->addSeparator();
     m_toolbar->addAction(aSave);
     m_toolbar->addAction(aSaveAs);
 }
 
 KateFileTreeModel *KateFileTreePluginView::model()
 {
     return m_documentModel;
 }
 
 KateFileTreeProxyModel *KateFileTreePluginView::proxy()
 {
     return m_proxyModel;
 }
 
 KateFileTree *KateFileTreePluginView::tree()
 {
     return m_fileTree;
 }
 
 void KateFileTreePluginView::documentOpened(KTextEditor::Document *doc)
 {
     if (m_loadingDocuments) {
         return;
     }
 
     m_documentModel->documentOpened(doc);
     m_proxyModel->invalidate();
 }
 
 void KateFileTreePluginView::documentClosed(KTextEditor::Document *doc)
 {
     Q_UNUSED(doc);
     m_proxyModel->invalidate();
 }
 
 void KateFileTreePluginView::viewChanged(KTextEditor::View *)
 {
     KTextEditor::View *view = m_mainWindow->activeView();
     if (!view) {
         return;
     }
 
     KTextEditor::Document *doc = view->document();
     QModelIndex index = m_proxyModel->docIndex(doc);
 
     QString display = m_proxyModel->data(index, Qt::DisplayRole).toString();
 
     // update the model on which doc is active
     m_documentModel->documentActivated(doc);
 
     m_fileTree->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
 
     m_fileTree->scrollTo(index);
 
     while (index != QModelIndex()) {
         m_fileTree->expand(index);
         index = index.parent();
     }
 }
 
 void KateFileTreePluginView::setListMode(bool listMode)
 {
     if (listMode) {
         m_documentModel->setListMode(true);
         m_fileTree->setRootIsDecorated(false);
     } else {
         m_documentModel->setListMode(false);
         m_fileTree->setRootIsDecorated(true);
     }
 
     m_proxyModel->sort(0, Qt::AscendingOrder);
     m_proxyModel->invalidate();
 }
 
 void KateFileTreePluginView::viewModeChanged(bool listMode)
 {
     setHasLocalPrefs(true);
     setListMode(listMode);
 }
 
 void KateFileTreePluginView::sortRoleChanged(int role)
 {
     setHasLocalPrefs(true);
     m_proxyModel->setSortRole(role);
     m_proxyModel->invalidate();
 }
 
 void KateFileTreePluginView::activateDocument(KTextEditor::Document *doc)
 {
     m_mainWindow->activateView(doc);
 }
 
 void KateFileTreePluginView::showToolView()
 {
     m_mainWindow->showToolView(m_toolView);
     m_toolView->setFocus();
 }
 
 void KateFileTreePluginView::hideToolView()
 {
     m_mainWindow->hideToolView(m_toolView);
 }
 
 void KateFileTreePluginView::showActiveDocument()
 {
     // hack?
     viewChanged();
     // make the tool view show if it was hidden
     showToolView();
 }
 
 bool KateFileTreePluginView::hasLocalPrefs()
 {
     return m_hasLocalPrefs;
 }
 
 void KateFileTreePluginView::setHasLocalPrefs(bool h)
 {
     m_hasLocalPrefs = h;
 }
 
 void KateFileTreePluginView::readSessionConfig(const KConfigGroup &g)
 {
     if (g.exists()) {
         m_hasLocalPrefs = true;
     } else {
         m_hasLocalPrefs = false;
     }
 
     // we chain to the global settings by using them as the defaults
     //  here in the session view config loading.
     const KateFileTreePluginSettings &defaults = m_plug->settings();
 
     bool listMode = g.readEntry("listMode", defaults.listMode());
 
     setListMode(listMode);
 
     int sortRole = g.readEntry("sortRole", defaults.sortRole());
     m_proxyModel->setSortRole(sortRole);
 }
 
 void KateFileTreePluginView::writeSessionConfig(KConfigGroup &g)
 {
     if (m_hasLocalPrefs) {
         g.writeEntry("listMode", QVariant(m_documentModel->listMode()));
         g.writeEntry("sortRole", int(m_proxyModel->sortRole()));
     } else {
         g.deleteEntry("listMode");
         g.deleteEntry("sortRole");
     }
 
     g.sync();
 }
 
 void KateFileTreePluginView::slotAboutToCreateDocuments()
 {
     m_loadingDocuments = true;
 }
 
 void KateFileTreePluginView::slotDocumentsCreated(const QList<KTextEditor::Document *> &docs)
 {
     m_documentModel->documentsOpened(docs);
     m_loadingDocuments = false;
     viewChanged();
 }
 
 void KateFileTreePluginView::slotDocumentSave()
 {
     if (auto view = m_mainWindow->activeView()) {
         view->document()->documentSave();
     }
 }
 
 void KateFileTreePluginView::slotDocumentSaveAs()
 {
     if (auto view = m_mainWindow->activeView()) {
         view->document()->documentSaveAs();
     }
 }
 
 //END KateFileTreePluginView
 
 #include "katefiletreeplugin.moc"
diff --git a/addons/filetree/katefiletreeplugin.h b/addons/filetree/katefiletreeplugin.h
index e8d8d45bd..579d97cbd 100644
--- a/addons/filetree/katefiletreeplugin.h
+++ b/addons/filetree/katefiletreeplugin.h
@@ -1,142 +1,142 @@
 /* This file is part of the KDE project
    Copyright (C) 2010 Thomas Fjellstrom <thomas@fjellstrom.ca>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KATE_FILETREE_PLUGIN_H
 #define KATE_FILETREE_PLUGIN_H
 
 #include <QIcon>
 
 #include <KTextEditor/Command>
 #include <ktexteditor/document.h>
 #include <ktexteditor/editor.h>
 #include <KTextEditor/Plugin>
 #include <ktexteditor/mainwindow.h>
 #include <ktexteditor/sessionconfiginterface.h>
 
 #include "katefiletreepluginsettings.h"
 
 #include <KXMLGUIClient>
 
 class KToolBar;
 
 class KateFileTree;
 class KateFileTreeModel;
 class KateFileTreeProxyModel;
 class KateFileTreeConfigPage;
 class KateFileTreePluginView;
 
 class KateFileTreePlugin: public KTextEditor::Plugin
 {
     Q_OBJECT
 
 public:
     explicit KateFileTreePlugin(QObject *parent = nullptr, const QList<QVariant> & = QList<QVariant>());
     ~KateFileTreePlugin() override;
 
     QObject *createView(KTextEditor::MainWindow *mainWindow) override;
 
     int configPages() const override;
     KTextEditor::ConfigPage *configPage(int number = 0, QWidget *parent = nullptr) override;
 
     const KateFileTreePluginSettings &settings();
 
-    void applyConfig(bool shadingEnabled, QColor viewShade, QColor editShade, bool listMode, int sortRole, bool showFulPath);
+    void applyConfig(bool shadingEnabled, const QColor& viewShade, const QColor& editShade, bool listMode, int sortRole, bool showFulPath);
 
 public Q_SLOTS:
     void viewDestroyed(QObject *view);
 
 private:
     QList<KateFileTreePluginView *> m_views;
     KateFileTreeConfigPage *m_confPage;
     KateFileTreePluginSettings m_settings;
 };
 
 class KateFileTreePluginView : public QObject, public KXMLGUIClient, public KTextEditor::SessionConfigInterface
 {
     Q_OBJECT
 
     Q_INTERFACES(KTextEditor::SessionConfigInterface)
 
 public:
     /**
       * Constructor.
       */
     KateFileTreePluginView(KTextEditor::MainWindow *mainWindow, KateFileTreePlugin *plug);
 
     /**
      * Virtual destructor.
      */
     ~KateFileTreePluginView() override;
 
     void readSessionConfig(const KConfigGroup &config) override;
     void writeSessionConfig(KConfigGroup &config) override;
 
     /**
      * The file tree model.
      * @return the file tree model
      */
     KateFileTreeModel *model();
     /**
      * The file tree proxy model.
      * @return the file tree proxy model
      */
     KateFileTreeProxyModel *proxy();
     /**
      * The file tree.
      * @return the file tree
      */
     KateFileTree *tree();
 
     void setListMode(bool listMode);
 
     bool hasLocalPrefs();
     void setHasLocalPrefs(bool);
 
 protected:
     void setupActions();
 
 private:
     QWidget *m_toolView;
     KToolBar *m_toolbar;
     KateFileTree *m_fileTree;
     KateFileTreeProxyModel *m_proxyModel;
     KateFileTreeModel *m_documentModel;
     bool m_hasLocalPrefs;
     bool m_loadingDocuments;
     KateFileTreePlugin *m_plug;
     KTextEditor::MainWindow *m_mainWindow;
 
 private Q_SLOTS:
     void showToolView();
     void hideToolView();
     void showActiveDocument();
     void activateDocument(KTextEditor::Document *);
     void viewChanged(KTextEditor::View * = nullptr);
     void documentOpened(KTextEditor::Document *);
     void documentClosed(KTextEditor::Document *);
     void viewModeChanged(bool);
     void sortRoleChanged(int);
     void slotAboutToCreateDocuments();
     void slotDocumentsCreated(const QList<KTextEditor::Document *> &);
     void slotDocumentSave();
     void slotDocumentSaveAs();
 };
 
 #endif //KATE_FILETREE_PLUGIN_H
 
diff --git a/addons/katebuild-plugin/plugin_katebuild.cpp b/addons/katebuild-plugin/plugin_katebuild.cpp
index 02e55737f..0ba7d8532 100644
--- a/addons/katebuild-plugin/plugin_katebuild.cpp
+++ b/addons/katebuild-plugin/plugin_katebuild.cpp
@@ -1,1277 +1,1277 @@
 /* plugin_katebuild.c                    Kate Plugin
 **
 ** Copyright (C) 2013 by Alexander Neundorf <neundorf@kde.org>
 ** Copyright (C) 2006-2015 by Kåre Särs <kare.sars@iki.fi>
 ** Copyright (C) 2011 by Ian Wakeling <ian.wakeling@ntlworld.com>
 **
 ** This code is mostly a modification of the GPL'ed Make plugin
 ** by Adriaan de Groot.
 */
 
 /*
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 ** GNU General Public License for more details.
 **
 ** You should have received a copy of the GNU General Public License
 ** along with this program in a file called COPYING; if not, write to
 ** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 ** MA 02110-1301, USA.
 */
 
 #include "plugin_katebuild.h"
 
 #include <cassert>
 
 #include <QRegularExpressionMatch>
 #include <QString>
 #include <QScrollBar>
 #include <QCompleter>
 #include <QDirModel>
 #include <QKeyEvent>
 #include <QFileInfo>
 #include <QDir>
 #include <QFileDialog>
 #include <QIcon>
 
 #include <QAction>
 
 #include <KTextEditor/Application>
 #include <KXMLGUIFactory>
 #include <KActionCollection>
 
 #include <kmessagebox.h>
 
 #include <klocalizedstring.h>
 #include <kpluginfactory.h>
 #include <kpluginloader.h>
 #include <kaboutdata.h>
 
 #include <ktexteditor/markinterface.h>
 #include <ktexteditor/movinginterface.h>
 
 
 #include "SelectTargetView.h"
 
 K_PLUGIN_FACTORY_WITH_JSON (KateBuildPluginFactory, "katebuildplugin.json", registerPlugin<KateBuildPlugin>();)
 
 static const QString DefConfigCmd = QStringLiteral("cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=/usr/local ../");
 static const QString DefConfClean;
 static const QString DefTargetName = QStringLiteral("all");
 static const QString DefBuildCmd = QStringLiteral("make");
 static const QString DefCleanCmd = QStringLiteral("make clean");
 
 static QIcon messageIcon(KateBuildView::ErrorCategory severity)
 {
 #define RETURN_CACHED_ICON(name) \
 { \
 static QIcon icon(QIcon::fromTheme(QStringLiteral(name))); \
 return icon; \
 }
     switch (severity)
     {
     case KateBuildView::CategoryError:
         RETURN_CACHED_ICON("dialog-error")
     case KateBuildView::CategoryWarning:
         RETURN_CACHED_ICON("dialog-warning")
     default:
         break;
     }
     return QIcon();
 }
 
 struct ItemData
 {
     // ensure destruction, but not inadvertently so by a variant value copy
     QSharedPointer<KTextEditor::MovingCursor> cursor;
 };
 
 Q_DECLARE_METATYPE(ItemData)
 
 
 /******************************************************************/
 KateBuildPlugin::KateBuildPlugin(QObject *parent, const VariantList&):
 KTextEditor::Plugin(parent)
 {
     // KF5 FIXME KGlobal::locale()->insertCatalog("katebuild-plugin");
 }
 
 /******************************************************************/
 QObject *KateBuildPlugin::createView (KTextEditor::MainWindow *mainWindow)
 {
     return new KateBuildView(this, mainWindow);
 }
 
 /******************************************************************/
 KateBuildView::KateBuildView(KTextEditor::Plugin *plugin, KTextEditor::MainWindow *mw)
     : QObject (mw)
     , m_win(mw)
     , m_buildWidget(nullptr)
     , m_outputWidgetWidth(0)
     , m_proc(this)
     , m_stdOut()
     , m_stdErr()
     , m_buildCancelled(false)
     , m_displayModeBeforeBuild(1)
     // NOTE this will not allow spaces in file names.
     // e.g. from gcc: "main.cpp:14: error: cannot convert ‘std::string’ to ‘int’ in return"
     , m_filenameDetector(QStringLiteral("(([a-np-zA-Z]:[\\\\/])?[a-zA-Z0-9_\\.\\+\\-/\\\\]+\\.[a-zA-Z0-9]+):([0-9]+)(.*)"))
     // e.g. from icpc: "main.cpp(14): error: no suitable conversion function from "std::string" to "int" exists"
     , m_filenameDetectorIcpc(QStringLiteral("(([a-np-zA-Z]:[\\\\/])?[a-zA-Z0-9_\\.\\+\\-/\\\\]+\\.[a-zA-Z0-9]+)\\(([0-9]+)\\)(:.*)"))
     , m_filenameDetectorGccWorked(false)
     , m_newDirDetector(QStringLiteral("make\\[.+\\]: .+ `.*'"))
 {
     KXMLGUIClient::setComponentName (QStringLiteral("katebuild"), i18n ("Kate Build Plugin"));
     setXMLFile(QStringLiteral("ui.rc"));
 
     m_toolView  = mw->createToolView(plugin, QStringLiteral("kate_plugin_katebuildplugin"),
                                       KTextEditor::MainWindow::Bottom,
                                       QIcon::fromTheme(QStringLiteral("application-x-ms-dos-executable")),
                                       i18n("Build Output"));
 
     QAction *a = actionCollection()->addAction(QStringLiteral("select_target"));
     a->setText(i18n("Select Target..."));
     a->setIcon(QIcon::fromTheme(QStringLiteral("select")));
     connect(a, &QAction::triggered, this, &KateBuildView::slotSelectTarget);
     a = actionCollection()->addAction(QStringLiteral("build_default_target"));
     a->setText(i18n("Build Default Target"));
     connect(a, &QAction::triggered, this, &KateBuildView::slotBuildDefaultTarget);
 
     a = actionCollection()->addAction(QStringLiteral("build_previous_target"));
     a->setText(i18n("Build Previous Target"));
     connect(a, &QAction::triggered, this, &KateBuildView::slotBuildPreviousTarget);
 
     a = actionCollection()->addAction(QStringLiteral("stop"));
     a->setText(i18n("Stop"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
     connect(a, &QAction::triggered, this, &KateBuildView::slotStop);
 
     a = actionCollection()->addAction(QStringLiteral("goto_next"));
     a->setText(i18n("Next Error"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-next")));
     actionCollection()->setDefaultShortcut(a, Qt::SHIFT+Qt::ALT+Qt::Key_Right);
     connect(a, &QAction::triggered, this, &KateBuildView::slotNext);
 
     a = actionCollection()->addAction(QStringLiteral("goto_prev"));
     a->setText(i18n("Previous Error"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-previous")));
     actionCollection()->setDefaultShortcut(a, Qt::SHIFT+Qt::ALT+Qt::Key_Left);
     connect(a, &QAction::triggered, this, &KateBuildView::slotPrev);
 
     m_showMarks = a = actionCollection()->addAction(QStringLiteral("show_marks"));
     a->setText(i18n("Show Marks"));
     a->setCheckable(true);
     connect(a, &QAction::triggered, this, &KateBuildView::slotDisplayOption);
 
     m_buildWidget = new QWidget(m_toolView);
     m_buildUi.setupUi(m_buildWidget);
     m_targetsUi = new TargetsUi(this, m_buildUi.u_tabWidget);
     m_buildUi.u_tabWidget->insertTab(0, m_targetsUi, i18nc("Tab label", "Target Settings"));
     m_buildUi.u_tabWidget->setCurrentWidget(m_targetsUi);
 
     m_buildWidget->installEventFilter(this);
 
     m_buildUi.buildAgainButton->setVisible(true);
     m_buildUi.cancelBuildButton->setVisible(true);
     m_buildUi.buildStatusLabel->setVisible(true);
     m_buildUi.buildAgainButton2->setVisible(false);
     m_buildUi.cancelBuildButton2->setVisible(false);
     m_buildUi.buildStatusLabel2->setVisible(false);
     m_buildUi.extraLineLayout->setAlignment(Qt::AlignRight);
     m_buildUi.cancelBuildButton->setEnabled(false);
     m_buildUi.cancelBuildButton2->setEnabled(false);
 
     connect(m_buildUi.errTreeWidget, &QTreeWidget::itemClicked, this, &KateBuildView::slotErrorSelected);
 
     m_buildUi.plainTextEdit->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
     m_buildUi.plainTextEdit->setReadOnly(true);
     slotDisplayMode(FullOutput);
 
     connect(m_buildUi.displayModeSlider, &QSlider::valueChanged, this, &KateBuildView::slotDisplayMode);
 
     connect(m_buildUi.buildAgainButton, &QPushButton::clicked, this, &KateBuildView::slotBuildPreviousTarget);
     connect(m_buildUi.cancelBuildButton, &QPushButton::clicked, this, &KateBuildView::slotStop);
     connect(m_buildUi.buildAgainButton2, &QPushButton::clicked, this, &KateBuildView::slotBuildPreviousTarget);
     connect(m_buildUi.cancelBuildButton2, &QPushButton::clicked, this, &KateBuildView::slotStop);
 
     connect(m_targetsUi->newTarget, &QToolButton::clicked, this, &KateBuildView::targetSetNew);
     connect(m_targetsUi->copyTarget, &QToolButton::clicked, this, &KateBuildView::targetOrSetCopy);
     connect(m_targetsUi->deleteTarget, &QToolButton::clicked, this, &KateBuildView::targetDelete);
 
     connect(m_targetsUi->addButton, &QToolButton::clicked, this, &KateBuildView::slotAddTargetClicked);
     connect(m_targetsUi->buildButton, &QToolButton::clicked, this, &KateBuildView::slotBuildActiveTarget);
     connect(m_targetsUi, &TargetsUi::enterPressed, this, &KateBuildView::slotBuildActiveTarget);
 
     m_proc.setOutputChannelMode(KProcess::SeparateChannels);
     connect(&m_proc, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), this, &KateBuildView::slotProcExited);
     connect(&m_proc, &KProcess::readyReadStandardError, this, &KateBuildView::slotReadReadyStdErr);
     connect(&m_proc, &KProcess::readyReadStandardOutput, this, &KateBuildView::slotReadReadyStdOut);
 
     connect(m_win, &KTextEditor::MainWindow::unhandledShortcutOverride, this, &KateBuildView::handleEsc);
     connect(m_win, &KTextEditor::MainWindow::viewChanged, this, &KateBuildView::slotViewChanged);
 
     m_toolView->installEventFilter(this);
 
     m_win->guiFactory()->addClient(this);
 
     // watch for project plugin view creation/deletion
     connect(m_win, &KTextEditor::MainWindow::pluginViewCreated, this, &KateBuildView::slotPluginViewCreated);
     connect(m_win, &KTextEditor::MainWindow::pluginViewDeleted, this, &KateBuildView::slotPluginViewDeleted);
 
     // Connect signals from project plugin to our slots
     m_projectPluginView = m_win->pluginView(QStringLiteral("kateprojectplugin"));
     slotPluginViewCreated(QStringLiteral("kateprojectplugin"), m_projectPluginView);
 }
 
 
 /******************************************************************/
 KateBuildView::~KateBuildView()
 {
     m_win->guiFactory()->removeClient( this );
     delete m_toolView;
 }
 
 /******************************************************************/
 void KateBuildView::readSessionConfig(const KConfigGroup& cg)
 {
     int numTargets = cg.readEntry(QStringLiteral("NumTargets"), 0);
     m_targetsUi->targetsModel.clear();
     int tmpIndex;
     int tmpCmd;
 
     if (numTargets == 0 ) {
         // either the config is empty or uses the older format
         m_targetsUi->targetsModel.addTargetSet(i18n("Target Set"), QString());
         m_targetsUi->targetsModel.addCommand(0, i18n("build"), cg.readEntry(QStringLiteral("Make Command"), DefBuildCmd));
         m_targetsUi->targetsModel.addCommand(0, i18n("clean"), cg.readEntry(QStringLiteral("Clean Command"), DefCleanCmd));
         m_targetsUi->targetsModel.addCommand(0, i18n("config"), DefConfigCmd);
 
         QString quickCmd = cg.readEntry(QStringLiteral("Quick Compile Command"));
         if (!quickCmd.isEmpty()) {
             m_targetsUi->targetsModel.addCommand(0, i18n("quick"), quickCmd);
         }
         tmpIndex = 0;
         tmpCmd = 0;
     }
     else {
         for (int i=0; i<numTargets; i++) {
             QStringList targetNames = cg.readEntry(QStringLiteral("%1 Target Names").arg(i), QStringList());
             QString targetSetName = cg.readEntry(QStringLiteral("%1 Target").arg(i), QString());
             QString buildDir = cg.readEntry(QStringLiteral("%1 BuildPath").arg(i), QString());
 
             m_targetsUi->targetsModel.addTargetSet(targetSetName, buildDir);
 
             if (targetNames.isEmpty()) {
                 QString quickCmd = cg.readEntry(QStringLiteral("%1 QuickCmd").arg(i));
                 m_targetsUi->targetsModel.addCommand(i, i18n("build"), cg.readEntry(QStringLiteral("%1 BuildCmd"), DefBuildCmd));
                 m_targetsUi->targetsModel.addCommand(i, i18n("clean"), cg.readEntry(QStringLiteral("%1 CleanCmd"), DefCleanCmd));
                 if (!quickCmd.isEmpty()) {
                     m_targetsUi->targetsModel.addCommand(i, i18n("quick"), quickCmd);
                 }
                 m_targetsUi->targetsModel.setDefaultCmd(i, i18n("build"));
             }
             else {
                 for (int tn=0; tn<targetNames.size(); ++tn) {
-                    const QString targetName = targetNames.at(tn);
+                    const QString& targetName = targetNames.at(tn);
                     m_targetsUi->targetsModel.addCommand(i, targetName, cg.readEntry(QStringLiteral("%1 BuildCmd %2").arg(i).arg(targetName), DefBuildCmd));
                 }
                 QString defCmd = cg.readEntry(QStringLiteral("%1 Target Default").arg(i), QString());
                 m_targetsUi->targetsModel.setDefaultCmd(i, defCmd);
             }
 
         }
         tmpIndex = cg.readEntry(QStringLiteral("Active Target Index"), 0);
         tmpCmd = cg.readEntry(QStringLiteral("Active Target Command"), 0);
     }
 
     m_targetsUi->targetsView->expandAll();
     m_targetsUi->targetsView->resizeColumnToContents(0);
     m_targetsUi->targetsView->collapseAll();
 
     QModelIndex root = m_targetsUi->targetsModel.index(tmpIndex);
     QModelIndex cmdIndex = m_targetsUi->targetsModel.index(tmpCmd, 0, root);
     m_targetsUi->targetsView->setCurrentIndex(cmdIndex);
 
     auto showMarks = cg.readEntry(QStringLiteral("Show Marks"), false);
     m_showMarks->setChecked(showMarks);
 
     // Add project targets, if any
     slotAddProjectTarget();
 }
 
 /******************************************************************/
 void KateBuildView::writeSessionConfig(KConfigGroup& cg)
 {
     // Don't save project targets, is not our area of accountability
     m_targetsUi->targetsModel.deleteTargetSet(i18n("Project Plugin Targets"));
 
     QList<TargetModel::TargetSet> targets = m_targetsUi->targetsModel.targetSets();
 
     cg.writeEntry("NumTargets", targets.size());
 
     for (int i=0; i<targets.size(); i++) {
         cg.writeEntry(QStringLiteral("%1 Target").arg(i), targets[i].name);
         cg.writeEntry(QStringLiteral("%1 BuildPath").arg(i), targets[i].workDir);
         QStringList cmdNames;
 
         for (int j=0; j<targets[i].commands.count(); j++) {
             const QString& cmdName = targets[i].commands[j].first;
             const QString& buildCmd = targets[i].commands[j].second;
             cmdNames << cmdName;
             cg.writeEntry(QStringLiteral("%1 BuildCmd %2").arg(i).arg(cmdName), buildCmd);
         }
         cg.writeEntry(QStringLiteral("%1 Target Names").arg(i), cmdNames);
         cg.writeEntry(QStringLiteral("%1 Target Default").arg(i), targets[i].defaultCmd);
     }
     int setRow = 0;
     int set = 0;
     QModelIndex ind = m_targetsUi->targetsView->currentIndex();
     if (ind.internalId() == TargetModel::InvalidIndex) {
         set = ind.row();
     }
     else {
         set = ind.internalId();
         setRow = ind.row();
     }
     if (setRow < 0) setRow = 0;
 
     cg.writeEntry(QStringLiteral("Active Target Index"), set);
     cg.writeEntry(QStringLiteral("Active Target Command"), setRow);
     cg.writeEntry(QStringLiteral("Show Marks"), m_showMarks->isChecked());
 
     // Restore project targets, if any
     slotAddProjectTarget();
 }
 
 
 /******************************************************************/
 void KateBuildView::slotNext()
 {
     const int itemCount = m_buildUi.errTreeWidget->topLevelItemCount();
     if (itemCount == 0) {
         return;
     }
 
     QTreeWidgetItem *item = m_buildUi.errTreeWidget->currentItem();
     if (item && item->isHidden()) item = nullptr;
 
     int i = (item == nullptr) ? -1 : m_buildUi.errTreeWidget->indexOfTopLevelItem(item);
 
     while (++i < itemCount) {
         item = m_buildUi.errTreeWidget->topLevelItem(i);
         // Search item which fit view settings and has desired data
         if (!item->text(1).isEmpty() && !item->isHidden() && item->data(1, Qt::UserRole).toInt()) {
             m_buildUi.errTreeWidget->setCurrentItem(item);
             m_buildUi.errTreeWidget->scrollToItem(item);
             slotErrorSelected(item);
             return;
         }
     }
 }
 
 /******************************************************************/
 void KateBuildView::slotPrev()
 {
     const int itemCount = m_buildUi.errTreeWidget->topLevelItemCount();
     if (itemCount == 0) {
         return;
     }
 
     QTreeWidgetItem *item = m_buildUi.errTreeWidget->currentItem();
     if (item && item->isHidden()) item = nullptr;
 
     int i = (item == nullptr) ? itemCount : m_buildUi.errTreeWidget->indexOfTopLevelItem(item);
 
     while (--i >= 0) {
         item = m_buildUi.errTreeWidget->topLevelItem(i);
         // Search item which fit view settings and has desired data
         if (!item->text(1).isEmpty() && !item->isHidden() && item->data(1, Qt::UserRole).toInt()) {
             m_buildUi.errTreeWidget->setCurrentItem(item);
             m_buildUi.errTreeWidget->scrollToItem(item);
             slotErrorSelected(item);
             return;
         }
     }
 }
 
 /******************************************************************/
 void KateBuildView::slotErrorSelected(QTreeWidgetItem *item)
 {
     // any view active?
     if (!m_win->activeView()) {
         return;
     }
 
     // Avoid garish highlighting of the selected line
     m_win->activeView()->setFocus();
 
     // Search the item where the data we need is stored
     while (!item->data(1, Qt::UserRole).toInt()) {
         item = m_buildUi.errTreeWidget->itemAbove(item);
         if (!item) {
             return;
         }
     }
 
     // get stuff
     const QString filename = item->data(0, Qt::UserRole).toString();
     if (filename.isEmpty()) {
         return;
     }
 
     int line = item->data(1, Qt::UserRole).toInt();
     int column = item->data(2, Qt::UserRole).toInt();
     // check with moving cursor
     auto data = item->data(0, DataRole).value<ItemData>();
     if (data.cursor) {
         line = data.cursor->line();
         column = data.cursor->column();
     }
 
     // open file (if needed, otherwise, this will activate only the right view...)
     m_win->openUrl(QUrl::fromLocalFile(filename));
 
     // do it ;)
     m_win->activeView()->setCursorPosition(KTextEditor::Cursor(line-1, column-1));
 }
 
 
 /******************************************************************/
 void KateBuildView::addError(const QString &filename, const QString &line,
                              const QString &column, const QString &message)
 {
     ErrorCategory errorCategory = CategoryInfo;
     QTreeWidgetItem* item = new QTreeWidgetItem(m_buildUi.errTreeWidget);
     item->setBackground(1, Qt::gray);
     // The strings are twice in case kate is translated but not make.
     if (message.contains(QStringLiteral("error")) ||
         message.contains(i18nc("The same word as 'make' uses to mark an error.","error")) ||
         message.contains(QStringLiteral("undefined reference")) ||
         message.contains(i18nc("The same word as 'ld' uses to mark an ...","undefined reference"))
        )
     {
         errorCategory = CategoryError;
         item->setForeground(1, Qt::red);
         m_numErrors++;
         item->setHidden(false);
     }
     if (message.contains(QStringLiteral("warning")) ||
         message.contains(i18nc("The same word as 'make' uses to mark a warning.","warning"))
        )
     {
         errorCategory = CategoryWarning;
         item->setForeground(1, Qt::yellow);
         m_numWarnings++;
         item->setHidden(m_buildUi.displayModeSlider->value() > 2);
     }
     item->setTextAlignment(1, Qt::AlignRight);
 
     // visible text
     //remove path from visible file name
     QFileInfo file(filename);
     item->setText(0, file.fileName());
     item->setText(1, line);
     item->setText(2, message.trimmed());
 
     // used to read from when activating an item
     item->setData(0, Qt::UserRole, filename);
     item->setData(1, Qt::UserRole, line);
     item->setData(2, Qt::UserRole, column);
 
     if (errorCategory == CategoryInfo) {
       item->setHidden(m_buildUi.displayModeSlider->value() > 1);
     }
 
     item->setData(0, ErrorRole, errorCategory);
 
     // add tooltips in all columns
     // The enclosing <qt>...</qt> enables word-wrap for long error messages
     item->setData(0, Qt::ToolTipRole, filename);
     item->setData(1, Qt::ToolTipRole, QStringLiteral("<qt>%1</qt>").arg(message));
     item->setData(2, Qt::ToolTipRole, QStringLiteral("<qt>%1</qt>").arg(message));
 }
 
 void KateBuildView::clearMarks()
 {
     for (auto& doc: m_markedDocs) {
         if (!doc) {
             continue;
         }
 
         KTextEditor::MarkInterface* iface = qobject_cast<KTextEditor::MarkInterface*>(doc);
         if (iface) {
             const QHash<int, KTextEditor::Mark*> marks = iface->marks();
             QHashIterator<int, KTextEditor::Mark*> i(marks);
             while (i.hasNext()) {
                 i.next();
                 auto markType = KTextEditor::MarkInterface::Error | KTextEditor::MarkInterface::Warning;
                 if (i.value()->type & markType) {
                     iface->removeMark(i.value()->line, markType);
                 }
             }
         }
     }
 
     m_markedDocs.clear();
 }
 
 void KateBuildView::addMarks(KTextEditor::Document *doc, bool mark)
 {
     KTextEditor::MarkInterface* iface = qobject_cast<KTextEditor::MarkInterface*>(doc);
     KTextEditor::MovingInterface* miface = qobject_cast<KTextEditor::MovingInterface*>(doc);
     if (!iface || m_markedDocs.contains(doc))
         return;
 
     QTreeWidgetItemIterator it(m_buildUi.errTreeWidget, QTreeWidgetItemIterator::All);
     while (*it) {
         QTreeWidgetItem *item = *it;
          ++it;
 
         auto filename = item->data(0, Qt::UserRole).toString();
         auto url = QUrl::fromLocalFile(filename);
         if (url != doc->url())
             continue;
 
         auto line = item->data(1, Qt::UserRole).toInt();
         if (mark) {
             ErrorCategory category = (ErrorCategory)item->data(0, ErrorRole).toInt();
             KTextEditor::MarkInterface::MarkTypes markType {};
 
             switch (category) {
             case CategoryError: {
                 markType = KTextEditor::MarkInterface::Error;
                 iface->setMarkDescription(markType, i18n("Error"));
                 break;
             }
             case CategoryWarning: {
                 markType = KTextEditor::MarkInterface::Warning;
                 iface->setMarkDescription(markType, i18n("Warning"));
                 break;
             }
             default:
                 break;
             }
 
             if (markType) {
                 const int ps = 32;
                 iface->setMarkPixmap(markType, messageIcon(category).pixmap(ps, ps));
                 iface->addMark(line - 1, markType);
             }
             m_markedDocs.insert(doc, doc);
         }
 
         // add moving cursor so link between message and location
         // is not broken by document changes
         if (miface) {
             auto data = item->data(0, DataRole).value<ItemData>();
             if (!data.cursor) {
                 auto column = item->data(2, Qt::UserRole).toInt();
                 data.cursor.reset(miface->newMovingCursor({line, column}));
                 QVariant var;
                 var.setValue(data);
                 item->setData(0, DataRole, var);
             }
         }
     }
 
     // ensure cleanup
     if (miface) {
         auto conn = connect(doc, SIGNAL(aboutToInvalidateMovingInterfaceContent(KTextEditor::Document*)),
             this, SLOT(slotInvalidateMoving(KTextEditor::Document*)), Qt::UniqueConnection);
         conn = connect(doc, SIGNAL(aboutToDeleteMovingInterfaceContent(KTextEditor::Document*)),
             this, SLOT(slotInvalidateMoving(KTextEditor::Document*)), Qt::UniqueConnection);
     }
 
     connect(doc, SIGNAL(markClicked(KTextEditor::Document*, KTextEditor::Mark, bool&)),
         this, SLOT(slotMarkClicked(KTextEditor::Document*,KTextEditor::Mark, bool&)), Qt::UniqueConnection);
 }
 
 void KateBuildView::slotInvalidateMoving(KTextEditor::Document* doc)
 {
     QTreeWidgetItemIterator it(m_buildUi.errTreeWidget, QTreeWidgetItemIterator::All);
     while (*it) {
         QTreeWidgetItem *item = *it;
          ++it;
 
         auto data = item->data(0, DataRole).value<ItemData>();
         if (data.cursor && data.cursor->document() == doc) {
             item->setData(0, DataRole, 0);
         }
     }
 }
 
 void KateBuildView::slotMarkClicked(KTextEditor::Document *doc, KTextEditor::Mark mark, bool &handled)
 {
     auto tree = m_buildUi.errTreeWidget;
     QTreeWidgetItemIterator it(tree, QTreeWidgetItemIterator::All);
     while (*it) {
         QTreeWidgetItem *item = *it;
          ++it;
 
         auto filename = item->data(0, Qt::UserRole).toString();
         auto line = item->data(1, Qt::UserRole).toInt();
         // prefer moving cursor's opinion if so available
         auto data = item->data(0, DataRole).value<ItemData>();
         if (data.cursor) {
             line = data.cursor->line();
         }
         if (line - 1 == mark.line && QUrl::fromLocalFile(filename) == doc->url()) {
             tree->blockSignals(true);
             tree->setCurrentItem(item);
             tree->scrollToItem(item, QAbstractItemView::PositionAtCenter);
             tree->blockSignals(false);
             handled = true;
             break;
         }
     }
 }
 
 void KateBuildView::slotViewChanged()
 {
     KTextEditor::View *activeView = m_win->activeView();
     auto doc = activeView ? activeView->document() : nullptr;
 
     if (doc) {
         addMarks(doc, m_showMarks->isChecked());
     }
 }
 
 void KateBuildView::slotDisplayOption()
 {
     if (m_showMarks) {
         if (!m_showMarks->isChecked()) {
             clearMarks();
         } else {
             slotViewChanged();
         }
     }
 }
 
 /******************************************************************/
 QUrl KateBuildView::docUrl()
 {
     KTextEditor::View *kv = m_win->activeView();
     if (!kv) {
         qDebug() << "no KTextEditor::View" << endl;
         return QUrl();
     }
 
     if (kv->document()->isModified()) kv->document()->save();
     return kv->document()->url();
 }
 
 /******************************************************************/
 bool KateBuildView::checkLocal(const QUrl &dir)
 {
     if (dir.path().isEmpty()) {
         KMessageBox::sorry(nullptr, i18n("There is no file or directory specified for building."));
         return false;
     }
     else if (!dir.isLocalFile()) {
         KMessageBox::sorry(nullptr,  i18n("The file \"%1\" is not a local file. "
         "Non-local files cannot be compiled.", dir.path()));
         return false;
     }
     return true;
 }
 
 
 
 /******************************************************************/
 void KateBuildView::clearBuildResults()
 {
     clearMarks();
     m_buildUi.plainTextEdit->clear();
     m_buildUi.errTreeWidget->clear();
     m_stdOut.clear();
     m_stdErr.clear();
     m_numErrors = 0;
     m_numWarnings = 0;
     m_make_dir_stack.clear();
 }
 
 /******************************************************************/
 bool KateBuildView::startProcess(const QString &dir, const QString &command)
 {
     if (m_proc.state() != QProcess::NotRunning) {
         return false;
     }
 
     // clear previous runs
     clearBuildResults();
 
     // activate the output tab
     m_buildUi.u_tabWidget->setCurrentIndex(1);
     m_displayModeBeforeBuild = m_buildUi.displayModeSlider->value();
     m_buildUi.displayModeSlider->setValue(0);
     m_win->showToolView(m_toolView);
 
     // set working directory
     m_make_dir = dir;
     m_make_dir_stack.push(m_make_dir);
 
     if (!QFile::exists(m_make_dir)) {
         KMessageBox::error(nullptr, i18n("Cannot run command: %1\nWork path does not exist: %2", command, m_make_dir));
         return false;
     }
 
     m_proc.setWorkingDirectory(m_make_dir);
     m_proc.setShellCommand(command);
     m_proc.start();
 
     if(!m_proc.waitForStarted(500)) {
         KMessageBox::error(nullptr, i18n("Failed to run \"%1\". exitStatus = %2", command, m_proc.exitStatus()));
         return false;
     }
 
     m_buildUi.cancelBuildButton->setEnabled(true);
     m_buildUi.cancelBuildButton2->setEnabled(true);
     m_buildUi.buildAgainButton->setEnabled(false);
     m_buildUi.buildAgainButton2->setEnabled(false);
 
     QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
     return true;
 }
 
 /******************************************************************/
 bool KateBuildView::slotStop()
 {
     if (m_proc.state() != QProcess::NotRunning) {
         m_buildCancelled = true;
         QString msg = i18n("Building <b>%1</b> cancelled", m_currentlyBuildingTarget);
         m_buildUi.buildStatusLabel->setText(msg);
         m_buildUi.buildStatusLabel2->setText(msg);
         m_proc.terminate();
         return true;
     }
     return false;
 }
 
 /******************************************************************/
 void KateBuildView::slotBuildActiveTarget() {
     if (!m_targetsUi->targetsView->currentIndex().isValid()) {
         slotSelectTarget();
     }
     else {
         buildCurrentTarget();
     }
 }
 
 /******************************************************************/
 void KateBuildView::slotBuildPreviousTarget() {
     if (!m_previousIndex.isValid()) {
         slotSelectTarget();
     }
     else {
         m_targetsUi->targetsView->setCurrentIndex(m_previousIndex);
         buildCurrentTarget();
     }
 }
 
 
 /******************************************************************/
 void KateBuildView::slotBuildDefaultTarget() {
     QModelIndex defaultTarget = m_targetsUi->targetsModel.defaultTarget(m_targetsUi->targetsView->currentIndex());
     m_targetsUi->targetsView->setCurrentIndex(defaultTarget);
     buildCurrentTarget();
 }
 
 
 /******************************************************************/
 void KateBuildView::slotSelectTarget() {
     SelectTargetView *dialog = new SelectTargetView(&(m_targetsUi->targetsModel));
 
     dialog->setCurrentIndex(m_targetsUi->targetsView->currentIndex());
 
     int result = dialog->exec();
     if (result == QDialog::Accepted) {
         m_targetsUi->targetsView->setCurrentIndex(dialog->currentIndex());
         buildCurrentTarget();
     }
     delete dialog;
     dialog = nullptr;
 }
 
 
 /******************************************************************/
 bool KateBuildView::buildCurrentTarget()
 {
     if (m_proc.state() != QProcess::NotRunning) {
         displayBuildResult(i18n("Already building..."), KTextEditor::Message::Warning);
         return false;
     }
 
     QFileInfo docFInfo = docUrl().toLocalFile(); // docUrl() saves the current document
 
     QModelIndex ind = m_targetsUi->targetsView->currentIndex();
     m_previousIndex = ind;
     if (!ind.isValid()) {
         KMessageBox::sorry(nullptr, i18n("No target available for building."));
         return false;
     }
 
     QString buildCmd = m_targetsUi->targetsModel.command(ind);
     QString cmdName = m_targetsUi->targetsModel.cmdName(ind);
     QString workDir = m_targetsUi->targetsModel.workDir(ind);
     QString targetSet = m_targetsUi->targetsModel.targetName(ind);
 
     QString dir = workDir;
     if (workDir.isEmpty()) {
         dir = docFInfo.absolutePath();
         if (dir.isEmpty()) {
             KMessageBox::sorry(nullptr, i18n("There is no local file or directory specified for building."));
             return false;
         }
     }
 
     // a single target can serve to build lots of projects with similar directory layout
     if (m_projectPluginView) {
         QFileInfo baseDir = m_projectPluginView->property("projectBaseDir").toString();
         dir.replace(QStringLiteral("%B"), baseDir.absoluteFilePath());
         dir.replace(QStringLiteral("%b"), baseDir.baseName());
     }
 
     // Check if the command contains the file name or directory
     if (buildCmd.contains(QStringLiteral("%f")) ||
         buildCmd.contains(QStringLiteral("%d")) ||
         buildCmd.contains(QStringLiteral("%n")))
     {
 
         if (docFInfo.absoluteFilePath().isEmpty()) {
             return false;
         }
 
         buildCmd.replace(QStringLiteral("%n"), docFInfo.baseName());
         buildCmd.replace(QStringLiteral("%f"), docFInfo.absoluteFilePath());
         buildCmd.replace(QStringLiteral("%d"), docFInfo.absolutePath());
     }
     m_filenameDetectorGccWorked = false;
     m_currentlyBuildingTarget = QStringLiteral("%1: %2").arg(targetSet, cmdName);
     m_buildCancelled = false;
     QString msg = i18n("Building target <b>%1</b> ...", m_currentlyBuildingTarget);
     m_buildUi.buildStatusLabel->setText(msg);
     m_buildUi.buildStatusLabel2->setText(msg);
     return startProcess(dir, buildCmd);
 }
 
 /******************************************************************/
 void KateBuildView::displayBuildResult(const QString &msg, KTextEditor::Message::MessageType level)
 {
     KTextEditor::View *kv = m_win->activeView();
     if (!kv) return;
 
     delete m_infoMessage;
     m_infoMessage = new KTextEditor::Message(xi18nc("@info", "<title>Make Results:</title><nl/>%1", msg), level);
     m_infoMessage->setWordWrap(true);
     m_infoMessage->setPosition(KTextEditor::Message::BottomInView);
     m_infoMessage->setAutoHide(5000);
     m_infoMessage->setAutoHideMode(KTextEditor::Message::Immediate);
     m_infoMessage->setView(kv);
     kv->document()->postMessage(m_infoMessage);
 }
 
 /******************************************************************/
 void KateBuildView::slotProcExited(int exitCode, QProcess::ExitStatus)
 {
     QApplication::restoreOverrideCursor();
     m_buildUi.cancelBuildButton->setEnabled(false);
     m_buildUi.cancelBuildButton2->setEnabled(false);
     m_buildUi.buildAgainButton->setEnabled(true);
     m_buildUi.buildAgainButton2->setEnabled(true);
 
     QString buildStatus = i18n("Building <b>%1</b> completed.", m_currentlyBuildingTarget);
 
     // did we get any errors?
     if (m_numErrors || m_numWarnings || (exitCode != 0)) {
        m_buildUi.u_tabWidget->setCurrentIndex(1);
        if (m_buildUi.displayModeSlider->value() == 0) {
            m_buildUi.displayModeSlider->setValue(m_displayModeBeforeBuild > 0 ? m_displayModeBeforeBuild: 1);
        }
        m_buildUi.errTreeWidget->resizeColumnToContents(0);
        m_buildUi.errTreeWidget->resizeColumnToContents(1);
        m_buildUi.errTreeWidget->resizeColumnToContents(2);
        m_buildUi.errTreeWidget->horizontalScrollBar()->setValue(0);
         //m_buildUi.errTreeWidget->setSortingEnabled(true);
         m_win->showToolView(m_toolView);
     }
 
     if (m_numErrors || m_numWarnings) {
         QStringList msgs;
         if (m_numErrors) {
             msgs << i18np("Found one error.", "Found %1 errors.", m_numErrors);
             buildStatus = i18n("Building <b>%1</b> had errors.", m_currentlyBuildingTarget);
         }
         else if (m_numWarnings) {
             msgs << i18np("Found one warning.", "Found %1 warnings.", m_numWarnings);
             buildStatus = i18n("Building <b>%1</b> had warnings.", m_currentlyBuildingTarget);
         }
         displayBuildResult(msgs.join(QLatin1Char('\n')), m_numErrors ? KTextEditor::Message::Error : KTextEditor::Message::Warning);
     }
     else if (exitCode != 0) {
         displayBuildResult(i18n("Build failed."), KTextEditor::Message::Warning);
     }
     else {
         displayBuildResult(i18n("Build completed without problems."), KTextEditor::Message::Positive);
     }
 
     if (!m_buildCancelled) {
         m_buildUi.buildStatusLabel->setText(buildStatus);
         m_buildUi.buildStatusLabel2->setText(buildStatus);
         m_buildCancelled = false;
         // add marks
         slotViewChanged();
     }
 
 }
 
 
 /******************************************************************/
 void KateBuildView::slotReadReadyStdOut()
 {
     // read data from procs stdout and add
     // the text to the end of the output
     // FIXME This works for utf8 but not for all charsets
     QString l = QString::fromUtf8(m_proc.readAllStandardOutput());
     l.remove(QLatin1Char('\r'));
     m_stdOut += l;
 
     // handle one line at a time
     do {
         const int end = m_stdOut.indexOf(QLatin1Char('\n'));
         if (end < 0) break;
 
         const QString line = m_stdOut.mid(0, end);
         m_buildUi.plainTextEdit->appendPlainText(line);
         //qDebug() << line;
 
         if (m_newDirDetector.match(line).hasMatch()) {
             //qDebug() << "Enter/Exit dir found";
             int open = line.indexOf(QLatin1Char('`'));
             int close = line.indexOf(QLatin1Char('\''));
             QString newDir = line.mid(open+1, close-open-1);
             //qDebug () << "New dir = " << newDir;
 
             if ((m_make_dir_stack.size() > 1) && (m_make_dir_stack.top() == newDir)) {
                 m_make_dir_stack.pop();
                 newDir = m_make_dir_stack.top();
             }
             else {
                 m_make_dir_stack.push(newDir);
             }
 
             m_make_dir = newDir;
         }
 
         m_stdOut.remove(0, end + 1);
     } while (1);
 }
 
 /******************************************************************/
 void KateBuildView::slotReadReadyStdErr()
 {
     // FIXME This works for utf8 but not for all charsets
     QString l = QString::fromUtf8(m_proc.readAllStandardError());
     l.remove(QLatin1Char('\r'));
     m_stdErr += l;
 
     do {
         const int end = m_stdErr.indexOf(QLatin1Char('\n'));
         if (end < 0) break;
 
         const QString line = m_stdErr.mid(0, end);
         m_buildUi.plainTextEdit->appendPlainText(line);
 
         processLine(line);
 
         m_stdErr.remove(0, end + 1);
     } while (1);
 }
 
 /******************************************************************/
 void KateBuildView::processLine(const QString &line)
 {
     //qDebug() << line ;
 
     //look for a filename
     QRegularExpressionMatch match = m_filenameDetector.match(line);
 
     if (match.hasMatch())
     {
         m_filenameDetectorGccWorked = true;
     }
     else
     {
         if (!m_filenameDetectorGccWorked)
         {
             // let's see whether the icpc regexp works:
             // so for icpc users error detection will be a bit slower,
             // since always both regexps are checked.
             // But this should be the minority, for gcc and clang users
             // both regexes will only be checked until the first regex
             // matched the first time.
             match = m_filenameDetectorIcpc.match(line);
         }
     }
 
     if (!match.hasMatch())
     {
         addError(QString(), QStringLiteral("0"), QString(), line);
         //kDebug() << "A filename was not found in the line ";
         return;
     }
 
     QString filename = match.captured(1);
     const QString line_n = match.captured(3);
     const QString msg = match.captured(4);
 
     //qDebug() << "File Name:"<<filename<< " msg:"<< msg;
     //add path to file
     if (QFile::exists(m_make_dir + QLatin1Char('/') + filename)) {
         filename = m_make_dir + QLatin1Char('/') + filename;
     }
 
     // get canonical path, if possible, to avoid duplicated opened files
     auto canonicalFilePath(QFileInfo(filename).canonicalFilePath());
     if (!canonicalFilePath.isEmpty()) {
         filename = canonicalFilePath;
     }
 
     // Now we have the data we need show the error/warning
     addError(filename, line_n, QStringLiteral("1"), msg);
 }
 
 
 /******************************************************************/
 void KateBuildView::slotAddTargetClicked()
 {
     QModelIndex current = m_targetsUi->targetsView->currentIndex();
     if (current.parent().isValid()) {
         current = current.parent();
     }
     QModelIndex index = m_targetsUi->targetsModel.addCommand(current.row(), DefTargetName, DefBuildCmd);
     m_targetsUi->targetsView->setCurrentIndex(index);
 }
 
 
 /******************************************************************/
 void KateBuildView::targetSetNew()
 {
     int row = m_targetsUi->targetsModel.addTargetSet(i18n("Target Set"), QString());
     QModelIndex buildIndex = m_targetsUi->targetsModel.addCommand(row, i18n("Build"), DefBuildCmd);
     m_targetsUi->targetsModel.addCommand(row, i18n("Clean"), DefCleanCmd);
     m_targetsUi->targetsModel.addCommand(row, i18n("Config"), DefConfigCmd);
     m_targetsUi->targetsModel.addCommand(row, i18n("ConfigClean"), DefConfClean);
     m_targetsUi->targetsView->setCurrentIndex(buildIndex);
 }
 
 /******************************************************************/
 void KateBuildView::targetOrSetCopy()
 {
     QModelIndex newIndex = m_targetsUi->targetsModel.copyTargetOrSet(m_targetsUi->targetsView->currentIndex());
     if (m_targetsUi->targetsModel.hasChildren(newIndex)) {
         m_targetsUi->targetsView->setCurrentIndex(newIndex.child(0,0));
         return;
     }
     m_targetsUi->targetsView->setCurrentIndex(newIndex);
 }
 
 
 /******************************************************************/
 void KateBuildView::targetDelete()
 {
     QModelIndex current = m_targetsUi->targetsView->currentIndex();
     m_targetsUi->targetsModel.deleteItem(current);
 
     if (m_targetsUi->targetsModel.rowCount() == 0) {
         targetSetNew();
     }
 }
 
 
 /******************************************************************/
 void KateBuildView::slotDisplayMode(int mode) {
     QTreeWidget *tree=m_buildUi.errTreeWidget;
     tree->setVisible(mode != 0);
     m_buildUi.plainTextEdit->setVisible(mode == 0);
 
     QString modeText;
     switch(mode)
     {
         case OnlyErrors:
             modeText = i18n("Only Errors");
             break;
         case ErrorsAndWarnings:
             modeText = i18n("Errors and Warnings");
             break;
         case ParsedOutput:
             modeText = i18n("Parsed Output");
             break;
         case FullOutput:
             modeText = i18n("Full Output");
             break;
     }
     m_buildUi.displayModeLabel->setText(modeText);
 
     if (mode < 1) {
         return;
     }
 
     const int itemCount = tree->topLevelItemCount();
 
     for (int i=0;i<itemCount;i++) {
         QTreeWidgetItem* item=tree->topLevelItem(i);
 
         const ErrorCategory errorCategory = static_cast<ErrorCategory>(item->data(0, ErrorRole).toInt());
 
         switch (errorCategory)
         {
         case CategoryInfo:
             item->setHidden(mode > 1);
             break;
         case CategoryWarning:
             item->setHidden(mode > 2);
             break;
         case CategoryError:
             item->setHidden(false);
             break;
         }
     }
 }
 
 /******************************************************************/
 void KateBuildView::slotPluginViewCreated(const QString &name, QObject *pluginView)
 {
     // add view
     if (pluginView && name == QLatin1String("kateprojectplugin")) {
         m_projectPluginView = pluginView;
         slotAddProjectTarget();
         connect(pluginView, SIGNAL(projectMapChanged()), this, SLOT(slotProjectMapChanged()), Qt::UniqueConnection);
     }
 }
 
 /******************************************************************/
 void KateBuildView::slotPluginViewDeleted(const QString &name, QObject *)
 {
     // remove view
     if (name == QLatin1String("kateprojectplugin")) {
         m_projectPluginView = nullptr;
         m_targetsUi->targetsModel.deleteTargetSet(i18n("Project Plugin Targets"));
     }
 }
 
 /******************************************************************/
 void KateBuildView::slotProjectMapChanged()
 {
     // only do stuff with valid project
     if (!m_projectPluginView) {
         return;
     }
     m_targetsUi->targetsModel.deleteTargetSet(i18n("Project Plugin Targets"));
     slotAddProjectTarget();
 }
 
 /******************************************************************/
 void KateBuildView::slotAddProjectTarget()
 {
     // only do stuff with valid project
     if (!m_projectPluginView) {
         return;
     }
     // query new project map
     QVariantMap projectMap = m_projectPluginView->property("projectMap").toMap();
 
     // do we have a valid map for build settings?
     QVariantMap buildMap = projectMap.value(QStringLiteral("build")).toMap();
     if (buildMap.isEmpty()) {
         return;
     }
 
     // Delete any old project plugin targets
     m_targetsUi->targetsModel.deleteTargetSet(i18n("Project Plugin Targets"));
 
     int set = m_targetsUi->targetsModel.addTargetSet(i18n("Project Plugin Targets"),
                                                      buildMap.value(QStringLiteral("directory")).toString());
 
     QVariantList targetsets = buildMap.value(QStringLiteral("targets")).toList();
     foreach (const QVariant &targetVariant, targetsets) {
         QVariantMap targetMap = targetVariant.toMap();
         QString tgtName = targetMap[QStringLiteral("name")].toString();
         QString buildCmd = targetMap[QStringLiteral("build_cmd")].toString();
 
         if (tgtName.isEmpty() || buildCmd.isEmpty()) {
             continue;
         }
         m_targetsUi->targetsModel.addCommand(set, tgtName, buildCmd);
     }
 
     QModelIndex ind = m_targetsUi->targetsModel.index(set);
     if (!ind.child(0,0).data().isValid()) {
         QString buildCmd = buildMap.value(QStringLiteral("build")).toString();
         QString cleanCmd = buildMap.value(QStringLiteral("clean")).toString();
         QString quickCmd = buildMap.value(QStringLiteral("quick")).toString();
         if (!buildCmd.isEmpty()) {
             // we have loaded an "old" project file (<= 4.12)
             m_targetsUi->targetsModel.addCommand(set, i18n("build"), buildCmd);
         }
         if (!cleanCmd.isEmpty()) {
             m_targetsUi->targetsModel.addCommand(set, i18n("clean"), cleanCmd);
         }
         if (!quickCmd.isEmpty()) {
             m_targetsUi->targetsModel.addCommand(set, i18n("quick"), quickCmd);
         }
     }
 }
 
 /******************************************************************/
 bool KateBuildView::eventFilter(QObject *obj, QEvent *event)
 {
     if (event->type() == QEvent::KeyPress) {
         QKeyEvent *ke = static_cast<QKeyEvent*>(event);
         if ((obj == m_toolView) && (ke->key() == Qt::Key_Escape)) {
             m_win->hideToolView(m_toolView);
             event->accept();
             return true;
         }
     }
     if ((event->type() == QEvent::Resize) && (obj == m_buildWidget)) {
         if (m_buildUi.u_tabWidget->currentIndex() == 1) {
             if ((m_outputWidgetWidth == 0) && m_buildUi.buildAgainButton->isVisible()) {
                 QSize msh = m_buildWidget->minimumSizeHint();
                 m_outputWidgetWidth = msh.width();
             }
         }
         bool useVertLayout = (m_buildWidget->width() < m_outputWidgetWidth);
         m_buildUi.buildAgainButton->setVisible(!useVertLayout);
         m_buildUi.cancelBuildButton->setVisible(!useVertLayout);
         m_buildUi.buildStatusLabel->setVisible(!useVertLayout);
         m_buildUi.buildAgainButton2->setVisible(useVertLayout);
         m_buildUi.cancelBuildButton2->setVisible(useVertLayout);
         m_buildUi.buildStatusLabel2->setVisible(useVertLayout);
     }
 
     return QObject::eventFilter(obj, event);
 }
 
 /******************************************************************/
 void KateBuildView::handleEsc(QEvent *e)
 {
     if (!m_win) return;
 
     QKeyEvent *k = static_cast<QKeyEvent *>(e);
     if (k->key() == Qt::Key_Escape && k->modifiers() == Qt::NoModifier) {
         if (m_toolView->isVisible()) {
             m_win->hideToolView(m_toolView);
         }
     }
 }
 
 
 #include "plugin_katebuild.moc"
 
 // kate: space-indent on; indent-width 4; replace-tabs on;
diff --git a/addons/lspclient/lspclientcompletion.cpp b/addons/lspclient/lspclientcompletion.cpp
index 8e597951a..08577d7cd 100644
--- a/addons/lspclient/lspclientcompletion.cpp
+++ b/addons/lspclient/lspclientcompletion.cpp
@@ -1,336 +1,337 @@
 /*  SPDX-License-Identifier: MIT
 
     Copyright (C) 2019 Mark Nauwelaerts <mark.nauwelaerts@gmail.com>
 
     Permission is hereby granted, free of charge, to any person obtaining
     a copy of this software and associated documentation files (the
     "Software"), to deal in the Software without restriction, including
     without limitation the rights to use, copy, modify, merge, publish,
     distribute, sublicense, and/or sell copies of the Software, and to
     permit persons to whom the Software is furnished to do so, subject to
     the following conditions:
 
     The above copyright notice and this permission notice shall be included
     in all copies or substantial portions of the Software.
 
     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "lspclientcompletion.h"
 #include "lspclientplugin.h"
 
 #include "lspclient_debug.h"
 
 #include <KTextEditor/Cursor>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
 #include <QIcon>
 #include <QUrl>
 
 #include <algorithm>
+#include <utility>
 
 #define RETURN_CACHED_ICON(name)                                                                   \
     {                                                                                              \
         static QIcon icon(QIcon::fromTheme(QStringLiteral(name)));                                 \
         return icon;                                                                               \
     }
 
 static QIcon kind_icon(LSPCompletionItemKind kind)
 {
     switch (kind) {
     case LSPCompletionItemKind::Method:
     case LSPCompletionItemKind::Function:
     case LSPCompletionItemKind::Constructor:
         RETURN_CACHED_ICON("code-function")
     case LSPCompletionItemKind::Variable:
         RETURN_CACHED_ICON("code-variable")
     case LSPCompletionItemKind::Class:
     case LSPCompletionItemKind::Interface:
     case LSPCompletionItemKind::Struct:
         RETURN_CACHED_ICON("code-class");
     case LSPCompletionItemKind::Module:
         RETURN_CACHED_ICON("code-block");
     case LSPCompletionItemKind::Field:
     case LSPCompletionItemKind::Property:
         // align with symbolview
         RETURN_CACHED_ICON("code-variable");
     case LSPCompletionItemKind::Enum:
     case LSPCompletionItemKind::EnumMember:
         RETURN_CACHED_ICON("enum");
     default:
         break;
     }
     return QIcon();
 }
 
 static KTextEditor::CodeCompletionModel::CompletionProperty
 kind_property(LSPCompletionItemKind kind)
 {
     using CompletionProperty = KTextEditor::CodeCompletionModel::CompletionProperty;
     auto p = CompletionProperty::NoProperty;
 
     switch (kind) {
     case LSPCompletionItemKind::Method:
     case LSPCompletionItemKind::Function:
     case LSPCompletionItemKind::Constructor:
         p = CompletionProperty::Function;
         break;
     case LSPCompletionItemKind::Variable:
         p = CompletionProperty::Variable;
         break;
     case LSPCompletionItemKind::Class:
     case LSPCompletionItemKind::Interface:
         p = CompletionProperty::Class;
         break;
     case LSPCompletionItemKind::Struct:
         p = CompletionProperty::Class;
         break;
     case LSPCompletionItemKind::Module:
         p = CompletionProperty::Namespace;
         break;
     case LSPCompletionItemKind::Enum:
     case LSPCompletionItemKind::EnumMember:
         p = CompletionProperty::Enum;
         break;
     default:
         break;
     }
     return p;
 }
 
 struct LSPClientCompletionItem : public LSPCompletionItem {
     int argumentHintDepth = 0;
     QString prefix;
     QString postfix;
 
     LSPClientCompletionItem(const LSPCompletionItem &item) : LSPCompletionItem(item)
     {
         // transform for later display
         // sigh, remove (leading) whitespace (looking at clangd here)
         // could skip the [] if empty detail, but it is a handy watermark anyway ;-)
         label = QString(label.simplified() + QStringLiteral(" [") + detail.simplified()
                         + QStringLiteral("]"));
     }
 
     LSPClientCompletionItem(const LSPSignatureInformation &sig, int activeParameter,
                             const QString &_sortText)
     {
         argumentHintDepth = 1;
         documentation = sig.documentation;
         label = sig.label;
         sortText = _sortText;
         // transform into prefix, name, suffix if active
         if (activeParameter >= 0 && activeParameter < sig.parameters.length()) {
             const auto &param = sig.parameters.at(activeParameter);
             if (param.start >= 0 && param.start < label.length() && param.end >= 0
                 && param.end < label.length() && param.start < param.end) {
                 prefix = label.mid(0, param.start);
                 postfix = label.mid(param.end);
                 label = label.mid(param.start, param.end - param.start);
             }
         }
     }
 };
 
-static bool compare_match(const LSPCompletionItem &a, const LSPCompletionItem b)
+static bool compare_match(const LSPCompletionItem &a, const LSPCompletionItem& b)
 {
     return a.sortText < b.sortText;
 }
 
 class LSPClientCompletionImpl : public LSPClientCompletion
 {
     Q_OBJECT
 
     typedef LSPClientCompletionImpl self_type;
 
     QSharedPointer<LSPClientServerManager> m_manager;
     QSharedPointer<LSPClientServer> m_server;
     bool m_selectedDocumentation = false;
 
     QVector<QChar> m_triggersCompletion;
     QVector<QChar> m_triggersSignature;
     bool m_triggerSignature = false;
 
     QList<LSPClientCompletionItem> m_matches;
     LSPClientServer::RequestHandle m_handle, m_handleSig;
 
 public:
     LSPClientCompletionImpl(QSharedPointer<LSPClientServerManager> manager)
-        : LSPClientCompletion(nullptr), m_manager(manager), m_server(nullptr)
+        : LSPClientCompletion(nullptr), m_manager(std::move(manager)), m_server(nullptr)
     {
     }
 
     void setServer(QSharedPointer<LSPClientServer> server) override
     {
         m_server = server;
         if (m_server) {
             const auto &caps = m_server->capabilities();
             m_triggersCompletion = caps.completionProvider.triggerCharacters;
             m_triggersSignature = caps.signatureHelpProvider.triggerCharacters;
         } else {
             m_triggersCompletion.clear();
             m_triggersSignature.clear();
         }
     }
 
     virtual void setSelectedDocumentation(bool s) override { m_selectedDocumentation = s; }
 
     QVariant data(const QModelIndex &index, int role) const override
     {
         if (!index.isValid() || index.row() >= m_matches.size()) {
             return QVariant();
         }
 
         const auto &match = m_matches.at(index.row());
 
         if (role == Qt::DisplayRole) {
             if (index.column() == KTextEditor::CodeCompletionModel::Name) {
                 return match.label;
             } else if (index.column() == KTextEditor::CodeCompletionModel::Prefix) {
                 return match.prefix;
             } else if (index.column() == KTextEditor::CodeCompletionModel::Postfix) {
                 return match.postfix;
             }
         } else if (role == Qt::DecorationRole
                    && index.column() == KTextEditor::CodeCompletionModel::Icon) {
             return kind_icon(match.kind);
         } else if (role == KTextEditor::CodeCompletionModel::CompletionRole) {
             return kind_property(match.kind);
         } else if (role == KTextEditor::CodeCompletionModel::ArgumentHintDepth) {
             return match.argumentHintDepth;
         } else if (role == KTextEditor::CodeCompletionModel::InheritanceDepth) {
             // (ab)use depth to indicate sort order
             return index.row();
         } else if (role == KTextEditor::CodeCompletionModel::IsExpandable) {
             return !match.documentation.value.isEmpty();
         } else if (role == KTextEditor::CodeCompletionModel::ExpandingWidget
                    && !match.documentation.value.isEmpty()) {
             // probably plaintext, but let's show markdown as-is for now
             // FIXME better presentation of markdown
             return match.documentation.value;
         } else if (role == KTextEditor::CodeCompletionModel::ItemSelected
                    && !match.argumentHintDepth && !match.documentation.value.isEmpty()
                    && m_selectedDocumentation) {
             return match.documentation.value;
         }
 
         return QVariant();
     }
 
     bool shouldStartCompletion(KTextEditor::View *view, const QString &insertedText,
                                bool userInsertion, const KTextEditor::Cursor &position) override
     {
         qCInfo(LSPCLIENT) << "should start " << userInsertion << insertedText;
 
         if (!userInsertion || !m_server || insertedText.isEmpty()) {
             return false;
         }
 
         // covers most already ...
         bool complete = CodeCompletionModelControllerInterface::shouldStartCompletion(
                 view, insertedText, userInsertion, position);
         QChar lastChar = insertedText.at(insertedText.count() - 1);
 
         m_triggerSignature = false;
         complete = complete || m_triggersCompletion.contains(lastChar);
         if (m_triggersSignature.contains(lastChar)) {
             complete = true;
             m_triggerSignature = true;
         }
 
         return complete;
     }
 
     void completionInvoked(KTextEditor::View *view, const KTextEditor::Range &range,
                            InvocationType it) override
     {
         Q_UNUSED(it)
 
         qCInfo(LSPCLIENT) << "completion invoked" << m_server;
 
         // maybe use WaitForReset ??
         // but more complex and already looks good anyway
         auto handler = [this](const QList<LSPCompletionItem> & compl) {
             beginResetModel();
             qCInfo(LSPCLIENT) << "adding completions " << compl.size();
             for (const auto &item : compl)
                 m_matches.push_back(item);
             std::stable_sort(m_matches.begin(), m_matches.end(), compare_match);
             setRowCount(m_matches.size());
             endResetModel();
         };
 
         auto sigHandler = [this](const LSPSignatureHelp &sig) {
             beginResetModel();
             qCInfo(LSPCLIENT) << "adding signatures " << sig.signatures.size();
             int index = 0;
             for (const auto &item : sig.signatures) {
                 int sortIndex = 10 + index;
                 int active = -1;
                 if (index == sig.activeSignature) {
                     sortIndex = 0;
                     active = sig.activeParameter;
                 }
                 // trick active first, others after that
                 m_matches.push_back(
                         { item, active, QString(QStringLiteral("%1").arg(sortIndex, 3, 10)) });
                 ++index;
             }
             std::stable_sort(m_matches.begin(), m_matches.end(), compare_match);
             setRowCount(m_matches.size());
             endResetModel();
         };
 
         beginResetModel();
         m_matches.clear();
         auto document = view->document();
         if (m_server && document) {
             // the default range is determined based on a reasonable identifier (word)
             // which is generally fine and nice, but let's pass actual cursor position
             // (which may be within this typical range)
             auto position = view->cursorPosition();
             auto cursor = qMax(range.start(), qMin(range.end(), position));
             m_manager->update(document, false);
             if (!m_triggerSignature) {
                 m_handle = m_server->documentCompletion(
                         document->url(), { cursor.line(), cursor.column() }, this, handler);
             }
             m_handleSig = m_server->signatureHelp(
                     document->url(), { cursor.line(), cursor.column() }, this, sigHandler);
         }
         setRowCount(m_matches.size());
         endResetModel();
     }
 
     void executeCompletionItem(KTextEditor::View *view, const KTextEditor::Range &word,
                                const QModelIndex &index) const override
     {
         if (index.row() < m_matches.size())
             view->document()->replaceText(word, m_matches.at(index.row()).insertText);
     }
 
     void aborted(KTextEditor::View *view) override
     {
         Q_UNUSED(view);
         beginResetModel();
         m_matches.clear();
         m_handle.cancel();
         m_handleSig.cancel();
         m_triggerSignature = false;
         endResetModel();
     }
 };
 
 LSPClientCompletion *LSPClientCompletion::new_(QSharedPointer<LSPClientServerManager> manager)
 {
-    return new LSPClientCompletionImpl(manager);
+    return new LSPClientCompletionImpl(std::move(manager));
 }
 
 #include "lspclientcompletion.moc"
diff --git a/addons/lspclient/lspclienthover.cpp b/addons/lspclient/lspclienthover.cpp
index 20e15dac8..6bdcf9fb4 100644
--- a/addons/lspclient/lspclienthover.cpp
+++ b/addons/lspclient/lspclienthover.cpp
@@ -1,118 +1,119 @@
 /*  SPDX-License-Identifier: MIT
 
     Copyright (C) 2019 Mark Nauwelaerts <mark.nauwelaerts@gmail.com>
     Copyright (C) 2019 Christoph Cullmann <cullmann@kde.org>
 
     Permission is hereby granted, free of charge, to any person obtaining
     a copy of this software and associated documentation files (the
     "Software"), to deal in the Software without restriction, including
     without limitation the rights to use, copy, modify, merge, publish,
     distribute, sublicense, and/or sell copies of the Software, and to
     permit persons to whom the Software is furnished to do so, subject to
     the following conditions:
 
     The above copyright notice and this permission notice shall be included
     in all copies or substantial portions of the Software.
 
     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "lspclienthover.h"
 #include "lspclientplugin.h"
 
 #include "lspclient_debug.h"
 
 #include <KTextEditor/Cursor>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
 #include <QToolTip>
+#include <utility>
 
 class LSPClientHoverImpl : public LSPClientHover
 {
     Q_OBJECT
 
     typedef LSPClientHoverImpl self_type;
 
     QSharedPointer<LSPClientServerManager> m_manager;
     QSharedPointer<LSPClientServer> m_server;
 
     LSPClientServer::RequestHandle m_handle;
 
 public:
     LSPClientHoverImpl(QSharedPointer<LSPClientServerManager> manager)
-        : LSPClientHover(), m_manager(manager), m_server(nullptr)
+        : LSPClientHover(), m_manager(std::move(manager)), m_server(nullptr)
     {
     }
 
     void setServer(QSharedPointer<LSPClientServer> server) override
     {
         m_server = server;
     }
 
     /**
      * This function is called whenever the users hovers over text such
      * that the text hint delay passes. Then, textHint() is called
      * for each registered TextHintProvider.
      *
      * Return the text hint (possibly Qt richtext) for @p view at @p position.
      *
      * If you do not have any contents to show, just return an empty QString().
      *
      * \param view the view that requests the text hint
      * \param position text cursor under the mouse position
      * \return text tool tip to be displayed, may be Qt richtext
      */
     QString textHint(KTextEditor::View *view,
                              const KTextEditor::Cursor &position) override
     {
         // hack: delayed handling of tooltip on our own, the API is too dumb for a-sync feedback ;=)
         if (m_server) {
             QPointer<KTextEditor::View> v(view);
             auto h = [this,v,position] (const LSPHover & info)
             {
                 if (!v || info.contents.isEmpty()) {
                     return;
                 }
 
                 // combine contents elements to one string
                 QString finalTooltip;
                 for (auto &element : info.contents) {
                     if (!finalTooltip.isEmpty()) {
                         finalTooltip.append(QLatin1Char('\n'));
                     }
                     finalTooltip.append(element.value);
                 }
 
                 // we need to cut this a bit if too long until we have
                 // something more sophisticated than a tool tip for it
                 if (finalTooltip.size() > 512) {
                     finalTooltip.resize(512);
                     finalTooltip.append(QStringLiteral("..."));
                 }
 
                 // show tool tip: think about a better way for "large" stuff
                 QToolTip::showText(v->mapToGlobal(v->cursorToCoordinate(position)), finalTooltip);
             };
 
             m_handle.cancel() = m_server->documentHover(view->document()->url(), position, this, h);
         }
 
         return QString();
     }
 
 };
 
 LSPClientHover*
 LSPClientHover::new_(QSharedPointer<LSPClientServerManager> manager)
 {
-    return new LSPClientHoverImpl(manager);
+    return new LSPClientHoverImpl(std::move(manager));
 }
 
 #include "lspclienthover.moc"
diff --git a/addons/lspclient/lspclientpluginview.cpp b/addons/lspclient/lspclientpluginview.cpp
index 46f69c6ee..12b55b2a5 100644
--- a/addons/lspclient/lspclientpluginview.cpp
+++ b/addons/lspclient/lspclientpluginview.cpp
@@ -1,1693 +1,1694 @@
 /*  SPDX-License-Identifier: MIT
 
     Copyright (C) 2019 Mark Nauwelaerts <mark.nauwelaerts@gmail.com>
 
     Permission is hereby granted, free of charge, to any person obtaining
     a copy of this software and associated documentation files (the
     "Software"), to deal in the Software without restriction, including
     without limitation the rights to use, copy, modify, merge, publish,
     distribute, sublicense, and/or sell copies of the Software, and to
     permit persons to whom the Software is furnished to do so, subject to
     the following conditions:
 
     The above copyright notice and this permission notice shall be included
     in all copies or substantial portions of the Software.
 
     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "lspclientpluginview.h"
 #include "lspclientsymbolview.h"
 #include "lspclientplugin.h"
 #include "lspclientservermanager.h"
 #include "lspclientcompletion.h"
 #include "lspclienthover.h"
 
 #include "lspclient_debug.h"
 
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KLocalizedString>
 #include <KStandardAction>
 #include <KXMLGUIFactory>
 #include <KAcceleratorManager>
 
 #include <KTextEditor/CodeCompletionInterface>
 #include <KTextEditor/Document>
 #include <KTextEditor/MainWindow>
 #include <KTextEditor/View>
 #include <KTextEditor/Message>
 #include <KTextEditor/MovingInterface>
 #include <KXMLGUIClient>
 
 #include <ktexteditor/markinterface.h>
 #include <ktexteditor/movinginterface.h>
 #include <ktexteditor/movingrange.h>
 #include <ktexteditor/configinterface.h>
 
 #include <QKeyEvent>
 #include <QHBoxLayout>
 #include <QAction>
 #include <QTreeView>
 #include <QStandardItem>
 #include <QHeaderView>
 #include <QInputDialog>
 #include <QTimer>
 #include <QSet>
 #include <QTextCodec>
 #include <QApplication>
 #include <QFileInfo>
 #include <QJsonObject>
+#include <utility>
 
 namespace RangeData {
 
 enum {
     // preserve UserRole for generic use where needed
     FileUrlRole = Qt::UserRole + 1,
     RangeRole,
     KindRole,
 };
 
 class KindEnum
 {
 public:
     enum _kind {
         Text = (int)LSPDocumentHighlightKind::Text,
         Read = (int)LSPDocumentHighlightKind::Read,
         Write = (int)LSPDocumentHighlightKind::Write,
         Error = 10 + (int)LSPDiagnosticSeverity::Error,
         Warning = 10 + (int)LSPDiagnosticSeverity::Warning,
         Information = 10 + (int)LSPDiagnosticSeverity::Information,
         Hint = 10 + (int)LSPDiagnosticSeverity::Hint,
         Related
     };
 
     KindEnum(int v) { m_value = (_kind)v; }
 
     KindEnum(LSPDocumentHighlightKind hl) : KindEnum((_kind)(hl)) {}
 
     KindEnum(LSPDiagnosticSeverity sev) : KindEnum(_kind(10 + (int)sev)) {}
 
     operator _kind() { return m_value; }
 
 private:
     _kind m_value;
 };
 
 static constexpr KTextEditor::MarkInterface::MarkTypes markType =
         KTextEditor::MarkInterface::markType31;
 static constexpr KTextEditor::MarkInterface::MarkTypes markTypeDiagError =
         KTextEditor::MarkInterface::Error;
 static constexpr KTextEditor::MarkInterface::MarkTypes markTypeDiagWarning =
         KTextEditor::MarkInterface::Warning;
 static constexpr KTextEditor::MarkInterface::MarkTypes markTypeDiagOther =
         KTextEditor::MarkInterface::markType30;
 static constexpr KTextEditor::MarkInterface::MarkTypes markTypeDiagAll =
         KTextEditor::MarkInterface::MarkTypes(markTypeDiagError | markTypeDiagWarning
                                               | markTypeDiagOther);
 
 }
 
 static QIcon diagnosticsIcon(LSPDiagnosticSeverity severity)
 {
 #define RETURN_CACHED_ICON(name)                                                                   \
     {                                                                                              \
         static QIcon icon(QIcon::fromTheme(QStringLiteral(name)));                                 \
         return icon;                                                                               \
     }
     switch (severity) {
     case LSPDiagnosticSeverity::Error:
         RETURN_CACHED_ICON("dialog-error")
     case LSPDiagnosticSeverity::Warning:
         RETURN_CACHED_ICON("dialog-warning")
     case LSPDiagnosticSeverity::Information:
     case LSPDiagnosticSeverity::Hint:
         RETURN_CACHED_ICON("dialog-information")
     default:
         break;
     }
     return QIcon();
 }
 
 static QIcon codeActionIcon()
 {
     static QIcon icon(QIcon::fromTheme(QStringLiteral("insert-text")));
     return icon;
 }
 
 KTextEditor::Document *findDocument(KTextEditor::MainWindow *mainWindow, const QUrl &url)
 {
     auto views = mainWindow->views();
     for (const auto v : views) {
         auto doc = v->document();
         if (doc && doc->url() == url)
             return doc;
     }
     return nullptr;
 }
 
 // helper to read lines from unopened documents
 // lightweight and does not require additional symbols
 class FileLineReader
 {
     QFile file;
     int lastLineNo = -1;
     QString lastLine;
 
 public:
     FileLineReader(const QUrl &url) : file(url.path()) { file.open(QIODevice::ReadOnly); }
 
     // called with non-descending lineno
     QString line(int lineno)
     {
         if (lineno == lastLineNo) {
             return lastLine;
         }
         while (file.isOpen() && !file.atEnd()) {
             auto line = file.readLine();
             if (++lastLineNo == lineno) {
                 QTextCodec::ConverterState state;
                 QTextCodec *codec = QTextCodec::codecForName("UTF-8");
                 QString text = codec->toUnicode(line.constData(), line.size(), &state);
                 if (state.invalidChars > 0) {
                     text = QString::fromLatin1(line);
                 }
                 while (text.size() && text.at(text.size() - 1).isSpace())
                     text.chop(1);
                 lastLine = text;
                 return text;
             }
         }
         return QString();
     }
 };
 
 class LSPClientActionView : public QObject
 {
     Q_OBJECT
 
     typedef LSPClientActionView self_type;
 
     LSPClientPlugin *m_plugin;
     KTextEditor::MainWindow *m_mainWindow;
     KXMLGUIClient *m_client;
     QSharedPointer<LSPClientServerManager> m_serverManager;
     QScopedPointer<LSPClientViewTracker> m_viewTracker;
     QScopedPointer<LSPClientCompletion> m_completion;
     QScopedPointer<LSPClientHover> m_hover;
     QScopedPointer<QObject> m_symbolView;
 
     QPointer<QAction> m_findDef;
     QPointer<QAction> m_findDecl;
     QPointer<QAction> m_findRef;
     QPointer<QAction> m_triggerHighlight;
     QPointer<QAction> m_triggerHover;
     QPointer<QAction> m_triggerFormat;
     QPointer<QAction> m_triggerRename;
     QPointer<QAction> m_complDocOn;
     QPointer<QAction> m_refDeclaration;
     QPointer<QAction> m_onTypeFormatting;
     QPointer<QAction> m_incrementalSync;
     QPointer<QAction> m_diagnostics;
     QPointer<QAction> m_diagnosticsHighlight;
     QPointer<QAction> m_diagnosticsMark;
     QPointer<QAction> m_diagnosticsSwitch;
     QPointer<QAction> m_diagnosticsCloseNon;
     QPointer<QAction> m_restartServer;
     QPointer<QAction> m_restartAll;
 
     // toolview
     QScopedPointer<QWidget> m_toolView;
     QPointer<QTabWidget> m_tabWidget;
     // applied search ranges
     typedef QMultiHash<KTextEditor::Document *, KTextEditor::MovingRange *> RangeCollection;
     RangeCollection m_ranges;
     // applied marks
     typedef QSet<KTextEditor::Document *> DocumentCollection;
     DocumentCollection m_marks;
     // modelis either owned by tree added to tabwidget or owned here
     QScopedPointer<QStandardItemModel> m_ownedModel;
     // in either case, the model that directs applying marks/ranges
     QPointer<QStandardItemModel> m_markModel;
     // goto definition and declaration jump list is more a menu than a
     // search result, so let's not keep adding new tabs for those
     // previous tree for definition result
     QPointer<QTreeView> m_defTree;
     // ... and for declaration
     QPointer<QTreeView> m_declTree;
 
     // diagnostics tab
     QPointer<QTreeView> m_diagnosticsTree;
     // tree widget is either owned here or by tab
     QScopedPointer<QTreeView> m_diagnosticsTreeOwn;
     QScopedPointer<QStandardItemModel> m_diagnosticsModel;
     // diagnostics ranges
     RangeCollection m_diagnosticsRanges;
     // and marks
     DocumentCollection m_diagnosticsMarks;
 
     // views on which completions have been registered
     QSet<KTextEditor::View *> m_completionViews;
 
     // views on which hovers have been registered
     QSet<KTextEditor::View *> m_hoverViews;
 
     // outstanding request
     LSPClientServer::RequestHandle m_handle;
     // timeout on request
     bool m_req_timeout = false;
 
     // accept incoming applyEdit
     bool m_accept_edit = false;
     // characters to trigger format request
     QVector<QChar> m_onTypeFormattingTriggers;
 
     KActionCollection *actionCollection() const { return m_client->actionCollection(); }
 
 public:
     LSPClientActionView(LSPClientPlugin *plugin, KTextEditor::MainWindow *mainWin,
                         KXMLGUIClient *client, QSharedPointer<LSPClientServerManager> serverManager)
         : QObject(mainWin),
           m_plugin(plugin),
           m_mainWindow(mainWin),
           m_client(client),
-          m_serverManager(serverManager),
+          m_serverManager(std::move(serverManager)),
           m_completion(LSPClientCompletion::new_(m_serverManager)),
           m_hover(LSPClientHover::new_(m_serverManager)),
           m_symbolView(LSPClientSymbolView::new_(plugin, mainWin, m_serverManager))
     {
         connect(m_mainWindow, &KTextEditor::MainWindow::viewChanged, this, &self_type::updateState);
         connect(m_mainWindow, &KTextEditor::MainWindow::unhandledShortcutOverride, this,
                 &self_type::handleEsc);
         connect(m_serverManager.data(), &LSPClientServerManager::serverChanged, this,
                 &self_type::updateState);
 
         m_findDef = actionCollection()->addAction(QStringLiteral("lspclient_find_definition"), this,
                                                   &self_type::goToDefinition);
         m_findDef->setText(i18n("Go to Definition"));
         m_findDecl = actionCollection()->addAction(QStringLiteral("lspclient_find_declaration"),
                                                    this, &self_type::goToDeclaration);
         m_findDecl->setText(i18n("Go to Declaration"));
         m_findRef = actionCollection()->addAction(QStringLiteral("lspclient_find_references"), this,
                                                   &self_type::findReferences);
         m_findRef->setText(i18n("Find References"));
         m_triggerHighlight = actionCollection()->addAction(QStringLiteral("lspclient_highlight"),
                                                            this, &self_type::highlight);
         m_triggerHighlight->setText(i18n("Highlight"));
         // perhaps hover suggests to do so on mouse-over,
         // but let's just use a (convenient) action/shortcut for it
         m_triggerHover = actionCollection()->addAction(QStringLiteral("lspclient_hover"), this,
                                                        &self_type::hover);
         m_triggerHover->setText(i18n("Hover"));
         m_triggerFormat = actionCollection()->addAction(QStringLiteral("lspclient_format"), this,
                                                         &self_type::format);
         m_triggerFormat->setText(i18n("Format"));
         m_triggerRename = actionCollection()->addAction(QStringLiteral("lspclient_rename"), this,
                                                         &self_type::rename);
         m_triggerRename->setText(i18n("Rename"));
 
         // general options
         m_complDocOn = actionCollection()->addAction(QStringLiteral("lspclient_completion_doc"),
                                                      this, &self_type::displayOptionChanged);
         m_complDocOn->setText(i18n("Show selected completion documentation"));
         m_complDocOn->setCheckable(true);
         m_refDeclaration =
                 actionCollection()->addAction(QStringLiteral("lspclient_references_declaration"),
                                               this, &self_type::displayOptionChanged);
         m_refDeclaration->setText(i18n("Include declaration in references"));
         m_refDeclaration->setCheckable(true);
         m_onTypeFormatting =
                 actionCollection()->addAction(QStringLiteral("lspclient_type_formatting"), this,
                                               &self_type::displayOptionChanged);
         m_onTypeFormatting->setText(i18n("Format on typing"));
         m_onTypeFormatting->setCheckable(true);
         m_incrementalSync =
                 actionCollection()->addAction(QStringLiteral("lspclient_incremental_sync"), this,
                                               &self_type::displayOptionChanged);
         m_incrementalSync->setText(i18n("Incremental document synchronization"));
         m_incrementalSync->setCheckable(true);
 
         // diagnostics
         m_diagnostics = actionCollection()->addAction(QStringLiteral("lspclient_diagnostics"), this,
                                                       &self_type::displayOptionChanged);
         m_diagnostics->setText(i18n("Show diagnostics notifications"));
         m_diagnostics->setCheckable(true);
         m_diagnosticsHighlight =
                 actionCollection()->addAction(QStringLiteral("lspclient_diagnostics_highlight"),
                                               this, &self_type::displayOptionChanged);
         m_diagnosticsHighlight->setText(i18n("Show diagnostics highlights"));
         m_diagnosticsHighlight->setCheckable(true);
         m_diagnosticsMark =
                 actionCollection()->addAction(QStringLiteral("lspclient_diagnostics_mark"), this,
                                               &self_type::displayOptionChanged);
         m_diagnosticsMark->setText(i18n("Show diagnostics marks"));
         m_diagnosticsMark->setCheckable(true);
         m_diagnosticsSwitch =
                 actionCollection()->addAction(QStringLiteral("lspclient_diagnostic_switch"), this,
                                               &self_type::switchToDiagnostics);
         m_diagnosticsSwitch->setText(i18n("Switch to diagnostics tab"));
         m_diagnosticsCloseNon =
                 actionCollection()->addAction(QStringLiteral("lspclient_diagnostic_close_non"),
                                               this, &self_type::closeNonDiagnostics);
         m_diagnosticsCloseNon->setText(i18n("Close all non-diagnostics tabs"));
 
         // server control
         m_restartServer = actionCollection()->addAction(QStringLiteral("lspclient_restart_server"),
                                                         this, &self_type::restartCurrent);
         m_restartServer->setText(i18n("Restart LSP Server"));
         m_restartAll = actionCollection()->addAction(QStringLiteral("lspclient_restart_all"), this,
                                                      &self_type::restartAll);
         m_restartAll->setText(i18n("Restart All LSP Servers"));
 
         // popup menu
         auto menu = new KActionMenu(i18n("LSP Client"), this);
         actionCollection()->addAction(QStringLiteral("popup_lspclient"), menu);
         menu->addAction(m_findDef);
         menu->addAction(m_findDecl);
         menu->addAction(m_findRef);
         menu->addAction(m_triggerHighlight);
         menu->addAction(m_triggerHover);
         menu->addAction(m_triggerFormat);
         menu->addAction(m_triggerRename);
         menu->addSeparator();
         menu->addAction(m_complDocOn);
         menu->addAction(m_refDeclaration);
         menu->addAction(m_onTypeFormatting);
         menu->addAction(m_incrementalSync);
         menu->addSeparator();
         menu->addAction(m_diagnostics);
         menu->addAction(m_diagnosticsHighlight);
         menu->addAction(m_diagnosticsMark);
         menu->addAction(m_diagnosticsSwitch);
         menu->addAction(m_diagnosticsCloseNon);
         menu->addSeparator();
         menu->addAction(m_restartServer);
         menu->addAction(m_restartAll);
 
         // sync with plugin settings if updated
         connect(m_plugin, &LSPClientPlugin::update, this, &self_type::configUpdated);
 
         // toolview
         m_toolView.reset(mainWin->createToolView(
                 plugin, QStringLiteral("kate_lspclient"), KTextEditor::MainWindow::Bottom,
                 QIcon::fromTheme(QStringLiteral("application-x-ms-dos-executable")),
                 i18n("LSP Client")));
         m_tabWidget = new QTabWidget(m_toolView.data());
         m_toolView->layout()->addWidget(m_tabWidget);
         m_tabWidget->setFocusPolicy(Qt::NoFocus);
         m_tabWidget->setTabsClosable(true);
         KAcceleratorManager::setNoAccel(m_tabWidget);
         connect(m_tabWidget, &QTabWidget::tabCloseRequested, this, &self_type::tabCloseRequested);
 
         // diagnostics tab
         m_diagnosticsTree = new QTreeView();
         configureTreeView(m_diagnosticsTree);
         m_diagnosticsTree->setAlternatingRowColors(true);
         m_diagnosticsTreeOwn.reset(m_diagnosticsTree);
         m_diagnosticsModel.reset(new QStandardItemModel());
         m_diagnosticsModel->setColumnCount(2);
         m_diagnosticsTree->setModel(m_diagnosticsModel.data());
         connect(m_diagnosticsTree, &QTreeView::clicked, this, &self_type::goToItemLocation);
         connect(m_diagnosticsTree, &QTreeView::doubleClicked, this, &self_type::triggerCodeAction);
 
         // track position in view to sync diagnostics list
         m_viewTracker.reset(LSPClientViewTracker::new_(plugin, mainWin, 0, 500));
         connect(m_viewTracker.data(), &LSPClientViewTracker::newState, this,
                 &self_type::onViewState);
 
         configUpdated();
         updateState();
     }
 
     ~LSPClientActionView()
     {
         // unregister all code-completion providers, else we might crash
         for (auto view : qAsConst(m_completionViews)) {
             qobject_cast<KTextEditor::CodeCompletionInterface *>(view)->unregisterCompletionModel(
                     m_completion.data());
         }
 
         // unregister all text-hint providers, else we might crash
         for (auto view : qAsConst(m_hoverViews)) {
             qobject_cast<KTextEditor::TextHintInterface *>(view)->unregisterTextHintProvider(
                     m_hover.data());
         }
 
         clearAllLocationMarks();
         clearAllDiagnosticsMarks();
     }
 
     void configureTreeView(QTreeView *treeView)
     {
         treeView->setHeaderHidden(true);
         treeView->setFocusPolicy(Qt::NoFocus);
         treeView->setLayoutDirection(Qt::LeftToRight);
         treeView->setSortingEnabled(false);
         treeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
     }
 
     void displayOptionChanged()
     {
         m_diagnosticsHighlight->setEnabled(m_diagnostics->isChecked());
         m_diagnosticsMark->setEnabled(m_diagnostics->isChecked());
         auto index = m_tabWidget->indexOf(m_diagnosticsTree);
         // setTabEnabled may still show it ... so let's be more forceful
         if (m_diagnostics->isChecked() && m_diagnosticsTreeOwn) {
             m_diagnosticsTreeOwn.take();
             m_tabWidget->insertTab(0, m_diagnosticsTree, i18nc("@title:tab", "Diagnostics"));
         } else if (!m_diagnostics->isChecked() && !m_diagnosticsTreeOwn) {
             m_diagnosticsTreeOwn.reset(m_diagnosticsTree);
             m_tabWidget->removeTab(index);
         }
         m_diagnosticsSwitch->setEnabled(m_diagnostics->isChecked());
         m_serverManager->setIncrementalSync(m_incrementalSync->isChecked());
         updateState();
     }
 
     void configUpdated()
     {
         if (m_complDocOn)
             m_complDocOn->setChecked(m_plugin->m_complDoc);
         if (m_refDeclaration)
             m_refDeclaration->setChecked(m_plugin->m_refDeclaration);
         if (m_onTypeFormatting)
             m_onTypeFormatting->setChecked(m_plugin->m_onTypeFormatting);
         if (m_incrementalSync)
             m_incrementalSync->setChecked(m_plugin->m_incrementalSync);
         if (m_diagnostics)
             m_diagnostics->setChecked(m_plugin->m_diagnostics);
         if (m_diagnosticsHighlight)
             m_diagnosticsHighlight->setChecked(m_plugin->m_diagnosticsHighlight);
         if (m_diagnosticsMark)
             m_diagnosticsMark->setChecked(m_plugin->m_diagnosticsMark);
         displayOptionChanged();
     }
 
     void restartCurrent()
     {
         KTextEditor::View *activeView = m_mainWindow->activeView();
         auto server = m_serverManager->findServer(activeView);
         if (server)
             m_serverManager->restart(server.data());
     }
 
     void restartAll() { m_serverManager->restart(nullptr); }
 
     static void clearMarks(KTextEditor::Document *doc, RangeCollection &ranges,
                            DocumentCollection &docs, uint markType)
     {
         KTextEditor::MarkInterface *iface =
                 docs.contains(doc) ? qobject_cast<KTextEditor::MarkInterface *>(doc) : nullptr;
         if (iface) {
             const QHash<int, KTextEditor::Mark *> marks = iface->marks();
             QHashIterator<int, KTextEditor::Mark *> i(marks);
             while (i.hasNext()) {
                 i.next();
                 if (i.value()->type & markType) {
                     iface->removeMark(i.value()->line, markType);
                 }
             }
             docs.remove(doc);
         }
 
         for (auto it = ranges.find(doc); it != ranges.end() && it.key() == doc;) {
             delete it.value();
             it = ranges.erase(it);
         }
     }
 
     static void clearMarks(RangeCollection &ranges, DocumentCollection &docs, uint markType)
     {
         while (!ranges.empty()) {
             clearMarks(ranges.begin().key(), ranges, docs, markType);
         }
     }
 
     Q_SLOT void clearAllMarks(KTextEditor::Document *doc)
     {
         clearMarks(doc, m_ranges, m_marks, RangeData::markType);
         clearMarks(doc, m_diagnosticsRanges, m_diagnosticsMarks, RangeData::markTypeDiagAll);
     }
 
     void clearAllLocationMarks()
     {
         clearMarks(m_ranges, m_marks, RangeData::markType);
         // no longer add any again
         m_ownedModel.reset();
         m_markModel.clear();
     }
 
     void clearAllDiagnosticsMarks()
     {
         clearMarks(m_diagnosticsRanges, m_diagnosticsMarks, RangeData::markTypeDiagAll);
     }
 
     void addMarks(KTextEditor::Document *doc, QStandardItem *item, RangeCollection *ranges,
                   DocumentCollection *docs)
     {
         Q_ASSERT(item);
         KTextEditor::MovingInterface *miface = qobject_cast<KTextEditor::MovingInterface *>(doc);
         KTextEditor::MarkInterface *iface = qobject_cast<KTextEditor::MarkInterface *>(doc);
         KTextEditor::View *activeView = m_mainWindow->activeView();
         KTextEditor::ConfigInterface *ciface =
                 qobject_cast<KTextEditor::ConfigInterface *>(activeView);
 
         if (!miface || !iface)
             return;
 
         auto url = item->data(RangeData::FileUrlRole).toUrl();
         if (url != doc->url())
             return;
 
         KTextEditor::Range range = item->data(RangeData::RangeRole).value<LSPRange>();
         auto line = range.start().line();
         RangeData::KindEnum kind = (RangeData::KindEnum)item->data(RangeData::KindRole).toInt();
 
         KTextEditor::Attribute::Ptr attr(new KTextEditor::Attribute());
 
         bool enabled = m_diagnostics && m_diagnostics->isChecked() && m_diagnosticsHighlight
                 && m_diagnosticsHighlight->isChecked();
         KTextEditor::MarkInterface::MarkTypes markType = RangeData::markType;
         switch (kind) {
         case RangeData::KindEnum::Text: {
             // well, it's a bit like searching for something, so re-use that color
             QColor rangeColor = Qt::yellow;
             if (ciface) {
                 rangeColor = ciface->configValue(QStringLiteral("search-highlight-color"))
                                      .value<QColor>();
             }
             attr->setBackground(rangeColor);
             enabled = true;
             break;
         }
         // FIXME are there any symbolic/configurable ways to pick these colors?
         case RangeData::KindEnum::Read:
             attr->setBackground(Qt::green);
             enabled = true;
             break;
         case RangeData::KindEnum::Write:
             attr->setBackground(Qt::red);
             enabled = true;
             break;
         // use underlining for diagnostics to avoid lots of fancy flickering
         case RangeData::KindEnum::Error:
             markType = RangeData::markTypeDiagError;
             attr->setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);
             attr->setUnderlineColor(Qt::red);
             break;
         case RangeData::KindEnum::Warning:
             markType = RangeData::markTypeDiagWarning;
             attr->setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);
             attr->setUnderlineColor(QColor(255, 128, 0));
             break;
         case RangeData::KindEnum::Information:
         case RangeData::KindEnum::Hint:
         case RangeData::KindEnum::Related:
             markType = RangeData::markTypeDiagOther;
             attr->setUnderlineStyle(QTextCharFormat::DashUnderline);
             attr->setUnderlineColor(Qt::blue);
             break;
         }
         if (activeView) {
             attr->setForeground(
                     activeView->defaultStyleAttribute(KTextEditor::dsNormal)->foreground().color());
         }
 
         // highlight the range
         if (enabled && ranges) {
             KTextEditor::MovingRange *mr = miface->newMovingRange(range);
             mr->setAttribute(attr);
             mr->setZDepth(-90000.0); // Set the z-depth to slightly worse than the selection
             mr->setAttributeOnlyForViews(true);
             ranges->insert(doc, mr);
         }
 
         // add match mark for range
         const int ps = 32;
         bool handleClick = true;
         enabled = m_diagnostics && m_diagnostics->isChecked() && m_diagnosticsMark
                 && m_diagnosticsMark->isChecked();
         switch (markType) {
         case RangeData::markType:
             iface->setMarkDescription(markType, i18n("RangeHighLight"));
             iface->setMarkPixmap(markType, QIcon().pixmap(0, 0));
             handleClick = false;
             enabled = true;
             break;
         case RangeData::markTypeDiagError:
             iface->setMarkDescription(markType, i18n("Error"));
             iface->setMarkPixmap(markType,
                                  diagnosticsIcon(LSPDiagnosticSeverity::Error).pixmap(ps, ps));
             break;
         case RangeData::markTypeDiagWarning:
             iface->setMarkDescription(markType, i18n("Warning"));
             iface->setMarkPixmap(markType,
                                  diagnosticsIcon(LSPDiagnosticSeverity::Warning).pixmap(ps, ps));
             break;
         case RangeData::markTypeDiagOther:
             iface->setMarkDescription(markType, i18n("Information"));
             iface->setMarkPixmap(
                     markType, diagnosticsIcon(LSPDiagnosticSeverity::Information).pixmap(ps, ps));
             break;
         default:
             Q_ASSERT(false);
             break;
         }
         if (enabled && docs) {
             iface->addMark(line, markType);
             docs->insert(doc);
         }
 
         // ensure runtime match
         connect(doc, SIGNAL(aboutToInvalidateMovingInterfaceContent(KTextEditor::Document *)), this,
                 SLOT(clearAllMarks(KTextEditor::Document *)), Qt::UniqueConnection);
         connect(doc, SIGNAL(aboutToDeleteMovingInterfaceContent(KTextEditor::Document *)), this,
                 SLOT(clearAllMarks(KTextEditor::Document *)), Qt::UniqueConnection);
 
         if (handleClick) {
             connect(doc, SIGNAL(markClicked(KTextEditor::Document *, KTextEditor::Mark, bool &)),
                     this, SLOT(onMarkClicked(KTextEditor::Document *, KTextEditor::Mark, bool &)),
                     Qt::UniqueConnection);
         }
     }
 
     void addMarksRec(KTextEditor::Document *doc, QStandardItem *item, RangeCollection *ranges,
                      DocumentCollection *docs)
     {
         Q_ASSERT(item);
         addMarks(doc, item, ranges, docs);
         for (int i = 0; i < item->rowCount(); ++i) {
             addMarksRec(doc, item->child(i), ranges, docs);
         }
     }
 
     void addMarks(KTextEditor::Document *doc, QStandardItemModel *treeModel,
                   RangeCollection &ranges, DocumentCollection &docs)
     {
         // check if already added
         auto oranges = ranges.contains(doc) ? nullptr : &ranges;
         auto odocs = docs.contains(doc) ? nullptr : &docs;
 
         if (!oranges && !odocs)
             return;
 
         Q_ASSERT(treeModel);
         addMarksRec(doc, treeModel->invisibleRootItem(), oranges, odocs);
     }
 
     void goToDocumentLocation(const QUrl &uri, int line, int column)
     {
         KTextEditor::View *activeView = m_mainWindow->activeView();
         if (!activeView || uri.isEmpty() || line < 0 || column < 0)
             return;
 
         KTextEditor::Document *document = activeView->document();
         KTextEditor::Cursor cdef(line, column);
 
         if (document && uri == document->url()) {
             activeView->setCursorPosition(cdef);
         } else {
             KTextEditor::View *view = m_mainWindow->openUrl(uri);
             if (view) {
                 view->setCursorPosition(cdef);
             }
         }
     }
 
     void goToItemLocation(const QModelIndex &index)
     {
         auto url = index.data(RangeData::FileUrlRole).toUrl();
         auto start = index.data(RangeData::RangeRole).value<LSPRange>().start();
         goToDocumentLocation(url, start.line(), start.column());
     }
 
     // custom item subclass that captures additional attributes;
     // a bit more convenient than the variant/role way
     struct DiagnosticItem : public QStandardItem {
         LSPDiagnostic m_diagnostic;
         LSPCodeAction m_codeAction;
         QSharedPointer<LSPClientRevisionSnapshot> m_snapshot;
 
         DiagnosticItem(const LSPDiagnostic &d) : m_diagnostic(d) {}
 
         DiagnosticItem(const LSPCodeAction &c, QSharedPointer<LSPClientRevisionSnapshot> s)
-            : m_codeAction(c), m_snapshot(s)
+            : m_codeAction(c), m_snapshot(std::move(s))
         {
             m_diagnostic.range = LSPRange::invalid();
         }
 
         bool isCodeAction() { return !m_diagnostic.range.isValid() && m_codeAction.title.size(); }
     };
 
     // double click on:
     // diagnostic item -> request and add actions (below item)
     // code action -> perform action (literal edit and/or execute command)
     // (execution of command may lead to an applyEdit request from server)
     void triggerCodeAction(const QModelIndex &index)
     {
         KTextEditor::View *activeView = m_mainWindow->activeView();
         QPointer<KTextEditor::Document> document = activeView->document();
         auto server = m_serverManager->findServer(activeView);
         auto it = dynamic_cast<DiagnosticItem *>(m_diagnosticsModel->itemFromIndex(index));
         if (!server || !document || !it)
             return;
 
         // click on an action ?
         if (it->isCodeAction()) {
             auto &action = it->m_codeAction;
             // apply edit before command
             applyWorkspaceEdit(action.edit, it->m_snapshot.data());
             const auto &command = action.command;
             if (command.command.size()) {
                 // accept edit requests that may be sent to execute command
                 m_accept_edit = true;
                 // but only for a short time
                 QTimer::singleShot(2000, this, [this] { m_accept_edit = false; });
                 server->executeCommand(command.command, command.arguments);
             }
             return;
         }
 
         // only engage action if
         // * active document matches diagnostic document
         // * if really clicked a diagnostic item
         //   (which is the case as it != nullptr and not a code action)
         // * if no code action invoked and added already
         //   (note; related items are also children)
         auto url = it->data(RangeData::FileUrlRole).toUrl();
         if (url != document->url() || it->data(Qt::UserRole).toBool())
             return;
 
         // store some things to find item safely later on
         QPersistentModelIndex pindex(index);
         QSharedPointer<LSPClientRevisionSnapshot> snapshot(
                 m_serverManager->snapshot(server.data()));
-        auto h = [this, url, snapshot, pindex](const QList<LSPCodeAction> actions) {
+        auto h = [this, url, snapshot, pindex](const QList<LSPCodeAction>& actions) {
             if (!pindex.isValid())
                 return;
             auto child = m_diagnosticsModel->itemFromIndex(pindex);
             if (!child)
                 return;
             // add actions below diagnostic item
             for (const auto &action : actions) {
                 auto item = new DiagnosticItem(action, snapshot);
                 child->appendRow(item);
                 auto text = action.kind.size()
                         ? QStringLiteral("[%1] %2").arg(action.kind).arg(action.title)
                         : action.title;
                 item->setData(text, Qt::DisplayRole);
                 item->setData(codeActionIcon(), Qt::DecorationRole);
             }
             m_diagnosticsTree->setExpanded(child->index(), true);
             // mark actions added
             child->setData(true, Qt::UserRole);
         };
 
         auto range = activeView->selectionRange();
         if (!range.isValid()) {
             range = document->documentRange();
         }
         server->documentCodeAction(url, range, {}, { it->m_diagnostic }, this, h);
     }
 
     void tabCloseRequested(int index)
     {
         auto widget = m_tabWidget->widget(index);
         if (widget != m_diagnosticsTree) {
             if (m_markModel && widget == m_markModel->parent()) {
                 clearAllLocationMarks();
             }
             delete widget;
         }
     }
 
     void switchToDiagnostics()
     {
         m_tabWidget->setCurrentWidget(m_diagnosticsTree);
         m_mainWindow->showToolView(m_toolView.data());
     }
 
     void closeNonDiagnostics()
     {
         for (int i = 0; i < m_tabWidget->count();) {
             if (m_tabWidget->widget(i) != m_diagnosticsTree) {
                 tabCloseRequested(i);
             } else {
                 ++i;
             }
         }
     }
 
     // local helper to overcome some differences in LSP types
     struct RangeItem {
         QUrl uri;
         LSPRange range;
         LSPDocumentHighlightKind kind;
     };
 
     static bool compareRangeItem(const RangeItem &a, const RangeItem &b)
     {
         return (a.uri < b.uri) || ((a.uri == b.uri) && a.range < b.range);
     }
 
     // provide Qt::DisplayRole (text) line lazily;
     // only find line's text content when so requested
     // This may then involve opening reading some file, at which time
     // all items for that file will be resolved in one go.
     struct LineItem : public QStandardItem {
         KTextEditor::MainWindow *m_mainWindow;
 
         LineItem(KTextEditor::MainWindow *mainWindow) : m_mainWindow(mainWindow) {}
 
         QVariant data(int role = Qt::UserRole + 1) const override
         {
             auto rootItem = this->parent();
             if (role != Qt::DisplayRole || !rootItem) {
                 return QStandardItem::data(role);
             }
 
             auto line = data(Qt::UserRole);
             // either of these mean we tried to obtain line already
             if (line.isValid() || rootItem->data(RangeData::KindRole).toBool()) {
                 return QStandardItem::data(role).toString().append(line.toString());
             }
 
             KTextEditor::Document *doc = nullptr;
             QScopedPointer<FileLineReader> fr;
             for (int i = 0; i < rootItem->rowCount(); i++) {
                 auto child = rootItem->child(i);
                 if (i == 0) {
                     auto url = child->data(RangeData::FileUrlRole).toUrl();
                     doc = findDocument(m_mainWindow, url);
                     if (!doc) {
                         fr.reset(new FileLineReader(url));
                     }
                 }
                 auto lineno = child->data(RangeData::RangeRole).value<LSPRange>().start().line();
                 auto line = doc ? doc->line(lineno) : fr->line(lineno);
                 child->setData(line, Qt::UserRole);
             }
 
             // mark as processed
             rootItem->setData(RangeData::KindRole, true);
 
             // should work ok
             return data(role);
         }
     };
 
     LSPRange transformRange(const QUrl &url, const LSPClientRevisionSnapshot &snapshot,
                             const LSPRange &range)
     {
         KTextEditor::MovingInterface *miface;
         qint64 revision;
 
         auto result = range;
         snapshot.find(url, miface, revision);
         if (miface) {
             miface->transformRange(result, KTextEditor::MovingRange::DoNotExpand,
                                    KTextEditor::MovingRange::AllowEmpty, revision);
         }
         return result;
     }
 
     void fillItemRoles(QStandardItem *item, const QUrl &url, const LSPRange _range,
                        RangeData::KindEnum kind,
                        const LSPClientRevisionSnapshot *snapshot = nullptr)
     {
         auto range = snapshot ? transformRange(url, *snapshot, _range) : _range;
         item->setData(QVariant(url), RangeData::FileUrlRole);
         QVariant vrange;
         vrange.setValue(range);
         item->setData(vrange, RangeData::RangeRole);
         item->setData((int)kind, RangeData::KindRole);
     }
 
     void makeTree(const QVector<RangeItem> &locations, const LSPClientRevisionSnapshot *snapshot)
     {
         // group by url, assuming input is suitably sorted that way
         auto treeModel = new QStandardItemModel();
         treeModel->setColumnCount(1);
 
         QUrl lastUrl;
         QStandardItem *parent = nullptr;
         for (const auto &loc : locations) {
             if (loc.uri != lastUrl) {
                 if (parent) {
                     parent->setText(
                             QStringLiteral("%1: %2").arg(lastUrl.path()).arg(parent->rowCount()));
                 }
                 lastUrl = loc.uri;
                 parent = new QStandardItem();
                 treeModel->appendRow(parent);
             }
             auto item = new LineItem(m_mainWindow);
             parent->appendRow(item);
             // add partial display data; line will be added by item later on
             item->setText(i18n("Line: %1: ", loc.range.start().line() + 1));
             fillItemRoles(item, loc.uri, loc.range, loc.kind, snapshot);
         }
         if (parent)
             parent->setText(QStringLiteral("%1: %2").arg(lastUrl.path()).arg(parent->rowCount()));
 
         // plain heuristic; mark for auto-expand all when safe and/or useful to do so
         if (treeModel->rowCount() <= 2 || locations.size() <= 20) {
             treeModel->invisibleRootItem()->setData(true, RangeData::KindRole);
         }
 
         m_ownedModel.reset(treeModel);
         m_markModel = treeModel;
     }
 
     void showTree(const QString &title, QPointer<QTreeView> *targetTree)
     {
         // clean up previous target if any
         if (targetTree && *targetTree) {
             int index = m_tabWidget->indexOf(*targetTree);
             if (index >= 0)
                 tabCloseRequested(index);
         }
 
         // setup view
         auto treeView = new QTreeView();
         configureTreeView(treeView);
 
         // transfer model from owned to tree and that in turn to tabwidget
         auto treeModel = m_ownedModel.take();
         treeView->setModel(treeModel);
         treeModel->setParent(treeView);
         int index = m_tabWidget->addTab(treeView, title);
         connect(treeView, &QTreeView::clicked, this, &self_type::goToItemLocation);
 
         if (treeModel->invisibleRootItem()->data(RangeData::KindRole).toBool()) {
             treeView->expandAll();
         }
 
         // track for later cleanup
         if (targetTree)
             *targetTree = treeView;
 
         // activate the resulting tab
         m_tabWidget->setCurrentIndex(index);
         m_mainWindow->showToolView(m_toolView.data());
     }
 
     void showMessage(const QString &text, KTextEditor::Message::MessageType level)
     {
         KTextEditor::View *view = m_mainWindow->activeView();
         if (!view || !view->document())
             return;
 
         auto kmsg = new KTextEditor::Message(text, level);
         kmsg->setPosition(KTextEditor::Message::BottomInView);
         kmsg->setAutoHide(500);
         kmsg->setView(view);
         view->document()->postMessage(kmsg);
     }
 
     void handleEsc(QEvent *e)
     {
         if (!m_mainWindow)
             return;
 
         QKeyEvent *k = static_cast<QKeyEvent *>(e);
         if (k->key() == Qt::Key_Escape && k->modifiers() == Qt::NoModifier) {
             if (!m_ranges.empty()) {
                 clearAllLocationMarks();
             } else if (m_toolView->isVisible()) {
                 m_mainWindow->hideToolView(m_toolView.data());
             }
         }
     }
 
     template<typename Handler>
     using LocationRequest =
             std::function<LSPClientServer::RequestHandle(LSPClientServer &, const QUrl &document,
                                                          const LSPPosition &pos,
                                                          const QObject *context, const Handler &h)>;
 
     template<typename Handler>
     void positionRequest(const LocationRequest<Handler> &req, const Handler &h,
                          QScopedPointer<LSPClientRevisionSnapshot> *snapshot = nullptr)
     {
         KTextEditor::View *activeView = m_mainWindow->activeView();
         auto server = m_serverManager->findServer(activeView);
         if (!server)
             return;
 
         // track revision if requested
         if (snapshot) {
             snapshot->reset(m_serverManager->snapshot(server.data()));
         }
 
         KTextEditor::Cursor cursor = activeView->cursorPosition();
 
         clearAllLocationMarks();
         m_req_timeout = false;
         QTimer::singleShot(1000, this, [this] { m_req_timeout = true; });
         m_handle.cancel() = req(*server, activeView->document()->url(),
                                 { cursor.line(), cursor.column() }, this, h);
     }
 
     QString currentWord()
     {
         KTextEditor::View *activeView = m_mainWindow->activeView();
         if (activeView) {
             KTextEditor::Cursor cursor = activeView->cursorPosition();
             return activeView->document()->wordAt(cursor);
         } else {
             return QString();
         }
     }
 
     // some template and function type trickery here, but at least that buck stops here then ...
     template<typename ReplyEntryType, bool doshow = true,
              typename HandlerType = ReplyHandler<QList<ReplyEntryType>>>
     void processLocations(const QString &title,
                           const typename utils::identity<LocationRequest<HandlerType>>::type &req,
                           bool onlyshow,
                           const std::function<RangeItem(const ReplyEntryType &)> &itemConverter,
                           QPointer<QTreeView> *targetTree = nullptr)
     {
         // no capture for move only using initializers available (yet), so shared outer type
         // the additional level of indirection is so it can be 'filled-in' after lambda creation
         QSharedPointer<QScopedPointer<LSPClientRevisionSnapshot>> s(
                 new QScopedPointer<LSPClientRevisionSnapshot>);
         auto h = [this, title, onlyshow, itemConverter, targetTree,
                   s](const QList<ReplyEntryType> &defs) {
             if (defs.count() == 0) {
                 showMessage(i18n("No results"), KTextEditor::Message::Information);
             } else {
                 // convert to helper type
                 QVector<RangeItem> ranges;
                 ranges.reserve(defs.size());
                 for (const auto &def : defs) {
                     ranges.push_back(itemConverter(def));
                 }
                 // ... so we can sort it also
                 std::stable_sort(ranges.begin(), ranges.end(), compareRangeItem);
                 makeTree(ranges, s.data()->data());
 
                 // assuming that reply ranges refer to revision when submitted
                 // (not specified anyway in protocol/reply)
                 if (defs.count() > 1 || onlyshow) {
                     showTree(title, targetTree);
                 }
                 // it's not nice to jump to some location if we are too late
                 if (!m_req_timeout && !onlyshow) {
                     // assuming here that the first location is the best one
                     const auto &item = itemConverter(defs.at(0));
                     const auto &pos = item.range.start();
                     goToDocumentLocation(item.uri, pos.line(), pos.column());
                 }
                 // update marks
                 updateState();
             }
         };
 
         positionRequest<HandlerType>(req, h, s.data());
     }
 
     static RangeItem locationToRangeItem(const LSPLocation &loc)
     {
         return { loc.uri, loc.range, LSPDocumentHighlightKind::Text };
     }
 
     void goToDefinition()
     {
         auto title = i18nc("@title:tab", "Definition: %1", currentWord());
         processLocations<LSPLocation>(title, &LSPClientServer::documentDefinition, false,
                                       &self_type::locationToRangeItem, &m_defTree);
     }
 
     void goToDeclaration()
     {
         auto title = i18nc("@title:tab", "Declaration: %1", currentWord());
         processLocations<LSPLocation>(title, &LSPClientServer::documentDeclaration, false,
                                       &self_type::locationToRangeItem, &m_declTree);
     }
 
     void findReferences()
     {
         auto title = i18nc("@title:tab", "References: %1", currentWord());
         bool decl = m_refDeclaration->isChecked();
         auto req = [decl](LSPClientServer &server, const QUrl &document, const LSPPosition &pos,
                           const QObject *context, const DocumentDefinitionReplyHandler &h) {
             return server.documentReferences(document, pos, decl, context, h);
         };
 
         processLocations<LSPLocation>(title, req, true, &self_type::locationToRangeItem);
     }
 
     void highlight()
     {
         // determine current url to capture and use later on
         QUrl url;
         const KTextEditor::View *viewForRequest(m_mainWindow->activeView());
         if (viewForRequest && viewForRequest->document()) {
             url = viewForRequest->document()->url();
         }
 
         auto title = i18nc("@title:tab", "Highlight: %1", currentWord());
         auto converter = [url](const LSPDocumentHighlight &hl) {
             return RangeItem { url, hl.range, hl.kind };
         };
 
         processLocations<LSPDocumentHighlight, false>(title, &LSPClientServer::documentHighlight,
                                                       true, converter);
     }
 
     void hover()
     {
         // trigger manually the normally automagic hover
         if (auto activeView = m_mainWindow->activeView()) {
             m_hover->textHint(activeView, activeView->cursorPosition());
         }
     }
 
     void applyEdits(KTextEditor::Document *doc, const LSPClientRevisionSnapshot *snapshot,
                     const QList<LSPTextEdit> &edits)
     {
         KTextEditor::MovingInterface *miface = qobject_cast<KTextEditor::MovingInterface *>(doc);
         if (!miface)
             return;
 
         // NOTE:
         // server might be pretty sloppy wrt edits (e.g. python-language-server)
         // e.g. send one edit for the whole document rather than 'surgical edits'
         // and that even when requesting format for a limited selection
         // ... but then we are but a client and do as we are told
         // all-in-all a low priority feature
 
         // all coordinates in edits are wrt original document,
         // so create moving ranges that will adjust to preceding edits as they are applied
         QVector<KTextEditor::MovingRange *> ranges;
         for (const auto &edit : edits) {
             auto range = snapshot ? transformRange(doc->url(), *snapshot, edit.range) : edit.range;
             KTextEditor::MovingRange *mr = miface->newMovingRange(range);
             ranges.append(mr);
         }
 
         // now make one transaction (a.o. for one undo) and apply in sequence
         {
             KTextEditor::Document::EditingTransaction transaction(doc);
             for (int i = 0; i < ranges.length(); ++i) {
                 doc->replaceText(ranges.at(i)->toRange(), edits.at(i).newText);
             }
         }
 
         qDeleteAll(ranges);
     }
 
     void applyWorkspaceEdit(const LSPWorkspaceEdit &edit, const LSPClientRevisionSnapshot *snapshot)
     {
         auto currentView = m_mainWindow->activeView();
         for (auto it = edit.changes.begin(); it != edit.changes.end(); ++it) {
             auto document = findDocument(m_mainWindow, it.key());
             if (!document) {
                 KTextEditor::View *view = m_mainWindow->openUrl(it.key());
                 if (view) {
                     document = view->document();
                 }
             }
             applyEdits(document, snapshot, it.value());
         }
         if (currentView) {
             m_mainWindow->activateView(currentView->document());
         }
     }
 
     void onApplyEdit(const LSPApplyWorkspaceEditParams &edit, const ApplyEditReplyHandler &h,
                      bool &handled)
     {
         if (handled)
             return;
         handled = true;
 
         if (m_accept_edit) {
             qCInfo(LSPCLIENT) << "applying edit" << edit.label;
             applyWorkspaceEdit(edit.edit, nullptr);
         } else {
             qCInfo(LSPCLIENT) << "ignoring edit";
         }
         h({ m_accept_edit, QString() });
     }
 
     template<typename Collection>
     void checkEditResult(const Collection &c)
     {
         if (c.size() == 0) {
             showMessage(i18n("No edits"), KTextEditor::Message::Information);
         }
     }
 
     void delayCancelRequest(LSPClientServer::RequestHandle &&h, int timeout_ms = 4000)
     {
         QTimer::singleShot(timeout_ms, this, [h]() mutable { h.cancel(); });
     }
 
     void format(QChar lastChar = QChar())
     {
         KTextEditor::View *activeView = m_mainWindow->activeView();
         QPointer<KTextEditor::Document> document = activeView->document();
         auto server = m_serverManager->findServer(activeView);
         if (!server || !document)
             return;
 
         int tabSize = 4;
         bool insertSpaces = true;
         auto cfgiface = qobject_cast<KTextEditor::ConfigInterface *>(document);
         if (cfgiface) {
             tabSize = cfgiface->configValue(QStringLiteral("tab-width")).toInt();
             insertSpaces = cfgiface->configValue(QStringLiteral("replace-tabs")).toBool();
         }
 
         // sigh, no move initialization capture ...
         // (again) assuming reply ranges wrt revisions submitted at this time
         QSharedPointer<LSPClientRevisionSnapshot> snapshot(
                 m_serverManager->snapshot(server.data()));
         auto h = [this, document, snapshot, lastChar](const QList<LSPTextEdit> &edits) {
             if (lastChar.isNull()) {
                 checkEditResult(edits);
             }
             if (document) {
                 applyEdits(document, snapshot.data(), edits);
             }
         };
 
         auto options = LSPFormattingOptions { tabSize, insertSpaces, QJsonObject() };
         auto handle = !lastChar.isNull()
                 ? server->documentOnTypeFormatting(document->url(), activeView->cursorPosition(),
                                                    lastChar, options, this, h)
                 : (activeView->selection()
                            ? server->documentRangeFormatting(
                                    document->url(), activeView->selectionRange(), options, this, h)
                            : server->documentFormatting(document->url(), options, this, h));
         delayCancelRequest(std::move(handle));
     }
 
     void rename()
     {
         KTextEditor::View *activeView = m_mainWindow->activeView();
         QPointer<KTextEditor::Document> document = activeView->document();
         auto server = m_serverManager->findServer(activeView);
         if (!server || !document)
             return;
 
         bool ok = false;
         // results are typically (too) limited
         // due to server implementation or limited view/scope
         // so let's add a disclaimer that it's not our fault
         QString newName = QInputDialog::getText(
                 activeView, i18nc("@title:window", "Rename"),
                 i18nc("@label:textbox", "New name (caution: not all references may be replaced)"),
                 QLineEdit::Normal, QString(), &ok);
         if (!ok) {
             return;
         }
 
         QSharedPointer<LSPClientRevisionSnapshot> snapshot(
                 m_serverManager->snapshot(server.data()));
         auto h = [this, snapshot](const LSPWorkspaceEdit &edit) {
             checkEditResult(edit.changes);
             applyWorkspaceEdit(edit, snapshot.data());
         };
         auto handle = server->documentRename(document->url(), activeView->cursorPosition(), newName,
                                              this, h);
         delayCancelRequest(std::move(handle));
     }
 
     static QStandardItem *getItem(const QStandardItemModel &model, const QUrl &url)
     {
         auto l = model.findItems(url.path());
         if (l.length()) {
             return l.at(0);
         }
         return nullptr;
     }
 
     // select/scroll to diagnostics item for document and (optionally) line
     bool syncDiagnostics(KTextEditor::Document *document, int line, bool allowTop, bool doShow)
     {
         if (!m_diagnosticsTree)
             return false;
 
         auto hint = QAbstractItemView::PositionAtTop;
         QStandardItem *targetItem = nullptr;
         QStandardItem *topItem = getItem(*m_diagnosticsModel, document->url());
         if (topItem) {
             int count = topItem->rowCount();
             // let's not run wild on a linear search in a flood of diagnostics
             // user is already in enough trouble as it is ;-)
             if (count > 50)
                 count = 0;
             for (int i = 0; i < count; ++i) {
                 auto item = topItem->child(i);
                 int itemline = item->data(RangeData::RangeRole).value<LSPRange>().start().line();
                 if (line == itemline && m_diagnosticsTree) {
                     targetItem = item;
                     hint = QAbstractItemView::PositionAtCenter;
                     break;
                 }
             }
         }
         if (!targetItem && allowTop) {
             targetItem = topItem;
         }
         if (targetItem) {
             m_diagnosticsTree->blockSignals(true);
             m_diagnosticsTree->scrollTo(targetItem->index(), hint);
             m_diagnosticsTree->setCurrentIndex(targetItem->index());
             m_diagnosticsTree->blockSignals(false);
             if (doShow) {
                 m_tabWidget->setCurrentWidget(m_diagnosticsTree);
                 m_mainWindow->showToolView(m_toolView.data());
             }
         }
         return targetItem != nullptr;
     }
 
     void onViewState(KTextEditor::View *view, LSPClientViewTracker::State newState)
     {
         if (!view || !view->document())
             return;
 
         // select top item on view change,
         // but otherwise leave selection unchanged if no match
         switch (newState) {
         case LSPClientViewTracker::ViewChanged:
             syncDiagnostics(view->document(), view->cursorPosition().line(), true, false);
             break;
         case LSPClientViewTracker::LineChanged:
             syncDiagnostics(view->document(), view->cursorPosition().line(), false, false);
             break;
         default:
             // should not happen
             break;
         }
     }
 
     Q_SLOT void onMarkClicked(KTextEditor::Document *document, KTextEditor::Mark mark,
                               bool &handled)
     {
         // no action if no mark was sprinkled here
         if (m_diagnosticsMarks.contains(document)
             && syncDiagnostics(document, mark.line, false, true)) {
             handled = true;
         }
     }
 
     void onDiagnostics(const LSPPublishDiagnosticsParams &diagnostics)
     {
         if (!m_diagnosticsTree)
             return;
 
         QStandardItemModel *model = m_diagnosticsModel.data();
         QStandardItem *topItem = getItem(*m_diagnosticsModel, diagnostics.uri);
 
         if (!topItem) {
             // no need to create an empty one
             if (diagnostics.diagnostics.size() == 0) {
                 return;
             }
             topItem = new QStandardItem();
             model->appendRow(topItem);
             topItem->setText(diagnostics.uri.path());
         } else {
             topItem->setRowCount(0);
         }
 
         for (const auto &diag : diagnostics.diagnostics) {
             auto item = new DiagnosticItem(diag);
             topItem->appendRow(item);
             QString source;
             if (diag.source.length()) {
                 source = QStringLiteral("[%1] ").arg(diag.source);
             }
             item->setData(diagnosticsIcon(diag.severity), Qt::DecorationRole);
             item->setText(source + diag.message);
             fillItemRoles(item, diagnostics.uri, diag.range, diag.severity);
             const auto &related = diag.relatedInformation;
             if (!related.location.uri.isEmpty()) {
                 auto relatedItemMessage = new QStandardItem();
                 relatedItemMessage->setText(related.message);
                 fillItemRoles(relatedItemMessage, related.location.uri, related.location.range,
                               RangeData::KindEnum::Related);
                 auto relatedItemPath = new QStandardItem();
                 auto basename = QFileInfo(related.location.uri.path()).fileName();
                 relatedItemPath->setText(QStringLiteral("%1:%2").arg(basename).arg(
                         related.location.range.start().line()));
                 item->appendRow({ relatedItemMessage, relatedItemPath });
                 m_diagnosticsTree->setExpanded(item->index(), true);
             }
         }
 
         // TODO perhaps add some custom delegate that only shows 1 line
         // and only the whole text when item selected ??
         m_diagnosticsTree->setExpanded(topItem->index(), true);
         m_diagnosticsTree->setRowHidden(topItem->row(), QModelIndex(), topItem->rowCount() == 0);
         m_diagnosticsTree->scrollTo(topItem->index(), QAbstractItemView::PositionAtTop);
 
         auto header = m_diagnosticsTree->header();
         header->setStretchLastSection(false);
         header->setMinimumSectionSize(0);
         header->setSectionResizeMode(0, QHeaderView::Stretch);
         header->setSectionResizeMode(1, QHeaderView::ResizeToContents);
 
         updateState();
     }
 
     void onDocumentUrlChanged(KTextEditor::Document *doc)
     {
         // url already changed by this time and new url not useufl
         (void)doc;
         // note; url also changes when closed
         // spec says;
         // if a language has a project system, diagnostics are not cleared by *server*
         // but in either case (url change or close); remove lingering diagnostics
         // collect active urls
         QSet<QString> fpaths;
         for (const auto &view : m_mainWindow->views()) {
             if (auto doc = view->document()) {
                 fpaths.insert(doc->url().path());
             }
         }
         // check and clear defunct entries
         const auto &model = *m_diagnosticsModel;
         for (int i = 0; i < model.rowCount(); ++i) {
             auto item = model.item(i);
             if (item && !fpaths.contains(item->text())) {
                 item->setRowCount(0);
                 if (m_diagnosticsTree) {
                     m_diagnosticsTree->setRowHidden(item->row(), QModelIndex(), true);
                 }
             }
         }
     }
 
     void onTextChanged(KTextEditor::Document *doc)
     {
         if (m_onTypeFormattingTriggers.size() == 0)
             return;
 
         KTextEditor::View *activeView = m_mainWindow->activeView();
         if (!activeView || activeView->document() != doc)
             return;
 
         // NOTE the intendation mode should probably be set to None,
         // so as not to experience unpleasant interference
         auto cursor = activeView->cursorPosition();
         QChar lastChar = cursor.column() == 0
                 ? QChar::fromLatin1('\n')
                 : doc->characterAt({ cursor.line(), cursor.column() - 1 });
         if (m_onTypeFormattingTriggers.contains(lastChar)) {
             format(lastChar);
         }
     }
 
     void updateState()
     {
         KTextEditor::View *activeView = m_mainWindow->activeView();
         auto doc = activeView ? activeView->document() : nullptr;
         auto server = m_serverManager->findServer(activeView);
         bool defEnabled = false, declEnabled = false, refEnabled = false;
         bool hoverEnabled = false, highlightEnabled = false;
         bool formatEnabled = false;
         bool renameEnabled = false;
 
         if (server) {
             const auto &caps = server->capabilities();
             defEnabled = caps.definitionProvider;
             // FIXME no real official protocol way to detect, so enable anyway
             declEnabled = caps.declarationProvider || true;
             refEnabled = caps.referencesProvider;
             hoverEnabled = caps.hoverProvider;
             highlightEnabled = caps.documentHighlightProvider;
             formatEnabled = caps.documentFormattingProvider || caps.documentRangeFormattingProvider;
             renameEnabled = caps.renameProvider;
 
             connect(server.data(), &LSPClientServer::publishDiagnostics, this,
                     &self_type::onDiagnostics, Qt::UniqueConnection);
             connect(server.data(), &LSPClientServer::applyEdit, this, &self_type::onApplyEdit,
                     Qt::UniqueConnection);
 
             // update format trigger characters
             const auto &fmt = caps.documentOnTypeFormattingProvider;
             if (fmt.provider && m_onTypeFormatting->isChecked()) {
                 m_onTypeFormattingTriggers = fmt.triggerCharacters;
             } else {
                 m_onTypeFormattingTriggers.clear();
             }
             // and monitor for such
             if (doc) {
                 connect(doc, &KTextEditor::Document::textChanged, this, &self_type::onTextChanged,
                         Qt::UniqueConnection);
                 connect(doc, &KTextEditor::Document::documentUrlChanged, this,
                         &self_type::onDocumentUrlChanged, Qt::UniqueConnection);
             }
         }
 
         if (m_findDef)
             m_findDef->setEnabled(defEnabled);
         if (m_findDecl)
             m_findDecl->setEnabled(declEnabled);
         if (m_findRef)
             m_findRef->setEnabled(refEnabled);
         if (m_triggerHighlight)
             m_triggerHighlight->setEnabled(highlightEnabled);
         if (m_triggerHover)
             m_triggerHover->setEnabled(hoverEnabled);
         if (m_triggerFormat)
             m_triggerFormat->setEnabled(formatEnabled);
         if (m_triggerRename)
             m_triggerRename->setEnabled(renameEnabled);
         if (m_complDocOn)
             m_complDocOn->setEnabled(server);
         if (m_restartServer)
             m_restartServer->setEnabled(server);
 
         // update completion with relevant server
         m_completion->setServer(server);
         if (m_complDocOn)
             m_completion->setSelectedDocumentation(m_complDocOn->isChecked());
         updateCompletion(activeView, server.data());
 
         // update hover with relevant server
         m_hover->setServer(server);
         updateHover(activeView, server.data());
 
         // update marks if applicable
         if (m_markModel && doc)
             addMarks(doc, m_markModel, m_ranges, m_marks);
         if (m_diagnosticsModel && doc) {
             clearMarks(doc, m_diagnosticsRanges, m_diagnosticsMarks, RangeData::markTypeDiagAll);
             addMarks(doc, m_diagnosticsModel.data(), m_diagnosticsRanges, m_diagnosticsMarks);
         }
 
         // connect for cleanup stuff
         if (activeView)
             connect(activeView, &KTextEditor::View::destroyed, this, &self_type::viewDestroyed,
                     Qt::UniqueConnection);
     }
 
     void viewDestroyed(QObject *view)
     {
         m_completionViews.remove(static_cast<KTextEditor::View *>(view));
         m_hoverViews.remove(static_cast<KTextEditor::View *>(view));
     }
 
     void updateCompletion(KTextEditor::View *view, LSPClientServer *server)
     {
         bool registered = m_completionViews.contains(view);
 
         KTextEditor::CodeCompletionInterface *cci =
                 qobject_cast<KTextEditor::CodeCompletionInterface *>(view);
 
         if (!cci) {
             return;
         }
 
         if (!registered && server && server->capabilities().completionProvider.provider) {
             qCInfo(LSPCLIENT) << "registering cci";
             cci->registerCompletionModel(m_completion.data());
             m_completionViews.insert(view);
         }
 
         if (registered && !server) {
             qCInfo(LSPCLIENT) << "unregistering cci";
             cci->unregisterCompletionModel(m_completion.data());
             m_completionViews.remove(view);
         }
     }
 
     void updateHover(KTextEditor::View *view, LSPClientServer *server)
     {
         bool registered = m_hoverViews.contains(view);
 
         KTextEditor::TextHintInterface *cci = qobject_cast<KTextEditor::TextHintInterface *>(view);
 
         if (!cci) {
             return;
         }
 
         if (!registered && server && server->capabilities().hoverProvider) {
             qCInfo(LSPCLIENT) << "registering cci";
             cci->registerTextHintProvider(m_hover.data());
             m_hoverViews.insert(view);
         }
 
         if (registered && !server) {
             qCInfo(LSPCLIENT) << "unregistering cci";
             cci->unregisterTextHintProvider(m_hover.data());
             m_hoverViews.remove(view);
         }
     }
 };
 
 class LSPClientPluginViewImpl : public QObject, public KXMLGUIClient
 {
     Q_OBJECT
 
     typedef LSPClientPluginViewImpl self_type;
 
     KTextEditor::MainWindow *m_mainWindow;
     QSharedPointer<LSPClientServerManager> m_serverManager;
     QScopedPointer<LSPClientActionView> m_actionView;
 
 public:
     LSPClientPluginViewImpl(LSPClientPlugin *plugin, KTextEditor::MainWindow *mainWin)
         : QObject(mainWin),
           m_mainWindow(mainWin),
           m_serverManager(LSPClientServerManager::new_(plugin, mainWin)),
           m_actionView(new LSPClientActionView(plugin, mainWin, this, m_serverManager))
     {
         KXMLGUIClient::setComponentName(QStringLiteral("lspclient"), i18n("LSP Client"));
         setXMLFile(QStringLiteral("ui.rc"));
 
         m_mainWindow->guiFactory()->addClient(this);
     }
 
     ~LSPClientPluginViewImpl()
     {
         // minimize/avoid some surprises;
         // safe construction/destruction by separate (helper) objects;
         // signals are auto-disconnected when high-level "view" objects are broken down
         // so it only remains to clean up lowest level here then prior to removal
         m_actionView.reset();
         m_serverManager.reset();
         m_mainWindow->guiFactory()->removeClient(this);
     }
 };
 
 QObject *LSPClientPluginView::new_(LSPClientPlugin *plugin, KTextEditor::MainWindow *mainWin)
 {
     return new LSPClientPluginViewImpl(plugin, mainWin);
 }
 
 #include "lspclientpluginview.moc"
diff --git a/addons/lspclient/lspclientserver.cpp b/addons/lspclient/lspclientserver.cpp
index 237ed749d..991dd7df8 100644
--- a/addons/lspclient/lspclientserver.cpp
+++ b/addons/lspclient/lspclientserver.cpp
@@ -1,1366 +1,1367 @@
 /*  SPDX-License-Identifier: MIT
 
     Copyright (C) 2019 Mark Nauwelaerts <mark.nauwelaerts@gmail.com>
 
     Permission is hereby granted, free of charge, to any person obtaining
     a copy of this software and associated documentation files (the
     "Software"), to deal in the Software without restriction, including
     without limitation the rights to use, copy, modify, merge, publish,
     distribute, sublicense, and/or sell copies of the Software, and to
     permit persons to whom the Software is furnished to do so, subject to
     the following conditions:
 
     The above copyright notice and this permission notice shall be included
     in all copies or substantial portions of the Software.
 
     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "lspclientserver.h"
 
 #include "lspclient_debug.h"
 
 #include <QScopedPointer>
 #include <QProcess>
 #include <QVariantMap>
 
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QCoreApplication>
 #include <QTime>
 #include <QFileInfo>
+#include <utility>
 
 // good/bad old school; allows easier concatenate
 #define CONTENT_LENGTH "Content-Length"
 
 static const QString MEMBER_ID = QStringLiteral("id");
 static const QString MEMBER_METHOD = QStringLiteral("method");
 static const QString MEMBER_ERROR = QStringLiteral("error");
 static const QString MEMBER_CODE = QStringLiteral("code");
 static const QString MEMBER_MESSAGE = QStringLiteral("message");
 static const QString MEMBER_PARAMS = QStringLiteral("params");
 static const QString MEMBER_RESULT = QStringLiteral("result");
 static const QString MEMBER_URI = QStringLiteral("uri");
 static const QString MEMBER_VERSION = QStringLiteral("version");
 static const QString MEMBER_START = QStringLiteral("start");
 static const QString MEMBER_END = QStringLiteral("end");
 static const QString MEMBER_POSITION = QStringLiteral("position");
 static const QString MEMBER_LOCATION = QStringLiteral("location");
 static const QString MEMBER_RANGE = QStringLiteral("range");
 static const QString MEMBER_LINE = QStringLiteral("line");
 static const QString MEMBER_CHARACTER = QStringLiteral("character");
 static const QString MEMBER_KIND = QStringLiteral("kind");
 static const QString MEMBER_TEXT = QStringLiteral("text");
 static const QString MEMBER_LANGID = QStringLiteral("languageId");
 static const QString MEMBER_LABEL = QStringLiteral("label");
 static const QString MEMBER_DOCUMENTATION = QStringLiteral("documentation");
 static const QString MEMBER_DETAIL = QStringLiteral("detail");
 static const QString MEMBER_COMMAND = QStringLiteral("command");
 static const QString MEMBER_EDIT = QStringLiteral("edit");
 static const QString MEMBER_TITLE = QStringLiteral("title");
 static const QString MEMBER_ARGUMENTS = QStringLiteral("arguments");
 static const QString MEMBER_DIAGNOSTICS = QStringLiteral("diagnostics");
 
 // message construction helpers
 static QJsonObject to_json(const LSPPosition &pos)
 {
     return QJsonObject { { MEMBER_LINE, pos.line() }, { MEMBER_CHARACTER, pos.column() } };
 }
 
 static QJsonObject to_json(const LSPRange &range)
 {
     return QJsonObject { { MEMBER_START, to_json(range.start()) },
                          { MEMBER_END, to_json(range.end()) } };
 }
 
 static QJsonValue to_json(const LSPLocation &location)
 {
     if (location.uri.isValid()) {
         return QJsonObject { { MEMBER_URI, location.uri.toString() },
                              { MEMBER_RANGE, to_json(location.range) } };
     }
     return QJsonValue();
 }
 
 static QJsonValue to_json(const LSPDiagnosticRelatedInformation &related)
 {
     auto loc = to_json(related.location);
     if (loc.isObject()) {
         return QJsonObject { { MEMBER_LOCATION, to_json(related.location) },
                              { MEMBER_MESSAGE, related.message } };
     }
     return QJsonValue();
 }
 
 static QJsonObject to_json(const LSPDiagnostic &diagnostic)
 {
     // required
     auto result = QJsonObject();
     result[MEMBER_RANGE] = to_json(diagnostic.range);
     result[MEMBER_MESSAGE] = diagnostic.message;
     // optional
     if (!diagnostic.code.isEmpty())
         result[QStringLiteral("code")] = diagnostic.code;
     if (diagnostic.severity != LSPDiagnosticSeverity::Unknown)
         result[QStringLiteral("severity")] = (int)diagnostic.severity;
     if (!diagnostic.source.isEmpty())
         result[QStringLiteral("source")] = diagnostic.source;
     auto related = to_json(diagnostic.relatedInformation);
     if (related.isObject()) {
         result[QStringLiteral("relatedInformation")] = related;
     }
     return result;
 }
 
 static QJsonArray to_json(const QList<LSPTextDocumentContentChangeEvent> &changes)
 {
     QJsonArray result;
     for (const auto &change : changes) {
         result.push_back(QJsonObject { { MEMBER_RANGE, to_json(change.range) },
                                        { MEMBER_TEXT, change.text } });
     }
     return result;
 }
 
 static QJsonObject versionedTextDocumentIdentifier(const QUrl &document, int version = -1)
 {
     QJsonObject map { { MEMBER_URI, document.toString() } };
     if (version >= 0)
         map[MEMBER_VERSION] = version;
     return map;
 }
 
 static QJsonObject textDocumentItem(const QUrl &document, const QString &lang, const QString &text,
                                     int version)
 {
     auto map = versionedTextDocumentIdentifier(document, version);
     map[MEMBER_TEXT] = text;
     map[MEMBER_LANGID] = lang;
     return map;
 }
 
 static QJsonObject textDocumentParams(const QJsonObject &m)
 {
     return QJsonObject { { QStringLiteral("textDocument"), m } };
 }
 
 static QJsonObject textDocumentParams(const QUrl &document, int version = -1)
 {
     return textDocumentParams(versionedTextDocumentIdentifier(document, version));
 }
 
 static QJsonObject textDocumentPositionParams(const QUrl &document, LSPPosition pos)
 {
     auto params = textDocumentParams(document);
     params[MEMBER_POSITION] = to_json(pos);
     return params;
 }
 
 static QJsonObject referenceParams(const QUrl &document, LSPPosition pos, bool decl)
 {
     auto params = textDocumentPositionParams(document, pos);
     params[QStringLiteral("context")] =
             QJsonObject { { QStringLiteral("includeDeclaration"), decl } };
     return params;
 }
 
 static QJsonObject formattingOptions(const LSPFormattingOptions &_options)
 {
     auto options = _options.extra;
     options[QStringLiteral("tabSize")] = _options.tabSize;
     options[QStringLiteral("insertSpaces")] = _options.insertSpaces;
     return options;
 }
 
 static QJsonObject documentRangeFormattingParams(const QUrl &document, const LSPRange *range,
                                                  const LSPFormattingOptions &_options)
 {
     auto params = textDocumentParams(document);
     if (range) {
         params[MEMBER_RANGE] = to_json(*range);
     }
     params[QStringLiteral("options")] = formattingOptions(_options);
     return params;
 }
 
 static QJsonObject documentOnTypeFormattingParams(const QUrl &document, const LSPPosition &pos,
                                                   const QChar &lastChar,
                                                   const LSPFormattingOptions &_options)
 {
     auto params = textDocumentPositionParams(document, pos);
     params[QStringLiteral("ch")] = QString(lastChar);
     params[QStringLiteral("options")] = formattingOptions(_options);
     return params;
 }
 
 static QJsonObject renameParams(const QUrl &document, const LSPPosition &pos,
                                 const QString &newName)
 {
     auto params = textDocumentPositionParams(document, pos);
     params[QStringLiteral("newName")] = newName;
     return params;
 }
 
 static QJsonObject codeActionParams(const QUrl &document, const LSPRange &range,
-                                    QList<QString> kinds, QList<LSPDiagnostic> diagnostics)
+                                    const QList<QString>& kinds, const QList<LSPDiagnostic>& diagnostics)
 {
     auto params = textDocumentParams(document);
     params[MEMBER_RANGE] = to_json(range);
     QJsonObject context;
     QJsonArray diags;
     for (const auto &diagnostic : diagnostics) {
         diags.push_back(to_json(diagnostic));
     }
     context[MEMBER_DIAGNOSTICS] = diags;
     if (kinds.length())
         context[QStringLiteral("only")] = QJsonArray::fromStringList(kinds);
     params[QStringLiteral("context")] = context;
     return params;
 }
 
 static QJsonObject executeCommandParams(const QString &command, const QJsonValue &args)
 {
     return QJsonObject { { MEMBER_COMMAND, command }, { MEMBER_ARGUMENTS, args } };
 }
 
 static QJsonObject applyWorkspaceEditResponse(const LSPApplyWorkspaceEditResponse &response)
 {
     return QJsonObject { { QStringLiteral("applied"), response.applied },
                          { QStringLiteral("failureReason"), response.failureReason } };
 }
 
 static void from_json(QVector<QChar> &trigger, const QJsonValue &json)
 {
     for (const auto &t : json.toArray()) {
         auto st = t.toString();
         if (st.length())
             trigger.push_back(st.at(0));
     }
 }
 
 static void from_json(LSPCompletionOptions &options, const QJsonValue &json)
 {
     if (json.isObject()) {
         auto ob = json.toObject();
         options.provider = true;
         options.resolveProvider = ob.value(QStringLiteral("resolveProvider")).toBool();
         from_json(options.triggerCharacters, ob.value(QStringLiteral("triggerCharacters")));
     }
 }
 
 static void from_json(LSPSignatureHelpOptions &options, const QJsonValue &json)
 {
     if (json.isObject()) {
         auto ob = json.toObject();
         options.provider = true;
         from_json(options.triggerCharacters, ob.value(QStringLiteral("triggerCharacters")));
     }
 }
 
 static void from_json(LSPDocumentOnTypeFormattingOptions &options, const QJsonValue &json)
 {
     if (json.isObject()) {
         auto ob = json.toObject();
         options.provider = true;
         from_json(options.triggerCharacters, ob.value(QStringLiteral("moreTriggerCharacter")));
         auto trigger = ob.value(QStringLiteral("firstTriggerCharacter")).toString();
         if (trigger.size()) {
             options.triggerCharacters.insert(0, trigger.at(0));
         }
     }
 }
 
 static void from_json(LSPServerCapabilities &caps, const QJsonObject &json)
 {
     auto sync = json.value(QStringLiteral("textDocumentSync"));
     caps.textDocumentSync =
             (LSPDocumentSyncKind)(sync.isObject() ? sync.toObject().value(QStringLiteral("change"))
                                                   : sync)
                     .toInt((int)LSPDocumentSyncKind::None);
     caps.hoverProvider = json.value(QStringLiteral("hoverProvider")).toBool();
     from_json(caps.completionProvider, json.value(QStringLiteral("completionProvider")));
     from_json(caps.signatureHelpProvider, json.value(QStringLiteral("signatureHelpProvider")));
     caps.definitionProvider = json.value(QStringLiteral("definitionProvider")).toBool();
     caps.declarationProvider = json.value(QStringLiteral("declarationProvider")).toBool();
     caps.referencesProvider = json.value(QStringLiteral("referencesProvider")).toBool();
     caps.documentSymbolProvider = json.value(QStringLiteral("documentSymbolProvider")).toBool();
     caps.documentHighlightProvider =
             json.value(QStringLiteral("documentHighlightProvider")).toBool();
     caps.documentFormattingProvider =
             json.value(QStringLiteral("documentFormattingProvider")).toBool();
     caps.documentRangeFormattingProvider =
             json.value(QStringLiteral("documentRangeFormattingProvider")).toBool();
     from_json(caps.documentOnTypeFormattingProvider,
               json.value(QStringLiteral("documentOnTypeFormattingProvider")));
     caps.renameProvider = json.value(QStringLiteral("renameProvider")).toBool();
     auto codeActionProvider = json.value(QStringLiteral("codeActionProvider"));
     caps.codeActionProvider = codeActionProvider.toBool() || codeActionProvider.isObject();
 }
 
 // follow suit; as performed in kate docmanager
 // normalize at this stage/layer to avoid surprises elsewhere
 // sadly this is not a single QUrl method as one might hope ...
 static QUrl normalizeUrl(const QUrl &url)
 {
     // Resolve symbolic links for local files (done anyway in KTextEditor)
     if (url.isLocalFile()) {
         QString normalizedUrl = QFileInfo(url.toLocalFile()).canonicalFilePath();
         if (!normalizedUrl.isEmpty()) {
             return QUrl::fromLocalFile(normalizedUrl);
         }
     }
 
     // else: cleanup only the .. stuff
     return url.adjusted(QUrl::NormalizePathSegments);
 }
 
 static LSPMarkupContent parseMarkupContent(const QJsonValue &v)
 {
     LSPMarkupContent ret;
     if (v.isObject()) {
         const auto &vm = v.toObject();
         ret.value = vm.value(QStringLiteral("value")).toString();
         auto kind = vm.value(MEMBER_KIND).toString();
         if (kind == QStringLiteral("plaintext")) {
             ret.kind = LSPMarkupKind::PlainText;
         } else if (kind == QStringLiteral("markdown")) {
             ret.kind = LSPMarkupKind::MarkDown;
         }
     } else if (v.isString()) {
         ret.kind = LSPMarkupKind::PlainText;
         ret.value = v.toString();
     }
     return ret;
 }
 
 static LSPPosition parsePosition(const QJsonObject &m)
 {
     auto line = m.value(MEMBER_LINE).toInt(-1);
     auto column = m.value(MEMBER_CHARACTER).toInt(-1);
     return { line, column };
 }
 
 static bool isPositionValid(const LSPPosition &pos)
 {
     return pos.isValid();
 }
 
 static LSPRange parseRange(const QJsonObject &range)
 {
     auto startpos = parsePosition(range.value(MEMBER_START).toObject());
     auto endpos = parsePosition(range.value(MEMBER_END).toObject());
     return { startpos, endpos };
 }
 
 static LSPLocation parseLocation(const QJsonObject &loc)
 {
     auto uri = normalizeUrl(QUrl(loc.value(MEMBER_URI).toString()));
     auto range = parseRange(loc.value(MEMBER_RANGE).toObject());
     return { QUrl(uri), range };
 }
 
 static LSPDocumentHighlight parseDocumentHighlight(const QJsonValue &result)
 {
     auto hover = result.toObject();
     auto range = parseRange(hover.value(MEMBER_RANGE).toObject());
     auto kind = (LSPDocumentHighlightKind)hover.value(MEMBER_KIND)
                         .toInt((int)LSPDocumentHighlightKind::Text); // default is
                                                                      // DocumentHighlightKind.Text
     return { range, kind };
 }
 
 static QList<LSPDocumentHighlight> parseDocumentHighlightList(const QJsonValue &result)
 {
     QList<LSPDocumentHighlight> ret;
     // could be array
     if (result.isArray()) {
         for (const auto &def : result.toArray()) {
             ret.push_back(parseDocumentHighlight(def));
         }
     } else if (result.isObject()) {
         // or a single value
         ret.push_back(parseDocumentHighlight(result));
     }
     return ret;
 }
 
 static LSPMarkupContent parseHoverContentElement(const QJsonValue &contents)
 {
     LSPMarkupContent result;
     if (contents.isString()) {
         result.value = contents.toString();
     } else {
         // should be object, pretend so
         auto cont = contents.toObject();
         auto text = cont.value(QStringLiteral("value")).toString();
         if (text.isEmpty()) {
             // nothing to lose, try markdown
             result = parseMarkupContent(contents);
         } else {
             result.value = text;
         }
     }
     if (result.value.length())
         result.kind = LSPMarkupKind::PlainText;
     return result;
 }
 
 static LSPHover parseHover(const QJsonValue &result)
 {
     LSPHover ret;
     auto hover = result.toObject();
     // normalize content which can be of many forms
     ret.range = parseRange(hover.value(MEMBER_RANGE).toObject());
     auto contents = hover.value(QStringLiteral("contents"));
 
     // support the deprecated MarkedString[] variant, used by e.g. Rust rls
     if (contents.isArray()) {
         for (const auto &c : contents.toArray()) {
             ret.contents.push_back(parseHoverContentElement(c));
         }
     } else {
         ret.contents.push_back(parseHoverContentElement(contents));
     }
 
     return ret;
 }
 
 static QList<LSPSymbolInformation> parseDocumentSymbols(const QJsonValue &result)
 {
     // the reply could be old SymbolInformation[] or new (hierarchical) DocumentSymbol[]
     // try to parse it adaptively in any case
     // if new style, hierarchy is specified clearly in reply
     // if old style, it is assumed the values enter linearly, that is;
     // * a parent/container is listed before its children
     // * if a name is defined/declared several times and then used as a parent,
     //   then it is the last instance that is used as a parent
 
     QList<LSPSymbolInformation> ret;
     QMap<QString, LSPSymbolInformation *> index;
 
     std::function<void(const QJsonObject &symbol, LSPSymbolInformation *parent)> parseSymbol =
             [&](const QJsonObject &symbol, LSPSymbolInformation *parent) {
                 // if flat list, try to find parent by name
                 if (!parent) {
                     auto container = symbol.value(QStringLiteral("containerName")).toString();
                     parent = index.value(container, nullptr);
                 }
                 auto list = parent ? &parent->children : &ret;
                 const auto &location = symbol.value(MEMBER_LOCATION).toObject();
                 const auto &mrange = symbol.contains(MEMBER_RANGE) ? symbol.value(MEMBER_RANGE)
                                                                    : location.value(MEMBER_RANGE);
                 auto range = parseRange(mrange.toObject());
                 if (isPositionValid(range.start()) && isPositionValid(range.end())) {
                     auto name = symbol.value(QStringLiteral("name")).toString();
                     auto kind = (LSPSymbolKind)symbol.value(MEMBER_KIND).toInt();
                     auto detail = symbol.value(MEMBER_DETAIL).toString();
                     list->push_back({ name, kind, range, detail });
                     index[name] = &list->back();
                     // proceed recursively
                     for (const auto &child : symbol.value(QStringLiteral("children")).toArray())
                         parseSymbol(child.toObject(), &list->back());
                 }
             };
 
     for (const auto &info : result.toArray()) {
         parseSymbol(info.toObject(), nullptr);
     }
     return ret;
 }
 
 static QList<LSPLocation> parseDocumentLocation(const QJsonValue &result)
 {
     QList<LSPLocation> ret;
     // could be array
     if (result.isArray()) {
         for (const auto &def : result.toArray()) {
             ret.push_back(parseLocation(def.toObject()));
         }
     } else if (result.isObject()) {
         // or a single value
         ret.push_back(parseLocation(result.toObject()));
     }
     return ret;
 }
 
 static QList<LSPCompletionItem> parseDocumentCompletion(const QJsonValue &result)
 {
     QList<LSPCompletionItem> ret;
     QJsonArray items = result.toArray();
     // might be CompletionList
     if (items.size() == 0) {
         items = result.toObject().value(QStringLiteral("items")).toArray();
     }
     for (const auto &vitem : items) {
         const auto &item = vitem.toObject();
         auto label = item.value(MEMBER_LABEL).toString();
         auto detail = item.value(MEMBER_DETAIL).toString();
         auto doc = parseMarkupContent(item.value(MEMBER_DOCUMENTATION));
         auto sortText = item.value(QStringLiteral("sortText")).toString();
         if (sortText.isEmpty())
             sortText = label;
         auto insertText = item.value(QStringLiteral("insertText")).toString();
         if (insertText.isEmpty())
             insertText = label;
         auto kind = (LSPCompletionItemKind)item.value(MEMBER_KIND).toInt();
         ret.push_back({ label, kind, detail, doc, sortText, insertText });
     }
     return ret;
 }
 
 static LSPSignatureInformation parseSignatureInformation(const QJsonObject &json)
 {
     LSPSignatureInformation info;
 
     info.label = json.value(MEMBER_LABEL).toString();
     info.documentation = parseMarkupContent(json.value(MEMBER_DOCUMENTATION));
     for (const auto &rpar : json.value(QStringLiteral("parameters")).toArray()) {
         auto par = rpar.toObject();
         auto label = par.value(MEMBER_LABEL);
         int begin = -1, end = -1;
         if (label.isArray()) {
             auto range = label.toArray();
             if (range.size() == 2) {
                 begin = range.at(0).toInt(-1);
                 end = range.at(1).toInt(-1);
                 if (begin > info.label.length())
                     begin = -1;
                 if (end > info.label.length())
                     end = -1;
             }
         } else {
             auto sub = label.toString();
             if (sub.length()) {
                 begin = info.label.indexOf(sub);
                 if (begin >= 0) {
                     end = begin + sub.length();
                 }
             }
         }
         info.parameters.push_back({ begin, end });
     }
     return info;
 }
 
 static LSPSignatureHelp parseSignatureHelp(const QJsonValue &result)
 {
     LSPSignatureHelp ret;
     QJsonObject sig = result.toObject();
 
     for (const auto &info : sig.value(QStringLiteral("signatures")).toArray()) {
         ret.signatures.push_back(parseSignatureInformation(info.toObject()));
     }
     ret.activeSignature = sig.value(QStringLiteral("activeSignature")).toInt(0);
     ret.activeParameter = sig.value(QStringLiteral("activeParameter")).toInt(0);
     ret.activeSignature = qMin(qMax(ret.activeSignature, 0), ret.signatures.size());
     ret.activeParameter = qMin(qMax(ret.activeParameter, 0), ret.signatures.size());
     return ret;
 }
 
 static QList<LSPTextEdit> parseTextEdit(const QJsonValue &result)
 {
     QList<LSPTextEdit> ret;
     for (const auto &redit : result.toArray()) {
         auto edit = redit.toObject();
         auto text = edit.value(QStringLiteral("newText")).toString();
         auto range = parseRange(edit.value(MEMBER_RANGE).toObject());
         ret.push_back({ range, text });
     }
     return ret;
 }
 
 static LSPWorkspaceEdit parseWorkSpaceEdit(const QJsonValue &result)
 {
     QHash<QUrl, QList<LSPTextEdit>> ret;
     auto changes = result.toObject().value(QStringLiteral("changes")).toObject();
     for (auto it = changes.begin(); it != changes.end(); ++it) {
         ret.insert(normalizeUrl(QUrl(it.key())), parseTextEdit(it.value()));
     }
     return { ret };
 }
 
 static LSPCommand parseCommand(const QJsonObject &result)
 {
     auto title = result.value(MEMBER_TITLE).toString();
     auto command = result.value(MEMBER_COMMAND).toString();
     auto args = result.value(MEMBER_ARGUMENTS).toArray();
     return { title, command, args };
 }
 
 static QList<LSPDiagnostic> parseDiagnostics(const QJsonArray &result)
 {
     QList<LSPDiagnostic> ret;
     for (const auto &vdiag : result) {
         auto diag = vdiag.toObject();
         auto range = parseRange(diag.value(MEMBER_RANGE).toObject());
         auto severity = (LSPDiagnosticSeverity)diag.value(QStringLiteral("severity")).toInt();
         auto code = diag.value(QStringLiteral("code")).toString();
         auto source = diag.value(QStringLiteral("source")).toString();
         auto message = diag.value(MEMBER_MESSAGE).toString();
         auto related = diag.value(QStringLiteral("relatedInformation")).toObject();
         auto relLocation = parseLocation(related.value(MEMBER_LOCATION).toObject());
         auto relMessage = related.value(MEMBER_MESSAGE).toString();
         ret.push_back({ range, severity, code, source, message, relLocation, relMessage });
     }
     return ret;
 }
 
 static QList<LSPCodeAction> parseCodeAction(const QJsonValue &result)
 {
     QList<LSPCodeAction> ret;
     for (const auto &vaction : result.toArray()) {
         auto action = vaction.toObject();
         // entry could be Command or CodeAction
         if (!action.value(MEMBER_COMMAND).isString()) {
             // CodeAction
             auto title = action.value(MEMBER_TITLE).toString();
             auto kind = action.value(MEMBER_KIND).toString();
             auto command = parseCommand(action.value(MEMBER_COMMAND).toObject());
             auto edit = parseWorkSpaceEdit(action.value(MEMBER_EDIT));
             auto diagnostics = parseDiagnostics(action.value(MEMBER_DIAGNOSTICS).toArray());
             ret.push_back({ title, kind, diagnostics, edit, command });
         } else {
             // Command
             auto command = parseCommand(action);
             ret.push_back({ command.title, QString(), {}, {}, command });
         }
     }
     return ret;
 }
 
 static LSPPublishDiagnosticsParams parseDiagnostics(const QJsonObject &result)
 {
     LSPPublishDiagnosticsParams ret;
 
     ret.uri = normalizeUrl(QUrl(result.value(MEMBER_URI).toString()));
     ret.diagnostics = parseDiagnostics(result.value(MEMBER_DIAGNOSTICS).toArray());
     return ret;
 }
 
 static LSPApplyWorkspaceEditParams parseApplyWorkspaceEditParams(const QJsonObject &result)
 {
     LSPApplyWorkspaceEditParams ret;
 
     ret.label = result.value(MEMBER_LABEL).toString();
     ret.edit = parseWorkSpaceEdit(result.value(MEMBER_EDIT));
     return ret;
 }
 
 using GenericReplyType = QJsonValue;
 using GenericReplyHandler = ReplyHandler<GenericReplyType>;
 
 class LSPClientServer::LSPClientServerPrivate
 {
     typedef LSPClientServerPrivate self_type;
 
     LSPClientServer *q;
     // server cmd line
     QStringList m_server;
     // workspace root to pass along
     QUrl m_root;
     // user provided init
     QJsonValue m_init;
     // server process
     QProcess m_sproc;
     // server declared capabilites
     LSPServerCapabilities m_capabilities;
     // server state
     State m_state = State::None;
     // last msg id
     int m_id = 0;
     // receive buffer
     QByteArray m_receive;
     // registered reply handlers
     QHash<int, GenericReplyHandler> m_handlers;
     // pending request responses
     static constexpr int MAX_REQUESTS = 5;
     QVector<int> m_requests { MAX_REQUESTS + 1 };
 
 public:
     LSPClientServerPrivate(LSPClientServer *_q, const QStringList &server, const QUrl &root,
                            const QJsonValue &init)
         : q(_q), m_server(server), m_root(root), m_init(init)
     {
         // setup async reading
         QObject::connect(&m_sproc, &QProcess::readyRead, utils::mem_fun(&self_type::read, this));
         QObject::connect(&m_sproc, &QProcess::stateChanged,
                          utils::mem_fun(&self_type::onStateChanged, this));
     }
 
     ~LSPClientServerPrivate() { stop(TIMEOUT_SHUTDOWN, TIMEOUT_SHUTDOWN); }
 
     const QStringList &cmdline() const { return m_server; }
 
     State state() { return m_state; }
 
     const LSPServerCapabilities &capabilities() { return m_capabilities; }
 
     int cancel(int reqid)
     {
         if (m_handlers.remove(reqid) > 0) {
             auto params = QJsonObject { { MEMBER_ID, reqid } };
             write(init_request(QStringLiteral("$/cancelRequest"), params));
         }
         return -1;
     }
 
 private:
     void setState(State s)
     {
         if (m_state != s) {
             m_state = s;
             emit q->stateChanged(q);
         }
     }
 
     RequestHandle write(const QJsonObject &msg, const GenericReplyHandler &h = nullptr,
                         const int *id = nullptr)
     {
         RequestHandle ret;
         ret.m_server = q;
 
         if (!running())
             return ret;
 
         auto ob = msg;
         ob.insert(QStringLiteral("jsonrpc"), QStringLiteral("2.0"));
         // notification == no handler
         if (h) {
             ob.insert(MEMBER_ID, ++m_id);
             ret.m_id = m_id;
             m_handlers[m_id] = h;
         } else if (id) {
             ob.insert(MEMBER_ID, *id);
         }
 
         QJsonDocument json(ob);
         auto sjson = json.toJson();
 
         qCInfo(LSPCLIENT) << "calling" << msg[MEMBER_METHOD].toString();
         qCDebug(LSPCLIENT) << "sending message:\n" << QString::fromUtf8(sjson);
         // some simple parsers expect length header first
         auto hdr = QStringLiteral(CONTENT_LENGTH ": %1\r\n").arg(sjson.length());
         // write is async, so no blocking wait occurs here
         m_sproc.write(hdr.toLatin1());
         m_sproc.write("\r\n");
         m_sproc.write(sjson);
 
         return ret;
     }
 
     RequestHandle send(const QJsonObject &msg, const GenericReplyHandler &h = nullptr)
     {
         if (m_state == State::Running)
             return write(msg, h);
         else
             qCWarning(LSPCLIENT) << "send for non-running server";
         return RequestHandle();
     }
 
     void read()
     {
         // accumulate in buffer
         m_receive.append(m_sproc.readAllStandardOutput());
 
         // try to get one (or more) message
         QByteArray &buffer = m_receive;
 
         while (true) {
             qCDebug(LSPCLIENT) << "buffer size" << buffer.length();
             auto header = QByteArray(CONTENT_LENGTH ":");
             int index = buffer.indexOf(header);
             if (index < 0) {
                 // avoid collecting junk
                 if (buffer.length() > 1 << 20)
                     buffer.clear();
                 break;
             }
             index += header.length();
             int endindex = buffer.indexOf("\r\n", index);
             auto msgstart = buffer.indexOf("\r\n\r\n", index);
             if (endindex < 0 || msgstart < 0)
                 break;
             msgstart += 4;
             bool ok = false;
             auto length = buffer.mid(index, endindex - index).toInt(&ok, 10);
             // FIXME perhaps detect if no reply for some time
             // then again possibly better left to user to restart in such case
             if (!ok) {
                 qCWarning(LSPCLIENT) << "invalid " CONTENT_LENGTH;
                 // flush and try to carry on to some next header
                 buffer.remove(0, msgstart);
                 continue;
             }
             // sanity check to avoid extensive buffering
             if (length > 1 << 29) {
                 qCWarning(LSPCLIENT) << "excessive size";
                 buffer.clear();
                 continue;
             }
             if (msgstart + length > buffer.length())
                 break;
             // now onto payload
             auto payload = buffer.mid(msgstart, length);
             buffer.remove(0, msgstart + length);
             qCInfo(LSPCLIENT) << "got message payload size " << length;
             qCDebug(LSPCLIENT) << "message payload:\n" << payload;
             QJsonParseError error {};
             auto msg = QJsonDocument::fromJson(payload, &error);
             if (error.error != QJsonParseError::NoError || !msg.isObject()) {
                 qCWarning(LSPCLIENT) << "invalid response payload";
                 continue;
             }
             auto result = msg.object();
             // check if it is the expected result
             int msgid = -1;
             if (result.contains(MEMBER_ID)) {
                 msgid = result[MEMBER_ID].toInt();
             } else {
                 processNotification(result);
                 continue;
             }
             // could be request
             if (result.contains(MEMBER_METHOD)) {
                 processRequest(result);
                 continue;
             }
 
             // a valid reply; what to do with it now
             auto it = m_handlers.find(msgid);
             if (it != m_handlers.end()) {
                 // copy handler to local storage
                 const auto handler = *it;
 
                 // remove handler from our set, do this pre handler execution to avoid races
                 m_handlers.erase(it);
 
                 // run handler, might e.g. trigger some new LSP actions for this server
                 handler(result.value(MEMBER_RESULT));
             } else {
                 // could have been canceled
                 qCDebug(LSPCLIENT) << "unexpected reply id";
             }
         }
     }
 
     static QJsonObject init_error(const LSPErrorCode code, const QString &msg)
     {
         return QJsonObject {
             { MEMBER_ERROR, QJsonObject { { MEMBER_CODE, (int)code }, { MEMBER_MESSAGE, msg } } }
         };
     }
 
     static QJsonObject init_request(const QString &method,
                                     const QJsonObject &params = QJsonObject())
     {
         return QJsonObject { { MEMBER_METHOD, method }, { MEMBER_PARAMS, params } };
     }
 
     static QJsonObject init_response(const QJsonValue &result = QJsonValue())
     {
         return QJsonObject { { MEMBER_RESULT, result } };
     }
 
     bool running() { return m_sproc.state() == QProcess::Running; }
 
     void onStateChanged(QProcess::ProcessState nstate)
     {
         if (nstate == QProcess::NotRunning) {
             setState(State::None);
         }
     }
 
     void shutdown()
     {
         if (m_state == State::Running) {
             qCInfo(LSPCLIENT) << "shutting down" << m_server;
             // cancel all pending
             m_handlers.clear();
             // shutdown sequence
             send(init_request(QStringLiteral("shutdown")));
             // maybe we will get/see reply on the above, maybe not
             // but not important or useful either way
             send(init_request(QStringLiteral("exit")));
             // no longer fit for regular use
             setState(State::Shutdown);
         }
     }
 
     void onInitializeReply(const QJsonValue &value)
     {
         // only parse parts that we use later on
         from_json(m_capabilities,
                   value.toObject().value(QStringLiteral("capabilities")).toObject());
         // finish init
         initialized();
     }
 
     void initialize()
     {
         QJsonObject codeAction {
             { QStringLiteral("codeActionLiteralSupport"),
               QJsonObject { { QStringLiteral("codeActionKind"),
                               QJsonObject { { QStringLiteral("valueSet"), QJsonArray() } } } } }
         };
         QJsonObject capabilities {
             { QStringLiteral("textDocument"),
               QJsonObject {
                       {
                               QStringLiteral("documentSymbol"),
                               QJsonObject { { QStringLiteral("hierarchicalDocumentSymbolSupport"),
                                               true } },
                       },
                       { QStringLiteral("publishDiagnostics"),
                         QJsonObject { { QStringLiteral("relatedInformation"), true } } },
                       { QStringLiteral("codeAction"), codeAction } } }
         };
         // NOTE a typical server does not use root all that much,
         // other than for some corner case (in) requests
         QJsonObject params { { QStringLiteral("processId"), QCoreApplication::applicationPid() },
                              { QStringLiteral("rootPath"), m_root.path() },
                              { QStringLiteral("rootUri"), m_root.toString() },
                              { QStringLiteral("capabilities"), capabilities },
                              { QStringLiteral("initializationOptions"), m_init } };
         //
         write(init_request(QStringLiteral("initialize"), params),
               utils::mem_fun(&self_type::onInitializeReply, this));
     }
 
     void initialized()
     {
         write(init_request(QStringLiteral("initialized")));
         setState(State::Running);
     }
 
 public:
     bool start()
     {
         if (m_state != State::None)
             return true;
 
         auto program = m_server.front();
         auto args = m_server;
         args.pop_front();
         qCInfo(LSPCLIENT) << "starting" << m_server << "with root" << m_root;
 
         // start LSP server in project root
         m_sproc.setWorkingDirectory(m_root.path());
 
         // at least we see some errors somewhere then
         m_sproc.setProcessChannelMode(QProcess::ForwardedErrorChannel);
         m_sproc.setReadChannel(QProcess::QProcess::StandardOutput);
         m_sproc.start(program, args);
         bool result = m_sproc.waitForStarted();
         if (!result) {
             qCWarning(LSPCLIENT) << m_sproc.error();
         } else {
             setState(State::Started);
             // perform initial handshake
             initialize();
         }
         return result;
     }
 
     void stop(int to_term, int to_kill)
     {
         if (running()) {
             shutdown();
             if ((to_term >= 0) && !m_sproc.waitForFinished(to_term))
                 m_sproc.terminate();
             if ((to_kill >= 0) && !m_sproc.waitForFinished(to_kill))
                 m_sproc.kill();
         }
     }
 
     RequestHandle documentSymbols(const QUrl &document, const GenericReplyHandler &h)
     {
         auto params = textDocumentParams(document);
         return send(init_request(QStringLiteral("textDocument/documentSymbol"), params), h);
     }
 
     RequestHandle documentDefinition(const QUrl &document, const LSPPosition &pos,
                                      const GenericReplyHandler &h)
     {
         auto params = textDocumentPositionParams(document, pos);
         return send(init_request(QStringLiteral("textDocument/definition"), params), h);
     }
 
     RequestHandle documentDeclaration(const QUrl &document, const LSPPosition &pos,
                                       const GenericReplyHandler &h)
     {
         auto params = textDocumentPositionParams(document, pos);
         return send(init_request(QStringLiteral("textDocument/declaration"), params), h);
     }
 
     RequestHandle documentHover(const QUrl &document, const LSPPosition &pos,
                                 const GenericReplyHandler &h)
     {
         auto params = textDocumentPositionParams(document, pos);
         return send(init_request(QStringLiteral("textDocument/hover"), params), h);
     }
 
     RequestHandle documentHighlight(const QUrl &document, const LSPPosition &pos,
                                     const GenericReplyHandler &h)
     {
         auto params = textDocumentPositionParams(document, pos);
         return send(init_request(QStringLiteral("textDocument/documentHighlight"), params), h);
     }
 
     RequestHandle documentReferences(const QUrl &document, const LSPPosition &pos, bool decl,
                                      const GenericReplyHandler &h)
     {
         auto params = referenceParams(document, pos, decl);
         return send(init_request(QStringLiteral("textDocument/references"), params), h);
     }
 
     RequestHandle documentCompletion(const QUrl &document, const LSPPosition &pos,
                                      const GenericReplyHandler &h)
     {
         auto params = textDocumentPositionParams(document, pos);
         return send(init_request(QStringLiteral("textDocument/completion"), params), h);
     }
 
     RequestHandle signatureHelp(const QUrl &document, const LSPPosition &pos,
                                 const GenericReplyHandler &h)
     {
         auto params = textDocumentPositionParams(document, pos);
         return send(init_request(QStringLiteral("textDocument/signatureHelp"), params), h);
     }
 
     RequestHandle documentFormatting(const QUrl &document, const LSPFormattingOptions &options,
                                      const GenericReplyHandler &h)
     {
         auto params = documentRangeFormattingParams(document, nullptr, options);
         return send(init_request(QStringLiteral("textDocument/formatting"), params), h);
     }
 
     RequestHandle documentRangeFormatting(const QUrl &document, const LSPRange &range,
                                           const LSPFormattingOptions &options,
                                           const GenericReplyHandler &h)
     {
         auto params = documentRangeFormattingParams(document, &range, options);
         return send(init_request(QStringLiteral("textDocument/rangeFormatting"), params), h);
     }
 
     RequestHandle documentOnTypeFormatting(const QUrl &document, const LSPPosition &pos,
                                            QChar lastChar, const LSPFormattingOptions &options,
                                            const GenericReplyHandler &h)
     {
         auto params = documentOnTypeFormattingParams(document, pos, lastChar, options);
         return send(init_request(QStringLiteral("textDocument/onTypeFormatting"), params), h);
     }
 
     RequestHandle documentRename(const QUrl &document, const LSPPosition &pos,
-                                 const QString newName, const GenericReplyHandler &h)
+                                 const QString& newName, const GenericReplyHandler &h)
     {
         auto params = renameParams(document, pos, newName);
         return send(init_request(QStringLiteral("textDocument/rename"), params), h);
     }
 
     RequestHandle documentCodeAction(const QUrl &document, const LSPRange &range,
                                      const QList<QString> &kinds, QList<LSPDiagnostic> diagnostics,
                                      const GenericReplyHandler &h)
     {
-        auto params = codeActionParams(document, range, kinds, diagnostics);
+        auto params = codeActionParams(document, range, kinds, std::move(diagnostics));
         return send(init_request(QStringLiteral("textDocument/codeAction"), params), h);
     }
 
     void executeCommand(const QString &command, const QJsonValue &args)
     {
         auto params = executeCommandParams(command, args);
         send(init_request(QStringLiteral("workspace/executeCommand"), params));
     }
 
     void didOpen(const QUrl &document, int version, const QString &langId, const QString &text)
     {
         auto params = textDocumentParams(textDocumentItem(document, langId, text, version));
         send(init_request(QStringLiteral("textDocument/didOpen"), params));
     }
 
     void didChange(const QUrl &document, int version, const QString &text,
                    const QList<LSPTextDocumentContentChangeEvent> &changes)
     {
         Q_ASSERT(text.size() == 0 || changes.size() == 0);
         auto params = textDocumentParams(document, version);
         params[QStringLiteral("contentChanges")] = text.size()
                 ? QJsonArray { QJsonObject { { MEMBER_TEXT, text } } }
                 : to_json(changes);
         send(init_request(QStringLiteral("textDocument/didChange"), params));
     }
 
     void didSave(const QUrl &document, const QString &text)
     {
         auto params = textDocumentParams(document);
         params[QStringLiteral("text")] = text;
         send(init_request(QStringLiteral("textDocument/didSave"), params));
     }
 
     void didClose(const QUrl &document)
     {
         auto params = textDocumentParams(document);
         send(init_request(QStringLiteral("textDocument/didClose"), params));
     }
 
     void processNotification(const QJsonObject &msg)
     {
         auto method = msg[MEMBER_METHOD].toString();
         if (method == QStringLiteral("textDocument/publishDiagnostics")) {
             emit q->publishDiagnostics(parseDiagnostics(msg[MEMBER_PARAMS].toObject()));
         } else {
             qCWarning(LSPCLIENT) << "discarding notification" << method;
         }
     }
 
     template<typename ReplyType>
     static GenericReplyHandler make_handler(
             const ReplyHandler<ReplyType> &h, const QObject *context,
             typename utils::identity<std::function<ReplyType(const GenericReplyType &)>>::type c)
     {
         QPointer<const QObject> ctx(context);
         return [ctx, h, c](const GenericReplyType &m) {
             if (ctx)
                 h(c(m));
         };
     }
 
     GenericReplyHandler prepareResponse(int msgid)
     {
         // allow limited number of outstanding requests
         auto ctx = QPointer<LSPClientServer>(q);
         m_requests.push_back(msgid);
         if (m_requests.size() > MAX_REQUESTS) {
             m_requests.pop_front();
         }
         auto h = [ctx, this, msgid](const GenericReplyType &response) {
             if (!ctx) {
                 return;
             }
             auto index = m_requests.indexOf(msgid);
             if (index >= 0) {
                 m_requests.remove(index);
                 write(init_response(response), nullptr, &msgid);
             } else {
                 qCWarning(LSPCLIENT) << "discarding response" << msgid;
             }
         };
         return h;
     }
 
     template<typename ReplyType>
     static ReplyHandler<ReplyType> responseHandler(
             const GenericReplyHandler &h,
             typename utils::identity<std::function<GenericReplyType(const ReplyType &)>>::type c)
     {
         return [h, c](const ReplyType &m) { h(c(m)); };
     }
 
     // pretty rare and limited use, but anyway
     void processRequest(const QJsonObject &msg)
     {
         auto method = msg[MEMBER_METHOD].toString();
         auto msgid = msg[MEMBER_ID].toInt();
         auto params = msg[MEMBER_PARAMS];
         bool handled = false;
         if (method == QStringLiteral("workspace/applyEdit")) {
             auto h = responseHandler<LSPApplyWorkspaceEditResponse>(prepareResponse(msgid),
                                                                     applyWorkspaceEditResponse);
             emit q->applyEdit(parseApplyWorkspaceEditParams(params.toObject()), h, handled);
         } else {
             write(init_error(LSPErrorCode::MethodNotFound, method), nullptr, &msgid);
             qCWarning(LSPCLIENT) << "discarding request" << method;
         }
     }
 };
 
 // generic convert handler
 // sprinkle some connection-like context safety
 // not so likely relevant/needed due to typical sequence of events,
 // but in case the latter would be changed in surprising ways ...
 template<typename ReplyType>
 static GenericReplyHandler
 make_handler(const ReplyHandler<ReplyType> &h, const QObject *context,
              typename utils::identity<std::function<ReplyType(const GenericReplyType &)>>::type c)
 {
     QPointer<const QObject> ctx(context);
     return [ctx, h, c](const GenericReplyType &m) {
         if (ctx)
             h(c(m));
     };
 }
 
 LSPClientServer::LSPClientServer(const QStringList &server, const QUrl &root,
                                  const QJsonValue &init)
     : d(new LSPClientServerPrivate(this, server, root, init))
 {
 }
 
 LSPClientServer::~LSPClientServer()
 {
     delete d;
 }
 
 const QStringList &LSPClientServer::cmdline() const
 {
     return d->cmdline();
 }
 
 LSPClientServer::State LSPClientServer::state() const
 {
     return d->state();
 }
 
 const LSPServerCapabilities &LSPClientServer::capabilities() const
 {
     return d->capabilities();
 }
 
 bool LSPClientServer::start()
 {
     return d->start();
 }
 
 void LSPClientServer::stop(int to_t, int to_k)
 {
     return d->stop(to_t, to_k);
 }
 
 int LSPClientServer::cancel(int reqid)
 {
     return d->cancel(reqid);
 }
 
 LSPClientServer::RequestHandle
 LSPClientServer::documentSymbols(const QUrl &document, const QObject *context,
                                  const DocumentSymbolsReplyHandler &h)
 {
     return d->documentSymbols(document, make_handler(h, context, parseDocumentSymbols));
 }
 
 LSPClientServer::RequestHandle
 LSPClientServer::documentDefinition(const QUrl &document, const LSPPosition &pos,
                                     const QObject *context, const DocumentDefinitionReplyHandler &h)
 {
     return d->documentDefinition(document, pos, make_handler(h, context, parseDocumentLocation));
 }
 
 LSPClientServer::RequestHandle
 LSPClientServer::documentDeclaration(const QUrl &document, const LSPPosition &pos,
                                      const QObject *context,
                                      const DocumentDefinitionReplyHandler &h)
 {
     return d->documentDeclaration(document, pos, make_handler(h, context, parseDocumentLocation));
 }
 
 LSPClientServer::RequestHandle LSPClientServer::documentHover(const QUrl &document,
                                                               const LSPPosition &pos,
                                                               const QObject *context,
                                                               const DocumentHoverReplyHandler &h)
 {
     return d->documentHover(document, pos, make_handler(h, context, parseHover));
 }
 
 LSPClientServer::RequestHandle
 LSPClientServer::documentHighlight(const QUrl &document, const LSPPosition &pos,
                                    const QObject *context, const DocumentHighlightReplyHandler &h)
 {
     return d->documentHighlight(document, pos,
                                 make_handler(h, context, parseDocumentHighlightList));
 }
 
 LSPClientServer::RequestHandle
 LSPClientServer::documentReferences(const QUrl &document, const LSPPosition &pos, bool decl,
                                     const QObject *context, const DocumentDefinitionReplyHandler &h)
 {
     return d->documentReferences(document, pos, decl,
                                  make_handler(h, context, parseDocumentLocation));
 }
 
 LSPClientServer::RequestHandle
 LSPClientServer::documentCompletion(const QUrl &document, const LSPPosition &pos,
                                     const QObject *context, const DocumentCompletionReplyHandler &h)
 {
     return d->documentCompletion(document, pos, make_handler(h, context, parseDocumentCompletion));
 }
 
 LSPClientServer::RequestHandle LSPClientServer::signatureHelp(const QUrl &document,
                                                               const LSPPosition &pos,
                                                               const QObject *context,
                                                               const SignatureHelpReplyHandler &h)
 {
     return d->signatureHelp(document, pos, make_handler(h, context, parseSignatureHelp));
 }
 
 LSPClientServer::RequestHandle
 LSPClientServer::documentFormatting(const QUrl &document, const LSPFormattingOptions &options,
                                     const QObject *context, const FormattingReplyHandler &h)
 {
     return d->documentFormatting(document, options, make_handler(h, context, parseTextEdit));
 }
 
 LSPClientServer::RequestHandle
 LSPClientServer::documentRangeFormatting(const QUrl &document, const LSPRange &range,
                                          const LSPFormattingOptions &options,
                                          const QObject *context, const FormattingReplyHandler &h)
 {
     return d->documentRangeFormatting(document, range, options,
                                       make_handler(h, context, parseTextEdit));
 }
 
 LSPClientServer::RequestHandle
 LSPClientServer::documentOnTypeFormatting(const QUrl &document, const LSPPosition &pos,
                                           const QChar lastChar, const LSPFormattingOptions &options,
                                           const QObject *context, const FormattingReplyHandler &h)
 {
     return d->documentOnTypeFormatting(document, pos, lastChar, options,
                                        make_handler(h, context, parseTextEdit));
 }
 
 LSPClientServer::RequestHandle
-LSPClientServer::documentRename(const QUrl &document, const LSPPosition &pos, const QString newName,
+LSPClientServer::documentRename(const QUrl &document, const LSPPosition &pos, const QString& newName,
                                 const QObject *context, const WorkspaceEditReplyHandler &h)
 {
     return d->documentRename(document, pos, newName, make_handler(h, context, parseWorkSpaceEdit));
 }
 
 LSPClientServer::RequestHandle
 LSPClientServer::documentCodeAction(const QUrl &document, const LSPRange &range,
                                     const QList<QString> &kinds, QList<LSPDiagnostic> diagnostics,
                                     const QObject *context, const CodeActionReplyHandler &h)
 {
-    return d->documentCodeAction(document, range, kinds, diagnostics,
+    return d->documentCodeAction(document, range, kinds, std::move(diagnostics),
                                  make_handler(h, context, parseCodeAction));
 }
 
 void LSPClientServer::executeCommand(const QString &command, const QJsonValue &args)
 {
     return d->executeCommand(command, args);
 }
 
 void LSPClientServer::didOpen(const QUrl &document, int version, const QString &langId,
                               const QString &text)
 {
     return d->didOpen(document, version, langId, text);
 }
 
 void LSPClientServer::didChange(const QUrl &document, int version, const QString &text,
                                 const QList<LSPTextDocumentContentChangeEvent> &changes)
 {
     return d->didChange(document, version, text, changes);
 }
 
 void LSPClientServer::didSave(const QUrl &document, const QString &text)
 {
     return d->didSave(document, text);
 }
 
 void LSPClientServer::didClose(const QUrl &document)
 {
     return d->didClose(document);
 }
diff --git a/addons/lspclient/lspclientserver.h b/addons/lspclient/lspclientserver.h
index bcb843229..c8fb2b00b 100644
--- a/addons/lspclient/lspclientserver.h
+++ b/addons/lspclient/lspclientserver.h
@@ -1,182 +1,182 @@
 /*  SPDX-License-Identifier: MIT
 
     Copyright (C) 2019 Mark Nauwelaerts <mark.nauwelaerts@gmail.com>
 
     Permission is hereby granted, free of charge, to any person obtaining
     a copy of this software and associated documentation files (the
     "Software"), to deal in the Software without restriction, including
     without limitation the rights to use, copy, modify, merge, publish,
     distribute, sublicense, and/or sell copies of the Software, and to
     permit persons to whom the Software is furnished to do so, subject to
     the following conditions:
 
     The above copyright notice and this permission notice shall be included
     in all copies or substantial portions of the Software.
 
     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #ifndef LSPCLIENTSERVER_H
 #define LSPCLIENTSERVER_H
 
 #include "lspclientprotocol.h"
 
 #include <QObject>
 #include <QString>
 #include <QUrl>
 #include <QList>
 #include <QVector>
 #include <QPointer>
 #include <QJsonValue>
 
 #include <functional>
 
 namespace utils {
 
 // template helper
 // function bind helpers
 template<typename R, typename T, typename Tp, typename... Args>
 inline std::function<R(Args...)> mem_fun(R (T::*pm)(Args...), Tp object)
 {
     return [object, pm](Args... args) { return (object->*pm)(std::forward<Args>(args)...); };
 }
 
 template<typename R, typename T, typename Tp, typename... Args>
 inline std::function<R(Args...)> mem_fun(R (T::*pm)(Args...) const, Tp object)
 {
     return [object, pm](Args... args) { return (object->*pm)(std::forward<Args>(args)...); };
 }
 
 // prevent argument deduction
 template<typename T>
 struct identity {
     typedef T type;
 };
 
 } // namespace utils
 
 static const int TIMEOUT_SHUTDOWN = 200;
 
 template<typename T>
 using ReplyHandler = std::function<void(const T &)>;
 
 using DocumentSymbolsReplyHandler = ReplyHandler<QList<LSPSymbolInformation>>;
 using DocumentDefinitionReplyHandler = ReplyHandler<QList<LSPLocation>>;
 using DocumentHighlightReplyHandler = ReplyHandler<QList<LSPDocumentHighlight>>;
 using DocumentHoverReplyHandler = ReplyHandler<LSPHover>;
 using DocumentCompletionReplyHandler = ReplyHandler<QList<LSPCompletionItem>>;
 using SignatureHelpReplyHandler = ReplyHandler<LSPSignatureHelp>;
 using FormattingReplyHandler = ReplyHandler<QList<LSPTextEdit>>;
 using CodeActionReplyHandler = ReplyHandler<QList<LSPCodeAction>>;
 using WorkspaceEditReplyHandler = ReplyHandler<LSPWorkspaceEdit>;
 using ApplyEditReplyHandler = ReplyHandler<LSPApplyWorkspaceEditResponse>;
 
 class LSPClientServer : public QObject
 {
     Q_OBJECT
 
 public:
     enum class State { None, Started, Running, Shutdown };
 
     class LSPClientServerPrivate;
     class RequestHandle
     {
         friend class LSPClientServerPrivate;
         QPointer<LSPClientServer> m_server;
         int m_id = -1;
 
     public:
         RequestHandle &cancel()
         {
             if (m_server)
                 m_server->cancel(m_id);
             return *this;
         }
     };
 
     LSPClientServer(const QStringList &server, const QUrl &root,
                     const QJsonValue &init = QJsonValue());
     ~LSPClientServer();
 
     // server management
     // request start
     bool start();
     // request shutdown/stop
     // if to_xxx >= 0 -> send signal if not exit'ed after timeout
     void stop(int to_term_ms, int to_kill_ms);
     int cancel(int id);
 
     // properties
     const QStringList &cmdline() const;
     State state() const;
     Q_SIGNAL void stateChanged(LSPClientServer *server);
 
     const LSPServerCapabilities &capabilities() const;
 
     // language
     RequestHandle documentSymbols(const QUrl &document, const QObject *context,
                                   const DocumentSymbolsReplyHandler &h);
     RequestHandle documentDefinition(const QUrl &document, const LSPPosition &pos,
                                      const QObject *context,
                                      const DocumentDefinitionReplyHandler &h);
     RequestHandle documentDeclaration(const QUrl &document, const LSPPosition &pos,
                                       const QObject *context,
                                       const DocumentDefinitionReplyHandler &h);
     RequestHandle documentHighlight(const QUrl &document, const LSPPosition &pos,
                                     const QObject *context, const DocumentHighlightReplyHandler &h);
     RequestHandle documentHover(const QUrl &document, const LSPPosition &pos,
                                 const QObject *context, const DocumentHoverReplyHandler &h);
     RequestHandle documentReferences(const QUrl &document, const LSPPosition &pos, bool decl,
                                      const QObject *context,
                                      const DocumentDefinitionReplyHandler &h);
     RequestHandle documentCompletion(const QUrl &document, const LSPPosition &pos,
                                      const QObject *context,
                                      const DocumentCompletionReplyHandler &h);
     RequestHandle signatureHelp(const QUrl &document, const LSPPosition &pos,
                                 const QObject *context, const SignatureHelpReplyHandler &h);
 
     RequestHandle documentFormatting(const QUrl &document, const LSPFormattingOptions &options,
                                      const QObject *context, const FormattingReplyHandler &h);
     RequestHandle documentRangeFormatting(const QUrl &document, const LSPRange &range,
                                           const LSPFormattingOptions &options,
                                           const QObject *context, const FormattingReplyHandler &h);
     RequestHandle documentOnTypeFormatting(const QUrl &document, const LSPPosition &pos,
                                            QChar lastChar, const LSPFormattingOptions &options,
                                            const QObject *context, const FormattingReplyHandler &h);
     RequestHandle documentRename(const QUrl &document, const LSPPosition &pos,
-                                 const QString newName, const QObject *context,
+                                 const QString& newName, const QObject *context,
                                  const WorkspaceEditReplyHandler &h);
 
     RequestHandle documentCodeAction(const QUrl &document, const LSPRange &range,
                                      const QList<QString> &kinds, QList<LSPDiagnostic> diagnostics,
                                      const QObject *context, const CodeActionReplyHandler &h);
     void executeCommand(const QString &command, const QJsonValue &args);
 
     // sync
     void didOpen(const QUrl &document, int version, const QString &langId, const QString &text);
     // only 1 of text or changes should be non-empty and is considered
     void didChange(const QUrl &document, int version, const QString &text,
                    const QList<LSPTextDocumentContentChangeEvent> &changes = {});
     void didSave(const QUrl &document, const QString &text);
     void didClose(const QUrl &document);
 
     // notifcation = signal
 Q_SIGNALS:
     void publishDiagnostics(const LSPPublishDiagnosticsParams &);
 
     // request = signal
     void applyEdit(const LSPApplyWorkspaceEditParams &req, const ApplyEditReplyHandler &h,
                    bool &handled);
 
 private:
     // pimpl data holder
     LSPClientServerPrivate *const d;
 };
 
 #endif
diff --git a/addons/lspclient/lspclientservermanager.cpp b/addons/lspclient/lspclientservermanager.cpp
index 80fc537c7..fb676af2b 100644
--- a/addons/lspclient/lspclientservermanager.cpp
+++ b/addons/lspclient/lspclientservermanager.cpp
@@ -1,807 +1,807 @@
 /*  SPDX-License-Identifier: MIT
 
     Copyright (C) 2019 Mark Nauwelaerts <mark.nauwelaerts@gmail.com>
 
     Permission is hereby granted, free of charge, to any person obtaining
     a copy of this software and associated documentation files (the
     "Software"), to deal in the Software without restriction, including
     without limitation the rights to use, copy, modify, merge, publish,
     distribute, sublicense, and/or sell copies of the Software, and to
     permit persons to whom the Software is furnished to do so, subject to
     the following conditions:
 
     The above copyright notice and this permission notice shall be included
     in all copies or substantial portions of the Software.
 
     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 /*
  * Some explanation here on server configuration JSON, pending such ending up
  * in real user level documentation ...
  *
  * The default configuration in JSON format is roughly as follows;
 {
     "global":
     {
         "root": null,
     },
     "servers":
     {
         "Python":
         {
             "command": "python3 -m pyls --check-parent-process"
         },
         "C":
         {
             "command": "clangd -log=verbose --background-index"
         },
         "C++":
         {
             "use": "C++"
         }
     }
 }
  * (the "command" can be an array or a string, which is then split into array)
  *
  * From the above, the gist is presumably clear.  In addition, each server
  * entry object may also have an "initializationOptions" entry, which is passed
  * along to the server as part of the 'initialize' method.  A clangd-specific
  * HACK^Hfeature uses this to add "compilationDatabasePath".
  *
  * Various stages of override/merge are applied;
  * + user configuration (loaded from file) overrides (internal) default configuration
  * + "lspclient" entry in projectMap overrides the above
  * + the resulting "global" entry is used to supplement (not override) any server entry
  *
  * One server instance is used per (root, servertype) combination.
  * If "root" is not specified, it default to the $HOME directory.  If it is
  * specified as an absolute path, then it used as-is, otherwise it is relative
  * to the projectBase.  For any document, the resulting "root" then determines
  * whether or not a separate instance is needed. If so, the "root" is passed
  * as rootUri/rootPath.
  *
  * In general, it is recommended to leave root unspecified, as it is not that
  * important for a server (your mileage may vary though).  Fewer instances
  * are obviously more efficient, and they also have a 'wider' view than
  * the view of many separate instances.
  */
 
 #include "lspclientservermanager.h"
 
 #include "lspclient_debug.h"
 
 #include <KTextEditor/Document>
 #include <KTextEditor/MainWindow>
 #include <KTextEditor/View>
 #include <KTextEditor/Message>
 #include <KLocalizedString>
 #include <KTextEditor/MovingInterface>
 
 #include <QDir>
 #include <QEventLoop>
 #include <QFileInfo>
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QJsonDocument>
 #include <QTimer>
 
 // helper to find a proper root dir for the given document & file name that indicate the root dir
 static QString rootForDocumentAndRootIndicationFileName(KTextEditor::Document *document,
                                                         const QString &rootIndicationFileName)
 {
     // search only feasible if document is local file
     if (!document->url().isLocalFile()) {
         return QString();
     }
 
     // search root upwards
     QDir dir(QFileInfo(document->url().toLocalFile()).absolutePath());
     QSet<QString> seenDirectories;
     while (!seenDirectories.contains(dir.absolutePath())) {
         // update guard
         seenDirectories.insert(dir.absolutePath());
 
         // the file that indicates the root dir is there => all fine
         if (dir.exists(rootIndicationFileName)) {
             return dir.absolutePath();
         }
 
         // else: cd up, if possible or abort
         if (!dir.cdUp()) {
             break;
         }
     }
 
     // no root found, bad luck
     return QString();
 }
 
 #include <memory>
 
 // local helper;
 // recursively merge top json top onto bottom json
 static QJsonObject merge(const QJsonObject &bottom, const QJsonObject &top)
 {
     QJsonObject result;
     for (auto item = top.begin(); item != top.end(); item++) {
         const auto &key = item.key();
         if (item.value().isObject()) {
             result.insert(key, merge(bottom.value(key).toObject(), item.value().toObject()));
         } else {
             result.insert(key, item.value());
         }
     }
     // parts only in bottom
     for (auto item = bottom.begin(); item != bottom.end(); item++) {
         if (!result.contains(item.key())) {
             result.insert(item.key(), item.value());
         }
     }
     return result;
 }
 
 // map (highlight)mode to lsp languageId
 static QString languageId(const QString &mode)
 {
     // special cases
     static QHash<QString, QString> m;
     auto it = m.find(mode);
     if (it != m.end()) {
         return *it;
     }
     // assume sane naming
     QString result = mode.toLower();
     result = result.replace(QStringLiteral("++"), QStringLiteral("pp"));
     return result.replace(QStringLiteral("#"), QStringLiteral("sharp"));
 }
 
 // helper guard to handle revision (un)lock
 struct RevisionGuard {
     QPointer<KTextEditor::Document> m_doc;
     KTextEditor::MovingInterface *m_movingInterface = nullptr;
     qint64 m_revision = -1;
 
     RevisionGuard(KTextEditor::Document *doc = nullptr)
         : m_doc(doc),
           m_movingInterface(qobject_cast<KTextEditor::MovingInterface *>(doc))
     {
         if (m_movingInterface) {
             m_revision = m_movingInterface->revision();
             m_movingInterface->lockRevision(m_revision);
         }
     }
 
     // really only need/allow this one (out of 5)
     RevisionGuard(RevisionGuard &&other) : RevisionGuard(nullptr)
     {
         std::swap(m_doc, other.m_doc);
         std::swap(m_movingInterface, other.m_movingInterface);
         std::swap(m_revision, other.m_revision);
     }
 
     void release()
     {
         m_movingInterface = nullptr;
         m_revision = -1;
     }
 
     ~RevisionGuard()
     {
         // NOTE: hopefully the revision is still valid at this time
         if (m_doc && m_movingInterface && m_revision >= 0) {
             m_movingInterface->unlockRevision(m_revision);
         }
     }
 };
 
 class LSPClientRevisionSnapshotImpl : public LSPClientRevisionSnapshot
 {
     Q_OBJECT
 
     typedef LSPClientRevisionSnapshotImpl self_type;
 
     // std::map has more relaxed constraints on value_type
     std::map<QUrl, RevisionGuard> m_guards;
 
     Q_SLOT
     void clearRevisions(KTextEditor::Document *doc)
     {
         for (auto &item : m_guards) {
             if (item.second.m_doc == doc) {
                 item.second.release();
             }
         }
     }
 
 public:
     void add(KTextEditor::Document *doc)
     {
         Q_ASSERT(doc);
 
         // make sure revision is cleared when needed and no longer used (to unlock or otherwise)
         // see e.g. implementation in katetexthistory.cpp and assert's in place there
         auto conn = connect(
                 doc, SIGNAL(aboutToInvalidateMovingInterfaceContent(KTextEditor::Document *)), this,
                 SLOT(clearRevisions(KTextEditor::Document *)));
         Q_ASSERT(conn);
         conn = connect(doc, SIGNAL(aboutToDeleteMovingInterfaceContent(KTextEditor::Document *)),
                        this, SLOT(clearRevisions(KTextEditor::Document *)));
         Q_ASSERT(conn);
         m_guards.emplace(doc->url(), doc);
     }
 
     void find(const QUrl &url, KTextEditor::MovingInterface *&miface,
               qint64 &revision) const override
     {
         auto it = m_guards.find(url);
         if (it != m_guards.end()) {
             miface = it->second.m_movingInterface;
             revision = it->second.m_revision;
         } else {
             miface = nullptr;
             revision = -1;
         }
     }
 };
 
 // helper class to sync document changes to LSP server
 class LSPClientServerManagerImpl : public LSPClientServerManager
 {
     Q_OBJECT
 
     typedef LSPClientServerManagerImpl self_type;
 
     struct DocumentInfo {
         QSharedPointer<LSPClientServer> server;
         KTextEditor::MovingInterface *movingInterface;
         QUrl url;
         qint64 version;
         bool open : 1;
         bool modified : 1;
         // used for incremental update (if non-empty)
         QList<LSPTextDocumentContentChangeEvent> changes;
     };
 
     LSPClientPlugin *m_plugin;
     KTextEditor::MainWindow *m_mainWindow;
     // merged default and user config
     QJsonObject m_serverConfig;
     // root -> (mode -> server)
     QMap<QUrl, QMap<QString, QSharedPointer<LSPClientServer>>> m_servers;
     QHash<KTextEditor::Document *, DocumentInfo> m_docs;
     bool m_incrementalSync = false;
 
     typedef QVector<QSharedPointer<LSPClientServer>> ServerList;
 
 public:
     LSPClientServerManagerImpl(LSPClientPlugin *plugin, KTextEditor::MainWindow *mainWin)
         : m_plugin(plugin), m_mainWindow(mainWin)
     {
         connect(plugin, &LSPClientPlugin::update, this, &self_type::updateServerConfig);
         QTimer::singleShot(100, this, &self_type::updateServerConfig);
     }
 
     ~LSPClientServerManagerImpl()
     {
         // stop everything as we go down
         // several stages;
         // stage 1; request shutdown of all servers (in parallel)
         // (give that some time)
         // stage 2; send TERM
         // stage 3; send KILL
 
         // stage 1
         QEventLoop q;
         QTimer t;
         connect(&t, &QTimer::timeout, &q, &QEventLoop::quit);
 
         auto run = [&q, &t](int ms) {
             t.setSingleShot(true);
             t.start(ms);
             q.exec();
         };
 
         int count = 0;
         for (const auto &el : m_servers) {
             for (const auto &s : el) {
                 disconnect(s.data(), nullptr, this, nullptr);
                 if (s->state() != LSPClientServer::State::None) {
                     auto handler = [&q, &count, s]() {
                         if (s->state() != LSPClientServer::State::None) {
                             if (--count == 0) {
                                 q.quit();
                             }
                         }
                     };
                     connect(s.data(), &LSPClientServer::stateChanged, this, handler);
                     ++count;
                     s->stop(-1, -1);
                 }
             }
         }
         run(500);
 
         // stage 2 and 3
         count = 0;
         for (count = 0; count < 2; ++count) {
             for (const auto &el : m_servers) {
                 for (const auto &s : el) {
                     s->stop(count == 0 ? 1 : -1, count == 0 ? -1 : 1);
                 }
             }
             run(100);
         }
     }
 
     void setIncrementalSync(bool inc) override { m_incrementalSync = inc; }
 
     QSharedPointer<LSPClientServer> findServer(KTextEditor::Document *document,
                                                bool updatedoc = true) override
     {
         if (!document || document->url().isEmpty())
             return nullptr;
 
         auto it = m_docs.find(document);
         auto server = it != m_docs.end() ? it->server : nullptr;
         if (!server) {
             if ((server = _findServer(document)))
                 trackDocument(document, server);
         }
 
         if (server && updatedoc)
             update(server.data(), false);
         return server;
     }
 
     QSharedPointer<LSPClientServer> findServer(KTextEditor::View *view,
                                                bool updatedoc = true) override
     {
         return view ? findServer(view->document(), updatedoc) : nullptr;
     }
 
     // restart a specific server or all servers if server == nullptr
     void restart(LSPClientServer *server) override
     {
         ServerList servers;
         // find entry for server(s) and move out
         for (auto &m : m_servers) {
             for (auto it = m.begin(); it != m.end();) {
                 if (!server || it->data() == server) {
                     servers.push_back(*it);
                     it = m.erase(it);
                 } else {
                     ++it;
                 }
             }
         }
         restart(servers);
     }
 
     virtual qint64 revision(KTextEditor::Document *doc) override
     {
         auto it = m_docs.find(doc);
         return it != m_docs.end() ? it->version : -1;
     }
 
     virtual LSPClientRevisionSnapshot *snapshot(LSPClientServer *server) override
     {
         auto result = new LSPClientRevisionSnapshotImpl;
         for (auto it = m_docs.begin(); it != m_docs.end(); ++it) {
             if (it->server == server) {
                 // sync server to latest revision that will be recorded
                 update(it.key(), false);
                 result->add(it.key());
             }
         }
         return result;
     }
 
 private:
     void showMessage(const QString &msg, KTextEditor::Message::MessageType level)
     {
         KTextEditor::View *view = m_mainWindow->activeView();
         if (!view || !view->document())
             return;
 
         auto kmsg = new KTextEditor::Message(xi18nc("@info", "<b>LSP Client:</b> %1", msg), level);
         kmsg->setPosition(KTextEditor::Message::AboveView);
         kmsg->setAutoHide(5000);
         kmsg->setAutoHideMode(KTextEditor::Message::Immediate);
         kmsg->setView(view);
         view->document()->postMessage(kmsg);
     }
 
     // caller ensures that servers are no longer present in m_servers
     void restart(const ServerList &servers)
     {
         // close docs
         for (const auto &server : servers) {
             // controlling server here, so disable usual state tracking response
             disconnect(server.data(), nullptr, this, nullptr);
             for (auto it = m_docs.begin(); it != m_docs.end();) {
                 auto &item = it.value();
                 if (item.server == server) {
                     // no need to close if server not in proper state
                     if (server->state() != LSPClientServer::State::Running) {
                         item.open = false;
                     }
                     it = _close(it, true);
                 } else {
                     ++it;
                 }
             }
         }
 
         // helper captures servers
         auto stopservers = [servers](int t, int k) {
             for (const auto &server : servers) {
                 server->stop(t, k);
             }
         };
 
         // trigger server shutdown now
         stopservers(-1, -1);
 
         // initiate delayed stages (TERM and KILL)
         // async, so give a bit more time
         QTimer::singleShot(2 * TIMEOUT_SHUTDOWN, this, [stopservers]() { stopservers(1, -1); });
         QTimer::singleShot(4 * TIMEOUT_SHUTDOWN, this, [stopservers]() { stopservers(-1, 1); });
 
         // as for the start part
         // trigger interested parties, which will again request a server as needed
         // let's delay this; less chance for server instances to trip over each other
         QTimer::singleShot(6 * TIMEOUT_SHUTDOWN, this, [this]() { emit serverChanged(); });
     }
 
     void onStateChanged(LSPClientServer *server)
     {
         if (server->state() == LSPClientServer::State::Running) {
             // clear for normal operation
             emit serverChanged();
         } else if (server->state() == LSPClientServer::State::None) {
             // went down
             showMessage(i18n("Server terminated unexpectedly: %1",
                              server->cmdline().join(QLatin1Char(' '))),
                         KTextEditor::Message::Warning);
             restart(server);
         }
     }
 
     QSharedPointer<LSPClientServer> _findServer(KTextEditor::Document *document)
     {
         QObject *projectView = m_mainWindow->pluginView(QStringLiteral("kateprojectplugin"));
         const auto projectBase =
                 QDir(projectView ? projectView->property("projectBaseDir").toString() : QString());
         const auto &projectMap =
                 projectView ? projectView->property("projectMap").toMap() : QVariantMap();
 
         // compute the LSP standardized language id
         auto langId = languageId(document->highlightingMode());
 
         // merge with project specific
         auto projectConfig = QJsonDocument::fromVariant(projectMap)
                                      .object()
                                      .value(QStringLiteral("lspclient"))
                                      .toObject();
         auto serverConfig = merge(m_serverConfig, projectConfig);
 
         // locate server config
         QJsonValue config;
         QSet<QString> used;
         while (true) {
             qCInfo(LSPCLIENT) << "language id " << langId;
             used << langId;
             config = serverConfig.value(QStringLiteral("servers")).toObject().value(langId);
             if (config.isObject()) {
                 const auto &base = config.toObject().value(QStringLiteral("use")).toString();
                 // basic cycle detection
                 if (!base.isEmpty() && !used.contains(base)) {
                     langId = base;
                     continue;
                 }
             }
             break;
         }
 
         if (!config.isObject())
             return nullptr;
 
         // merge global settings
         serverConfig =
                 merge(serverConfig.value(QStringLiteral("global")).toObject(), config.toObject());
 
         QString rootpath;
         auto rootv = serverConfig.value(QStringLiteral("root"));
         if (rootv.isString()) {
             auto sroot = rootv.toString();
             if (QDir::isAbsolutePath(sroot)) {
                 rootpath = sroot;
             } else if (!projectBase.isEmpty()) {
                 rootpath = QDir(projectBase).absoluteFilePath(sroot);
             }
         }
 
         /**
          * no explicit set root dir? search for a matching root based on some name filters
          * this is required for some LSP servers like rls that don't handle that on their own like
          * clangd does
          */
         if (rootpath.isEmpty()) {
             const auto fileNamesForDetection =
                     serverConfig.value(QStringLiteral("rootIndicationFileNames"));
             if (fileNamesForDetection.isArray()) {
                 // we try each file name alternative in the listed order
                 // this allows to have preferences
                 for (auto name : fileNamesForDetection.toArray()) {
                     if (name.isString()) {
                         rootpath =
                                 rootForDocumentAndRootIndicationFileName(document, name.toString());
                         if (!rootpath.isEmpty()) {
                             break;
                         }
                     }
                 }
             }
         }
 
         // last fallback: home directory
         if (rootpath.isEmpty()) {
             rootpath = QDir::homePath();
         }
 
         auto root = QUrl::fromLocalFile(rootpath);
         auto server = m_servers.value(root).value(langId);
         if (!server) {
             QStringList cmdline;
 
             // choose debug command line for debug mode, fallback to command
             auto vcmdline =
                     serverConfig.value(m_plugin->m_debugMode ? QStringLiteral("commandDebug")
                                                              : QStringLiteral("command"));
             if (vcmdline.isUndefined()) {
                 vcmdline = serverConfig.value(QStringLiteral("command"));
             }
 
             auto scmdline = vcmdline.toString();
             if (!scmdline.isEmpty()) {
                 cmdline = scmdline.split(QLatin1Char(' '));
             } else {
                 for (const auto &c : vcmdline.toArray()) {
                     cmdline.push_back(c.toString());
                 }
             }
             if (cmdline.length() > 0) {
                 server.reset(new LSPClientServer(
                         cmdline, root,
                         serverConfig.value(QStringLiteral("initializationOptions"))));
                 m_servers[root][langId] = server;
                 connect(server.data(), &LSPClientServer::stateChanged, this,
                         &self_type::onStateChanged, Qt::UniqueConnection);
                 if (!server->start()) {
                     showMessage(i18n("Failed to start server: %1", cmdline.join(QLatin1Char(' '))),
                                 KTextEditor::Message::Error);
                 }
             }
         }
         return (server && server->state() == LSPClientServer::State::Running) ? server : nullptr;
     }
 
     void updateServerConfig()
     {
         // default configuration, compiled into plugin resource, reading can't fail
         QFile defaultConfigFile(QStringLiteral(":/lspclient/settings.json"));
         defaultConfigFile.open(QIODevice::ReadOnly);
         Q_ASSERT(defaultConfigFile.isOpen());
         m_serverConfig = QJsonDocument::fromJson(defaultConfigFile.readAll()).object();
 
         // consider specified configuration
         const auto &configPath = m_plugin->m_configPath.path();
         if (!configPath.isEmpty()) {
             QFile f(configPath);
             if (f.open(QIODevice::ReadOnly)) {
                 auto data = f.readAll();
                 auto json = QJsonDocument::fromJson(data);
                 if (json.isObject()) {
                     m_serverConfig = merge(m_serverConfig, json.object());
                 } else {
                     showMessage(i18n("Failed to parse server configuration: %1", configPath),
                                 KTextEditor::Message::Error);
                 }
             } else {
                 showMessage(i18n("Failed to read server configuration: %1", configPath),
                             KTextEditor::Message::Error);
             }
         }
 
         // we could (but do not) perform restartAll here;
         // for now let's leave that up to user
         // but maybe we do have a server now where not before, so let's signal
         emit serverChanged();
     }
 
-    void trackDocument(KTextEditor::Document *doc, QSharedPointer<LSPClientServer> server)
+    void trackDocument(KTextEditor::Document *doc, const QSharedPointer<LSPClientServer>& server)
     {
         auto it = m_docs.find(doc);
         if (it == m_docs.end()) {
             KTextEditor::MovingInterface *miface =
                     qobject_cast<KTextEditor::MovingInterface *>(doc);
             it = m_docs.insert(doc, { server, miface, doc->url(), 0, false, false, {} });
             // track document
             connect(doc, &KTextEditor::Document::documentUrlChanged, this, &self_type::untrack,
                     Qt::UniqueConnection);
             connect(doc, &KTextEditor::Document::highlightingModeChanged, this, &self_type::untrack,
                     Qt::UniqueConnection);
             connect(doc, &KTextEditor::Document::aboutToClose, this, &self_type::untrack,
                     Qt::UniqueConnection);
             connect(doc, &KTextEditor::Document::destroyed, this, &self_type::untrack,
                     Qt::UniqueConnection);
             connect(doc, &KTextEditor::Document::textChanged, this, &self_type::onTextChanged,
                     Qt::UniqueConnection);
             // in case of incremental change
             connect(doc, &KTextEditor::Document::textInserted, this, &self_type::onTextInserted,
                     Qt::UniqueConnection);
             connect(doc, &KTextEditor::Document::textRemoved, this, &self_type::onTextRemoved,
                     Qt::UniqueConnection);
             connect(doc, &KTextEditor::Document::lineWrapped, this, &self_type::onLineWrapped,
                     Qt::UniqueConnection);
             connect(doc, &KTextEditor::Document::lineUnwrapped, this, &self_type::onLineUnwrapped,
                     Qt::UniqueConnection);
         } else {
             it->server = server;
         }
     }
 
     decltype(m_docs)::iterator _close(decltype(m_docs)::iterator it, bool remove)
     {
         if (it != m_docs.end()) {
             if (it->open) {
                 // release server side (use url as registered with)
                 (it->server)->didClose(it->url);
                 it->open = false;
             }
             if (remove) {
                 disconnect(it.key(), nullptr, this, nullptr);
                 it = m_docs.erase(it);
             }
         }
         return it;
     }
 
     void _close(KTextEditor::Document *doc, bool remove)
     {
         auto it = m_docs.find(doc);
         if (it != m_docs.end()) {
             _close(it, remove);
         }
     }
 
     void untrack(QObject *doc)
     {
         _close(qobject_cast<KTextEditor::Document *>(doc), true);
         emit serverChanged();
     }
 
     void close(KTextEditor::Document *doc) { _close(doc, false); }
 
     void update(const decltype(m_docs)::iterator &it, bool force)
     {
         auto doc = it.key();
         if (it != m_docs.end() && it->server) {
             if (it->movingInterface) {
                 it->version = it->movingInterface->revision();
             } else if (it->modified) {
                 ++it->version;
             }
             if (!m_incrementalSync) {
                 it->changes.clear();
             }
             if (it->open) {
                 if (it->modified || force) {
                     (it->server)
                             ->didChange(it->url, it->version,
                                         (it->changes.size() == 0) ? doc->text() : QString(),
                                         it->changes);
                 }
             } else {
                 (it->server)
                         ->didOpen(it->url, it->version, languageId(doc->highlightingMode()),
                                   doc->text());
                 it->open = true;
             }
             it->modified = false;
             it->changes.clear();
         }
     }
 
     void update(KTextEditor::Document *doc, bool force) override
     {
         update(m_docs.find(doc), force);
     }
 
     void update(LSPClientServer *server, bool force)
     {
         for (auto it = m_docs.begin(); it != m_docs.end(); ++it) {
             if (it->server == server) {
                 update(it, force);
             }
         }
     }
 
     void onTextChanged(KTextEditor::Document *doc)
     {
         auto it = m_docs.find(doc);
         if (it != m_docs.end()) {
             it->modified = true;
         }
     }
 
     DocumentInfo *getDocumentInfo(KTextEditor::Document *doc)
     {
         if (!m_incrementalSync)
             return nullptr;
 
         auto it = m_docs.find(doc);
         if (it != m_docs.end() && it->server) {
             const auto &caps = it->server->capabilities();
             if (caps.textDocumentSync == LSPDocumentSyncKind::Incremental) {
                 return &(*it);
             }
         }
         return nullptr;
     }
 
     void onTextInserted(KTextEditor::Document *doc, const KTextEditor::Cursor &position,
                         const QString &text)
     {
         auto info = getDocumentInfo(doc);
         if (info) {
             info->changes.push_back({ LSPRange { position, position }, text });
         }
     }
 
     void onTextRemoved(KTextEditor::Document *doc, const KTextEditor::Range &range,
                        const QString &text)
     {
         (void)text;
         auto info = getDocumentInfo(doc);
         if (info) {
             info->changes.push_back({ range, QString() });
         }
     }
 
     void onLineWrapped(KTextEditor::Document *doc, const KTextEditor::Cursor &position)
     {
         // so a 'newline' has been inserted at position
         // could have been UNIX style or other kind, let's ask the document
         auto text = doc->text({ position, { position.line() + 1, 0 } });
         onTextInserted(doc, position, text);
     }
 
     void onLineUnwrapped(KTextEditor::Document *doc, int line)
     {
         // lines line-1 and line got replaced by current content of line-1
         Q_ASSERT(line > 0);
         auto info = getDocumentInfo(doc);
         if (info) {
             LSPRange oldrange { { line - 1, 0 }, { line + 1, 0 } };
             LSPRange newrange { { line - 1, 0 }, { line, 0 } };
             auto text = doc->text(newrange);
             info->changes.push_back({ oldrange, text });
         }
     }
 };
 
 QSharedPointer<LSPClientServerManager>
 LSPClientServerManager::new_(LSPClientPlugin *plugin, KTextEditor::MainWindow *mainWin)
 {
     return QSharedPointer<LSPClientServerManager>(new LSPClientServerManagerImpl(plugin, mainWin));
 }
 
 #include "lspclientservermanager.moc"
diff --git a/addons/lspclient/lspclientsymbolview.cpp b/addons/lspclient/lspclientsymbolview.cpp
index 020f0cd7e..bed86a32a 100644
--- a/addons/lspclient/lspclientsymbolview.cpp
+++ b/addons/lspclient/lspclientsymbolview.cpp
@@ -1,554 +1,555 @@
 /*  SPDX-License-Identifier: MIT
 
     Copyright (C) 2019 Mark Nauwelaerts <mark.nauwelaerts@gmail.com>
     Copyright (C) 2019 Christoph Cullmann <cullmann@kde.org>
 
     Permission is hereby granted, free of charge, to any person obtaining
     a copy of this software and associated documentation files (the
     "Software"), to deal in the Software without restriction, including
     without limitation the rights to use, copy, modify, merge, publish,
     distribute, sublicense, and/or sell copies of the Software, and to
     permit persons to whom the Software is furnished to do so, subject to
     the following conditions:
 
     The above copyright notice and this permission notice shall be included
     in all copies or substantial portions of the Software.
 
     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
     CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
     TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
     SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
 #include "lspclientsymbolview.h"
 
 #include <KLineEdit>
 #include <KLocalizedString>
 #include <KRecursiveFilterProxyModel>
 
 #include <KTextEditor/Document>
 #include <KTextEditor/MainWindow>
 #include <KTextEditor/View>
 
 #include <QHBoxLayout>
 #include <QTreeView>
 #include <QMenu>
 #include <QTimer>
 #include <QPointer>
 #include <QStandardItemModel>
 
 #include <memory>
+#include <utility>
 
 class LSPClientViewTrackerImpl : public LSPClientViewTracker
 {
     Q_OBJECT
 
     typedef LSPClientViewTrackerImpl self_type;
 
     LSPClientPlugin *m_plugin;
     KTextEditor::MainWindow *m_mainWindow;
     // timers to delay some todo's
     QTimer m_changeTimer;
     int m_change;
     QTimer m_motionTimer;
     int m_motion;
     int m_oldCursorLine = -1;
 
 public:
     LSPClientViewTrackerImpl(LSPClientPlugin *plugin, KTextEditor::MainWindow *mainWin,
                              int change_ms, int motion_ms)
         : m_plugin(plugin), m_mainWindow(mainWin), m_change(change_ms), m_motion(motion_ms)
     {
         // get updated
         m_changeTimer.setSingleShot(true);
         auto ch = [this]() { emit newState(m_mainWindow->activeView(), TextChanged); };
         connect(&m_changeTimer, &QTimer::timeout, this, ch);
 
         m_motionTimer.setSingleShot(true);
         auto mh = [this]() { emit newState(m_mainWindow->activeView(), LineChanged); };
         connect(&m_motionTimer, &QTimer::timeout, this, mh);
 
         // track views
         connect(m_mainWindow, &KTextEditor::MainWindow::viewChanged, this, &self_type::viewChanged);
     }
 
     void viewChanged(KTextEditor::View *view)
     {
         m_motionTimer.stop();
         m_changeTimer.stop();
 
         if (view) {
             if (m_motion) {
                 connect(view, &KTextEditor::View::cursorPositionChanged, this,
                         &self_type::cursorPositionChanged, Qt::UniqueConnection);
             }
             if (m_change > 0 && view->document()) {
                 connect(view->document(), &KTextEditor::Document::textChanged, this,
                         &self_type::textChanged, Qt::UniqueConnection);
             }
             emit newState(view, ViewChanged);
             m_oldCursorLine = view->cursorPosition().line();
         }
     }
 
     void textChanged()
     {
         m_motionTimer.stop();
         m_changeTimer.start(m_change);
     }
 
     void cursorPositionChanged(KTextEditor::View *view, const KTextEditor::Cursor &newPosition)
     {
         if (m_changeTimer.isActive()) {
             // change trumps motion
             return;
         }
 
         if (view && newPosition.line() != m_oldCursorLine) {
             m_oldCursorLine = newPosition.line();
             m_motionTimer.start(m_motion);
         }
     }
 };
 
 LSPClientViewTracker *LSPClientViewTracker::new_(LSPClientPlugin *plugin,
                                                  KTextEditor::MainWindow *mainWin, int change_ms,
                                                  int motion_ms)
 {
     return new LSPClientViewTrackerImpl(plugin, mainWin, change_ms, motion_ms);
 }
 
 /*
  * Instantiates and manages the symbol outline toolview.
  */
 class LSPClientSymbolViewImpl : public QObject, public LSPClientSymbolView
 {
     Q_OBJECT
 
     typedef LSPClientSymbolViewImpl self_type;
 
     LSPClientPlugin *m_plugin;
     KTextEditor::MainWindow *m_mainWindow;
     QSharedPointer<LSPClientServerManager> m_serverManager;
     QScopedPointer<QWidget> m_toolview;
     // parent ownership
     QPointer<QTreeView> m_symbols;
     QPointer<KLineEdit> m_filter;
     QScopedPointer<QMenu> m_popup;
     // initialized/updated from plugin settings
     // managed by context menu later on
     // parent ownership
     QAction *m_detailsOn;
     QAction *m_expandOn;
     QAction *m_treeOn;
     QAction *m_sortOn;
     // view tracking
     QScopedPointer<LSPClientViewTracker> m_viewTracker;
     // outstanding request
     LSPClientServer::RequestHandle m_handle;
     // cached outline models
     struct ModelData {
         KTextEditor::Document *document;
         qint64 revision;
         std::shared_ptr<QStandardItemModel> model;
     };
     QList<ModelData> m_models;
     // max number to cache
     static constexpr int MAX_MODELS = 10;
     // last outline model we constructed
     std::shared_ptr<QStandardItemModel> m_outline;
     // filter model, setup once
     KRecursiveFilterProxyModel m_filterModel;
 
     // cached icons for model
     const QIcon m_icon_pkg = QIcon::fromTheme(QStringLiteral("code-block"));
     const QIcon m_icon_class = QIcon::fromTheme(QStringLiteral("code-class"));
     const QIcon m_icon_typedef = QIcon::fromTheme(QStringLiteral("code-typedef"));
     const QIcon m_icon_function = QIcon::fromTheme(QStringLiteral("code-function"));
     const QIcon m_icon_var = QIcon::fromTheme(QStringLiteral("code-variable"));
 
 public:
     LSPClientSymbolViewImpl(LSPClientPlugin *plugin, KTextEditor::MainWindow *mainWin,
                             QSharedPointer<LSPClientServerManager> manager)
         : m_plugin(plugin),
           m_mainWindow(mainWin),
-          m_serverManager(manager),
+          m_serverManager(std::move(manager)),
           m_outline(new QStandardItemModel())
     {
         m_toolview.reset(m_mainWindow->createToolView(
                 plugin, QStringLiteral("lspclient_symbol_outline"), KTextEditor::MainWindow::Right,
                 QIcon::fromTheme(QStringLiteral("code-context")),
                 i18n("LSP Client Symbol Outline")));
 
         m_symbols = new QTreeView(m_toolview.data());
         m_symbols->setFocusPolicy(Qt::NoFocus);
         m_symbols->setLayoutDirection(Qt::LeftToRight);
         m_toolview->layout()->setContentsMargins(0, 0, 0, 0);
         m_toolview->layout()->addWidget(m_symbols);
         m_toolview->layout()->setSpacing(0);
 
         // setup filter line edit
         m_filter = new KLineEdit(m_toolview.data());
         m_toolview->layout()->addWidget(m_filter);
         m_filter->setPlaceholderText(i18n("Filter..."));
         m_filter->setClearButtonEnabled(true);
         connect(m_filter, &KLineEdit::textChanged, this, &self_type::filterTextChanged);
 
         m_symbols->setContextMenuPolicy(Qt::CustomContextMenu);
         m_symbols->setIndentation(10);
         m_symbols->setEditTriggers(QAbstractItemView::NoEditTriggers);
         m_symbols->setAllColumnsShowFocus(true);
 
         // init filter model once, later we only swap the source model!
         QItemSelectionModel *m = m_symbols->selectionModel();
         m_filterModel.setFilterCaseSensitivity(Qt::CaseInsensitive);
         m_filterModel.setSortCaseSensitivity(Qt::CaseInsensitive);
         m_filterModel.setSourceModel(m_outline.get());
         m_symbols->setModel(&m_filterModel);
         delete m;
 
         connect(m_symbols, &QTreeView::customContextMenuRequested, this,
                 &self_type::showContextMenu);
         connect(m_symbols, &QTreeView::activated, this, &self_type::goToSymbol);
         connect(m_symbols, &QTreeView::clicked, this, &self_type::goToSymbol);
 
         // context menu
         m_popup.reset(new QMenu(m_symbols));
         m_treeOn = m_popup->addAction(i18n("Tree Mode"), this, &self_type::displayOptionChanged);
         m_treeOn->setCheckable(true);
         m_expandOn = m_popup->addAction(i18n("Automatically Expand Tree"), this,
                                         &self_type::displayOptionChanged);
         m_expandOn->setCheckable(true);
         m_sortOn = m_popup->addAction(i18n("Sort Alphabetically"), this,
                                       &self_type::displayOptionChanged);
         m_sortOn->setCheckable(true);
         m_detailsOn =
                 m_popup->addAction(i18n("Show Details"), this, &self_type::displayOptionChanged);
         m_detailsOn->setCheckable(true);
         m_popup->addSeparator();
         m_popup->addAction(i18n("Expand All"), m_symbols.data(), &QTreeView::expandAll);
         m_popup->addAction(i18n("Collapse All"), m_symbols.data(), &QTreeView::collapseAll);
 
         // sync with plugin settings if updated
         connect(m_plugin, &LSPClientPlugin::update, this, &self_type::configUpdated);
 
         // get updated
         m_viewTracker.reset(LSPClientViewTracker::new_(plugin, mainWin, 500, 100));
         connect(m_viewTracker.data(), &LSPClientViewTracker::newState, this,
                 &self_type::onViewState);
         connect(m_serverManager.data(), &LSPClientServerManager::serverChanged, this,
                 [this]() { refresh(false); });
 
         // limit cached models; will not go beyond capacity set here
         m_models.reserve(MAX_MODELS + 1);
 
         // initial trigger of symbols view update
         configUpdated();
     }
 
     void displayOptionChanged()
     {
         m_expandOn->setEnabled(m_treeOn->isChecked());
         refresh(false);
     }
 
     void configUpdated()
     {
         m_treeOn->setChecked(m_plugin->m_symbolTree);
         m_detailsOn->setChecked(m_plugin->m_symbolDetails);
         m_expandOn->setChecked(m_plugin->m_symbolExpand);
         m_sortOn->setChecked(m_plugin->m_symbolSort);
         displayOptionChanged();
     }
 
     void showContextMenu(const QPoint &) { m_popup->popup(QCursor::pos(), m_treeOn); }
 
     void onViewState(KTextEditor::View *, LSPClientViewTracker::State newState)
     {
         switch (newState) {
         case LSPClientViewTracker::ViewChanged:
             refresh(true);
             break;
         case LSPClientViewTracker::TextChanged:
             refresh(false);
             break;
         case LSPClientViewTracker::LineChanged:
             updateCurrentTreeItem();
             break;
         }
     }
 
     void makeNodes(const QList<LSPSymbolInformation> &symbols, bool tree, bool show_detail,
                    QStandardItemModel *model, QStandardItem *parent, bool &details)
     {
         const QIcon *icon = nullptr;
         for (const auto &symbol : symbols) {
             switch (symbol.kind) {
             case LSPSymbolKind::File:
             case LSPSymbolKind::Module:
             case LSPSymbolKind::Namespace:
             case LSPSymbolKind::Package:
                 if (symbol.children.count() == 0)
                     continue;
                 icon = &m_icon_pkg;
                 break;
             case LSPSymbolKind::Class:
             case LSPSymbolKind::Interface:
                 icon = &m_icon_class;
                 break;
             case LSPSymbolKind::Enum:
                 icon = &m_icon_typedef;
                 break;
             case LSPSymbolKind::Method:
             case LSPSymbolKind::Function:
             case LSPSymbolKind::Constructor:
                 icon = &m_icon_function;
                 break;
             // all others considered/assumed Variable
             case LSPSymbolKind::Variable:
             case LSPSymbolKind::Constant:
             case LSPSymbolKind::String:
             case LSPSymbolKind::Number:
             case LSPSymbolKind::Property:
             case LSPSymbolKind::Field:
             default:
                 // skip local variable
                 // property, field, etc unlikely in such case anyway
                 if (parent && parent->icon().cacheKey() == m_icon_function.cacheKey())
                     continue;
                 icon = &m_icon_var;
             }
 
             auto node = new QStandardItem();
             if (parent && tree)
                 parent->appendRow(node);
             else
                 model->appendRow(node);
 
             if (!symbol.detail.isEmpty())
                 details = true;
             auto detail = show_detail ? symbol.detail : QString();
             node->setText(symbol.name + detail);
             node->setIcon(*icon);
             node->setData(QVariant::fromValue<KTextEditor::Range>(symbol.range), Qt::UserRole);
             // recurse children
             makeNodes(symbol.children, tree, show_detail, model, node, details);
         }
     }
 
     void onDocumentSymbols(const QList<LSPSymbolInformation> &outline)
     {
         onDocumentSymbolsOrProblem(outline, QString(), true);
     }
 
     void onDocumentSymbolsOrProblem(const QList<LSPSymbolInformation> &outline,
                                     const QString &problem = QString(), bool cache = false)
     {
         if (!m_symbols)
             return;
 
         // construct new model for data
         auto newModel = std::make_shared<QStandardItemModel>();
 
         // if we have some problem, just report that, else construct model
         bool details = false;
         if (problem.isEmpty()) {
             makeNodes(outline, m_treeOn->isChecked(), m_detailsOn->isChecked(), newModel.get(),
                       nullptr, details);
             if (cache) {
                 // last request has been placed at head of model list
                 Q_ASSERT(!m_models.isEmpty());
                 m_models[0].model = newModel;
             }
         } else {
             newModel->appendRow(new QStandardItem(problem));
         }
 
         // cache detail info with model
         newModel->invisibleRootItem()->setData(details);
 
         // fixup headers
         QStringList headers { i18n("Symbols") };
         newModel->setHorizontalHeaderLabels(headers);
 
         setModel(newModel);
     }
 
-    void setModel(std::shared_ptr<QStandardItemModel> newModel)
+    void setModel(const std::shared_ptr<QStandardItemModel>& newModel)
     {
         Q_ASSERT(newModel);
 
         // update filter model, do this before the assignment below deletes the old model!
         m_filterModel.setSourceModel(newModel.get());
 
         // delete old outline if there, keep our new one alive
         m_outline = newModel;
 
         // fixup sorting
         if (m_sortOn->isChecked()) {
             m_symbols->setSortingEnabled(true);
             m_symbols->sortByColumn(0);
         } else {
             m_symbols->sortByColumn(-1);
         }
 
         // handle auto-expansion
         if (m_expandOn->isChecked()) {
             m_symbols->expandAll();
         }
 
         // recover detail info from model data
         bool details = newModel->invisibleRootItem()->data().toBool();
 
         // disable detail setting if no such info available
         // (as an indication there is nothing to show anyway)
         m_detailsOn->setEnabled(details);
 
         // hide detail column if not needed/wanted
         bool showDetails = m_detailsOn->isChecked() && details;
         m_symbols->setColumnHidden(1, !showDetails);
 
         // current item tracking
         updateCurrentTreeItem();
     }
 
     void refresh(bool clear)
     {
         // cancel old request!
         m_handle.cancel();
 
         // check if we have some server for the current view => trigger request
         auto view = m_mainWindow->activeView();
         if (auto server = m_serverManager->findServer(view)) {
             // clear current model in any case
             // this avoids that we show stuff not matching the current view
             // but let's only do it if needed, e.g. when changing view
             // so as to avoid unhealthy flickering in other cases
             if (clear) {
                 onDocumentSymbolsOrProblem(QList<LSPSymbolInformation>(), QString(), false);
             }
 
             // check (valid) cache
             auto doc = view->document();
             auto revision = m_serverManager->revision(doc);
             auto it = m_models.begin();
             for (; it != m_models.end(); ++it) {
                 if (it->document == doc) {
                     break;
                 }
             }
             if (it != m_models.end()) {
                 // move to most recently used head
                 m_models.move(it - m_models.begin(), 0);
                 auto &model = m_models.front();
                 // re-use if possible
                 if (revision == model.revision && model.model) {
                     setModel(model.model);
                     return;
                 }
                 it->revision = revision;
             } else {
                 m_models.insert(0, { doc, revision, nullptr });
                 if (m_models.size() > MAX_MODELS) {
                     m_models.pop_back();
                 }
             }
 
             server->documentSymbols(view->document()->url(), this,
                                     utils::mem_fun(&self_type::onDocumentSymbols, this));
 
             return;
         }
 
         // else: inform that no server is there
         onDocumentSymbolsOrProblem(QList<LSPSymbolInformation>(),
                                    i18n("No LSP server for this document."));
     }
 
     QStandardItem *getCurrentItem(QStandardItem *item, int line)
     {
         // first traverse the child items to have deepest match!
         // only do this if our stuff is expanded
         if (item == m_outline->invisibleRootItem()
             || m_symbols->isExpanded(m_filterModel.mapFromSource(m_outline->indexFromItem(item)))) {
             for (int i = 0; i < item->rowCount(); i++) {
                 if (auto citem = getCurrentItem(item->child(i), line)) {
                     return citem;
                 }
             }
         }
 
         // does the line match our item?
         return item->data(Qt::UserRole).value<KTextEditor::Range>().overlapsLine(line) ? item
                                                                                        : nullptr;
     }
 
     void updateCurrentTreeItem()
     {
         KTextEditor::View *editView = m_mainWindow->activeView();
         if (!editView || !m_symbols) {
             return;
         }
 
         /**
          * get item if any
          */
         QStandardItem *item = getCurrentItem(m_outline->invisibleRootItem(),
                                              editView->cursorPositionVirtual().line());
         if (!item) {
             return;
         }
 
         /**
          * select it
          */
         QModelIndex index = m_filterModel.mapFromSource(m_outline->indexFromItem(item));
         m_symbols->scrollTo(index);
         m_symbols->selectionModel()->setCurrentIndex(
                 index, QItemSelectionModel::Clear | QItemSelectionModel::Select);
     }
 
     void goToSymbol(const QModelIndex &index)
     {
         KTextEditor::View *kv = m_mainWindow->activeView();
         const auto range = index.data(Qt::UserRole).value<KTextEditor::Range>();
         if (kv && range.isValid()) {
             kv->setCursorPosition(range.start());
         }
     }
 
 private Q_SLOTS:
     /**
      * React on filter change
      * @param filterText new filter text
      */
     void filterTextChanged(const QString &filterText)
     {
         if (!m_symbols) {
             return;
         }
 
         /**
          * filter
          */
         m_filterModel.setFilterFixedString(filterText);
 
         /**
          * expand
          */
         if (!filterText.isEmpty()) {
             QTimer::singleShot(100, m_symbols, &QTreeView::expandAll);
         }
     }
 };
 
 QObject *LSPClientSymbolView::new_(LSPClientPlugin *plugin, KTextEditor::MainWindow *mainWin,
                                    QSharedPointer<LSPClientServerManager> manager)
 {
-    return new LSPClientSymbolViewImpl(plugin, mainWin, manager);
+    return new LSPClientSymbolViewImpl(plugin, mainWin, std::move(manager));
 }
 
 #include "lspclientsymbolview.moc"
diff --git a/addons/project/kateproject.cpp b/addons/project/kateproject.cpp
index 2a92ee8c7..0d1fe0c30 100644
--- a/addons/project/kateproject.cpp
+++ b/addons/project/kateproject.cpp
@@ -1,405 +1,406 @@
 /*  This file is part of the Kate project.
  *
  *  Copyright (C) 2012 Christoph Cullmann <cullmann@kde.org>
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #include "kateproject.h"
 #include "kateprojectworker.h"
 
 #include <klocalizedstring.h>
 
 #include <ktexteditor/document.h>
 
 #include <ThreadWeaver/Queue>
 
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QPlainTextDocumentLayout>
 #include <QJsonDocument>
 #include <QJsonParseError>
+#include <utility>
 
 KateProject::KateProject(ThreadWeaver::Queue *weaver)
     : QObject()
     , m_fileLastModified()
     , m_notesDocument(nullptr)
     , m_untrackedDocumentsRoot(nullptr)
     , m_weaver(weaver)
 {
 }
 
 KateProject::~KateProject()
 {
     saveNotesDocument();
 }
 
 bool KateProject::loadFromFile(const QString &fileName)
 {
     /**
      * bail out if already fileName set!
      */
     if (!m_fileName.isEmpty()) {
         return false;
     }
 
     /**
      * set new filename and base directory
      */
     m_fileName = fileName;
     m_baseDir = QFileInfo(m_fileName).canonicalPath();
 
     /**
      * trigger reload
      */
     return reload();
 }
 
 bool KateProject::reload(bool force)
 {
     QVariantMap map = readProjectFile();
 
     if (map.isEmpty()) {
         m_fileLastModified = QDateTime();
     } else {
         m_fileLastModified = QFileInfo(m_fileName).lastModified();
         m_globalProject = map;
     }
 
     return load(m_globalProject, force);
 }
 
 QVariantMap KateProject::readProjectFile() const
 {
     QFile file(m_fileName);
 
     if (!file.open(QFile::ReadOnly)) {
         return QVariantMap();
     }
 
     /**
      * parse the whole file, bail out again on error!
      */
     const QByteArray jsonData = file.readAll();
     QJsonParseError parseError;
     QJsonDocument project(QJsonDocument::fromJson(jsonData, &parseError));
 
     if (parseError.error != QJsonParseError::NoError) {
         return QVariantMap();
     }
 
     return project.toVariant().toMap();
 }
 
 bool KateProject::loadFromData(const QVariantMap& globalProject, const QString& directory)
 {
     m_baseDir = directory;
     m_fileName = QDir(directory).filePath(QStringLiteral(".kateproject"));
     m_globalProject = globalProject;
     return load(globalProject);
 }
 
 bool KateProject::load(const QVariantMap &globalProject, bool force)
 {
     /**
      * no name, bad => bail out
      */
     if (globalProject[QStringLiteral("name")].toString().isEmpty()) {
         return false;
     }
 
     /**
      * support out-of-source project files
      */
     if (!globalProject[QStringLiteral("directory")].toString().isEmpty()) {
         m_baseDir = QFileInfo(globalProject[QStringLiteral("directory")].toString()).canonicalFilePath();
     }
 
     /**
      * anything changed?
      * else be done without forced reload!
      */
     if (!force && (m_projectMap == globalProject)) {
         return true;
     }
 
     /**
      * setup global attributes in this object
      */
     m_projectMap = globalProject;
 
     /**
      * emit that we changed stuff
      */
     emit projectMapChanged();
 
 
     KateProjectWorker * w = new KateProjectWorker(m_baseDir, m_projectMap);
     connect(w, &KateProjectWorker::loadDone, this, &KateProject::loadProjectDone);
     connect(w, &KateProjectWorker::loadIndexDone, this, &KateProject::loadIndexDone);
     m_weaver->stream() << w;
 
     return true;
 }
 
-void KateProject::loadProjectDone(KateProjectSharedQStandardItem topLevel, KateProjectSharedQMapStringItem file2Item)
+void KateProject::loadProjectDone(const KateProjectSharedQStandardItem& topLevel, KateProjectSharedQMapStringItem file2Item)
 {
     m_model.clear();
     m_model.invisibleRootItem()->appendColumn(topLevel->takeColumn(0));
 
-    m_file2Item = file2Item;
+    m_file2Item = std::move(file2Item);
 
     /**
      * readd the documents that are open atm
      */
     m_untrackedDocumentsRoot = nullptr;
     for (auto i = m_documents.constBegin(); i != m_documents.constEnd(); i++) {
         registerDocument(i.key());
     }
 
     emit modelChanged();
 }
 
 void KateProject::loadIndexDone(KateProjectSharedProjectIndex projectIndex)
 {
     /**
      * move to our project
      */
-    m_projectIndex = projectIndex;
+    m_projectIndex = std::move(projectIndex);
 
     /**
      * notify external world that data is available
      */
     emit indexChanged();
 }
 
 QString KateProject::projectLocalFileName(const QString &suffix) const
 {
     /**
      * nothing on empty file names for project
      * should not happen
      */
     if (m_baseDir.isEmpty() || suffix.isEmpty()) {
         return QString();
     }
 
     /**
      * compute full file name
      */
     return m_baseDir + QStringLiteral(".kateproject.") + suffix;
 }
 
 QTextDocument *KateProject::notesDocument()
 {
     /**
      * already there?
      */
     if (m_notesDocument) {
         return m_notesDocument;
     }
 
     /**
      * else create it
      */
     m_notesDocument = new QTextDocument(this);
     m_notesDocument->setDocumentLayout(new QPlainTextDocumentLayout(m_notesDocument));
 
     /**
      * get file name
      */
     const QString notesFileName = projectLocalFileName(QStringLiteral("notes"));
     if (notesFileName.isEmpty()) {
         return m_notesDocument;
     }
 
     /**
      * and load text if possible
      */
     QFile inFile(notesFileName);
     if (inFile.open(QIODevice::ReadOnly)) {
         QTextStream inStream(&inFile);
         inStream.setCodec("UTF-8");
         m_notesDocument->setPlainText(inStream.readAll());
     }
 
     /**
      * and be done
      */
     return m_notesDocument;
 }
 
 void KateProject::saveNotesDocument()
 {
     /**
      * no notes document, nothing to do
      */
     if (!m_notesDocument) {
         return;
     }
 
     /**
      * get content & filename
      */
     const QString content = m_notesDocument->toPlainText();
     const QString notesFileName = projectLocalFileName(QStringLiteral("notes"));
     if (notesFileName.isEmpty()) {
         return;
     }
 
     /**
      * no content => unlink file, if there
      */
     if (content.isEmpty()) {
         if (QFile::exists(notesFileName)) {
             QFile::remove(notesFileName);
         }
         return;
     }
 
     /**
      * else: save content to file
      */
     QFile outFile(projectLocalFileName(QStringLiteral("notes")));
     if (outFile.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
         QTextStream outStream(&outFile);
         outStream.setCodec("UTF-8");
         outStream << content;
     }
 }
 
 void KateProject::slotModifiedChanged(KTextEditor::Document *document)
 {
     KateProjectItem *item = itemForFile(m_documents.value(document));
 
     if (!item) {
         return;
     }
 
     item->slotModifiedChanged(document);
 }
 
 void KateProject::slotModifiedOnDisk(KTextEditor::Document *document,
                                      bool isModified, KTextEditor::ModificationInterface::ModifiedOnDiskReason reason)
 {
     KateProjectItem *item = itemForFile(m_documents.value(document));
 
     if (!item) {
         return;
     }
 
     item->slotModifiedOnDisk(document, isModified, reason);
 }
 
 void KateProject::registerDocument(KTextEditor::Document *document)
 {
     // remember the document, if not already there
     if (!m_documents.contains(document)) {
         m_documents[document] = document->url().toLocalFile();
     }
 
     // try to get item for the document
     KateProjectItem *item = itemForFile(document->url().toLocalFile());
 
     // if we got one, we are done, else create a dummy!
     if (item) {
         disconnect(document, &KTextEditor::Document::modifiedChanged, this, &KateProject::slotModifiedChanged);
         disconnect(document, SIGNAL(modifiedOnDisk(KTextEditor::Document *, bool, KTextEditor::ModificationInterface::ModifiedOnDiskReason)), this, SLOT(slotModifiedOnDisk(KTextEditor::Document *, bool, KTextEditor::ModificationInterface::ModifiedOnDiskReason)));
         item->slotModifiedChanged(document);
 
         /*FIXME    item->slotModifiedOnDisk(document,document->isModified(),qobject_cast<KTextEditor::ModificationInterface*>(document)->modifiedOnDisk()); FIXME*/
 
         connect(document, &KTextEditor::Document::modifiedChanged, this, &KateProject::slotModifiedChanged);
         connect(document, SIGNAL(modifiedOnDisk(KTextEditor::Document *, bool, KTextEditor::ModificationInterface::ModifiedOnDiskReason)), this, SLOT(slotModifiedOnDisk(KTextEditor::Document *, bool, KTextEditor::ModificationInterface::ModifiedOnDiskReason)));
 
         return;
     }
 
     registerUntrackedDocument(document);
 }
 
 void KateProject::registerUntrackedDocument(KTextEditor::Document *document)
 {
     // perhaps create the parent item
     if (!m_untrackedDocumentsRoot) {
         m_untrackedDocumentsRoot = new KateProjectItem(KateProjectItem::Directory, i18n("<untracked>"));
         m_model.insertRow(0, m_untrackedDocumentsRoot);
     }
 
     // create document item
     QFileInfo fileInfo(document->url().toLocalFile());
     KateProjectItem *fileItem = new KateProjectItem(KateProjectItem::File, fileInfo.fileName());
     fileItem->setData(document->url().toLocalFile(), Qt::ToolTipRole);
     fileItem->slotModifiedChanged(document);
     connect(document, &KTextEditor::Document::modifiedChanged, this, &KateProject::slotModifiedChanged);
     connect(document, SIGNAL(modifiedOnDisk(KTextEditor::Document *, bool, KTextEditor::ModificationInterface::ModifiedOnDiskReason)), this, SLOT(slotModifiedOnDisk(KTextEditor::Document *, bool, KTextEditor::ModificationInterface::ModifiedOnDiskReason)));
 
     bool inserted = false;
     for (int i = 0; i < m_untrackedDocumentsRoot->rowCount(); ++i) {
         if (m_untrackedDocumentsRoot->child(i)->data(Qt::UserRole).toString() > document->url().toLocalFile()) {
             m_untrackedDocumentsRoot->insertRow(i, fileItem);
             inserted = true;
             break;
         }
     }
     if (!inserted) {
         m_untrackedDocumentsRoot->appendRow(fileItem);
     }
 
     fileItem->setData(document->url().toLocalFile(), Qt::UserRole);
     fileItem->setData(QVariant(true), Qt::UserRole + 3);
 
     if (!m_file2Item) {
         m_file2Item = KateProjectSharedQMapStringItem(new QMap<QString, KateProjectItem *> ());
     }
     (*m_file2Item)[document->url().toLocalFile()] = fileItem;
 }
 
 void KateProject::unregisterDocument(KTextEditor::Document *document)
 {
     if (!m_documents.contains(document)) {
         return;
     }
 
     disconnect(document, &KTextEditor::Document::modifiedChanged, this, &KateProject::slotModifiedChanged);
 
     const QString &file = m_documents.value(document);
 
     if (m_untrackedDocumentsRoot) {
         KateProjectItem *item = static_cast<KateProjectItem *>(itemForFile(file));
         if (item && item->data(Qt::UserRole + 3).toBool()) {
             unregisterUntrackedItem(item);
             m_file2Item->remove(file);
         }
     }
 
     m_documents.remove(document);
 }
 
 void KateProject::unregisterUntrackedItem(const KateProjectItem *item)
 {
     for (int i = 0; i < m_untrackedDocumentsRoot->rowCount(); ++i) {
         if (m_untrackedDocumentsRoot->child(i) == item) {
             m_untrackedDocumentsRoot->removeRow(i);
             break;
         }
     }
 
     if (m_untrackedDocumentsRoot->rowCount() < 1) {
         m_model.removeRow(0);
         m_untrackedDocumentsRoot = nullptr;
     }
 }
diff --git a/addons/project/kateproject.h b/addons/project/kateproject.h
index 6652148a0..158181f22 100644
--- a/addons/project/kateproject.h
+++ b/addons/project/kateproject.h
@@ -1,302 +1,302 @@
 /*  This file is part of the Kate project.
  *
  *  Copyright (C) 2010 Christoph Cullmann <cullmann@kde.org>
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #ifndef KATE_PROJECT_H
 #define KATE_PROJECT_H
 
 #include <QDateTime>
 #include <QMap>
 #include <QSharedPointer>
 #include <QTextDocument>
 #include <KTextEditor/ModificationInterface>
 #include "kateprojectindex.h"
 #include "kateprojectitem.h"
 
 /**
  * Shared pointer data types.
  * Used to pass pointers over queued connected slots
  */
 typedef QSharedPointer<QStandardItem> KateProjectSharedQStandardItem;
 Q_DECLARE_METATYPE(KateProjectSharedQStandardItem)
 
 typedef QSharedPointer<QMap<QString, KateProjectItem *> > KateProjectSharedQMapStringItem;
 Q_DECLARE_METATYPE(KateProjectSharedQMapStringItem)
 
 typedef QSharedPointer<KateProjectIndex> KateProjectSharedProjectIndex;
 Q_DECLARE_METATYPE(KateProjectSharedProjectIndex)
 
 namespace ThreadWeaver {
 class Queue;
 }
 
 /**
  * Class representing a project.
  * Holds project properties like name, groups, contained files, ...
  */
 class KateProject : public QObject
 {
     Q_OBJECT
 
 public:
     /**
      * construct empty project
      */
     KateProject(ThreadWeaver::Queue *weaver);
 
     /**
      * deconstruct project
      */
     ~KateProject() override;
 
     /**
      * Load a project from project file
      * Only works once, afterwards use reload().
      * @param fileName name of project file
      * @return success
      */
     bool loadFromFile(const QString &fileName);
     bool loadFromData(const QVariantMap &globalProject, const QString &directory);
 
     /**
      * Try to reload a project.
      * If the reload fails, e.g. because the file is not readable or corrupt, nothing will happen!
      * @param force will enforce the worker to update files list and co even if the content of the file was not changed!
      * @return success
      */
     bool reload(bool force = false);
 
     /**
      * Accessor to file name.
      * @return file name
      */
     const QString &fileName() const {
         return m_fileName;
     }
 
     /**
      * Return the base directory of this project.
      * @return base directory of project, might not be the directory of the fileName!
      */
     const QString &baseDir() const {
         return m_baseDir;
     }
 
     /**
      * Return the time when the project file has been modified last.
      * @return QFileInfo::lastModified()
      */
     QDateTime fileLastModified() const { return m_fileLastModified; }
 
     /**
      * Accessor to project map containing the whole project info.
      * @return project info
      */
     const QVariantMap &projectMap() const {
         return m_projectMap;
     }
 
     /**
      * Accessor to project name.
      * @return project name
      */
     QString name() const {
         //MSVC doesn't support QStringLiteral here
         return m_projectMap[QStringLiteral("name")].toString();
     }
 
     /**
      * Accessor for the model.
      * @return model of this project
      */
     QStandardItemModel *model() {
         return &m_model;
     }
 
     /**
      * Flat list of all files in the project
      * @return list of files in project
      */
     QStringList files() {
         return m_file2Item ? m_file2Item->keys() : QStringList();
     }
 
     /**
      * get item for file
      * @param file file to get item for
      * @return item for given file or 0
      */
     KateProjectItem *itemForFile(const QString &file) {
         return m_file2Item ? m_file2Item->value(file) : nullptr;
     }
 
     /**
      * Access to project index.
      * May be null.
      * Don't store this pointer, might change.
      * @return project index
      */
     KateProjectIndex *projectIndex() {
         return m_projectIndex.data();
     }
 
     /**
      * Computes a suitable file name for the given suffix.
      * If you e.g. want to store a "notes" file, you could pass "notes" and get
      * the full path to projectbasedir/.kateproject.notes
      * @param suffix suffix for the file
      * @return full path for project local file, on error => empty string
      */
     QString projectLocalFileName(const QString &suffix) const;
 
     /**
      * Document with project local notes.
      * Will be stored in a projectLocalFile "notes.txt".
      * @return notes document
      */
     QTextDocument *notesDocument();
 
     /**
      * Save the notes document to "notes.txt" if any document around.
      */
     void saveNotesDocument();
 
     /**
      * Register a document for this project.
      * @param document document to register
      */
     void registerDocument(KTextEditor::Document *document);
 
     /**
      * Unregister a document for this project.
      * @param document document to unregister
      */
     void unregisterDocument(KTextEditor::Document *document);
 
 private Q_SLOTS:
     bool load(const QVariantMap &globalProject, bool force = false);
 
     /**
      * Used for worker to send back the results of project loading
      * @param topLevel new toplevel element for model
      * @param file2Item new file => item mapping
      */
-    void loadProjectDone(KateProjectSharedQStandardItem topLevel, KateProjectSharedQMapStringItem file2Item);
+    void loadProjectDone(const KateProjectSharedQStandardItem& topLevel, KateProjectSharedQMapStringItem file2Item);
 
     /**
      * Used for worker to send back the results of index loading
      * @param projectIndex new project index
      */
     void loadIndexDone(KateProjectSharedProjectIndex projectIndex);
 
     void slotModifiedChanged(KTextEditor::Document *);
 
     void slotModifiedOnDisk(KTextEditor::Document *document,
                             bool isModified, KTextEditor::ModificationInterface::ModifiedOnDiskReason reason);
 
 Q_SIGNALS:
     /**
      * Emitted on project map changes.
      * This includes the name!
      */
     void projectMapChanged();
 
     /**
      * Emitted on model changes.
      * This includes the files list, itemForFile mapping!
      */
     void modelChanged();
 
     /**
      * Emitted when the index creation is finished.
      * This includes the ctags index.
      */
     void indexChanged();
 
 private:
     void registerUntrackedDocument(KTextEditor::Document *document);
     void unregisterUntrackedItem(const KateProjectItem *item);
     QVariantMap readProjectFile() const;
 
 private:
 
     /**
      * Last modification time of the project file
      */
     QDateTime m_fileLastModified;
 
     /**
      * project file name
      */
     QString m_fileName;
 
     /**
      * base directory of the project
      */
     QString m_baseDir;
 
     /**
      * project name
      */
     QString m_name;
 
     /**
      * variant map representing the project
      */
     QVariantMap m_projectMap;
 
     /**
      * standard item model with content of this project
      */
     QStandardItemModel m_model;
 
     /**
      * mapping files => items
      */
     KateProjectSharedQMapStringItem m_file2Item;
 
     /**
      * project index, if any
      */
     KateProjectSharedProjectIndex m_projectIndex;
 
     /**
      * notes buffer for project local notes
      */
     QTextDocument *m_notesDocument;
 
     /**
      * Set of existing documents for this project.
      */
     QMap<KTextEditor::Document *, QString> m_documents;
 
     /**
      * Parent item for existing documents that are not in the project tree
      */
     QStandardItem *m_untrackedDocumentsRoot;
 
     ThreadWeaver::Queue *m_weaver;
 
     /**
      * project configuration (read from file or injected)
      */
     QVariantMap m_globalProject;
 };
 
 #endif
diff --git a/addons/xmltools/pseudo_dtd.cpp b/addons/xmltools/pseudo_dtd.cpp
index cb04cd3ff..c2cd43f63 100644
--- a/addons/xmltools/pseudo_dtd.cpp
+++ b/addons/xmltools/pseudo_dtd.cpp
@@ -1,448 +1,448 @@
 /***************************************************************************
     pseudoDtd.cpp
     copyright           : (C) 2001-2002 by Daniel Naber
     email               : daniel.naber@t-online.de
  ***************************************************************************/
 
 /***************************************************************************
  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License
  as published by the Free Software Foundation; either version 2
  of the License, or ( at your option ) any later version.
 
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  ***************************************************************************/
 
 #include "pseudo_dtd.h"
 
 #include <qdom.h>
 #include <qregexp.h>
 
 #include <klocalizedstring.h>
 #include <kmessagebox.h>
 
 PseudoDTD::PseudoDTD()
 {
     // "SGML support" only means case-insensivity, because HTML is case-insensitive up to version 4:
     m_sgmlSupport = true;   // TODO: make this an run-time option ( maybe automatically set )
 }
 
 PseudoDTD::~PseudoDTD()
 {
 }
 
 void PseudoDTD::analyzeDTD(QString &metaDtdUrl, QString &metaDtd)
 {
     QDomDocument doc(QStringLiteral("dtdIn_xml"));
     if (! doc.setContent(metaDtd)) {
         KMessageBox::error(nullptr, i18n("The file '%1' could not be parsed. "
                                    "Please check that the file is well-formed XML.", metaDtdUrl),
                            i18n("XML Plugin Error"));
         return;
     }
 
     if (doc.doctype().name() != QLatin1String("dtd")) {
         KMessageBox::error(nullptr, i18n("The file '%1' is not in the expected format. "
                                    "Please check that the file is of this type:\n"
                                    "-//Norman Walsh//DTD DTDParse V2.0//EN\n"
                                    "You can produce such files with dtdparse. "
                                    "See the Kate Plugin documentation for more information.", metaDtdUrl),
                            i18n("XML Plugin Error"));
         return;
     }
 
     uint listLength = 0;
     listLength += doc.elementsByTagName(QStringLiteral("entity")).count();
     listLength += doc.elementsByTagName(QStringLiteral("element")).count();
     // count this twice, as it will be iterated twice ( TODO: optimize that? ):
     listLength += doc.elementsByTagName(QStringLiteral("attlist")).count() * 2;
 
     QProgressDialog progress(i18n("Analyzing meta DTD..."), i18n("Cancel"), 0, listLength);
     progress.setMinimumDuration(400);
     progress.setValue(0);
 
     // Get information from meta DTD and put it in Qt data structures for fast access:
     if (! parseEntities(&doc, &progress)) {
         return;
     }
 
     if (! parseElements(&doc, &progress)) {
         return;
     }
 
     if (! parseAttributes(&doc, &progress)) {
         return;
     }
 
     if (! parseAttributeValues(&doc, &progress)) {
         return;
     }
 
     progress.setValue(listLength);     // just to make sure the dialog disappears
 
 }
 
 // ========================================================================
 // DOM stuff:
 
 /**
  * Iterate through the XML to get a mapping which sub-elements are allowed for
  * all elements.
  */
 bool PseudoDTD::parseElements(QDomDocument *doc, QProgressDialog *progress)
 {
 
     m_elementsList.clear();
     // We only display a list, i.e. we pretend that the content model is just
     // a set, so we use a map. This is necessary e.g. for xhtml 1.0's head element,
     // which would otherwise display some elements twice.
     QMap<QString, bool> subelementList;   // the bool is not used
 
     QDomNodeList list = doc->elementsByTagName(QStringLiteral("element"));
     uint listLength = list.count();      // speedup (really! )
 
     for (uint i = 0; i < listLength; i++) {
         if (progress->wasCanceled()) {
             return false;
         }
 
         progress->setValue(progress->value() + 1);
         // FIXME!:
         //qApp->processEvents();
 
         subelementList.clear();
         QDomNode node = list.item(i);
         QDomElement elem = node.toElement();
 
         if (!elem.isNull()) {
             // Enter the expanded content model, which may also include stuff not allowed.
             // We do not care if it's a <sequence-group> or whatever.
             QDomNodeList contentModelList = elem.elementsByTagName(QStringLiteral("content-model-expanded"));
             QDomNode contentModelNode = contentModelList.item(0);
             QDomElement contentModelElem = contentModelNode.toElement();
             if (! contentModelElem.isNull()) {
                 // check for <pcdata/>:
                 QDomNodeList pcdataList = contentModelElem.elementsByTagName(QStringLiteral("pcdata"));
 
                 // check for other sub elements:
                 QDomNodeList subList = contentModelElem.elementsByTagName(QStringLiteral("element-name"));
                 uint subListLength = subList.count();
                 for (uint l = 0; l < subListLength; l++) {
                     QDomNode subNode = subList.item(l);
                     QDomElement subElem = subNode.toElement();
                     if (!subElem.isNull()) {
                         subelementList[subElem.attribute(QStringLiteral("name"))] = true;
                     }
                 }
 
                 // anders: check if this is an EMPTY element, and put "__EMPTY" in the
                 // sub list, so that we can insert tags in empty form if required.
                 QDomNodeList emptyList = elem.elementsByTagName(QStringLiteral("empty"));
                 if (emptyList.count()) {
                     subelementList[QStringLiteral("__EMPTY")] = true;
                 }
             }
 
             // Now remove the elements not allowed (e.g. <a> is explicitly not allowed in <a>
             // in the HTML 4.01 Strict DTD):
             QDomNodeList exclusionsList = elem.elementsByTagName(QStringLiteral("exclusions"));
             if (exclusionsList.length() > 0) {
                 // sometimes there are no exclusions ( e.g. in XML DTDs there are never exclusions )
                 QDomNode exclusionsNode = exclusionsList.item(0);
                 QDomElement exclusionsElem = exclusionsNode.toElement();
                 if (! exclusionsElem.isNull()) {
                     QDomNodeList subList = exclusionsElem.elementsByTagName(QStringLiteral("element-name"));
                     uint subListLength = subList.count();
                     for (uint l = 0; l < subListLength; l++) {
                         QDomNode subNode = subList.item(l);
                         QDomElement subElem = subNode.toElement();
                         if (!subElem.isNull()) {
                             QMap<QString, bool>::Iterator it = subelementList.find(subElem.attribute(QStringLiteral("name")));
                             if (it != subelementList.end()) {
                                 subelementList.erase(it);
                             }
                         }
                     }
                 }
             }
 
             // turn the map into a list:
             QStringList subelementListTmp;
             QMap<QString, bool>::Iterator it;
             for (it = subelementList.begin(); it != subelementList.end(); ++it) {
                 subelementListTmp.append(it.key());
             }
 
             m_elementsList.insert(elem.attribute(QStringLiteral("name")), subelementListTmp);
 
         }
 
     } // end iteration over all <element> nodes
     return true;
 }
 
 /**
  * Check which elements are allowed inside a parent element. This returns
  * a list of allowed elements, but it doesn't care about order or if only a certain
  * number of occurrences is allowed.
  */
 QStringList PseudoDTD::allowedElements(const QString &parentElement)
 {
     if (m_sgmlSupport) {
         // find the matching element, ignoring case:
         QMap<QString, QStringList>::Iterator it;
         for (it = m_elementsList.begin(); it != m_elementsList.end(); ++it) {
             if (it.key().compare(parentElement, Qt::CaseInsensitive) == 0) {
                 return it.value();
             }
         }
     } else if (m_elementsList.contains(parentElement)) {
         return m_elementsList[parentElement];
     }
 
     return QStringList();
 }
 
 /**
  * Iterate through the XML to get a mapping which attributes are allowed inside
  * all elements.
  */
 bool PseudoDTD::parseAttributes(QDomDocument *doc, QProgressDialog *progress)
 {
     m_attributesList.clear();
 //   QStringList allowedAttributes;
     QDomNodeList list = doc->elementsByTagName(QStringLiteral("attlist"));
     uint listLength = list.count();
 
     for (uint i = 0; i < listLength; i++) {
         if (progress->wasCanceled()) {
             return false;
         }
 
         progress->setValue(progress->value() + 1);
         // FIXME!!
         //qApp->processEvents();
 
         ElementAttributes attrs;
         QDomNode node = list.item(i);
         QDomElement elem = node.toElement();
         if (!elem.isNull()) {
             QDomNodeList attributeList = elem.elementsByTagName(QStringLiteral("attribute"));
             uint attributeListLength = attributeList.count();
             for (uint l = 0; l < attributeListLength; l++) {
                 QDomNode attributeNode = attributeList.item(l);
                 QDomElement attributeElem = attributeNode.toElement();
 
                 if (! attributeElem.isNull()) {
                     if (attributeElem.attribute(QStringLiteral("type")) == QLatin1String("#REQUIRED")) {
                         attrs.requiredAttributes.append(attributeElem.attribute(QStringLiteral("name")));
                     } else {
                         attrs.optionalAttributes.append(attributeElem.attribute(QStringLiteral("name")));
                     }
                 }
             }
             m_attributesList.insert(elem.attribute(QStringLiteral("name")), attrs);
         }
     }
 
     return true;
 }
 
 /** Check which attributes are allowed for an element.
  */
 QStringList PseudoDTD::allowedAttributes(const QString &element)
 {
     if (m_sgmlSupport) {
         // find the matching element, ignoring case:
         QMap<QString, ElementAttributes>::Iterator it;
         for (it = m_attributesList.begin(); it != m_attributesList.end(); ++it) {
             if (it.key().compare(element, Qt::CaseInsensitive) == 0) {
                 return it.value().optionalAttributes + it.value().requiredAttributes;
             }
         }
     } else if (m_attributesList.contains(element)) {
         return m_attributesList[element].optionalAttributes + m_attributesList[element].requiredAttributes;
     }
 
     return QStringList();
 }
 
 QStringList PseudoDTD::requiredAttributes(const QString &element) const
 {
     if (m_sgmlSupport) {
         QMap<QString, ElementAttributes>::ConstIterator it;
         for (it = m_attributesList.begin(); it != m_attributesList.end(); ++it) {
             if (it.key().compare(element, Qt::CaseInsensitive) == 0) {
                 return it.value().requiredAttributes;
             }
         }
     } else if (m_attributesList.contains(element)) {
         return m_attributesList[element].requiredAttributes;
     }
 
     return QStringList();
 }
 
 /**
  * Iterate through the XML to get a mapping which attribute values are allowed
  * for all attributes inside all elements.
  */
 bool PseudoDTD::parseAttributeValues(QDomDocument *doc, QProgressDialog *progress)
 {
     m_attributevaluesList.clear();                        // 1 element : n possible attributes
     QMap<QString, QStringList> attributevaluesTmp;    // 1 attribute : n possible values
     QDomNodeList list = doc->elementsByTagName(QStringLiteral("attlist"));
     uint listLength = list.count();
 
     for (uint i = 0; i < listLength; i++) {
         if (progress->wasCanceled()) {
             return false;
         }
 
         progress->setValue(progress->value() + 1);
         // FIXME!
         //qApp->processEvents();
 
         attributevaluesTmp.clear();
         QDomNode node = list.item(i);
         QDomElement elem = node.toElement();
         if (!elem.isNull()) {
             // Enter the list of <attribute>:
             QDomNodeList attributeList = elem.elementsByTagName(QStringLiteral("attribute"));
             uint attributeListLength = attributeList.count();
             for (uint l = 0; l < attributeListLength; l++) {
                 QDomNode attributeNode = attributeList.item(l);
                 QDomElement attributeElem = attributeNode.toElement();
                 if (! attributeElem.isNull()) {
                     QString value = attributeElem.attribute(QStringLiteral("value"));
                     attributevaluesTmp.insert(attributeElem.attribute(QStringLiteral("name")), value.split(QChar(' ')));
                 }
             }
             m_attributevaluesList.insert(elem.attribute(QStringLiteral("name")), attributevaluesTmp);
         }
     }
     return true;
 }
 
 /**
  * Check which attributes values are allowed for an attribute in an element
  * (the element is necessary because e.g. "href" inside <a> could be different
  * to an "href" inside <link>):
  */
 QStringList PseudoDTD::attributeValues(const QString &element, const QString &attribute)
 {
     // Direct access would be faster than iteration of course but not always correct,
     // because we need to be case-insensitive.
     if (m_sgmlSupport) {
         // first find the matching element, ignoring case:
         QMap< QString, QMap<QString, QStringList> >::Iterator it;
         for (it = m_attributevaluesList.begin(); it != m_attributevaluesList.end(); ++it) {
             if (it.key().compare(element, Qt::CaseInsensitive) == 0) {
                 QMap<QString, QStringList> attrVals = it.value();
                 QMap<QString, QStringList>::Iterator itV;
                 // then find the matching attribute for that element, ignoring case:
                 for (itV = attrVals.begin(); itV != attrVals.end(); ++itV) {
                     if (itV.key().compare(attribute, Qt::CaseInsensitive) == 0) {
                         return(itV.value());
                     }
                 }
             }
         }
     } else if (m_attributevaluesList.contains(element)) {
         QMap<QString, QStringList> attrVals = m_attributevaluesList[element];
         if (attrVals.contains(attribute)) {
             return attrVals[attribute];
         }
     }
 
     // no predefined values available:
     return QStringList();
 }
 
 /**
  * Iterate through the XML to get a mapping of all entity names and their expanded
  * version, e.g. nbsp => &#160;. Parameter entities are ignored.
  */
 bool PseudoDTD::parseEntities(QDomDocument *doc, QProgressDialog *progress)
 {
     m_entityList.clear();
     QDomNodeList list = doc->elementsByTagName(QStringLiteral("entity"));
     uint listLength = list.count();
 
     for (uint i = 0; i < listLength; i++) {
         if (progress->wasCanceled()) {
             return false;
         }
 
         progress->setValue(progress->value() + 1);
         //FIXME!!
         //qApp->processEvents();
         QDomNode node = list.item(i);
         QDomElement elem = node.toElement();
         if (!elem.isNull()
                 && elem.attribute(QStringLiteral("type")) != QLatin1String("param")) {
             // TODO: what's cdata <-> gen ?
             QDomNodeList expandedList = elem.elementsByTagName(QStringLiteral("text-expanded"));
             QDomNode expandedNode = expandedList.item(0);
             QDomElement expandedElem = expandedNode.toElement();
             if (! expandedElem.isNull()) {
                 QString exp = expandedElem.text();
                 // TODO: support more than one &#...; in the expanded text
                 /* TODO include do this when the unicode font problem is solved:
                 if( exp.contains(QRegularExpression("^&#x[a-zA-Z0-9]+;$")) ) {
                 // hexadecimal numbers, e.g. "&#x236;"
                 uint end = exp.find( ";" );
                 exp = exp.mid( 3, end-3 );
                 exp = QChar();
                 } else if( exp.contains(QRegularExpression("^&#[0-9]+;$")) ) {
                 // decimal numbers, e.g. "&#236;"
                 uint end = exp.find( ";" );
                 exp = exp.mid( 2, end-2 );
                 exp = QChar( exp.toInt() );
                 }
                 */
                 m_entityList.insert(elem.attribute(QStringLiteral("name")), exp);
             } else {
                 m_entityList.insert(elem.attribute(QStringLiteral("name")), QString());
             }
         }
     }
     return true;
 }
 
 /**
  * Get a list of all ( non-parameter ) entities that start with a certain string.
  */
 QStringList PseudoDTD::entities(const QString &start)
 {
     QStringList entities;
     QMap<QString, QString>::Iterator it;
     for (it = m_entityList.begin(); it != m_entityList.end(); ++it) {
         if ((*it).startsWith(start)) {
-            QString str = it.key();
+            const QString& str = it.key();
             /* TODO: show entities as unicode character
             if( !it.data().isEmpty() ) {
             //str += " -- " + it.data();
             QRegExp re( "&#(\\d+);" );
             if( re.search(it.data()) != -1 ) {
             uint ch = re.cap( 1).toUInt();
             str += " -- " + QChar( ch).decomposition();
             }
             //qDebug() << "#" << it.data();
             }
             */
             entities.append(str);
             // TODO: later use a table view
         }
     }
     return entities;
 }
 
 // kate: space-indent on; indent-width 4; replace-tabs on; mixed-indent off;
diff --git a/kate/katedocmanager.cpp b/kate/katedocmanager.cpp
index 9b0c84fea..6bf4d0b3a 100644
--- a/kate/katedocmanager.cpp
+++ b/kate/katedocmanager.cpp
@@ -1,598 +1,598 @@
 /* This file is part of the KDE project
    Copyright (C) 2001 Christoph Cullmann <cullmann@kde.org>
    Copyright (C) 2002 Joseph Wenninger <jowenn@kde.org>
    Copyright (C) 2007 Flavio Castelli <flavio.castelli@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "katedocmanager.h"
 
 #include "kateapp.h"
 #include "katemainwindow.h"
 #include "kateviewmanager.h"
 #include "katesavemodifieddialog.h"
 #include "katedebug.h"
 
 #include <ktexteditor/view.h>
 #include <ktexteditor/editor.h>
 
 #include <KCodecs>
 #include <KMessageBox>
 #include <KIO/DeleteJob>
 #include <KColorScheme>
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <QByteArray>
 #include <QDateTime>
 #include <QHash>
 #include <QTextCodec>
 #include <QTimer>
 #include <QApplication>
 #include <QListView>
 #include <QProgressDialog>
 #include <QFileDialog>
 
 KateDocManager::KateDocManager(QObject *parent)
     : QObject(parent)
     , m_metaInfos(QStringLiteral("katemetainfos"), KConfig::NoGlobals)
     , m_saveMetaInfos(true)
     , m_daysMetaInfos(0)
 {
     // set our application wrapper
     KTextEditor::Editor::instance()->setApplication(KateApp::self()->wrapper());
 
     // create one doc, we always have at least one around!
     createDoc();
 }
 
 KateDocManager::~KateDocManager()
 {
     // write metainfos?
     if (m_saveMetaInfos) {
         // saving meta-infos when file is saved is not enough, we need to do it once more at the end
         saveMetaInfos(m_docList);
 
         // purge saved filesessions
         if (m_daysMetaInfos > 0) {
             const QStringList groups = m_metaInfos.groupList();
             QDateTime def(QDate(1970, 1, 1));
             for (const auto& group : groups) {
                 QDateTime last = m_metaInfos.group(group).readEntry("Time", def);
                 if (last.daysTo(QDateTime::currentDateTimeUtc()) > m_daysMetaInfos) {
                     m_metaInfos.deleteGroup(group);
                 }
             }
         }
     }
 
     qDeleteAll(m_docInfos);
 }
 
 KTextEditor::Document *KateDocManager::createDoc(const KateDocumentInfo &docInfo)
 {
     KTextEditor::Document *doc = KTextEditor::Editor::instance()->createDocument(this);
 
     // turn of the editorpart's own modification dialog, we have our own one, too!
     const KConfigGroup generalGroup(KSharedConfig::openConfig(), "General");
     bool ownModNotification = generalGroup.readEntry("Modified Notification", false);
     if (qobject_cast<KTextEditor::ModificationInterface *>(doc)) {
         qobject_cast<KTextEditor::ModificationInterface *>(doc)->setModifiedOnDiskWarning(!ownModNotification);
     }
 
     m_docList.append(doc);
     m_docInfos.insert(doc, new KateDocumentInfo(docInfo));
 
     // connect internal signals...
     connect(doc, &KTextEditor::Document::modifiedChanged, this, &KateDocManager::slotModChanged1);
     connect(doc, SIGNAL(modifiedOnDisk(KTextEditor::Document*,bool,KTextEditor::ModificationInterface::ModifiedOnDiskReason)),
             this, SLOT(slotModifiedOnDisc(KTextEditor::Document*,bool,KTextEditor::ModificationInterface::ModifiedOnDiskReason)));
 
     // we have a new document, show it the world
     emit documentCreated(doc);
     emit documentCreatedViewManager(doc);
 
     // return our new document
     return doc;
 }
 
 KateDocumentInfo *KateDocManager::documentInfo(KTextEditor::Document *doc)
 {
     return m_docInfos.contains(doc) ? m_docInfos[doc] : nullptr;
 }
 
 static QUrl
 normalizeUrl(const QUrl & url)
 {
     // Resolve symbolic links for local files (done anyway in KTextEditor)
     if (url.isLocalFile()) {
         QString normalizedUrl = QFileInfo(url.toLocalFile()).canonicalFilePath();
         if (!normalizedUrl.isEmpty()) {
             return QUrl::fromLocalFile(normalizedUrl);
         }
     }
 
     // else: cleanup only the .. stuff
     return url.adjusted(QUrl::NormalizePathSegments);
 }
 
 KTextEditor::Document *KateDocManager::findDocument(const QUrl &url) const
 {
     const QUrl u(normalizeUrl(url));
     for(KTextEditor::Document *it : m_docList) {
         if (it->url() == u) {
             return it;
         }
     }
     return nullptr;
 }
 
 QList<KTextEditor::Document *> KateDocManager::openUrls(const QList<QUrl> &urls, const QString &encoding, bool isTempFile, const KateDocumentInfo &docInfo)
 {
     QList<KTextEditor::Document *> docs;
 
     emit aboutToCreateDocuments();
 
     foreach(const QUrl & url, urls) {
         docs << openUrl(url, encoding, isTempFile, docInfo);
     }
 
     emit documentsCreated(docs);
 
     return docs;
 }
 
 KTextEditor::Document *KateDocManager::openUrl(const QUrl &url, const QString &encoding, bool isTempFile, const KateDocumentInfo &docInfo)
 {
     // special handling: if only one unmodified empty buffer in the list,
     // keep this buffer in mind to close it after opening the new url
     KTextEditor::Document *untitledDoc = nullptr;
     if ((documentList().count() == 1) && (!documentList().at(0)->isModified()
                                           && documentList().at(0)->url().isEmpty())) {
         untitledDoc = documentList().first();
     }
 
     //
     // create new document
     //
     const QUrl u(normalizeUrl(url));
     KTextEditor::Document *doc = nullptr;
 
     // always new document if url is empty...
     if (!u.isEmpty()) {
         doc = findDocument(u);
     }
 
     if (!doc) {
         if (untitledDoc) {
             // reuse the untitled document which is not needed
             auto & info = m_docInfos.find(untitledDoc).value();
             delete info;
             info = new KateDocumentInfo(docInfo);
             doc = untitledDoc;
         } else {
             doc = createDoc(docInfo);
         }
 
         if (!encoding.isEmpty()) {
             doc->setEncoding(encoding);
         }
 
         if (!u.isEmpty()) {
             doc->openUrl(u);
             loadMetaInfos(doc, u);
         }
     }
 
     //
     // if needed, register as temporary file
     //
     if (isTempFile && u.isLocalFile()) {
         QFileInfo fi(u.toLocalFile());
         if (fi.exists()) {
             m_tempFiles[doc] = qMakePair(u, fi.lastModified());
             qCDebug(LOG_KATE) << "temporary file will be deleted after use unless modified: " << u;
         }
     }
 
     return doc;
 }
 
 bool KateDocManager::closeDocuments(const QList<KTextEditor::Document *> &documents, bool closeUrl)
 {
     if (documents.isEmpty()) {
         return false;
     }
 
     saveMetaInfos(documents);
 
     emit aboutToDeleteDocuments(documents);
 
     int last = 0;
     bool success = true;
     foreach(KTextEditor::Document * doc, documents) {
         if (closeUrl && !doc->closeUrl()) {
             success = false;    // get out on first error
             break;
         }
 
         if (closeUrl && m_tempFiles.contains(doc)) {
             QFileInfo fi(m_tempFiles[ doc ].first.toLocalFile());
             if (fi.lastModified() <= m_tempFiles[ doc ].second ||
                     KMessageBox::questionYesNo(KateApp::self()->activeKateMainWindow(),
                                                i18n("The supposedly temporary file %1 has been modified. "
                                                     "Do you want to delete it anyway?", m_tempFiles[ doc ].first.url(QUrl::PreferLocalFile)),
                                                i18n("Delete File?")) == KMessageBox::Yes) {
                 KIO::del(m_tempFiles[ doc ].first, KIO::HideProgressInfo);
                 qCDebug(LOG_KATE) << "Deleted temporary file " << m_tempFiles[ doc ].first;
                 m_tempFiles.remove(doc);
             } else {
                 m_tempFiles.remove(doc);
                 qCDebug(LOG_KATE) << "The supposedly temporary file " << m_tempFiles[ doc ].first.url() << " have been modified since loaded, and has not been deleted.";
             }
         }
 
         KateApp::self()->emitDocumentClosed(QString::number((qptrdiff)doc));
 
         // document will be deleted, soon
         emit documentWillBeDeleted(doc);
 
         // really delete the document and its infos
         delete m_docInfos.take(doc);
         delete m_docList.takeAt(m_docList.indexOf(doc));
 
         // document is gone, emit our signals
         emit documentDeleted(doc);
 
         last++;
     }
 
     /**
      * never ever empty the whole document list
      * do this before documentsDeleted is emitted, to have no flicker
      */
     if (m_docList.isEmpty()) {
         createDoc();
     }
 
     emit documentsDeleted(documents.mid(last));
 
     return success;
 }
 
 bool KateDocManager::closeDocument(KTextEditor::Document *doc, bool closeUrl)
 {
     if (!doc) {
         return false;
     }
 
     QList<KTextEditor::Document *> documents;
     documents.append(doc);
 
     return closeDocuments(documents, closeUrl);
 }
 
-bool KateDocManager::closeDocumentList(QList<KTextEditor::Document *> documents)
+bool KateDocManager::closeDocumentList(const QList<KTextEditor::Document *>& documents)
 {
     QList<KTextEditor::Document *> modifiedDocuments;
     foreach(KTextEditor::Document * document, documents) {
         if (document->isModified()) {
             modifiedDocuments.append(document);
         }
     }
 
     if (modifiedDocuments.size() > 0 && !KateSaveModifiedDialog::queryClose(nullptr, modifiedDocuments)) {
         return false;
     }
 
     return closeDocuments(documents, false);   // Do not show save/discard dialog
 }
 
 bool KateDocManager::closeAllDocuments(bool closeUrl)
 {
     /**
      * just close all documents
      */
     return closeDocuments(m_docList, closeUrl);
 }
 
 bool KateDocManager::closeOtherDocuments(KTextEditor::Document *doc)
 {
     /**
      * close all documents beside the passed one
      */
     QList<KTextEditor::Document *> documents = m_docList;
     documents.removeOne(doc);
     return closeDocuments(documents);
 }
 
 /**
  * Find all modified documents.
  * @return Return the list of all modified documents.
  */
 QList<KTextEditor::Document *> KateDocManager::modifiedDocumentList()
 {
     QList<KTextEditor::Document *> modified;
     foreach(KTextEditor::Document * doc, m_docList) {
         if (doc->isModified()) {
             modified.append(doc);
         }
     }
     return modified;
 }
 
 bool KateDocManager::queryCloseDocuments(KateMainWindow *w)
 {
     int docCount = m_docList.count();
     foreach(KTextEditor::Document * doc, m_docList) {
         if (doc->url().isEmpty() && doc->isModified()) {
             int msgres = KMessageBox::warningYesNoCancel(w,
                          i18n("<p>The document '%1' has been modified, but not saved.</p>"
                               "<p>Do you want to save your changes or discard them?</p>", doc->documentName()),
                          i18n("Close Document"), KStandardGuiItem::save(), KStandardGuiItem::discard());
 
             if (msgres == KMessageBox::Cancel) {
                 return false;
             }
 
             if (msgres == KMessageBox::Yes) {
                 const QUrl url = QFileDialog::getSaveFileUrl(w, i18n("Save As"));
                 if (!url.isEmpty()) {
                     if (!doc->saveAs(url)) {
                         return false;
                     }
                 } else {
                     return false;
                 }
             }
         } else {
             if (!doc->queryClose()) {
                 return false;
             }
         }
     }
 
     // document count changed while queryClose, abort and notify user
     if (m_docList.count() > docCount) {
         KMessageBox::information(w,
                                  i18n("New file opened while trying to close Kate, closing aborted."),
                                  i18n("Closing Aborted"));
         return false;
     }
 
     return true;
 }
 
 void KateDocManager::saveAll()
 {
     foreach(KTextEditor::Document * doc, m_docList)
     if (doc->isModified()) {
         doc->documentSave();
     }
 }
 
 void KateDocManager::saveSelected(const QList<KTextEditor::Document *> &docList)
 {
     foreach(KTextEditor::Document * doc, docList) {
         if (doc->isModified()) {
             doc->documentSave();
         }
     }
 }
 
 void KateDocManager::reloadAll()
 {
     // reload all docs that are NOT modified on disk
     foreach(KTextEditor::Document * doc, m_docList) {
         if (! documentInfo(doc)->modifiedOnDisc) {
             doc->documentReload();
         }
     }
 
     // take care of all documents that ARE modified on disk
     KateApp::self()->activeKateMainWindow()->showModOnDiskPrompt();
 }
 
 void KateDocManager::closeOrphaned()
 {
     QList<KTextEditor::Document *> documents;
 
     foreach(KTextEditor::Document * doc, m_docList) {
         KateDocumentInfo *info = documentInfo(doc);
         if (info && !info->openSuccess) {
             documents.append(doc);
         }
     }
 
     closeDocuments(documents);
 }
 
 void KateDocManager::saveDocumentList(KConfig *config)
 {
     KConfigGroup openDocGroup(config, "Open Documents");
 
     openDocGroup.writeEntry("Count", m_docList.count());
 
     int i = 0;
     foreach(KTextEditor::Document * doc, m_docList) {
         KConfigGroup cg(config, QStringLiteral("Document %1").arg(i));
         doc->writeSessionConfig(cg);
         i++;
     }
 }
 
 void KateDocManager::restoreDocumentList(KConfig *config)
 {
     KConfigGroup openDocGroup(config, "Open Documents");
     unsigned int count = openDocGroup.readEntry("Count", 0);
 
     if (count == 0) {
         return;
     }
 
     QProgressDialog progress;
     progress.setWindowTitle(i18n("Starting Up"));
     progress.setLabelText(i18n("Reopening files from the last session..."));
     progress.setModal(true);
     progress.setCancelButton(nullptr);
     progress.setRange(0, count);
 
     for (unsigned int i = 0; i < count; i++) {
         KConfigGroup cg(config, QStringLiteral("Document %1").arg(i));
         KTextEditor::Document *doc = nullptr;
 
         if (i == 0) {
             doc = m_docList.first();
         } else {
             doc = createDoc();
         }
 
         connect(doc, SIGNAL(completed()), this, SLOT(documentOpened()));
         connect(doc, &KParts::ReadOnlyPart::canceled, this, &KateDocManager::documentOpened);
 
         doc->readSessionConfig(cg);
 
         progress.setValue(i);
     }
 }
 
 void KateDocManager::slotModifiedOnDisc(KTextEditor::Document *doc, bool b, KTextEditor::ModificationInterface::ModifiedOnDiskReason reason)
 {
     if (m_docInfos.contains(doc)) {
         m_docInfos[doc]->modifiedOnDisc = b;
         m_docInfos[doc]->modifiedOnDiscReason = reason;
         slotModChanged1(doc);
     }
 }
 
 /**
  * Load file's meta-information if the checksum didn't change since last time.
  */
 bool KateDocManager::loadMetaInfos(KTextEditor::Document *doc, const QUrl &url)
 {
     if (!m_saveMetaInfos) {
         return false;
     }
 
     if (!m_metaInfos.hasGroup(url.toDisplayString())) {
         return false;
     }
 
     const QByteArray checksum = doc->checksum().toHex();
     bool ok = true;
     if (!checksum.isEmpty()) {
         KConfigGroup urlGroup(&m_metaInfos, url.toDisplayString());
         const QString old_checksum = urlGroup.readEntry("Checksum");
 
         if (QString::fromLatin1(checksum) == old_checksum) {
             QSet<QString> flags;
             if (documentInfo(doc)->openedByUser) {
                 flags << QStringLiteral ("SkipEncoding");
             }
             flags << QStringLiteral ("SkipUrl");
             doc->readSessionConfig(urlGroup, flags);
         } else {
             urlGroup.deleteGroup();
             ok = false;
         }
 
         m_metaInfos.sync();
     }
 
     return ok && doc->url() == url;
 }
 
 /**
  * Save file's meta-information if doc is in 'unmodified' state
  */
 
 void KateDocManager::saveMetaInfos(const QList<KTextEditor::Document *> &documents)
 {
     /**
      * skip work if no meta infos wanted
      */
     if (!m_saveMetaInfos) {
         return;
     }
 
     /**
      * store meta info for all non-modified documents which have some checksum
      */
     const QDateTime now = QDateTime::currentDateTimeUtc();
     foreach(KTextEditor::Document * doc, documents) {
         /**
          * skip modified docs
          */
         if (doc->isModified()) {
             continue;
         }
 
         const QByteArray checksum = doc->checksum().toHex();
         if (!checksum.isEmpty()) {
 
             /**
              * write the group with checksum and time
              */
             KConfigGroup urlGroup(&m_metaInfos, doc->url().toString());
             urlGroup.writeEntry("Checksum", QString::fromLatin1(checksum));
             urlGroup.writeEntry("Time", now);
 
             /**
              * write document session config
              */
             doc->writeSessionConfig(urlGroup);
         }
     }
 
     /**
      * sync to not loose data
      */
     m_metaInfos.sync();
 }
 
 void KateDocManager::slotModChanged(KTextEditor::Document *doc)
 {
     QList<KTextEditor::Document *> documents;
     documents.append(doc);
     saveMetaInfos(documents);
 }
 
 void KateDocManager::slotModChanged1(KTextEditor::Document *doc)
 {
     QMetaObject::invokeMethod(KateApp::self()->activeKateMainWindow(), "queueModifiedOnDisc",
                                   Qt::QueuedConnection, Q_ARG(KTextEditor::Document *, doc));
 }
 
 void KateDocManager::documentOpened()
 {
     KColorScheme colors(QPalette::Active);
 
     KTextEditor::Document *doc = qobject_cast<KTextEditor::Document *>(sender());
     if (!doc) {
         return;    // should never happen, but who knows
     }
     disconnect(doc, SIGNAL(completed()), this, SLOT(documentOpened()));
     disconnect(doc, &KParts::ReadOnlyPart::canceled, this, &KateDocManager::documentOpened);
 
     // Only set "no success" when doc is empty to avoid close of files
     // with other trouble when do closeOrphaned()
     if (doc->openingError() && doc->isEmpty()) {
         KateDocumentInfo *info = documentInfo(doc);
         if (info) {
             info->openSuccess = false;
         }
     }
 }
diff --git a/kate/katedocmanager.h b/kate/katedocmanager.h
index 0074179d0..d37e30b6b 100644
--- a/kate/katedocmanager.h
+++ b/kate/katedocmanager.h
@@ -1,214 +1,214 @@
 /* This file is part of the KDE project
    Copyright (C) 2001 Christoph Cullmann <cullmann@kde.org>
    Copyright (C) 2002 Joseph Wenninger <jowenn@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef __KATE_DOCMANAGER_H__
 #define __KATE_DOCMANAGER_H__
 
 #include <ktexteditor/document.h>
 #include <ktexteditor/editor.h>
 #include <ktexteditor/modificationinterface.h>
 
 #include <QList>
 #include <QObject>
 #include <QByteArray>
 #include <QHash>
 #include <QMap>
 #include <QPair>
 #include <QDateTime>
 
 #include <KConfig>
 
 class KateMainWindow;
 
 class KateDocumentInfo
 {
 public:
     enum CustomRoles {RestoreOpeningFailedRole };
 
 public:
     KateDocumentInfo() = default;
 
     bool modifiedOnDisc = false;
     KTextEditor::ModificationInterface::ModifiedOnDiskReason modifiedOnDiscReason = KTextEditor::ModificationInterface::OnDiskUnmodified;
 
     bool openedByUser = false;
     bool openSuccess = true;
 };
 
 class KateDocManager : public QObject
 {
     Q_OBJECT
 
 public:
     KateDocManager(QObject *parent);
     ~KateDocManager() override;
 
     KTextEditor::Document *createDoc(const KateDocumentInfo &docInfo = KateDocumentInfo());
 
     KateDocumentInfo *documentInfo(KTextEditor::Document *doc);
 
     /** Returns the documentNumber of the doc with url URL or -1 if no such doc is found */
     KTextEditor::Document *findDocument(const QUrl &url) const;
 
     const QList<KTextEditor::Document *> &documentList() const {
         return m_docList;
     }
 
     KTextEditor::Document *openUrl(const QUrl &,
                                    const QString &encoding = QString(),
                                    bool isTempFile = false,
                                    const KateDocumentInfo &docInfo = KateDocumentInfo());
 
     QList<KTextEditor::Document *> openUrls(const QList<QUrl> &,
                                             const QString &encoding = QString(),
                                             bool isTempFile = false,
                                             const KateDocumentInfo &docInfo = KateDocumentInfo());
 
     bool closeDocument(KTextEditor::Document *, bool closeUrl = true);
     bool closeDocuments(const QList<KTextEditor::Document *> &documents, bool closeUrl = true);
-    bool closeDocumentList(QList<KTextEditor::Document *> documents);
+    bool closeDocumentList(const QList<KTextEditor::Document *>& documents);
     bool closeAllDocuments(bool closeUrl = true);
     bool closeOtherDocuments(KTextEditor::Document *);
 
     QList<KTextEditor::Document *> modifiedDocumentList();
     bool queryCloseDocuments(KateMainWindow *w);
 
     void saveDocumentList(KConfig *config);
     void restoreDocumentList(KConfig *config);
 
     inline bool getSaveMetaInfos() {
         return m_saveMetaInfos;
     }
     inline void setSaveMetaInfos(bool b) {
         m_saveMetaInfos = b;
     }
 
     inline int getDaysMetaInfos() {
         return m_daysMetaInfos;
     }
     inline void setDaysMetaInfos(int i) {
         m_daysMetaInfos = i;
     }
 
 public Q_SLOTS:
     /**
      * saves all documents that has at least one view.
      * documents with no views are ignored :P
      */
     void saveAll();
 
     /**
      * reloads all documents that has at least one view.
      * documents with no views are ignored :P
      */
     void reloadAll();
 
     /**
      * close all documents, which could not be reopened
      */
     void closeOrphaned();
 
     /**
      * save selected documents from the File List
      */
     void saveSelected(const QList<KTextEditor::Document *> &);
 
 Q_SIGNALS:
     /**
      * This signal is emitted when the \p document was created.
      */
     void documentCreated(KTextEditor::Document *document);
 
     /**
      * This signal is emitted when the \p document was created.
      * This is emitted after the initial documentCreated for internal use in view manager
      */
     void documentCreatedViewManager(KTextEditor::Document *document);
 
     /**
      * This signal is emitted before a \p document which should be closed is deleted
      * The document is still accessible and usable, but it will be deleted
      * after this signal was send.
      *
      * @param document document that will be deleted
      */
     void documentWillBeDeleted(KTextEditor::Document *document);
 
     /**
      * This signal is emitted when the \p document has been deleted.
      *
      *  Warning !!! DO NOT ACCESS THE DATA REFERENCED BY THE POINTER, IT IS ALREADY INVALID
      *  Use the pointer only to remove mappings in hash or maps
      */
     void documentDeleted(KTextEditor::Document *document);
 
     /**
      * This signal is emitted before the batch of documents is being created.
      *
      * You can use it to pause some updates.
      */
     void aboutToCreateDocuments();
 
     /**
      * This signal is emitted after the batch of documents is created.
      *
      * @param documents list of documents that have been created
      */
     void documentsCreated(const QList<KTextEditor::Document *> &documents);
 
     /**
      * This signal is emitted before the documents batch is going to be deleted
      *
      * note that the batch can be interrupted in the middle and only some
      * of the documents may be actually deleted. See documentsDeleted() signal.
      */
     void aboutToDeleteDocuments(const QList<KTextEditor::Document *> &);
 
     /**
      * This signal is emitted after the documents batch was deleted
      *
      * This is the batch closing signal for aboutToDeleteDocuments
      * @param documents the documents that weren't deleted after all
      */
     void documentsDeleted(const QList<KTextEditor::Document *> &documents);
 
 private Q_SLOTS:
     void slotModifiedOnDisc(KTextEditor::Document *doc, bool b, KTextEditor::ModificationInterface::ModifiedOnDiskReason reason);
     void slotModChanged(KTextEditor::Document *doc);
     void slotModChanged1(KTextEditor::Document *doc);
 
 private:
     bool loadMetaInfos(KTextEditor::Document *doc, const QUrl &url);
     void saveMetaInfos(const QList<KTextEditor::Document *> &docs);
 
     QList<KTextEditor::Document *> m_docList;
     QHash<KTextEditor::Document *, KateDocumentInfo *> m_docInfos;
 
     KConfig m_metaInfos;
     bool m_saveMetaInfos;
     int m_daysMetaInfos;
 
     typedef QPair<QUrl, QDateTime> TPair;
     QMap<KTextEditor::Document *, TPair> m_tempFiles;
 
 private Q_SLOTS:
     void documentOpened();
 };
 
 #endif
diff --git a/kate/katesavemodifieddialog.cpp b/kate/katesavemodifieddialog.cpp
index 9137f19f8..d20c8092e 100644
--- a/kate/katesavemodifieddialog.cpp
+++ b/kate/katesavemodifieddialog.cpp
@@ -1,246 +1,246 @@
 /* This file is part of the KDE project
    Copyright (C) 2004 Joseph Wenninger <jowenn@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "katesavemodifieddialog.h"
 
 #include "katedebug.h"
 
 #include <KGuiItem>
 #include <KStandardGuiItem>
 #include <KMessageBox>
 #include <KLocalizedString>
 
 #include <QLabel>
 #include <QPushButton>
 #include <QTreeWidget>
 #include <QVBoxLayout>
 #include <QFileDialog>
 
 class AbstractKateSaveModifiedDialogCheckListItem: public QTreeWidgetItem
 {
 public:
     AbstractKateSaveModifiedDialogCheckListItem(const QString &title, const QString &url): QTreeWidgetItem() {
         setFlags(flags() | Qt::ItemIsUserCheckable);
         setText(0, title);
         setText(1, url);
         setCheckState(0, Qt::Checked);
         setState(InitialState);
     }
     ~AbstractKateSaveModifiedDialogCheckListItem() override
     {}
     virtual bool synchronousSave(QWidget *dialogParent) = 0;
     enum STATE {InitialState, SaveOKState, SaveFailedState};
     STATE state() const {
         return m_state;
     }
     void setState(enum STATE state) {
         m_state = state;
         switch (state) {
         case InitialState:
             setIcon(0, QIcon());
             break;
         case SaveOKState:
             setIcon(0, QIcon::fromTheme(QStringLiteral("dialog-ok")));
             // QStringLiteral("ok") icon should probably be QStringLiteral("dialog-success"), but we don't have that icon in KDE 4.0
             break;
         case SaveFailedState:
             setIcon(0, QIcon::fromTheme(QStringLiteral("dialog-error")));
             break;
         }
     }
 private:
     STATE m_state;
 };
 
 class KateSaveModifiedDocumentCheckListItem: public AbstractKateSaveModifiedDialogCheckListItem
 {
 public:
     KateSaveModifiedDocumentCheckListItem(KTextEditor::Document *document)
         : AbstractKateSaveModifiedDialogCheckListItem(document->documentName(), document->url().toString()) {
         m_document = document;
     }
     ~KateSaveModifiedDocumentCheckListItem() override
     {}
     bool synchronousSave(QWidget *dialogParent) override {
         if (m_document->url().isEmpty()) {
             const QUrl url = QFileDialog::getSaveFileUrl(dialogParent, i18n("Save As (%1)", m_document->documentName()));
             if (!url.isEmpty()) {
                 if (!m_document->saveAs(url)) {
                     setState(SaveFailedState);
                     setText(1, m_document->url().toString());
                     return false;
                 } else {
                     bool sc = m_document->waitSaveComplete();
                     setText(1, m_document->url().toString());
                     if (!sc) {
                         setState(SaveFailedState);
                         return false;
                     } else {
                         setState(SaveOKState);
                         return true;
                     }
                 }
             } else {
                 //setState(SaveFailedState);
                 return false;
             }
         } else {
             //document has an existing location
             if (!m_document->save()) {
                 setState(SaveFailedState);
                 setText(1, m_document->url().toString());
                 return false;
             } else {
                 bool sc = m_document->waitSaveComplete();
                 setText(1, m_document->url().toString());
                 if (!sc) {
                     setState(SaveFailedState);
                     return false;
                 } else {
                     setState(SaveOKState);
                     return true;
                 }
             }
 
         }
 
         return false;
 
     }
 private:
     KTextEditor::Document *m_document;
 };
 
-KateSaveModifiedDialog::KateSaveModifiedDialog(QWidget *parent, QList<KTextEditor::Document *> documents):
+KateSaveModifiedDialog::KateSaveModifiedDialog(QWidget *parent, const QList<KTextEditor::Document *>& documents):
     QDialog(parent)
 {
     setWindowTitle(i18n("Save Documents"));
     setObjectName(QStringLiteral("KateSaveModifiedDialog"));
     setModal(true);
 
     QVBoxLayout *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     // label
     QLabel *lbl = new QLabel(i18n("<qt>The following documents have been modified. Do you want to save them before closing?</qt>"), this);
     mainLayout->addWidget(lbl);
 
     // main view
     m_list = new QTreeWidget(this);
     mainLayout->addWidget(m_list);
     m_list->setColumnCount(2);
     m_list->setHeaderLabels(QStringList() << i18n("Documents") << i18n("Location"));
     m_list->setRootIsDecorated(true);
 
     foreach(KTextEditor::Document * doc, documents) {
         m_list->addTopLevelItem(new KateSaveModifiedDocumentCheckListItem(doc));
     }
     m_list->resizeColumnToContents(0);
 
     connect(m_list, &QTreeWidget::itemChanged, this, &KateSaveModifiedDialog::slotItemActivated);
 
     QPushButton *selectAllButton = new QPushButton(i18n("Se&lect All"), this);
     mainLayout->addWidget(selectAllButton);
     connect(selectAllButton, &QPushButton::clicked, this, &KateSaveModifiedDialog::slotSelectAll);
 
     // dialog buttons
     QDialogButtonBox *buttons = new QDialogButtonBox(this);
     mainLayout->addWidget(buttons);
 
     m_saveButton = new QPushButton;
     KGuiItem::assign(m_saveButton, KStandardGuiItem::save());
     buttons->addButton(m_saveButton, QDialogButtonBox::YesRole);
     connect(m_saveButton, &QPushButton::clicked, this, &KateSaveModifiedDialog::slotSaveSelected);
 
     QPushButton *discardButton = new QPushButton;
     KGuiItem::assign(discardButton, KStandardGuiItem::discard());
     buttons->addButton(discardButton, QDialogButtonBox::NoRole);
     connect(discardButton, &QPushButton::clicked, this, &KateSaveModifiedDialog::slotDoNotSave);
 
     QPushButton *cancelButton = new QPushButton;
     KGuiItem::assign(cancelButton, KStandardGuiItem::cancel());
     cancelButton->setDefault(true);
     cancelButton->setFocus();
     buttons->addButton(cancelButton, QDialogButtonBox::RejectRole);
     connect(cancelButton, &QPushButton::clicked, this, &KateSaveModifiedDialog::reject);
 }
 
 KateSaveModifiedDialog::~KateSaveModifiedDialog()
 {}
 
 void KateSaveModifiedDialog::slotItemActivated(QTreeWidgetItem *, int)
 {
     bool enableSaveButton = false;
 
     for (int i = 0; i < m_list->topLevelItemCount(); ++i) {
         if (m_list->topLevelItem(i)->checkState(0) == Qt::Checked) {
             enableSaveButton = true;
             break;
         }
     }
 
     m_saveButton->setEnabled(enableSaveButton);
 }
 
 void KateSaveModifiedDialog::slotSelectAll()
 {
     for (int i = 0; i < m_list->topLevelItemCount(); ++i) {
         m_list->topLevelItem(i)->setCheckState(0, Qt::Checked);
     }
 
     m_saveButton->setEnabled(true);
 }
 
 void KateSaveModifiedDialog::slotSaveSelected()
 {
     if (doSave()) {
         done(QDialog::Accepted);
     }
 }
 
 void KateSaveModifiedDialog::slotDoNotSave()
 {
     done(QDialog::Accepted);
 }
 
 bool KateSaveModifiedDialog::doSave()
 {
     for (int i = 0; i < m_list->topLevelItemCount(); ++i) {
         AbstractKateSaveModifiedDialogCheckListItem *cit = static_cast<AbstractKateSaveModifiedDialogCheckListItem *>(m_list->topLevelItem(i));
 
         if (cit->checkState(0) == Qt::Checked && (cit->state() != AbstractKateSaveModifiedDialogCheckListItem::SaveOKState)) {
             if (!cit->synchronousSave(this /*perhaps that should be the kate mainwindow*/)) {
                 if (cit->state() == AbstractKateSaveModifiedDialogCheckListItem::SaveFailedState) {
                     KMessageBox::sorry(this, i18n("Data you requested to be saved could not be written. Please choose how you want to proceed."));
                 }
                 return false;
             }
         } else if ((cit->checkState(0) != Qt::Checked) && (cit->state() == AbstractKateSaveModifiedDialogCheckListItem::SaveFailedState)) {
             cit->setState(AbstractKateSaveModifiedDialogCheckListItem::InitialState);
         }
     }
 
     return true;
 }
 
 bool KateSaveModifiedDialog::queryClose(QWidget *parent, const QList<KTextEditor::Document *> &documents)
 {
     KateSaveModifiedDialog d(parent, documents);
     return (d.exec() != QDialog::Rejected);
 }
 
diff --git a/kate/katesavemodifieddialog.h b/kate/katesavemodifieddialog.h
index 6cbc01e4a..06a7f6431 100644
--- a/kate/katesavemodifieddialog.h
+++ b/kate/katesavemodifieddialog.h
@@ -1,54 +1,54 @@
 /* This file is part of the KDE project
    Copyright (C) 2004 Joseph Wenninger <jowenn@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef _KATE_SAVE_MODIFIED_DIALOG_
 #define _KATE_SAVE_MODIFIED_DIALOG_
 
 #include <ktexteditor/document.h>
 
 #include <QList>
 #include <QDialog>
 
 class QTreeWidget;
 class QTreeWidgetItem;
 class QPushButton;
 
 class KateSaveModifiedDialog: public QDialog
 {
     Q_OBJECT
 public:
-    KateSaveModifiedDialog(QWidget *parent, QList<KTextEditor::Document *> documents);
+    KateSaveModifiedDialog(QWidget *parent, const QList<KTextEditor::Document *>& documents);
     ~KateSaveModifiedDialog() override;
     static bool queryClose(QWidget *parent, const QList<KTextEditor::Document *> &documents);
 protected:
     bool doSave();
 protected Q_SLOTS:
     void slotSelectAll();
     void slotItemActivated(QTreeWidgetItem *, int);
     void slotSaveSelected();
     void slotDoNotSave();
 
 private:
     QTreeWidgetItem *m_documentRoot;
     QTreeWidget *m_list;
     QPushButton *m_saveButton;
 };
 
 #endif
 
diff --git a/kate/session/katesessionmanagedialog.cpp b/kate/session/katesessionmanagedialog.cpp
index 089a21d08..fac711298 100644
--- a/kate/session/katesessionmanagedialog.cpp
+++ b/kate/session/katesessionmanagedialog.cpp
@@ -1,508 +1,508 @@
 /* This file is part of the KDE project
  *
  *  Copyright (C) 2005 Christoph Cullmann <cullmann@kde.org>
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #include "katesessionmanagedialog.h"
 
 #include "kateapp.h"
 #include "katesessionchooseritem.h"
 #include "katesessionmanager.h"
 
 #include <KColorScheme>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <KStandardGuiItem>
 
 #include <QInputDialog>
 
 KateSessionManageDialog::KateSessionManageDialog(QWidget *parent)
     : QDialog(parent)
 {
     setupUi(this);
     setWindowTitle(i18n("Manage Sessions"));
     m_dontAskCheckBox->hide();
 
     m_sessionList->installEventFilter(this);
     connect(m_sessionList, &QTreeWidget::currentItemChanged, this, &KateSessionManageDialog::selectionChanged);
     connect(m_sessionList, &QTreeWidget::itemDoubleClicked, this, &KateSessionManageDialog::openSession);
     m_sessionList->header()->moveSection(0, 1); // Re-order columns to "Files, Sessions"
 
     m_filterBox->installEventFilter(this);
     connect(m_filterBox, &QLineEdit::textChanged, this, &KateSessionManageDialog::filterChanged);
     connect(m_sortButton, &QPushButton::clicked, this, &KateSessionManageDialog::changeSortOrder);
 
     connect(m_newButton, &QPushButton::clicked, this, &KateSessionManageDialog::openNewSession);
 
     KGuiItem::assign(m_openButton, KStandardGuiItem::open());
     m_openButton->setDefault(true);
     connect(m_openButton, &QPushButton::clicked, this, &KateSessionManageDialog::openSession);
 
     connect(m_templateButton, &QPushButton::clicked, this, &KateSessionManageDialog::openSessionAsTemplate);
 
     connect(m_copyButton, &QPushButton::clicked, this, &KateSessionManageDialog::copySession);
 
     connect(m_renameButton, &QPushButton::clicked, this, &KateSessionManageDialog::editBegin);
 
     connect(m_deleteButton, &QPushButton::clicked, this, &KateSessionManageDialog::updateDeleteList);
 
     KGuiItem::assign(m_closeButton, KStandardGuiItem::close());
     connect(m_closeButton, &QPushButton::clicked, this, &KateSessionManageDialog::closeDialog);
 
     connect(KateApp::self()->sessionManager(), &KateSessionManager::sessionListChanged, this, &KateSessionManageDialog::updateSessionList);
 
     changeSortOrder(); // Set order to SortAlphabetical, set button text and fill session list
 }
 
 
 KateSessionManageDialog::KateSessionManageDialog(QWidget *parent, const QString &lastSession)
     : KateSessionManageDialog(parent)
 {
     setWindowTitle(i18n("Session Chooser"));
     m_dontAskCheckBox->show();
     m_chooserMode = true;
     connect(m_dontAskCheckBox, &QCheckBox::toggled, this, &KateSessionManageDialog::dontAskToggled);
 
     m_prefferedSession = lastSession;
     changeSortOrder(); // Set order to SortChronological
 }
 
 
 KateSessionManageDialog::~KateSessionManageDialog()
 {}
 
 
 void KateSessionManageDialog::dontAskToggled()
 {
     m_templateButton->setEnabled(!m_dontAskCheckBox->isChecked());
 }
 
 
 void KateSessionManageDialog::changeSortOrder()
 {
     switch (m_sortOrder) {
         case SortAlphabetical:
             m_sortOrder = SortChronological;
             m_sortButton->setText(i18n("Sort Alphabetical"));
             //m_sortButton->setIcon(QIcon::fromTheme(QStringLiteral("FIXME")));
             break;
         case SortChronological:
             m_sortOrder = SortAlphabetical;
             m_sortButton->setText(i18n("Sort Last Used"));
             //m_sortButton->setIcon(QIcon::fromTheme(QStringLiteral("FIXME")));
             break;
     }
 
     updateSessionList();
 }
 
 
 void KateSessionManageDialog::filterChanged()
 {
     static QPointer<QTimer> delay;
 
     if (!delay) {
         delay = new QTimer(this); // Should be auto cleard by Qt when we die
         delay->setSingleShot(true);
         delay->setInterval(400);
         connect(delay, &QTimer::timeout, this, &KateSessionManageDialog::updateSessionList);
     }
 
     delay->start();
 }
 
 
 void KateSessionManageDialog::done(int result)
 {
-    for (auto session : qAsConst(m_deleteList)) {
+    for (const auto& session : qAsConst(m_deleteList)) {
         KateApp::self()->sessionManager()->deleteSession(session);
     }
     m_deleteList.clear(); // May not needed, but anyway
 
     if (ResultQuit == result) {
         QDialog::done(0);
         return;
     }
 
     if (m_chooserMode && m_dontAskCheckBox->isChecked()) {
         // write back our nice boolean :)
         KConfigGroup generalConfig(KSharedConfig::openConfig(), QStringLiteral("General"));
         switch (result) {
         case ResultOpen:
             generalConfig.writeEntry("Startup Session", "last");
             break;
         case ResultNew:
             generalConfig.writeEntry("Startup Session", "new");
             break;
         default:
             break;
         }
         generalConfig.sync();
     }
 
     QDialog::done(1);
 }
 
 
 void KateSessionManageDialog::selectionChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
 {
     Q_UNUSED(previous);
 
     if (m_editByUser) {
         editDone(); // Field was left unchanged, no need to apply
         return;
     }
 
     if (!current) {
         m_openButton->setEnabled(false);
         m_templateButton->setEnabled(false);
         m_copyButton->setEnabled(false);
         m_renameButton->setEnabled(false);
         m_deleteButton->setEnabled(false);
         return;
     }
 
     const KateSession::Ptr activeSession = KateApp::self()->sessionManager()->activeSession();
     const bool notActiveSession = !KateApp::self()->sessionManager()->sessionIsActive(currentSelectedSession()->name());
 
     m_deleteButton->setEnabled(notActiveSession);
 
     if (m_deleteList.contains(currentSelectedSession())) {
         m_deleteButton->setText(i18n("Restore"));
         m_openButton->setEnabled(false);
         m_templateButton->setEnabled(false);
         m_copyButton->setEnabled(true); // Looks a little strange but is OK
         m_renameButton->setEnabled(false);
     } else {
         KGuiItem::assign(m_deleteButton, KStandardGuiItem::del());
         m_openButton->setEnabled(currentSelectedSession() != activeSession);
         m_templateButton->setEnabled(true);
         m_copyButton->setEnabled(true);
         m_renameButton->setEnabled(true);
     }
 }
 
 
 void KateSessionManageDialog::disableButtons()
 {
     m_openButton->setEnabled(false);
     m_newButton->setEnabled(false);
     m_templateButton->setEnabled(false);
     m_dontAskCheckBox->setEnabled(false);
     m_copyButton->setEnabled(false);
     m_renameButton->setEnabled(false);
     m_deleteButton->setEnabled(false);
     m_closeButton->setEnabled(false);
     m_sortButton->setEnabled(false);
     m_filterBox->setEnabled(false);
 }
 
 
 void KateSessionManageDialog::editBegin()
 {
     if (m_editByUser) {
         return;
     }
 
     KateSessionChooserItem *item = currentSessionItem();
 
     if (!item) {
         return;
     }
 
     disableButtons();
 
     item->setFlags(item->flags() | Qt::ItemIsEditable);
     m_sessionList->clearSelection();
     m_sessionList->editItem(item, 0);
 
     // Always apply changes user did, like Dolphin
     connect(m_sessionList, &QTreeWidget::itemChanged, this, &KateSessionManageDialog::editApply);
     connect(m_sessionList->itemWidget(item, 0), &QObject::destroyed, this, &KateSessionManageDialog::editApply);
 
     m_editByUser = item; // Do it last to block eventFilter() actions until we are ready
 }
 
 
 void KateSessionManageDialog::editDone()
 {
     m_editByUser = nullptr;
     disconnect(m_sessionList, &QTreeWidget::itemChanged, this, &KateSessionManageDialog::editApply);
     updateSessionList();
 
     m_newButton->setEnabled(true);
     m_dontAskCheckBox->setEnabled(true);
     m_closeButton->setEnabled(true);
     m_sortButton->setEnabled(true);
     m_filterBox->setEnabled(true);
 
     m_sessionList->setFocus();
 }
 
 
 void KateSessionManageDialog::editApply()
 {
     if (!m_editByUser) {
         return;
     }
 
     KateApp::self()->sessionManager()->renameSession(m_editByUser->session, m_editByUser->text(0));
     editDone();
 }
 
 
 void KateSessionManageDialog::copySession()
 {
     KateSessionChooserItem *item = currentSessionItem();
 
     if (!item) {
         return;
     }
 
     m_prefferedSession = KateApp::self()->sessionManager()->copySession(item->session);
     m_sessionList->setFocus(); // Only needed when user abort
 }
 
 
 void KateSessionManageDialog::openSession()
 {
     KateSessionChooserItem *item = currentSessionItem();
 
     if (!item) {
         return;
     }
 
     hide();
 
     // this might fail, e.g. if session is in use, then e.g. end kate, bug 390740
     const bool success = KateApp::self()->sessionManager()->activateSession(item->session);
     done(success ? ResultOpen : ResultQuit);
 }
 
 
 void KateSessionManageDialog::openSessionAsTemplate()
 {
     KateSessionChooserItem *item = currentSessionItem();
 
     if (!item) {
         return;
     }
 
     hide();
 
     KateSessionManager *sm = KateApp::self()->sessionManager();
     KateSession::Ptr ns = KateSession::createAnonymousFrom(item->session, sm->anonymousSessionFile());
     sm->activateSession(ns);
 
     done(ResultOpen);
 }
 
 
 void KateSessionManageDialog::openNewSession()
 {
     hide();
     KateApp::self()->sessionManager()->sessionNew();
     done(ResultNew);
 }
 
 
 void KateSessionManageDialog::updateDeleteList()
 {
     KateSessionChooserItem *item = currentSessionItem();
 
     if (!item) {
         return;
     }
 
     const KateSession::Ptr session = item->session;
     if (m_deleteList.contains(session)) {
         m_deleteList.remove(session);
         item->setForeground(0, QBrush(KColorScheme(QPalette::Active).foreground(KColorScheme::NormalText).color()));
         item->setIcon(0, QIcon());
         item->setToolTip(0, QString());
     } else {
         m_deleteList.insert(session);
         markItemAsToBeDeleted(item);
     }
 
     // To ease multiple deletions, move the selection
     QTreeWidgetItem *newItem = m_sessionList->itemBelow(item) ? m_sessionList->itemBelow(item) : m_sessionList->topLevelItem(0);
     m_sessionList->setCurrentItem(newItem);
     m_sessionList->setFocus();
 }
 
 
 void KateSessionManageDialog::markItemAsToBeDeleted(QTreeWidgetItem *item)
 {
     item->setForeground(0, QBrush(KColorScheme(QPalette::Active).foreground(KColorScheme::InactiveText).color()));
     item->setIcon(0, QIcon::fromTheme(QStringLiteral("emblem-warning")));
     item->setToolTip(0, i18n("Session will be deleted on dialog close"));
 }
 
 
 void KateSessionManageDialog::closeDialog()
 {
     done(ResultQuit);
 }
 
 
 void KateSessionManageDialog::updateSessionList()
 {
     if (m_editByUser) {
         // Don't crash accidentally an ongoing edit
         return;
     }
 
     KateSession::Ptr currSelSession = currentSelectedSession();
     KateSession::Ptr activeSession = KateApp::self()->sessionManager()->activeSession();
 
     m_sessionList->clear();
 
     KateSessionList slist = KateApp::self()->sessionManager()->sessionList();
     switch (m_sortOrder) {
         case SortAlphabetical: std::sort (slist.begin(), slist.end(), KateSession::compareByName); break;
         case SortChronological: std::sort (slist.begin(), slist.end(), KateSession::compareByTimeDesc); break;
     }
 
     KateSessionChooserItem *prefferedItem = nullptr;
     KateSessionChooserItem *currSessionItem = nullptr;
     KateSessionChooserItem *activeSessionItem= nullptr;
 
     for (const KateSession::Ptr &session : qAsConst(slist)) {
         if (!m_filterBox->text().isEmpty()) {
             if (!session->name().contains(m_filterBox->text(), Qt::CaseInsensitive)) {
                 continue;
             }
         }
 
         KateSessionChooserItem *item = new KateSessionChooserItem(m_sessionList, session);
         if (session == currSelSession) {
             currSessionItem = item;
         } else if (session == activeSession) {
             activeSessionItem = item;
         } else if (session->name() == m_prefferedSession) {
             prefferedItem = item;
             m_prefferedSession.clear();
         }
 
         if (m_deleteList.contains(session)) {
             markItemAsToBeDeleted(item);
         }
     }
 
     m_sessionList->resizeColumnToContents(1); // Minimize "Files" column
 
     if (!prefferedItem) {
         prefferedItem = currSessionItem ? currSessionItem : activeSessionItem;
     }
 
     if (prefferedItem) {
         m_sessionList->setCurrentItem(prefferedItem);
         m_sessionList->scrollToItem(prefferedItem);
     } else if (m_sessionList->topLevelItemCount() > 0) {
         m_sessionList->setCurrentItem(m_sessionList->topLevelItem(0));
     }
 
     if (m_filterBox->hasFocus()){
         return;
     }
 
     if (m_sessionList->topLevelItemCount() == 0) {
         m_newButton->setFocus();
     } else {
         m_sessionList->setFocus();
     }
 }
 
 
 KateSessionChooserItem *KateSessionManageDialog::currentSessionItem() const
 {
     return static_cast<KateSessionChooserItem *>(m_sessionList->currentItem());
 }
 
 
 KateSession::Ptr KateSessionManageDialog::currentSelectedSession() const
 {
     KateSessionChooserItem *item = currentSessionItem();
 
     if (!item) {
         return KateSession::Ptr();
     }
 
     return item->session;
 }
 
 
 bool KateSessionManageDialog::eventFilter(QObject *object, QEvent *event)
 {
     QKeyEvent *ke = static_cast<QKeyEvent*>(event);
 
     if (object == m_sessionList) {
         if (!m_editByUser) { // No need for further action
             return false;
         }
 
         if (event->type() == QEvent::KeyPress) {
             switch (ke->key()) {
                 // Avoid to apply changes with untypical keys/don't left edit field this way
                 case Qt::Key_Up :
                 case Qt::Key_Down :
                 case Qt::Key_PageUp :
                 case Qt::Key_PageDown :
                     return true;
                 default:
                     break;
             }
 
         } else if (event->type() == QEvent::KeyRelease) {
             switch (ke->key()) {
                 case Qt::Key_Escape :
                     editDone(); // Abort edit
                     break;
                 case Qt::Key_Return :
                     editApply();
                     break;
                 default:
                     break;
             }
         }
 
     } else if (object == m_filterBox) {
         // Catch Return key to avoid to finish the dialog
         if (event->type() == QEvent::KeyPress && (ke->key() == Qt::Key_Return || ke->key() == Qt::Key_Enter)) {
             updateSessionList();
             m_sessionList->setFocus();
             return true;
         }
     }
 
     return false;
 }
 
 
 void KateSessionManageDialog::closeEvent(QCloseEvent *event)
 {
     Q_UNUSED(event);
 
     if (m_editByUser) {
         // We must catch closeEvent here due to connected signal of QLineEdit::destroyed->editApply()->crash!
         editDone(); // editApply() don't work, m_editByUser->text(0) will not updated from QLineEdit
     }
 }
diff --git a/kate/session/katesessionmanager.cpp b/kate/session/katesessionmanager.cpp
index 55751f65e..43c055a68 100644
--- a/kate/session/katesessionmanager.cpp
+++ b/kate/session/katesessionmanager.cpp
@@ -1,651 +1,651 @@
 /* This file is part of the KDE project
  *
  *  Copyright (C) 2005 Christoph Cullmann <cullmann@kde.org>
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  */
 
 #include "katesessionmanager.h"
 
 #include "katesessionmanagedialog.h"
 
 #include "kateapp.h"
 #include "katepluginmanager.h"
 #include "katerunninginstanceinfo.h"
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KIO/CopyJob>
 #include <KDesktopFile>
 #include <KDirWatch>
 #include <KService>
 #include <KShell>
 
 #include <QApplication>
 #include <QCryptographicHash>
 #include <QDir>
 #include <QInputDialog>
 #include <QScopedPointer>
 #include <QUrl>
 
 #ifndef Q_OS_WIN
 #include <unistd.h>
 #endif
 
 //BEGIN KateSessionManager
 
 KateSessionManager::KateSessionManager(QObject *parent, const QString &sessionsDir)
     : QObject(parent)
 {
     if (sessionsDir.isEmpty()) {
         m_sessionsDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QStringLiteral("/kate/sessions");
     } else {
         m_sessionsDir = sessionsDir;
     }
 
     // create dir if needed
     QDir().mkpath(m_sessionsDir);
 
     m_dirWatch = new KDirWatch(this);
     m_dirWatch->addDir(m_sessionsDir);
     connect(m_dirWatch, &KDirWatch::dirty, this, &KateSessionManager::updateSessionList);
 
     updateSessionList();
 }
 
 KateSessionManager::~KateSessionManager()
 {
     delete m_dirWatch;
 }
 
 void KateSessionManager::updateSessionList()
 {
     QStringList list;
 
     // Let's get a list of all session we have atm
     QDir dir(m_sessionsDir, QStringLiteral("*.katesession"), QDir::Time);
 
     for (unsigned int i = 0; i < dir.count(); ++i) {
         QString name = dir[i];
         name.chop(12); // .katesession
         list << QUrl::fromPercentEncoding(name.toLatin1());
     }
 
     // write jump list actions to disk in the kate.desktop file
     updateJumpListActions(list);
 
     bool changed = false;
 
     // Add new sessions to our list
-    for (const QString session : qAsConst(list)) {
+    for (const QString& session : qAsConst(list)) {
         if (!m_sessions.contains(session)) {
             const QString file = sessionFileForName(session);
             m_sessions.insert(session, KateSession::create(file, session));
             changed = true;
         }
     }
     // Remove gone sessions from our list
-    for (const QString session : m_sessions.keys()) {
+    for (const QString& session : m_sessions.keys()) {
         if ((list.indexOf(session) < 0) && (m_sessions.value(session) != activeSession())) {
             m_sessions.remove(session);
             changed = true;
         }
     }
 
     if (changed) {
         emit sessionListChanged();
     }
 }
 
 bool KateSessionManager::activateSession(KateSession::Ptr session,
         const bool closeAndSaveLast,
         const bool loadNew)
 {
     if (activeSession() == session) {
         return true;
     }
 
     if (!session->isAnonymous()) {
         //check if the requested session is already open in another instance
         KateRunningInstanceMap instances;
         if (!fillinRunningKateAppInstances(&instances)) {
             KMessageBox::error(nullptr, i18n("Internal error: there is more than one instance open for a given session."));
             return false;
         }
 
         if (instances.contains(session->name())) {
             if (KMessageBox::questionYesNo(nullptr, i18n("Session '%1' is already opened in another kate instance, change there instead of reopening?", session->name()),
                                            QString(), KStandardGuiItem::yes(), KStandardGuiItem::no(), QStringLiteral("katesessionmanager_switch_instance")) == KMessageBox::Yes) {
                 instances[session->name()]->dbus_if->call(QStringLiteral("activate"));
                 cleanupRunningKateAppInstanceMap(&instances);
                 return false;
             }
         }
 
         cleanupRunningKateAppInstanceMap(&instances);
     }
     // try to close and save last session
     if (closeAndSaveLast) {
         if (KateApp::self()->activeKateMainWindow()) {
             if (!KateApp::self()->activeKateMainWindow()->queryClose_internal()) {
                 return true;
             }
         }
 
         // save last session or not?
         saveActiveSession();
 
         // really close last
         KateApp::self()->documentManager()->closeAllDocuments();
     }
 
     // set the new session
     m_activeSession = session;
 
     // there is one case in which we don't want the restoration and that is
     // when restoring session from session manager.
     // In that case the restore is handled by the caller
     if (loadNew) {
         loadSession(session);
     }
 
     emit sessionChanged();
     return true;
 }
 
 void KateSessionManager::loadSession(const KateSession::Ptr &session) const
 {
     // open the new session
     KSharedConfigPtr sharedConfig = KSharedConfig::openConfig();
     KConfig *sc = session->config();
     const bool loadDocs = !session->isAnonymous(); // do not load docs for new sessions
 
     // if we have no session config object, try to load the default
     // (anonymous/unnamed sessions)
     // load plugin config + plugins
     KateApp::self()->pluginManager()->loadConfig(sc);
 
     if (loadDocs) {
         KateApp::self()->documentManager()->restoreDocumentList(sc);
     }
 
     // window config
     KConfigGroup c(sharedConfig, "General");
 
     KConfig *cfg = sc;
     bool delete_cfg = false;
     // a new, named session, read settings of the default session.
     if (! sc->hasGroup("Open MainWindows")) {
         delete_cfg = true;
         cfg = new KConfig(anonymousSessionFile(), KConfig::SimpleConfig);
     }
 
     if (c.readEntry("Restore Window Configuration", true)) {
         int wCount = cfg->group("Open MainWindows").readEntry("Count", 1);
 
         for (int i = 0; i < wCount; ++i) {
             if (i >= KateApp::self()->mainWindowsCount()) {
                 KateApp::self()->newMainWindow(cfg, QStringLiteral("MainWindow%1").arg(i));
             } else {
                 KateApp::self()->mainWindow(i)->readProperties(KConfigGroup(cfg, QStringLiteral("MainWindow%1").arg(i)));
             }
 
             KateApp::self()->mainWindow(i)->restoreWindowConfig(KConfigGroup(cfg, QStringLiteral("MainWindow%1 Settings").arg(i)));
         }
 
         // remove mainwindows we need no longer...
         if (wCount > 0) {
             while (wCount < KateApp::self()->mainWindowsCount()) {
                 delete KateApp::self()->mainWindow(KateApp::self()->mainWindowsCount() - 1);
             }
         }
     } else {
         // load recent files for all existing windows, see bug 408499
         for (int i = 0; i < KateApp::self()->mainWindowsCount(); ++i) {
             KateApp::self()->mainWindow(i)->loadOpenRecent(cfg);
         }
     }
 
     // ensure we have at least one window, always! load recent files for it, too, see bug 408499
     if (KateApp::self()->mainWindowsCount() == 0) {
         auto w = KateApp::self()->newMainWindow();
         w->loadOpenRecent(cfg);
     }
 
     if (delete_cfg) {
         delete cfg;
     }
 
     // we shall always have some existing windows here!
     Q_ASSERT(KateApp::self()->mainWindowsCount() > 0);
 }
 
 bool KateSessionManager::activateSession(const QString &name, const bool closeAndSaveLast, const bool loadNew)
 {
     return activateSession(giveSession(name), closeAndSaveLast, loadNew);
 }
 
 bool KateSessionManager::activateAnonymousSession()
 {
     return activateSession(QString(), false);
 }
 
 KateSession::Ptr KateSessionManager::giveSession(const QString &name)
 {
     if (name.isEmpty()) {
         return KateSession::createAnonymous(anonymousSessionFile());
     }
 
     if (m_sessions.contains(name)) {
         return m_sessions.value(name);
     }
 
     KateSession::Ptr s = KateSession::create(sessionFileForName(name), name);
     saveSessionTo(s->config());
     m_sessions[name] = s;
     // Due to this add to m_sessions will updateSessionList() no signal emit,
     // but it's importand to add. Otherwise could it be happen that m_activeSession
     // is not part of m_sessions but a double
     emit sessionListChanged();
 
     return s;
 }
 
 bool KateSessionManager::deleteSession(KateSession::Ptr session)
 {
     if (sessionIsActive(session->name())) {
         return false;
     }
 
     QFile::remove(session->file());
     m_sessions.remove(session->name());
     // Due to this remove from m_sessions will updateSessionList() no signal emit,
     // but this way is there no delay between deletion and information
     emit sessionListChanged();
 
     return true;
 }
 
 QString KateSessionManager::copySession(const KateSession::Ptr &session, const QString &newName)
 {
     const QString name = askForNewSessionName(session, newName);
 
     if (name.isEmpty()) {
         return name;
     }
 
     const QString newFile = sessionFileForName(name);
 
     KateSession::Ptr ns = KateSession::createFrom(session, newFile, name);
     ns->config()->sync();
 
     return name;
 }
 
 QString KateSessionManager::renameSession(KateSession::Ptr session, const QString &newName)
 {
     const QString name = askForNewSessionName(session, newName);
 
     if (name.isEmpty()) {
         return name;
     }
 
     const QString newFile = sessionFileForName(name);
 
     session->config()->sync();
 
     const QUrl srcUrl = QUrl::fromLocalFile(session->file());
     const QUrl dstUrl = QUrl::fromLocalFile(newFile);
     KIO::CopyJob *job = KIO::move(srcUrl, dstUrl, KIO::HideProgressInfo);
 
     if (!job->exec()) {
         KMessageBox::sorry(QApplication::activeWindow(),
                            i18n("The session could not be renamed to \"%1\". Failed to write to \"%2\"", newName, newFile),
                            i18n("Session Renaming"));
         return QString();
     }
 
     m_sessions[newName] = m_sessions.take(session->name());
     session->setName(newName);
     session->setFile(newFile);
     session->config()->sync();
     // updateSessionList() will this edit not notice, so force signal
     emit sessionListChanged();
 
     if (session == activeSession()) {
         emit sessionChanged();
     }
 
     return name;
 }
 
 void KateSessionManager::saveSessionTo(KConfig *sc) const
 {
     // Clear the session file to avoid to accumulate outdated entries
-    for (auto group : sc->groupList()) {
+    for (const auto& group : sc->groupList()) {
         sc->deleteGroup(group);
     }
 
     // save plugin configs and which plugins to load
     KateApp::self()->pluginManager()->writeConfig(sc);
 
     // save document configs + which documents to load
     KateApp::self()->documentManager()->saveDocumentList(sc);
 
     sc->group("Open MainWindows").writeEntry("Count", KateApp::self()->mainWindowsCount());
 
     // save config for all windows around ;)
     bool saveWindowConfig = KConfigGroup(KSharedConfig::openConfig(), "General").readEntry("Restore Window Configuration", true);
     for (int i = 0; i < KateApp::self()->mainWindowsCount(); ++i) {
         KConfigGroup cg(sc, QStringLiteral("MainWindow%1").arg(i));
         // saveProperties() handles saving the "open recent" files list
         KateApp::self()->mainWindow(i)->saveProperties(cg);
         if (saveWindowConfig) {
             KateApp::self()->mainWindow(i)->saveWindowConfig(KConfigGroup(sc, QStringLiteral("MainWindow%1 Settings").arg(i)));
         }
     }
 
     sc->sync();
 
     /**
      * try to sync file to disk
      */
     QFile fileToSync(sc->name());
     if (fileToSync.open(QIODevice::ReadOnly)) {
 #ifndef Q_OS_WIN
         // ensure that the file is written to disk
 #ifdef HAVE_FDATASYNC
         fdatasync(fileToSync.handle());
 #else
         fsync(fileToSync.handle());
 #endif
 #endif
     }
 }
 
 bool KateSessionManager::saveActiveSession(bool rememberAsLast)
 {
     if (!activeSession()) {
         return false;
     }
 
     KConfig *sc = activeSession()->config();
 
     saveSessionTo(sc);
 
     if (rememberAsLast && !activeSession()->isAnonymous()) {
         KSharedConfigPtr c = KSharedConfig::openConfig();
         c->group("General").writeEntry("Last Session", activeSession()->name());
         c->sync();
     }
     return true;
 }
 
 bool KateSessionManager::chooseSession()
 {
     const KConfigGroup c(KSharedConfig::openConfig(), "General");
 
     // get last used session, default to default session
     const QString lastSession(c.readEntry("Last Session", QString()));
     const QString sesStart(c.readEntry("Startup Session", "manual"));
 
     // uhh, just open last used session, show no chooser
     if (sesStart == QStringLiteral("last")) {
         return activateSession(lastSession, false);
     }
 
     // start with empty new session or in case no sessions exist
     if (sesStart == QStringLiteral("new") || sessionList().size() == 0) {
         return activateAnonymousSession();
     }
 
     // else: ask the user
     return QScopedPointer<KateSessionManageDialog>(new KateSessionManageDialog(nullptr, lastSession))->exec();
 }
 
 void KateSessionManager::sessionNew()
 {
     activateSession(giveSession(QString()));
 }
 
 void KateSessionManager::sessionSave()
 {
     if (activeSession() && activeSession()->isAnonymous()) {
         sessionSaveAs();
     } else {
         saveActiveSession();
     }
 }
 
 void KateSessionManager::sessionSaveAs()
 {
     const QString newName = askForNewSessionName(activeSession());
 
     if (newName.isEmpty()) {
         return;
     }
 
     activeSession()->config()->sync();
 
     KateSession::Ptr ns = KateSession::createFrom(activeSession(), sessionFileForName(newName), newName);
     m_activeSession = ns;
     saveActiveSession();
 
     emit sessionChanged();
 }
 
 QString KateSessionManager::askForNewSessionName(KateSession::Ptr session, const QString &newName)
 {
     if (session->name() == newName && !session->isAnonymous()) {
         return QString();
     }
 
     const QString messagePrompt = i18n("Session name:");
     const KLocalizedString messageExist = ki18n("There is already an existing session with your chosen name: %1\n"
                                                 "Please choose a different one.");
     const QString messageEmpty = i18n("To save a session, you must specify a name.");
 
     QString messageTotal = messagePrompt;
     QString name = newName;
 
     while (true) {
         QString preset = name;
 
         if (name.isEmpty()) {
             preset = suggestNewSessionName(session->name());
             messageTotal = messageEmpty + QStringLiteral("\n\n") + messagePrompt;
 
         } else if (QFile::exists(sessionFileForName(name))) {
             preset = suggestNewSessionName(name);
             if (preset.isEmpty()) {
                 // Very unlikely, but as fall back we keep users input
                 preset = name;
             }
             messageTotal = messageExist.subs(name).toString() + QStringLiteral("\n\n") + messagePrompt;
 
         } else {
             return name;
         }
 
         QInputDialog dlg(KateApp::self()->activeKateMainWindow());
         dlg.setInputMode(QInputDialog::TextInput);
         if (session->isAnonymous()) {
             dlg.setWindowTitle(i18n("Specify a name for this session"));
         } else {
             dlg.setWindowTitle(i18n("Specify a new name for session: %1", session->name()));
         }
         dlg.setLabelText(messageTotal);
         dlg.setTextValue(preset);
         dlg.resize(900,100);  // FIXME Calc somehow a proper size
         bool ok = dlg.exec();
         name = dlg.textValue();
 
         if (!ok) {
             return QString();
         }
     }
 }
 
 QString KateSessionManager::suggestNewSessionName(const QString &target)
 {
     if (target.isEmpty()) {
         // Here could also a default name set or the current session name used
         return QString();
     }
 
     const QString mask = QStringLiteral("%1 (%2)");
     QString name;
 
     for (int i = 2; i < 1000000; i++) { // Should be enough to get an unique name
         name = mask.arg(target).arg(i);
 
         if (!QFile::exists(sessionFileForName(name))) {
             return name;
         }
     }
 
     return QString();
 }
 
 void KateSessionManager::sessionManage()
 {
     QScopedPointer<KateSessionManageDialog>(new KateSessionManageDialog(KateApp::self()->activeKateMainWindow()))->exec();
 }
 
 
 bool KateSessionManager::sessionIsActive(const QString &session)
 {
     // Try to avoid unneed action
     if (activeSession() && activeSession()->name() == session) {
         return true;
     }
 
     QDBusConnectionInterface *i = QDBusConnection::sessionBus().interface();
     if (!i) {
         return false;
     }
 
     // look up all running kate instances and there sessions
     QDBusReply<QStringList> servicesReply = i->registeredServiceNames();
     QStringList services;
     if (servicesReply.isValid()) {
         services = servicesReply.value();
     }
 
     for (const QString &s : qAsConst(services)) {
         if (!s.startsWith(QStringLiteral("org.kde.kate-"))) {
             continue;
         }
 
         KateRunningInstanceInfo rii(s);
         if (rii.valid && rii.sessionName == session) {
             return true;
         }
     }
 
     return false;
 }
 
 
 QString KateSessionManager::anonymousSessionFile() const
 {
     const QString file = m_sessionsDir + QStringLiteral("/../anonymous.katesession");
     return QDir().cleanPath(file);
 }
 
 QString KateSessionManager::sessionFileForName(const QString &name) const
 {
     Q_ASSERT(!name.isEmpty());
     const QString sname = QString::fromLatin1(QUrl::toPercentEncoding(name, QByteArray(), QByteArray(".")));
     return m_sessionsDir + QStringLiteral("/") + sname + QStringLiteral(".katesession");
 }
 
 KateSessionList KateSessionManager::sessionList()
 {
     return m_sessions.values();
 }
 
 void KateSessionManager::updateJumpListActions(const QStringList &sessionList)
 {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     KService::Ptr service = KService::serviceByStorageId(qApp->desktopFileName());
     if (!service) {
         return;
     }
 
     QScopedPointer<KDesktopFile> df(new KDesktopFile(service->entryPath()));
 
     QStringList newActions = df->readActions();
 
     // try to keep existing custom actions intact, only remove our "Session" actions and add them back later
     newActions.erase(std::remove_if(newActions.begin(), newActions.end(), [](const QString &action) {
         return action.startsWith(QLatin1String("Session "));
     }), newActions.end());
 
     // Limit the number of list entries we like to offer
     const int maxEntryCount = std::min(sessionList.count(), 10);
 
     // sessionList is ordered by time, but we like it alphabetical to avoid even more a needed update
     QStringList sessionSubList = sessionList.mid(0, maxEntryCount);
     sessionSubList.sort();
 
     // we compute the new group names in advance so we can tell whether we changed something
     // and avoid touching the desktop file leading to an expensive ksycoca recreation
     QStringList sessionActions;
     sessionActions.reserve(maxEntryCount);
 
     for (int i = 0; i < maxEntryCount; ++i) {
         sessionActions << QStringLiteral("Session %1").arg(QString::fromLatin1(QCryptographicHash::hash(sessionSubList.at(i).toUtf8()
                                                                              , QCryptographicHash::Md5).toHex()));
     }
 
     newActions += sessionActions;
 
     // nothing to do
     if (df->readActions() == newActions) {
         return;
     }
 
     const QString &localPath = service->locateLocal();
     if (service->entryPath() != localPath) {
         df.reset(df->copyTo(localPath));
     }
 
     // remove all Session action groups first to not leave behind any cruft
     for (const QString &action : df->readActions()) {
         if (action.startsWith(QLatin1String("Session "))) {
             // TODO is there no deleteGroup(KConfigGroup)?
             df->deleteGroup(df->actionGroup(action).name());
         }
     }
 
     for (int i = 0; i < maxEntryCount; ++i) {
         const QString &action = sessionActions.at(i); // is a transform of sessionSubList, so count and order is identical
         const QString &session = sessionSubList.at(i);
 
         KConfigGroup grp = df->actionGroup(action);
         grp.writeEntry(QStringLiteral("Name"), session);
         grp.writeEntry(QStringLiteral("Exec"), QStringLiteral("kate -s %1").arg(KShell::quoteArg(session))); // TODO proper executable name?
     }
 
     df->desktopGroup().writeXdgListEntry("Actions", newActions);
 #endif
 }
 
 //END KateSessionManager