diff --git a/kdevplatform/language/codegen/documentchangeset.cpp b/kdevplatform/language/codegen/documentchangeset.cpp
index faded88b16..6f65418219 100644
--- a/kdevplatform/language/codegen/documentchangeset.cpp
+++ b/kdevplatform/language/codegen/documentchangeset.cpp
@@ -1,612 +1,618 @@
 /*
    Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
    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 "documentchangeset.h"
 
 #include "coderepresentation.h"
 #include <debug.h>
 
 #include <algorithm>
 
 #include <QStringList>
 #include <QMimeDatabase>
 
 #include <KLocalizedString>
 
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/idocumentcontroller.h>
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <language/editor/modificationrevisionset.h>
 
 #include <interfaces/isourceformattercontroller.h>
 #include <interfaces/isourceformatter.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 
 #include <project/projectmodel.h>
 
 #include <util/path.h>
 #include <util/shellutils.h>
 
 namespace KDevelop {
 using ChangesList = QList<DocumentChangePointer>;
 using ChangesHash = QHash<IndexedString, ChangesList>;
 
 class DocumentChangeSetPrivate
 {
 public:
     DocumentChangeSet::ReplacementPolicy replacePolicy;
     DocumentChangeSet::FormatPolicy formatPolicy;
     DocumentChangeSet::DUChainUpdateHandling updatePolicy;
     DocumentChangeSet::ActivationPolicy activationPolicy;
 
     ChangesHash changes;
     QHash<IndexedString, IndexedString> documentsRename;
 
     DocumentChangeSet::ChangeResult addChange(const DocumentChangePointer& change);
     DocumentChangeSet::ChangeResult replaceOldText(CodeRepresentation* repr, const QString& newText,
                                                    const ChangesList& sortedChangesList);
     DocumentChangeSet::ChangeResult generateNewText(const IndexedString& file,
                                                     ChangesList& sortedChanges,
                                                     const CodeRepresentation* repr,
                                                     QString& output);
     DocumentChangeSet::ChangeResult removeDuplicates(const IndexedString& file,
                                                      ChangesList& filteredChanges);
     void formatChanges();
     void updateFiles();
 };
 
 // Simple helpers to clear up code clutter
 namespace {
 inline bool changeIsValid(const DocumentChange& change, const QStringList& textLines)
 {
     return change.m_range.start() <= change.m_range.end() &&
            change.m_range.end().line() < textLines.size() &&
            change.m_range.start().line() >= 0 &&
            change.m_range.start().column() >= 0 &&
            change.m_range.start().column() <= textLines[change.m_range.start().line()].length() &&
            change.m_range.end().column() >= 0 &&
            change.m_range.end().column() <= textLines[change.m_range.end().line()].length();
 }
 
 inline bool duplicateChanges(const DocumentChangePointer& previous, const DocumentChangePointer& current)
 {
     // Given the option of considering a duplicate two changes in the same range
     // but with different old texts to be ignored
     return previous->m_range == current->m_range &&
            previous->m_newText == current->m_newText &&
            (previous->m_oldText == current->m_oldText ||
             (previous->m_ignoreOldText && current->m_ignoreOldText));
 }
 
 inline QString rangeText(const KTextEditor::Range& range, const QStringList& textLines)
 {
     QStringList ret;
     ret.reserve(range.end().line() - range.start().line() + 1);
     for (int line = range.start().line(); line <= range.end().line(); ++line) {
         const QString lineText = textLines.at(line);
         int startColumn = 0;
         int endColumn = lineText.length();
         if (line == range.start().line()) {
             startColumn = range.start().column();
         }
         if (line == range.end().line()) {
             endColumn = range.end().column();
         }
         ret << lineText.mid(startColumn, endColumn - startColumn);
     }
 
     return ret.join(QLatin1Char('\n'));
 }
 
 // need to have it as otherwise the arguments can exceed the maximum of 10
 static QString printRange(const KTextEditor::Range& r)
 {
     return i18nc("text range line:column->line:column", "%1:%2->%3:%4",
                  r.start().line(), r.start().column(),
                  r.end().line(), r.end().column());
 }
 }
 
 DocumentChangeSet::DocumentChangeSet()
     : d_ptr(new DocumentChangeSetPrivate)
 {
     Q_D(DocumentChangeSet);
 
     d->replacePolicy = StopOnFailedChange;
     d->formatPolicy = AutoFormatChanges;
     d->updatePolicy = SimpleUpdate;
     d->activationPolicy = DoNotActivate;
 }
 
 DocumentChangeSet::DocumentChangeSet(const DocumentChangeSet& rhs)
     : d_ptr(new DocumentChangeSetPrivate(*rhs.d_ptr))
 {
 }
 
 DocumentChangeSet& DocumentChangeSet::operator=(const DocumentChangeSet& rhs)
 {
     *d_ptr = *rhs.d_ptr;
     return *this;
 }
 
 DocumentChangeSet::~DocumentChangeSet() = default;
 
 DocumentChangeSet::ChangeResult DocumentChangeSet::addChange(const DocumentChange& change)
 {
     Q_D(DocumentChangeSet);
 
     return d->addChange(DocumentChangePointer(new DocumentChange(change)));
 }
 
 DocumentChangeSet::ChangeResult DocumentChangeSet::addChange(const DocumentChangePointer& change)
 {
     Q_D(DocumentChangeSet);
 
     return d->addChange(change);
 }
 
 DocumentChangeSet::ChangeResult DocumentChangeSet::addDocumentRenameChange(const IndexedString& oldFile,
                                                                            const IndexedString& newname)
 {
     Q_D(DocumentChangeSet);
 
     d->documentsRename.insert(oldFile, newname);
     return DocumentChangeSet::ChangeResult::successfulResult();
 }
 
 DocumentChangeSet::ChangeResult DocumentChangeSetPrivate::addChange(const DocumentChangePointer& change)
 {
     changes[change->m_document].append(change);
     return DocumentChangeSet::ChangeResult::successfulResult();
 }
 
 void DocumentChangeSet::setReplacementPolicy(DocumentChangeSet::ReplacementPolicy policy)
 {
     Q_D(DocumentChangeSet);
 
     d->replacePolicy = policy;
 }
 
 void DocumentChangeSet::setFormatPolicy(DocumentChangeSet::FormatPolicy policy)
 {
     Q_D(DocumentChangeSet);
 
     d->formatPolicy = policy;
 }
 
 void DocumentChangeSet::setUpdateHandling(DocumentChangeSet::DUChainUpdateHandling policy)
 {
     Q_D(DocumentChangeSet);
 
     d->updatePolicy = policy;
 }
 
 void DocumentChangeSet::setActivationPolicy(DocumentChangeSet::ActivationPolicy policy)
 {
     Q_D(DocumentChangeSet);
 
     d->activationPolicy = policy;
 }
 
 DocumentChangeSet::ChangeResult DocumentChangeSet::applyAllChanges()
 {
     Q_D(DocumentChangeSet);
 
     QUrl oldActiveDoc;
     if (IDocument* activeDoc = ICore::self()->documentController()->activeDocument()) {
         oldActiveDoc = activeDoc->url();
     }
 
     QList<QUrl> allFiles;
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    const auto changedFiles =
+        QSet<IndexedString>(d->documentsRename.constKeyValueBegin(), d->documentsRename.constKeyValueEnd()) +
+        QSet<IndexedString>(d->changes.constKeyValueBegin(), d->changes.constKeyValueEnd());
+#else
     const auto changedFiles = d->documentsRename.keys().toSet() + d->changes.keys().toSet();
+#endif
     allFiles.reserve(changedFiles.size());
     for (const IndexedString& file : changedFiles) {
         allFiles << file.toUrl();
     }
 
     if (!KDevelop::ensureWritable(allFiles)) {
         return ChangeResult(QStringLiteral("some affected files are not writable"));
     }
 
     // rename files
     QHash<IndexedString, IndexedString>::const_iterator it = d->documentsRename.constBegin();
     for (; it != d->documentsRename.constEnd(); ++it) {
         QUrl url = it.key().toUrl();
         IProject* p = ICore::self()->projectController()->findProjectForUrl(url);
         if (p) {
             QList<ProjectFileItem*> files = p->filesForPath(it.key());
             if (!files.isEmpty()) {
                 ProjectBaseItem::RenameStatus renamed = files.first()->rename(it.value().str());
                 if (renamed == ProjectBaseItem::RenameOk) {
                     const QUrl newUrl = Path(Path(url).parent(), it.value().str()).toUrl();
                     if (url == oldActiveDoc) {
                         oldActiveDoc = newUrl;
                     }
                     IndexedString idxNewDoc(newUrl);
 
                     // ensure changes operate on new file name
                     ChangesHash::iterator iter = d->changes.find(it.key());
                     if (iter != d->changes.end()) {
                         // copy changes
                         ChangesList value = iter.value();
                         // remove old entry
                         d->changes.erase(iter);
                         // adapt to new url
                         for (auto& change : value) {
                             change->m_document = idxNewDoc;
                         }
 
                         d->changes[idxNewDoc] = value;
                     }
                 } else {
                     ///FIXME: share code with project manager for the error code string representation
                     return ChangeResult(i18n("Could not rename '%1' to '%2'",
                                              url.toDisplayString(QUrl::PreferLocalFile), it.value().str()));
                 }
             } else {
                 //TODO: do it outside the project management?
                 qCWarning(LANGUAGE) << "tried to rename file not tracked by project - not implemented";
             }
         } else {
             qCWarning(LANGUAGE) << "tried to rename a file outside of a project - not implemented";
         }
     }
 
     QMap<IndexedString, CodeRepresentation::Ptr> codeRepresentations;
     QMap<IndexedString, QString> newTexts;
     ChangesHash filteredSortedChanges;
     ChangeResult result = ChangeResult::successfulResult();
 
     const QList<IndexedString> files(d->changes.keys());
 
     for (const IndexedString& file : files) {
         CodeRepresentation::Ptr repr = createCodeRepresentation(file);
         if (!repr) {
             return ChangeResult(QStringLiteral("Could not create a Representation for %1").arg(file.str()));
         }
 
         codeRepresentations[file] = repr;
 
         QList<DocumentChangePointer>& sortedChangesList(filteredSortedChanges[file]);
         {
             result = d->removeDuplicates(file, sortedChangesList);
             if (!result)
                 return result;
         }
 
         {
             result = d->generateNewText(file, sortedChangesList, repr.data(), newTexts[file]);
             if (!result)
                 return result;
         }
     }
 
     QMap<IndexedString, QString> oldTexts;
 
     //Apply the changes to the files
     for (const IndexedString& file : files) {
         oldTexts[file] = codeRepresentations[file]->text();
 
         result = d->replaceOldText(codeRepresentations[file].data(), newTexts[file], filteredSortedChanges[file]);
         if (!result && d->replacePolicy == StopOnFailedChange) {
             //Revert all files
             for (auto it = oldTexts.constBegin(), end = oldTexts.constEnd(); it != end; ++it) {
                 const IndexedString& revertFile = it.key();
                 const QString& oldText = it.value();
                 codeRepresentations[revertFile]->setText(oldText);
             }
 
             return result;
         }
     }
 
     d->updateFiles();
 
     if (d->activationPolicy == Activate) {
         for (const IndexedString& file : files) {
             ICore::self()->documentController()->openDocument(file.toUrl());
         }
     }
 
     // ensure the old document is still activated
     if (oldActiveDoc.isValid()) {
         ICore::self()->documentController()->openDocument(oldActiveDoc);
     }
 
     return result;
 }
 
 DocumentChangeSet::ChangeResult DocumentChangeSetPrivate::replaceOldText(CodeRepresentation* repr,
                                                                          const QString& newText,
                                                                          const ChangesList& sortedChangesList)
 {
     auto* dynamic = dynamic_cast<DynamicCodeRepresentation*>(repr);
     if (dynamic) {
         auto transaction = dynamic->makeEditTransaction();
         //Replay the changes one by one
 
         for (int pos = sortedChangesList.size() - 1; pos >= 0; --pos) {
             const DocumentChange& change(*sortedChangesList[pos]);
             if (!dynamic->replace(change.m_range, change.m_oldText, change.m_newText, change.m_ignoreOldText)) {
                 QString warningString = i18nc(
                     "Inconsistent change in <filename> between <range>, found <oldText> (encountered <foundText>) -> <newText>",
                     "Inconsistent change in %1 between %2, found %3 (encountered \"%4\") -> \"%5\"",
                     change.m_document.str(),
                     printRange(change.m_range),
                     change.m_oldText,
                     dynamic->rangeText(change.m_range),
                     change.m_newText);
 
                 if (replacePolicy == DocumentChangeSet::WarnOnFailedChange) {
                     qCWarning(LANGUAGE) << warningString;
                 } else if (replacePolicy == DocumentChangeSet::StopOnFailedChange) {
                     return DocumentChangeSet::ChangeResult(warningString);
                 }
                 //If set to ignore failed changes just continue with the others
             }
         }
 
         return DocumentChangeSet::ChangeResult::successfulResult();
     }
 
     //For files on disk
     if (!repr->setText(newText)) {
         QString warningString = i18n("Could not replace text in the document: %1",
                                      sortedChangesList.begin()->data()->m_document.str());
         if (replacePolicy == DocumentChangeSet::WarnOnFailedChange) {
             qCWarning(LANGUAGE) << warningString;
         }
 
         return DocumentChangeSet::ChangeResult(warningString);
     }
 
     return DocumentChangeSet::ChangeResult::successfulResult();
 }
 
 DocumentChangeSet::ChangeResult DocumentChangeSetPrivate::generateNewText(const IndexedString& file,
                                                                           ChangesList& sortedChanges,
                                                                           const CodeRepresentation* repr,
                                                                           QString& output)
 {
     //Create the actual new modified file
     QStringList textLines = repr->text().split(QLatin1Char('\n'));
 
     QUrl url = file.toUrl();
 
     QMimeType mime = QMimeDatabase().mimeTypeForUrl(url);
 
     auto core = ICore::self();
     ISourceFormatter* formatter = core ? core->sourceFormatterController()->formatterForUrl(file.toUrl(), mime) : nullptr;
 
     QVector<int> removedLines;
 
     for (int pos = sortedChanges.size() - 1; pos >= 0; --pos) {
         DocumentChange& change(*sortedChanges[pos]);
         QString encountered;
         if (changeIsValid(change, textLines)  && //We demand this, although it should be fixed
             ((encountered = rangeText(change.m_range, textLines)) == change.m_oldText || change.m_ignoreOldText)) {
             ///Problem: This does not work if the other changes significantly alter the context @todo Use the changed context
             QString leftContext = QStringList(textLines.mid(0, change.m_range.start().line() + 1)).join(QLatin1Char(
                                                                                                             '\n'));
             leftContext.chop(textLines[change.m_range.start().line()].length() - change.m_range.start().column());
 
             QString rightContext = QStringList(textLines.mid(change.m_range.end().line())).join(QLatin1Char('\n')).mid(
                 change.m_range.end().column());
 
             if (formatter && (formatPolicy == DocumentChangeSet::AutoFormatChanges
                               || formatPolicy == DocumentChangeSet::AutoFormatChangesKeepIndentation)) {
                 QString oldNewText = change.m_newText;
                 change.m_newText = formatter->formatSource(change.m_newText, url, mime, leftContext, rightContext);
 
                 if (formatPolicy == DocumentChangeSet::AutoFormatChangesKeepIndentation) {
                     // Reproduce the previous indentation
                     const QStringList oldLines = oldNewText.split(QLatin1Char('\n'));
                     QStringList newLines = change.m_newText.split(QLatin1Char('\n'));
 
                     if (oldLines.size() == newLines.size()) {
                         for (int line = 0; line < newLines.size(); ++line) {
                             // Keep the previous indentation
                             QString oldIndentation;
                             for (const QChar a : oldLines[line]) {
                                 if (a.isSpace()) {
                                     oldIndentation.append(a);
                                 } else {
                                     break;
                                 }
                             }
 
                             int newIndentationLength = 0;
 
                             for (int a = 0; a < newLines[line].size(); ++a) {
                                 if (newLines[line][a].isSpace()) {
                                     newIndentationLength = a;
                                 } else {
                                     break;
                                 }
                             }
 
                             newLines[line].replace(0, newIndentationLength, oldIndentation);
                         }
 
                         change.m_newText = newLines.join(QLatin1Char('\n'));
                     } else {
                         qCDebug(LANGUAGE) << "Cannot keep the indentation because the line count has changed" <<
                             oldNewText;
                     }
                 }
             }
 
             QString& line = textLines[change.m_range.start().line()];
             if (change.m_range.start().line() == change.m_range.end().line()) {
                 // simply replace existing line content
                 line.replace(change.m_range.start().column(),
                              change.m_range.end().column() - change.m_range.start().column(),
                              change.m_newText);
             } else {
                 // replace first line contents
                 line.replace(change.m_range.start().column(), line.length() - change.m_range.start().column(),
                              change.m_newText);
                 // null other lines and remember for deletion
                 const int firstLine = change.m_range.start().line() + 1;
                 const int lastLine = change.m_range.end().line();
                 removedLines.reserve(removedLines.size() + lastLine - firstLine + 1);
                 for (int i = firstLine; i <= lastLine; ++i) {
                     textLines[i].clear();
                     removedLines << i;
                 }
             }
         } else {
             QString warningString = i18nc("Inconsistent change in <document> at <range>"
                                           " = <oldText> (encountered <encountered>) -> <newText>",
                                           "Inconsistent change in %1 at %2"
                                           " = \"%3\"(encountered \"%4\") -> \"%5\"",
                                           file.str(),
                                           printRange(change.m_range),
                                           change.m_oldText,
                                           encountered,
                                           change.m_newText);
 
             if (replacePolicy == DocumentChangeSet::IgnoreFailedChange) {
                 //Just don't do the replacement
             } else if (replacePolicy == DocumentChangeSet::WarnOnFailedChange) {
                 qCWarning(LANGUAGE) << warningString;
             } else {
                 return DocumentChangeSet::ChangeResult(warningString, sortedChanges[pos]);
             }
         }
     }
 
     if (!removedLines.isEmpty()) {
         int offset = 0;
         std::sort(removedLines.begin(), removedLines.end());
         for (int l : qAsConst(removedLines)) {
             textLines.removeAt(l - offset);
             ++offset;
         }
     }
     output = textLines.join(QLatin1Char('\n'));
     return DocumentChangeSet::ChangeResult::successfulResult();
 }
 
 //Removes all duplicate changes for a single file, and then returns (via filteredChanges) the filtered duplicates
 DocumentChangeSet::ChangeResult DocumentChangeSetPrivate::removeDuplicates(const IndexedString& file,
                                                                            ChangesList& filteredChanges)
 {
     using ChangesMap = QMultiMap<KTextEditor::Cursor, DocumentChangePointer>;
     ChangesMap sortedChanges;
 
     for (const DocumentChangePointer& change : qAsConst(changes[file])) {
         sortedChanges.insert(change->m_range.end(), change);
     }
 
     //Remove duplicates
     ChangesMap::iterator previous = sortedChanges.begin();
     for (ChangesMap::iterator it = ++sortedChanges.begin(); it != sortedChanges.end();) {
         if ((*previous) && (*previous)->m_range.end() > (*it)->m_range.start()) {
             //intersection
             if (duplicateChanges((*previous), *it)) {
                 //duplicate, remove one
                 it = sortedChanges.erase(it);
                 continue;
             }
             //When two changes contain each other, and the container change is set to ignore old text, then it should be safe to
             //just ignore the contained change, and apply the bigger change
             else if ((*it)->m_range.contains((*previous)->m_range) && (*it)->m_ignoreOldText) {
                 qCDebug(LANGUAGE) << "Removing change: " << (*previous)->m_oldText << "->" << (*previous)->m_newText
                                   << ", because it is contained by change: " << (*it)->m_oldText << "->" <<
                 (*it)->m_newText;
                 sortedChanges.erase(previous);
             }
             //This case is for when both have the same end, either of them could be the containing range
             else if ((*previous)->m_range.contains((*it)->m_range) && (*previous)->m_ignoreOldText) {
                 qCDebug(LANGUAGE) << "Removing change: " << (*it)->m_oldText << "->" << (*it)->m_newText
                                   << ", because it is contained by change: " << (*previous)->m_oldText
                                   << "->" << (*previous)->m_newText;
                 it = sortedChanges.erase(it);
                 continue;
             } else {
                 return DocumentChangeSet::ChangeResult(
                     i18nc("Inconsistent change-request at <document>:"
                           "intersecting changes: "
                           "<previous-oldText> -> <previous-newText> @<range> & "
                           "<new-oldText> -> <new-newText> @<range>",
                           "Inconsistent change-request at %1; "
                           "intersecting changes: "
                           "\"%2\"->\"%3\"@%4 & \"%5\"->\"%6\"@%7 ",
                           file.str(),
                           (*previous)->m_oldText,
                           (*previous)->m_newText,
                           printRange((*previous)->m_range),
                           (*it)->m_oldText,
                           (*it)->m_newText,
                           printRange((*it)->m_range)));
             }
         }
         previous = it;
         ++it;
     }
 
     filteredChanges = sortedChanges.values();
     return DocumentChangeSet::ChangeResult::successfulResult();
 }
 
 void DocumentChangeSetPrivate::updateFiles()
 {
     ModificationRevisionSet::clearCache();
     const auto files = changes.keys();
     for (const IndexedString& file : files) {
         ModificationRevision::clearModificationCache(file);
     }
 
     if (updatePolicy != DocumentChangeSet::NoUpdate && ICore::self()) {
         // The active document should be updated first, so that the user sees the results instantly
         if (IDocument* activeDoc = ICore::self()->documentController()->activeDocument()) {
             ICore::self()->languageController()->backgroundParser()->addDocument(IndexedString(activeDoc->url()));
         }
 
         // If there are currently open documents that now need an update, update them too
         const auto documents = ICore::self()->languageController()->backgroundParser()->managedDocuments();
         for (const IndexedString& doc : documents) {
             DUChainReadLocker lock(DUChain::lock());
             TopDUContext* top = DUChainUtils::standardContextForUrl(doc.toUrl(), true);
             if ((top && top->parsingEnvironmentFile() && top->parsingEnvironmentFile()->needsUpdate()) || !top) {
                 lock.unlock();
                 ICore::self()->languageController()->backgroundParser()->addDocument(doc);
             }
         }
 
         // Eventually update _all_ affected files
         const auto files = changes.keys();
         for (const IndexedString& file : files) {
             if (!file.toUrl().isValid()) {
                 qCWarning(LANGUAGE) << "Trying to apply changes to an invalid document";
                 continue;
             }
 
             ICore::self()->languageController()->backgroundParser()->addDocument(file);
         }
     }
 }
 }
diff --git a/kdevplatform/project/projectchangesmodel.cpp b/kdevplatform/project/projectchangesmodel.cpp
index ffe3e9fcbe..40d819f397 100644
--- a/kdevplatform/project/projectchangesmodel.cpp
+++ b/kdevplatform/project/projectchangesmodel.cpp
@@ -1,295 +1,300 @@
 /* This file is part of KDevelop
     Copyright 2010 Aleix Pol Gonzalez <aleixpol@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 "projectchangesmodel.h"
 
 #include "debug.h"
 
 #include <KLocalizedString>
 
 #include <vcs/interfaces/ibasicversioncontrol.h>
 #include <interfaces/ibranchingversioncontrol.h>
 #include <interfaces/iplugin.h>
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iprojectcontroller.h>
 #include <vcs/vcsstatusinfo.h>
 #include <vcs/vcsjob.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/idocumentcontroller.h>
 #include <project/projectmodel.h>
 #include <util/path.h>
 
 #include <QDir>
 #include <QIcon>
 
 #include <array>
 
 Q_DECLARE_METATYPE(KDevelop::IProject*)
 
 using namespace KDevelop;
 
 ProjectChangesModel::ProjectChangesModel(QObject* parent)
     : VcsFileChangesModel(parent)
 {
     const auto projects = ICore::self()->projectController()->projects();
     for (IProject* p : projects) {
         addProject(p);
     }
 
     connect(ICore::self()->projectController(), &IProjectController::projectOpened,
                                               this, &ProjectChangesModel::addProject);
     connect(ICore::self()->projectController(), &IProjectController::projectClosing,
                                               this, &ProjectChangesModel::removeProject);
     
     connect(ICore::self()->documentController(), &IDocumentController::documentSaved,
                                                 this, &ProjectChangesModel::documentSaved);
     connect(ICore::self()->projectController()->projectModel(), &ProjectModel::rowsInserted,
                                                 this, &ProjectChangesModel::itemsAdded);
     
     connect(ICore::self()->runController(), &IRunController::jobUnregistered, this, &ProjectChangesModel::jobUnregistered);
 }
 
 ProjectChangesModel::~ProjectChangesModel()
 {}
 
 void ProjectChangesModel::addProject(IProject* p)
 {
     QStandardItem* it = new QStandardItem(p->name());
     it->setData(p->name(), ProjectChangesModel::ProjectNameRole);
     IPlugin* plugin = p->versionControlPlugin();
     if(plugin) {
         auto* vcs = plugin->extension<IBasicVersionControl>();
 
         auto info = ICore::self()->pluginController()->pluginInfo(plugin);
 
         it->setIcon(QIcon::fromTheme(info.iconName()));
         it->setToolTip(vcs->name());
 
         auto* branchingExtension = plugin->extension<KDevelop::IBranchingVersionControl>();
         if(branchingExtension) {
             const auto pathUrl = p->path().toUrl();
             branchingExtension->registerRepositoryForCurrentBranchChanges(pathUrl);
             // can't use new signal slot syntax here, IBranchingVersionControl is not a QObject
             connect(plugin, SIGNAL(repositoryBranchChanged(QUrl)), this, SLOT(repositoryBranchChanged(QUrl)));
             repositoryBranchChanged(pathUrl);
         } else
             reload(QList<IProject*>() << p);
     } else {
         it->setEnabled(false);
     }
     
     appendRow(it);
 }
 
 void ProjectChangesModel::removeProject(IProject* p)
 {
     QStandardItem* it=projectItem(p);
     if (!it) {
         // when the project is closed before it was fully populated, we won't ever see a
         // projectOpened signal - handle this gracefully by just ignoring the remove request
         return;
     }
     removeRow(it->row());
 }
 
 QStandardItem* findItemChild(QStandardItem* parent, const QVariant& value, int role = Qt::DisplayRole)
 {
     for(int i=0; i<parent->rowCount(); i++) {
         QStandardItem* curr=parent->child(i);
         
         if(curr->data(role) == value)
             return curr;
     }
     return nullptr;
 }
 
 QStandardItem* ProjectChangesModel::projectItem(IProject* p) const
 {
     return findItemChild(invisibleRootItem(), p->name(), ProjectChangesModel::ProjectNameRole);
 }
 
 void ProjectChangesModel::updateState(IProject* p, const KDevelop::VcsStatusInfo& status)
 {
     QStandardItem* pItem = projectItem(p);
     Q_ASSERT(pItem);
     
     VcsFileChangesModel::updateState(pItem, status);
 }
 
 void ProjectChangesModel::changes(IProject* project, const QList<QUrl>& urls, IBasicVersionControl::RecursionMode mode)
 {
     IPlugin* vcsplugin=project->versionControlPlugin();
     IBasicVersionControl* vcs = vcsplugin ? vcsplugin->extension<IBasicVersionControl>() : nullptr;
     
     if(vcs && vcs->isVersionControlled(urls.first())) { //TODO: filter?
         VcsJob* job=vcs->status(urls, mode);
         job->setProperty("urls", QVariant::fromValue<QList<QUrl>>(urls));
         job->setProperty("mode", QVariant::fromValue<int>(mode));
         job->setProperty("project", QVariant::fromValue(project));
         connect(job, &VcsJob::finished, this, &ProjectChangesModel::statusReady);
         
         ICore::self()->runController()->registerJob(job);
     }
 }
 
 void ProjectChangesModel::statusReady(KJob* job)
 {
     auto* status=static_cast<VcsJob*>(job);
 
     const QList<QVariant> states = status->fetchResults().toList();
     auto* project = job->property("project").value<KDevelop::IProject*>();
     if(!project)
         return;
 
     QSet<QUrl> foundUrls;
     foundUrls.reserve(states.size());
     for (const QVariant& state : states) {
         const VcsStatusInfo st = state.value<VcsStatusInfo>();
         foundUrls += st.url();
 
         updateState(project, st);
     }
 
     QStandardItem* itProject = projectItem(project);
     if (!itProject) {
         qCDebug(PROJECT) << "Project no longer listed in model:" << project->name() << "- skipping update";
         return;
     }
 
     IBasicVersionControl::RecursionMode mode = IBasicVersionControl::RecursionMode(job->property("mode").toInt());
-    const QSet<QUrl> uncertainUrls = urls(itProject).toSet().subtract(foundUrls);
+    const QList<QUrl> projectUrls = urls(itProject);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    const QSet<QUrl> uncertainUrls = QSet<QUrl>(projectUrls.begin(), projectUrls.end()).subtract(foundUrls);
+#else
+    const QSet<QUrl> uncertainUrls = projectUrls.toSet().subtract(foundUrls);
+#endif
     const QList<QUrl> sourceUrls = job->property("urls").value<QList<QUrl>>();
     for (const QUrl& url : sourceUrls) {
         if(url.isLocalFile() && QDir(url.toLocalFile()).exists()) {
             for (const QUrl& currentUrl : uncertainUrls) {
                 if((mode == IBasicVersionControl::NonRecursive && currentUrl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash) == url.adjusted(QUrl::StripTrailingSlash))
                     || (mode == IBasicVersionControl::Recursive && url.isParentOf(currentUrl))
                 ) {
                     removeUrl(currentUrl);
                 }
             }
         }
     }
 }
 
 void ProjectChangesModel::documentSaved(KDevelop::IDocument* document)
 {
     reload({document->url()});
 }
 
 void ProjectChangesModel::itemsAdded(const QModelIndex& parent, int start, int end)
 {
     ProjectModel* model=ICore::self()->projectController()->projectModel();
     ProjectBaseItem* item=model->itemFromIndex(parent);
 
     if(!item)
         return;
 
     IProject* project=item->project();
     
     if(!project)
         return;
     
     QList<QUrl> urls;
     
     for(int i=start; i<end; i++) {
         QModelIndex idx=parent.model()->index(i, 0, parent);
         item=model->itemFromIndex(idx);
         
         if(item->type()==ProjectBaseItem::File || item->type()==ProjectBaseItem::Folder || item->type()==ProjectBaseItem::BuildFolder)
             urls += item->path().toUrl();
     }
         
     if(!urls.isEmpty())
         changes(project, urls, KDevelop::IBasicVersionControl::NonRecursive);
 }
 
 void ProjectChangesModel::reload(const QList<IProject*>& projects)
 {
     for (IProject* project : projects) {
         changes(project, {project->path().toUrl()}, KDevelop::IBasicVersionControl::Recursive);
     }
 }
 
 void ProjectChangesModel::reload(const QList<QUrl>& urls)
 {
     for (const QUrl& url : urls) {
         IProject* project=ICore::self()->projectController()->findProjectForUrl(url);
         
         if (project) {
             // FIXME: merge multiple urls of the same project
             changes(project, {url}, KDevelop::IBasicVersionControl::NonRecursive);
         }
     }
 }
 
 void ProjectChangesModel::reloadAll()
 {
     QList< IProject* > projects = ICore::self()->projectController()->projects();
     reload(projects);
 }
 
 void ProjectChangesModel::jobUnregistered(KJob* job)
 {
     static const std::array<VcsJob::JobType, 7> readOnly = {
         KDevelop::VcsJob::Add,
         KDevelop::VcsJob::Remove,
         KDevelop::VcsJob::Pull,
         KDevelop::VcsJob::Commit,
         KDevelop::VcsJob::Move,
         KDevelop::VcsJob::Copy,
         KDevelop::VcsJob::Revert,
     };
 
     auto* vcsjob = qobject_cast<VcsJob*>(job);
     if (vcsjob && std::find(readOnly.begin(), readOnly.end(), vcsjob->type()) != readOnly.end()) {
         reloadAll();
     }
 }
 
 void ProjectChangesModel::repositoryBranchChanged(const QUrl& url)
 {
     IProject* project = ICore::self()->projectController()->findProjectForUrl(url);
     if(project) {
         IPlugin* v = project->versionControlPlugin();
         Q_ASSERT(v);
         auto* branching = v->extension<IBranchingVersionControl>();
         Q_ASSERT(branching);
         VcsJob* job = branching->currentBranch(url);
         connect(job, &VcsJob::resultsReady, this, &ProjectChangesModel::branchNameReady);
         job->setProperty("project", QVariant::fromValue<QObject*>(project));
         ICore::self()->runController()->registerJob(job);
     }
 }
 
 void ProjectChangesModel::branchNameReady(VcsJob* job)
 {
     auto* project = qobject_cast<IProject*>(job->property("project").value<QObject*>());
     if(job->status()==VcsJob::JobSucceeded) {
         QString name = job->fetchResults().toString();
         QString branchName = name.isEmpty() ? i18n("no branch") : name;
         projectItem(project)->setText(i18nc("project name (branch name)", "%1 (%2)", project->name(), branchName));
     } else {
         projectItem(project)->setText(project->name());
     }
 
     reload(QList<IProject*>() << project);
 }
diff --git a/kdevplatform/serialization/tests/bench_itemrepository.cpp b/kdevplatform/serialization/tests/bench_itemrepository.cpp
index 4151e9c53e..9e3f7bd432 100644
--- a/kdevplatform/serialization/tests/bench_itemrepository.cpp
+++ b/kdevplatform/serialization/tests/bench_itemrepository.cpp
@@ -1,224 +1,228 @@
 /*
  * This file is part of KDevelop
  * Copyright 2012-2013 Milian Wolff <mail@milianw.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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  */
 
 #include "bench_itemrepository.h"
 
 #include <serialization/itemrepository.h>
 #include <serialization/indexedstring.h>
 
 #include <algorithm>
 #include <QTest>
 
 QTEST_GUILESS_MAIN(BenchItemRepository)
 
 using namespace KDevelop;
 
 struct TestData
 {
     uint length;
 
     TestData& operator=(const TestData& rhs) = delete;
 
     uint itemSize() const
     {
         return sizeof(TestData) + length;
     }
     uint hash() const
     {
         const char* str = (( const char* )this) + sizeof(TestData);
         return IndexedString::hashString(str, length);
     }
 };
 
 struct TestDataRepositoryItemRequest
 {
     //The text is supposed to be utf8 encoded
     TestDataRepositoryItemRequest(const char* text, uint length)
         : m_length(length)
         , m_text(text)
         , m_hash(IndexedString::hashString(text, length))
     {
     }
 
     enum {
         AverageSize = 10 //This should be the approximate average size of an Item
     };
 
     using HashType = uint;
 
     //Should return the hash-value associated with this request(For example the hash of a string)
     HashType hash() const
     {
         return m_hash;
     }
 
     //Should return the size of an item created with createItem
     uint itemSize() const
     {
         return sizeof(TestData) + m_length;
     }
     //Should create an item where the information of the requested item is permanently stored. The pointer
     //@param item equals an allocated range with the size of itemSize().
     void createItem(TestData* item) const
     {
         item->length = m_length;
         void* itemText = reinterpret_cast<void*>(item + 1);
         memcpy(itemText, m_text, m_length);
     }
 
     static void destroy(TestData* item, AbstractItemRepository&)
     {
         Q_UNUSED(item);
         //Nothing to do here (The object is not intelligent)
     }
 
     static bool persistent(const TestData* item)
     {
         Q_UNUSED(item);
         return true;
     }
 
     //Should return whether the here requested item equals the given item
     bool equals(const TestData* item) const
     {
         return item->length == m_length && (memcmp(++item, m_text, m_length) == 0);
     }
     unsigned short m_length;
     const char* m_text;
     unsigned int m_hash;
 };
 
 using TestDataRepository = ItemRepository<TestData, TestDataRepositoryItemRequest, false, true>;
 
 void BenchItemRepository::initTestCase()
 {
     ItemRepositoryRegistry::initialize(m_repositoryPath);
 }
 
 void BenchItemRepository::cleanupTestCase()
 {
     ItemRepositoryRegistry::deleteRepositoryFromDisk(m_repositoryPath);
 }
 
 static QVector<QString> generateData()
 {
     QVector<QString> data;
     static const int NUM_ITEMS = 100000;
     data.resize(NUM_ITEMS);
     for (int i = 0; i < NUM_ITEMS; ++i) {
         data[i] = QStringLiteral("/foo/%1").arg(i);
     }
 
     return data;
 }
 
 static QVector<uint> insertData(const QVector<QString>& data, TestDataRepository& repo)
 {
     QVector<uint> indices;
     indices.reserve(data.size());
     for (const QString& item : data) {
         const QByteArray byteArray = item.toUtf8();
         indices << repo.index(TestDataRepositoryItemRequest(byteArray.constData(), byteArray.length()));
     }
 
     return indices;
 }
 
 void BenchItemRepository::insert()
 {
     TestDataRepository repo("TestDataRepositoryInsert");
     const QVector<QString> data = generateData();
     QVector<uint> indices;
     QBENCHMARK_ONCE {
         indices = insertData(data, repo);
         repo.store();
     }
     Q_ASSERT(indices.size() == data.size());
     QCOMPARE(repo.statistics().totalItems, uint(data.size()));
 }
 
 void BenchItemRepository::remove()
 {
     TestDataRepository repo("TestDataRepositoryRemove");
     const QVector<QString> data = generateData();
     const QVector<uint> indices = insertData(data, repo);
     repo.store();
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    QVERIFY(indices.size() == QSet<uint>(indices.begin(), indices.end()).size());
+#else
     QVERIFY(indices.size() == indices.toList().toSet().size());
+#endif
     QVERIFY(indices.size() == data.size());
     QBENCHMARK_ONCE {
         for (uint index : indices) {
             repo.deleteItem(index);
         }
 
         repo.store();
     }
     QCOMPARE(repo.statistics().totalItems, 0u);
 }
 
 void BenchItemRepository::removeDisk()
 {
     const QVector<QString> data = generateData();
     QVector<uint> indices;
     {
         TestDataRepository repo("TestDataRepositoryRemoveDisk");
         indices = insertData(data, repo);
         repo.store();
     }
     TestDataRepository repo("TestDataRepositoryRemoveDisk");
     QVERIFY(repo.statistics().totalItems == static_cast<uint>(data.size()));
     QBENCHMARK_ONCE {
         for (uint index : qAsConst(indices)) {
             repo.deleteItem(index);
         }
 
         repo.store();
     }
     QCOMPARE(repo.statistics().totalItems, 0u);
 }
 
 void BenchItemRepository::lookupKey()
 {
     TestDataRepository repo("TestDataRepositoryLookupKey");
     const QVector<QString> data = generateData();
     QVector<uint> indices = insertData(data, repo);
     srand(0);
     std::random_shuffle(indices.begin(), indices.end());
     QBENCHMARK {
         for (uint index : qAsConst(indices)) {
             repo.itemFromIndex(index);
         }
     }
 }
 
 void BenchItemRepository::lookupValue()
 {
     TestDataRepository repo("TestDataRepositoryLookupValue");
     const QVector<QString> data = generateData();
     QVector<uint> indices = insertData(data, repo);
     srand(0);
     std::random_shuffle(indices.begin(), indices.end());
     QBENCHMARK {
         for (const QString& item : data) {
             const QByteArray byteArray = item.toUtf8();
             repo.findIndex(TestDataRepositoryItemRequest(byteArray.constData(), byteArray.length()));
         }
     }
 }
diff --git a/kdevplatform/shell/plugincontroller.cpp b/kdevplatform/shell/plugincontroller.cpp
index c7ac8aca4c..bbfeb73dff 100644
--- a/kdevplatform/shell/plugincontroller.cpp
+++ b/kdevplatform/shell/plugincontroller.cpp
@@ -1,868 +1,883 @@
 /* This file is part of the KDE project
 Copyright 2004, 2007 Alexander Dymo <adymo@kdevelop.org>
 Copyright 2006 Matt Rogers <mattr@kde.org
 Copyright 2007 Andreas Pakulat <apaku@gmx.de>
 
 Based on code from Kopete
 Copyright (c) 2002-2003 Martijn Klingens <klingens@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 "plugincontroller.h"
 
 #include <QElapsedTimer>
 #include <QMap>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KPluginFactory>
 #include <KPluginLoader>
 
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/iplugin.h>
 #include <interfaces/isession.h>
 #include <interfaces/idebugcontroller.h>
 #include <interfaces/idocumentationcontroller.h>
 #include <interfaces/ipluginversion.h>
 
 #include "core.h"
 #include "shellextension.h"
 #include "runcontroller.h"
 #include "debugcontroller.h"
 #include "documentationcontroller.h"
 #include "sourceformattercontroller.h"
 #include "projectcontroller.h"
 #include "ktexteditorpluginintegration.h"
 #include "debug.h"
 
 namespace {
 
 inline QString KEY_Plugins() { return QStringLiteral("Plugins"); }
 inline QString KEY_Suffix_Enabled() { return QStringLiteral("Enabled"); }
 
 inline QString KEY_LoadMode() { return QStringLiteral("X-KDevelop-LoadMode"); }
 inline QString KEY_Category() { return QStringLiteral("X-KDevelop-Category"); }
 inline QString KEY_Mode() { return QStringLiteral("X-KDevelop-Mode"); }
 inline QString KEY_Version() { return QStringLiteral("X-KDevelop-Version"); }
 inline QString KEY_Interfaces() { return QStringLiteral("X-KDevelop-Interfaces"); }
 inline QString KEY_Required() { return QStringLiteral("X-KDevelop-IRequired"); }
 inline QString KEY_Optional() { return QStringLiteral("X-KDevelop-IOptional"); }
 inline QString KEY_KPlugin() { return QStringLiteral("KPlugin"); }
 inline QString KEY_EnabledByDefault() { return QStringLiteral("EnabledByDefault"); }
 
 inline QString KEY_Global() { return QStringLiteral("Global"); }
 inline QString KEY_Project() { return QStringLiteral("Project"); }
 inline QString KEY_Gui() { return QStringLiteral("GUI"); }
 inline QString KEY_AlwaysOn() { return QStringLiteral("AlwaysOn"); }
 inline QString KEY_UserSelectable() { return QStringLiteral("UserSelectable"); }
 
 bool isUserSelectable( const KPluginMetaData& info )
 {
     QString loadMode = info.value(KEY_LoadMode());
     return loadMode.isEmpty() || loadMode == KEY_UserSelectable();
 }
 
 bool isGlobalPlugin( const KPluginMetaData& info )
 {
     return info.value(KEY_Category()) == KEY_Global();
 }
 
 bool hasMandatoryProperties( const KPluginMetaData& info )
 {
     QString mode = info.value(KEY_Mode());
     if (mode.isEmpty()) {
         return false;
     }
 
     // when the plugin is installed into the versioned plugin path, it's good to go
     if (info.fileName().contains(QLatin1String("/kdevplatform/" QT_STRINGIFY(KDEVELOP_PLUGIN_VERSION) "/"))) {
         return true;
     }
 
     // the version property is only required when the plugin is not installed into the right directory
     QVariant version = info.rawData().value(KEY_Version()).toVariant();
     if (version.isValid() && version.value<int>() == KDEVELOP_PLUGIN_VERSION) {
         return true;
     }
 
     return false;
 }
 
+inline QSet<QString> stringSet(const QVariant& variant)
+{
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    const QStringList list = variant.toStringList();
+    return QSet<QString>(list.begin(), list.end());
+#else
+    return variant.toStringList().toSet();
+#endif
+}
+
 bool constraintsMatch( const KPluginMetaData& info, const QVariantMap& constraints)
 {
     for (auto it = constraints.begin(); it != constraints.end(); ++it) {
         const auto property = info.rawData().value(it.key()).toVariant();
 
         if (!property.isValid()) {
             return false;
         } else if (property.canConvert<QStringList>()) {
-            QSet<QString> values = property.toStringList().toSet();
-            QSet<QString> expected = it.value().toStringList().toSet();
+            const QSet<QString> values = stringSet(property);
+            const QSet<QString> expected = stringSet(it.value());
             if (!values.contains(expected)) {
                 return false;
             }
         } else if (it.value() != property) {
             return false;
         }
     }
     return true;
 }
 
 struct Dependency
 {
     explicit Dependency(const QString &dependency)
         : interface(dependency)
     {
         if (dependency.contains(QLatin1Char('@'))) {
             const auto list = dependency.split(QLatin1Char('@'), QString::SkipEmptyParts);
             if (list.size() == 2) {
                 interface = list.at(0);
                 pluginName = list.at(1);
             }
         }
     }
 
     QString interface;
     QString pluginName;
 };
 
 }
 
 namespace KDevelop {
 
 class PluginControllerPrivate
 {
 public:
     explicit PluginControllerPrivate(Core *core)
         : core(core)
     {}
 
     QVector<KPluginMetaData> plugins;
 
     //map plugin infos to currently loaded plugins
     using InfoToPluginMap = QHash<KPluginMetaData, IPlugin*>;
     InfoToPluginMap loadedPlugins;
 
     // The plugin manager's mode. The mode is StartingUp until loadAllPlugins()
     // has finished loading the plugins, after which it is set to Running.
     // ShuttingDown and DoneShutdown are used during shutdown by the
     // async unloading of plugins.
     enum CleanupMode
     {
         Running     /**< the plugin manager is running */,
         CleaningUp  /**< the plugin manager is cleaning up for shutdown */,
         CleanupDone /**< the plugin manager has finished cleaning up */
     };
     CleanupMode cleanupMode;
 
     bool canUnload(const KPluginMetaData& plugin)
     {
         qCDebug(SHELL) << "checking can unload for:" << plugin.name() << plugin.value(KEY_LoadMode());
         if (plugin.value(KEY_LoadMode()) == KEY_AlwaysOn()) {
             return false;
         }
         const QStringList interfaces = KPluginMetaData::readStringList(plugin.rawData(), KEY_Interfaces());
         qCDebug(SHELL) << "checking dependencies:" << interfaces;
         for (auto it = loadedPlugins.constBegin(), end = loadedPlugins.constEnd(); it != end; ++it) {
             const KPluginMetaData& info = it.key();
             if (info.pluginId() != plugin.pluginId()) {
                 const QStringList dependencies =
                     KPluginMetaData::readStringList(plugin.rawData(), KEY_Required()) +
                     KPluginMetaData::readStringList(plugin.rawData(), KEY_Optional());
                 for (const QString& dep : dependencies) {
                     Dependency dependency(dep);
                     if (!dependency.pluginName.isEmpty() && dependency.pluginName != plugin.pluginId()) {
                         continue;
                     }
                     if (interfaces.contains(dependency.interface) && !canUnload(info)) {
                         return false;
                     }
                 }
             }
         }
         return true;
     }
 
     KPluginMetaData infoForId( const QString& id ) const
     {
         for (const KPluginMetaData& info : plugins) {
             if (info.pluginId() == id) {
                 return info;
             }
         }
         return KPluginMetaData();
     }
 
     /**
      * Iterate over all cached plugin infos, and call the functor for every enabled plugin.
      *
      * If an extension and/or pluginName is given, the functor will only be called for
      * those plugins matching this information.
      *
      * The functor should return false when the iteration can be stopped, and true if it
      * should be continued.
      */
     template<typename F>
     void foreachEnabledPlugin(F func, const QString &extension = {}, const QVariantMap& constraints = QVariantMap(), const QString &pluginName = {}) const
     {
         const auto currentPlugins = plugins;
         for (const auto& info : currentPlugins) {
             if ((pluginName.isEmpty() || info.pluginId() == pluginName)
                 && (extension.isEmpty() || KPluginMetaData::readStringList(info.rawData(), KEY_Interfaces()).contains(extension))
                 && constraintsMatch(info, constraints)
                 && isEnabled(info))
             {
                 if (!func(info)) {
                     break;
                 }
             }
         }
     }
 
     enum EnableState {
         DisabledByEnv,
         DisabledBySetting,
         DisabledByUnknown,
 
         FirstEnabledState,
         EnabledBySetting = FirstEnabledState,
         AlwaysEnabled
     };
 
     /**
      * Estimate enabled state of a plugin
      */
     EnableState enabledState(const KPluginMetaData& info) const
     {
         // first check black listing from environment
         static const QStringList disabledPlugins = QString::fromLatin1(qgetenv("KDEV_DISABLE_PLUGINS")).split(QLatin1Char(';'));
         if (disabledPlugins.contains(info.pluginId())) {
             return DisabledByEnv;
         }
 
         if (!isUserSelectable( info ))
             return AlwaysEnabled;
 
         // read stored user preference
         const KConfigGroup grp = Core::self()->activeSession()->config()->group( KEY_Plugins() );
         const QString pluginEnabledKey = info.pluginId() + KEY_Suffix_Enabled();
         if (grp.hasKey(pluginEnabledKey)) {
             return grp.readEntry(pluginEnabledKey, true) ? EnabledBySetting : DisabledBySetting;
         }
 
         // should not happen
         return DisabledByUnknown;
     }
 
     /**
      * Decide whether a plugin is enabled
      */
     bool isEnabled(const KPluginMetaData& info) const
     {
         return (enabledState(info) >= FirstEnabledState);
     }
 
     Core* const core;
 };
 
 PluginController::PluginController(Core *core)
     : IPluginController()
     , d_ptr(new PluginControllerPrivate(core))
 {
     Q_D(PluginController);
 
     setObjectName(QStringLiteral("PluginController"));
 
     QSet<QString> foundPlugins;
     auto newPlugins = KPluginLoader::findPlugins(QStringLiteral("kdevplatform/" QT_STRINGIFY(KDEVELOP_PLUGIN_VERSION)), [&](const KPluginMetaData& meta) {
         if (meta.serviceTypes().contains(QStringLiteral("KDevelop/Plugin"))) {
             foundPlugins.insert(meta.pluginId());
             return true;
         } else {
             qCWarning(SHELL) << "Plugin" << meta.fileName() << "is installed into the kdevplatform plugin directory, but does not have"
                 " \"KDevelop/Plugin\" set as the service type. This plugin will not be loaded.";
             return false;
         }
     });
 
     qCDebug(SHELL) << "Found" << newPlugins.size() << "plugins:" << foundPlugins;
     if (newPlugins.isEmpty()) {
         qCWarning(SHELL) << "Did not find any plugins, check your environment.";
         qCWarning(SHELL) << "  Note: QT_PLUGIN_PATH is set to:" << qgetenv("QT_PLUGIN_PATH");
     }
 
     d->plugins = newPlugins;
 
     KTextEditorIntegration::initialize();
     const QVector<KPluginMetaData> ktePlugins = KPluginLoader::findPlugins(QStringLiteral("ktexteditor"), [](const KPluginMetaData & md) {
         return md.serviceTypes().contains(QStringLiteral("KTextEditor/Plugin"))
             && md.serviceTypes().contains(QStringLiteral("KDevelop/Plugin"));
     });
 
     foundPlugins.clear();
     std::for_each(ktePlugins.cbegin(), ktePlugins.cend(), [&foundPlugins](const KPluginMetaData& data) {
         foundPlugins << data.pluginId();
     });
     qCDebug(SHELL) << "Found" << ktePlugins.size() << " KTextEditor plugins:" << foundPlugins;
 
     d->plugins.reserve(d->plugins.size() + ktePlugins.size());
     for (const auto& info : ktePlugins) {
         auto data = info.rawData();
         // temporary workaround for Kate's ctags plugin being enabled by default
         // see https://mail.kde.org/pipermail/kwrite-devel/2019-July/004821.html
         if (info.pluginId() == QLatin1String("katectagsplugin")) {
             auto kpluginData = data[KEY_KPlugin()].toObject();
             kpluginData[KEY_EnabledByDefault()] = false;
             data[KEY_KPlugin()] = kpluginData;
         }
         // add some KDevelop specific JSON data
         data[KEY_Category()] = KEY_Global();
         data[KEY_Mode()] = KEY_Gui();
         data[KEY_Version()] = KDEVELOP_PLUGIN_VERSION;
         d->plugins.append({data, info.fileName(), info.metaDataFileName()});
     }
 
     d->cleanupMode = PluginControllerPrivate::Running;
     // Register the KDevelop::IPlugin* metatype so we can properly unload it
     qRegisterMetaType<KDevelop::IPlugin*>( "KDevelop::IPlugin*" );
 }
 
 PluginController::~PluginController()
 {
     Q_D(PluginController);
 
     if ( d->cleanupMode != PluginControllerPrivate::CleanupDone ) {
         qCWarning(SHELL) << "Destructing plugin controller without going through the shutdown process!";
     }
 }
 
 KPluginMetaData PluginController::pluginInfo( const IPlugin* plugin ) const
 {
     Q_D(const PluginController);
 
     return d->loadedPlugins.key(const_cast<IPlugin*>(plugin));
 }
 
 void PluginController::cleanup()
 {
     Q_D(PluginController);
 
     if(d->cleanupMode != PluginControllerPrivate::Running)
     {
         //qCDebug(SHELL) << "called when not running. state =" << d->cleanupMode;
         return;
     }
 
     d->cleanupMode = PluginControllerPrivate::CleaningUp;
 
     // Ask all plugins to unload
     while ( !d->loadedPlugins.isEmpty() )
     {
         //Let the plugin do some stuff before unloading
         unloadPlugin(d->loadedPlugins.begin().value(), Now);
     }
 
     d->cleanupMode = PluginControllerPrivate::CleanupDone;
 }
 
 IPlugin* PluginController::loadPlugin( const QString& pluginName )
 {
     return loadPluginInternal( pluginName );
 }
 
 void PluginController::initialize()
 {
     Q_D(PluginController);
 
     QElapsedTimer timer;
     timer.start();
 
     QMap<QString, bool> pluginMap;
     if( ShellExtension::getInstance()->defaultPlugins().isEmpty() )
     {
         for (const KPluginMetaData& pi : qAsConst(d->plugins)) {
             QJsonValue enabledByDefaultValue = pi.rawData()[KEY_KPlugin()].toObject()[KEY_EnabledByDefault()];
             // plugins enabled until explicitly specified otherwise
             const bool enabledByDefault = (enabledByDefaultValue.isNull() || enabledByDefaultValue.toBool());
             pluginMap.insert(pi.pluginId(), enabledByDefault);
         }
     } else
     {
         // Get the default from the ShellExtension
         const auto defaultPlugins = ShellExtension::getInstance()->defaultPlugins();
         for (const QString& s : defaultPlugins) {
             pluginMap.insert( s, true );
         }
     }
 
     KConfigGroup grp = Core::self()->activeSession()->config()->group( KEY_Plugins() );
     QMap<QString, QString> entries = grp.entryMap();
 
     QMap<QString, QString>::Iterator it;
     for ( it = entries.begin(); it != entries.end(); ++it )
     {
         const QString key = it.key();
         if (key.endsWith(KEY_Suffix_Enabled())) {
             const QString pluginid = key.left(key.length() - 7);
             const bool defValue = pluginMap.value( pluginid, false );
             const bool enabled = grp.readEntry(key, defValue);
             pluginMap.insert( pluginid, enabled );
         }
     }
 
     // store current known set of enabled plugins
     for (const KPluginMetaData& pi : qAsConst(d->plugins)) {
         if (isUserSelectable(pi)) {
             auto it = pluginMap.constFind(pi.pluginId());
             if (it != pluginMap.constEnd() && (it.value())) {
                 grp.writeEntry(pi.pluginId() + KEY_Suffix_Enabled(), true);
             }
         } else {
             // Backward compat: Remove any now-obsolete entries
             grp.deleteEntry(pi.pluginId() + QLatin1String("Disabled"));
         }
     }
     // Synchronize so we're writing out to the file.
     grp.sync();
 
     // load global plugins
     for (const KPluginMetaData& pi : qAsConst(d->plugins)) {
         if (isGlobalPlugin(pi)) {
             loadPluginInternal(pi.pluginId());
         }
     }
 
     qCDebug(SHELL) << "Done loading plugins - took:" << timer.elapsed() << "ms";
 }
 
 QList<IPlugin *> PluginController::loadedPlugins() const
 {
     Q_D(const PluginController);
 
     return d->loadedPlugins.values();
 }
 
 bool PluginController::unloadPlugin( const QString & pluginId )
 {
     Q_D(PluginController);
 
     IPlugin *thePlugin = plugin( pluginId );
     bool canUnload = d->canUnload( d->infoForId( pluginId ) );
     qCDebug(SHELL) << "Unloading plugin:" << pluginId << "?" << thePlugin << canUnload;
     if( thePlugin && canUnload )
     {
         return unloadPlugin(thePlugin, Later);
     }
     return (canUnload && thePlugin);
 }
 
 bool PluginController::unloadPlugin(IPlugin* plugin, PluginDeletion deletion)
 {
     Q_D(PluginController);
 
     qCDebug(SHELL) << "unloading plugin:" << plugin << pluginInfo( plugin ).name();
 
     emit unloadingPlugin(plugin);
     plugin->unload();
     emit pluginUnloaded(plugin);
 
     //Remove the plugin from our list of plugins so we create a new
     //instance when we're asked for it again.
     //This is important to do right here, not later when the plugin really
     //vanishes. For example project re-opening might try to reload the plugin
     //and then would get the "old" pointer which will be deleted in the next
     //event loop run and thus causing crashes.
     for ( PluginControllerPrivate::InfoToPluginMap::Iterator it = d->loadedPlugins.begin();
             it != d->loadedPlugins.end(); ++it )
     {
         if ( it.value() == plugin )
         {
             d->loadedPlugins.erase( it );
             break;
         }
     }
 
     if (deletion == Later)
         plugin->deleteLater();
     else
         delete plugin;
     return true;
 }
 
 KPluginMetaData PluginController::infoForPluginId( const QString &pluginId ) const
 {
     Q_D(const PluginController);
 
     auto it = std::find_if(d->plugins.constBegin(), d->plugins.constEnd(), [&](const KPluginMetaData& info) {
         return (info.pluginId() == pluginId);
     });
     return (it != d->plugins.constEnd()) ? *it : KPluginMetaData();
 }
 
 IPlugin *PluginController::loadPluginInternal( const QString &pluginId )
 {
     Q_D(PluginController);
 
     QElapsedTimer timer;
     timer.start();
 
     KPluginMetaData info = infoForPluginId( pluginId );
     if ( !info.isValid() ) {
         qCWarning(SHELL) << "Unable to find a plugin named '" << pluginId << "'!" ;
         return nullptr;
     }
 
     if ( IPlugin* plugin = d->loadedPlugins.value( info ) ) {
         return plugin;
     }
 
     const auto enabledState = d->enabledState(info);
     if (enabledState < PluginControllerPrivate::FirstEnabledState) {
         // Do not load disabled plugins
         qCDebug(SHELL) << "Not loading plugin named" << pluginId << (
             (enabledState == PluginControllerPrivate::DisabledByEnv) ?
                 "because disabled by KDEV_DISABLE_PLUGINS." :
             (enabledState == PluginControllerPrivate::DisabledBySetting) ?
                 "because disabled by setting." :
             /* else, should not happen */
                 "because disabled for unknown reason.");
         return nullptr;
     }
 
     if ( !hasMandatoryProperties( info ) ) {
         qCWarning(SHELL) << "Unable to load plugin named" << pluginId << "because not all mandatory properties are set.";
         return nullptr;
     }
 
     if ( info.value(KEY_Mode()) == KEY_Gui() && Core::self()->setupFlags() == Core::NoUi ) {
         qCDebug(SHELL) << "Not loading plugin named" << pluginId
                        << "- Running in No-Ui mode, but the plugin says it needs a GUI";
         return nullptr;
     }
 
     qCDebug(SHELL) << "Attempting to load" << pluginId << "- name:" << info.name();
 
     emit loadingPlugin( info.pluginId() );
 
     // first, ensure all dependencies are available and not disabled
     // this is unrelated to whether they are loaded already or not.
     // when we depend on e.g. A and B, but B cannot be found, then we
     // do not want to load A first and then fail on B and leave A loaded.
     // this would happen if we'd skip this step here and directly loadDependencies.
     QStringList missingInterfaces;
     if ( !hasUnresolvedDependencies( info, missingInterfaces ) ) {
         qCWarning(SHELL) << "Can't load plugin" << pluginId
                    << "some of its required dependencies could not be fulfilled:"
                    << missingInterfaces.join(QLatin1Char(','));
         return nullptr;
     }
 
     // now ensure all dependencies are loaded
     QString failedDependency;
     if( !loadDependencies( info, failedDependency ) ) {
         qCWarning(SHELL) << "Can't load plugin" << pluginId
                    << "because a required dependency could not be loaded:" << failedDependency;
         return nullptr;
     }
 
     // same for optional dependencies, but don't error out if anything fails
     loadOptionalDependencies( info );
 
     // now we can finally load the plugin itself
     KPluginLoader loader(info.fileName());
     auto factory = loader.factory();
     if (!factory) {
         qCWarning(SHELL) << "Can't load plugin" << pluginId
                    << "because a factory to load the plugin could not be obtained:" << loader.errorString();
         return nullptr;
     }
 
     // now create it
     auto plugin = factory->create<IPlugin>(d->core);
     if (!plugin) {
         if (auto katePlugin = factory->create<KTextEditor::Plugin>(d->core, QVariantList() << info.pluginId())) {
             plugin = new KTextEditorIntegration::Plugin(katePlugin, d->core);
         } else {
             qCWarning(SHELL) << "Creating plugin" << pluginId << "failed.";
             return nullptr;
         }
     }
 
     KConfigGroup group = Core::self()->activeSession()->config()->group(KEY_Plugins());
     // runtime errors such as missing executables on the system or such get checked now
     if (plugin->hasError()) {
         qCWarning(SHELL) << "Could not load plugin" << pluginId << ", it reported the error:" << plugin->errorDescription()
                     << "Disabling the plugin now.";
         group.writeEntry(info.pluginId() + KEY_Suffix_Enabled(), false); // do the same as KPluginInfo did
         group.sync();
         unloadPlugin(pluginId);
         return nullptr;
     }
 
     // yay, it all worked - the plugin is loaded
     d->loadedPlugins.insert(info, plugin);
     group.writeEntry(info.pluginId() + KEY_Suffix_Enabled(), true); // do the same as KPluginInfo did
     group.sync();
     qCDebug(SHELL) << "Successfully loaded plugin" << pluginId << "from" << loader.fileName() << "- took:" << timer.elapsed() << "ms";
     emit pluginLoaded( plugin );
 
     return plugin;
 }
 
 
 IPlugin* PluginController::plugin(const QString& pluginId) const
 {
     Q_D(const PluginController);
 
     KPluginMetaData info = infoForPluginId( pluginId );
     if ( !info.isValid() )
         return nullptr;
 
     return d->loadedPlugins.value( info );
 }
 
 bool PluginController::hasUnresolvedDependencies( const KPluginMetaData& info, QStringList& missing ) const
 {
     Q_D(const PluginController);
 
-    QSet<QString> required = KPluginMetaData::readStringList(info.rawData(), KEY_Required()).toSet();
+    const QStringList requiredList = KPluginMetaData::readStringList(info.rawData(), KEY_Required());
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    QSet<QString> required(requiredList.begin(), requiredList.end());
+#else
+    QSet<QString> required = requiredList.toSet();
+#endif
     if (!required.isEmpty()) {
         d->foreachEnabledPlugin([&required] (const KPluginMetaData& plugin) -> bool {
             const auto interfaces = KPluginMetaData::readStringList(plugin.rawData(), KEY_Interfaces());
             for (const QString& iface : interfaces) {
                 required.remove(iface);
                 required.remove(iface + QLatin1Char('@') + plugin.pluginId());
             }
             return !required.isEmpty();
         });
     }
     // if we found all dependencies required should be empty now
     if (!required.isEmpty()) {
         missing = required.values();
         return false;
     }
     return true;
 }
 
 void PluginController::loadOptionalDependencies( const KPluginMetaData& info )
 {
    const QStringList dependencies = KPluginMetaData::readStringList(info.rawData(), KEY_Optional());
    for (const QString& dep : dependencies) {
         Dependency dependency(dep);
         if (!pluginForExtension(dependency.interface, dependency.pluginName)) {
             qCDebug(SHELL) << "Couldn't load optional dependency:" << dep << info.pluginId();
         }
     }
 }
 
 bool PluginController::loadDependencies( const KPluginMetaData& info, QString& failedDependency )
 {
    const QStringList dependencies = KPluginMetaData::readStringList(info.rawData(), KEY_Required());
    for (const QString& value : dependencies) {
         Dependency dependency(value);
         if (!pluginForExtension(dependency.interface, dependency.pluginName)) {
             failedDependency = value;
             return false;
         }
     }
     return true;
 }
 
 IPlugin *PluginController::pluginForExtension(const QString &extension, const QString &pluginName, const QVariantMap& constraints)
 {
     Q_D(PluginController);
 
     IPlugin* plugin = nullptr;
     d->foreachEnabledPlugin([this, &plugin] (const KPluginMetaData& info) -> bool {
         Q_D(PluginController);
 
         plugin = d->loadedPlugins.value( info );
         if( !plugin ) {
             plugin = loadPluginInternal( info.pluginId() );
         }
         return !plugin;
     }, extension, constraints, pluginName);
 
     return plugin;
 }
 
 QList<IPlugin*> PluginController::allPluginsForExtension(const QString &extension, const QVariantMap& constraints)
 {
     Q_D(PluginController);
 
     //qCDebug(SHELL) << "Finding all Plugins for Extension:" << extension << "|" << constraints;
     QList<IPlugin*> plugins;
     d->foreachEnabledPlugin([this, &plugins] (const KPluginMetaData& info) -> bool {
         Q_D(PluginController);
 
         IPlugin* plugin = d->loadedPlugins.value( info );
         if( !plugin) {
             plugin = loadPluginInternal( info.pluginId() );
         }
         if (plugin && !plugins.contains(plugin)) {
             plugins << plugin;
         }
         return true;
     }, extension, constraints);
     return plugins;
 }
 
 QVector<KPluginMetaData> PluginController::queryExtensionPlugins(const QString& extension, const QVariantMap& constraints) const
 {
     Q_D(const PluginController);
 
     QVector<KPluginMetaData> plugins;
     d->foreachEnabledPlugin([&plugins] (const KPluginMetaData& info) -> bool {
         plugins << info;
         return true;
     }, extension, constraints);
     return plugins;
 }
 
 QStringList PluginController::allPluginNames() const
 {
     Q_D(const PluginController);
 
     QStringList names;
     names.reserve(d->plugins.size());
     for (const KPluginMetaData& info : qAsConst(d->plugins)) {
         names << info.pluginId();
     }
     return names;
 }
 
 QList<ContextMenuExtension> PluginController::queryPluginsForContextMenuExtensions(KDevelop::Context* context, QWidget* parent) const
 {
     Q_D(const PluginController);
 
     // This fixes random order of extension menu items between different runs of KDevelop.
     // Without sorting we have random reordering of "Analyze With" submenu for example:
     // 1) "Cppcheck" actions, "Vera++" actions - first run
     // 2) "Vera++" actions, "Cppcheck" actions - some other run.
     QMultiMap<QString, IPlugin*> sortedPlugins;
     for (auto it = d->loadedPlugins.constBegin(); it != d->loadedPlugins.constEnd(); ++it) {
         sortedPlugins.insert(it.key().name(), it.value());
     }
 
     QList<ContextMenuExtension> exts;
     exts.reserve(sortedPlugins.size());
     for (IPlugin* plugin : qAsConst(sortedPlugins)) {
         exts << plugin->contextMenuExtension(context, parent);
     }
 
     exts << Core::self()->debugControllerInternal()->contextMenuExtension(context, parent);
     exts << Core::self()->documentationControllerInternal()->contextMenuExtension(context, parent);
     exts << Core::self()->sourceFormatterControllerInternal()->contextMenuExtension(context, parent);
     exts << Core::self()->runControllerInternal()->contextMenuExtension(context, parent);
     exts << Core::self()->projectControllerInternal()->contextMenuExtension(context, parent);
 
     return exts;
 }
 
 QStringList PluginController::projectPlugins() const
 {
     Q_D(const PluginController);
 
     QStringList names;
     for (const KPluginMetaData& info : qAsConst(d->plugins)) {
         if (info.value(KEY_Category()) == KEY_Project()) {
             names << info.pluginId();
         }
     }
     return names;
 }
 
 void PluginController::loadProjectPlugins()
 {
     const auto pluginNames = projectPlugins();
     for (const QString& name : pluginNames) {
         loadPluginInternal( name );
     }
 }
 
 void PluginController::unloadProjectPlugins()
 {
     const auto pluginNames = projectPlugins();
     for (const QString& name : pluginNames) {
         unloadPlugin( name );
     }
 }
 
 QVector<KPluginMetaData> PluginController::allPluginInfos() const
 {
     Q_D(const PluginController);
 
     return d->plugins;
 }
 
 void PluginController::updateLoadedPlugins()
 {
     Q_D(PluginController);
 
     QStringList defaultPlugins = ShellExtension::getInstance()->defaultPlugins();
     KConfigGroup grp = Core::self()->activeSession()->config()->group( KEY_Plugins() );
     for (const KPluginMetaData& info : qAsConst(d->plugins)) {
         if( isGlobalPlugin( info ) )
         {
             bool enabled = grp.readEntry(info.pluginId() + KEY_Suffix_Enabled(), ( defaultPlugins.isEmpty() || defaultPlugins.contains( info.pluginId() ) ) ) || !isUserSelectable( info );
             bool loaded = d->loadedPlugins.contains( info );
             if( loaded && !enabled )
             {
                 qCDebug(SHELL) << "unloading" << info.pluginId();
                 if( !unloadPlugin( info.pluginId() ) )
                 {
                     grp.writeEntry( info.pluginId() + KEY_Suffix_Enabled(), false );
                 }
             } else if( !loaded && enabled )
             {
                 loadPluginInternal( info.pluginId() );
             }
         }
         // TODO: what about project plugins? what about dependency plugins?
     }
 }
 
 void PluginController::resetToDefaults()
 {
     Q_D(PluginController);
 
     KSharedConfigPtr cfg = Core::self()->activeSession()->config();
     cfg->deleteGroup( KEY_Plugins() );
     cfg->sync();
     KConfigGroup grp = cfg->group( KEY_Plugins() );
     QStringList plugins = ShellExtension::getInstance()->defaultPlugins();
     if( plugins.isEmpty() )
     {
         for (const KPluginMetaData& info : qAsConst(d->plugins)) {
             if (!isUserSelectable(info)) {
                 continue;
             }
 
             QJsonValue enabledByDefault = info.rawData()[KEY_KPlugin()].toObject()[KEY_EnabledByDefault()];
             // plugins enabled until explicitly specified otherwise
             if (enabledByDefault.isNull() || enabledByDefault.toBool()) {
                 plugins << info.pluginId();
             }
         }
     }
     for (const QString& s : qAsConst(plugins)) {
         grp.writeEntry(s + KEY_Suffix_Enabled(), true);
     }
     grp.sync();
 }
 
 }
 
diff --git a/kdevplatform/shell/workingsets/workingset.cpp b/kdevplatform/shell/workingsets/workingset.cpp
index db736e3034..b5b00b2924 100644
--- a/kdevplatform/shell/workingsets/workingset.cpp
+++ b/kdevplatform/shell/workingsets/workingset.cpp
@@ -1,585 +1,595 @@
 /*
     Copyright David Nolden  <david.nolden.kdevelop@art-master.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 "workingset.h"
 #include "debug.h"
 
 #include <sublime/area.h>
 #include <sublime/mainwindow.h>
 
 #include <QPainter>
 
 #include <KProtocolInfo>
 #include <KTextEditor/Document>
 
 #include <textdocument.h>
 #include <core.h>
 #include <interfaces/isession.h>
 #include <uicontroller.h>
 #include <util/pushvalue.h>
 #include <documentcontroller.h>
 #include <workingsetcontroller.h>
 
 #define SYNC_OFTEN
 
 using namespace KDevelop;
 
 bool WorkingSet::m_loading = false;
 
 namespace {
 
 QIcon generateIcon(const WorkingSetIconParameters& params)
 {
     QImage pixmap(16, 16, QImage::Format_ARGB32);
     // fill the background with a transparent color
     pixmap.fill(QColor::fromRgba(qRgba(0, 0, 0, 0)));
     const uint coloredCount = params.coloredCount;
     // coordinates of the rectangles to draw, for 16x16 icons specifically
     QList<QRect> rects{
         {1, 1, 5, 5},
         {1, 9, 5, 5},
         {9, 1, 5, 5},
         {9, 9, 5, 5},
     };
     if ( params.swapDiagonal ) {
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 13, 0))
         rects.swapItemsAt(1, 2);
 #else
         rects.swap(1, 2);
 #endif
     }
 
     QPainter painter(&pixmap);
     // color for non-colored squares, paint them brighter if the working set is the active one
     const int inact = 40;
     QColor darkColor = QColor::fromRgb(inact, inact, inact);
     // color for colored squares
     // this code is not fragile, you can just tune the magic formulas at random and see what looks good.
     // just make sure to keep it within the 0-360 / 0-255 / 0-255 space of the HSV model
     QColor brightColor = QColor::fromHsv(params.hue, qMin<uint>(255, 215 + (params.setId*5) % 150),
                                          205 + (params.setId*11) % 50);
     // Y'UV "Y" value, the approximate "lightness" of the color
     // If it is above 0.6, then making the color darker a bit is okay,
     // if it is below 0.35, then the color should be a bit brighter.
     float brightY = 0.299 * brightColor.redF() + 0.587 * brightColor.greenF() + 0.114 * brightColor.blueF();
     if ( brightY > 0.6 ) {
         if ( params.setId % 7 < 2 ) {
             // 2/7 chance to make the color significantly darker
             brightColor = brightColor.darker(120 + (params.setId*7) % 35);
         }
         else if ( params.setId % 5 == 0 ) {
             // 1/5 chance to make it a bit darker
             brightColor = brightColor.darker(110 + (params.setId*3) % 10);
         }
     }
     if ( brightY < 0.35 ) {
         // always make the color brighter to avoid very dark colors (like rgb(0, 0, 255))
         brightColor = brightColor.lighter(120 + (params.setId*13) % 55);
     }
     int at = 0;
     for (const QRect& rect : qAsConst(rects)) {
         QColor currentColor;
         // pick the colored squares; you can get different patterns by re-ordering the "rects" list
         if ( (at + params.setId*7) % 4 < coloredCount ) {
             currentColor = brightColor;
         }
         else {
             currentColor = darkColor;
         }
         // draw the filling of the square
         painter.setPen(QColor(currentColor));
         painter.setBrush(QBrush(currentColor));
         painter.drawRect(rect);
         // draw a slight set-in shadow for the square -- it's barely recognizeable,
         // but it looks way better than without
         painter.setBrush(Qt::NoBrush);
         painter.setPen(QColor(0, 0, 0, 50));
         painter.drawRect(rect);
         painter.setPen(QColor(0, 0, 0, 25));
         painter.drawRect(rect.x() + 1, rect.y() + 1, rect.width() - 2, rect.height() - 2);
         at += 1;
     }
     return QIcon(QPixmap::fromImage(pixmap));
 }
 
 }
 
 WorkingSet::WorkingSet(const QString& id)
     : QObject()
     , m_id(id)
     , m_icon(generateIcon(WorkingSetIconParameters(id)))
 {
 }
 
 void WorkingSet::saveFromArea( Sublime::Area* a, Sublime::AreaIndex * area, KConfigGroup setGroup, KConfigGroup areaGroup )
 {
     if (area->isSplit()) {
         setGroup.writeEntry("Orientation", area->orientation() == Qt::Horizontal ? "Horizontal" : "Vertical");
 
         if (area->first()) {
             saveFromArea(a, area->first(), KConfigGroup(&setGroup, "0"), KConfigGroup(&areaGroup, "0"));
         }
 
         if (area->second()) {
             saveFromArea(a, area->second(), KConfigGroup(&setGroup, "1"), KConfigGroup(&areaGroup, "1"));
         }
     } else {
         setGroup.writeEntry("View Count", area->viewCount());
         areaGroup.writeEntry("View Count", area->viewCount());
         int index = 0;
         const auto views = area->views();
         for (Sublime::View* view : views) {
             //The working set config gets an updated list of files
             QString docSpec = view->document()->documentSpecifier();
 
             //only save the documents from protocols KIO understands
             //otherwise we try to load kdev:// too early
             if (!KProtocolInfo::isKnownProtocol(QUrl(docSpec))) {
                 continue;
             }
 
             setGroup.writeEntry(QStringLiteral("View %1").arg(index), docSpec);
             //The area specific config stores the working set documents in order along with their state
             areaGroup.writeEntry(QStringLiteral("View %1").arg(index), docSpec);
             KConfigGroup viewGroup(&areaGroup, QStringLiteral("View %1 Config").arg(index));
             view->writeSessionConfig(viewGroup);
             ++index;
         }
     }
 }
 
 bool WorkingSet::isEmpty() const
 {
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     KConfigGroup group = setConfig.group(m_id);
     return !group.hasKey("Orientation") && group.readEntry("View Count", 0) == 0;
 }
 
 struct DisableMainWindowUpdatesFromArea
 {
     explicit DisableMainWindowUpdatesFromArea(Sublime::Area* area) : m_area(area) {
         if(area) {
             const auto windows = Core::self()->uiControllerInternal()->mainWindows();
             for (Sublime::MainWindow* window : windows) {
                 if(window->area() == area) {
                     if(window->updatesEnabled()) {
                         wasUpdatesEnabled.insert(window);
                         window->setUpdatesEnabled(false);
                     }
                 }
             }
         }
     }
 
     ~DisableMainWindowUpdatesFromArea() {
         if(m_area) {
             for (Sublime::MainWindow* window : qAsConst(wasUpdatesEnabled)) {
                 window->setUpdatesEnabled(wasUpdatesEnabled.contains(window));
             }
         }
     }
 
 private:
     Q_DISABLE_COPY(DisableMainWindowUpdatesFromArea)
 
     Sublime::Area* m_area;
     QSet<Sublime::MainWindow*> wasUpdatesEnabled;
 };
 
 void loadFileList(QStringList& ret, const KConfigGroup& group)
 {
     if (group.hasKey("Orientation")) {
         QStringList subgroups = group.groupList();
 
         if (subgroups.contains(QStringLiteral("0"))) {
 
             {
                 KConfigGroup subgroup(&group, "0");
                 loadFileList(ret, subgroup);
             }
 
             if (subgroups.contains(QStringLiteral("1"))) {
                 KConfigGroup subgroup(&group, "1");
                 loadFileList(ret, subgroup);
             }
         }
 
     } else {
         int viewCount = group.readEntry("View Count", 0);
         ret.reserve(ret.size() + viewCount);
         for (int i = 0; i < viewCount; ++i) {
             QString specifier = group.readEntry(QStringLiteral("View %1").arg(i), QString());
 
             ret << specifier;
         }
     }
 }
 
 QStringList WorkingSet::fileList() const
 {
     QStringList ret;
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     KConfigGroup group = setConfig.group(m_id);
 
     loadFileList(ret, group);
     return ret;
 }
 
+QSet<QString> WorkingSet::fileSet() const
+{
+    const QStringList fileList = this->fileList();
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    return QSet<QString>(fileList.begin(), fileList.end());
+#else
+    return fileList.toSet();
+#endif
+}
+
 void WorkingSet::loadToArea(Sublime::Area* area, Sublime::AreaIndex* areaIndex) {
     PushValue<bool> enableLoading(m_loading, true);
 
     /// We cannot disable the updates here, because (probably) due to a bug in Qt,
     /// which causes the updates to stay disabled forever after some complex operations
     /// on the sub-views. This could be reproduced by creating two working-sets with complex
     /// split-view configurations and switching between them. Re-enabling the updates doesn't help.
 //     DisableMainWindowUpdatesFromArea updatesDisabler(area);
 
     qCDebug(SHELL) << "loading working-set" << m_id << "into area" << area;
 
     QMultiMap<QString, Sublime::View*> recycle;
 
     const auto viewsBefore = area->views();
     for (Sublime::View* view : viewsBefore) {
         recycle.insert( view->document()->documentSpecifier(), area->removeView(view) );
     }
 
     qCDebug(SHELL) << "recycling" << recycle.size() << "old views";
 
     Q_ASSERT( area->views().empty() );
 
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     KConfigGroup setGroup = setConfig.group(m_id);
     KConfigGroup areaGroup = setConfig.group(m_id + QLatin1Char('|') + area->title());
 
     loadToArea(area, areaIndex, setGroup, areaGroup, recycle);
 
     // Delete views which were not recycled
     qCDebug(SHELL) << "deleting " << recycle.size() << " old views";
     qDeleteAll( recycle );
 
     area->setActiveView(nullptr);
 
     //activate view in the working set
     /// @todo correctly select one out of multiple equal views
     QString activeView = areaGroup.readEntry("Active View", QString());
     const auto viewsAfter = area->views();
     for (Sublime::View* v : viewsAfter) {
         if (v->document()->documentSpecifier() == activeView) {
             area->setActiveView(v);
             break;
         }
     }
 
     if( !area->activeView() && !area->views().isEmpty() )
         area->setActiveView( area->views().at(0) );
 
     if( area->activeView() ) {
         const auto windows = Core::self()->uiControllerInternal()->mainWindows();
         for (Sublime::MainWindow* window : windows) {
                 if(window->area() == area) {
                     window->activateView( area->activeView() );
                 }
         }
     }
 }
 
 void WorkingSet::loadToArea(Sublime::Area* area, Sublime::AreaIndex* areaIndex, const KConfigGroup& setGroup, const KConfigGroup& areaGroup, QMultiMap<QString, Sublime::View*>& recycle)
 {
     Q_ASSERT( !areaIndex->isSplit() );
     if (setGroup.hasKey("Orientation")) {
         QStringList subgroups = setGroup.groupList();
         /// @todo also save and restore the ratio
 
         if (subgroups.contains(QStringLiteral("0")) && subgroups.contains(QStringLiteral("1"))) {
 //             qCDebug(SHELL) << "has zero, split:" << split;
 
             Qt::Orientation orientation = setGroup.readEntry("Orientation", "Horizontal") == QLatin1String("Vertical") ? Qt::Vertical : Qt::Horizontal;
             if(!areaIndex->isSplit()){
                 areaIndex->split(orientation);
             }else{
                 areaIndex->setOrientation(orientation);
             }
 
             loadToArea(area, areaIndex->first(), KConfigGroup(&setGroup, "0"), KConfigGroup(&areaGroup, "0"), recycle);
 
             loadToArea(area, areaIndex->second(), KConfigGroup(&setGroup, "1"), KConfigGroup(&areaGroup, "1"), recycle);
 
             if( areaIndex->first()->viewCount() == 0 )
                 areaIndex->unsplit(areaIndex->first());
             else if( areaIndex->second()->viewCount() == 0 )
                 areaIndex->unsplit(areaIndex->second());
         }
     } else {
 
         //Load all documents from the workingset into this areaIndex
         int viewCount = setGroup.readEntry("View Count", 0);
         QMap<int, Sublime::View*> createdViews;
         for (int i = 0; i < viewCount; ++i) {
             QString specifier = setGroup.readEntry(QStringLiteral("View %1").arg(i), QString());
             if (specifier.isEmpty()) {
                 continue;
             }
             Sublime::View* previousView = area->views().empty() ? nullptr : area->views().at(area->views().size() - 1);
 
             QMultiMap<QString, Sublime::View*>::iterator it = recycle.find( specifier );
             if( it != recycle.end() )
             {
                 area->addView( *it, areaIndex, previousView );
                 recycle.erase( it );
                 continue;
             }
             IDocument* doc = Core::self()->documentControllerInternal()->openDocument(QUrl::fromUserInput(specifier),
                              KTextEditor::Cursor::invalid(), IDocumentController::DoNotActivate | IDocumentController::DoNotCreateView);
             auto *document = dynamic_cast<Sublime::Document*>(doc);
             if (document) {
                 Sublime::View* view = document->createView();
                 area->addView(view, areaIndex, previousView);
                 createdViews[i] = view;
             } else {
                 qCWarning(SHELL) << "Unable to create view" << specifier;
             }
         }
 
         //Load state
         for (int i = 0; i < viewCount; ++i)
         {
             KConfigGroup viewGroup(&areaGroup, QStringLiteral("View %1 Config").arg(i));
             if (viewGroup.exists() && createdViews.contains(i))
                 createdViews[i]->readSessionConfig(viewGroup);
         }
     }
 }
 
 void deleteGroupRecursive(KConfigGroup group) {
 //     qCDebug(SHELL) << "deleting" << group.name();
     const auto entryMap = group.entryMap();
     for (auto it = entryMap.begin(), end = entryMap.end(); it != end; ++it) {
         group.deleteEntry(it.key());
     }
     Q_ASSERT(group.entryMap().isEmpty());
 
     const auto groupList = group.groupList();
     for (const QString& subGroup : groupList) {
         deleteGroupRecursive(group.group(subGroup));
         group.deleteGroup(subGroup);
     }
     //Why doesn't this work?
 //     Q_ASSERT(group.groupList().isEmpty());
     group.deleteGroup();
 }
 
 void WorkingSet::deleteSet(bool force, bool silent)
 {
     if(m_areas.isEmpty() || force) {
         emit aboutToRemove(this);
 
         KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
         KConfigGroup group = setConfig.group(m_id);
         deleteGroupRecursive(group);
 #ifdef SYNC_OFTEN
         setConfig.sync();
 #endif
 
         if(!silent)
             emit setChangedSignificantly();
     }
 }
 
 void WorkingSet::saveFromArea(Sublime::Area* area, Sublime::AreaIndex* areaIndex)
 {
     qCDebug(SHELL) << "saving" << m_id << "from area";
 
     bool wasPersistent = isPersistent();
 
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
 
     KConfigGroup setGroup = setConfig.group(m_id);
     deleteGroupRecursive(setGroup);
 
     KConfigGroup areaGroup = setConfig.group(m_id + QLatin1Char('|') + area->title());
     QString lastActiveView = areaGroup.readEntry("Active View", "");
     deleteGroupRecursive(areaGroup);
     if (area->activeView() && area->activeView()->document())
         areaGroup.writeEntry("Active View", area->activeView()->document()->documentSpecifier());
     else
         areaGroup.writeEntry("Active View", lastActiveView);
 
     saveFromArea(area, areaIndex, setGroup, areaGroup);
 
     if(isEmpty())
     {
         deleteGroupRecursive(setGroup);
         deleteGroupRecursive(areaGroup);
     }
 
     setPersistent(wasPersistent);
 
 #ifdef SYNC_OFTEN
     setConfig.sync();
 #endif
 
     emit setChangedSignificantly();
 }
 
 void WorkingSet::areaViewAdded(Sublime::AreaIndex*, Sublime::View*) {
     auto* area = qobject_cast<Sublime::Area*>(sender());
     Q_ASSERT(area);
     Q_ASSERT(area->workingSet() == m_id);
 
     qCDebug(SHELL) << "added view in" << area << ", id" << m_id;
     if (m_loading) {
         qCDebug(SHELL) << "doing nothing because loading";
         return;
     }
 
     changed(area);
 }
 
 void WorkingSet::areaViewRemoved(Sublime::AreaIndex*, Sublime::View* view) {
     auto* area = qobject_cast<Sublime::Area*>(sender());
     Q_ASSERT(area);
     Q_ASSERT(area->workingSet() == m_id);
 
     qCDebug(SHELL) << "removed view in" << area << ", id" << m_id;
     if (m_loading) {
         qCDebug(SHELL) << "doing nothing because loading";
         return;
     }
 
     const auto areasBefore = m_areas; // TODO: check if areas could be changed, otherwise use m_areas directly
     for (Sublime::Area* otherArea : areasBefore) {
         if(otherArea == area)
             continue;
         const auto otherAreaViews = otherArea->views();
         bool hadDocument = std::any_of(otherAreaViews.begin(), otherAreaViews.end(), [&](Sublime::View* otherView) {
             return (view->document() == otherView->document());
         });
 
         if(!hadDocument)
         {
             // We do this to prevent UI flicker. The view has already been removed from
             // one of the connected areas, so the working-set has already recorded the change.
             return;
         }
 
     }
 
     changed(area);
 }
 
 void WorkingSet::setPersistent(bool persistent) {
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     KConfigGroup group = setConfig.group(m_id);
     group.writeEntry("persistent", persistent);
 #ifdef SYNC_OFTEN
     group.sync();
 #endif
     qCDebug(SHELL) << "setting" << m_id << "persistent:" << persistent;
 }
 
 bool WorkingSet::isPersistent() const {
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     KConfigGroup group = setConfig.group(m_id);
     return group.readEntry("persistent", false);
 }
 
 QIcon WorkingSet::icon() const
 {
     return m_icon;
 }
 
 bool WorkingSet::isConnected( Sublime::Area* area )
 {
   return m_areas.contains( area );
 }
 
 QString WorkingSet::id() const
 {
   return m_id;
 }
 
 bool WorkingSet::hasConnectedAreas() const
 {
   return !m_areas.isEmpty();
 }
 
 bool WorkingSet::hasConnectedAreas(const QList<Sublime::Area*>& areas) const
 {
     for (Sublime::Area* area : areas) {
         if (m_areas.contains(area))
             return true;
     }
 
   return false;
 }
 
 void WorkingSet::connectArea( Sublime::Area* area )
 {
   if ( m_areas.contains( area ) ) {
     qCDebug(SHELL) << "tried to double-connect area";
     return;
   }
 
   qCDebug(SHELL) << "connecting" << m_id << "to area" << area;
 
 //         Q_ASSERT(area->workingSet() == m_id);
 
   m_areas.push_back( area );
   connect( area, &Sublime::Area::viewAdded, this, &WorkingSet::areaViewAdded );
   connect( area, &Sublime::Area::viewRemoved, this, &WorkingSet::areaViewRemoved );
 }
 
 void WorkingSet::disconnectArea( Sublime::Area* area )
 {
   if ( !m_areas.contains( area ) ) {
     qCDebug(SHELL) << "tried to disconnect not connected area";
     return;
   }
 
   qCDebug(SHELL) << "disconnecting" << m_id << "from area" << area;
 
 //         Q_ASSERT(area->workingSet() == m_id);
 
   disconnect( area, &Sublime::Area::viewAdded, this, &WorkingSet::areaViewAdded );
   disconnect( area, &Sublime::Area::viewRemoved, this, &WorkingSet::areaViewRemoved );
   m_areas.removeAll( area );
 }
 
 void WorkingSet::changed( Sublime::Area* area )
 {
   if ( m_loading ) {
     return;
   }
 
   {
     //Do not capture changes done while loading
     PushValue<bool> enableLoading( m_loading, true );
 
     qCDebug(SHELL) << "recording change done to" << m_id;
     saveFromArea( area, area->rootIndex() );
 
     for (auto& a : qAsConst(m_areas)) {
       if (a != area ) {
         loadToArea(a, a->rootIndex());
       }
     }
   }
 
   emit setChangedSignificantly();
 }
 
diff --git a/kdevplatform/shell/workingsets/workingset.h b/kdevplatform/shell/workingsets/workingset.h
index ea280ea19e..517e3d56cc 100644
--- a/kdevplatform/shell/workingsets/workingset.h
+++ b/kdevplatform/shell/workingsets/workingset.h
@@ -1,128 +1,131 @@
 /*
     Copyright David Nolden  <david.nolden.kdevelop@art-master.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.
 */
 
 #ifndef KDEVPLATFORM_WORKINGSET_H
 #define KDEVPLATFORM_WORKINGSET_H
 
 #include <QObject>
 #include <QIcon>
 #include <KConfigGroup>
 #include <QPointer>
+#include <QSet>
 
 namespace Sublime {
 class Area;
 class AreaIndex;
 class View;
 }
 
 namespace KDevelop {
 
 /// Contains all significant parameters which control the appearance of a working set icon
 struct WorkingSetIconParameters {
     explicit WorkingSetIconParameters(const QString& id)
         : setId(qHash(id) % 268435459)
         , coloredCount((setId % 15 < 4) ? 1 : (setId % 15 < 10) ? 2 : (setId % 15 == 14) ? 4 : 3)
         , hue((setId % 273 * 83) % 360)
         , swapDiagonal(setId % 31 < 16)
     { };
     // calculate layout and colors depending on the working set ID
     // modulo it so it's around 2^28, leaving some space before uint overflows
     const uint setId;
     // amount of colored squares in this icon (the rest is grey or whatever you set as default color)
     // use 4-6-4-1 weighting for 1, 2, 3, 4 squares, because that's the number of arrangements for each
     const uint coloredCount;
     const uint hue;
     bool swapDiagonal;
     // between 0 and 100, 100 = very similar, 0 = very different
     // 20 points should make a significantly different icon.
     uint similarity(const WorkingSetIconParameters& other) const {
         int sim = 100;
         uint hueDiff = qAbs<int>(hue - other.hue);
         hueDiff = hueDiff > 180 ? 360 - hueDiff : hueDiff;
         sim -= hueDiff > 35 ? 50 : (hueDiff * 50) / 180;
         if ( coloredCount != other.coloredCount ) {
             sim -= 50;
         }
         else if ( coloredCount == 2 && swapDiagonal != other.swapDiagonal ) {
             sim -= 35;
         }
         return sim;
     };
 };
 
 
 class WorkingSet : public QObject {
     Q_OBJECT
 
 public:
     explicit WorkingSet(const QString& id);
 
     bool isConnected(Sublime::Area* area);
 
     QIcon icon() const;
 
     bool isPersistent() const;
 
     void setPersistent(bool persistent);
 
     QString id() const;
 
     QStringList fileList() const;
 
+    QSet<QString> fileSet() const;
+
     bool isEmpty() const;
 
     ///Updates this working-set from the given area and area-index
     void saveFromArea(Sublime::Area* area, Sublime::AreaIndex * areaIndex);
 
     ///Loads this working-set directly from the configuration file, and stores it in the given area
     ///Does not ask the user, this should be done beforehand.
     void loadToArea(Sublime::Area* area, Sublime::AreaIndex* areaIndex);
 
     bool hasConnectedAreas() const;
 
     bool hasConnectedAreas(const QList<Sublime::Area*>& areas) const;
 
     void connectArea(Sublime::Area* area);
 
     void disconnectArea(Sublime::Area* area);
 
     void deleteSet(bool force, bool silent = false);
 
 private Q_SLOTS:
     void areaViewAdded(Sublime::AreaIndex* /*index*/, Sublime::View* /*view*/);
     void areaViewRemoved(Sublime::AreaIndex* /*index*/, Sublime::View* /*view*/);
 
 Q_SIGNALS:
     void setChangedSignificantly();
     void aboutToRemove(WorkingSet*);
 
 private:
     void changed(Sublime::Area* area);
 
     void saveFromArea(Sublime::Area* area, Sublime::AreaIndex *areaIndex, KConfigGroup setGroup, KConfigGroup areaGroup);
     void loadToArea(Sublime::Area* area, Sublime::AreaIndex *areaIndex, const KConfigGroup& setGroup, const KConfigGroup& areaGroup, QMultiMap<QString, Sublime::View*>& recycle);
 
     const QString m_id;
     const QIcon m_icon;
     QVector<QPointer<Sublime::Area>> m_areas;
     static bool m_loading;
 };
 
 }
 
 #endif // KDEVPLATFORM_WORKINGSET_H
diff --git a/kdevplatform/shell/workingsets/workingsettoolbutton.cpp b/kdevplatform/shell/workingsets/workingsettoolbutton.cpp
index 74bb3d2835..8106672835 100644
--- a/kdevplatform/shell/workingsets/workingsettoolbutton.cpp
+++ b/kdevplatform/shell/workingsets/workingsettoolbutton.cpp
@@ -1,175 +1,175 @@
 /*
     Copyright David Nolden  <david.nolden.kdevelop@art-master.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 "workingsettoolbutton.h"
 
 #include <QContextMenuEvent>
 
 #include <sublime/mainwindow.h>
 #include <sublime/area.h>
 
 #include "core.h"
 #include "mainwindow.h"
 #include "workingset.h"
 #include "workingsetcontroller.h"
 #include "workingsethelpers.h"
 #include "documentcontroller.h"
 
 #include <interfaces/idocumentcontroller.h>
 #include <util/activetooltip.h>
 
 using namespace KDevelop;
 
 WorkingSetToolButton::WorkingSetToolButton(QWidget* parent, WorkingSet* set)
     : QToolButton(parent), m_set(set), m_toolTipEnabled(true)
 {
     setFocusPolicy(Qt::NoFocus);
     setWorkingSet(set);
     setAutoRaise(true);
 
     connect(this, &WorkingSetToolButton::clicked, this, &WorkingSetToolButton::buttonTriggered);
 }
 
 WorkingSet* WorkingSetToolButton::workingSet() const
 {
     return m_set;
 }
 
 void WorkingSetToolButton::setWorkingSet(WorkingSet* set)
 {
     m_set = set;
 
     setIcon(set ? set->icon() : QIcon());
 }
 
 void WorkingSetToolButton::contextMenuEvent(QContextMenuEvent* ev)
 {
     showTooltip(ev->globalPos());
 
     ev->accept();
 }
 
 void WorkingSetToolButton::intersectSet()
 {
     Q_ASSERT(m_set);
 
     m_set->setPersistent(true);
 
-    filterViews(Core::self()->workingSetControllerInternal()->workingSet(mainWindow()->area()->workingSet())->fileList().toSet() & m_set->fileList().toSet());
+    filterViews(Core::self()->workingSetControllerInternal()->workingSet(mainWindow()->area()->workingSet())->fileSet() & m_set->fileSet());
 }
 
 void WorkingSetToolButton::subtractSet()
 {
     Q_ASSERT(m_set);
 
     m_set->setPersistent(true);
 
-    filterViews(Core::self()->workingSetControllerInternal()->workingSet(mainWindow()->area()->workingSet())->fileList().toSet() - m_set->fileList().toSet());
+    filterViews(Core::self()->workingSetControllerInternal()->workingSet(mainWindow()->area()->workingSet())->fileSet() - m_set->fileSet());
 }
 
 void WorkingSetToolButton::mergeSet()
 {
     Q_ASSERT(m_set);
 
-    const QSet<QString> loadFiles = m_set->fileList().toSet() - Core::self()->workingSetControllerInternal()->workingSet(mainWindow()->area()->workingSet())->fileList().toSet();
+    const QSet<QString> loadFiles = m_set->fileSet() - Core::self()->workingSetControllerInternal()->workingSet(mainWindow()->area()->workingSet())->fileSet();
     for (const QString& file : loadFiles) {
         Core::self()->documentController()->openDocument(QUrl::fromUserInput(file));
     }
 }
 
 void WorkingSetToolButton::duplicateSet()
 {
     Q_ASSERT(m_set);
 
     if(!Core::self()->documentControllerInternal()->saveAllDocumentsForWindow(mainWindow(), KDevelop::IDocument::Default, true))
         return;
     WorkingSet* set = Core::self()->workingSetControllerInternal()->newWorkingSet(QStringLiteral("clone"));
     set->setPersistent(true);
     set->saveFromArea(mainWindow()->area(), mainWindow()->area()->rootIndex());
     mainWindow()->area()->setWorkingSet(set->id());
 }
 
 void WorkingSetToolButton::loadSet()
 {
     Q_ASSERT(m_set);
 
     m_set->setPersistent(true);
 
     if(!Core::self()->documentControllerInternal()->saveAllDocumentsForWindow(mainWindow(), KDevelop::IDocument::Default, true))
         return;
     mainWindow()->area()->setWorkingSet(QString(m_set->id()));
 }
 
 void WorkingSetToolButton::closeSet(bool ask)
 {
     Q_ASSERT(m_set);
 
     m_set->setPersistent(true);
     m_set->saveFromArea(mainWindow()->area(), mainWindow()->area()->rootIndex());
 
     if(ask && !Core::self()->documentControllerInternal()->saveAllDocumentsForWindow(mainWindow(), KDevelop::IDocument::Default, true))
         return;
     mainWindow()->area()->setWorkingSet(QString());
 }
 
 bool WorkingSetToolButton::event(QEvent* e)
 {
     if(m_toolTipEnabled && e->type() == QEvent::ToolTip) {
         auto* helpEvent = static_cast<QHelpEvent*>(e);
         showTooltip(helpEvent->globalPos());
         e->accept();
         return true;
     }
 
     return QToolButton::event(e);
 }
 
 void WorkingSetToolButton::showTooltip(const QPoint& globalPos)
 {
     Q_ASSERT(m_set);
     static WorkingSetToolButton* oldTooltipButton;
 
     WorkingSetController* controller = Core::self()->workingSetControllerInternal();
 
     if(controller->tooltip() && oldTooltipButton == this)
         return;
 
     oldTooltipButton = this;
 
     controller->showToolTip(m_set, globalPos + QPoint(10, 20));
 
     QRect extended(parentWidget()->mapToGlobal(geometry().topLeft()),
                     parentWidget()->mapToGlobal(geometry().bottomRight()));
     controller->tooltip()->setHandleRect(extended);
 }
 
 void WorkingSetToolButton::buttonTriggered()
 {
     Q_ASSERT(m_set);
 
     if(mainWindow()->area()->workingSet() == m_set->id()) {
         showTooltip(QCursor::pos());
     }else{
         //Only close the working-set if the file was saved before
         if(!Core::self()->documentControllerInternal()->saveAllDocumentsForWindow(mainWindow(), KDevelop::IDocument::Default, true))
             return;
         m_set->setPersistent(true);
         mainWindow()->area()->setWorkingSet(m_set->id());
     }
 }
 
diff --git a/kdevplatform/shell/workingsets/workingsettooltipwidget.cpp b/kdevplatform/shell/workingsets/workingsettooltipwidget.cpp
index 8165c09c2c..ae7eb9376c 100644
--- a/kdevplatform/shell/workingsets/workingsettooltipwidget.cpp
+++ b/kdevplatform/shell/workingsets/workingsettooltipwidget.cpp
@@ -1,393 +1,393 @@
 /*
     Copyright David Nolden  <david.nolden.kdevelop@art-master.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 "workingsettooltipwidget.h"
 
 #include <KLocalizedString>
 
 #include <QPushButton>
 #include <QVBoxLayout>
 
 #include "debug.h"
 #include "core.h"
 #include "documentcontroller.h"
 #include "mainwindow.h"
 
 #include <sublime/view.h>
 #include <sublime/mainwindow.h>
 #include <sublime/area.h>
 #include <sublime/document.h>
 
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iuicontroller.h>
 #include <util/activetooltip.h>
 
 #include "workingset.h"
 #include "workingsetcontroller.h"
 #include "workingsetfilelabel.h"
 #include "workingsettoolbutton.h"
 #include "workingsethelpers.h"
 
 using namespace KDevelop;
 
 class FileWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     QToolButton* m_button;
     class WorkingSetFileLabel* m_label;
 };
 
 WorkingSetToolTipWidget::WorkingSetToolTipWidget(QWidget* parent, WorkingSet* set, MainWindow* mainwindow) : QWidget(parent), m_set(set) {
     auto* layout = new QVBoxLayout(this);
     layout->setSpacing(0);
 
     layout->setMargin(0);
 
     connect(mainwindow->area(),
             &Sublime::Area::viewAdded, this, &WorkingSetToolTipWidget::updateFileButtons,
             Qt::QueuedConnection);
     connect(mainwindow->area(),
             &Sublime::Area::viewRemoved, this, &WorkingSetToolTipWidget::updateFileButtons,
             Qt::QueuedConnection);
 
     connect(Core::self()->workingSetControllerInternal(), &WorkingSetController::workingSetSwitched,
             this, &WorkingSetToolTipWidget::updateFileButtons);
 
     // title bar
     {
         auto* topLayout = new QHBoxLayout;
         m_setButton = new WorkingSetToolButton(this, set);
         m_setButton->hide();
 
         topLayout->addSpacing(5);
         QLabel* icon = new QLabel;
         topLayout->addWidget(icon);
         topLayout->addSpacing(5);
 
         QString label;
         if (m_set->isConnected(mainwindow->area())) {
             label = i18n("<b>Active Working Set</b>");
         } else {
             label = i18n("<b>Working Set</b>");
         }
         QLabel* name = new QLabel(label);
         name->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
         topLayout->addWidget(name);
          topLayout->addSpacing(10);
 
         icon->setPixmap(m_setButton->icon().pixmap(name->sizeHint().height()+8, name->sizeHint().height()+8));
 
         topLayout->addStretch();
 
         m_openButton = new QPushButton;
         m_openButton->setFlat(true);
         topLayout->addWidget(m_openButton);
 
         m_deleteButton = new QPushButton;
         m_deleteButton->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
         m_deleteButton->setText(i18n("Delete"));
         m_deleteButton->setToolTip(i18n("Remove this working set. The contained documents are not affected."));
         m_deleteButton->setFlat(true);
         connect(m_deleteButton, &QPushButton::clicked, m_set, [&] { m_set->deleteSet(false); });
         connect(m_deleteButton, &QPushButton::clicked, this, &WorkingSetToolTipWidget::shouldClose);
         topLayout->addWidget(m_deleteButton);
         layout->addLayout(topLayout);
         // horizontal line
         QFrame* line = new QFrame();
         line->setFrameShape(QFrame::HLine);
         line->setFrameShadow(QFrame::Raised);
         layout->addWidget(line);
     }
 
     // everything else is added to the following widget which just has a different background color
     auto* bodyLayout = new QVBoxLayout;
     {
         QWidget* body = new QWidget();
         body->setLayout(bodyLayout);
         layout->addWidget(body);
         body->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
     }
 
     // document list actions
     {
         auto* actionsLayout = new QHBoxLayout;
 
         m_documentsLabel = new QLabel(i18n("Documents:"));
         m_documentsLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
         actionsLayout->addWidget(m_documentsLabel);
 
         actionsLayout->addStretch();
 
         m_mergeButton = new QPushButton;
         m_mergeButton->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
         m_mergeButton->setText(i18n("Add All"));
         m_mergeButton->setToolTip(i18n("Add all documents that are part of this working set to the currently active working set."));
         m_mergeButton->setFlat(true);
         connect(m_mergeButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::mergeSet);
         actionsLayout->addWidget(m_mergeButton);
 
         m_subtractButton = new QPushButton;
         m_subtractButton->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
         m_subtractButton->setText(i18n("Remove All"));
         m_subtractButton->setToolTip(i18n("Remove all documents that are part of this working set from the currently active working set."));
         m_subtractButton->setFlat(true);
         connect(m_subtractButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::subtractSet);
         actionsLayout->addWidget(m_subtractButton);
         bodyLayout->addLayout(actionsLayout);
     }
 
     QSet<QString> hadFiles;
 
     auto* filesLayout = new QVBoxLayout;
     filesLayout->setMargin(0);
 
     const auto setFiles = m_set->fileList();
     for (const QString& file : setFiles) {
 
         if(hadFiles.contains(file))
             continue;
 
         hadFiles.insert(file);
 
         auto* widget = new FileWidget;
         widget->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
 
         auto* fileLayout = new QHBoxLayout(widget);
 
         auto* plusButton = new QToolButton;
         plusButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Maximum);
         fileLayout->addWidget(plusButton);
 
         auto* fileLabel = new WorkingSetFileLabel;
         fileLabel->setTextFormat(Qt::RichText);
         // We add spaces behind and after, to make it look nicer
         fileLabel->setText(QLatin1String("&nbsp;") + Core::self()->projectController()->prettyFileName(QUrl::fromUserInput(file)) + QLatin1String("&nbsp;"));
         fileLabel->setToolTip(i18nc("@info:tooltip", "Click to open and activate this document."));
         fileLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
         fileLayout->addWidget(fileLabel);
         fileLayout->setMargin(0);
 
         plusButton->setMaximumHeight(fileLabel->sizeHint().height() + 4);
         plusButton->setMaximumWidth(plusButton->maximumHeight());
 
         plusButton->setObjectName(file);
         fileLabel->setObjectName(file);
         fileLabel->setCursor(QCursor(Qt::PointingHandCursor));
 
         widget->m_button = plusButton;
         widget->m_label = fileLabel;
 
         filesLayout->addWidget(widget);
         m_fileWidgets.insert(file, widget);
         m_orderedFileWidgets.push_back(widget);
 
         connect(plusButton, &QToolButton::clicked, this, &WorkingSetToolTipWidget::buttonClicked);
         connect(fileLabel, &WorkingSetFileLabel::clicked, this, &WorkingSetToolTipWidget::labelClicked);
     }
 
     bodyLayout->addLayout(filesLayout);
 
     updateFileButtons();
     connect(set, &WorkingSet::setChangedSignificantly, this, &WorkingSetToolTipWidget::updateFileButtons);
     connect(mainwindow->area(), &Sublime::Area::changedWorkingSet, this, &WorkingSetToolTipWidget::updateFileButtons, Qt::QueuedConnection);
 
     QMetaObject::invokeMethod(this, "updateFileButtons");
 }
 
 void WorkingSetToolTipWidget::nextDocument()
 {
     int active = -1;
     for(int a = 0; a < m_orderedFileWidgets.size(); ++a)
         if(m_orderedFileWidgets[a]->m_label->isActive())
             active = a;
 
     if(active == -1)
     {
         qCWarning(SHELL) << "Found no active document";
         return;
     }
 
     int next = (active + 1) % m_orderedFileWidgets.size();
     while(m_orderedFileWidgets[next]->isHidden() && next != active)
         next = (next + 1) % m_orderedFileWidgets.size();
 
     m_orderedFileWidgets[next]->m_label->emitClicked();
 }
 
 void WorkingSetToolTipWidget::previousDocument()
 {
     int active = -1;
     for(int a = 0; a < m_orderedFileWidgets.size(); ++a)
         if(m_orderedFileWidgets[a]->m_label->isActive())
             active = a;
 
     if(active == -1)
     {
         qCWarning(SHELL) << "Found no active document";
         return;
     }
 
     int next = active - 1;
     if(next < 0)
         next += m_orderedFileWidgets.size();
 
     while(m_orderedFileWidgets[next]->isHidden() && next != active)
     {
         next -= 1;
         if(next < 0)
             next += m_orderedFileWidgets.size();
     }
 
     m_orderedFileWidgets[next]->m_label->emitClicked();
 }
 
 
 void WorkingSetToolTipWidget::updateFileButtons()
 {
     auto* mainWindow = qobject_cast<MainWindow*>(Core::self()->uiController()->activeMainWindow());
     Q_ASSERT(mainWindow);
 
     WorkingSetController* controller = Core::self()->workingSetControllerInternal();
     ActiveToolTip* tooltip = controller->tooltip();
 
     QString activeFile;
     if(mainWindow->area()->activeView())
         activeFile = mainWindow->area()->activeView()->document()->documentSpecifier();
 
     WorkingSet* currentWorkingSet = nullptr;
     QSet<QString> openFiles;
 
     if(!mainWindow->area()->workingSet().isEmpty())
     {
         currentWorkingSet = controller->workingSet(mainWindow->area()->workingSet());
-        openFiles = currentWorkingSet->fileList().toSet();
+        openFiles = currentWorkingSet->fileSet();
     }
 
     bool allOpen = true;
     bool noneOpen = true;
 
     bool needResize = false;
 
     bool allHidden = true;
 
     for(QMap< QString, FileWidget* >::iterator it = m_fileWidgets.begin(); it != m_fileWidgets.end(); ++it) {
         if(openFiles.contains(it.key())) {
             noneOpen = false;
             (*it)->m_button->setToolTip(i18n("Remove this file from the current working set"));
             (*it)->m_button->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
             (*it)->show();
         }else{
             allOpen = false;
             (*it)->m_button->setToolTip(i18n("Add this file to the current working set"));
             (*it)->m_button->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
             if(currentWorkingSet == m_set)
             {
                 (*it)->hide();
                 needResize = true;
             }
         }
 
 
         if(!(*it)->isHidden())
             allHidden = false;
 
         (*it)->m_label->setIsActiveFile(it.key() == activeFile);
     }
 
     // NOTE: always hide merge&subtract all on current working set
     // if we want to enable mergeButton, we have to fix it's behavior since it operates directly on the
     // set contents and not on the m_fileWidgets
     m_mergeButton->setHidden(allOpen || currentWorkingSet == m_set);
     m_subtractButton->setHidden(noneOpen || currentWorkingSet == m_set);
     m_deleteButton->setHidden(m_set->hasConnectedAreas());
     m_documentsLabel->setHidden(m_mergeButton->isHidden() && m_subtractButton->isHidden() && m_deleteButton->isHidden());
 
     if(currentWorkingSet == m_set) {
         disconnect(m_openButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::loadSet);
         connect(m_openButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::closeSet);
         connect(m_openButton, &QPushButton::clicked, this, &WorkingSetToolTipWidget::shouldClose);
         m_openButton->setIcon(QIcon::fromTheme(QStringLiteral("project-development-close")));
         m_openButton->setText(i18n("Stash"));
     }else{
         disconnect(m_openButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::closeSet);
         connect(m_openButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::loadSet);
         disconnect(m_openButton, &QPushButton::clicked, this, &WorkingSetToolTipWidget::shouldClose);
         m_openButton->setIcon(QIcon::fromTheme(QStringLiteral("project-open")));
         m_openButton->setText(i18n("Load"));
     }
 
     if(allHidden && tooltip)
         tooltip->hide();
 
     if(needResize && tooltip)
         tooltip->resize(tooltip->sizeHint());
 }
 
 void WorkingSetToolTipWidget::buttonClicked(bool)
 {
     QPointer<WorkingSetToolTipWidget> stillExists(this);
 
     auto* s = qobject_cast<QToolButton*>(sender());
     Q_ASSERT(s);
 
     auto* mainWindow = qobject_cast<MainWindow*>(Core::self()->uiController()->activeMainWindow());
     Q_ASSERT(mainWindow);
-    QSet<QString> openFiles = Core::self()->workingSetControllerInternal()->workingSet(mainWindow->area()->workingSet())->fileList().toSet();
+    QSet<QString> openFiles = Core::self()->workingSetControllerInternal()->workingSet(mainWindow->area()->workingSet())->fileSet();
 
     if(!openFiles.contains(s->objectName())) {
         Core::self()->documentControllerInternal()->openDocument(QUrl::fromUserInput(s->objectName()));
     }else{
         openFiles.remove(s->objectName());
         filterViews(openFiles);
     }
 
     if(stillExists)
         updateFileButtons();
 }
 
 void WorkingSetToolTipWidget::labelClicked()
 {
     QPointer<WorkingSetToolTipWidget> stillExists(this);
 
     auto* s = qobject_cast<WorkingSetFileLabel*>(sender());
     Q_ASSERT(s);
 
     bool found = false;
 
     auto* window = static_cast<Sublime::MainWindow*>(ICore::self()->uiController()->activeMainWindow());
 
     const auto views = window->area()->views();
     for (Sublime::View* view : views) {
         if(view->document()->documentSpecifier() == s->objectName())
         {
             window->activateView(view);
             found = true;
             break;
         }
     }
 
     if(!found)
         Core::self()->documentControllerInternal()->openDocument(QUrl::fromUserInput(s->objectName()));
 
     if(stillExists)
         updateFileButtons();
 }
 
 #include "workingsettooltipwidget.moc"
diff --git a/kdevplatform/sublime/mainwindow_p.h b/kdevplatform/sublime/mainwindow_p.h
index a0d59583ac..27a2e07adb 100644
--- a/kdevplatform/sublime/mainwindow_p.h
+++ b/kdevplatform/sublime/mainwindow_p.h
@@ -1,162 +1,169 @@
 /***************************************************************************
  *   Copyright 2006-2007 Alexander Dymo  <adymo@kdevelop.org>       *
  *                                                                         *
  *   This program 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 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 Library 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.         *
  ***************************************************************************/
 #ifndef KDEVPLATFORM_SUBLIMEMAINWINDOW_P_H
 #define KDEVPLATFORM_SUBLIMEMAINWINDOW_P_H
 
 #include <QMap>
 #include <QObject>
 #include <QPointer>
 #include <QSet>
 
 #include "area.h"
 #include "sublimedefs.h"
 
 #include "mainwindow.h"
 #include <QPushButton>
 
 class QAction;
 class QSplitter;
 class IdealToolBar;
 
 namespace Sublime {
 
 class View;
 class Container;
 class Controller;
 class AreaIndex;
 class IdealMainWidget;
 class IdealController;
 class MessageWidget;
 class Message;
 
 class MainWindowPrivate: public QObject {
     Q_OBJECT
 public:
     MainWindowPrivate(MainWindow *w, Controller* controller);
     ~MainWindowPrivate() override;
 
     /**Use this to create tool views for an area.*/
     class IdealToolViewCreator {
     public:
         explicit IdealToolViewCreator(MainWindowPrivate *_d): d(_d) {}
         Area::WalkerMode operator() (View *view, Sublime::Position position);
     private:
         MainWindowPrivate* const d;
     };
 
     /**Use this to create views for an area.*/
     class ViewCreator {
     public:
-        explicit ViewCreator(MainWindowPrivate *_d, const QList<View*>& _topViews = QList<View*>()): d(_d), topViews(_topViews.toSet()) {}
+        explicit ViewCreator(MainWindowPrivate *_d, const QList<View*>& _topViews = QList<View*>())
+            : d(_d)
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+            , topViews(_topViews.begin(), _topViews.end())
+#else
+            , topViews(_topViews.toSet())
+#endif
+        {}
         Area::WalkerMode operator() (AreaIndex *index);
     private:
         MainWindowPrivate* const d;
         const QSet<View*> topViews;
     };
 
     /**Reconstructs the mainwindow according to the current area.*/
     void reconstruct();
     /**Reconstructs the views according to the current area index.*/
     void reconstructViews(const QList<View*>& topViews = QList<View*>());
     /**Clears the area leaving mainwindow empty.*/
     void clearArea();
     
     /** Sets a @p w widget that will be shown when there are no documents on the area */
     void setBackgroundCentralWidget(QWidget* w);
 
     void activateFirstVisibleView();
 
     Controller* const controller;
     Area *area;
     QList<View*> docks;
     QMap<View*, Container*> viewContainers;
     QMap<QWidget*, View*> widgetToView;
 
     View *activeView;
     View *activeToolView;
 
     QWidget *centralWidget;
     QWidget* bgCentralWidget;
     MessageWidget* messageWidget;
     ViewBarContainer* viewBarContainer;
     QSplitter* splitterCentralWidget;
 
     IdealController *idealController;
     bool ignoreDockShown;
     bool autoAreaSettingsSave;
 
     bool eventFilter(QObject* obj, QEvent* event) override;
     void disableConcentrationMode();
 
     void postMessage(Message* message);
 
 public Q_SLOTS:
     void toggleDocksShown();
 
     void viewAdded(Sublime::AreaIndex *index, Sublime::View *view);
     void viewRemovedInternal(Sublime::AreaIndex *index, Sublime::View *view);
     void raiseToolView(Sublime::View* view);
     void aboutToRemoveView(Sublime::AreaIndex *index, Sublime::View *view);
     void toolViewAdded(Sublime::View *toolView, Sublime::Position position);
     void aboutToRemoveToolView(Sublime::View *toolView, Sublime::Position position);
     void toolViewMoved(Sublime::View *toolView, Sublime::Position position);
 
     void setTabBarLeftCornerWidget(QWidget* widget);
 
 private Q_SLOTS:
     void updateAreaSwitcher(Sublime::Area *area);
     void slotDockShown(Sublime::View*, Sublime::Position, bool);
     void widgetCloseRequest(QWidget* widget);
 
     void showLeftDock(bool b);
     void showRightDock(bool b);
     void showBottomDock(bool b);
     void focusEditor();
     void selectNextDock();
     void selectPreviousDock();
 
     void messageDestroyed(Message* message);
 
 private:
     void restoreConcentrationMode();
 
     void setBackgroundVisible(bool v);
     Qt::DockWidgetArea positionToDockArea(Position position);
     void cleanCentralWidget();
 
     MainWindow* const m_mainWindow;
     // uses QPointer to make already-deleted splitters detectable
     QMap<AreaIndex*, QPointer<QSplitter> > m_indexSplitters;
 
     QMap<Area*, QAction*> m_areaActions;
     QPointer<QWidget> m_leftTabbarCornerWidget;
     QPointer<QToolBar> m_concentrateToolBar;
     IdealToolBar* m_bottomToolBar;
     IdealToolBar* m_rightToolBar;
     IdealToolBar* m_leftToolBar;
 
     QAction* m_concentrationModeAction;
 
     QHash<Message*, QVector<QSharedPointer<QAction>>> m_messageHash;
 };
 
 }
 
 #endif
 
diff --git a/kdevplatform/util/environmentselectionmodel.cpp b/kdevplatform/util/environmentselectionmodel.cpp
index e37592f149..a4b80742f6 100644
--- a/kdevplatform/util/environmentselectionmodel.cpp
+++ b/kdevplatform/util/environmentselectionmodel.cpp
@@ -1,111 +1,121 @@
 /* This file is part of KDevelop
 Copyright 2013 Ivan Shapovalov <intelfx100@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 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 "environmentselectionmodel.h"
 
 #include <KLocalizedString>
 
 namespace {
 
 QStringList entriesFromEnv(const KDevelop::EnvironmentProfileList& env)
 {
     // We add an empty (i. e. default profile) entry to the front of the model's list.
     return QStringList(QString()) + env.profileNames();
 }
 
 }
 
 namespace KDevelop {
 
 EnvironmentSelectionModel::EnvironmentSelectionModel(QObject* parent) :
     QStringListModel(parent)
     , m_env(KSharedConfig::openConfig())
 {
-    setStringList(entriesFromEnv(m_env));
-    m_profilesLookupTable = stringList().toSet();
+    const QStringList entries = entriesFromEnv(m_env);
+    setStringList(entries);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    m_profilesLookupTable = QSet<QString>(entries.begin(), entries.end());
+#else
+    m_profilesLookupTable = entries.toSet();
+#endif
 }
 
 QVariant EnvironmentSelectionModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (section != 0 ||
         orientation != Qt::Horizontal ||
         role != Qt::DisplayRole) {
         return QVariant();
     }
 
     return i18nc("@title:column", "Profile");
 }
 
 QVariant EnvironmentSelectionModel::data(const QModelIndex& index, int role) const
 {
     QVariant nativeData = QStringListModel::data(index, Qt::DisplayRole);
     QString profileName = nativeData.toString();
 
     switch (role) {
     case Qt::DisplayRole:
         if (profileName.isEmpty()) {
             return i18nc("@item:inlistbox", "Use default profile (currently: %1)", m_env.defaultProfileName());
         }
 
         if (!m_profilesLookupTable.contains(profileName)) {
             return i18nc("@item:inlistbox", "%1 (does not exist)", profileName);
         }
 
         return nativeData;
 
     case EffectiveNameRole:
         if (profileName.isEmpty()) {
             return m_env.defaultProfileName();
         }
 
         return nativeData;
 
     default:
         return QStringListModel::data(index, role);
     }
 }
 
 bool EnvironmentSelectionModel::setData(const QModelIndex& /*index*/, const QVariant& /*value*/, int /*role*/)
 {
     return false;
 }
 
 EnvironmentProfileList EnvironmentSelectionModel::environmentProfiles() const
 {
     return m_env;
 }
 
 void EnvironmentSelectionModel::reload()
 {
     m_env = EnvironmentProfileList(KSharedConfig::openConfig());
 
-    setStringList(entriesFromEnv(m_env));
-    m_profilesLookupTable = stringList().toSet();
+    const QStringList entries = entriesFromEnv(m_env);
+    setStringList(entries);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    m_profilesLookupTable = QSet<QString>(entries.begin(), entries.end());
+#else
+    m_profilesLookupTable = entries.toSet();
+#endif
 }
 
 QString EnvironmentSelectionModel::reloadSelectedItem(const QString& currentProfile)
 {
     if (m_profilesLookupTable.contains(currentProfile)) {
         return currentProfile;
     } else {
         return QString();
     }
 }
 
 } // namespace KDevelop
diff --git a/kdevplatform/vcs/models/vcsfilechangesmodel.cpp b/kdevplatform/vcs/models/vcsfilechangesmodel.cpp
index 1507cece59..061595e1ca 100644
--- a/kdevplatform/vcs/models/vcsfilechangesmodel.cpp
+++ b/kdevplatform/vcs/models/vcsfilechangesmodel.cpp
@@ -1,310 +1,314 @@
 /*  This file is part of KDevelop
     Copyright 2010 Aleix Pol <aleixpol@kde.org>
 
     Split into separate class
     Copyright 2011 Andrey Batyiev <batyiev@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 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 "vcsfilechangesmodel.h"
 
 #include "debug.h"
 
 #include <QIcon>
 #include <QMimeDatabase>
 
 #include <KLocalizedString>
 
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 
 #include <vcs/vcsstatusinfo.h>
 
 namespace KDevelop
 {
 
 static QString stateToString(KDevelop::VcsStatusInfo::State state)
 {
     switch(state)
     {
         case KDevelop::VcsStatusInfo::ItemAdded:
             return i18nc("file was added to versioncontrolsystem", "Added");
         case KDevelop::VcsStatusInfo::ItemDeleted:
             return i18nc("file was deleted from versioncontrolsystem", "Deleted");
         case KDevelop::VcsStatusInfo::ItemHasConflicts:
             return i18nc("file is conflicting (versioncontrolsystem)", "Has Conflicts");
         case KDevelop::VcsStatusInfo::ItemModified:
             return i18nc("version controlled file was modified", "Modified");
         case KDevelop::VcsStatusInfo::ItemUpToDate:
             return i18nc("file is up to date in versioncontrolsystem", "Up To Date");
         case KDevelop::VcsStatusInfo::ItemUnknown:
         case KDevelop::VcsStatusInfo::ItemUserState:
             return i18nc("file is not known to versioncontrolsystem", "Unknown");
     }
     return i18nc("Unknown VCS file status, probably a backend error", "?");
 }
 
 static QIcon stateToIcon(KDevelop::VcsStatusInfo::State state)
 {
     switch(state)
     {
         case KDevelop::VcsStatusInfo::ItemAdded:
             return QIcon::fromTheme(QStringLiteral("vcs-added"));
         case KDevelop::VcsStatusInfo::ItemDeleted:
             return QIcon::fromTheme(QStringLiteral("vcs-removed"));
         case KDevelop::VcsStatusInfo::ItemHasConflicts:
             return QIcon::fromTheme(QStringLiteral("vcs-conflicting"));
         case KDevelop::VcsStatusInfo::ItemModified:
             return QIcon::fromTheme(QStringLiteral("vcs-locally-modified"));
         case KDevelop::VcsStatusInfo::ItemUpToDate:
             return QIcon::fromTheme(QStringLiteral("vcs-normal"));
         case KDevelop::VcsStatusInfo::ItemUnknown:
         case KDevelop::VcsStatusInfo::ItemUserState:
             return QIcon::fromTheme(QStringLiteral("unknown"));
     }
     return QIcon::fromTheme(QStringLiteral("dialog-error"));
 }
 
 VcsFileChangesSortProxyModel::VcsFileChangesSortProxyModel(QObject* parent)
     : QSortFilterProxyModel(parent)
 {
 }
 
 bool VcsFileChangesSortProxyModel::lessThan(const QModelIndex& source_left, const QModelIndex& source_right) const
 {
     const auto leftStatus = source_left.data(VcsFileChangesModel::StateRole).value<VcsStatusInfo::State>();
     const auto rightStatus = source_right.data(VcsFileChangesModel::StateRole).value<VcsStatusInfo::State>();
     if (leftStatus != rightStatus) {
         return leftStatus < rightStatus;
     }
 
     const QString leftPath = source_left.data(VcsFileChangesModel::UrlRole).toString();
     const QString rightPath = source_right.data(VcsFileChangesModel::UrlRole).toString();
     return QString::localeAwareCompare(leftPath, rightPath) < 0;
 }
 
 class VcsStatusInfoItem : public QStandardItem
 {
 public:
     explicit VcsStatusInfoItem(const VcsStatusInfo& info)
         : QStandardItem()
         , m_info(info) {}
 
     void setStatus(const VcsStatusInfo& info) {
         m_info = info;
         emitDataChanged();
     }
 
     QVariant data(int role) const override
     {
         switch(role) {
             case Qt::DisplayRole:
                 return stateToString(m_info.state());
             case Qt::DecorationRole:
                 return stateToIcon(m_info.state());
             case VcsFileChangesModel::VcsStatusInfoRole:
                 return QVariant::fromValue(m_info);
             case VcsFileChangesModel::UrlRole:
                 return m_info.url();
             case VcsFileChangesModel::StateRole:
                 return QVariant::fromValue(m_info.state());
         }
         return {};
     }
 
 private:
     VcsStatusInfo m_info;
 };
 
 class VcsFileChangesModelPrivate
 {
 public:
     bool allowSelection;
 };
 
 VcsFileChangesModel::VcsFileChangesModel(QObject *parent, bool allowSelection)
     : QStandardItemModel(parent)
     , d_ptr(new VcsFileChangesModelPrivate{allowSelection})
 {
     setColumnCount(2);
     setHeaderData(0, Qt::Horizontal, i18n("Filename"));
     setHeaderData(1, Qt::Horizontal, i18n("Status"));
 }
 
 VcsFileChangesModel::~VcsFileChangesModel()
 {
 }
 
 int VcsFileChangesModel::updateState(QStandardItem *parent, const KDevelop::VcsStatusInfo &status)
 {
      Q_D(VcsFileChangesModel);
 
    if(status.state()==VcsStatusInfo::ItemUnknown || status.state()==VcsStatusInfo::ItemUpToDate) {
         removeUrl(status.url());
         return -1;
     } else {
         QStandardItem* item = fileItemForUrl(parent, status.url());
         if(!item) {
             QString path = ICore::self()->projectController()->prettyFileName(status.url(), KDevelop::IProjectController::FormatPlain);
             QMimeType mime = status.url().isLocalFile()
                 ? QMimeDatabase().mimeTypeForFile(status.url().toLocalFile(), QMimeDatabase::MatchExtension)
                 : QMimeDatabase().mimeTypeForUrl(status.url());
             QIcon icon = QIcon::fromTheme(mime.iconName());
             item = new QStandardItem(icon, path);
             auto itStatus = new VcsStatusInfoItem(status);
 
             if(d->allowSelection) {
                 item->setCheckable(true);
                 item->setCheckState(status.state() == VcsStatusInfo::ItemUnknown ? Qt::Unchecked : Qt::Checked);
             }
 
             parent->appendRow({ item, itStatus });
         } else {
             QStandardItem *parent = item->parent();
             if(parent == nullptr)
                 parent = invisibleRootItem();
             auto statusInfoItem = static_cast<VcsStatusInfoItem*>(parent->child(item->row(), 1));
             statusInfoItem->setStatus(status);
         }
 
         return item->row();
     }
 }
 
 QVariant VcsFileChangesModel::data(const QModelIndex &index, int role) const
 {
     if (role >= VcsStatusInfoRole && index.column()==0) {
         return QStandardItemModel::data(index.sibling(index.row(), 1), role);
     }
     return QStandardItemModel::data(index, role);
 }
 
 QStandardItem* VcsFileChangesModel::fileItemForUrl(QStandardItem* parent, const QUrl& url) const
 {
     Q_ASSERT(parent);
     if (!parent) {
         qCWarning(VCS) << "null QStandardItem passed to" << Q_FUNC_INFO;
         return nullptr;
     }
 
     for(int i=0, c=parent->rowCount(); i<c; i++) {
         QStandardItem* item = parent->child(i);
         if(indexFromItem(item).data(UrlRole).toUrl() == url) {
             return parent->child(i);
         }
     }
     return nullptr;
 }
 
 void VcsFileChangesModel::setAllChecked(bool checked)
 {
     Q_D(VcsFileChangesModel);
 
     if(!d->allowSelection)
         return;
     QStandardItem* parent = invisibleRootItem();
     for(int i = 0, c = parent->rowCount(); i < c; i++) {
         QStandardItem* item = parent->child(i);
         item->setCheckState(checked ? Qt::Checked : Qt::Unchecked);
     }
 }
 
 QList<QUrl> VcsFileChangesModel::checkedUrls(QStandardItem *parent) const
 {
     Q_D(const VcsFileChangesModel);
 
     Q_ASSERT(parent);
     if (!parent) {
         qCWarning(VCS) << "null QStandardItem passed to" << Q_FUNC_INFO;
         return {};
     }
 
     QList<QUrl> ret;
     for(int i = 0, c = parent->rowCount(); i < c; i++) {
         QStandardItem* item = parent->child(i);
         if(!d->allowSelection || item->checkState() == Qt::Checked) {
             ret << indexFromItem(item).data(UrlRole).toUrl();
         }
     }
     return ret;
 }
 
 QList<QUrl> VcsFileChangesModel::urls(QStandardItem *parent) const
 {
     Q_ASSERT(parent);
     if (!parent) {
         qCWarning(VCS) << "null QStandardItem passed to" << Q_FUNC_INFO;
         return {};
     }
 
     QList<QUrl> ret;
     const int c = parent->rowCount();
     ret.reserve(c);
     for (int i = 0; i < c; i++) {
         QStandardItem* item = parent->child(i);
         ret << indexFromItem(item).data(UrlRole).toUrl();
     }
     return ret;
 }
 
 void VcsFileChangesModel::checkUrls(QStandardItem *parent, const QList<QUrl>& urls) const
 {
     Q_D(const VcsFileChangesModel);
 
     Q_ASSERT(parent);
     if (!parent) {
         qCWarning(VCS) << "null QStandardItem passed to" << Q_FUNC_INFO;
         return;
     }
 
     if(!d->allowSelection)
         return;
 
-    QSet<QUrl> urlSet(urls.toSet());
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    const QSet<QUrl> urlSet(urls.begin(), urls.end());
+#else
+    const QSet<QUrl> urlSet(urls.toSet());
+#endif
     for(int i = 0, c = parent->rowCount(); i < c; i++) {
         QStandardItem* item = parent->child(i);
         item->setCheckState(urlSet.contains(indexFromItem(item).data(UrlRole).toUrl()) ?
             Qt::Checked :
             Qt::Unchecked);
     }
 }
 
 void VcsFileChangesModel::setIsCheckbable(bool checkable)
 {
     Q_D(VcsFileChangesModel);
 
     d->allowSelection = checkable;
 }
 
 bool VcsFileChangesModel::isCheckable() const
 {
     Q_D(const VcsFileChangesModel);
 
     return d->allowSelection;
 }
 
 bool VcsFileChangesModel::removeUrl(const QUrl& url)
 {
     const auto matches = match(index(0, 0), UrlRole, url, 1, Qt::MatchExactly);
     if (matches.isEmpty())
         return false;
 
     const auto& idx = matches.first();
     return removeRow(idx.row(), idx.parent());
 }
 
 }
diff --git a/plugins/cmake/cmakeutils.cpp b/plugins/cmake/cmakeutils.cpp
index b3fba48749..ed445c9b76 100644
--- a/plugins/cmake/cmakeutils.cpp
+++ b/plugins/cmake/cmakeutils.cpp
@@ -1,742 +1,747 @@
 /* KDevelop CMake Support
  *
  * Copyright 2009 Andreas Pakulat <apaku@gmx.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 "cmakeutils.h"
 #include "cmakeprojectdata.h"
 
 #include <QFileInfo>
 #include <QDir>
 #include <QProcess>
 #include <QTemporaryDir>
 #include <QRegularExpression>
 
 #include <KShell>
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <project/projectmodel.h>
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iruntimecontroller.h>
 #include <interfaces/iruntime.h>
 #include <interfaces/iplugincontroller.h>
 #include <QStandardPaths>
 
 #include "icmakedocumentation.h"
 #include "cmakebuilddirchooser.h"
 #include "settings/cmakecachemodel.h"
 #include "debug.h"
 #include "cmakebuilderconfig.h"
 #include <cmakecachereader.h>
 #include "parser/cmakelistsparser.h"
 
 using namespace KDevelop;
 
 namespace Config
 {
 namespace Old
 {
 static const QString currentBuildDirKey = QStringLiteral("CurrentBuildDir");
 static const QString oldcmakeExecutableKey = QStringLiteral("CMake Binary"); // Todo: Remove at some point
 static const QString currentBuildTypeKey = QStringLiteral("CurrentBuildType");
 static const QString currentInstallDirKey = QStringLiteral("CurrentInstallDir");
 static const QString currentEnvironmentKey = QStringLiteral("CurrentEnvironment");
 static const QString currentExtraArgumentsKey = QStringLiteral("Extra Arguments");
 static const QString currentCMakeExecutableKey = QStringLiteral("Current CMake Binary");
 static const QString projectRootRelativeKey = QStringLiteral("ProjectRootRelative");
 static const QString projectBuildDirs = QStringLiteral("BuildDirs");
 }
 
 static const QString buildDirIndexKey_ = QStringLiteral("Current Build Directory Index");
 static const QString buildDirOverrideIndexKey = QStringLiteral("Temporary Build Directory Index");
 static const QString buildDirCountKey = QStringLiteral("Build Directory Count");
 
 //the used builddir will change for every runtime
 static QString buildDirIndexKey() {
     const QString currentRuntime = ICore::self()->runtimeController()->currentRuntime()->name();
     return buildDirIndexKey_ + QLatin1Char('-') + currentRuntime;
 }
 
 namespace Specific
 {
 static const QString buildDirPathKey = QStringLiteral("Build Directory Path");
 // TODO: migrate to more generic & consistent key term "CMake Executable"
 // Support the old "CMake Binary" key too for backwards compatibility during
 // a reasonable transition period. Both keys are saved at least until 5.2.0
 // is released. Import support for the old key will need to remain for a
 // considerably longer period, ideally.
 static const QString cmakeBinaryKey = QStringLiteral("CMake Binary");
 static const QString cmakeExecutableKey = QStringLiteral("CMake Executable");
 static const QString cmakeBuildTypeKey = QStringLiteral("Build Type");
 static const QString cmakeInstallDirKey = QStringLiteral("Install Directory");
 static const QString cmakeEnvironmentKey = QStringLiteral("Environment Profile");
 static const QString cmakeArgumentsKey = QStringLiteral("Extra Arguments");
 static const QString buildDirRuntime = QStringLiteral("Runtime");
 }
 
 static const QString groupNameBuildDir = QStringLiteral("CMake Build Directory %1");
 static const QString groupName = QStringLiteral("CMake");
 
 } // namespace Config
 
 namespace
 {
 
 KConfigGroup baseGroup( KDevelop::IProject* project )
 {
     if (!project)
         return KConfigGroup();
 
     return project->projectConfiguration()->group( Config::groupName );
 }
 
 KConfigGroup buildDirGroup( KDevelop::IProject* project, int buildDirIndex )
 {
     return baseGroup(project).group( Config::groupNameBuildDir.arg(buildDirIndex) );
 }
 
 bool buildDirGroupExists( KDevelop::IProject* project, int buildDirIndex )
 {
     return baseGroup(project).hasGroup( Config::groupNameBuildDir.arg(buildDirIndex) );
 }
 
 QString readBuildDirParameter( KDevelop::IProject* project, const QString& key, const QString& aDefault, int buildDirectory )
 {
     const int buildDirIndex = buildDirectory<0 ? CMake::currentBuildDirIndex(project) : buildDirectory;
     if (buildDirIndex >= 0)
         return buildDirGroup( project, buildDirIndex ).readEntry( key, aDefault );
 
     else
         return aDefault;
 }
 
 void writeBuildDirParameter( KDevelop::IProject* project, const QString& key, const QString& value )
 {
     int buildDirIndex = CMake::currentBuildDirIndex(project);
     if (buildDirIndex >= 0)
     {
         KConfigGroup buildDirGrp = buildDirGroup( project, buildDirIndex );
         buildDirGrp.writeEntry( key, value );
     }
 
     else
     {
         qCWarning(CMAKE) << "cannot write key" << key << "(" << value << ")" << "when no builddir is set!";
     }
 }
 
 void writeProjectBaseParameter( KDevelop::IProject* project, const QString& key, const QString& value )
 {
     KConfigGroup baseGrp = baseGroup(project);
     baseGrp.writeEntry( key, value );
 }
 
 void setBuildDirRuntime( KDevelop::IProject* project, const QString& name)
 {
     writeBuildDirParameter(project, Config::Specific::buildDirRuntime, name);
 }
 
 QString buildDirRuntime( KDevelop::IProject* project, int builddir)
 {
     return readBuildDirParameter(project, Config::Specific::buildDirRuntime, QString(), builddir);
 }
 
 } // namespace
 
 namespace CMake
 {
 
 KDevelop::Path::List resolveSystemDirs(KDevelop::IProject* project, const QStringList& dirs)
 {
     const KDevelop::Path buildDir(CMake::currentBuildDir(project));
     const KDevelop::Path installDir(CMake::currentInstallDir(project));
 
     KDevelop::Path::List newList;
     newList.reserve(dirs.size());
     for (const QString& s : dirs) {
         KDevelop::Path dir;
         if(s.startsWith(QLatin1String("#[bin_dir]")))
         {
             dir = KDevelop::Path(buildDir, s);
         }
         else if(s.startsWith(QLatin1String("#[install_dir]")))
         {
             dir = KDevelop::Path(installDir, s);
         }
         else
         {
             dir = KDevelop::Path(s);
         }
 
 //         qCDebug(CMAKE) << "resolved" << s << "to" << d;
 
         if (!newList.contains(dir))
         {
             newList.append(dir);
         }
     }
     return newList;
 }
 
 ///NOTE: when you change this, update @c defaultConfigure in cmakemanagertest.cpp
 bool checkForNeedingConfigure( KDevelop::IProject* project )
 {
     auto currentRuntime = ICore::self()->runtimeController()->currentRuntime();
     const QString currentRuntimeName = currentRuntime->name();
     const KDevelop::Path builddir = currentBuildDir(project);
     const bool isValid = (buildDirRuntime(project, -1) == currentRuntimeName || buildDirRuntime(project, -1).isEmpty()) && builddir.isValid();
 
     if( !isValid )
     {
         auto addBuildDir = [project](const KDevelop::Path& buildFolder, const KDevelop::Path& installPrefix, const QString &extraArguments, const QString &buildType, const KDevelop::Path &cmakeExecutable){
             int addedBuildDirIndex = buildDirCount( project ); // old count is the new index
 
             // Initialize the kconfig items with the values from the dialog, this ensures the settings
             // end up in the config file once the changes are saved
             qCDebug(CMAKE) << "adding to cmake config: new builddir index" << addedBuildDirIndex;
             qCDebug(CMAKE) << "adding to cmake config: builddir path " << buildFolder;
             qCDebug(CMAKE) << "adding to cmake config: installdir " << installPrefix;
             qCDebug(CMAKE) << "adding to cmake config: extra args" << extraArguments;
             qCDebug(CMAKE) << "adding to cmake config: build type " << buildType;
             qCDebug(CMAKE) << "adding to cmake config: cmake executable " << cmakeExecutable;
             qCDebug(CMAKE) << "adding to cmake config: environment <null>";
             CMake::setBuildDirCount( project, addedBuildDirIndex + 1 );
             CMake::setCurrentBuildDirIndex( project, addedBuildDirIndex );
             CMake::setCurrentBuildDir( project, buildFolder );
             CMake::setCurrentInstallDir( project, installPrefix );
             CMake::setCurrentExtraArguments( project, extraArguments );
             CMake::setCurrentBuildType( project, buildType );
             CMake::setCurrentCMakeExecutable(project, cmakeExecutable );
             CMake::setCurrentEnvironment( project, QString() );
         };
 
         if (!currentRuntime->buildPath().isEmpty()) {
             const Path newBuilddir(currentRuntime->buildPath(), QLatin1String("build-") + currentRuntimeName + project->name());
             const Path installPath(QString::fromUtf8(currentRuntime->getenv("KDEV_DEFAULT_INSTALL_PREFIX")));
 
             addBuildDir(newBuilddir, installPath, {}, QStringLiteral("Debug"), {});
             setBuildDirRuntime( project, currentRuntimeName );
             return true;
         }
 
         CMakeBuildDirChooser bd;
         bd.setProject( project );
         const auto builddirs = CMake::allBuildDirs(project);
         bd.setAlreadyUsed( builddirs );
         bd.setShowAvailableBuildDirs(!builddirs.isEmpty());
         bd.setCMakeExecutable(currentCMakeExecutable(project));
 
         if( !bd.exec() )
         {
             return false;
         }
 
         if (bd.reuseBuilddir())
         {
             CMake::setCurrentBuildDirIndex( project, bd.alreadyUsedIndex() );
         }
         else
         {
             addBuildDir(bd.buildFolder(), bd.installPrefix(), bd.extraArguments(), bd.buildType(), bd.cmakeExecutable());
         }
         setBuildDirRuntime( project, currentRuntimeName );
 
         return true;
     } else if( !QFile::exists( KDevelop::Path(builddir, QStringLiteral("CMakeCache.txt")).toLocalFile() ) ||
                 //TODO: maybe we could use the builder for that?
                !(QFile::exists( KDevelop::Path(builddir, QStringLiteral("Makefile")).toLocalFile() ) ||
                     QFile::exists( KDevelop::Path(builddir, QStringLiteral("build.ninja")).toLocalFile() ) ) )
     {
         // User entered information already, but cmake hasn't actually been run yet.
         setBuildDirRuntime( project, currentRuntimeName );
         return true;
     }
     setBuildDirRuntime( project, currentRuntimeName );
     return false;
 }
 
 QHash<KDevelop::Path, QStringList> enumerateTargets(const KDevelop::Path& targetsFilePath, const QString& sourceDir, const KDevelop::Path &buildDir)
 {
     const QString buildPath = buildDir.toLocalFile();
     QHash<KDevelop::Path, QStringList> targets;
     QFile targetsFile(targetsFilePath.toLocalFile());
     if (!targetsFile.open(QIODevice::ReadOnly)) {
         qCDebug(CMAKE) << "Couldn't find the Targets file in" << targetsFile.fileName();
     }
 
     QTextStream targetsFileStream(&targetsFile);
     const QRegularExpression rx(QStringLiteral("^(.*)/CMakeFiles/(.*).dir$"));
     while (!targetsFileStream.atEnd()) {
         const QString line = targetsFileStream.readLine();
         auto match = rx.match(line);
         if (!match.isValid())
             qCDebug(CMAKE) << "invalid match for" << line;
         const QString sourcePath = match.captured(1).replace(buildPath, sourceDir);
         targets[KDevelop::Path(sourcePath)].append(match.captured(2));
     }
     return targets;
 }
 
 KDevelop::Path projectRoot(KDevelop::IProject* project)
 {
     if (!project) {
         return {};
     }
 
     return project->path().cd(CMake::projectRootRelative(project));
 }
 
 KDevelop::Path currentBuildDir( KDevelop::IProject* project, int builddir )
 {
     return KDevelop::Path(readBuildDirParameter( project, Config::Specific::buildDirPathKey, QString(), builddir ));
 }
 
 KDevelop::Path commandsFile(KDevelop::IProject* project)
 {
     auto currentBuildDir = CMake::currentBuildDir(project);
     if (currentBuildDir.isEmpty()) {
         return {};
     }
 
     return KDevelop::Path(currentBuildDir, QStringLiteral("compile_commands.json"));
 }
 
 KDevelop::Path targetDirectoriesFile(KDevelop::IProject* project)
 {
     auto currentBuildDir = CMake::currentBuildDir(project);
     if (currentBuildDir.isEmpty()) {
         return {};
     }
 
     return KDevelop::Path(currentBuildDir, QStringLiteral("CMakeFiles/TargetDirectories.txt"));
 }
 
 QString currentBuildType( KDevelop::IProject* project, int builddir )
 {
     return readBuildDirParameter( project, Config::Specific::cmakeBuildTypeKey, QStringLiteral("Release"), builddir );
 }
 
 QString findExecutable()
 {
     auto cmake = QStandardPaths::findExecutable(QStringLiteral("cmake"));
 #ifdef Q_OS_WIN
     if (cmake.isEmpty())
         cmake = QStandardPaths::findExecutable(QStringLiteral("cmake"), {
             QStringLiteral("C:\\Program Files (x86)\\CMake\\bin"),
             QStringLiteral("C:\\Program Files\\CMake\\bin"),
             QStringLiteral("C:\\Program Files (x86)\\CMake 2.8\\bin"),
             QStringLiteral("C:\\Program Files\\CMake 2.8\\bin")});
 #endif
     return cmake;
 }
 
 KDevelop::Path currentCMakeExecutable(KDevelop::IProject* project, int builddir)
 {
     auto defaultCMakeExecutable = CMakeBuilderSettings::self()->cmakeExecutable().toLocalFile();
 
     if (!QFileInfo::exists(ICore::self()->runtimeController()->currentRuntime()->pathInHost(KDevelop::Path(defaultCMakeExecutable)).toLocalFile()))
         defaultCMakeExecutable = CMake::findExecutable();
 
     if (project) {
         // check for "CMake Executable" but for now also "CMake Binary", falling back to the default.
         auto projectCMakeExecutable = readBuildDirParameter( project, Config::Specific::cmakeExecutableKey,
             readBuildDirParameter( project, Config::Specific::cmakeBinaryKey, defaultCMakeExecutable, builddir),
             builddir );
         if (projectCMakeExecutable != defaultCMakeExecutable) {
             QFileInfo info(projectCMakeExecutable);
             if (!info.isExecutable()) {
                 projectCMakeExecutable = defaultCMakeExecutable;
             }
         }
         return KDevelop::Path(projectCMakeExecutable);
     }
     return KDevelop::Path(defaultCMakeExecutable);
 }
 
 KDevelop::Path currentInstallDir( KDevelop::IProject* project, int builddir )
 {
     return KDevelop::Path(readBuildDirParameter( project, Config::Specific::cmakeInstallDirKey, QString(), builddir ));
 }
 
 QString projectRootRelative( KDevelop::IProject* project )
 {
     return baseGroup(project).readEntry( Config::Old::projectRootRelativeKey, "." );
 }
 
 bool hasProjectRootRelative(KDevelop::IProject* project)
 {
     return baseGroup(project).hasKey( Config::Old::projectRootRelativeKey );
 }
 
 QString currentExtraArguments( KDevelop::IProject* project, int builddir )
 {
     return readBuildDirParameter( project, Config::Specific::cmakeArgumentsKey, QString(), builddir );
 }
 
 void setCurrentInstallDir( KDevelop::IProject* project, const KDevelop::Path& path )
 {
     writeBuildDirParameter( project, Config::Specific::cmakeInstallDirKey, path.toLocalFile() );
 }
 
 void setCurrentBuildType( KDevelop::IProject* project, const QString& type )
 {
     writeBuildDirParameter( project, Config::Specific::cmakeBuildTypeKey, type );
 }
 
 void setCurrentCMakeExecutable(KDevelop::IProject* project, const KDevelop::Path& path)
 {
     // maintain compatibility with older versions for now
     writeBuildDirParameter(project, Config::Specific::cmakeBinaryKey, path.toLocalFile());
     writeBuildDirParameter(project, Config::Specific::cmakeExecutableKey, path.toLocalFile());
 }
 
 void setCurrentBuildDir( KDevelop::IProject* project, const KDevelop::Path& path )
 {
     writeBuildDirParameter( project, Config::Specific::buildDirPathKey, path.toLocalFile() );
 }
 
 void setProjectRootRelative( KDevelop::IProject* project, const QString& relative)
 {
     writeProjectBaseParameter( project, Config::Old::projectRootRelativeKey, relative );
 }
 
 void setCurrentExtraArguments( KDevelop::IProject* project, const QString& string)
 {
     writeBuildDirParameter( project, Config::Specific::cmakeArgumentsKey, string );
 }
 
 QString currentEnvironment(KDevelop::IProject* project, int builddir)
 {
     return readBuildDirParameter( project, Config::Specific::cmakeEnvironmentKey, QString(), builddir );
 }
 
 int currentBuildDirIndex( KDevelop::IProject* project )
 {
     KConfigGroup baseGrp = baseGroup(project);
 
     if ( baseGrp.hasKey( Config::buildDirOverrideIndexKey ) )
         return baseGrp.readEntry<int>( Config::buildDirOverrideIndexKey, -1 );
 
     else if (baseGrp.hasKey(Config::buildDirIndexKey()))
         return baseGrp.readEntry<int>( Config::buildDirIndexKey(), -1 );
     else
         return baseGrp.readEntry<int>( Config::buildDirIndexKey_, -1 ); // backwards compatibility
 }
 
 void setCurrentBuildDirIndex( KDevelop::IProject* project, int buildDirIndex )
 {
     writeProjectBaseParameter( project, Config::buildDirIndexKey(), QString::number (buildDirIndex) );
 }
 
 void setCurrentEnvironment( KDevelop::IProject* project, const QString& environment )
 {
     writeBuildDirParameter( project, Config::Specific::cmakeEnvironmentKey, environment );
 }
 
 void initBuildDirConfig( KDevelop::IProject* project )
 {
     int buildDirIndex = currentBuildDirIndex( project );
     if (buildDirCount(project) <= buildDirIndex )
         setBuildDirCount( project, buildDirIndex + 1 );
 }
 
 int buildDirCount( KDevelop::IProject* project )
 {
     return baseGroup(project).readEntry<int>( Config::buildDirCountKey, 0 );
 }
 
 void setBuildDirCount( KDevelop::IProject* project, int count )
 {
     writeProjectBaseParameter( project, Config::buildDirCountKey, QString::number(count) );
 }
 
 void removeBuildDirConfig( KDevelop::IProject* project )
 {
     int buildDirIndex = currentBuildDirIndex( project );
     if ( !buildDirGroupExists( project, buildDirIndex ) )
     {
         qCWarning(CMAKE) << "build directory config" << buildDirIndex << "to be removed but does not exist";
         return;
     }
 
     int bdCount = buildDirCount(project);
     setBuildDirCount( project, bdCount - 1 );
     removeOverrideBuildDirIndex( project );
     setCurrentBuildDirIndex( project, -1 );
 
     // move (rename) the upper config groups to keep the numbering
     // if there's nothing to move, just delete the group physically
     if (buildDirIndex + 1 == bdCount)
         buildDirGroup( project, buildDirIndex ).deleteGroup();
 
     else for (int i = buildDirIndex + 1; i < bdCount; ++i)
     {
         KConfigGroup src = buildDirGroup( project, i );
         KConfigGroup dest = buildDirGroup( project, i - 1 );
         dest.deleteGroup();
         src.copyTo(&dest);
         src.deleteGroup();
     }
 }
 
 QHash<QString, QString> readCacheValues(const KDevelop::Path& cmakeCachePath, QSet<QString> variables)
 {
     QHash<QString, QString> ret;
     QFile file(cmakeCachePath.toLocalFile());
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         qCWarning(CMAKE) << "couldn't open CMakeCache.txt" << cmakeCachePath;
         return ret;
     }
 
     QTextStream in(&file);
     while (!in.atEnd() && !variables.isEmpty())
     {
         QString line = in.readLine().trimmed();
         if(!line.isEmpty() && line[0].isLetter())
         {
             CacheLine c;
             c.readLine(line);
 
             if(!c.isCorrect())
                 continue;
 
             if (variables.remove(c.name())) {
                 ret[c.name()] = c.value();
             }
         }
     }
     return ret;
 }
 
 void updateConfig( KDevelop::IProject* project, int buildDirIndex)
 {
     if (buildDirIndex < 0)
         return;
 
     KConfigGroup buildDirGrp = buildDirGroup( project, buildDirIndex );
     const KDevelop::Path builddir(buildDirGrp.readEntry( Config::Specific::buildDirPathKey, QString() ));
     const KDevelop::Path cacheFilePath( builddir, QStringLiteral("CMakeCache.txt"));
 
     const QMap<QString, QString> keys = {
         { QStringLiteral("CMAKE_COMMAND"), Config::Specific::cmakeExecutableKey },
         { QStringLiteral("CMAKE_INSTALL_PREFIX"), Config::Specific::cmakeInstallDirKey },
         { QStringLiteral("CMAKE_BUILD_TYPE"), Config::Specific::cmakeBuildTypeKey }
     };
 
-    const QHash<QString, QString> cacheValues = readCacheValues(cacheFilePath, keys.keys().toSet());
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    const QSet<QString> variables(keys.constKeyValueBegin(), keys.constKeyValueEnd());
+#else
+    const QSet<QString> variables = keys.keys().toSet();
+#endif
+    const QHash<QString, QString> cacheValues = readCacheValues(cacheFilePath, variables);
     for(auto it = cacheValues.constBegin(), itEnd = cacheValues.constEnd(); it!=itEnd; ++it) {
         const QString key = keys.value(it.key());
         Q_ASSERT(!key.isEmpty());
 
         // Use cache only when the config value is not set. Without this check we will always
         // overwrite values provided by the user in config dialog.
         if (buildDirGrp.readEntry(key).isEmpty() && !it.value().isEmpty())
         {
             buildDirGrp.writeEntry( key, it.value() );
         }
     }
 }
 
 void attemptMigrate( KDevelop::IProject* project )
 {
     if ( !baseGroup(project).hasKey( Config::Old::projectBuildDirs ) )
     {
         qCDebug(CMAKE) << "CMake settings migration: already done, exiting";
         return;
     }
 
     KConfigGroup baseGrp = baseGroup(project);
 
     KDevelop::Path buildDir( baseGrp.readEntry( Config::Old::currentBuildDirKey, QString() ) );
     int buildDirIndex = -1;
     const QStringList existingBuildDirs = baseGrp.readEntry( Config::Old::projectBuildDirs, QStringList() );
     {
         // also, find current build directory in this list (we need an index, not path)
         QString currentBuildDirCanonicalPath = QDir( buildDir.toLocalFile() ).canonicalPath();
 
         for( int i = 0; i < existingBuildDirs.count(); ++i )
         {
             const QString& nextBuildDir = existingBuildDirs.at(i);
             if( QDir(nextBuildDir).canonicalPath() == currentBuildDirCanonicalPath )
             {
                 buildDirIndex = i;
             }
         }
     }
     int buildDirsCount = existingBuildDirs.count();
 
     qCDebug(CMAKE) << "CMake settings migration: existing build directories" << existingBuildDirs;
     qCDebug(CMAKE) << "CMake settings migration: build directory count" << buildDirsCount;
     qCDebug(CMAKE) << "CMake settings migration: current build directory" << buildDir << "(index" << buildDirIndex << ")";
 
     baseGrp.writeEntry( Config::buildDirCountKey, buildDirsCount );
     baseGrp.writeEntry( Config::buildDirIndexKey(), buildDirIndex );
 
     for (int i = 0; i < buildDirsCount; ++i)
     {
         qCDebug(CMAKE) << "CMake settings migration: writing group" << i << ": path" << existingBuildDirs.at(i);
 
         KConfigGroup buildDirGrp = buildDirGroup( project, i );
         buildDirGrp.writeEntry( Config::Specific::buildDirPathKey, existingBuildDirs.at(i) );
     }
 
     baseGrp.deleteEntry( Config::Old::currentBuildDirKey );
     baseGrp.deleteEntry( Config::Old::currentCMakeExecutableKey );
     baseGrp.deleteEntry( Config::Old::currentBuildTypeKey );
     baseGrp.deleteEntry( Config::Old::currentInstallDirKey );
     baseGrp.deleteEntry( Config::Old::currentEnvironmentKey );
     baseGrp.deleteEntry( Config::Old::currentExtraArgumentsKey );
     baseGrp.deleteEntry( Config::Old::projectBuildDirs );
 }
 
 void setOverrideBuildDirIndex( KDevelop::IProject* project, int overrideBuildDirIndex )
 {
     writeProjectBaseParameter( project, Config::buildDirOverrideIndexKey, QString::number(overrideBuildDirIndex) );
 }
 
 void removeOverrideBuildDirIndex( KDevelop::IProject* project, bool writeToMainIndex )
 {
     KConfigGroup baseGrp = baseGroup(project);
 
     if( !baseGrp.hasKey(Config::buildDirOverrideIndexKey) )
         return;
     if( writeToMainIndex )
         baseGrp.writeEntry( Config::buildDirIndexKey(), baseGrp.readEntry(Config::buildDirOverrideIndexKey) );
 
     baseGrp.deleteEntry(Config::buildDirOverrideIndexKey);
 }
 
 ICMakeDocumentation* cmakeDocumentation()
 {
     return KDevelop::ICore::self()->pluginController()->extensionForPlugin<ICMakeDocumentation>(QStringLiteral("org.kdevelop.ICMakeDocumentation"));
 }
 
 QStringList allBuildDirs(KDevelop::IProject* project)
 {
     QStringList result;
     int bdCount = buildDirCount(project);
     result.reserve(bdCount);
     for (int i = 0; i < bdCount; ++i)
         result += buildDirGroup( project, i ).readEntry( Config::Specific::buildDirPathKey );
     return result;
 }
 
 QString executeProcess(const QString& execName, const QStringList& args)
 {
     Q_ASSERT(!execName.isEmpty());
     qCDebug(CMAKE) << "Executing:" << execName << "::" << args;
 
     QProcess p;
     QTemporaryDir tmp(QStringLiteral("kdevcmakemanager"));
     p.setWorkingDirectory( tmp.path() );
     p.start(execName, args, QIODevice::ReadOnly);
 
     if(!p.waitForFinished())
     {
         qCDebug(CMAKE) << "failed to execute:" << execName << args << p.exitStatus() << p.readAllStandardError();
     }
 
     QByteArray b = p.readAllStandardOutput();
     QString t = QString::fromUtf8(b.trimmed());
     return t;
 }
 
 QStringList supportedGenerators()
 {
     QStringList generatorNames;
 
     bool hasNinja = ICore::self() && ICore::self()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IProjectBuilder"), QStringLiteral("KDevNinjaBuilder"));
     if (hasNinja)
         generatorNames << QStringLiteral("Ninja");
 
 #ifdef Q_OS_WIN
     // Visual Studio solution is the standard generator under windows, but we don't want to use
     // the VS IDE, so we need nmake makefiles
     generatorNames << QStringLiteral("NMake Makefiles") << QStringLiteral("MinGW Makefiles");
 #endif
     generatorNames << QStringLiteral("Unix Makefiles");
 
     return generatorNames;
 }
 
 QString defaultGenerator()
 {
     const QStringList generatorNames = supportedGenerators();
 
     QString defGen = generatorNames.value(CMakeBuilderSettings::self()->generator());
     if (defGen.isEmpty())
     {
         qCWarning(CMAKE) << "Couldn't find builder with index " << CMakeBuilderSettings::self()->generator()
                    << ", defaulting to 0";
         CMakeBuilderSettings::self()->setGenerator(0);
         defGen = generatorNames.at(0);
     }
     return defGen;
 }
 
 QVector<Test> importTestSuites(const Path &buildDir, const QString &cmakeTestFileName)
 {
     const auto cmakeTestFile = Path(buildDir, cmakeTestFileName).toLocalFile()  ;
     const auto contents = CMakeListsParser::readCMakeFile(cmakeTestFile);
     
     QVector<Test> tests;
     for (const auto& entry: contents) {
         if (entry.name == QLatin1String("add_test")) {
             auto args = entry.arguments;
             Test test;
             test.name = args.takeFirst().value;
             test.executable = args.takeFirst().value;
             test.arguments = kTransform<QStringList>(args, [](const CMakeFunctionArgument& arg) { return arg.value; });
             tests += test;
         } else if (entry.name == QLatin1String("subdirs")) {
             tests += importTestSuites(Path(buildDir, entry.arguments.first().value));
         } else if (entry.name == QLatin1String("include")) {
             // Include directive points directly to a .cmake file hosting the tests
             tests += importTestSuites(Path(buildDir, entry.arguments.first().value), QString());
         } else if (entry.name == QLatin1String("set_tests_properties")) {
             if(entry.arguments.count() < 4 || entry.arguments.count() % 2) {
                 qCWarning(CMAKE) << "found set_tests_properties() with unexpected number of arguments:"
                                  << entry.arguments.count();
                 continue;
             }
             if (tests.isEmpty() || entry.arguments.first().value != tests.last().name) {
                 qCWarning(CMAKE) << "found set_tests_properties(" << entry.arguments.first().value
                                  << " ...), but expected test " << tests.last().name;
                 continue;
             }
             if (entry.arguments[1].value != QLatin1String("PROPERTIES")) {
                 qCWarning(CMAKE) << "found set_tests_properties(" << entry.arguments.first().value
                                  << entry.arguments.at(1).value << "...), but expected PROPERTIES as second argument";
                 continue;
             }
             Test &test = tests.last();
             for (int i = 2; i < entry.arguments.count(); i += 2)
                 test.properties[entry.arguments[i].value] = entry.arguments[i + 1].value;
         }
     }
 
     return tests;
 }
 
 QVector<Test> importTestSuites(const Path &buildDir) {
     return importTestSuites(buildDir, QStringLiteral("CTestTestfile.cmake"));
 }
 
 }
diff --git a/plugins/cmake/duchain/usebuilder.cpp b/plugins/cmake/duchain/usebuilder.cpp
index 3cd72a5fd6..fefb3fe562 100644
--- a/plugins/cmake/duchain/usebuilder.cpp
+++ b/plugins/cmake/duchain/usebuilder.cpp
@@ -1,65 +1,73 @@
 /* KDevelop CMake Support
  *
  * Copyright 2014 Aleix Pol <aleixpol@kde.org>
  *
  * 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 "usebuilder.h"
 #include <cmakeutils.h>
 #include <QGlobalStatic>
 #include <language/duchain/declaration.h>
 
-static QStringList initCommands()
+static QSet<QString> initCommands()
 {
     QStringList ids = CMake::executeProcess(QStringLiteral("cmake"), QStringList(QStringLiteral("--help-command-list"))).split(QLatin1Char('\n'));
+    if (ids.isEmpty()) {
+        return {};
+    }
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    const auto secondIt = ids.constBegin() + 1;
+    return QSet<QString>(secondIt, ids.constEnd());
+#else
     ids.removeFirst();
-    return ids;
+    return ids.toSet();
+#endif
 }
 
 // TODO: maybe share this again with codecompletionmodel and documentation
-Q_GLOBAL_STATIC_WITH_ARGS(QSet<QString>, s_commands, (initCommands().toSet()))
+Q_GLOBAL_STATIC_WITH_ARGS(QSet<QString>, s_commands, (initCommands()))
 
 UseBuilder::UseBuilder(const KDevelop::ReferencedTopDUContext& ctx)
     : m_ctx(ctx)
 {
 }
 
 void UseBuilder::startVisiting(CMakeContentIterator* node)
 {
     for(; node->hasNext(); ) {
         const CMakeFunctionDesc& func = node->next();
 
         QString fname = func.name.toLower();
         if (!s_commands->contains(fname)) {
             KDevelop::DUChainWriteLocker lock;
 
             KDevelop::Identifier nameid(fname);
             QList<KDevelop::Declaration*> declarations = m_ctx->findDeclarations(nameid, func.range().start);
             if (!declarations.isEmpty()) {
                 newUse(
                     func.nameRange(),
                     KDevelop::DeclarationPointer(declarations.first())
                 );
             }
         }
     }
 }
 
 void UseBuilder::newUse(const KDevelop::RangeInRevision& sr, const KDevelop::DeclarationPointer& d)
 {
     m_ctx->createUse(m_ctx->indexForUsedDeclaration(d.data()), sr, 0);
 }
diff --git a/plugins/grepview/grepfindthread.cpp b/plugins/grepview/grepfindthread.cpp
index 714512d3de..74d04cc2ba 100644
--- a/plugins/grepview/grepfindthread.cpp
+++ b/plugins/grepview/grepfindthread.cpp
@@ -1,176 +1,178 @@
 #include "grepfindthread.h"
 #include "debug.h"
 
 #include <QDir>
 #include <QSet>
 
 #include <project/projectmodel.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/icore.h>
 
 #include <serialization/indexedstring.h>
 
+#include <algorithm>
 
 using KDevelop::IndexedString;
 
 /**
  * @return Return true in case @p url is in @p dir within a maximum depth of @p maxDepth
  */
 static bool isInDirectory(const QUrl& url, const QUrl& dir, int maxDepth)
 {
     QUrl folderUrl = url.adjusted(QUrl::RemoveFilename);
 
     int currentLevel = maxDepth;
     while(currentLevel > 0) {
         folderUrl = folderUrl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
         if ( folderUrl == dir.adjusted(QUrl::StripTrailingSlash) ) {
             return true;
         }
         currentLevel--;
     }
     return false;
 }
 
 // the abort parameter must be volatile so that it
 // is evaluated every time - optimization might prevent that
 
 static QList<QUrl> thread_getProjectFiles(const QUrl& dir, int depth, const QStringList& include,
                                          const QStringList& exlude, volatile bool &abort)
 {
     ///@todo This is not thread-safe!
     KDevelop::IProject *project = KDevelop::ICore::self()->projectController()->findProjectForUrl( dir );
     QList<QUrl> res;
     if(!project)
         return res;
 
     const QSet<IndexedString> fileSet = project->fileSet();
     for (const IndexedString& item : fileSet) {
         if(abort)
             break;
         QUrl url = item.toUrl();
         if( url != dir )
         {
             if ( depth == 0 ) {
                 if ( url.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash) != dir.adjusted(QUrl::StripTrailingSlash) ) {
                     continue;
                 }
             } else if ( !dir.isParentOf(url) ) {
                 continue;
             } else if ( depth > 0 ) {
                 // To ensure the current file is within the defined depth limit, navigate up the tree for as many levels
                 // as the depth value, trying to find "dir", which is the project folder. If after all the loops there
                 // is no match, it means the current file is deeper down the project tree than the limit depth, and so
                 // it must be skipped.
                 if(!isInDirectory(url, dir, depth))
                     continue;
             }
         }
         if( QDir::match(include, url.fileName()) && !QDir::match(exlude, url.toLocalFile()) )
             res << url;
     }
 
     return res;
 }
 
 static QList<QUrl> thread_findFiles(const QDir& dir, int depth, const QStringList& include,
                                    const QStringList& exclude, volatile bool &abort)
 {
     QFileInfoList infos = dir.entryInfoList(include, QDir::NoDotAndDotDot|QDir::Files|QDir::Readable);
 
     if(!QFileInfo(dir.path()).isDir())
         infos << QFileInfo(dir.path());
 
     QList<QUrl> dirFiles;
     for (const QFileInfo& currFile : qAsConst(infos)) {
         QString currName = currFile.canonicalFilePath();
         if(!QDir::match(exclude, currName))
             dirFiles << QUrl::fromLocalFile(currName);
     }
     if(depth != 0)
     {
         static const QDir::Filters dirFilter = QDir::NoDotAndDotDot|QDir::AllDirs|QDir::Readable|QDir::NoSymLinks;
         const auto dirs = dir.entryInfoList(QStringList(), dirFilter);
         for (const QFileInfo& currDir : dirs) {
             if(abort)
                 break;
             QString canonical = currDir.canonicalFilePath();
             if (!canonical.startsWith(dir.canonicalPath()))
                 continue;
 
             if ( depth > 0 ) {
                 depth--;
             }
 
             dirFiles << thread_findFiles(canonical, depth, include, exclude, abort);
         }
     }
     return dirFiles;
 }
 
 GrepFindFilesThread::GrepFindFilesThread(QObject* parent,
                                          const QList<QUrl>& startDirs,
                                          int depth, const QString& pats,
                                          const QString& excl,
                                          bool onlyProject)
 : QThread(parent)
 , m_startDirs(startDirs)
 , m_patString(pats)
 , m_exclString(excl)
 , m_depth(depth)
 , m_project(onlyProject)
 , m_tryAbort(false)
 {
     setTerminationEnabled(false);
 }
 
 void GrepFindFilesThread::tryAbort()
 {
     m_tryAbort = true;
 }
 
 bool GrepFindFilesThread::triesToAbort() const
 {
     return m_tryAbort;
 }
 
 void GrepFindFilesThread::run()
 {
     QStringList include = GrepFindFilesThread::parseInclude(m_patString);
     QStringList exclude = GrepFindFilesThread::parseExclude(m_exclString);
 
     qCDebug(PLUGIN_GREPVIEW) << "running with start dir" << m_startDirs;
 
     for (const QUrl& directory : qAsConst(m_startDirs)) {
         if(m_project)
             m_files += thread_getProjectFiles(directory, m_depth, include, exclude, m_tryAbort);
         else
         {
             m_files += thread_findFiles(directory.toLocalFile(), m_depth, include, exclude, m_tryAbort);
         }
     }
 }
 
 QList<QUrl> GrepFindFilesThread::files() const {
-    auto tmpList = QList<QUrl>::fromSet(m_files.toSet());
+    auto tmpList = m_files;
     std::sort(tmpList.begin(), tmpList.end());
+    tmpList.erase(std::unique(tmpList.begin(), tmpList.end()), tmpList.end());
     return tmpList;
 }
 
 QStringList GrepFindFilesThread::parseExclude(const QString& excl)
 {
     QStringList exclude;
     // Split around commas or spaces
     const auto excludesList = excl.split(QRegExp(QStringLiteral(",|\\s")), QString::SkipEmptyParts);
     exclude.reserve(excludesList.size());
     for (const auto& sub : excludesList) {
         exclude << QStringLiteral("*%1*").arg(sub);
     }
     return exclude;
 }
 
 QStringList GrepFindFilesThread::parseInclude(const QString& inc)
 {
     // Split around commas or spaces
     return inc.split(QRegExp(QStringLiteral(",|\\s")), QString::SkipEmptyParts);
 }
diff --git a/plugins/patchreview/patchreviewtoolview.cpp b/plugins/patchreview/patchreviewtoolview.cpp
index f06810e41e..8fbb5b88ee 100644
--- a/plugins/patchreview/patchreviewtoolview.cpp
+++ b/plugins/patchreview/patchreviewtoolview.cpp
@@ -1,603 +1,607 @@
 /***************************************************************************
    Copyright 2006-2009 David Nolden <david.nolden.kdevelop@art-master.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.                                   *
 *                                                                         *
 ***************************************************************************/
 
 #include "patchreviewtoolview.h"
 #include "localpatchsource.h"
 #include "patchreview.h"
 #include "debug.h"
 #include <libkomparediff2/diffmodellist.h>
 #include <libkomparediff2/komparemodellist.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <vcs/models/vcsfilechangesmodel.h>
 #include <interfaces/ipatchsource.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/itestcontroller.h>
 #include <interfaces/itestsuite.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/context.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iuicontroller.h>
 #include <util/projecttestjob.h>
 #include <sublime/area.h>
 #include <sublime/view.h>
 #include <sublime/document.h>
 #include <sublime/mainwindow.h>
 #include <sublime/message.h>
 
 #include <QFileInfo>
 #include <QMenu>
 #include <QJsonObject>
 #include <QJsonArray>
 
 #include <KLocalizedString>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
 #ifdef WITH_PURPOSE
 #include <Purpose/AlternativesModel>
 #include <PurposeWidgets/Menu>
 #endif
 
 using namespace KDevelop;
 
 class PatchFilesModel : public VcsFileChangesModel
 {
     Q_OBJECT
 public:
     PatchFilesModel( QObject *parent, bool allowSelection ) : VcsFileChangesModel( parent, allowSelection ) { };
     enum ItemRoles { HunksNumberRole = LastItemRole+1 };
 
 public Q_SLOTS:
     void updateState( const KDevelop::VcsStatusInfo &status, unsigned hunksNum ) {
         int row = VcsFileChangesModel::updateState( invisibleRootItem(), status );
         if ( row == -1 )
             return;
 
         QStandardItem *item = invisibleRootItem()->child( row, 0 );
         setFileInfo( item, hunksNum );
         item->setData( QVariant( hunksNum ), HunksNumberRole );
     }
 
     void updateState( const KDevelop::VcsStatusInfo &status ) {
         int row = VcsFileChangesModel::updateState( invisibleRootItem(), status );
         if ( row == -1 )
             return;
 
         QStandardItem *item = invisibleRootItem()->child( row, 0 );
         setFileInfo( invisibleRootItem()->child( row, 0 ), item->data( HunksNumberRole ).toUInt() );
     }
 
 private:
     void setFileInfo( QStandardItem *item, unsigned int hunksNum ) {
         const auto url = item->index().data(VcsFileChangesModel::UrlRole).toUrl();
         const QString path = ICore::self()->projectController()->prettyFileName(url, KDevelop::IProjectController::FormatPlain);
         const QString newText = i18ncp( "%1: number of changed hunks, %2: file name",
             "%2 (1 hunk)", "%2 (%1 hunks)", hunksNum,
             path);
         item->setText( newText );
     }
 };
 
 PatchReviewToolView::PatchReviewToolView( QWidget* parent, PatchReviewPlugin* plugin )
     : QWidget( parent ),
     m_resetCheckedUrls( true ),
     m_plugin( plugin )
 {
     setWindowIcon(QIcon::fromTheme(QStringLiteral("text-x-patch"), windowIcon()));
 
     connect( m_plugin->finishReviewAction(), &QAction::triggered, this, &PatchReviewToolView::finishReview );
 
     connect( plugin, &PatchReviewPlugin::patchChanged, this, &PatchReviewToolView::patchChanged );
     connect( plugin, &PatchReviewPlugin::startingNewReview, this, &PatchReviewToolView::startingNewReview );
     connect( ICore::self()->documentController(), &IDocumentController::documentActivated, this, &PatchReviewToolView::documentActivated );
 
     auto* w = qobject_cast<Sublime::MainWindow*>(ICore::self()->uiController()->activeMainWindow());
     connect(w, &Sublime::MainWindow::areaChanged, m_plugin, &PatchReviewPlugin::areaChanged);
 
     showEditDialog();
     patchChanged();
 }
 
 void PatchReviewToolView::resizeEvent(QResizeEvent* ev)
 {
     bool vertical = (width() < height());
     m_editPatch.buttonsLayout->setDirection(vertical ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight);
     m_editPatch.contentLayout->setDirection(vertical ? QBoxLayout::TopToBottom : QBoxLayout::LeftToRight);
     m_editPatch.buttonsSpacer->changeSize(vertical ? 0 : 40, 0, QSizePolicy::Fixed, QSizePolicy::Fixed);
     QWidget::resizeEvent(ev);
     if(m_customWidget) {
         m_editPatch.contentLayout->removeWidget( m_customWidget );
         m_editPatch.contentLayout->insertWidget(0, m_customWidget );
     }
 }
 
 void PatchReviewToolView::startingNewReview()
 {
     m_resetCheckedUrls = true;
 }
 
 void PatchReviewToolView::patchChanged() {
     fillEditFromPatch();
     kompareModelChanged();
 
 #ifdef WITH_PURPOSE
     IPatchSource::Ptr p = m_plugin->patch();
     if (p) {
         m_exportMenu->model()->setInputData(QJsonObject {
             { QStringLiteral("urls"), QJsonArray { p->file().toString() } },
             { QStringLiteral("mimeType"), { QStringLiteral("text/x-patch") } },
             { QStringLiteral("localBaseDir"), { p->baseDir().toString() } },
             { QStringLiteral("updateComment"), { QStringLiteral("Patch updated through KDevelop's Patch Review plugin") } }
         });
     }
 #endif
 }
 
 PatchReviewToolView::~PatchReviewToolView()
 {
 }
 
 LocalPatchSource* PatchReviewToolView::GetLocalPatchSource() {
     IPatchSource::Ptr ips = m_plugin->patch();
 
     if ( !ips )
         return nullptr;
     return qobject_cast<LocalPatchSource*>(ips.data());
 }
 
 void PatchReviewToolView::fillEditFromPatch() {
     IPatchSource::Ptr ipatch = m_plugin->patch();
     if ( !ipatch )
         return;
 
     m_editPatch.cancelReview->setVisible( ipatch->canCancel() );
 
     m_fileModel->setIsCheckbable( m_plugin->patch()->canSelectFiles() );
 
     if( m_customWidget ) {
         qCDebug(PLUGIN_PATCHREVIEW) << "removing custom widget";
         m_customWidget->hide();
         m_editPatch.contentLayout->removeWidget( m_customWidget );
     }
 
     m_customWidget = ipatch->customWidget();
     if( m_customWidget ) {
         m_editPatch.contentLayout->insertWidget( 0, m_customWidget );
         m_customWidget->show();
         qCDebug(PLUGIN_PATCHREVIEW) << "got custom widget";
     }
 
     bool showTests = false;
     QMap<QUrl, VcsStatusInfo::State> files = ipatch->additionalSelectableFiles();
     QMap<QUrl, VcsStatusInfo::State>::const_iterator it = files.constBegin();
 
     for (; it != files.constEnd(); ++it) {
         auto project = ICore::self()->projectController()->findProjectForUrl(it.key());
         if (project && !ICore::self()->testController()->testSuitesForProject(project).isEmpty()) {
             showTests = true;
             break;
         }
     }
 
     m_editPatch.testsButton->setVisible(showTests);
     m_editPatch.testProgressBar->hide();
 }
 
 void PatchReviewToolView::slotAppliedChanged( int newState ) {
     if ( LocalPatchSource* lpatch = GetLocalPatchSource() ) {
         lpatch->setAlreadyApplied( newState == Qt::Checked );
         m_plugin->notifyPatchChanged();
     }
 }
 
 void PatchReviewToolView::showEditDialog() {
     m_editPatch.setupUi( this );
 
     bool allowSelection = m_plugin->patch() && m_plugin->patch()->canSelectFiles();
     m_fileModel = new PatchFilesModel( this, allowSelection );
     m_fileSortProxyModel = new VcsFileChangesSortProxyModel(this);
     m_fileSortProxyModel->setSourceModel(m_fileModel);
     m_fileSortProxyModel->sort(1);
     m_fileSortProxyModel->setDynamicSortFilter(true);
     m_editPatch.filesList->setModel( m_fileSortProxyModel );
     m_editPatch.filesList->header()->hide();
     m_editPatch.filesList->setRootIsDecorated( false );
     m_editPatch.filesList->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(m_editPatch.filesList, &QTreeView::customContextMenuRequested, this, &PatchReviewToolView::customContextMenuRequested);
     connect(m_fileModel, &PatchFilesModel::itemChanged, this, &PatchReviewToolView::fileItemChanged);
     m_editPatch.finishReview->setDefaultAction(m_plugin->finishReviewAction());
 
 #ifdef WITH_PURPOSE
     m_exportMenu = new Purpose::Menu(this);
     connect(m_exportMenu, &Purpose::Menu::finished, this, [](const QJsonObject &output, int error, const QString &errorMessage) {
         Sublime::Message* message;
         if (error==0) {
             const QString messageText = i18n("<qt>You can find the new request at:<br /><a href='%1'>%1</a> </qt>", output[QLatin1String("url")].toString());
             message = new Sublime::Message(messageText, Sublime::Message::Information);
         } else {
             const QString messageText = i18n("Couldn't export the patch.\n%1", errorMessage);
             message = new Sublime::Message(messageText, Sublime::Message::Error);
         }
         ICore::self()->uiController()->postMessage(message);
     });
     // set the model input parameters to avoid terminal warnings
     m_exportMenu->model()->setInputData(QJsonObject {
         { QStringLiteral("urls"), QJsonArray { QString() } },
         { QStringLiteral("mimeType"), { QStringLiteral("text/x-patch") } }
     });
     m_exportMenu->model()->setPluginType(QStringLiteral("Export"));
     m_editPatch.exportReview->setMenu( m_exportMenu );
 #else
     m_editPatch.exportReview->setEnabled(false);
 #endif
 
     connect( m_editPatch.previousHunk, &QToolButton::clicked, this, &PatchReviewToolView::prevHunk );
     connect( m_editPatch.nextHunk, &QToolButton::clicked, this, &PatchReviewToolView::nextHunk );
     connect( m_editPatch.previousFile, &QToolButton::clicked, this, &PatchReviewToolView::prevFile );
     connect( m_editPatch.nextFile, &QToolButton::clicked, this, &PatchReviewToolView::nextFile );
     connect( m_editPatch.filesList, &QTreeView::activated , this, &PatchReviewToolView::fileDoubleClicked );
 
     connect( m_editPatch.cancelReview, &QPushButton::clicked, m_plugin, &PatchReviewPlugin::cancelReview );
     //connect( m_editPatch.cancelButton, SIGNAL(pressed()), this, SLOT(slotEditCancel()) );
 
     //connect( this, SIGNAL(finished(int)), this, SLOT(slotEditDialogFinished(int)) );
 
     connect( m_editPatch.updateButton, &QPushButton::clicked, m_plugin, &PatchReviewPlugin::forceUpdate );
 
     connect( m_editPatch.testsButton, &QPushButton::clicked, this, &PatchReviewToolView::runTests );
 
     m_selectAllAction = new QAction(QIcon::fromTheme(QStringLiteral("edit-select-all")), i18n("Select All"), this );
     connect( m_selectAllAction, &QAction::triggered, this, &PatchReviewToolView::selectAll );
     m_deselectAllAction = new QAction( i18n("Deselect All"), this );
     connect( m_deselectAllAction, &QAction::triggered, this, &PatchReviewToolView::deselectAll );
 }
 
 void PatchReviewToolView::customContextMenuRequested(const QPoint& pos)
 {
     QList<QUrl> urls;
     const QModelIndexList selectionIdxs = m_editPatch.filesList->selectionModel()->selectedIndexes();
     urls.reserve(selectionIdxs.size());
     for (const QModelIndex& idx : selectionIdxs) {
         urls += idx.data(KDevelop::VcsFileChangesModel::UrlRole).toUrl();
     }
 
     QPointer<QMenu> menu = new QMenu(m_editPatch.filesList);
     QList<ContextMenuExtension> extensions;
     if(!urls.isEmpty()) {
         KDevelop::FileContext context(urls);
         extensions = ICore::self()->pluginController()->queryPluginsForContextMenuExtensions(&context, menu);
     }
 
     QList<QAction*> vcsActions;
     for (const ContextMenuExtension& ext : qAsConst(extensions)) {
         vcsActions += ext.actions(ContextMenuExtension::VcsGroup);
     }
 
     menu->addAction(m_selectAllAction);
     menu->addAction(m_deselectAllAction);
     menu->addActions(vcsActions);
     menu->exec(m_editPatch.filesList->viewport()->mapToGlobal(pos));
 
     delete menu;
 }
 
 void PatchReviewToolView::nextHunk()
 {
     IDocument* current = ICore::self()->documentController()->activeDocument();
     if(current && current->textDocument())
         m_plugin->seekHunk( true, current->textDocument()->url() );
 }
 
 void PatchReviewToolView::prevHunk()
 {
     IDocument* current = ICore::self()->documentController()->activeDocument();
     if(current && current->textDocument())
         m_plugin->seekHunk( false, current->textDocument()->url() );
 }
 
 void PatchReviewToolView::seekFile(bool forwards)
 {
     if(!m_plugin->patch())
         return;
-    QList<QUrl> checkedUrls = m_fileModel->checkedUrls();
+    const QList<QUrl> checkedUrls = m_fileModel->checkedUrls();
     QList<QUrl> allUrls = m_fileModel->urls();
     IDocument* current = ICore::self()->documentController()->activeDocument();
     if(!current || checkedUrls.empty())
         return;
     qCDebug(PLUGIN_PATCHREVIEW) << "seeking direction" << forwards;
     int currentIndex = allUrls.indexOf(current->url());
     QUrl newUrl;
     if((forwards && current->url() == checkedUrls.back()) ||
             (!forwards && current->url() == checkedUrls[0]))
     {
         newUrl = m_plugin->patch()->file();
         qCDebug(PLUGIN_PATCHREVIEW) << "jumping to patch";
     }
     else if(current->url() == m_plugin->patch()->file() || currentIndex == -1)
     {
         if(forwards)
             newUrl = checkedUrls[0];
         else
             newUrl = checkedUrls.back();
         qCDebug(PLUGIN_PATCHREVIEW) << "jumping from patch";
     }
     else
     {
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+        QSet<QUrl> checkedUrlsSet(checkedUrls.begin(), checkedUrls.end());
+#else
         QSet<QUrl> checkedUrlsSet( checkedUrls.toSet() );
+#endif
         for(int offset = 1; offset < allUrls.size(); ++offset)
         {
             int pos;
             if(forwards) {
                 pos = (currentIndex + offset) % allUrls.size();
             }else{
                 pos = currentIndex - offset;
                 if(pos < 0)
                     pos += allUrls.size();
             }
             if(checkedUrlsSet.contains(allUrls[pos]))
             {
                 newUrl = allUrls[pos];
                 break;
             }
         }
     }
 
     if(newUrl.isValid())
     {
         open( newUrl, true );
     }else{
         qCDebug(PLUGIN_PATCHREVIEW) << "found no valid target url";
     }
 }
 
 void PatchReviewToolView::open( const QUrl& url, bool activate ) const
 {
     qCDebug(PLUGIN_PATCHREVIEW) << "activating url" << url;
     // If the document is already open in this area, just re-activate it
     if(KDevelop::IDocument* doc = ICore::self()->documentController()->documentForUrl(url)) {
         const auto views = ICore::self()->uiController()->activeArea()->views();
         for (Sublime::View* view : views) {
             if(view->document() == dynamic_cast<Sublime::Document*>(doc))
             {
                 if (activate) {
                     // use openDocument() for the activation so that the document is added to File/Open Recent.
                     ICore::self()->documentController()->openDocument(doc->url(), KTextEditor::Range::invalid());
                 }
                 return;
             }
         }
     }
 
     QStandardItem* item = m_fileModel->itemForUrl( url );
 
     IDocument* buddyDoc = nullptr;
 
     if (m_plugin->patch() && item) {
         for (int preRow = item->row() - 1; preRow >= 0; --preRow) {
             QStandardItem* preItem = m_fileModel->item(preRow);
             if (!m_fileModel->isCheckable() || preItem->checkState() == Qt::Checked) {
                 // found valid predecessor, take it as buddy
                 buddyDoc = ICore::self()->documentController()->documentForUrl(preItem->index().data(VcsFileChangesModel::UrlRole).toUrl());
                 if (buddyDoc) {
                     break;
                 }
             }
         }
         if (!buddyDoc) {
             buddyDoc = ICore::self()->documentController()->documentForUrl(m_plugin->patch()->file());
         }
     }
 
     // we simplify and assume that documents to be opened without activating them also need not be
     // added to the Files/Open Recent menu.
     IDocument* newDoc = ICore::self()->documentController()->openDocument(url, KTextEditor::Range::invalid(),
         activate ? IDocumentController::DefaultMode : IDocumentController::DoNotActivate|IDocumentController::DoNotAddToRecentOpen,
         QString(), buddyDoc);
 
     KTextEditor::View* view = nullptr;
     if(newDoc)
         view = newDoc->activeTextView();
 
     if(view && view->cursorPosition().line() == 0)
         m_plugin->seekHunk( true, url );
 }
 
 void PatchReviewToolView::fileItemChanged( QStandardItem* item )
 {
     if (item->column() != 0 || !m_plugin->patch())
         return;
 
     QUrl url = item->index().data(VcsFileChangesModel::UrlRole).toUrl();
     if (url.isEmpty())
         return;
 
     KDevelop::IDocument* doc = ICore::self()->documentController()->documentForUrl(url);
     if(m_fileModel->isCheckable() && item->checkState() != Qt::Checked)
     {   // The file was deselected, so eventually close it
         if(doc && doc->state() == IDocument::Clean)
         {
             const auto views = ICore::self()->uiController()->activeArea()->views();
             for (Sublime::View* view : views) {
                 if(view->document() == dynamic_cast<Sublime::Document*>(doc))
                 {
                     ICore::self()->uiController()->activeArea()->closeView(view);
                     return;
                 }
             }
         }
     } else if (!doc) {
         // Maybe the file was unchecked before, or it  was just loaded.
         open( url, false );
     }
 }
 
 void PatchReviewToolView::nextFile()
 {
     seekFile(true);
 }
 
 void PatchReviewToolView::prevFile()
 {
     seekFile(false);
 }
 
 void PatchReviewToolView::deselectAll()
 {
     m_fileModel->setAllChecked(false);
 }
 
 void PatchReviewToolView::selectAll()
 {
     m_fileModel->setAllChecked(true);
 }
 
 void PatchReviewToolView::finishReview() {
     QList<QUrl> selectedUrls = m_fileModel->checkedUrls();
     qCDebug(PLUGIN_PATCHREVIEW) << "finishing review with" << selectedUrls;
     m_plugin->finishReview( selectedUrls );
 }
 
 void PatchReviewToolView::fileDoubleClicked( const QModelIndex& idx )
 {
     const QUrl file = idx.data(VcsFileChangesModel::UrlRole).toUrl();
     open( file, true );
 }
 
 void PatchReviewToolView::kompareModelChanged() {
 
     QList<QUrl> oldCheckedUrls = m_fileModel->checkedUrls();
 
     m_fileModel->clear();
 
     if ( !m_plugin->modelList() )
         return;
 
     QMap<QUrl, KDevelop::VcsStatusInfo::State> additionalUrls = m_plugin->patch()->additionalSelectableFiles();
 
     const Diff2::DiffModelList* models = m_plugin->modelList()->models();
     if( models )
     {
         for (auto* model : *models) {
             const Diff2::DifferenceList* diffs = model->differences();
             int cnt = 0;
             if ( diffs )
                 cnt = diffs->count();
 
             const QUrl file = m_plugin->urlForFileModel(model);
             if( file.isLocalFile() && !QFileInfo( file.toLocalFile() ).isReadable() )
                 continue;
 
             VcsStatusInfo status;
             status.setUrl( file );
             status.setState( cnt>0 ? VcsStatusInfo::ItemModified : VcsStatusInfo::ItemUpToDate );
 
             m_fileModel->updateState( status, cnt );
         }
     }
 
     for( QMap<QUrl, KDevelop::VcsStatusInfo::State>::const_iterator it = additionalUrls.constBegin(); it != additionalUrls.constEnd(); ++it ) {
         VcsStatusInfo status;
         status.setUrl( it.key() );
         status.setState( it.value() );
         m_fileModel->updateState( status );
     }
 
     if(!m_resetCheckedUrls)
         m_fileModel->setCheckedUrls(oldCheckedUrls);
     else
         m_resetCheckedUrls = false;
 
     m_editPatch.filesList->resizeColumnToContents( 0 );
 
     // Eventually select the active document
     documentActivated( ICore::self()->documentController()->activeDocument() );
 }
 
 void PatchReviewToolView::documentActivated( IDocument* doc ) {
     if( !doc )
         return;
 
     if ( !m_plugin->modelList() )
         return;
 
     const auto matches = m_fileSortProxyModel->match(
         m_fileSortProxyModel->index(0, 0), VcsFileChangesModel::UrlRole,
         doc->url(), 1, Qt::MatchExactly);
     m_editPatch.filesList->setCurrentIndex(matches.value(0));
 }
 
 void PatchReviewToolView::runTests()
 {
     IPatchSource::Ptr ipatch = m_plugin->patch();
     if ( !ipatch ) {
         return;
     }
 
     IProject* project = nullptr;
     QMap<QUrl, VcsStatusInfo::State> files = ipatch->additionalSelectableFiles();
     QMap<QUrl, VcsStatusInfo::State>::const_iterator it = files.constBegin();
 
     for (; it != files.constEnd(); ++it) {
         project = ICore::self()->projectController()->findProjectForUrl(it.key());
         if (project) {
            break;
         }
     }
 
     if (!project) {
         return;
     }
 
     m_editPatch.testProgressBar->setFormat(i18n("Running tests: %p%"));
     m_editPatch.testProgressBar->setValue(0);
     m_editPatch.testProgressBar->show();
 
     auto* job = new ProjectTestJob(project, this);
     connect(job, &ProjectTestJob::finished, this, &PatchReviewToolView::testJobResult);
     connect(job, SIGNAL(percent(KJob*,ulong)), this, SLOT(testJobPercent(KJob*,ulong)));
     ICore::self()->runController()->registerJob(job);
 }
 
 void PatchReviewToolView::testJobPercent(KJob* job, ulong percent)
 {
     Q_UNUSED(job);
     m_editPatch.testProgressBar->setValue(percent);
 }
 
 void PatchReviewToolView::testJobResult(KJob* job)
 {
     auto* testJob = qobject_cast<ProjectTestJob*>(job);
     if (!testJob) {
         return;
     }
 
     ProjectTestResult result = testJob->testResult();
 
     QString format;
     if (result.passed > 0 && result.failed == 0 && result.error == 0)
     {
         format = i18np("Test passed", "All %1 tests passed", result.passed);
     }
     else
     {
         format = i18n("Test results: %1 passed, %2 failed, %3 errors", result.passed, result.failed, result.error);
     }
     m_editPatch.testProgressBar->setFormat(format);
 
     // Needed because some test jobs may raise their own output views
     ICore::self()->uiController()->raiseToolView(this);
 }
 
 #include "patchreviewtoolview.moc"