diff --git a/kdevplatform/language/codegen/documentchangeset.cpp b/kdevplatform/language/codegen/documentchangeset.cpp
index faded88b16..a9a313b389 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<KDevelop::IndexedString>(d->documentsRename.keyBegin(), d->documentsRename.keyEnd()) +
+        QSet<KDevelop::IndexedString>(d->changes.keyBegin(), d->changes.keyEnd());
+#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/plugins/cmake/cmakeutils.cpp b/plugins/cmake/cmakeutils.cpp
index c548a574d3..c42f8635c2 100644
--- a/plugins/cmake/cmakeutils.cpp
+++ b/plugins/cmake/cmakeutils.cpp
@@ -1,743 +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 }
     };
 
+#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
+    const QSet<QString> variables(keys.keyBegin(), keys.keyEnd());
+#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"));
 }
 
 }