diff --git a/analyzers/cppcheck/config/globalconfigpage.cpp b/analyzers/cppcheck/config/globalconfigpage.cpp
index 945bcbcb55..72f63f98d5 100644
--- a/analyzers/cppcheck/config/globalconfigpage.cpp
+++ b/analyzers/cppcheck/config/globalconfigpage.cpp
@@ -1,60 +1,58 @@
 /*
  * Copyright 2015 Laszlo Kis-Adam <laszlo.kis-adam@kdemail.net>
  * Copyright 2016 Anton Anikin <anton.anikin@htower.ru>
  *
  * 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, see <http://www.gnu.org/licenses/>.
  */
 
 #include "globalconfigpage.h"
 #include "ui_globalconfigpage.h"
 
 #include "globalsettings.h"
 
-#include <QVBoxLayout>
-
 namespace cppcheck
 {
 
 GlobalConfigPage::GlobalConfigPage(KDevelop::IPlugin* plugin, QWidget* parent)
     : ConfigPage(plugin, GlobalSettings::self(), parent)
 {
     Ui::GlobalConfigPage ui;
     ui.setupUi(this);
 }
 
 GlobalConfigPage::~GlobalConfigPage()
 {
 }
 
 KDevelop::ConfigPage::ConfigPageType GlobalConfigPage::configPageType() const
 {
     return KDevelop::ConfigPage::AnalyzerConfigPage;
 }
 
 QString GlobalConfigPage::name() const
 {
     return i18n("Cppcheck");
 }
 
 QString GlobalConfigPage::fullName() const
 {
     return i18n("Configure Cppcheck Settings");
 }
 
 QIcon GlobalConfigPage::icon() const
 {
     return QIcon::fromTheme(QStringLiteral("cppcheck"));
 }
 
 }
diff --git a/analyzers/cppcheck/plugin.cpp b/analyzers/cppcheck/plugin.cpp
index 4d89c2677d..2437fcb5da 100644
--- a/analyzers/cppcheck/plugin.cpp
+++ b/analyzers/cppcheck/plugin.cpp
@@ -1,263 +1,262 @@
 /* This file is part of KDevelop
    Copyright 2013 Christoph Thielecke <crissi99@gmx.de>
    Copyright 2016-2017 Anton Anikin <anton.anikin@htower.ru>
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "plugin.h"
 
 #include "config/globalconfigpage.h"
 #include "config/projectconfigpage.h"
 #include "globalsettings.h"
 
 #include "debug.h"
 #include "job.h"
 #include "problemmodel.h"
 
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/iuicontroller.h>
 #include <kactioncollection.h>
 #include <kpluginfactory.h>
 #include <language/interfaces/editorcontext.h>
 #include <project/projectconfigpage.h>
 #include <project/projectmodel.h>
 #include <util/jobstatus.h>
 
 #include <QAction>
-#include <QMessageBox>
 
 K_PLUGIN_FACTORY_WITH_JSON(CppcheckFactory, "kdevcppcheck.json", registerPlugin<cppcheck::Plugin>();)
 
 namespace cppcheck
 {
 
 Plugin::Plugin(QObject* parent, const QVariantList&)
     : IPlugin("kdevcppcheck", parent)
     , m_job(nullptr)
     , m_currentProject(nullptr)
     , m_model(new ProblemModel(this))
 {
     qCDebug(KDEV_CPPCHECK) << "setting cppcheck rc file";
     setXMLFile("kdevcppcheck.rc");
 
     m_actionFile = new QAction(QIcon::fromTheme("cppcheck"), i18n("Cppcheck (Current File)"), this);
     connect(m_actionFile, &QAction::triggered, [this](){
         runCppcheck(false);
     });
     actionCollection()->addAction("cppcheck_file", m_actionFile);
 
     m_actionProject = new QAction(QIcon::fromTheme("cppcheck"), i18n("Cppcheck (Current Project)"), this);
     connect(m_actionProject, &QAction::triggered, [this](){
         runCppcheck(true);
     });
     actionCollection()->addAction("cppcheck_project", m_actionProject);
 
     m_actionProjectItem = new QAction(QIcon::fromTheme("cppcheck"), i18n("Cppcheck"), this);
 
     connect(core()->documentController(), &KDevelop::IDocumentController::documentClosed,
             this, &Plugin::updateActions);
     connect(core()->documentController(), &KDevelop::IDocumentController::documentActivated,
             this, &Plugin::updateActions);
 
     connect(core()->projectController(), &KDevelop::IProjectController::projectOpened,
             this, &Plugin::updateActions);
     connect(core()->projectController(), &KDevelop::IProjectController::projectClosed,
             this, &Plugin::projectClosed);
 
     updateActions();
 }
 
 Plugin::~Plugin()
 {
     killCppcheck();
 }
 
 bool Plugin::isRunning()
 {
     return m_job;
 }
 
 void Plugin::killCppcheck()
 {
     if (m_job) {
         m_job->kill(KJob::EmitResult);
     }
 }
 
 void Plugin::raiseProblemsView()
 {
     m_model->show();
 }
 
 void Plugin::raiseOutputView()
 {
     core()->uiController()->findToolView(
         i18nc("@title:window", "Test"),
         nullptr,
         KDevelop::IUiController::FindFlags::Raise);
 }
 
 void Plugin::updateActions()
 {
     m_currentProject = nullptr;
 
     m_actionFile->setEnabled(false);
     m_actionProject->setEnabled(false);
 
     if (isRunning()) {
         return;
     }
 
     KDevelop::IDocument* activeDocument = core()->documentController()->activeDocument();
     if (!activeDocument) {
         return;
     }
 
     QUrl url = activeDocument->url();
 
     m_currentProject = core()->projectController()->findProjectForUrl(url);
     if (!m_currentProject) {
         return;
     }
 
     m_actionFile->setEnabled(true);
     m_actionProject->setEnabled(true);
 }
 
 void Plugin::projectClosed(KDevelop::IProject* project)
 {
     if (project != m_model->project()) {
         return;
     }
 
     killCppcheck();
     m_model->reset();
 }
 
 void Plugin::runCppcheck(bool checkProject)
 {
     KDevelop::IDocument* doc = core()->documentController()->activeDocument();
     Q_ASSERT(doc);
 
     if (checkProject) {
         runCppcheck(m_currentProject, m_currentProject->path().toUrl().toLocalFile());
     } else {
         runCppcheck(m_currentProject, doc->url().toLocalFile());
     }
 }
 
 void Plugin::runCppcheck(KDevelop::IProject* project, const QString& path)
 {
     m_model->reset(project, path);
 
     Parameters params(project);
     params.checkPath = path;
 
     m_job = new Job(params);
 
     connect(m_job, &Job::problemsDetected, m_model.data(), &ProblemModel::addProblems);
     connect(m_job, &Job::finished, this, &Plugin::result);
 
     core()->uiController()->registerStatus(new KDevelop::JobStatus(m_job, "Cppcheck"));
     core()->runController()->registerJob(m_job);
 
     if (params.hideOutputView) {
         raiseProblemsView();
     } else {
         raiseOutputView();
     }
 
     updateActions();
 }
 
 void Plugin::result(KJob*)
 {
     if (!core()->projectController()->projects().contains(m_model->project())) {
         m_model->reset();
     } else {
         m_model->setProblems();
 
         if (m_job->status() == KDevelop::OutputExecuteJob::JobStatus::JobSucceeded ||
             m_job->status() == KDevelop::OutputExecuteJob::JobStatus::JobCanceled) {
             raiseProblemsView();
         } else {
             raiseOutputView();
         }
     }
 
     m_job = nullptr; // job is automatically deleted later
 
     updateActions();
 }
 
 KDevelop::ContextMenuExtension Plugin::contextMenuExtension(KDevelop::Context* context)
 {
     KDevelop::ContextMenuExtension extension = KDevelop::IPlugin::contextMenuExtension(context);
 
     if (context->hasType(KDevelop::Context::EditorContext) &&
         m_currentProject && !isRunning()) {
 
         extension.addAction(KDevelop::ContextMenuExtension::AnalyzeGroup, m_actionFile);
         extension.addAction(KDevelop::ContextMenuExtension::AnalyzeGroup, m_actionProject);
     }
 
     if (context->hasType(KDevelop::Context::ProjectItemContext) && !isRunning()) {
         auto pContext = dynamic_cast<KDevelop::ProjectItemContext*>(context);
         if (pContext->items().size() != 1) {
             return extension;
         }
 
         auto item = pContext->items().first();
 
         switch (item->type()) {
             case KDevelop::ProjectBaseItem::File:
             case KDevelop::ProjectBaseItem::Folder:
             case KDevelop::ProjectBaseItem::BuildFolder:
                 break;
 
             default:
                 return extension;
         }
 
         m_actionProjectItem->disconnect();
         connect(m_actionProjectItem, &QAction::triggered, [this, item](){
             runCppcheck(item->project(), item->path().toLocalFile());
         });
 
         extension.addAction(KDevelop::ContextMenuExtension::AnalyzeGroup, m_actionProjectItem);
     }
 
     return extension;
 }
 
 KDevelop::ConfigPage* Plugin::perProjectConfigPage(int number, const KDevelop::ProjectConfigOptions& options, QWidget* parent)
 {
     return number ? nullptr : new ProjectConfigPage(this, options.project, parent);
 }
 
 KDevelop::ConfigPage* Plugin::configPage(int number, QWidget* parent)
 {
     return number ? nullptr : new GlobalConfigPage(this, parent);
 }
 
 }
 
 #include "plugin.moc"
diff --git a/analyzers/heaptrack/job.cpp b/analyzers/heaptrack/job.cpp
index b5663624c4..7055377902 100644
--- a/analyzers/heaptrack/job.cpp
+++ b/analyzers/heaptrack/job.cpp
@@ -1,151 +1,150 @@
 /* This file is part of KDevelop
    Copyright 2017 Anton Anikin <anton.anikin@htower.ru>
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "job.h"
 
 #include "debug.h"
 #include "globalsettings.h"
 #include "utils.h"
 
 #include <execute/iexecuteplugin.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/iuicontroller.h>
 #include <klocalizedstring.h>
-#include <kmessagebox.h>
 #include <util/environmentprofilelist.h>
 #include <util/path.h>
 
 #include <QFileInfo>
 #include <QRegularExpression>
 
 namespace Heaptrack
 {
 
 Job::Job(KDevelop::ILaunchConfiguration* launchConfig)
     : m_pid(-1)
 {
     Q_ASSERT(launchConfig);
 
     auto pluginController = KDevelop::ICore::self()->pluginController();
     auto iface = pluginController->pluginForExtension(QStringLiteral("org.kdevelop.IExecutePlugin"))->extension<IExecutePlugin>();
     Q_ASSERT(iface);
 
     QString envProfile = iface->environmentProfileName(launchConfig);
     if (envProfile.isEmpty()) {
         envProfile = KDevelop::EnvironmentProfileList(KSharedConfig::openConfig()).defaultProfileName();
     }
     setEnvironmentProfile(envProfile);
 
     QString errorString;
 
     m_analyzedExecutable = iface->executable(launchConfig, errorString).toLocalFile();
     if (!errorString.isEmpty()) {
         setError(-1);
         setErrorText(errorString);
     }
 
     QStringList analyzedExecutableArguments = iface->arguments(launchConfig, errorString);
     if (!errorString.isEmpty()) {
         setError(-1);
         setErrorText(errorString);
     }
 
     QUrl workDir = iface->workingDirectory(launchConfig);
     if (workDir.isEmpty() || !workDir.isValid()) {
         workDir = QUrl::fromLocalFile(QFileInfo(m_analyzedExecutable).absolutePath());
     }
     setWorkingDirectory(workDir);
 
     *this << KDevelop::Path(GlobalSettings::heaptrackExecutable()).toLocalFile();
     *this << m_analyzedExecutable;
     *this << analyzedExecutableArguments;
 
     setup();
 }
 
 Job::Job(long int pid)
     : m_pid(pid)
 {
     *this << KDevelop::Path(GlobalSettings::heaptrackExecutable()).toLocalFile();
     *this << QStringLiteral("-p");
     *this << QString::number(m_pid);
 
     setup();
 }
 
 void Job::setup()
 {
     setProperties(DisplayStdout);
     setProperties(DisplayStderr);
     setProperties(PostProcessOutput);
 
     setCapabilities(Killable);
     setStandardToolView(KDevelop::IOutputView::TestView);
     setBehaviours(KDevelop::IOutputView::AutoScroll);
 
     KDevelop::ICore::self()->uiController()->registerStatus(this);
     connect(this, &Job::finished, this, [this]() {
         emit hideProgress(this);
     });
 }
 
 Job::~Job()
 {
 }
 
 QString Job::statusName() const
 {
     QString target = m_pid < 0 ? QFileInfo(m_analyzedExecutable).fileName()
                                : QString("PID: %1").arg(m_pid);
     return i18n("Heaptrack Analysis (%1)", target);
 }
 
 QString Job::resultsFile() const
 {
     return m_resultsFile;
 }
 
 void Job::start()
 {
     emit showProgress(this, 0, 0, 0);
     OutputExecuteJob::start();
 }
 
 void Job::postProcessStdout(const QStringList& lines)
 {
     static const auto resultRegex =
         QRegularExpression(QStringLiteral("heaptrack output will be written to \\\"(.+)\\\""));
 
     if (m_resultsFile.isEmpty()) {
         QRegularExpressionMatch match;
         for (const QString & line : lines) {
             match = resultRegex.match(line);
             if (match.hasMatch()) {
                 m_resultsFile = match.captured(1);
                 break;
             }
         }
     }
 
     OutputExecuteJob::postProcessStdout(lines);
 }
 
 }
diff --git a/app/main.cpp b/app/main.cpp
index ffdfeee1dd..1d7ed32bbd 100644
--- a/app/main.cpp
+++ b/app/main.cpp
@@ -1,756 +1,755 @@
 /***************************************************************************
  *   Copyright 2003-2009 Alexander Dymo <adymo@kdevelop.org>               *
  *   Copyright 2007 Ralf Habacker  <Ralf.Habacker@freenet.de>              *
  *   Copyright 2006-2007 Matt Rogers  <mattr@kde.org>                      *
  *   Copyright 2006-2007 Hamish Rodda <rodda@kde.org>                      *
  *   Copyright 2005-2007 Adam Treat <treat@kde.org>                        *
  *   Copyright 2003-2007 Jens Dagerbo <jens.dagerbo@swipnet.se>            *
  *   Copyright 2001-2002 Bernd Gehrmann <bernd@mail.berlios.de>            *
  *   Copyright 2001-2002 Matthias Hoelzer-Kluepfel <hoelzer@kde.org>       *
  *   Copyright 2003 Roberto Raggi <roberto@kdevelop.org>                   *
  *   Copyright 2010 Niko Sams <niko.sams@gmail.com>                        *
  *   Copyright 2015 Kevin Funk <kfunk@kde.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.         *
  ***************************************************************************/
 
 #include <config.h>
 
 #include "urlinfo.h"
 
 #include <KLocalizedString>
 #include <Kdelibs4ConfigMigrator>
 #include <kaboutdata.h>
 #include <ktexteditor/cursor.h>
 #include <kcrash.h>
 
 #include <QApplication>
 #include <QElapsedTimer>
 #include <QCommandLineParser>
 #include <QCommandLineOption>
 #include <QFileInfo>
-#include <QDir>
-#include <QProcess>
+#include <QProcessEnvironment>
 #include <QSessionManager>
 #include <QTextStream>
 #include <QDBusInterface>
 #include <QDBusReply>
 #include <QLoggingCategory>
 
 Q_DECLARE_LOGGING_CATEGORY(APP)
 Q_LOGGING_CATEGORY(APP, "kdevelop.app")
 
 #include <shell/core.h>
 #include <shell/mainwindow.h>
 #include <shell/projectcontroller.h>
 #include <shell/documentcontroller.h>
 #include <shell/plugincontroller.h>
 #include <shell/sessioncontroller.h>
 #include <shell/runcontroller.h>
 #include <shell/launchconfiguration.h>
 #include <shell/session.h>
 #include <interfaces/ilauncher.h>
 #include <interfaces/iproject.h>
 #include <interfaces/launchconfigurationtype.h>
 #include <util/path.h>
 
 #include "kdevideextension.h"
 #if KDEVELOP_SINGLE_APP
 #include "qtsingleapplication.h"
 #endif
 
 #include <iostream>
 
 #ifdef Q_OS_MAC
 #include <CoreFoundation/CoreFoundation.h>
 #endif
 
 using namespace KDevelop;
 
 namespace {
 
 #if KDEVELOP_SINGLE_APP
 QString serializeOpenFilesMessage(const QVector<UrlInfo> &infos)
 {
     QByteArray message;
     QDataStream stream(&message, QIODevice::WriteOnly);
     stream << QByteArrayLiteral("open");
     stream << infos;
     return QString::fromLatin1(message.toHex());
 }
 #endif
 
 void openFiles(const QVector<UrlInfo>& infos)
 {
     foreach (const UrlInfo& file, infos) {
         if (!ICore::self()->documentController()->openDocument(file.url, file.cursor)) {
             qWarning() << i18n("Could not open %1", file.url.toDisplayString(QUrl::PreferLocalFile));
         }
     }
 }
 
 }
 
 class KDevelopApplication:
 #if KDEVELOP_SINGLE_APP
     public SharedTools::QtSingleApplication
 #else
     public QApplication
 #endif
 {
 public:
     explicit KDevelopApplication(int &argc, char **argv, bool GUIenabled = true)
 #if KDEVELOP_SINGLE_APP
         : SharedTools::QtSingleApplication(QStringLiteral("KDevelop"), argc, argv)
 #else
         : QApplication(argc, argv, GUIenabled)
 #endif
         {
             Q_UNUSED(GUIenabled);
             connect(this, &QGuiApplication::saveStateRequest, this, &KDevelopApplication::saveState);
         }
 
 #if KDEVELOP_SINGLE_APP
 public Q_SLOTS:
     void remoteArguments(const QString &message, QObject *socket)
     {
         Q_UNUSED(socket);
 
         QByteArray ba = QByteArray::fromHex(message.toLatin1());
         QDataStream stream(ba);
         QByteArray command;
         stream >> command;
 
         qCDebug(APP) << "Received remote command: " << command;
 
         if (command == "open") {
             QVector<UrlInfo> infos;
             stream >> infos;
             openFiles(infos);
         } else {
             qCWarning(APP) << "Unknown remote command: " << command;
         }
     }
 
     void fileOpenRequested(const QString &file)
     {
         openFiles({UrlInfo(file)});
     }
 #endif
 
 private Q_SLOTS:
     void saveState( QSessionManager& sm ) {
         if (KDevelop::Core::self() && KDevelop::Core::self()->sessionController()) {
             QString x11SessionId = QString("%1_%2").arg(sm.sessionId()).arg(sm.sessionKey());
             const auto activeSession = KDevelop::Core::self()->sessionController()->activeSession();
             if (!activeSession) {
                 qWarning() << "No active session, can't save state";
                 return;
             }
 
             QString kdevelopSessionId = activeSession->id().toString();
             sm.setRestartCommand({QCoreApplication::applicationFilePath(), "-session", x11SessionId, "-s", kdevelopSessionId});
         }
     }
 };
 
 /// Tries to find a session identified by @p data in @p sessions.
 /// The @p data may be either a session's name or a string-representation of its UUID.
 /// @return pointer to the session or NULL if nothing appropriate has been found
 static const KDevelop::SessionInfo* findSessionInList( const SessionInfos& sessions, const QString& data )
 {
     // We won't search a session without input data, since that could lead to false-positives
     // with unnamed sessions
     if( data.isEmpty() )
         return nullptr;
 
     for( auto it = sessions.constBegin(); it != sessions.constEnd(); ++it ) {
         if ( ( it->name == data ) || ( it->uuid.toString() == data ) ) {
             const KDevelop::SessionInfo& sessionRef = *it;
             return &sessionRef;
         }
     }
     return nullptr;
 }
 
 /// Performs a DBus call to open the given @p files in the running kdev instance identified by @p pid
 /// Returns the exit status
 static int openFilesInRunningInstance(const QVector<UrlInfo>& files, qint64 pid)
 {
     const QString service = QString("org.kdevelop.kdevelop-%1").arg(pid);
     QDBusInterface iface(service, "/org/kdevelop/DocumentController", "org.kdevelop.DocumentController");
 
     QStringList urls;
     bool errors_occured = false;
     foreach ( const UrlInfo& file, files ) {
         QDBusReply<bool> result = iface.call("openDocumentSimple", file.url.toString(), file.cursor.line(), file.cursor.column());
         if ( ! result.value() ) {
             QTextStream err(stderr);
             err << i18n("Could not open file %1.", file.url.toDisplayString(QUrl::PreferLocalFile)) << "\n";
             errors_occured = true;
         }
     }
     // make the window visible
     QDBusMessage makeVisible = QDBusMessage::createMethodCall( service, "/kdevelop/MainWindow", "org.kdevelop.MainWindow",
                                                                "ensureVisible" );
     QDBusConnection::sessionBus().asyncCall( makeVisible );
     return errors_occured;
 }
 
 /// Gets the PID of a running KDevelop instance, eventually asking the user if there is more than one.
 /// Returns -1 in case there are no running sessions.
 static qint64 getRunningSessionPid()
 {
     SessionInfos candidates;
     foreach( const KDevelop::SessionInfo& si, KDevelop::SessionController::availableSessionInfos() ) {
         if( KDevelop::SessionController::isSessionRunning(si.uuid.toString()) ) {
             candidates << si;
         }
     }
     if ( candidates.isEmpty() ) {
         return -1;
     }
 
     QString sessionUuid;
     if ( candidates.size() == 1 ) {
         sessionUuid = candidates.first().uuid.toString();
     }
     else {
         const QString title = i18n("Select the session to open the document in");
         sessionUuid = KDevelop::SessionController::showSessionChooserDialog(title, true);
     }
     return KDevelop::SessionController::sessionRunInfo(sessionUuid).holderPid;
 }
 
 static QString findSessionId(const SessionInfos& availableSessionInfos, const QString& session)
 {
     //If there is a session and a project with the same name, always open the session
     //regardless of the order encountered
     QString projectAsSession;
     foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
     {
         if ( session == si.name || session == si.uuid.toString() ) {
             return si.uuid.toString();
         } else if (projectAsSession.isEmpty()) {
             foreach(const QUrl& k, si.projects) {
                 QString fn(k.fileName());
                 fn = fn.left(fn.indexOf('.'));
                 if ( session == fn ) {
                     projectAsSession = si.uuid.toString();
                 }
             }
         }
     }
 
     if (projectAsSession.isEmpty())  {
         QTextStream qerr(stderr);
         qerr << endl << i18n("Cannot open unknown session %1. See `--list-sessions` switch for available sessions or use `-n` to create a new one.",
                              session) << endl;
     }
     return projectAsSession;
 }
 
 static qint64 findSessionPid(const QString &sessionId)
 {
     KDevelop::SessionRunInfo sessionInfo = KDevelop::SessionController::sessionRunInfo( sessionId );
     return sessionInfo.holderPid;
 }
 
 int main( int argc, char *argv[] )
 {
     QElapsedTimer timer;
     timer.start();
 
     // TODO: Maybe generalize, add KDEVELOP_STANDALONE build option
 #if defined(Q_OS_WIN) || defined(Q_OS_MAC)
     qputenv("KDE_FORK_SLAVES", "1"); // KIO slaves will be forked off instead of being started via DBus
 #endif
 
     // Useful for valgrind runs, just `export KDEV_DISABLE_JIT=1`
     if (qEnvironmentVariableIsSet("KDEV_DISABLE_JIT")) {
         qputenv("KDEV_DISABLE_WELCOMEPAGE", "1");
         qputenv("QT_ENABLE_REGEXP_JIT", "0");
     }
 
     // Don't show any debug output by default.
     // If you need to enable additional logging for debugging use a rules file
     // as explained in the QLoggingCategory documentation:
     // http://qt-project.org/doc/qt-5/qloggingcategory.html#logging-rules
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\n"));
     KLocalizedString::setApplicationDomain("kdevelop");
     QCoreApplication::setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
 
 #ifdef Q_OS_MAC
     CFBundleRef mainBundle = CFBundleGetMainBundle();
     if (mainBundle) {
         // get the application's Info Dictionary. For app bundles this would live in the bundle's Info.plist,
         // for regular executables it is obtained in another way.
         CFMutableDictionaryRef infoDict = (CFMutableDictionaryRef) CFBundleGetInfoDictionary(mainBundle);
         if (infoDict) {
             // Try to prevent App Nap on OS X. This can be tricky in practice, at least in 10.9 .
             CFDictionarySetValue(infoDict, CFSTR("NSAppSleepDisabled"), kCFBooleanTrue);
             CFDictionarySetValue(infoDict, CFSTR("NSSupportsAutomaticTermination"), kCFBooleanFalse);
         }
     }
 #endif
 
     static const char description[] = I18N_NOOP( "The KDevelop Integrated Development Environment" );
     KAboutData aboutData( "kdevelop", i18n( "KDevelop" ), QByteArray(VERSION), i18n(description), KAboutLicense::GPL,
                           i18n("Copyright 1999-2017, The KDevelop developers"), QString(), "https://www.kdevelop.org/");
     aboutData.setDesktopFileName(QStringLiteral("org.kde.kdevelop.desktop"));
     aboutData.addAuthor( i18n("Kevin Funk"), i18n( "Co-maintainer, C++/Clang, QA, Windows Support" ), "kfunk@kde.org" );
     aboutData.addAuthor( i18n("Sven Brauch"), i18n( "Co-maintainer, AppImage, Python Support, User Interface improvements" ), "svenbrauch@gmail.com" );
     aboutData.addAuthor( i18n("Aleix Pol Gonzalez"), i18n( "CMake Support, Run Support, Kross Support" ), "aleixpol@gmail.com" );
     aboutData.addAuthor( i18n("Milian Wolff"), i18n( "C++/Clang, Generic manager, Webdevelopment Plugins, Snippets, Performance" ), "mail@milianw.de" );
     aboutData.addAuthor( i18n("Olivier JG"), i18n( "C++/Clang, DUChain, Bug Fixes" ), "olivier.jg@gmail.com" );
     aboutData.addAuthor( i18n("Andreas Pakulat"), i18n( "Architecture, VCS Support, Project Management Support, QMake Projectmanager" ), "apaku@gmx.de" );
     aboutData.addAuthor( i18n("Alexander Dymo"), i18n( "Architecture, Sublime UI, Ruby support" ), "adymo@kdevelop.org" );
     aboutData.addAuthor( i18n("David Nolden"), i18n( "Definition-Use Chain, C++ Support, Code Navigation, Code Completion, Coding Assistance, Refactoring" ), "david.nolden.kdevelop@art-master.de" );
     aboutData.addAuthor( i18n("Vladimir Prus"), i18n( "GDB integration" ), "ghost@cs.msu.su" );
     aboutData.addAuthor( i18n("Hamish Rodda"), i18n( "Text editor integration, definition-use chain" ), "rodda@kde.org" );
     aboutData.addAuthor( i18n("Amilcar do Carmo Lucas"), i18n( "Website admin, API documentation, Doxygen and autoproject patches" ), "amilcar@kdevelop.org" );
     aboutData.addAuthor( i18n("Niko Sams"), i18n( "GDB integration, Webdevelopment Plugins" ), "niko.sams@gmail.com" );
 
     aboutData.addCredit( i18n("Matt Rogers"), QString(), "mattr@kde.org");
     aboutData.addCredit( i18n("Cédric Pasteur"), i18n("astyle and indent support"), "cedric.pasteur@free.fr" );
     aboutData.addCredit( i18n("Evgeniy Ivanov"), i18n("Distributed VCS, Git, Mercurial"), "powerfox@kde.ru" );
     // QTest integration is separate in playground currently.
     //aboutData.addCredit( i18n("Manuel Breugelmanns"), i18n( "Veritas, QTest integration"), "mbr.nxi@gmail.com" );
     aboutData.addCredit( i18n("Robert Gruber") , i18n( "SnippetPart, debugger and usability patches" ), "rgruber@users.sourceforge.net" );
     aboutData.addCredit( i18n("Dukju Ahn"), i18n( "Subversion plugin, Custom Make Manager, Overall improvements" ), "dukjuahn@gmail.com" );
     aboutData.addCredit( i18n("Harald Fernengel"), i18n( "Ported to Qt 3, patches, valgrind, diff and perforce support" ), "harry@kdevelop.org" );
     aboutData.addCredit( i18n("Roberto Raggi"), i18n( "C++ parser" ), "roberto@kdevelop.org" );
     aboutData.addCredit( i18n("The KWrite authors"), i18n( "Kate editor component" ), "kwrite-devel@kde.org" );
     aboutData.addCredit( i18n("Nokia Corporation/Qt Software"), i18n( "Designer code" ), "qt-info@nokia.com" );
 
     aboutData.addCredit( i18n("Contributors to older versions:"), QString(), "" );
     aboutData.addCredit( i18n("Bernd Gehrmann"), i18n( "Initial idea, basic architecture, much initial source code" ), "bernd@kdevelop.org" );
     aboutData.addCredit( i18n("Caleb Tennis"), i18n( "KTabBar, bugfixes" ), "caleb@aei-tech.com" );
     aboutData.addCredit( i18n("Richard Dale"), i18n( "Java & Objective C support" ), "Richard_Dale@tipitina.demon.co.uk" );
     aboutData.addCredit( i18n("John Birch"), i18n( "Debugger frontend" ), "jbb@kdevelop.org" );
     aboutData.addCredit( i18n("Sandy Meier"), i18n( "PHP support, context menu stuff" ), "smeier@kdevelop.org" );
     aboutData.addCredit( i18n("Kurt Granroth"), i18n( "KDE application templates" ), "kurth@granroth.org" );
     aboutData.addCredit( i18n("Ian Reinhart Geiser"), i18n( "Dist part, bash support, application templates" ), "geiseri@yahoo.com" );
     aboutData.addCredit( i18n("Matthias Hoelzer-Kluepfel"), i18n( "Several components, htdig indexing" ), "hoelzer@kde.org" );
     aboutData.addCredit( i18n("Victor Roeder"), i18n( "Help with Automake manager and persistent class store" ), "victor_roeder@gmx.de" );
     aboutData.addCredit( i18n("Simon Hausmann"), i18n( "Help with KParts infrastructure" ), "hausmann@kde.org" );
     aboutData.addCredit( i18n("Oliver Kellogg"), i18n( "Ada support" ), "okellogg@users.sourceforge.net" );
     aboutData.addCredit( i18n("Jakob Simon-Gaarde"), i18n( "QMake projectmanager" ), "jsgaarde@tdcspace.dk" );
     aboutData.addCredit( i18n("Falk Brettschneider"), i18n( "MDI modes, QEditor, bugfixes" ), "falkbr@kdevelop.org" );
     aboutData.addCredit( i18n("Mario Scalas"), i18n( "PartExplorer, redesign of CvsPart, patches, bugs(fixes)" ), "mario.scalas@libero.it" );
     aboutData.addCredit( i18n("Jens Dagerbo"), i18n( "Replace, Bookmarks, FileList and CTags2 plugins. Overall improvements and patches" ), "jens.dagerbo@swipnet.se" );
     aboutData.addCredit( i18n("Julian Rockey"), i18n( "Filecreate part and other bits and patches" ), "linux@jrockey.com" );
     aboutData.addCredit( i18n("Ajay Guleria"), i18n( "ClearCase support" ), "ajay_guleria@yahoo.com" );
     aboutData.addCredit( i18n("Marek Janukowicz"), i18n( "Ruby support" ), "child@t17.ds.pwr.wroc.pl" );
     aboutData.addCredit( i18n("Robert Moniot"), i18n( "Fortran documentation" ), "moniot@fordham.edu" );
     aboutData.addCredit( i18n("Ka-Ping Yee"), i18n( "Python documentation utility" ), "ping@lfw.org" );
     aboutData.addCredit( i18n("Dimitri van Heesch"), i18n( "Doxygen wizard" ), "dimitri@stack.nl" );
     aboutData.addCredit( i18n("Hugo Varotto"), i18n( "Fileselector component" ), "hugo@varotto-usa.com" );
     aboutData.addCredit( i18n("Matt Newell"), i18n( "Fileselector component" ), "newellm@proaxis.com" );
     aboutData.addCredit( i18n("Daniel Engelschalt"), i18n( "C++ code completion, persistent class store" ), "daniel.engelschalt@gmx.net" );
     aboutData.addCredit( i18n("Stephane Ancelot"), i18n( "Patches" ), "sancelot@free.fr" );
     aboutData.addCredit( i18n("Jens Zurheide"), i18n( "Patches" ), "jens.zurheide@gmx.de" );
     aboutData.addCredit( i18n("Luc Willems"), i18n( "Help with Perl support" ), "Willems.luc@pandora.be" );
     aboutData.addCredit( i18n("Marcel Turino"), i18n( "Documentation index view" ), "M.Turino@gmx.de" );
     aboutData.addCredit( i18n("Yann Hodique"), i18n( "Patches" ), "Yann.Hodique@lifl.fr" );
     aboutData.addCredit( i18n("Tobias Gl\303\244\303\237er") , i18n( "Documentation Finder,  qmake projectmanager patches, usability improvements, bugfixes ... " ), "tobi.web@gmx.de" );
     aboutData.addCredit( i18n("Andreas Koepfle") , i18n( "QMake project manager patches" ), "koepfle@ti.uni-mannheim.de" );
     aboutData.addCredit( i18n("Sascha Cunz") , i18n( "Cleanup and bugfixes for qEditor, AutoMake and much other stuff" ), "mail@sacu.de" );
     aboutData.addCredit( i18n("Zoran Karavla"), i18n( "Artwork for the ruby language" ), "webmaster@the-error.net", "http://the-error.net" );
 
 
     //we can't use KCmdLineArgs as it doesn't allow arguments for the debugee
     //so lookup the --debug switch and eat everything behind by decrementing argc
     //debugArgs is filled with args after --debug <debuger>
     QStringList debugArgs;
     QString debugeeName;
     {
         bool debugFound = false;
         int c = argc;
         for (int i=0; i < c; ++i) {
             if (debugFound) {
                 debugArgs << argv[i];
             } else if ((qstrcmp(argv[i], "--debug") == 0) || (qstrcmp(argv[i], "-d") == 0)) {
                 if (argc > (i + 1)) {
                     i++;
                 }
                 argc = i + 1;
                 debugFound = true;
             } else if (QString(argv[i]).startsWith("--debug=")) {
                 argc = i + 1;
                 debugFound = true;
             }
         }
     }
 
     KDevelopApplication app(argc, argv);
 
     KCrash::initialize();
 
     Kdelibs4ConfigMigrator migrator(QStringLiteral("kdevelop"));
     migrator.setConfigFiles({QStringLiteral("kdeveloprc")});
     migrator.setUiFiles({QStringLiteral("kdevelopui.rc")});
     migrator.migrate();
 
     // High DPI support
     app.setAttribute(Qt::AA_UseHighDpiPixmaps, true);
 
     qCDebug(APP) << "Startup";
 
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     parser.addVersionOption();
     parser.addHelpOption();
     aboutData.setupCommandLine(&parser);
 
     parser.addOption(QCommandLineOption{QStringList{"n", "new-session"}, i18n("Open KDevelop with a new session using the given name."), "name"});
     parser.addOption(QCommandLineOption{QStringList{"s", "open-session"}, i18n("Open KDevelop with the given session.\n"
                      "You can pass either hash or the name of the session." ), "session"});
     parser.addOption(QCommandLineOption{QStringList{"rm", "remove-session"}, i18n("Delete the given session.\n"
                      "You can pass either hash or the name of the session." ), "session"});
     parser.addOption(QCommandLineOption{QStringList{"ps", "pick-session"}, i18n("Shows all available sessions and lets you select one to open.")});
     parser.addOption(QCommandLineOption{QStringList{"pss", "pick-session-shell"}, i18n("List all available sessions on shell and lets you select one to open.")});
     parser.addOption(QCommandLineOption{QStringList{"l", "list-sessions"}, i18n("List available sessions and quit.")});
     parser.addOption(QCommandLineOption{QStringList{"p", "project"}, i18n("Open KDevelop and load the given project."), "project"});
     parser.addOption(QCommandLineOption{QStringList{"d", "debug"},
                      i18n("Start debugging an application in KDevelop with the given debugger.\n"
                      "The executable that should be debugged must follow - including arguments.\n"
                      "Example: kdevelop --debug gdb myapp --foo bar"), "debugger"});
 
     // this is used by the 'kdevelop!' script to retrieve the pid of a KDEVELOP
     // instance. When this is called, then we should just print the PID on the
     // standard-output. If a session is specified through open-session, then
     // we should return the PID of that session. Otherwise, if only a single
     // session is running, then we should just return the PID of that session.
     // Otherwise, we should print a command-line session-chooser dialog ("--pss"),
     // which only shows the running sessions, and the user can pick one.
     parser.addOption(QCommandLineOption{QStringList{"pid"}});
 
     parser.addPositionalArgument("files", i18n( "Files to load" ), "[FILE...]");
 
     // The session-controller needs to arguments to eventually pass them to newly opened sessions
     KDevelop::SessionController::setArguments(argc, argv);
 
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     if(parser.isSet("list-sessions"))
     {
         QTextStream qout(stdout);
         qout << endl << ki18n("Available sessions (use '-s HASH' or '-s NAME' to open a specific one):").toString() << endl << endl;
         qout << QString("%1").arg(ki18n("Hash").toString(), -38) << '\t' << ki18n("Name: Opened Projects").toString() << endl;
         foreach(const KDevelop::SessionInfo& si, KDevelop::SessionController::availableSessionInfos())
         {
             if ( si.name.isEmpty() && si.projects.isEmpty() ) {
                 continue;
             }
             qout << si.uuid.toString() << '\t' << si.description;
 
             if(KDevelop::SessionController::isSessionRunning(si.uuid.toString()))
                 qout << "     " << i18n("[running]");
 
             qout << endl;
         }
         return 0;
     }
 
     // Handle extra arguments, which stand for files to open
     QVector<UrlInfo> initialFiles;
     foreach (const QString &file, parser.positionalArguments()) {
         initialFiles.append(UrlInfo(file));
     }
 
     const auto availableSessionInfos = KDevelop::SessionController::availableSessionInfos();
 
     if (!initialFiles.isEmpty() && !parser.isSet("new-session")) {
 #if KDEVELOP_SINGLE_APP
         if (app.isRunning()) {
             bool success = app.sendMessage(serializeOpenFilesMessage(initialFiles));
             if (success) {
                 return 0;
             }
         }
 #else
         qint64 pid = -1;
         if (parser.isSet("open-session")) {
             const QString session = findSessionId(availableSessionInfos, parser.value("open-session"));
             if (session.isEmpty()) {
                 return 1;
             } else if (KDevelop::SessionController::isSessionRunning(session)) {
                 pid = findSessionPid(session);
             }
         } else {
             pid = getRunningSessionPid();
         }
         if ( pid > 0 ) {
             return openFilesInRunningInstance(initialFiles, pid);
         }
         // else there are no running sessions, and the generated list of files will be opened below.
 #endif
     }
 
     // if empty, restart kdevelop with last active session, see SessionController::defaultSessionId
     QString session;
 
     uint nRunningSessions = 0;
     foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
         if(KDevelop::SessionController::isSessionRunning(si.uuid.toString()))
             ++nRunningSessions;
 
     // also show the picker dialog when a pid shall be retrieved and multiple
     // sessions are running.
     if(parser.isSet("pss") || (parser.isSet("pid") && !parser.isSet("open-session") && !parser.isSet("ps") && nRunningSessions > 1))
     {
         QTextStream qerr(stderr);
         SessionInfos candidates;
         foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
             if( (!si.name.isEmpty() || !si.projects.isEmpty() || parser.isSet("pid")) &&
                 (!parser.isSet("pid") || KDevelop::SessionController::isSessionRunning(si.uuid.toString())))
                 candidates << si;
 
         if(candidates.size() == 0)
         {
             qerr << "no session available" << endl;
             return 1;
         }
 
         if(candidates.size() == 1 && parser.isSet("pid"))
         {
             session = candidates[0].uuid.toString();
         }else{
             for(int i = 0; i < candidates.size(); ++i)
                 qerr << "[" << i << "]: " << candidates[i].description << endl;
 
             int chosen;
             std::cin >> chosen;
             if(std::cin.good() && (chosen >= 0 && chosen < candidates.size()))
             {
                 session = candidates[chosen].uuid.toString();
             }else{
                 qerr << "invalid selection" << endl;
                 return 1;
             }
         }
     }
 
     if(parser.isSet("ps"))
     {
         bool onlyRunning = parser.isSet("pid");
         session = KDevelop::SessionController::showSessionChooserDialog(i18n("Select the session you would like to use"), onlyRunning);
         if(session.isEmpty())
             return 1;
     }
 
     if ( parser.isSet("debug") ) {
         if ( debugArgs.isEmpty() ) {
             QTextStream qerr(stderr);
             qerr << endl << i18nc("@info:shell", "Specify the executable you want to debug.") << endl;
             return 1;
         }
 
         QFileInfo executableFileInfo(debugArgs.first());
         if (!executableFileInfo.exists()) {
             executableFileInfo = QStandardPaths::findExecutable(debugArgs.first());
             if (!executableFileInfo.exists()) {
                 QTextStream qerr(stderr);
                 qerr << endl << i18nc("@info:shell", "Specified executable does not exist.") << endl;
                 return 1;
             }
         }
 
         debugArgs.first() = executableFileInfo.absoluteFilePath();
         debugeeName = i18n("Debug %1", executableFileInfo.fileName());
         session = debugeeName;
     } else if ( parser.isSet("new-session") )
     {
         session = parser.value("new-session");
         foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
         {
             if ( session == si.name ) {
                 QTextStream qerr(stderr);
                 qerr << endl << i18n("A session with the name %1 exists already. Use the -s switch to open it.", session) << endl;
                 return 1;
             }
         }
         // session doesn't exist, we can create it
     } else if ( parser.isSet("open-session") ) {
         session = findSessionId(availableSessionInfos, parser.value("open-session"));
         if (session.isEmpty()) {
             return 1;
         }
     } else if ( parser.isSet("remove-session") )
     {
         session = parser.value("remove-session");
         auto si = findSessionInList(availableSessionInfos, session);
         if (!si) {
             QTextStream qerr(stderr);
             qerr << endl << i18n("No session with the name %1 exists.", session) << endl;
             return 1;
         }
 
         auto sessionLock = KDevelop::SessionController::tryLockSession(si->uuid.toString());
         if (!sessionLock.lock) {
             QTextStream qerr(stderr);
             qerr << endl << i18n("Could not lock session %1 for deletion.", session) << endl;
             return 1;
         }
         KDevelop::SessionController::deleteSessionFromDisk(sessionLock.lock);
         QTextStream qout(stdout);
         qout << endl << i18n("Session with name %1 was successfully removed.", session) << endl;
         return 0;
     }
 
     if(parser.isSet("pid")) {
         if (session.isEmpty())
         {   // just pick the first running session
             foreach(const KDevelop::SessionInfo& si, availableSessionInfos)
                 if(KDevelop::SessionController::isSessionRunning(si.uuid.toString()))
                     session = si.uuid.toString();
         }
         const KDevelop::SessionInfo* sessionData = findSessionInList(availableSessionInfos, session);
 
         if( !sessionData ) {
             qCritical() << "session not given or does not exist";
             return 5;
         }
 
         const auto pid = findSessionPid(sessionData->uuid.toString());
         if (pid > 0) {
             // Print the PID and we're ready
             std::cout << pid << std::endl;
             return 0;
         } else {
             qCritical() << sessionData->uuid.toString() << sessionData->name << "is not running";
             return 5;
         }
     }
 
     KDevIDEExtension::init();
 
     if(!Core::initialize(Core::Default, session))
         return 5;
 
     // register a DBUS service for this process, so that we can open files in it from other invocations
     QDBusConnection::sessionBus().registerService(QString("org.kdevelop.kdevelop-%1").arg(app.applicationPid()));
 
 //     TODO: port to kf5
 //     KGlobal::locale()->insertCatalog( Core::self()->componentData().catalogName() );
     Core* core = Core::self();
     if (!QProcessEnvironment::systemEnvironment().contains("KDEV_DISABLE_WELCOMEPAGE")) {
         core->pluginController()->loadPlugin("KDevWelcomePage");
     }
 
     QStringList projectNames = parser.values("project");
     foreach(const QString& projectName, projectNames)
     {
         QFileInfo info( projectName );
         if( info.suffix() == "kdev4" ) {
             // make sure the project is not already opened by the session controller
             bool shouldOpen = true;
             Path path(info.absoluteFilePath());
             foreach(KDevelop::IProject* project, core->projectController()->projects()) {
                 if (project->projectFile() == path) {
                     shouldOpen = false;
                     break;
                 }
             }
             if (shouldOpen) {
                 core->projectController()->openProject( path.toUrl() );
             }
         }
     }
 
     const QString debugStr = QStringLiteral("debug");
     if ( parser.isSet(debugStr) ) {
         Q_ASSERT( !debugeeName.isEmpty() );
         QString launchName = debugeeName;
 
         KDevelop::LaunchConfiguration* launch = nullptr;
         qCDebug(APP) << launchName;
         foreach (KDevelop::LaunchConfiguration *l, core->runControllerInternal()->launchConfigurationsInternal()) {
             qCDebug(APP) << l->name();
             if (l->name() == launchName) {
                 launch = l;
             }
         }
 
         KDevelop::LaunchConfigurationType *type = nullptr;
         foreach (KDevelop::LaunchConfigurationType *t, core->runController()->launchConfigurationTypes()) {
             qCDebug(APP) << t->id();
             if (t->id() == "Native Application") {
                 type = t;
                 break;
             }
         }
         if (!type) {
             QTextStream qerr(stderr);
             qerr << endl << i18n("Cannot find native launch configuration type") << endl;
             return 1;
         }
 
         if (launch && launch->type()->id() != "Native Application") launch = nullptr;
         if (launch && launch->launcherForMode(debugStr) != parser.value(debugStr)) launch = nullptr;
         if (!launch) {
             qCDebug(APP) << launchName << "not found, creating a new one";
             QPair<QString,QString> launcher;
             launcher.first = debugStr;
             foreach (KDevelop::ILauncher *l, type->launchers()) {
                 if (l->id() == parser.value(debugStr)) {
                     if (l->supportedModes().contains(debugStr)) {
                         launcher.second = l->id();
                     }
                 }
             }
             if (launcher.second.isEmpty()) {
                 QTextStream qerr(stderr);
                 qerr << endl << i18n("Cannot find launcher %1", parser.value(debugStr)) << endl;
                 return 1;
             }
             KDevelop::ILaunchConfiguration* ilaunch = core->runController()->createLaunchConfiguration(type, launcher, nullptr, launchName);
             launch = dynamic_cast<KDevelop::LaunchConfiguration*>(ilaunch);
         }
 
         type->configureLaunchFromCmdLineArguments(launch->config(), debugArgs);
         launch->config().writeEntry("Break on Start", true);
         core->runControllerInternal()->setDefaultLaunch(launch);
 
         core->runControllerInternal()->execute(debugStr, launch);
     } else {
         openFiles(initialFiles);
     }
 
 #if KDEVELOP_SINGLE_APP
     // Set up remote arguments.
     QObject::connect(&app, &SharedTools::QtSingleApplication::messageReceived,
                      &app, &KDevelopApplication::remoteArguments);
 
     QObject::connect(&app, &SharedTools::QtSingleApplication::fileOpenRequest,
                      &app, &KDevelopApplication::fileOpenRequested);
 #endif
 
 
 #ifdef WITH_WELCOMEPAGE
     // make it possible to disable the welcome page, useful for valgrind runs e.g.
     if (!qEnvironmentVariableIsSet("KDEV_DISABLE_WELCOMEPAGE")) {
         trySetupWelcomePageView();
     }
 #endif
 
     qCDebug(APP) << "Done startup" << "- took:" << timer.elapsed() << "ms";
     timer.invalidate();
 
     return app.exec();
 }
diff --git a/app/plasma/dataengine/kdevelopsessionsengine.cpp b/app/plasma/dataengine/kdevelopsessionsengine.cpp
index b84b588f9e..508f5deff7 100644
--- a/app/plasma/dataengine/kdevelopsessionsengine.cpp
+++ b/app/plasma/dataengine/kdevelopsessionsengine.cpp
@@ -1,161 +1,159 @@
 /*****************************************************************************
 *   Copyright (C) 2012 by Eike Hein <hein@kde.org>                           *
 *   Copyright (C) 2011 by Shaun Reich <shaun.reich@kdemail.net>              *
 *   Copyright (C) 2008 by Montel Laurent <montel@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, see <http://www.gnu.org/licenses/>.    *
 *****************************************************************************/
 
 #include "kdevelopsessionsengine.h"
 #include "kdevelopsessionsservice.h"
-#include <QtCore/QStandardPaths>
-#include <QtCore/QDir>
 
 #include <KDirWatch>
 #include <KConfig>
 #include <QFileInfo>
 #include <QDir>
 #include <QStandardPaths>
 
 KDevelopSessionsEngine::KDevelopSessionsEngine(QObject *parent, const QVariantList &args)
     : Plasma::DataEngine(parent, args),
       m_dirWatch(nullptr)
 {
     init();
 }
 
 KDevelopSessionsEngine::~KDevelopSessionsEngine()
 {
 }
 
 void KDevelopSessionsEngine::init()
 {
     m_dirWatch = new KDirWatch( this );
 
     const QStringList sessionDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, "kdevelop/sessions", QStandardPaths::LocateDirectory );
 
     for ( int i = 0; i < sessionDirs.count(); ++i )
         m_dirWatch->addDir( sessionDirs[i], KDirWatch::WatchSubDirs );
 
     connect(m_dirWatch, &KDirWatch::dirty, this, &KDevelopSessionsEngine::updateSessions);
 
     updateSessions();
 }
 
 Plasma::Service *KDevelopSessionsEngine::serviceForSource(const QString &source)
 {
     return new KDevelopSessionsService( this, source );
 }
 
 QStringList findSessions()
 {
     QStringList sessionDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, "kdevelop/sessions", QStandardPaths::LocateDirectory);
     QStringList sessionrcs;
     Q_FOREACH(const QString& dir, sessionDirs) {
         QDir d(dir);
         Q_FOREACH(const QString& sessionDir, d.entryList(QDir::Dirs)) {
             QDir sd(d.absoluteFilePath(sessionDir));
             QString path(sd.filePath("sessionrc"));
             if(QFile::exists(path)) {
                 sessionrcs += path;
             }
         }
     }
     return sessionrcs;
 }
 
 void KDevelopSessionsEngine::updateSessions()
 {
     QStringList sessionrcs = findSessions();
 
     QHash<QString, Session> sessions;
 
     QStringList::const_iterator it;
 
     for (it = sessionrcs.constBegin(); it != sessionrcs.constEnd(); ++it)
     {
         KConfig cfg( *it, KConfig::SimpleConfig );
 
         // Only consider sessions that have open projects.
         if ( cfg.hasGroup( "General Options" ) && !cfg.group( "General Options" ).readEntry( "Open Projects", "" ).isEmpty() )
         {
             Session session;
             session.hash = QFileInfo( *it ).dir().dirName();
             session.name = cfg.group( "" ).readEntry( "SessionName", "" );
             session.description = cfg.group( "" ).readEntry( "SessionPrettyContents", "" );
 
             sessions.insert(session.hash, session);
         }
     }
 
     QHash<QString, Session>::const_iterator it2;
 
     for (it2 = sessions.constBegin(); it2 != sessions.constEnd(); ++it2)
     {
         const Session& session = it2.value();
 
         if ( !m_currentSessions.contains( session.hash ) )
         {
             // Publish new session.
 
             m_currentSessions.insert( session.hash, session );
             setData( session.hash, "sessionName", session.name );
             setData( session.hash, "sessionString", session.description );
         }
         else
         {
             // Publish data changes for older sessions.
 
             Session oldSession( m_currentSessions.value(session.hash) );
 
             bool modified = false;
 
             if ( session.name != oldSession.name )
             {
                 oldSession.name = session.name;
                 modified = true;
                 setData( session.hash, "sessionName", session.name );
             }
 
             if ( session.description != oldSession.description )
             {
                 oldSession.description = session.description;
                 modified = true;
                 setData( session.hash, "sessionString", session.description );
             }
 
             if ( modified )
                 m_currentSessions.insert( oldSession.hash, oldSession );
         }
     }
 
     QHash<QString, Session>::iterator it3 = m_currentSessions.begin();
 
     while ( it3 != m_currentSessions.end() )
     {
         const Session& session = it3.value();
 
         if ( !sessions.contains( session.hash ) )
         {
             removeSource( session.hash );
             it3 = m_currentSessions.erase( it3 );
         }
         else
             ++it3;
     }
 }
 
 K_EXPORT_PLASMA_DATAENGINE_WITH_JSON(kdevelopsessionsengine, KDevelopSessionsEngine, "plasma-dataengine-kdevelopsessions.json")
 
 #include "kdevelopsessionsengine.moc"
diff --git a/app/plasma/runner/kdevelopsessions.cpp b/app/plasma/runner/kdevelopsessions.cpp
index 98a732c2e8..1d1ba4b2ff 100644
--- a/app/plasma/runner/kdevelopsessions.cpp
+++ b/app/plasma/runner/kdevelopsessions.cpp
@@ -1,186 +1,183 @@
 /*
  *   Copyright 2008,2011 Sebastian Kügler <sebas@kde.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, 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.
  */
 
 #include "kdevelopsessions.h"
 
 #include <QtCore/QCollator>
-#include <QtCore/QStandardPaths>
 #include <QtCore/QDir>
 #include <KLocalizedString>
 
 
 #include <QDebug>
 #include <QIcon>
 #include <QFile>
 #include <KDirWatch>
 #include <KToolInvocation>
 #include <KConfig>
 #include <KConfigGroup>
-#include <QUrl>
-#include <KStringHandler>
 #include <QStandardPaths>
 
 K_EXPORT_PLASMA_RUNNER(kdevelopsessions, KDevelopSessions)
 
 bool kdevelopsessions_runner_compare_sessions(const Session &s1, const Session &s2)
 {
     QCollator c;
     return c.compare(s1.name, s2.name) < 0;
 }
 
 KDevelopSessions::KDevelopSessions(QObject *parent, const QVariantList& args)
     : Plasma::AbstractRunner(parent, args)
 {
     setObjectName(QStringLiteral("KDevelop Sessions"));
     setIgnoredTypes(Plasma::RunnerContext::File | Plasma::RunnerContext::Directory | Plasma::RunnerContext::NetworkLocation);
     m_icon = QIcon::fromTheme(QStringLiteral("kdevelop"));
 
     loadSessions();
 
     // listen for changes to the list of kdevelop sessions
     KDirWatch *historyWatch = new KDirWatch(this);
     const QStringList sessiondirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation,
                                                               QStringLiteral("kdevelop/sessions"));
     foreach (const QString &dir, sessiondirs) {
         historyWatch->addDir(dir);
     }
     connect(historyWatch, &KDirWatch::dirty, this, &KDevelopSessions::loadSessions);
     connect(historyWatch, &KDirWatch::created, this, &KDevelopSessions::loadSessions);
     connect(historyWatch, &KDirWatch::deleted, this, &KDevelopSessions::loadSessions);
 
     Plasma::RunnerSyntax s(QStringLiteral(":q:"), i18n("Finds KDevelop sessions matching :q:."));
     s.addExampleQuery(QStringLiteral("kdevelop :q:"));
     addSyntax(s);
 
     setDefaultSyntax(Plasma::RunnerSyntax(QStringLiteral("kdevelop"), i18n("Lists all the KDevelop editor sessions in your account.")));
 }
 
 KDevelopSessions::~KDevelopSessions() = default;
 
 QStringList findSessions()
 {
     QStringList sessionDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation,
                                                         QStringLiteral("kdevelop/sessions"),
                                                         QStandardPaths::LocateDirectory);
     QStringList sessionrcs;
     Q_FOREACH(const QString& dir, sessionDirs) {
         QDir d(dir);
         Q_FOREACH(const QString& sessionDir, d.entryList(QDir::Dirs)) {
             QDir sd(d.absoluteFilePath(sessionDir));
             QString path(sd.filePath(QStringLiteral("sessionrc")));
             if(QFile::exists(path)) {
                 sessionrcs += path;
             }
         }
     }
     return sessionrcs;
 }
 
 void KDevelopSessions::loadSessions()
 {
     m_sessions.clear();
     // Switch kdevelop session: -u
     // Should we add a match for this option or would that clutter the matches too much?
     const QStringList list = findSessions();
     foreach (const QString &sessionfile, list)
     {
         Session session;
         session.id = sessionfile.section('/', -2, -2);
         KConfig cfg(sessionfile, KConfig::SimpleConfig);
         KConfigGroup group = cfg.group(QString());
         session.name = group.readEntry("SessionPrettyContents");;
         m_sessions << session;
     }
     std::sort(m_sessions.begin(), m_sessions.end(), kdevelopsessions_runner_compare_sessions);
 }
 
 void KDevelopSessions::match(Plasma::RunnerContext &context)
 {
     if (m_sessions.isEmpty()) {
         return;
     }
 
     QString term = context.query();
     if (term.length() < 3) {
         return;
     }
 
     bool listAll = false;
 
     if (term.startsWith(QStringLiteral("kdevelop"), Qt::CaseInsensitive)) {
         if (term.trimmed().compare(QStringLiteral("kdevelop"), Qt::CaseInsensitive) == 0) {
             listAll = true;
             term.clear();
         } else if (term.at(8) == QLatin1Char(' ') ) {
             term.remove(QStringLiteral("kdevelop"), Qt::CaseInsensitive);
             term = term.trimmed();
         } else {
             term.clear();
         }
     }
 
     if (term.isEmpty() && !listAll) {
         return;
     }
 
     foreach (const Session &session, m_sessions) {
         if (!context.isValid()) {
             return;
         }
 
         if (listAll || (!term.isEmpty() && session.name.contains(term, Qt::CaseInsensitive))) {
             Plasma::QueryMatch match(this);
             if (listAll) {
                 // All sessions listed, but with a low priority
                 match.setType(Plasma::QueryMatch::ExactMatch);
                 match.setRelevance(0.8);
             } else {
                 if (session.name.compare(term, Qt::CaseInsensitive) == 0) {
                     // parameter to kdevelop matches session exactly, bump it up!
                     match.setType(Plasma::QueryMatch::ExactMatch);
                     match.setRelevance(1.0);
                 } else {
                     // fuzzy match of the session in "kdevelop $session"
                     match.setType(Plasma::QueryMatch::PossibleMatch);
                     match.setRelevance(0.8);
                 }
             }
             match.setIcon(m_icon);
             match.setData(session.id);
             match.setText(session.name);
             match.setSubtext(i18n("Open KDevelop Session"));
             context.addMatch(match);
         }
     }
 }
 
 void KDevelopSessions::run(const Plasma::RunnerContext &context, const Plasma::QueryMatch &match)
 {
     Q_UNUSED(context)
     QString sessionId = match.data().toString();
     if (sessionId.isEmpty()) {
         qWarning() << "No KDevelop session id in match!";
         return;
     }
     qDebug() << "Open KDevelop session" << sessionId;
     const QStringList args = {QStringLiteral("--open-session"), sessionId};
     KToolInvocation::kdeinitExec(QStringLiteral("kdevelop"), args);
 }
 
 #include "kdevelopsessions.moc"
diff --git a/debuggers/common/dialogs/processselection.cpp b/debuggers/common/dialogs/processselection.cpp
index 57200f4736..0c4dbbbd4f 100644
--- a/debuggers/common/dialogs/processselection.cpp
+++ b/debuggers/common/dialogs/processselection.cpp
@@ -1,100 +1,98 @@
 /* KDevelop GDB Support
  *
  * Copyright 2009 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 "processselection.h"
 
 #include <processui/ksysguardprocesslist.h>
 #include <processcore/process.h>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include <QAbstractItemView>
 #include <QDialogButtonBox>
-#include <QLabel>
 #include <QLineEdit>
 #include <QPushButton>
-#include <QTimer>
 #include <QTreeView>
 #include <QVBoxLayout>
 
 
 using namespace KDevMI;
 
 ProcessSelectionDialog::ProcessSelectionDialog(QWidget *parent)
     : QDialog(parent)
 {
     setWindowTitle(i18n("Attach to a Process"));
     m_processList = new KSysGuardProcessList(this);
     QVBoxLayout* mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
     mainLayout->addWidget(m_processList);
     QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     mainLayout->addWidget(buttonBox);
 
     connect(m_processList->treeView()->selectionModel(), &QItemSelectionModel::selectionChanged,
              this, &ProcessSelectionDialog::selectionChanged);
     m_processList->treeView()->setSelectionMode(QAbstractItemView::SingleSelection);
     m_processList->setState(ProcessFilter::UserProcesses);
     m_processList->setKillButtonVisible(false);
     m_processList->filterLineEdit()->setFocus();
     //m_processList->setPidFilter(qApp->pid());
 
     connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
     m_attachButton = buttonBox->button(QDialogButtonBox::Ok);
     m_attachButton->setDefault(true);
     m_attachButton->setText(i18n("Attach"));
     m_attachButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     m_attachButton->setEnabled(false);
 
     KConfigGroup config = KSharedConfig::openConfig()->group("GdbProcessSelectionDialog");
     m_processList->filterLineEdit()->setText(config.readEntry("filterText", QString()));
     m_processList->loadSettings(config);
     restoreGeometry(config.readEntry("dialogGeometry", QByteArray()));
 }
 
 ProcessSelectionDialog::~ProcessSelectionDialog()
 {
     KConfigGroup config = KSharedConfig::openConfig()->group("GdbProcessSelectionDialog");
     config.writeEntry("filterText", m_processList->filterLineEdit()->text());
     m_processList->saveSettings(config);
     config.writeEntry("dialogGeometry", saveGeometry());
 }
 
 long int ProcessSelectionDialog::pidSelected()
 {
     QList<KSysGuard::Process*> ps=m_processList->selectedProcesses();
     Q_ASSERT(ps.count()==1);
 
     KSysGuard::Process* process=ps.first();
 
     return process->pid();
 }
 
 QSize ProcessSelectionDialog::sizeHint() const
 {
     return QSize(740, 720);
 }
 
 void ProcessSelectionDialog::selectionChanged(const QItemSelection &selected)
 {
     m_attachButton->setEnabled(selected.count());
 }
diff --git a/debuggers/common/mi/milexer.h b/debuggers/common/mi/milexer.h
index 08268ad17d..c647b11132 100644
--- a/debuggers/common/mi/milexer.h
+++ b/debuggers/common/mi/milexer.h
@@ -1,151 +1,149 @@
 /***************************************************************************
  *   Copyright (C) 2004 by Roberto Raggi                                   *
  *   roberto@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.,                                       *
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 #ifndef MILEXER_H
 #define MILEXER_H
 
-#include <QMap>
-#include <QString>
 #include <QVector>
 
 namespace KDevMI { namespace MI {
 
 class MILexer;
 struct TokenStream;
 
 typedef void (MILexer::*scan_fun_ptr)(int *kind);
 
 struct Token
 {
     int kind;
     int position;
     int length;
 };
 
 struct FileSymbol
 {
     QByteArray contents;
     TokenStream *tokenStream;
 
     inline FileSymbol()
         : tokenStream(nullptr) {}
 
     inline ~FileSymbol();
 };
 
 struct TokenStream
 {
     inline int lookAhead(int n = 0) const
     { return (m_currentToken + n)->kind; }
 
     inline int currentToken() const
     { return m_currentToken->kind; }
 
     inline QByteArray currentTokenText() const
     { return tokenText(-1); }
 
     QByteArray tokenText(int index = 0) const;
 
     inline int lineOffset(int line) const
     { return m_lines.at(line); }
 
     void positionAt(int position, int *line, int *column) const;
 
     inline void getTokenStartPosition(int index, int *line, int *column) const
     { positionAt((m_firstToken + index)->position, line, column); }
 
     inline void getTokenEndPosition(int index, int *line, int *column) const
     {
         Token *tk = m_firstToken + index;
         positionAt(tk->position + tk->length, line, column);
     }
 
     inline void rewind(int index)
     { m_currentToken = m_firstToken + index; }
 
     inline int cursor() const
     { return m_currentToken - m_firstToken; }
 
     inline void nextToken()
     { m_currentToken++; m_cursor++; }
 
 //private:
     QByteArray m_contents;
 
     QVector<int> m_lines;
     int m_line;
 
     QVector<Token> m_tokens;
     int m_tokensCount;
 
     Token *m_firstToken;
     Token *m_currentToken;
 
     int m_cursor;
 };
 
 class MILexer
 {
 public:
     MILexer();
     ~MILexer();
 
     TokenStream *tokenize(const FileSymbol *fileSymbol);
 
 private:
     int nextToken(int &position, int &len);
 
     void scanChar(int *kind);
     void scanUnicodeChar(int *kind);
     void scanNewline(int *kind);
     void scanWhiteSpaces(int *kind);
     void scanStringLiteral(int *kind);
     void scanNumberLiteral(int *kind);
     void scanIdentifier(int *kind);
 
     void setupScanTable();
 
 private:
     static bool s_initialized;
     static scan_fun_ptr s_scan_table[128 + 1];
 
     QByteArray m_contents;
     int m_ptr;
     // Cached 'm_contents.length()'
     int m_length;
 
     QVector<int> m_lines;
     int m_line;
 
     QVector<Token> m_tokens;
     int m_tokensCount;
 
     int m_cursor;
 };
 
 inline FileSymbol::~FileSymbol()
 {
     delete tokenStream;
     tokenStream = nullptr;
 }
 
 } // end of MI
 } // end of KDevMI
 
 #endif
diff --git a/debuggers/common/mi/miparser.h b/debuggers/common/mi/miparser.h
index d9dbbf5140..8ffbf2040f 100644
--- a/debuggers/common/mi/miparser.h
+++ b/debuggers/common/mi/miparser.h
@@ -1,85 +1,85 @@
 /***************************************************************************
  *   Copyright (C) 2004 by Roberto Raggi                                   *
  *   roberto@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.,                                       *
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 #ifndef MIPARSER_H
 #define MIPARSER_H
 
 #include <memory>
 
 #include "mi.h"
 #include "milexer.h"
 
-#include <QString>
+class QString;
 
 namespace KDevMI { namespace MI {
 
 /**
 @author Roberto Raggi
 */
 class MIParser
 {
 public:
     MIParser();
     ~MIParser();
 
     std::unique_ptr<Record> parse(FileSymbol *file);
 
 protected: // rules
     std::unique_ptr<Record> parseResultOrAsyncRecord();
     std::unique_ptr<Record> parsePrompt();
     std::unique_ptr<Record> parseStreamRecord();
 
     bool parseResult(Result *&result);
     bool parseValue(Value *&value);
     bool parseTuple(Value *&value);
     bool parseList(Value *&value);
 
     /** Creates new TupleValue object, writes its address
         into *value, parses a comma-separated set of values,
         and adds each new value into (*value)->results.
         If 'start' and 'end' are not zero, they specify
         start and end delimiter of the list.
         Parsing stops when we see 'end' character, or, if
         'end' is zero, at the end of input.
     */
     bool parseCSV(TupleValue** value,
                   char start = 0, char end = 0);
 
     /** @overload
         Same as above, but writes into existing tuple.
     */
     bool parseCSV(TupleValue& value,
                   char start = 0, char end = 0);
 
     /** Parses a string literal and returns it. Advances
         the lexer past the literal. Processes C escape sequences
         in the string.
         @pre lex->lookAhead(0) == Token_string_literal
     */
     QString parseStringLiteral();
 
 private:
     MILexer m_lexer;
     TokenStream *m_lex;
 };
 
 } // end of namespace MI
 } // end of namespace KDevMI
 
 #endif
diff --git a/debuggers/common/mibreakpointcontroller.h b/debuggers/common/mibreakpointcontroller.h
index a3b13a42af..161066e24b 100644
--- a/debuggers/common/mibreakpointcontroller.h
+++ b/debuggers/common/mibreakpointcontroller.h
@@ -1,122 +1,118 @@
 /* This file is part of the KDE project
    Copyright (C) 2002 Matthias Hoelzer-Kluepfel <hoelzer@kde.org>
    Copyright (C) 2002 John Firebaugh <jfirebaugh@kde.org>
    Copyright (C) 2007 Hamish Rodda <rodda@kde.org>
    Copyright (C) 2009 Niko Sams <niko.sams@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., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 #ifndef MIBREAKPOINTCONTROLLER_H
 #define MIBREAKPOINTCONTROLLER_H
 
 #include "dbgglobal.h"
 
 #include <debugger/interfaces/ibreakpointcontroller.h>
 #include <debugger/interfaces/idebugsession.h>
 
-#include <QObject>
-
-class QModelIndex;
-
 namespace KDevMI {
 
 namespace MI {
 struct AsyncRecord;
 struct ResultRecord;
 struct Value;
 }
 
 struct BreakpointData {
     int debuggerId;
     KDevelop::BreakpointModel::ColumnFlags dirty;
     KDevelop::BreakpointModel::ColumnFlags sent;
     KDevelop::BreakpointModel::ColumnFlags errors;
     bool pending;
 
     BreakpointData()
         : debuggerId(-1)
         , pending(false)
     {}
 };
 
 typedef QSharedPointer<BreakpointData> BreakpointDataPtr;
 
 class MIDebugSession;
 /**
 * Handles signals from the editor that relate to breakpoints and the execution
 * point of the debugger.
 * We may change, add or remove breakpoints in this class.
 */
 class MIBreakpointController : public KDevelop::IBreakpointController
 {
     Q_OBJECT
 public:
     explicit MIBreakpointController(MIDebugSession* parent);
 
     using IBreakpointController::breakpointModel;
 
     /**
      * Controls whether when duplicate breakpoints are received via async notification from GDB,
      * one of the duplicates will be deleted.
      */
     void setDeleteDuplicateBreakpoints(bool enable);
 
     void breakpointAdded(int row) override;
     void breakpointModelChanged(int row, KDevelop::BreakpointModel::ColumnFlags columns) override;
     void breakpointAboutToBeDeleted(int row) override;
     void debuggerStateChanged(KDevelop::IDebugSession::DebuggerState) override;
 
     void notifyBreakpointCreated(const MI::AsyncRecord& r);
     void notifyBreakpointModified(const MI::AsyncRecord& r);
     void notifyBreakpointDeleted(const MI::AsyncRecord& r);
 
 public Q_SLOTS:
     void initSendBreakpoints();
 
 private Q_SLOTS:
     void programStopped(const MI::AsyncRecord &r);
 
 private:
     MIDebugSession* debugSession() const;
 
     int breakpointRow(const BreakpointDataPtr& breakpoint);
     void createBreakpoint(int row);
     void sendUpdates(int row);
     void recalculateState(int row);
 
     void sendMaybe(KDevelop::Breakpoint *breakpoint) override;
 
     void createFromDebugger(const MI::Value& miBkpt);
     void updateFromDebugger(int row, const MI::Value& miBkpt,
                        KDevelop::BreakpointModel::ColumnFlags lockedColumns = nullptr);
 
     int rowFromDebuggerId(int gdbId) const;
 
     struct Handler;
     struct InsertedHandler;
     struct UpdateHandler;
     struct DeleteHandler;
     struct IgnoreChanges;
 
     QList<BreakpointDataPtr> m_breakpoints;
     QList<BreakpointDataPtr> m_pendingDeleted;
     int m_ignoreChanges = 0;
     bool m_deleteDuplicateBreakpoints = false;
 };
 
 } // end of namespace KDevMI
 
 #endif // MIBREAKPOINTCONTROLLER_H
diff --git a/debuggers/common/midebugjobs.cpp b/debuggers/common/midebugjobs.cpp
index 5eb77fe95d..673929624a 100644
--- a/debuggers/common/midebugjobs.cpp
+++ b/debuggers/common/midebugjobs.cpp
@@ -1,218 +1,217 @@
 /*
 * Common Code for Debugger Support
 *
 * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
 * Copyright 2007 Hamish Rodda <rodda@kde.org>
 * Copyright 2009 Andreas Pakulat <apaku@gmx.de>
 * Copyright 2016  Aetf <aetf@unlimitedcodeworks.xyz>
 *
 * 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 "midebugjobs.h"
 
 #include "debuglog.h"
 #include "dialogs/selectcoredialog.h"
 #include "midebugsession.h"
 #include "midebuggerplugin.h"
 
 #include <execute/iexecuteplugin.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/ilaunchconfiguration.h>
 #include <interfaces/iuicontroller.h>
 #include <outputview/outputmodel.h>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KParts/MainWindow>
 
 #include <QFileInfo>
-#include <QRegularExpression>
 
 using namespace KDevMI;
 using namespace KDevelop;
 
 MIDebugJob::MIDebugJob(MIDebuggerPlugin* p, ILaunchConfiguration* launchcfg,
                    IExecutePlugin* execute, QObject* parent)
     : KDevelop::OutputJob(parent)
     , m_launchcfg(launchcfg)
     , m_execute(execute)
 {
     setCapabilities(Killable);
 
     m_session = p->createSession();
     connect(m_session, &MIDebugSession::inferiorStdoutLines, this, &MIDebugJob::stdoutReceived);
     connect(m_session, &MIDebugSession::inferiorStderrLines, this, &MIDebugJob::stderrReceived);
 
     connect(m_session, &MIDebugSession::finished, this, &MIDebugJob::done);
 
     if (launchcfg->project()) {
         setObjectName(i18nc("ProjectName: run configuration name", "%1: %2",
                             launchcfg->project()->name(), launchcfg->name()));
     } else {
         setObjectName(launchcfg->name());
     }
 }
 
 void MIDebugJob::start()
 {
     Q_ASSERT(m_execute);
 
     QString err;
 
     // check if the config is valid
     QString executable = m_execute->executable(m_launchcfg, err).toLocalFile();
     if (!err.isEmpty()) {
         setError(-1);
         setErrorText(err);
         emitResult();
         return;
     }
 
     if (!QFileInfo(executable).isExecutable()) {
         setError(-1);
         setErrorText(i18n("'%1' is not an executable", executable));
         emitResult();
         return;
     }
 
     QStringList arguments = m_execute->arguments(m_launchcfg, err);
     if (!err.isEmpty()) {
         setError(-1);
         setErrorText(err);
         emitResult();
         return;
     }
 
     setStandardToolView(IOutputView::DebugView);
     setBehaviours(IOutputView::Behaviours(IOutputView::AllowUserClose) | KDevelop::IOutputView::AutoScroll);
 
     auto model = new KDevelop::OutputModel;
     model->setFilteringStrategy(OutputModel::NativeAppErrorFilter);
     setModel(model);
     setTitle(m_launchcfg->name());
 
     KConfigGroup grp = m_launchcfg->config();
     QString startWith = grp.readEntry(Config::StartWithEntry, QString("ApplicationOutput"));
     if (startWith == "ApplicationOutput") {
         setVerbosity(Verbose);
     } else {
         setVerbosity(Silent);
     }
 
     startOutput();
 
     if (!m_session->startDebugging(m_launchcfg, m_execute)) {
         done();
     }
 }
 
 bool MIDebugJob::doKill()
 {
     m_session->stopDebugger();
     return true;
 }
 
 void MIDebugJob::stderrReceived(const QStringList& l)
 {
     if (OutputModel* m = model()) {
         m->appendLines(l);
     }
 }
 
 void MIDebugJob::stdoutReceived(const QStringList& l)
 {
     if (OutputModel* m = model()) {
         m->appendLines(l);
     }
 }
 
 OutputModel* MIDebugJob::model()
 {
     return qobject_cast<OutputModel*>(OutputJob::model());
 }
 
 void MIDebugJob::done()
 {
     emitResult();
 }
 
 MIExamineCoreJob::MIExamineCoreJob(MIDebuggerPlugin *plugin, QObject *parent)
     : KJob(parent)
 {
     setCapabilities(Killable);
 
     m_session = plugin->createSession();
     connect(m_session, &MIDebugSession::finished, this, &MIExamineCoreJob::done);
 
     setObjectName(i18n("Debug core file"));
 }
 
 void MIExamineCoreJob::start()
 {
     SelectCoreDialog dlg(ICore::self()->uiController()->activeMainWindow());
     if (dlg.exec() == QDialog::Rejected) {
         done();
         return;
     }
 
     if (!m_session->examineCoreFile(dlg.executableFile(), dlg.core())) {
         done();
     }
 }
 
 bool MIExamineCoreJob::doKill()
 {
     m_session->stopDebugger();
     return true;
 }
 
 void MIExamineCoreJob::done()
 {
     emitResult();
 }
 
 MIAttachProcessJob::MIAttachProcessJob(MIDebuggerPlugin *plugin, int pid, QObject *parent)
     : KJob(parent)
     , m_pid(pid)
 {
     setCapabilities(Killable);
 
     m_session = plugin->createSession();
     connect(m_session, &MIDebugSession::finished, this, &MIAttachProcessJob::done);
 
     setObjectName(i18n("Debug process %1", pid));
 }
 
 void MIAttachProcessJob::start()
 {
     if (!m_session->attachToProcess(m_pid)) {
         done();
     }
 }
 
 bool MIAttachProcessJob::doKill()
 {
     m_session->stopDebugger();
     return true;
 }
 
 void MIAttachProcessJob::done()
 {
     emitResult();
 }
diff --git a/debuggers/common/midebugsession.cpp b/debuggers/common/midebugsession.cpp
index 89c53ec4bb..910ecb05d1 100644
--- a/debuggers/common/midebugsession.cpp
+++ b/debuggers/common/midebugsession.cpp
@@ -1,1316 +1,1317 @@
 /*
  * Common code for debugger support
  *
  * Copyright 1999-2001 John Birch <jbb@kdevelop.org>
  * Copyright 2001 by Bernd Gehrmann <bernd@kdevelop.org>
  * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2009 Niko Sams <niko.sams@gmail.com>
  * Copyright 2016  Aetf <aetf@unlimitedcodeworks.xyz>
  *
  * 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 "midebugsession.h"
 
 #include "debuglog.h"
 #include "midebugger.h"
 #include "mivariable.h"
 #include "mi/mi.h"
 #include "mi/micommand.h"
 #include "mi/micommandqueue.h"
 #include "stty.h"
 
 #include <debugger/breakpoint/breakpointmodel.h>
 #include <debugger/interfaces/ivariablecontroller.h>
 #include <debugger/interfaces/iframestackmodel.h>
 #include <execute/iexecuteplugin.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocument.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/ilaunchconfiguration.h>
 #include <util/processlinemaker.h>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <KShell>
 
 #include <QApplication>
 #include <QFileInfo>
 #include <QMetaEnum>
 #include <QPointer>
 #include <QRegularExpression>
 #include <QUrl>
+#include <QTimer>
 
 using namespace KDevelop;
 using namespace KDevMI;
 using namespace KDevMI::MI;
 
 MIDebugSession::MIDebugSession(MIDebuggerPlugin *plugin)
     : m_procLineMaker(new ProcessLineMaker(this))
     , m_commandQueue(new CommandQueue)
     , m_sessionState(NotStartedState)
     , m_debugger(nullptr)
     , m_debuggerState(s_dbgNotStarted | s_appNotStarted)
     , m_stateReloadInProgress(false)
     , m_stateReloadNeeded(false)
     , m_tty(nullptr)
     , m_hasCrashed(false)
     , m_sourceInitFile(true)
     , m_plugin(plugin)
 {
     // setup signals
     connect(m_procLineMaker, &ProcessLineMaker::receivedStdoutLines,
             this, &MIDebugSession::inferiorStdoutLines);
     connect(m_procLineMaker, &ProcessLineMaker::receivedStderrLines,
             this, &MIDebugSession::inferiorStderrLines);
 
     // forward tty output to process line maker
     connect(this, &MIDebugSession::inferiorTtyStdout,
             m_procLineMaker, &ProcessLineMaker::slotReceivedStdout);
     connect(this, &MIDebugSession::inferiorTtyStderr,
             m_procLineMaker, &ProcessLineMaker::slotReceivedStderr);
 
     // FIXME: see if this still works
     //connect(statusBarIndicator, SIGNAL(doubleClicked()),
     //        controller, SLOT(explainDebuggerStatus()));
 
     // FIXME: reimplement / re-enable
     //connect(this, SIGNAL(addWatchVariable(QString)), controller->variables(), SLOT(slotAddWatchVariable(QString)));
     //connect(this, SIGNAL(evaluateExpression(QString)), controller->variables(), SLOT(slotEvaluateExpression(QString)));
 }
 
 MIDebugSession::~MIDebugSession()
 {
     qCDebug(DEBUGGERCOMMON) << "Destroying MIDebugSession";
     // Deleting the session involves shutting down gdb nicely.
     // When were attached to a process, we must first detach so that the process
     // can continue running as it was before being attached. gdb is quite slow to
     // detach from a process, so we must process events within here to get a "clean"
     // shutdown.
     if (!debuggerStateIsOn(s_dbgNotStarted)) {
         stopDebugger();
     }
 }
 
 IDebugSession::DebuggerState MIDebugSession::state() const
 {
     return m_sessionState;
 }
 
 QMap<QString, MIVariable*> & MIDebugSession::variableMapping()
 {
     return m_allVariables;
 }
 
 MIVariable* MIDebugSession::findVariableByVarobjName(const QString &varobjName) const
 {
     if (m_allVariables.count(varobjName) == 0)
         return nullptr;
     return m_allVariables.value(varobjName);
 }
 
 void MIDebugSession::markAllVariableDead()
 {
     for (auto i = m_allVariables.begin(), e = m_allVariables.end(); i != e; ++i)
     {
         i.value()->markAsDead();
     }
     m_allVariables.clear();
 }
 
 bool MIDebugSession::restartAvaliable() const
 {
     if (debuggerStateIsOn(s_attached) || debuggerStateIsOn(s_core)) {
         return false;
     } else {
         return true;
     }
 }
 
 bool MIDebugSession::startDebugger(ILaunchConfiguration *cfg)
 {
     qCDebug(DEBUGGERCOMMON) << "Starting new debugger instance";
     if (m_debugger) {
         qCWarning(DEBUGGERCOMMON) << "m_debugger object still exists";
         delete m_debugger;
         m_debugger = nullptr;
     }
     m_debugger = createDebugger();
     m_debugger->setParent(this);
 
     // output signals
     connect(m_debugger, &MIDebugger::applicationOutput,
             this, [this](const QString &output) {
                 auto lines = output.split(QRegularExpression("[\r\n]"), QString::SkipEmptyParts);
                 for (auto &line : lines) {
                     int p = line.length();
                     while (p >= 1 && (line[p-1] == '\r' || line[p-1] == '\n'))
                         p--;
                     if (p != line.length())
                         line.remove(p, line.length() - p);
                 }
                 emit inferiorStdoutLines(lines);
             });
     connect(m_debugger, &MIDebugger::userCommandOutput, this, &MIDebugSession::debuggerUserCommandOutput);
     connect(m_debugger, &MIDebugger::internalCommandOutput, this, &MIDebugSession::debuggerInternalCommandOutput);
     connect(m_debugger, &MIDebugger::debuggerInternalOutput, this, &MIDebugSession::debuggerInternalOutput);
 
     // state signals
     connect(m_debugger, &MIDebugger::programStopped, this, &MIDebugSession::inferiorStopped);
     connect(m_debugger, &MIDebugger::programRunning, this, &MIDebugSession::inferiorRunning);
 
     // internal handlers
     connect(m_debugger, &MIDebugger::ready, this, &MIDebugSession::slotDebuggerReady);
     connect(m_debugger, &MIDebugger::exited, this, &MIDebugSession::slotDebuggerExited);
     connect(m_debugger, &MIDebugger::programStopped, this, &MIDebugSession::slotInferiorStopped);
     connect(m_debugger, &MIDebugger::programRunning, this, &MIDebugSession::slotInferiorRunning);
     connect(m_debugger, &MIDebugger::notification, this, &MIDebugSession::processNotification);
 
 
     // start the debugger. Do this after connecting all signals so that initial
     // debugger output, and important events like the debugger died are reported.
     QStringList extraArguments;
     if (!m_sourceInitFile)
         extraArguments << "--nx";
 
     auto config = cfg ? cfg->config()
                 // FIXME: this is only used when attachToProcess or examineCoreFile.
                 // Change to use a global launch configuration when calling
                 : KConfigGroup(KSharedConfig::openConfig(), "GDB Config");
 
     if (!m_debugger->start(config, extraArguments)) {
         // debugger failed to start, ensure debugger and session state are correctly updated.
         setDebuggerStateOn(s_dbgFailedStart);
         return false;
     }
 
     // FIXME: here, we should wait until the debugger is up and waiting for input.
     // Then, clear s_dbgNotStarted
     // It's better to do this right away so that the state bit is always correct.
     setDebuggerStateOff(s_dbgNotStarted);
 
     // Initialise debugger. At this stage debugger is sitting wondering what to do,
     // and to whom.
     initializeDebugger();
 
     qCDebug(DEBUGGERCOMMON) << "Debugger instance started";
     return true;
 }
 
 bool MIDebugSession::startDebugging(ILaunchConfiguration* cfg, IExecutePlugin* iexec)
 {
     qCDebug(DEBUGGERCOMMON) << "Starting new debug session";
     Q_ASSERT(cfg);
     Q_ASSERT(iexec);
 
     // Ensure debugger is started first
     if (debuggerStateIsOn(s_appNotStarted)) {
         emit showMessage(i18n("Running program"), 1000);
     }
 
     if (debuggerStateIsOn(s_dbgNotStarted)) {
         if (!startDebugger(cfg))
             return false;
     }
 
     if (debuggerStateIsOn(s_shuttingDown)) {
         qCDebug(DEBUGGERCOMMON) << "Tried to run when debugger shutting down";
         return false;
     }
 
     // Only dummy err here, actual erros have been checked already in the job and we don't get here if there were any
     QString err;
     QString executable = iexec->executable(cfg, err).toLocalFile();
     configInferior(cfg, iexec, executable);
 
     // Set up the tty for the inferior
     bool config_useExternalTerminal = iexec->useTerminal(cfg);
     QString config_ternimalName = iexec->terminal(cfg);
     if (!config_ternimalName.isEmpty()) {
         // the external terminal cmd contains additional arguments, just get the terminal name
         config_ternimalName = KShell::splitArgs(config_ternimalName).first();
     }
 
     m_tty.reset(new STTY(config_useExternalTerminal, config_ternimalName));
     if (!config_useExternalTerminal) {
         connect(m_tty.get(), &STTY::OutOutput, this, &MIDebugSession::inferiorTtyStdout);
         connect(m_tty.get(), &STTY::ErrOutput, this, &MIDebugSession::inferiorTtyStderr);
     }
     QString tty(m_tty->getSlave());
     if (tty.isEmpty()) {
         KMessageBox::information(qApp->activeWindow(), m_tty->lastError(), i18n("warning"));
 
         m_tty.reset(nullptr);
         return false;
     }
     addCommand(InferiorTtySet, tty);
 
     // Change the working directory to the correct one
     QString dir = iexec->workingDirectory(cfg).toLocalFile();
     if (dir.isEmpty()) {
         dir = QFileInfo(executable).absolutePath();
     }
     addCommand(EnvironmentCd, '"' + dir + '"');
 
     // Set the run arguments
     QStringList arguments = iexec->arguments(cfg, err);
     if (!arguments.isEmpty())
         addCommand(ExecArguments, KShell::joinArgs(arguments));
 
     // Do other debugger specific config options and actually start the inferior program
     if (!execInferior(cfg, iexec, executable)) {
         return false;
     }
 
     QString config_startWith = cfg->config().readEntry(Config::StartWithEntry, QStringLiteral("ApplicationOutput"));
     if (config_startWith == "GdbConsole") {
         emit raiseDebuggerConsoleViews();
     } else if (config_startWith == "FrameStack") {
         emit raiseFramestackViews();
     } else {
         // ApplicationOutput is raised in DebugJob (by setting job to Verbose/Silent)
     }
 
     return true;
 }
 
 // FIXME: use same configuration process as startDebugging
 bool MIDebugSession::attachToProcess(int pid)
 {
     qCDebug(DEBUGGERCOMMON) << "Attach to process" << pid;
 
     emit showMessage(i18n("Attaching to process %1", pid), 1000);
 
     if (debuggerStateIsOn(s_dbgNotStarted)) {
         // FIXME: use global launch configuration rather than nullptr
         if (!startDebugger(nullptr)) {
             return false;
         }
     }
 
     setDebuggerStateOn(s_attached);
 
     //set current state to running, after attaching we will get *stopped response
     setDebuggerStateOn(s_appRunning);
 
     addCommand(TargetAttach, QString::number(pid),
                this, &MIDebugSession::handleTargetAttach,
                CmdHandlesError);
 
     addCommand(new SentinelCommand(breakpointController(),
                                    &MIBreakpointController::initSendBreakpoints));
 
     raiseEvent(connected_to_program);
 
     emit raiseFramestackViews();
 
     return true;
 }
 
 void MIDebugSession::handleTargetAttach(const MI::ResultRecord& r)
 {
     if (r.reason == "error") {
         KMessageBox::error(
             qApp->activeWindow(),
             i18n("<b>Could not attach debugger:</b><br />")+
             r["msg"].literal(),
             i18n("Startup error"));
         stopDebugger();
     }
 }
 
 bool MIDebugSession::examineCoreFile(const QUrl &debugee, const QUrl &coreFile)
 {
     emit showMessage(i18n("Examining core file %1", coreFile.toLocalFile()), 1000);
 
     if (debuggerStateIsOn(s_dbgNotStarted)) {
         // FIXME: use global launch configuration rather than nullptr
         if (!startDebugger(nullptr)) {
             return false;
         }
     }
 
     // FIXME: support non-local URLs
     if (!loadCoreFile(nullptr, debugee.toLocalFile(), coreFile.toLocalFile())) {
         return false;
     }
 
     raiseEvent(program_state_changed);
 
     return true;
 }
 
 #define ENUM_NAME(o,e,v) (o::staticMetaObject.enumerator(o::staticMetaObject.indexOfEnumerator(#e)).valueToKey((v)))
 void MIDebugSession::setSessionState(DebuggerState state)
 {
     qCDebug(DEBUGGERCOMMON) << "Session state changed to"
                             << ENUM_NAME(IDebugSession, DebuggerState, state)
                             << "(" << state << ")";
     if (state != m_sessionState) {
         m_sessionState = state;
         emit stateChanged(state);
     }
 }
 
 bool MIDebugSession::debuggerStateIsOn(DBGStateFlags state) const
 {
     return m_debuggerState & state;
 }
 
 DBGStateFlags MIDebugSession::debuggerState() const
 {
     return m_debuggerState;
 }
 
 void MIDebugSession::setDebuggerStateOn(DBGStateFlags stateOn)
 {
     DBGStateFlags oldState = m_debuggerState;
 
     debuggerStateChange(m_debuggerState, m_debuggerState | stateOn);
     m_debuggerState |= stateOn;
 
     handleDebuggerStateChange(oldState, m_debuggerState);
 }
 
 void MIDebugSession::setDebuggerStateOff(DBGStateFlags stateOff)
 {
     DBGStateFlags oldState = m_debuggerState;
 
     debuggerStateChange(m_debuggerState, m_debuggerState & ~stateOff);
     m_debuggerState &= ~stateOff;
 
     handleDebuggerStateChange(oldState, m_debuggerState);
 }
 
 void MIDebugSession::setDebuggerState(DBGStateFlags newState)
 {
     DBGStateFlags oldState = m_debuggerState;
 
     debuggerStateChange(m_debuggerState, newState);
     m_debuggerState = newState;
 
     handleDebuggerStateChange(oldState, m_debuggerState);
 }
 
 void MIDebugSession::debuggerStateChange(DBGStateFlags oldState, DBGStateFlags newState)
 {
     int delta = oldState ^ newState;
     if (delta)
     {
         QString out;
 #define STATE_CHECK(name) \
     do { \
         if (delta & name) { \
             out += ((newState & name) ? " +" : " -"); \
             out += #name; \
             delta &= ~name; \
         } \
     } while (0)
         STATE_CHECK(s_dbgNotStarted);
         STATE_CHECK(s_appNotStarted);
         STATE_CHECK(s_programExited);
         STATE_CHECK(s_attached);
         STATE_CHECK(s_core);
         STATE_CHECK(s_shuttingDown);
         STATE_CHECK(s_dbgBusy);
         STATE_CHECK(s_appRunning);
         STATE_CHECK(s_dbgNotListening);
         STATE_CHECK(s_automaticContinue);
 #undef STATE_CHECK
 
         for (unsigned int i = 0; delta != 0 && i < 32; ++i) {
             if (delta & (1 << i))  {
                 delta &= ~(1 << i);
                 out += ((1 << i) & newState) ? " +" : " -";
                 out += QString::number(i);
             }
         }
         qCDebug(DEBUGGERCOMMON) << "Debugger state change:" << out;
     }
 }
 
 void MIDebugSession::handleDebuggerStateChange(DBGStateFlags oldState, DBGStateFlags newState)
 {
     QString message;
 
     DebuggerState oldSessionState = state();
     DebuggerState newSessionState = oldSessionState;
     DBGStateFlags changedState = oldState ^ newState;
 
     if (newState & s_dbgNotStarted) {
         if (changedState & s_dbgNotStarted) {
             message = i18n("Debugger stopped");
             emit finished();
         }
         if (oldSessionState != NotStartedState || newState & s_dbgFailedStart) {
             newSessionState = EndedState;
         }
     } else {
         if (newState & s_appNotStarted) {
             if (oldSessionState == NotStartedState || oldSessionState == StartingState) {
                 newSessionState = StartingState;
             } else {
                 newSessionState = StoppedState;
             }
         } else if (newState & s_programExited) {
             if (changedState & s_programExited) {
                 message = i18n("Process exited");
             }
             newSessionState = StoppedState;
         } else if (newState & s_appRunning) {
             if (changedState & s_appRunning) {
                 message = i18n("Application is running");
             }
             newSessionState = ActiveState;
         } else {
             if (changedState & s_appRunning) {
                 message = i18n("Application is paused");
             }
             newSessionState = PausedState;
         }
     }
 
     // And now? :-)
     qCDebug(DEBUGGERCOMMON) << "Debugger state changed to: " << newState << message;
 
     if (!message.isEmpty())
         emit showMessage(message, 3000);
 
     emit debuggerStateChanged(oldState, newState);
 
     // must be last, since it can lead to deletion of the DebugSession
     if (newSessionState != oldSessionState) {
         setSessionState(newSessionState);
     }
 }
 
 void MIDebugSession::restartDebugger()
 {
     // We implement restart as kill + slotRun, as opposed as plain "run"
     // command because kill + slotRun allows any special logic in slotRun
     // to apply for restart.
     //
     // That includes:
     // - checking for out-of-date project
     // - special setup for remote debugging.
     //
     // Had we used plain 'run' command, restart for remote debugging simply
     // would not work.
     if (!debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown)) {
         // FIXME: s_dbgBusy or m_debugger->isReady()?
         if (debuggerStateIsOn(s_dbgBusy)) {
             interruptDebugger();
         }
         // The -exec-abort is not implemented in gdb
         // addCommand(ExecAbort);
         addCommand(NonMI, "kill");
     }
     run();
 }
 
 void MIDebugSession::stopDebugger()
 {
     if (debuggerStateIsOn(s_dbgNotStarted)) {
         // we are force to stop even before debugger started, just reset
         qCDebug(DEBUGGERCOMMON) << "Stopping debugger when it's not started";
         return;
     }
 
     m_commandQueue->clear();
 
     qCDebug(DEBUGGERCOMMON) << "try stopping debugger";
     if (debuggerStateIsOn(s_shuttingDown) || !m_debugger)
         return;
 
     setDebuggerStateOn(s_shuttingDown);
     qCDebug(DEBUGGERCOMMON) << "stopping debugger";
 
     // Get debugger's attention if it's busy. We need debugger to be at the
     // command line so we can stop it.
     if (!m_debugger->isReady()) {
         qCDebug(DEBUGGERCOMMON) << "debugger busy on shutdown - interruping";
         interruptDebugger();
     }
 
     // If the app is attached then we release it here. This doesn't stop
     // the app running.
     if (debuggerStateIsOn(s_attached)) {
         addCommand(TargetDetach);
         emit debuggerUserCommandOutput("(gdb) detach\n");
     }
 
     // Now try to stop debugger running.
     addCommand(GdbExit);
     emit debuggerUserCommandOutput("(gdb) quit");
 
     // We cannot wait forever, kill gdb after 5 seconds if it's not yet quit
     QPointer<MIDebugSession> guarded_this(this);
     QTimer::singleShot(5000, [guarded_this](){
         if (guarded_this) {
             if (!guarded_this->debuggerStateIsOn(s_programExited)
                 && guarded_this->debuggerStateIsOn(s_shuttingDown)) {
                 qCDebug(DEBUGGERCOMMON) << "debugger not shutdown - killing";
                 guarded_this->m_debugger->kill();
                 guarded_this->setDebuggerState(s_dbgNotStarted | s_appNotStarted);
                 guarded_this->raiseEvent(debugger_exited);
             }
         }
     });
 
     emit reset();
 }
 
 void MIDebugSession::interruptDebugger()
 {
     Q_ASSERT(m_debugger);
 
     // Explicitly send the interrupt in case something went wrong with the usual
     // ensureGdbListening logic.
     m_debugger->interrupt();
     addCommand(ExecInterrupt, QString(), CmdInterrupt);
 }
 
 void MIDebugSession::run()
 {
     if (debuggerStateIsOn(s_appNotStarted|s_dbgNotStarted|s_shuttingDown))
         return;
 
     addCommand(MI::ExecContinue, QString(), CmdMaybeStartsRunning);
 }
 
 void MIDebugSession::runToCursor()
 {
     if (IDocument* doc = ICore::self()->documentController()->activeDocument()) {
         KTextEditor::Cursor cursor = doc->cursorPosition();
         if (cursor.isValid())
             runUntil(doc->url(), cursor.line() + 1);
     }
 }
 
 void MIDebugSession::jumpToCursor()
 {
     if (IDocument* doc = ICore::self()->documentController()->activeDocument()) {
         KTextEditor::Cursor cursor = doc->cursorPosition();
         if (cursor.isValid())
             jumpTo(doc->url(), cursor.line() + 1);
     }
 }
 
 void MIDebugSession::stepOver()
 {
     if (debuggerStateIsOn(s_appNotStarted|s_shuttingDown))
         return;
 
     addCommand(ExecNext, QString(), CmdMaybeStartsRunning | CmdTemporaryRun);
 }
 
 void MIDebugSession::stepIntoInstruction()
 {
     if (debuggerStateIsOn(s_appNotStarted|s_shuttingDown))
         return;
 
     addCommand(ExecStepInstruction, QString(),
                CmdMaybeStartsRunning | CmdTemporaryRun);
 }
 
 void MIDebugSession::stepInto()
 {
     if (debuggerStateIsOn(s_appNotStarted|s_shuttingDown))
         return;
 
     addCommand(ExecStep, QString(), CmdMaybeStartsRunning | CmdTemporaryRun);
 }
 
 void MIDebugSession::stepOverInstruction()
 {
     if (debuggerStateIsOn(s_appNotStarted|s_shuttingDown))
         return;
 
     addCommand(ExecNextInstruction, QString(),
                CmdMaybeStartsRunning | CmdTemporaryRun);
 }
 
 void MIDebugSession::stepOut()
 {
     if (debuggerStateIsOn(s_appNotStarted|s_shuttingDown))
         return;
 
     addCommand(ExecFinish, QString(), CmdMaybeStartsRunning | CmdTemporaryRun);
 }
 
 void MIDebugSession::runUntil(const QUrl& url, int line)
 {
     if (debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown))
         return;
 
     if (!url.isValid()) {
         addCommand(ExecUntil, QString::number(line),
                    CmdMaybeStartsRunning | CmdTemporaryRun);
     } else {
         addCommand(ExecUntil,
                    QString("%1:%2").arg(url.toLocalFile()).arg(line),
                    CmdMaybeStartsRunning | CmdTemporaryRun);
     }
 }
 
 void MIDebugSession::runUntil(const QString& address)
 {
     if (debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown))
         return;
 
     if (!address.isEmpty()) {
         addCommand(ExecUntil, QString("*%1").arg(address),
                    CmdMaybeStartsRunning | CmdTemporaryRun);
     }
 }
 
 void MIDebugSession::jumpTo(const QUrl& url, int line)
 {
     if (debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown))
         return;
 
     if (url.isValid()) {
         addCommand(NonMI, QString("tbreak %1:%2").arg(url.toLocalFile()).arg(line));
         addCommand(NonMI, QString("jump %1:%2").arg(url.toLocalFile()).arg(line));
     }
 }
 
 void MIDebugSession::jumpToMemoryAddress(const QString& address)
 {
     if (debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown))
         return;
 
     if (!address.isEmpty()) {
         addCommand(NonMI, QString("tbreak *%1").arg(address));
         addCommand(NonMI, QString("jump *%1").arg(address));
     }
 }
 
 void MIDebugSession::addUserCommand(const QString& cmd)
 {
     auto usercmd = createUserCommand(cmd);
     if (!usercmd)
         return;
 
     queueCmd(usercmd);
     // User command can theoreticall modify absolutely everything,
     // so need to force a reload.
 
     // We can do it right now, and don't wait for user command to finish
     // since commands used to reload all view will be executed after
     // user command anyway.
     if (!debuggerStateIsOn(s_appNotStarted) && !debuggerStateIsOn(s_programExited))
         raiseEvent(program_state_changed);
 }
 
 MICommand *MIDebugSession::createUserCommand(const QString &cmd) const
 {
     MICommand *res = nullptr;
     if (!cmd.isEmpty() && cmd[0].isDigit()) {
         // Add a space to the beginning, so debugger won't get confused if the
         // command starts with a number (won't mix it up with command token added)
         res = new UserCommand(MI::NonMI, " " + cmd);
     } else {
         res = new UserCommand(MI::NonMI, cmd);
     }
     return res;
 }
 
 MICommand *MIDebugSession::createCommand(CommandType type, const QString& arguments,
                                          CommandFlags flags) const
 {
     return new MICommand(type, arguments, flags);
 }
 
 void MIDebugSession::addCommand(MICommand* cmd)
 {
     queueCmd(cmd);
 }
 
 void MIDebugSession::addCommand(MI::CommandType type, const QString& arguments, MI::CommandFlags flags)
 {
     queueCmd(createCommand(type, arguments, flags));
 }
 
 void MIDebugSession::addCommand(MI::CommandType type, const QString& arguments,
                 MI::MICommandHandler *handler,
                 MI::CommandFlags flags)
 {
     auto cmd = createCommand(type, arguments, flags);
     cmd->setHandler(handler);
     queueCmd(cmd);
 }
 
 void MIDebugSession::addCommand(MI::CommandType type, const QString& arguments,
                 const MI::FunctionCommandHandler::Function& callback,
                 MI::CommandFlags flags)
 {
     auto cmd = createCommand(type, arguments, flags);
     cmd->setHandler(callback);
     queueCmd(cmd);
 }
 
 // Fairly obvious that we'll add whatever command you give me to a queue
 // Not quite so obvious though is that if we are going to run again. then any
 // information requests become redundent and must be removed.
 // We also try and run whatever command happens to be at the head of
 // the queue.
 void MIDebugSession::queueCmd(MICommand *cmd)
 {
     if (debuggerStateIsOn(s_dbgNotStarted)) {
         KMessageBox::information(
             qApp->activeWindow(),
             i18n("<b>Gdb command sent when debugger is not running</b><br>"
                  "The command was:<br> %1", cmd->initialString()),
             i18n("Internal error"));
         return;
     }
 
     if (m_stateReloadInProgress)
         cmd->setStateReloading(true);
 
     m_commandQueue->enqueue(cmd);
 
     qCDebug(DEBUGGERCOMMON) << "QUEUE: " << cmd->initialString()
                             << (m_stateReloadInProgress ? "(state reloading)" : "")
                             << m_commandQueue->count() << "pending";
 
     bool varCommandWithContext= (cmd->type() >= MI::VarAssign
                                  && cmd->type() <= MI::VarUpdate
                                  && cmd->type() != MI::VarDelete);
 
     bool stackCommandWithContext = (cmd->type() >= MI::StackInfoDepth
                                     && cmd->type() <= MI::StackListLocals);
 
     if (varCommandWithContext || stackCommandWithContext) {
         if (cmd->thread() == -1)
             qCDebug(DEBUGGERCOMMON) << "\t--thread will be added on execution";
 
         if (cmd->frame() == -1)
             qCDebug(DEBUGGERCOMMON) << "\t--frame will be added on execution";
     }
 
     setDebuggerStateOn(s_dbgBusy);
     raiseEvent(debugger_busy);
 
     executeCmd();
 }
 
 void MIDebugSession::executeCmd()
 {
     Q_ASSERT(m_debugger);
 
     if (debuggerStateIsOn(s_dbgNotListening) && m_commandQueue->haveImmediateCommand()) {
         // We may have to call this even while a command is currently executing, because
         // debugger can get into a state where a command such as ExecRun does not send a response
         // while the inferior is running.
         ensureDebuggerListening();
     }
 
     if (!m_debugger->isReady())
         return;
 
     MICommand* currentCmd = m_commandQueue->nextCommand();
     if (!currentCmd)
         return;
 
     if (currentCmd->flags() & (CmdMaybeStartsRunning | CmdInterrupt)) {
         setDebuggerStateOff(s_automaticContinue);
     }
 
     if (currentCmd->flags() & CmdMaybeStartsRunning) {
         // GDB can be in a state where it is listening for commands while the program is running.
         // However, when we send a command such as ExecContinue in this state, GDB may return to
         // the non-listening state without acknowledging that the ExecContinue command has even
         // finished, let alone sending a new notification about the program's running state.
         // So let's be extra cautious about ensuring that we will wake GDB up again if required.
         setDebuggerStateOn(s_dbgNotListening);
     }
 
     bool varCommandWithContext= (currentCmd->type() >= MI::VarAssign
                                  && currentCmd->type() <= MI::VarUpdate
                                  && currentCmd->type() != MI::VarDelete);
 
     bool stackCommandWithContext = (currentCmd->type() >= MI::StackInfoDepth
                                     && currentCmd->type() <= MI::StackListLocals);
 
     if (varCommandWithContext || stackCommandWithContext) {
         // Most var commands should be executed in the context
         // of the selected thread and frame.
         if (currentCmd->thread() == -1)
             currentCmd->setThread(frameStackModel()->currentThread());
 
         if (currentCmd->frame() == -1)
             currentCmd->setFrame(frameStackModel()->currentFrame());
     }
 
     QString commandText = currentCmd->cmdToSend();
     bool bad_command = false;
     QString message;
 
     int length = commandText.length();
     // No i18n for message since it's mainly for debugging.
     if (length == 0) {
         // The command might decide it's no longer necessary to send
         // it.
         if (SentinelCommand* sc = dynamic_cast<SentinelCommand*>(currentCmd))
         {
             qCDebug(DEBUGGERCOMMON) << "SEND: sentinel command, not sending";
             sc->invokeHandler();
         }
         else
         {
             qCDebug(DEBUGGERCOMMON) << "SEND: command " << currentCmd->initialString()
                           << "changed its mind, not sending";
         }
 
         delete currentCmd;
         executeCmd();
         return;
     } else {
         if (commandText[length-1] != '\n') {
             bad_command = true;
             message = "Debugger command does not end with newline";
         }
     }
 
     if (bad_command) {
         KMessageBox::information(qApp->activeWindow(),
                                  i18n("<b>Invalid debugger command</b><br>%1", message),
                                  i18n("Invalid debugger command"));
         executeCmd();
         return;
     }
 
     m_debugger->execute(currentCmd);
 }
 
 void MIDebugSession::ensureDebuggerListening()
 {
     Q_ASSERT(m_debugger);
 
     // Note: we don't use interruptDebugger() here since
     // we don't want to queue more commands before queuing a command
     m_debugger->interrupt();
 
     setDebuggerStateOn(s_interruptSent);
     if (debuggerStateIsOn(s_appRunning))
         setDebuggerStateOn(s_automaticContinue);
     setDebuggerStateOff(s_dbgNotListening);
 }
 
 void MIDebugSession::destroyCmds()
 {
     m_commandQueue->clear();
 }
 
 // FIXME: I don't fully remember what is the business with
 // m_stateReloadInProgress and whether we can lift it to the
 // generic level.
 void MIDebugSession::raiseEvent(event_t e)
 {
     if (e == program_exited || e == debugger_exited) {
         m_stateReloadInProgress = false;
     }
 
     if (e == program_state_changed) {
         m_stateReloadInProgress = true;
         qCDebug(DEBUGGERCOMMON) << "State reload in progress\n";
     }
 
     IDebugSession::raiseEvent(e);
 
     if (e == program_state_changed) {
         m_stateReloadInProgress = false;
     }
 }
 
 bool KDevMI::MIDebugSession::hasCrashed() const
 {
     return m_hasCrashed;
 }
 
 void MIDebugSession::slotDebuggerReady()
 {
     Q_ASSERT(m_debugger);
 
     m_stateReloadInProgress = false;
 
     executeCmd();
     if (m_debugger->isReady()) {
         /* There is nothing in the command queue and no command is currently executing. */
         if (debuggerStateIsOn(s_automaticContinue)) {
             if (!debuggerStateIsOn(s_appRunning)) {
                 qCDebug(DEBUGGERCOMMON) << "Posting automatic continue";
                 addCommand(ExecContinue, QString(), CmdMaybeStartsRunning);
             }
             setDebuggerStateOff(s_automaticContinue);
             return;
         }
 
         if (m_stateReloadNeeded && !debuggerStateIsOn(s_appRunning)) {
             qCDebug(DEBUGGERCOMMON) << "Finishing program stop";
             // Set to false right now, so that if 'actOnProgramPauseMI_part2'
             // sends some commands, we won't call it again when handling replies
             // from that commands.
             m_stateReloadNeeded = false;
             reloadProgramState();
         }
 
         qCDebug(DEBUGGERCOMMON) << "No more commands";
         setDebuggerStateOff(s_dbgBusy);
         raiseEvent(debugger_ready);
     }
 }
 
 void MIDebugSession::slotDebuggerExited(bool abnormal, const QString &msg)
 {
     /* Technically speaking, GDB is likely not to kill the application, and
        we should have some backup mechanism to make sure the application is
        killed by KDevelop.  But even if application stays around, we no longer
        can control it in any way, so mark it as exited.  */
     setDebuggerStateOn(s_appNotStarted);
     setDebuggerStateOn(s_dbgNotStarted);
     setDebuggerStateOn(s_programExited);
     setDebuggerStateOff(s_shuttingDown);
 
     if (!msg.isEmpty())
         emit showMessage(msg, 3000);
 
     if (abnormal) {
         /* The error is reported to user in MIDebugger now.
         KMessageBox::information(
             KDevelop::ICore::self()->uiController()->activeMainWindow(),
             i18n("<b>Debugger exited abnormally</b>"
                 "<p>This is likely a bug in GDB. "
                 "Examine the gdb output window and then stop the debugger"),
             i18n("Debugger exited abnormally"));
         */
         // FIXME: not sure if the following still applies.
         // Note: we don't stop the debugger here, becuse that will hide gdb
         // window and prevent the user from finding the exact reason of the
         // problem.
     }
 
     /* FIXME: raiseEvent is handled across multiple places where we explicitly
      * stop/kill the debugger, a better way is to let the debugger itself report
      * its exited event.
      */
     // raiseEvent(debugger_exited);
 }
 
 void MIDebugSession::slotInferiorStopped(const MI::AsyncRecord& r)
 {
     /* By default, reload all state on program stop.  */
     m_stateReloadNeeded = true;
     setDebuggerStateOff(s_appRunning);
     setDebuggerStateOff(s_dbgNotListening);
 
     QString reason;
     if (r.hasField("reason")) reason = r["reason"].literal();
 
     if (reason == "exited-normally" || reason == "exited") {
         if (r.hasField("exit-code")) {
             programNoApp(i18n("Exited with return code: %1", r["exit-code"].literal()));
         } else {
             programNoApp(i18n("Exited normally"));
         }
         m_stateReloadNeeded = false;
         return;
     }
 
     if (reason == "exited-signalled") {
         programNoApp(i18n("Exited on signal %1", r["signal-name"].literal()));
         m_stateReloadNeeded = false;
         return;
     }
 
     if (reason == "watchpoint-scope") {
         QString number = r["wpnum"].literal();
 
         // FIXME: shuld remove this watchpoint
         // But first, we should consider if removing all
         // watchpoinst on program exit is the right thing to
         // do.
 
         addCommand(ExecContinue, QString(), CmdMaybeStartsRunning);
 
         m_stateReloadNeeded = false;
         return;
     }
 
     bool wasInterrupt = false;
 
     if (reason == "signal-received") {
         QString name = r["signal-name"].literal();
         QString user_name = r["signal-meaning"].literal();
 
         // SIGINT is a "break into running program".
         // We do this when the user set/mod/clears a breakpoint but the
         // application is running.
         // And the user does this to stop the program also.
         if (name == "SIGINT" && debuggerStateIsOn(s_interruptSent)) {
             wasInterrupt = true;
         } else {
             // Whenever we have a signal raised then tell the user, but don't
             // end the program as we want to allow the user to look at why the
             // program has a signal that's caused the prog to stop.
             // Continuing from SIG FPE/SEGV will cause a "Cannot ..." and
             // that'll end the program.
             programFinished(i18n("Program received signal %1 (%2)", name, user_name));
 
             m_hasCrashed = true;
         }
     }
 
     if (!reason.contains("exited")) {
         // FIXME: we should immediately update the current thread and
         // frame in the framestackmodel, so that any user actions
         // are in that thread. However, the way current framestack model
         // is implemented, we can't change thread id until we refresh
         // the entire list of threads -- otherwise we might set a thread
         // id that is not already in the list, and it will be upset.
 
         //Indicates if program state should be reloaded immediately.
         bool updateState = false;
 
         if (r.hasField("frame")) {
             const MI::Value& frame = r["frame"];
             QString file, line, addr;
 
             if (frame.hasField("fullname")) file = frame["fullname"].literal();;
             if (frame.hasField("line"))     line = frame["line"].literal();
             if (frame.hasField("addr"))     addr = frame["addr"].literal();
 
             // gdb counts lines from 1 and we don't
             setCurrentPosition(QUrl::fromLocalFile(file), line.toInt() - 1, addr);
 
             updateState = true;
         }
 
         if (updateState) {
             reloadProgramState();
         }
     }
 
     setDebuggerStateOff(s_interruptSent);
     if (!wasInterrupt)
         setDebuggerStateOff(s_automaticContinue);
 }
 
 void MIDebugSession::slotInferiorRunning()
 {
     setDebuggerStateOn(s_appRunning);
     raiseEvent(program_running);
 
     if (m_commandQueue->haveImmediateCommand() ||
         (m_debugger->currentCommand() && (m_debugger->currentCommand()->flags() & (CmdImmediately | CmdInterrupt)))) {
         ensureDebuggerListening();
     } else {
         setDebuggerStateOn(s_dbgNotListening);
     }
 }
 
 void MIDebugSession::processNotification(const MI::AsyncRecord & async)
 {
     if (async.reason == "thread-group-started") {
         setDebuggerStateOff(s_appNotStarted | s_programExited);
     } else if (async.reason == "thread-group-exited") {
         setDebuggerStateOn(s_programExited);
     } else if (async.reason == "library-loaded") {
         // do nothing
     } else if (async.reason == "breakpoint-created") {
         breakpointController()->notifyBreakpointCreated(async);
     } else if (async.reason == "breakpoint-modified") {
         breakpointController()->notifyBreakpointModified(async);
     } else if (async.reason == "breakpoint-deleted") {
         breakpointController()->notifyBreakpointDeleted(async);
     } else {
         qCDebug(DEBUGGERCOMMON) << "Unhandled notification: " << async.reason;
     }
 }
 
 void MIDebugSession::reloadProgramState()
 {
     raiseEvent(program_state_changed);
     m_stateReloadNeeded = false;
 }
 
 // There is no app anymore. This can be caused by program exiting
 // an invalid program specified or ...
 // gdb is still running though, but only the run command (may) make sense
 // all other commands are disabled.
 void MIDebugSession::programNoApp(const QString& msg)
 {
     qCDebug(DEBUGGERCOMMON) << msg;
 
     setDebuggerState(s_appNotStarted | s_programExited | (m_debuggerState & s_shuttingDown));
 
     destroyCmds();
 
     // The application has existed, but it's possible that
     // some of application output is still in the pipe. We use
     // different pipes to communicate with gdb and to get application
     // output, so "exited" message from gdb might have arrived before
     // last application output. Get this last bit.
 
     // Note: this method can be called when we open an invalid
     // core file. In that case, tty_ won't be set.
     if (m_tty){
         m_tty->readRemaining();
         // Tty is no longer usable, delete it. Without this, QSocketNotifier
         // will continuously bomd STTY with signals, so we need to either disable
         // QSocketNotifier, or delete STTY. The latter is simpler, since we can't
         // reuse it for future debug sessions anyway.
         m_tty.reset(nullptr);
     }
 
     stopDebugger();
 
     raiseEvent(program_exited);
     raiseEvent(debugger_exited);
 
     emit showMessage(msg, 0);
 
     programFinished(msg);
 }
 
 void MIDebugSession::programFinished(const QString& msg)
 {
     QString m = QString("*** %0 ***").arg(msg.trimmed());
     emit inferiorStderrLines(QStringList(m));
 
     /* Also show message in gdb window, so that users who
        prefer to look at gdb window know what's up.  */
     emit debuggerUserCommandOutput(m);
 }
 
 void MIDebugSession::explainDebuggerStatus()
 {
     MICommand* currentCmd_ = m_debugger->currentCommand();
     QString information =
         i18np("1 command in queue\n", "%1 commands in queue\n", m_commandQueue->count()) +
         i18ncp("Only the 0 and 1 cases need to be translated", "1 command being processed by gdb\n", "%1 commands being processed by gdb\n", (currentCmd_ ? 1 : 0)) +
         i18n("Debugger state: %1\n", m_debuggerState);
 
     if (currentCmd_) {
         QString extra = i18n("Current command class: '%1'\n"
                              "Current command text: '%2'\n"
                              "Current command original text: '%3'\n",
                              typeid(*currentCmd_).name(),
                              currentCmd_->cmdToSend(),
                              currentCmd_->initialString());
 
         information += extra;
     }
 
     KMessageBox::information(qApp->activeWindow(), information,
                              i18n("Debugger status"));
 }
 
 // There is no app anymore. This can be caused by program exiting
 // an invalid program specified or ...
 // gdb is still running though, but only the run command (may) make sense
 // all other commands are disabled.
 void MIDebugSession::handleNoInferior(const QString& msg)
 {
     qCDebug(DEBUGGERCOMMON) << msg;
 
     setDebuggerState(s_appNotStarted | s_programExited | (debuggerState() & s_shuttingDown));
 
     destroyCmds();
 
     // The application has existed, but it's possible that
     // some of application output is still in the pipe. We use
     // different pipes to communicate with gdb and to get application
     // output, so "exited" message from gdb might have arrived before
     // last application output. Get this last bit.
 
     // Note: this method can be called when we open an invalid
     // core file. In that case, tty_ won't be set.
     if (m_tty){
         m_tty->readRemaining();
         // Tty is no longer usable, delete it. Without this, QSocketNotifier
         // will continuously bomd STTY with signals, so we need to either disable
         // QSocketNotifier, or delete STTY. The latter is simpler, since we can't
         // reuse it for future debug sessions anyway.
         m_tty.reset(nullptr);
     }
 
     stopDebugger();
 
     raiseEvent(program_exited);
     raiseEvent(debugger_exited);
 
     emit showMessage(msg, 0);
 
     handleInferiorFinished(msg);
 }
 
 void MIDebugSession::handleInferiorFinished(const QString& msg)
 {
     QString m = QStringLiteral("*** %0 ***").arg(msg.trimmed());
     emit inferiorStderrLines(QStringList(m));
 
     /* Also show message in gdb window, so that users who
        prefer to look at gdb window know what's up.  */
     emit debuggerUserCommandOutput(m);
 }
 
 // FIXME: connect to debugger's slot.
 void MIDebugSession::defaultErrorHandler(const MI::ResultRecord& result)
 {
     QString msg = result["msg"].literal();
 
     if (msg.contains("No such process"))
     {
         setDebuggerState(s_appNotStarted|s_programExited);
         raiseEvent(program_exited);
         return;
     }
 
     KMessageBox::information(
         qApp->activeWindow(),
         i18n("<b>Debugger error</b>"
              "<p>Debugger reported the following error:"
              "<p><tt>%1", result["msg"].literal()),
         i18n("Debugger error"));
 
     // Error most likely means that some change made in GUI
     // was not communicated to the gdb, so GUI is now not
     // in sync with gdb. Resync it.
     //
     // Another approach is to make each widget reload it content
     // on errors from commands that it sent, but that's too complex.
     // Errors are supposed to happen rarely, so full reload on error
     // is not a big deal. Well, maybe except for memory view, but
     // it's no auto-reloaded anyway.
     //
     // Also, don't reload state on errors appeared during state
     // reloading!
     if (!m_debugger->currentCommand()->stateReloading())
         raiseEvent(program_state_changed);
 }
 
 void MIDebugSession::setSourceInitFile(bool enable)
 {
     m_sourceInitFile = enable;
 }
diff --git a/debuggers/common/mivariable.h b/debuggers/common/mivariable.h
index 952dbd871c..2619203b0c 100644
--- a/debuggers/common/mivariable.h
+++ b/debuggers/common/mivariable.h
@@ -1,88 +1,87 @@
 /*
  * MI based debugger specific Variable
  *
  * Copyright 2009 Vladimir Prus <ghost@cs.msu.su>
  *
  * 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 MIVARIABLE_H
 #define MIVARIABLE_H
 
 #include "mi/mi.h"
 
 #include <debugger/variable/variablecollection.h>
 
-#include <QMap>
 #include <QPointer>
 
 
 class CreateVarobjHandler;
 class FetchMoreChildrenHandler;
 class SetFormatHandler;
 namespace KDevMI {
 class MIDebugSession;
 class MIVariable : public KDevelop::Variable
 {
 public:
     MIVariable(MIDebugSession *session, KDevelop::TreeModel* model, KDevelop::TreeItem* parent,
                const QString& expression, const QString& display = "");
 
     ~MIVariable();
 
     /* FIXME: should eventually remove, so that existence of
         varobjs is fully encapsulalated inside GdbVariable.  */
     const QString& varobj() const;
     void handleUpdate(const MI::Value& var);
 
     /* Called when debugger dies.  Clears the association between varobj names
         and Variable instances.  */
     void markAsDead();
 
     bool canSetFormat() const override { return true; }
 
 protected: // Variable overrides
     void attachMaybe(QObject *callback, const char *callbackMethod) override;
     void fetchMoreChildren() override;
     void formatChanged() override;
 
 protected: // Internal
     friend class ::CreateVarobjHandler;
     friend class ::FetchMoreChildrenHandler;
     friend class ::SetFormatHandler;
 
     /**
      * Construct a MIVariable child directly from a MI value
      */
     MIVariable *createChild(const MI::Value &child);
 
     QString enquotedExpression() const;
     virtual QString formatValue(const QString &rawValue) const;
 
     bool sessionIsAlive() const;
 
     void setVarobj(const QString& v);
     QString varobj_;
 
     QPointer<MIDebugSession> debugSession;
 
     // How many children should be fetched in one
     // increment.
     static const int fetchStep = 5;
 };
 } // end of KDevMI
 
 #endif
diff --git a/debuggers/common/registers/modelsmanager.h b/debuggers/common/registers/modelsmanager.h
index ad2315f198..974e63efab 100644
--- a/debuggers/common/registers/modelsmanager.h
+++ b/debuggers/common/registers/modelsmanager.h
@@ -1,101 +1,100 @@
 /*
  * Class to manage register models.
  * Copyright (C) 2013  Vlas Puhov <vlas.puhov@mail.ru>
  *
  * 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 MODELSMANAGER_H
 #define MODELSMANAGER_H
 
 #include <QObject>
 #include <QString>
 #include <QVector>
 #include <QScopedPointer>
 
 #include <KConfigGroup>
 
 #include "registercontroller.h"
 
 class QAbstractItemView;
-class QStandardItemModel;
 class QStandardItem;
 class QModelIndex;
 
 namespace KDevMI {
 class Models;
 class IRegisterController;
 struct Register;
 struct RegistersGroup;
 class GroupsName;
 
 class ModelsManager : public QObject
 {
     Q_OBJECT
 
 public:
     explicit ModelsManager(QObject* parent = nullptr);
 
     ~ModelsManager() override;
 
     ///Adds new @p view with @p name, if not yet registered.
     ///All views removed after debug session ended.
     ///@return: Name of the new view.
     QString addView(QAbstractItemView* view);
 
     void setController(IRegisterController* rc);
 
     ///Sets @p format for the @p group, if format is valid. Does nothing otherwise.
     void setFormat(const QString& group, Format format);
 
     ///Returns all supported formats for @p group. The first one is current.
     QVector<Format> formats(const QString& group) const;
 
     ///Sets @p mode for the @p group, if mode is valid. Does nothing otherwise.
     void setMode(const QString& group, Mode mode);
 
     ///Returns all supported modes for @p group. The first one is current.
     QVector<Mode> modes(const QString& group) const;
 
 Q_SIGNALS:
     ///Emitted when a register in a model changed. Updated value should be send to the debugger.
     void registerChanged(const Register&);
 
 public Q_SLOTS:
     void updateModelForGroup(const RegistersGroup& group);
 
     ///Forcedly updates registers in @p group.
     void updateRegisters(const QString& group = QString());
 
 private:
     void save(const GroupsName&);
     void load(const GroupsName&);
 
 private Q_SLOTS:
     void flagChanged(const QModelIndex&);
 
     void itemChanged(QStandardItem*);
 
 private:
     QScopedPointer<Models> m_models;
 
     IRegisterController* m_controller;
 
     KConfigGroup m_config;
 };
 
 } // end of namespace KDevMI
 #endif // MODELSMANAGER_H
diff --git a/debuggers/common/stringhelpers.cpp b/debuggers/common/stringhelpers.cpp
index 57bbb3f13a..7be2e8a4a6 100644
--- a/debuggers/common/stringhelpers.cpp
+++ b/debuggers/common/stringhelpers.cpp
@@ -1,286 +1,284 @@
 /*
    Copyright 2007 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 "stringhelpers.h"
 
 #include "debuglog.h"
 
 #include <language/duchain/stringhelpers.h>
 #include <language/duchain/safetycounter.h>
 
-#include <QByteArray>
 #include <QChar>
 #include <QString>
-#include <QStringList>
 
 namespace Utils {
 
 bool parenFits( QChar c1, QChar c2 ) {
   if( c1 == '<' && c2 == '>' ) return true;
   else if( c1 == '(' && c2 == ')' ) return true;
   else if( c1 == '[' && c2 == ']' ) return true;
   else if( c1 == '{' && c2 == '}' ) return true;
   else
     return false;
 }
 
 bool isParen( QChar c1 ) {
   if( c1 == '<' || c1 == '>' ) return true;
   else if( c1 == '(' || c1 == ')' ) return true;
   else if( c1 == '[' || c1 == ']' ) return true;
   else if( c1 == '{' || c1 == '}' ) return true;
   else
     return false;
 }
 
 bool isTypeParen( QChar c1 ) {
   if( c1 == '<' || c1 == '>' ) return true;
   else
     return false;
 }
 
 bool isTypeOpenParen( QChar c1 ) {
   if( c1 == '<' ) return true;
   else
     return false;
 }
 
 bool isTypeCloseParen( QChar c1 ) {
   if( c1 == '>' ) return true;
   else
     return false;
 }
 
 bool isLeftParen( QChar c1 ) {
   if( c1 == '<' ) return true;
   else if( c1 == '(' ) return true;
   else if( c1 == '[' ) return true;
   else if( c1 == '{' ) return true;
   else
     return false;
 }
 
 enum { T_ACCESS, T_PAREN, T_BRACKET, T_IDE, T_UNKNOWN, T_TEMP };
 
 int expressionAt( const QString& text, int index ) {
 
   if( index == 0 )
     return 0;
 
   int last = T_UNKNOWN;
   int start = index;
   --index;
 
   while ( index > 0 ) {
     while ( index > 0 && text[ index ].isSpace() ) {
       --index;
     }
 
     QChar ch = text[ index ];
     QString ch2 = text.mid( index - 1, 2 );
     if ( ( last != T_IDE ) && ( ch.isLetterOrNumber() || ch == '_' ) ) {
       while ( index > 0 && ( text[ index ].isLetterOrNumber() || text[ index ] == '_' ) ) {
         --index;
       }
       last = T_IDE;
     } else if ( last != T_IDE && ch == ')' ) {
       int count = 0;
       while ( index > 0 ) {
         QChar ch = text[ index ];
         if ( ch == '(' ) {
           ++count;
         } else if ( ch == ')' ) {
           --count;
         }
         --index;
         if ( count == 0 ) {
           //index;
           last = T_PAREN;
           break;
         }
       }
     } else if ( last != T_IDE && ch == '>' && ch2 != "->" ) {
       int count = 0;
       while ( index > 0 ) {
         QChar ch = text[ index ];
         if ( ch == '<' ) {
           ++count;
         } else if ( ch == '>' ) {
           --count;
         } else if ( count == 0 ) {
           //--index;
           last = T_TEMP;
           break;
         }
         --index;
       }
     } else if ( ch == ']' ) {
       int count = 0;
       while ( index > 0 ) {
         QChar ch = text[ index ];
         if ( ch == '[' ) {
           ++count;
         } else if ( ch == ']' ) {
           --count;
         } else if ( count == 0 ) {
           //--index;
           last = T_BRACKET;
           break;
         }
         --index;
       }
     } else if ( ch == '.' ) {
       --index;
       last = T_ACCESS;
     } else if ( ch2 == "::" ) {
       index -= 2;
       last = T_ACCESS;
     } else if ( ch2 == "->" ) {
       index -= 2;
       last = T_ACCESS;
     } else {
       if ( start > index ) {
         ++index;
       }
       last = T_UNKNOWN;
       break;
     }
   }
 
   ///If we're at the first item, the above algorithm cannot be used safely,
   ///so just determine whether the sign is valid for the beginning of an expression, if it isn't reject it.
   if ( index == 0 && start > index && !( text[ index ].isLetterOrNumber() || text[ index ] == '_' || text[ index ] == ':' ) ) {
     ++index;
   }
 
   return index;
 }
 
 QString quoteExpression(QString expr)
 {
     return quote(expr, '"');
 }
 
 QString unquoteExpression(QString expr)
 {
     return unquote(expr, false);
 }
 
 QString quote(QString str, char quoteCh)
 {
     str.replace("\\", "\\\\").replace(quoteCh, QStringLiteral("\\") + quoteCh);
     return str.prepend(quoteCh).append(quoteCh);
 }
 
 QString unquote(const QString &str, bool unescapeUnicode, char quoteCh)
 {
     if (str.startsWith(quoteCh) && str.endsWith(quoteCh)) {
         QString res;
         res.reserve(str.length());
         bool esc = false;
         int type = 0;
         QString escSeq;
         escSeq.reserve(4);
         // skip beginning and ending quoteCh, no need for str = str.mid(1, str.length() - 2)
         for (int i = 1; i != str.length() - 1; i++) {
             auto ch = str[i];
             if (esc) {
                 switch (ch.unicode()) {
                 case '\\':
                     if (type != 0) {
                         escSeq += ch;
                         qCDebug(DEBUGGERCOMMON) << "Unrecognized escape sequence:" << escSeq;
                         res += '\\';
                         res += escSeq;
                         escSeq.clear();
                         esc = false;
                         type = 0;
                     } else {
                         res.append('\\');
                         // escSeq.clear();    // escSeq must be empty.
                         esc = false;
                     }
                     break;
                 case 'u':
                 case 'x':
                     if (type != 0 || !unescapeUnicode) {
                         escSeq += ch;
                         qCDebug(DEBUGGERCOMMON) << "Unrecognized escape sequence:" << escSeq;
                         res += '\\';
                         res += escSeq;
                         escSeq.clear();
                         esc = false;
                         type = 0;
                     } else {
                         type = ch == 'u' ? 1 : 2;
                     }
                     break;
                 case '0': case '1': case '2': case '3': case '4':
                 case '5': case '6': case '7': case '8': case '9':
                 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                     escSeq += ch;
                     if (type == 0) {
                         qCDebug(DEBUGGERCOMMON) << "Unrecognized escape sequence:" << escSeq;
                         res += '\\';
                         res += escSeq;
                         escSeq.clear();
                         esc = false;
                         type = 0;
                     } else {
                         // \uNNNN
                         // \xNN
                         if (escSeq.length() == (type == 1 ? 4 : 2)) {
                             // no need to handle error, we know for sure escSeq is '[0-9a-fA-F]+'
                             auto code = escSeq.toInt(nullptr, 16);
                             res += QChar(code);
                             escSeq.clear();
                             esc = false;
                             type = 0;
                         }
                     }
                     break;
                 default:
                     if (type == 0 && ch == quoteCh) {
                         res += ch;
                     } else {
                         escSeq += ch;
                         qCDebug(DEBUGGERCOMMON) << "Unrecognized escape sequence:" << escSeq;
                         res += '\\';
                         res += escSeq;
                         escSeq.clear();
                     }
                     esc = false;
                     type = 0;
                     break;
                 }
             } else {
                 if (ch == '\\') {
                     esc = true;
                     continue;
                 }
                 res += ch;
             }
         }
         return res;
     } else {
         return str;
     }
 }
 
 } // end of namespace Utils
diff --git a/debuggers/common/widgets/debuggerconsoleview.cpp b/debuggers/common/widgets/debuggerconsoleview.cpp
index 4c0f644f04..b2c8f6affd 100644
--- a/debuggers/common/widgets/debuggerconsoleview.cpp
+++ b/debuggers/common/widgets/debuggerconsoleview.cpp
@@ -1,409 +1,408 @@
 /*
  * Debugger Console View
  *
  * Copyright 2003 John Birch <jbb@kdevelop.org>
  * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2016  Aetf <aetf@unlimitedcodeworks.xyz>
  *
  * 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 "debuggerconsoleview.h"
 
 #include "debuglog.h"
 #include "midebuggerplugin.h"
 #include "midebugsession.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/idebugcontroller.h>
 
 #include <KColorScheme>
 #include <KHistoryComboBox>
 #include <KLocalizedString>
 
 #include <QAction>
-#include <QClipboard>
 #include <QEvent>
 #include <QHBoxLayout>
 #include <QIcon>
 #include <QLabel>
 #include <QMenu>
 #include <QScopedPointer>
 #include <QScrollBar>
 #include <QStyle>
 #include <QTextEdit>
 #include <QToolBar>
 #include <QVBoxLayout>
-#include <QWidget>
+#include <QPoint>
 
 using namespace KDevMI;
 
 DebuggerConsoleView::DebuggerConsoleView(MIDebuggerPlugin *plugin, QWidget *parent)
     : QWidget(parent)
     , m_repeatLastCommand(false)
     , m_showInternalCommands(false)
     , m_cmdEditorHadFocus(false)
     , m_maxLines(5000)
 {
     setWindowIcon(QIcon::fromTheme("dialog-scripts"));
     setWindowTitle(i18n("Debugger Console"));
     setWhatsThis(i18n("<b>Debugger Console</b><p>"
                       "Shows all debugger commands being executed. "
                       "You can also issue any other debugger command while debugging.</p>"));
 
     setupUi();
 
     m_actRepeat = new QAction(QIcon::fromTheme("edit-redo"),
                               i18n("Repeat last command when hit Return"),
                               this);
     m_actRepeat->setCheckable(true);
     m_actRepeat->setChecked(m_repeatLastCommand);
     connect(m_actRepeat, &QAction::toggled, this, &DebuggerConsoleView::toggleRepeat);
     m_toolBar->insertAction(m_actCmdEditor, m_actRepeat);
 
     m_actInterrupt = new QAction(QIcon::fromTheme("media-playback-pause"),
                                  i18n("Pause execution of the app to enter gdb commands"),
                                  this);
     connect(m_actInterrupt, &QAction::triggered, this, &DebuggerConsoleView::interruptDebugger);
     m_toolBar->insertAction(m_actCmdEditor, m_actInterrupt);
     setShowInterrupt(true);
 
     m_actShowInternal = new QAction(i18n("Show Internal Commands"), this);
     m_actShowInternal->setCheckable(true);
     m_actShowInternal->setChecked(m_showInternalCommands);
     m_actShowInternal->setWhatsThis(i18n(
         "Controls if commands issued internally by KDevelop "
         "will be shown or not.<br>"
         "This option will affect only future commands, it will not "
         "add or remove already issued commands from the view."));
     connect(m_actShowInternal, &QAction::toggled,
             this, &DebuggerConsoleView::toggleShowInternalCommands);
 
     handleDebuggerStateChange(s_none, s_dbgNotStarted);
 
     m_updateTimer.setSingleShot(true);
     connect(&m_updateTimer, &QTimer::timeout, this, &DebuggerConsoleView::flushPending);
 
     connect(plugin->core()->debugController(), &KDevelop::IDebugController::currentSessionChanged,
             this, &DebuggerConsoleView::handleSessionChanged);
 
     connect(plugin, &MIDebuggerPlugin::reset, this, &DebuggerConsoleView::clear);
     connect(plugin, &MIDebuggerPlugin::raiseDebuggerConsoleViews,
             this, &DebuggerConsoleView::requestRaise);
 
     handleSessionChanged(plugin->core()->debugController()->currentSession());
 
     updateColors();
 }
 
 void DebuggerConsoleView::changeEvent(QEvent *event)
 {
     if (event->type() == QEvent::PaletteChange) {
         updateColors();
     }
 }
 
 void DebuggerConsoleView::updateColors()
 {
     KColorScheme scheme(QPalette::Active);
     m_stdColor = scheme.foreground(KColorScheme::LinkText).color();
     m_errorColor = scheme.foreground(KColorScheme::NegativeText).color();
 }
 
 void DebuggerConsoleView::setupUi()
 {
     setupToolBar();
 
     m_textView = new QTextEdit;
     m_textView->setReadOnly(true);
     m_textView->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(m_textView, &QTextEdit::customContextMenuRequested,
             this, &DebuggerConsoleView::showContextMenu);
 
     auto vbox = new QVBoxLayout;
     vbox->setMargin(0);
     vbox->addWidget(m_textView);
     vbox->addWidget(m_toolBar);
 
     setLayout(vbox);
 
     m_cmdEditor = new KHistoryComboBox(this);
     m_cmdEditor->setDuplicatesEnabled(false);
     connect(m_cmdEditor,
             static_cast<void(KHistoryComboBox::*)(const QString&)>(&KHistoryComboBox::returnPressed),
             this, &DebuggerConsoleView::trySendCommand);
 
     auto label = new QLabel(i18n("&Command:"), this);
     label->setBuddy(m_cmdEditor);
 
     auto hbox = new QHBoxLayout;
     hbox->addWidget(label);
     hbox->addWidget(m_cmdEditor);
     hbox->setStretchFactor(m_cmdEditor, 1);
     hbox->setContentsMargins(0, 0, 0, 0);
 
     auto cmdEditor = new QWidget(this);
     cmdEditor->setLayout(hbox);
     m_actCmdEditor = m_toolBar->addWidget(cmdEditor);
 }
 
 void DebuggerConsoleView::setupToolBar()
 {
     m_toolBar = new QToolBar(this);
     int iconSize = style()->pixelMetric(QStyle::PM_SmallIconSize);
     m_toolBar->setIconSize(QSize(iconSize, iconSize));
     m_toolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);
     m_toolBar->setFloatable(false);
     m_toolBar->setMovable(false);
     m_toolBar->setWindowTitle(i18n("%1 Command Bar", windowTitle()));
     m_toolBar->setContextMenuPolicy(Qt::PreventContextMenu);
 
     // remove margins, to make command editor nicely aligned with the output
     m_toolBar->layout()->setContentsMargins(0, 0, 0, 0);
 }
 
 void DebuggerConsoleView::focusInEvent(QFocusEvent*)
 {
     m_textView->verticalScrollBar()->setValue(m_textView->verticalScrollBar()->maximum());
     m_cmdEditor->setFocus();
 }
 
 DebuggerConsoleView::~DebuggerConsoleView()
 {
 }
 
 void DebuggerConsoleView::setShowInterrupt(bool enable)
 {
     m_actInterrupt->setVisible(enable);
 }
 
 void DebuggerConsoleView::setReplacePrompt(const QString& prompt)
 {
     m_alterPrompt = prompt;
 }
 
 void DebuggerConsoleView::setShowInternalCommands(bool enable)
 {
     if (enable != m_showInternalCommands)
     {
         m_showInternalCommands = enable;
 
         // Set of strings to show changes, text edit still has old
         // set. Refresh.
         m_textView->clear();
         QStringList& newList = m_showInternalCommands ? m_allOutput : m_userOutput;
 
         for (const auto &line : newList) {
             // Note that color formatting is already applied to 'line'.
             appendLine(line);
         }
     }
 }
 
 void DebuggerConsoleView::showContextMenu(const QPoint &pos)
 {
     QScopedPointer<QMenu> popup(m_textView->createStandardContextMenu(pos));
 
     popup->addSeparator();
     popup->addAction(m_actShowInternal);
 
     popup->exec(m_textView->mapToGlobal(pos));
 }
 
 void DebuggerConsoleView::toggleRepeat(bool checked)
 {
     m_repeatLastCommand = checked;
 }
 
 void DebuggerConsoleView::toggleShowInternalCommands(bool checked)
 {
     setShowInternalCommands(checked);
 }
 
 void DebuggerConsoleView::appendLine(const QString& line)
 {
     m_pendingOutput += line;
 
     // To improve performance, we update the view after some delay.
     if (!m_updateTimer.isActive())
     {
         m_updateTimer.start(100);
     }
 }
 
 void DebuggerConsoleView::flushPending()
 {
     m_textView->setUpdatesEnabled(false);
 
     QTextDocument *document = m_textView->document();
     QTextCursor cursor(document);
     cursor.movePosition(QTextCursor::End);
     cursor.insertHtml(m_pendingOutput);
     m_pendingOutput.clear();
 
     m_textView->verticalScrollBar()->setValue(m_textView->verticalScrollBar()->maximum());
     m_textView->setUpdatesEnabled(true);
     m_textView->update();
     if (m_cmdEditorHadFocus) {
         m_cmdEditor->setFocus();
     }
 }
 
 void DebuggerConsoleView::clear()
 {
     if (m_textView)
         m_textView->clear();
 
     if (m_cmdEditor)
         m_cmdEditor->clear();
 
     m_userOutput.clear();
     m_allOutput.clear();
 }
 
 void DebuggerConsoleView::handleDebuggerStateChange(DBGStateFlags, DBGStateFlags newStatus)
 {
     if (newStatus & s_dbgNotStarted) {
         m_actInterrupt->setEnabled(false);
         m_cmdEditor->setEnabled(false);
         return;
     } else {
         m_actInterrupt->setEnabled(true);
     }
 
     if (newStatus & s_dbgBusy) {
         if (m_cmdEditor->isEnabled()) {
             m_cmdEditorHadFocus = m_cmdEditor->hasFocus();
         }
         m_cmdEditor->setEnabled(false);
     } else {
         m_cmdEditor->setEnabled(true);
     }
 }
 
 QString DebuggerConsoleView::toHtmlEscaped(QString text)
 {
     text = text.toHtmlEscaped();
 
     text.replace('\n', "<br>");
     return text;
 }
 
 
 QString DebuggerConsoleView::colorify(QString text, const QColor& color)
 {
     text = "<font color=\"" + color.name() +  "\">" + text + "</font>";
     return text;
 }
 
 void DebuggerConsoleView::receivedInternalCommandStdout(const QString& line)
 {
     receivedStdout(line, true);
 }
 
 void DebuggerConsoleView::receivedUserCommandStdout(const QString& line)
 {
     receivedStdout(line, false);
 }
 
 void DebuggerConsoleView::receivedStdout(const QString& line, bool internal)
 {
     QString colored = toHtmlEscaped(line);
     if (colored.startsWith("(gdb)")) {
         if (!m_alterPrompt.isEmpty()) {
             colored.replace(0, 5, m_alterPrompt);
         }
         colored = colorify(colored, m_stdColor);
     }
 
     m_allOutput.append(colored);
     trimList(m_allOutput, m_maxLines);
 
     if (!internal) {
         m_userOutput.append(colored);
         trimList(m_userOutput, m_maxLines);
     }
 
     if (!internal || m_showInternalCommands)
         appendLine(colored);
 }
 
 void DebuggerConsoleView::receivedStderr(const QString& line)
 {
     QString colored = toHtmlEscaped(line);
     colored = colorify(colored, m_errorColor);
 
     // Errors are shown inside user commands too.
     m_allOutput.append(colored);
     trimList(m_allOutput, m_maxLines);
 
     m_userOutput.append(colored);
     trimList(m_userOutput, m_maxLines);
 
     appendLine(colored);
 }
 
 void DebuggerConsoleView::trimList(QStringList& l, int max_size)
 {
     int length = l.count();
     if (length > max_size)
     {
         for(int to_delete = length - max_size; to_delete; --to_delete)
         {
             l.erase(l.begin());
         }
     }
 }
 
 void DebuggerConsoleView::trySendCommand(QString cmd)
 {
     if (m_repeatLastCommand && cmd.isEmpty()) {
         cmd = m_cmdEditor->historyItems().last();
     }
     if (!cmd.isEmpty())
     {
         m_cmdEditor->addToHistory(cmd);
         m_cmdEditor->clearEditText();
 
         emit sendCommand(cmd);
     }
 }
 
 void DebuggerConsoleView::handleSessionChanged(KDevelop::IDebugSession* s)
 {
     MIDebugSession *session = qobject_cast<MIDebugSession*>(s);
     if (!session) return;
 
     connect(this, &DebuggerConsoleView::sendCommand,
              session, &MIDebugSession::addUserCommand);
     connect(this, &DebuggerConsoleView::interruptDebugger,
              session, &MIDebugSession::interruptDebugger);
 
      connect(session, &MIDebugSession::debuggerInternalCommandOutput,
              this, &DebuggerConsoleView::receivedInternalCommandStdout);
      connect(session, &MIDebugSession::debuggerUserCommandOutput,
              this, &DebuggerConsoleView::receivedUserCommandStdout);
      connect(session, &MIDebugSession::debuggerInternalOutput,
              this, &DebuggerConsoleView::receivedStderr);
 
      connect(session, &MIDebugSession::debuggerStateChanged,
              this, &DebuggerConsoleView::handleDebuggerStateChange);
 
      handleDebuggerStateChange(s_none, session->debuggerState());
 }
diff --git a/debuggers/common/widgets/debuggerconsoleview.h b/debuggers/common/widgets/debuggerconsoleview.h
index d64101dc46..83f79f4cc5 100644
--- a/debuggers/common/widgets/debuggerconsoleview.h
+++ b/debuggers/common/widgets/debuggerconsoleview.h
@@ -1,165 +1,164 @@
 /*
  * Debugger Console View
  *
  * Copyright 2003 John Birch <jbb@kdevelop.org>
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2016  Aetf <aetf@unlimitedcodeworks.xyz>
  *
  * 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/>.
  *
  */
 
 #ifndef DEBUGGERCONSOLEVIEW_H
 #define DEBUGGERCONSOLEVIEW_H
 
 #include <QWidget>
-#include <QPoint>
 #include <QStringList>
 #include <QTimer>
 
 #include "dbgglobal.h"
 
 class QMenu;
 class QTextEdit;
 class QToolBar;
 class KHistoryComboBox;
 
 namespace KDevelop {
 class IDebugSession;
 }
 
 namespace KDevMI {
 class MIDebuggerPlugin;
 
 /**
  * @brief A debugger console gives the user direct access to the debugger command line interface.
  */
 class DebuggerConsoleView : public QWidget
 {
     Q_OBJECT
 public:
     explicit DebuggerConsoleView(MIDebuggerPlugin *plugin, QWidget *parent = nullptr);
     ~DebuggerConsoleView();
 
     /**
      * Whether show a button allowing user to interrupt debugger execution.
      */
     void setShowInterrupt(bool enable);
 
     /**
      * If set to a nonempty string, the default "(gdb)" prompt will be replaced.
      * This only affects output lines after the call.
      */
     void setReplacePrompt(const QString &prompt);
 
     void setShowInternalCommands(bool enable);
 
 Q_SIGNALS:
     void requestRaise();
     /**
      * Proxy signals for DebugSession
      */
     void interruptDebugger();
     void sendCommand(const QString &cmd);
 
 
 protected:
     void setupUi();
     void setupToolBar();
 
     /**
      * Arranges for 'line' to be shown to the user.
      * Adds 'line' to m_pendingOutput and makes sure
      * m_updateTimer is running.
      */
     void appendLine(const QString &line);
     void updateColors();
 
     /**
      * escape html meta characters and handle line break
      */
     QString toHtmlEscaped(QString text);
 
     QString colorify(QString text, const QColor &color);
 
     /**
      * Makes 'l' no longer than 'max_size' by
      * removing excessive elements from the top.
      */
     void trimList(QStringList& l, int max_size);
 
     void changeEvent(QEvent *e) override;
     void focusInEvent(QFocusEvent *e) override;
 
 protected Q_SLOTS:
     void showContextMenu(const QPoint &pos);
     void toggleRepeat(bool checked);
     void toggleShowInternalCommands(bool checked);
     void flushPending();
     void clear();
 
     void handleSessionChanged(KDevelop::IDebugSession *session);
     void handleDebuggerStateChange(DBGStateFlags oldStatus, DBGStateFlags newStatus);
     void receivedInternalCommandStdout(const QString &line);
     void receivedUserCommandStdout(const QString &line);
     void receivedStdout(const QString &line, bool internal);
     void receivedStderr(const QString &line);
 
     void trySendCommand(QString cmd);
 private:
     QAction *m_actRepeat;
     QAction *m_actInterrupt;
     QAction *m_actShowInternal;
     QAction *m_actCmdEditor;
 
     QTextEdit *m_textView;
     QMenu *m_contextMenu;
     QToolBar *m_toolBar;
     KHistoryComboBox *m_cmdEditor;
 
     bool m_repeatLastCommand;
     bool m_showInternalCommands;
     bool m_cmdEditorHadFocus;
 
     /**
      * The output from user commands only and from all
      * commands. We keep it here so that if we switch
      * "Show internal commands" on, we can show previous
      * internal commands.
      */
     QStringList m_allOutput;
     QStringList m_userOutput;
 
     /**
      * For performance reasons, we don't immediately add new text
      * to QTExtEdit. Instead we add it to m_pendingOutput and
      * flush it on timer.
      */
     QString m_pendingOutput;
     QTimer m_updateTimer;
 
     QColor m_stdColor;
     QColor m_errorColor;
 
     int m_maxLines;
 
     QString m_alterPrompt;
 };
 
 } // end of namespace KDevMI
 
 #endif // DEBUGGERCONSOLEVIEW_H
diff --git a/debuggers/common/widgets/disassemblewidget.cpp b/debuggers/common/widgets/disassemblewidget.cpp
index ddf99a2311..672f035972 100644
--- a/debuggers/common/widgets/disassemblewidget.cpp
+++ b/debuggers/common/widgets/disassemblewidget.cpp
@@ -1,541 +1,539 @@
 /*
  * GDB Debugger Support
  *
  * Copyright 2000 John Birch <jbb@kdevelop.org>
  * Copyright 2006 Vladimir Prus  <ghost@cs.msu.su>
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2013 Vlas Puhov <vlas.puhov@mail.ru>
  *
  * 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 "disassemblewidget.h"
 
 #include "midebuggerplugin.h"
 #include "debuglog.h"
 #include "midebugsession.h"
 #include "mi/micommand.h"
 #include "registers/registersmanager.h"
 
 #include <debugger/interfaces/idebugsession.h>
 #include <interfaces/icore.h>
 #include <interfaces/idebugcontroller.h>
 #include <util/autoorientedsplitter.h>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
-#include <KTextEdit>
 
 #include <QShowEvent>
 #include <QHideEvent>
 #include <QAction>
 #include <QMenu>
-#include <QBoxLayout>
-#include <QComboBox>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
 #include <QPushButton>
 #include <QSplitter>
-#include <QHeaderView>
 #include <QFontDatabase>
 
 using namespace KDevMI;
 using namespace KDevMI::MI;
 
 
 SelectAddressDialog::SelectAddressDialog(QWidget* parent)
     : QDialog(parent)
 {
     m_ui.setupUi(this);
     setWindowTitle(i18n("Address Selector"));
 
     connect(m_ui.comboBox, &KHistoryComboBox::editTextChanged,
             this, &SelectAddressDialog::validateInput);
     connect(m_ui.comboBox, static_cast<void(KHistoryComboBox::*)()>(&KHistoryComboBox::returnPressed),
             this, &SelectAddressDialog::itemSelected);
 }
 
 QString SelectAddressDialog::address() const
 {
     return hasValidAddress() ? m_ui.comboBox->currentText() : QString();
 }
 
 bool SelectAddressDialog::hasValidAddress() const
 {
     bool ok;
     m_ui.comboBox->currentText().toLongLong(&ok, 16);
 
     return ok;
 }
 
 void SelectAddressDialog::updateOkState()
 {
     m_ui.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(hasValidAddress());
 }
 
 void SelectAddressDialog::validateInput()
 {
     updateOkState();
 }
 
 void SelectAddressDialog::itemSelected()
 {
     QString text = m_ui.comboBox->currentText();
     if( hasValidAddress() && m_ui.comboBox->findText(text) < 0 )
         m_ui.comboBox->addItem(text);
 }
 
 
 
 DisassembleWindow::DisassembleWindow(QWidget *parent, DisassembleWidget* widget)
     : QTreeWidget(parent)
 {
     /*context menu commands */{
     m_selectAddrAction = new QAction(i18n("Change &address"), this);
     m_selectAddrAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     connect(m_selectAddrAction, &QAction::triggered, widget, &DisassembleWidget::slotChangeAddress);
 
     m_jumpToLocation = new QAction(QIcon::fromTheme("debug-execute-to-cursor"), i18n("&Jump to Cursor"), this);
     m_jumpToLocation->setWhatsThis(i18n("Sets the execution pointer to the current cursor position."));
     connect(m_jumpToLocation,&QAction::triggered, widget, &DisassembleWidget::jumpToCursor);
 
     m_runUntilCursor = new QAction(QIcon::fromTheme("debug-run-cursor"), i18n("&Run to Cursor"), this);
     m_runUntilCursor->setWhatsThis(i18n("Continues execution until the cursor position is reached."));
     connect(m_runUntilCursor,&QAction::triggered, widget, &DisassembleWidget::runToCursor);
 
     m_disassemblyFlavorAtt = new QAction(i18n("&AT&&T"), this);
     m_disassemblyFlavorAtt->setToolTip(i18n("GDB will use the AT&T disassembly flavor (e.g. mov 0xc(%ebp),%eax)."));
     m_disassemblyFlavorAtt->setData(DisassemblyFlavorATT);
     m_disassemblyFlavorAtt->setCheckable(true);
 
     m_disassemblyFlavorIntel = new QAction(i18n("&Intel"), this);
     m_disassemblyFlavorIntel->setToolTip(i18n("GDB will use the Intel disassembly flavor (e.g. mov eax, DWORD PTR [ebp+0xc])."));
     m_disassemblyFlavorIntel->setData(DisassemblyFlavorIntel);
     m_disassemblyFlavorIntel->setCheckable(true);
 
     m_disassemblyFlavorActionGroup = new QActionGroup(this);
     m_disassemblyFlavorActionGroup->setExclusive(true);
     m_disassemblyFlavorActionGroup->addAction(m_disassemblyFlavorAtt);
     m_disassemblyFlavorActionGroup->addAction(m_disassemblyFlavorIntel);
     connect(m_disassemblyFlavorActionGroup, &QActionGroup::triggered, widget, &DisassembleWidget::setDisassemblyFlavor);
     }
 }
 
 void DisassembleWindow::setDisassemblyFlavor(DisassemblyFlavor flavor)
 {
     switch(flavor)
     {
     default:
     case DisassemblyFlavorUnknown:
         m_disassemblyFlavorAtt->setChecked(false);
         m_disassemblyFlavorIntel->setChecked(false);
         break;
     case DisassemblyFlavorATT:
         m_disassemblyFlavorAtt->setChecked(true);
         m_disassemblyFlavorIntel->setChecked(false);
         break;
     case DisassemblyFlavorIntel:
         m_disassemblyFlavorAtt->setChecked(false);
         m_disassemblyFlavorIntel->setChecked(true);
         break;
     }
 }
 
 void DisassembleWindow::contextMenuEvent(QContextMenuEvent *e)
 {
         QMenu popup(this);
         popup.addAction(m_selectAddrAction);
         popup.addAction(m_jumpToLocation);
         popup.addAction(m_runUntilCursor);
         QMenu* disassemblyFlavorMenu = popup.addMenu(i18n("Disassembly flavor"));
         disassemblyFlavorMenu->addAction(m_disassemblyFlavorAtt);
         disassemblyFlavorMenu->addAction(m_disassemblyFlavorIntel);
         popup.exec(e->globalPos());
 }
 /***************************************************************************/
 /***************************************************************************/
 /***************************************************************************/
 DisassembleWidget::DisassembleWidget(MIDebuggerPlugin* plugin, QWidget *parent)
         : QWidget(parent),
         active_(false),
         lower_(0),
         upper_(0),
         address_(0),
         m_splitter(new KDevelop::AutoOrientedSplitter(this))
 {
         QVBoxLayout* topLayout = new QVBoxLayout(this);
         topLayout->setMargin(0);
 
         QHBoxLayout* controlsLayout = new QHBoxLayout;
 
         topLayout->addLayout(controlsLayout);
 
 
     {   // initialize disasm/registers views
         topLayout->addWidget(m_splitter);
 
         //topLayout->setMargin(0);
 
         m_disassembleWindow = new DisassembleWindow(m_splitter, this);
 
         m_disassembleWindow->setWhatsThis(i18n("<b>Machine code display</b><p>"
                         "A machine code view into your running "
                         "executable with the current instruction "
                         "highlighted. You can step instruction by "
                         "instruction using the debuggers toolbar "
                         "buttons of \"step over\" instruction and "
                         "\"step into\" instruction."));
 
         m_disassembleWindow->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
         m_disassembleWindow->setSelectionMode(QTreeWidget::SingleSelection);
         m_disassembleWindow->setColumnCount(ColumnCount);
         m_disassembleWindow->setUniformRowHeights(true);
         m_disassembleWindow->setRootIsDecorated(false);
 
         m_disassembleWindow->setHeaderLabels(QStringList() << "" << i18n("Address") << i18n("Function") << i18n("Instruction"));
 
         m_splitter->setStretchFactor(0, 1);
         m_splitter->setContentsMargins(0, 0, 0, 0);
 
         m_registersManager = new RegistersManager(m_splitter);
 
         m_config = KSharedConfig::openConfig()->group("Disassemble/Registers View");
 
         QByteArray state = m_config.readEntry<QByteArray>("splitterState", QByteArray());
         if (!state.isEmpty()) {
             m_splitter->restoreState(state);
         }
 
     }
 
     setLayout(topLayout);
 
     setWindowIcon( QIcon::fromTheme("system-run", windowIcon()) );
     setWindowTitle(i18n("Disassemble/Registers View"));
 
     KDevelop::IDebugController* pDC=KDevelop::ICore::self()->debugController();
     Q_ASSERT(pDC);
 
     connect(pDC,
             &KDevelop::IDebugController::currentSessionChanged,
             this, &DisassembleWidget::currentSessionChanged);
 
     connect(plugin, &MIDebuggerPlugin::reset, this, &DisassembleWidget::slotDeactivate);
 
     m_dlg = new SelectAddressDialog(this);
 
     // show the data if debug session is active
     KDevelop::IDebugSession* pS = pDC->currentSession();
 
     currentSessionChanged(pS);
 
     if(pS && !pS->currentAddr().isEmpty())
         slotShowStepInSource(pS->currentUrl(), pS->currentLine(), pS->currentAddr());
 }
 
 void DisassembleWidget::jumpToCursor() {
     MIDebugSession *s = qobject_cast<MIDebugSession*>(KDevelop::ICore::
             self()->debugController()->currentSession());
     if (s && s->isRunning()) {
         QString address = m_disassembleWindow->selectedItems().at(0)->text(Address);
         s->jumpToMemoryAddress(address);
     }
 }
 
 void DisassembleWidget::runToCursor(){
     MIDebugSession *s = qobject_cast<MIDebugSession*>(KDevelop::ICore::
             self()->debugController()->currentSession());
     if (s && s->isRunning()) {
         QString address = m_disassembleWindow->selectedItems().at(0)->text(Address);
         s->runUntil(address);
     }
 }
 
 void DisassembleWidget::currentSessionChanged(KDevelop::IDebugSession* s)
 {
     MIDebugSession *session = qobject_cast<MIDebugSession*>(s);
 
     enableControls( session != nullptr ); // disable if session closed
 
     m_registersManager->setSession(session);
 
     if (session) {
         connect(session, &MIDebugSession::showStepInSource,
                 this, &DisassembleWidget::slotShowStepInSource);
         connect(session,&MIDebugSession::showStepInDisassemble,this, &DisassembleWidget::update);
     }
 }
 
 
 /***************************************************************************/
 
 DisassembleWidget::~DisassembleWidget()
 {
    m_config.writeEntry("splitterState", m_splitter->saveState());
 }
 
 /***************************************************************************/
 
 bool DisassembleWidget::displayCurrent()
 {
     if(address_ < lower_ || address_ > upper_) return false;
 
     bool bFound=false;
     for (int line=0; line < m_disassembleWindow->topLevelItemCount(); line++)
     {
         QTreeWidgetItem* item = m_disassembleWindow->topLevelItem(line);
         unsigned long address = item->text(Address).toULong(&ok,16);
 
         if (address == address_)
         {
             // put cursor at start of line and highlight the line
             m_disassembleWindow->setCurrentItem(item);
             static const QIcon icon = QIcon::fromTheme(QStringLiteral("go-next"));
             item->setIcon(Icon, icon);
             bFound = true;  // need to process all items to clear icons
         }
         else if(!item->icon(Icon).isNull()) item->setIcon(Icon, QIcon());
     }
 
     return bFound;
 }
 
 /***************************************************************************/
 
 void DisassembleWidget::slotActivate(bool activate)
 {
     qCDebug(DEBUGGERCOMMON) << "Disassemble widget active: " << activate;
 
     if (active_ != activate)
     {
         active_ = activate;
         if (active_)
         {
             updateDisassemblyFlavor();
             m_registersManager->updateRegisters();
             if (!displayCurrent())
                 disassembleMemoryRegion();
         }
     }
 }
 
 /***************************************************************************/
 
 void DisassembleWidget::slotShowStepInSource(const QUrl&, int,
         const QString& currentAddress)
 {
     update(currentAddress);
 }
 
 void DisassembleWidget::updateExecutionAddressHandler(const ResultRecord& r)
 {
     const Value& content = r["asm_insns"];
     const Value& pc = content[0];
     if( pc.hasField("address") ){
         QString addr = pc["address"].literal();
         address_ = addr.toULong(&ok,16);
 
         disassembleMemoryRegion(addr);
     }
 }
 
 /***************************************************************************/
 
 void DisassembleWidget::disassembleMemoryRegion(const QString& from, const QString& to)
 {
     MIDebugSession *s = qobject_cast<MIDebugSession*>(KDevelop::ICore::
             self()->debugController()->currentSession());
     if(!s || !s->isRunning()) return;
 
     //only get $pc
     if (from.isEmpty()){
         s->addCommand(DataDisassemble, "-s \"$pc\" -e \"$pc+1\" -- 0",
                       this, &DisassembleWidget::updateExecutionAddressHandler);
     }else{
 
         QString cmd = (to.isEmpty())?
         QString("-s %1 -e \"%1 + 256\" -- 0").arg(from ):
         QString("-s %1 -e %2+1 -- 0").arg(from).arg(to); // if both addr set
 
         s->addCommand(DataDisassemble, cmd,
                       this, &DisassembleWidget::disassembleMemoryHandler);
    }
 }
 
 /***************************************************************************/
 
 void DisassembleWidget::disassembleMemoryHandler(const ResultRecord& r)
 {
     const Value& content = r["asm_insns"];
     QString currentFunction;
 
     m_disassembleWindow->clear();
 
     for(int i = 0; i < content.size(); ++i)
     {
         const Value& line = content[i];
 
         QString addr, fct, offs, inst;
 
         if( line.hasField("address") )   addr = line["address"].literal();
         if( line.hasField("func-name") ) fct  = line["func-name"].literal();
         if( line.hasField("offset") )    offs = line["offset"].literal();
         if( line.hasField("inst") )      inst = line["inst"].literal();
 
         //We use offset at the same column where function is.
         if(currentFunction == fct){
             if(!fct.isEmpty()){
                 fct = QString("+") + offs;
             }
         }else { currentFunction = fct; }
 
         m_disassembleWindow->addTopLevelItem(new QTreeWidgetItem(m_disassembleWindow,
                                                                  QStringList() << QString() << addr << fct << inst));
 
         if (i == 0) {
             lower_ = addr.toULong(&ok,16);
         } else  if (i == content.size()-1) {
             upper_ = addr.toULong(&ok,16);
         }
     }
 
   displayCurrent();
 
   m_disassembleWindow->resizeColumnToContents(Icon);       // make Icon always visible
   m_disassembleWindow->resizeColumnToContents(Address);    // make entire address always visible
 }
 
 
 void DisassembleWidget::showEvent(QShowEvent*)
 {
     slotActivate(true);
 
     //it doesn't work for large names of functions
 //    for (int i = 0; i < m_disassembleWindow->model()->columnCount(); ++i)
 //        m_disassembleWindow->resizeColumnToContents(i);
 }
 
 void DisassembleWidget::hideEvent(QHideEvent*)
 {
     slotActivate(false);
 }
 
 void DisassembleWidget::slotDeactivate()
 {
     slotActivate(false);
 }
 
 void DisassembleWidget::enableControls(bool enabled)
 {
     m_disassembleWindow->setEnabled(enabled);
 }
 
 void DisassembleWidget::slotChangeAddress()
 {
     if(!m_dlg) return;
     m_dlg->updateOkState();
 
     if (!m_disassembleWindow->selectedItems().isEmpty()) {
         m_dlg->setAddress(m_disassembleWindow->selectedItems().first()->text(Address));
     }
 
     if (m_dlg->exec() == QDialog::Rejected)
         return;
 
     unsigned long addr = m_dlg->address().toULong(&ok,16);
 
     if (addr < lower_ || addr > upper_ || !displayCurrent())
         disassembleMemoryRegion(m_dlg->address());
 }
 
 void SelectAddressDialog::setAddress ( const QString& address )
 {
      m_ui.comboBox->setCurrentItem ( address, true );
 }
 
 void DisassembleWidget::update(const QString &address)
 {
     if (!active_) {
         return;
     }
 
     address_ = address.toULong(&ok, 16);
     if (!displayCurrent()) {
         disassembleMemoryRegion();
     }
     m_registersManager->updateRegisters();
 }
 
 void DisassembleWidget::setDisassemblyFlavor(QAction* action)
 {
     MIDebugSession* s = qobject_cast<MIDebugSession*>(KDevelop::ICore::
             self()->debugController()->currentSession());
     if(!s || !s->isRunning()) {
         return;
     }
 
     DisassemblyFlavor disassemblyFlavor = static_cast<DisassemblyFlavor>(action->data().toInt());
     QString cmd;
     switch(disassemblyFlavor)
     {
     default:
         // unknown flavor, do not build a GDB command
         break;
     case DisassemblyFlavorATT:
         cmd = QStringLiteral("disassembly-flavor att");
         break;
     case DisassemblyFlavorIntel:
         cmd = QStringLiteral("disassembly-flavor intel");
         break;
     }
     qCDebug(DEBUGGERCOMMON) << "Disassemble widget set " << cmd;
 
     if (!cmd.isEmpty()) {
         s->addCommand(GdbSet, cmd, this, &DisassembleWidget::setDisassemblyFlavorHandler);
     }
 }
 
 void DisassembleWidget::setDisassemblyFlavorHandler(const ResultRecord& r)
 {
     if (r.reason == "done" && active_) {
         disassembleMemoryRegion();
     }
 }
 
 void DisassembleWidget::updateDisassemblyFlavor()
 {
     MIDebugSession* s = qobject_cast<MIDebugSession*>(KDevelop::ICore::
             self()->debugController()->currentSession());
     if(!s || !s->isRunning()) {
         return;
     }
 
     s->addCommand(GdbShow, QStringLiteral("disassembly-flavor"), this, &DisassembleWidget::showDisassemblyFlavorHandler);
 }
 
 void DisassembleWidget::showDisassemblyFlavorHandler(const ResultRecord& r)
 {
     const Value& value = r["value"];
     qCDebug(DEBUGGERCOMMON) << "Disassemble widget disassembly flavor" << value.literal();
 
     DisassemblyFlavor disassemblyFlavor = DisassemblyFlavorUnknown;
     if (value.literal() == "att") {
         disassemblyFlavor = DisassemblyFlavorATT;
     } else if (value.literal() == "intel") {
         disassemblyFlavor = DisassemblyFlavorIntel;
     } else if (value.literal() == "default") {
         disassemblyFlavor = DisassemblyFlavorATT;
     }
     m_disassembleWindow->setDisassemblyFlavor(disassemblyFlavor);
 }
diff --git a/debuggers/gdb/debuggerplugin.h b/debuggers/gdb/debuggerplugin.h
index 1bd00603aa..c72981a014 100644
--- a/debuggers/gdb/debuggerplugin.h
+++ b/debuggers/gdb/debuggerplugin.h
@@ -1,93 +1,81 @@
 /*
  * GDB Debugger Support
  * Copyright 2016  Aetf <aetf@unlimitedcodeworks.xyz>
  *
  * 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/>.
  *
  */
 
 #ifndef _DEBUGGERPART_H_
 #define _DEBUGGERPART_H_
 
 #include "config.h"
 
-#include <QByteArray>
-#include <QLabel>
-#include <QtCore/QVariant>
+#include <QVariantList>
 
 #include <KConfigGroup>
 #include <KTextEditor/Cursor>
-#include <QUrl>
 
 #include <interfaces/iplugin.h>
 #include <interfaces/istatus.h>
 
 #include "midebuggerplugin.h"
 #include "debugsession.h"
 
-class QLabel;
-class QMenu;
-class QDBusInterface;
-class QSignalMapper;
-class ProcessWidget;
-
-class KToolBar;
-class QAction;
-
 class GdbLauncher;
 
 namespace KDevelop {
 class Context;
 class ProcessLineMaker;
 }
 
 namespace KDevMI {
 class DisassembleWidget;
 
 namespace GDB {
 class GDBOutputWidget;
 class MemoryViewerWidget;
 
 class CppDebuggerPlugin : public MIDebuggerPlugin
 {
     Q_OBJECT
 
 public:
     friend class DebugSession;
 
     explicit CppDebuggerPlugin(QObject *parent, const QVariantList & = QVariantList());
     ~CppDebuggerPlugin() override;
 
     void unload() override;
 
     DebugSession *createSession() override;
     void unloadToolviews() override;
     void setupToolviews() override;
 
 private:
     void setupExecutePlugin(KDevelop::IPlugin* plugin, bool load);
 
     DebuggerToolFactory<DisassembleWidget>* disassemblefactory;
     DebuggerToolFactory<GDBOutputWidget, CppDebuggerPlugin>* gdbfactory;
     DebuggerToolFactory<MemoryViewerWidget, CppDebuggerPlugin>* memoryviewerfactory;
     QHash<KDevelop::IPlugin*, GdbLauncher*> m_launchers;
 };
 
 } // end of namespace GDB
 } // end of namespace KDevMI
 
 #endif
diff --git a/debuggers/gdb/debuggertracingdialog.cpp b/debuggers/gdb/debuggertracingdialog.cpp
index ca01ebbe72..654c2385bf 100644
--- a/debuggers/gdb/debuggertracingdialog.cpp
+++ b/debuggers/gdb/debuggertracingdialog.cpp
@@ -1,127 +1,124 @@
 /*
  * Dialog for configuring breakpoint tracing.
  *
  * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
  *
  * 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 "debuggertracingdialog.h"
 #include "breakpoint.h"
 
-#include <QLabel>
-#include <QCheckBox>
-#include <QLineEdit>
 #include <keditlistbox.h>
 #include <kmessagebox.h>
 
 /* WARNING: this code was not yet ported to KDevelop4 and is unused, but is 
    intended to be ported.  */
 
 using namespace KDevMI::GDB;
 
 DebuggerTracingDialog
 ::DebuggerTracingDialog(Breakpoint* bp,
                         QWidget* parent)
 : QDialog(parent), bp_(bp)
 {
     setupUi(this);
 
     expressions->setButtons(KEditListBox::Add | KEditListBox::Remove);
 
     connect(enable, SIGNAL(stateChanged(int)),
             this, SLOT(enableOrDisable(int)));
 
     connect(enableCustomFormat, SIGNAL(stateChanged(int)),
             this, SLOT(enableOrDisableCustomFormat(int)));
 
     enable->setChecked(bp_->tracingEnabled());
     expressions->setItems(bp_->tracedExpressions());
     enableCustomFormat->setChecked(bp_->traceFormatStringEnabled());
     customFormat->setText(bp_->traceFormatString());
 
     enableOrDisable(enable->isChecked());
 
     // Go away if the breakpoint does
     connect(bp_, SIGNAL(destroyed(QObject*)), this, SLOT(reject()));
 }
 
 void DebuggerTracingDialog::enableOrDisable(int state)
 {
     bool enable = (state == Qt::Checked);
 
     expressionsLabel->setEnabled(enable);
     expressions->setEnabled(enable);
     enableCustomFormat->setEnabled(enable);
     customFormat->setEnabled(enable && enableCustomFormat->isChecked());
 }
 
 void DebuggerTracingDialog::enableOrDisableCustomFormat(int state)
 {
     customFormat->setEnabled(state == Qt::Checked);
 }
 
 void DebuggerTracingDialog::accept()
 {
     // Check that if we use format string,
     // the number of expression is not larget than the number of
     // format specifiers
     bool ok = true;
 
     if (enableCustomFormat->isChecked())
     {
         QString s = customFormat->text();
         int percent_count = 0;
         for (int i = 0; i < s.length(); ++i)
             if (s[i] == '%')
             {
                 if (i+1 < s.length())
                 {
                     if (s[i+1] != '%')
                     {
                         ++percent_count;
                     }
                     else
                     {
                         // Double %
                         ++i;
                     }
                 }
             }
 
         if (percent_count < expressions->items().count())
         {
             ok = false;
 
             KMessageBox::error(
                 this,
                 "<b>Not enough format specifiers</b>"
                 "<p>The number of format specifiers in the custom format "
                 "string is less than the number of expressions. Either remove "
                 "some expressions or edit the format string.",
                 "Not enough format specifiers");
         }
     }
 
     if (ok)
     {
         bp_->setTracingEnabled(enable->isChecked());
         bp_->setTracedExpressions(expressions->items());
         bp_->setTraceFormatStringEnabled(enableCustomFormat->isChecked());
         bp_->setTraceFormatString(customFormat->text());
         QDialog::accept();
     }
 }
diff --git a/debuggers/gdb/debuggertracingdialog.ui b/debuggers/gdb/debuggertracingdialog.ui
index f23e37fc1a..39583ab52a 100644
--- a/debuggers/gdb/debuggertracingdialog.ui
+++ b/debuggers/gdb/debuggertracingdialog.ui
@@ -1,129 +1,128 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>DebuggerTracingDialog</class>
  <widget class="QDialog" name="DebuggerTracingDialog">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>438</width>
     <height>409</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Tracing Configuration</string>
   </property>
   <layout class="QGridLayout">
    <item row="4" column="0" colspan="2">
     <widget class="QLineEdit" name="customFormat">
      <property name="enabled">
       <bool>false</bool>
      </property>
      <property name="whatsThis">
       <string>&lt;b&gt;Custom format string&lt;/b&gt;
 &lt;p&gt;Specify a C-style format string that will be used when printing the chosen expression. For example:
 &lt;p align=&quot;center&quot;&gt; &lt;tt&gt;Tracepoint 1: g = %d&lt;/tt&gt;&lt;/p&gt;
 If custom format string is not enabled, names and values of all expressions will be printed, using &quot;%d&quot; as format specifier for all expressions.</string>
      </property>
     </widget>
    </item>
    <item row="1" column="0" colspan="2">
     <widget class="QLabel" name="expressionsLabel">
      <property name="enabled">
       <bool>false</bool>
      </property>
      <property name="text">
       <string>Expressions to print:</string>
      </property>
      <property name="wordWrap">
       <bool>false</bool>
      </property>
     </widget>
    </item>
    <item row="0" column="0" colspan="2">
     <widget class="QCheckBox" name="enable">
      <property name="whatsThis">
       <string>&lt;b&gt;Enable tracing&lt;/b&gt;
 &lt;p&gt;Tracing is a mechanism to automatically print values of the chosen expressions and continue execution when breakpoint is hit. You can think of it as printf debugging that does not require modifying the source.&lt;/p&gt;</string>
      </property>
      <property name="text">
       <string>Enable tracing</string>
      </property>
     </widget>
    </item>
    <item row="3" column="0">
     <widget class="QCheckBox" name="enableCustomFormat">
      <property name="enabled">
       <bool>false</bool>
      </property>
      <property name="text">
       <string>Custom format string</string>
      </property>
     </widget>
    </item>
    <item row="2" column="0" colspan="2">
     <widget class="KEditListBox" name="expressions">
      <property name="enabled">
       <bool>false</bool>
      </property>
      <property name="title">
       <string/>
      </property>
     </widget>
    </item>
    <item row="5" column="0" colspan="2">
     <widget class="QDialogButtonBox" name="buttonBox">
      <property name="standardButtons">
       <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KEditListBox</class>
    <extends>QGroupBox</extends>
    <header>keditlistbox.h</header>
   </customwidget>
  </customwidgets>
  <includes>
   <include location="local">keditlistbox.h</include>
-  <include location="local">klineedit.h</include>
  </includes>
  <resources/>
  <connections>
   <connection>
    <sender>buttonBox</sender>
    <signal>accepted()</signal>
    <receiver>DebuggerTracingDialog</receiver>
    <slot>accept()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>307</x>
      <y>384</y>
     </hint>
     <hint type="destinationlabel">
      <x>63</x>
      <y>8</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>buttonBox</sender>
    <signal>rejected()</signal>
    <receiver>DebuggerTracingDialog</receiver>
    <slot>reject()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>400</x>
      <y>385</y>
     </hint>
     <hint type="destinationlabel">
      <x>342</x>
      <y>8</y>
     </hint>
    </hints>
   </connection>
  </connections>
 </ui>
diff --git a/debuggers/gdb/debugsession.h b/debuggers/gdb/debugsession.h
index 8016397f23..f5493ba1db 100644
--- a/debuggers/gdb/debugsession.h
+++ b/debuggers/gdb/debugsession.h
@@ -1,111 +1,105 @@
 /*
  * GDB Debugger Support
  *
  * Copyright 1999-2001 John Birch <jbb@kdevelop.org>
  * Copyright 2001 by Bernd Gehrmann <bernd@kdevelop.org>
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2009 Niko Sams <niko.sams@gmail.com>
  *
  * 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 GDB_DEBUGSESSION_H
 #define GDB_DEBUGSESSION_H
 
 #include "midebugsession.h"
 
 #include "dbgglobal.h"
 #include "gdb.h"
 #include "gdbbreakpointcontroller.h"
 #include "gdbframestackmodel.h"
 #include "variablecontroller.h"
 #include "mi/mi.h"
 
-
 #include <KConfigGroup>
 
-#include <QPointer>
-#include <QScopedPointer>
-
-
 class IExecutePlugin;
-class KToolBar;
 
 namespace KDevelop {
 class ProcessLineMaker;
 class ILaunchConfiguration;
 }
 
 namespace KDevMI {
 
 class STTY;
 
 namespace MI {
 class MICommand;
 class CommandQueue;
 }
 
 namespace GDB {
 
 class CppDebuggerPlugin;
 class DebugSession : public MIDebugSession
 {
     Q_OBJECT
 public:
     explicit DebugSession(CppDebuggerPlugin *plugin = nullptr);
     ~DebugSession() override;
 
     BreakpointController * breakpointController() const override;
     VariableController * variableController() const override;
     GdbFrameStackModel * frameStackModel() const override;
 
     /// FIXME: only used in unit test currently, potentially could
     /// be made a user configurable option.
     /// Whether turn off auto-disable ASLR when starting inferiors
     void setAutoDisableASLR(bool enable);
 
 protected:
     GdbDebugger *createDebugger() const override;
     void initializeDebugger() override;
 
     void configInferior(KDevelop::ILaunchConfiguration* cfg, IExecutePlugin* iexec, const QString&) override;
 
     bool execInferior(KDevelop::ILaunchConfiguration* cfg, IExecutePlugin*,
                       const QString& executable) override;
 
     bool loadCoreFile(KDevelop::ILaunchConfiguration *cfg,
                       const QString &debugee, const QString &corefile) override;
 
 private Q_SLOTS:
     void handleVersion(const QStringList& s);
     void handleFileExecAndSymbols(const MI::ResultRecord& r);
     void handleCoreFile(const MI::ResultRecord& r);
 
 private:
     friend class GdbTest;
 
     BreakpointController *m_breakpointController;
     VariableController *m_variableController;
     GdbFrameStackModel *m_frameStackModel;
 
     bool m_autoDisableASLR;
 };
 
 } // end of namespace GDB
 } // end of namespace KDevMI
 
 #endif
diff --git a/debuggers/gdb/gdb.cpp b/debuggers/gdb/gdb.cpp
index f3d24fc0f3..5462ab3340 100644
--- a/debuggers/gdb/gdb.cpp
+++ b/debuggers/gdb/gdb.cpp
@@ -1,99 +1,98 @@
 /*
  * Low level GDB interface.
  *
  * Copyright 1999 John Birch <jbb@kdevelop.org >
  * Copyright 2007 Vladimir Prus <ghost@cs.msu.su>
  * Copyright 2016 Aetf <aetf@unlimitedcodeworks.xyz>
  *
  * 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 "gdb.h"
 
 #include "dbgglobal.h"
 #include "debuglog.h"
 
-#include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KShell>
 
 #include <QApplication>
 #include <QFileInfo>
 #include <QUrl>
 
 using namespace KDevMI::GDB;
 using namespace KDevMI::MI;
 
 GdbDebugger::GdbDebugger(QObject* parent)
     : MIDebugger(parent)
 {
 }
 
 GdbDebugger::~GdbDebugger()
 {
 }
 
 bool GdbDebugger::start(KConfigGroup& config, const QStringList& extraArguments)
 {
     // FIXME: verify that default value leads to something sensible
     QUrl gdbUrl = config.readEntry(Config::GdbPathEntry, QUrl());
     if (gdbUrl.isEmpty()) {
         debuggerExecutable_ = QStringLiteral("gdb");
     } else {
         // FIXME: verify its' a local path.
         debuggerExecutable_ = gdbUrl.url(QUrl::PreferLocalFile | QUrl::StripTrailingSlash);
     }
 
     QStringList arguments = extraArguments;
     arguments << "--interpreter=mi2" << "-quiet";
 
     QUrl shell = config.readEntry(Config::DebuggerShellEntry, QUrl());
     if(!shell.isEmpty()) {
         qCDebug(DEBUGGERGDB) << "have shell" << shell;
         QString shell_without_args = shell.toLocalFile().split(QChar(' ')).first();
 
         QFileInfo info(shell_without_args);
         /*if( info.isRelative() )
         {
             shell_without_args = build_dir + "/" + shell_without_args;
             info.setFile( shell_without_args );
         }*/
         if(!info.exists()) {
             KMessageBox::information(
                 qApp->activeWindow(),
                 i18n("Could not locate the debugging shell '%1'.", shell_without_args ),
                 i18n("Debugging Shell Not Found") );
             return false;
         }
 
         arguments.insert(0, debuggerExecutable_);
         arguments.insert(0, shell.toLocalFile());
         process_->setShellCommand(KShell::joinArgs(arguments));
     } else {
         process_->setProgram(debuggerExecutable_, arguments);
     }
 
     process_->start();
 
     qCDebug(DEBUGGERGDB) << "Starting GDB with command" << shell.toLocalFile() + QLatin1Char(' ') + debuggerExecutable_
                            + QLatin1Char(' ') + arguments.join(QLatin1Char(' '));
     qCDebug(DEBUGGERGDB) << "GDB process pid:" << process_->pid();
     emit userCommandOutput(shell.toLocalFile() + QLatin1Char(' ') + debuggerExecutable_
                            + QLatin1Char(' ') + arguments.join(QLatin1Char(' ')) + QLatin1Char('\n'));
     return true;
 }
diff --git a/debuggers/gdb/gdbconfigpage.cpp b/debuggers/gdb/gdbconfigpage.cpp
index bd28bfd16e..fe65550349 100644
--- a/debuggers/gdb/gdbconfigpage.cpp
+++ b/debuggers/gdb/gdbconfigpage.cpp
@@ -1,193 +1,191 @@
 /*
 * GDB Debugger Support
 *
 * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
 * Copyright 2007 Hamish Rodda <rodda@kde.org>
 * 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 "gdbconfigpage.h"
 
 #include <QDebug>
 
 #include <kconfiggroup.h>
 #include <KLocalizedString>
-#include <kshell.h>
 #include <kmessagebox.h>
-#include <kparts/mainwindow.h>
 
 #include <outputview/outputmodel.h>
 #include <interfaces/idebugcontroller.h>
 #include <interfaces/ilaunchconfiguration.h>
 #include <interfaces/iproject.h>
 #include <project/interfaces/iprojectbuilder.h>
 #include <project/builderjob.h>
 #include <interfaces/iuicontroller.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <util/executecompositejob.h>
 #include <execute/iexecuteplugin.h>
 
 #include "dbgglobal.h"
 #include "debugsession.h"
 #include "debuggerplugin.h"
 #include "midebugjobs.h"
 
 #include "ui_gdbconfigpage.h"
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/icore.h>
 
 using namespace KDevelop;
 namespace Config = KDevMI::GDB::Config;
 
 GdbConfigPage::GdbConfigPage( QWidget* parent )
     : LaunchConfigurationPage(parent), ui( new Ui::GdbConfigPage )
 {
     ui->setupUi( this );
     ui->kcfg_gdbPath->setMode(KFile::File|KFile::ExistingOnly|KFile::LocalOnly);
     connect(ui->kcfg_asmDemangle, &QCheckBox::toggled, this, &GdbConfigPage::changed);
     connect(ui->kcfg_configGdbScript, &KUrlRequester::textChanged, this, &GdbConfigPage::changed);
     //connect(ui->kcfg_dbgTerminal, SIGNAL(toggled(bool)), this, SIGNAL(changed()));
     connect(ui->kcfg_debuggingShell, &KUrlRequester::textChanged, this, &GdbConfigPage::changed);
     connect(ui->kcfg_displayStaticMembers, &QCheckBox::toggled, this, &GdbConfigPage::changed);
     connect(ui->kcfg_gdbPath, &KUrlRequester::textChanged, this, &GdbConfigPage::changed);
     connect(ui->kcfg_runGdbScript, &KUrlRequester::textChanged, this, &GdbConfigPage::changed);
     connect(ui->kcfg_runShellScript, &KUrlRequester::textChanged, this, &GdbConfigPage::changed);
     connect(ui->kcfg_startWith, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &GdbConfigPage::changed);
 
     //Setup data info for combobox
     ui->kcfg_startWith->setItemData(0, "ApplicationOutput" );
     ui->kcfg_startWith->setItemData(1, "GdbConsole" );
     ui->kcfg_startWith->setItemData(2, "FrameStack" );
 }
 
 GdbConfigPage::~GdbConfigPage()
 {
     delete ui;
 }
 
 QIcon GdbConfigPage::icon() const
 {
     return QIcon();
 }
 
 void GdbConfigPage::loadFromConfiguration( const KConfigGroup& cfg, KDevelop::IProject*  )
 {
     bool block = blockSignals( true );
     ui->kcfg_gdbPath->setUrl( cfg.readEntry( Config::GdbPathEntry, QUrl() ) );
     ui->kcfg_debuggingShell->setUrl( cfg.readEntry( Config::DebuggerShellEntry, QUrl() ) );
     ui->kcfg_configGdbScript->setUrl( cfg.readEntry( Config::RemoteGdbConfigEntry, QUrl() ) );
     ui->kcfg_runShellScript->setUrl( cfg.readEntry( Config::RemoteGdbShellEntry, QUrl() ) );
     ui->kcfg_runGdbScript->setUrl( cfg.readEntry( Config::RemoteGdbRunEntry, QUrl() ) );
     ui->kcfg_displayStaticMembers->setChecked( cfg.readEntry( Config::StaticMembersEntry, false ) );
     ui->kcfg_asmDemangle->setChecked( cfg.readEntry( Config::DemangleNamesEntry, true) );
     ui->kcfg_startWith->setCurrentIndex( ui->kcfg_startWith->findData( cfg.readEntry( KDevMI::Config::StartWithEntry, "ApplicationOutput" ) ) );
     blockSignals( block );
 }
 
 void GdbConfigPage::saveToConfiguration( KConfigGroup cfg, KDevelop::IProject* ) const
 {
     cfg.writeEntry(Config::GdbPathEntry, ui->kcfg_gdbPath->url() );
     cfg.writeEntry(Config::DebuggerShellEntry, ui->kcfg_debuggingShell->url() );
     cfg.writeEntry(Config::RemoteGdbConfigEntry, ui->kcfg_configGdbScript->url() );
     cfg.writeEntry(Config::RemoteGdbShellEntry, ui->kcfg_runShellScript->url() );
     cfg.writeEntry(Config::RemoteGdbRunEntry, ui->kcfg_runGdbScript->url() );
     cfg.writeEntry(Config::StaticMembersEntry, ui->kcfg_displayStaticMembers->isChecked() );
     cfg.writeEntry(Config::DemangleNamesEntry, ui->kcfg_asmDemangle->isChecked() );
     cfg.writeEntry(KDevMI::Config::StartWithEntry, ui->kcfg_startWith->itemData( ui->kcfg_startWith->currentIndex() ).toString() );
 }
 
 QString GdbConfigPage::title() const
 {
     return i18n( "GDB Configuration" );
 }
 
 
 GdbLauncher::GdbLauncher( KDevMI::GDB::CppDebuggerPlugin* p, IExecutePlugin* execute )
     : m_plugin( p )
     , m_execute( execute )
 {
     factoryList << new GdbConfigPageFactory();
 }
 
 QList< KDevelop::LaunchConfigurationPageFactory* > GdbLauncher::configPages() const
 {
     return factoryList;
 }
 
 QString GdbLauncher::id()
 {
     return "gdb";
 }
 
 QString GdbLauncher::name() const
 {
     return i18n("GDB");
 }
 
 KJob* GdbLauncher::start(const QString& launchMode, KDevelop::ILaunchConfiguration* cfg)
 {
     Q_ASSERT(cfg);
     if( !cfg )
     {
         return nullptr;
     }
     if( launchMode == "debug" )
     {
         Q_ASSERT(m_execute);
         Q_ASSERT(m_plugin);
 
         if (KDevelop::ICore::self()->debugController()->currentSession() != nullptr) {
             KMessageBox::ButtonCode answer = KMessageBox::warningYesNo(
                 nullptr,
                 i18n("A program is already being debugged. Do you want to abort the "
                      "currently running debug session and continue with the launch?"));
             if (answer == KMessageBox::No)
                 return nullptr;
         }
 
         QList<KJob*> l;
         KJob* depjob = m_execute->dependencyJob(cfg);
         if( depjob )
         {
             l << depjob;
         }
         l << new KDevMI::MIDebugJob( m_plugin, cfg, m_execute );
         return new KDevelop::ExecuteCompositeJob( KDevelop::ICore::self()->runController(), l );
     }
     qWarning() << "Unknown launch mode" << launchMode << "for config:" << cfg->name();
     return nullptr;
 }
 
 QStringList GdbLauncher::supportedModes() const
 {
     return QStringList() << "debug";
 }
 
 QString GdbLauncher::description() const
 {
     return i18n("Executes a native application in GDB");
 }
 
 KDevelop::LaunchConfigurationPage* GdbConfigPageFactory::createWidget( QWidget* parent )
 {
     return new GdbConfigPage( parent );
 }
 
 
 
diff --git a/debuggers/gdb/gdboutputwidget.cpp b/debuggers/gdb/gdboutputwidget.cpp
index b0b02c2839..990342392e 100644
--- a/debuggers/gdb/gdboutputwidget.cpp
+++ b/debuggers/gdb/gdboutputwidget.cpp
@@ -1,459 +1,458 @@
 /*
  * GDB Debugger Support
  *
  * Copyright 2003 John Birch <jbb@kdevelop.org>
  * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
  * Copyright 2007 Hamish Rodda <rodda@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 "gdboutputwidget.h"
 
 #include "dbgglobal.h"
 #include "debuggerplugin.h"
 #include "debuglog.h"
 #include "debugsession.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/idebugcontroller.h>
 
 #include <KColorScheme>
-#include <KComboBox>
 #include <KHistoryComboBox>
 #include <KLocalizedString>
 
 #include <QApplication>
 #include <QClipboard>
 #include <QFocusEvent>
 #include <QMenu>
 #include <QLabel>
-#include <QLayout>
+#include <QVBoxLayout>
 #include <QToolButton>
 #include <QToolTip>
 #include <QScrollBar>
 #include <QScopedPointer>
 
 using namespace KDevMI::GDB;
 
 /***************************************************************************/
 
 GDBOutputWidget::GDBOutputWidget(CppDebuggerPlugin* plugin, QWidget *parent) :
     QWidget(parent),
     m_userGDBCmdEditor(nullptr),
     m_Interrupt(nullptr),
     m_gdbView(nullptr),
     showInternalCommands_(false),
     maxLines_(5000)
 {
     setWindowIcon(QIcon::fromTheme("dialog-scripts", windowIcon()));
     setWindowTitle(i18n("GDB Output"));
     setWhatsThis(i18n("<b>GDB output</b><p>"
                     "Shows all gdb commands being executed. "
                     "You can also issue any other gdb command while debugging.</p>"));
 
     m_gdbView = new OutputTextEdit(this);
     m_gdbView->setReadOnly(true);
 
     m_userGDBCmdEditor = new KHistoryComboBox (this);
 
     QLabel *label = new QLabel(i18n("&GDB cmd:"), this);
     label->setBuddy(m_userGDBCmdEditor);
 
     m_Interrupt = new QToolButton( this );
     m_Interrupt->setIcon ( QIcon::fromTheme( "media-playback-pause" ) );
     m_Interrupt->setToolTip( i18n ( "Pause execution of the app to enter gdb commands" ) );
 
     QVBoxLayout *topLayout = new QVBoxLayout(this);
     topLayout->addWidget(m_gdbView);
     topLayout->setStretchFactor(m_gdbView, 1);
     topLayout->setMargin(0);
 
     QBoxLayout *userGDBCmdEntry = new QHBoxLayout();
     userGDBCmdEntry->addWidget(label);
     userGDBCmdEntry->addWidget(m_userGDBCmdEditor);
     userGDBCmdEntry->setStretchFactor(m_userGDBCmdEditor, 1);
     userGDBCmdEntry->addWidget(m_Interrupt);
     topLayout->addLayout(userGDBCmdEntry);
 
     setLayout(topLayout);
 
     slotStateChanged(s_none, s_dbgNotStarted);
 
     connect(m_userGDBCmdEditor, static_cast<void(KHistoryComboBox::*)()>(&KHistoryComboBox::returnPressed),
             this, &GDBOutputWidget::slotGDBCmd);
     connect(m_Interrupt, &QToolButton::clicked, this, &GDBOutputWidget::breakInto);
 
     updateTimer_.setSingleShot(true);
     connect(&updateTimer_, &QTimer::timeout,
              this, &GDBOutputWidget::flushPending);
 
     connect(KDevelop::ICore::self()->debugController(), &KDevelop::IDebugController::currentSessionChanged,
             this, &GDBOutputWidget::currentSessionChanged);
 
     connect(plugin, &CppDebuggerPlugin::reset, this, &GDBOutputWidget::clear);
     connect(plugin, &CppDebuggerPlugin::raiseDebuggerConsoleViews, this, &GDBOutputWidget::requestRaise);
 
     currentSessionChanged(KDevelop::ICore::self()->debugController()->currentSession());
 
 //     TODO Port to KF5
 //     connect(KGlobalSettings::self(), SIGNAL(kdisplayPaletteChanged()),
 //             this, SLOT(updateColors()));
     updateColors();
 
 }
 
 void GDBOutputWidget::updateColors()
 {
     KColorScheme scheme(QPalette::Active);
     gdbColor_ = scheme.foreground(KColorScheme::LinkText).color();
     errorColor_ = scheme.foreground(KColorScheme::NegativeText).color();
 }
 
 void GDBOutputWidget::currentSessionChanged(KDevelop::IDebugSession* s)
 {
     if (!s)
         return;
 
     DebugSession *session = qobject_cast<DebugSession*>(s);
     if (!session)
         return;
 
      connect(this, &GDBOutputWidget::userGDBCmd,
              session, &DebugSession::addUserCommand);
      connect(this, &GDBOutputWidget::breakInto,
              session, &DebugSession::interruptDebugger);
 
      connect(session, &DebugSession::debuggerInternalCommandOutput,
              this, &GDBOutputWidget::slotInternalCommandStdout);
      connect(session, &DebugSession::debuggerUserCommandOutput,
              this, &GDBOutputWidget::slotUserCommandStdout);
      // debugger internal output, treat it as an internal command output
      connect(session, &DebugSession::debuggerInternalOutput,
              this, &GDBOutputWidget::slotInternalCommandStdout);
 
      connect(session, &DebugSession::debuggerStateChanged,
              this, &GDBOutputWidget::slotStateChanged);
 
      slotStateChanged(s_none, session->debuggerState());
 }
 
 
 /***************************************************************************/
 
 GDBOutputWidget::~GDBOutputWidget()
 {
     delete m_gdbView;
     delete m_userGDBCmdEditor;
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::clear()
 {
     if (m_gdbView)
         m_gdbView->clear();
 
     userCommands_.clear();
     allCommands_.clear();
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::slotInternalCommandStdout(const QString& line)
 {
     newStdoutLine(line, true);
 }
 
 void GDBOutputWidget::slotUserCommandStdout(const QString& line)
 {
     qCDebug(DEBUGGERGDB) << "User command stdout: " << line;
     newStdoutLine(line, false);
 }
 
 namespace {
     QString colorify(QString text, const QColor& color)
     {
         // Make sure the newline is at the end of the newly-added
         // string. This is so that we can always correctly remove
         // newline inside 'flushPending'.
         if (!text.endsWith('\n'))
           text.append('\n');
 
         if (text.endsWith('\n'))
         {
             text.remove(text.length()-1, 1);
         }
         text = "<font color=\"" + color.name() +  "\">" + text + "</font><br>";
         return text;
     }
 }
 
 
 void GDBOutputWidget::newStdoutLine(const QString& line,
                                     bool internal)
 {
     QString s = line.toHtmlEscaped();
     if (s.startsWith("(gdb)"))
     {
         s = colorify(s, gdbColor_);
     }
     else
         s.replace('\n', "<br>");
 
     allCommands_.append(s);
     allCommandsRaw_.append(line);
     trimList(allCommands_, maxLines_);
     trimList(allCommandsRaw_, maxLines_);
 
     if (!internal)
     {
         userCommands_.append(s);
         userCommandsRaw_.append(line);
         trimList(userCommands_, maxLines_);
         trimList(userCommandsRaw_, maxLines_);
     }
 
     if (!internal || showInternalCommands_)
         showLine(s);
 }
 
 
 void GDBOutputWidget::showLine(const QString& line)
 {
     pendingOutput_ += line;
 
     // To improve performance, we update the view after some delay.
     if (!updateTimer_.isActive())
     {
         updateTimer_.start(100);
     }
 }
 
 void GDBOutputWidget::trimList(QStringList& l, int max_size)
 {
     int length = l.count();
     if (length > max_size)
     {
         for(int to_delete = length - max_size; to_delete; --to_delete)
         {
             l.erase(l.begin());
         }
     }
 }
 
 void GDBOutputWidget::setShowInternalCommands(bool show)
 {
     if (show != showInternalCommands_)
     {
         showInternalCommands_ = show;
 
         // Set of strings to show changes, text edit still has old
         // set. Refresh.
         m_gdbView->clear();
         QStringList& newList =
             showInternalCommands_ ? allCommands_ : userCommands_;
 
         QStringList::iterator i = newList.begin(), e = newList.end();
         for(; i != e; ++i)
         {
             // Note that color formatting is already applied to '*i'.
             showLine(*i);
         }
     }
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::slotReceivedStderr(const char* line)
 {
     QString colored = colorify(QString::fromLatin1(line).toHtmlEscaped(), errorColor_);
     // Errors are shown inside user commands too.
     allCommands_.append(colored);
     trimList(allCommands_, maxLines_);
     userCommands_.append(colored);
     trimList(userCommands_, maxLines_);
 
     allCommandsRaw_.append(line);
     trimList(allCommandsRaw_, maxLines_);
     userCommandsRaw_.append(line);
     trimList(userCommandsRaw_, maxLines_);
 
     showLine(colored);
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::slotGDBCmd()
 {
     QString GDBCmd(m_userGDBCmdEditor->currentText());
     if (!GDBCmd.isEmpty())
     {
         m_userGDBCmdEditor->addToHistory(GDBCmd);
         m_userGDBCmdEditor->clearEditText();
         emit userGDBCmd(GDBCmd);
     }
 }
 
 void GDBOutputWidget::flushPending()
 {
     m_gdbView->setUpdatesEnabled(false);
 
     // QTextEdit adds newline after paragraph automatically.
     // So, remove trailing newline to avoid double newlines.
     if (pendingOutput_.endsWith('\n'))
         pendingOutput_.remove(pendingOutput_.length()-1, 1);
     Q_ASSERT(!pendingOutput_.endsWith('\n'));
 
     QTextDocument *document = m_gdbView->document();
     QTextCursor cursor(document);
     cursor.movePosition(QTextCursor::End);
     cursor.insertHtml(pendingOutput_);
     pendingOutput_ = "";
 
     m_gdbView->verticalScrollBar()->setValue(m_gdbView->verticalScrollBar()->maximum());
     m_gdbView->setUpdatesEnabled(true);
     m_gdbView->update();
     if (m_cmdEditorHadFocus) {
         m_userGDBCmdEditor->setFocus();
     }
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::slotStateChanged(KDevMI::DBGStateFlags oldStatus, KDevMI::DBGStateFlags newStatus)
 {
     Q_UNUSED(oldStatus)
     if (newStatus & s_dbgNotStarted)
     {
         m_Interrupt->setEnabled(false);
         m_userGDBCmdEditor->setEnabled(false);
         return;
     }
     else
     {
         m_Interrupt->setEnabled(true);
     }
 
     if (newStatus & s_dbgBusy)
     {
         if (m_userGDBCmdEditor->isEnabled()) {
             m_cmdEditorHadFocus = m_userGDBCmdEditor->hasFocus();
         }
         m_userGDBCmdEditor->setEnabled(false);
     }
     else
     {
         m_userGDBCmdEditor->setEnabled(true);
     }
 }
 
 /***************************************************************************/
 
 void GDBOutputWidget::focusInEvent(QFocusEvent */*e*/)
 {
     m_gdbView->verticalScrollBar()->setValue(m_gdbView->verticalScrollBar()->maximum());
     m_userGDBCmdEditor->setFocus();
 }
 
 void GDBOutputWidget::savePartialProjectSession()
 {
     KConfigGroup config(KSharedConfig::openConfig(), "GDB Debugger");
 
     config.writeEntry("showInternalCommands", showInternalCommands_);
 }
 
 void GDBOutputWidget::restorePartialProjectSession()
 {
     KConfigGroup config(KSharedConfig::openConfig(), "GDB Debugger");
 
     showInternalCommands_ = config.readEntry("showInternalCommands", false);
 }
 
 
 void GDBOutputWidget::contextMenuEvent(QContextMenuEvent * e)
 {
     QScopedPointer<QMenu> popup(new QMenu(this));
 
     QAction* action = popup->addAction(i18n("Show Internal Commands"),
                                this,
                                SLOT(toggleShowInternalCommands()));
 
     action->setCheckable(true);
     action->setChecked(showInternalCommands_);
     action->setWhatsThis(i18n(
             "Controls if commands issued internally by KDevelop "
             "will be shown or not.<br>"
             "This option will affect only future commands, it will not "
             "add or remove already issued commands from the view."));
 
     popup->addAction(i18n("Copy All"),
                       this,
                       SLOT(copyAll()));
 
     popup->exec(e->globalPos());
 }
 
 void GDBOutputWidget::copyAll()
 {
     /* See comments for allCommandRaw_ for explanations of
        this complex logic, as opposed to calling text(). */
     const QStringList& raw = showInternalCommands_ ?
         allCommandsRaw_ : userCommandsRaw_;
     QString text;
     for (int i = 0; i < raw.size(); ++i)
         text += raw.at(i);
 
     // Make sure the text is pastable both with Ctrl-C and with
     // middle click.
     QApplication::clipboard()->setText(text, QClipboard::Clipboard);
     QApplication::clipboard()->setText(text, QClipboard::Selection);
 }
 
 void GDBOutputWidget::toggleShowInternalCommands()
 {
     setShowInternalCommands(!showInternalCommands_);
 }
 
 
 OutputTextEdit::OutputTextEdit(GDBOutputWidget * parent)
     : QTextEdit(parent)
 {
 }
 
 void OutputTextEdit::contextMenuEvent(QContextMenuEvent * event)
 {
     QMenu* popup = createStandardContextMenu();
 
     QAction* action = popup->addAction(i18n("Show Internal Commands"),
                                parent(),
                                SLOT(toggleShowInternalCommands()));
 
     action->setCheckable(true);
     action->setChecked(static_cast<GDBOutputWidget*>(parent())->showInternalCommands());
     action->setWhatsThis(i18n(
             "Controls if commands issued internally by KDevelop "
             "will be shown or not.<br>"
             "This option will affect only future commands, it will not "
             "add or remove already issued commands from the view."));
 
     popup->exec(event->globalPos());
 }
 
 bool GDBOutputWidget::showInternalCommands() const
 {
     return showInternalCommands_;
 }
diff --git a/debuggers/gdb/gdboutputwidget.h b/debuggers/gdb/gdboutputwidget.h
index c63072adf6..ee6a119cba 100644
--- a/debuggers/gdb/gdboutputwidget.h
+++ b/debuggers/gdb/gdboutputwidget.h
@@ -1,156 +1,154 @@
 /*
  * GDB Debugger Support
  *
  * Copyright 2003 John Birch <jbb@kdevelop.org>
  * Copyright 2007 Hamish Rodda <rodda@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.
  */
 
 #ifndef _GDBOUTPUTWIDGET_H_
 #define _GDBOUTPUTWIDGET_H_
 
 #include "dbgglobal.h"
 
-#include <QFocusEvent>
 #include <QTextEdit>
 #include <QTimer>
 #include <QStringList>
 
 namespace KDevelop {
 class IDebugSession;
 }
 
 class KHistoryComboBox;
-class QTextEdit;
 class QToolButton;
 
 namespace KDevMI
 {
 namespace GDB
 {
 
 class GDBController;
 class CppDebuggerPlugin;
 
 class GDBOutputWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     explicit GDBOutputWidget(CppDebuggerPlugin* plugin, QWidget *parent=nullptr );
     ~GDBOutputWidget() override;
 
     void savePartialProjectSession();
     void restorePartialProjectSession();
 
     bool showInternalCommands() const;
 
 public Q_SLOTS:
     void clear();
 
     void slotInternalCommandStdout(const QString& line);
     void slotUserCommandStdout(const QString& line);
     void slotReceivedStderr(const char* line);
     void slotStateChanged(DBGStateFlags oldStatus, DBGStateFlags newStatus);
 
     void slotGDBCmd();
 
     void flushPending();
 
     void copyAll();
     void toggleShowInternalCommands();
 
 private Q_SLOTS:
     void currentSessionChanged(KDevelop::IDebugSession *session);
     void updateColors();
 
 protected:
     void focusInEvent(QFocusEvent *e) override;
     void contextMenuEvent(QContextMenuEvent* e) override;
 
 Q_SIGNALS:
     void requestRaise();
     void userGDBCmd(const QString &cmd);
     void breakInto();
 
 private:
     void newStdoutLine(const QString& line, bool internal);
 
     /** Arranges for 'line' to be shown to the user.
         Adds 'line' to pendingOutput_ and makes sure
         updateTimer_ is running. */
     void showLine(const QString& line);
 
     /** Makes 'l' no longer than 'max_size' by
         removing excessive elements from the top.
     */
     void trimList(QStringList& l, int max_size);
 
     GDBController* m_controller;
     KHistoryComboBox*  m_userGDBCmdEditor;
     QToolButton*    m_Interrupt;
     QTextEdit*      m_gdbView;
 
     bool m_cmdEditorHadFocus;
 
     void setShowInternalCommands(bool);
     friend class OutputText;
 
     /** The output from user commands only and from
         all commands. We keep it here so that if we switch
         "Show internal commands" on, we can show previous 
         internal commands. 
     */
     QStringList userCommands_, allCommands_;
     /** Same output, without any fancy formatting.  Keeping it
         here because I can't find any way to extract raw text,
         without formatting, out of QTextEdit except for
         selecting everything and calling 'copy()'. The latter
         approach is just ugly.  */
     QStringList userCommandsRaw_, allCommandsRaw_;
 
 
     /** For performance reasons, we don't immediately add new text
         to QTExtEdit. Instead we add it to pendingOutput_ and 
         flush it on timer.
     */
     QString pendingOutput_;
     QTimer updateTimer_;
 
     bool showInternalCommands_;
 
     int maxLines_;
 
     QColor gdbColor_;
     QColor errorColor_;
 };
 
 class OutputTextEdit : public QTextEdit
 {
     Q_OBJECT
 
 public:
     explicit OutputTextEdit(GDBOutputWidget* parent);
 
 protected:
     void contextMenuEvent(QContextMenuEvent* event) override;
 };
 
 } // end of namespace GDB
 } // end of namespace KDevMI
 
 #endif
diff --git a/debuggers/gdb/memviewdlg.cpp b/debuggers/gdb/memviewdlg.cpp
index b8539373e0..a75066262e 100644
--- a/debuggers/gdb/memviewdlg.cpp
+++ b/debuggers/gdb/memviewdlg.cpp
@@ -1,477 +1,476 @@
 /***************************************************************************
     begin                : Tue Oct 5 1999
     copyright            : (C) 1999 by John Birch
     email                : jbb@kdevelop.org
  **************************************************************************
  * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
  ***************************************************************************
  *                                                                         *
  *   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 "memviewdlg.h"
 
 #include "dbgglobal.h"
 #include "debugsession.h"
 #include "mi/micommand.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/idebugcontroller.h>
 
 #include <KLocalizedString>
 
 #include <Okteta/ByteArrayColumnView>
 #include <Okteta/ByteArrayModel>
 
 #include <QAction>
 #include <QContextMenuEvent>
 #include <QFormLayout>
 #include <QLineEdit>
 #include <QDialogButtonBox>
 #include <QMenu>
 #include <QPushButton>
 #include <QToolBox>
-#include <QVariant>
 #include <QVBoxLayout>
 
 #include <cctype>
 
 using KDevMI::MI::CommandType;
 
 namespace KDevMI
 {
 namespace GDB
 {
 
 /** Container for controls that select memory range.
      *
     The memory range selection is embedded into memory view widget,
     it's not a standalone dialog. However, we want to have easy way
     to hide/show all controls, so we group them in this class.
 */
 class MemoryRangeSelector : public QWidget
 {
     public:
         QLineEdit* startAddressLineEdit;
         QLineEdit* amountLineEdit;
         QPushButton* okButton;
         QPushButton* cancelButton;
 
     explicit MemoryRangeSelector(QWidget* parent)
     : QWidget(parent)
     {
         QVBoxLayout* l = new QVBoxLayout(this);
 
         // Form layout: labels + address field
         auto formLayout = new QFormLayout();
         l->addLayout(formLayout);
 
         startAddressLineEdit = new QLineEdit(this);
         formLayout->addRow(i18n("Start:"), startAddressLineEdit);
 
         amountLineEdit = new QLineEdit(this);
         formLayout->addRow(i18n("Amount:"), amountLineEdit);
 
         auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel, this);
         l->addWidget(buttonBox);
 
         okButton = buttonBox->button(QDialogButtonBox::Ok);
         cancelButton = buttonBox->button(QDialogButtonBox::Cancel);
 
         setLayout(l);
 
         connect(startAddressLineEdit, &QLineEdit::returnPressed, okButton, [this]() {
                 okButton->animateClick();
         });
 
         connect(amountLineEdit, &QLineEdit::returnPressed, okButton, [this]() {
                 okButton->animateClick();
         });
     }
 };
 
 MemoryView::MemoryView(QWidget* parent)
 : QWidget(parent),
     // New memory view can be created only when debugger is active,
     // so don't set s_appNotStarted here.
     m_memViewView(nullptr),
     m_debuggerState(0)
 {
     setWindowTitle(i18n("Memory view"));
     emit captionChanged(windowTitle());
 
     initWidget();
 
     if (isOk())
         slotEnableOrDisable();
 
     auto debugController = KDevelop::ICore::self()->debugController();
     Q_ASSERT(debugController);
 
     connect(debugController, &KDevelop::IDebugController::currentSessionChanged,
             this, &MemoryView::currentSessionChanged);
 }
 
 void MemoryView::currentSessionChanged(KDevelop::IDebugSession* s)
 {
     DebugSession *session = qobject_cast<DebugSession*>(s);
     if (!session) return;
 
     connect(session, &DebugSession::debuggerStateChanged,
              this, &MemoryView::slotStateChanged);
 }
 
 void MemoryView::slotStateChanged(DBGStateFlags oldState, DBGStateFlags newState)
 {
     Q_UNUSED(oldState);
     debuggerStateChanged(newState);
 }
 
 void MemoryView::initWidget()
 {
     QVBoxLayout *l = new QVBoxLayout(this);
     l->setContentsMargins(0, 0, 0, 0);
 
     m_memViewModel = new Okteta::ByteArrayModel(0, -1, this);
     m_memViewView = new Okteta::ByteArrayColumnView(this);
     m_memViewView->setByteArrayModel(m_memViewModel);
 
     m_memViewModel->setReadOnly(false);
     m_memViewView->setReadOnly(false);
     m_memViewView->setOverwriteMode(true);
     m_memViewView->setOverwriteOnly(true);
     m_memViewModel->setAutoDelete(false);
 
     m_memViewView->setValueCoding( Okteta::ByteArrayColumnView::HexadecimalCoding );
     m_memViewView->setNoOfGroupedBytes(4);
     m_memViewView->setByteSpacingWidth(2);
     m_memViewView->setGroupSpacingWidth(12);
     m_memViewView->setLayoutStyle(Okteta::AbstractByteArrayView::FullSizeLayoutStyle);
 
 
     m_memViewView->setShowsNonprinting(false);
     m_memViewView->setSubstituteChar('*');
 
     m_rangeSelector = new MemoryRangeSelector(this);
     l->addWidget(m_rangeSelector);
 
     connect(m_rangeSelector->okButton, &QPushButton::clicked,
             this, &MemoryView::slotChangeMemoryRange);
 
     connect(m_rangeSelector->cancelButton, &QPushButton::clicked,
             this, &MemoryView::slotHideRangeDialog);
 
     connect(m_rangeSelector->startAddressLineEdit,
             &QLineEdit::textChanged,
             this,
             &MemoryView::slotEnableOrDisable);
 
     connect(m_rangeSelector->amountLineEdit,
             &QLineEdit::textChanged,
             this,
             &MemoryView::slotEnableOrDisable);
 
     l->addWidget(m_memViewView);
 }
 
 void MemoryView::debuggerStateChanged(DBGStateFlags state)
 {
     if (isOk())
     {
         m_debuggerState = state;
         slotEnableOrDisable();
     }
 }
 
 
 void MemoryView::slotHideRangeDialog()
 {
     m_rangeSelector->hide();
 }
 
 void MemoryView::slotChangeMemoryRange()
 {
     DebugSession *session = qobject_cast<DebugSession*>(
         KDevelop::ICore::self()->debugController()->currentSession());
     if (!session) return;
 
     QString amount = m_rangeSelector->amountLineEdit->text();
     if(amount.isEmpty())
         amount = QString("sizeof(%1)").arg(m_rangeSelector->startAddressLineEdit->text());
 
     session->addCommand(new MI::ExpressionValueCommand(amount, this, &MemoryView::sizeComputed));
 }
 
 void MemoryView::sizeComputed(const QString& size)
 {
     DebugSession *session = qobject_cast<DebugSession*>(
         KDevelop::ICore::self()->debugController()->currentSession());
     if (!session) return;
 
     session->addCommand(MI::DataReadMemory,
             QString("%1 x 1 1 %2")
                 .arg(m_rangeSelector->startAddressLineEdit->text())
                 .arg(size),
             this,
             &MemoryView::memoryRead);
 }
 
 void MemoryView::memoryRead(const MI::ResultRecord& r)
 {
     const MI::Value& content = r["memory"][0]["data"];
     bool startStringConverted;
     m_memStart = r["addr"].literal().toULongLong(&startStringConverted, 16);
     m_memData.resize(content.size());
 
     m_memStartStr = m_rangeSelector->startAddressLineEdit->text();
     m_memAmountStr = m_rangeSelector->amountLineEdit->text();
 
     setWindowTitle(i18np("%2 (1 byte)","%2 (%1 bytes)",m_memData.size(),m_memStartStr));
     emit captionChanged(windowTitle());
 
     for(int i = 0; i < content.size(); ++i)
     {
         m_memData[i] = content[i].literal().toInt(0, 16);
     }
 
     m_memViewModel->setData(reinterpret_cast<Okteta::Byte*>(m_memData.data()), m_memData.size());
 
     slotHideRangeDialog();
 }
 
 
 void MemoryView::memoryEdited(int start, int end)
 {
     DebugSession *session = qobject_cast<DebugSession*>(
         KDevelop::ICore::self()->debugController()->currentSession());
     if (!session) return;
 
     for(int i = start; i <= end; ++i)
     {
         session->addCommand(MI::GdbSet,
                 QString("*(char*)(%1 + %2) = %3")
                     .arg(m_memStart)
                     .arg(i)
                     .arg(QString::number(m_memData[i])));
     }
 }
 
 void MemoryView::contextMenuEvent(QContextMenuEvent *e)
 {
     if (!isOk())
         return;
 
     QMenu menu;
 
     bool app_running = !(m_debuggerState & s_appNotStarted);
 
     QAction* reload = menu.addAction(i18n("&Reload"));
     reload->setIcon(QIcon::fromTheme("view-refresh"));
     reload->setEnabled(app_running && !m_memData.isEmpty() );
 
     QActionGroup *formatGroup = NULL;
     QActionGroup *groupingGroup = NULL;
     if (m_memViewModel && m_memViewView)
     {
         // make Format menu with action group
         QMenu *formatMenu = new QMenu(i18n("&Format"));
         formatGroup = new QActionGroup(formatMenu);
 
         QAction *binary = formatGroup->addAction(i18n("&Binary"));
         binary->setData(Okteta::ByteArrayColumnView::BinaryCoding);
         binary->setShortcut(Qt::Key_B);
         formatMenu->addAction(binary);
 
         QAction *octal = formatGroup->addAction(i18n("&Octal"));
         octal->setData(Okteta::ByteArrayColumnView::OctalCoding);
         octal->setShortcut(Qt::Key_O);
         formatMenu->addAction(octal);
 
         QAction *decimal = formatGroup->addAction(i18n("&Decimal"));
         decimal->setData(Okteta::ByteArrayColumnView::DecimalCoding);
         decimal->setShortcut(Qt::Key_D);
         formatMenu->addAction(decimal);
 
         QAction *hex = formatGroup->addAction(i18n("&Hexadecimal"));
         hex->setData(Okteta::ByteArrayColumnView::HexadecimalCoding);
         hex->setShortcut(Qt::Key_H);
         formatMenu->addAction(hex);
 
         foreach(QAction* act, formatGroup->actions())
         {
             act->setCheckable(true);
             act->setChecked(act->data().toInt() ==  m_memViewView->valueCoding());
             act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
         }
 
         menu.addMenu(formatMenu);
 
 
         // make Grouping menu with action group
         QMenu *groupingMenu = new QMenu(i18n("&Grouping"));
         groupingGroup = new QActionGroup(groupingMenu);
 
         QAction *group0 = groupingGroup->addAction(i18n("&0"));
         group0->setData(0);
         group0->setShortcut(Qt::Key_0);
         groupingMenu->addAction(group0);
 
         QAction *group1 = groupingGroup->addAction(i18n("&1"));
         group1->setData(1);
         group1->setShortcut(Qt::Key_1);
         groupingMenu->addAction(group1);
 
         QAction *group2 = groupingGroup->addAction(i18n("&2"));
         group2->setData(2);
         group2->setShortcut(Qt::Key_2);
         groupingMenu->addAction(group2);
 
         QAction *group4 = groupingGroup->addAction(i18n("&4"));
         group4->setData(4);
         group4->setShortcut(Qt::Key_4);
         groupingMenu->addAction(group4);
 
         QAction *group8 = groupingGroup->addAction(i18n("&8"));
         group8->setData(8);
         group8->setShortcut(Qt::Key_8);
         groupingMenu->addAction(group8);
 
         QAction *group16 = groupingGroup->addAction(i18n("1&6"));
         group16->setData(16);
         group16->setShortcut(Qt::Key_6);
         groupingMenu->addAction(group16);
 
         foreach(QAction* act, groupingGroup->actions())
         {
             act->setCheckable(true);
             act->setChecked(act->data().toInt() == m_memViewView->noOfGroupedBytes());
             act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
         }
 
         menu.addMenu(groupingMenu);
     }
 
     QAction* write = menu.addAction(i18n("Write changes"));
     write->setIcon(QIcon::fromTheme("document-save"));
     write->setEnabled(app_running && m_memViewView && m_memViewView->isModified());
 
     QAction* range = menu.addAction(i18n("Change memory range"));
     range->setEnabled(app_running && !m_rangeSelector->isVisible());
     range->setIcon(QIcon::fromTheme("document-edit"));
 
     QAction* close = menu.addAction(i18n("Close this view"));
     close->setIcon(QIcon::fromTheme("window-close"));
 
 
     QAction* result = menu.exec(e->globalPos());
 
 
     if (result == reload)
     {
         // We use m_memStart and m_memAmount stored in this,
         // not textual m_memStartStr and m_memAmountStr,
         // because program position might have changes and expressions
         // are no longer valid.
         DebugSession *session = qobject_cast<DebugSession*>(
             KDevelop::ICore::self()->debugController()->currentSession());
         if (session) {
             session->addCommand(MI::DataReadMemory,
                     QString("%1 x 1 1 %2").arg(m_memStart).arg(m_memData.size()),
                     this,
                     &MemoryView::memoryRead);
         }
     }
 
     if (result && formatGroup && formatGroup == result->actionGroup())
         m_memViewView->setValueCoding( (Okteta::ByteArrayColumnView::ValueCoding)result->data().toInt());
 
     if (result && groupingGroup && groupingGroup == result->actionGroup())
         m_memViewView->setNoOfGroupedBytes(result->data().toInt());
 
     if (result == write)
     {
         memoryEdited(0, m_memData.size());
         m_memViewView->setModified(false);
     }
 
     if (result == range)
     {
         m_rangeSelector->startAddressLineEdit->setText(m_memStartStr);
         m_rangeSelector->amountLineEdit->setText(m_memAmountStr);
 
         m_rangeSelector->show();
         m_rangeSelector->startAddressLineEdit->setFocus();
     }
 
     if (result == close)
         delete this;
 }
 
 bool MemoryView::isOk() const
 {
     return m_memViewView;
 }
 
 void MemoryView::slotEnableOrDisable()
 {
     bool app_started = !(m_debuggerState & s_appNotStarted);
 
     bool enabled_ = app_started && !m_rangeSelector->startAddressLineEdit->text().isEmpty();
 
     m_rangeSelector->okButton->setEnabled(enabled_);
 }
 
 
 MemoryViewerWidget::MemoryViewerWidget(CppDebuggerPlugin* /*plugin*/, QWidget* parent)
 : QWidget(parent)
 {
     setWindowIcon(QIcon::fromTheme("server-database", windowIcon()));
     setWindowTitle(i18n("Memory viewer"));
 
     QAction * newMemoryViewerAction = new QAction(this);
     newMemoryViewerAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     newMemoryViewerAction->setText(i18n("New memory viewer"));
     newMemoryViewerAction->setToolTip(i18nc("@info:tooltip", "Open a new memory viewer."));
     newMemoryViewerAction->setIcon(QIcon::fromTheme("window-new"));
     connect(newMemoryViewerAction, &QAction::triggered, this , &MemoryViewerWidget::slotAddMemoryView);
     addAction(newMemoryViewerAction);
 
     QVBoxLayout *l = new QVBoxLayout(this);
     l->setContentsMargins(0, 0, 0, 0);
 
     m_toolBox = new QToolBox(this);
     m_toolBox->setContentsMargins(0, 0, 0, 0);
     l->addWidget(m_toolBox);
 
     setLayout(l);
 
     // Start with one empty memory view.
     slotAddMemoryView();
 }
 
 void MemoryViewerWidget::slotAddMemoryView()
 {
     MemoryView* widget = new MemoryView(this);
     m_toolBox->addItem(widget, widget->windowTitle());
     m_toolBox->setCurrentIndex(m_toolBox->indexOf(widget));
 
     connect(widget, &MemoryView::captionChanged,
             this, &MemoryViewerWidget::slotChildCaptionChanged);
 }
 
 void MemoryViewerWidget::slotChildCaptionChanged(const QString& caption)
 {
     const QWidget* s = static_cast<const QWidget*>(sender());
     QWidget* ncs = const_cast<QWidget*>(s);
     QString cap = caption;
     // Prevent intepreting '&' as accelerator specifier.
     cap.replace('&', "&&");
     m_toolBox->setItemText(m_toolBox->indexOf(ncs), cap);
 }
 
 } // end of namespace GDB
 } // end of namespace KDevMI
diff --git a/debuggers/gdb/memviewdlg.h b/debuggers/gdb/memviewdlg.h
index 0b33afd851..25dcb05183 100644
--- a/debuggers/gdb/memviewdlg.h
+++ b/debuggers/gdb/memviewdlg.h
@@ -1,123 +1,121 @@
 /***************************************************************************
     begin                : Tue Oct 5 1999
     copyright            : (C) 1999 by John Birch
     email                : jbb@kdevelop.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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef MEMVIEW_H_
 #define MEMVIEW_H_
 
 #include "dbgglobal.h"
 #include "mi/mi.h"
 
-#include <QContextMenuEvent>
 #include <QWidget>
 
 namespace Okteta {
 class ByteArrayModel;
 }
 namespace Okteta {
 class ByteArrayColumnView;
 }
 
 namespace KDevelop {
 class IDebugSession;
 }
 
-class QLineEdit;
 class QToolBox;
 
 
 namespace KDevMI
 {
 namespace GDB
 {
     class CppDebuggerPlugin;
     class MemoryView;
     class GDBController;
     class MemoryRangeSelector;
 
     class MemoryViewerWidget : public QWidget
     {
         Q_OBJECT
     public:
         explicit MemoryViewerWidget(CppDebuggerPlugin* plugin, QWidget* parent = nullptr);
 
     public Q_SLOTS:
         /** Adds a new memory view. */
         void slotAddMemoryView();
 
     Q_SIGNALS:
         void requestRaise();
 
 
     private Q_SLOTS:
         void slotChildCaptionChanged(const QString& caption);
 
     private: // Data
         QToolBox* m_toolBox;
     };
 
     class MemoryView : public QWidget
     {
         Q_OBJECT
     public:
         explicit MemoryView(QWidget* parent);
 
         void debuggerStateChanged(DBGStateFlags state);
 
     Q_SIGNALS:
         void captionChanged(const QString& caption);
 
     private: // Callbacks
         void sizeComputed(const QString& value);
 
         void memoryRead(const MI::ResultRecord& r);
 
         // Returns true is we successfully created the memoryView, and
         // can work.
         bool isOk() const;
 
     private Q_SLOTS:
         void memoryEdited(int start, int end);
         /** Informs the view about changes in debugger state.
          *  Allows view to disable itself when debugger is not running. */
         void slotStateChanged(DBGStateFlags oldState, DBGStateFlags newState);
 
         /** Invoked when user has changed memory range.
             Gets memory for the new range. */
         void slotChangeMemoryRange();
         void slotHideRangeDialog();
         void slotEnableOrDisable();
 
     private: // QWidget overrides
         void contextMenuEvent(QContextMenuEvent* e) override;
 
         void initWidget();
 
         MemoryRangeSelector* m_rangeSelector;
         Okteta::ByteArrayModel *m_memViewModel;
         Okteta::ByteArrayColumnView *m_memViewView;
 
         quintptr m_memStart;
         QString m_memStartStr, m_memAmountStr;
         QByteArray m_memData;
         int m_debuggerState;
 
     private slots:
         void currentSessionChanged(KDevelop::IDebugSession* session);
     };
 
 } // end of namespace GDB
 } // end of namespace KDevMI
 
 #endif
diff --git a/debuggers/gdb/printers/tests/qlistcontainer.cpp b/debuggers/gdb/printers/tests/qlistcontainer.cpp
index 02fb6000de..12e38b3450 100644
--- a/debuggers/gdb/printers/tests/qlistcontainer.cpp
+++ b/debuggers/gdb/printers/tests/qlistcontainer.cpp
@@ -1,68 +1,67 @@
 #include <QList>
 #include <QVector>
 #include <QQueue>
 #include <QStack>
 #include <QLinkedList>
 #include <QSet>
 #include <QString>
-#include <QDebug>
 
 struct A {
     explicit A(const QString& _a = QString(), const QString& _b = QString(),
       int _c = -1, int _d = -1)
     : a(_a), b(_b), c(_c), d(_d)
     {}
     bool operator==(const A& other) const
     {
         return a == other.a && b == other.b && c == other.c && d == other.d;
     }
     QString a;
     QString b;
     int c;
     int d;
 };
 
 uint qHash(const A& a)
 {
     return qHash(a.a) + qHash(a.b);
 }
 
 template<template <typename> class Container>
 void doStuff()
 {
     Container<int> intList;
     intList << 10 << 20;
     intList << 30;
 
     Container<QString> stringList;
     stringList << "a" << "bc";
     stringList << "d";
 
     Container<A> structList;
     structList << A("a", "b", 100, -200);
     structList << A();
 
     Container<int*> pointerList;
     pointerList << new int(1) << new int(2);
     pointerList << new int(3);
     qDeleteAll(pointerList);
 
     Container<QPair<int, int> > pairList;
     pairList << QPair<int, int>(1, 2) << qMakePair(2, 3);
     pairList << qMakePair(4, 5);
 
     // don't leave context
     int i = 0;
     Q_UNUSED(i);
 }
 
 int main()
 {
     doStuff<QList>();
     doStuff<QVector>();
     doStuff<QQueue>();
     doStuff<QStack>();
     doStuff<QLinkedList>();
     doStuff<QSet>();
     return 0;
 }
diff --git a/debuggers/gdb/unittests/debugeeqt.cpp b/debuggers/gdb/unittests/debugeeqt.cpp
index 1ed0c92c3e..64af2dceac 100644
--- a/debuggers/gdb/unittests/debugeeqt.cpp
+++ b/debuggers/gdb/unittests/debugeeqt.cpp
@@ -1,31 +1,30 @@
 /*
    Copyright 2011 Niko Sams <niko.sams@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 #include <QDebug>
 #include <QtCore/QString>
-#include <QtCore/qpointer.h>
 
 int main()
 {
     qDebug();
     for(int i=0; i<10; ++i) {
         QString x("foobar");
         x += QString::number(i);
         qDebug() << x;
     }
     return 0;
 }
diff --git a/debuggers/lldb/debugsession.cpp b/debuggers/lldb/debugsession.cpp
index ae8ba118be..309aa739dc 100644
--- a/debuggers/lldb/debugsession.cpp
+++ b/debuggers/lldb/debugsession.cpp
@@ -1,500 +1,499 @@
 /*
  * LLDB Debugger Support
  * Copyright 2016  Aetf <aetf@unlimitedcodeworks.xyz>
  *
  * 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 "debugsession.h"
 
 #include "controllers/variable.h"
 #include "dbgglobal.h"
 #include "debuggerplugin.h"
 #include "debuglog.h"
 #include "lldbcommand.h"
 #include "mi/micommand.h"
 #include "stty.h"
 #include "stringhelpers.h"
 
 #include <debugger/breakpoint/breakpoint.h>
 #include <debugger/breakpoint/breakpointmodel.h>
 #include <execute/iexecuteplugin.h>
 #include <interfaces/icore.h>
 #include <interfaces/idebugcontroller.h>
 #include <interfaces/ilaunchconfiguration.h>
 #include <util/environmentprofilelist.h>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KShell>
 
 #include <QApplication>
 #include <QDir>
 #include <QFileInfo>
-#include <QProcess>
 #include <QStandardPaths>
 #include <QGuiApplication>
 
 using namespace KDevMI::LLDB;
 using namespace KDevMI::MI;
 using namespace KDevelop;
 
 struct ExecRunHandler : public MICommandHandler
 {
     explicit ExecRunHandler(DebugSession *session, int maxRetry = 5)
         : m_session(session)
         , m_remainRetry(maxRetry)
         , m_activeCommands(1)
     {
     }
 
     void handle(const ResultRecord& r) override
     {
         --m_activeCommands;
         if (r.reason == QLatin1String("error")) {
             if (r.hasField("msg")
                 && r["msg"].literal().contains("Invalid process during debug session")) {
                 // for some unknown reason, lldb-mi sometimes fails to start process
                 if (m_remainRetry && m_session) {
                     qCDebug(DEBUGGERLLDB) << "Retry starting";
                     --m_remainRetry;
                     // resend the command again.
                     ++m_activeCommands;
                     m_session->addCommand(ExecRun, QStringLiteral(""),
                                           this, // use *this as handler, so we can track error times
                                           CmdMaybeStartsRunning | CmdHandlesError);
                     return;
                 }
             }
             qCDebug(DEBUGGERLLDB) << "Failed to start inferior:"
                                   << "exceeded retry times or session become invalid";
             m_session->stopDebugger();
         }
         if (m_activeCommands == 0)
             delete this;
     }
 
     bool handlesError() override { return true; }
     bool autoDelete() override { return false; }
 
     QPointer<DebugSession> m_session;
     int m_remainRetry;
     int m_activeCommands;
 };
 
 DebugSession::DebugSession(LldbDebuggerPlugin *plugin)
     : MIDebugSession(plugin)
     , m_breakpointController(nullptr)
     , m_variableController(nullptr)
     , m_frameStackModel(nullptr)
     , m_formatterPath()
     , m_hasCorrectCLIOutput(false)
 {
     m_breakpointController = new BreakpointController(this);
     m_variableController = new VariableController(this);
     m_frameStackModel = new LldbFrameStackModel(this);
 
     if (m_plugin) m_plugin->setupToolviews();
 
     connect(this, &DebugSession::stateChanged, this, &DebugSession::handleSessionStateChange);
 }
 
 DebugSession::~DebugSession()
 {
     if (m_plugin) m_plugin->unloadToolviews();
 }
 
 BreakpointController *DebugSession::breakpointController() const
 {
     return m_breakpointController;
 }
 
 VariableController *DebugSession::variableController() const
 {
     return m_variableController;
 }
 
 LldbFrameStackModel *DebugSession::frameStackModel() const
 {
     return m_frameStackModel;
 }
 
 LldbDebugger *DebugSession::createDebugger() const
 {
     return new LldbDebugger;
 }
 
 MICommand *DebugSession::createCommand(MI::CommandType type, const QString& arguments,
                                        MI::CommandFlags flags) const
 {
     return new LldbCommand(type, arguments, flags);
 }
 
 MICommand *DebugSession::createUserCommand(const QString& cmd) const
 {
     if (m_hasCorrectCLIOutput)
         return MIDebugSession::createUserCommand(cmd);
     auto msg = i18n("Attempting to execute user command on unsupported LLDB version");
     emit debuggerInternalOutput(msg);
     qCDebug(DEBUGGERLLDB) << "Attempting user command on unsupported LLDB version";
     return nullptr;
 }
 
 void DebugSession::setFormatterPath(const QString &path)
 {
     m_formatterPath = path;
 }
 
 void DebugSession::initializeDebugger()
 {
     //addCommand(MI::EnableTimings, "yes");
 
     // Check version
     addCommand(new CliCommand(MI::NonMI, "version", this, &DebugSession::handleVersion));
 
     // load data formatter
     auto formatterPath = m_formatterPath;
     if (!QFileInfo(formatterPath).isFile()) {
         formatterPath = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                                "kdevlldb/formatters/all.py");
     }
     if (!formatterPath.isEmpty()) {
         addCommand(MI::NonMI, "command script import " + KShell::quoteArg(formatterPath));
     }
 
 
     // Treat char array as string
     addCommand(MI::GdbSet, "print char-array-as-string on");
 
     // set a larger term width.
     // TODO: set term-width to exact max column count in console view
     addCommand(MI::NonMI, "settings set term-width 1024");
 
     qCDebug(DEBUGGERLLDB) << "Initialized LLDB";
 }
 
 void DebugSession::configInferior(ILaunchConfiguration *cfg, IExecutePlugin *iexec, const QString &executable)
 {
     // Read Configuration values
     KConfigGroup grp = cfg->config();
 
     // Create target as early as possible, so we can do target specific configuration later
     QString filesymbols = Utils::quote(executable);
     bool remoteDebugging = grp.readEntry(Config::LldbRemoteDebuggingEntry, false);
     if (remoteDebugging) {
         auto connStr = grp.readEntry(Config::LldbRemoteServerEntry, QString());
         auto remoteDir = grp.readEntry(Config::LldbRemotePathEntry, QString());
         auto remoteExe = QDir(remoteDir).filePath(QFileInfo(executable).fileName());
 
         filesymbols += " -r " + Utils::quote(remoteExe);
 
         addCommand(MI::FileExecAndSymbols, filesymbols,
                    this, &DebugSession::handleFileExecAndSymbols,
                    CmdHandlesError);
 
         addCommand(MI::TargetSelect, "remote " + connStr,
                    this, &DebugSession::handleTargetSelect, CmdHandlesError);
 
         // ensure executable is on remote end
         addCommand(MI::NonMI, QStringLiteral("platform mkdir -v 755 %0").arg(Utils::quote(remoteDir)));
         addCommand(MI::NonMI, QStringLiteral("platform put-file %0 %1")
                               .arg(Utils::quote(executable), Utils::quote(remoteExe)));
     } else {
         addCommand(MI::FileExecAndSymbols, filesymbols,
                    this, &DebugSession::handleFileExecAndSymbols,
                    CmdHandlesError);
     }
 
     raiseEvent(connected_to_program);
 
     // Set the environment variables has effect only after target created
     const EnvironmentProfileList environmentProfiles(KSharedConfig::openConfig());
     QString envProfileName = iexec->environmentProfileName(cfg);
     if (envProfileName.isEmpty()) {
         qCWarning(DEBUGGERCOMMON) << i18n("No environment profile specified, looks like a broken "
                                           "configuration, please check run configuration '%1'. "
                                           "Using default environment profile.", cfg->name());
         envProfileName = environmentProfiles.defaultProfileName();
     }
     QStringList vars;
     for (auto it = environmentProfiles.variables(envProfileName).constBegin(),
               ite = environmentProfiles.variables(envProfileName).constEnd();
          it != ite; ++it) {
         vars.append(QStringLiteral("%0=%1").arg(it.key(), Utils::quote(it.value())));
     }
     // actually using lldb command 'settings set target.env-vars' which accepts multiple values
     addCommand(GdbSet, "environment " + vars.join(" "));
 
     // Break on start: can't use "-exec-run --start" because in lldb-mi
     // the inferior stops without any notification
     bool breakOnStart = grp.readEntry(KDevMI::Config::BreakOnStartEntry, false);
     if (breakOnStart) {
         BreakpointModel* m = ICore::self()->debugController()->breakpointModel();
         bool found = false;
         foreach (Breakpoint *b, m->breakpoints()) {
             if (b->location() == "main") {
                 found = true;
                 break;
             }
         }
         if (!found) {
             m->addCodeBreakpoint("main");
         }
     }
 
     // Needed so that breakpoint widget has a chance to insert breakpoints.
     // FIXME: a bit hacky, as we're really not ready for new commands.
     setDebuggerStateOn(s_dbgBusy);
     raiseEvent(debugger_ready);
 
     qCDebug(DEBUGGERGDB) << "Per inferior configuration done";
 }
 
 bool DebugSession::execInferior(ILaunchConfiguration *cfg, IExecutePlugin *, const QString &)
 {
     qCDebug(DEBUGGERGDB) << "Executing inferior";
 
     KConfigGroup grp = cfg->config();
 
     // Start inferior
     bool remoteDebugging = grp.readEntry(Config::LldbRemoteDebuggingEntry, false);
     QUrl configLldbScript = grp.readEntry(Config::LldbConfigScriptEntry, QUrl());
     addCommand(new SentinelCommand([this, remoteDebugging, configLldbScript]() {
         // setup inferior I/O redirection
         if (!remoteDebugging) {
             // FIXME: a hacky way to emulate tty setting on linux. Not sure if this provides all needed
             // functionalities of a pty. Should make this conditional on other platforms.
 
             // no need to quote, settings set takes 'raw' input
             addCommand(MI::NonMI, QStringLiteral("settings set target.input-path %0").arg(m_tty->getSlave()));
             addCommand(MI::NonMI, QStringLiteral("settings set target.output-path %0").arg(m_tty->getSlave()));
             addCommand(MI::NonMI, QStringLiteral("settings set target.error-path %0").arg(m_tty->getSlave()));
         } else {
             // what is the expected behavior for using external terminal when doing remote debugging?
         }
 
         // send breakpoints already in our breakpoint model to lldb
         auto bc = breakpointController();
         bc->initSendBreakpoints();
 
         qCDebug(DEBUGGERLLDB) << "Turn on delete duplicate mode";
         // turn on delete duplicate breakpoints model, so that breakpoints created by user command in
         // the script and returned as a =breakpoint-created notification won't get duplicated with the
         // one already in our model.
         // we will turn this model off once we first reach a paused state, and from that time on,
         // the user can create duplicated breakpoints using normal command.
         bc->setDeleteDuplicateBreakpoints(true);
         // run custom config script right before we starting the inferior,
         // so the user has the freedom to change everything.
         if (configLldbScript.isValid()) {
             addCommand(MI::NonMI, "command source -s 0 " + KShell::quoteArg(configLldbScript.toLocalFile()));
         }
 
         addCommand(MI::ExecRun, QString(), new ExecRunHandler(this),
                    CmdMaybeStartsRunning | CmdHandlesError);
     }, CmdMaybeStartsRunning));
     return true;
 }
 
 bool DebugSession::loadCoreFile(ILaunchConfiguration *,
                                 const QString &debugee, const QString &corefile)
 {
     addCommand(MI::FileExecAndSymbols, debugee,
                this, &DebugSession::handleFileExecAndSymbols,
                CmdHandlesError);
     raiseEvent(connected_to_program);
 
     addCommand(new CliCommand(NonMI, "target create -c " + Utils::quote(corefile),
                               this, &DebugSession::handleCoreFile,
                               CmdHandlesError));
     return true;
 }
 
 void DebugSession::interruptDebugger()
 {
     if (debuggerStateIsOn(s_dbgNotStarted|s_shuttingDown))
         return;
 
     addCommand(ExecInterrupt, QString(), CmdInterrupt);
     return;
 }
 
 void DebugSession::ensureDebuggerListening()
 {
     // lldb always uses async mode and prompt is always available.
     // no need to interrupt
     setDebuggerStateOff(s_dbgNotListening);
     // NOTE: there is actually a bug in lldb-mi that, when receiving SIGINT,
     // it would print '^done', which doesn't coresponds to any previous command.
     // This confuses our command queue.
 }
 
 void DebugSession::handleFileExecAndSymbols(const MI::ResultRecord& r)
 {
     if (r.reason == "error") {
         KMessageBox::error(
             qApp->activeWindow(),
             i18n("<b>Could not start debugger:</b><br />")+
             r["msg"].literal(),
             i18n("Startup error"));
         stopDebugger();
     }
 }
 
 void DebugSession::handleTargetSelect(const MI::ResultRecord& r)
 {
     if (r.reason == "error") {
         KMessageBox::error(qApp->activeWindow(),
             i18n("<b>Error connecting to remote target:</b><br />")+
             r["msg"].literal(),
             i18n("Startup error"));
         stopDebugger();
     }
 }
 
 void DebugSession::handleCoreFile(const QStringList &s)
 {
     qCDebug(DEBUGGERLLDB) << s;
     for (const auto &line : s) {
         if (line.startsWith("error:")) {
             KMessageBox::error(
                 qApp->activeWindow(),
                 i18n("<b>Failed to load core file</b>"
                 "<p>Debugger reported the following error:"
                 "<p><tt>%1",
                 s.join('\n')),
                 i18n("Startup error"));
             stopDebugger();
             return;
         }
     }
     // There's no "thread-group-started" notification from lldb-mi, so pretend we have received one.
     // see MIDebugSession::processNotification(const MI::AsyncRecord & async)
     setDebuggerStateOff(s_appNotStarted | s_programExited);
 
     setDebuggerStateOn(s_programExited | s_core);
 }
 
 void DebugSession::handleVersion(const QStringList& s)
 {
     m_hasCorrectCLIOutput = !s.isEmpty();
     if (!m_hasCorrectCLIOutput) {
         // No output from 'version' command. It's likely that
         // the lldb used is not patched for the CLI output
 
         if (!qobject_cast<QGuiApplication*>(qApp))  {
             //for unittest
             qFatal("You need a graphical application.");
         }
 
         auto ans = KMessageBox::warningYesNo(
             qApp->activeWindow(),
             i18n("<b>Your lldb-mi version is unsupported, as it lacks an essential patch.</b><br/>"
                  "See https://llvm.org/bugs/show_bug.cgi?id=28026 for more information.<br/>"
                  "Debugger console will be disabled to prevent crash.<br/>"
                  "Do you want to continue?"),
             i18n("LLDB Version Unsupported"),
             KStandardGuiItem::yes(),
             KStandardGuiItem::no(),
             "unsupported-lldb-debugger");
         if (ans == KMessageBox::ButtonCode::No) {
             programFinished("Stopped because of unsupported LLDB version");
             stopDebugger();
         }
         return;
     }
 
     qCDebug(DEBUGGERLLDB) << s.first();
 
 // minimal version is 3.8.1
 #ifdef Q_OS_OSX
     QRegularExpression rx("^lldb-(\\d+).(\\d+).(\\d+)\\b", QRegularExpression::MultilineOption);
     // lldb 3.8.1 reports version 350.99.0 on OS X
     const int min_ver[] = {350, 99, 0};
 #else
     QRegularExpression rx("^lldb version (\\d+).(\\d+).(\\d+)\\b", QRegularExpression::MultilineOption);
     const int min_ver[] = {3, 8, 1};
 #endif
 
     auto match = rx.match(s.first());
     int version[] = {0, 0, 0};
     if (match.hasMatch()) {
         for (int i = 0; i != 3; ++i) {
             version[i] = match.captured(i+1).toInt();
         }
     }
 
     bool ok = true;
     for (int i = 0; i < 3; ++i) {
         if (version[i] < min_ver[i]) {
             ok = false;
             break;
         } else if (version[i] > min_ver[i]) {
             ok = true;
             break;
         }
     }
 
     if (!ok) {
         if (!qobject_cast<QGuiApplication*>(qApp))  {
             //for unittest
             qFatal("You need a graphical application.");
         }
 
         KMessageBox::error(
             qApp->activeWindow(),
             i18n("<b>You need lldb-mi from LLDB 3.8.1 or higher.</b><br />"
             "You are using: %1", s.first()),
             i18n("LLDB Error"));
         stopDebugger();
     }
 }
 
 void DebugSession::updateAllVariables()
 {
     // FIXME: this is only a workaround for lldb-mi doesn't provide -var-update changelist
     // for variables that have a python synthetic provider. Remove this after this is fixed
     // in the upstream.
 
     // re-fetch all toplevel variables, as -var-update doesn't work with data formatter
     // we have to pick out top level variables first, as refetching will delete child
     // variables.
     QList<LldbVariable*> toplevels;
     for (auto it = m_allVariables.begin(), ite = m_allVariables.end(); it != ite; ++it) {
         LldbVariable *var = qobject_cast<LldbVariable*>(it.value());
         if (var->topLevel()) {
             toplevels << var;
         }
     }
 
     for (auto var : toplevels) {
         var->refetch();
     }
 }
 
 void DebugSession::handleSessionStateChange(IDebugSession::DebuggerState state)
 {
     if (state == IDebugSession::PausedState) {
         // session is paused, the user can input any commands now.
         // Turn off delete duplicate breakpoints mode, as the user
         // may intentionaly want to do this.
         qCDebug(DEBUGGERLLDB) << "Turn off delete duplicate mode";
         breakpointController()->setDeleteDuplicateBreakpoints(false);
     }
 }
diff --git a/debuggers/lldb/unittests/debugees/debugeeqt.cpp b/debuggers/lldb/unittests/debugees/debugeeqt.cpp
index 1ed0c92c3e..64af2dceac 100644
--- a/debuggers/lldb/unittests/debugees/debugeeqt.cpp
+++ b/debuggers/lldb/unittests/debugees/debugeeqt.cpp
@@ -1,31 +1,30 @@
 /*
    Copyright 2011 Niko Sams <niko.sams@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 #include <QDebug>
 #include <QtCore/QString>
-#include <QtCore/qpointer.h>
 
 int main()
 {
     qDebug();
     for(int i=0; i<10; ++i) {
         QString x("foobar");
         x += QString::number(i);
         qDebug() << x;
     }
     return 0;
 }
diff --git a/debuggers/lldb/unittests/test_lldbformatters.cpp b/debuggers/lldb/unittests/test_lldbformatters.cpp
index dff51489fb..ceb85242f0 100644
--- a/debuggers/lldb/unittests/test_lldbformatters.cpp
+++ b/debuggers/lldb/unittests/test_lldbformatters.cpp
@@ -1,1008 +1,1007 @@
 /*
  * Unit tests for LLDB debugger plugin
  * Copyright 2016  Aetf <aetf@unlimitedcodeworks.xyz>
  *
  * 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 "test_lldbformatters.h"
 
 #include "controllers/variable.h"
 #include "controllers/variablecontroller.h"
 #include "debugsession.h"
 #include "stringhelpers.h"
 #include "testhelper.h"
 
 #include <execute/iexecuteplugin.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/ilaunchconfiguration.h>
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 #include <QDebug>
-#include <QRegularExpression>
 #include <QString>
 #include <QTest>
 #include <QUrl>
 
 #include <algorithm>
 #include <vector>
 
 #define WAIT_FOR_STATE(session, state) \
     do { if (!KDevMI::LLDB::waitForState((session), (state), __FILE__, __LINE__)) return; } while (0)
 
 #define WAIT_FOR_STATE_AND_IDLE(session, state) \
     do { if (!KDevMI::LLDB::waitForState((session), (state), __FILE__, __LINE__, true)) return; } while (0)
 
 #define WAIT_FOR_A_WHILE_AND_IDLE(session, ms) \
     do { if (!KDevMI::LLDB::waitForAWhile((session), (ms), __FILE__, __LINE__)) return; \
          if (!KDevMI::LLDB::waitForState((session), DebugSession::PausedState, __FILE__, __LINE__, true)) \
              return; \
     } while (0)
 
 #define WAIT_FOR(session, condition) \
     do { \
         KDevMI::LLDB::TestWaiter w((session), #condition, __FILE__, __LINE__); \
         while (w.waitUnless((condition))) /* nothing */ ; \
     } while(0)
 
 #define COMPARE_DATA(index, expected) \
     do { if (!KDevMI::LLDB::compareData((index), (expected), __FILE__, __LINE__)) return; } while (0)
 
 #define VERIFY_LOCAL(row, name, summary, children) \
     do { \
         if (!verifyVariable((row), (name), (summary), (children), __FILE__, __LINE__)) \
             return; \
     } while (0)
 
 #define VERIFY_WATCH(row, name, summary, children) \
     do { \
         if (!verifyVariable((row), (name), (summary), (children), __FILE__, __LINE__, false)) \
             return; \
     } while (0)
 
 #define findSourceFile(name) \
     findSourceFile(__FILE__, (name))
 
 using namespace KDevelop;
 using namespace KDevMI::LLDB;
 
 class TestLaunchConfiguration : public ILaunchConfiguration
 {
 public:
     explicit TestLaunchConfiguration(const QString& executable,
                             const QUrl& workingDirectory = QUrl()) {
         auto execPath = findExecutable(executable);
         qDebug() << "FIND" << execPath;
         c = new KConfig();
         c->deleteGroup("launch");
         cfg = c->group("launch");
         cfg.writeEntry("isExecutable", true);
         cfg.writeEntry("Executable", execPath);
         cfg.writeEntry("Working Directory", workingDirectory);
     }
     ~TestLaunchConfiguration() override {
         delete c;
     }
     const KConfigGroup config() const override { return cfg; }
     KConfigGroup config() override { return cfg; };
     QString name() const override { return QString("Test-Launch"); }
     KDevelop::IProject* project() const override { return nullptr; }
     KDevelop::LaunchConfigurationType* type() const override { return nullptr; }
 
     KConfig *rootConfig() { return c; }
 private:
     KConfigGroup cfg;
     KConfig *c;
 };
 
 class TestDebugSession : public DebugSession
 {
     Q_OBJECT
 public:
     TestDebugSession() : DebugSession()
     {
         setSourceInitFile(false);
         setFormatterPath(findSourceFile("../formatters/all.py"));
 
         KDevelop::ICore::self()->debugController()->addSession(this);
 
         variableController()->setAutoUpdate(IVariableController::UpdateLocals);
     }
 };
 
 VariableCollection *LldbFormattersTest::variableCollection()
 {
     return m_core->debugController()->variableCollection();
 }
 
 QModelIndex LldbFormattersTest::watchVariableIndexAt(int i, int col)
 {
     auto watchRoot = variableCollection()->indexForItem(variableCollection()->watches(), 0);
     return variableCollection()->index(i, col, watchRoot);
 }
 
 QModelIndex LldbFormattersTest::localVariableIndexAt(int i, int col)
 {
     auto localRoot = variableCollection()->indexForItem(variableCollection()->locals(), 0);
     return variableCollection()->index(i, col, localRoot);
 }
 
 // Note: line is zero-based
 KDevelop::Breakpoint* LldbFormattersTest::addCodeBreakpoint(const QUrl& location, int line)
 {
     return m_core->debugController()->breakpointModel()->addCodeBreakpoint(location, line);
 }
 
 // Called before the first testfunction is executed
 void LldbFormattersTest::initTestCase()
 {
     AutoTestShell::init();
     m_core = TestCore::initialize(Core::NoUi);
 
     m_iface = m_core->pluginController()
                 ->pluginForExtension("org.kdevelop.IExecutePlugin", "kdevexecute")
                 ->extension<IExecutePlugin>();
     Q_ASSERT(m_iface);
 }
 
 // Called after the last testfunction was executed
 void LldbFormattersTest::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 // Called before each testfunction is executed
 void LldbFormattersTest::init()
 {
     //remove all breakpoints - so we can set our own in the test
     KConfigGroup bpCfg = KSharedConfig::openConfig()->group("breakpoints");
     bpCfg.writeEntry("number", 0);
     bpCfg.sync();
 
     auto count = m_core->debugController()->breakpointModel()->rowCount();
     m_core->debugController()->breakpointModel()->removeRows(0, count);
 
     while (variableCollection()->watches()->childCount() > 0) {
         auto idx = watchVariableIndexAt(0);
         auto var = dynamic_cast<LldbVariable*>(variableCollection()->itemForIndex(idx));
         if (!var) break;
         var->die();
     }
 
     m_session = new TestDebugSession;
 }
 
 void LldbFormattersTest::cleanup()
 {
     // Called after every testfunction
     if (m_session)
         m_session->stopDebugger();
     WAIT_FOR_STATE(m_session, DebugSession::EndedState);
     m_session.clear();
 }
 
 bool LldbFormattersTest::verifyVariable(int index, const QString &name,
                                         const QString &expectedSummary,
                                         QStringList expectedChildren,
                                         const char *file, int line,
                                         bool isLocal, bool useRE, bool unordered)
 {
     QList<QPair<QString, QString>> childrenPairs;
     childrenPairs.reserve(expectedChildren.size());
     if (unordered) {
         qDebug() << "useRE set to true when unordered = true";
         useRE = true;
         expectedChildren.sort();
         for (auto c : expectedChildren) {
             childrenPairs << qMakePair(QStringLiteral(R"(^\[\d+\]$)"), c);
         }
     } else {
         for (int i = 0; i != expectedChildren.size(); ++i) {
             childrenPairs << qMakePair(QStringLiteral("[%0]").arg(i), expectedChildren[i]);
         }
     }
     return verifyVariable(index, name, expectedSummary, childrenPairs, file, line, isLocal, useRE, unordered);
 }
 
 bool LldbFormattersTest::verifyVariable(int index, const QString &name,
                                         const QString &expectedSummary,
                                         QList<QPair<QString, QString>> expectedChildren,
                                         const char *file, int line,
                                         bool isLocal, bool useRE, bool unordered)
 {
     QModelIndex varIdx, summaryIdx;
     if (isLocal) {
         varIdx = localVariableIndexAt(index, 0);
         summaryIdx = localVariableIndexAt(index, 1);
     } else {
         varIdx = watchVariableIndexAt(index, 0);
         summaryIdx = watchVariableIndexAt(index, 1);
     }
 
     if (!compareData(varIdx, name, file, line)) {
         return false;
     }
     if (!compareData(summaryIdx, expectedSummary, file, line, useRE)) {
         return false;
     }
 
     // fetch all children
     auto var = variableCollection()->itemForIndex(varIdx);
     auto childCount = 0;
     while (childCount != variableCollection()->rowCount(varIdx)) {
         childCount = variableCollection()->rowCount(varIdx);
         var->fetchMoreChildren();
         if (!waitForAWhile(m_session, 50, file, line))
             return false;
     }
     if (childCount != expectedChildren.length()) {
         QTest::qFail(qPrintable(QString("'%0' didn't match expected '%1' in %2:%3")
                                 .arg(childCount).arg(expectedChildren.length()).arg(file).arg(line)),
                      file, line);
         return false;
     }
 
     QVector<int> theOrder;
     theOrder.reserve(childCount);
     for (int i = 0; i != childCount; ++i) {
         theOrder.push_back(i);
     }
     if (unordered) {
         qDebug() << "actual list sorted for unordered compare";
         std::sort(theOrder.begin(), theOrder.end(), [&](int a, int b){
             auto indexA = variableCollection()->index(a, 1, varIdx);
             auto indexB = variableCollection()->index(b, 1, varIdx);
             return indexA.model()->data(indexA, Qt::DisplayRole).toString()
                 < indexB.model()->data(indexB, Qt::DisplayRole).toString();
         });
         std::sort(expectedChildren.begin(), expectedChildren.end(),
                   [](const QPair<QString, QString> &a, const QPair<QString, QString> &b){
             return a.second < b.second;
         });
         qDebug() << "sorted actual order" << theOrder;
         qDebug() << "sorted expectedChildren" << expectedChildren;
     }
 
     for (int i = 0; i != childCount; ++i) {
         if (!compareData(variableCollection()->index(theOrder[i], 0, varIdx),
                          expectedChildren[i].first, file, line, useRE)) {
             return false;
         }
 
         if (!compareData(variableCollection()->index(theOrder[i], 1, varIdx),
                          expectedChildren[i].second, file, line, useRE)) {
             return false;
         }
     }
     return true;
 }
 
 void LldbFormattersTest::testQChar()
 {
     TestLaunchConfiguration cfg("lldb_qchar");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qchar.cpp")), 4);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     QList<QPair<QString, QString>> children;
     children << qMakePair(QStringLiteral("ucs"), QStringLiteral("107"));
 
     VERIFY_LOCAL(0, "c", "'k'", children);
 }
 
 void LldbFormattersTest::testQString()
 {
     TestLaunchConfiguration cfg("lldb_qstring");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qstring.cpp")), 4);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     QString expected = QString::fromUtf8("test最后一个不是特殊字符'\"\\u6211");
     QStringList children;
     for (auto ch : expected) {
         children << Utils::quote(ch, '\'');
     }
 
     VERIFY_LOCAL(0, "s", Utils::quote(expected), children);
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     QCOMPARE(m_session->currentLine(), 5);
 
     expected.append("x");
     children << "'x'";
 
     VERIFY_LOCAL(0, "s", Utils::quote(expected), children);
 
     m_session->run();
     WAIT_FOR_STATE(m_session, DebugSession::EndedState);
 }
 
 void LldbFormattersTest::testQByteArray()
 {
     TestLaunchConfiguration cfg("lldb_qbytearray");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qbytearray.cpp")), 4);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     QStringList charlist {
         R"(-26 '\xe6')",
         R"(-104 '\x98')",
         R"(-81 '\xaf')",
         R"(39 ''')",
         R"(34 '"')",
         R"(92 '\')",
         R"(117 'u')",
         R"(54 '6')",
         R"(50 '2')",
         R"(49 '1')",
         R"(49 '1')",
     };
 
     VERIFY_LOCAL(0, "ba", R"("\xe6\x98\xaf'\"\\u6211")", charlist);
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     QCOMPARE(m_session->currentLine(), 5);
 
     charlist << "120 'x'";
     VERIFY_LOCAL(0, "ba", R"("\xe6\x98\xaf'\"\\u6211x")", charlist);
 
     m_session->run();
     WAIT_FOR_STATE(m_session, DebugSession::EndedState);
 }
 
 
 void LldbFormattersTest::testQListContainer_data()
 {
     QTest::addColumn<QString>("container");
     QTest::addColumn<bool>("unordered");
 
     QTest::newRow("QList") << "QList" << false;
     QTest::newRow("QQueue") << "QQueue" << false;
     QTest::newRow("QVector") << "QVector" << false;
     QTest::newRow("QStack") << "QStack" << false;
     QTest::newRow("QLinkedList") << "QLinkedList" << false;
     QTest::newRow("QSet") << "QSet" << true;
 }
 
 void LldbFormattersTest::testQListContainer()
 {
     QFETCH(QString, container);
     QFETCH(bool, unordered);
 
     TestLaunchConfiguration cfg("lldb_qlistcontainer");
     cfg.config().writeEntry(KDevMI::Config::BreakOnStartEntry, true);
 
     auto watchRoot = variableCollection()->indexForItem(variableCollection()->watches(), 0);
     variableCollection()->expanded(watchRoot);
     variableCollection()->variableWidgetShown();
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     m_session->addUserCommand(QString("break set --func doStuff<%1>()").arg(container));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     m_session->run();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // <int>
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     auto var = variableCollection()->watches()->add("intList");
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "intList", "<size=0>", QStringList{},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     variableCollection()->expanded(watchVariableIndexAt(0)); // expand this node for correct update.
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "intList", "<size=2>", QStringList{"10", "20"},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     if (!verifyVariable(0, "intList", "<size=3>", QStringList{"10", "20", "30"},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
     var->die();
 
     // <QString>
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     var = variableCollection()->watches()->add("stringList");
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "stringList", "<size=0>", QStringList{},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     variableCollection()->expanded(watchVariableIndexAt(0)); // expand this node for correct update.
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
 
     if (!verifyVariable(0, "stringList", "<size=2>", QStringList{"\"a\"", "\"bc\""},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     if (!verifyVariable(0, "stringList", "<size=3>", QStringList{"\"a\"", "\"bc\"", "\"d\""},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
     var->die();
 
     // <struct A>
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     var = variableCollection()->watches()->add("structList");
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "structList", "<size=0>", QStringList{},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     variableCollection()->expanded(watchVariableIndexAt(0)); // expand this node for correct update.
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "structList", "<size=1>", QStringList{"{...}"},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     if (!verifyVariable(0, "structList", "<size=2>", QStringList{"{...}", "{...}"},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
     var->die();
 
     // <int*>
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     var = variableCollection()->watches()->add("pointerList");
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "pointerList", "<size=0>", QStringList{},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     variableCollection()->expanded(watchVariableIndexAt(0)); // expand this node for correct update.
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "pointerList", "<size=2>", QStringList{"^0x[0-9A-Fa-f]+$", "^0x[0-9A-Fa-f]+$"},
                         __FILE__, __LINE__, false, true, unordered)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     if (!verifyVariable(0, "pointerList", "<size=3>", QStringList{"^0x[0-9A-Fa-f]+$", "^0x[0-9A-Fa-f]+$",
                                                                   "^0x[0-9A-Fa-f]+$"},
                         __FILE__, __LINE__, false, true, unordered)) {
         return;
     }
     var->die();
     m_session->stepOver(); // step over qDeleteAll
 
     // <QPair<int, int>>
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     var = variableCollection()->watches()->add("pairList");
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     VERIFY_WATCH(0, "pairList", "<size=0>", QStringList{});
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     variableCollection()->expanded(watchVariableIndexAt(0)); // expand this node for correct update.
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "pairList", "<size=2>", QStringList{"{...}", "{...}"},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     if (!verifyVariable(0, "pairList", "<size=3>", QStringList{"{...}", "{...}", "{...}"},
                         __FILE__, __LINE__, false, false, unordered)) {
         return;
     }
     var->die();
 }
 
 void LldbFormattersTest::testQListPOD()
 {
     TestLaunchConfiguration cfg("lldb_qlistpod");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qlistpod.cpp")), 30);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     auto watchRoot = variableCollection()->indexForItem(variableCollection()->watches(), 0);
     variableCollection()->expanded(watchRoot);
     variableCollection()->variableWidgetShown();
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     variableCollection()->watches()->add("b");
     variableCollection()->watches()->add("c");
     variableCollection()->watches()->add("uc");
     variableCollection()->watches()->add("s");
     variableCollection()->watches()->add("us");
     variableCollection()->watches()->add("i");
     variableCollection()->watches()->add("ui");
     variableCollection()->watches()->add("l");
     variableCollection()->watches()->add("ul");
     variableCollection()->watches()->add("i64");
     variableCollection()->watches()->add("ui64");
     variableCollection()->watches()->add("f");
     variableCollection()->watches()->add("d");
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     VERIFY_WATCH(0, "b", "<size=1>", (QStringList{"false"}));
     VERIFY_WATCH(1, "c", "<size=1>", (QStringList{"50 '2'"}));
     VERIFY_WATCH(2, "uc", "<size=1>", (QStringList{"50 '2'"}));
 
     VERIFY_WATCH(3, "s", "<size=1>", (QStringList{"50"}));
     VERIFY_WATCH(4, "us", "<size=1>", (QStringList{"50"}));
 
     VERIFY_WATCH(5, "i", "<size=1>", (QStringList{"50"}));
     VERIFY_WATCH(6, "ui", "<size=1>", (QStringList{"50"}));
 
     VERIFY_WATCH(7, "l", "<size=1>", (QStringList{"50"}));
     VERIFY_WATCH(8, "ul", "<size=1>", (QStringList{"50"}));
 
     VERIFY_WATCH(9, "i64", "<size=1>", (QStringList{"50"}));
     VERIFY_WATCH(10, "ui64", "<size=1>", (QStringList{"50"}));
 
     VERIFY_WATCH(11, "f", "<size=1>", (QStringList{"50"}));
     VERIFY_WATCH(12, "d", "<size=1>", (QStringList{"50"}));
 }
 
 void LldbFormattersTest::testQMapInt()
 {
     TestLaunchConfiguration cfg("lldb_qmapint");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qmapint.cpp")), 6);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     VERIFY_LOCAL(0, "m", "<size=2>", (QStringList{"(10, 100)", "(20, 200)"}));
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     QCOMPARE(m_session->currentLine(), 7);
 
     VERIFY_LOCAL(0, "m", "<size=3>", (QStringList{"(10, 100)", "(20, 200)", "(30, 300)"}));
 }
 
 void LldbFormattersTest::testQMapString()
 {
     TestLaunchConfiguration cfg("lldb_qmapstring");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qmapstring.cpp")), 7);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     VERIFY_LOCAL(0, "m", "<size=2>", (QStringList{"(\"10\", \"100\")", "(\"20\", \"200\")"}));
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     QCOMPARE(m_session->currentLine(), 8);
 
     VERIFY_LOCAL(0, "m", "<size=3>",
                  (QStringList{"(\"10\", \"100\")", "(\"20\", \"200\")", "(\"30\", \"300\")"}));
 }
 
 void LldbFormattersTest::testQMapStringBool()
 {
     TestLaunchConfiguration cfg("lldb_qmapstringbool");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qmapstringbool.cpp")), 7);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     VERIFY_LOCAL(0, "m", "<size=2>", (QStringList{"(\"10\", true)", "(\"20\", false)"}));
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     QCOMPARE(m_session->currentLine(), 8);
 
     VERIFY_LOCAL(0, "m", "<size=3>", (QStringList{"(\"10\", true)", "(\"20\", false)", "(\"30\", true)"}));
 }
 
 
 void LldbFormattersTest::testQHashInt()
 {
     TestLaunchConfiguration cfg("lldb_qhashint");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qhashint.cpp")), 6);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "h", "<size=2>", {"(10, 100)", "(20, 200)"},
                         __FILE__, __LINE__, true, false, true)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     QCOMPARE(m_session->currentLine(), 7);
 
     if (!verifyVariable(0, "h", "<size=3>", {"(10, 100)", "(20, 200)", "(30, 300)"},
                         __FILE__, __LINE__, true, false, true)) {
         return;
     }
 }
 
 void LldbFormattersTest::testQHashString()
 {
     TestLaunchConfiguration cfg("lldb_qhashstring");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qhashstring.cpp")), 7);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "h", "<size=2>", {"(\"10\", \"100\")", "(\"20\", \"200\")"},
                         __FILE__, __LINE__, true, false, true)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     QCOMPARE(m_session->currentLine(), 8);
 
     if (!verifyVariable(0, "h", "<size=3>",
                         {"(\"10\", \"100\")", "(\"20\", \"200\")", "(\"30\", \"300\")"},
                         __FILE__, __LINE__, true, false, true)) {
         return;
     }
 }
 
 void LldbFormattersTest::testQSetInt()
 {
     TestLaunchConfiguration cfg("lldb_qsetint");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qsetint.cpp")), 6);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "s", "<size=2>", {"10", "20"},
                         __FILE__, __LINE__, true, false, true)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     QCOMPARE(m_session->currentLine(), 7);
 
     if (!verifyVariable(0, "s", "<size=3>", {"10", "20", "30"},
                         __FILE__, __LINE__, true, false, true)) {
         return;
     }
 }
 
 void LldbFormattersTest::testQSetString()
 {
     TestLaunchConfiguration cfg("lldb_qsetstring");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qsetstring.cpp")), 7);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     if (!verifyVariable(0, "s", "<size=2>", {"\"10\"", "\"20\""},
                         __FILE__, __LINE__, true, false, true)) {
         return;
     }
 
     m_session->stepOver();
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
     QCOMPARE(m_session->currentLine(), 8);
 
     if (!verifyVariable(0, "s", "<size=3>",
                         {"\"10\"", "\"20\"", "\"30\""},
                         __FILE__, __LINE__, true, false, true)) {
         return;
     }
 }
 
 void LldbFormattersTest::testQDate()
 {
     TestLaunchConfiguration cfg("lldb_qdate");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qdate.cpp")), 5);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     QList<QPair<QString, QString>> children;
     children.append({"jd", "2455217"});
     children.append({"(ISO)", "\"2010-01-20\""});
     children.append({"(Locale)", "\".+\""}); // (Locale) and summary are locale dependent
     if (!verifyVariable(0, "d", ".+", children,
                         __FILE__, __LINE__, true, true, false)) {
         return;
     }
 }
 
 void LldbFormattersTest::testQTime()
 {
     TestLaunchConfiguration cfg("lldb_qtime");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qtime.cpp")), 5);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     QList<QPair<QString, QString>> children;
     children.append({"mds", "55810123"});
     children.append({"(ISO)", "\"15:30:10.000123\""});
     children.append({"(Locale)", "\".+\""}); // (Locale) and summary are locale dependent
     if (!verifyVariable(0, "t", ".+", children,
                         __FILE__, __LINE__, true, true, false)) {
         return;
     }
 }
 
 void LldbFormattersTest::testQDateTime()
 {
     TestLaunchConfiguration cfg("lldb_qdatetime");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qdatetime.cpp")), 5);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     QList<QPair<QString, QString>> children;
     children.append({"toTime_t", "1264019473"});
     children.append({"(ISO)", "\"2010-01-20 20:31:13\""});
     children.append({"(Locale)", "\".+\""}); // (Locale), (UTC) and summary are locale dependent
     children.append({"(UTC)", "\".+\""});
     if (!verifyVariable(0, "dt", ".+", children,
                         __FILE__, __LINE__, true, true, false)) {
         return;
     }
 }
 
 void LldbFormattersTest::testQUrl()
 {
     TestLaunchConfiguration cfg("lldb_qurl");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("qurl.cpp")), 4);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     QList<QPair<QString, QString>> children;
     children.append({"(port)", "-1"});
     children.append({"(scheme)", "\"http\""});
     children.append({"(userName)", "<Invalid>"});
     children.append({"(password)", "<Invalid>"});
     children.append({"(host)", "\"www.kdevelop.org\""});
     children.append({"(path)", "\"/foo\""});
     children.append({"(query)", "<Invalid>"});
     children.append({"(fragment)", "<Invalid>"});
     VERIFY_LOCAL(0, "u", "\"http://www.kdevelop.org/foo\"", children);
 }
 
 void LldbFormattersTest::testQUuid()
 {
     TestLaunchConfiguration cfg("lldb_quuid");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("quuid.cpp")), 4);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     variableCollection()->expanded(localVariableIndexAt(0));
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     VERIFY_LOCAL(0, "id", "QUuid({9ec3b70b-d105-42bf-b3b4-656e44d2e223})", (QStringList{}));
 }
 
 void LldbFormattersTest::testKTextEditorTypes()
 {
     TestLaunchConfiguration cfg("lldb_ktexteditortypes");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("ktexteditortypes.cpp")), 8);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     auto watchRoot = variableCollection()->indexForItem(variableCollection()->watches(), 0);
     variableCollection()->expanded(watchRoot);
     variableCollection()->variableWidgetShown();
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     variableCollection()->watches()->add("cursor");
     variableCollection()->watches()->add("range");
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     QList<QPair<QString, QString>> cursorChildren;
     cursorChildren.append({"m_line", "1"});
     cursorChildren.append({"m_column", "1"});
 
     QList<QPair<QString, QString>> rangeChildren;
     rangeChildren.append({"m_start", "(1, 1)"});
     rangeChildren.append({"m_end", "(2, 2)"});
 
     VERIFY_WATCH(0, "cursor", "(1, 1)", cursorChildren);
     VERIFY_WATCH(1, "range", "[(1, 1) -> (2, 2)]", rangeChildren);
 }
 
 void LldbFormattersTest::testKDevelopTypes()
 {
     TestLaunchConfiguration cfg("lldb_kdeveloptypes");
     addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile("kdeveloptypes.cpp")), 11);
 
     QVERIFY(m_session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(m_session, DebugSession::PausedState);
 
     // Should be two rows ('auto', 'local')
     QCOMPARE(variableCollection()->rowCount(), 2);
 
     auto watchRoot = variableCollection()->indexForItem(variableCollection()->watches(), 0);
     variableCollection()->expanded(watchRoot);
     variableCollection()->variableWidgetShown();
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     variableCollection()->watches()->add("path1");
     variableCollection()->watches()->add("path2");
     WAIT_FOR_A_WHILE_AND_IDLE(m_session, 50);
 
     QList<QPair<QString, QString>> path1Children;
     path1Children.append({"m_data", "<size=2>"});
 
     QList<QPair<QString, QString>> path2Children;
     path2Children.append({"m_data", "<size=3>"});
 
     VERIFY_WATCH(0, "path1", "(\"tmp\", \"foo\")", path1Children);
     VERIFY_WATCH(1, "path2", "(\"http://www.test.com\", \"tmp\", \"asdf.txt\")", path2Children);
 }
 
 QTEST_MAIN(LldbFormattersTest)
 
 #include "test_lldbformatters.moc"
diff --git a/debuggers/lldb/widgets/lldbconfigpage.cpp b/debuggers/lldb/widgets/lldbconfigpage.cpp
index 6e628c1d6b..766c599736 100644
--- a/debuggers/lldb/widgets/lldbconfigpage.cpp
+++ b/debuggers/lldb/widgets/lldbconfigpage.cpp
@@ -1,121 +1,120 @@
 /*
  * LLDB Debugger Support
  * Copyright 2016  Aetf <aetf@unlimitedcodeworks.xyz>
  *
  * 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 "lldbconfigpage.h"
 #include "ui_lldbconfigpage.h"
 
 #include "dbgglobal.h"
 
 #include <util/environmentselectionwidget.h>
 
 #include <KConfigGroup>
 #include <KUrlRequester>
 
 #include <QComboBox>
-#include <QCheckBox>
 #include <QGroupBox>
 #include <QLineEdit>
 #include <QRegularExpression>
 #include <QRegularExpressionValidator>
 
 using namespace KDevelop;
 namespace Config = KDevMI::LLDB::Config;
 
 LldbConfigPage::LldbConfigPage(QWidget* parent)
     : LaunchConfigurationPage(parent)
     , ui(new Ui::LldbConfigPage)
 {
     ui->setupUi(this);
     ui->lineDebuggerExec->setMode(KFile::File|KFile::ExistingOnly|KFile::LocalOnly);
     ui->lineConfigScript->setMode(KFile::File|KFile::ExistingOnly|KFile::LocalOnly);
 
     QRegularExpression rx(R"([^:]+:\d+)");
     ui->lineRemoteServer->setValidator(new QRegularExpressionValidator(rx, this));
 
     ui->comboStartWith->setItemData(0, "ApplicationOutput");
     ui->comboStartWith->setItemData(1, "GdbConsole");
     ui->comboStartWith->setItemData(2, "FrameStack");
 
     connect(ui->lineDebuggerExec, &KUrlRequester::textChanged, this, &LldbConfigPage::changed);
     connect(ui->lineDebuggerArgs, &QLineEdit::textChanged, this, &LldbConfigPage::changed);
     connect(ui->comboEnv, &EnvironmentSelectionWidget::currentProfileChanged,
             this, &LldbConfigPage::changed);
 
     connect(ui->lineConfigScript, &KUrlRequester::textChanged, this, &LldbConfigPage::changed);
     connect(ui->comboStartWith, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
             this, &LldbConfigPage::changed);
 
     connect(ui->groupRemote, &QGroupBox::clicked, this, &LldbConfigPage::changed);
     connect(ui->lineRemoteServer, &QLineEdit::textChanged, this, &LldbConfigPage::changed);
     connect(ui->lineOnDevPath, &QLineEdit::textChanged, this, &LldbConfigPage::changed);
 }
 
 LldbConfigPage::~LldbConfigPage()
 {
     delete ui;
 }
 
 QIcon LldbConfigPage::icon() const
 {
     return {};
 }
 
 QString LldbConfigPage::title() const
 {
     return i18n("LLDB Configuration");
 }
 
 void LldbConfigPage::loadFromConfiguration(const KConfigGroup& cfg, KDevelop::IProject *)
 {
     bool block = blockSignals(true);
     ui->lineDebuggerExec->setUrl(cfg.readEntry(Config::LldbExecutableEntry, QUrl()));
     ui->lineDebuggerArgs->setText(cfg.readEntry(Config::LldbArgumentsEntry, QString()));
     ui->comboEnv->setCurrentProfile(cfg.readEntry(Config::LldbEnvironmentEntry, QString()));
     ui->checkInheritSystem->setChecked(cfg.readEntry(Config::LldbInheritSystemEnvEntry, true));
     ui->lineConfigScript->setUrl(cfg.readEntry(Config::LldbConfigScriptEntry, QUrl()));
     ui->checkBreakOnStart->setChecked(cfg.readEntry(KDevMI::Config::BreakOnStartEntry, false));
     ui->comboStartWith->setCurrentIndex(ui->comboStartWith->findData(
         cfg.readEntry(KDevMI::Config::StartWithEntry, "ApplicationOutput")));
     ui->groupRemote->setChecked(cfg.readEntry(Config::LldbRemoteDebuggingEntry, false));
     ui->lineRemoteServer->setText(cfg.readEntry(Config::LldbRemoteServerEntry, QString()));
     ui->lineOnDevPath->setText(cfg.readEntry(Config::LldbRemotePathEntry, QString()));
     blockSignals(block);
 }
 
 void LldbConfigPage::saveToConfiguration(KConfigGroup cfg, KDevelop::IProject *) const
 {
     cfg.writeEntry(Config::LldbExecutableEntry, ui->lineDebuggerExec->url());
     cfg.writeEntry(Config::LldbArgumentsEntry, ui->lineDebuggerArgs->text());
     cfg.writeEntry(Config::LldbEnvironmentEntry, ui->comboEnv->currentProfile());
     cfg.writeEntry(Config::LldbInheritSystemEnvEntry, ui->checkInheritSystem->isChecked());
     cfg.writeEntry(Config::LldbConfigScriptEntry, ui->lineConfigScript->url());
     cfg.writeEntry(KDevMI::Config::BreakOnStartEntry, ui->checkBreakOnStart->isChecked());
     cfg.writeEntry(KDevMI::Config::StartWithEntry, ui->comboStartWith->currentData().toString());
     cfg.writeEntry(Config::LldbRemoteDebuggingEntry, ui->groupRemote->isChecked());
     cfg.writeEntry(Config::LldbRemoteServerEntry, ui->lineRemoteServer->text());
     cfg.writeEntry(Config::LldbRemotePathEntry, ui->lineOnDevPath->text());
 }
 
 KDevelop::LaunchConfigurationPage * LldbConfigPageFactory::createWidget(QWidget* parent)
 {
     return new LldbConfigPage(parent);
 }
diff --git a/documentation/manpage/manpagedocumentation.cpp b/documentation/manpage/manpagedocumentation.cpp
index f3584b9186..15c91e6b0e 100644
--- a/documentation/manpage/manpagedocumentation.cpp
+++ b/documentation/manpage/manpagedocumentation.cpp
@@ -1,106 +1,100 @@
 /*  This file is part of KDevelop
     Copyright 2010 Yannick Motta <yannick.motta@gmail.com>
     Copyright 2010 Benjamin Port <port.benjamin@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 <QLabel>
 #include <KLocalizedString>
 #include <QTreeView>
-#include <QHeaderView>
-#include <QProgressBar>
-#include <QVBoxLayout>
-#include <QStackedWidget>
 #include <QStandardPaths>
 
 #include "manpagedocumentation.h"
 #include "manpageplugin.h"
 #include "manpagedocumentationwidget.h"
 
 #include <KIO/TransferJob>
-#include <KIO/Job>
 #include <kio/jobclasses.h>
 #include <documentation/standarddocumentationview.h>
 
 ManPagePlugin* ManPageDocumentation::s_provider=nullptr;
 
 
 ManPageDocumentation::ManPageDocumentation(const QString& name, const QUrl& url)
     : m_url(url), m_name(name)
 {
     KIO::StoredTransferJob* transferJob = KIO::storedGet(m_url, KIO::NoReload, KIO::HideProgressInfo);
     connect( transferJob, &KIO::StoredTransferJob::finished, this, &ManPageDocumentation::finished);
     transferJob->start();
 }
 
 void ManPageDocumentation::finished(KJob* j)
 {
     KIO::StoredTransferJob* job = qobject_cast<KIO::StoredTransferJob*>(j);
     if(job && job->error()==0) {
         m_description = QString::fromUtf8(job->data());
     } else {
         m_description.clear();
     }
     emit descriptionChanged();
 }
 
 KDevelop::IDocumentationProvider* ManPageDocumentation::provider() const
 {
     return s_provider;
 }
 
 QString ManPageDocumentation::description() const
 {
     return m_description;
 }
 
 QWidget* ManPageDocumentation::documentationWidget(KDevelop::DocumentationFindWidget* findWidget, QWidget* parent )
 {
     KDevelop::StandardDocumentationView* view = new KDevelop::StandardDocumentationView(findWidget, parent);
     view->setDocumentation(IDocumentation::Ptr(this));
 
     // apply custom style-sheet to normalize look of the page
     const QString cssFile = QStandardPaths::locate(QStandardPaths::GenericDataLocation, "kdevmanpage/manpagedocumentation.css");
     QWebSettings* settings = view->settings();
     settings->setUserStyleSheetUrl(QUrl::fromLocalFile(cssFile));
 
     view->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
     QObject::connect(view, &KDevelop::StandardDocumentationView::linkClicked, ManPageDocumentation::s_provider->model(), &ManPageModel::showItemFromUrl);
     return view;
 }
 
 bool ManPageDocumentation::providesWidget() const
 {
     return false;
 }
 
 QWidget* ManPageHomeDocumentation::documentationWidget(KDevelop::DocumentationFindWidget *findWidget, QWidget *parent){
     Q_UNUSED(findWidget);
     return new ManPageDocumentationWidget(parent);
 }
 
 
 QString ManPageHomeDocumentation::name() const
 {
     return i18n("Man Content Page");
 }
 
 KDevelop::IDocumentationProvider* ManPageHomeDocumentation::provider() const
 {
     return ManPageDocumentation::s_provider;
 }
 
diff --git a/documentation/manpage/manpagedocumentation.h b/documentation/manpage/manpagedocumentation.h
index 97c920a010..4140aee7cc 100644
--- a/documentation/manpage/manpagedocumentation.h
+++ b/documentation/manpage/manpagedocumentation.h
@@ -1,72 +1,71 @@
 /*  This file is part of KDevelop
     Copyright 2010 Yannick Motta <yannick.motta@gmail.com>
     Copyright 2010 Benjamin Port <port.benjamin@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.
 */
 
 #ifndef MANPAGEDOCUMENTATION_H
 #define MANPAGEDOCUMENTATION_H
 
 #include "manpagemodel.h"
 
 #include <interfaces/idocumentation.h>
 
 #include <QUrl>
 #include <QtCore/QObject>
 #include <QtCore/QString>
 #include <QIODevice>
 
 class QWidget;
-class QStackedWidget;
 class QTreeView;
 
 class ManPagePlugin;
 
 class ManPageDocumentation : public KDevelop::IDocumentation
 {
     Q_OBJECT
     public:
         ManPageDocumentation(const QString& name, const QUrl& url);
         QString name() const override { return m_name; }
         QString description() const override;
         virtual bool providesWidget() const;
         QWidget* documentationWidget(KDevelop::DocumentationFindWidget* findWidget, QWidget* parent = nullptr) override;
         KDevelop::IDocumentationProvider* provider() const override;
         static ManPagePlugin* s_provider;
 
     private slots:
         void finished(KJob*);
 
     private:
         const QUrl m_url;
         const QString m_name;
         QString m_description;
 
 };
 
 class ManPageHomeDocumentation : public KDevelop::IDocumentation
 {
     Q_OBJECT
     public:
         KDevelop::IDocumentationProvider* provider() const override;
         QString name() const override;
         QString description() const override { return name(); }
         QWidget* documentationWidget ( KDevelop::DocumentationFindWidget* findWidget, QWidget* parent = nullptr ) override;
 };
 
 
 #endif // MANPAGEDOCUMENTATION_H
diff --git a/documentation/manpage/tests/test_manpagemodel.cpp b/documentation/manpage/tests/test_manpagemodel.cpp
index eedbdebdf6..10977d6ace 100644
--- a/documentation/manpage/tests/test_manpagemodel.cpp
+++ b/documentation/manpage/tests/test_manpagemodel.cpp
@@ -1,72 +1,72 @@
 /*  This file is part of KDevelop
     Copyright 2014 Kevin Funk <kfunk@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 "../manpagedocumentation.h"
 #include "../manpagemodel.h"
 
 #include <tests/modeltest.h>
 
 #include <QDebug>
 #include <QSignalSpy>
-#include <QtTest>
+#include <QTest>
 
 class TestManPageModel : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void testModel();
     void testDocumentation();
 };
 
 void TestManPageModel::testModel()
 {
     ManPageModel model;
     QSignalSpy spy(&model, SIGNAL(manPagesLoaded()));
     spy.wait();
 
     if (model.isLoaded()) {
         QVERIFY(model.rowCount() > 0);
         new ModelTest(&model);
     } else {
         QCOMPARE(model.rowCount(), 0);
     }
 }
 
 void TestManPageModel::testDocumentation()
 {
     ManPageDocumentation documentation("dlopen", QUrl("man: (3)/dlmopen"));
     QSignalSpy spy(&documentation, SIGNAL(descriptionChanged()));
     QVERIFY(spy.wait());
 
     const QString description = documentation.description();
     qDebug() << "Description:" << description;
     if (description.isEmpty() || description.contains("No man page matching to dlmopen found")) {
         QSKIP("This test requires installed man pages for dlmopen & friends");
     }
 
     // check that we've found the correct page by checking some references
     QVERIFY(description.contains("dlclose"));
     QVERIFY(description.contains("dlerror"));
     QVERIFY(description.contains("dlopen"));
 }
 
 QTEST_MAIN(TestManPageModel)
 
 #include "test_manpagemodel.moc"
diff --git a/documentation/qthelp/qthelpconfig.cpp b/documentation/qthelp/qthelpconfig.cpp
index 6a0ca6f8b8..d947daa12f 100644
--- a/documentation/qthelp/qthelpconfig.cpp
+++ b/documentation/qthelp/qthelpconfig.cpp
@@ -1,357 +1,355 @@
 /*  This file is part of KDevelop
 
     Copyright 2010 Benjamin Port <port.benjamin@gmail.com>
     Copyright 2014 Kevin Funk <kfunk@kde.org>
     Copyright 2016 Andreas Cord-Landwehr <cordlandwehr@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 "qthelpconfig.h"
 
 #include <QHelpEngineCore>
-#include <QFileDialog>
 #include <QToolButton>
 #include <QHeaderView>
 
 #include <KMessageBox>
-#include <KMessageWidget>
 #include <KLocalizedString>
 #include <KNS3/Button>
 
 #include "ui_qthelpconfig.h"
 #include "ui_qthelpconfigeditdialog.h"
 #include "qthelp_config_shared.h"
 #include "debug.h"
 #include "qthelpplugin.h"
 
 enum Column
 {
     NameColumn,
     PathColumn,
     IconColumn,
     GhnsColumn,
     ConfigColumn
 };
 
 class QtHelpConfigEditDialog : public QDialog, public Ui_QtHelpConfigEditDialog
 {
 public:
     explicit QtHelpConfigEditDialog(QTreeWidgetItem* modifiedItem, QtHelpConfig* parent = nullptr,
                                     Qt::WindowFlags f = nullptr)
         : QDialog(parent, f)
         , m_modifiedItem(modifiedItem)
         , m_config(parent)
     {
         setupUi(this);
 
         if (modifiedItem) {
             setWindowTitle(i18n("Modify Entry"));
         } else {
             setWindowTitle(i18n("Add New Entry"));
         }
         qchIcon->setIcon("qtlogo");
     }
 
     bool checkQtHelpFile();
 
     void accept() override;
 
 private:
     QTreeWidgetItem* m_modifiedItem;
     QtHelpConfig* m_config;
 };
 
 bool QtHelpConfigEditDialog::checkQtHelpFile()
 {
     //verify if the file is valid and if there is a name
     if(qchName->text().isEmpty()){
         KMessageBox::error(this, i18n("Name cannot be empty."));
         return false;
     }
 
     return m_config->checkNamespace(qchRequester->text(), m_modifiedItem);
 }
 
 void QtHelpConfigEditDialog::accept()
 {
     if (!checkQtHelpFile())
         return;
 
     QDialog::accept();
 }
 
 QtHelpConfig::QtHelpConfig(QtHelpPlugin* plugin, QWidget *parent)
     : KDevelop::ConfigPage(plugin, nullptr, parent)
 {
     m_configWidget = new Ui::QtHelpConfigUI;
     m_configWidget->setupUi(this);
     m_configWidget->addButton->setIcon(QIcon::fromTheme("list-add"));
     connect(m_configWidget->addButton, &QPushButton::clicked, this, &QtHelpConfig::add);
 
     // Table
     m_configWidget->qchTable->setColumnHidden(IconColumn, true);
     m_configWidget->qchTable->setColumnHidden(GhnsColumn, true);
     m_configWidget->qchTable->model()->setHeaderData(ConfigColumn, Qt::Horizontal, QVariant());
     m_configWidget->qchTable->header()->setSectionsMovable(false);
     m_configWidget->qchTable->header()->setStretchLastSection(false);
     m_configWidget->qchTable->header()->setSectionResizeMode(NameColumn, QHeaderView::Stretch);
     m_configWidget->qchTable->header()->setSectionResizeMode(PathColumn, QHeaderView::Stretch);
     m_configWidget->qchTable->header()->setSectionResizeMode(ConfigColumn, QHeaderView::Fixed);
 
     // Add GHNS button
     KNS3::Button *knsButton = new KNS3::Button(i18nc("Allow user to get some API documentation with GHNS", "Get New Documentation"), "kdevelop-qthelp.knsrc", m_configWidget->boxQchManage);
     m_configWidget->tableCtrlLayout->insertWidget(1, knsButton);
     connect(knsButton, &KNS3::Button::dialogFinished, this, &QtHelpConfig::knsUpdate);
     connect(m_configWidget->loadQtDocsCheckBox, &QCheckBox::toggled,
             this, static_cast<void(QtHelpConfig::*)()>(&QtHelpConfig::changed));
     m_configWidget->qchSearchDir->setMode(KFile::Directory);
     connect(m_configWidget->qchSearchDir, &KUrlRequester::textChanged,
             this, &QtHelpConfig::changed);
 
     // Set availability information for QtHelp
     m_configWidget->messageAvailabilityQtDocs->setCloseButtonVisible(false);
     if(plugin->isQtHelpAvailable()) {
         m_configWidget->messageAvailabilityQtDocs->setVisible(false);
     } else {
         m_configWidget->messageAvailabilityQtDocs->setText(
             i18n("The command \"qmake -query\" could not provide a path to a QtHelp file (QCH)."));
         m_configWidget->loadQtDocsCheckBox->setVisible(false);
     }
     reset();
 }
 
 QtHelpConfig::~QtHelpConfig()
 {
     delete m_configWidget;
 }
 
 KDevelop::ConfigPage::ConfigPageType QtHelpConfig::configPageType() const
 {
     return KDevelop::ConfigPage::DocumentationConfigPage;
 }
 
 void QtHelpConfig::apply()
 {
     QStringList iconList, nameList, pathList, ghnsList;
     for (int i = 0; i < m_configWidget->qchTable->topLevelItemCount(); i++) {
         const QTreeWidgetItem* item = m_configWidget->qchTable->topLevelItem(i);
         nameList << item->text(0);
         pathList << item->text(1);
         iconList << item->text(2);
         ghnsList << item->text(3);
     }
     QString searchDir = m_configWidget->qchSearchDir->text();
     bool loadQtDoc = m_configWidget->loadQtDocsCheckBox->isChecked();
 
     qtHelpWriteConfig(iconList, nameList, pathList, ghnsList, searchDir, loadQtDoc);
     static_cast<QtHelpPlugin*>(plugin())->readConfig();
 }
 
 void QtHelpConfig::reset()
 {
     m_configWidget->qchTable->clear();
 
     QStringList iconList, nameList, pathList, ghnsList;
     QString searchDir;
     bool loadQtDoc;
     qtHelpReadConfig(iconList, nameList, pathList, ghnsList, searchDir, loadQtDoc);
 
     const int size = qMin(qMin(iconList.size(), nameList.size()), pathList.size());
     for(int i = 0; i < size; ++i) {
         QString ghnsStatus = ghnsList.size()>i ? ghnsList.at(i) : "0";
         addTableItem(iconList.at(i), nameList.at(i), pathList.at(i), ghnsStatus);
     }
     m_configWidget->qchSearchDir->setText(searchDir);
     m_configWidget->loadQtDocsCheckBox->setChecked(loadQtDoc);
 
     emit changed();
 }
 
 void QtHelpConfig::defaults()
 {
     bool change = false;
     if(m_configWidget->qchTable->topLevelItemCount() > 0) {
         m_configWidget->qchTable->clear();
         change = true;
     }
     if(!m_configWidget->loadQtDocsCheckBox->isChecked()){
         m_configWidget->loadQtDocsCheckBox->setChecked(true);
         change = true;
     }
 
     if (change) {
         emit changed();
     }
 }
 
 void QtHelpConfig::add()
 {
     QtHelpConfigEditDialog dialog(nullptr, this);
     if (!dialog.exec())
         return;
 
     QTreeWidgetItem* item = addTableItem(dialog.qchIcon->icon(), dialog.qchName->text(), dialog.qchRequester->text(), "0");
     m_configWidget->qchTable->setCurrentItem(item);
     emit changed();
 }
 
 void QtHelpConfig::modify(QTreeWidgetItem* item)
 {
     if (!item)
         return;
 
     QtHelpConfigEditDialog dialog(item, this);
     if (item->text(GhnsColumn) != "0") {
         dialog.qchRequester->setText(i18n("Documentation provided by GHNS"));
         dialog.qchRequester->setEnabled(false);
     } else {
         dialog.qchRequester->setText(item->text(PathColumn));
         dialog.qchRequester->setEnabled(true);
     }
     dialog.qchName->setText(item->text(NameColumn));
     dialog.qchIcon->setIcon(item->text(IconColumn));
     if (!dialog.exec()) {
         return;
     }
 
     item->setIcon(NameColumn, QIcon(dialog.qchIcon->icon()));
     item->setText(NameColumn, dialog.qchName->text());
     item->setText(IconColumn, dialog.qchIcon->icon());
     if(item->text(GhnsColumn) == "0") {
         item->setText(PathColumn, dialog.qchRequester->text());
     }
     emit changed();
 }
 
 bool QtHelpConfig::checkNamespace(const QString& filename, QTreeWidgetItem* modifiedItem)
 {
     QString qtHelpNamespace = QHelpEngineCore::namespaceName(filename);
     if (qtHelpNamespace.isEmpty()) {
         // Open error message (not valid Qt Compressed Help file)
         KMessageBox::error(this, i18n("Qt Compressed Help file is not valid."));
         return false;
     }
     // verify if it's the namespace it's not already in the list
     for(int i=0; i < m_configWidget->qchTable->topLevelItemCount(); i++) {
         const QTreeWidgetItem* item = m_configWidget->qchTable->topLevelItem(i);
         if (item != modifiedItem){
             if (qtHelpNamespace == QHelpEngineCore::namespaceName(item->text(PathColumn))) {
                 // Open error message, documentation already imported
                 KMessageBox::error(this, i18n("Documentation already imported"));
                 return false;
             }
         }
     }
     return true;
 }
 
 void QtHelpConfig::remove(QTreeWidgetItem* item)
 {
     if (!item)
         return;
 
     delete item;
     emit changed();
 }
 
 void QtHelpConfig::knsUpdate(KNS3::Entry::List list)
 {
     if (list.isEmpty())
         return;
 
     foreach (const KNS3::Entry& e, list) {
         if(e.status() == KNS3::Entry::Installed) {
             if(e.installedFiles().size() == 1) {
                 QString filename = e.installedFiles().at(0);
                 if(checkNamespace(filename, nullptr)){
                     QTreeWidgetItem* item = addTableItem("documentation", e.name(), filename, "1");
                     m_configWidget->qchTable->setCurrentItem(item);
                 } else {
                     qCDebug(QTHELP) << "namespace error";
                 }
             }
         } else if(e.status() ==  KNS3::Entry::Deleted) {
             if(e.uninstalledFiles().size() == 1) {
                 for(int i=0; i < m_configWidget->qchTable->topLevelItemCount(); i++) {
                     QTreeWidgetItem* item = m_configWidget->qchTable->topLevelItem(i);
                     if (e.uninstalledFiles().at(0) == item->text(PathColumn)) {
                         delete item;
                         break;
                     }
                 }
             }
         }
     }
     emit changed();
 }
 
 QString QtHelpConfig::name() const
 {
     return i18n("Qt Help");
 }
 
 QString QtHelpConfig::fullName() const
 {
     return i18n("Configure Qt Help Settings");
 }
 
 QIcon QtHelpConfig::icon() const
 {
     return QIcon::fromTheme(QStringLiteral("qtlogo"));
 }
 
 QTreeWidgetItem * QtHelpConfig::addTableItem(const QString &icon, const QString &name,
                                              const QString &path, const QString &ghnsStatus)
 {
     QTreeWidgetItem *item = new QTreeWidgetItem(m_configWidget->qchTable);
     item->setIcon(NameColumn, QIcon::fromTheme(icon));
     item->setText(NameColumn, name);
     item->setToolTip(NameColumn, name);
     item->setText(PathColumn, path);
     item->setToolTip(PathColumn, path);
     item->setText(IconColumn, icon);
     item->setText(GhnsColumn, ghnsStatus);
 
     QWidget *ctrlWidget = new QWidget(item->treeWidget());
     ctrlWidget->setLayout(new QHBoxLayout(ctrlWidget));
 
     QToolButton *modifyBtn = new QToolButton(item->treeWidget());
     modifyBtn->setIcon(QIcon::fromTheme("document-edit"));
     modifyBtn->setToolTip(i18n("Modify"));
     connect(modifyBtn, &QPushButton::clicked, this, [=](){
         modify(item);
     });
     QToolButton *removeBtn = new QToolButton(item->treeWidget());
     removeBtn->setIcon(QIcon::fromTheme("entry-delete"));
     removeBtn->setToolTip(i18n("Delete"));
     if (item->text(GhnsColumn) != "0") {
         // KNS3 currently does not provide API to uninstall entries
         // just removing the files results in wrong installed states in the KNS3 dialog
         // TODO: add API to KNS to remove files without UI interaction
         removeBtn->setEnabled(false);
         removeBtn->setToolTip(tr("Please uninstall this via GHNS"));
     } else {
         connect(removeBtn, &QPushButton::clicked, this, [=](){
             remove(item);
         });
     }
     ctrlWidget->layout()->addWidget(modifyBtn);
     ctrlWidget->layout()->addWidget(removeBtn);
     m_configWidget->qchTable->setItemWidget(item, ConfigColumn, ctrlWidget);
 
     return item;
 }
diff --git a/documentation/qthelp/qthelpplugin.cpp b/documentation/qthelp/qthelpplugin.cpp
index 60860e9e67..d4c112e8da 100644
--- a/documentation/qthelp/qthelpplugin.cpp
+++ b/documentation/qthelp/qthelpplugin.cpp
@@ -1,181 +1,180 @@
 /*  This file is part of KDevelop
     Copyright 2009 Aleix Pol <aleixpol@kde.org>
     Copyright 2010 Benjamin Port <port.benjamin@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 "qthelpplugin.h"
 
 #include <kpluginfactory.h>
-#include <KAboutData>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentationcontroller.h>
 #include <QDirIterator>
 #include "qthelpprovider.h"
 #include "qthelpqtdoc.h"
 #include "qthelp_config_shared.h"
 #include "debug.h"
 #include "qthelpconfig.h"
 
 QtHelpPlugin *QtHelpPlugin::s_plugin = nullptr;
 
 K_PLUGIN_FACTORY_WITH_JSON(QtHelpPluginFactory, "kdevqthelp.json", registerPlugin<QtHelpPlugin>(); )
 
 QtHelpPlugin::QtHelpPlugin(QObject* parent, const QVariantList& args)
     : KDevelop::IPlugin("kdevqthelp", parent)
     , m_qtHelpProviders()
     , m_qtDoc(new QtHelpQtDoc(this, QVariantList()))
     , m_loadSystemQtDoc(false)
 {
     Q_UNUSED(args);
     s_plugin = this;
     connect(this, &QtHelpPlugin::changedProvidersList, KDevelop::ICore::self()->documentationController(), &KDevelop::IDocumentationController::changedDocumentationProviders);
     QMetaObject::invokeMethod(this, "readConfig", Qt::QueuedConnection);
 }
 
 QtHelpPlugin::~QtHelpPlugin()
 {
 }
 
 
 void QtHelpPlugin::readConfig()
 {
     QStringList iconList, nameList, pathList, ghnsList;
     QString searchDir;
     qtHelpReadConfig(iconList, nameList, pathList, ghnsList, searchDir, m_loadSystemQtDoc);
 
     searchHelpDirectory(pathList, nameList, iconList, searchDir);
     loadQtHelpProvider(pathList, nameList, iconList);
     loadQtDocumentation(m_loadSystemQtDoc);
 
     emit changedProvidersList();
 }
 
 void QtHelpPlugin::loadQtDocumentation(bool loadQtDoc)
 {
     if(!loadQtDoc){
         m_qtDoc->unloadDocumentation();
     } else if(loadQtDoc) {
         m_qtDoc->loadDocumentation();
     }
 }
 
 void QtHelpPlugin::searchHelpDirectory(QStringList& pathList, QStringList& nameList, QStringList& iconList, const QString& searchDir)
 {
     if (searchDir.isEmpty()) {
         return;
     }
 
     qCDebug(QTHELP) << "Searching qch files in: " << searchDir;
     QDirIterator dirIt(searchDir, QStringList() << "*.qch", QDir::Files, QDirIterator::Subdirectories);
     const QString logo("qtlogo");
     while(dirIt.hasNext() == true)
     {
         dirIt.next();
         qCDebug(QTHELP) << "qch found: " << dirIt.filePath();
         pathList.append(dirIt.filePath());
         nameList.append(dirIt.fileInfo().baseName());
         iconList.append(logo);
     }
 }
 
 
 void QtHelpPlugin::loadQtHelpProvider(QStringList pathList, QStringList nameList, QStringList iconList)
 {
     QList<QtHelpProvider*> oldList(m_qtHelpProviders);
     m_qtHelpProviders.clear();
     for(int i=0; i < pathList.length(); i++) {
         // check if provider already exist
         QString fileName = pathList.at(i);
         QString name = nameList.at(i);
         QString iconName = iconList.at(i);
         QString nameSpace = QHelpEngineCore::namespaceName(fileName);
         if(!nameSpace.isEmpty()){
             QtHelpProvider *provider = nullptr;
             foreach(QtHelpProvider* oldProvider, oldList){
                 if(QHelpEngineCore::namespaceName(oldProvider->fileName()) == nameSpace){
                     provider = oldProvider;
                     oldList.removeAll(provider);
                     break;
                 }
             }
             if(!provider){
                 provider = new QtHelpProvider(this, fileName, name, iconName, QVariantList());
             }else{
                 provider->setName(name);
                 provider->setIconName(iconName);
             }
 
             bool exist = false;
             foreach(QtHelpProvider* existingProvider, m_qtHelpProviders){
                 if(QHelpEngineCore::namespaceName(existingProvider->fileName()) ==  nameSpace){
                     exist = true;
                     break;
                 }
             }
 
             if(!exist){
                 m_qtHelpProviders.append(provider);
             }
         }
     }
 
     // delete unused providers
     qDeleteAll(oldList);
 }
 
 QList<KDevelop::IDocumentationProvider*> QtHelpPlugin::providers()
 {
     QList<KDevelop::IDocumentationProvider*> list;
     foreach(QtHelpProvider* provider, m_qtHelpProviders) {
         list.append(provider);
     }
     if(m_loadSystemQtDoc){
         list.append(m_qtDoc);
     }
     return list;
 }
 
 QList<QtHelpProvider*> QtHelpPlugin::qtHelpProviderLoaded()
 {
     return m_qtHelpProviders;
 }
 
 bool QtHelpPlugin::isQtHelpQtDocLoaded() const
 {
     return m_loadSystemQtDoc;
 }
 
 bool QtHelpPlugin::isQtHelpAvailable() const
 {
     return !m_qtDoc->qchFiles().isEmpty();
 }
 
 KDevelop::ConfigPage* QtHelpPlugin::configPage(int number, QWidget* parent)
 {
     if (number == 0) {
         return new QtHelpConfig(this, parent);
     }
     return nullptr;
 }
 
 int QtHelpPlugin::configPages() const
 {
     return 1;
 }
 
 #include "qthelpplugin.moc"
diff --git a/documentation/qthelp/qthelpproviderabstract.cpp b/documentation/qthelp/qthelpproviderabstract.cpp
index 2d42cb99d3..165d7f30b8 100644
--- a/documentation/qthelp/qthelpproviderabstract.cpp
+++ b/documentation/qthelp/qthelpproviderabstract.cpp
@@ -1,111 +1,110 @@
 /*  This file is part of KDevelop
     Copyright 2009 Aleix Pol <aleixpol@kde.org>
     Copyright 2009 David Nolden <david.nolden.kdevelop@art-master.de>
     Copyright 2010 Benjamin Port <port.benjamin@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 "qthelpprovider.h"
 
 #include <QHelpIndexModel>
-#include <QTemporaryFile>
 #include <QHelpContentModel>
 
 #include <QStandardPaths>
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/parsingenvironment.h>
 
 #include "qthelpdocumentation.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 QtHelpProviderAbstract::QtHelpProviderAbstract(QObject *parent, const QString &collectionFileName, const QVariantList &args)
     : QObject(parent)
     , m_engine(QStandardPaths::writableLocation(QStandardPaths::DataLocation)+'/'+collectionFileName)
 {
     Q_UNUSED(args);
     if( !m_engine.setupData() ) {
         qWarning() << "Couldn't setup QtHelp Collection file";
     }
 }
 
 
 QtHelpProviderAbstract::~QtHelpProviderAbstract()
 {
 }
 
 IDocumentation::Ptr QtHelpProviderAbstract::documentationForDeclaration(Declaration* dec) const
 {
     QtHelpDocumentation::s_provider = const_cast<QtHelpProviderAbstract*>(this);
     if (dec) {
         static const IndexedString qmlJs("QML/JS");
         QString id;
 
         {
             DUChainReadLocker lock;
             id = dec->qualifiedIdentifier().toString(RemoveTemplateInformation);
             if (dec->topContext()->parsingEnvironmentFile()->language() == qmlJs && !id.isEmpty())
                 id = QLatin1String("QML.") + id;
         }
 
         if (!id.isEmpty()) {
             QMap<QString, QUrl> links = m_engine.linksForIdentifier(id);
 
             if(!links.isEmpty())
                 return IDocumentation::Ptr(new QtHelpDocumentation(id, links));
         }
     }
 
     return {};
 }
 
 QAbstractListModel* QtHelpProviderAbstract::indexModel() const
 {
     QtHelpDocumentation::s_provider = const_cast<QtHelpProviderAbstract*>(this);
     return m_engine.indexModel();
 }
 
 IDocumentation::Ptr QtHelpProviderAbstract::documentationForIndex(const QModelIndex& idx) const
 {
     QtHelpDocumentation::s_provider = const_cast<QtHelpProviderAbstract*>(this);
     QString name=idx.data(Qt::DisplayRole).toString();
     return IDocumentation::Ptr(new QtHelpDocumentation(name, m_engine.indexModel()->linksForKeyword(name)));
 }
 
 void QtHelpProviderAbstract::jumpedTo(const QUrl& newUrl) const
 {
     QtHelpDocumentation::s_provider = const_cast<QtHelpProviderAbstract*>(this);
     QMap<QString, QUrl> info;
     info.insert(newUrl.toString(), newUrl);
     IDocumentation::Ptr doc(new QtHelpDocumentation(newUrl.toString(), info));
     emit addHistory(doc);
 }
 
 IDocumentation::Ptr QtHelpProviderAbstract::homePage() const
 {
     QtHelpDocumentation::s_provider = const_cast<QtHelpProviderAbstract*>(this);
     return IDocumentation::Ptr(new HomeDocumentation);
 }
 
 bool QtHelpProviderAbstract::isValid() const
 {
     return !m_engine.registeredDocumentations().isEmpty();
 }
diff --git a/documentation/qthelp/qthelpproviderabstract.h b/documentation/qthelp/qthelpproviderabstract.h
index 1f5f1b28fb..1d74546e37 100644
--- a/documentation/qthelp/qthelpproviderabstract.h
+++ b/documentation/qthelp/qthelpproviderabstract.h
@@ -1,58 +1,56 @@
 /*  This file is part of KDevelop
     Copyright 2009 Aleix Pol <aleixpol@kde.org>
     Copyright 2009 David Nolden <david.nolden.kdevelop@art-master.de>
     Copyright 2010 Benjamin Port <port.benjamin@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.
 */
 
 #ifndef QTHELPPROVIDERABSTRACT_H
 #define QTHELPPROVIDERABSTRACT_H
 
 #include <interfaces/idocumentationprovider.h>
 #include <QObject>
-#include <QString>
-#include <QUrl>
 #include <QVariantList>
 #include <QHelpEngine>
 
 class QtHelpProviderAbstract : public QObject, public KDevelop::IDocumentationProvider
 {
     Q_OBJECT
     Q_INTERFACES( KDevelop::IDocumentationProvider )
 public:
     QtHelpProviderAbstract(QObject *parent, const QString &collectionFileName, const QVariantList & args);
     virtual ~QtHelpProviderAbstract();
     KDevelop::IDocumentation::Ptr documentationForDeclaration (KDevelop::Declaration*) const override;
 
     KDevelop::IDocumentation::Ptr documentationForIndex(const QModelIndex& idx) const override;
     QAbstractListModel* indexModel() const override;
 
     KDevelop::IDocumentation::Ptr homePage() const override;
 
     /// @return False in case we failed to load any documentation files, else true
     bool isValid() const;
 
     QHelpEngine* engine() { return &m_engine; }
 public slots:
     void jumpedTo(const QUrl& newUrl) const;
 signals:
     void addHistory(const KDevelop::IDocumentation::Ptr& doc) const override;
 protected:
     QHelpEngine m_engine;
 };
 
 #endif // QTHELPPROVIDERABSTRACT_H
diff --git a/file_templates/classes/qt_interface/interface.h b/file_templates/classes/qt_interface/interface.h
index 5b137635be..906dac36d6 100644
--- a/file_templates/classes/qt_interface/interface.h
+++ b/file_templates/classes/qt_interface/interface.h
@@ -1,71 +1,71 @@
 {% extends "cpp_header.h" %}
 {% load kdev_filters %}
 
 {% block includes %}
 {{ block.super }}
 {% if not base_classes %}
-#include <QtPlugin>
+#include <QObject>
 {% endif %}
 {% endblock %}
 
 {% block class_body %}
 public:
 {# doing our own destructor, to ensure there is one #}
 {% if not base_classes %}
     virtual ~{{ name }}();
 {% else %}{# Assumption: subclassing only other interfaces #}
     ~{{ name }}() override;
 {% endif %}
 
     {% for method in public_functions %}
         {# skipping any defined destructor #}
         {% if not method.isDestructor %}
 
         {% include "class_method_declaration_apidox_cpp.txt" %}
         {% include "class_method_declaration_cpp.txt" %}
 
         {% endif %}
     {% endfor %}
 
 {% for property in members %}
 
     {% include "class_property_getter_declaration_apidox_cpp.txt" %}
     virtual {{ property.type }} {{ property.name }}() const = 0;
 
 
     {% include "class_property_setter_declaration_apidox_cpp.txt" %}
     virtual void set{{ property.name|upper_first }}({{ property.type|arg_type }} {{ property.name }}) = 0;
 
 {% endfor %}
 {% if protected_functions %}
 
 protected:
     {% for method in protected_functions %}
         {# skipping any defined destructor #}
         {% if not method.isDestructor %}
 
         {% include "class_method_declaration_apidox_cpp.txt" %}
         {% include "class_method_declaration_cpp.txt" %}
 
         {% endif %}
     {% endfor %}
 {% endif %}
 {% if private_functions %}
 
 private:
     {% for method in private_functions %}
     {# skipping any defined destructor #}
     {% if not method.isDestructor %}
 
         {% include "class_method_declaration_apidox_cpp.txt" %}
         {% include "class_method_declaration_cpp.txt" %}
 
     {% endif %}
     {% endfor %}
 {% endif %}
 {% endblock class_body %}
 
 {% block outside_namespace %}
 {{ block.super }}
 Q_DECLARE_INTERFACE({% if namespaces %}{{ namespaces|join:"::" }}::{% endif %}{{ name }}, "{{ interfaceid }}")
 {% endblock %}
diff --git a/file_templates/testing/cpp_qtestlib/class.cpp b/file_templates/testing/cpp_qtestlib/class.cpp
index f978bbe4cb..843e501f3f 100644
--- a/file_templates/testing/cpp_qtestlib/class.cpp
+++ b/file_templates/testing/cpp_qtestlib/class.cpp
@@ -1,49 +1,49 @@
 {% load kdev_filters %}
 {% include "license_header_cpp.txt" %}
 
 #include "{{ output_file_header }}"
 
 
-#include <QtTest>
+#include <QTest>
 
 
 {{ qtest_main }}({{ name }});
 
 
 {% if testCase_initAndCleanup %}
 void {{name}}::initTestCase()
 {
     // Called before the first testfunction is executed
 }
 
 
 void {{name}}::cleanupTestCase()
 {
     // Called after the last testfunction was executed
 }
 
 
 {% endif %}
 {% if test_initAndCleanup %}
 void {{name}}::init()
 {
     // Called before each testfunction is executed
 }
 
 
 void {{name}}::cleanup()
 {
     // Called after every testfunction
 }
 
 
 {% endif %}
 {% for case in testCases %}
 
 void {{ name }}::{% if test_prefixMethods %}test{{ case|upper_first }}{% else %}{{ case }}{% endif %}()
 {
 
 
 }
 
 {% endfor %}
diff --git a/formatters/astyle/astyle_formatter.cpp b/formatters/astyle/astyle_formatter.cpp
index 2ed142ed0a..0a83e7637b 100644
--- a/formatters/astyle/astyle_formatter.cpp
+++ b/formatters/astyle/astyle_formatter.cpp
@@ -1,530 +1,527 @@
 /* This file is part of KDevelop
 *  Copyright (C) 2008 Cédric Pasteur <cedric.pasteur@free.fr>
    Copyright (C) 2001 Matthias Hölzer-Klüpfel <mhk@caldera.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; see the file COPYING.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 
 */
 #include "astyle_formatter.h"
 
-#include <QRadioButton>
-#include <QSpinBox>
-#include <QCheckBox>
 #include <QString>
 
 #include <interfaces/isourceformatter.h>
 #include <util/formattinghelpers.h>
 
 #include "astyle_stringiterator.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 AStyleFormatter::AStyleFormatter()
 : ASFormatter()
 {
 }
 
 QString AStyleFormatter::formatSource(const QString &text, const QString& leftContext, const QString& rightContext)
 {
     QString useText = leftContext + text + rightContext;
 
     AStyleStringIterator is(useText);
     QString output;
     QTextStream os(&output, QIODevice::WriteOnly);
 
     init(&is);
 
     while(hasMoreLines())
         os << QString::fromUtf8(nextLine().c_str()) << endl;
 
     init(nullptr);
 
     return extractFormattedTextFromContext(output, text, leftContext, rightContext, m_options["FillCount"].toInt());
 }
 
 void AStyleFormatter::setOption(const QString &key, const QVariant &value)
 {
     m_options[key] = value;
 }
 
 void AStyleFormatter::updateFormatter()
 {
     qCDebug(ASTYLE) << "Updating option with: " << ISourceFormatter::optionMapToString(m_options) << endl;
     // fill
     int wsCount = m_options["FillCount"].toInt();
     if(m_options["Fill"].toString() == "Tabs") {
         ///TODO: rename FillForce somehow...
         bool force = m_options["FillForce"].toBool();
         AStyleFormatter::setTabSpaceConversionMode(false);
         AStyleFormatter::setTabIndentation(wsCount, force );
         m_indentString = "\t";
     } else {
         AStyleFormatter::setSpaceIndentation(wsCount);
         m_indentString = "";
         m_indentString.fill(' ', wsCount);
 
         AStyleFormatter::setTabSpaceConversionMode(m_options["FillForce"].toBool());
     }
 
     AStyleFormatter::setEmptyLineFill(m_options["Fill_EmptyLines"].toBool());
 
     // indent
     AStyleFormatter::setSwitchIndent(m_options["IndentSwitches"].toBool());
     AStyleFormatter::setClassIndent(m_options["IndentClasses"].toBool());
     AStyleFormatter::setCaseIndent(m_options["IndentCases"].toBool());
     AStyleFormatter::setBracketIndent(m_options["IndentBrackets"].toBool());
     AStyleFormatter::setNamespaceIndent(m_options["IndentNamespaces"].toBool());
     AStyleFormatter::setLabelIndent(m_options["IndentLabels"].toBool());
     AStyleFormatter::setBlockIndent(m_options["IndentBlocks"].toBool());
     AStyleFormatter::setPreprocessorIndent(m_options["IndentPreprocessors"].toBool());
 
     // continuation
     AStyleFormatter::setMaxInStatementIndentLength(m_options["MaxStatement"].toInt());
     if(m_options["MinConditional"].toInt() != -1)
         AStyleFormatter::setMinConditionalIndentLength(m_options["MinConditional"].toInt());
 
     // brackets
     QString s = m_options["Brackets"].toString();
     if(s == "Break")
         AStyleFormatter::setBracketFormatMode(astyle::BREAK_MODE);
     else if(s == "Attach")
         AStyleFormatter::setBracketFormatMode(astyle::ATTACH_MODE);
     else if(s == "Linux")
         AStyleFormatter::setBracketFormatMode(astyle::LINUX_MODE);
     else if(s == "Stroustrup")
         AStyleFormatter::setBracketFormatMode(astyle::STROUSTRUP_MODE);
     else if(s == "Horstmann" || s == "RunInMode")
         AStyleFormatter::setBracketFormatMode(astyle::RUN_IN_MODE);
     else
         AStyleFormatter::setBracketFormatMode(astyle::NONE_MODE);
 
     AStyleFormatter::setBreakClosingHeaderBracketsMode(m_options["BracketsCloseHeaders"].toBool());
     // blocks
     AStyleFormatter::setBreakBlocksMode(m_options["BlockBreak"].toBool());
     AStyleFormatter::setBreakClosingHeaderBlocksMode(m_options["BlockBreakAll"].toBool());
     AStyleFormatter::setBreakElseIfsMode(m_options["BlockIfElse"].toBool());
 
     // padding
     AStyleFormatter::setOperatorPaddingMode(m_options["PadOperators"].toBool());
     AStyleFormatter::setParensInsidePaddingMode(m_options["PadParenthesesIn"].toBool());
     AStyleFormatter::setParensOutsidePaddingMode(m_options["PadParenthesesOut"].toBool());
     AStyleFormatter::setParensHeaderPaddingMode(m_options["PadParenthesesHeader"].toBool());
     AStyleFormatter::setParensUnPaddingMode(m_options["PadParenthesesUn"].toBool());
 
     // oneliner
     AStyleFormatter::setBreakOneLineBlocksMode(!m_options["KeepBlocks"].toBool());
     AStyleFormatter::setSingleStatementsMode(!m_options["KeepStatements"].toBool());
 
     // pointer
     s = m_options["PointerAlign"].toString();
     if(s == "Name")
         AStyleFormatter::setPointerAlignment(astyle::PTR_ALIGN_NAME);
     else if(s == "Middle")
         AStyleFormatter::setPointerAlignment(astyle::PTR_ALIGN_MIDDLE);
     else if(s == "Type")
         AStyleFormatter::setPointerAlignment(astyle::PTR_ALIGN_TYPE);
     else
         AStyleFormatter::setPointerAlignment(astyle::PTR_ALIGN_NONE);
 }
 
 void AStyleFormatter::resetStyle()
 {
     setSpaceIndentation(4);
     setBracketFormatMode(astyle::NONE_MODE);
     setBreakOneLineBlocksMode(true);
     setSingleStatementsMode(true);
     // blocks
     setBreakBlocksMode(false);
     setBreakClosingHeaderBlocksMode(false);
     setBreakElseIfsMode(false);
     setBreakClosingHeaderBracketsMode(false);
     //indent
     setTabIndentation(4, false);
     setEmptyLineFill(false);
     setMaxInStatementIndentLength(40);
     setMinConditionalIndentLength(-1);
     setSwitchIndent(true);
     setClassIndent(true);
     setCaseIndent(false);
     setBracketIndent(false);
     setNamespaceIndent(true);
     setLabelIndent(true);
     setBlockIndent(false);
     setPreprocessorIndent(false);
     //padding
     setOperatorPaddingMode(false);
     setParensInsidePaddingMode(true);
     setParensOutsidePaddingMode(true);
     setParensHeaderPaddingMode(true);
     setParensUnPaddingMode(true);
 }
 
 bool AStyleFormatter::predefinedStyle( const QString & style )
 {
     if(style == "ANSI") {
         resetStyle();
         setBracketIndent(false);
         setSpaceIndentation(4);
         setBracketFormatMode(astyle::BREAK_MODE);
         setClassIndent(false);
         setSwitchIndent(false);
         setNamespaceIndent(false);
         return true;
     } else if(style == "K&R") {
         resetStyle();
         setBracketIndent(false);
         setSpaceIndentation(4);
         setBracketFormatMode(astyle::ATTACH_MODE);
         setClassIndent(false);
         setSwitchIndent(false);
         setNamespaceIndent(false);
         return true;
     } else if(style == "Linux") {
         resetStyle();
         setBracketIndent(false);
         setSpaceIndentation(8);
         setBracketFormatMode(astyle::LINUX_MODE);
         setClassIndent(false);
         setSwitchIndent(false);
         setNamespaceIndent(false);
         return true;
     } else if(style == "GNU") {
         resetStyle();
         setBlockIndent(true);
         setSpaceIndentation(2);
         setBracketFormatMode(astyle::BREAK_MODE);
         setClassIndent(false);
         setSwitchIndent(false);
         setNamespaceIndent(false);
         return true;
     } else if(style == "Java") {
         resetStyle();
         setJavaStyle();
         setBracketIndent(false);
         setSpaceIndentation(4);
         setBracketFormatMode(astyle::ATTACH_MODE);
         setSwitchIndent(false);
         return true;
     } else if (style == "Stroustrup") {
         resetStyle();
         setBracketFormatMode(astyle::STROUSTRUP_MODE);
         setBlockIndent(false);
         setBracketIndent(false);
         setSpaceIndentation(5);
         setClassIndent(false);
         setSwitchIndent(false);
         setNamespaceIndent(false);
         return true;
     } else if (style == "Horstmann") {
         resetStyle();
         setBracketFormatMode(astyle::RUN_IN_MODE);
         setBlockIndent(false);
         setBracketIndent(false);
         setSwitchIndent(true);
         setSpaceIndentation(3);
         setClassIndent(false);
         setNamespaceIndent(false);
         return true;
     } else if (style == "Whitesmith") {
         resetStyle();
         setSpaceIndentation(4);
         setBracketFormatMode(astyle::BREAK_MODE);
         setBlockIndent(false);
         setBracketIndent(true);
         setClassIndent(true);
         setSwitchIndent(true);
         setNamespaceIndent(false);
         return true;
     } else if (style == "Banner") {
         resetStyle();
         setSpaceIndentation(4);
         setBracketFormatMode(astyle::ATTACH_MODE);
         setBlockIndent(false);
         setBracketIndent(true);
         setClassIndent(true);
         setSwitchIndent(true);
         setNamespaceIndent(false);
         return true;
     } else if (style == "1TBS") {
         resetStyle();
         setSpaceIndentation(4);
         setBracketFormatMode(astyle::LINUX_MODE);
         setBlockIndent(false);
         setBracketIndent(false);
         setAddBracketsMode(true);
         setClassIndent(false);
         setSwitchIndent(false);
         setNamespaceIndent(false);
         return true;
     } else if (style == "KDELibs") {
         // http://techbase.kde.org/Policies/Kdelibs_Coding_Style
         resetStyle();
         setSpaceIndentation(4);
         setBracketFormatMode(astyle::LINUX_MODE);
         setPointerAlignment(astyle::PTR_ALIGN_TYPE);
         setLabelIndent(true);
         setOperatorPaddingMode(true);
         setParensInsidePaddingMode(false);
         setParensOutsidePaddingMode(false);
         setParensHeaderPaddingMode(true);
         setParensUnPaddingMode(true);
         setSingleStatementsMode(false);
         setTabSpaceConversionMode(true);
         setPreprocessorIndent(true);
         setSwitchIndent(false);
         setClassIndent(false);
         setNamespaceIndent(false);
         return true;
     } else if (style == "Qt") {
         // http://qt-project.org/wiki/Qt_Coding_Style
         resetStyle();
         setPointerAlignment(astyle::PTR_ALIGN_NAME);
         setOperatorPaddingMode(true);
         setBracketFormatMode(astyle::LINUX_MODE);
         setSwitchIndent(false);
         setParensInsidePaddingMode(false);
         setParensOutsidePaddingMode(false);
         setParensHeaderPaddingMode(true);
         setParensUnPaddingMode(true);
         setSpaceIndentation(4);
         setClassIndent(false);
         setNamespaceIndent(false);
         return true;
     }
 
     return false;
 }
 
 QVariant AStyleFormatter::option(const QString &key)
 {
     if(!m_options.contains(key))
         qCDebug(ASTYLE) << "Missing option name " << key << endl;
     return m_options[key];
 }
 
 QString AStyleFormatter::indentString()
 {
     return QString(getIndentString().c_str());
 }
 
 void AStyleFormatter::loadStyle(const QString &content)
 {
     m_options = ISourceFormatter::stringToOptionMap(content);
     updateFormatter();
 }
 
 QString AStyleFormatter::saveStyle()
 {
     return ISourceFormatter::optionMapToString(m_options);
 }
 
 void AStyleFormatter::setTabIndentation(int length, bool forceTabs)
 {
     ASFormatter::setTabIndentation(length, forceTabs);
     m_options["Fill"] = "Tabs";
     m_options["FillForce"] = forceTabs;
     m_options["FillCount"] = length;
 }
 
 void AStyleFormatter::setSpaceIndentation(int length)
 {
     ASFormatter::setSpaceIndentation(length);
     m_options["Fill"] = "Spaces";
     m_options["FillCount"] = length;
 }
 
 void AStyleFormatter::setTabSpaceConversionMode(bool mode)
 {
     m_options["FillForce"] = mode;
     ASFormatter::setTabSpaceConversionMode(mode);
 }
 
 void AStyleFormatter::setFillEmptyLines(bool on)
 {
     m_options["FillEmptyLines"] = on;
     ASFormatter::setEmptyLineFill(on);
 }
 
 void AStyleFormatter::setBlockIndent(bool on)
 {
     m_options["IndentBlocks"] = on;
     ASFormatter::setBlockIndent(on);
 }
 
 void AStyleFormatter::setBracketIndent(bool on)
 {
     m_options["IndentBrackets"] = on;
     ASFormatter::setBracketIndent(on);
 }
 
 void AStyleFormatter::setCaseIndent(bool on)
 {
     m_options["IndentCases"] = on;
     ASFormatter::setCaseIndent(on);
 }
 
 void AStyleFormatter::setClassIndent(bool on)
 {
     m_options["IndentClasses"] = on;
     ASFormatter::setClassIndent(on);
 }
 
 void AStyleFormatter::setLabelIndent(bool on)
 {
     m_options["IndentLabels"] = on;
     ASFormatter::setLabelIndent(on);
 }
 
 void AStyleFormatter::setNamespaceIndent(bool on)
 {
     m_options["IndentNamespaces"] = on;
     ASFormatter::setNamespaceIndent(on);
 }
 
 void AStyleFormatter::setPreprocessorIndent(bool on)
 {
     m_options["IndentPreprocessors"] = on;
     ASFormatter::setPreprocDefineIndent(on);
 }
 
 void AStyleFormatter::setSwitchIndent(bool on)
 {
     m_options["IndentSwitches"] = on;
     ASFormatter::setSwitchIndent(on);
 }
 
 void AStyleFormatter::setMaxInStatementIndentLength(int max)
 {
     m_options["MaxStatement"] = max;
     ASFormatter::setMaxInStatementIndentLength(max);
 }
 
 void AStyleFormatter::setMinConditionalIndentLength(int min)
 {
     m_options["MinConditional"] = min;
     ASFormatter::setMinConditionalIndentOption(min);
     ASFormatter::setMinConditionalIndentLength();
 }
 
 void AStyleFormatter::setBracketFormatMode(astyle::BracketMode mode)
 {
     switch (mode) {
     case astyle::NONE_MODE:
         m_options["Brackets"] = "";
         break;
     case astyle::ATTACH_MODE:
         m_options["Brackets"] = "Attach";
         break;
     case astyle::BREAK_MODE:
         m_options["Brackets"] = "Break";
         break;
     case astyle::LINUX_MODE:
         m_options["Brackets"] = "Linux";
         break;
     case astyle::STROUSTRUP_MODE:
         m_options["Brackets"] = "Stroustrup";
         break;
     case astyle::RUN_IN_MODE:
         m_options["Brackets"] = "RunInMode";
         break;
     }
     ASFormatter::setBracketFormatMode(mode);
 }
 
 void AStyleFormatter::setBreakClosingHeaderBracketsMode(bool state)
 {
     m_options["BracketsCloseHeaders"] = state;
     ASFormatter::setBreakClosingHeaderBracketsMode(state);
 }
 
 void AStyleFormatter::setBreakBlocksMode(bool state)
 {
     m_options["BlockBreak"] = state;
     ASFormatter::setBreakBlocksMode(state);
 }
 
 void AStyleFormatter::setBreakElseIfsMode(bool state)
 {
     m_options["BlockIfElse"] = state;
     ASFormatter::setBreakElseIfsMode(state);
 }
 
 void AStyleFormatter::setBreakClosingHeaderBlocksMode(bool state)
 {
     m_options["BlockBreakAll"] = state;
     ASFormatter::setBreakClosingHeaderBlocksMode(state);
 }
 
 void AStyleFormatter::setOperatorPaddingMode(bool mode)
 {
     m_options["PadOperators"] = mode;
     ASFormatter::setOperatorPaddingMode(mode);
 }
 
 void AStyleFormatter::setParensOutsidePaddingMode(bool mode)
 {
     m_options["PadParenthesesOut"] = mode;
     ASFormatter::setParensOutsidePaddingMode(mode);
 }
 
 void AStyleFormatter::setParensInsidePaddingMode(bool mode)
 {
     m_options["PadParenthesesIn"] = mode;
     ASFormatter::setParensInsidePaddingMode(mode);
 }
 
 void AStyleFormatter::setParensHeaderPaddingMode(bool mode) {
     m_options["PadParenthesesHeader"] = mode;
     ASFormatter::setParensHeaderPaddingMode(mode);
 }
 
 void AStyleFormatter::setParensUnPaddingMode(bool state)
 {
     m_options["PadParenthesesUn"] = state;
     ASFormatter::setParensUnPaddingMode(state);
 }
 
 void AStyleFormatter::setBreakOneLineBlocksMode(bool state)
 {
     m_options["KeepBlocks"] = !state;
     ASFormatter::setBreakOneLineBlocksMode(state);
 }
 
 void AStyleFormatter::setSingleStatementsMode(bool state)
 {
     m_options["KeepStatements"] = !state;
     ASFormatter::setSingleStatementsMode(state);
 }
 
 void AStyleFormatter::setPointerAlignment(astyle::PointerAlign alignment)
 {
     switch (alignment) {
         case astyle::PTR_ALIGN_NONE:
             m_options["PointerAlign"] = "None";
             break;
         case astyle::PTR_ALIGN_NAME:
             m_options["PointerAlign"] = "Name";
             break;
         case astyle::PTR_ALIGN_MIDDLE:
             m_options["PointerAlign"] = "Middle";
             break;
         case astyle::PTR_ALIGN_TYPE:
             m_options["PointerAlign"] = "Type";
             break;
     }
     ASFormatter::setPointerAlignment(alignment);
 }
diff --git a/formatters/astyle/astyle_formatter.h b/formatters/astyle/astyle_formatter.h
index 6548483c24..91c2951e63 100644
--- a/formatters/astyle/astyle_formatter.h
+++ b/formatters/astyle/astyle_formatter.h
@@ -1,92 +1,90 @@
 /* This file is part of KDevelop
 *  Copyright (C) 2008 Cédric Pasteur <cedric.pasteur@free.fr>
 Copyright (C) 2001 Matthias Hölzer-Klüpfel <mhk@caldera.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; see the file COPYING.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 
 */
 
 #ifndef ASTYLEFORMATTER_H
 #define ASTYLEFORMATTER_H
 
-#include <QMap>
 #include <QVariant>
 #include <QString>
-#include <QStringList>
 
 #include "astyle.h"
 
 class AStyleFormatter : public astyle::ASFormatter
 {
 public:
     /** Creates an empty AStyleFormatter with C style by default.
     */
     AStyleFormatter();
 
     QString formatSource(const QString& text, const QString& leftContext = QString(), const QString& rightContext = QString());
 
     QVariant option(const QString &name);
     void setOption(const QString &key, const QVariant &value);
     QString indentString();
 
     bool predefinedStyle(const QString &name);
     void loadStyle(const QString &content);
     QString saveStyle();
 
     // indent
     void setTabIndentation(int length, bool forceTabs);
     void setSpaceIndentation(int length);
     void setTabSpaceConversionMode(bool mode);
     void setFillEmptyLines(bool on);
     void setBlockIndent(bool on);
     void setBracketIndent(bool on);
     void setCaseIndent(bool on);
     void setClassIndent(bool on);
     void setLabelIndent(bool on);
     void setNamespaceIndent(bool on);
     void setPreprocessorIndent(bool on);
     void setSwitchIndent(bool on);
     void setMaxInStatementIndentLength(int max);
     void setMinConditionalIndentLength(int min);
     //brackets
     void setBracketFormatMode(astyle::BracketMode mode);
     void setBreakClosingHeaderBracketsMode(bool state);
     //blocks
     void setBreakBlocksMode(bool state);
     void setBreakElseIfsMode(bool state);
     void setBreakClosingHeaderBlocksMode(bool state);
     //padding
     void setOperatorPaddingMode(bool mode);
     void setParensOutsidePaddingMode(bool mode);
     void setParensInsidePaddingMode(bool mode);
     void setParensHeaderPaddingMode(bool mode);
     void setParensUnPaddingMode(bool state);
     //oneliners
     void setBreakOneLineBlocksMode(bool state);
     void setSingleStatementsMode(bool state);
     //pointer
     void setPointerAlignment(astyle::PointerAlign alignment);
 
 protected:
     void updateFormatter();
     void resetStyle();
 
 private:
     QString m_indentString;
     QVariantMap m_options;
 };
 
 #endif // ASTYLEFORMATTER_H
diff --git a/formatters/astyle/astyle_plugin.cpp b/formatters/astyle/astyle_plugin.cpp
index 12c9d56429..e203dcaa7f 100644
--- a/formatters/astyle/astyle_plugin.cpp
+++ b/formatters/astyle/astyle_plugin.cpp
@@ -1,266 +1,264 @@
 /* This file is part of KDevelop
 *  Copyright (C) 2008 Cédric Pasteur <cedric.pasteur@free.fr>
    Copyright (C) 2001 Matthias Hölzer-Klüpfel <mhk@caldera.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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
 
 #include "astyle_plugin.h"
 
 #include <QMimeDatabase>
 
-#include <KPluginLoader>
 #include <KPluginFactory>
-#include <KAboutData>
 
 #include <interfaces/icore.h>
 #include <interfaces/isourceformattercontroller.h>
 
 #include "astyle_formatter.h"
 #include "astyle_stringiterator.h"
 #include "astyle_preferences.h"
 #include <KLocalizedString>
 #include <QUrl>
 
 using namespace KDevelop;
 
 K_PLUGIN_FACTORY_WITH_JSON(AStyleFactory, "kdevastyle.json", registerPlugin<AStylePlugin>();)
 
 AStylePlugin::AStylePlugin(QObject *parent, const QVariantList&)
     : IPlugin("kdevastyle", parent)
     , m_formatter(new AStyleFormatter())
 {
     currentStyle = predefinedStyles().at(0);
 }
 
 AStylePlugin::~AStylePlugin()
 {
 }
 
 QString AStylePlugin::name()
 {
     // This needs to match the X-KDE-PluginInfo-Name entry from the .desktop file!
     return QStringLiteral("kdevastyle");
 }
 
 QString AStylePlugin::caption()
 {
     return QStringLiteral("Artistic Style");
 }
 
 QString AStylePlugin::description()
 {
     return i18n("<b>Artistic Style</b> is a source code indenter, formatter,"
         " and beautifier for the C, C++, C# and Java programming languages.<br />"
         "Home Page: <a href=\"http://astyle.sourceforge.net/\">http://astyle.sourceforge.net</a>");
 }
 
 QString AStylePlugin::formatSourceWithStyle( SourceFormatterStyle s, const QString& text, const QUrl& /*url*/, const QMimeType& mime, const QString& leftContext, const QString& rightContext )
 {
     if(mime.inherits(QStringLiteral("text/x-java")))
         m_formatter->setJavaStyle();
     else if(mime.inherits(QStringLiteral("text/x-csharp")))
         m_formatter->setSharpStyle();
     else
         m_formatter->setCStyle();
 
     if( s.content().isEmpty() )
     {
         m_formatter->predefinedStyle( s.name() );
     } else
     {
         m_formatter->loadStyle( s.content() );
     }
     
     return m_formatter->formatSource(text, leftContext, rightContext);
 }
 
 QString AStylePlugin::formatSource(const QString& text, const QUrl &url, const QMimeType& mime, const QString& leftContext, const QString& rightContext)
 {
     return formatSourceWithStyle( ICore::self()->sourceFormatterController()->styleForMimeType( mime ), text, url, mime, leftContext, rightContext );
 }
 
 static SourceFormatterStyle::MimeList supportedMimeTypes()
 {
     return {
         {QStringLiteral("text/x-c++src"), QStringLiteral("C++")},
         {QStringLiteral("text/x-chdr"), QStringLiteral("C")},
         {QStringLiteral("text/x-c++hdr"), QStringLiteral("C++")},
         {QStringLiteral("text/x-csrc"), QStringLiteral("C")},
         {QStringLiteral("text/x-java"), QStringLiteral("Java")},
         {QStringLiteral("text/x-csharp"), QStringLiteral("C#")},
     };
 }
 
 SourceFormatterStyle predefinedStyle(const QString& name, const QString& caption = QString())
 {
     SourceFormatterStyle st = SourceFormatterStyle( name );
     st.setCaption( caption.isEmpty() ? name : caption );
     AStyleFormatter fmt;
     fmt.predefinedStyle( name );
     st.setContent( fmt.saveStyle() );
     st.setMimeTypes(supportedMimeTypes());
     return st;
 }
 
 QList<SourceFormatterStyle> AStylePlugin::predefinedStyles()
 {
     return {
         predefinedStyle(QStringLiteral("ANSI")),
         predefinedStyle(QStringLiteral("GNU")),
         predefinedStyle(QStringLiteral("Java")),
         predefinedStyle(QStringLiteral("K&R"), QStringLiteral("Kernighan & Ritchie")),
         predefinedStyle(QStringLiteral("Linux")),
         predefinedStyle(QStringLiteral("Stroustrup")),
         predefinedStyle(QStringLiteral("Horstmann")),
         predefinedStyle(QStringLiteral("Whitesmith")),
         predefinedStyle(QStringLiteral("Banner")),
         predefinedStyle(QStringLiteral("1TBS")),
         predefinedStyle(QStringLiteral("KDELibs")),
         predefinedStyle(QStringLiteral("Qt")),
     };
 }
 
 SettingsWidget* AStylePlugin::editStyleWidget(const QMimeType& mime)
 {
     AStylePreferences::Language lang = AStylePreferences::CPP;
     if(mime.inherits("text/x-java"))
         lang = AStylePreferences::Java;
     else if(mime.inherits("text/x-csharp"))
         lang = AStylePreferences::CSharp;
     return new AStylePreferences(lang);
 }
 
 QString AStylePlugin::previewText(const SourceFormatterStyle& /*style*/, const QMimeType& /*mime*/)
 {
     return "// Indentation\n" + indentingSample() + "\t// Formatting\n"
         + formattingSample();
 }
 
 AStylePlugin::Indentation AStylePlugin::indentation( const QUrl &url )
 {
     // Call formatSource first, to initialize the m_formatter data structures according to the URL
     formatSource( "", url, QMimeDatabase().mimeTypeForUrl(url), QString(), QString() );
 
     Indentation ret;
 
     ret.indentWidth = m_formatter->option("FillCount").toInt();
     
     QString s = m_formatter->option("Fill").toString();
     if(s == "Tabs")
     {
         // Do tabs-only indentation
         ret.indentationTabWidth = ret.indentWidth;
     }else{
         // Don't use tabs at all
         ret.indentationTabWidth = -1;
     }
     
     return ret;
 }
 
 QString AStylePlugin::formattingSample()
 {
     return 
     "void func(){\n"
     "\tif(isFoo(a,b))\n"
     "\tbar(a,b);\n"
     "if(isFoo)\n"
     "\ta=bar((b-c)*a,*d--);\n"
     "if(  isFoo( a,b ) )\n"
     "\tbar(a, b);\n"
     "if (isFoo) {isFoo=false;cat << isFoo <<endl;}\n"
     "if(isFoo)DoBar();if (isFoo){\n"
     "\tbar();\n"
     "}\n"
     "\telse if(isBar()){\n"
     "\tannotherBar();\n"
     "}\n"
     "int var = 1;\n"
     "int *ptr = &var;\n"
     "int& ref = i;\n"
     "\n"
     "QList<int>::const_iterator it = list.begin();\n"
     "}\n"
     "namespace A {\n"
     "namespace B {\n"
     "class someClass {\n"
     "void foo() {\n"
     "  if (true) {\n"
     "    func();\n"
     "  } else {\n"
     "    // bla\n"
     "  }\n"
     "}\n"
     "};\n"
     "}\n"
     "}\n";
 }
 
 QString AStylePlugin::indentingSample()
 {
     return
     "#define foobar(A)\\\n"
     "{Foo();Bar();}\n"
     "#define anotherFoo(B)\\\n"
     "return Bar()\n"
     "\n"
     "namespace Bar\n"
     "{\n"
     "class Foo\n"
     "{public:\n"
     "Foo();\n"
     "virtual ~Foo();\n"
     "};\n"
     "switch (foo)\n"
     "{\n"
     "case 1:\n"
     "a+=1;\n"
     "break;\n"
     "case 2:\n"
     "{\n"
     "a += 2;\n"
     " break;\n"
     "}\n"
     "}\n"
     "if (isFoo)\n"
     "{\n"
     "bar();\n"
     "}\n"
     "else\n"
     "{\n"
     "anotherBar();\n"
     "}\n"
     "int foo()\n"
     "\twhile(isFoo)\n"
     "\t\t{\n"
     "\t\t\t...\n"
     "\t\t\tgoto error;\n"
     "\t\t....\n"
     "\t\terror:\n"
     "\t\t\t...\n"
     "\t\t}\n"
     "\t}\n"
     "fooArray[]={ red,\n"
     "\tgreen,\n"
     "\tdarkblue};\n"
     "fooFunction(barArg1,\n"
     "\tbarArg2,\n"
     "\tbarArg3);\n"
     "struct foo{ int bar() {} };\n";
 }
 
 #include "astyle_plugin.moc"
diff --git a/formatters/customscript/customscript_plugin.cpp b/formatters/customscript/customscript_plugin.cpp
index 145fd53d78..2b7ac7ae92 100644
--- a/formatters/customscript/customscript_plugin.cpp
+++ b/formatters/customscript/customscript_plugin.cpp
@@ -1,553 +1,551 @@
 /* This file is part of KDevelop
    Copyright (C) 2008 Cédric Pasteur <cedric.pasteur@free.fr>
    Copyright (C) 2011 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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
 
 #include "customscript_plugin.h"
 
-#include <KPluginLoader>
 #include <KPluginFactory>
-#include <KAboutData>
 #include <QTextStream>
 #include <QTemporaryFile>
 #include <QMimeDatabase>
 #include <KProcess>
 #include <interfaces/icore.h>
 #include <interfaces/isourceformattercontroller.h>
 #include <interfaces/isourceformatter.h>
 #include <memory>
 #include <QDir>
 #include <QLoggingCategory>
 Q_DECLARE_LOGGING_CATEGORY(CUSTOMSCRIPT)
 Q_LOGGING_CATEGORY(CUSTOMSCRIPT, "kdevelop.formatters.customscript")
 
 #include <util/formattinghelpers.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <KMessageBox>
 #include <interfaces/iuicontroller.h>
 #include <KParts/MainWindow>
 #include <KLocalizedString>
 #include <interfaces/ilanguagecontroller.h>
 #include <language/interfaces/ilanguagesupport.h>
 #include <util/path.h>
 
 using namespace KDevelop;
 
 static QPointer<CustomScriptPlugin> indentPluginSingleton;
 
 K_PLUGIN_FACTORY_WITH_JSON(CustomScriptFactory, "kdevcustomscript.json", registerPlugin<CustomScriptPlugin>(); )
 
 // Replaces ${KEY} in command with variables[KEY]
 static QString replaceVariables(QString command, QMap<QString, QString> variables)
 {
     while (command.contains("${")) {
         int pos = command.indexOf("${");
         int end = command.indexOf("}", pos + 2);
         if (end == -1) {
             break;
         }
         QString key = command.mid(pos + 2, end - pos - 2);
 
         if (variables.contains(key)) {
             command.replace(pos, 1 + end - pos, variables[key]);
         } else {
             qCDebug(CUSTOMSCRIPT) << "found no variable while replacing in shell-command" << command << "key" << key << "available:" << variables;
             command.replace(pos, 1 + end - pos, "");
         }
     }
     return command;
 }
 
 CustomScriptPlugin::CustomScriptPlugin(QObject* parent, const QVariantList&)
     : IPlugin("kdevcustomscript", parent)
 {
     m_currentStyle = predefinedStyles().at(0);
     indentPluginSingleton = this;
 }
 
 CustomScriptPlugin::~CustomScriptPlugin()
 {
 }
 
 QString CustomScriptPlugin::name()
 {
     // This needs to match the X-KDE-PluginInfo-Name entry from the .desktop file!
     return "kdevcustomscript";
 }
 
 QString CustomScriptPlugin::caption()
 {
     return "Custom Script Formatter";
 }
 
 QString CustomScriptPlugin::description()
 {
     return i18n("<b>Indent and Format Source Code.</b><br />"
                 "This plugin allows using powerful external formatting tools "
                 "that can be invoked through the command-line.<br />"
                 "For example, the <b>uncrustify</b>, <b>astyle</b> or <b>indent</b> "
                 "formatters can be used.<br />"
                 "The advantage of command-line formatters is that formatting configurations "
                 "can be easily shared by all team members, independent of their preferred IDE.");
 }
 
 QString CustomScriptPlugin::formatSourceWithStyle(SourceFormatterStyle style, const QString& text, const QUrl& url, const QMimeType& /*mime*/, const QString& leftContext, const QString& rightContext)
 {
     KProcess proc;
     QTextStream ios(&proc);
 
     std::unique_ptr<QTemporaryFile> tmpFile;
 
     if (style.content().isEmpty()) {
         style = predefinedStyle(style.name());
         if (style.content().isEmpty()) {
             qWarning() << "Empty contents for style" << style.name() << "for indent plugin";
             return text;
         }
     }
 
     QString useText = text;
     useText = leftContext + useText + rightContext;
 
     QMap<QString, QString> projectVariables;
     foreach (IProject* project, ICore::self()->projectController()->projects()) {
         projectVariables[project->name()] = project->path().toUrl().toLocalFile();
     }
 
     QString command = style.content();
 
     // Replace ${Project} with the project path
     command = replaceVariables(command, projectVariables);
     command.replace("$FILE", url.toLocalFile());
 
     if (command.contains("$TMPFILE")) {
         tmpFile.reset(new QTemporaryFile(QDir::tempPath() + "/code"));
         tmpFile->setAutoRemove(false);
         if (tmpFile->open()) {
             qCDebug(CUSTOMSCRIPT) << "using temporary file" << tmpFile->fileName();
             command.replace("$TMPFILE", tmpFile->fileName());
             QByteArray useTextArray = useText.toLocal8Bit();
             if (tmpFile->write(useTextArray) != useTextArray.size()) {
                 qWarning() << "failed to write text to temporary file";
                 return text;
             }
         } else {
             qWarning() << "Failed to create a temporary file";
             return text;
         }
         tmpFile->close();
     }
 
     qCDebug(CUSTOMSCRIPT) << "using shell command for indentation: " << command;
     proc.setShellCommand(command);
     proc.setOutputChannelMode(KProcess::OnlyStdoutChannel);
 
     proc.start();
     if (!proc.waitForStarted()) {
         qCDebug(CUSTOMSCRIPT) << "Unable to start indent" << endl;
         return text;
     }
 
     if (!tmpFile.get()) {
         proc.write(useText.toLocal8Bit());
     }
 
     proc.closeWriteChannel();
     if (!proc.waitForFinished()) {
         qCDebug(CUSTOMSCRIPT) << "Process doesn't finish" << endl;
         return text;
     }
 
     QString output;
 
     if (tmpFile.get()) {
         QFile f(tmpFile->fileName());
         if (f.open(QIODevice::ReadOnly)) {
             output = QString::fromLocal8Bit(f.readAll());
         } else {
             qWarning() << "Failed opening the temporary file for reading";
             return text;
         }
     } else {
         output = ios.readAll();
     }
     if (output.isEmpty()) {
         qWarning() << "indent returned empty text for style" << style.name() << style.content();
         return text;
     }
 
     int tabWidth = 4;
     if ((!leftContext.isEmpty() || !rightContext.isEmpty()) && (text.contains('	') || output.contains('	'))) {
         // If we have to do contex-matching with tabs, determine the correct tab-width so that the context
         // can be matched correctly
         Indentation indent = indentation(url);
         if (indent.indentationTabWidth > 0) {
             tabWidth = indent.indentationTabWidth;
         }
     }
 
     return KDevelop::extractFormattedTextFromContext(output, text, leftContext, rightContext, tabWidth);
 }
 
 QString CustomScriptPlugin::formatSource(const QString& text, const QUrl& url, const QMimeType& mime, const QString& leftContext, const QString& rightContext)
 {
     return formatSourceWithStyle(KDevelop::ICore::self()->sourceFormatterController()->styleForMimeType(mime), text, url, mime, leftContext, rightContext);
 }
 
 static QList<SourceFormatterStyle> stylesFromLanguagePlugins()
 {
     QList<KDevelop::SourceFormatterStyle> styles;
     foreach (auto lang, ICore::self()->languageController()->loadedLanguages()) {
         const SourceFormatterItemList& languageStyles = lang->sourceFormatterItems();
         for (const SourceFormatterStyleItem& item: languageStyles) {
             if (item.engine == "customscript") {
                 styles << item.style;
             }
         }
     }
 
     return styles;
 };
 
 KDevelop::SourceFormatterStyle CustomScriptPlugin::predefinedStyle(const QString& name)
 {
     for (auto langStyle: stylesFromLanguagePlugins()) {
         qCDebug(CUSTOMSCRIPT) << "looking at style from language with custom sample" << langStyle.description() << langStyle.overrideSample();
         if (langStyle.name() == name) {
             return langStyle;
         }
     }
 
     SourceFormatterStyle result(name);
     if (name == "GNU_indent_GNU") {
         result.setCaption(i18n("Gnu Indent: GNU"));
         result.setContent("indent");
     } else if (name == "GNU_indent_KR") {
         result.setCaption(i18n("Gnu Indent: Kernighan & Ritchie"));
         result.setContent("indent -kr");
     } else if (name == "GNU_indent_orig") {
         result.setCaption(i18n("Gnu Indent: Original Berkeley indent style"));
         result.setContent("indent -orig");
     } else if (name == "kdev_format_source") {
         result.setCaption("KDevelop: kdev_format_source");
         result.setContent("kdev_format_source $FILE $TMPFILE");
         result.setUsePreview(false);
         result.setDescription(i18n("Description:<br />"
                                    "<b>kdev_format_source</b> is a script bundled with KDevelop "
                                    "which allows using fine-grained formatting rules by placing "
                                    "meta-files called <b>format_sources</b> into the file-system.<br /><br />"
                                    "Each line of the <b>format_sources</b> files defines a list of wildcards "
                                    "followed by a colon and the used formatting-command.<br /><br />"
                                    "The formatting-command should use <b>$TMPFILE</b> to reference the "
                                    "temporary file to reformat.<br /><br />"
                                    "Example:<br />"
                                    "<b>*.cpp *.h : myformatter $TMPFILE</b><br />"
                                    "This will reformat all files ending with <b>.cpp</b> or <b>.h</b> using "
                                    "the custom formatting script <b>myformatter</b>.<br /><br />"
                                    "Example: <br />"
                                    "<b>subdir/* : uncrustify -l CPP -f $TMPFILE -c uncrustify.config -o $TMPFILE</b> <br />"
                                    "This will reformat all files in subdirectory <b>subdir</b> using the <b>uncrustify</b> "
                                    "tool with the config-file <b>uncrustify.config</b>."));
     }
     result.setMimeTypes({
         {"text/x-c++src", "C++"}, {"text/x-chdr", "C"},
         {"text/x-c++hdr", "C++"}, {"text/x-csrc", "C"},
         {"text/x-java", "Java"}, {"text/x-csharp", "C#"}
     });
     return result;
 }
 
 QList<KDevelop::SourceFormatterStyle> CustomScriptPlugin::predefinedStyles()
 {
     QList<KDevelop::SourceFormatterStyle> styles = stylesFromLanguagePlugins();
     styles << predefinedStyle("kdev_format_source");
     styles << predefinedStyle("GNU_indent_GNU");
     styles << predefinedStyle("GNU_indent_KR");
     styles << predefinedStyle("GNU_indent_orig");
     return styles;
 }
 
 KDevelop::SettingsWidget* CustomScriptPlugin::editStyleWidget(const QMimeType& mime)
 {
     Q_UNUSED(mime);
     return new CustomScriptPreferences();
 }
 
 static QString formattingSample()
 {
     return
         "// Formatting\n"
         "void func(){\n"
         "\tif(isFoo(a,b))\n"
         "\tbar(a,b);\n"
         "if(isFoo)\n"
         "\ta=bar((b-c)*a,*d--);\n"
         "if(  isFoo( a,b ) )\n"
         "\tbar(a, b);\n"
         "if (isFoo) {isFoo=false;cat << isFoo <<endl;}\n"
         "if(isFoo)DoBar();if (isFoo){\n"
         "\tbar();\n"
         "}\n"
         "\telse if(isBar()){\n"
         "\tannotherBar();\n"
         "}\n"
         "int var = 1;\n"
         "int *ptr = &var;\n"
         "int &ref = i;\n"
         "\n"
         "QList<int>::const_iterator it = list.begin();\n"
         "}\n"
         "namespace A {\n"
         "namespace B {\n"
         "void foo() {\n"
         "  if (true) {\n"
         "    func();\n"
         "  } else {\n"
         "    // bla\n"
         "  }\n"
         "}\n"
         "}\n"
         "}\n";
 }
 
 static QString indentingSample()
 {
     return
         "// Indentation\n"
         "#define foobar(A)\\\n"
         "{Foo();Bar();}\n"
         "#define anotherFoo(B)\\\n"
         "return Bar()\n"
         "\n"
         "namespace Bar\n"
         "{\n"
         "class Foo\n"
         "{public:\n"
         "Foo();\n"
         "virtual ~Foo();\n"
         "};\n"
         "switch (foo)\n"
         "{\n"
         "case 1:\n"
         "a+=1;\n"
         "break;\n"
         "case 2:\n"
         "{\n"
         "a += 2;\n"
         " break;\n"
         "}\n"
         "}\n"
         "if (isFoo)\n"
         "{\n"
         "bar();\n"
         "}\n"
         "else\n"
         "{\n"
         "anotherBar();\n"
         "}\n"
         "int foo()\n"
         "\twhile(isFoo)\n"
         "\t\t{\n"
         "\t\t\t...\n"
         "\t\t\tgoto error;\n"
         "\t\t....\n"
         "\t\terror:\n"
         "\t\t\t...\n"
         "\t\t}\n"
         "\t}\n"
         "fooArray[]={ red,\n"
         "\tgreen,\n"
         "\tdarkblue};\n"
         "fooFunction(barArg1,\n"
         "\tbarArg2,\n"
         "\tbarArg3);\n";
 }
 
 QString CustomScriptPlugin::previewText(const SourceFormatterStyle& style, const QMimeType& /*mime*/)
 {
     if (!style.overrideSample().isEmpty()) {
         return style.overrideSample();
     }
     return formattingSample() + "\n\n" + indentingSample();
 }
 
 QStringList CustomScriptPlugin::computeIndentationFromSample(const QUrl& url)
 {
     QStringList ret;
 
     auto languages = ICore::self()->languageController()->languagesForUrl(url);
     if (languages.isEmpty()) {
         return ret;
     }
 
     QString sample = languages[0]->indentationSample();
     QString formattedSample = formatSource(sample, url, QMimeDatabase().mimeTypeForUrl(url), QString(), QString());
 
     QStringList lines = formattedSample.split("\n");
     foreach (QString line, lines) {
         if (!line.isEmpty() && line[0].isSpace()) {
             QString indent;
             foreach (QChar c, line) {
                 if (c.isSpace()) {
                     indent.push_back(c);
                 } else {
                     break;
                 }
             }
 
             if (!indent.isEmpty() && !ret.contains(indent)) {
                 ret.push_back(indent);
             }
         }
     }
 
     return ret;
 }
 
 CustomScriptPlugin::Indentation CustomScriptPlugin::indentation(const QUrl& url)
 {
     Indentation ret;
     QStringList indent = computeIndentationFromSample(url);
     if (indent.isEmpty()) {
         qCDebug(CUSTOMSCRIPT) << "failed extracting a valid indentation from sample for url" << url;
         return ret; // No valid indentation could be extracted
     }
 
     if (indent[0].contains(' ')) {
         ret.indentWidth = indent[0].count(' ');
     }
 
     if (!indent.join("").contains('	')) {
         ret.indentationTabWidth = -1;         // Tabs are not used for indentation
     }
     if (indent[0] == "	") {
         // The script indents with tabs-only
         // The problem is that we don't know how
         // wide a tab is supposed to be.
         //
         // We need indentation-width=tab-width
         // to make the editor do tab-only formatting,
         // so choose a random with of 4.
         ret.indentWidth = 4;
         ret.indentationTabWidth = 4;
     } else if (ret.indentWidth)   {
         // Tabs are used for indentation, alongside with spaces
         // Try finding out how many spaces one tab stands for.
         // Do it by assuming a uniform indentation-step with each level.
 
         for (int pos = 0; pos < indent.size(); ++pos) {
             if (indent[pos] == "	"&& pos >= 1) {
                 // This line consists of only a tab.
                 int prevWidth = indent[pos - 1].length();
                 int prevPrevWidth = (pos >= 2) ? indent[pos - 2].length() : 0;
                 int step = prevWidth - prevPrevWidth;
                 qCDebug(CUSTOMSCRIPT) << "found in line " << pos << prevWidth << prevPrevWidth << step;
                 if (step > 0 && step <= prevWidth) {
                     qCDebug(CUSTOMSCRIPT) << "Done";
                     ret.indentationTabWidth = prevWidth + step;
                     break;
                 }
             }
         }
     }
 
     qCDebug(CUSTOMSCRIPT) << "indent-sample" << "\"" + indent.join("\n") + "\"" << "extracted tab-width" << ret.indentationTabWidth << "extracted indentation width" << ret.indentWidth;
 
     return ret;
 }
 
 void CustomScriptPreferences::updateTimeout()
 {
     const QString& text = indentPluginSingleton.data()->previewText(m_style, QMimeType());
     QString formatted = indentPluginSingleton.data()->formatSourceWithStyle(m_style, text, QUrl(), QMimeType());
     emit previewTextChanged(formatted);
 }
 
 CustomScriptPreferences::CustomScriptPreferences()
 {
     m_updateTimer = new QTimer(this);
     m_updateTimer->setSingleShot(true);
     connect(m_updateTimer, &QTimer::timeout, this, &CustomScriptPreferences::updateTimeout);
     m_vLayout = new QVBoxLayout(this);
     m_captionLabel = new QLabel;
     m_vLayout->addWidget(m_captionLabel);
     m_vLayout->addSpacing(10);
     m_hLayout = new QHBoxLayout;
     m_vLayout->addLayout(m_hLayout);
     m_commandLabel = new QLabel;
     m_hLayout->addWidget(m_commandLabel);
     m_commandEdit = new QLineEdit;
     m_hLayout->addWidget(m_commandEdit);
     m_commandLabel->setText(i18n("Command:"));
     m_vLayout->addSpacing(10);
     m_bottomLabel = new QLabel;
     m_vLayout->addWidget(m_bottomLabel);
     m_bottomLabel->setTextFormat(Qt::RichText);
     m_bottomLabel->setText(
         i18n("<i>You can enter an arbitrary shell command.</i><br />"
              "The unformatted source-code is reached to the command <br />"
              "through the standard input, and the <br />"
              "formatted result is read from the standard output.<br />"
              "<br />"
              "If you add <b>$TMPFILE</b> into the command, then <br />"
              "a temporary file is used for transferring the code."));
     connect(m_commandEdit, &QLineEdit::textEdited, this, &CustomScriptPreferences::textEdited);
 
     m_vLayout->addSpacing(10);
 
     m_moreVariablesButton = new QPushButton(i18n("More Variables"));
     connect(m_moreVariablesButton, &QPushButton::clicked, this, &CustomScriptPreferences::moreVariablesClicked);
     m_vLayout->addWidget(m_moreVariablesButton);
 }
 
 void CustomScriptPreferences::load(const KDevelop::SourceFormatterStyle& style)
 {
     m_style = style;
     m_commandEdit->setText(style.content());
     m_captionLabel->setText(i18n("Style: %1", style.caption()));
 
     updateTimeout();
 }
 
 QString CustomScriptPreferences::save()
 {
     return m_commandEdit->text();
 }
 
 void CustomScriptPreferences::moreVariablesClicked(bool)
 {
     KMessageBox::information(ICore::self()->uiController()->activeMainWindow(),
                              i18n("<b>$TMPFILE</b> will be replaced with the path to a temporary file. <br />"
                                   "The code will be written into the file, the temporary <br />"
                                   "file will be substituted into that position, and the result <br />"
                                   "will be read out of that file. <br />"
                                   "<br />"
                                   "<b>$FILE</b> will be replaced with the path of the original file. <br />"
                                   "The contents of the file must not be modified, changes are allowed <br />"
                                   "only in $TMPFILE.<br />"
                                   "<br />"
                                   "<b>${PROJECT_NAME}</b> will be replaced by the path of <br />"
                                   "the currently open project with the matching name."
 
                                   ), i18n("Variable Replacements"));
 }
 
 #include "customscript_plugin.moc"
 
 // kate: indent-mode cstyle; space-indent off; tab-width 4;
diff --git a/kdeintegration/executeplasmoid/executeplasmoidplugin.cpp b/kdeintegration/executeplasmoid/executeplasmoidplugin.cpp
index 6c1ed2fe5e..31dee57084 100644
--- a/kdeintegration/executeplasmoid/executeplasmoidplugin.cpp
+++ b/kdeintegration/executeplasmoid/executeplasmoidplugin.cpp
@@ -1,96 +1,95 @@
 /*
   * This file is part of KDevelop
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2009 Niko Sams <niko.sams@gmail.com>
  *
  * 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 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 "executeplasmoidplugin.h"
 #include "plasmoidexecutionconfig.h"
 #include "plasmoidexecutionjob.h"
 #include "debug.h"
 #include <kpluginfactory.h>
-#include <KAboutData>
 #include <QUrl>
 #include <interfaces/icore.h>
 
 using namespace KDevelop;
 
 Q_LOGGING_CATEGORY(EXECUTEPLASMOID, "kdevelop.kdeintegration.executeplasmoid")
 K_PLUGIN_FACTORY_WITH_JSON(KDevExecutePlasmoidFactory,"kdevexecuteplasmoid.json", registerPlugin<ExecutePlasmoidPlugin>(); )
 
 ExecutePlasmoidPlugin::ExecutePlasmoidPlugin(QObject *parent, const QVariantList&)
     : KDevelop::IPlugin("kdevexecuteplasmoid", parent)
 {
     m_configType = new PlasmoidExecutionConfigType();
     m_configType->addLauncher( new PlasmoidLauncher( this ) );
     qCDebug(EXECUTEPLASMOID) << "adding plasmoid launch config";
     core()->runController()->addConfigurationType( m_configType );
 }
 
 ExecutePlasmoidPlugin::~ExecutePlasmoidPlugin()
 {}
 
 void ExecutePlasmoidPlugin::unload()
 {
     core()->runController()->removeConfigurationType( m_configType );
     delete m_configType;
     m_configType = nullptr;
 }
 
 QUrl ExecutePlasmoidPlugin::executable(ILaunchConfiguration* config, QString& /*error*/) const
 {
     return QUrl::fromLocalFile(PlasmoidExecutionJob::executable(config));
 }
 
 QStringList ExecutePlasmoidPlugin::arguments(ILaunchConfiguration* config, QString& /*error*/) const
 {
     return PlasmoidExecutionJob::arguments(config);
 }
 
 KJob* ExecutePlasmoidPlugin::dependencyJob(ILaunchConfiguration* config) const
 {
     return PlasmoidLauncher::calculateDependencies(config);
 }
 
 QUrl ExecutePlasmoidPlugin::workingDirectory(ILaunchConfiguration* config) const
 {
     return QUrl::fromLocalFile(PlasmoidExecutionJob::workingDirectory(config));
 }
 
 QString ExecutePlasmoidPlugin::environmentProfileName(ILaunchConfiguration* /*config*/) const
 {
     return QString();
 }
 
 QString ExecutePlasmoidPlugin::nativeAppConfigTypeId() const
 {
     return PlasmoidExecutionConfigType::typeId();
 }
 
 bool ExecutePlasmoidPlugin::useTerminal(ILaunchConfiguration* /*config*/) const
 {
     return false;
 }
 
 QString ExecutePlasmoidPlugin::terminal(ILaunchConfiguration* /*config*/) const
 {
     return QString();
 }
 
 #include "executeplasmoidplugin.moc"
diff --git a/kdeintegration/executeplasmoid/executeplasmoidplugin.h b/kdeintegration/executeplasmoid/executeplasmoidplugin.h
index 5f784c2a2d..881dd3c9d3 100644
--- a/kdeintegration/executeplasmoid/executeplasmoidplugin.h
+++ b/kdeintegration/executeplasmoid/executeplasmoidplugin.h
@@ -1,57 +1,56 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2009 Niko Sams <niko.sams@gmail.com>
  *
  * 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 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 EXECUTEPLASMOIDPLUGIN_H
 #define EXECUTEPLASMOIDPLUGIN_H
 
 #include <interfaces/iplugin.h>
 #include <execute/iexecuteplugin.h>
-#include <QtCore/QVariant>
-#include <QtCore/QProcess>
+#include <QVariantList>
 
 class PlasmoidExecutionConfigType;
 class QUrl;
 class KJob;
 
 class ExecutePlasmoidPlugin : public KDevelop::IPlugin, public IExecutePlugin
 {
     Q_OBJECT
     Q_INTERFACES( IExecutePlugin )
     public:
         explicit ExecutePlasmoidPlugin(QObject *parent, const QVariantList & = QVariantList() );
         ~ExecutePlasmoidPlugin() override;
         void unload() override;
 
         QUrl executable(KDevelop::ILaunchConfiguration* config, QString& error) const override;
         QStringList arguments(KDevelop::ILaunchConfiguration* config, QString& error) const override;
         KJob* dependencyJob(KDevelop::ILaunchConfiguration* config) const override;
         QString environmentProfileName(KDevelop::ILaunchConfiguration* config) const override;
         QString nativeAppConfigTypeId() const override;
         QString terminal(KDevelop::ILaunchConfiguration* config) const override;
         bool useTerminal(KDevelop::ILaunchConfiguration* config) const override;
         QUrl workingDirectory(KDevelop::ILaunchConfiguration* config) const override;
 
     private:
         PlasmoidExecutionConfigType* m_configType;
 };
 
 #endif // EXECUTEPLASMOIDPLUGIN_H
diff --git a/kdeintegration/executeplasmoid/plasmoidexecutionjob.cpp b/kdeintegration/executeplasmoid/plasmoidexecutionjob.cpp
index a8c6f73bdf..bde9f90146 100644
--- a/kdeintegration/executeplasmoid/plasmoidexecutionjob.cpp
+++ b/kdeintegration/executeplasmoid/plasmoidexecutionjob.cpp
@@ -1,155 +1,152 @@
 /*  This file is part of KDevelop
     Copyright 2009 Andreas Pakulat <apaku@gmx.de>
     Copyright 2009 Niko Sams <niko.sams@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 "plasmoidexecutionjob.h"
 #include "executeplasmoidplugin.h"
 
 #include <QFileInfo>
 #include <QDir>
 
-#include <kprocess.h>
 #include <KLocalizedString>
 #include <kconfiggroup.h>
-#include <kparts/mainwindow.h>
 
 #include <interfaces/ilaunchconfiguration.h>
 #include <outputview/outputmodel.h>
 #include <outputview/outputdelegate.h>
 #include <util/processlinemaker.h>
 #include <util/commandexecutor.h>
 #include <util/path.h>
 
-#include <kshell.h>
 #include <interfaces/icore.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iproject.h>
 #include <project/projectmodel.h>
 #include <QStandardPaths>
 
 using namespace KDevelop;
 
 PlasmoidExecutionJob::PlasmoidExecutionJob(ExecutePlasmoidPlugin* iface, ILaunchConfiguration* cfg)
     : OutputJob( iface )
 {
     QString identifier = cfg->config().readEntry("PlasmoidIdentifier", "");
 
     Q_ASSERT(!identifier.isEmpty());
     setToolTitle(i18n("Plasmoid Viewer"));
     setCapabilities(Killable);
     setStandardToolView( IOutputView::RunView );
     setBehaviours(IOutputView::AllowUserClose | IOutputView::AutoScroll );
     setObjectName("plasmoidviewer "+identifier);
     setDelegate(new OutputDelegate);
 
     m_process = new CommandExecutor(executable(cfg), this);
     m_process->setArguments( arguments(cfg) );
     m_process->setWorkingDirectory(workingDirectory(cfg));
 
     OutputModel* model = new OutputModel(QUrl::fromLocalFile(m_process->workingDirectory()), this);
     model->setFilteringStrategy(OutputModel::CompilerFilter);
     setModel( model );
 
     connect(m_process, &CommandExecutor::receivedStandardError, model,
             &OutputModel::appendLines );
     connect(m_process, &CommandExecutor::receivedStandardOutput, model,
             &OutputModel::appendLines );
 
     connect( m_process, &CommandExecutor::failed, this, &PlasmoidExecutionJob::slotFailed );
     connect( m_process, &CommandExecutor::completed, this, &PlasmoidExecutionJob::slotCompleted );
 }
 
 
 void PlasmoidExecutionJob::start()
 {
     startOutput();
     model()->appendLine( m_process->workingDirectory() + "> " + m_process->command() + " " + m_process->arguments().join(" ") );
     m_process->start();
 }
 
 bool PlasmoidExecutionJob::doKill()
 {
     m_process->kill();
     model()->appendLine( i18n("** Killed **") );
     return true;
 }
 
 OutputModel* PlasmoidExecutionJob::model()
 {
     return qobject_cast<OutputModel*>( OutputJob::model() );
 }
 
 void PlasmoidExecutionJob::slotCompleted(int code)
 {
     if( code != 0 ) {
         setError( FailedShownError );
         model()->appendLine( i18n("*** Failed ***") );
     } else {
         model()->appendLine( i18n("*** Finished ***") );
     }
     emitResult();
 }
 
 void PlasmoidExecutionJob::slotFailed(QProcess::ProcessError error)
 {
     setError(error);
     // FIXME need more detail
     setErrorText(i18n("Plasmoid failed to execute on %1", m_process->workingDirectory()));
     model()->appendLine( i18n("*** Failed ***") );
     emitResult();
 }
 
 QString PlasmoidExecutionJob::executable(ILaunchConfiguration*)
 {
     return QStandardPaths::findExecutable("plasmoidviewer");
 }
 
 QStringList PlasmoidExecutionJob::arguments(ILaunchConfiguration* cfg)
 {
     QStringList arguments = cfg->config().readEntry("Arguments", QStringList());
     if(workingDirectory(cfg) == QDir::tempPath()) {
         QString identifier = cfg->config().readEntry("PlasmoidIdentifier", "");
         arguments += "-a";
         arguments += identifier;
     } else {
         arguments += { "-a", "." };
     }
     return arguments;
 }
 
 QString PlasmoidExecutionJob::workingDirectory(ILaunchConfiguration* cfg)
 {
     QString workingDirectory;
     IProject* p = cfg->project();
     if(p) {
         QString identifier = cfg->config().readEntry("PlasmoidIdentifier", "");
         QString possiblePath = Path(p->path(), identifier).toLocalFile();
         if(QFileInfo(possiblePath).isDir()) {
             workingDirectory = possiblePath;
         }
     }
 
     if(workingDirectory.isEmpty())
     {
         workingDirectory = QDir::tempPath();
     }
     return workingDirectory;
 }
 
diff --git a/kdeintegration/executeplasmoid/plasmoidexecutionjob.h b/kdeintegration/executeplasmoid/plasmoidexecutionjob.h
index dbbb0ef6a3..39e252a479 100644
--- a/kdeintegration/executeplasmoid/plasmoidexecutionjob.h
+++ b/kdeintegration/executeplasmoid/plasmoidexecutionjob.h
@@ -1,60 +1,59 @@
 /*  This file is part of KDevelop
     Copyright 2009 Andreas Pakulat <apaku@gmx.de>
     Copyright 2009 Niko Sams <niko.sams@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.
 */
 
 #ifndef PLASMOIDEXECUTIONJOB_H
 #define PLASMOIDEXECUTIONJOB_H
 
 #include <QtCore/QProcess>
 #include <outputview/outputjob.h>
 
-class QUrl;
 class ExecutePlasmoidPlugin;
 
 namespace KDevelop
 {
 class ILaunchConfiguration;
 class ProcessLineMaker;
 class OutputModel;
 class CommandExecutor;
 }
 
 
 class PlasmoidExecutionJob : public KDevelop::OutputJob
 {
 Q_OBJECT
 public:
     PlasmoidExecutionJob( ExecutePlasmoidPlugin* parent, KDevelop::ILaunchConfiguration* cfg );
     void start() override;
     bool doKill() override;
     KDevelop::OutputModel* model();
 
     static QString executable(KDevelop::ILaunchConfiguration* cfg);
     static QStringList arguments(KDevelop::ILaunchConfiguration* cfg);
     static QString workingDirectory(KDevelop::ILaunchConfiguration* cfg);
 
 public slots:
     void slotCompleted(int);
     void slotFailed(QProcess::ProcessError);
 
 private:
     KDevelop::CommandExecutor* m_process;
 };
 
 #endif
diff --git a/languages/clang/clangparsejob.cpp b/languages/clang/clangparsejob.cpp
index edd0efc8af..be6afbf8d7 100644
--- a/languages/clang/clangparsejob.cpp
+++ b/languages/clang/clangparsejob.cpp
@@ -1,385 +1,384 @@
 /*
     This file is part of KDevelop
 
     Copyright 2013 Olivier de Gaalon <olivier.jg@gmail.com>
     Copyright 2013 Milian Wolff <mail@milianw.de>
 
     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 "clangparsejob.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/idocumentcontroller.h>
 
 #include <language/interfaces/icodehighlighting.h>
 
 #include <language/backgroundparser/urlparselock.h>
 #include <language/backgroundparser/backgroundparser.h>
 
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/parsingenvironment.h>
 
 #include <languages/plugins/custom-definesandincludes/idefinesandincludesmanager.h>
 
 #include <project/projectmodel.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 
 #include "clangsettings/clangsettingsmanager.h"
 #include "duchain/clanghelpers.h"
 #include "duchain/clangpch.h"
 #include "duchain/duchainutils.h"
 #include "duchain/parsesession.h"
 #include "duchain/clangindex.h"
 #include "duchain/clangparsingenvironmentfile.h"
 #include "util/clangdebug.h"
 #include "util/clangtypes.h"
 
 #include "clangsupport.h"
 #include "duchain/documentfinderhelpers.h"
 
 #include <QFile>
 #include <QStringList>
 #include <QFileInfo>
 #include <QReadLocker>
-#include <QProcess>
 #include <memory>
 
 using namespace KDevelop;
 
 namespace {
 
 QString findConfigFile(const QString& forFile, const QString& configFileName)
 {
     QDir dir = QFileInfo(forFile).dir();
     while (dir.exists()) {
         const QFileInfo customIncludePaths(dir, configFileName);
         if (customIncludePaths.exists()) {
             return customIncludePaths.absoluteFilePath();
         }
 
         if (!dir.cdUp()) {
             break;
         }
     }
 
     return {};
 }
 
 Path::List readPathListFile(const QString& filepath)
 {
     if (filepath.isEmpty()) {
         return {};
     }
 
     QFile f(filepath);
     if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
         return {};
     }
 
     const QString text = QString::fromLocal8Bit(f.readAll());
     const QStringList lines = text.split(QLatin1Char('\n'), QString::SkipEmptyParts);
     Path::List paths(lines.length());
     std::transform(lines.begin(), lines.end(), paths.begin(), [] (const QString& line) { return Path(line); });
     return paths;
 }
 
 /**
  * File should contain the header to precompile and use while parsing
  * @returns the first path in the file
  */
 Path userDefinedPchIncludeForFile(const QString& sourcefile)
 {
     static const QString pchIncludeFilename = QStringLiteral(".kdev_pch_include");
     const auto paths = readPathListFile(findConfigFile(sourcefile, pchIncludeFilename));
     return paths.isEmpty() ? Path() : paths.first();
 }
 
 ProjectFileItem* findProjectFileItem(const IndexedString& url, bool* hasBuildSystemInfo)
 {
     ProjectFileItem* file = nullptr;
 
     *hasBuildSystemInfo = false;
     for (auto project: ICore::self()->projectController()->projects()) {
         auto files = project->filesForPath(url);
         if (files.isEmpty()) {
             continue;
         }
 
         file = files.last();
 
         // A file might be defined in different targets.
         // Prefer file items defined inside a target with non-empty includes.
         for (auto f: files) {
             if (!dynamic_cast<ProjectTargetItem*>(f->parent())) {
                 continue;
             }
             file = f;
             if (!IDefinesAndIncludesManager::manager()->includes(f, IDefinesAndIncludesManager::ProjectSpecific).isEmpty()) {
                 break;
             }
         }
     }
     if (file && file->project()) {
         if (auto bsm = file->project()->buildSystemManager()) {
             *hasBuildSystemInfo = bsm->hasBuildInfo(file);
         }
     }
     return file;
 }
 
 ClangParsingEnvironmentFile* parsingEnvironmentFile(const TopDUContext* context)
 {
     return dynamic_cast<ClangParsingEnvironmentFile*>(context->parsingEnvironmentFile().data());
 }
 
 DocumentChangeTracker* trackerForUrl(const IndexedString& url)
 {
     return ICore::self()->languageController()->backgroundParser()->trackerForUrl(url);
 }
 
 }
 
 ClangParseJob::ClangParseJob(const IndexedString& url, ILanguageSupport* languageSupport)
     : ParseJob(url, languageSupport)
 {
     const auto tuUrl = clang()->index()->translationUnitForUrl(url);
     bool hasBuildSystemInfo;
     if (auto file = findProjectFileItem(tuUrl, &hasBuildSystemInfo)) {
         m_environment.addIncludes(IDefinesAndIncludesManager::manager()->includes(file));
         m_environment.addFrameworkDirectories(IDefinesAndIncludesManager::manager()->frameworkDirectories(file));
         m_environment.addDefines(IDefinesAndIncludesManager::manager()->defines(file));
         m_environment.setParserSettings(ClangSettingsManager::self()->parserSettings(file));
     } else {
         m_environment.addIncludes(IDefinesAndIncludesManager::manager()->includes(tuUrl.str()));
         m_environment.addFrameworkDirectories(IDefinesAndIncludesManager::manager()->frameworkDirectories(tuUrl.str()));
         m_environment.addDefines(IDefinesAndIncludesManager::manager()->defines(tuUrl.str()));
         m_environment.setParserSettings(ClangSettingsManager::self()->parserSettings(tuUrl.str()));
     }
     const bool isSource = ClangHelpers::isSource(tuUrl.str());
     m_environment.setQuality(
         isSource ? (hasBuildSystemInfo ? ClangParsingEnvironment::BuildSystem : ClangParsingEnvironment::Source)
         : ClangParsingEnvironment::Unknown
     );
     m_environment.setTranslationUnitUrl(tuUrl);
 
     Path::List projectPaths;
     const auto& projects = ICore::self()->projectController()->projects();
     projectPaths.reserve(projects.size());
     foreach (auto project, projects) {
         projectPaths.append(project->path());
     }
     m_environment.setProjectPaths(projectPaths);
 
     foreach(auto document, ICore::self()->documentController()->openDocuments()) {
         auto textDocument = document->textDocument();
         // TODO: Introduce a cache so we don't have to re-read all the open documents
         // which were not changed since the last run
         if (!textDocument || !textDocument->url().isLocalFile()
             || !DocumentFinderHelpers::mimeTypesList().contains(textDocument->mimeType()))
         {
             continue;
         }
         m_unsavedFiles << UnsavedFile(textDocument->url().toLocalFile(), textDocument->textLines(textDocument->documentRange()));
         const IndexedString indexedUrl(textDocument->url());
         m_unsavedRevisions.insert(indexedUrl, ModificationRevision::revisionForFile(indexedUrl));
         if (indexedUrl == tuUrl) {
             m_tuDocumentIsUnsaved = true;
         }
     }
 
     if (auto tracker = trackerForUrl(url)) {
         tracker->reset();
     }
 }
 
 ClangSupport* ClangParseJob::clang() const
 {
     return static_cast<ClangSupport*>(languageSupport());
 }
 
 void ClangParseJob::run(ThreadWeaver::JobPointer /*self*/, ThreadWeaver::Thread* /*thread*/)
 {
     QReadLocker parseLock(languageSupport()->parseLock());
 
     if (abortRequested()) {
         return;
     }
 
     {
         const auto tuUrlStr = m_environment.translationUnitUrl().str();
         if (!m_tuDocumentIsUnsaved && !QFile::exists(tuUrlStr)) {
             // maybe we requested a parse job some time ago but now the file
             // does not exist anymore. return early then
             clang()->index()->unpinTranslationUnitForUrl(document());
             return;
         }
 
         m_environment.addIncludes(IDefinesAndIncludesManager::manager()->includesInBackground(tuUrlStr));
         m_environment.addFrameworkDirectories(IDefinesAndIncludesManager::manager()->frameworkDirectoriesInBackground(tuUrlStr));
         m_environment.addDefines(IDefinesAndIncludesManager::manager()->definesInBackground(tuUrlStr));
         m_environment.setPchInclude(userDefinedPchIncludeForFile(tuUrlStr));
     }
 
     if (abortRequested()) {
         return;
     }
 
     // NOTE: we must have all declarations, contexts and uses available for files that are opened in the editor
     //       it is very hard to check this for all included files of this TU, and previously lead to problems
     //       when we tried to skip function bodies as an optimization for files that where not open in the editor.
     //       now, we always build everything, which is correct but a tad bit slower. we can try to optimize later.
     setMinimumFeatures(static_cast<TopDUContext::Features>(minimumFeatures() | TopDUContext::AllDeclarationsContextsAndUses));
 
     if (minimumFeatures() & AttachASTWithoutUpdating) {
         // The context doesn't need to be updated, but has no AST attached (restored from disk),
         // so attach AST to it, without updating DUChain
         ParseSession session(createSessionData());
 
         DUChainWriteLocker lock;
         auto ctx = DUChainUtils::standardContextForUrl(document().toUrl());
         if (!ctx) {
             clangDebug() << "Lost context while attaching AST";
             return;
         }
         ctx->setAst(IAstContainer::Ptr(session.data()));
 
         if (minimumFeatures() & UpdateHighlighting) {
             lock.unlock();
             languageSupport()->codeHighlighting()->highlightDUChain(ctx);
         }
         return;
     }
 
     {
         UrlParseLock urlLock(document());
         if (abortRequested() || !isUpdateRequired(ParseSession::languageString())) {
             return;
         }
     }
 
     ParseSession session(ClangIntegration::DUChainUtils::findParseSessionData(document(), m_environment.translationUnitUrl()));
     if (abortRequested()) {
         return;
     }
 
     if (!session.data() || !session.reparse(m_unsavedFiles, m_environment)) {
         session.setData(createSessionData());
     }
 
     if (!session.unit()) {
         // failed to parse file, unpin and don't try again
         clang()->index()->unpinTranslationUnitForUrl(document());
         return;
     }
 
     if (!clang_getFile(session.unit(), document().byteArray().constData())) {
         // this parse job's document does not exist in the pinned translation unit
         // so we need to unpin and re-add this document
         // Ideally we'd reset m_environment and session, but this is much simpler
         // and shouldn't be a common case
         clang()->index()->unpinTranslationUnitForUrl(document());
         if (!(minimumFeatures() & Rescheduled)) {
             auto features = static_cast<TopDUContext::Features>(minimumFeatures() | Rescheduled);
             ICore::self()->languageController()->backgroundParser()->addDocument(document(), features, priority());
         }
         return;
     }
 
     Imports imports = ClangHelpers::tuImports(session.unit());
     IncludeFileContexts includedFiles;
     if (auto pch = clang()->index()->pch(m_environment)) {
         auto pchFile = pch->mapFile(session.unit());
         includedFiles = pch->mapIncludes(session.unit());
         includedFiles.insert(pchFile, pch->context());
         auto tuFile = clang_getFile(session.unit(), m_environment.translationUnitUrl().byteArray().constData());
         imports.insert(tuFile, { pchFile, CursorInRevision(0, 0) } );
     }
 
     if (abortRequested()) {
         return;
     }
 
     auto context = ClangHelpers::buildDUChain(session.mainFile(), imports, session,
                                               minimumFeatures(), includedFiles,
                                               clang()->index(), [this] { return abortRequested(); });
     setDuChain(context);
 
     if (abortRequested()) {
         return;
     }
 
     if (context) {
         if (minimumFeatures() & TopDUContext::AST) {
             DUChainWriteLocker lock;
             context->setAst(IAstContainer::Ptr(session.data()));
         }
 #ifdef QT_DEBUG
         DUChainReadLocker lock;
         auto file = parsingEnvironmentFile(context);
         Q_ASSERT(file);
         // verify that features and environment where properly set in ClangHelpers::buildDUChain
         Q_ASSERT(file->featuresSatisfied(TopDUContext::Features(minimumFeatures() & ~TopDUContext::ForceUpdateRecursive)));
         if (trackerForUrl(context->url())) {
             Q_ASSERT(file->featuresSatisfied(TopDUContext::AllDeclarationsContextsAndUses));
         }
 #endif
     }
 
     foreach(const auto& context, includedFiles) {
         if (!context) {
             continue;
         }
         {
             // prefer the editor modification revision, instead of the on-disk revision
             auto it = m_unsavedRevisions.find(context->url());
             if (it != m_unsavedRevisions.end()) {
                 DUChainWriteLocker lock;
                 auto file = parsingEnvironmentFile(context);
                 Q_ASSERT(file);
                 file->setModificationRevision(it.value());
             }
         }
         if (trackerForUrl(context->url())) {
             if (clang()->index()->translationUnitForUrl(context->url()) == m_environment.translationUnitUrl()) {
                 // cache the parse session and the contained translation unit for this chain
                 // this then allows us to quickly reparse the document if it is changed by
                 // the user
                 // otherwise no editor component is open for this document and we can dispose
                 // the TU to save memory
                 // share the session data with all contexts that are pinned to this TU
                 DUChainWriteLocker lock;
                 context->setAst(IAstContainer::Ptr(session.data()));
             }
             languageSupport()->codeHighlighting()->highlightDUChain(context);
         }
     }
 }
 
 ParseSessionData::Ptr ClangParseJob::createSessionData() const
 {
     return ParseSessionData::Ptr(new ParseSessionData(m_unsavedFiles, clang()->index(), m_environment, ParseSessionData::NoOption));
 }
 
 const ParsingEnvironment* ClangParseJob::environment() const
 {
     return &m_environment;
 }
diff --git a/languages/clang/clangsettings/clangsettingsmanager.cpp b/languages/clang/clangsettings/clangsettingsmanager.cpp
index e6d7e1c678..434e113159 100644
--- a/languages/clang/clangsettings/clangsettingsmanager.cpp
+++ b/languages/clang/clangsettings/clangsettingsmanager.cpp
@@ -1,133 +1,130 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2015 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 "clangsettingsmanager.h"
 
 #include <KConfigGroup>
 #include <KConfig>
 
-#include <QThread>
-#include <QCoreApplication>
-
 #include <interfaces/icore.h>
 #include <interfaces/isession.h>
 #include <interfaces/iproject.h>
 #include <languages/plugins/custom-definesandincludes/idefinesandincludesmanager.h>
 #include <util/path.h>
 
 #include <project/projectmodel.h>
 
 using namespace KDevelop;
 
 namespace
 {
     const QString settingsGroup = QStringLiteral("Clang Settings");
 
     const QString macros = QStringLiteral("macros");
     const QString lookAhead = QStringLiteral("lookAhead");
 
     const QString forwardDeclare = QStringLiteral("forwardDeclare");
 
 AssistantsSettings readAssistantsSettings(KConfig* cfg)
 {
     auto grp = cfg->group(settingsGroup);
     AssistantsSettings settings;
 
     settings.forwardDeclare = grp.readEntry(forwardDeclare, true);
 
     return settings;
 }
 
 CodeCompletionSettings readCodeCompletionSettings(KConfig* cfg)
 {
     auto grp = cfg->group(settingsGroup);
     CodeCompletionSettings settings;
 
     settings.macros = grp.readEntry(macros, true);
     settings.lookAhead = grp.readEntry(lookAhead, false);
 
     return settings;
 }
 }
 
 ClangSettingsManager* ClangSettingsManager::self()
 {
     static ClangSettingsManager manager;
     return &manager;
 }
 
 AssistantsSettings ClangSettingsManager::assistantsSettings() const
 {
     auto cfg = ICore::self()->activeSession()->config();
     return readAssistantsSettings(cfg.data());
 }
 
 CodeCompletionSettings ClangSettingsManager::codeCompletionSettings() const
 {
     if (m_enableTesting) {
         CodeCompletionSettings settings;
         settings.lookAhead = true;
         settings.macros = true;
         return settings;
     }
 
     auto cfg = ICore::self()->activeSession()->config();
     return readCodeCompletionSettings(cfg.data());
 }
 
 ParserSettings ClangSettingsManager::parserSettings(KDevelop::ProjectBaseItem* item) const
 {
     return {IDefinesAndIncludesManager::manager()->parserArguments(item)};
 }
 
 ParserSettings ClangSettingsManager::parserSettings(const QString& path) const
 {
     return {IDefinesAndIncludesManager::manager()->parserArguments(path)};
 }
 
 ClangSettingsManager::ClangSettingsManager()
 {}
 
 bool ParserSettings::isCpp() const
 {
     return parserOptions.contains(QStringLiteral("-std=c++"));
 }
 
 QVector<QByteArray> ParserSettings::toClangAPI() const
 {
     // TODO: This is not efficient.
     auto list = parserOptions.split(QLatin1Char(' '), QString::SkipEmptyParts);
     QVector<QByteArray> result;
     result.reserve(list.size());
 
     std::transform(list.constBegin(), list.constEnd(),
                    std::back_inserter(result),
                    [] (const QString &argument) { return argument.toUtf8(); });
 
     return result;
 }
 
 bool ParserSettings::operator==(const ParserSettings& rhs) const
 {
     return parserOptions == rhs.parserOptions;
 }
diff --git a/languages/clang/clangsettings/clangsettingsmanager.h b/languages/clang/clangsettings/clangsettingsmanager.h
index 1a0c8c9a8a..2a0b1d5388 100644
--- a/languages/clang/clangsettings/clangsettingsmanager.h
+++ b/languages/clang/clangsettings/clangsettingsmanager.h
@@ -1,80 +1,78 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2015 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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/>.
  *
  */
 
 #ifndef CLANGSETTINGSMANAGER_H
 #define CLANGSETTINGSMANAGER_H
 
 #include <QString>
 #include <QMetaType>
 
 #include "clangprivateexport.h"
 
-class KConfig;
-
 namespace KDevelop
 {
 class ProjectBaseItem;
 class IProject;
 }
 
 struct ParserSettings
 {
     QString parserOptions;
     bool isCpp() const;
     QVector<QByteArray> toClangAPI() const;
     bool operator==(const ParserSettings& rhs) const;
 };
 Q_DECLARE_METATYPE(ParserSettings);
 
 struct CodeCompletionSettings
 {
     bool macros = true;
     bool lookAhead = false;
 };
 
 struct AssistantsSettings
 {
     bool forwardDeclare = true;
 };
 
 class KDEVCLANGPRIVATE_EXPORT ClangSettingsManager
 {
 public:
     static ClangSettingsManager* self();
 
     AssistantsSettings assistantsSettings() const;
 
     CodeCompletionSettings codeCompletionSettings() const;
 
     ParserSettings parserSettings(KDevelop::ProjectBaseItem* item) const;
 
     ParserSettings parserSettings(const QString& path) const;
 
 private:
     ClangSettingsManager();
 
     bool m_enableTesting = false;
     friend class CodeCompletionTestBase;
 };
 
 #endif // CLANGSETTINGSMANAGER_H
diff --git a/languages/clang/clangsupport.h b/languages/clang/clangsupport.h
index 77d4bcc5dd..69aed2d5ef 100644
--- a/languages/clang/clangsupport.h
+++ b/languages/clang/clangsupport.h
@@ -1,105 +1,104 @@
 /*
     This file is part of KDevelop
 
     Copyright 2013 Olivier de Gaalon <olivier.jg@gmail.com>
     Copyright 2013 Milian Wolff <mail@milianw.de>
     Copyright 2014 Kevin Funk <kfunk@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #ifndef KDEVCLANGSUPPORT_H
 #define KDEVCLANGSUPPORT_H
 
 #include <interfaces/iplugin.h>
 #include <language/interfaces/ilanguagesupport.h>
 #include <interfaces/ibuddydocumentfinder.h>
 
-#include <QStringList>
 #include <QVariantList>
 
 class ClangIndex;
 class ClangRefactoring;
 namespace KDevelop
 {
 class IDocument;
 }
 
 namespace KTextEditor
 {
 class View;
 class Document;
 }
 
 class ClangSupport : public KDevelop::IPlugin, public KDevelop::ILanguageSupport, public KDevelop::IBuddyDocumentFinder
 {
     Q_OBJECT
     Q_INTERFACES(KDevelop::ILanguageSupport)
 
 public:
     explicit ClangSupport(QObject *parent, const QVariantList& args = QVariantList());
     ~ClangSupport() override;
 
     /** Name Of the Language */
     QString name() const override;
 
     /** Parsejob used by background parser to parse given url */
     KDevelop::ParseJob *createParseJob(const KDevelop::IndexedString &url) override;
 
     /** the code highlighter */
     KDevelop::ICodeHighlighting* codeHighlighting() const override;
     KDevelop::BasicRefactoring* refactoring() const override;
     KDevelop::ICreateClassHelper* createClassHelper() const override;
 
     void createActionsForMainWindow(Sublime::MainWindow* window, QString& xmlFile, KActionCollection& actions) override;
     KDevelop::ContextMenuExtension contextMenuExtension(KDevelop::Context* context) override;
 
     KTextEditor::Range specialLanguageObjectRange(const QUrl &url, const KTextEditor::Cursor& position) override;
     QPair<QUrl, KTextEditor::Cursor> specialLanguageObjectJumpCursor(const QUrl &url, const KTextEditor::Cursor& position) override;
     QWidget* specialLanguageObjectNavigationWidget(const QUrl &url, const KTextEditor::Cursor& position) override;
 
     ClangIndex* index();
 
     KDevelop::TopDUContext* standardContext(const QUrl &url, bool proxyContext = false) override;
 
     KDevelop::ConfigPage* configPage(int number, QWidget *parent) override;
 
     int configPages() const override;
 
     int suggestedReparseDelayForChange(KTextEditor::Document* doc, const KTextEditor::Range& changedRange,
                                        const QString& changedText, bool removal) const override;
 
     //BEGIN IBuddyDocumentFinder
 
     bool areBuddies(const QUrl &url1, const QUrl& url2) override;
     bool buddyOrder(const QUrl &url1, const QUrl& url2) override;
     QVector< QUrl > getPotentialBuddies(const QUrl &url) const override;
 
     //END IBuddyDocumentFinder
 
 private slots:
     void documentActivated(KDevelop::IDocument* doc);
     void disableKeywordCompletion(KTextEditor::View* view);
     void enableKeywordCompletion(KTextEditor::View* view);
 
 private:
     KDevelop::ICodeHighlighting *m_highlighting;
     ClangRefactoring *m_refactoring;
     QScopedPointer<ClangIndex> m_index;
 };
 
 #endif
 
diff --git a/languages/clang/codecompletion/includepathcompletioncontext.cpp b/languages/clang/codecompletion/includepathcompletioncontext.cpp
index 1ef6da62aa..46c26d60e8 100644
--- a/languages/clang/codecompletion/includepathcompletioncontext.cpp
+++ b/languages/clang/codecompletion/includepathcompletioncontext.cpp
@@ -1,286 +1,285 @@
 /*
  * This file is part of KDevelop
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  * Copyright 2015 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 "includepathcompletioncontext.h"
 
 #include "duchain/navigationwidget.h"
 #include "duchain/clanghelpers.h"
 
 #include <language/codecompletion/abstractincludefilecompletionitem.h>
 
 #include <QDirIterator>
-#include <QRegularExpression>
 
 #include <KTextEditor/View>
 
 #include <algorithm>
 
 using namespace KDevelop;
 
 /**
  * Parse the last line of @p text and extract information about any existing include path from it.
  */
 IncludePathProperties IncludePathProperties::parseText(const QString& text, int rightBoundary)
 {
     IncludePathProperties properties;
 
     int idx = text.lastIndexOf(QLatin1Char('\n'));
     if (idx == -1) {
         idx = 0;
     }
     if (rightBoundary == -1) {
         rightBoundary = text.length();
     }
 
     // what follows is a relatively simple parser for include lines that may contain comments, i.e.:
     // /*comment*/ #include /*comment*/ "path.h" /*comment*/
     enum FindState {
         FindBang,
         FindInclude,
         FindType,
         FindTypeEnd
     };
     FindState state = FindBang;
     QChar expectedEnd = QLatin1Char('>');
     for (; idx < text.size(); ++idx) {
         const auto c = text.at(idx);
         if (c.isSpace()) {
             continue;
         }
         if (c == QLatin1Char('/') && state != FindTypeEnd) {
             // skip comments
             if (idx >= text.length() - 1 || text.at(idx + 1) != QLatin1Char('*')) {
                 properties.valid = false;
                 return properties;
             }
             idx += 2;
             while (idx < text.length() - 1 && (text.at(idx) != QLatin1Char('*') || text.at(idx + 1) != QLatin1Char('/'))) {
                 ++idx;
             }
             if (idx >= text.length() - 1 || text.at(idx) != QLatin1Char('*') || text.at(idx + 1) != QLatin1Char('/')) {
                 properties.valid = false;
                 return properties;
             }
             ++idx;
             continue;
         }
         switch (state) {
             case FindBang:
                 if (c != QLatin1Char('#')) {
                     return properties;
                 }
                 state = FindInclude;
                 break;
             case FindInclude:
                 if (text.midRef(idx, 7) != QLatin1String("include")) {
                     return properties;
                 }
                 idx += 6;
                 state = FindType;
                 properties.valid = true;
                 break;
             case FindType:
                 properties.inputFrom = idx + 1;
                 if (c == QLatin1Char('"')) {
                     expectedEnd = QLatin1Char('"');
                     properties.local = true;
                 } else if (c != QLatin1Char('<')) {
                     properties.valid = false;
                     return properties;
                 }
                 state = FindTypeEnd;
                 break;
             case FindTypeEnd:
                 if (c == expectedEnd) {
                     properties.inputTo = idx;
                     // stop iteration
                     idx = text.size();
                 }
                 break;
         }
     }
 
     if (!properties.valid) {
         return properties;
     }
 
     // properly append to existing paths without overriding it
     // i.e.: #include <foo/> should become #include <foo/bar.h>
     // or: #include <header.h> should again become #include <header.h>
     // see unit tests for more examples
     if (properties.inputFrom != -1) {
         int end = properties.inputTo;
         if (end >= rightBoundary || end == -1) {
             end = text.lastIndexOf(QLatin1Char('/'), rightBoundary - 1) + 1;
         }
         if (end > 0) {
             properties.prefixPath = text.mid(properties.inputFrom, end - properties.inputFrom);
             properties.inputFrom += properties.prefixPath.length();
         }
     }
 
     return properties;
 }
 
 namespace
 {
 
 QVector<KDevelop::IncludeItem> includeItemsForUrl(const QUrl& url, const IncludePathProperties& properties, const Path::List& includePaths )
 {
     QVector<IncludeItem> includeItems;
     Path::List paths = includePaths;
 
     if (properties.local) {
         paths.push_front(Path(url).parent());
     }
 
     std::sort(paths.begin(), paths.end());
     auto last = std::unique(paths.begin(), paths.end());
 
     int pathNumber = 0;
     for (auto it = paths.begin(); it != last; it++ ) {
         auto searchPath = *it;
         if (!properties.prefixPath.isEmpty()) {
             searchPath.addPath(properties.prefixPath);
         }
 
         QSet<QString> foundIncludePaths;
         QDirIterator dirIterator(searchPath.toLocalFile());
         while (dirIterator.hasNext()) {
             dirIterator.next();
             KDevelop::IncludeItem item;
             item.name = dirIterator.fileName();
 
             if (item.name.startsWith(QLatin1Char('.')) || item.name.endsWith(QLatin1Char('~'))) { //filter out ".", "..", hidden files, and backups
                 continue;
             }
 
             const auto info = dirIterator.fileInfo();
             item.isDirectory = info.isDir();
 
             // filter files that are not a header
             // note: system headers sometimes don't have any extension, and we still want to show those
             if (!item.isDirectory && item.name.contains(QLatin1Char('.')) && !ClangHelpers::isHeader(item.name)) {
                 continue;
             }
 
             const QString fullPath = info.canonicalFilePath();
             if (foundIncludePaths.contains(fullPath)) {
                 continue;
             } else {
                 foundIncludePaths.insert(fullPath);
             }
 
             item.basePath = searchPath.toUrl();
             item.pathNumber = pathNumber;
 
             includeItems << item;
         }
         ++pathNumber;
     }
 
     return includeItems;
 }
 }
 
 class IncludeFileCompletionItem : public AbstractIncludeFileCompletionItem<ClangNavigationWidget>
 {
 public:
     explicit IncludeFileCompletionItem(const IncludeItem& include)
         : AbstractIncludeFileCompletionItem<ClangNavigationWidget>(include)
     {}
 
     void execute(KTextEditor::View* view, const KTextEditor::Range& word) override
     {
         auto document = view->document();
         auto range = word;
         const int lineNumber = word.end().line();
         const QString line = document->line(lineNumber);
         const auto properties = IncludePathProperties::parseText(line, word.end().column());
         if (!properties.valid) {
             return;
         }
 
         QString newText = includeItem.isDirectory ? (includeItem.name + QLatin1Char('/')) : includeItem.name;
 
         if (properties.inputFrom == -1) {
             newText.prepend(QLatin1Char('<'));
         } else {
             range.setStart({lineNumber, properties.inputFrom});
         }
         if (properties.inputTo == -1) {
             // Add suffix
             if (properties.local) {
                 newText += QLatin1Char('"');
             } else {
                 newText += QLatin1Char('>');
             }
 
             // replace the whole line
             range.setEnd({lineNumber, line.size()});
         } else {
             range.setEnd({lineNumber, properties.inputTo});
         }
 
         document->replaceText(range, newText);
 
         if (includeItem.isDirectory) {
             // ensure we can continue to add files/paths when we just added a directory
             int offset = (properties.inputTo == -1) ? 1 : 0;
             view->setCursorPosition(range.start() + KTextEditor::Cursor(0, newText.length() - offset));
         } else {
             // place cursor at end of line
             view->setCursorPosition({lineNumber, document->lineLength(lineNumber)});
         }
     }
 };
 
 IncludePathCompletionContext::IncludePathCompletionContext(const DUContextPointer& context,
                                                            const ParseSessionData::Ptr& sessionData,
                                                            const QUrl& url,
                                                            const KTextEditor::Cursor& position,
                                                            const QString& text)
     : CodeCompletionContext(context, text, CursorInRevision::castFromSimpleCursor(position), 0)
 {
     const IncludePathProperties properties = IncludePathProperties::parseText(text);
 
     if (!properties.valid) {
         return;
     }
 
     m_includeItems = includeItemsForUrl(url, properties, properties.local ?  sessionData->environment().includes().project : sessionData->environment().includes().system);
 }
 
 QList< CompletionTreeItemPointer > IncludePathCompletionContext::completionItems(bool& abort, bool)
 {
     QList<CompletionTreeItemPointer> items;
 
     for (const auto& includeItem: m_includeItems) {
         if (abort) {
             return items;
         }
 
         items << CompletionTreeItemPointer(new IncludeFileCompletionItem(includeItem));
     }
 
     return items;
 }
diff --git a/languages/clang/codecompletion/model.cpp b/languages/clang/codecompletion/model.cpp
index 8541ed5576..fd5d71a531 100644
--- a/languages/clang/codecompletion/model.cpp
+++ b/languages/clang/codecompletion/model.cpp
@@ -1,218 +1,216 @@
 /*
  * This file is part of KDevelop
  * Copyright 2014 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 "model.h"
 
 #include "util/clangdebug.h"
 #include "context.h"
 #include "includepathcompletioncontext.h"
 
 #include "duchain/parsesession.h"
 #include "duchain/clangindex.h"
 #include "duchain/duchainutils.h"
 
 #include <language/codecompletion/codecompletionworker.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/duchainlock.h>
 
-#include <QRegularExpression>
-
 #include <KTextEditor/View>
 #include <KTextEditor/Document>
 
 using namespace KDevelop;
 
 namespace {
 
 bool isSpaceOnly(const QString& string)
 {
     return std::find_if(string.begin(), string.end(), [] (const QChar c) { return !c.isSpace(); }) == string.end();
 }
 
 bool includePathCompletionRequired(const QString& text)
 {
     const auto properties = IncludePathProperties::parseText(text);
     return properties.valid;
 }
 
 QSharedPointer<CodeCompletionContext> createCompletionContext(const DUContextPointer& context,
                                                               const ParseSessionData::Ptr& session,
                                                               const QUrl& url,
                                                               const KTextEditor::Cursor& position,
                                                               const QString& text,
                                                               const QString& followingText)
 {
     if (includePathCompletionRequired(text)) {
         return QSharedPointer<IncludePathCompletionContext>::create(context, session, url, position, text);
     } else {
         return QSharedPointer<ClangCodeCompletionContext>::create(context, session, url, position, text, followingText);
     }
 }
 
 class ClangCodeCompletionWorker : public CodeCompletionWorker
 {
     Q_OBJECT
 public:
     ClangCodeCompletionWorker(ClangIndex* index, CodeCompletionModel* model)
         : CodeCompletionWorker(model)
         , m_index(index)
     {}
     ~ClangCodeCompletionWorker() override = default;
 
 public slots:
     void completionRequested(const QUrl &url, const KTextEditor::Cursor& position, const QString& text, const QString& followingText)
     {
         aborting() = false;
 
         DUChainReadLocker lock;
         if (aborting()) {
             failed();
             return;
         }
 
         auto top = DUChainUtils::standardContextForUrl(url);
         if (!top) {
             qCWarning(KDEV_CLANG) << "No context found for" << url;
             return;
         }
 
         ParseSessionData::Ptr sessionData(ClangIntegration::DUChainUtils::findParseSessionData(top->url(), m_index->translationUnitForUrl(top->url())));
 
         if (!sessionData) {
             // TODO: trigger reparse and re-request code completion
             qCWarning(KDEV_CLANG) << "No parse session / AST attached to context for url" << url;
             return;
         }
 
         if (aborting()) {
             failed();
             return;
         }
 
         // We hold DUChain lock, and ask for ParseSession, but TUDUChain indirectly holds ParseSession lock.
         lock.unlock();
 
         auto completionContext = ::createCompletionContext(DUContextPointer(top), sessionData, url, position, text, followingText);
 
         lock.lock();
         if (aborting()) {
             failed();
             return;
         }
 
         bool abort = false;
         // NOTE: cursor might be wrong here, but shouldn't matter much I hope...
         //       when the document changed significantly, then the cache is off anyways and we don't get anything sensible
         //       the position here is just a "optimization" to only search up to that position
         const auto& items = completionContext->completionItems(abort);
 
         if (aborting()) {
             failed();
             return;
         }
 
         auto tree = computeGroups( items, {} );
 
         if (aborting()) {
             failed();
             return;
         }
 
         tree += completionContext->ungroupedElements();
 
         foundDeclarations( tree, {} );
     }
 private:
     ClangIndex* m_index;
 };
 }
 
 ClangCodeCompletionModel::ClangCodeCompletionModel(ClangIndex* index, QObject* parent)
     : CodeCompletionModel(parent)
     , m_index(index)
 {
     qRegisterMetaType<KTextEditor::Cursor>();
 }
 
 ClangCodeCompletionModel::~ClangCodeCompletionModel()
 {
 
 }
 
 bool ClangCodeCompletionModel::shouldStartCompletion(KTextEditor::View* view, const QString& inserted,
                                                      bool userInsertion, const KTextEditor::Cursor& position)
 {
     static const QString noCompletionAfter = QStringLiteral(";{}]) ");
 
     if (inserted.isEmpty() || isSpaceOnly(inserted)) {
         return false;
     }
     const auto lastChar = inserted.at(inserted.size() - 1);
     if (noCompletionAfter.contains(lastChar)) {
         return false;
     }
     // also show include path completion after dashes
     if (userInsertion && lastChar == QLatin1Char('-') && includePathCompletionRequired(view->document()->line(position.line()))) {
         return true;
     }
     return KDevelop::CodeCompletionModel::shouldStartCompletion(view, inserted, userInsertion, position);
 }
 
 KTextEditor::Range ClangCodeCompletionModel::completionRange(KTextEditor::View* view, const KTextEditor::Cursor& position)
 {
     auto range = KDevelop::CodeCompletionModel::completionRange(view, position);
     const auto includeProperties = IncludePathProperties::parseText(view->document()->line(position.line()), position.column());
     if (includeProperties.valid && includeProperties.inputFrom != -1) {
         // expand include path range to include e.g. dashes
         range.setStart({position.line(), includeProperties.inputFrom});
     }
     return range;
 }
 
 bool ClangCodeCompletionModel::shouldAbortCompletion(KTextEditor::View* view, const KTextEditor::Range& range, const QString& currentCompletion)
 {
     const auto shouldAbort = KDevelop::CodeCompletionModel::shouldAbortCompletion(view, range, currentCompletion);
     if (shouldAbort && includePathCompletionRequired(view->document()->line(range.end().line()))) {
         // don't abort include path completion which can contain dashes
         return false;
     }
     return shouldAbort;
 }
 
 CodeCompletionWorker* ClangCodeCompletionModel::createCompletionWorker()
 {
     auto worker = new ClangCodeCompletionWorker(m_index, this);
     connect(this, &ClangCodeCompletionModel::requestCompletion,
             worker, &ClangCodeCompletionWorker::completionRequested);
     return worker;
 }
 
 void ClangCodeCompletionModel::completionInvokedInternal(KTextEditor::View* view, const KTextEditor::Range& range,
                                                          CodeCompletionModel::InvocationType /*invocationType*/, const QUrl &url)
 {
     auto text = view->document()->text({0, 0, range.start().line(), range.start().column()});
     auto followingText = view->document()->text({{range.start().line(), range.start().column()}, view->document()->documentEnd()});
     emit requestCompletion(url, KTextEditor::Cursor(range.start()), text, followingText);
 }
 
 #include "model.moc"
 #include "moc_model.cpp"
diff --git a/languages/clang/codecompletion/model.h b/languages/clang/codecompletion/model.h
index 5899725933..38b22909fb 100644
--- a/languages/clang/codecompletion/model.h
+++ b/languages/clang/codecompletion/model.h
@@ -1,61 +1,59 @@
 /*
  * This file is part of KDevelop
  * Copyright 2014 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/>.
  */
 
 #ifndef CLANGCODECOMPLETIONMODEL_H
 #define CLANGCODECOMPLETIONMODEL_H
 
 #include <language/codecompletion/codecompletionmodel.h>
 
-#include <QMetaType>
-
 #include "clangprivateexport.h"
 
 class ClangIndex;
 
 class KDEVCLANGPRIVATE_EXPORT ClangCodeCompletionModel : public KDevelop::CodeCompletionModel
 {
     Q_OBJECT
 
 public:
     explicit ClangCodeCompletionModel(ClangIndex* index, QObject* parent);
     ~ClangCodeCompletionModel() override;
 
     bool shouldStartCompletion(KTextEditor::View* view, const QString& inserted,
                                bool userInsertion, const KTextEditor::Cursor& position) override;
 
     KTextEditor::Range completionRange(KTextEditor::View* view, const KTextEditor::Cursor& position) override;
 
     bool shouldAbortCompletion(KTextEditor::View* view, const KTextEditor::Range& range, const QString& currentCompletion) override;
 
 signals:
     void requestCompletion(const QUrl &url, const KTextEditor::Cursor& cursor, const QString& text, const QString& followingText);
 
 protected:
     KDevelop::CodeCompletionWorker* createCompletionWorker() override;
 
     void completionInvokedInternal(KTextEditor::View* view, const KTextEditor::Range& range,
                                    InvocationType invocationType, const QUrl &url) override;
 
 private:
     ClangIndex* m_index;
 };
 
 #endif // CLANGCODECOMPLETIONMODEL_H
diff --git a/languages/clang/codegen/adaptsignatureassistant.h b/languages/clang/codegen/adaptsignatureassistant.h
index 8d52ef4db2..08011ecacf 100644
--- a/languages/clang/codegen/adaptsignatureassistant.h
+++ b/languages/clang/codegen/adaptsignatureassistant.h
@@ -1,76 +1,75 @@
 /*
    Copyright 2009 David Nolden <david.nolden.kdevelop@art-master.de>
    Copyright 2014 Kevin Funk <kfunk@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
 
 #ifndef SIGNATUREASSISTANT_H
 #define SIGNATUREASSISTANT_H
 
 #include "adaptsignatureaction.h"
 #include "clangprivateexport.h"
 
 #include <language/assistant/staticassistant.h>
 #include <language/duchain/identifier.h>
 #include <language/duchain/topducontext.h>
 
 #include <QPointer>
-#include <QUrl>
 
 namespace KTextEditor {
 class View;
 }
 
 class KDEVCLANGPRIVATE_EXPORT AdaptSignatureAssistant : public KDevelop::StaticAssistant
 {
     Q_OBJECT
 
 public:
     explicit AdaptSignatureAssistant(KDevelop::ILanguageSupport* supportedLanguage);
 
     QString title() const override;
     void textChanged(KTextEditor::Document* doc, const KTextEditor::Range& invocationRange, const QString& removedText = QString()) override;
     bool isUseful() const override;
     KTextEditor::Range displayRange() const override;
 
 private:
     ///Compare @a newSignature to m_oldSignature and put differences in @a oldPositions
     ///@returns whether or not there are any differences
     bool getSignatureChanges(const Signature &newSignature, QList<int> &oldPositions) const;
     ///Set default params in @a newSignature based on m_oldSignature's defaults and @a oldPositions
     void setDefaultParams(Signature &newSignature, const QList<int> &oldPositions) const;
     ///@returns RenameActions for each parameter in newSignature that has been renamed
     QList<KDevelop::RenameAction*> getRenameActions(const Signature &newSignature, const QList<int> &oldPositions) const;
 
     // If this is true, the user is editing on the definition side,
     // and the declaration should be updated
     bool m_editingDefinition = false;
     KDevelop::Identifier m_declarationName;
     KDevelop::DeclarationId m_otherSideId;
     KDevelop::ReferencedTopDUContext m_otherSideTopContext;
     KDevelop::DUContextPointer m_otherSideContext;
     KTextEditor::Cursor m_lastEditPosition;
     //old signature of the _other_side
     Signature m_oldSignature;
     QPointer<KTextEditor::Document> m_document;
     QPointer<KTextEditor::View> m_view;
 
 private slots:
     void updateReady(const KDevelop::IndexedString& document, const KDevelop::ReferencedTopDUContext& context) override;
     void reset();
 };
 
 #endif // SIGNATUREASSISTANT_H
diff --git a/languages/clang/duchain/clangdiagnosticevaluator.cpp b/languages/clang/duchain/clangdiagnosticevaluator.cpp
index a71e711df6..669cd82acf 100644
--- a/languages/clang/duchain/clangdiagnosticevaluator.cpp
+++ b/languages/clang/duchain/clangdiagnosticevaluator.cpp
@@ -1,133 +1,131 @@
 /*
  * Copyright 2014 Kevin Funk <kfunk@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) 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 "clangdiagnosticevaluator.h"
 #include "unknowndeclarationproblem.h"
 #include "missingincludepathproblem.h"
 #include "util/clangtypes.h"
 
-#include <QString>
-
 namespace
 {
 
 /**
  * Check whether the problem stated in @p diagnostic may be caused by a missing include
  *
  * @return True if this may be fixable by adding a include, false otherwise
  */
 bool isDeclarationProblem(const QByteArray& description)
 {
     /* libclang does not currently expose an enum or any other way to query
      * what specific semantic error we're dealing with. Instead, we have to
      * parse the clang error message and guess if a missing include could be
      * the reason for the error
      *
      * There is no nice way of determining what identifier we're looking at either,
      * so we have to read that from the diagnostic too. Hopefully libclang will
      * get these features in the future.
      *
      * I have suggested this feature to clang devs. For reference, see:
      * http://lists.cs.uiuc.edu/pipermail/cfe-dev/2014-March/036036.html
      */
 
     return description.startsWith( QByteArrayLiteral("use of undeclared identifier") )
            || description.startsWith( QByteArrayLiteral("no member named") )
            || description.startsWith( QByteArrayLiteral("unknown type name") )
            || description.startsWith( QByteArrayLiteral("variable has incomplete type") )
            || description.startsWith( QByteArrayLiteral("member access into incomplete type") );
 }
 
 /// @return true if @p diagnostic says that include file not found
 bool isIncludeFileNotFound(const QByteArray& description)
 {
     return description.endsWith(QByteArrayLiteral("file not found"));
 }
 
 bool isReplaceWithDotProblem(const QByteArray& description)
 {
     // TODO: The diagnostic message depends on LibClang version.
     static const QByteArray diagnosticMessages[] = {
         QByteArrayLiteral("did you mean to use '.'?"),
         QByteArrayLiteral("maybe you meant to use '.'?")
     };
 
     for (const auto& diagnStr : diagnosticMessages) {
         if (description.endsWith(diagnStr)) {
             return true;
         }
     }
 
     return false;
 }
 
 bool isReplaceWithArrowProblem(const QByteArray& description)
 {
     // TODO: The diagnostic message depends on LibClang version.
     static const QByteArray diagnosticMessages[] = {
         QByteArrayLiteral("did you mean to use '->'?"),
         QByteArrayLiteral("maybe you meant to use '->'?")
     };
 
     for (const auto& diagnStr : diagnosticMessages) {
         if (description.endsWith(diagnStr)) {
             return true;
         }
     }
 
     return false;
 }
 
 }
 
 ClangDiagnosticEvaluator::DiagnosticType ClangDiagnosticEvaluator::diagnosticType(CXDiagnostic diagnostic)
 {
     const ClangString str(clang_getDiagnosticSpelling(diagnostic));
     const auto description = QByteArray::fromRawData(str.c_str(), qstrlen(str.c_str()));
 
     if (isDeclarationProblem(description)) {
         return UnknownDeclarationProblem;
     } else if (isIncludeFileNotFound(description)) {
         return IncludeFileNotFoundProblem;
     } else if (isReplaceWithDotProblem(description)) {
         return ReplaceWithDotProblem;
     } else if (isReplaceWithArrowProblem(description)) {
         return ReplaceWithArrowProblem;
     }
 
     return Unknown;
 }
 
 ClangProblem* ClangDiagnosticEvaluator::createProblem(CXDiagnostic diagnostic, CXTranslationUnit unit)
 {
     switch (diagnosticType(diagnostic)) {
     case IncludeFileNotFoundProblem:
         return new MissingIncludePathProblem(diagnostic, unit);
         break;
     case UnknownDeclarationProblem:
         return new class UnknownDeclarationProblem(diagnostic, unit);
         break;
     default:
         return new ClangProblem(diagnostic, unit);
         break;
     }
 }
 
diff --git a/languages/clang/duchain/documentfinderhelpers.cpp b/languages/clang/duchain/documentfinderhelpers.cpp
index 5138be4032..ef23abda4c 100644
--- a/languages/clang/duchain/documentfinderhelpers.cpp
+++ b/languages/clang/duchain/documentfinderhelpers.cpp
@@ -1,287 +1,281 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 "documentfinderhelpers.h"
 
 #include "duchain/clanghelpers.h"
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/functiondeclaration.h>
 #include <language/duchain/functiondefinition.h>
 #include <language/duchain/duchainutils.h>
 
 #include <KDesktopFile>
-#include <KConfigGroup>
-
-#include <QSet>
-#include <QStandardPaths>
-#include <QMimeDatabase>
-#include <QMimeType>
 
 using namespace KDevelop;
 
 namespace {
 
 enum FileType {
     Unknown, ///< Doesn't belong to C++
     Header,  ///< Is a header file
     Source   ///< Is a C(++) file
 };
 
 class PotentialBuddyCollector : public DUChainUtils::DUChainItemFilter
 {
 public:
     enum BuddyMode {
         Header,
         Source
     };
 
     explicit PotentialBuddyCollector(BuddyMode mode)
      : mode(mode)
     {}
 
     bool accept(Declaration* decl) override
     {
         if (decl->range().isEmpty())
             return false;
 
         if (mode == Header && decl->isFunctionDeclaration()) {
             // Search for definitions of our declarations
             FunctionDefinition* def = FunctionDefinition::definition(decl);
             if (def) {
                 vote(def->url().toUrl());
             }
 
             return true;
         }
         else if (mode == Source && decl->isFunctionDeclaration()) {
             FunctionDefinition* fdef = dynamic_cast<FunctionDefinition*>(decl);
             if (fdef) {
                 Declaration* fdecl = fdef->declaration();
                 if (fdecl) {
                     vote(fdecl->url().toUrl());
                 }
             }
 
             return true;
         } else {
             return false;
         }
     }
     bool accept(DUContext* ctx) override
     {
         if (ctx->type() == DUContext::Class || ctx->type() == DUContext::Namespace || ctx->type() == DUContext::Global || ctx->type() == DUContext::Other || ctx->type() == DUContext::Helper ) {
             return true;
         } else {
             return false;
         }
     }
 
     QUrl bestBuddy() const
     {
         QUrl ret;
         int bestCount = 0;
         for (auto it = m_buddyFiles.begin(); it != m_buddyFiles.end(); ++it) {
             if(it.value() > bestCount) {
                 bestCount = it.value();
                 ret = it.key();
             }
         }
 
         return ret;
     }
 private:
     BuddyMode mode;
     QHash<QUrl, int> m_buddyFiles;
 
     void vote(const QUrl& url)
     {
         m_buddyFiles[url]++;
     }
 };
 
 /**
  * Tries to find a buddy file to the given file by looking at the DUChain.
  *
  * The project might keep source files separate from headers. To cover
  * this situation, we examine DUChain for the most probable buddy file.
  * This of course only works if we have parsed the buddy file, but it is
  * better than nothing.
  *
  * @param url url of the source/header file to find a buddy for
  * @param type type of the file @p url
  *
  * @returns QUrl of the most probable buddy file, or an empty url
  **/
 QUrl duchainBuddyFile(const QUrl& url, FileType type)
 {
     DUChainReadLocker lock;
 
     auto ctx = DUChainUtils::standardContextForUrl(url);
     if (ctx) {
         PotentialBuddyCollector collector( type == Header ? PotentialBuddyCollector::Header : PotentialBuddyCollector::Source );
         DUChainUtils::collectItems(ctx, collector);
 
         return collector.bestBuddy();
     }
 
     return QUrl();
 }
 
 /**
  * Generates the base path (without extension) and the file type
  * for the specified url.
  *
  * @returns pair of base path and file type which has been found for @p url.
  */
 QPair<QString,FileType> basePathAndTypeForUrl(const QUrl &url)
 {
     QString path = url.toLocalFile();
     int idxSlash = path.lastIndexOf(QLatin1Char('/'));
     int idxDot = path.lastIndexOf(QLatin1Char('.'));
     FileType fileType = Unknown;
     QString basePath;
     if (idxSlash >= 0 && idxDot >= 0 && idxDot > idxSlash) {
         basePath = path.left(idxDot);
         if (idxDot + 1 < path.length()) {
             QString extension = path.mid(idxDot + 1);
             if (ClangHelpers::isHeader(extension)) {
                 fileType = Header;
             } else if (ClangHelpers::isSource(extension)) {
                 fileType = Source;
             }
         }
     } else {
         basePath = path;
     }
 
     return qMakePair(basePath, fileType);
 }
 
 }
 
 namespace DocumentFinderHelpers {
 QStringList mimeTypesList()
 {
     static const QStringList mimeTypes = {
         QStringLiteral("text/x-chdr"),
         QStringLiteral("text/x-c++hdr"),
         QStringLiteral("text/x-csrc"),
         QStringLiteral("text/x-c++src"),
         QStringLiteral("text/x-objcsrc")
     };
     return mimeTypes;
 }
 
 bool areBuddies(const QUrl &url1, const QUrl& url2)
 {
     auto type1 = basePathAndTypeForUrl(url1);
     auto type2 = basePathAndTypeForUrl(url2);
 
     QUrl headerPath;
     QUrl sourcePath;
 
     // Check that one file is a header, the other one is source
     if (type1.second == Header && type2.second == Source) {
         headerPath = url1;
         sourcePath = url2;
     } else if (type1.second == Source && type2.second == Header) {
         headerPath = url2;
         sourcePath = url1;
     } else {
         // Some other file constellation
         return false;
     }
 
     // The simplest directory layout is with header + source in one directory.
     // So check that first.
     if (type1.first == type2.first) {
         return true;
     }
 
     // Also check if the DUChain thinks this is likely
     if (duchainBuddyFile(sourcePath, Source) == headerPath) {
         return true;
     }
 
     return false;
 }
 
 bool buddyOrder(const QUrl &url1, const QUrl& url2)
 {
     auto type1 = basePathAndTypeForUrl(url1);
     auto type2 = basePathAndTypeForUrl(url2);
     // Precondition is that the two URLs are buddies, so don't check it
     return(type1.second == Header && type2.second == Source);
 }
 
 QVector< QUrl > getPotentialBuddies(const QUrl &url, bool checkDUChain)
 {
     auto type = basePathAndTypeForUrl(url);
     // Don't do anything for types we don't know
     if (type.second == Unknown) {
         return {};
     }
 
     // Depending on the buddy's file type we either generate source extensions (for headers)
     // or header extensions (for sources)
     const auto& extensions = ( type.second == Header ? ClangHelpers::sourceExtensions() : ClangHelpers::headerExtensions() );
     QVector< QUrl > buddies;
     for(const QString& extension : extensions) {
         if (!extension.contains(QLatin1Char('.'))) {
             buddies.append(QUrl::fromLocalFile(type.first + QLatin1Char('.') + extension));
         } else {
             buddies.append(QUrl::fromLocalFile(type.first + extension));
         }
     }
 
     if (checkDUChain) {
         // Also ask DUChain for a guess
         QUrl bestBuddy = duchainBuddyFile(url, type.second);
         if (!buddies.contains(bestBuddy)) {
             buddies.append(bestBuddy);
         }
     }
 
     return buddies;
 }
 
 QString sourceForHeader(const QString& headerPath)
 {
     if (!ClangHelpers::isHeader(headerPath)) {
         return {};
     }
 
     QString targetUrl;
     auto buddies = DocumentFinderHelpers::getPotentialBuddies(QUrl::fromLocalFile(headerPath));
     for (const auto& buddy : buddies) {
         const auto local = buddy.toLocalFile();
         if (QFileInfo::exists(local)) {
             targetUrl = local;
             break;
         }
     }
 
     return targetUrl;
 }
 
 }
diff --git a/languages/clang/duchain/documentfinderhelpers.h b/languages/clang/duchain/documentfinderhelpers.h
index b8fa1b53d3..996823b255 100644
--- a/languages/clang/duchain/documentfinderhelpers.h
+++ b/languages/clang/duchain/documentfinderhelpers.h
@@ -1,59 +1,61 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 DOCUMENTFINDERHELPERS_H
 #define DOCUMENTFINDERHELPERS_H
 
-#include <QStringList>
 #include <QVector>
 
 #include <QUrl>
 
 #include "clangprivateexport.h"
 
+class QStringList;
+class QString;
+
 /// Helper class for handling @see IBuddyDocumentFinder features.
 namespace DocumentFinderHelpers
 {
 /// @return All supported mime types
 KDEVCLANGPRIVATE_EXPORT QStringList mimeTypesList();
 
 /**
  * Considers the URLs as buddy documents if the base path (without extension)
  * is the same, and one extension starts with h/H and the other one with c/C.
  * For example, foo.hpp and foo.C are buddies.
  */
 KDEVCLANGPRIVATE_EXPORT bool areBuddies(const QUrl &url1, const QUrl& url2);
 
 /// @see KDevelop::IBuddyDocumentFinder
 KDEVCLANGPRIVATE_EXPORT bool buddyOrder(const QUrl &url1, const QUrl& url2);
 
 /// @see KDevelop::IBuddyDocumentFinder
 KDEVCLANGPRIVATE_EXPORT QVector< QUrl > getPotentialBuddies(const QUrl &url, bool checkDUChain = true);
 
 /**
  * Returns path to the source file for given @p headerPath
  *
  * If no source file exists or @p headerPath is not a header an empty sting is returned
  */
 KDEVCLANGPRIVATE_EXPORT QString sourceForHeader(const QString& headerPath);
 };
 
 #endif // DOCUMENTFINDERHELPERS_H
diff --git a/languages/clang/duchain/macronavigationcontext.cpp b/languages/clang/duchain/macronavigationcontext.cpp
index abb2542944..90d62388aa 100644
--- a/languages/clang/duchain/macronavigationcontext.cpp
+++ b/languages/clang/duchain/macronavigationcontext.cpp
@@ -1,105 +1,102 @@
 /*
    Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
    Copyright 2014 Kevin Funk <kfunk@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "macronavigationcontext.h"
 
 #include "util/clangdebug.h"
 #include "util/clangutils.h"
 
 #include <KTextEditor/Editor>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 #include <KTextEditor/ConfigInterface>
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/declaration.h>
 #include <serialization/indexedstring.h>
 #include <interfaces/icore.h>
 #include <interfaces/ipartcontroller.h>
 
-#include <QVBoxLayout>
-#include <QLabel>
-
 using namespace KDevelop;
 
 MacroNavigationContext::MacroNavigationContext(const MacroDefinition::Ptr& macro,
                                                const KDevelop::DocumentCursor& /* expansionLocation */)
     : m_macro(macro)
 {
 }
 
 MacroNavigationContext::~MacroNavigationContext()
 {
 }
 
 QString MacroNavigationContext::name() const
 {
     return m_macro->identifier().toString();
 }
 
 QString MacroNavigationContext::html(bool shorten)
 {
     clear();
 
     modifyHtml() += QLatin1String("<html><body><p>") + fontSizePrefix(shorten);
     addExternalHtml(m_prefix);
 
     QStringList parameterList;
     FOREACH_FUNCTION(const auto& parameter, m_macro->parameters) {
         parameterList << parameter.str();
     }
     const QString parameters = (!parameterList.isEmpty() ?
         QStringLiteral("(%1)").arg(parameterList.join(QLatin1String(", "))) :
         QString());
 
     const QUrl url = m_macro->url().toUrl();
     const QString path = url.toLocalFile();
     KTextEditor::Cursor cursor(m_macro->rangeInCurrentRevision().start());
     NavigationAction action(url, cursor);
     modifyHtml() += i18nc("%1: macro type, i.e.: 'Function macro' or just 'Macro'"
                           "%2: the macro name and arguments",
                           "%1: %2",
                           (m_macro->isFunctionLike() ? i18n("Function macro") : i18n("Macro")),
                           importantHighlight(name()) + parameters);
     modifyHtml() += QStringLiteral("<br/>");
     modifyHtml() += i18nc("%1: the link to the definition", "Defined in: %1",
                           createLink(QStringLiteral("%1 :%2").arg(url.fileName()).arg(cursor.line()+1), path, action));
 
     modifyHtml() += QStringLiteral(" "); //The action name _must_ stay "show_uses", since that is also used from outside
     makeLink(i18n("Show uses"), QStringLiteral("show_uses"), NavigationAction(m_macro.dynamicCast<Declaration>(), NavigationAction::NavigateUses));
 
     auto code = m_macro->definition().str();
     modifyHtml() += QLatin1String("<p>") + i18n("Body: ");
     modifyHtml() += QLatin1String("<tt>") + code.toHtmlEscaped().replace(QStringLiteral("\n"), QStringLiteral("<br/>")) + QLatin1String("</tt>");
     modifyHtml() += QLatin1String("</p>");
 
     modifyHtml() += fontSizeSuffix(shorten) + QLatin1String("</p></body></html>");
     return currentHtml();
 }
 
 QString MacroNavigationContext::retrievePreprocessedBody(const DocumentCursor& /*expansionLocation*/) const
 {
     const TopDUContext* topContext = m_macro->topContext();
     if (!topContext) {
         return QString();
     }
 
     // TODO: Implement me. Still not exactly sure what do to here...
     return QString();
 }
diff --git a/languages/clang/duchain/parsesession.h b/languages/clang/duchain/parsesession.h
index d988e96a08..163eae1390 100644
--- a/languages/clang/duchain/parsesession.h
+++ b/languages/clang/duchain/parsesession.h
@@ -1,139 +1,138 @@
 /*
     This file is part of KDevelop
 
     Copyright 2013 Olivier de Gaalon <olivier.jg@gmail.com>
     Copyright 2013 Milian Wolff <mail@milianw.de>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #ifndef PARSESESSION_H
 #define PARSESESSION_H
 
 #include <QList>
-#include <QUrl>
 #include <QTemporaryFile>
 
 #include <clang-c/Index.h>
 
 #include <serialization/indexedstring.h>
 
 #include <util/path.h>
 
 #include <language/duchain/problem.h>
 #include <language/interfaces/iastcontainer.h>
 
 #include "clangprivateexport.h"
 
 #include "clangparsingenvironment.h"
 #include "unsavedfile.h"
 
 class ClangIndex;
 
 class KDEVCLANGPRIVATE_EXPORT ParseSessionData : public KDevelop::IAstContainer
 {
 public:
     using Ptr = QExplicitlySharedDataPointer<ParseSessionData>;
 
     enum Option {
         NoOption,                     ///< No special options
         SkipFunctionBodies,           ///< Pass CXTranslationUnit_SkipFunctionBodies (likely unwanted)
         PrecompiledHeader             ///< Pass CXTranslationUnit_PrecompiledPreamble and others to cache precompiled headers
     };
     Q_DECLARE_FLAGS(Options, Option)
 
     /**
      * Parse the given @p contents.
      *
      * @param unsavedFiles Optional unsaved document contents from the editor.
      */
     ParseSessionData(const QVector<UnsavedFile>& unsavedFiles, ClangIndex* index,
                      const ClangParsingEnvironment& environment, Options options = Options());
 
     ~ParseSessionData();
 
     ClangParsingEnvironment environment() const;
 
 private:
     friend class ParseSession;
     void setUnit(CXTranslationUnit unit);
     QByteArray writeDefinesFile(const QMap<QString, QString>& defines);
 
     QMutex m_mutex;
 
     CXFile m_file = nullptr;
     CXTranslationUnit m_unit = nullptr;
     ClangParsingEnvironment m_environment;
     /// TODO: share this file for all TUs that use the same defines (probably most in a project)
     ///       best would be a PCH, if possible
     QTemporaryFile m_definesFile;
 };
 
 /**
  * Thread-safe utility class around a CXTranslationUnit.
  *
  * It will lock the mutex of the currently set ParseSessionData and thereby ensure
  * only one ParseSession can operate on a given CXTranslationUnit stored therein.
  */
 class KDEVCLANGPRIVATE_EXPORT ParseSession
 {
 public:
     /**
      * @return a unique identifier for Clang documents.
      */
     static KDevelop::IndexedString languageString();
 
     /**
      * Initialize a parse session with the given data and, if that data is valid, lock its mutex.
      */
     explicit ParseSession(const ParseSessionData::Ptr& data);
     /**
      * Unlocks the mutex of the currently set ParseSessionData.
      */
     ~ParseSession();
 
     /**
      * Unlocks the mutex of the currently set ParseSessionData, and instead acquire the lock in @p data.
      */
     void setData(const ParseSessionData::Ptr& data);
     ParseSessionData::Ptr data() const;
 
     /**
      * @return find the CXFile for the given path.
      */
     CXFile file(const QByteArray& path) const;
 
     /**
      * @return the CXFile for the first file in this translation unit.
      */
     CXFile mainFile() const;
 
     QList<KDevelop::ProblemPointer> problemsForFile(CXFile file) const;
 
     CXTranslationUnit unit() const;
 
     bool reparse(const QVector<UnsavedFile>& unsavedFiles, const ClangParsingEnvironment& environment);
 
     ClangParsingEnvironment environment() const;
 
 private:
     Q_DISABLE_COPY(ParseSession);
 
     ParseSessionData::Ptr d;
 
 };
 
 #endif // PARSESESSION_H
diff --git a/languages/clang/duchain/unknowndeclarationproblem.cpp b/languages/clang/duchain/unknowndeclarationproblem.cpp
index 2a68184940..465b6e97a5 100644
--- a/languages/clang/duchain/unknowndeclarationproblem.cpp
+++ b/languages/clang/duchain/unknowndeclarationproblem.cpp
@@ -1,556 +1,555 @@
 /*
  * Copyright 2014 Jørgen Kvalsvik <lycantrophe@lavabit.com>
  * Copyright 2014 Kevin Funk <kfunk@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) 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 "unknowndeclarationproblem.h"
 
 #include "clanghelpers.h"
 #include "parsesession.h"
 #include "../util/clangdebug.h"
 #include "../util/clangutils.h"
 #include "../util/clangtypes.h"
 #include "../clangsettings/clangsettingsmanager.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 
 #include <language/duchain/persistentsymboltable.h>
 #include <language/duchain/aliasdeclaration.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <languages/plugins/custom-definesandincludes/idefinesandincludesmanager.h>
 
 #include <project/projectmodel.h>
 #include <util/path.h>
 
 #include <QDir>
-#include <QProcess>
 #include <QRegularExpression>
 
 #include <algorithm>
 
 using namespace KDevelop;
 
 namespace {
 /** Under some conditions, such as when looking up suggestions
  * for the undeclared namespace 'std' we will get an awful lot
  * of suggestions. This parameter limits how many suggestions
  * will pop up, as rarely more than a few will be relevant anyways
  *
  * Forward declaration suggestions are included in this number
  */
 const int maxSuggestions = 5;
 
 /**
  * We don't want anything from the bits directory -
  * we'd rather prefer forwarding includes, such as <vector>
  */
 bool isBlacklisted(const QString& path)
 {
     if (ClangHelpers::isSource(path))
         return true;
 
     // Do not allow including directly from the bits directory.
     // Instead use one of the forwarding headers in other directories, when possible.
     if (path.contains( QLatin1String("bits") ) && path.contains(QLatin1String("/include/c++/")))
         return true;
 
     return false;
 }
 
 QStringList scanIncludePaths( const QString& identifier, const QDir& dir, int maxDepth = 3 )
 {
     if (!maxDepth) {
         return {};
     }
 
     QStringList candidates;
     const auto path = dir.absolutePath();
 
     if( isBlacklisted( path ) ) {
         return {};
     }
 
     const QStringList nameFilters = {identifier, identifier + QLatin1String(".*")};
     for (const auto& file : dir.entryList(nameFilters, QDir::Files)) {
         if (identifier.compare(file, Qt::CaseInsensitive) == 0 || ClangHelpers::isHeader(file)) {
             const QString filePath = path + QLatin1Char('/') + file;
             clangDebug() << "Found candidate file" << filePath;
             candidates.append( filePath );
         }
     }
 
     maxDepth--;
     for( const auto& subdir : dir.entryList( QDir::Dirs | QDir::NoDotAndDotDot ) )
         candidates += scanIncludePaths( identifier, QDir{ path + QLatin1Char('/') + subdir }, maxDepth );
 
     return candidates;
 }
 
 /**
  * Find files in dir that match the given identifier. Matches common C++ header file extensions only.
  */
 QStringList scanIncludePaths( const QualifiedIdentifier& identifier, const KDevelop::Path::List& includes )
 {
     const auto stripped_identifier = identifier.last().toString();
     QStringList candidates;
     for( const auto& include : includes ) {
         candidates += scanIncludePaths( stripped_identifier, QDir{ include.toLocalFile() } );
     }
 
     std::sort( candidates.begin(), candidates.end() );
     candidates.erase( std::unique( candidates.begin(), candidates.end() ), candidates.end() );
     return candidates;
 }
 
 /**
  * Determine how much path is shared between two includes.
  *  boost/tr1/unordered_map
  *  boost/tr1/unordered_set
  * have a shared path of 2 where
  *  boost/tr1/unordered_map
  *  boost/vector
  * have a shared path of 1
  */
 int sharedPathLevel(const QString& a, const QString& b)
 {
     int shared = -1;
     for(auto x = a.begin(), y = b.begin(); *x == *y && x != a.end() && y != b.end() ; ++x, ++y ) {
         if( *x == QDir::separator() ) {
             ++shared;
         }
     }
 
     return shared;
 }
 
 /**
  * Try to find a proper include position from the DUChain:
  *
  * look at existing imports (i.e. #include's) and find a fitting
  * file with the same/similar path to the new include file and use that
  *
  * TODO: Implement a fallback scheme
  */
 KDevelop::DocumentRange includeDirectivePosition(const KDevelop::Path& source, const QString& includeFile)
 {
     static const QRegularExpression mocFilenameExpression(QStringLiteral("(moc_[^\\/\\\\]+\\.cpp$|\\.moc$)") );
 
     DUChainReadLocker lock;
     const TopDUContext* top = DUChainUtils::standardContextForUrl( source.toUrl() );
     if( !top ) {
         clangDebug() << "unable to find standard context for" << source.toLocalFile() << "Creating null range";
         return KDevelop::DocumentRange::invalid();
     }
 
     int line = -1;
 
     // look at existing #include statements and re-use them
     int currentMatchQuality = -1;
     for( const auto& import : top->importedParentContexts() ) {
 
         const auto importFilename = import.context(top)->url().str();
         const int matchQuality = sharedPathLevel( importFilename , includeFile );
         if( matchQuality < currentMatchQuality ) {
             continue;
         }
 
         const auto match = mocFilenameExpression.match(importFilename);
         if (match.isValid()) {
             clangDebug() << "moc file detected in" << source.toUrl().toDisplayString() << ":" << importFilename << "-- not using as include insertion location";
             continue;
         }
 
         line = import.position.line + 1;
         currentMatchQuality = matchQuality;
     }
 
     if( line == -1 ) {
         /* Insert at the top of the document */
         return {IndexedString(source.pathOrUrl()), {0, 0, 0, 0}};
     }
 
     return {IndexedString(source.pathOrUrl()), {line, 0, line, 0}};
 }
 
 KDevelop::DocumentRange forwardDeclarationPosition(const QualifiedIdentifier& identifier, const KDevelop::Path& source)
 {
     DUChainReadLocker lock;
     const TopDUContext* top = DUChainUtils::standardContextForUrl( source.toUrl() );
     if( !top ) {
         clangDebug() << "unable to find standard context for" << source.toLocalFile() << "Creating null range";
         return KDevelop::DocumentRange::invalid();
     }
 
     if (!top->findDeclarations(identifier).isEmpty()) {
         // Already forward-declared
         return KDevelop::DocumentRange::invalid();
     }
 
     int line = std::numeric_limits< int >::max();
     for( const auto decl : top->localDeclarations() ) {
         line = std::min( line, decl->range().start.line );
     }
 
     if( line == std::numeric_limits< int >::max() ) {
         return KDevelop::DocumentRange::invalid();
     }
 
     // We want it one line above the first declaration
     line = std::max( line - 1, 0 );
 
     return {IndexedString(source.pathOrUrl()), {line, 0, line, 0}};
 }
 
 /**
  * Iteratively build all levels of the current scope. A (missing) type anywhere
  * can be arbitrarily namespaced, so we create the permutations of possible
  * nestings of namespaces it can currently be in,
  *
  * TODO: add detection of namespace aliases, such as 'using namespace KDevelop;'
  *
  * namespace foo {
  *      namespace bar {
  *          function baz() {
  *              type var;
  *          }
  *      }
  * }
  *
  * Would give:
  * foo::bar::baz::type
  * foo::bar::type
  * foo::type
  * type
  */
 QVector<KDevelop::QualifiedIdentifier> findPossibleQualifiedIdentifiers( const QualifiedIdentifier& identifier, const KDevelop::Path& file, const KDevelop::CursorInRevision& cursor )
 {
     DUChainReadLocker lock;
     const TopDUContext* top = DUChainUtils::standardContextForUrl( file.toUrl() );
 
     if( !top ) {
         clangDebug() << "unable to find standard context for" << file.toLocalFile() << "Not creating duchain candidates";
         return {};
     }
 
     const auto* context = top->findContextAt( cursor );
     if( !context ) {
         clangDebug() << "No context found at" << cursor;
         return {};
     }
 
     QVector<KDevelop::QualifiedIdentifier> declarations{ identifier };
     for( auto scopes = context->scopeIdentifier(); !scopes.isEmpty(); scopes.pop() ) {
         declarations.append( scopes + identifier );
     }
 
     clangDebug() << "Possible declarations:" << declarations;
     return declarations;
 }
 
 }
 
 QStringList UnknownDeclarationProblem::findMatchingIncludeFiles(const QVector<Declaration*>& declarations)
 {
     DUChainReadLocker lock;
 
     QStringList candidates;
     for (const auto decl: declarations) {
         // skip declarations that don't belong to us
         const auto& file = decl->topContext()->parsingEnvironmentFile();
         if (!file || file->language() != ParseSession::languageString()) {
             continue;
         }
 
         if( dynamic_cast<KDevelop::AliasDeclaration*>( decl ) ) {
             continue;
         }
 
         if( decl->isForwardDeclaration() ) {
             continue;
         }
 
         const auto filepath = decl->url().toUrl().toLocalFile();
 
         if( !isBlacklisted( filepath ) ) {
             candidates << filepath;
             clangDebug() << "Adding" << filepath << "determined from candidate" << decl->toString();
         }
 
         for( const auto importer : file->importers() ) {
             if( importer->imports().count() != 1 && !isBlacklisted( filepath ) ) {
                 continue;
             }
             if( importer->topContext()->localDeclarations().count() ) {
                 continue;
             }
 
             const auto filePath = importer->url().toUrl().toLocalFile();
             if( isBlacklisted( filePath ) ) {
                 continue;
             }
 
             /* This file is a forwarder, such as <vector>
              * <vector> does not actually implement the functions, but include other headers that do
              * we prefer this to other headers
              */
             candidates << filePath;
             clangDebug() << "Adding forwarder file" << filePath << "to the result set";
         }
     }
 
     std::sort( candidates.begin(), candidates.end() );
     candidates.erase( std::unique( candidates.begin(), candidates.end() ), candidates.end() );
     clangDebug() << "Candidates: " << candidates;
     return candidates;
 }
 
 namespace {
 
 /**
  * Takes a filepath and the include paths and determines what directive to use.
  */
 ClangFixit directiveForFile( const QString& includefile, const KDevelop::Path::List& includepaths, const KDevelop::Path& source )
 {
     const auto sourceFolder = source.parent();
     const Path canonicalFile( QFileInfo( includefile ).canonicalFilePath() );
 
     QString shortestDirective;
     bool isRelative = false;
 
     // we can include the file directly
     if (sourceFolder == canonicalFile.parent()) {
         shortestDirective = canonicalFile.lastPathSegment();
         isRelative = true;
     } else {
         // find the include directive with the shortest length
         for( const auto& includePath : includepaths ) {
             QString relative = includePath.relativePath( canonicalFile );
             if( relative.startsWith( QLatin1String("./") ) )
                 relative = relative.mid( 2 );
 
             if( shortestDirective.isEmpty() || relative.length() < shortestDirective.length() ) {
                 shortestDirective = relative;
                 isRelative = includePath == sourceFolder;
             }
         }
     }
 
     if( shortestDirective.isEmpty() ) {
         // Item not found in include path
         return {};
     }
 
     const auto range = DocumentRange(IndexedString(source.pathOrUrl()), includeDirectivePosition(source, canonicalFile.lastPathSegment()));
     if( !range.isValid() ) {
         clangDebug() << "unable to determine valid position for" << includefile << "in" << source.pathOrUrl();
         return {};
     }
 
     QString directive;
     if( isRelative ) {
         directive = QStringLiteral("#include \"%1\"").arg(shortestDirective);
     } else {
         directive = QStringLiteral("#include <%1>").arg(shortestDirective);
     }
     return ClangFixit{directive + QLatin1Char('\n'), range, QObject::tr("Insert \'%1\'").arg(directive)};
 }
 
 KDevelop::Path::List includePaths( const KDevelop::Path& file )
 {
     // Find project's custom include paths
     const auto source = file.toLocalFile();
     const auto item = ICore::self()->projectController()->projectModel()->itemForPath( KDevelop::IndexedString( source ) );
 
     return IDefinesAndIncludesManager::manager()->includes(item);
 }
 
 /**
  * Return a list of header files viable for inclusions. All elements will be unique
  */
 QStringList includeFiles(const QualifiedIdentifier& identifier, const QVector<Declaration*> declarations, const KDevelop::Path& file)
 {
     const auto includes = includePaths( file );
     if( includes.isEmpty() ) {
         clangDebug() << "Include path is empty";
         return {};
     }
 
     const auto candidates = UnknownDeclarationProblem::findMatchingIncludeFiles(declarations);
     if( !candidates.isEmpty() ) {
         // If we find a candidate from the duchain we don't bother scanning the include paths
         return candidates;
     }
 
     return scanIncludePaths(identifier, includes);
 }
 
 /**
  * Construct viable forward declarations for the type name.
  */
 ClangFixits forwardDeclarations(const QVector<Declaration*>& matchingDeclarations, const Path& source)
 {
     DUChainReadLocker lock;
     ClangFixits fixits;
     for (const auto decl : matchingDeclarations) {
         const auto qid = decl->qualifiedIdentifier();
 
         if (qid.count() > 1) {
             // TODO: Currently we're not able to determine what is namespaces, class names etc
             // and makes a suitable forward declaration, so just suggest "vanilla" declarations.
             continue;
         }
 
         const auto range = forwardDeclarationPosition(qid, source);
         if (!range.isValid()) {
             continue; // do not know where to insert
         }
 
         if (const auto classDecl = dynamic_cast<ClassDeclaration*>(decl)) {
             const auto name = qid.last().toString();
 
             switch (classDecl->classType()) {
             case ClassDeclarationData::Class:
                 fixits += {
                     QLatin1String("class ") + name + QLatin1String(";\n"), range,
                     QObject::tr("Forward declare as 'class'")
                 };
                 break;
             case ClassDeclarationData::Struct:
                 fixits += {
                     QLatin1String("struct ") + name + QLatin1String(";\n"), range,
                     QObject::tr("Forward declare as 'struct'")
                 };
                 break;
             default:
                 break;
             }
         }
     }
     return fixits;
 }
 
 /**
  * Search the persistent symbol table for matching declarations for identifiers @p identifiers
  */
 QVector<Declaration*> findMatchingDeclarations(const QVector<QualifiedIdentifier>& identifiers)
 {
     DUChainReadLocker lock;
 
     QVector<Declaration*> matchingDeclarations;
     matchingDeclarations.reserve(identifiers.size());
     for (const auto& declaration : identifiers) {
         clangDebug() << "Considering candidate declaration" << declaration;
         const IndexedDeclaration* declarations;
         uint declarationCount;
         PersistentSymbolTable::self().declarations( declaration , declarationCount, declarations );
 
         for (uint i = 0; i < declarationCount; ++i) {
             // Skip if the declaration is invalid or if it is an alias declaration -
             // we want the actual declaration (and its file)
             if (auto decl = declarations[i].declaration()) {
                 matchingDeclarations << decl;
             }
         }
     }
     return matchingDeclarations;
 }
 
 ClangFixits fixUnknownDeclaration( const QualifiedIdentifier& identifier, const KDevelop::Path& file, const KDevelop::DocumentRange& docrange )
 {
     ClangFixits fixits;
 
     const CursorInRevision cursor{docrange.start().line(), docrange.start().column()};
 
     const auto possibleIdentifiers = findPossibleQualifiedIdentifiers(identifier, file, cursor);
     const auto matchingDeclarations = findMatchingDeclarations(possibleIdentifiers);
 
     if (ClangSettingsManager::self()->assistantsSettings().forwardDeclare) {
         for (const auto& fixit : forwardDeclarations(matchingDeclarations, file)) {
             fixits << fixit;
             if (fixits.size() == maxSuggestions) {
                 return fixits;
             }
         }
     }
 
     const auto includefiles = includeFiles(identifier, matchingDeclarations, file);
     if (includefiles.isEmpty()) {
         // return early as the computation of the include paths is quite expensive
         return fixits;
     }
 
     const auto includepaths = includePaths( file );
     clangDebug() << "found include paths for" << file << ":" << includepaths;
 
     /* create fixits for candidates */
     for( const auto& includeFile : includefiles ) {
         const auto fixit = directiveForFile( includeFile, includepaths, file /* UP */ );
         if (!fixit.range.isValid()) {
             clangDebug() << "unable to create directive for" << includeFile << "in" << file.toLocalFile();
             continue;
         }
 
         fixits << fixit;
 
         if (fixits.size() == maxSuggestions) {
             return fixits;
         }
     }
 
     return fixits;
 }
 
 QString symbolFromDiagnosticSpelling(const QString& str)
 {
     /* in all error messages the symbol is in in the first pair of quotes */
     const auto split = str.split( QLatin1Char('\'') );
     auto symbol = split.value( 1 );
 
     if( str.startsWith( QLatin1String("No member named") ) ) {
         symbol = split.value( 3 ) + QLatin1String("::") + split.value( 1 );
     }
     return symbol;
 }
 
 }
 
 UnknownDeclarationProblem::UnknownDeclarationProblem(CXDiagnostic diagnostic, CXTranslationUnit unit)
     : ClangProblem(diagnostic, unit)
 {
     setSymbol(QualifiedIdentifier(symbolFromDiagnosticSpelling(description())));
 }
 
 void UnknownDeclarationProblem::setSymbol(const QualifiedIdentifier& identifier)
 {
     m_identifier = identifier;
 }
 
 IAssistant::Ptr UnknownDeclarationProblem::solutionAssistant() const
 {
     const Path path(finalLocation().document.str());
     const auto fixits = allFixits() + fixUnknownDeclaration(m_identifier, path, finalLocation());
     return IAssistant::Ptr(new ClangFixitAssistant(fixits));
 }
diff --git a/languages/clang/tests/codecompletiontestbase.cpp b/languages/clang/tests/codecompletiontestbase.cpp
index 4ba4af3d4d..ff754d5c31 100644
--- a/languages/clang/tests/codecompletiontestbase.cpp
+++ b/languages/clang/tests/codecompletiontestbase.cpp
@@ -1,84 +1,86 @@
 /*
  * Copyright 2014  David Stevens <dgedstevens@gmail.com>
  * Copyright 2014  Kevin Funk <kfunk@kde.org>
  * Copyright 2015 Milian Wolff <mail@milianw.de>
  * Copyright 2015 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 "codecompletiontestbase.h"
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/testproject.h>
 
 #include <interfaces/idocumentcontroller.h>
 
 #include "clangsettings/clangsettingsmanager.h"
 
 #include <language/codecompletion/codecompletiontesthelper.h>
 
 #include <KTextEditor/Editor>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
+#include <QLoggingCategory>
+
 void DeleteDocument::operator()(KTextEditor::View* view) const
 {
     delete view->document();
 }
 
 std::unique_ptr<KTextEditor::View, DeleteDocument> CodeCompletionTestBase::createView(const QUrl& url, QObject* parent) const
 {
     KTextEditor::Editor* editor = KTextEditor::Editor::instance();
     Q_ASSERT(editor);
 
     auto doc = editor->createDocument(parent);
     Q_ASSERT(doc);
     bool opened = doc->openUrl(url);
     Q_ASSERT(opened);
     Q_UNUSED(opened);
 
     auto view = doc->createView(nullptr);
     Q_ASSERT(view);
     return std::unique_ptr<KTextEditor::View, DeleteDocument>(view);
 }
 
 void CodeCompletionTestBase::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.plugins.clang.debug=true\n"));
     QVERIFY(qputenv("KDEV_DISABLE_PLUGINS", "kdevcppsupport"));
     QVERIFY(qputenv("KDEV_CLANG_DISPLAY_DIAGS", "1"));
     AutoTestShell::init({QStringLiteral("kdevclangsupport")});
     auto core = TestCore::initialize();
     delete core->projectController();
     m_projectController = new TestProjectController(core);
     core->setProjectController(m_projectController);
     ICore::self()->documentController()->closeAllDocuments();
 
     ClangSettingsManager::self()->m_enableTesting = true;
 }
 
 void CodeCompletionTestBase::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void CodeCompletionTestBase::init()
 {
     m_projectController->closeAllProjects();
 }
diff --git a/languages/clang/tests/test_assistants.cpp b/languages/clang/tests/test_assistants.cpp
index 2bf5fb5ec9..7fd0403af3 100644
--- a/languages/clang/tests/test_assistants.cpp
+++ b/languages/clang/tests/test_assistants.cpp
@@ -1,791 +1,792 @@
 /* This file is part of KDevelop
      Copyright 2012 Olivier de Gaalon <olivier.jg@gmail.com>
                2014 David Stevens <dgedstevens@gmail.com>
 
      This library is free software; you can redistribute it and/or
      modify it under the terms of the GNU Library General Public
      License version 2 as published by the Free Software Foundation.
 
      This library is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the GNU
      Library General Public License for more details.
 
      You should have received a copy of the GNU Library General Public License
      along with this library; see the file COPYING.LIB. If not, write to
      the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      Boston, MA 02110-1301, USA.
 */
 
 #include "test_assistants.h"
 
 #include "codegen/clangrefactoring.h"
 
-#include <QtTest/QtTest>
+#include <QTest>
+#include <QLoggingCategory>
 #include <QTemporaryDir>
 
 #include <ktexteditor/view.h>
 #include <ktexteditor/document.h>
 
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <tests/testfile.h>
 
 #include <util/foregroundlock.h>
 
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/isourceformattercontroller.h>
 
 #include <language/assistant/staticassistant.h>
 #include <language/assistant/staticassistantsmanager.h>
 #include <language/assistant/renameaction.h>
 #include <language/assistant/renameassistant.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <language/codegen/coderepresentation.h>
 
 #include <shell/documentcontroller.h>
 
 #include <clang-c/Index.h>
 
 using namespace KDevelop;
 using namespace KTextEditor;
 
 QTEST_MAIN(TestAssistants)
 
 ForegroundLock *globalTestLock = nullptr;
 StaticAssistantsManager *staticAssistantsManager() { return Core::self()->languageController()->staticAssistantsManager(); }
 
 void TestAssistants::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral(
         "*.debug=false\n"
         "default.debug=true\n"
         "kdevelop.plugins.clang.debug=true\n"
     ));
     QVERIFY(qputenv("KDEV_DISABLE_PLUGINS", "kdevcppsupport"));
     QVERIFY(qputenv("KDEV_CLANG_DISPLAY_DIAGS", "1"));
     AutoTestShell::init({QStringLiteral("kdevclangsupport"), QStringLiteral("kdevproblemreporter")});
     TestCore::initialize();
     DUChain::self()->disablePersistentStorage();
     Core::self()->languageController()->backgroundParser()->setDelay(0);
     Core::self()->sourceFormatterController()->disableSourceFormatting(true);
     CodeRepresentation::setDiskChangesForbidden(true);
 
     globalTestLock = new ForegroundLock;
 }
 
 void TestAssistants::cleanupTestCase()
 {
     Core::self()->cleanup();
     delete globalTestLock;
     globalTestLock = nullptr;
 }
 
 static QUrl createFile(const QString& fileContents, QString extension, int id)
 {
     static QTemporaryDir tempDirA;
     Q_ASSERT(tempDirA.isValid());
     static QDir dirA(tempDirA.path());
     QFile file(dirA.filePath(QString::number(id) + extension));
     file.open(QIODevice::WriteOnly | QIODevice::Text);
     file.write(fileContents.toUtf8());
     file.close();
     return QUrl::fromLocalFile(file.fileName());
 }
 
 class Testbed
 {
 public:
     enum TestDoc
     {
         HeaderDoc,
         CppDoc
     };
 
     enum IncludeBehavior
     {
         NoAutoInclude,
         AutoInclude,
     };
 
     Testbed(const QString& headerContents, const QString& cppContents, IncludeBehavior include = AutoInclude)
         : m_includeBehavior(include)
     {
         static int i = 0;
         int id = i;
         ++i;
         m_headerDocument.url = createFile(headerContents,".h",id);
         m_headerDocument.textDoc = openDocument(m_headerDocument.url);
 
         QString preamble;
         if (include == AutoInclude)
             preamble = QStringLiteral("#include \"%1\"\n").arg(m_headerDocument.url.toLocalFile());
         m_cppDocument.url = createFile(preamble + cppContents,".cpp",id);
         m_cppDocument.textDoc = openDocument(m_cppDocument.url);
     }
     ~Testbed()
     {
         Core::self()->documentController()->documentForUrl(m_cppDocument.url)->textDocument();
         Core::self()->documentController()->documentForUrl(m_cppDocument.url)->close(KDevelop::IDocument::Discard);
         Core::self()->documentController()->documentForUrl(m_headerDocument.url)->close(KDevelop::IDocument::Discard);
     }
 
     void changeDocument(TestDoc which, Range where, const QString& what, bool waitForUpdate = false)
     {
         TestDocument document;
         if (which == CppDoc)
         {
             document = m_cppDocument;
             if (m_includeBehavior == AutoInclude) {
                 where = Range(where.start().line() + 1, where.start().column(),
                               where.end().line() + 1, where.end().column()); //The include adds a line
             }
         }
         else {
             document = m_headerDocument;
         }
         // we must activate the document, otherwise we cannot find the correct active view
         auto kdevdoc = ICore::self()->documentController()->documentForUrl(document.url);
         QVERIFY(kdevdoc);
         ICore::self()->documentController()->activateDocument(kdevdoc);
         auto view = ICore::self()->documentController()->activeTextDocumentView();
         QCOMPARE(view->document(), document.textDoc);
 
         view->setSelection(where);
         view->removeSelectionText();
         view->setCursorPosition(where.start());
         view->insertText(what);
         QCoreApplication::processEvents();
         if (waitForUpdate) {
             DUChain::self()->waitForUpdate(IndexedString(document.url), KDevelop::TopDUContext::AllDeclarationsAndContexts);
         }
     }
 
     QString documentText(TestDoc which)
     {
         if (which == CppDoc)
         {
             //The CPP document text shouldn't include the autogenerated include line
             QString text = m_cppDocument.textDoc->text();
             return m_includeBehavior == AutoInclude ? text.mid(text.indexOf("\n") + 1) : text;
         }
         else
             return m_headerDocument.textDoc->text();
     }
 
     QString includeFileName() const
     {
         return m_headerDocument.url.toLocalFile();
     }
 
     KTextEditor::Document *document(TestDoc which) const
     {
         return Core::self()->documentController()->documentForUrl(
             which == CppDoc ? m_cppDocument.url : m_headerDocument.url)->textDocument();
     }
 
 private:
     struct TestDocument {
         QUrl url;
         Document *textDoc;
     };
 
     Document* openDocument(const QUrl& url)
     {
         Core::self()->documentController()->openDocument(url);
         DUChain::self()->waitForUpdate(IndexedString(url), KDevelop::TopDUContext::AllDeclarationsAndContexts);
         return Core::self()->documentController()->documentForUrl(url)->textDocument();
     }
 
     IncludeBehavior m_includeBehavior;
     TestDocument m_headerDocument;
     TestDocument m_cppDocument;
 };
 
 
 /**
  * A StateChange describes an insertion/deletion/replacement and the expected result
 **/
 struct StateChange
 {
     StateChange(){};
     StateChange(Testbed::TestDoc document, const Range& range, const QString& newText, const QString& result)
         : document(document)
         , range(range)
         , newText(newText)
         , result(result)
     {
     }
     Testbed::TestDoc document;
     Range range;
     QString newText;
     QString result;
 };
 
 Q_DECLARE_METATYPE(StateChange)
 Q_DECLARE_METATYPE(QList<StateChange>)
 
 void TestAssistants::testRenameAssistant_data()
 {
     QTest::addColumn<QString>("fileContents");
     QTest::addColumn<QString>("oldDeclarationName");
     QTest::addColumn<QList<StateChange> >("stateChanges");
     QTest::addColumn<QString>("finalFileContents");
 
     QTest::newRow("Prepend Text")
         << "int foo(int i)\n { i = 0; return i; }"
         << "i"
         << QList<StateChange>{
             StateChange(Testbed::CppDoc, Range(0,12,0,12), "u", "ui"),
             StateChange(Testbed::CppDoc, Range(0,13,0,13), "z", "uzi"),
         }
         << "int foo(int uzi)\n { uzi = 0; return uzi; }";
 
     QTest::newRow("Append Text")
         << "int foo(int i)\n { i = 0; return i; }"
         << "i"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0,13,0,13), "d", "id"))
         << "int foo(int id)\n { id = 0; return id; }";
 
     QTest::newRow("Replace Text")
         << "int foo(int i)\n { i = 0; return i; }"
         << "i"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0,12,0,13), "u", "u"))
         << "int foo(int u)\n { u = 0; return u; }";
 
     QTest::newRow("Paste Replace")
         << "int foo(int abg)\n { abg = 0; return abg; }"
         << "abg"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0,12,0,15), "abcdefg", "abcdefg"))
         << "int foo(int abcdefg)\n { abcdefg = 0; return abcdefg; }";
 
     QTest::newRow("Paste Insert")
         << "int foo(int abg)\n { abg = 0; return abg; }"
         << "abg"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0,14,0,14), "cdef", "abcdefg"))
         << "int foo(int abcdefg)\n { abcdefg = 0; return abcdefg; }";
 
     QTest::newRow("Letter-by-Letter Prepend")
         << "int foo(int i)\n { i = 0; return i; }"
         << "i"
         << (QList<StateChange>()
             << StateChange(Testbed::CppDoc, Range(0,12,0,12), "a", "ai")
             << StateChange(Testbed::CppDoc, Range(0,13,0,13), "b", "abi")
             << StateChange(Testbed::CppDoc, Range(0,14,0,14), "c", "abci")
         )
         << "int foo(int abci)\n { abci = 0; return abci; }";
     QTest::newRow("Letter-by-Letter Insert")
         << "int foo(int abg)\n { abg = 0; return abg; }"
         << "abg"
         << (QList<StateChange>()
             << StateChange(Testbed::CppDoc, Range(0,14,0,14), "c", "abcg")
             << StateChange(Testbed::CppDoc, Range(0,15,0,15), "d", "abcdg")
             << StateChange(Testbed::CppDoc, Range(0,16,0,16), "e", "abcdeg")
             << StateChange(Testbed::CppDoc, Range(0,17,0,17), "f", "abcdefg")
         )
         << "int foo(int abcdefg)\n { abcdefg = 0; return abcdefg; }";
 }
 
 ProblemPointer findStaticAssistantProblem(const QVector<ProblemPointer>& problems)
 {
     const auto renameProblemIt = std::find_if(problems.cbegin(), problems.cend(), [](const ProblemPointer& p) {
         return dynamic_cast<const StaticAssistantProblem*>(p.constData());
     });
     if (renameProblemIt != problems.cend())
         return *renameProblemIt;
 
     return {};
 }
 
 void TestAssistants::testRenameAssistant()
 {
     QFETCH(QString, fileContents);
     Testbed testbed("", fileContents);
 
     const auto document = testbed.document(Testbed::CppDoc);
     QVERIFY(document);
 
     QExplicitlySharedDataPointer<IAssistant> assistant;
 
     QFETCH(QString, oldDeclarationName);
     QFETCH(QList<StateChange>, stateChanges);
     foreach(StateChange stateChange, stateChanges)
     {
         testbed.changeDocument(Testbed::CppDoc, stateChange.range, stateChange.newText, true);
 
         DUChainReadLocker lock;
 
         auto topCtx = DUChain::self()->chainForDocument(document->url());
         QVERIFY(topCtx);
 
         const auto problem = findStaticAssistantProblem(DUChainUtils::allProblemsForContext(topCtx));
         if (problem)
             assistant = problem->solutionAssistant();
 
         if (stateChange.result.isEmpty()) {
             QVERIFY(!assistant || !assistant->actions().size());
         } else {
             qWarning() << assistant.data() << stateChange.result;
             QVERIFY(assistant && assistant->actions().size());
             RenameAction *r = qobject_cast<RenameAction*>(assistant->actions().first().data());
             QCOMPARE(r->oldDeclarationName(), oldDeclarationName);
             QCOMPARE(r->newDeclarationName(), stateChange.result);
         }
     }
 
     if (assistant && assistant->actions().size()) {
         assistant->actions().first()->execute();
     }
     QFETCH(QString, finalFileContents);
     QCOMPARE(testbed.documentText(Testbed::CppDoc), finalFileContents);
 }
 
 void TestAssistants::testRenameAssistantUndoRename()
 {
     Testbed testbed("", "int foo(int i)\n { i = 0; return i; }");
     testbed.changeDocument(Testbed::CppDoc, Range(0,13,0,13), "d", true);
 
     const auto document = testbed.document(Testbed::CppDoc);
     QVERIFY(document);
 
     DUChainReadLocker lock;
     auto topCtx = DUChain::self()->chainForDocument(document->url());
     QVERIFY(topCtx);
 
     auto firstProblem = findStaticAssistantProblem(DUChainUtils::allProblemsForContext(topCtx));
     QVERIFY(firstProblem);
     auto assistant = firstProblem->solutionAssistant();
     QVERIFY(assistant);
 
     QVERIFY(assistant->actions().size() > 0);
     RenameAction *r = qobject_cast<RenameAction*>(assistant->actions().first().data());
     qWarning() << topCtx->problems() << assistant->actions().first().data() << assistant->actions().size();
     QVERIFY(r);
 
     // now rename the variable back to its original identifier
     testbed.changeDocument(Testbed::CppDoc, Range(0,13,0,14), "");
     // there should be no assistant anymore
     QVERIFY(!assistant || assistant->actions().isEmpty());
 }
 
 const QString SHOULD_ASSIST = "SHOULD_ASSIST"; //An assistant will be visible
 const QString NO_ASSIST = "NO_ASSIST";               //No assistant visible
 
 void TestAssistants::testSignatureAssistant_data()
 {
     QTest::addColumn<QString>("headerContents");
     QTest::addColumn<QString>("cppContents");
     QTest::addColumn<QList<StateChange> >("stateChanges");
     QTest::addColumn<QString>("finalHeaderContents");
     QTest::addColumn<QString>("finalCppContents");
 
     QTest::newRow("change_argument_type")
       << "class Foo {\nint bar(int a, char* b, int c = 10); \n};"
       << "int Foo::bar(int a, char* b, int c)\n{ a = c; b = new char; return a + *b; }"
       << (QList<StateChange>() << StateChange(Testbed::HeaderDoc, Range(1,8,1,11), "char", SHOULD_ASSIST))
       << "class Foo {\nint bar(char a, char* b, int c = 10); \n};"
       << "int Foo::bar(char a, char* b, int c)\n{ a = c; b = new char; return a + *b; }";
 
     QTest::newRow("prepend_arg_header")
       << "class Foo { void bar(int i); };"
       << "void Foo::bar(int i)\n{}"
       << (QList<StateChange>() << StateChange(Testbed::HeaderDoc, Range(0, 21, 0, 21), "char c, ", SHOULD_ASSIST))
       << "class Foo { void bar(char c, int i); };"
       << "void Foo::bar(char c, int i)\n{}";
 
     QTest::newRow("prepend_arg_cpp")
       << "class Foo { void bar(int i); };"
       << "void Foo::bar(int i)\n{}"
       << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0, 14, 0, 14), "char c, ", SHOULD_ASSIST))
       << "class Foo { void bar(char c, int i); };"
       << "void Foo::bar(char c, int i)\n{}";
 
     QTest::newRow("change_default_parameter")
         << "class Foo {\nint bar(int a, char* b, int c = 10); \n};"
         << "int Foo::bar(int a, char* b, int c)\n{ a = c; b = new char; return a + *b; }"
         << (QList<StateChange>() << StateChange(Testbed::HeaderDoc, Range(1,29,1,34), "", NO_ASSIST))
         << "class Foo {\nint bar(int a, char* b, int c); \n};"
         << "int Foo::bar(int a, char* b, int c)\n{ a = c; b = new char; return a + *b; }";
 
     QTest::newRow("change_function_type")
         << "class Foo {\nint bar(int a, char* b, int c = 10); \n};"
         << "int Foo::bar(int a, char* b, int c)\n{ a = c; b = new char; return a + *b; }"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0,0,0,3), "char", SHOULD_ASSIST))
         << "class Foo {\nchar bar(int a, char* b, int c = 10); \n};"
         << "char Foo::bar(int a, char* b, int c)\n{ a = c; b = new char; return a + *b; }";
 
     QTest::newRow("swap_args_definition_side")
         << "class Foo {\nint bar(int a, char* b, int c = 10); \n};"
         << "int Foo::bar(int a, char* b, int c)\n{ a = c; b = new char; return a + *b; }"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0,13,0,28), "char* b, int a,", SHOULD_ASSIST))
         << "class Foo {\nint bar(char* b, int a, int c = 10); \n};"
         << "int Foo::bar(char* b, int a, int c)\n{ a = c; b = new char; return a + *b; }";
 
     // see https://bugs.kde.org/show_bug.cgi?id=299393
     // actually related to the whitespaces in the header...
     QTest::newRow("change_function_constness")
         << "class Foo {\nvoid bar(const Foo&) const;\n};"
         << "void Foo::bar(const Foo&) const\n{}"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0,25,0,31), "", SHOULD_ASSIST))
         << "class Foo {\nvoid bar(const Foo&);\n};"
         << "void Foo::bar(const Foo&)\n{}";
 
     // see https://bugs.kde.org/show_bug.cgi?id=356179
     QTest::newRow("keep_static_cpp")
         << "class Foo { static void bar(int i); };"
         << "void Foo::bar(int i)\n{}"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0, 19, 0, 19), ", char c", SHOULD_ASSIST))
         << "class Foo { static void bar(int i, char c); };"
         << "void Foo::bar(int i, char c)\n{}";
     QTest::newRow("keep_static_header")
         << "class Foo { static void bar(int i); };"
         << "void Foo::bar(int i)\n{}"
         << (QList<StateChange>() << StateChange(Testbed::HeaderDoc, Range(0, 33, 0, 33), ", char c", SHOULD_ASSIST))
         << "class Foo { static void bar(int i, char c); };"
         << "void Foo::bar(int i, char c)\n{}";
 
     // see https://bugs.kde.org/show_bug.cgi?id=356178
     QTest::newRow("keep_default_args_cpp_before")
         << "class Foo { void bar(bool b, int i = 0); };"
         << "void Foo::bar(bool b, int i)\n{}"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0, 14, 0, 14), "char c, ", SHOULD_ASSIST))
         << "class Foo { void bar(char c, bool b, int i = 0); };"
         << "void Foo::bar(char c, bool b, int i)\n{}";
     QTest::newRow("keep_default_args_cpp_after")
         << "class Foo { void bar(bool b, int i = 0); };"
         << "void Foo::bar(bool b, int i)\n{}"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0, 27, 0, 27), ", char c", SHOULD_ASSIST))
         << "class Foo { void bar(bool b, int i = 0, char c = {} /* TODO */); };"
         << "void Foo::bar(bool b, int i, char c)\n{}";
     QTest::newRow("keep_default_args_header_before")
         << "class Foo { void bar(bool b, int i = 0); };"
         << "void Foo::bar(bool b, int i)\n{}"
         << (QList<StateChange>() << StateChange(Testbed::HeaderDoc, Range(0, 29, 0, 29), "char c = 'A', ", SHOULD_ASSIST))
         << "class Foo { void bar(bool b, char c = 'A', int i = 0); };"
         << "void Foo::bar(bool b, char c, int i)\n{}";
     QTest::newRow("keep_default_args_header_after")
         << "class Foo { void bar(bool b, int i = 0); };"
         << "void Foo::bar(bool b, int i)\n{}"
         << (QList<StateChange>() << StateChange(Testbed::HeaderDoc, Range(0, 38, 0, 38), ", char c = 'A'", SHOULD_ASSIST))
         << "class Foo { void bar(bool b, int i = 0, char c = 'A'); };"
         << "void Foo::bar(bool b, int i, char c)\n{}";
 
     // see https://bugs.kde.org/show_bug.cgi?id=355356
     QTest::newRow("no_retval_on_ctor")
         << "class Foo { Foo(); };"
         << "Foo::Foo()\n{}"
         << (QList<StateChange>() << StateChange(Testbed::HeaderDoc, Range(0, 16, 0, 16), "char c", SHOULD_ASSIST))
         << "class Foo { Foo(char c); };"
         << "Foo::Foo(char c)\n{}";
 
     // see https://bugs.kde.org/show_bug.cgi?id=298511
     QTest::newRow("change_return_type_header")
         << "struct Foo { int bar(); };"
         << "int Foo::bar()\n{}"
         << (QList<StateChange>() << StateChange(Testbed::HeaderDoc, Range(0, 13, 0, 16), "char", SHOULD_ASSIST))
         << "struct Foo { char bar(); };"
         << "char Foo::bar()\n{}";
     QTest::newRow("change_return_type_impl")
         << "struct Foo { int bar(); };"
         << "int Foo::bar()\n{}"
         << (QList<StateChange>() << StateChange(Testbed::CppDoc, Range(0, 0, 0, 3), "char", SHOULD_ASSIST))
         << "struct Foo { char bar(); };"
         << "char Foo::bar()\n{}";
 }
 
 void TestAssistants::testSignatureAssistant()
 {
     QFETCH(QString, headerContents);
     QFETCH(QString, cppContents);
     Testbed testbed(headerContents, cppContents);
 
     QExplicitlySharedDataPointer<IAssistant> assistant;
 
     QFETCH(QList<StateChange>, stateChanges);
     foreach (StateChange stateChange, stateChanges)
     {
         testbed.changeDocument(stateChange.document, stateChange.range, stateChange.newText, true);
 
         const auto document = testbed.document(stateChange.document);
         QVERIFY(document);
 
         DUChainReadLocker lock;
 
         auto topCtx = DUChain::self()->chainForDocument(document->url());
         QVERIFY(topCtx);
 
         const auto problem = findStaticAssistantProblem(DUChainUtils::allProblemsForContext(topCtx));
         if (problem) {
             assistant = problem->solutionAssistant();
         }
 
         if (stateChange.result == SHOULD_ASSIST) {
 #if CINDEX_VERSION_MINOR < 35
             QEXPECT_FAIL("change_function_type", "Clang sees that return type of out-of-line definition differs from that in the declaration and won't parse the code...", Abort);
             QEXPECT_FAIL("change_return_type_impl", "Clang sees that return type of out-of-line definition differs from that in the declaration and won't include the function's AST and thus we never get updated about the new return type...", Abort);
 #endif
             QVERIFY(assistant && !assistant->actions().isEmpty());
         } else {
             QVERIFY(!assistant || assistant->actions().isEmpty());
         }
     }
 
     if (assistant && !assistant->actions().isEmpty())
         assistant->actions().first()->execute();
 
     QFETCH(QString, finalHeaderContents);
     QFETCH(QString, finalCppContents);
     QCOMPARE(testbed.documentText(Testbed::HeaderDoc), finalHeaderContents);
     QCOMPARE(testbed.documentText(Testbed::CppDoc), finalCppContents);
 }
 
 enum UnknownDeclarationAction
 {
     NoUnknownDeclarationAction = 0x0,
     ForwardDecls = 0x1,
     MissingInclude = 0x2
 };
 Q_DECLARE_FLAGS(UnknownDeclarationActions, UnknownDeclarationAction)
 Q_DECLARE_METATYPE(UnknownDeclarationActions)
 
 void TestAssistants::testUnknownDeclarationAssistant_data()
 {
     QTest::addColumn<QString>("headerContents");
     QTest::addColumn<QString>("globalText");
     QTest::addColumn<QString>("functionText");
     QTest::addColumn<UnknownDeclarationActions>("actions");
 
     QTest::newRow("unincluded_struct") << "struct test{};" << "" << "test"
         << UnknownDeclarationActions(ForwardDecls | MissingInclude);
     QTest::newRow("forward_declared_struct") << "struct test{};" << "struct test;" << "test *f; f->"
         << UnknownDeclarationActions(MissingInclude);
     QTest::newRow("unknown_struct") << "" << "" << "test"
         << UnknownDeclarationActions();
     QTest::newRow("not a class type") << "void test();" << "" << "test"
         << UnknownDeclarationActions();
 }
 
 void TestAssistants::testUnknownDeclarationAssistant()
 {
     QFETCH(QString, headerContents);
     QFETCH(QString, globalText);
     QFETCH(QString, functionText);
     QFETCH(UnknownDeclarationActions, actions);
 
     static const auto cppContents = QStringLiteral("%1\nvoid f_u_n_c_t_i_o_n() {\n}");
     Testbed testbed(headerContents, cppContents.arg(globalText), Testbed::NoAutoInclude);
     const auto document = testbed.document(Testbed::CppDoc);
     QVERIFY(document);
     const int line = document->lines() - 1;
     testbed.changeDocument(Testbed::CppDoc, Range(line, 0, line, 0), functionText, true);
 
     DUChainReadLocker lock;
 
     auto topCtx = DUChain::self()->chainForDocument(document->url());
     QVERIFY(topCtx);
 
     const auto problems = topCtx->problems();
 
     if (actions == NoUnknownDeclarationAction) {
         QVERIFY(!problems.isEmpty());
         return;
     }
 
     auto firstProblem = problems.first();
     auto assistant = firstProblem->solutionAssistant();
     QVERIFY(assistant);
     const auto assistantActions = assistant->actions();
     QStringList actionDescriptions;
     for (auto action: assistantActions) {
         actionDescriptions << action->description();
     }
 
     {
         const bool hasForwardDecls =
             actionDescriptions.contains(QObject::tr("Forward declare as 'struct'")) ||
             actionDescriptions.contains(QObject::tr("Forward declare as 'class'"));
         QCOMPARE(hasForwardDecls, static_cast<bool>(actions & ForwardDecls));
     }
 
     {
         auto fileName = testbed.includeFileName();
         fileName = fileName.mid(fileName.lastIndexOf('/') + 1);
         const auto description = QObject::tr("Insert \'%1\'")
             .arg(QStringLiteral("#include \"%1\"").arg(fileName));
         const bool hasMissingInclude = actionDescriptions.contains(description);
         QCOMPARE(hasMissingInclude, static_cast<bool>(actions & MissingInclude));
     }
 }
 
 void TestAssistants::testMoveIntoSource()
 {
     QFETCH(QString, origHeader);
     QFETCH(QString, origImpl);
     QFETCH(QString, newHeader);
     QFETCH(QString, newImpl);
     QFETCH(QualifiedIdentifier, id);
 
     TestFile header(origHeader, "h");
     TestFile impl("#include \"" + header.url().byteArray() + "\"\n" + origImpl, "cpp", &header);
 
     {
         TopDUContext* headerCtx = nullptr;
         {
             DUChainReadLocker lock;
             headerCtx = DUChain::self()->chainForDocument(header.url());
         }
         // Here is a problem: when launching tests one by one, we can reuse the same tmp file for headers.
         // But because of document chain for header wasn't unloaded properly in previous run we reuse it here
         // Therefore when using headerCtx->findDeclarations below we find declarations from the previous launch -> tests fail
         if (headerCtx) {
             // TODO: Investigate why this chain doesn't get updated when parsing source file
             DUChainWriteLocker lock;
             DUChain::self()->removeDocumentChain(headerCtx);
         }
     }
 
     impl.parse(KDevelop::TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(impl.waitForParsed());
 
     IndexedDeclaration declaration;
     {
         DUChainReadLocker lock;
         auto headerCtx = DUChain::self()->chainForDocument(header.url());
         QVERIFY(headerCtx);
         auto decls = headerCtx->findDeclarations(id);
         Q_ASSERT(!decls.isEmpty());
         declaration = IndexedDeclaration(decls.first());
         QVERIFY(declaration.isValid());
     }
     CodeRepresentation::setDiskChangesForbidden(false);
     ClangRefactoring refactoring;
     QCOMPARE(refactoring.moveIntoSource(declaration), QString());
     CodeRepresentation::setDiskChangesForbidden(true);
 
     QCOMPARE(header.fileContents(), newHeader);
     QVERIFY(impl.fileContents().endsWith(newImpl));
 }
 
 void TestAssistants::testMoveIntoSource_data()
 {
     QTest::addColumn<QString>("origHeader");
     QTest::addColumn<QString>("origImpl");
     QTest::addColumn<QString>("newHeader");
     QTest::addColumn<QString>("newImpl");
     QTest::addColumn<QualifiedIdentifier>("id");
 
     const QualifiedIdentifier fooId("foo");
 
     QTest::newRow("globalfunction") << QString("int foo()\n{\n    int i = 0;\n    return 0;\n}\n")
                                     << QString()
                                     << QString("int foo();\n")
                                     << QString("\nint foo()\n{\n    int i = 0;\n    return 0;\n}\n")
                                     << fooId;
 
     QTest::newRow("staticfunction") << QString("static int foo()\n{\n    int i = 0;\n    return 0;\n}\n")
                                     << QString()
                                     << QString("static int foo();\n")
                                     << QString("\nint foo()\n{\n    int i = 0;\n    return 0;\n}\n")
                                     << fooId;
 
     QTest::newRow("funcsameline") << QString("int foo() {\n    int i = 0;\n    return 0;\n}\n")
                                     << QString()
                                     << QString("int foo();\n")
                                     << QString("\nint foo() {\n    int i = 0;\n    return 0;\n}\n")
                                     << fooId;
 
     QTest::newRow("func-comment") << QString("int foo()\n/* foobar */ {\n    int i = 0;\n    return 0;\n}\n")
                                     << QString()
                                     << QString("int foo()\n/* foobar */;\n")
                                     << QString("\nint foo() {\n    int i = 0;\n    return 0;\n}\n")
                                     << fooId;
 
     QTest::newRow("func-comment2") << QString("int foo()\n/*asdf*/\n{\n    int i = 0;\n    return 0;\n}\n")
                                     << QString()
                                     << QString("int foo()\n/*asdf*/;\n")
                                     << QString("\nint foo()\n{\n    int i = 0;\n    return 0;\n}\n")
                                     << fooId;
 
     const QualifiedIdentifier aFooId("a::foo");
     QTest::newRow("class-method") << QString("class a {\n    int foo(){\n        return 0;\n    }\n};\n")
                                     << QString()
                                     << QString("class a {\n    int foo();\n};\n")
                                     << QString("\nint a::foo() {\n        return 0;\n    }\n")
                                     << aFooId;
 
     QTest::newRow("class-method-const") << QString("class a {\n    int foo() const\n    {\n        return 0;\n    }\n};\n")
                                     << QString()
                                     << QString("class a {\n    int foo() const;\n};\n")
                                     << QString("\nint a::foo() const\n    {\n        return 0;\n    }\n")
                                     << aFooId;
 
     QTest::newRow("class-method-const-sameline") << QString("class a {\n    int foo() const{\n        return 0;\n    }\n};\n")
                                     << QString()
                                     << QString("class a {\n    int foo() const;\n};\n")
                                     << QString("\nint a::foo() const {\n        return 0;\n    }\n")
                                     << aFooId;
     QTest::newRow("elaborated-type") << QString("namespace NS{class C{};} class a {\nint foo(const NS::C c) const{\nreturn 0;\n}\n};\n")
                                     << QString()
                                     << QString("namespace NS{class C{};} class a {\nint foo(const NS::C c) const;\n};\n")
                                     << QString("\nint a::foo(const NS::C c) const {\nreturn 0;\n}\n")
                                     << aFooId;
     QTest::newRow("add-into-namespace") << QString("namespace NS{class a {\nint foo() const {\nreturn 0;\n}\n};\n}")
                                     << QString("namespace NS{\n}")
                                     << QString("namespace NS{class a {\nint foo() const;\n};\n}")
                                     << QString("namespace NS{\n\nint a::foo() const {\nreturn 0;\n}\n}")
                                     << QualifiedIdentifier("NS::a::foo");
     QTest::newRow("class-template-parameter")
         << QString(R"(
             namespace first {
             template <typename T>
             class Test{};
 
             namespace second {
                 template <typename T>
                 class List;
             }
 
             class MoveIntoSource
             {
             public:
                 void f(const second::List<const volatile Test<first::second::List<int*>>*>& param){}
             };}
         )")
         << QString("")
         << QString(R"(
             namespace first {
             template <typename T>
             class Test{};
 
             namespace second {
                 template <typename T>
                 class List;
             }
 
             class MoveIntoSource
             {
             public:
                 void f(const second::List<const volatile Test<first::second::List<int*>>*>& param);
             };}
         )")
         << QString("namespace first {\nvoid MoveIntoSource::f(const first::second::List< const volatile first::Test< first::second::List< int* > >* >& param) {}}\n\n")
         << QualifiedIdentifier("first::MoveIntoSource::f");
 
         QTest::newRow("move-unexposed-type")
             << QString("namespace std { template<typename _CharT> class basic_string; \ntypedef basic_string<char> string;}\n void move(std::string i){}")
             << QString("")
             << QString("namespace std { template<typename _CharT> class basic_string; \ntypedef basic_string<char> string;}\n void move(std::string i);")
             << QString("void move(std::string i) {}\n")
             << QualifiedIdentifier("move");
         QTest::newRow("move-constructor")
             << QString("class Class{Class(){}\n};")
             << QString("")
             << QString("class Class{Class();\n};")
             << QString("Class::Class() {}\n")
             << QualifiedIdentifier("Class::Class");
 }
diff --git a/languages/clang/tests/test_buddies.cpp b/languages/clang/tests/test_buddies.cpp
index e38116bc2d..eb9743732c 100644
--- a/languages/clang/tests/test_buddies.cpp
+++ b/languages/clang/tests/test_buddies.cpp
@@ -1,516 +1,517 @@
 /***************************************************************************
  *   Copyright 2011 Martin Heide <martin.heide@gmx.net>                    *
  *   Copyright 2012 Milian Wolff <mail@milianw.de>                         *
  *                                                                         *
  *   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.         *
  ***************************************************************************/
 
 #include "test_buddies.h"
 
 #include <QSplitter>
-#include <QtTest/QtTest>
+#include <QTest>
+#include <QLoggingCategory>
 
 #include <KParts/MainWindow>
 #include <KTextEditor/View>
 #include <KTextEditor/Document>
 
 #include <sublime/area.h>
 #include <sublime/view.h>
 #include <sublime/mainwindow.h>
 #include <sublime/container.h>
 #include <sublime/document.h>
 #include <sublime/urldocument.h>
 #include <sublime/controller.h>
 
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <tests/testfile.h>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentationcontroller.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/ibuddydocumentfinder.h>
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/ducontext.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/parsingenvironment.h>
 
 using namespace KDevelop;
 
 #include <KSharedConfig>
 #include <QMimeDatabase>
 #include <QMimeType>
 
 Sublime::MainWindow* toSublimeWindow(KParts::MainWindow* window)
 {
     Sublime::MainWindow* ret = dynamic_cast<Sublime::MainWindow*>(window);
     Q_ASSERT(ret);
     return ret;
 }
 
 void TestBuddies::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.plugins.clang.debug=true\n"));
     QVERIFY(qputenv("KDEV_DISABLE_PLUGINS", "kdevcppsupport"));
     AutoTestShell::init({QStringLiteral("kdevclangsupport")});
     TestCore::initialize();
     m_documentController = ICore::self()->documentController();
     m_uiController = ICore::self()->uiController();
     m_sublimeController = m_uiController->controller();
 }
 
 void TestBuddies::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestBuddies::init()
 {
     // Make sure we start with an empty document set
     QCOMPARE(m_documentController->openDocuments().count(), 0);
 }
 
 void TestBuddies::cleanup()
 {
     m_documentController->closeAllDocuments();
 }
 
 void TestBuddies::verifyFilename(Sublime::View *view, const QString& endOfFilename)
 {
     QVERIFY(view);
     if (view) {
         Sublime::UrlDocument *urlDoc = dynamic_cast<Sublime::UrlDocument *>(view->document());
         QVERIFY(urlDoc);
         if (urlDoc) {
             qDebug() << urlDoc->url().toLocalFile() << endOfFilename;
             QVERIFY(urlDoc->url().toLocalFile().endsWith(endOfFilename));
         }
     }
 }
 
 void TestBuddies::createFile(const QDir& dir, const QString& filename)
 {
     QFile file(dir.filePath(filename));
     QVERIFY(file.open(QIODevice::WriteOnly | QIODevice::Text));
     file.close();
 }
 
 void TestBuddies::enableBuddies(bool enable)
 {
     {
         KConfigGroup uiGroup = KSharedConfig::openConfig()->group("UiSettings");
         uiGroup.writeEntry("TabBarArrangeBuddies", (enable ? 1 : 0));
         uiGroup.sync();
     }
     m_sublimeController->loadSettings();
     QCOMPARE(m_sublimeController->arrangeBuddies(), enable);
 }
 
 void TestBuddies::enableOpenAfterCurrent(bool enable)
 {
     {
         KConfigGroup uiGroup = KSharedConfig::openConfig()->group("UiSettings");
         uiGroup.writeEntry("TabBarOpenAfterCurrent", (enable ? 1 : 0));
         uiGroup.sync();
     }
     m_sublimeController->loadSettings();
     QCOMPARE(m_sublimeController->openAfterCurrent(), enable);
 }
 
 void TestBuddies::testDeclarationDefinitionOrder()
 {
     enableBuddies();
     enableOpenAfterCurrent();
 
     QTemporaryDir tempDirA;
     QDir dirA(tempDirA.path());
     createFile(dirA, "a.cpp");
     createFile(dirA, "b.cpp");
     createFile(dirA, "c.cpp");
     createFile(dirA, "a.h");
     createFile(dirA, "b.h");
     createFile(dirA, "c.h");
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("a.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("b.h")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("c.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("b.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("a.h")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("c.h")));
 
     Sublime::Area *area = m_uiController->activeArea();
     Sublime::AreaIndex* areaIndex = area->indexOf(toSublimeWindow(m_uiController->activeMainWindow())->activeView());
     QCOMPARE(m_documentController->openDocuments().count(), 6);
     //QCOMPARE(m_uiController->documents().count(), 6);
     QCOMPARE(areaIndex->viewCount(), 6);
 
     verifyFilename(areaIndex->views().value(0), "a.h");
     verifyFilename(areaIndex->views().value(1), "a.cpp");
     verifyFilename(areaIndex->views().value(2), "b.h");
     verifyFilename(areaIndex->views().value(3), "b.cpp");
     verifyFilename(areaIndex->views().value(4), "c.h");
     verifyFilename(areaIndex->views().value(5), "c.cpp");
 }
 
 void TestBuddies::testMultiDotFilenames()
 {
     enableBuddies();
     enableOpenAfterCurrent();
 
     QTemporaryDir tempDirA;
     QDir dirA(tempDirA.path());
     createFile(dirA, "a.cpp");
     createFile(dirA, "lots.of.dots.cpp");
     createFile(dirA, "b.cpp");
     createFile(dirA, "lots.of.dots.h");
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("a.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("lots.of.dots.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("b.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("lots.of.dots.h")));
 
     Sublime::Area *area = m_uiController->activeArea();
     Sublime::AreaIndex* areaIndex = area->indexOf(toSublimeWindow(m_uiController->activeMainWindow())->activeView());
     QCOMPARE(m_documentController->openDocuments().count(), 4);
     //QCOMPARE(m_sublimeController->documents().count(), 4);
     QCOMPARE(areaIndex->viewCount(), 4);
 
     verifyFilename(areaIndex->views().value(0), "a.cpp");
     verifyFilename(areaIndex->views().value(1), "lots.of.dots.h");
     verifyFilename(areaIndex->views().value(2), "lots.of.dots.cpp");
     verifyFilename(areaIndex->views().value(3), "b.cpp");
 }
 
 
 void TestBuddies::testActivation()
 {
     enableBuddies();
     enableOpenAfterCurrent();
 
     QTemporaryDir tempDirA;
     QDir dirA(tempDirA.path());
     createFile(dirA, "a.h");
     createFile(dirA, "a.cpp");
     createFile(dirA, "b.cpp");
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("a.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("a.h")));
     verifyFilename(toSublimeWindow(m_uiController->activeMainWindow())->activeView(), "a.h");
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("b.cpp")));
     verifyFilename(toSublimeWindow(m_uiController->activeMainWindow())->activeView(), "b.cpp");
 }
 
 void TestBuddies::testDisableBuddies()
 {
 /*  3. Deactivate buddy option, Activate open next to active tab
        Open a.cpp a.h
        Verify order (a.cpp a.h)
        Verify that a.h is activated
        Activate a.cpp
        Open b.cpp
        Verify order (a.cpp b.cpp a.h) */
     enableBuddies(false);
     enableOpenAfterCurrent();
 
     QTemporaryDir tempDirA;
     QDir dirA(tempDirA.path());
     createFile(dirA, "a.h");
     createFile(dirA, "a.cpp");
     createFile(dirA, "b.cpp");
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("a.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("a.h")));
 
     Sublime::Area *area = m_uiController->activeArea();
     Sublime::AreaIndex* areaIndex = area->indexOf(toSublimeWindow(m_uiController->activeMainWindow())->activeView());
 
     // Buddies disabled => order of tabs should be the order of file opening
     verifyFilename(areaIndex->views().value(0), "a.cpp");
     verifyFilename(areaIndex->views().value(1), "a.h");
     verifyFilename(toSublimeWindow(m_uiController->activeMainWindow())->activeView(), "a.h");
 
     //activate a.cpp => new doc should be opened right next to it
     toSublimeWindow(m_uiController->activeMainWindow())->activateView(areaIndex->views().value(0));
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("b.cpp")));
     verifyFilename(areaIndex->views().value(0), "a.cpp");
     verifyFilename(areaIndex->views().value(1), "b.cpp");
     verifyFilename(areaIndex->views().value(2), "a.h");
     verifyFilename(toSublimeWindow(m_uiController->activeMainWindow())->activeView(), "b.cpp");
 }
 
 void TestBuddies::testDisableOpenAfterCurrent()
 {
 /*  5. Enable buddy option, Disable open next to active tab
        Open foo.h bar.cpp foo.cpp
        Verify order (foo.h foo.cpp bar.cpp)
        Verify that foo.cpp is activated
        Open x.cpp => tab must be placed at the end
        Verify order (foo.h foo.cpp bar.cpp x.cpp)
        Verify that x.cpp is activated*/
     enableBuddies();
     enableOpenAfterCurrent(false);
 
     QTemporaryDir tempDirA;
     QDir dirA;
     createFile(dirA, "foo.h");
     createFile(dirA, "bar.cpp");
     createFile(dirA, "foo.cpp");
     createFile(dirA, "x.cpp");
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("foo.h")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("bar.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("foo.cpp")));
 
     Sublime::Area *area = m_uiController->activeArea();
     Sublime::AreaIndex* areaIndex = area->indexOf(toSublimeWindow(m_uiController->activeMainWindow())->activeView());
 
     verifyFilename(areaIndex->views().value(0), "foo.h");
     verifyFilename(areaIndex->views().value(1), "foo.cpp");
     verifyFilename(areaIndex->views().value(2), "bar.cpp");
     verifyFilename(toSublimeWindow(m_uiController->activeMainWindow())->activeView(), "foo.cpp");
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("x.cpp")));
     verifyFilename(areaIndex->views().value(0), "foo.h");
     verifyFilename(areaIndex->views().value(1), "foo.cpp");
     verifyFilename(areaIndex->views().value(2), "bar.cpp");
     verifyFilename(areaIndex->views().value(3), "x.cpp");
     verifyFilename(toSublimeWindow(m_uiController->activeMainWindow())->activeView(), "x.cpp");
 }
 
 void TestBuddies::testDisableAll()
 {
 /*  6. Disable buddy option, Disable open next to active tab
        Open       foo.cpp bar.h foo.h
        Activate   bar.h
        Open       bar.cpp
        Verify order (foo.cpp bar.h foo.h bar.cpp)
        Verify that bar.cpp is activated*/
     enableBuddies(false);
     enableOpenAfterCurrent(false);
 
     QTemporaryDir tempDirA;
     QDir dirA(tempDirA.path());
     createFile(dirA, "foo.h");
     createFile(dirA, "foo.cpp");
     createFile(dirA, "bar.h");
     createFile(dirA, "bar.cpp");
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("foo.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("bar.h")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("foo.h")));
     Sublime::Area *area = m_uiController->activeArea();
     Sublime::AreaIndex* areaIndex = area->indexOf(toSublimeWindow(m_uiController->activeMainWindow())->activeView());
 
     //activate bar.h
     toSublimeWindow(m_uiController->activeMainWindow())->activateView(areaIndex->views().value(1));
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("bar.cpp")));
 
     verifyFilename(areaIndex->views().value(0), "foo.cpp");
     verifyFilename(areaIndex->views().value(1), "bar.h");
     verifyFilename(areaIndex->views().value(2), "foo.h");
     verifyFilename(areaIndex->views().value(3), "bar.cpp");
     verifyFilename(toSublimeWindow(m_uiController->activeMainWindow())->activeView(), "bar.cpp");
 }
 
 
 void TestBuddies::testMultipleFolders()
 {
 /*  4. Multiple folders:
        Activate buddy option
        Open f/a.cpp f/xyz.cpp g/a.h
        Verify g/a.h is activated
        Verify order (f/a.cpp f/xyz.cpp g/a.h)*/
     enableBuddies();
     enableOpenAfterCurrent();
 
     QTemporaryDir tempDirA;
     QDir dirA(tempDirA.path());
     createFile(dirA, "a.cpp");
     createFile(dirA, "x.cpp");
     QTemporaryDir tempDirB;
     QDir dirB(tempDirB.path());
     createFile(dirB, "a.h");  // different folder => not dirA/a.cpp's buddy!
 
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("a.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("x.cpp")));
     m_documentController->openDocument(QUrl::fromLocalFile(dirB.filePath("a.h")));
 
     Sublime::Area *area = m_uiController->activeArea();
     Sublime::AreaIndex* areaIndex = area->indexOf(toSublimeWindow(m_uiController->activeMainWindow())->activeView());
 
     verifyFilename(areaIndex->views().value(0), "a.cpp");
     verifyFilename(areaIndex->views().value(1), "x.cpp");
     verifyFilename(areaIndex->views().value(2), "a.h");
     verifyFilename(toSublimeWindow(m_uiController->activeMainWindow())->activeView(), "a.h");
 }
 
 void TestBuddies::testSplitViewBuddies()
 {
     Sublime::MainWindow *pMainWindow = toSublimeWindow(m_uiController->activeMainWindow());
 
     enableBuddies();
     enableOpenAfterCurrent();
 
     QTemporaryDir tempDirA;
     QDir dirA(tempDirA.path());
     createFile(dirA, "classA.cpp");
     createFile(dirA, "classA.h");
 
     Sublime::Area *pCodeArea = m_uiController->activeArea();
     QVERIFY(pCodeArea);
 
     IDocument *pClassAHeader = m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("classA.h")));
     QVERIFY(pClassAHeader);
     pMainWindow->activeView()->setObjectName("classA.h");
 
     // now, create a splitted view of the active view (pClassAHeader)
     Sublime::View *pNewView = pMainWindow->activeView()->document()->createView();
     pNewView->setObjectName("splitOf" + pMainWindow->activeView()->objectName());
     pCodeArea->addView(pNewView, pMainWindow->activeView(), Qt::Vertical);
     // and activate it
     pMainWindow->activateView(pNewView);
 
     // get the current view's container from the mainwindow
     QWidget *pCentral = pMainWindow->centralWidget();
     QVERIFY(pCentral);
     QVERIFY(pCentral->inherits("QWidget"));
 
     QWidget *pSplitter = pCentral->findChild<QSplitter*>();
     QVERIFY(pSplitter);
     QVERIFY(pSplitter->inherits("QSplitter"));
 
     Sublime::Container *pContainer = pSplitter->findChild<Sublime::Container*>();
     QVERIFY(pContainer);
 
     // check that it only contains pNewView
     QVERIFY(pContainer->count() == 1 && pContainer->hasWidget(pNewView->widget()));
 
     // now open the corresponding definition file, classA.cpp
     IDocument *pClassAImplem = m_documentController->openDocument(QUrl::fromLocalFile(dirA.filePath("classA.cpp")));
     QVERIFY(pClassAImplem);
     pMainWindow->activeView()->setObjectName("classA.cpp");
 
     // and check its presence alongside pNewView in pContainer
     QVERIFY(pContainer->hasWidget(pNewView->widget()));
     QVERIFY(pContainer->hasWidget(pMainWindow->activeView()->widget()));
 }
 
 void TestBuddies::testDUChainBuddy()
 {
     enableBuddies();
     enableOpenAfterCurrent();
 
     QTemporaryDir dirA;
 
     TestFile header("void myfunction();\n", "h", nullptr, dirA.path());
     TestFile other("void otherfunction() {}\n", "cpp", nullptr, dirA.path());
     TestFile source(
         QString("#include \"%1\"\nvoid myfunction() {}\n").arg(header.url().toUrl().fileName()),
         "cpp", nullptr, dirA.path()
     );
 
     header.parseAndWait();
     other.parseAndWait();
     source.parseAndWait();
 
     // Test IBuddyDocumentFinder::getPotentialBuddies()
     QMimeDatabase db;
     IBuddyDocumentFinder* sourceBuddyFinder = IBuddyDocumentFinder::finderForMimeType(db.mimeTypeForUrl(source.url().toUrl()).name());
     QVector< QUrl > sourceBuddies = sourceBuddyFinder->getPotentialBuddies(source.url().toUrl());
     if (!sourceBuddies.contains(header.url().toUrl())) {
         qDebug() << "got source buddies: " << sourceBuddies;
         qDebug() << "expected: " << header.url().toUrl();
         QFAIL("Failed to find buddy for source file");
     }
     QVERIFY2(!sourceBuddies.contains(other.url().toUrl()), "source buddy list contains unrelated file");
 
     IBuddyDocumentFinder* headerBuddyFinder = IBuddyDocumentFinder::finderForMimeType(db.mimeTypeForUrl(header.url().toUrl()).name());
     QVector< QUrl > headerBuddies = headerBuddyFinder->getPotentialBuddies(header.url().toUrl());
     if (!headerBuddies.contains(source.url().toUrl())) {
         qDebug() << "got header buddies: " << headerBuddies;
         qDebug() << "expected: " << source.url().toUrl();
         QFAIL("Failed to find buddy for header file");
     }
     QVERIFY2(!headerBuddies.contains(other.url().toUrl()), "header buddy list contains unrelated file");
 
     // Test IBuddyDocumentFinder::areBuddies()
     QVERIFY(sourceBuddyFinder->areBuddies(source.url().toUrl(), header.url().toUrl()));
 }
 
 void TestBuddies::testDUChainBuddyVote()
 {
     /*
      * Test that the DUChain buddy system finds the buddy file with the most
      * common declarations/definitions
      */
 
     enableBuddies();
     enableOpenAfterCurrent();
 
     QTemporaryDir dirA;
 
     TestFile header("void func1();\nvoid func2();\nvoid func3();\n", "h", nullptr, dirA.path());
     TestFile source1(
         QString("#include \"%1\"\nvoid func1() {}\n").arg(header.url().toUrl().fileName()),
         "cpp", nullptr, dirA.path()
     );
     TestFile source2(
         QString("#include \"%1\"\nvoid func2() {}\nvoid func3() {}\n").arg(header.url().toUrl().fileName()),
         "cpp", nullptr, dirA.path()
     );
 
     // -> buddy(header) should resolve to source2
 
     header.parseAndWait();
     source1.parseAndWait();
     source2.parseAndWait();
 
     // Test IBuddyDocumentFinder::getPotentialBuddies()
     QMimeDatabase db;
     IBuddyDocumentFinder* sourceBuddyFinder = IBuddyDocumentFinder::finderForMimeType(db.mimeTypeForUrl(source1.url().toUrl()).name());
     QVector< QUrl > sourceBuddies = sourceBuddyFinder->getPotentialBuddies(source1.url().toUrl());
     if (!sourceBuddies.contains(header.url().toUrl())) {
         qDebug() << "got source buddies: " << sourceBuddies;
         qDebug() << "expected: " << header.url().toUrl();
         QFAIL("Failed to find buddy for source file");
     }
 
     IBuddyDocumentFinder* source2BuddyFinder = IBuddyDocumentFinder::finderForMimeType(db.mimeTypeForUrl(source2.url().toUrl()).name());
     QVector< QUrl > source2Buddies = source2BuddyFinder->getPotentialBuddies(source2.url().toUrl());
     if (!source2Buddies.contains(header.url().toUrl())) {
         qDebug() << "got source2 buddies: " << source2Buddies;
         qDebug() << "expected: " << header.url().toUrl();
         QFAIL("Failed to find buddy for source2 file");
     }
 
     IBuddyDocumentFinder* headerBuddyFinder = IBuddyDocumentFinder::finderForMimeType(db.mimeTypeForUrl(header.url().toUrl()).name());
     QVector< QUrl > headerBuddies = headerBuddyFinder->getPotentialBuddies(header.url().toUrl());
     if (!headerBuddies.contains(source2.url().toUrl())) {
         qDebug() << "got header buddies: " << headerBuddies;
         qDebug() << "expected: " << source2.url().toUrl();
         QFAIL("Failed to find buddy for header file");
     }
     QVERIFY2(!headerBuddies.contains(source1.url().toUrl()), "header buddy list contains weaker file");
 }
 
 QTEST_MAIN(TestBuddies)
diff --git a/languages/clang/tests/test_clangutils.cpp b/languages/clang/tests/test_clangutils.cpp
index 6322482863..851cabb5c9 100644
--- a/languages/clang/tests/test_clangutils.cpp
+++ b/languages/clang/tests/test_clangutils.cpp
@@ -1,278 +1,278 @@
 /*
  * Copyright 2014  Kevin Funk <kfunk@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) 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 "test_clangutils.h"
 
 #include "../util/clangutils.h"
 #include "../util/clangtypes.h"
 #include "../util/clangdebug.h"
 
 #include <language/editor/documentrange.h>
 #include <tests/testcore.h>
 #include <tests/testhelpers.h>
 #include <tests/autotestshell.h>
 
 #include <clang-c/Index.h>
 
 #include <QTemporaryFile>
 
 #include <QDebug>
-#include <QtTest>
+#include <QTest>
 
 #include <memory>
 
 QTEST_MAIN(TestClangUtils)
 
 using namespace KDevelop;
 
 namespace {
 
 struct CursorCollectorVisitor
 {
     QVector<CXCursor> cursors;
 
     static CXChildVisitResult visit(CXCursor cursor, CXCursor /*parent*/, CXClientData d)
     {
         CursorCollectorVisitor* thisPtr = static_cast<CursorCollectorVisitor*>(d);
         thisPtr->cursors << cursor;
 
         return CXChildVisit_Recurse;
     };
 };
 
 CXSourceRange toCXRange(CXTranslationUnit unit, const DocumentRange& range)
 {
     auto file = clang_getFile(unit, QString::fromUtf8(range.document.c_str(), range.document.length()).toUtf8());
     auto begin = clang_getLocation(unit, file, range.start().line()+1, range.start().column()+1);
     auto end = clang_getLocation(unit, file, range.end().line()+1, range.end().column()+1);
     return clang_getRange(begin, end);
 }
 
 void parse(const QByteArray& code, CXTranslationUnit* unit, QString* fileName = nullptr)
 {
     Q_ASSERT(unit);
 
     QTemporaryFile tempFile;
     QVERIFY(tempFile.open());
     tempFile.write(code);
     tempFile.flush();
 
     if (fileName) {
         *fileName = tempFile.fileName();
     }
 
     std::unique_ptr<void, void(*)(CXIndex)> index(clang_createIndex(1, 1), clang_disposeIndex);
     const QVector<const char*> args = {"-std=c++11", "-xc++", "-Wall", "-nostdinc", "-nostdinc++"};
     *unit = clang_parseTranslationUnit(
         index.get(), qPrintable(tempFile.fileName()),
         args.data(), args.size(),
         nullptr, 0,
         CXTranslationUnit_None
     );
     QVERIFY(*unit);
 }
 
 template<typename Visitor>
 void runVisitor(const QByteArray& code, Visitor& visitor)
 {
     runVisitor(code, &Visitor::visit, &visitor);
 }
 
 void runVisitor(const QByteArray& code, CXCursorVisitor visitor, CXClientData data)
 {
     CXTranslationUnit unit;
     parse(code, &unit);
     const auto startCursor = clang_getTranslationUnitCursor(unit);
     QVERIFY(!clang_Cursor_isNull(startCursor));
     QVERIFY(clang_visitChildren(startCursor, visitor, data) == 0);
 }
 
 }
 
 void TestClangUtils::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.plugins.clang.debug=true\n"));
     QVERIFY(qputenv("KDEV_DISABLE_PLUGINS", "kdevcppsupport"));
     AutoTestShell::init();
     TestCore::initialize(Core::NoUi);
 }
 
 void TestClangUtils::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestClangUtils::testGetScope()
 {
     QFETCH(QByteArray, code);
     QFETCH(int, cursorIndex);
     QFETCH(QString, expectedScope);
 
     CursorCollectorVisitor visitor;
     runVisitor(code, visitor);
     QVERIFY(cursorIndex < visitor.cursors.size());
     const auto cursor = visitor.cursors[cursorIndex];
     clangDebug() << "Found decl:" << clang_getCursorSpelling(cursor) << "| range:" << ClangRange(clang_getCursorExtent(cursor)).toRange();
     const QString scope = ClangUtils::getScope(cursor);
     QCOMPARE(scope, expectedScope);
 
     QVERIFY(!visitor.cursors.isEmpty());
 }
 
 void TestClangUtils::testGetScope_data()
 {
     QTest::addColumn<QByteArray>("code");
     QTest::addColumn<int>("cursorIndex");
     QTest::addColumn<QString>("expectedScope");
 
     QTest::newRow("func-decl-inside-ns")
         << QByteArray("namespace ns1 { void foo(); } ns1::foo() {}")
         << 2
         << "ns1";
     QTest::newRow("fwd-decl-inside-ns")
         << QByteArray("namespace ns1 { struct foo; } struct ns1::foo {};")
         << 2
         << "ns1";
     QTest::newRow("fwd-decl-inside-ns-inside-ns")
         << QByteArray("namespace ns1 { namespace ns2 { struct foo; } } struct ns1::ns2::foo {};")
         << 3
         << "ns1::ns2";
     QTest::newRow("fwd-decl-inside-ns-inside-ns")
         << QByteArray("namespace ns1 { namespace ns2 { struct foo; } } struct ns1::ns2::foo {};")
         << 3
         << "ns1::ns2";
     QTest::newRow("using-namespace")
         << QByteArray("namespace ns1 { struct klass { struct foo; }; } using namespace ns1; struct klass::foo {};")
         << 5
         << "ns1::klass";
     QTest::newRow("fwd-decl-def-inside-namespace")
         << QByteArray("namespace ns1 { struct klass { struct foo; }; } namespace ns1 { struct klass::foo {}; }")
         << 4
         << "klass";
 }
 
 void TestClangUtils::testTemplateArgumentTypes()
 {
     QFETCH(QByteArray, code);
     QFETCH(int, cursorIndex);
     QFETCH(QStringList, expectedTypes);
 
     CursorCollectorVisitor visitor;
     runVisitor(code, visitor);
     QVERIFY(cursorIndex < visitor.cursors.size());
     const auto cursor = visitor.cursors[cursorIndex];
     const QStringList types = ClangUtils::templateArgumentTypes(cursor);
 
     QCOMPARE(types, expectedTypes);
 }
 
 void TestClangUtils::testTemplateArgumentTypes_data()
 {
     QTest::addColumn<QByteArray>("code");
     QTest::addColumn<int>("cursorIndex");
     QTest::addColumn<QStringList>("expectedTypes");
 
     QTest::newRow("template-spec")
         << QByteArray(
             "template<typename T>\n"
             "struct is_void\n"
             "{ };\n"
             "template<>\n"
             "struct is_void<void>\n"
             "{ };\n")
         << 2
         << QStringList({"void"});
 
     // Partially specialise one
     QTest::newRow("template-partial-spec")
         << QByteArray(
             "template<typename T, unsigned N>\n"
             "struct is_void\n"
             "{ };\n"
             "template<typename T>\n"
             "struct is_void<T, 3>\n"
             "{ };\n")
         << 3
         << QStringList({"type-parameter-0-0", ""});
 
     // Fully specialise 3 args
     QTest::newRow("template-full-spec")
         << QByteArray(
             "template<typename T, typename R, unsigned N>\n"
             "struct is_void\n"
             "{ };\n"
             "template<>\n"
             "struct is_void<unsigned, void, 5>\n"
             "{ };\n")
         << 4
         << QStringList({"unsigned int", "void", ""});
 }
 
 void TestClangUtils::testGetRawContents()
 {
     QFETCH(QByteArray, code);
     QFETCH(KTextEditor::Range, range);
     QFETCH(QString, expectedContents);
 
     CXTranslationUnit unit;
     QString fileName;
     parse(code, &unit, &fileName);
 
     DocumentRange documentRange{IndexedString(fileName), range};
     auto cxRange = toCXRange(unit, documentRange);
     const QString contents = QString::fromLatin1(ClangUtils::getRawContents(unit, cxRange));
     QCOMPARE(contents, expectedContents);
 }
 
 void TestClangUtils::testGetRawContents_data()
 {
     QTest::addColumn<QByteArray>("code");
     QTest::addColumn<KTextEditor::Range>("range");
     QTest::addColumn<QString>("expectedContents");
 
     QTest::newRow("complete")
         << QByteArray("void; int foo = 42; void;")
         << KTextEditor::Range(0, 6, 0, 19)
         << "int foo = 42;";
     QTest::newRow("cut-off-at-start")
         << QByteArray("void; int foo = 42; void;")
         << KTextEditor::Range(0, 7, 0, 19)
         << "nt foo = 42;";
     QTest::newRow("cut-off-at-end")
         << QByteArray("void; int foo = 42; void;")
         << KTextEditor::Range(0, 6, 0, 17)
         << "int foo = 4";
     QTest::newRow("whitespace")
         << QByteArray("void; int         ; void;")
         << KTextEditor::Range(0, 5, 0, 18)
         << " int         ";
     QTest::newRow("empty-range")
         << QByteArray("void;")
         << KTextEditor::Range(0, 0, 0, 0)
         << "";
 }
 
 void TestClangUtils::testRangeForIncludePathSpec()
 {
     QCOMPARE(ClangUtils::rangeForIncludePathSpec("#include <vector>"), KTextEditor::Range(0, 10, 0, 16));
     QCOMPARE(ClangUtils::rangeForIncludePathSpec("#include <foo\\\".h>"), KTextEditor::Range(0, 10, 0, 17));
     QCOMPARE(ClangUtils::rangeForIncludePathSpec("#include \"foo\\\".h\""), KTextEditor::Range(0, 10, 0, 17));
     QCOMPARE(ClangUtils::rangeForIncludePathSpec("#include \"foo<>.h\""), KTextEditor::Range(0, 10, 0, 17));
 }
diff --git a/languages/clang/tests/test_duchain.cpp b/languages/clang/tests/test_duchain.cpp
index 29b0103bc1..11768f7609 100644
--- a/languages/clang/tests/test_duchain.cpp
+++ b/languages/clang/tests/test_duchain.cpp
@@ -1,2019 +1,2024 @@
 /*
  * Copyright 2014  Milian Wolff <mail@milianw.de>
  * Copyright 2014  Kevin Funk <kfunk@kde.org>
  * Copyright 2015  Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 "test_duchain.h"
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/testfile.h>
 #include <tests/testproject.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/duchain/problem.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/structuretype.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/types/typealiastype.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/abstractfunctiondeclaration.h>
 #include <language/duchain/functiondefinition.h>
 #include <language/duchain/classfunctiondeclaration.h>
 #include <language/duchain/forwarddeclaration.h>
 #include <language/duchain/use.h>
 #include <language/duchain/duchaindumper.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/idocumentcontroller.h>
 #include <util/kdevstringhandler.h>
 
 #include "duchain/clangparsingenvironmentfile.h"
 #include "duchain/clangparsingenvironment.h"
 #include "duchain/parsesession.h"
 
 #include <languages/plugins/custom-definesandincludes/idefinesandincludesmanager.h>
 
-#include <QtTest>
+#include <KConfigGroup>
+
+#include <QTest>
+#include <QSignalSpy>
+#include <QLoggingCategory>
+#include <QThread>
 
 QTEST_MAIN(TestDUChain);
 
 using namespace KDevelop;
 
 class TestEnvironmentProvider final : public IDefinesAndIncludesManager::BackgroundProvider
 {
 public:
     ~TestEnvironmentProvider() override = default;
     QHash< QString, QString > definesInBackground(const QString& /*path*/) const override
     {
         return defines;
     }
 
     Path::List includesInBackground(const QString& /*path*/) const override
     {
         return includes;
     }
 
     Path::List frameworkDirectoriesInBackground(const QString&) const override
     {
         return {};
     }
 
     IDefinesAndIncludesManager::Type type() const override
     {
         return IDefinesAndIncludesManager::UserDefined;
     }
 
     QHash<QString, QString> defines;
     Path::List includes;
 };
 
 TestDUChain::~TestDUChain() = default;
 
 void TestDUChain::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.plugins.clang.debug=true\n"));
     QVERIFY(qputenv("KDEV_DISABLE_PLUGINS", "kdevcppsupport"));
     QVERIFY(qputenv("KDEV_CLANG_DISPLAY_DIAGS", "1"));
     AutoTestShell::init({QStringLiteral("kdevclangsupport")});
     auto core = TestCore::initialize();
     delete core->projectController();
     m_projectController = new TestProjectController(core);
     core->setProjectController(m_projectController);
 }
 
 void TestDUChain::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestDUChain::cleanup()
 {
     if (m_provider) {
         IDefinesAndIncludesManager::manager()->unregisterBackgroundProvider(m_provider.data());
     }
 }
 
 void TestDUChain::init()
 {
     m_provider.reset(new TestEnvironmentProvider);
     IDefinesAndIncludesManager::manager()->registerBackgroundProvider(m_provider.data());
 }
 
 struct ExpectedComment
 {
     QString identifier;
     QString comment;
 };
 Q_DECLARE_METATYPE(ExpectedComment)
 Q_DECLARE_METATYPE(AbstractType::WhichType)
 
 void TestDUChain::testComments()
 {
     QFETCH(QString, code);
     QFETCH(ExpectedComment, expectedComment);
 
     TestFile file(code, "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     auto candidates = top->findDeclarations(QualifiedIdentifier(expectedComment.identifier));
     QVERIFY(!candidates.isEmpty());
     auto decl = candidates.first();
     QString comment = QString::fromLocal8Bit(decl->comment());
     comment = KDevelop::htmlToPlainText(comment, KDevelop::CompleteMode);
     QCOMPARE(comment, expectedComment.comment);
 }
 
 void TestDUChain::testComments_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<ExpectedComment>("expectedComment");
 
     // note: Clang only retrieves the comments when in doxygen-style format (i.e. '///', '/**', '///<')
     QTest::newRow("invalid1")
         << "//this is foo\nint foo;"
         << ExpectedComment{"foo", QString()};
     QTest::newRow("invalid2")
         << "/*this is foo*/\nint foo;"
         << ExpectedComment{"foo", QString()};
     QTest::newRow("basic1")
         << "///this is foo\nint foo;"
         << ExpectedComment{"foo", "this is foo"};
     QTest::newRow("basic2")
         << "/**this is foo*/\nint foo;"
         << ExpectedComment{"foo", "this is foo"};
     QTest::newRow("enumerator")
         << "enum Foo { bar1, ///<this is bar1\nbar2 ///<this is bar2\n };"
         << ExpectedComment{"Foo::bar1", "this is bar1"};
     QTest::newRow("comment-formatting")
         << "/** a\n * multiline\n *\n * comment\n */ int foo;"
         << ExpectedComment{"foo", "a multiline\ncomment"};
     QTest::newRow("comment-doxygen-tags")
         << "/** @see bar()\n@param a foo\n*/\nvoid foo(int a);\nvoid bar();"
         << ExpectedComment{"foo", "bar()\na\nfoo"};
 }
 
 void TestDUChain::testElaboratedType()
 {
     QFETCH(QString, code);
     QFETCH(AbstractType::WhichType, type);
 
     TestFile file(code, "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
 
     auto decl = file.topContext()->localDeclarations()[1];
     QVERIFY(decl);
 
     auto function = dynamic_cast<FunctionDeclaration*>(decl);
     QVERIFY(function);
 
     auto functionType = function->type<FunctionType>();
     QVERIFY(functionType);
 
 #if CINDEX_VERSION_MINOR < 34
     QEXPECT_FAIL("namespace", "The ElaboratedType is not exposed through the libclang interface, not much we can do here", Abort);
 #endif
     QVERIFY(functionType->returnType()->whichType() != AbstractType::TypeDelayed);
 #if CINDEX_VERSION_MINOR < 34
     QEXPECT_FAIL("typedef", "After using clang_getCanonicalType on ElaboratedType all typedef information get's stripped away", Continue);
 #endif
     QCOMPARE(functionType->returnType()->whichType(), type);
 }
 
 void TestDUChain::testElaboratedType_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<AbstractType::WhichType>("type");
 
     QTest::newRow("namespace")
         << "namespace NS{struct Type{};} struct NS::Type foo();"
         << AbstractType::TypeStructure;
     QTest::newRow("enum")
         << "enum Enum{}; enum Enum foo();"
         << AbstractType::TypeEnumeration;
     QTest::newRow("typedef")
         << "namespace NS{typedef int type;} NS::type foo();"
         << AbstractType::TypeAlias;
 }
 
 void TestDUChain::testInclude()
 {
     TestFile header("int foo() { return 42; }\n", "h");
     // NOTE: header is _not_ explicitly being parsed, instead the impl job does that
 
     TestFile impl("#include \"" + header.url().byteArray() + "\"\n"
                   "int main() { return foo(); }", "cpp", &header);
     impl.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     auto implCtx = impl.topContext();
     QVERIFY(implCtx);
 
     DUChainReadLocker lock;
     QCOMPARE(implCtx->localDeclarations().size(), 1);
 
     auto headerCtx = DUChain::self()->chainForDocument(header.url());
     QVERIFY(headerCtx);
     QVERIFY(!headerCtx->parsingEnvironmentFile()->needsUpdate());
     QCOMPARE(headerCtx->localDeclarations().size(), 1);
 
     QVERIFY(implCtx->imports(headerCtx, CursorInRevision(0, 10)));
 
     Declaration* foo = headerCtx->localDeclarations().first();
     QCOMPARE(foo->uses().size(), 1);
     QCOMPARE(foo->uses().begin().key(), impl.url());
     QCOMPARE(foo->uses().begin()->size(), 1);
     QCOMPARE(foo->uses().begin()->first(), RangeInRevision(1, 20, 1, 23));
 }
 
 void TestDUChain::testMissingInclude()
 {
     auto code = R"(
 #pragma once
 #include "missing1.h"
 
 template<class T>
 class A
 {
     T a;
 };
 
 #include "missing2.h"
 
 class B : public A<int>
 {
 };
     )";
 
     // NOTE: This fails and needs fixing. If the include of "missing2.h"
     //       above is commented out, then it doesn't fail. Maybe
     //       clang stops processing when it encounters the second missing
     //       header, or similar.
 
     TestFile header(code, "h");
     TestFile impl("#include \"" + header.url().byteArray() + "\"\n", "cpp", &header);
     QVERIFY(impl.parseAndWait(TopDUContext::AllDeclarationsContextsAndUses));
 
     DUChainReadLocker lock;
 
     auto top = impl.topContext();
     QVERIFY(top);
 
     QCOMPARE(top->importedParentContexts().count(), 1);
 
     TopDUContext* headerCtx = dynamic_cast<TopDUContext*>(top->importedParentContexts().first().context(top));
     QVERIFY(headerCtx);
     QCOMPARE(headerCtx->url(), header.url());
 
 #if CINDEX_VERSION_MINOR < 34
     QEXPECT_FAIL("", "Second missing header isn't reported", Continue);
 #endif
     QCOMPARE(headerCtx->problems().count(), 2);
 
     QCOMPARE(headerCtx->localDeclarations().count(), 2);
 
     auto a = dynamic_cast<ClassDeclaration*>(headerCtx->localDeclarations().first());
     QVERIFY(a);
 
     auto b = dynamic_cast<ClassDeclaration*>(headerCtx->localDeclarations().last());
     QVERIFY(b);
 
 #if CINDEX_VERSION_MINOR < 34
     QEXPECT_FAIL("", "Base class isn't assigned correctly", Continue);
 #endif
     QCOMPARE(b->baseClassesSize(), 1u);
 
 #if CINDEX_VERSION_MINOR < 34
     // at least the one problem we have should have been propagated
     QCOMPARE(top->problems().count(), 1);
 #else
     // two errors:
     // /tmp/testfile_f32415.h:3:10: error: 'missing1.h' file not found
     // /tmp/testfile_f32415.h:11:10: error: 'missing2.h' file not found
     QCOMPARE(top->problems().count(), 2);
 #endif
 }
 
 QByteArray createCode(const QByteArray& prefix, const int functions)
 {
     QByteArray code;
     code += "#ifndef " + prefix + "_H\n";
     code += "#define " + prefix + "_H\n";
     for (int i = 0; i < functions; ++i) {
         code += "void myFunc_" + prefix + "(int arg1, char arg2, const char* arg3);\n";
     }
     code += "#endif\n";
     return code;
 }
 
 void TestDUChain::testIncludeLocking()
 {
     TestFile header1(createCode("Header1", 1000), "h");
     TestFile header2(createCode("Header2", 1000), "h");
     TestFile header3(createCode("Header3", 1000), "h");
 
     ICore::self()->languageController()->backgroundParser()->setThreadCount(3);
 
     TestFile impl1("#include \"" + header1.url().byteArray() + "\"\n"
                    "#include \"" + header2.url().byteArray() + "\"\n"
                    "#include \"" + header3.url().byteArray() + "\"\n"
                    "int main() { return 0; }", "cpp");
 
     TestFile impl2("#include \"" + header2.url().byteArray() + "\"\n"
                    "#include \"" + header1.url().byteArray() + "\"\n"
                    "#include \"" + header3.url().byteArray() + "\"\n"
                    "int main() { return 0; }", "cpp");
 
     TestFile impl3("#include \"" + header3.url().byteArray() + "\"\n"
                    "#include \"" + header1.url().byteArray() + "\"\n"
                    "#include \"" + header2.url().byteArray() + "\"\n"
                    "int main() { return 0; }", "cpp");
 
     impl1.parse(TopDUContext::AllDeclarationsContextsAndUses);
     impl2.parse(TopDUContext::AllDeclarationsContextsAndUses);
     impl3.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     QVERIFY(impl1.waitForParsed(5000));
     QVERIFY(impl2.waitForParsed(5000));
     QVERIFY(impl3.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(DUChain::self()->chainForDocument(header1.url()));
     QVERIFY(DUChain::self()->chainForDocument(header2.url()));
     QVERIFY(DUChain::self()->chainForDocument(header3.url()));
 }
 
 void TestDUChain::testReparse()
 {
     TestFile file("int main() { int i = 42; return i; }", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     DeclarationPointer mainDecl;
     DeclarationPointer iDecl;
     for (int i = 0; i < 3; ++i) {
         QVERIFY(file.waitForParsed(500));
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->childContexts().size(), 1);
         QCOMPARE(file.topContext()->localDeclarations().size(), 1);
         DUContext *exprContext = file.topContext()->childContexts().first()->childContexts().first();
         QCOMPARE(exprContext->localDeclarations().size(), 1);
 
         if (i) {
             QVERIFY(mainDecl);
             QCOMPARE(mainDecl.data(), file.topContext()->localDeclarations().first());
 
             QVERIFY(iDecl);
             QCOMPARE(iDecl.data(), exprContext->localDeclarations().first());
         }
         mainDecl = file.topContext()->localDeclarations().first();
         iDecl = exprContext->localDeclarations().first();
 
         QVERIFY(mainDecl->uses().isEmpty());
         QCOMPARE(iDecl->uses().size(), 1);
         QCOMPARE(iDecl->uses().begin()->size(), 1);
 
         if (i == 1) {
             file.setFileContents("int main()\n{\nfloat i = 13; return i - 5;\n}\n");
         }
 
         file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive));
     }
 }
 
 void TestDUChain::testReparseError()
 {
     TestFile file("int i = 1 / 0;\n", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     for (int i = 0; i < 2; ++i) {
         QVERIFY(file.waitForParsed(500));
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         if (!i) {
             QCOMPARE(file.topContext()->problems().size(), 1);
             file.setFileContents("int i = 0;\n");
         } else {
             QCOMPARE(file.topContext()->problems().size(), 0);
         }
 
         file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive));
     }
 }
 
 void TestDUChain::testTemplate()
 {
     TestFile file("template<typename T> struct foo { T bar; };\n"
                   "int main() { foo<int> myFoo; return myFoo.bar; }\n", "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto fooDecl = file.topContext()->localDeclarations().first();
     QVERIFY(fooDecl->internalContext());
     QCOMPARE(fooDecl->internalContext()->localDeclarations().size(), 2);
 
     QCOMPARE(file.topContext()->findDeclarations(QualifiedIdentifier("foo< T >")).size(), 1);
     QCOMPARE(file.topContext()->findDeclarations(QualifiedIdentifier("foo< T >::bar")).size(), 1);
 
     auto mainCtx = file.topContext()->localDeclarations().last()->internalContext()->childContexts().first();
     QVERIFY(mainCtx);
     auto myFoo = mainCtx->localDeclarations().first();
     QVERIFY(myFoo);
     QCOMPARE(myFoo->abstractType()->toString().remove(' '), QStringLiteral("foo<int>"));
 }
 
 void TestDUChain::testNamespace()
 {
     TestFile file("namespace foo { struct bar { int baz; }; }\n"
                   "int main() { foo::bar myBar; }\n", "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto fooDecl = file.topContext()->localDeclarations().first();
     QVERIFY(fooDecl->internalContext());
     QCOMPARE(fooDecl->internalContext()->localDeclarations().size(), 1);
 
     DUContext* top = file.topContext().data();
     DUContext* mainCtx = file.topContext()->childContexts().last();
 
     auto foo = top->localDeclarations().first();
     QCOMPARE(foo->qualifiedIdentifier().toString(), QString("foo"));
 
     DUContext* fooCtx = file.topContext()->childContexts().first();
     QCOMPARE(fooCtx->localScopeIdentifier().toString(), QString("foo"));
     QCOMPARE(fooCtx->scopeIdentifier(true).toString(), QString("foo"));
     QCOMPARE(fooCtx->localDeclarations().size(), 1);
     auto bar = fooCtx->localDeclarations().first();
     QCOMPARE(bar->qualifiedIdentifier().toString(), QString("foo::bar"));
     QCOMPARE(fooCtx->childContexts().size(), 1);
 
     DUContext* barCtx = fooCtx->childContexts().first();
     QCOMPARE(barCtx->localScopeIdentifier().toString(), QString("bar"));
     QCOMPARE(barCtx->scopeIdentifier(true).toString(), QString("foo::bar"));
     QCOMPARE(barCtx->localDeclarations().size(), 1);
     auto baz = barCtx->localDeclarations().first();
     QCOMPARE(baz->qualifiedIdentifier().toString(), QString("foo::bar::baz"));
 
     for (auto ctx : {top, mainCtx}) {
         QCOMPARE(ctx->findDeclarations(QualifiedIdentifier("foo")).size(), 1);
         QCOMPARE(ctx->findDeclarations(QualifiedIdentifier("foo::bar")).size(), 1);
         QCOMPARE(ctx->findDeclarations(QualifiedIdentifier("foo::bar::baz")).size(), 1);
     }
 }
 
 void TestDUChain::testAutoTypeDeduction()
 {
     TestFile file(R"(
         const volatile auto foo = 5;
         template<class T> struct myTemplate {};
         myTemplate<myTemplate<int>& > templRefParam;
         auto autoTemplRefParam = templRefParam;
     )", "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
 
     DUContext* ctx = file.topContext().data();
     QVERIFY(ctx);
     QCOMPARE(ctx->localDeclarations().size(), 4);
     QCOMPARE(ctx->findDeclarations(QualifiedIdentifier("foo")).size(), 1);
     Declaration* decl = ctx->findDeclarations(QualifiedIdentifier("foo"))[0];
     QCOMPARE(decl->identifier(), Identifier("foo"));
 #if CINDEX_VERSION_MINOR < 31
     QEXPECT_FAIL("", "No type deduction here unfortunately, missing API in Clang", Continue);
 #endif
     QVERIFY(decl->type<IntegralType>());
 #if CINDEX_VERSION_MINOR < 31
     QCOMPARE(decl->toString(), QStringLiteral("const volatile auto foo"));
 #else
     QCOMPARE(decl->toString(), QStringLiteral("const volatile int foo"));
 #endif
 
     decl = ctx->findDeclarations(QualifiedIdentifier("autoTemplRefParam"))[0];
     QVERIFY(decl);
     QVERIFY(decl->abstractType());
 #if CINDEX_VERSION_MINOR < 31
     QEXPECT_FAIL("", "Auto type is not exposed via LibClang", Continue);
 #endif
     QCOMPARE(decl->abstractType()->toString(), QStringLiteral("myTemplate< myTemplate< int >& >"));
 }
 
 void TestDUChain::testTypeDeductionInTemplateInstantiation()
 {
     // see: http://clang-developers.42468.n3.nabble.com/RFC-missing-libclang-query-functions-features-td2504253.html
     TestFile file("template<typename T> struct foo { T member; } foo<int> f; auto i = f.member;", "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
 
     DUContext* ctx = file.topContext().data();
     QVERIFY(ctx);
     QCOMPARE(ctx->localDeclarations().size(), 3);
     Declaration* decl = nullptr;
 
     // check 'foo' declaration
     decl = ctx->localDeclarations()[0];
     QVERIFY(decl);
     QCOMPARE(decl->identifier(), Identifier("foo< T >"));
 
     // check type of 'member' inside declaration-scope
     QCOMPARE(ctx->childContexts().size(), 1);
     DUContext* fooCtx = ctx->childContexts().first();
     QVERIFY(fooCtx);
     // Should there really be two declarations?
     QCOMPARE(fooCtx->localDeclarations().size(), 2);
     decl = fooCtx->localDeclarations()[1];
     QCOMPARE(decl->identifier(), Identifier("member"));
 
     // check type of 'member' in definition of 'f'
     decl = ctx->localDeclarations()[1];
     QCOMPARE(decl->identifier(), Identifier("f"));
     decl = ctx->localDeclarations()[2];
     QCOMPARE(decl->identifier(), Identifier("i"));
 #if CINDEX_VERSION_MINOR < 31
     QEXPECT_FAIL("", "No type deduction here unfortunately, missing API in Clang", Continue);
 #endif
     QVERIFY(decl->type<IntegralType>());
 }
 
 void TestDUChain::testVirtualMemberFunction()
 {
     //Forward-declarations with "struct" or "class" are considered equal, so make sure the override is detected correctly.
     TestFile file("struct S {}; struct A { virtual S* ret(); }; struct B : public A { virtual S* ret(); };", "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     DUContext* top = file.topContext().data();
     QVERIFY(top);
 
     QCOMPARE(top->childContexts().count(), 3);
     QCOMPARE(top->localDeclarations().count(), 3);
     QCOMPARE(top->childContexts()[2]->localDeclarations().count(), 1);
     Declaration* decl = top->childContexts()[2]->localDeclarations()[0];
     QCOMPARE(decl->identifier(), Identifier("ret"));
     QVERIFY(DUChainUtils::getOverridden(decl));
 }
 
 void TestDUChain::testBaseClasses()
 {
     TestFile file("class Base {}; class Inherited : public Base {};", "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     DUContext* top = file.topContext().data();
     QVERIFY(top);
 
     QCOMPARE(top->localDeclarations().count(), 2);
     Declaration* baseDecl = top->localDeclarations().first();
     QCOMPARE(baseDecl->identifier(), Identifier("Base"));
 
     ClassDeclaration* inheritedDecl = dynamic_cast<ClassDeclaration*>(top->localDeclarations()[1]);
     QCOMPARE(inheritedDecl->identifier(), Identifier("Inherited"));
 
     QVERIFY(inheritedDecl);
     QCOMPARE(inheritedDecl->baseClassesSize(), 1u);
 
     QCOMPARE(baseDecl->uses().count(), 1);
     QCOMPARE(baseDecl->uses().first().count(), 1);
     QCOMPARE(baseDecl->uses().first().first(), RangeInRevision(0, 40, 0, 44));
 }
 
 void TestDUChain::testReparseBaseClasses()
 {
     TestFile file("struct a{}; struct b : a {};\n", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     for (int i = 0; i < 2; ++i) {
         qDebug() << "run: " << i;
         QVERIFY(file.waitForParsed(500));
         DUChainWriteLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->childContexts().size(), 2);
         QCOMPARE(file.topContext()->childContexts().first()->importers().size(), 1);
         QCOMPARE(file.topContext()->childContexts().last()->importedParentContexts().size(), 1);
 
         QCOMPARE(file.topContext()->localDeclarations().size(), 2);
         auto aDecl = dynamic_cast<ClassDeclaration*>(file.topContext()->localDeclarations().first());
         QVERIFY(aDecl);
         QCOMPARE(aDecl->baseClassesSize(), 0u);
         auto bDecl = dynamic_cast<ClassDeclaration*>(file.topContext()->localDeclarations().last());
         QVERIFY(bDecl);
         QCOMPARE(bDecl->baseClassesSize(), 1u);
         int distance = 0;
         QVERIFY(bDecl->isPublicBaseClass(aDecl, file.topContext(), &distance));
         QCOMPARE(distance, 1);
 
         file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive));
     }
 }
 
 void TestDUChain::testReparseBaseClassesTemplates()
 {
     TestFile file("template<typename T> struct a{}; struct b : a<int> {};\n", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     for (int i = 0; i < 2; ++i) {
         qDebug() << "run: " << i;
         QVERIFY(file.waitForParsed(500));
         DUChainWriteLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->childContexts().size(), 2);
         QCOMPARE(file.topContext()->childContexts().first()->importers().size(), 1);
         QCOMPARE(file.topContext()->childContexts().last()->importedParentContexts().size(), 1);
 
         QCOMPARE(file.topContext()->localDeclarations().size(), 2);
         auto aDecl = dynamic_cast<ClassDeclaration*>(file.topContext()->localDeclarations().first());
         QVERIFY(aDecl);
         QCOMPARE(aDecl->baseClassesSize(), 0u);
         auto bDecl = dynamic_cast<ClassDeclaration*>(file.topContext()->localDeclarations().last());
         QVERIFY(bDecl);
         QCOMPARE(bDecl->baseClassesSize(), 1u);
         int distance = 0;
         QVERIFY(bDecl->isPublicBaseClass(aDecl, file.topContext(), &distance));
         QCOMPARE(distance, 1);
 
         file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive));
     }
 }
 
 void TestDUChain::testGetInheriters_data()
 {
     QTest::addColumn<QString>("code");
 
     QTest::newRow("inline") << "struct Base { struct Inner {}; }; struct Inherited : Base, Base::Inner {};";
     QTest::newRow("outline") << "struct Base { struct Inner; }; struct Base::Inner {}; struct Inherited : Base, Base::Inner {};";
 }
 
 void TestDUChain::testGetInheriters()
 {
     QFETCH(QString, code);
     TestFile file(code, "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     QVERIFY(top->problems().isEmpty());
 
     QCOMPARE(top->localDeclarations().count(), 2);
     Declaration* baseDecl = top->localDeclarations().first();
     QCOMPARE(baseDecl->identifier(), Identifier("Base"));
 
     DUContext* baseCtx = baseDecl->internalContext();
     QVERIFY(baseCtx);
     QCOMPARE(baseCtx->localDeclarations().count(), 1);
 
     Declaration* innerDecl = baseCtx->localDeclarations().first();
     QCOMPARE(innerDecl->identifier(), Identifier("Inner"));
     if (auto forward = dynamic_cast<ForwardDeclaration*>(innerDecl)) {
         innerDecl = forward->resolve(top);
     }
     QVERIFY(dynamic_cast<ClassDeclaration*>(innerDecl));
 
     Declaration* inheritedDecl = top->localDeclarations().last();
     QVERIFY(inheritedDecl);
     QCOMPARE(inheritedDecl->identifier(), Identifier("Inherited"));
 
     uint maxAllowedSteps = uint(-1);
     auto baseInheriters = DUChainUtils::getInheriters(baseDecl, maxAllowedSteps);
     QCOMPARE(baseInheriters, QList<Declaration*>() << inheritedDecl);
 
     maxAllowedSteps = uint(-1);
     auto innerInheriters = DUChainUtils::getInheriters(innerDecl, maxAllowedSteps);
     QCOMPARE(innerInheriters, QList<Declaration*>() << inheritedDecl);
 
     maxAllowedSteps = uint(-1);
     auto inheritedInheriters = DUChainUtils::getInheriters(inheritedDecl, maxAllowedSteps);
     QCOMPARE(inheritedInheriters.count(), 0);
 }
 
 void TestDUChain::testGlobalFunctionDeclaration()
 {
     TestFile file("void foo(int arg1, char arg2);\n", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     file.waitForParsed();
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 1);
     QCOMPARE(file.topContext()->childContexts().size(), 1);
     QVERIFY(!file.topContext()->childContexts().first()->inSymbolTable());
 }
 
 void TestDUChain::testFunctionDefinitionVsDeclaration()
 {
     TestFile file("void func(); void func() {}\n", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed());
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto funcDecl = file.topContext()->localDeclarations()[0];
     QVERIFY(!funcDecl->isDefinition());
     QVERIFY(!dynamic_cast<FunctionDefinition*>(funcDecl));
     auto funcDef = file.topContext()->localDeclarations()[1];
     QVERIFY(dynamic_cast<FunctionDefinition*>(funcDef));
     QVERIFY(funcDef->isDefinition());
 }
 
 void TestDUChain::testEnsureNoDoubleVisit()
 {
     // On some language construct, we may up visiting the same cursor multiple times
     // Example: "struct SomeStruct {} s;"
     // decl: "SomeStruct SomeStruct " of kind StructDecl (2) in main.cpp@[(1,1),(1,17)]
     // decl: "struct SomeStruct s " of kind VarDecl (9) in main.cpp@[(1,1),(1,19)]
     // decl: "SomeStruct SomeStruct " of kind StructDecl (2) in main.cpp@[(1,1),(1,17)]
     //
     // => We end up visiting the StructDecl twice (or more)
     //    That's because we use clang_visitChildren not just on the translation unit cursor.
     //    Apparently just "recursing" vs. "visiting children explicitly"
     //    results in a different AST traversal
 
     TestFile file("struct SomeStruct {} s;\n", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
 
     // there should only be one declaration for "SomeStruct"
     auto candidates = top->findDeclarations(QualifiedIdentifier("SomeStruct"));
     QCOMPARE(candidates.size(), 1);
 }
 
 void TestDUChain::testParsingEnvironment()
 {
     const TopDUContext::Features features = TopDUContext::AllDeclarationsContextsAndUses;
 
     IndexedTopDUContext indexed;
     ClangParsingEnvironment lastEnv;
     {
         TestFile file("int main() {}\n", "cpp");
         auto astFeatures = static_cast<TopDUContext::Features>(features | TopDUContext::AST);
         file.parse(astFeatures);
         file.setKeepDUChainData(true);
         QVERIFY(file.waitForParsed());
 
         DUChainWriteLocker lock;
         auto top = file.topContext();
         QVERIFY(top);
         auto sessionData = ParseSessionData::Ptr(dynamic_cast<ParseSessionData*>(top->ast().data()));
         lock.unlock();
         ParseSession session(sessionData);
         lock.lock();
         QVERIFY(session.data());
         QVERIFY(top);
 
         auto envFile = QExplicitlySharedDataPointer<ClangParsingEnvironmentFile>(
             dynamic_cast<ClangParsingEnvironmentFile*>(file.topContext()->parsingEnvironmentFile().data()));
 
         QCOMPARE(envFile->features(), astFeatures);
         QVERIFY(envFile->featuresSatisfied(astFeatures));
         QCOMPARE(envFile->environmentQuality(), ClangParsingEnvironment::Source);
 
         // if no environment is given, no update should be triggered
         QVERIFY(!envFile->needsUpdate());
 
         // same env should also not trigger a reparse
         ClangParsingEnvironment env = session.environment();
         QCOMPARE(env.quality(), ClangParsingEnvironment::Source);
         QVERIFY(!envFile->needsUpdate(&env));
 
         // but changing the environment should trigger an update
         env.addIncludes(Path::List() << Path("/foo/bar/baz"));
         QVERIFY(envFile->needsUpdate(&env));
         envFile->setEnvironment(env);
         QVERIFY(!envFile->needsUpdate(&env));
 
         // setting the environment quality higher should require an update
         env.setQuality(ClangParsingEnvironment::BuildSystem);
         QVERIFY(envFile->needsUpdate(&env));
         envFile->setEnvironment(env);
         QVERIFY(!envFile->needsUpdate(&env));
 
         // changing defines requires an update
         env.addDefines(QHash<QString, QString>{ { "foo", "bar" } });
         QVERIFY(envFile->needsUpdate(&env));
 
         // but only when changing the defines for the envFile's TU
         const auto barTU = IndexedString("bar.cpp");
         const auto oldTU = env.translationUnitUrl();
         env.setTranslationUnitUrl(barTU);
         QCOMPARE(env.translationUnitUrl(), barTU);
         QVERIFY(!envFile->needsUpdate(&env));
         env.setTranslationUnitUrl(oldTU);
         QVERIFY(envFile->needsUpdate(&env));
 
         // update it again
         envFile->setEnvironment(env);
         QVERIFY(!envFile->needsUpdate(&env));
         lastEnv = env;
 
         // now compare against a lower quality environment
         // in such a case, we do not want to trigger an update
         env.setQuality(ClangParsingEnvironment::Unknown);
         env.setTranslationUnitUrl(barTU);
         QVERIFY(!envFile->needsUpdate(&env));
 
         // even when the environment changes
         env.addIncludes(Path::List() << Path("/lalalala"));
         QVERIFY(!envFile->needsUpdate(&env));
 
         indexed = top->indexed();
     }
 
     DUChain::self()->storeToDisk();
 
     {
         DUChainWriteLocker lock;
         QVERIFY(!DUChain::self()->isInMemory(indexed.index()));
         QVERIFY(indexed.data());
         QVERIFY(DUChain::self()->environmentFileForDocument(indexed));
         auto envFile = QExplicitlySharedDataPointer<ClangParsingEnvironmentFile>(
             dynamic_cast<ClangParsingEnvironmentFile*>(DUChain::self()->environmentFileForDocument(indexed).data()));
         QVERIFY(envFile);
 
         QCOMPARE(envFile->features(), features);
         QVERIFY(envFile->featuresSatisfied(features));
         QVERIFY(!envFile->needsUpdate(&lastEnv));
         DUChain::self()->removeDocumentChain(indexed.data());
     }
 }
 
 void TestDUChain::testActiveDocumentHasASTAttached()
 {
   const TopDUContext::Features features = TopDUContext::AllDeclarationsContextsAndUses;
 
     IndexedTopDUContext indexed;
     ClangParsingEnvironment lastEnv;
     {
         TestFile file("int main() {}\n", "cpp");
         auto astFeatures = static_cast<TopDUContext::Features>(features | TopDUContext::AST);
         file.parse(astFeatures);
         file.setKeepDUChainData(true);
         QVERIFY(file.waitForParsed());
 
         DUChainWriteLocker lock;
         auto top = file.topContext();
         QVERIFY(top);
         auto sessionData = ParseSessionData::Ptr(dynamic_cast<ParseSessionData*>(top->ast().data()));
         lock.unlock();
         ParseSession session(sessionData);
         lock.lock();
         QVERIFY(session.data());
         QVERIFY(top);
         QVERIFY(top->ast());
 
         indexed = top->indexed();
     }
 
     DUChain::self()->storeToDisk();
 
     {
         DUChainWriteLocker lock;
         QVERIFY(!DUChain::self()->isInMemory(indexed.index()));
         QVERIFY(indexed.data());
     }
 
     QUrl url;
     {
         DUChainReadLocker lock;
         auto ctx = indexed.data();
         QVERIFY(ctx);
         QVERIFY(!ctx->ast());
         url = ctx->url().toUrl();
     }
 
     QVERIFY(!QFileInfo::exists(url.toLocalFile()));
     QFile file(url.toLocalFile());
     file.open(QIODevice::WriteOnly);
     Q_ASSERT(file.isOpen());
 
     auto document = ICore::self()->documentController()->openDocument(url);
     QVERIFY(document);
     ICore::self()->documentController()->activateDocument(document);
 
     QApplication::processEvents();
     ICore::self()->languageController()->backgroundParser()->parseDocuments();
     QThread::sleep(1);
 
     document->close(KDevelop::IDocument::Discard);
     {
         DUChainReadLocker lock;
         auto ctx = indexed.data();
         QVERIFY(ctx);
         QVERIFY(ctx->ast());
     }
 
     DUChainWriteLocker lock;
     DUChain::self()->removeDocumentChain(indexed.data());
 }
 
 void TestDUChain::testActiveDocumentsGetBestPriority()
 {
     // note: this test would make more sense in kdevplatform, but we don't have a language plugin available there
     // (required for background parsing)
     // TODO: Create a fake-language plugin in kdevplatform for testing purposes, use that.
 
     TestFile file1("int main() {}\n", "cpp");
     TestFile file2("int main() {}\n", "cpp");
     TestFile file3("int main() {}\n", "cpp");
 
     DUChain::self()->storeToDisk();
 
     auto backgroundParser = ICore::self()->languageController()->backgroundParser();
     QVERIFY(!backgroundParser->isQueued(file1.url()));
 
     auto documentController = ICore::self()->documentController();
 
     // open first document (no activation)
     auto doc = documentController->openDocument(file1.url().toUrl(), KTextEditor::Range::invalid(), {IDocumentController::DoNotActivate});
     QVERIFY(doc);
     QVERIFY(backgroundParser->isQueued(file1.url()));
     QCOMPARE(backgroundParser->priorityForDocument(file1.url()), (int)BackgroundParser::NormalPriority);
 
     // open second document, activate
     doc = documentController->openDocument(file2.url().toUrl());
     QVERIFY(doc);
     QVERIFY(backgroundParser->isQueued(file2.url()));
     QCOMPARE(backgroundParser->priorityForDocument(file2.url()), (int)BackgroundParser::BestPriority);
 
     // open third document, activate, too
     doc = documentController->openDocument(file3.url().toUrl());
     QVERIFY(doc);
     QVERIFY(backgroundParser->isQueued(file3.url()));
     QCOMPARE(backgroundParser->priorityForDocument(file3.url()), (int)BackgroundParser::BestPriority);
 }
 
 void TestDUChain::testSystemIncludes()
 {
     ClangParsingEnvironment env;
 
     Path::List projectIncludes = {
         Path("/projects/1"),
         Path("/projects/1/sub"),
         Path("/projects/2"),
         Path("/projects/2/sub")
     };
     env.addIncludes(projectIncludes);
     auto includes = env.includes();
     // no project paths set, so everything is considered a system include
     QCOMPARE(includes.system, projectIncludes);
     QVERIFY(includes.project.isEmpty());
 
     Path::List systemIncludes = {
         Path("/sys"),
         Path("/sys/sub")
     };
     env.addIncludes(systemIncludes);
     includes = env.includes();
     QCOMPARE(includes.system, projectIncludes + systemIncludes);
     QVERIFY(includes.project.isEmpty());
 
     Path::List projects = {
         Path("/projects/1"),
         Path("/projects/2")
     };
     env.setProjectPaths(projects);
     // now the list should be properly separated
     QCOMPARE(env.projectPaths(), projects);
     includes = env.includes();
     QCOMPARE(includes.system, systemIncludes);
     QCOMPARE(includes.project, projectIncludes);
 }
 
 void TestDUChain::benchDUChainBuilder()
 {
     QBENCHMARK_ONCE {
         TestFile file(
             "#include <vector>\n"
             "#include <map>\n"
             "#include <set>\n"
             "#include <algorithm>\n"
             "#include <functional>\n"
             "#include <limits>\n"
             "#include <bitset>\n"
             "#include <iostream>\n"
             "#include <string>\n"
             "#include <mutex>\n", "cpp");
         file.parse(TopDUContext::AllDeclarationsContextsAndUses);
         QVERIFY(file.waitForParsed(60000));
 
         DUChainReadLocker lock;
         auto top = file.topContext();
         QVERIFY(top);
     }
 }
 
 void TestDUChain::testReparseWithAllDeclarationsContextsAndUses()
 {
     TestFile file("int foo() { return 0; } int main() { return foo(); }", "cpp");
     file.parse(TopDUContext::VisibleDeclarationsAndContexts);
 
     QVERIFY(file.waitForParsed(1000));
 
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->childContexts().size(), 2);
         QCOMPARE(file.topContext()->localDeclarations().size(), 2);
 
         auto dec = file.topContext()->localDeclarations().at(0);
         QEXPECT_FAIL("", "Skipping of function bodies is disabled for now", Continue);
         QVERIFY(dec->uses().isEmpty());
     }
 
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     QVERIFY(file.waitForParsed(500));
 
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->childContexts().size(), 2);
         QCOMPARE(file.topContext()->localDeclarations().size(), 2);
 
         auto mainDecl = file.topContext()->localDeclarations()[1];
         QVERIFY(mainDecl->uses().isEmpty());
         auto foo = file.topContext()->localDeclarations().first();
         QCOMPARE(foo->uses().size(), 1);
     }
 }
 
 void TestDUChain::testReparseOnDocumentActivated()
 {
     TestFile file("int foo() { return 0; } int main() { return foo(); }", "cpp");
     file.parse(TopDUContext::VisibleDeclarationsAndContexts);
 
     QVERIFY(file.waitForParsed(1000));
 
     {
         DUChainReadLocker lock;
         auto ctx = file.topContext();
         QVERIFY(ctx);
         QCOMPARE(ctx->childContexts().size(), 2);
         QCOMPARE(ctx->localDeclarations().size(), 2);
 
         auto dec = ctx->localDeclarations().at(0);
         QEXPECT_FAIL("", "Skipping of function bodies was disabled for now", Continue);
         QVERIFY(dec->uses().isEmpty());
 
         QVERIFY(!ctx->ast());
     }
 
     auto backgroundParser = ICore::self()->languageController()->backgroundParser();
     QVERIFY(!backgroundParser->isQueued(file.url()));
 
     auto doc = ICore::self()->documentController()->openDocument(file.url().toUrl());
     QVERIFY(doc);
     QVERIFY(backgroundParser->isQueued(file.url()));
 
     QSignalSpy spy(backgroundParser, &BackgroundParser::parseJobFinished);
     spy.wait();
 
     doc->close(KDevelop::IDocument::Discard);
 
     {
         DUChainReadLocker lock;
         auto ctx = file.topContext();
         QCOMPARE(ctx->features() & TopDUContext::AllDeclarationsContextsAndUses, static_cast<int>(TopDUContext::AllDeclarationsContextsAndUses));
         QVERIFY(ctx->topContext()->ast());
     }
 }
 
 void TestDUChain::testReparseInclude()
 {
     TestFile header("int foo() { return 42; }\n", "h");
     TestFile impl("#include \"" + header.url().byteArray() + "\"\n"
                   "int main() { return foo(); }", "cpp", &header);
 
     // Use TopDUContext::AST to imitate that document is opened in the editor, so that ClangParseJob can store translation unit, that'll be used for reparsing.
     impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsAndContexts|TopDUContext::AST));
     QVERIFY(impl.waitForParsed(5000));
     {
         DUChainReadLocker lock;
         auto implCtx = impl.topContext();
         QVERIFY(implCtx);
         QCOMPARE(implCtx->importedParentContexts().size(), 1);
     }
 
     impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST));
     QVERIFY(impl.waitForParsed(5000));
 
     DUChainReadLocker lock;
     auto implCtx = impl.topContext();
     QVERIFY(implCtx);
     QCOMPARE(implCtx->localDeclarations().size(), 1);
 
     QCOMPARE(implCtx->importedParentContexts().size(), 1);
 
     auto headerCtx = DUChain::self()->chainForDocument(header.url());
     QVERIFY(headerCtx);
     QVERIFY(!headerCtx->parsingEnvironmentFile()->needsUpdate());
     QCOMPARE(headerCtx->localDeclarations().size(), 1);
 
     QVERIFY(implCtx->imports(headerCtx, CursorInRevision(0, 10)));
 
     Declaration* foo = headerCtx->localDeclarations().first();
     QCOMPARE(foo->uses().size(), 1);
     QCOMPARE(foo->uses().begin().key(), impl.url());
     QCOMPARE(foo->uses().begin()->size(), 1);
     QCOMPARE(foo->uses().begin()->first(), RangeInRevision(1, 20, 1, 23));
 
     QCOMPARE(DUChain::self()->allEnvironmentFiles(header.url()).size(), 1);
     QCOMPARE(DUChain::self()->allEnvironmentFiles(impl.url()).size(), 1);
     QCOMPARE(DUChain::self()->chainsForDocument(header.url()).size(), 1);
     QCOMPARE(DUChain::self()->chainsForDocument(impl.url()).size(), 1);
 }
 
 void TestDUChain::testReparseChangeEnvironment()
 {
     TestFile header("int foo() { return 42; }\n", "h");
     TestFile impl("#include \"" + header.url().byteArray() + "\"\n"
                   "int main() { return foo(); }", "cpp", &header);
 
     uint hashes[3] = {0, 0, 0};
 
     for (int i = 0; i < 3; ++i) {
         impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
         QVERIFY(impl.waitForParsed(5000));
 
         {
             DUChainReadLocker lock;
             QVERIFY(impl.topContext());
             auto env = dynamic_cast<ClangParsingEnvironmentFile*>(impl.topContext()->parsingEnvironmentFile().data());
             QVERIFY(env);
             QCOMPARE(env->environmentQuality(), ClangParsingEnvironment::Source);
             hashes[i] = env->environmentHash();
             QVERIFY(hashes[i]);
 
             // we should never end up with multiple env files or chains in memory for these files
             QCOMPARE(DUChain::self()->allEnvironmentFiles(impl.url()).size(), 1);
             QCOMPARE(DUChain::self()->chainsForDocument(impl.url()).size(), 1);
             QCOMPARE(DUChain::self()->allEnvironmentFiles(header.url()).size(), 1);
             QCOMPARE(DUChain::self()->chainsForDocument(header.url()).size(), 1);
         }
 
         // in every run, we expect the environment to have changed
         for (int j = 0; j < i; ++j) {
             QVERIFY(hashes[i] != hashes[j]);
         }
 
         if (i == 0) {
             // 1) change defines
             m_provider->defines.insert("foooooooo", "baaar!");
         } else if (i == 1) {
             // 2) change includes
             m_provider->includes.append(Path("/foo/bar/asdf/lalala"));
         } // 3) stop
     }
 }
 
 void TestDUChain::testMacroDependentHeader()
 {
     TestFile header("struct MY_CLASS { class Q{Q(); int m;}; int m; };\n", "h");
     TestFile impl("#define MY_CLASS A\n"
                   "#include \"" + header.url().byteArray() + "\"\n"
                   "#undef MY_CLASS\n"
                   "#define MY_CLASS B\n"
                   "#include \"" + header.url().byteArray() + "\"\n"
                   "#undef MY_CLASS\n"
                   "A a;\n"
                   "const A::Q aq;\n"
                   "B b;\n"
                   "const B::Q bq;\n"
                   "int am = a.m;\n"
                   "int aqm = aq.m;\n"
                   "int bm = b.m;\n"
                   "int bqm = bq.m;\n"
                   , "cpp", &header);
 
     impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
     QVERIFY(impl.waitForParsed(500000));
 
     DUChainReadLocker lock;
     TopDUContext* top = impl.topContext().data();
     QVERIFY(top);
     QCOMPARE(top->localDeclarations().size(), 10); // 2x macro, then a, aq, b, bq
     QCOMPARE(top->importedParentContexts().size(), 1);
     AbstractType::Ptr type = top->localDeclarations()[2]->abstractType();
     StructureType* sType = dynamic_cast<StructureType*>(type.data());
     QVERIFY(sType);
     QCOMPARE(sType->toString(), QString("A"));
     Declaration* decl = sType->declaration(top);
     QVERIFY(decl);
     AbstractType::Ptr type2 = top->localDeclarations()[4]->abstractType();
     StructureType* sType2 = dynamic_cast<StructureType*>(type2.data());
     QVERIFY(sType2);
     QCOMPARE(sType2->toString(), QString("B"));
     Declaration* decl2 = sType2->declaration(top);
     QVERIFY(decl2);
 
     TopDUContext* top2 = dynamic_cast<TopDUContext*>(top->importedParentContexts()[0].context(top));
     QVERIFY(top2);
     QCOMPARE(top2->localDeclarations().size(), 2);
     QCOMPARE(top2->localDeclarations()[0], decl);
     QCOMPARE(top2->localDeclarations()[1], decl2);
     qDebug() << "DECL RANGE:" << top2->localDeclarations()[0]->range().castToSimpleRange();
     qDebug() << "CTX RANGE:" << top2->localDeclarations()[0]->internalContext()->range().castToSimpleRange();
 
     // validate uses:
     QCOMPARE(top->usesCount(), 14);
     QCOMPARE(top->uses()[0].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("A"));
     QCOMPARE(top->uses()[1].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("A"));
     QCOMPARE(top->uses()[2].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("A::Q"));
     QCOMPARE(top->uses()[3].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("B"));
     QCOMPARE(top->uses()[4].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("B"));
     QCOMPARE(top->uses()[5].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("B::Q"));
     QCOMPARE(top->uses()[6].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("a"));
     QCOMPARE(top->uses()[7].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("A::m"));
     QCOMPARE(top->uses()[8].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("aq"));
     QCOMPARE(top->uses()[9].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("A::Q::m"));
     QCOMPARE(top->uses()[10].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("b"));
     QCOMPARE(top->uses()[11].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("B::m"));
     QCOMPARE(top->uses()[12].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("bq"));
     QCOMPARE(top->uses()[13].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("B::Q::m"));
 }
 
 void TestDUChain::testHeaderParsingOrder1()
 {
     TestFile header("typedef const A<int> B;\n", "h");
     TestFile impl("template<class T> class A{};\n"
                   "#include \"" + header.url().byteArray() + "\"\n"
                   "B c;", "cpp", &header);
 
     impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
     QVERIFY(impl.waitForParsed(500000));
 
     DUChainReadLocker lock;
     TopDUContext* top = impl.topContext().data();
     QVERIFY(top);
     QCOMPARE(top->localDeclarations().size(), 2);
     QCOMPARE(top->importedParentContexts().size(), 1);
     AbstractType::Ptr type = top->localDeclarations()[1]->abstractType();
     TypeAliasType* aType = dynamic_cast<TypeAliasType*>(type.data());
     QVERIFY(aType);
     AbstractType::Ptr targetType = aType->type();
     QVERIFY(targetType);
     IdentifiedType *idType = dynamic_cast<IdentifiedType*>(targetType.data());
     QVERIFY(idType);
     // this declaration could be resolved, because it was created with an
     // indirect DeclarationId that is resolved from the perspective of 'top'
     Declaration* decl = idType->declaration(top);
     // NOTE: the decl. doesn't know (yet) about the template insantiation <int>
     QVERIFY(decl);
     QCOMPARE(decl, top->localDeclarations()[0]);
     
     // now ensure that a use was build for 'A' in header1
     TopDUContext* top2 = dynamic_cast<TopDUContext*>(top->importedParentContexts()[0].context(top));
     QVERIFY(top2);
     QEXPECT_FAIL("", "the use could not be created because the corresponding declaration didn't exist yet", Continue);
     QCOMPARE(top2->usesCount(), 1);
     // Declaration* decl2 = top2->uses()[0].usedDeclaration(top2);
     // QVERIFY(decl2);
     // QCOMPARE(decl, decl2);
 }
 
 void TestDUChain::testHeaderParsingOrder2()
 {
     TestFile header("template<class T> class A{};\n", "h");
     TestFile header2("typedef const A<int> B;\n", "h");
     TestFile impl("#include \"" + header.url().byteArray() + "\"\n"
                   "#include \"" + header2.url().byteArray() + "\"\n"
                   "B c;", "cpp", &header);
 
     impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
     QVERIFY(impl.waitForParsed(500000));
 
     DUChainReadLocker lock;
     TopDUContext* top = impl.topContext().data();
     QVERIFY(top);
     QCOMPARE(top->localDeclarations().size(), 1);
     QCOMPARE(top->importedParentContexts().size(), 2);
     AbstractType::Ptr type = top->localDeclarations()[0]->abstractType();
     TypeAliasType* aType = dynamic_cast<TypeAliasType*>(type.data());
     QVERIFY(aType);
     AbstractType::Ptr targetType = aType->type();
     QVERIFY(targetType);
     IdentifiedType *idType = dynamic_cast<IdentifiedType*>(targetType.data());
     QVERIFY(idType);
     Declaration* decl = idType->declaration(top);
     // NOTE: the decl. doesn't know (yet) about the template insantiation <int>
     QVERIFY(decl);
     
     // now ensure that a use was build for 'A' in header2
     TopDUContext* top2 = dynamic_cast<TopDUContext*>(top->importedParentContexts()[1].context(top));
     QVERIFY(top2);
     QCOMPARE(top2->usesCount(), 1);
     Declaration* decl2 = top2->uses()[0].usedDeclaration(top2);
     QCOMPARE(decl, decl2);
 }
 
 void TestDUChain::testMacrosRanges()
 {
     TestFile file("#define FUNC_MACROS(x) struct str##x{};\nFUNC_MACROS(x);", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto macroDefinition = file.topContext()->localDeclarations()[0];
     QVERIFY(macroDefinition);
     QCOMPARE(macroDefinition->range(), RangeInRevision(0,8,0,19));
     auto structDeclaration = file.topContext()->localDeclarations()[1];
     QVERIFY(structDeclaration);
     QCOMPARE(structDeclaration->range(), RangeInRevision(1,0,1,0));
 
     QCOMPARE(macroDefinition->uses().size(), 1);
     QCOMPARE(macroDefinition->uses().begin()->first(), RangeInRevision(1,0,1,11));
 }
 
 void TestDUChain::testMacroUses()
 {
     TestFile file("#define USER(x) x\n#define USED\nUSER(USED)", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto macroDefinition1 = file.topContext()->localDeclarations()[0];
     auto macroDefinition2 = file.topContext()->localDeclarations()[1];
 
     QCOMPARE(macroDefinition1->uses().size(), 1);
     QCOMPARE(macroDefinition1->uses().begin()->first(), RangeInRevision(2,0,2,4));
 #if CINDEX_VERSION_MINOR < 32
     QEXPECT_FAIL("", "This appears to be a clang bug, the AST doesn't contain the macro use", Continue);
 #endif
     QCOMPARE(macroDefinition2->uses().size(), 1);
     if (macroDefinition2->uses().size())
     {
         QCOMPARE(macroDefinition2->uses().begin()->first(), RangeInRevision(2,5,2,9));
     }
 }
 
 void TestDUChain::testMultiLineMacroRanges()
 {
     TestFile file("#define FUNC_MACROS(x) struct str##x{};\nFUNC_MACROS(x\n);", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto macroDefinition = file.topContext()->localDeclarations()[0];
     QVERIFY(macroDefinition);
     QCOMPARE(macroDefinition->range(), RangeInRevision(0,8,0,19));
     auto structDeclaration = file.topContext()->localDeclarations()[1];
     QVERIFY(structDeclaration);
     QCOMPARE(structDeclaration->range(), RangeInRevision(1,0,1,0));
 
     QCOMPARE(macroDefinition->uses().size(), 1);
     QCOMPARE(macroDefinition->uses().begin()->first(), RangeInRevision(1,0,1,11));
 }
 
 void TestDUChain::testNestedMacroRanges()
 {
     TestFile file("#define INNER int var; var = 0;\n#define MACRO() INNER\nint main(){MACRO(\n);}", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 3);
     auto main = file.topContext()->localDeclarations()[2];
     QVERIFY(main);
     auto mainCtx = main->internalContext()->childContexts().first();
     QVERIFY(mainCtx);
     QCOMPARE(mainCtx->localDeclarations().size(), 1);
     auto var = mainCtx->localDeclarations().first();
     QVERIFY(var);
     QCOMPARE(var->range(), RangeInRevision(2,11,2,11));
 
     QCOMPARE(var->uses().size(), 1);
     QCOMPARE(var->uses().begin()->first(), RangeInRevision(2,11,2,11));
 }
 
 void TestDUChain::testNestedImports()
 {
     TestFile B("#pragma once\nint B();\n", "h");
     TestFile C("#pragma once\n#include \"" + B.url().byteArray() + "\"\nint C();\n", "h");
     TestFile A("#include \"" + B.url().byteArray() + "\"\n" + "#include \"" + C.url().byteArray() + "\"\nint A();\n", "cpp");
 
     A.parse();
     QVERIFY(A.waitForParsed(5000));
 
     DUChainReadLocker lock;
 
     auto BCtx = DUChain::self()->chainForDocument(B.url().toUrl());
     QVERIFY(BCtx);
     QVERIFY(BCtx->importedParentContexts().isEmpty());
 
     auto CCtx = DUChain::self()->chainForDocument(C.url().toUrl());
     QVERIFY(CCtx);
     QCOMPARE(CCtx->importedParentContexts().size(), 1);
     QVERIFY(CCtx->imports(BCtx, CursorInRevision(1, 10)));
 
     auto ACtx = A.topContext();
     QVERIFY(ACtx);
     QCOMPARE(ACtx->importedParentContexts().size(), 2);
     QVERIFY(ACtx->imports(BCtx, CursorInRevision(0, 10)));
     QVERIFY(ACtx->imports(CCtx, CursorInRevision(1, 10)));
 }
 
 void TestDUChain::testEnvironmentWithDifferentOrderOfElements()
 {
     TestFile file("int main();\n", "cpp");
 
     m_provider->includes.clear();
     m_provider->includes.append(Path("/path1"));
     m_provider->includes.append(Path("/path2"));
 
     m_provider->defines.clear();
     m_provider->defines.insert("key1", "value1");
     m_provider->defines.insert("key2", "value2");
     m_provider->defines.insert("key3", "value3");
 
     uint previousHash = 0;
     for (int i: {0, 1, 2, 3}) {
         file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
 
         QVERIFY(file.waitForParsed(5000));
 
         {
             DUChainReadLocker lock;
             QVERIFY(file.topContext());
             auto env = dynamic_cast<ClangParsingEnvironmentFile*>(file.topContext()->parsingEnvironmentFile().data());
             QVERIFY(env);
             QCOMPARE(env->environmentQuality(), ClangParsingEnvironment::Source);
             if (previousHash) {
                 if (i == 3) {
                     QVERIFY(previousHash != env->environmentHash());
                 } else {
                     QCOMPARE(previousHash, env->environmentHash());
                 }
             }
             previousHash = env->environmentHash();
             QVERIFY(previousHash);
         }
 
         if (i == 0) {
             //Change order of defines. Hash of the environment should stay the same.
             m_provider->defines.clear();
             m_provider->defines.insert("key3", "value3");
             m_provider->defines.insert("key1", "value1");
             m_provider->defines.insert("key2", "value2");
         } else if (i == 1) {
             //Add the same macros twice. Hash of the environment should stay the same.
             m_provider->defines.clear();
             m_provider->defines.insert("key2", "value2");
             m_provider->defines.insert("key3", "value3");
             m_provider->defines.insert("key3", "value3");
             m_provider->defines.insert("key1", "value1");
         } else if (i == 2) {
             //OTOH order of includes should change hash of the environment.
             m_provider->includes.clear();
             m_provider->includes.append(Path("/path2"));
             m_provider->includes.append(Path("/path1"));
         }
     }
 }
 
 void TestDUChain::testReparseMacro()
 {
     TestFile file("#define DECLARE(a) typedef struct a##_ {} *a;\nDECLARE(D);\nD d;", "cpp");
     file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST));
     QVERIFY(file.waitForParsed(5000));
 
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
     }
 
     file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 5);
 
     auto macroDefinition = file.topContext()->localDeclarations()[0];
     QVERIFY(macroDefinition);
     QCOMPARE(macroDefinition->range(), RangeInRevision(0,8,0,15));
     QCOMPARE(macroDefinition->uses().size(), 1);
     QCOMPARE(macroDefinition->uses().begin()->first(), RangeInRevision(1,0,1,7));
 
     auto structDeclaration = file.topContext()->localDeclarations()[1];
     QVERIFY(structDeclaration);
     QCOMPARE(structDeclaration->range(), RangeInRevision(1,0,1,0));
 
     auto structTypedef = file.topContext()->localDeclarations()[3];
     QVERIFY(structTypedef);
     QCOMPARE(structTypedef->range(), RangeInRevision(1,8,1,9));
     QCOMPARE(structTypedef->uses().size(), 1);
     QCOMPARE(structTypedef->uses().begin()->first(), RangeInRevision(2,0,2,1));
 }
 
 void TestDUChain::testGotoStatement()
 {
     TestFile file("int main() {\ngoto label;\ngoto label;\nlabel: return 0;}", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 1);
     auto main = file.topContext()->localDeclarations()[0];
     QVERIFY(main);
     auto mainCtx = main->internalContext()->childContexts().first();
     QVERIFY(mainCtx);
     QCOMPARE(mainCtx->localDeclarations().size(), 1);
     auto label = mainCtx->localDeclarations().first();
     QVERIFY(label);
     QCOMPARE(label->range(), RangeInRevision(3,0,3,5));
 
     QCOMPARE(label->uses().size(), 1);
     QCOMPARE(label->uses().begin()->first(), RangeInRevision(1,5,1,10));
     QCOMPARE(label->uses().begin()->last(), RangeInRevision(2,5,2,10));
 }
 
 void TestDUChain::testRangesOfOperatorsInsideMacro()
 {
     TestFile file("class Test{public: Test& operator++(int);};\n#define MACRO(var) var++;\nint main(){\nTest tst; MACRO(tst)}", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 3);
     auto testClass = file.topContext()->localDeclarations()[0];
     QVERIFY(testClass);
     auto operatorPlusPlus = testClass->internalContext()->localDeclarations().first();
     QVERIFY(operatorPlusPlus);
     QCOMPARE(operatorPlusPlus->uses().size(), 1);
     QCOMPARE(operatorPlusPlus->uses().begin()->first(), RangeInRevision(3,10,3,10));
 }
 
 void TestDUChain::testUsesCreatedForDeclarations()
 {
     auto code = R"(template<typename T> void functionTemplate(T);
             template<typename U> void functionTemplate(U) {}
 
             namespace NS { class Class{}; }
             using NS::Class;
 
             Class function();
             NS::Class function() { return {}; }
 
             int main () {
                 functionTemplate(int());
                 function(); }
     )";
     TestFile file(code, "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed());
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
 
     auto functionTemplate = file.topContext()->findDeclarations(QualifiedIdentifier("functionTemplate"));
     QVERIFY(!functionTemplate.isEmpty());
     auto functionTemplateDeclaration = DUChainUtils::declarationForDefinition(functionTemplate.first());
     QVERIFY(!functionTemplateDeclaration->isDefinition());
 #if CINDEX_VERSION_MINOR < 29
     QEXPECT_FAIL("", "No API in LibClang to determine function template type", Continue);
 #endif
     QCOMPARE(functionTemplateDeclaration->uses().count(), 1);
 
     auto function = file.topContext()->findDeclarations(QualifiedIdentifier("function"));
     QVERIFY(!function.isEmpty());
     auto functionDeclaration = DUChainUtils::declarationForDefinition(function.first());
     QVERIFY(!functionDeclaration->isDefinition());
     QCOMPARE(functionDeclaration->uses().count(), 1);
 }
 
 void TestDUChain::testReparseIncludeGuard()
 {
     TestFile header("#ifndef GUARD\n#define GUARD\nint something;\n#endif\n", "h");
     TestFile impl("#include \"" + header.url().byteArray() + "\"\n", "cpp", &header);
 
     QVERIFY(impl.parseAndWait(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::AST  )));
     {
         DUChainReadLocker lock;
         QCOMPARE(static_cast<TopDUContext*>(impl.topContext()->
             importedParentContexts().first().context(impl.topContext()))->problems().size(), 0);
     }
     QVERIFY(impl.parseAndWait(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive)));
     {
         DUChainReadLocker lock;
         QCOMPARE(static_cast<TopDUContext*>(impl.topContext()->
             importedParentContexts().first().context(impl.topContext()))->problems().size(), 0);
     }
 }
 
 void TestDUChain::testExternC()
 {
     auto code = R"(extern "C" { void foo(); })";
     TestFile file(code, "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     QVERIFY(!top->findDeclarations(QualifiedIdentifier("foo")).isEmpty());
 }
 
 void TestDUChain::testReparseUnchanged_data()
 {
     QTest::addColumn<QString>("headerCode");
     QTest::addColumn<QString>("implCode");
 
     QTest::newRow("include-guards") << R"(
         #ifndef GUARD
         #define GUARD
         int something;
         #endif
     )" << R"(
         #include "%1"
     )";
 
     QTest::newRow("template-default-parameters") << R"(
         #ifndef TEST_H
         #define TEST_H
 
         template<unsigned T=123, unsigned... U>
         class dummy;
 
         template<unsigned T, unsigned... U>
         class dummy {
             int field[T];
         };
 
         #endif
     )" << R"(
         #include "%1"
 
         int main(int, char **) {
             dummy<> x;
             (void)x;
         }
     )";
 }
 
 void TestDUChain::testReparseUnchanged()
 {
     QFETCH(QString, headerCode);
     QFETCH(QString, implCode);
     TestFile header(headerCode, "h");
     TestFile impl(implCode.arg(header.url().str()), "cpp", &header);
 
     auto checkProblems = [&] (bool reparsed) {
         DUChainReadLocker lock;
         auto headerCtx = DUChain::self()->chainForDocument(header.url());
         QVERIFY(headerCtx);
         QVERIFY(headerCtx->problems().isEmpty());
         auto implCtx = DUChain::self()->chainForDocument(impl.url());
         QVERIFY(implCtx);
         if (reparsed && CINDEX_VERSION_MINOR > 29 && CINDEX_VERSION_MINOR < 33) {
             QEXPECT_FAIL("template-default-parameters", "the precompiled preamble messes the default template parameters up in clang 3.7", Continue);
         }
         QVERIFY(implCtx->problems().isEmpty());
     };
 
     impl.parseAndWait(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::AST  ));
     checkProblems(false);
 
     impl.parseAndWait(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive));
     checkProblems(true);
 }
 
 void TestDUChain::testTypeAliasTemplate()
 {
     TestFile file("template <typename T> using TypeAliasTemplate = T;", "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
 
     auto templateAlias = file.topContext()->localDeclarations().last();
     QVERIFY(templateAlias);
 #if CINDEX_VERSION_MINOR < 31
     QEXPECT_FAIL("", "TypeAliasTemplate is not exposed via LibClang", Abort);
 #endif
     QVERIFY(templateAlias->abstractType());
     QCOMPARE(templateAlias->abstractType()->toString(), QStringLiteral("TypeAliasTemplate"));
 }
 
 void TestDUChain::testDeclarationsInsideMacroExpansion()
 {
     TestFile header("#define DECLARE(a) typedef struct a##__ {int var;} *a\nDECLARE(D);\n", "h");
     TestFile file("#include \"" + header.url().byteArray() + "\"\nint main(){\nD d; d->var;}\n", "cpp");
 
     file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST));
     QVERIFY(file.waitForParsed(5000));
 
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
     }
 
     file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 1);
 
     auto context = file.topContext()->childContexts().first()->childContexts().first();
     QVERIFY(context);
     QCOMPARE(context->localDeclarations().size(), 1);
     QCOMPARE(context->usesCount(), 3);
 
     QCOMPARE(context->uses()[0].m_range, RangeInRevision({2, 0}, {2, 1}));
     QCOMPARE(context->uses()[1].m_range, RangeInRevision({2, 5}, {2, 6}));
     QCOMPARE(context->uses()[2].m_range, RangeInRevision({2, 8}, {2, 11}));
 }
 
 // see also: https://bugs.kde.org/show_bug.cgi?id=368067
 void TestDUChain::testForwardTemplateTypeParameterContext()
 {
     TestFile file(R"(
         template<typename MatchingName> class Foo;
 
         class MatchingName { void bar(); };
         void MatchingName::bar() {  }
     )", "cpp");
 
     file.parse();
     QVERIFY(file.waitForParsed(500));
     DUChainReadLocker lock;
     const auto top = file.topContext();
     QVERIFY(top);
     DUChainDumper dumper(DUChainDumper::Features(DUChainDumper::DumpContext | DUChainDumper::DumpProblems));
     dumper.dump(top);
 
     auto declarations = top->localDeclarations();
     QCOMPARE(declarations.size(), 2);
 }
 
 // see also: https://bugs.kde.org/show_bug.cgi?id=368460
 void TestDUChain::testTemplateFunctionParameterName()
 {
     TestFile file(R"(
         template<class T>
         void foo(int name);
 
         void bar(int name);
     )", "cpp");
 
     file.parse();
     QVERIFY(file.waitForParsed(500));
     DUChainReadLocker lock;
     const auto top = file.topContext();
     QVERIFY(top);
     DUChainDumper dumper(DUChainDumper::Features(DUChainDumper::DumpContext | DUChainDumper::DumpProblems));
     dumper.dump(top);
 
     auto declarations = top->localDeclarations();
     QCOMPARE(declarations.size(), 2);
 
     for (auto decl : declarations) {
         auto ctx = DUChainUtils::getArgumentContext(decl);
         QVERIFY(ctx);
         auto args = ctx->localDeclarations();
         if (decl == declarations.first())
             QEXPECT_FAIL("", "We get two declarations, for both template and args :(", Continue);
         QCOMPARE(args.size(), 1);
         if (decl == declarations.first())
             QEXPECT_FAIL("", "see above, this then triggers T T here", Continue);
         QCOMPARE(args.first()->toString(), QStringLiteral("int name"));
     }
 }
 
 static bool containsErrors(const QList<Problem::Ptr>& problems)
 {
     auto it = std::find_if(problems.begin(), problems.end(), [] (const Problem::Ptr& problem) {
         return problem->severity() == Problem::Error;
     });
     return it != problems.end();
 }
 
 static bool expectedXmmintrinErrors(const QList<Problem::Ptr>& problems)
 {
     foreach (const auto& problem, problems) {
         if (problem->severity() == Problem::Error && !problem->description().contains("Cannot initialize a parameter of type")) {
             return false;
         }
     }
     return true;
 }
 
 static void verifyNoErrors(TopDUContext* top, QSet<TopDUContext*>& checked)
 {
     const auto problems = top->problems();
     if (containsErrors(problems)) {
         qDebug() << top->url() << top->problems();
         if (top->url().str().endsWith("xmmintrin.h") && expectedXmmintrinErrors(problems)) {
             QEXPECT_FAIL("", "there are still some errors in xmmintrin.h b/c some clang provided intrinsincs are more strict than the GCC ones.", Continue);
             QVERIFY(false);
         } else {
             QFAIL("parse error detected");
         }
     }
     const auto imports = top->importedParentContexts();
     foreach (const auto& import, imports) {
         auto ctx = import.context(top);
         QVERIFY(ctx);
         auto importedTop = ctx->topContext();
         if (checked.contains(importedTop)) {
             continue;
         }
         checked.insert(importedTop);
         verifyNoErrors(importedTop, checked);
     }
 }
 
 void TestDUChain::testFriendDeclaration()
 {
     TestFile file(R"(
         struct FriendFoo
         {
             friend class FriendBar;
         };
 
         class FriendBar{};
 
         FriendBar friendBar;
     )", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     QVERIFY(file.waitForParsed(1000));
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->localDeclarations().size(), 3);
 
         auto friendBar = file.topContext()->localDeclarations()[1];
         if (CINDEX_VERSION_MINOR < 37) {
             QEXPECT_FAIL("", "Your clang version is too old", Abort);
         }
         QCOMPARE(friendBar->uses().size(), 1);
         QCOMPARE(friendBar->uses().begin()->first(), RangeInRevision(3,25,3,34));
         QCOMPARE(friendBar->uses().begin()->last(), RangeInRevision(8,8,8,17));
     }
 }
 
 void TestDUChain::testVariadicTemplateArguments()
 {
     TestFile file(R"(
         template<typename T, typename... Targs>
         class VariadicTemplate {};
 
         VariadicTemplate<int, double, bool> variadic;
     )", "cpp");
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     QVERIFY(file.waitForParsed(1000));
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->localDeclarations().size(), 2);
 
         auto decl = file.topContext()->localDeclarations()[1];
         QVERIFY(decl);
         if (CINDEX_VERSION_MINOR < 37) {
             QEXPECT_FAIL("", "Your clang version is too old", Abort);
         }
         QCOMPARE(decl->toString(), QStringLiteral("VariadicTemplate< int, double, bool > variadic"));
 
         QVERIFY(decl->abstractType());
         QCOMPARE(decl->abstractType()->toString(), QStringLiteral("VariadicTemplate< int, double, bool >"));
     }
 }
 
 void TestDUChain::testGccCompatibility()
 {
     // TODO: make it easier to change the compiler provider for testing purposes
     QTemporaryDir dir;
     auto project = new TestProject(Path(dir.path()), this);
     auto definesAndIncludesConfig = project->projectConfiguration()->group("CustomDefinesAndIncludes");
     auto pathConfig = definesAndIncludesConfig.group("ProjectPath0");
     pathConfig.writeEntry("Path", ".");
     pathConfig.group("Compiler").writeEntry("Name", "GCC");
     m_projectController->addProject(project);
 
     {
         // TODO: Also test in C mode. Currently it doesn't work (some intrinsics missing?)
         TestFile file(R"(
             #include <x86intrin.h>
 
             int main() { return 0; }
         )", "cpp", project, dir.path());
 
         file.parse();
         QVERIFY(file.waitForParsed(5000));
 
         DUChainReadLocker lock;
         QSet<TopDUContext*> checked;
         verifyNoErrors(file.topContext(), checked);
     }
 
     m_projectController->closeAllProjects();
 }
 
 void TestDUChain::testQtIntegration()
 {
     QTemporaryDir includeDir;
     {
         QDir dir(includeDir.path());
         dir.mkdir("QtCore");
         // create the file but don't put anything in it
         QFile header(includeDir.path() + "/QtCore/qobjectdefs.h");
         QVERIFY(header.open(QIODevice::WriteOnly | QIODevice::Text));
     }
     QTemporaryDir dir;
     auto project = new TestProject(Path(dir.path()), this);
     m_provider->defines.clear();
     m_provider->includes = {Path(includeDir.path() + "/QtCore")};
 
     m_projectController->addProject(project);
 
     {
         TestFile file(R"(
             #define slots
             #define signals
             #define Q_SLOTS
             #define Q_SIGNALS
             #include <QtCore/qobjectdefs.h>
 
             struct MyObject {
             public:
               void other1();
             public slots:
               void slot1();
             signals:
               void signal1();
             private Q_SLOTS:
               void slot2();
             Q_SIGNALS:
               void signal2();
             public:
               void other2();
             };
         )", "cpp", project, dir.path());
 
         file.parse();
         QVERIFY(file.waitForParsed(5000));
 
         DUChainReadLocker lock;
         auto top = file.topContext();
         QVERIFY(top);
         QVERIFY(top->problems().isEmpty());
         const auto methods = top->childContexts().last()->localDeclarations();
         QCOMPARE(methods.size(), 6);
         foreach(auto method, methods) {
             auto classFunction = dynamic_cast<ClassFunctionDeclaration*>(method);
             QVERIFY(classFunction);
             auto id = classFunction->identifier().toString();
             QCOMPARE(classFunction->isSignal(), id.startsWith(QLatin1String("signal")));
             QCOMPARE(classFunction->isSlot(), id.startsWith(QLatin1String("slot")));
         }
     }
 
     m_projectController->closeAllProjects();
 }
diff --git a/languages/clang/tests/test_duchainutils.cpp b/languages/clang/tests/test_duchainutils.cpp
index 7393587763..634fe96fbe 100644
--- a/languages/clang/tests/test_duchainutils.cpp
+++ b/languages/clang/tests/test_duchainutils.cpp
@@ -1,80 +1,81 @@
 /*
  * Copyright 2014  Kevin Funk <kfunk@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) 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 "test_duchainutils.h"
 
 #include <language/duchain/duchainlock.h>
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/testfile.h>
 #include <tests/testhelpers.h>
 
 #include "../duchain/duchainutils.h"
 
-#include <QtTest>
+#include <QLoggingCategory>
+#include <QTest>
 
 using namespace KDevelop;
 
 QTEST_GUILESS_MAIN(TestDUChainUtils);
 
 void TestDUChainUtils::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.plugins.clang.debug=true\n"));
     QVERIFY(qputenv("KDEV_DISABLE_PLUGINS", "kdevcppsupport"));
     AutoTestShell::init();
     TestCore::initialize(Core::NoUi);
 }
 
 void TestDUChainUtils::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestDUChainUtils::getFunctionSignatureRange()
 {
     QFETCH(QString, code);
     QFETCH(KTextEditor::Range, expectedRange);
     {
         TestFile file(code, "cpp");
         file.parse();
         QVERIFY(file.waitForParsed());
 
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
 
         const auto functionDecl = file.topContext()->localDeclarations()[0];
         const auto range = ClangIntegration::DUChainUtils::functionSignatureRange(functionDecl);
         QCOMPARE(range, expectedRange);
     }
 }
 
 void TestDUChainUtils::getFunctionSignatureRange_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<KTextEditor::Range>("expectedRange");
 
     QTest::newRow("function-declaration")
         << "void func(\nint a, int b\n);\n"
         << KTextEditor::Range(0, 0, 2, 1);
     QTest::newRow("function-definition")
         << "void func(\nint a, int b\n) {}\n"
         << KTextEditor::Range(0, 0, 2, 2);
 
 }
diff --git a/languages/clang/tests/test_files.cpp b/languages/clang/tests/test_files.cpp
index 42a5810c9d..9f785d3c70 100644
--- a/languages/clang/tests/test_files.cpp
+++ b/languages/clang/tests/test_files.cpp
@@ -1,94 +1,95 @@
 /*************************************************************************************
  *  Copyright (C) 2013 by Milian Wolff <mail@milianw.de>                             *
  *  Copyright (C) 2013 Olivier de Gaalon <olivier.jg@gmail.com>                      *
  *                                                                                   *
  *  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 "test_files.h"
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/problem.h>
 #include <language/codegen/coderepresentation.h>
 #include <language/backgroundparser/backgroundparser.h>
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/json/declarationvalidator.h>
 
 #include "testfilepaths.h"
 
 //Include all used json tests, otherwise "Test not found"
 #include <tests/json/jsondeclarationtests.h>
 #include <tests/json/jsonducontexttests.h>
 #include <tests/json/jsontypetests.h>
 #include <interfaces/ilanguagecontroller.h>
 
-#include <QtTest>
+#include <QTest>
+#include <QLoggingCategory>
 
 using namespace KDevelop;
 
 QTEST_MAIN(TestFiles)
 
 void TestFiles::initTestCase()
 {
     qputenv("KDEV_CLANG_JSON_TEST_RUN", "1");
     qputenv("KDEV_CLANG_EXTRA_ARGUMENTS", "-Wno-unused-variable -Wno-unused-parameter -Wno-unused-comparison -Wno-unused-value -Wno-unused-private-field -Wno-ignored-attributes");
 
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.plugins.clang.debug=true\n"));
     QVERIFY(qputenv("KDEV_DISABLE_PLUGINS", "kdevcppsupport"));
     QVERIFY(qputenv("KDEV_CLANG_DISPLAY_DIAGS", "1"));
     AutoTestShell::init({"kdevclangsupport"});
     TestCore::initialize(Core::NoUi);
     DUChain::self()->disablePersistentStorage();
     Core::self()->languageController()->backgroundParser()->setDelay(0);
     CodeRepresentation::setDiskChangesForbidden(true);
 }
 
 void TestFiles::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestFiles::testFiles_data()
 {
     QTest::addColumn<QString>("fileName");
     const QString testDirPath = TEST_FILES_DIR;
     const QStringList files = QDir(testDirPath).entryList({"*.h", "*.cpp", "*.c", "*.cl"}, QDir::Files);
     foreach (const QString& file, files) {
         QTest::newRow(file.toUtf8().constData()) << QString(testDirPath + '/' + file);
     }
 }
 
 void TestFiles::testFiles()
 {
     QFETCH(QString, fileName);
     const IndexedString indexedFileName(fileName);
     ReferencedTopDUContext top =
         DUChain::self()->waitForUpdate(indexedFileName, TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(top);
     DUChainReadLocker lock;
     DeclarationValidator validator;
     top->visit(validator);
     QVERIFY(validator.testsPassed());
 
     foreach(auto problem, top->problems()) {
         qDebug() << problem;
     }
 
     if (!QTest::currentDataTag() || strcmp("invalid.cpp", QTest::currentDataTag()) != 0) {
         QVERIFY(top->problems().isEmpty());
     }
 }
diff --git a/languages/clang/tests/test_refactoring.cpp b/languages/clang/tests/test_refactoring.cpp
index af51213266..6f9f4f65a3 100644
--- a/languages/clang/tests/test_refactoring.cpp
+++ b/languages/clang/tests/test_refactoring.cpp
@@ -1,143 +1,144 @@
 /*
  * Copyright 2017 Kevin Funk <kfunk@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) 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 "test_refactoring.h"
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/testfile.h>
 #include <tests/testproject.h>
 #include <interfaces/ilanguagecontroller.h>
 
 #include "codegen/clangrefactoring.h"
 
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/declaration.h>
 #include <language/interfaces/ilanguagesupport.h>
 
 #include <QTemporaryDir>
-#include <QtTest>
+#include <QLoggingCategory>
+#include <QTest>
 
 QTEST_MAIN(TestRefactoring);
 
 using namespace KDevelop;
 
 TestRefactoring::~TestRefactoring() = default;
 
 void TestRefactoring::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.plugins.clang.debug=true\n"));
 
     QVERIFY(qputenv("KDEV_CLANG_DISPLAY_DIAGS", "1"));
 
     AutoTestShell::init({QStringLiteral("kdevclangsupport")});
 
     auto core = TestCore::initialize();
     delete core->projectController();
     m_projectController = new TestProjectController(core);
     core->setProjectController(m_projectController);
 }
 
 void TestRefactoring::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestRefactoring::cleanup()
 {
 }
 
 void TestRefactoring::init()
 {
 }
 
 void TestRefactoring::testClassRename()
 {
     const QString codeBefore(R"(
 class Foo {
 public:
     Foo();
     ~Foo();
 };
 Foo::Foo() {
 }
 Foo::~Foo() {
 }
     )");
 
     const QString codeAfter(R"(
 class FooNew {
 public:
     FooNew();
     ~FooNew();
 };
 FooNew::FooNew() {
 }
 FooNew::~FooNew() {
 }
     )");
 
     QTemporaryDir dir;
     auto project = new TestProject(Path(dir.path()), this);
     m_projectController->addProject(project);
 
     TestFile file(codeBefore, "cpp", project, dir.path());
     QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsAndUses));
 
     DUChainReadLocker lock;
 
     auto top = file.topContext();
     QVERIFY(top);
 
     auto declaration = top->localDeclarations().first();
     QVERIFY(declaration);
 
     const QString originalName = declaration->identifier().identifier().str();
     const QString newName = QStringLiteral("FooNew");
 
     QSharedPointer<BasicRefactoringCollector> collector(new BasicRefactoringCollector(declaration));
 
     // TODO: Do this without GUI?
     UsesWidget uses(declaration, collector);
     lock.unlock();
 
     for (int i = 0; i < 30000; i += 1000) {
         if (collector->isReady()) {
             break;
         }
         QTest::qWait(1000);
     }
     QVERIFY(collector->isReady());
 
     BasicRefactoring::NameAndCollector nameAndCollector{newName, collector};
 
     auto languages = ICore::self()->languageController()->languagesForUrl(file.url().toUrl());
     QVERIFY(!languages.isEmpty());
     auto clangLanguageSupport = languages.first();
     QVERIFY(clangLanguageSupport);
     auto clangRefactoring = qobject_cast<ClangRefactoring*>(clangLanguageSupport->refactoring());
     QVERIFY(clangRefactoring);
 
     clangRefactoring->renameCollectedDeclarations(nameAndCollector.collector.data(), newName, originalName);
     QCOMPARE(file.fileContents(), codeAfter);
 
     m_projectController->closeAllProjects();
 }
 
diff --git a/languages/clang/util/clangtypes.cpp b/languages/clang/util/clangtypes.cpp
index a91320ea9a..1b0fb2bb6d 100644
--- a/languages/clang/util/clangtypes.cpp
+++ b/languages/clang/util/clangtypes.cpp
@@ -1,233 +1,232 @@
 /*
     This file is part of KDevelop
 
     Copyright 2013 Olivier de Gaalon <olivier.jg@gmail.com>
     Copyright 2013 Milian Wolff <mail@milianw.de>
 
     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 "clangtypes.h"
 
-#include <QFileInfo>
 #include <QReadLocker>
 
 #include <language/editor/documentcursor.h>
 #include <language/editor/documentrange.h>
 #include <util/path.h>
 
 using namespace KDevelop;
 
 namespace {
 
 template<typename T>
 inline T cursorForCXSrcLoc(CXSourceLocation loc)
 {
     uint line = 0;
     uint column = 0;
     clang_getFileLocation(loc, nullptr, &line, &column, nullptr);
     return {static_cast<int>(line-1), static_cast<int>(column-1)};
 }
 
 }
 
 ClangString::ClangString(CXString string)
     : string(string)
 {
 }
 
 ClangString::~ClangString()
 {
     clang_disposeString(string);
 }
 
 const char* ClangString::c_str() const
 {
     return clang_getCString(string);
 }
 
 bool ClangString::isEmpty() const
 {
     auto str = c_str();
     return !str || !str[0];
 }
 
 QString ClangString::toString() const
 {
     return QString::fromUtf8(c_str());
 }
 
 QByteArray ClangString::toByteArray() const
 {
     return QByteArray(c_str());
 }
 
 IndexedString ClangString::toIndexed() const
 {
     return IndexedString(c_str());
 }
 
 QTextStream& operator<<(QTextStream& stream, const ClangString& str)
 {
     return stream << str.toString();
 }
 
 QDebug operator<<(QDebug stream, const ClangString& str)
 {
     return stream << str.toString();
 }
 
 ClangLocation::ClangLocation(CXSourceLocation location)
     : location(location)
 {
 
 }
 
 ClangLocation::operator DocumentCursor() const
 {
     uint line = 0;
     uint column = 0;
     CXFile file;
     clang_getFileLocation(location, &file, &line, &column, nullptr);
     ClangString fileName(clang_getFileName(file));
     return {IndexedString(fileName.c_str()), {static_cast<int>(line-1), static_cast<int>(column-1)}};
 }
 
 ClangLocation::operator KTextEditor::Cursor() const
 {
     return cursorForCXSrcLoc<KTextEditor::Cursor>(location);
 }
 
 ClangLocation::operator CursorInRevision() const
 {
     return cursorForCXSrcLoc<CursorInRevision>(location);
 }
 
 ClangLocation::operator CXSourceLocation() const
 {
     return location;
 }
 
 ClangLocation::~ClangLocation()
 {
 }
 
 QDebug operator<<(QDebug stream, const ClangLocation& location)
 {
     return stream << static_cast<DocumentCursor>(location);
 }
 
 ClangRange::ClangRange(CXSourceRange range)
     : m_range(range)
 {
 
 }
 
 ClangLocation ClangRange::start() const
 {
     return ClangLocation(clang_getRangeStart(m_range));
 }
 
 ClangLocation ClangRange::end() const
 {
     return ClangLocation(clang_getRangeEnd(m_range));
 }
 
 CXSourceRange ClangRange::range() const
 {
     return m_range;
 }
 
 DocumentRange ClangRange::toDocumentRange() const
 {
     auto start = clang_getRangeStart(m_range);
     CXFile file;
     clang_getFileLocation(start, &file, nullptr, nullptr, nullptr);
     ClangString fileName(clang_getFileName(file));
     return {IndexedString(QUrl::fromLocalFile(fileName.toString()).adjusted(QUrl::NormalizePathSegments)), toRange()};
 }
 
 KTextEditor::Range ClangRange::toRange() const
 {
     return {start(), end()};
 }
 
 RangeInRevision ClangRange::toRangeInRevision() const
 {
     return {start(), end()};
 }
 
 ClangRange::~ClangRange()
 {
 }
 
 QDebug operator<<(QDebug stream, const ClangRange& range)
 {
     return stream << range.toDocumentRange();
 }
 
 ClangTokens::ClangTokens(CXTranslationUnit unit, CXSourceRange range)
     : m_unit(unit)
 {
     clang_tokenize(m_unit, range, &m_tokens, &m_numTokens);
 }
 ClangTokens::~ClangTokens()
 {
     clang_disposeTokens(m_unit, m_tokens, m_numTokens);
 }
 CXToken* ClangTokens::begin() const
 {
     return m_tokens;
 }
 CXToken* ClangTokens::end() const
 {
     return m_tokens + m_numTokens;
 }
 std::reverse_iterator<CXToken*> ClangTokens::rbegin() const
 {
     return std::reverse_iterator<CXToken*>(end());
 }
 std::reverse_iterator<CXToken*> ClangTokens::rend() const
 {
     return std::reverse_iterator<CXToken*>(begin());
 }
 uint ClangTokens::size() const
 {
     return m_numTokens;
 }
 CXToken ClangTokens::at(uint index) const {
     Q_ASSERT(index < m_numTokens);
     return m_tokens[index];
 }
 
 CXTranslationUnit ClangTokens::unit() const
 {
     return m_unit;
 }
 
 QDebug operator<<(QDebug stream, const ClangTokens& tokens)
 {
     stream << "ClangTokens {";
     for (uint i = 0; i < tokens.size(); ++i) {
         stream << i << tokens.at(i) << ClangString(clang_getTokenSpelling(tokens.unit(), tokens.at(i))) << ",";
     }
     return stream << "}";
 }
 
 QDebug operator<<(QDebug stream, const CXToken& token)
 {
     return stream << clang_getTokenKind(token);
 }
diff --git a/languages/plugins/custom-definesandincludes/compilerprovider/compilerprovider.cpp b/languages/plugins/custom-definesandincludes/compilerprovider/compilerprovider.cpp
index a723e05dec..8bf5b70004 100644
--- a/languages/plugins/custom-definesandincludes/compilerprovider/compilerprovider.cpp
+++ b/languages/plugins/custom-definesandincludes/compilerprovider/compilerprovider.cpp
@@ -1,239 +1,237 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 "compilerprovider.h"
 
 #include "../debugarea.h"
 
 #include "compilerfactories.h"
 #include "settingsmanager.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <project/projectmodel.h>
 
-#include <KPluginFactory>
-#include <KAboutData>
 #include <KLocalizedString>
 #include <QStandardPaths>
 
 using namespace KDevelop;
 
 namespace
 {
 class NoCompiler : public ICompiler
 {
 public:
     NoCompiler():
         ICompiler(i18n("None"), QString(), QString(), false)
     {}
 
     QHash< QString, QString > defines(const QString&) const override
     {
         return {};
     }
 
     Path::List includes(const QString&) const override
     {
         return {};
     }
 };
 
 static CompilerPointer createDummyCompiler()
 {
     static CompilerPointer compiler(new NoCompiler());
     return compiler;
 }
 
 ConfigEntry configForItem(KDevelop::ProjectBaseItem* item)
 {
     if(!item){
         return ConfigEntry();
     }
 
     const Path itemPath = item->path();
     const Path rootDirectory = item->project()->path();
 
     auto paths = SettingsManager::globalInstance()->readPaths(item->project()->projectConfiguration().data());
     ConfigEntry config;
     Path closestPath;
 
     // find config entry closest to the requested item
     for (const auto& entry : paths) {
         auto configEntry = entry;
         Path targetDirectory = rootDirectory;
 
         targetDirectory.addPath(entry.path);
 
         if (targetDirectory == itemPath) {
             return configEntry;
         }
 
         if (targetDirectory.isParentOf(itemPath)) {
             if (config.path.isEmpty() || targetDirectory.segments().size() > closestPath.segments().size()) {
                 config = configEntry;
                 closestPath = targetDirectory;
             }
         }
     }
 
     return config;
 }
 }
 
 CompilerProvider::CompilerProvider( SettingsManager* settings, QObject* parent )
     : QObject( parent )
     , m_settings(settings)
 {
     m_factories.append(CompilerFactoryPointer(new GccFactory()));
     m_factories.append(CompilerFactoryPointer(new ClangFactory()));
 #ifdef _WIN32
     m_factories.append(CompilerFactoryPointer(new MsvcFactory()));
 #endif
 
     if (!QStandardPaths::findExecutable( "clang" ).isEmpty()) {
         m_factories[1]->registerDefaultCompilers(this);
     }
     if (!QStandardPaths::findExecutable( "gcc" ).isEmpty()) {
         m_factories[0]->registerDefaultCompilers(this);
     }
 #ifdef _WIN32
     if (!QStandardPaths::findExecutable("cl.exe").isEmpty()) {
         m_factories[2]->registerDefaultCompilers(this);
     }
 #endif
 
     registerCompiler(createDummyCompiler());
     retrieveUserDefinedCompilers();
 }
 
 CompilerProvider::~CompilerProvider() = default;
 
 QHash<QString, QString> CompilerProvider::defines( ProjectBaseItem* item ) const
 {
     auto config = configForItem(item);
     auto languageType = Utils::Cpp;
     if (item) {
         languageType = Utils::languageType(item->path(), config.parserArguments.parseAmbiguousAsCPP);
     }
 
     return config.compiler->defines(languageType == Utils::C ? config.parserArguments.cArguments : config.parserArguments.cppArguments);
 }
 
 Path::List CompilerProvider::includes( ProjectBaseItem* item ) const
 {
     auto config = configForItem(item);
     auto languageType = Utils::Cpp;
     if (item) {
         languageType = Utils::languageType(item->path(), config.parserArguments.parseAmbiguousAsCPP);
     }
 
     return config.compiler->includes(languageType == Utils::C ? config.parserArguments.cArguments : config.parserArguments.cppArguments);
 }
 
 Path::List CompilerProvider::frameworkDirectories( ProjectBaseItem* /* item */ ) const
 {
     return {};
 }
 
 IDefinesAndIncludesManager::Type CompilerProvider::type() const
 {
     return IDefinesAndIncludesManager::CompilerSpecific;
 }
 
 CompilerPointer CompilerProvider::checkCompilerExists( const CompilerPointer& compiler ) const
 {
     //This may happen for opened for the first time projects
     if ( !compiler ) {
         for ( auto& compiler : m_compilers ) {
             if ( QStandardPaths::findExecutable( compiler->path() ).isEmpty() ) {
                 continue;
             }
 
             return compiler;
         }
     } else {
         for ( auto it = m_compilers.constBegin(); it != m_compilers.constEnd(); it++ ) {
             if ( (*it)->name() == compiler->name() ) {
                 return *it;
             }
         }
     }
 
     return createDummyCompiler();
 }
 
 QVector< CompilerPointer > CompilerProvider::compilers() const
 {
     return m_compilers;
 }
 
 CompilerPointer CompilerProvider::compilerForItem( KDevelop::ProjectBaseItem* item ) const
 {
     auto compiler = configForItem(item).compiler;
     Q_ASSERT(compiler);
     return compiler;
 }
 
 bool CompilerProvider::registerCompiler(const CompilerPointer& compiler)
 {
     if (!compiler) {
         return false;
     }
 
     for(auto c: m_compilers){
         if (c->name() == compiler->name()) {
             return false;
         }
     }
     m_compilers.append(compiler);
     return true;
 }
 
 void CompilerProvider::unregisterCompiler(const CompilerPointer& compiler)
 {
     if (!compiler->editable()) {
         return;
     }
 
     for (int i = 0; i < m_compilers.count(); i++) {
         if (m_compilers[i]->name() == compiler->name()) {
             m_compilers.remove(i);
             break;
         }
     }
 }
 
 QVector< CompilerFactoryPointer > CompilerProvider::compilerFactories() const
 {
     return m_factories;
 }
 
 void CompilerProvider::retrieveUserDefinedCompilers()
 {
     auto compilers = m_settings->userDefinedCompilers();
     for (auto c : compilers) {
         registerCompiler(c);
     }
 }
diff --git a/languages/plugins/custom-definesandincludes/compilerprovider/gcclikecompiler.cpp b/languages/plugins/custom-definesandincludes/compilerprovider/gcclikecompiler.cpp
index bf8784c15c..8a7e677731 100644
--- a/languages/plugins/custom-definesandincludes/compilerprovider/gcclikecompiler.cpp
+++ b/languages/plugins/custom-definesandincludes/compilerprovider/gcclikecompiler.cpp
@@ -1,193 +1,193 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 "gcclikecompiler.h"
 
-#include <QDir>
+#include <QFileInfo>
 #include <QProcess>
 #include <QRegularExpression>
 #include <QMap>
 
 #include "../debugarea.h"
 
 using namespace KDevelop;
 
 namespace
 {
 // compilers don't deduplicate QStringLiteral
 QString minusXC() { return QStringLiteral("-xc"); }
 QString minusXCPlusPlus() { return QStringLiteral("-xc++"); }
 
 QStringList languageOptions(const QString& arguments)
 {
 
     // TODO: handle -ansi flag: In C mode, this is equivalent to -std=c90. In C++ mode, it is equivalent to -std=c++98.
     // TODO: check for -x flag on command line
     const QRegularExpression regexp("-std=(\\S+)");
     // see gcc manpage or llvm/tools/clang/include/clang/Frontend/LangStandards.def for list of valid language options
     auto result = regexp.match(arguments);
     if(result.hasMatch()){
         auto standard = result.captured(0);
         QString mode = result.captured(1);
         QString language;
         if (mode.startsWith(QLatin1String("c++")) || mode.startsWith(QLatin1String("gnu++"))) {
             language = minusXCPlusPlus();
         } else if (mode.startsWith(QLatin1String("iso9899:"))) {
             // all iso9899:xxxxx modes are C standards
             language = minusXC();
         } else {
             // check for c11, gnu99, etc: all of them have a digit after the c/gnu
             const QRegularExpression cRegexp("(c|gnu)\\d.*");
             if (cRegexp.match(mode).hasMatch()) {
                 language = minusXC();
             }
         }
         if (language.isEmpty()) {
             qCWarning(DEFINESANDINCLUDES) << "Failed to determine language from -std= flag:" << arguments;
             language = minusXCPlusPlus();
         }
         return {standard, language};
 
     }
     // no -std= flag passed -> assume c++11
     return {QStringLiteral("-std=c++11"), minusXCPlusPlus()};
 }
 
 }
 
 Defines GccLikeCompiler::defines(const QString& arguments) const
 {
     if (!m_definesIncludes.value(arguments).definedMacros.isEmpty() ) {
         return m_definesIncludes.value(arguments).definedMacros;
     }
 
     // #define a 1
     // #define a
     QRegExp defineExpression( "#define\\s+(\\S+)(?:\\s+(.*)\\s*)?");
 
     QProcess proc;
     proc.setProcessChannelMode( QProcess::MergedChannels );
 
     // TODO: what about -mXXX or -target= flags, some of these change search paths/defines
     auto compilerArguments = languageOptions(arguments);
     compilerArguments.append("-dM");
     compilerArguments.append("-E");
     compilerArguments.append(QProcess::nullDevice());
 
     proc.start(path(), compilerArguments);
 
     if ( !proc.waitForStarted( 1000 ) || !proc.waitForFinished( 1000 ) ) {
         definesAndIncludesDebug() <<  "Unable to read standard macro definitions from "<< path();
         return {};
     }
 
     while ( proc.canReadLine() ) {
         auto line = proc.readLine();
 
         if ( defineExpression.indexIn( line ) != -1 ) {
             m_definesIncludes[arguments].definedMacros[defineExpression.cap( 1 )] = defineExpression.cap( 2 ).trimmed();
         }
     }
 
     return m_definesIncludes[arguments].definedMacros;
 }
 
 Path::List GccLikeCompiler::includes(const QString& arguments) const
 {
     if ( !m_definesIncludes.value(arguments).includePaths.isEmpty() ) {
         return m_definesIncludes.value(arguments).includePaths;
     }
 
     QProcess proc;
     proc.setProcessChannelMode( QProcess::MergedChannels );
 
     // The following command will spit out a bunch of information we don't care
     // about before spitting out the include paths.  The parts we care about
     // look like this:
     // #include "..." search starts here:
     // #include <...> search starts here:
     //  /usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2
     //  /usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/i486-linux-gnu
     //  /usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/backward
     //  /usr/local/include
     //  /usr/lib/gcc/i486-linux-gnu/4.1.2/include
     //  /usr/include
     // End of search list.
 
     auto compilerArguments = languageOptions(arguments);
     compilerArguments.append("-E");
     compilerArguments.append("-v");
     compilerArguments.append(QProcess::nullDevice());
 
     proc.start(path(), compilerArguments);
 
     if ( !proc.waitForStarted( 1000 ) || !proc.waitForFinished( 1000 ) ) {
         definesAndIncludesDebug() <<  "Unable to read standard include paths from " << path();
         return {};
     }
 
     // We'll use the following constants to know what we're currently parsing.
     enum Status {
         Initial,
         FirstSearch,
         Includes,
         Finished
     };
     Status mode = Initial;
 
     foreach( const QString &line, QString::fromLocal8Bit( proc.readAllStandardOutput() ).split( '\n' ) ) {
         switch ( mode ) {
             case Initial:
                 if ( line.indexOf( "#include \"...\"" ) != -1 ) {
                     mode = FirstSearch;
                 }
                 break;
             case FirstSearch:
                 if ( line.indexOf( "#include <...>" ) != -1 ) {
                     mode = Includes;
                     break;
                 }
             case Includes:
                 //Detect the include-paths by the first space that is prepended. Reason: The list may contain relative paths like "."
                 if ( !line.startsWith( ' ' ) ) {
                     // We've reached the end of the list.
                     mode = Finished;
                 } else {
                     // This is an include path, add it to the list.
                     m_definesIncludes[arguments].includePaths << Path(QFileInfo(line.trimmed()).canonicalFilePath());
                 }
                 break;
             default:
                 break;
         }
         if ( mode == Finished ) {
             break;
         }
     }
 
     return m_definesIncludes[arguments].includePaths;
 }
 
 GccLikeCompiler::GccLikeCompiler(const QString& name, const QString& path, bool editable, const QString& factoryName):
     ICompiler(name, path, factoryName, editable)
 {}
diff --git a/languages/plugins/custom-definesandincludes/compilerprovider/icompiler.h b/languages/plugins/custom-definesandincludes/compilerprovider/icompiler.h
index e635f030ca..accfb3023a 100644
--- a/languages/plugins/custom-definesandincludes/compilerprovider/icompiler.h
+++ b/languages/plugins/custom-definesandincludes/compilerprovider/icompiler.h
@@ -1,86 +1,85 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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/>.
  *
  */
 
 #ifndef ICOMPILER_H
 #define ICOMPILER_H
 
-#include <QHash>
 #include <QString>
 #include <QSharedPointer>
 
 #include "../idefinesandincludesmanager.h"
 
 /// An interface that represents a compiler. Compiler provides standard include directories and standard defined macros.
 class ICompiler
 {
 public:
     /**
      * @param name The user visible name
      * @param path path to the compiler
      * @param factoryName name of the factory that created this compiler
      * @param editable whether user can change the name and the path to the compiler (should be set to false for automatically detected compilers)
     **/
     ICompiler( const QString& name, const QString& path, const QString& factoryName, bool editable );
 
     /**
      * @param arguments compiler command-line arguments
      * @return list of defined macros for the compiler
      */
     virtual KDevelop::Defines defines(const QString& arguments) const = 0;
 
     /**
      * @param arguments compiler command-line arguments
      * @return list of include directories for the compiler
      */
     virtual KDevelop::Path::List includes(const QString& arguments) const = 0;
 
     void setPath( const QString &path );
 
     /// @return path to the compiler
     QString path() const;
 
     void setName( const QString &name );
 
     /// @return user visible name
     QString name() const;
 
     /// Indicates if the compiler name/path can be set manually
     bool editable() const;
 
     /// @return name of the factory that created this compiler
     QString factoryName() const;
 
     virtual ~ICompiler() = default;
 
 private:
     bool m_editable;
     QString m_name;
     QString m_path;
     QString m_factoryName;
 };
 
 typedef QSharedPointer<ICompiler> CompilerPointer;
 
 Q_DECLARE_METATYPE(CompilerPointer);
 
 #endif // ICOMPILER_H
diff --git a/languages/plugins/custom-definesandincludes/compilerprovider/tests/test_compilerprovider.cpp b/languages/plugins/custom-definesandincludes/compilerprovider/tests/test_compilerprovider.cpp
index af147f5459..98ab5ff429 100644
--- a/languages/plugins/custom-definesandincludes/compilerprovider/tests/test_compilerprovider.cpp
+++ b/languages/plugins/custom-definesandincludes/compilerprovider/tests/test_compilerprovider.cpp
@@ -1,253 +1,254 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 "test_compilerprovider.h"
 
-#include <QtTest/QtTest>
+#include <QTest>
+#include <QTemporaryFile>
 
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <project/projectmodel.h>
 
 #include <serialization/indexedstring.h>
 
 #include <algorithm>
 
 #include "../compilerprovider.h"
 #include "../settingsmanager.h"
 #include "../tests/projectsgenerator.h"
 
 using namespace KDevelop;
 
 namespace
 {
 void testCompilerEntry(SettingsManager* settings, KConfig* config){
     auto entries = settings->readPaths(config);
     auto entry = entries.first();
     auto compilers = settings->provider()->compilers();
     Q_ASSERT(!compilers.isEmpty());
     bool gccCompilerInstalled = std::any_of(compilers.begin(), compilers.end(), [](const CompilerPointer& compiler){return compiler->name().contains("gcc", Qt::CaseInsensitive);});
     if (gccCompilerInstalled) {
         QCOMPARE(entry.compiler->name(), QStringLiteral("GCC"));
     }
 }
 
 void testAddingEntry(SettingsManager* settings, KConfig* config){
     auto entries = settings->readPaths(config);
     auto entry = entries.first();
     auto compilers = settings->provider()->compilers();
     ConfigEntry otherEntry;
     otherEntry.defines["TEST"] = "lalal";
     otherEntry.includes = QStringList() << "/foo";
     otherEntry.path = "test";
     otherEntry.compiler = compilers.first();
     entries << otherEntry;
     settings->writePaths(config, entries);
 
     auto readWriteEntries = settings->readPaths(config);
     QCOMPARE(readWriteEntries.size(), 2);
     QCOMPARE(readWriteEntries.at(0).path, entry.path);
     QCOMPARE(readWriteEntries.at(0).defines, entry.defines);
     QCOMPARE(readWriteEntries.at(0).includes, entry.includes);
     QCOMPARE(readWriteEntries.at(0).compiler->name(), entry.compiler->name());
 
     QCOMPARE(readWriteEntries.at(1).path, otherEntry.path);
     QCOMPARE(readWriteEntries.at(1).defines, otherEntry.defines);
     QCOMPARE(readWriteEntries.at(1).includes, otherEntry.includes);
     QCOMPARE(readWriteEntries.at(1).compiler->name(), otherEntry.compiler->name());
 }
 }
 
 void TestCompilerProvider::initTestCase()
 {
     AutoTestShell::init();
     TestCore::initialize();
 }
 
 void TestCompilerProvider::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestCompilerProvider::testRegisterCompiler()
 {
     auto settings = SettingsManager::globalInstance();
     auto provider = settings->provider();
     auto cf = provider->compilerFactories();
     for (int i = 0 ; i < cf.size(); ++i) {
         auto compiler = cf[i]->createCompiler(QString::number(i), QString::number(i));
         QVERIFY(provider->registerCompiler(compiler));
         QVERIFY(!provider->registerCompiler(compiler));
         QVERIFY(provider->compilers().contains(compiler));
     }
     QVERIFY(!provider->registerCompiler({}));
 }
 
 void TestCompilerProvider::testCompilerIncludesAndDefines()
 {
     auto settings = SettingsManager::globalInstance();
     auto provider = settings->provider();
     for (auto c : provider->compilers()) {
         if (!c->editable() && !c->path().isEmpty()) {
             QVERIFY(!c->defines({}).isEmpty());
             QVERIFY(!c->includes({}).isEmpty());
         }
     }
 
     QVERIFY(!provider->defines(nullptr).isEmpty());
     QVERIFY(!provider->includes(nullptr).isEmpty());
 
     auto compiler = provider->compilerForItem(nullptr);
     QVERIFY(compiler);
     QVERIFY(!compiler->defines(QStringLiteral("--std=c++11")).isEmpty());
     QVERIFY(!compiler->includes(QStringLiteral("--std=c++11")).isEmpty());
 }
 
 void TestCompilerProvider::testStorageBackwardsCompatible()
 {
     auto settings = SettingsManager::globalInstance();
     QTemporaryFile file;
     QVERIFY(file.open());
     QTextStream stream(&file);
     stream << "[Buildset]\n" <<
       "BuildItems=@Variant(\\x00\\x00\\x00\\t\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x0b\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x1a\\x00S\\x00i\\x00m\\x00p\\x00l\\x00e\\x00P\\x00r\\x00o\\x00j\\x00e\\x00c\\x00t)\n" <<
       "[CustomBuildSystem]\n" << "CurrentConfiguration=BuildConfig0\n" <<
       "[CustomDefinesAndIncludes][ProjectPath0]\n" <<
       "Defines=\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x0c\\x00_\\x00D\\x00E\\x00B\\x00U\\x00G\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x10\\x00V\\x00A\\x00R\\x00I\\x00A\\x00B\\x00L\\x00E\\x00\\x00\\x00\\n\\x00\\x00\\x00\\x00\\n\\x00V\\x00A\\x00L\\x00U\\x00E\n" <<
       "Includes=\\x00\\x00\\x00\\x01\\x00\\x00\\x00$\\x00/\\x00u\\x00s\\x00r\\x00/\\x00i\\x00n\\x00c\\x00l\\x00u\\x00d\\x00e\\x00/\\x00m\\x00y\\x00d\\x00i\\x00r\n" <<
       "Path=/\n" <<
       "[CustomDefinesAndIncludes][ProjectPath0][Compiler]\nName=GCC\nPath=gcc\nType=GCC\n";
     file.close();
     KConfig config(file.fileName());
     auto entries = settings->readPaths(&config);
     QCOMPARE(entries.size(), 1);
     auto entry = entries.first();
     Defines defines;
     defines["VARIABLE"] = "VALUE";
     defines["_DEBUG"] = QString();
     QCOMPARE(entry.defines, defines);
     QStringList includes = QStringList() << "/usr/include/mydir";
     QCOMPARE(entry.includes, includes);
     QCOMPARE(entry.path, QString("/"));
     QVERIFY(entry.compiler);
 
     testCompilerEntry(settings, &config);
     testAddingEntry(settings, &config);
 }
 
 void TestCompilerProvider::testStorageNewSystem()
 {
     auto settings = SettingsManager::globalInstance();
     QTemporaryFile file;
     QVERIFY(file.open());
     QTextStream stream(&file);
     stream << "[Buildset]\n" <<
       "BuildItems=@Variant(\\x00\\x00\\x00\\t\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x0b\\x00\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x1a\\x00S\\x00i\\x00m\\x00p\\x00l\\x00e\\x00P\\x00r\\x00o\\x00j\\x00e\\x00c\\x00t)\n\n" <<
       "[CustomBuildSystem]\n" << "CurrentConfiguration=BuildConfig0\n\n" <<
       "[CustomDefinesAndIncludes][ProjectPath0]\n" << "Path=/\n\n" <<
       "[CustomDefinesAndIncludes][ProjectPath0][Defines]\n" <<
       "_DEBUG=\n" <<
       "VARIABLE=VALUE\n" <<
       "[CustomDefinesAndIncludes][ProjectPath0][Includes]\n" <<
       "1=/usr/include/mydir\n" <<
       "2=/usr/local/include/mydir\n" <<
       "[CustomDefinesAndIncludes][ProjectPath0][Compiler]\nName=GCC\nPath=gcc\nType=GCC\n";
     file.close();
     KConfig config(file.fileName());
     auto entries = settings->readPaths(&config);
     QCOMPARE(entries.size(), 1);
     auto entry = entries.first();
     QCOMPARE(entry.path, QString("/"));
     Defines defines;
     defines["VARIABLE"] = "VALUE";
     defines["_DEBUG"] = QString();
     QCOMPARE(entry.defines, defines);
     QMap<QString, QString> includeMap;
     includeMap["1"] = "/usr/include/mydir";
     includeMap["2"] = "/usr/local/include/mydir";
 
     int i = 0;
     for(auto it = includeMap.begin(); it != includeMap.end(); it++)
     {
         QCOMPARE(entry.includes.at(i++), it.value());
     }
 
     testCompilerEntry(settings, &config);
     testAddingEntry(settings, &config);
 }
 
 void TestCompilerProvider::testCompilerIncludesAndDefinesForProject()
 {
     auto project = ProjectsGenerator::GenerateMultiPathProject();
     Q_ASSERT(project);
 
     auto settings = SettingsManager::globalInstance();
     auto provider = settings->provider();
 
     Q_ASSERT(!provider->compilerFactories().isEmpty());
     auto compiler = provider->compilerFactories().first()->createCompiler("name", "path");
 
     QVERIFY(provider->registerCompiler(compiler));
     QVERIFY(provider->compilers().contains(compiler));
 
     auto projectCompiler = provider->compilerForItem(project->projectItem());
 
     QVERIFY(projectCompiler);
     QVERIFY(projectCompiler != compiler);
 
     ProjectBaseItem* mainfile = nullptr;
     for (const auto& file: project->fileSet() ) {
         for (auto i: project->filesForPath(file)) {
             if( i->text() == "main.cpp" ) {
                 mainfile = i;
                 break;
             }
         }
     }
     QVERIFY(mainfile);
     auto mainCompiler = provider->compilerForItem(mainfile);
     QVERIFY(mainCompiler);
     QVERIFY(mainCompiler->name() == projectCompiler->name());
 
     ConfigEntry entry;
     entry.path = "src/main.cpp";
     entry.compiler = compiler;
 
     auto entries = settings->readPaths(project->projectConfiguration().data());
 
     entries.append(entry);
     settings->writePaths(project->projectConfiguration().data(), entries);
 
     QVERIFY(provider->compilers().contains(compiler));
 
     mainCompiler = provider->compilerForItem(mainfile);
     QVERIFY(mainCompiler);
     QVERIFY(mainCompiler->name() == compiler->name());
 
     ICore::self()->projectController()->closeProject(project);
 }
 
 QTEST_MAIN(TestCompilerProvider)
diff --git a/languages/plugins/custom-definesandincludes/compilerprovider/widget/compilersmodel.h b/languages/plugins/custom-definesandincludes/compilerprovider/widget/compilersmodel.h
index 056fc5ab0f..b5c3c5a0d5 100644
--- a/languages/plugins/custom-definesandincludes/compilerprovider/widget/compilersmodel.h
+++ b/languages/plugins/custom-definesandincludes/compilerprovider/widget/compilersmodel.h
@@ -1,69 +1,68 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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/>.
  *
  */
 
 #ifndef COMPILERMODEL_H
 #define COMPILERMODEL_H
 
 #include <QAbstractItemModel>
 #include <QItemSelection>
-#include <QHash>
 
 #include "../compilerprovider/icompiler.h"
 
 class TreeItem;
 
 class CompilersModel : public QAbstractItemModel
 {
     Q_OBJECT
 
 public:
     enum SpecialRole {
         CompilerDataRole = Qt::UserRole + 1
     };
 
     explicit CompilersModel( QObject* parent = nullptr );
 
     void setCompilers( const QVector<CompilerPointer>& compilers );
     QVector<CompilerPointer> compilers() const;
     QModelIndex addCompiler(const CompilerPointer& compiler);
     void updateCompiler(const QItemSelection& compiler);
 
 signals:
     /// emitted whenever new compiler added or existing one modified/deleted.
     void compilerChanged();
 
 public:
     QVariant data( const QModelIndex& index, int role = Qt::DisplayRole ) const override;
     int rowCount( const QModelIndex& parent = QModelIndex() ) const override;
     Qt::ItemFlags flags( const QModelIndex& index ) const override;
     int columnCount( const QModelIndex& parent = QModelIndex() ) const override;
     QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const override;
     QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
     QModelIndex parent(const QModelIndex& child) const override;
     bool removeRows(int row, int count, const QModelIndex& parent = QModelIndex()) override;
 
 private:
     TreeItem* m_rootItem;
 };
 
 #endif // COMPILERMODEL_H
diff --git a/languages/plugins/custom-definesandincludes/compilerprovider/widget/compilerswidget.h b/languages/plugins/custom-definesandincludes/compilerprovider/widget/compilerswidget.h
index 15513ad6d2..2631056918 100644
--- a/languages/plugins/custom-definesandincludes/compilerprovider/widget/compilerswidget.h
+++ b/languages/plugins/custom-definesandincludes/compilerprovider/widget/compilerswidget.h
@@ -1,84 +1,83 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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/>.
  *
  */
 
 #ifndef COMPILERWIDGET_H
 #define COMPILERWIDGET_H
 
-#include <QAbstractItemModel>
 #include <QVector>
 #include <QWidget>
 
 #include <interfaces/configpage.h>
 
 #include "../compilerprovider/icompiler.h"
 
 namespace Ui
 {
 class CompilersWidget;
 }
 
 class CompilersModel;
 class QMenu;
 class QSignalMapper;
 
 class CompilersWidget : public KDevelop::ConfigPage
 {
     Q_OBJECT
 
 public:
     explicit CompilersWidget(QWidget* parent = nullptr);
     ~CompilersWidget() override;
 
     void setCompilers(const QVector<CompilerPointer>& compilers);
     QVector<CompilerPointer> compilers() const;
     void clear();
 
     QString name() const override;
     QString fullName() const override;
     QIcon icon() const override;
 
     KDevelop::ConfigPage::ConfigPageType configPageType() const override;
 
     void apply() override;
     void reset() override;
     void defaults() override;
 
 private slots:
     void deleteCompiler();
     void addCompiler(const QString& factoryName);
     void compilerSelected(const QModelIndex& index);
     void compilerEdited();
 
 signals:
     void compilerChanged();
 
 private:
     void enableItems(bool enable);
 
     QScopedPointer<Ui::CompilersWidget> m_ui;
     CompilersModel* m_compilersModel;
     QMenu *m_addMenu;
     QSignalMapper *m_mapper;
 };
 
 #endif
diff --git a/languages/plugins/custom-definesandincludes/definesandincludesmanager.cpp b/languages/plugins/custom-definesandincludes/definesandincludesmanager.cpp
index 744f23098d..405fdd1d8b 100644
--- a/languages/plugins/custom-definesandincludes/definesandincludesmanager.cpp
+++ b/languages/plugins/custom-definesandincludes/definesandincludesmanager.cpp
@@ -1,392 +1,391 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 "definesandincludesmanager.h"
 
 #include "kcm_widget/definesandincludesconfigpage.h"
 #include "compilerprovider/compilerprovider.h"
 #include "compilerprovider/widget/compilerswidget.h"
 #include "noprojectincludesanddefines/noprojectincludepathsmanager.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <project/projectmodel.h>
 
 #include <KPluginFactory>
-#include <KAboutData>
 
 #include <QThread>
 #include <QCoreApplication>
 
 #include <algorithm>
 
 using namespace KDevelop;
 
 namespace
 {
 ///@return: The ConfigEntry, with includes/defines from @p paths for all parent folders of @p item.
 static ConfigEntry findConfigForItem(QVector<ConfigEntry> paths, const KDevelop::ProjectBaseItem* item)
 {
     ConfigEntry ret;
 
     const Path itemPath = item->path();
     const Path rootDirectory = item->project()->path();
     Path closestPath;
 
     std::sort(paths.begin(), paths.end(), [] (const ConfigEntry& lhs, const ConfigEntry& rhs) {
         // sort in reverse order to do a bottom-up search
         return lhs.path > rhs.path;
     });
 
     for (const ConfigEntry & entry : paths) {
         Path targetDirectory = rootDirectory;
         // note: a dot represents the project root
         if (entry.path != ".") {
             targetDirectory.addPath(entry.path);
         }
 
         if (targetDirectory == itemPath || targetDirectory.isParentOf(itemPath)) {
             ret.includes += entry.includes;
 
             for (auto it = entry.defines.constBegin(); it != entry.defines.constEnd(); it++) {
                 if (!ret.defines.contains(it.key())) {
                     ret.defines[it.key()] = it.value();
                 }
             }
 
             if (targetDirectory.segments().size() > closestPath.segments().size()) {
                 ret.parserArguments = entry.parserArguments;
                 closestPath = targetDirectory;
             }
         }
     }
     ret.includes.removeDuplicates();
 
     Q_ASSERT(!ret.parserArguments.cppArguments.isEmpty());
     Q_ASSERT(!ret.parserArguments.cArguments.isEmpty());
 
     return ret;
 }
 
 void merge(Defines* target, const Defines& source)
 {
     if (target->isEmpty()) {
         *target = source;
         return;
     }
 
     for (auto it = source.constBegin(); it != source.constEnd(); ++it) {
         target->insert(it.key(), it.value());
     }
 }
 
 QString argumentsForPath(const Path& path, const ParserArguments& arguments)
 {
     auto languageType = Utils::languageType(path, arguments.parseAmbiguousAsCPP);
     switch (languageType) {
     case Utils::C:
         return arguments.cArguments;
     case Utils::Cpp:
         return arguments.cppArguments;
     case Utils::OpenCl:
         return arguments.openClArguments;
     case Utils::ObjC:
         return QString();
     case Utils::Other:
         return QString();
     }
     Q_UNREACHABLE();
     return QString();
 }
 
 }
 
 K_PLUGIN_FACTORY_WITH_JSON(DefinesAndIncludesManagerFactory, "kdevdefinesandincludesmanager.json", registerPlugin<DefinesAndIncludesManager>(); )
 
 DefinesAndIncludesManager::DefinesAndIncludesManager( QObject* parent, const QVariantList& )
     : IPlugin("kdevdefinesandincludesmanager", parent )
     , m_settings(SettingsManager::globalInstance())
     , m_noProjectIPM(new NoProjectIncludePathsManager())
 {
     registerProvider(m_settings->provider());
 #ifdef Q_OS_OSX
     m_defaultFrameworkDirectories += Path(QStringLiteral("/Library/Frameworks"));
     m_defaultFrameworkDirectories += Path(QStringLiteral("/System/Library/Frameworks"));
 #endif
 }
 
 DefinesAndIncludesManager::~DefinesAndIncludesManager() = default;
 
 Defines DefinesAndIncludesManager::defines( ProjectBaseItem* item, Type type  ) const
 {
     Q_ASSERT(QThread::currentThread() == qApp->thread());
 
     if (!item) {
         return m_settings->provider()->defines(nullptr);
     }
 
     Defines defines;
 
     for (auto provider : m_providers) {
         if (provider->type() & type) {
             merge(&defines, provider->defines(item));
         }
     }
 
     if ( type & ProjectSpecific ) {
         auto buildManager = item->project()->buildSystemManager();
         if ( buildManager ) {
             merge(&defines, buildManager->defines(item));
         }
     }
 
     // Manually set defines have the highest priority and overwrite values of all other types of defines.
     if (type & UserDefined) {
         auto cfg = item->project()->projectConfiguration().data();
 
         merge(&defines, findConfigForItem(m_settings->readPaths(cfg), item).defines);
     }
 
     merge(&defines, m_noProjectIPM->includesAndDefines(item->path().path()).second);
 
     return defines;
 }
 
 Path::List DefinesAndIncludesManager::includes( ProjectBaseItem* item, Type type ) const
 {
     Q_ASSERT(QThread::currentThread() == qApp->thread());
 
     if (!item) {
         return m_settings->provider()->includes(nullptr);
     }
 
     Path::List includes;
 
     if (type & UserDefined) {
         auto cfg = item->project()->projectConfiguration().data();
 
         includes += KDevelop::toPathList(findConfigForItem(m_settings->readPaths(cfg), item).includes);
     }
 
     if ( type & ProjectSpecific ) {
         auto buildManager = item->project()->buildSystemManager();
         if ( buildManager ) {
             includes += buildManager->includeDirectories(item);
         }
     }
 
     for (auto provider : m_providers) {
         if ( !(provider->type() & type) ) {
             continue;
         }
         auto newItems = provider->includes(item);
         if ( provider->type() & DefinesAndIncludesManager::CompilerSpecific ) {
             // If an item occurs in the "compiler specific" list, but was previously supplied
             // in the user include path list already, remove it from there.
             // Re-ordering the system include paths causes confusion in some cases.
             Q_FOREACH (const auto& x, newItems ) {
                 includes.removeAll(x);
             }
         }
         includes += newItems;
     }
 
     includes += m_noProjectIPM->includesAndDefines(item->path().path()).first;
 
     return includes;
 }
 
 Path::List DefinesAndIncludesManager::frameworkDirectories( ProjectBaseItem* item, Type type ) const
 {
     Q_ASSERT(QThread::currentThread() == qApp->thread());
 
     if (!item) {
         return m_settings->provider()->frameworkDirectories(nullptr);
     }
 
     Path::List frameworkDirectories = m_defaultFrameworkDirectories;
 
     if ( type & ProjectSpecific ) {
         auto buildManager = item->project()->buildSystemManager();
         if ( buildManager ) {
             frameworkDirectories += buildManager->frameworkDirectories(item);
         }
     }
 
     for (auto provider : m_providers) {
         if (provider->type() & type) {
             frameworkDirectories += provider->frameworkDirectories(item);
         }
     }
 
     return frameworkDirectories;
 }
 
 bool DefinesAndIncludesManager::unregisterProvider(IDefinesAndIncludesManager::Provider* provider)
 {
     int idx = m_providers.indexOf(provider);
     if (idx != -1) {
         m_providers.remove(idx);
         return true;
     }
 
     return false;
 }
 
 void DefinesAndIncludesManager::registerProvider(IDefinesAndIncludesManager::Provider* provider)
 {
     Q_ASSERT(provider);
     if (m_providers.contains(provider)) {
         return;
     }
 
     m_providers.push_back(provider);
 }
 
 Defines DefinesAndIncludesManager::defines(const QString& path) const
 {
     Defines ret = m_settings->provider()->defines(nullptr);
     merge(&ret, m_noProjectIPM->includesAndDefines(path).second);
     return ret;
 }
 
 Path::List DefinesAndIncludesManager::includes(const QString& path) const
 {
     return m_settings->provider()->includes(nullptr) 
            + m_noProjectIPM->includesAndDefines(path).first;
 }
 
 Path::List DefinesAndIncludesManager::frameworkDirectories(const QString& /* path */) const
 {
     return m_settings->provider()->frameworkDirectories(nullptr);
 }
 
 void DefinesAndIncludesManager::openConfigurationDialog(const QString& pathToFile)
 {
     if (auto project = KDevelop::ICore::self()->projectController()->findProjectForUrl(QUrl::fromLocalFile(pathToFile))) {
         KDevelop::ICore::self()->projectController()->configureProject(project);
     } else {
         m_noProjectIPM->openConfigurationDialog(pathToFile);
     }
 }
 
 Path::List DefinesAndIncludesManager::includesInBackground(const QString& path) const
 {
     Path::List includes;
 
     for (auto provider: m_backgroundProviders) {
         includes += provider->includesInBackground(path);
     }
 
     return includes;
 }
 
 Path::List DefinesAndIncludesManager::frameworkDirectoriesInBackground(const QString& path) const
 {
     Path::List fwDirs;
 
     for (auto provider: m_backgroundProviders) {
         fwDirs += provider->frameworkDirectoriesInBackground(path);
     }
 
     return fwDirs;
 }
 
 Defines DefinesAndIncludesManager::definesInBackground(const QString& path) const
 {
     QHash<QString, QString> defines;
 
     for (auto provider: m_backgroundProviders) {
         auto result = provider->definesInBackground(path);
         for (auto it = result.constBegin(); it != result.constEnd(); it++) {
             defines[it.key()] = it.value();
         }
     }
 
     merge(&defines, m_noProjectIPM->includesAndDefines(path).second);
 
     return defines;
 }
 
 bool DefinesAndIncludesManager::unregisterBackgroundProvider(IDefinesAndIncludesManager::BackgroundProvider* provider)
 {
     int idx = m_backgroundProviders.indexOf(provider);
     if (idx != -1) {
         m_backgroundProviders.remove(idx);
         return true;
     }
 
     return false;
 }
 
 void DefinesAndIncludesManager::registerBackgroundProvider(IDefinesAndIncludesManager::BackgroundProvider* provider)
 {
     Q_ASSERT(provider);
     if (m_backgroundProviders.contains(provider)) {
         return;
     }
 
     m_backgroundProviders.push_back(provider);
 }
 
 QString DefinesAndIncludesManager::parserArguments(KDevelop::ProjectBaseItem* item) const
 {
     Q_ASSERT(item);
 
     Q_ASSERT(QThread::currentThread() == qApp->thread());
 
     auto cfg = item->project()->projectConfiguration().data();
     const auto arguments = findConfigForItem(m_settings->readPaths(cfg), item).parserArguments;
     return argumentsForPath(item->path(), arguments);
 }
 
 QString DefinesAndIncludesManager::parserArguments(const QString& path) const
 {
     const auto args = m_settings->defaultParserArguments();
     return argumentsForPath(Path(path), args);
 }
 
 int DefinesAndIncludesManager::perProjectConfigPages() const
 {
     return 1;
 }
 
 ConfigPage* DefinesAndIncludesManager::perProjectConfigPage(int number, const ProjectConfigOptions& options, QWidget* parent)
 {
     if (number == 0) {
         return new DefinesAndIncludesConfigPage(this, options, parent);
     }
     return nullptr;
 }
 
 KDevelop::ConfigPage* DefinesAndIncludesManager::configPage(int number, QWidget* parent)
 {
     return number == 0 ? new CompilersWidget(parent) : nullptr;
 }
 
 int DefinesAndIncludesManager::configPages() const
 {
     return 1;
 }
 
 #include "definesandincludesmanager.moc"
diff --git a/languages/plugins/custom-definesandincludes/idefinesandincludesmanager.h b/languages/plugins/custom-definesandincludes/idefinesandincludesmanager.h
index 6ee4611218..ae93ddea97 100644
--- a/languages/plugins/custom-definesandincludes/idefinesandincludesmanager.h
+++ b/languages/plugins/custom-definesandincludes/idefinesandincludesmanager.h
@@ -1,217 +1,214 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 IDEFINESANDINCLUDES_H
 #define IDEFINESANDINCLUDES_H
 
 #include <QHash>
 #include <QPointer>
 #include <QString>
-#include <QStringList>
-
-#include <KConfigGroup>
 
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 
 #include <util/path.h>
 
 namespace KDevelop
 {
 class ProjectBaseItem;
 class IProject;
 
 using Defines = QHash<QString, QString>;
 
 /** An interface that provides language plugins with include directories/files and defines.
 * Call IDefinesAndIncludesManager::manager() to get the instance of the plugin.
 **/
 class IDefinesAndIncludesManager
 {
 public:
     /// The type of includes/defines
     enum Type {
         CompilerSpecific = 1, ///< Those that compiler provides
         ProjectSpecific = 2, ///< Those that project manager provides
         UserDefined = 4,    ///< Those that user defines
         All = CompilerSpecific | ProjectSpecific | UserDefined
      };
 
     /**
      * Class that actually does all the work of calculating i/d.
      *
      * Implement one in e.g. project manager and register it with @see registerProvider
      * To unregister it use @see unregisterProvider
      *
      * @sa BackgroundProvider
     **/
     class Provider
     {
     public:
         virtual ~Provider() = default;
 
         virtual Defines defines( ProjectBaseItem* item ) const = 0;
 
         virtual Path::List includes( ProjectBaseItem* item ) const = 0;
 
         virtual Path::List frameworkDirectories( ProjectBaseItem* item ) const = 0;
 
         /// @return the type of i/d this provider provides
         virtual Type type() const = 0;
     };
 
     /**
      * Use this as base class for provider, if computing includes/defines can takes a long time (e.g. parsing Makefile by running make).
      *
      * This provider will be queried for includes/defines in a background thread.
      *
      * @sa Provider
     **/
     class BackgroundProvider
     {
     public:
         virtual ~BackgroundProvider() = default;
 
         virtual Path::List includesInBackground( const QString& path ) const = 0;
 
         virtual Path::List frameworkDirectoriesInBackground( const QString& path ) const = 0;
 
         virtual Defines definesInBackground( const QString& path ) const = 0;
 
         /// @return the type of i/d this provider provides
         virtual Type type() const = 0;
     };
 
     ///@param item project item
     ///@return list of defines for @p item
     ///NOTE: call it from the foreground thread only.
     virtual Defines defines( ProjectBaseItem* item, Type type = All ) const = 0;
 
     ///@param item project item
     ///@return list of include directories/files for @p item
     ///NOTE: call it from the foreground thread only.
     virtual Path::List includes( ProjectBaseItem* item, Type type = All ) const = 0;
 
     ///@param item project item
     ///@return list of framework directories for @p item
     ///NOTE: call it from the foreground thread only.
     virtual Path::List frameworkDirectories( ProjectBaseItem* item, Type type = All ) const = 0;
 
     ///@param path path to an out-of-project file.
     ///@return list of defines for @p path
     ///NOTE: call it from the foreground thread only.
     virtual Defines defines( const QString& path ) const = 0;
 
     ///@param path path to an out-of-project file.
     ///@return list of include directories/files for @p path
     ///NOTE: call it from the foreground thread only.
     virtual Path::List includes( const QString& path ) const = 0;
 
     ///@param path path to an out-of-project file.
     ///@return list of framework directories for @p path
     ///NOTE: call it from the foreground thread only.
     virtual Path::List frameworkDirectories( const QString& path ) const = 0;
 
     /**
      * Computes include directories in background thread.
      *
      * This is especially useful for CustomMake projects.
      *
      * Call it from background thread if possible.
     **/
     virtual Path::List includesInBackground( const QString& path ) const = 0;
 
     /**
      * Computes framework directories in background thread.
      *
      * This is especially useful for CustomMake projects.
      *
      * Call it from background thread if possible.
     **/
     virtual Path::List frameworkDirectoriesInBackground( const QString& path ) const = 0;
 
     /**
      * Computes defined macros in background thread.
      *
      * Call it from background thread if possible.
     **/
     virtual Defines definesInBackground( const QString& path ) const = 0;
 
     /**
      * @param item project item. Use nullptr to get default arguments
      * @return The parser command-line arguments used to parse the @p item
      */
     virtual QString parserArguments(ProjectBaseItem* item) const = 0;
 
     virtual QString parserArguments(const QString& path) const = 0;
 
     ///@return the instance of the plugin.
     inline static IDefinesAndIncludesManager* manager();
 
     virtual ~IDefinesAndIncludesManager() = default;
 
     /**
      * Register the @p provider
      */
     virtual void registerProvider(Provider* provider) = 0;
 
     /**
      * Unregister the provider
      *
      * @return true on success, false otherwise (e.g. if not registered)
      */
     virtual bool unregisterProvider(Provider* provider) = 0;
 
     /**
      * Use this to register the background provider
      *
      * This provider will be queried for includes/defines in a background thread.
      */
     virtual void registerBackgroundProvider(BackgroundProvider* provider) = 0;
 
     /**
      * Unregister the background provider.
      *
      * @sa registerBackgroundProvider
      */
     virtual bool unregisterBackgroundProvider(BackgroundProvider* provider) = 0;
 
     /// Opens a configuration dialog for @p pathToFile to modify include directories/files and defined macros.
     virtual void openConfigurationDialog(const QString& pathToFile) = 0;
 };
 
 inline IDefinesAndIncludesManager* IDefinesAndIncludesManager::manager()
 {
     static QPointer<IPlugin> manager;
     if (!manager) {
         manager = ICore::self()->pluginController()->pluginForExtension( QStringLiteral("org.kdevelop.IDefinesAndIncludesManager") );
     }
     Q_ASSERT(manager);
 
     auto extension = manager->extension<IDefinesAndIncludesManager>();
     return extension;
 }
 
 }
 
 Q_DECLARE_INTERFACE( KDevelop::IDefinesAndIncludesManager, "org.kdevelop.IDefinesAndIncludesManager" )
 
 #endif
diff --git a/languages/plugins/custom-definesandincludes/kcm_widget/definesandincludesconfigpage.cpp b/languages/plugins/custom-definesandincludes/kcm_widget/definesandincludesconfigpage.cpp
index b186c13be7..3519474b0d 100644
--- a/languages/plugins/custom-definesandincludes/kcm_widget/definesandincludesconfigpage.cpp
+++ b/languages/plugins/custom-definesandincludes/kcm_widget/definesandincludesconfigpage.cpp
@@ -1,99 +1,96 @@
 /************************************************************************
  *                                                                      *
  * Copyright 2010 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #include <QVBoxLayout>
 #include <QIcon>
 
-#include <KPluginFactory>
-#include <KAboutData>
-
 #include "projectpathswidget.h"
 #include "customdefinesandincludes.h"
 #include "../compilerprovider/compilerprovider.h"
 
 #include <interfaces/iruncontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/idocument.h>
 #include <serialization/indexedstring.h>
 #include <project/projectmodel.h>
 
 #include "definesandincludesconfigpage.h"
 
 DefinesAndIncludesConfigPage::DefinesAndIncludesConfigPage(KDevelop::IPlugin* plugin, const KDevelop::ProjectConfigOptions& options, QWidget* parent)
     : ProjectConfigPage<CustomDefinesAndIncludes>(plugin, options, parent)
 {
     QVBoxLayout* layout = new QVBoxLayout( this );
     configWidget = new ProjectPathsWidget( this );
     configWidget->setProject( project() );
     connect(configWidget, &ProjectPathsWidget::changed, this, &DefinesAndIncludesConfigPage::changed);
     layout->addWidget( configWidget );
 }
 
 DefinesAndIncludesConfigPage::~DefinesAndIncludesConfigPage()
 {
 }
 
 void DefinesAndIncludesConfigPage::loadFrom( KConfig* cfg )
 {
     configWidget->clear();
 
     auto settings = SettingsManager::globalInstance();
 
     configWidget->setPaths( settings->readPaths( cfg ) );
 }
 
 void DefinesAndIncludesConfigPage::saveTo(KConfig* cfg, KDevelop::IProject*)
 {
     auto settings = SettingsManager::globalInstance();
     settings->writePaths( cfg, configWidget->paths() );
 
     if ( settings->needToReparseCurrentProject( cfg ) ) {
         KDevelop::ICore::self()->projectController()->reparseProject(project(), true);
     }
 }
 
 void DefinesAndIncludesConfigPage::reset()
 {
    ProjectConfigPage::reset();
    loadFrom(CustomDefinesAndIncludes::self()->config());
 }
 
 void DefinesAndIncludesConfigPage::apply()
 {
     ProjectConfigPage::apply();
     saveTo(CustomDefinesAndIncludes::self()->config(), project());
 }
 
 QString DefinesAndIncludesConfigPage::name() const
 {
     return i18n("Language Support");
 }
 
 QString DefinesAndIncludesConfigPage::fullName() const
 {
     return i18n("Configure Language Support");
 }
 
 QIcon DefinesAndIncludesConfigPage::icon() const
 {
     return QIcon::fromTheme("kdevelop");
 }
diff --git a/languages/plugins/custom-definesandincludes/kcm_widget/definesmodel.h b/languages/plugins/custom-definesandincludes/kcm_widget/definesmodel.h
index 03c41fff32..47fe300413 100644
--- a/languages/plugins/custom-definesandincludes/kcm_widget/definesmodel.h
+++ b/languages/plugins/custom-definesandincludes/kcm_widget/definesmodel.h
@@ -1,45 +1,44 @@
 /************************************************************************
  *                                                                      *
  * Copyright 2010 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #ifndef DEFINESMODEL_H
 #define DEFINESMODEL_H
 
 #include <QAbstractTableModel>
-#include <QHash>
 
 #include "idefinesandincludesmanager.h"
 
 class DefinesModel : public QAbstractTableModel
 {
 Q_OBJECT
 public:
     explicit DefinesModel( QObject* parent = nullptr );
     void setDefines( const KDevelop::Defines& defines );
     KDevelop::Defines defines() const;
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
     int rowCount(const QModelIndex& parent = QModelIndex()) const override;
     bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
     Qt::ItemFlags flags(const QModelIndex& index) const override;
     int columnCount(const QModelIndex& parent = QModelIndex()) const override;
     QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
     bool removeRows( int row, int count, const QModelIndex& parent = QModelIndex() ) override;
 private:
     QList<QPair<QString,QString> > m_defines;
 };
 
 #endif // DEFINESMODEL_H
diff --git a/languages/plugins/custom-definesandincludes/kcm_widget/defineswidget.h b/languages/plugins/custom-definesandincludes/kcm_widget/defineswidget.h
index e450071364..63f197aeb9 100644
--- a/languages/plugins/custom-definesandincludes/kcm_widget/defineswidget.h
+++ b/languages/plugins/custom-definesandincludes/kcm_widget/defineswidget.h
@@ -1,60 +1,58 @@
 /************************************************************************
  *                                                                      *
  * Copyright 2010 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #ifndef KDEVELOP_PROJECTMANAGERS_CUSTOM_BUILDSYSTEM_DEFINESWIDGET_H
 #define KDEVELOP_PROJECTMANAGERS_CUSTOM_BUILDSYSTEM_DEFINESWIDGET_H
 
 #include <QWidget>
 
-#include <qabstractitemmodel.h>
 #include "idefinesandincludesmanager.h"
 
 namespace Ui
 {
 class DefinesWidget;
 }
 
 namespace KDevelop
 {
     class IProject;
 }
 
 class DefinesModel;
-class QItemSelection;
 
 class DefinesWidget : public QWidget
 {
 Q_OBJECT
 public:
     explicit DefinesWidget( QWidget* parent = nullptr );
     void setDefines( const KDevelop::Defines& defines );
     void clear();
 signals:
     void definesChanged( const KDevelop::Defines& defines );
 private slots:
     // Forward defines model changes
     void definesChanged();
 
     // Handle Del key in defines list
     void deleteDefine();
 private:
     Ui::DefinesWidget* ui;
     DefinesModel* definesModel;
 };
 
 #endif
diff --git a/languages/plugins/custom-definesandincludes/kcm_widget/includeswidget.h b/languages/plugins/custom-definesandincludes/kcm_widget/includeswidget.h
index 13fbf1ff2a..cb59494ea0 100644
--- a/languages/plugins/custom-definesandincludes/kcm_widget/includeswidget.h
+++ b/languages/plugins/custom-definesandincludes/kcm_widget/includeswidget.h
@@ -1,72 +1,68 @@
 /************************************************************************
  *                                                                      *
  * Copyright 2010 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #ifndef KDEVELOP_PROJECTMANAGERS_CUSTOM_BUILDSYSTEM_INCLUDESWIDGET_H
 #define KDEVELOP_PROJECTMANAGERS_CUSTOM_BUILDSYSTEM_INCLUDESWIDGET_H
 
 #include <QWidget>
 
-#include <qabstractitemmodel.h>
-
-class KUrlRequester;
 namespace Ui
 {
 class IncludesWidget;
 }
 
 namespace KDevelop
 {
     class IProject;
 }
 class QUrl;
 class ProjectPathsModel;
 class IncludesModel;
-class QItemSelection;
 
 class IncludesWidget : public QWidget
 {
 Q_OBJECT
 public:
     explicit IncludesWidget( QWidget* parent = nullptr );
     void setProject(KDevelop::IProject* w_project);
     void setIncludes( const QStringList& );
     void clear();
 signals:
     void includesChanged( const QStringList& );
 private slots:
     // Handling of include-path url-requester, add and remove buttons
     void includePathSelected( const QModelIndex& selected );
     void includePathEdited();
     void includePathUrlSelected(const QUrl&);
     void addIncludePath();
     // Handles action and also Del-key in list
     void deleteIncludePath();
     void checkIfIncludePathExist();
 
     // Forward includes model changes
     void includesChanged();
 private:
     Ui::IncludesWidget* ui;
     IncludesModel* includesModel;
     QString makeIncludeDirAbsolute( const QUrl &url ) const;
     // Enables/Disables widgets based on UI state/selection
     void updateEnablements();
     void updatePathsModel( const QVariant& newData, int role );
 };
 
 #endif
diff --git a/languages/plugins/custom-definesandincludes/kcm_widget/projectpathswidget.h b/languages/plugins/custom-definesandincludes/kcm_widget/projectpathswidget.h
index 26d1864797..15e54e3dcf 100644
--- a/languages/plugins/custom-definesandincludes/kcm_widget/projectpathswidget.h
+++ b/languages/plugins/custom-definesandincludes/kcm_widget/projectpathswidget.h
@@ -1,87 +1,83 @@
 /************************************************************************
  *                                                                      *
  * Copyright 2010 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #ifndef KDEVELOP_PROJECTMANAGERS_CUSTOM_BUILDSYSTEM_PROJECTPATHSWIDGET_H
 #define KDEVELOP_PROJECTMANAGERS_CUSTOM_BUILDSYSTEM_PROJECTPATHSWIDGET_H
 
 #include <QWidget>
 
-#include <qabstractitemmodel.h>
-
 #include "../compilerprovider/icompiler.h"
 #include "../compilerprovider/settingsmanager.h"
 
-class KUrlRequester;
 namespace Ui
 {
 class ProjectPathsWidget;
 }
 
 namespace KDevelop
 {
     class IProject;
 }
 
 class ProjectPathsModel;
-class QItemSelection;
 
 class ProjectPathsWidget : public QWidget
 {
 Q_OBJECT
 public:
     explicit ProjectPathsWidget( QWidget* parent = nullptr );
     void setProject(KDevelop::IProject* w_project);
     void setPaths( const QVector<ConfigEntry>& );
     QVector<ConfigEntry> paths() const;
     void clear();
 
 signals:
     void changed();
 
 private:
     void setCurrentCompiler(const QString& name);
 
     CompilerPointer currentCompiler() const;
 
 private slots:
     // Handling of project-path combobox, add and remove buttons
     void projectPathSelected( int index );
     void addProjectPath();
     void deleteProjectPath();
     void batchEdit();
     void tabChanged(int);
     void changeCompilerForPath();
 
     // Forward includes model changes into the pathsModel
     void includesChanged( const QStringList& includes );
 
     // Forward defines model changes into the pathsModel
     void definesChanged( const KDevelop::Defines& defines );
 
     void parserArgumentsChanged();
 
 private:
     Ui::ProjectPathsWidget* ui;
     ProjectPathsModel* pathsModel;
     // Enables/Disables widgets based on UI state/selection
     void updateEnablements();
     void updatePathsModel( const QVariant& newData, int role );
 };
 
 #endif
 
diff --git a/languages/plugins/custom-definesandincludes/tests/test_definesandincludes.cpp b/languages/plugins/custom-definesandincludes/tests/test_definesandincludes.cpp
index fffaba469d..43c33dd6e0 100644
--- a/languages/plugins/custom-definesandincludes/tests/test_definesandincludes.cpp
+++ b/languages/plugins/custom-definesandincludes/tests/test_definesandincludes.cpp
@@ -1,155 +1,155 @@
 /************************************************************************
  *                                                                      *
  * Copyright 2010 Andreas Pakulat <apaku@gmx.de>                        *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>         *
  *                                                                      *
  * 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #include "test_definesandincludes.h"
 #include "projectsgenerator.h"
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <project/projectmodel.h>
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <tests/testhelpers.h>
 
 #include <serialization/indexedstring.h>
 
 #include "idefinesandincludesmanager.h"
 
 using namespace KDevelop;
 
 static IProject* s_currentProject = nullptr;
 
 void TestDefinesAndIncludes::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestDefinesAndIncludes::initTestCase()
 {
     AutoTestShell::init();
     TestCore::initialize();
 }
 
 void TestDefinesAndIncludes::cleanup()
 {
     ICore::self()->projectController()->closeProject( s_currentProject );
 }
 
 void TestDefinesAndIncludes::loadSimpleProject()
 {
     s_currentProject = ProjectsGenerator::GenerateSimpleProject();
     QVERIFY( s_currentProject );
 
     auto manager = IDefinesAndIncludesManager::manager();
     QVERIFY( manager );
     const auto actualIncludes = manager->includes( s_currentProject->projectItem(), IDefinesAndIncludesManager::UserDefined );
     const auto actualDefines = manager->defines( s_currentProject->projectItem(), IDefinesAndIncludesManager::UserDefined );
 
     qDebug() << actualDefines << actualIncludes;
 
     QCOMPARE( actualIncludes, Path::List() << Path( "/usr/include/mydir") );
 
     Defines defines;
     defines.insert( "_DEBUG", "" );
     defines.insert( "VARIABLE", "VALUE" );
     QCOMPARE( actualDefines, defines );
 
     QVERIFY(!manager->parserArguments(s_currentProject->projectItem()).isEmpty());
     QVERIFY(!manager->parserArguments(QStringLiteral("/some/path/to/file.cpp")).isEmpty());
 }
 
 void TestDefinesAndIncludes::loadMultiPathProject()
 {
     s_currentProject = ProjectsGenerator::GenerateMultiPathProject();
     QVERIFY( s_currentProject );
 
     auto manager = IDefinesAndIncludesManager::manager();
     QVERIFY( manager );
     Path::List includes = Path::List() << Path("/usr/include/otherdir");
 
     QHash<QString,QString> defines;
     defines.insert("SOURCE", "CONTENT");
     defines.insert("_COPY", "");
 
     QCOMPARE( manager->includes( s_currentProject->projectItem(), IDefinesAndIncludesManager::UserDefined ), includes );
     QCOMPARE( manager->defines( s_currentProject->projectItem(), IDefinesAndIncludesManager::UserDefined ), defines );
     QVERIFY(!manager->parserArguments(s_currentProject->projectItem()).isEmpty());
 
     ProjectBaseItem* mainfile = nullptr;
     for (const auto& file: s_currentProject->fileSet() ) {
         for (auto i: s_currentProject->filesForPath(file)) {
             if( i->text() == "main.cpp" ) {
                 mainfile = i;
                 break;
             }
         }
     }
     QVERIFY(mainfile);
 
     includes.prepend(Path("/usr/local/include/mydir"));
     defines.insert("BUILD", "debug");
     qDebug() << includes << "VS" << manager->includes( mainfile, IDefinesAndIncludesManager::UserDefined );
     qDebug() << mainfile << mainfile->path();
     QCOMPARE(manager->includes( mainfile, IDefinesAndIncludesManager::UserDefined ), includes);
     QCOMPARE(defines, manager->defines( mainfile, IDefinesAndIncludesManager::UserDefined ));
     QVERIFY(!manager->parserArguments(mainfile).isEmpty());
 }
 
 void TestDefinesAndIncludes::testNoProjectIncludeDirectories()
 {
     s_currentProject = ProjectsGenerator::GenerateSimpleProjectWithOutOfProjectFiles();
     QVERIFY(s_currentProject);
 
     auto manager = KDevelop::IDefinesAndIncludesManager::manager();
     QVERIFY(manager);
 
     auto projectIncludes = manager->includes(s_currentProject->projectItem(), IDefinesAndIncludesManager::UserDefined);
 
     Path includePath1(s_currentProject->path().path() + QDir::separator() + "include1.h");
     Path includePath2(s_currentProject->path().path() + QDir::separator() + "include2.h");
 
     QVERIFY(!projectIncludes.contains(includePath1));
     QVERIFY(!projectIncludes.contains(includePath2));
 
     auto noProjectIncludes = manager->includes(s_currentProject->path().path() + "/src/main.cpp");
     QVERIFY(noProjectIncludes.contains(includePath1));
     QVERIFY(noProjectIncludes.contains(includePath2));
     QVERIFY(!manager->parserArguments(s_currentProject->projectItem()).isEmpty());
 }
 
 void TestDefinesAndIncludes::testEmptyProject()
 {
     s_currentProject = ProjectsGenerator::GenerateEmptyProject();
     QVERIFY(s_currentProject);
 
     auto manager = KDevelop::IDefinesAndIncludesManager::manager();
     QVERIFY(manager);
 
     auto projectIncludes = manager->includes(s_currentProject->projectItem());
     auto projectDefines = manager->defines(s_currentProject->projectItem());
     auto parserArguments = manager->parserArguments(s_currentProject->projectItem());
 
     QVERIFY(!projectIncludes.isEmpty());
     QVERIFY(!projectDefines.isEmpty());
     QVERIFY(!parserArguments.isEmpty());
 }
 
 QTEST_MAIN(TestDefinesAndIncludes)
diff --git a/languages/qmljs/codecompletion/context.cpp b/languages/qmljs/codecompletion/context.cpp
index d5dc25c3a9..367ef7a65c 100644
--- a/languages/qmljs/codecompletion/context.cpp
+++ b/languages/qmljs/codecompletion/context.cpp
@@ -1,502 +1,501 @@
 /*
  * This file is part of qmljs, the QML/JS language support plugin for KDevelop
  * Copyright (c) 2013 Sven Brauch <svenbrauch@googlemail.com>
  *
  * 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 "context.h"
 
 #include "items/modulecompletionitem.h"
 #include "items/functioncalltipcompletionitem.h"
 
 #include <language/codecompletion/codecompletionitem.h>
 #include <language/codecompletion/normaldeclarationcompletionitem.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/namespacealiasdeclaration.h>
 #include <language/duchain/codemodel.h>
 
 #include <qmljs/qmljsdocument.h>
 #include <qmljs/parser/qmljslexer_p.h>
 #include "../duchain/expressionvisitor.h"
 #include "../duchain/helper.h"
 #include "../duchain/cache.h"
 #include "../duchain/frameworks/nodejs.h"
 
 #include <QtCore/QDir>
 #include <QtCore/QRegExp>
-#include <QtCore/QStandardPaths>
 
 using namespace KDevelop;
 
 typedef QPair<Declaration*, int> DeclarationDepthPair;
 
 namespace QmlJS {
 
 CodeCompletionContext::CodeCompletionContext(const DUContextPointer& context, const QString& text,
                                              const CursorInRevision& position, int depth)
 : KDevelop::CodeCompletionContext(context, extractLastLine(text), position, depth),
   m_completionKind(NormalCompletion)
 {
     // Detect "import ..." and provide import completions
     if (m_text.startsWith("import ")) {
         m_completionKind = ImportCompletion;
     }
 
     // Node.js module completions
     if (m_text.endsWith(QLatin1String("require("))) {
         m_completionKind = NodeModulesCompletion;
     }
 
     // Detect whether the cursor is in a comment
     bool isLastLine = true;
     bool inString = false;
 
     for (int index = text.size()-1; index > 0; --index) {
         const QChar c = text.at(index);
         const QChar prev = text.at(index - 1);
 
         if (c == QLatin1Char('\n')) {
             isLastLine = false;
         } else if (isLastLine && prev == QLatin1Char('/') && c == QLatin1Char('/')) {
             // Single-line comment on the current line, we are in a comment
             m_completionKind = CommentCompletion;
             break;
         } else if (prev == QLatin1Char('/') && c == QLatin1Char('*')) {
             // Start of a multi-line comment encountered
             m_completionKind = CommentCompletion;
             break;
         } else if (prev == QLatin1Char('*') && c == QLatin1Char('/')) {
             // End of a multi-line comment. Because /* and */ cannot be nested,
             // encountering a */ is enough to know that the cursor is outside a
             // comment
             break;
         } else if (prev != QLatin1Char('\\') && (c == QLatin1Char('"') || c == QLatin1Char('\''))) {
             // Toggle whether we are in a string or not
             inString = !inString;
         }
     }
 
     if (inString) {
         m_completionKind = StringCompletion;
     }
 
     // Some specific constructs don't need any code-completion at all (mainly
     // because the user will declare new things, not use ones)
     if (m_text.contains(QRegExp(QLatin1String("(var|function)\\s+$"))) ||                   // "var |" or "function |"
         m_text.contains(QRegExp(QLatin1String("property\\s+[a-zA-Z0-9_]+\\s+$"))) ||        // "property <type> |"
         m_text.contains(QRegExp(QLatin1String("function(\\s+[a-zA-Z0-9_]+)?\\s*\\($"))) ||  // "function (|" or "function <name> (|"
         m_text.contains(QRegExp(QLatin1String("id:\\s*")))                                  // "id: |"
     ) {
         m_completionKind = NoCompletion;
     }
 }
 
 QList<CompletionTreeItemPointer> CodeCompletionContext::completionItems(bool& abort, bool fullCompletion)
 {
     Q_UNUSED (fullCompletion);
 
     if (abort) {
         return QList<CompletionTreeItemPointer>();
     }
 
     switch (m_completionKind) {
     case NormalCompletion:
         return normalCompletion();
     case CommentCompletion:
         return commentCompletion();
     case ImportCompletion:
         return importCompletion();
     case NodeModulesCompletion:
         return nodeModuleCompletions();
     case StringCompletion:
     case NoCompletion:
         break;
     }
 
     return QList<CompletionTreeItemPointer>();
 }
 
 AbstractType::Ptr CodeCompletionContext::typeToMatch() const
 {
     return m_typeToMatch;
 }
 
 QList<KDevelop::CompletionTreeItemPointer> CodeCompletionContext::normalCompletion()
 {
     QList<CompletionTreeItemPointer> items;
     QChar lastChar = m_text.size() > 0 ? m_text.at(m_text.size() - 1) : QLatin1Char('\0');
     bool inQmlObjectScope = (m_duContext->type() == DUContext::Class);
 
     // Start with the function call-tips, because functionCallTips is also responsible
     // for setting m_declarationForTypeMatch
     items << functionCallTips();
 
     if (lastChar == QLatin1Char('.') || lastChar == QLatin1Char('[')) {
         // Offer completions for object members and array subscripts
         items << fieldCompletions(
             m_text.left(m_text.size() - 1),
             lastChar == QLatin1Char('[') ? CompletionItem::QuotesAndBracket :
             CompletionItem::NoDecoration
         );
     }
 
     // "object." must only display the members of object, the declarations
     // available in the current context.
     if (lastChar != QLatin1Char('.')) {
         if (inQmlObjectScope) {
             DUChainReadLocker lock;
 
             // The cursor is in a QML object and there is nothing before it. Display
             // a list of properties and signals that can be used in a script binding.
             // Note that the properties/signals of parent QML objects are not displayed here
             items << completionsInContext(m_duContext,
                                           CompletionOnlyLocal | CompletionHideWrappers,
                                           CompletionItem::ColonOrBracket);
             items << completionsFromImports(CompletionHideWrappers);
             items << completionsInContext(DUContextPointer(m_duContext->topContext()),
                                           CompletionHideWrappers,
                                           CompletionItem::NoDecoration);
         } else {
             items << completionsInContext(m_duContext,
                                           nullptr,
                                           CompletionItem::NoDecoration);
             items << completionsFromImports(nullptr);
             items << completionsFromNodeModule(nullptr, QLatin1String("__builtin_ecmascript"));
 
             if (!QmlJS::isQmlFile(m_duContext.data())) {
                 items << completionsFromNodeModule(nullptr, QLatin1String("__builtin_dom"));
             }
         }
     }
 
     return items;
 }
 
 QList<CompletionTreeItemPointer> CodeCompletionContext::commentCompletion()
 {
     return QList<CompletionTreeItemPointer>();
 }
 
 QList<CompletionTreeItemPointer> CodeCompletionContext::importCompletion()
 {
     QList<CompletionTreeItemPointer> items;
     QString fragment = m_text.section(QLatin1Char(' '), -1, -1);
 
     // Use the cache to find the directory corresponding to the fragment
     // (org.kde is, for instance, /usr/lib64/kde4/imports/org/kde), and list
     // its subdirectories
     QString dataDir = Cache::instance().modulePath(m_duContext->url(), fragment);
     QDir dir;
 
     if (!dataDir.isEmpty()) {
         dir.setPath(dataDir);
 
         for (const QString& entry : dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name)) {
             items.append(CompletionTreeItemPointer(new ModuleCompletionItem(
                 fragment + entry.section(QLatin1Char('.'), 0, 0),
                 ModuleCompletionItem::Import
             )));
         }
     }
 
     return items;
 }
 
 QList<CompletionTreeItemPointer> CodeCompletionContext::nodeModuleCompletions()
 {
     QList<CompletionTreeItemPointer> items;
     QDir dir;
 
     for (auto path : NodeJS::instance().moduleDirectories(m_duContext->url().str())) {
         dir.setPath(path.toLocalFile());
 
         for (QString entry : dir.entryList(QDir::Files, QDir::Name)) {
             entry.replace(QLatin1String(".js"), QString());
 
             if (entry.startsWith(QLatin1String("__"))) {
                 // Internal module, don't show
                 continue;
             }
 
             items.append(CompletionTreeItemPointer(
                 new ModuleCompletionItem(entry, ModuleCompletionItem::Quotes)
             ));
         }
     }
 
     return items;
 }
 
 QList<CompletionTreeItemPointer> CodeCompletionContext::functionCallTips()
 {
     Stack<ExpressionStackEntry> stack = expressionStack(m_text);
     QList<CompletionTreeItemPointer> items;
     int argumentHintDepth = 1;
     bool isTopOfStack = true;
     DUChainReadLocker lock;
 
     while (!stack.isEmpty()) {
         ExpressionStackEntry entry = stack.pop();
 
         if (isTopOfStack && entry.operatorStart > entry.startPosition) {
             // Deduce the declaration for type matching using operatorStart:
             //
             // table[document.base +
             //       [             ^
             //
             // ^ = operatorStart. Just before operatorStart is a code snippet that ends
             // with the declaration whose type should be used.
             DeclarationPointer decl = declarationAtEndOfString(m_text.left(entry.operatorStart));
 
             if (decl) {
                 m_typeToMatch = decl->abstractType();
             }
         }
 
         if (entry.startPosition > 0 && m_text.at(entry.startPosition - 1) == QLatin1Char('(')) {
             // The current entry represents a function call, create a call-tip for it
             DeclarationPointer functionDecl = declarationAtEndOfString(m_text.left(entry.startPosition - 1));
 
             if (functionDecl) {
                 auto  item = new FunctionCalltipCompletionItem(
                     functionDecl,
                     argumentHintDepth,
                     entry.commas
                 );
 
                 items << CompletionTreeItemPointer(item);
                 argumentHintDepth++;
 
                 if (isTopOfStack && !m_typeToMatch) {
                     m_typeToMatch = item->currentArgumentType();
                 }
             }
         }
 
         isTopOfStack = false;
     }
 
     return items;
 }
 
 QList<CompletionTreeItemPointer> CodeCompletionContext::completionsFromImports(CompletionInContextFlags flags)
 {
     QList<CompletionTreeItemPointer> items;
 
     // Iterate over all the imported namespaces and add their definitions
     DUChainReadLocker lock;
     QList<Declaration*> imports = m_duContext->findDeclarations(globalImportIdentifier());
     QList<Declaration*> realImports;
 
     foreach (Declaration* import, imports) {
         if (import->kind() != Declaration::NamespaceAlias) {
             continue;
         }
 
         NamespaceAliasDeclaration* decl = static_cast<NamespaceAliasDeclaration *>(import);
         realImports << m_duContext->findDeclarations(decl->importIdentifier());
     }
 
     foreach (Declaration* import, realImports) {
         items << completionsInContext(
             DUContextPointer(import->internalContext()),
             flags,
             CompletionItem::NoDecoration
         );
     }
 
     return items;
 }
 
 QList<CompletionTreeItemPointer> CodeCompletionContext::completionsFromNodeModule(CompletionInContextFlags flags,
                                                                                   const QString& module)
 {
     return completionsInContext(
         DUContextPointer(QmlJS::getInternalContext(
             QmlJS::NodeJS::instance().moduleExports(module, m_duContext->url())
         )),
         flags | CompletionOnlyLocal,
         CompletionItem::NoDecoration
     );
 }
 
 QList<CompletionTreeItemPointer> CodeCompletionContext::completionsInContext(const DUContextPointer& context,
                                                                              CompletionInContextFlags flags,
                                                                              CompletionItem::Decoration decoration)
 {
     QList<CompletionTreeItemPointer> items;
     DUChainReadLocker lock;
 
     if (context) {
         const QList<DeclarationDepthPair>& declarations = context->allDeclarations(
             CursorInRevision::invalid(),
             context->topContext(),
             !flags.testFlag(CompletionOnlyLocal)
         );
 
         foreach (const DeclarationDepthPair& decl, declarations) {
             DeclarationPointer declaration(decl.first);
             CompletionItem::Decoration decorationOfThisItem = decoration;
 
             if (declaration->identifier() == globalImportIdentifier()) {
                 continue;
             } if (declaration->qualifiedIdentifier().isEmpty()) {
                 continue;
             } else if (context->owner() && (
                             context->owner()->kind() == Declaration::Namespace ||
                             context->owner()->kind() == Declaration::NamespaceAlias
                        ) && decl.second != 0 && decl.second != 1001) {
                 // Only show the local declarations of modules, or the declarations
                 // immediately in its imported parent contexts (that are global
                 // contexts, hence the distance of 1001). This prevens "String()",
                 // "QtQuick1.0" and "builtins" from being listed when the user
                 // types "PlasmaCore.".
                 continue;
             } else if (decorationOfThisItem == CompletionItem::NoDecoration &&
                        declaration->abstractType() &&
                        declaration->abstractType()->whichType() == AbstractType::TypeFunction) {
                 // Decorate function calls with brackets
                 decorationOfThisItem = CompletionItem::Brackets;
             } else if (flags.testFlag(CompletionHideWrappers)) {
                 ClassDeclaration* classDecl = dynamic_cast<ClassDeclaration*>(declaration.data());
 
                 if (classDecl && classDecl->classType() == ClassDeclarationData::Interface) {
                     continue;
                 }
             }
 
             items << CompletionTreeItemPointer(new CompletionItem(declaration, decl.second, decorationOfThisItem));
         }
     }
 
     return items;
 }
 
 QList<CompletionTreeItemPointer> CodeCompletionContext::fieldCompletions(const QString& expression,
                                                                          CompletionItem::Decoration decoration)
 {
     // The statement given to this method ends with an expression that may identify
     // a declaration ("foo" in "test(1, 2, foo"). List the declarations of this
     // inner context
     DUContext* context = getInternalContext(declarationAtEndOfString(expression));
 
     if (context) {
         return completionsInContext(DUContextPointer(context),
                                     CompletionOnlyLocal,
                                     decoration);
     } else {
         return QList<CompletionTreeItemPointer>();
     }
 }
 
 Stack<CodeCompletionContext::ExpressionStackEntry> CodeCompletionContext::expressionStack(const QString& expression)
 {
     Stack<CodeCompletionContext::ExpressionStackEntry> stack;
     ExpressionStackEntry entry;
     QmlJS::Lexer lexer(nullptr);
     bool atEnd = false;
 
     lexer.setCode(expression, 1, false);
 
     entry.startPosition = 0;
     entry.operatorStart = 0;
     entry.operatorEnd = 0;
     entry.commas = 0;
 
     stack.push(entry);
 
     // NOTE: KDevelop uses 0-indexed columns while QMLJS uses 1-indexed columns
     while (!atEnd) {
         switch (lexer.lex()) {
         case QmlJSGrammar::EOF_SYMBOL:
             atEnd = true;
             break;
         case QmlJSGrammar::T_LBRACE:
         case QmlJSGrammar::T_LBRACKET:
         case QmlJSGrammar::T_LPAREN:
             entry.startPosition = lexer.tokenEndColumn() - 1;
             entry.operatorStart = entry.startPosition;
             entry.operatorEnd = entry.startPosition;
             entry.commas = 0;
 
             stack.push(entry);
             break;
         case QmlJSGrammar::T_RBRACE:
         case QmlJSGrammar::T_RBRACKET:
         case QmlJSGrammar::T_RPAREN:
             if (stack.count() > 1) {
                 stack.pop();
             }
             break;
         case QmlJSGrammar::T_IDENTIFIER:
         case QmlJSGrammar::T_DOT:
         case QmlJSGrammar::T_THIS:
             break;
         case QmlJSGrammar::T_COMMA:
             stack.top().commas++;
         default:
             // The last operator of every sub-expression is stored on the stack
             // so that "A = foo." can know that attributes of foo having the same
             // type as A should be highlighted.
             stack.top().operatorStart = lexer.tokenStartColumn() - 1;
             stack.top().operatorEnd = lexer.tokenEndColumn() - 1;
         }
     }
 
     return stack;
 }
 
 DeclarationPointer CodeCompletionContext::declarationAtEndOfString(const QString& expression)
 {
     // Build the expression stack of expression and use the valid portion of the
     // top sub-expression to find the right-most declaration that can be found
     // in expression.
     QmlJS::Document::MutablePtr doc = QmlJS::Document::create("inline", Dialect::JavaScript);
     ExpressionStackEntry topEntry = expressionStack(expression).top();
 
     doc->setSource(expression.mid(topEntry.operatorEnd));
     doc->parseExpression();
 
     if (!doc || !doc->isParsedCorrectly()) {
         return DeclarationPointer();
     }
 
     // Use ExpressionVisitor to find the type (and associated declaration) of
     // the snippet that has been parsed. The inner context of the declaration
     // can be used to get the list of completions
     ExpressionVisitor visitor(m_duContext.data());
     doc->ast()->accept(&visitor);
 
     return visitor.lastDeclaration();
 }
 
 bool CodeCompletionContext::containsOnlySpaces(const QString& str)
 {
     for (int i=0; i<str.size(); ++i) {
         if (!str.at(i).isSpace()) {
             return false;
         }
     }
 
     return true;
 }
 
 }
diff --git a/languages/qmljs/duchain/cache.h b/languages/qmljs/duchain/cache.h
index 2bbf524425..7ac77b0c40 100644
--- a/languages/qmljs/duchain/cache.h
+++ b/languages/qmljs/duchain/cache.h
@@ -1,124 +1,126 @@
 /*
  * This file is part of qmljs, the QML/JS language support plugin for KDevelop
  * Copyright (c) 2013 Sven Brauch <svenbrauch@googlemail.com>
  * Copyright (c) 2014 Denis Steckelmacher <steckdenis@yahoo.fr>
  *
  * 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/>.
  *
  */
 #ifndef __CACHE_H__
 #define __CACHE_H__
 
 #include "duchainexport.h"
 #include <serialization/indexedstring.h>
 #include <util/path.h>
 
 #include <QHash>
-#include <QStringList>
-#include <QFileInfo>
+#include <QString>
+#include <QFileInfoList>
 #include <QList>
 #include <QSet>
 #include <QMutex>
 
+class QStringList;
+
 namespace QmlJS
 {
 
 /**
  * Cache for values that may be slow to compute (search paths, things
  * involving QStandardPaths, etc)
  */
 class KDEVQMLJSDUCHAIN_EXPORT Cache
 {
 private:
     Cache();
 
 public:
     static Cache& instance();
 
     /**
      * Path corresponding to a module name
      *
      * The path returned can either be the one of a module file shipped with
      * kdev-qmljs, or the path of a directory containing the module components
      * (one .qml file per component, and possibly .so files if the module has
      * native components)
      *
      * @param version If not null, the file being looked for is "uri_version.qml".
      *                If null, then the untouched uri is used for searching.
      */
     QString modulePath(const KDevelop::IndexedString& baseFile,
                        const QString& uri,
                        const QString& version = QStringLiteral("1.0"));
 
     /**
      * Return the list of the paths of the given files.
      *
      * Files having a name ending in ".so" are replaced with the path of their
      * qmlplugindump dump.
      */
     QStringList getFileNames(const QFileInfoList& fileInfos);
 
     /**
      * Set the custom include directories list of a file
      */
     void setFileCustomIncludes(const KDevelop::IndexedString& file,
                                const KDevelop::Path::List& dirs);
 
     /**
      * Add a dependency between two URLs
      */
     void addDependency(const KDevelop::IndexedString& file, const KDevelop::IndexedString& dependency);
 
     /**
      * List of the files that depend on a given URL
      */
     QList<KDevelop::IndexedString> filesThatDependOn(const KDevelop::IndexedString& file);
 
     /**
      * List of the dependencies of a file
      */
     QList<KDevelop::IndexedString> dependencies(const KDevelop::IndexedString& file);
 
     /**
      * Return whether a file is up to date (all its dependencies are up to date
      * and the file has been freshly parsed)
      */
     bool isUpToDate(const KDevelop::IndexedString& file);
     void setUpToDate(const KDevelop::IndexedString& file, bool upToDate);
 
 private:
     struct PluginDumpExecutable {
         QString executable;
         QString quickVersion;       // Version of QtQuick that should be imported when this qmlplugindump is used
 
         PluginDumpExecutable(const QString& e, const QString &v)
         : executable(e), quickVersion(v)
         {}
     };
 
     QMutex m_mutex;
     QHash<QString, QString> m_modulePaths;
     QList<PluginDumpExecutable> m_pluginDumpExecutables;
     QHash<KDevelop::IndexedString, QSet<KDevelop::IndexedString>> m_dependees;
     QHash<KDevelop::IndexedString, QSet<KDevelop::IndexedString>> m_dependencies;
     QHash<KDevelop::IndexedString, bool> m_isUpToDate;
     QHash<KDevelop::IndexedString, KDevelop::Path::List> m_includeDirs;
 };
 
 }
 
 #endif
diff --git a/languages/qmljs/duchain/declarationbuilder.cpp b/languages/qmljs/duchain/declarationbuilder.cpp
index 4961e6fd96..1b3a5732f5 100644
--- a/languages/qmljs/duchain/declarationbuilder.cpp
+++ b/languages/qmljs/duchain/declarationbuilder.cpp
@@ -1,1542 +1,1541 @@
 /*************************************************************************************
  *  Copyright (C) 2012 by Aleix Pol <aleixpol@kde.org>                               *
  *  Copyright (C) 2012 by 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) 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 "declarationbuilder.h"
 #include "debug.h"
 
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/enumerationtype.h>
 #include <language/duchain/types/enumeratortype.h>
 #include <language/duchain/types/arraytype.h>
 #include <language/duchain/types/typeutils.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/aliasdeclaration.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/namespacealiasdeclaration.h>
 
 #include "expressionvisitor.h"
 #include "parsesession.h"
 #include "functiondeclaration.h"
 #include "functiontype.h"
 #include "helper.h"
 #include "cache.h"
 #include "frameworks/nodejs.h"
 
-#include <QtCore/QDirIterator>
 #include <QtCore/QFileInfo>
 #include <QtCore/QStandardPaths>
 #include <KLocalizedString>
 
 using namespace KDevelop;
 
 DeclarationBuilder::DeclarationBuilder(ParseSession* session)
 : m_prebuilding(false)
 {
     m_session = session;
 }
 
 ReferencedTopDUContext DeclarationBuilder::build(const IndexedString& url,
                                                  QmlJS::AST::Node* node,
                                                  ReferencedTopDUContext updateContext)
 {
     Q_ASSERT(m_session->url() == url);
 
     // The declaration builder needs to run twice, so it can resolve uses of e.g. functions
     // which are called before they are defined (which is easily possible, due to JS's dynamic nature).
     if (!m_prebuilding) {
         qCDebug(KDEV_QMLJS_DUCHAIN) << "building, but running pre-builder first";
         auto  prebuilder = new DeclarationBuilder(m_session);
 
         prebuilder->m_prebuilding = true;
         updateContext = prebuilder->build(url, node, updateContext);
 
         qCDebug(KDEV_QMLJS_DUCHAIN) << "pre-builder finished";
         delete prebuilder;
 
         if (!m_session->allDependenciesSatisfied()) {
             qCDebug(KDEV_QMLJS_DUCHAIN) << "dependencies were missing, don't perform the second parsing pass";
             return updateContext;
         }
     } else {
         qCDebug(KDEV_QMLJS_DUCHAIN) << "prebuilding";
     }
 
     return DeclarationBuilderBase::build(url, node, updateContext);
 }
 
 void DeclarationBuilder::startVisiting(QmlJS::AST::Node* node)
 {
     DUContext* builtinQmlContext = nullptr;
 
     if (QmlJS::isQmlFile(currentContext()) && !currentContext()->url().str().contains("__builtin_qml.qml")) {
         builtinQmlContext = m_session->contextOfFile(
             QStandardPaths::locate(QStandardPaths::GenericDataLocation, QLatin1String("kdevqmljssupport/nodejsmodules/__builtin_qml.qml"))
         );
     }
 
     {
         DUChainWriteLocker lock;
 
         // Remove all the imported parent contexts: imports may have been edited
         // and there musn't be any leftover parent context
         currentContext()->topContext()->clearImportedParentContexts();
 
         // Initialize Node.js
         QmlJS::NodeJS::instance().initialize(this);
 
         // Built-in QML types (color, rect, etc)
         if (builtinQmlContext) {
             topContext()->addImportedParentContext(builtinQmlContext);
         }
     }
 
     DeclarationBuilderBase::startVisiting(node);
 }
 
 /*
  * Functions
  */
 template<typename Decl>
 void DeclarationBuilder::declareFunction(QmlJS::AST::Node* node,
                                          bool newPrototypeContext,
                                          const QualifiedIdentifier& name,
                                          const RangeInRevision& nameRange,
                                          QmlJS::AST::Node* parameters,
                                          const RangeInRevision& parametersRange,
                                          QmlJS::AST::Node* body,
                                          const RangeInRevision& bodyRange)
 {
     setComment(node);
 
     // Declare the function
     QmlJS::FunctionType::Ptr func(new QmlJS::FunctionType);
     Decl* decl;
 
     {
         DUChainWriteLocker lock;
 
         decl = openDeclaration<Decl>(name, nameRange);
         decl->setKind(Declaration::Type);
         func->setDeclaration(decl);
         decl->setType(func);
     }
     openType(func);
 
     // Parameters, if any (a function must always have an internal function context,
     // so always open a context here even if there are no parameters)
     DUContext* parametersContext = openContext(
         node + 1,                                               // Don't call setContextOnNode on node, only the body context can be associated with node
         RangeInRevision(parametersRange.start, bodyRange.end),  // Ensure that this context contains both the parameters and the body
         DUContext::Function,
         name
     );
 
     if (parameters) {
         QmlJS::AST::Node::accept(parameters, this);
     }
 
     // The internal context of the function is its parameter context
     {
         DUChainWriteLocker lock;
         decl->setInternalContext(parametersContext);
     }
 
     // Open the prototype context, if any. This has to be done before the body
     // because this context is needed for "this" to be properly resolved
     // in it.
     if (newPrototypeContext) {
         DUChainWriteLocker lock;
         QmlJS::FunctionDeclaration* d = reinterpret_cast<QmlJS::FunctionDeclaration*>(decl);
 
         d->setPrototypeContext(openContext(
             node + 2,                   // Don't call setContextOnNode on node, only the body context can be associated with node
             RangeInRevision(parametersRange.start, parametersRange.start),
             DUContext::Function,        // This allows QmlJS::getOwnerOfContext to know that the parent of this context is the function declaration
             QualifiedIdentifier(name)
         ));
 
         if (name.last() != Identifier(QLatin1String("Object"))) {
             // Every class inherit from Object
             QmlJS::importObjectContext(currentContext(), topContext());
         }
 
         closeContext();
     }
 
     // Body, if any (it is a child context of the parameters)
     openContext(
         node,
         bodyRange,
         DUContext::Other,
         name
     );
 
     if (body) {
         QmlJS::AST::Node::accept(body, this);
     }
 
     // Close the body context and then the parameters context
     closeContext();
     closeContext();
 }
 
 template<typename Node>
 void DeclarationBuilder::declareParameters(Node* node, QStringRef Node::*typeAttribute)
 {
     for (Node *plist = node; plist; plist = plist->next) {
         const QualifiedIdentifier name(plist->name.toString());
         const RangeInRevision range = m_session->locationToRange(plist->identifierToken);
 
         AbstractType::Ptr type = (typeAttribute ?
             typeFromName((plist->*typeAttribute).toString()) :              // The typeAttribute attribute of plist contains the type name of the argument
             AbstractType::Ptr(new IntegralType(IntegralType::TypeMixed))    // No type information, use mixed
         );
 
         {
             DUChainWriteLocker lock;
             openDeclaration<Declaration>(name, range);
         }
         openType(type);
         closeAndAssignType();
 
         if (QmlJS::FunctionType::Ptr funType = currentType<QmlJS::FunctionType>()) {
             funType->addArgument(type);
         }
     }
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::FunctionDeclaration* node)
 {
     declareFunction<QmlJS::FunctionDeclaration>(
         node,
         true,   // A function declaration always has its own prototype context
         QualifiedIdentifier(node->name.toString()),
         m_session->locationToRange(node->identifierToken),
         node->formals,
         m_session->locationsToRange(node->lparenToken, node->rparenToken),
         node->body,
         m_session->locationsToRange(node->lbraceToken, node->rbraceToken)
     );
 
     return false;
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::FunctionExpression* node)
 {
     declareFunction<QmlJS::FunctionDeclaration>(
         node,
         false,
         QualifiedIdentifier(),
         QmlJS::emptyRangeOnLine(node->functionToken),
         node->formals,
         m_session->locationsToRange(node->lparenToken, node->rparenToken),
         node->body,
         m_session->locationsToRange(node->lbraceToken, node->rbraceToken)
     );
 
     return false;
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::FormalParameterList* node)
 {
     declareParameters(node, (QStringRef QmlJS::AST::FormalParameterList::*)nullptr);
 
     return DeclarationBuilderBase::visit(node);
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::UiParameterList* node)
 {
     declareParameters(node, &QmlJS::AST::UiParameterList::type);
 
     return DeclarationBuilderBase::visit(node);
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::ReturnStatement* node)
 {
     if (QmlJS::FunctionType::Ptr func = currentType<QmlJS::FunctionType>()) {
         AbstractType::Ptr returnType;
 
         if (node->expression) {
             returnType = findType(node->expression).type;
         } else {
             returnType = new IntegralType(IntegralType::TypeVoid);
         }
 
         DUChainWriteLocker lock;
 
         func->setReturnType(QmlJS::mergeTypes(func->returnType(), returnType));
     }
 
     return false;   // findType has already explored node
 }
 
 void DeclarationBuilder::endVisitFunction()
 {
     QmlJS::FunctionType::Ptr func = currentType<QmlJS::FunctionType>();
 
     if (func && !func->returnType()) {
         // A function that returns nothing returns void
         DUChainWriteLocker lock;
 
         func->setReturnType(AbstractType::Ptr(new IntegralType(IntegralType::TypeVoid)));
     }
 
     closeAndAssignType();
 }
 
 void DeclarationBuilder::endVisit(QmlJS::AST::FunctionDeclaration* node)
 {
     DeclarationBuilderBase::endVisit(node);
 
     endVisitFunction();
 }
 
 void DeclarationBuilder::endVisit(QmlJS::AST::FunctionExpression* node)
 {
     DeclarationBuilderBase::endVisit(node);
 
     endVisitFunction();
 }
 
 /*
  * Variables
  */
 void DeclarationBuilder::inferArgumentsFromCall(QmlJS::AST::Node* base, QmlJS::AST::ArgumentList* arguments)
 {
     ContextBuilder::ExpressionType expr = findType(base);
     QmlJS::FunctionType::Ptr func_type = QmlJS::FunctionType::Ptr::dynamicCast(expr.type);
     DUChainWriteLocker lock;
 
     if (!func_type) {
         return;
     }
 
     auto func_declaration = dynamic_cast<FunctionDeclaration*>(func_type->declaration(topContext()));
 
     if (!func_declaration || !func_declaration->internalContext()) {
         return;
     }
 
     // Put the argument nodes in a list that has a definite size
     QVector<Declaration *> argumentDecls = func_declaration->internalContext()->localDeclarations();
     QVector<QmlJS::AST::ArgumentList *> args;
 
     for (auto argument = arguments; argument; argument = argument->next) {
         args.append(argument);
     }
 
     // Don't update a function when it is called with the wrong number
     // of arguments
     if (args.size() != argumentDecls.count()) {
         return;
     }
 
     // Update the types of the function arguments
     QmlJS::FunctionType::Ptr new_func_type(new QmlJS::FunctionType);
 
     for (int i=0; i<args.size(); ++i) {
         QmlJS::AST::ArgumentList *argument = args.at(i);
         AbstractType::Ptr current_type = argumentDecls.at(i)->abstractType();
 
         // Merge the current type of the argument with its type in the call expression
         AbstractType::Ptr call_type = findType(argument->expression).type;
         AbstractType::Ptr new_type = QmlJS::mergeTypes(current_type, call_type);
 
         // Update the declaration of the argument and its type in the function type
         if (func_declaration->topContext() == topContext()) {
             new_func_type->addArgument(new_type);
             argumentDecls.at(i)->setAbstractType(new_type);
         }
 
         // Add a warning if it is possible that the argument types don't match
         if (!m_prebuilding && !areTypesEqual(current_type, call_type)) {
             m_session->addProblem(argument, i18n(
                 "Possible type mismatch between the argument type (%1) and the value passed as argument (%2)",
                 current_type->toString(),
                 call_type->toString()
             ), IProblem::Hint);
         }
     }
 
     // Replace the function's type with the new type having updated arguments
     if (func_declaration->topContext() == topContext()) {
         new_func_type->setReturnType(func_type->returnType());
         new_func_type->setDeclaration(func_declaration);
         func_declaration->setAbstractType(new_func_type.cast<AbstractType>());
 
         if (expr.declaration) {
             // expr.declaration is the variable that contains the function, while
             // func_declaration is the declaration of the function. They can be
             // different and both need to be updated
             expr.declaration->setAbstractType(new_func_type.cast<AbstractType>());
         }
     }
 
     return;
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::VariableDeclaration* node)
 {
     setComment(m_session->commentForLocation(node->firstSourceLocation()).toUtf8());
 
     const QualifiedIdentifier name(node->name.toString());
     const RangeInRevision range = m_session->locationToRange(node->identifierToken);
     const AbstractType::Ptr type = findType(node->expression).type;
 
     {
         DUChainWriteLocker lock;
         openDeclaration<Declaration>(name, range);
     }
     openType(type);
 
     return false;   // findType has already explored node
 }
 
 void DeclarationBuilder::endVisit(QmlJS::AST::VariableDeclaration* node)
 {
     DeclarationBuilderBase::endVisit(node);
 
     closeAndAssignType();
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::BinaryExpression* node)
 {
     if (node->op == QSOperator::Assign) {
         ExpressionType leftType = findType(node->left);
         ExpressionType rightType = findType(node->right);
         DUChainWriteLocker lock;
 
         if (leftType.declaration) {
             DUContext* leftCtx = leftType.declaration->context();
             DUContext* leftInternalCtx = QmlJS::getInternalContext(leftType.declaration);
 
             // object.prototype.method = function(){} : when assigning a function
             // to a variable living in a Class context, set the prototype
             // context of the function to the context of the variable
             if (rightType.declaration && leftCtx->type() == DUContext::Class) {
                 auto func = rightType.declaration.dynamicCast<QmlJS::FunctionDeclaration>();
 
                 if (!QmlJS::getOwnerOfContext(leftCtx) && !leftCtx->importers().isEmpty()) {
                     // MyClass.prototype.myfunc declares "myfunc" in a small context
                     // that is imported by MyClass. The prototype of myfunc should
                     // be the context of MyClass, not the small context in which
                     // it has been declared
                     leftCtx = leftCtx->importers().at(0);
                 }
 
                 if (func && !func->prototypeContext()) {
                     func->setPrototypeContext(leftCtx);
                 }
             }
 
             if (leftType.declaration->topContext() != topContext()) {
                 // Do not modify a declaration of another file
             } else if (leftType.isPrototype && leftInternalCtx) {
                 // Assigning something to a prototype is equivalent to making it
                 // inherit from a class: "Class.prototype = ClassOrObject;"
                 leftInternalCtx->clearImportedParentContexts();
 
                 QmlJS::importDeclarationInContext(
                     leftInternalCtx,
                     rightType.declaration
                 );
             } else {
                 // Merge the already-known type of the variable with the new one
                 leftType.declaration->setAbstractType(QmlJS::mergeTypes(leftType.type, rightType.type));
             }
         }
 
         return false;   // findType has already explored node
     }
 
     return DeclarationBuilderBase::visit(node);
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::CallExpression* node)
 {
     inferArgumentsFromCall(node->base, node->arguments);
     return false;
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::NewMemberExpression* node)
 {
     inferArgumentsFromCall(node->base, node->arguments);
     return false;
 }
 
 /*
  * Arrays
  */
 void DeclarationBuilder::declareFieldMember(const KDevelop::DeclarationPointer& declaration,
                                             const QString& member,
                                             QmlJS::AST::Node* node,
                                             const QmlJS::AST::SourceLocation& location)
 {
     if (QmlJS::isPrototypeIdentifier(member)) {
         // Don't declare "prototype", this is a special member
         return;
     }
 
     if (!m_session->allDependenciesSatisfied()) {
         // Don't declare anything automatically if dependencies are missing: the
         // checks hereafter may pass now but fail later, thus causing disappearing
         // declarations
         return;
     }
 
     DUChainWriteLocker lock;
     QualifiedIdentifier identifier(member);
 
     // Declaration must have an internal context so that the member can be added
     // into it.
     DUContext* ctx = QmlJS::getInternalContext(declaration);
 
     if (!ctx || ctx->topContext() != topContext()) {
         return;
     }
 
     // No need to re-declare a field if it already exists
     if (QmlJS::getDeclaration(identifier, ctx, false)) {
         return;
     }
 
     // The internal context of declaration is already closed and does not contain
     // location. This can be worked around by opening a new context, declaring the
     // new field in it, and then adding the context as a parent of
     // declaration->internalContext().
     RangeInRevision range = m_session->locationToRange(location);
     IntegralType::Ptr type = IntegralType::Ptr(new IntegralType(IntegralType::TypeMixed));
     DUContext* importedContext = openContext(node, range, DUContext::Class);
     Declaration* decl = openDeclaration<Declaration>(identifier, range);
 
     decl->setInSymbolTable(false);  // This declaration is in an anonymous context, and the symbol table acts as if the declaration was in the global context
     openType(type);
     closeAndAssignType();
     closeContext();
 
     ctx->addImportedParentContext(importedContext);
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::FieldMemberExpression* node)
 {
     setComment(m_session->commentForLocation(node->firstSourceLocation()).toUtf8());
 
     ExpressionType type = findType(node->base);
 
     if (type.declaration) {
         declareFieldMember(
             type.declaration,
             node->name.toString(),
             node,
             node->identifierToken
         );
     }
 
     return false;       // findType has already visited node->base
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::ArrayMemberExpression* node)
 {
     setComment(m_session->commentForLocation(node->firstSourceLocation()).toUtf8());
 
     // When the user types array["new_key"], declare "new_key" as a new field of
     // array.
     auto stringLiteral = QmlJS::AST::cast<QmlJS::AST::StringLiteral*>(node->expression);
 
     if (!stringLiteral) {
         return DeclarationBuilderBase::visit(node);
     }
 
     ExpressionType type = findType(node->base);
 
     if (type.declaration) {
         declareFieldMember(
             type.declaration,
             stringLiteral->value.toString(),
             node,
             stringLiteral->literalToken
         );
     }
 
     node->expression->accept(this);
     return false;       // findType has already visited node->base, and we have just visited node->expression
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::ObjectLiteral* node)
 {
     setComment(m_session->commentForLocation(node->firstSourceLocation()).toUtf8());
 
     // Object literals can appear in the "values" property of enumerations. Their
     // keys must be declared in the enumeration, not in an anonymous class
     if (currentContext()->type() == DUContext::Enum) {
         return DeclarationBuilderBase::visit(node);
     }
 
     // Open an anonymous class declaration, with its internal context
     StructureType::Ptr type(new StructureType);
     {
         DUChainWriteLocker lock;
         ClassDeclaration* decl = openDeclaration<ClassDeclaration>(
             QualifiedIdentifier(),
             QmlJS::emptyRangeOnLine(node->lbraceToken)
         );
 
         decl->setKind(Declaration::Type);
         decl->setInternalContext(openContext(
             node,
             m_session->locationsToRange(node->lbraceToken, node->rbraceToken),
             DUContext::Class
         ));
 
         type->setDeclaration(decl);
 
         // Every object literal inherits from Object
         QmlJS::importObjectContext(currentContext(), topContext());
     }
     openType(type);
 
     return DeclarationBuilderBase::visit(node);
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::PropertyNameAndValue* node)
 {
     setComment(node);
 
     if (!node->name || !node->value) {
         return DeclarationBuilderBase::visit(node);
     }
 
     RangeInRevision range(m_session->locationToRange(node->name->propertyNameToken));
     QualifiedIdentifier name(QmlJS::getNodeValue(node->name));
 
     // The type of the declaration can either be an enumeration value or the type
     // of its expression
     ExpressionType type;
     bool inSymbolTable = false;
 
     if (currentContext()->type() == DUContext::Enum) {
         // This is an enumeration value
         auto value = QmlJS::AST::cast<QmlJS::AST::NumericLiteral*>(node->value);
         EnumeratorType::Ptr enumerator(new EnumeratorType);
 
         enumerator->setDataType(IntegralType::TypeInt);
 
         if (value) {
             enumerator->setValue((int)value->value);
         }
 
         type.type = AbstractType::Ptr::staticCast(enumerator);
         type.declaration = nullptr;
         inSymbolTable = true;
     } else {
         // Normal value
         type = findType(node->value);
     }
 
     // If a function is assigned to an object member, set the prototype context
     // of the function to the object containing the member
     if (type.declaration) {
         DUChainWriteLocker lock;
         auto func = type.declaration.dynamicCast<QmlJS::FunctionDeclaration>();
 
         if (func && !func->prototypeContext()) {
             func->setPrototypeContext(currentContext());
         }
     }
 
     // Open the declaration
     {
         DUChainWriteLocker lock;
         ClassMemberDeclaration* decl = openDeclaration<ClassMemberDeclaration>(name, range);
 
         decl->setInSymbolTable(inSymbolTable);
     }
     openType(type.type);
 
     return false;   // findType has already explored node->expression
 }
 
 void DeclarationBuilder::endVisit(QmlJS::AST::PropertyNameAndValue* node)
 {
     DeclarationBuilderBase::endVisit(node);
 
     closeAndAssignType();
 }
 
 void DeclarationBuilder::endVisit(QmlJS::AST::ObjectLiteral* node)
 {
     DeclarationBuilderBase::endVisit(node);
 
     if (currentContext()->type() != DUContext::Enum) {
         // Enums are special-cased in visit(ObjectLiteral)
         closeContext();
         closeAndAssignType();
     }
 }
 
 /*
  * plugins.qmltypes files
  */
 void DeclarationBuilder::declareComponent(QmlJS::AST::UiObjectInitializer* node,
                                           const RangeInRevision &range,
                                           const QualifiedIdentifier &name)
 {
     QString baseClass = QmlJS::getQMLAttributeValue(node->members, "prototype").value.section('/', -1, -1);
 
     // Declare the component itself
     StructureType::Ptr type(new StructureType);
 
     ClassDeclaration* decl;
     {
         DUChainWriteLocker lock;
         decl = openDeclaration<ClassDeclaration>(name, range);
 
         decl->setKind(Declaration::Type);
         decl->setClassType(ClassDeclarationData::Interface);
         decl->clearBaseClasses();
 
         if (!baseClass.isNull()) {
             addBaseClass(decl, baseClass);
         }
 
         type->setDeclaration(decl);
         decl->setType(type);            // declareExports needs to know the type of decl
     }
     openType(type);
 }
 
 void DeclarationBuilder::declareMethod(QmlJS::AST::UiObjectInitializer* node,
                                        const RangeInRevision &range,
                                        const QualifiedIdentifier &name,
                                        bool isSlot,
                                        bool isSignal)
 {
     QString type_name = QmlJS::getQMLAttributeValue(node->members, "type").value;
     QmlJS::FunctionType::Ptr type(new QmlJS::FunctionType);
 
     if (type_name.isNull()) {
         type->setReturnType(typeFromName("void"));
     } else {
         type->setReturnType(typeFromName(type_name));
     }
 
     {
         DUChainWriteLocker lock;
         ClassFunctionDeclaration* decl = openDeclaration<ClassFunctionDeclaration>(name, range);
 
         decl->setIsSlot(isSlot);
         decl->setIsSignal(isSignal);
         type->setDeclaration(decl);
     }
     openType(type);
 }
 
 void DeclarationBuilder::declareProperty(QmlJS::AST::UiObjectInitializer* node,
                                          const RangeInRevision &range,
                                          const QualifiedIdentifier &name)
 {
     AbstractType::Ptr type = typeFromName(QmlJS::getQMLAttributeValue(node->members, "type").value);
 
     {
         DUChainWriteLocker lock;
         ClassMemberDeclaration* decl = openDeclaration<ClassMemberDeclaration>(name, range);
 
         decl->setAbstractType(type);
     }
     openType(type);
 }
 
 void DeclarationBuilder::declareParameter(QmlJS::AST::UiObjectInitializer* node,
                                           const RangeInRevision &range,
                                           const QualifiedIdentifier &name)
 {
     QmlJS::FunctionType::Ptr function = currentType<QmlJS::FunctionType>();
     AbstractType::Ptr type = typeFromName(QmlJS::getQMLAttributeValue(node->members, "type").value);
 
     Q_ASSERT(function);
     function->addArgument(type);
 
     {
         DUChainWriteLocker lock;
         openDeclaration<Declaration>(name, range);
     }
     openType(type);
 }
 
 void DeclarationBuilder::declareEnum(const RangeInRevision &range,
                                      const QualifiedIdentifier &name)
 {
     EnumerationType::Ptr type(new EnumerationType);
 
     {
         DUChainWriteLocker lock;
         ClassMemberDeclaration* decl = openDeclaration<ClassMemberDeclaration>(name, range);
 
         decl->setKind(Declaration::Type);
         decl->setType(type);                // The type needs to be set here because closeContext is called before closeAndAssignType and needs to know the type of decl
 
         type->setDataType(IntegralType::TypeEnumeration);
         type->setDeclaration(decl);
     }
     openType(type);
 }
 
 void DeclarationBuilder::declareComponentSubclass(QmlJS::AST::UiObjectInitializer* node,
                                                   const KDevelop::RangeInRevision& range,
                                                   const QString& baseclass,
                                                   QmlJS::AST::UiQualifiedId* qualifiedId)
 {
     QualifiedIdentifier name(
         QmlJS::getQMLAttributeValue(node->members, "name").value.section('/', -1, -1)
     );
     DUContext::ContextType contextType = DUContext::Class;
 
     if (baseclass == QLatin1String("Component")) {
         // QML component, equivalent to a QML class
         declareComponent(node, range, name);
     } else if (baseclass == QLatin1String("Method") ||
                baseclass == QLatin1String("Signal") ||
                baseclass == QLatin1String("Slot")) {
         // Method (that can also be a signal or a slot)
         declareMethod(node, range, name, baseclass == QLatin1String("Slot"), baseclass == QLatin1String("Signal"));
         contextType = DUContext::Function;
     } else if (baseclass == QLatin1String("Property")) {
         // A property
         declareProperty(node, range, name);
     } else if (baseclass == QLatin1String("Parameter") && currentType<QmlJS::FunctionType>()) {
         // One parameter of a signal/slot/method
         declareParameter(node, range, name);
     } else if (baseclass == QLatin1String("Enum")) {
         // Enumeration. The "values" key contains a dictionary of name -> number entries.
         declareEnum(range, name);
         contextType = DUContext::Enum;
         name = QualifiedIdentifier();   // Enum contexts should have no name so that their members have the correct scope
     } else {
         // Define an anonymous subclass of the baseclass. This subclass will
         // be instantiated when "id:" is encountered
         name = QualifiedIdentifier();
 
         // Use ExpressionVisitor to find the declaration of the base class
         DeclarationPointer baseClass = findType(qualifiedId).declaration;
         StructureType::Ptr type(new StructureType);
 
         {
             DUChainWriteLocker lock;
             ClassDeclaration* decl = openDeclaration<ClassDeclaration>(
                 currentContext()->type() == DUContext::Global ?
                     QualifiedIdentifier(m_session->moduleName()) :
                     name,
                 QmlJS::emptyRangeOnLine(node->lbraceToken)
             );
 
             decl->clearBaseClasses();
             decl->setKind(Declaration::Type);
             decl->setType(type);                // The class needs to know its type early because it contains definitions that depend on that type
             type->setDeclaration(decl);
 
             if (baseClass) {
                 addBaseClass(decl, baseClass->indexedType());
             }
         }
         openType(type);
     }
 
     // Open a context of the proper type and identifier
     openContext(
         node,
         m_session->locationsToInnerRange(node->lbraceToken, node->rbraceToken),
         contextType,
         name
     );
 
     DUContext* ctx = currentContext();
     Declaration* decl = currentDeclaration();
 
     {
         // Set the inner context of the current declaration, because nested classes
         // need to know the inner context of their parents
         DUChainWriteLocker lock;
 
         decl->setInternalContext(ctx);
 
         if (contextType == DUContext::Enum) {
             ctx->setPropagateDeclarations(true);
         }
     }
 
     // If we have have declared a class, import the context of its base classes
     registerBaseClasses();
 }
 
 void DeclarationBuilder::declareComponentInstance(QmlJS::AST::ExpressionStatement* expression)
 {
     if (!expression) {
         return;
     }
 
     auto identifier = QmlJS::AST::cast<QmlJS::AST::IdentifierExpression *>(expression->expression);
 
     if (!identifier) {
         return;
     }
 
     {
         DUChainWriteLocker lock;
 
         injectContext(topContext());
         Declaration* decl = openDeclaration<Declaration>(
             QualifiedIdentifier(identifier->name.toString()),
             m_session->locationToRange(identifier->identifierToken)
         );
         closeInjectedContext();
 
         // Put the declaration in the global scope
         decl->setKind(Declaration::Instance);
         decl->setType(currentAbstractType());
     }
     closeDeclaration();
 }
 
 DeclarationBuilder::ExportLiteralsAndNames DeclarationBuilder::exportedNames(QmlJS::AST::ExpressionStatement* exports)
 {
     ExportLiteralsAndNames res;
 
     if (!exports) {
         return res;
     }
 
     auto exportslist = QmlJS::AST::cast<QmlJS::AST::ArrayLiteral*>(exports->expression);
 
     if (!exportslist) {
         return res;
     }
 
     // Explore all the exported symbols for this component and keep only those
     // having a version compatible with the one of this module
     QSet<QString> knownNames;
 
     for (auto it = exportslist->elements; it && it->expression; it = it->next) {
         auto stringliteral = QmlJS::AST::cast<QmlJS::AST::StringLiteral *>(it->expression);
 
         if (!stringliteral) {
             continue;
         }
 
         // String literal like "Namespace/Class version".
         QStringList nameAndVersion = stringliteral->value.toString().section('/', -1, -1).split(' ');
         QString name = nameAndVersion.at(0);
         QString version = (nameAndVersion.count() > 1 ? nameAndVersion.at(1) : QLatin1String("1.0"));
 
         if (!knownNames.contains(name)) {
             knownNames.insert(name);
             res.append(qMakePair(stringliteral, name));
         }
     }
 
     return res;
 }
 
 
 void DeclarationBuilder::declareExports(const ExportLiteralsAndNames& exports,
                                         ClassDeclaration* classdecl)
 {
     DUChainWriteLocker lock;
 
     // Create the exported versions of the component
     for (auto exp : exports) {
         QmlJS::AST::StringLiteral* literal = exp.first;
         QString name = exp.second;
         StructureType::Ptr type(new StructureType);
 
         injectContext(currentContext()->parentContext());   // Don't declare the export in its C++-ish component, but in the scope above
         ClassDeclaration* decl = openDeclaration<ClassDeclaration>(
             QualifiedIdentifier(name),
             m_session->locationToRange(literal->literalToken)
         );
         closeInjectedContext();
 
         // The exported version inherits from the C++ component
         decl->setKind(Declaration::Type);
         decl->setClassType(ClassDeclarationData::Class);
         decl->clearBaseClasses();
         type->setDeclaration(decl);
 
         addBaseClass(decl, classdecl->indexedType());
 
         // Open a context for the exported class, and register its base class in it
         decl->setInternalContext(openContext(
             literal,
             DUContext::Class,
             QualifiedIdentifier(name)
         ));
         registerBaseClasses();
         closeContext();
 
         openType(type);
         closeAndAssignType();
     }
 }
 
 /*
  * UI
  */
 void DeclarationBuilder::importDirectory(const QString& directory, QmlJS::AST::UiImport* node)
 {
     DUChainWriteLocker lock;
     QString currentFilePath = currentContext()->topContext()->url().str();
     QFileInfo dir(directory);
     QFileInfoList entries;
 
     if (dir.isDir()) {
         // Import all the files in the given directory
         entries = QDir(directory).entryInfoList(
             QStringList()
                 << (QLatin1String("*.") + currentFilePath.section(QLatin1Char('.'), -1, -1))
                 << QLatin1String("*.qmltypes")
                 << QLatin1String("*.so"),
             QDir::Files
         );
     } else if (dir.isFile()) {
         // Import the specific file given in the import statement
         entries.append(dir);
     } else if (!m_prebuilding) {
         m_session->addProblem(node, i18n("Module not found, some types or properties may not be recognized"));
         return;
     }
 
     // Translate the QFileInfos into QStrings (and replace .so files with
     // qmlplugindump dumps)
     lock.unlock();
     QStringList filePaths = QmlJS::Cache::instance().getFileNames(entries);
     lock.lock();
 
     if (node && !node->importId.isEmpty()) {
         // Open a namespace that will contain the declarations
         QualifiedIdentifier identifier(node->importId.toString());
         RangeInRevision range = m_session->locationToRange(node->importIdToken);
 
         Declaration* decl = openDeclaration<Declaration>(identifier, range);
         decl->setKind(Declaration::Namespace);
         decl->setInternalContext(openContext(node, range, DUContext::Class, identifier));
     }
 
     for (const QString& filePath : filePaths) {
         if (filePath == currentFilePath) {
             continue;
         }
 
         ReferencedTopDUContext context = m_session->contextOfFile(filePath);
 
         if (context) {
             currentContext()->addImportedParentContext(context.data());
         }
     }
 
     if (node && !node->importId.isEmpty()) {
         // Close the namespace containing the declarations
         closeContext();
         closeDeclaration();
     }
 }
 
 void DeclarationBuilder::importModule(QmlJS::AST::UiImport* node)
 {
     QmlJS::AST::UiQualifiedId *part = node->importUri;
     QString uri;
 
     while (part) {
         if (!uri.isEmpty()) {
             uri.append('.');
         }
 
         uri.append(part->name.toString());
         part = part->next;
     }
 
     // Version of the import
     QString version = m_session->symbolAt(node->versionToken);
 
     // Import the directory containing the module
     QString modulePath = QmlJS::Cache::instance().modulePath(m_session->url(), uri, version);
     importDirectory(modulePath, node);
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::UiImport* node)
 {
     if (node->importUri) {
         importModule(node);
     } else if (!node->fileName.isNull() && node->fileName != QLatin1String(".")) {
         QUrl currentFileUrl = currentContext()->topContext()->url().toUrl();
         QUrl importUrl = QUrl(node->fileName.toString());
 
         importDirectory(currentFileUrl.resolved(importUrl).toLocalFile(), node);
     }
 
     return DeclarationBuilderBase::visit(node);
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::UiObjectDefinition* node)
 {
     setComment(node);
 
     // Do not crash if the user has typed an empty object definition
     if (!node->initializer || !node->initializer->members) {
         m_skipEndVisit.push(true);
         return DeclarationBuilderBase::visit(node);
     }
 
     RangeInRevision range(m_session->locationToRange(node->qualifiedTypeNameId->identifierToken));
     QString baseclass = node->qualifiedTypeNameId->name.toString();
 
     // "Component" needs special care: a component that appears only in a future
     // version of this module, or that already appeared in a former version, must
     // be skipped because it is useless
     ExportLiteralsAndNames exports;
 
     if (baseclass == QLatin1String("Component")) {
         QmlJS::AST::Statement* statement = QmlJS::getQMLAttribute(node->initializer->members, QLatin1String("exports"));
 
         exports = exportedNames(QmlJS::AST::cast<QmlJS::AST::ExpressionStatement *>(statement));
 
         if (statement && exports.count() == 0) {
             // This component has an "exports:" member but no export matched
             // the version of this module. Skip the component
             m_skipEndVisit.push(true);
             return false;
         }
     } else if (baseclass == QLatin1String("Module")) {
         // "Module" is disabled. This allows the declarations of a module
         // dump to appear in the same namespace as the .qml files in the same
         // directory.
         m_skipEndVisit.push(true);
         return true;
     }
 
     // Declare the component subclass
     declareComponentSubclass(node->initializer, range, baseclass, node->qualifiedTypeNameId);
 
     // If we had a component with exported names, declare these exports
     if (baseclass == QLatin1String("Component")) {
         ClassDeclaration* classDecl = currentDeclaration<ClassDeclaration>();
 
         if (classDecl) {
             declareExports(exports, classDecl);
         }
     }
 
     m_skipEndVisit.push(false);
     return DeclarationBuilderBase::visit(node);
 }
 
 void DeclarationBuilder::endVisit(QmlJS::AST::UiObjectDefinition* node)
 {
     DeclarationBuilderBase::endVisit(node);
 
     // Do not crash if the user has typed an empty object definition
     if (!m_skipEndVisit.pop()) {
         closeContext();
         closeAndAssignType();
     }
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::UiScriptBinding* node)
 {
     setComment(node);
 
     if (!node->qualifiedId) {
         return DeclarationBuilderBase::visit(node);
     }
 
     // Special-case some binding names
     QString bindingName = node->qualifiedId->name.toString();
 
     if (bindingName == QLatin1String("id")) {
         // Instantiate a QML component: its type is the current type (the anonymous
         // QML class that surrounds the declaration)
         declareComponentInstance(QmlJS::AST::cast<QmlJS::AST::ExpressionStatement *>(node->statement));
     }
 
     // Use ExpressionVisitor to find the signal/property bound
     DeclarationPointer bindingDecl = findType(node->qualifiedId).declaration;
     DUChainPointer<ClassFunctionDeclaration> signal;
 
     // If a Javascript block is used as expression or if the script binding is a
     // slot, open a subcontext so that variables declared in the binding are kept
     // local, and the signal parameters can be visible to the slot
     if ((
             bindingDecl &&
             (signal = bindingDecl.dynamicCast<ClassFunctionDeclaration>()) &&
             signal->isSignal()
         ) ||
         node->statement->kind == QmlJS::AST::Node::Kind_Block) {
 
         openContext(
             node->statement,
             m_session->locationsToInnerRange(
                 node->statement->firstSourceLocation(),
                 node->statement->lastSourceLocation()
             ),
             DUContext::Other
         );
 
         // If this script binding is a slot, import the parameters of its signal
         if (signal && signal->isSignal() && signal->internalContext()) {
             DUChainWriteLocker lock;
 
             currentContext()->addIndirectImport(DUContext::Import(
                 signal->internalContext(),
                 nullptr
             ));
         }
     } else {
         // Check that the type of the value matches the type of the property
         AbstractType::Ptr expressionType = findType(node->statement).type;
         DUChainReadLocker lock;
 
         if (!m_prebuilding && bindingDecl && !areTypesEqual(bindingDecl->abstractType(), expressionType)) {
             m_session->addProblem(node->qualifiedId, i18n(
                 "Mismatch between the value type (%1) and the property type (%2)",
                 expressionType->toString(),
                 bindingDecl->abstractType()->toString()
             ), IProblem::Error);
         }
     }
 
     return DeclarationBuilderBase::visit(node);
 }
 
 void DeclarationBuilder::endVisit(QmlJS::AST::UiScriptBinding* node)
 {
     QmlJS::AST::Visitor::endVisit(node);
 
     // If visit(UiScriptBinding) has opened a context, close it
     if (currentContext()->type() == DUContext::Other) {
         closeContext();
     }
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::UiObjectBinding* node)
 {
     setComment(node);
 
     if (!node->qualifiedId || !node->qualifiedTypeNameId || !node->initializer) {
         return DeclarationBuilderBase::visit(node);
     }
 
     // Declare the component subclass. "Behavior on ... {}" is treated exactly
     // like "Behavior {}".
     RangeInRevision range = m_session->locationToRange(node->qualifiedTypeNameId->identifierToken);
     QString baseclass = node->qualifiedTypeNameId->name.toString();
 
     declareComponentSubclass(node->initializer, range, baseclass, node->qualifiedTypeNameId);
 
     return DeclarationBuilderBase::visit(node);
 }
 
 void DeclarationBuilder::endVisit(QmlJS::AST::UiObjectBinding* node)
 {
     DeclarationBuilderBase::endVisit(node);
 
     if (node->qualifiedId && node->qualifiedTypeNameId && node->initializer) {
         closeContext();
         closeAndAssignType();
     }
 }
 
 bool DeclarationBuilder::visit(QmlJS::AST::UiPublicMember* node)
 {
     setComment(node);
 
     RangeInRevision range = m_session->locationToRange(node->identifierToken);
     QualifiedIdentifier id(node->name.toString());
     QString typeName = node->memberType.toString();
     bool res = DeclarationBuilderBase::visit(node);
 
     // Build the type of the public member
     if (node->type == QmlJS::AST::UiPublicMember::Signal) {
         // Open a function declaration corresponding to this signal
         declareFunction<ClassFunctionDeclaration>(
             node,
             false,
             QualifiedIdentifier(node->name.toString()),
             m_session->locationToRange(node->identifierToken),
             node->parameters,
             m_session->locationToRange(node->identifierToken),  // The AST does not provide the location of the parens
             nullptr,
             m_session->locationToRange(node->identifierToken)   // A body range must be provided
         );
 
         // This declaration is a signal and its return type is void
         {
             DUChainWriteLocker lock;
 
             currentDeclaration<ClassFunctionDeclaration>()->setIsSignal(true);
             currentType<QmlJS::FunctionType>()->setReturnType(typeFromName("void"));
         }
     } else {
         AbstractType::Ptr type;
 
         if (typeName == "alias") {
             // Property aliases take the type of their aliased property
             type = findType(node->statement).type;
             res = false;        // findType has already explored node->statement
         } else {
             type = typeFromName(typeName);
 
             if (node->typeModifier == QLatin1String("list")) {
                 // QML list, noted "list<type>" in the source file
                 ArrayType::Ptr array(new ArrayType);
 
                 array->setElementType(type);
                 type = array.cast<AbstractType>();
             }
         }
 
         {
             DUChainWriteLocker lock;
             Declaration* decl = openDeclaration<ClassMemberDeclaration>(id, range);
 
             decl->setInSymbolTable(false);
         }
         openType(type);
     }
 
     return res;
 }
 
 void DeclarationBuilder::endVisit(QmlJS::AST::UiPublicMember* node)
 {
     DeclarationBuilderBase::endVisit(node);
 
     closeAndAssignType();
 }
 
 /*
  * Utils
  */
 void DeclarationBuilder::setComment(QmlJS::AST::Node* node)
 {
     setComment(m_session->commentForLocation(node->firstSourceLocation()).toUtf8());
 }
 
 void DeclarationBuilder::closeAndAssignType()
 {
     closeType();
     Declaration* dec = currentDeclaration();
     Q_ASSERT(dec);
 
     if (auto type = lastType()) {
         DUChainWriteLocker lock;
         dec->setType(type);
     }
     closeDeclaration();
 }
 
 AbstractType::Ptr DeclarationBuilder::typeFromName(const QString& name)
 {
     auto type = IntegralType::TypeNone;
     QString realName = name;
 
     // Built-in types
     if (name == QLatin1String("string")) {
         type = IntegralType::TypeString;
     } else if (name == QLatin1String("bool")) {
         type = IntegralType::TypeBoolean;
     } else if (name == QLatin1String("int")) {
         type = IntegralType::TypeInt;
     } else if (name == QLatin1String("float")) {
         type = IntegralType::TypeFloat;
     } else if (name == QLatin1String("double") || name == QLatin1String("real")) {
         type = IntegralType::TypeDouble;
     } else if (name == QLatin1String("void")) {
         type = IntegralType::TypeVoid;
     } else if (name == QLatin1String("var") || name == QLatin1String("variant")) {
         type = IntegralType::TypeMixed;
     } else if (m_session->language() == QmlJS::Dialect::Qml) {
         // In QML files, some Qt type names need to be renamed to the QML equivalent
         if (name == QLatin1String("QFont")) {
             realName = QStringLiteral("Font");
         } else if (name == QLatin1String("QColor")) {
             realName = QStringLiteral("color");
         } else if (name == QLatin1String("QDateTime")) {
             realName = QStringLiteral("date");
         } else if (name == QLatin1String("QDate")) {
             realName = QStringLiteral("date");
         } else if (name == QLatin1String("QTime")) {
             realName = QStringLiteral("time");
         } else if (name == QLatin1String("QRect") || name == QLatin1String("QRectF")) {
             realName = QStringLiteral("rect");
         } else if (name == QLatin1String("QPoint") || name == QLatin1String("QPointF")) {
             realName = QStringLiteral("point");
         } else if (name == QLatin1String("QSize") || name == QLatin1String("QSizeF")) {
             realName = QStringLiteral("size");
         } else if (name == QLatin1String("QUrl")) {
             realName = QStringLiteral("url");
         } else if (name == QLatin1String("QVector3D")) {
             realName = QStringLiteral("vector3d");
         } else if (name.endsWith(QLatin1String("ScriptString"))) {
             // Q{Declarative,Qml}ScriptString represents a JS snippet
             auto  func = new QmlJS::FunctionType;
             func->setReturnType(AbstractType::Ptr(new IntegralType(IntegralType::TypeVoid)));
             return AbstractType::Ptr(func);
         }
     }
 
     if (type == IntegralType::TypeNone) {
         // Not a built-in type, but a class
         return typeFromClassName(realName);
     } else {
         return AbstractType::Ptr(new IntegralType(type));
     }
 }
 
 AbstractType::Ptr DeclarationBuilder::typeFromClassName(const QString& name)
 {
     DeclarationPointer decl = QmlJS::getDeclaration(QualifiedIdentifier(name), currentContext());
 
     if (!decl) {
         if (name == QLatin1String("QRegExp")) {
             decl = QmlJS::NodeJS::instance().moduleMember(QStringLiteral("__builtin_ecmascript"), QStringLiteral("RegExp"), currentContext()->url());
         }
     }
 
     if (decl) {
         return decl->abstractType();
     } else {
         DelayedType::Ptr type(new DelayedType);
         type->setKind(DelayedType::Unresolved);
         type->setIdentifier(IndexedTypeIdentifier(name));
         return type;
     }
 }
 
 void DeclarationBuilder::addBaseClass(ClassDeclaration* classDecl, const QString& name)
 {
     addBaseClass(classDecl, IndexedType(typeFromClassName(name)));
 }
 
 void DeclarationBuilder::addBaseClass(ClassDeclaration* classDecl, const IndexedType& type)
 {
     BaseClassInstance baseClass;
 
     baseClass.access = Declaration::Public;
     baseClass.virtualInheritance = false;
     baseClass.baseClass = type;
 
     classDecl->addBaseClass(baseClass);
 }
 
 void DeclarationBuilder::registerBaseClasses()
 {
     ClassDeclaration* classdecl = currentDeclaration<ClassDeclaration>();
     DUContext *ctx = currentContext();
 
     if (classdecl) {
         DUChainWriteLocker lock;
 
         for (uint i=0; i<classdecl->baseClassesSize(); ++i)
         {
             const BaseClassInstance &baseClass = classdecl->baseClasses()[i];
             StructureType::Ptr baseType = StructureType::Ptr::dynamicCast(baseClass.baseClass.abstractType());
             TopDUContext* topctx = topContext();
 
             if (baseType && baseType->declaration(topctx)) {
                 QmlJS::importDeclarationInContext(ctx, DeclarationPointer(baseType->declaration(topctx)));
             }
         }
     }
 }
 
 static bool enumContainsEnumerator(const AbstractType::Ptr& a, const AbstractType::Ptr& b)
 {
     Q_ASSERT(a->whichType() == AbstractType::TypeEnumeration);
     auto aEnum = EnumerationType::Ptr::staticCast(a);
     Q_ASSERT(b->whichType() == AbstractType::TypeEnumerator);
     auto bEnumerator = EnumeratorType::Ptr::staticCast(b);
     return bEnumerator->qualifiedIdentifier().beginsWith(aEnum->qualifiedIdentifier());
 }
 
 static bool isNumeric(const IntegralType::Ptr& type)
 {
     return type->dataType() == IntegralType::TypeInt
         || type->dataType() == IntegralType::TypeIntegral
         || type->dataType() == IntegralType::TypeFloat
         || type->dataType() == IntegralType::TypeDouble;
 }
 
 bool DeclarationBuilder::areTypesEqual(const AbstractType::Ptr& a, const AbstractType::Ptr& b)
 {
     if (!a || !b) {
         return true;
     }
 
     if (a->whichType() == AbstractType::TypeUnsure || b->whichType() == AbstractType::TypeUnsure) {
         // Don't try to guess something if one of the types is unsure
         return true;
     }
 
     const auto bIntegral = IntegralType::Ptr::dynamicCast(b);
     if (bIntegral && (bIntegral->dataType() == IntegralType::TypeString || bIntegral->dataType() == IntegralType::TypeMixed)) {
         // In QML/JS, a string can be converted to nearly everything else, similarly ignore mixed types
         return true;
     }
 
     const auto aIntegral = IntegralType::Ptr::dynamicCast(a);
     if (aIntegral && (aIntegral->dataType() == IntegralType::TypeString || aIntegral->dataType() == IntegralType::TypeMixed)) {
         // In QML/JS, nearly everything can be to a string, similarly ignore mixed types
         return true;
     }
     if (aIntegral && bIntegral) {
         if (isNumeric(aIntegral) && isNumeric(bIntegral)) {
             // Casts between integral types is possible
             return true;
         }
     }
 
     if (a->whichType() == AbstractType::TypeEnumeration && b->whichType() == AbstractType::TypeEnumerator) {
         return enumContainsEnumerator(a, b);
     } else if (a->whichType() == AbstractType::TypeEnumerator && b->whichType() == AbstractType::TypeEnumeration) {
         return enumContainsEnumerator(b, a);
     }
 
     {
         auto aId = dynamic_cast<const IdentifiedType*>(a.constData());
         auto bId = dynamic_cast<const IdentifiedType*>(b.constData());
         if (aId && bId && aId->qualifiedIdentifier() == bId->qualifiedIdentifier())
             return true;
     }
 
     {
         auto aStruct = StructureType::Ptr::dynamicCast(a);
         auto bStruct = StructureType::Ptr::dynamicCast(b);
         if (aStruct && bStruct) {
             auto top = currentContext()->topContext();
             auto aDecl = dynamic_cast<ClassDeclaration*>(aStruct->declaration(top));
             auto bDecl = dynamic_cast<ClassDeclaration*>(bStruct->declaration(top));
             if (aDecl && bDecl) {
                 if (aDecl->isPublicBaseClass(bDecl, top) || bDecl->isPublicBaseClass(aDecl, top)) {
                     return true;
                 }
             }
         }
     }
 
     return a->equals(b.constData());
 }
diff --git a/languages/qmljs/duchain/frameworks/nodejs.cpp b/languages/qmljs/duchain/frameworks/nodejs.cpp
index 41964e443a..f593845842 100644
--- a/languages/qmljs/duchain/frameworks/nodejs.cpp
+++ b/languages/qmljs/duchain/frameworks/nodejs.cpp
@@ -1,215 +1,214 @@
 /*
  * This file is part of qmljs, the QML/JS language support plugin for KDevelop
  * Copyright (c) 2014 Denis Steckelmacher <steckdenis@yahoo.fr>
  *
  * 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 "nodejs.h"
 #include "../helper.h"
 #include "../parsesession.h"
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/types/structuretype.h>
 #include <language/duchain/types/integraltype.h>
 #include <util/path.h>
 
 #include <QFile>
-#include <QDir>
 #include <QStandardPaths>
 
 using namespace KDevelop;
 
 namespace QmlJS {
 
 NodeJS::NodeJS()
 {
 }
 
 NodeJS& NodeJS::instance()
 {
     static NodeJS* i = nullptr;
 
     if (!i) {
         i = new NodeJS();
     }
 
     return *i;
 }
 
 void NodeJS::initialize(DeclarationBuilder* builder)
 {
     QMutexLocker lock(&m_mutex);
 
     // Create "module", a structure that may contain "exports" if the module
     // refers to module.exports
     createObject(QStringLiteral("module"), 1, builder);
 
     // Create "exports", that can also contain the exported symbols of the module
     createObject(QStringLiteral("exports"), 2, builder);
 }
 
 void NodeJS::createObject(const QString& name, int index, DeclarationBuilder* builder)
 {
     QualifiedIdentifier identifier(name);
 
     StructureType::Ptr type(new StructureType);
     Declaration* decl = builder->openDeclaration<Declaration>(identifier, RangeInRevision());
 
     type->setDeclaration(decl);
     decl->setAlwaysForceDirect(true);
     decl->setKind(Declaration::Type);   // Not exactly what the user would expect, but this ensures that QmlJS::getInternalContext does not recurse infinitely
     decl->setInternalContext(builder->openContext(
         (QmlJS::AST::Node*)nullptr + index,                // Index is used to disambiguate the contexts. "node" is never dereferenced and is only stored in a hash table
         RangeInRevision(),
         DUContext::Class,
         identifier
     ));
 
     builder->closeContext();
     builder->openType(type);
     builder->closeAndAssignType();
 }
 
 DeclarationPointer NodeJS::moduleExports(const QString& moduleName, const IndexedString& url)
 {
     QString urlStr = url.str();
     QString fileName = moduleFileName(moduleName, urlStr);
     DeclarationPointer exports;
 
     if (fileName.isEmpty() || urlStr.contains("__builtin_ecmascript.js") || urlStr == fileName) {
         return exports;
     }
 
     ReferencedTopDUContext topContext = ParseSession::contextOfFile(fileName, url, 0);
     DUChainReadLocker lock;
 
     if (topContext) {
         static const QualifiedIdentifier idModule(QStringLiteral("module"));
         static const QualifiedIdentifier idExports(QStringLiteral("exports"));
 
         // Try "module.exports". If this declaration exists, it contains the
         // module's exports
         exports = getDeclaration(idModule, topContext.data());
 
         if (exports && exports->internalContext()) {
             exports = getDeclaration(idExports, exports->internalContext(), false);
         }
 
         // Try "exports", that always exist, has a structure type, and contains
         // the exported symbols
         if (!exports) {
             exports = getDeclaration(idExports, topContext.data());
         }
     }
 
     return exports;
 }
 
 DeclarationPointer NodeJS::moduleMember(const QString& moduleName,
                                         const QString& memberName,
                                         const IndexedString& url)
 {
     DeclarationPointer module = moduleExports(moduleName, url);
     DeclarationPointer member;
 
     if (module) {
         member = QmlJS::getDeclaration(
             QualifiedIdentifier(memberName),
             QmlJS::getInternalContext(module),
             false
         );
     }
 
     return member;
 }
 
 Path::List NodeJS::moduleDirectories(const QString& url)
 {
     Path::List paths;
 
     // QML/JS ships several modules that exist only in binary form in Node.js
     QStringList dirs = QStandardPaths::locateAll(
         QStandardPaths::GenericDataLocation,
         QStringLiteral("kdevqmljssupport/nodejsmodules"),
         QStandardPaths::LocateDirectory
     );
 
     for (auto dir : dirs) {
         paths.append(Path(dir));
     }
 
     // url/../node_modules, then url/../../node_modules, etc
     Path path(url);
     path.addPath(QStringLiteral(".."));
 
     while (path.segments().size() > 1) {
         paths.append(path.cd(QStringLiteral("node_modules")));
         path.addPath(QStringLiteral(".."));
     }
 
     return paths;
 }
 
 QString NodeJS::moduleFileName(const QString& moduleName, const QString& url)
 {
     QMutexLocker lock(&m_mutex);
     auto pair = qMakePair(moduleName, url);
 
     if (m_cachedModuleFileNames.contains(pair)) {
         return m_cachedModuleFileNames.value(pair);
     }
 
     QString& fileName = m_cachedModuleFileNames[pair];
 
     // Absolue and relative URLs
     if (moduleName.startsWith(QLatin1Char('/')) || moduleName.startsWith(QLatin1Char('.'))) {
         // NOTE: This is not portable to Windows, but the Node.js documentation
         // only talks about module names that start with /, ./ and ../ .
         fileName = fileOrDirectoryPath(Path(url).cd(QStringLiteral("..")).cd(moduleName).toLocalFile());
         return fileName;
     }
 
     // Try all the paths that might contain modules
     for (auto path : moduleDirectories(url)) {
         fileName = fileOrDirectoryPath(path.cd(moduleName).toLocalFile());
 
         if (!fileName.isNull()) {
             break;
         }
     }
 
     return fileName;
 }
 
 QString NodeJS::fileOrDirectoryPath(const QString& baseName)
 {
     if (QFile::exists(baseName)) {
         return baseName;
     } else if (QFile::exists(baseName + QLatin1String(".js"))) {
         return baseName + QLatin1String(".js");
     } else if (QFile::exists(baseName + QLatin1String("/index.js"))) {
         // TODO: package.json files currently not supported
         return baseName + QLatin1String("/index.js");
     }
 
     return QString();
 }
 
 }
diff --git a/languages/qmljs/duchain/tests/test_qmljscontexts.cpp b/languages/qmljs/duchain/tests/test_qmljscontexts.cpp
index 5ccb8c8f7c..e1a5e2a0fe 100644
--- a/languages/qmljs/duchain/tests/test_qmljscontexts.cpp
+++ b/languages/qmljs/duchain/tests/test_qmljscontexts.cpp
@@ -1,146 +1,146 @@
 /*
  * This file is part of KDevelop
  * Copyright 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 "test_qmljscontexts.h"
 
 #include "../helper.h"
 #include "../parsesession.h"
 #include "../declarationbuilder.h"
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/testhelpers.h>
 
-#include <QtTest>
+#include <QTest>
 
 QTEST_GUILESS_MAIN(TestContexts);
 
 using namespace KDevelop;
 
 void TestContexts::initTestCase()
 {
     AutoTestShell::init();
     TestCore::initialize(Core::NoUi);
 
     QmlJS::registerDUChainItems();
 }
 
 void TestContexts::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestContexts::testFunctionContext()
 {
     QFETCH(QString, code);
     QFETCH(RangeInRevision, argCtxRange);
     QFETCH(RangeInRevision, bodyCtxRange);
 
     const IndexedString file(QUrl(QString("file:///internal/%1-functionContext.js").arg(qrand())));
     ParseSession session(file, code, 0);
     QVERIFY(session.ast());
     QCOMPARE(session.language().dialect(), QmlJS::Dialect::JavaScript);
 
     DeclarationBuilder builder(&session);
     ReferencedTopDUContext top = builder.build(file, session.ast());
     QVERIFY(top);
 
     DUChainReadLocker lock;
 
     QCOMPARE(top->type(), DUContext::Global);
 
     // the function arguments (containing the prototype context and the function body)
     QCOMPARE(top->childContexts().count(), 3);        // module, exports, the function
 
     DUContext* argCtx = top->childContexts().at(2);
     QCOMPARE(argCtx->type(), DUContext::Function);
     QCOMPARE(argCtx->range(), argCtxRange);
     QCOMPARE(argCtx->childContexts().size(), 2);    // The prototype context then the body context
 
     DUContext* bodyCtx = argCtx->childContexts().at(1);
     QVERIFY(bodyCtx);
     QCOMPARE(bodyCtx->type(), DUContext::Other);
     QCOMPARE(bodyCtx->range(), bodyCtxRange);
 }
 
 void TestContexts::testFunctionContext_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<RangeInRevision>("argCtxRange");
     QTest::addColumn<RangeInRevision>("bodyCtxRange");
     //                         0         1
     //                         012345678901234567890
     QTest::newRow("empty") << "function foo() {;}"
                            << RangeInRevision(0, 12, 0, 18)
                            << RangeInRevision(0, 15, 0, 18);
 
     //                        0         1         2         3
     //                        01234567890123456789012345678901234567890
     QTest::newRow("args") << "function foo(arg1, arg2, arg3) {;}"
                            << RangeInRevision(0, 12, 0, 34)
                            << RangeInRevision(0, 31, 0, 34);
 
     //                           0         1         2
     //                           0123456789012345678901234567890
     QTest::newRow("newline") << "function foo() {;\n}"
                            << RangeInRevision(0, 12, 1, 1)
                            << RangeInRevision(0, 15, 1, 1);
 }
 
 void TestContexts::testQMLContext()
 {
     const IndexedString file(QUrl("file:///internal/testQMLContext.qml"));
     ParseSession session(file, "Text {\n"
                                "  id: main\n"
                                "  Text {\n"
                                "    id: child1\n"
                                "  }\n"
                                "  Text {\n"
                                "    id: child2\n"
                                "  }\n"
                                "}\n", 0);
     QVERIFY(session.ast());
     QCOMPARE(session.language().dialect(), QmlJS::Dialect::Qml);
 
     DeclarationBuilder builder(&session);
     ReferencedTopDUContext top = builder.build(file, session.ast());
     QVERIFY(top);
 
     DUChainReadLocker lock;
 
     QCOMPARE(top->type(), DUContext::Global);
 
     QCOMPARE(top->childContexts().count(), 3);        // module, exports, Text
     DUContext* mainCtx = top->childContexts().at(2);
     QCOMPARE(mainCtx->type(), DUContext::Class);
     QCOMPARE(mainCtx->range(), RangeInRevision(0, 6, 8, 0));
     QCOMPARE(mainCtx->childContexts().size(), 2);
 
     DUContext* child1Ctx = mainCtx->childContexts().first();
     QCOMPARE(child1Ctx->type(), DUContext::Class);
     QCOMPARE(child1Ctx->range(), RangeInRevision(2, 8, 4, 2));
     QCOMPARE(child1Ctx->childContexts().size(), 0);
 
     DUContext* child2Ctx = mainCtx->childContexts().last();
     QCOMPARE(child2Ctx->type(), DUContext::Class);
     QCOMPARE(child2Ctx->range(), RangeInRevision(5, 8, 7, 2));
     QCOMPARE(child2Ctx->childContexts().size(), 0);
 }
diff --git a/languages/qmljs/duchain/tests/test_qmljsdeclarations.cpp b/languages/qmljs/duchain/tests/test_qmljsdeclarations.cpp
index dc90925387..2e8af4bf27 100644
--- a/languages/qmljs/duchain/tests/test_qmljsdeclarations.cpp
+++ b/languages/qmljs/duchain/tests/test_qmljsdeclarations.cpp
@@ -1,288 +1,288 @@
 /*
  * This file is part of KDevelop
  * Copyright 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 "test_qmljsdeclarations.h"
 
 #include "../helper.h"
 #include "../parsesession.h"
 #include "../declarationbuilder.h"
 #include "../cache.h"
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/testhelpers.h>
 
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/problem.h>
 #include <language/duchain/classdeclaration.h>
 
-#include <QtTest>
+#include <QTest>
 
 QTEST_GUILESS_MAIN(TestDeclarations);
 
 using namespace KDevelop;
 
 void TestDeclarations::initTestCase()
 {
     AutoTestShell::init({"kdevqmljslanguagesupport"});
     TestCore::initialize(Core::NoUi);
 
     QmlJS::registerDUChainItems();
 }
 
 void TestDeclarations::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestDeclarations::testJSProblems()
 {
     const IndexedString file(QUrl("file:///internal/jsproblems.js"));
     ParseSession session(file,
         "function f(a) {}\n"
         "f(2);\n"
         "f(true);\n",
     0);
 
     QVERIFY(session.ast());
     DeclarationBuilder builder(&session);
 
     builder.build(file, session.ast());
     auto problems = session.problems();
 
     QCOMPARE(problems.count(), 1);
     QCOMPARE((KTextEditor::Range)problems.at(0)->finalLocation(), KTextEditor::Range(2, 2, 2, 6));
 }
 
 void TestDeclarations::testFunction()
 {
     const IndexedString file(QUrl("file:///internal/functionArgs.js"));
     //                          0         1         2         3
     //                          01234567890123456789012345678901234567890
     ParseSession session(file, "/**\n * some comment\n */\n"
                                "function foo(arg1, arg2, arg3) { var i = 0; }", 0);
     QVERIFY(session.ast());
     QVERIFY(session.problems().isEmpty());
     QCOMPARE(session.language().dialect(), QmlJS::Dialect::JavaScript);
 
     DeclarationBuilder builder(&session);
     ReferencedTopDUContext top = builder.build(file, session.ast());
     QVERIFY(top);
 
     DUChainReadLocker lock;
 
     QCOMPARE(top->localDeclarations().size(), 3); // module, exports and foo
 
     FunctionDeclaration* fooDec = dynamic_cast<FunctionDeclaration*>(top->localDeclarations().at(2));
     QVERIFY(fooDec);
     QCOMPARE(fooDec->range(), RangeInRevision(3, 9, 3, 12));
     QCOMPARE(QString::fromUtf8(fooDec->comment()), QString("some comment"));
 
     QVERIFY(fooDec->internalContext());
     DUContext* argCtx = fooDec->internalContext();
     QCOMPARE(argCtx->localDeclarations().size(), 3);
 
     Declaration* arg1 = argCtx->localDeclarations().at(0);
     QCOMPARE(arg1->identifier().toString(), QString("arg1"));
     QCOMPARE(arg1->range(), RangeInRevision(3, 13, 3, 17));
 
     Declaration* arg2 = argCtx->localDeclarations().at(1);
     QCOMPARE(arg2->identifier().toString(), QString("arg2"));
     QCOMPARE(arg2->range(), RangeInRevision(3, 19, 3, 23));
 
     Declaration* arg3 = argCtx->localDeclarations().at(2);
     QCOMPARE(arg3->identifier().toString(), QString("arg3"));
     QCOMPARE(arg3->range(), RangeInRevision(3, 25, 3, 29));
 
     FunctionType::Ptr funType = fooDec->type<FunctionType>();
     QVERIFY(funType);
     QVERIFY(funType->returnType().cast<IntegralType>());
     QCOMPARE(funType->returnType().cast<IntegralType>()->dataType(), (uint) IntegralType::TypeVoid);
 
     QCOMPARE(argCtx->childContexts().size(), 2);
     DUContext* bodyCtx = argCtx->childContexts().at(1);
     QVERIFY(bodyCtx);
     QVERIFY(bodyCtx->findDeclarations(arg1->identifier()).contains(arg1));
     QVERIFY(bodyCtx->findDeclarations(arg2->identifier()).contains(arg2));
     QVERIFY(bodyCtx->findDeclarations(arg3->identifier()).contains(arg3));
 
     QCOMPARE(bodyCtx->localDeclarations().count(), 1);
 }
 
 void TestDeclarations::testQMLId()
 {
     const IndexedString file(QUrl("file:///internal/qmlId.qml"));
 
     ReferencedTopDUContext top;
 
     DeclarationPointer oldDec;
     {
         //                          0         1         2         3
         //                          01234567890123456789012345678901234567890
         ParseSession session(file, "/** file comment **/\n"
                                    "import QtQuick 1.0\n"
                                    "/**\n * some comment\n */\n"
                                    "Text { id: test; Text { id: child; } }", 0);
         QVERIFY(session.ast());
         QVERIFY(session.problems().isEmpty());
         QCOMPARE(session.language().dialect(), QmlJS::Dialect::Qml);
 
         DeclarationBuilder builder(&session);
         top = builder.build(file, session.ast());
         QVERIFY(top);
 
         DUChainReadLocker lock;
 
         QCOMPARE(top->localDeclarations().size(), 5);       // module, exports, Text, test and child are all in the global scope
 
         // First declaration, the anonymous class
         ClassDeclaration* classDecl = dynamic_cast<ClassDeclaration *>(top->localDeclarations().at(2));
         QVERIFY(classDecl);
         QCOMPARE(classDecl->abstractType()->toString(), QString("qmlId"));
         QCOMPARE(classDecl->range(), RangeInRevision(5, 0, 5, 0));
         QVERIFY(classDecl->internalContext());
         QCOMPARE(classDecl->internalContext()->range(), RangeInRevision(5, 6, 5, 37));
 
         // Second declaration: test
         Declaration* dec = top->localDeclarations().at(3);
         QVERIFY(dec);
         QCOMPARE(dec->identifier().toString(), QString("test"));
         QCOMPARE(dec->abstractType()->toString(), QString("qmlId"));
 
         oldDec = dec;
     }
 
     // test recompile
     {
         //                          0         1         2         3
         //                          01234567890123456789012345678901234567890
         ParseSession session(file, "/** file comment **/\n"
                                    "import QtQuick 1.0\n"
                                    "/**\n * some comment\n */\n"
                                    "Text { id: test; Text { id: child;}\n"
                                    " Text {id: foo;} }", 0);
         QVERIFY(session.ast());
         QVERIFY(session.problems().isEmpty());
         QCOMPARE(session.language().dialect(), QmlJS::Dialect::Qml);
 
         DeclarationBuilder builder(&session);
         ReferencedTopDUContext top2 = builder.build(file, session.ast(), top);
         QVERIFY(top2);
         QCOMPARE(top2.data(), top.data());
 
         DUChainReadLocker lock;
 
         QCOMPARE(top->localDeclarations().size(), 6); // module, exports, Text, test, child and foo
         // First declaration, the anonymous class
         ClassDeclaration* classDecl = dynamic_cast<ClassDeclaration *>(top->localDeclarations().at(2));
         QVERIFY(classDecl);
         QCOMPARE(classDecl->abstractType()->toString(), QString("qmlId"));
         QCOMPARE(classDecl->range(), RangeInRevision(5, 0, 5, 0));
         QVERIFY(classDecl->internalContext());
         QCOMPARE(classDecl->internalContext()->range(), RangeInRevision(5, 6, 6, 17));
 
         // Second declaration: test
         Declaration* dec = top->localDeclarations().at(3);
         QVERIFY(dec);
         QCOMPARE(dec->identifier().toString(), QString("test"));
         QCOMPARE(dec->abstractType()->toString(), QString("qmlId"));
     }
 }
 
 void TestDeclarations::testProperty()
 {
     const IndexedString file(QUrl("file:///internal/qmlProperty.qml"));
     //                          0         1         2         3
     //                          01234567890123456789012345678901234567890
     ParseSession session(file, "Text {\n"
                                " /// some comment\n"
                                " property int foo;\n"
                                "}", 0);
     QVERIFY(session.ast());
     QVERIFY(session.problems().isEmpty());
     QCOMPARE(session.language().dialect(), QmlJS::Dialect::Qml);
 
     DeclarationBuilder builder(&session);
     ReferencedTopDUContext top = builder.build(file, session.ast());
     QVERIFY(top);
 
     DUChainReadLocker lock;
 
     QCOMPARE(top->localDeclarations().size(), 3);        // module, exports, Text
     ClassDeclaration* text = dynamic_cast<ClassDeclaration*>(top->localDeclarations().at(2));
     QVERIFY(text);
     QVERIFY(text->internalContext());
     QCOMPARE(text->internalContext()->type(), DUContext::Class);
     QCOMPARE(text->internalContext()->localDeclarations().size(), 1);
     ClassMemberDeclaration* foo = dynamic_cast<ClassMemberDeclaration*>(text->internalContext()->localDeclarations().first());
     QVERIFY(foo);
     QCOMPARE(foo->identifier().toString(), QString("foo"));
     QVERIFY(foo->abstractType());
     QCOMPARE(foo->abstractType()->toString(), QString("int"));
     QCOMPARE(QString::fromUtf8(foo->comment()), QString("some comment"));
 }
 
 /**
  * Test that all qmltypes files for built-in QtQuick modules are found on the system.
  * These files are also available on CI machines, since an installed Qt5 is assumed
  */
 void TestDeclarations::testQMLtypesImportPaths()
 {
     KDevelop::IndexedString stubPath;
     QString path;
 
     // QtQuick QML modules
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtQuick", "2.0");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtTest", "1.1");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtQuick.Layouts", "1.1");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtQuick.Controls", "1.1");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtQuick.Dialogs", "1.1");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtQuick.LocalStorage", "2.0");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtQuick.Particles", "2.0");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtQuick.Window", "2.2");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtQuick.XmlListModel", "2.0");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 
     // QtQml QML modules
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtQml.Models", "2.3");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 
     // QtMultimedia QML modules
     path = QmlJS::Cache::instance().modulePath(stubPath, "QtMultimedia", "5.6");
     QVERIFY(QFileInfo::exists(path + "/plugins.qmltypes"));
 }
diff --git a/languages/qmljs/kdevqmljsplugin.cpp b/languages/qmljs/kdevqmljsplugin.cpp
index 70712bd7a6..7a2d505bc7 100644
--- a/languages/qmljs/kdevqmljsplugin.cpp
+++ b/languages/qmljs/kdevqmljsplugin.cpp
@@ -1,205 +1,204 @@
 /*************************************************************************************
  *  Copyright (C) 2012 by Aleix Pol <aleixpol@kde.org>                               *
  *  Copyright (C) 2012 by Milian Wolff <mail@milianw.de>                             *
  *  Copyright (C) 2013 by Sven Brauch <svenbrauch@gmail.com>                         *
  *                                                                                   *
  *  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 "kdevqmljsplugin.h"
 
 #include "qmljsparsejob.h"
 #include "qmljshighlighting.h"
 #include "codecompletion/model.h"
 #include "navigation/propertypreviewwidget.h"
 #include "duchain/helper.h"
 
 #include <qmljs/qmljsmodelmanagerinterface.h>
 
 #include <KPluginFactory>
-#include <KAboutData>
 
 #include <language/codecompletion/codecompletion.h>
 #include <language/assistant/renameassistant.h>
 #include <language/assistant/staticassistantsmanager.h>
 #include <language/codegen/basicrefactoring.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainutils.h>
 #include <language/interfaces/editorcontext.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/contextmenuextension.h>
 
 #include <QReadWriteLock>
 
 K_PLUGIN_FACTORY_WITH_JSON(KDevQmlJsSupportFactory, "kdevqmljs.json", registerPlugin<KDevQmlJsPlugin>(); )
 
 using namespace KDevelop;
 
 /// TODO: Extend? See qmljsmodelmanager.h in qt-creator.git
 class ModelManager: public QmlJS::ModelManagerInterface
 {
     Q_OBJECT
 
 public:
     explicit ModelManager(QObject *parent = nullptr);
     ~ModelManager() override;
 };
 
 ModelManager::ModelManager(QObject* parent)
     : QmlJS::ModelManagerInterface(parent) {}
 
 ModelManager::~ModelManager() {}
 
 KDevQmlJsPlugin::KDevQmlJsPlugin(QObject* parent, const QVariantList& )
 : IPlugin(QLatin1String("kdevqmljssupport"), parent )
 , ILanguageSupport()
 , m_highlighting(new QmlJsHighlighting(this))
 , m_refactoring(new BasicRefactoring(this))
 , m_modelManager(new ModelManager(this))
 {
     QmlJS::registerDUChainItems();
 
     CodeCompletionModel* codeCompletion = new QmlJS::CodeCompletionModel(this);
     new KDevelop::CodeCompletion(this, codeCompletion, name());
 
     auto assistantsManager = core()->languageController()->staticAssistantsManager();
     assistantsManager->registerAssistant(StaticAssistant::Ptr(new RenameAssistant(this)));
 }
 
 KDevQmlJsPlugin::~KDevQmlJsPlugin()
 {
     parseLock()->lockForWrite();
     // By locking the parse-mutexes, we make sure that parse jobs get a chance to finish in a good state
     parseLock()->unlock();
 
     QmlJS::unregisterDUChainItems();
 }
 
 ParseJob* KDevQmlJsPlugin::createParseJob(const IndexedString& url)
 {
     return new QmlJsParseJob(url, this);
 }
 
 QString KDevQmlJsPlugin::name() const
 {
     return "qml/js";
 }
 
 ICodeHighlighting* KDevQmlJsPlugin::codeHighlighting() const
 {
     return m_highlighting;
 }
 
 BasicRefactoring* KDevQmlJsPlugin::refactoring() const
 {
     return m_refactoring;
 }
 
 ContextMenuExtension KDevQmlJsPlugin::contextMenuExtension(Context* context)
 {
     ContextMenuExtension cm;
     EditorContext *ec = dynamic_cast<KDevelop::EditorContext *>(context);
 
     if (ec && ICore::self()->languageController()->languagesForUrl(ec->url()).contains(this)) {
         // It's a QML/JS file, let's add our context menu.
         m_refactoring->fillContextMenu(cm, context);
     }
 
     return cm;
 }
 
 const QString textFromDoc(const IDocument* doc, const KTextEditor::Range& range) {
     return doc->textDocument()->line(range.start().line()).mid(range.start().column(), range.end().column()-range.start().column());
 };
 
 // Finds how many spaces the given string has at one end.
 // direction=+1 -> left end of the string, -1 for right end.
 int spacesAtCorner(const QString& string, int direction = +1) {
     int spaces = 0;
     QString::const_iterator it;
     for ( it = direction == 1 ? string.begin() : string.end()-1 ; it != string.end(); it += direction ) {
         if ( ! it->isSpace() ) break;
         spaces += 1;
     }
     return spaces;
 }
 
 // Take the given QML line and check if it's a line of the form foo.bar: value.
 // Return ranges for the key and the value.
 const QPair<KTextEditor::Range, KTextEditor::Range> parseProperty(const QString& line, const KTextEditor::Cursor& position) {
     QStringList items = line.split(';');
     QString matchingItem;
     int col_offset = -1;
     // This is to also support FooAnimation { foo: bar; baz: bang; duration: 200 }
     // or similar
     foreach ( const QString& item, items ) {
         col_offset += item.size() + 1;
         if ( position.column() < col_offset ) {
             matchingItem = item;
             break;
         }
     }
     QStringList split = matchingItem.split(':');
     if ( split.size() != 2 ) {
         // The expression is not of the form foo:bar, thus invalid.
         return qMakePair(KTextEditor::Range::invalid(), KTextEditor::Range::invalid());
     }
     QString key = split.at(0);
     QString value = split.at(1);
 
     // For animations or similar, remove the trailing '}' if there's no semicolon after the last entry
     if ( value.trimmed().endsWith('}') ) {
         col_offset -= value.size() - value.lastIndexOf('}') + 1;
         value = value.left(value.lastIndexOf('}')-1);
     }
 
     return qMakePair(
     KTextEditor::Range(
         KTextEditor::Cursor(position.line(), col_offset - value.size() - key.size() + spacesAtCorner(key, +1) - 1),
         KTextEditor::Cursor(position.line(), col_offset - value.size() - 1 + spacesAtCorner(key, -1))
     ),
     KTextEditor::Range(
         KTextEditor::Cursor(position.line(), col_offset - value.size() + spacesAtCorner(value, +1)),
         KTextEditor::Cursor(position.line(), col_offset + spacesAtCorner(value, -1))
     ));
 };
 
 QWidget* KDevQmlJsPlugin::specialLanguageObjectNavigationWidget(const QUrl& url, const KTextEditor::Cursor& position)
 {
     IDocument* doc = ICore::self()->documentController()->documentForUrl(url);
     if ( doc && doc->textDocument() ) {
         // Check for a QML property, and construct a property preview widget
         // if the property key is listed in the supported properties.
         QPair<KTextEditor::Range, KTextEditor::Range> property = parseProperty(doc->textDocument()->line(position.line()), position);
         if ( property.first.isValid() && property.second.isValid() ) {
             Declaration* decl = DUChainUtils::itemUnderCursor(url, property.first.start()).declaration;
 
             return PropertyPreviewWidget::constructIfPossible(
                 doc->textDocument(),
                 property.first,
                 property.second,
                 decl,
                 textFromDoc(doc, property.first),
                 textFromDoc(doc, property.second)
             );
         }
     }
     // Otherwise, display no special "navigation" widget.
     return KDevelop::ILanguageSupport::specialLanguageObjectNavigationWidget(url, position);
 }
 
 #include "kdevqmljsplugin.moc"
diff --git a/languages/qmljs/libs/utils/fileutils.cpp b/languages/qmljs/libs/utils/fileutils.cpp
index 8158f140a6..2443059eaa 100644
--- a/languages/qmljs/libs/utils/fileutils.cpp
+++ b/languages/qmljs/libs/utils/fileutils.cpp
@@ -1,794 +1,793 @@
 /****************************************************************************
 **
 ** Copyright (C) 2015 The Qt Company Ltd.
 ** Contact: http://www.qt.io/licensing
 **
 ** This file is part of Qt Creator.
 **
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company.  For licensing terms and
 ** conditions see http://www.qt.io/terms-conditions.  For further information
 ** use the contact form at http://www.qt.io/contact-us.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 2.1 or version 3 as published by the Free
 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
 ** LICENSE.LGPLv3 included in the packaging of this file.  Please review the
 ** following information to ensure the GNU Lesser General Public License
 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, The Qt Company gives you certain additional
 ** rights.  These rights are described in The Qt Company LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ****************************************************************************/
 
 #include "fileutils.h"
 #include "savefile.h"
 
 #include "algorithm.h"
 #include "hostosinfo.h"
 #include "qtcassert.h"
 
 #include <QDir>
 #include <QDebug>
 #include <QDateTime>
 #include <QDragEnterEvent>
 #include <QDropEvent>
 #include <QMessageBox>
-#include <QTimer>
 #include <QUrl>
 
 #ifdef Q_OS_WIN
 #include <qt_windows.h>
 #include <shlobj.h>
 #endif
 
 #ifdef Q_OS_OSX
 #include "fileutils_mac.h"
 #endif
 
 QT_BEGIN_NAMESPACE
 QDebug operator<<(QDebug dbg, const Utils::FileName &c)
 {
     return dbg << c.toString();
 }
 
 QT_END_NAMESPACE
 
 namespace Utils {
 
 /*! \class Utils::FileUtils
 
   \brief The FileUtils class contains file and directory related convenience
   functions.
 
 */
 
 /*!
   Removes the directory \a filePath and its subdirectories recursively.
 
   \note The \a error parameter is optional.
 
   Returns whether the operation succeeded.
 */
 bool FileUtils::removeRecursively(const FileName &filePath, QString *error)
 {
     QFileInfo fileInfo = filePath.toFileInfo();
     if (!fileInfo.exists() && !fileInfo.isSymLink())
         return true;
     QFile::setPermissions(filePath.toString(), fileInfo.permissions() | QFile::WriteUser);
     if (fileInfo.isDir()) {
         QDir dir(filePath.toString());
         dir = dir.canonicalPath();
         if (dir.isRoot()) {
             if (error) {
                 *error = QCoreApplication::translate("Utils::FileUtils",
                     "Refusing to remove root directory.");
             }
             return false;
         }
         if (dir.path() == QDir::home().canonicalPath()) {
             if (error) {
                 *error = QCoreApplication::translate("Utils::FileUtils",
                     "Refusing to remove your home directory.");
             }
             return false;
         }
 
         QStringList fileNames = dir.entryList(QDir::Files | QDir::Hidden
                                               | QDir::System | QDir::Dirs | QDir::NoDotAndDotDot);
         foreach (const QString &fileName, fileNames) {
             if (!removeRecursively(FileName(filePath).appendPath(fileName), error))
                 return false;
         }
         if (!QDir::root().rmdir(dir.path())) {
             if (error) {
                 *error = QCoreApplication::translate("Utils::FileUtils", "Failed to remove directory \"%1\".")
                         .arg(filePath.toUserOutput());
             }
             return false;
         }
     } else {
         if (!QFile::remove(filePath.toString())) {
             if (error) {
                 *error = QCoreApplication::translate("Utils::FileUtils", "Failed to remove file \"%1\".")
                         .arg(filePath.toUserOutput());
             }
             return false;
         }
     }
     return true;
 }
 
 /*!
   Copies the directory specified by \a srcFilePath recursively to \a tgtFilePath. \a tgtFilePath will contain
   the target directory, which will be created. Example usage:
 
   \code
     QString error;
     book ok = Utils::FileUtils::copyRecursively("/foo/bar", "/foo/baz", &error);
     if (!ok)
       qDebug() << error;
   \endcode
 
   This will copy the contents of /foo/bar into to the baz directory under /foo, which will be created in the process.
 
   \note The \a error parameter is optional.
 
   Returns whether the operation succeeded.
 */
 bool FileUtils::copyRecursively(const FileName &srcFilePath, const FileName &tgtFilePath,
                                 QString *error, const std::function<bool (QFileInfo, QFileInfo, QString *)> &copyHelper)
 {
     QFileInfo srcFileInfo = srcFilePath.toFileInfo();
     if (srcFileInfo.isDir()) {
         if (!tgtFilePath.exists()) {
             QDir targetDir(tgtFilePath.toString());
             targetDir.cdUp();
             if (!targetDir.mkdir(tgtFilePath.fileName())) {
                 if (error) {
                     *error = QCoreApplication::translate("Utils::FileUtils", "Failed to create directory \"%1\".")
                             .arg(tgtFilePath.toUserOutput());
                 }
                 return false;
             }
         }
         QDir sourceDir(srcFilePath.toString());
         QStringList fileNames = sourceDir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot
                                                     | QDir::Hidden | QDir::System);
         foreach (const QString &fileName, fileNames) {
             FileName newSrcFilePath = srcFilePath;
             newSrcFilePath.appendPath(fileName);
             FileName newTgtFilePath = tgtFilePath;
             newTgtFilePath.appendPath(fileName);
             if (!copyRecursively(newSrcFilePath, newTgtFilePath, error, copyHelper))
                 return false;
         }
     } else {
         if (copyHelper) {
             if (!copyHelper(srcFileInfo, tgtFilePath.toFileInfo(), error))
                 return false;
         } else {
             if (!QFile::copy(srcFilePath.toString(), tgtFilePath.toString())) {
                 if (error) {
                     *error = QCoreApplication::translate("Utils::FileUtils", "Could not copy file \"%1\" to \"%2\".")
                             .arg(srcFilePath.toUserOutput(), tgtFilePath.toUserOutput());
                 }
                 return false;
             }
         }
     }
     return true;
 }
 
 /*!
   If \a filePath is a directory, the function will recursively check all files and return
   true if one of them is newer than \a timeStamp. If \a filePath is a single file, true will
   be returned if the file is newer than \a timeStamp.
 
   Returns whether at least one file in \a filePath has a newer date than
   \a timeStamp.
 */
 bool FileUtils::isFileNewerThan(const FileName &filePath, const QDateTime &timeStamp)
 {
     QFileInfo fileInfo = filePath.toFileInfo();
     if (!fileInfo.exists() || fileInfo.lastModified() >= timeStamp)
         return true;
     if (fileInfo.isDir()) {
         const QStringList dirContents = QDir(filePath.toString())
             .entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
         foreach (const QString &curFileName, dirContents) {
             if (isFileNewerThan(FileName(filePath).appendPath(curFileName), timeStamp))
                 return true;
         }
     }
     return false;
 }
 
 /*!
   Recursively resolves possibly present symlinks in \a filePath.
   Unlike QFileInfo::canonicalFilePath(), this function will still return the expected target file
   even if the symlink is dangling.
 
   \note Maximum recursion depth == 16.
 
   Returns the symlink target file path.
 */
 FileName FileUtils::resolveSymlinks(const FileName &path)
 {
     QFileInfo f = path.toFileInfo();
     int links = 16;
     while (links-- && f.isSymLink())
         f.setFile(f.symLinkTarget());
     if (links <= 0)
         return FileName();
     return FileName::fromString(f.filePath());
 }
 
 /*!
   Like QDir::toNativeSeparators(), but use prefix '~' instead of $HOME on unix systems when an
   absolute path is given.
 
   Returns the possibly shortened path with native separators.
 */
 QString FileUtils::shortNativePath(const FileName &path)
 {
     if (HostOsInfo::isAnyUnixHost()) {
         const FileName home = FileName::fromString(QDir::cleanPath(QDir::homePath()));
         if (path.isChildOf(home)) {
             return QLatin1Char('~') + QDir::separator()
                 + QDir::toNativeSeparators(path.relativeChildPath(home).toString());
         }
     }
     return path.toUserOutput();
 }
 
 QString FileUtils::fileSystemFriendlyName(const QString &name)
 {
     QString result = name;
     result.replace(QRegExp(QLatin1String("\\W")), QLatin1String("_"));
     result.replace(QRegExp(QLatin1String("_+")), QLatin1String("_")); // compact _
     result.remove(QRegExp(QLatin1String("^_*"))); // remove leading _
     result.remove(QRegExp(QLatin1String("_+$"))); // remove trailing _
     if (result.isEmpty())
         result = QLatin1String("unknown");
     return result;
 }
 
 int FileUtils::indexOfQmakeUnfriendly(const QString &name, int startpos)
 {
     static QRegExp checkRegExp(QLatin1String("[^a-zA-Z0-9_.-]"));
     return checkRegExp.indexIn(name, startpos);
 }
 
 QString FileUtils::qmakeFriendlyName(const QString &name)
 {
     QString result = name;
 
     // Remove characters that might trip up a build system (especially qmake):
     int pos = indexOfQmakeUnfriendly(result);
     while (pos >= 0) {
         result[pos] = QLatin1Char('_');
         pos = indexOfQmakeUnfriendly(result, pos);
     }
     return fileSystemFriendlyName(result);
 }
 
 bool FileUtils::makeWritable(const FileName &path)
 {
     const QString fileName = path.toString();
     return QFile::setPermissions(fileName, QFile::permissions(fileName) | QFile::WriteUser);
 }
 
 // makes sure that capitalization of directories is canonical on Windows and OS X.
 // This mimics the logic in QDeclarative_isFileCaseCorrect
 QString FileUtils::normalizePathName(const QString &name)
 {
 #ifdef Q_OS_WIN
     const QString nativeSeparatorName(QDir::toNativeSeparators(name));
     const LPCTSTR nameC = reinterpret_cast<LPCTSTR>(nativeSeparatorName.utf16()); // MinGW
     PIDLIST_ABSOLUTE file;
     HRESULT hr = SHParseDisplayName(nameC, NULL, &file, 0, NULL);
     if (FAILED(hr))
         return name;
     TCHAR buffer[MAX_PATH];
     if (!SHGetPathFromIDList(file, buffer))
         return name;
     return QDir::fromNativeSeparators(QString::fromUtf16(reinterpret_cast<const ushort *>(buffer)));
 #elif defined(Q_OS_OSX)
     return Internal::normalizePathName(name);
 #else // do not try to handle case-insensitive file systems on Linux
     return name;
 #endif
 }
 
 bool FileUtils::isRelativePath(const QString &path)
 {
     if (path.startsWith(QLatin1Char('/')))
         return false;
     if (HostOsInfo::isWindowsHost()) {
         if (path.startsWith(QLatin1Char('\\')))
             return false;
         // Unlike QFileInfo, this won't accept a relative path with a drive letter.
         // Such paths result in a royal mess anyway ...
         if (path.length() >= 3 && path.at(1) == QLatin1Char(':') && path.at(0).isLetter()
                 && (path.at(2) == QLatin1Char('/') || path.at(2) == QLatin1Char('\\')))
             return false;
     }
     return true;
 }
 
 QString FileUtils::resolvePath(const QString &baseDir, const QString &fileName)
 {
     if (fileName.isEmpty())
         return QString();
     if (isAbsolutePath(fileName))
         return QDir::cleanPath(fileName);
     return QDir::cleanPath(baseDir + QLatin1Char('/') + fileName);
 }
 
 
 QByteArray FileReader::fetchQrc(const QString &fileName)
 {
     QTC_ASSERT(fileName.startsWith(QLatin1Char(':')), return QByteArray());
     QFile file(fileName);
     bool ok = file.open(QIODevice::ReadOnly);
     QTC_ASSERT(ok, qWarning() << fileName << "not there!"; return QByteArray());
     return file.readAll();
 }
 
 bool FileReader::fetch(const QString &fileName, QIODevice::OpenMode mode)
 {
     QTC_ASSERT(!(mode & ~(QIODevice::ReadOnly | QIODevice::Text)), return false);
 
     QFile file(fileName);
     if (!file.open(QIODevice::ReadOnly | mode)) {
         m_errorString = tr("Cannot open %1 for reading: %2").arg(
                 QDir::toNativeSeparators(fileName), file.errorString());
         return false;
     }
     m_data = file.readAll();
     if (file.error() != QFile::NoError) {
         m_errorString = tr("Cannot read %1: %2").arg(
                 QDir::toNativeSeparators(fileName), file.errorString());
         return false;
     }
     return true;
 }
 
 bool FileReader::fetch(const QString &fileName, QIODevice::OpenMode mode, QString *errorString)
 {
     if (fetch(fileName, mode))
         return true;
     if (errorString)
         *errorString = m_errorString;
     return false;
 }
 
 bool FileReader::fetch(const QString &fileName, QIODevice::OpenMode mode, QWidget *parent)
 {
     if (fetch(fileName, mode))
         return true;
     if (parent)
         QMessageBox::critical(parent, tr("File Error"), m_errorString);
     return false;
 }
 
 
 FileSaverBase::FileSaverBase()
     : m_file(nullptr)
     , m_hasError(false)
 {
 }
 
 FileSaverBase::~FileSaverBase()
 {
 }
 
 bool FileSaverBase::finalize()
 {
     m_file->close();
     setResult(m_file->error() == QFile::NoError);
     // We delete the object, so it is really closed even if it is a QTemporaryFile.
     delete m_file;
     m_file = 0;
     return !m_hasError;
 }
 
 bool FileSaverBase::finalize(QString *errStr)
 {
     if (finalize())
         return true;
     if (errStr)
         *errStr = errorString();
     return false;
 }
 
 bool FileSaverBase::finalize(QWidget *parent)
 {
     if (finalize())
         return true;
     QMessageBox::critical(parent, tr("File Error"), errorString());
     return false;
 }
 
 bool FileSaverBase::write(const char *data, int len)
 {
     if (m_hasError)
         return false;
     return setResult(m_file->write(data, len) == len);
 }
 
 bool FileSaverBase::write(const QByteArray &bytes)
 {
     if (m_hasError)
         return false;
     return setResult(m_file->write(bytes) == bytes.count());
 }
 
 bool FileSaverBase::setResult(bool ok)
 {
     if (!ok && !m_hasError) {
         m_errorString = tr("Cannot write file %1. Disk full?").arg(
                 QDir::toNativeSeparators(m_fileName));
         m_hasError = true;
     }
     return ok;
 }
 
 bool FileSaverBase::setResult(QTextStream *stream)
 {
     stream->flush();
     return setResult(stream->status() == QTextStream::Ok);
 }
 
 bool FileSaverBase::setResult(QDataStream *stream)
 {
     return setResult(stream->status() == QDataStream::Ok);
 }
 
 bool FileSaverBase::setResult(QXmlStreamWriter *stream)
 {
     return setResult(!stream->hasError());
 }
 
 
 FileSaver::FileSaver(const QString &filename, QIODevice::OpenMode mode)
 {
     m_fileName = filename;
     if (mode & (QIODevice::ReadOnly | QIODevice::Append)) {
         m_file = new QFile(filename);
         m_isSafe = false;
     } else {
         m_file = new SaveFile(filename);
         m_isSafe = true;
     }
     if (!m_file->open(QIODevice::WriteOnly | mode)) {
         QString err = QFile::exists(filename) ?
                 tr("Cannot overwrite file %1: %2") : tr("Cannot create file %1: %2");
         m_errorString = err.arg(QDir::toNativeSeparators(filename), m_file->errorString());
         m_hasError = true;
     }
 }
 
 bool FileSaver::finalize()
 {
     if (!m_isSafe)
         return FileSaverBase::finalize();
 
     SaveFile *sf = static_cast<SaveFile *>(m_file);
     if (m_hasError) {
         if (sf->isOpen())
             sf->rollback();
     } else {
         setResult(sf->commit());
     }
     delete sf;
     m_file = 0;
     return !m_hasError;
 }
 
 TempFileSaver::TempFileSaver(const QString &templ)
     : m_autoRemove(true)
 {
     QTemporaryFile *tempFile = new QTemporaryFile();
     if (!templ.isEmpty())
         tempFile->setFileTemplate(templ);
     tempFile->setAutoRemove(false);
     if (!tempFile->open()) {
         m_errorString = tr("Cannot create temporary file in %1: %2").arg(
                 QDir::toNativeSeparators(QFileInfo(tempFile->fileTemplate()).absolutePath()),
                 tempFile->errorString());
         m_hasError = true;
     }
     m_file = tempFile;
     m_fileName = tempFile->fileName();
 }
 
 TempFileSaver::~TempFileSaver()
 {
     delete m_file;
     m_file = 0;
     if (m_autoRemove)
         QFile::remove(m_fileName);
 }
 
 /*! \class Utils::FileName
 
     \brief The FileName class is a light-weight convenience class for filenames.
 
     On windows filenames are compared case insensitively.
 */
 
 FileName::FileName()
     : QString()
 {
 
 }
 
 /// Constructs a FileName from \a info
 FileName::FileName(const QFileInfo &info)
     : QString(info.absoluteFilePath())
 {
 }
 
 /// \returns a QFileInfo
 QFileInfo FileName::toFileInfo() const
 {
     return QFileInfo(*this);
 }
 
 /// \returns a QString for passing on to QString based APIs
 const QString &FileName::toString() const
 {
     return *this;
 }
 
 /// \returns a QString to display to the user
 /// Converts the separators to the native format
 QString FileName::toUserOutput() const
 {
     return QDir::toNativeSeparators(toString());
 }
 
 QString FileName::fileName(int pathComponents) const
 {
     if (pathComponents < 0)
         return *this;
     const QChar slash = QLatin1Char('/');
     QTC_CHECK(!endsWith(slash));
     int i = lastIndexOf(slash);
     if (pathComponents == 0 || i == -1)
         return mid(i + 1);
     int component = i + 1;
     // skip adjacent slashes
     while (i > 0 && at(--i) == slash);
     while (i >= 0 && --pathComponents >= 0) {
         i = lastIndexOf(slash, i);
         component = i + 1;
         while (i > 0 && at(--i) == slash);
     }
 
     // If there are no more slashes before the found one, return the entire string
     if (i > 0 && lastIndexOf(slash, i) != -1)
         return mid(component);
     return *this;
 }
 
 /// \returns a bool indicating whether a file with this
 /// FileName exists.
 bool FileName::exists() const
 {
     return QFileInfo::exists(*this);
 }
 
 /// Find the parent directory of a given directory.
 
 /// Returns an empty FileName if the current directory is already
 /// a root level directory.
 
 /// \returns \a FileName with the last segment removed.
 FileName FileName::parentDir() const
 {
     const QString basePath = toString();
     if (basePath.isEmpty())
         return FileName();
 
     const QDir base(basePath);
     if (base.isRoot())
         return FileName();
 
     const QString path = basePath + QLatin1String("/..");
     const QString parent = QDir::cleanPath(path);
 
     return FileName::fromString(parent);
 }
 
 /// Constructs a FileName from \a filename
 /// \a filename is not checked for validity.
 FileName FileName::fromString(const QString &filename)
 {
     return FileName(filename);
 }
 
 /// Constructs a FileName from \a fileName. The \a defaultExtension is appended
 /// to \a filename if that does not have an extension already.
 /// \a fileName is not checked for validity.
 FileName FileName::fromString(const QString &filename, const QString &defaultExtension)
 {
     if (filename.isEmpty() || defaultExtension.isEmpty())
         return filename;
 
     QString rc = filename;
     QFileInfo fi(filename);
     // Add extension unless user specified something else
     const QChar dot = QLatin1Char('.');
     if (!fi.fileName().contains(dot)) {
         if (!defaultExtension.startsWith(dot))
             rc += dot;
         rc += defaultExtension;
     }
     return rc;
 }
 
 /// Constructs a FileName from \a fileName
 /// \a fileName is not checked for validity.
 FileName FileName::fromLatin1(const QByteArray &filename)
 {
     return FileName(QString::fromLatin1(filename));
 }
 
 /// Constructs a FileName from \a fileName
 /// \a fileName is only passed through QDir::cleanPath
 FileName FileName::fromUserInput(const QString &filename)
 {
     QString clean = QDir::cleanPath(filename);
     if (clean.startsWith(QLatin1String("~/")))
         clean = QDir::homePath() + clean.mid(1);
     return FileName(clean);
 }
 
 /// Constructs a FileName from \a fileName, which is encoded as UTF-8.
 /// \a fileName is not checked for validity.
 FileName FileName::fromUtf8(const char *filename, int filenameSize)
 {
     return FileName(QString::fromUtf8(filename, filenameSize));
 }
 
 FileName::FileName(const QString &string)
     : QString(string)
 {
 
 }
 
 bool FileName::operator==(const FileName &other) const
 {
     return QString::compare(*this, other, HostOsInfo::fileNameCaseSensitivity()) == 0;
 }
 
 bool FileName::operator!=(const FileName &other) const
 {
     return !(*this == other);
 }
 
 bool FileName::operator<(const FileName &other) const
 {
     return QString::compare(*this, other, HostOsInfo::fileNameCaseSensitivity()) < 0;
 }
 
 bool FileName::operator<=(const FileName &other) const
 {
     return QString::compare(*this, other, HostOsInfo::fileNameCaseSensitivity()) <= 0;
 }
 
 bool FileName::operator>(const FileName &other) const
 {
     return other < *this;
 }
 
 bool FileName::operator>=(const FileName &other) const
 {
     return other <= *this;
 }
 
 /// \returns whether FileName is a child of \a s
 bool FileName::isChildOf(const FileName &s) const
 {
     if (s.isEmpty())
         return false;
     if (!QString::startsWith(s, HostOsInfo::fileNameCaseSensitivity()))
         return false;
     if (size() <= s.size())
         return false;
     // s is root, '/' was already tested in startsWith
     if (s.QString::endsWith(QLatin1Char('/')))
         return true;
     // s is a directory, next character should be '/' (/tmpdir is NOT a child of /tmp)
     return at(s.size()) == QLatin1Char('/');
 }
 
 /// \overload
 bool FileName::isChildOf(const QDir &dir) const
 {
     return isChildOf(FileName::fromString(dir.absolutePath()));
 }
 
 /// \returns whether FileName endsWith \a s
 bool FileName::endsWith(const QString &s) const
 {
     return QString::endsWith(s, HostOsInfo::fileNameCaseSensitivity());
 }
 
 /// \returns the relativeChildPath of FileName to parent if FileName is a child of parent
 /// \note returns a empty FileName if FileName is not a child of parent
 /// That is, this never returns a path starting with "../"
 FileName FileName::relativeChildPath(const FileName &parent) const
 {
     if (!isChildOf(parent))
         return FileName();
     return FileName(QString::mid(parent.size() + 1, -1));
 }
 
 /// Appends \a s, ensuring a / between the parts
 FileName &FileName::appendPath(const QString &s)
 {
     if (s.isEmpty())
         return *this;
     if (!isEmpty() && !QString::endsWith(QLatin1Char('/')))
         appendString(QLatin1Char('/'));
     appendString(s);
     return *this;
 }
 
 FileName &FileName::appendString(const QString &str)
 {
     QString::append(str);
     return *this;
 }
 
 FileName &FileName::appendString(QChar str)
 {
     QString::append(str);
     return *this;
 }
 
 QTextStream &operator<<(QTextStream &s, const FileName &fn)
 {
     return s << fn.toString();
 }
 
 int FileNameList::removeDuplicates()
 {
     QSet<FileName> seen;
     int removed = 0;
 
     for (int i = 0; i < size(); ) {
         const FileName &fn = at(i);
         if (seen.contains(fn)) {
             removeAt(i);
             ++removed;
         } else {
             seen.insert(fn);
             ++i;
         }
     }
 
     return removed;
 }
 
 } // namespace Utils
 
 QT_BEGIN_NAMESPACE
 uint qHash(const Utils::FileName &a)
 {
     if (Utils::HostOsInfo::fileNameCaseSensitivity() == Qt::CaseInsensitive)
         return qHash(a.toString().toUpper());
     return qHash(a.toString());
 }
 QT_END_NAMESPACE
diff --git a/languages/qmljs/navigation/propertypreviewwidget.cpp b/languages/qmljs/navigation/propertypreviewwidget.cpp
index a2e50f1138..67f3fcb93f 100644
--- a/languages/qmljs/navigation/propertypreviewwidget.cpp
+++ b/languages/qmljs/navigation/propertypreviewwidget.cpp
@@ -1,184 +1,183 @@
 /*************************************************************************************
  *  Copyright (C) 2013 by Sven Brauch <svenbrauch@gmail.com>                         *
  *                                                                                   *
  *  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 "propertypreviewwidget.h"
 
 #include <QQuickWidget>
 #include <QQuickItem>
-#include <QLayout>
+#include <QHBoxLayout>
 #include <QLabel>
-#include <QDir>
 #include <QStandardPaths>
 #include <KLocalizedString>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 #include <KDeclarative/KDeclarative>
 
 #include <language/duchain/ducontext.h>
 #include <language/duchain/duchainlock.h>
 
 // List of supported properties. The string must be the name of the property,
 // which can contain dots if necessary
 QHash<QString, SupportedProperty> PropertyPreviewWidget::supportedProperties;
 
 QWidget* PropertyPreviewWidget::constructIfPossible(KTextEditor::Document* doc,
                                                     KTextEditor::Range keyRange,
                                                     KTextEditor::Range valueRange,
                                                     Declaration* decl,
                                                     const QString& key,
                                                     const QString& value)
 {
 #define PROP(key, filename, type, class) \
     supportedProperties.insertMulti(key, SupportedProperty(QUrl(base + filename), type, class));
 
     if ( supportedProperties.isEmpty() ) {
         QString base = QStandardPaths::locate(
             QStandardPaths::GenericDataLocation,
             QLatin1String("kdevqmljssupport/propertywidgets"),
             QStandardPaths::LocateDirectory
         ) + '/';
 
         // Positioning
         PROP("width", "Width.qml", QString(), QString())
         PROP("height", "Height.qml", QString(), QString())
         PROP("spacing", "Spacing.qml", QString(), QString())
 
         // Margins
         PROP("margins", "Spacing.qml", QString(), "QQuickAnchors");         // matches anchors.margins and anchors { margins: }
         PROP("margins", "Spacing.qml", QString(), "QDeclarativeAnchors");
         PROP("leftMargin", "Spacing.qml", QString(), "QQuickAnchors");
         PROP("leftMargin", "Spacing.qml", QString(), "QDeclarativeAnchors");
         PROP("rightMargin", "Spacing.qml", QString(), "QQuickAnchors");
         PROP("rightMargin", "Spacing.qml", QString(), "QDeclarativeAnchors");
         PROP("topMargin", "Spacing.qml", QString(), "QQuickAnchors");
         PROP("topMargin", "Spacing.qml", QString(), "QDeclarativeAnchors");
         PROP("bottomMargin", "Spacing.qml", QString(), "QQuickAnchors");
         PROP("bottomMargin", "Spacing.qml", QString(), "QDeclarativeAnchors");
 
         // Animations
         PROP("duration", "Duration.qml", QString(), QString())
 
         // Font QDeclarativeFontValueType, QQuickFontValueType
         PROP("family", "FontFamily.qml", QString(), "QDeclarativeFontValueType")
         PROP("family", "FontFamily.qml", QString(), "QQuickFontValueType")
         PROP("pointSize", "FontSize.qml", QString(), "QDeclarativeFontValueType")
         PROP("pointSize", "FontSize.qml", QString(), "QQuickFontValueType")
 
         // Appearance
         PROP("opacity", "Opacity.qml", QString(), QString())
 
         // Type-dependend widgets
         PROP(QString(), "ColorPicker.qml", "color", QString())
     }
 #undef PROP
 
     QList<SupportedProperty> properties;
 
     properties << supportedProperties.values(key.section(QLatin1Char('.'), -1, -1));
     properties << supportedProperties.values(QString());
 
     // Explore each possible supported property and return the first supported widget
     DUChainReadLocker lock;
 
     for (const SupportedProperty& property : properties) {
         if (!decl || !decl->abstractType() || !decl->context() || !decl->context()->owner()) {
             continue;
         }
 
         if (!decl->abstractType()->toString().contains(property.typeContains)) {
             continue;
         }
 
         if (!decl->context()->owner()->toString().contains(property.classContains)) {
             continue;
         }
 
         return new PropertyPreviewWidget(doc, keyRange, valueRange, property, value);
     }
 
     return nullptr;
 }
 
 void PropertyPreviewWidget::updateValue()
 {
     QString newValue = view->rootObject()->property("value").toString();
 
     // set the cursor to the edited range, otherwise the view will jump if we call doc->endEditing()
     //document->activeView()->setCursorPosition(KTextEditor::Cursor(valueRange.start.line, valueRange.start.column));
     if (valueRange.end().column() - valueRange.start().column() == newValue.size()) {
         document->replaceText(valueRange, newValue);
     }
     else {
         // the length of the text changed so don't replace it but remove the old
         // and insert the new text.
         KTextEditor::Document::EditingTransaction transaction(document);
         document->removeText(valueRange);
         document->insertText(valueRange.start(), newValue);
 
         valueRange.setRange(
             valueRange.start(),
             KTextEditor::Cursor(valueRange.start().line(), valueRange.start().column() + newValue.size())
         );
     }
 }
 
 PropertyPreviewWidget::~PropertyPreviewWidget()
 {
 }
 
 PropertyPreviewWidget::PropertyPreviewWidget(KTextEditor::Document* doc, KTextEditor::Range keyRange, KTextEditor::Range valueRange,
                                              const SupportedProperty& property, const QString& value)
     : QWidget()
     , view(new QQuickWidget)
     , document(doc)
     , keyRange(keyRange)
     , valueRange(valueRange)
     , property(property)
 {
     //setup kdeclarative library
     KDeclarative::KDeclarative kdeclarative;
     kdeclarative.setDeclarativeEngine(view->engine());
     kdeclarative.setupBindings();        //binds things like kconfig and icons
 
     // Configure layout
     auto l = new QHBoxLayout;
 
     l->setContentsMargins(0, 0, 0, 0);
     setLayout(l);
 
     // see docstring for ILanguageSupport::specialLanguageObjectNavigationWidget
     setProperty("DoNotCloseOnCursorMove", true);
 
     view->setSource(property.qmlfile);
 
     if (!view->rootObject()) {
         // don't crash because of a syntax error or missing QML file
         l->addWidget(new QLabel(i18n("Error loading QML file: %1", property.qmlfile.path())));
         delete view;
         return;
     }
 
     // set the initial value read from the document
     view->rootObject()->setProperty("initialValue", value);
 
     // connect to the slot which has to be emitted from QML when the value changes
     QObject::connect(view->rootObject(), SIGNAL(valueChanged()),
                      this, SLOT(updateValue()));
     l->addWidget(view);
 }
diff --git a/languages/qmljs/tests/test_files.cpp b/languages/qmljs/tests/test_files.cpp
index 66bd48532f..0b8c7844c0 100644
--- a/languages/qmljs/tests/test_files.cpp
+++ b/languages/qmljs/tests/test_files.cpp
@@ -1,141 +1,141 @@
 /*************************************************************************************
  *  Copyright (C) 2013 by Milian Wolff <mail@milianw.de>                             *
  *  Copyright (C) 2013 Olivier de Gaalon <olivier.jg@gmail.com>                      *
  *                                                                                   *
  *  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 "test_files.h"
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/problem.h>
 #include <language/codegen/coderepresentation.h>
 #include <language/backgroundparser/backgroundparser.h>
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/json/declarationvalidator.h>
 
 #include "testfilepaths.h"
 
 //Include all used json tests, otherwise "Test not found"
 #include <tests/json/jsondeclarationtests.h>
 #include <tests/json/jsonducontexttests.h>
 #include <tests/json/jsontypetests.h>
 #include <interfaces/ilanguagecontroller.h>
 
-#include <QtTest>
+#include <QTest>
 
 // #include "cppjsontests.h"
 
 using namespace KDevelop;
 
 QTEST_MAIN(TestFiles)
 
 void TestFiles::initTestCase()
 {
   AutoTestShell::init({"kdevqmljslanguagesupport"});
   TestCore::initialize(KDevelop::Core::NoUi);
   DUChain::self()->disablePersistentStorage();
   Core::self()->languageController()->backgroundParser()->setDelay(0);
   CodeRepresentation::setDiskChangesForbidden(true);
 }
 
 void TestFiles::cleanupTestCase()
 {
   TestCore::shutdown();
 }
 
 void TestFiles::testQMLCustomComponent()
 {
     // First parse CustomComponent, so that it is visible and can be used
     // by CustomComponentUser. Then re-parse CustomComponent and assert that
     // it has been used.
     parseAndCheck(TEST_FILES_DIR "/custom_component/CustomComponent.qml", false);
     parseAndCheck(TEST_FILES_DIR "/custom_component/CustomComponentUser.qml");
     parseAndCheck(TEST_FILES_DIR "/custom_component/CustomComponent.qml");
 }
 
 void TestFiles::testQMLTypes()
 {
     parseAndCheck(TEST_FILES_DIR "/qmltypes/AnItem.qml", true);
 }
 
 void TestFiles::testTypeMismatchFalsePositives()
 {
     parseAndCheck(TEST_FILES_DIR "/type_mismatch_false_positives/code.js", true);
 }
 
 void TestFiles::testJSUsesBetweenFiles()
 {
     parseAndCheck(TEST_FILES_DIR "/js_cross_file_uses/js_variable_definition.js", false);
     parseAndCheck(TEST_FILES_DIR "/js_cross_file_uses/js_variable_use.js");
     parseAndCheck(TEST_FILES_DIR "/js_cross_file_uses/js_variable_definition.js");
 }
 
 void TestFiles::testNodeJS()
 {
     parseAndCheck(TEST_FILES_DIR "/node_modules/module.js", false); // Ensure that module.js is in the DUChain
     parseAndCheck(TEST_FILES_DIR "/node.js/module2.js", false);
     parseAndCheck(TEST_FILES_DIR "/node.js/main.js");
 }
 
 void TestFiles::testFiles_data()
 {
   QTest::addColumn<QString>("fileName");
   const QString testDirPath = TEST_FILES_DIR;
   QStringList files = QDir(testDirPath).entryList(QStringList() << "*.js" << "*.qml", QDir::Files);
   foreach (QString file, files) {
     QTest::newRow(file.toUtf8()) << QString(testDirPath + "/" + file);
   }
 }
 
 void TestFiles::testFiles()
 {
   QFETCH(QString, fileName);
   parseAndCheck(fileName);
 }
 
 void TestFiles::parseAndCheck(const QString& fileName, bool check)
 {
   const IndexedString indexedFileName(fileName);
   ReferencedTopDUContext top =
       DUChain::self()->waitForUpdate(indexedFileName, KDevelop::TopDUContext::AllDeclarationsContextsAndUses);
 
   while (!ICore::self()->languageController()->backgroundParser()->isIdle()) {
       QTest::qWait(500);
   }
 
   QVERIFY(top);
 
   if (check) {
     DUChainReadLocker lock;
     DeclarationValidator validator;
     top->visit(validator);
     QVERIFY(validator.testsPassed());
 
     if (!top->problems().isEmpty()) {
         foreach(auto p, top->problems()) {
             qDebug() << p;
         }
     }
     if (!QTest::currentDataTag() || strcmp("failparse.js", QTest::currentDataTag()) != 0) {
         QEXPECT_FAIL("plugins.qml", "not working properly yet", Continue);
         QEXPECT_FAIL("qrc_import.qml", "just making sure it does not crash", Continue);
         QEXPECT_FAIL("dynamicObjectProperties.2.qml", "just making sure it does not crash", Continue);
         QVERIFY(top->problems().isEmpty());
     }
   }
 }
diff --git a/projectbuilders/cmakebuilder/cmakebuilder.cpp b/projectbuilders/cmakebuilder/cmakebuilder.cpp
index 995144f5d9..86793bb2a2 100644
--- a/projectbuilders/cmakebuilder/cmakebuilder.cpp
+++ b/projectbuilders/cmakebuilder/cmakebuilder.cpp
@@ -1,274 +1,270 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006-2007 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 "cmakebuilder.h"
 #include "debug.h"
 
 #include <config.h>
 #include <cmakebuilderconfig.h>
 
 #include <project/projectmodel.h>
 
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <project/builderjob.h>
 #include <makebuilder/imakebuilder.h>
 
 #include <kpluginfactory.h>
-#include <kpluginloader.h>
-#include <kparts/mainwindow.h>
-#include <kio/deletejob.h>
-#include <kaboutdata.h>
 #include <KLocalizedString>
 #include <kjob.h>
 #include <QUrl>
 
 Q_LOGGING_CATEGORY(CMAKEBUILDER, "kdevelop.projectbuilders.cmakebuilder")
 
 #include "cmakejob.h"
 #include "prunejob.h"
 #include "cmakebuilderpreferences.h"
 #include "cmakeutils.h"
 #include <cmakemodelitems.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(CMakeBuilderFactory, "kdevcmakebuilder.json", registerPlugin<CMakeBuilder>(); )
 
 class ErrorJob : public KJob
 {
 public:
     ErrorJob(QObject* parent, const QString& error)
         : KJob(parent)
         , m_error(error)
     {}
 
     void start() override {
         setError(!m_error.isEmpty());
         setErrorText(m_error);
         emitResult();
     }
 
 private:
     QString m_error;
 };
 
 CMakeBuilder::CMakeBuilder(QObject *parent, const QVariantList &)
     : KDevelop::IPlugin("kdevcmakebuilder", parent)
 {
     addBuilder("Makefile", QStringList("Unix Makefiles") << "NMake Makefiles", core()->pluginController()->pluginForExtension("org.kdevelop.IMakeBuilder"));
     addBuilder("build.ninja", QStringList("Ninja"), core()->pluginController()->pluginForExtension("org.kdevelop.IProjectBuilder", "KDevNinjaBuilder"));
 }
 
 CMakeBuilder::~CMakeBuilder()
 {
 }
 
 void CMakeBuilder::addBuilder(const QString& neededfile, const QStringList& generators, KDevelop::IPlugin* i)
 {
     if( i )
     {
         IProjectBuilder* b = i->extension<KDevelop::IProjectBuilder>();
         if( b )
         {
             m_builders[neededfile] = b;
             foreach(const QString& gen, generators) {
                 m_buildersForGenerator[gen] = b;
             }
             // can't use new signal/slot syntax here, IProjectBuilder is not a QObject
             connect(i, SIGNAL(built(KDevelop::ProjectBaseItem*)), this, SIGNAL(built(KDevelop::ProjectBaseItem*)));
             connect(i, SIGNAL(failed(KDevelop::ProjectBaseItem*)), this, SIGNAL(failed(KDevelop::ProjectBaseItem*)));
             connect(i, SIGNAL(cleaned(KDevelop::ProjectBaseItem*)), this, SIGNAL(cleaned(KDevelop::ProjectBaseItem*)));
             connect(i, SIGNAL(installed(KDevelop::ProjectBaseItem*)), this, SIGNAL(installed(KDevelop::ProjectBaseItem*)));
 
             qCDebug(CMAKEBUILDER) << "Added builder " << i->metaObject()->className() << "for" << neededfile;
         }
         else
             qWarning() << "Couldn't add" << i->metaObject()->className();
     }
 }
 
 KJob* CMakeBuilder::build(KDevelop::ProjectBaseItem *dom)
 {
     KDevelop::IProject* p = dom->project();
     IProjectBuilder* builder = builderForProject(p);
     if( builder )
     {
         bool valid;
         KJob* configure = checkConfigureJob(dom->project(), valid);
 
         KJob* build = nullptr;
         if(dom->file())
         {
             IMakeBuilder* makeBuilder = dynamic_cast<IMakeBuilder*>(builder);
             if (!makeBuilder) {
                 return new ErrorJob(this, i18n("Could not find the make builder. Check your installation"));
             }
             KDevelop::ProjectFileItem* file = dom->file();
             int lastDot = file->text().lastIndexOf('.');
             QString target = file->text().mid(0, lastDot)+".o";
             build = makeBuilder->executeMakeTarget(dom->parent(), target);
             qCDebug(CMAKEBUILDER) << "create build job for target" << build << dom << target;
         }
         qCDebug(CMAKEBUILDER) << "Building with" << builder;
         if (!build)
         {
             build = builder->build(dom);
         }
         if( configure )
         {
             qCDebug(CMAKEBUILDER) << "creating composite job";
             KDevelop::BuilderJob* builderJob = new KDevelop::BuilderJob;
             builderJob->addCustomJob( KDevelop::BuilderJob::Configure, configure, dom );
             builderJob->addCustomJob( KDevelop::BuilderJob::Build, build, dom );
             builderJob->updateJobName();
             build = builderJob;
         }
         return build;
     }
     return new ErrorJob(this, i18n("Could not find a builder for %1", p->name()));
 }
 
 KJob* CMakeBuilder::clean(KDevelop::ProjectBaseItem *dom)
 {
     IProjectBuilder* builder = builderForProject(dom->project());
     if( builder )
     {
         bool valid;
         KJob* configure = checkConfigureJob(dom->project(), valid);
 
         KDevelop::ProjectBaseItem* item = dom;
         if(dom->file()) //It doesn't work to compile a file
             item=(KDevelop::ProjectBaseItem*) dom->parent();
 
         qCDebug(CMAKEBUILDER) << "Cleaning with" << builder;
         KJob* clean = builder->clean(item);
         if( configure ) {
             KDevelop::BuilderJob* builderJob = new KDevelop::BuilderJob;
             builderJob->addCustomJob( KDevelop::BuilderJob::Configure, configure, item );
             builderJob->addCustomJob( KDevelop::BuilderJob::Clean, clean, item );
             builderJob->updateJobName();
             clean = builderJob;
         }
         return clean;
     }
     return new ErrorJob(this, i18n("Could not find a builder for %1", dom->project()->name()));
 }
 
 KJob* CMakeBuilder::install(KDevelop::ProjectBaseItem *dom, const QUrl &installPrefix)
 {
     IProjectBuilder* builder = builderForProject(dom->project());
     if( builder )
     {
         bool valid;
         KJob* configure = checkConfigureJob(dom->project(), valid);
 
         KDevelop::ProjectBaseItem* item = dom;
         if(dom->file())
             item=(KDevelop::ProjectBaseItem*) dom->parent();
 
         qCDebug(CMAKEBUILDER) << "Installing with" << builder;
         KJob* install = builder->install(item, installPrefix);
         if( configure ) {
             KDevelop::BuilderJob* builderJob = new KDevelop::BuilderJob;
             builderJob->addCustomJob( KDevelop::BuilderJob::Configure, configure, item );
             builderJob->addCustomJob( KDevelop::BuilderJob::Install, install, item );
             builderJob->updateJobName();
             install = builderJob;
         }
         return install;
 
     }
     return new ErrorJob(this, i18n("Could not find a builder for %1", dom->project()->name()));
 }
 
 KJob* CMakeBuilder::checkConfigureJob(KDevelop::IProject* project, bool& valid)
 {
     valid = false;
     KJob* configure = nullptr;
     if( CMake::checkForNeedingConfigure(project) )
     {
         configure = this->configure(project);
     }
     else if( CMake::currentBuildDir(project).isEmpty() )
     {
         return new ErrorJob(this, i18n("No Build Directory configured, cannot install"));
     }
     valid = true;
     return configure;
 }
 
 KJob* CMakeBuilder::configure( KDevelop::IProject* project )
 {
     if( CMake::currentBuildDir( project ).isEmpty() )
     {
         return new ErrorJob(this, i18n("No Build Directory configured, cannot configure"));
     }
     CMakeJob* job = new CMakeJob(this);
     job->setProject(project);
     connect(job, &KJob::result, this, [this, project] {
         emit configured(project);
     });
     return job;
 }
 
 KJob* CMakeBuilder::prune( KDevelop::IProject* project )
 {
     return new PruneJob(project);
 }
 
 KDevelop::IProjectBuilder* CMakeBuilder::builderForProject(KDevelop::IProject* p) const
 {
     QString builddir = CMake::currentBuildDir( p ).toLocalFile();
     QMap<QString, IProjectBuilder*>::const_iterator it = m_builders.constBegin(), itEnd = m_builders.constEnd();
     for(; it!=itEnd; ++it) {
         if(QFile::exists(builddir+'/'+it.key()))
             return it.value();
     }
     //It means that it still has to be generated, so use the builder for
     //the generator we use
     return m_buildersForGenerator[CMake::defaultGenerator()];
 }
 
 QList< KDevelop::IProjectBuilder* > CMakeBuilder::additionalBuilderPlugins( KDevelop::IProject* project  ) const
 {
     IProjectBuilder* b = builderForProject( project );
     QList< KDevelop::IProjectBuilder* > ret;
     if(b)
         ret << b;
     return ret;
 }
 
 int CMakeBuilder::configPages() const
 {
     return 1;
 }
 
 KDevelop::ConfigPage* CMakeBuilder::configPage(int number, QWidget* parent)
 {
     if (number == 0) {
         return new CMakeBuilderPreferences(this, parent);
     }
     return nullptr;
 }
 
 
 #include "cmakebuilder.moc"
diff --git a/projectbuilders/cmakebuilder/cmakebuilder.h b/projectbuilders/cmakebuilder/cmakebuilder.h
index d0ec823fb0..2c1d59d723 100644
--- a/projectbuilders/cmakebuilder/cmakebuilder.h
+++ b/projectbuilders/cmakebuilder/cmakebuilder.h
@@ -1,84 +1,82 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006-2007 Aleix Pol <aleixpol@gmail.com>
  *
  * 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 CMAKEBUILDER_H
 #define CMAKEBUILDER_H
 
 #include <interfaces/iplugin.h>
 #include <QtCore/QList>
-#include <QtCore/QVariant>
-#include <QtCore/QPair>
-#include <QtCore/QSet>
+#include <QVariantList>
 #include <QUrl>
 #include <project/interfaces/iprojectbuilder.h>
 
 class QStringList;
-class QSignalMapper;
 class KDialog;
+
 namespace KDevelop{
     class ProjectBaseItem;
     class CommandExecutor;
     class OutputModel;
 }
 
 /**
  * @author Aleix Pol
 */
 class CMakeBuilder : public KDevelop::IPlugin, public KDevelop::IProjectBuilder
 {
     Q_OBJECT
     Q_INTERFACES( KDevelop::IProjectBuilder )
 
 public:
     explicit CMakeBuilder(QObject *parent = nullptr, const QVariantList &args = QVariantList());
     ~CMakeBuilder() override;
 
     KJob* build(KDevelop::ProjectBaseItem *dom) override;
     KJob* install(KDevelop::ProjectBaseItem *dom, const QUrl &installPrefix) override;
     KJob* clean(KDevelop::ProjectBaseItem *dom) override;
     KJob* configure(KDevelop::IProject*) override;
     KJob* prune(KDevelop::IProject*) override;
 
 	QList< KDevelop::IProjectBuilder* > additionalBuilderPlugins( KDevelop::IProject* project ) const override;
 
 //     bool updateConfig( KDevelop::IProject* project );
 
     int configPages() const override;
     KDevelop::ConfigPage* configPage(int number, QWidget* parent) override;
 
 Q_SIGNALS:
     void built(KDevelop::ProjectBaseItem*);
     void failed(KDevelop::ProjectBaseItem*);
     void installed(KDevelop::ProjectBaseItem*);
     void cleaned(KDevelop::ProjectBaseItem*);
     void configured(KDevelop::IProject*);
     void pruned(KDevelop::IProject*);
 
 private:
     KJob* checkConfigureJob(KDevelop::IProject* project, bool& valid);
 
     void addBuilder(const QString& neededfile, const QStringList& generator, KDevelop::IPlugin* i);
     KDevelop::IProjectBuilder* builderForProject(KDevelop::IProject* p) const;
     QMap<QString, KDevelop::IProjectBuilder*> m_builders;
     QMap<QString, IProjectBuilder*> m_buildersForGenerator;
 };
 
 #endif // CMAKEBUILDER_H
 
diff --git a/projectbuilders/cmakebuilder/cmakebuilderpreferences.h b/projectbuilders/cmakebuilder/cmakebuilderpreferences.h
index 8e92919237..3ba80234b6 100644
--- a/projectbuilders/cmakebuilder/cmakebuilderpreferences.h
+++ b/projectbuilders/cmakebuilder/cmakebuilderpreferences.h
@@ -1,47 +1,46 @@
 /* KDevelop CCMake Support
  *
  * Copyright 2012 Aleix Pol Gonzalez <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.
  */
 
 #ifndef CMAKEBUILDERPREFERENCES_H
 #define CMAKEBUILDERPREFERENCES_H
 
 #include <interfaces/configpage.h>
 
 class QWidget;
-class QStringList;
 class CMakeBuilderSettings;
 namespace Ui { class CMakeBuilderPreferences; }
 
 class CMakeBuilderPreferences : public KDevelop::ConfigPage
 {
     Q_OBJECT
 
 public:
     explicit CMakeBuilderPreferences(KDevelop::IPlugin* plugin, QWidget* parent = nullptr);
     ~CMakeBuilderPreferences() override;
 
     QString name() const override;
     QString fullName() const override;
     QIcon icon() const override;
 
 private:
     Ui::CMakeBuilderPreferences* m_prefsUi;
 };
 
 #endif
diff --git a/projectbuilders/cmakebuilder/cmakejob.cpp b/projectbuilders/cmakebuilder/cmakejob.cpp
index 6f8f906481..b22983bfa8 100644
--- a/projectbuilders/cmakebuilder/cmakejob.cpp
+++ b/projectbuilders/cmakebuilder/cmakejob.cpp
@@ -1,140 +1,138 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006-2007 Andreas Pakulat <apaku@gmx.de>
  * Copyright 2008 Hamish Rodda <rodda@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 "cmakejob.h"
 
 #include <cmakebuilderconfig.h>
 #include <cmakebuilder.h>
 
-#include <QtCore/QFile>
 #include <QtCore/QDir>
 
 #include <project/projectmodel.h>
 
 #include <interfaces/iproject.h>
 
 #include <kshell.h>
-#include <kjob.h>
 #include <klocalizedstring.h>
 
 #include "cmakeutils.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 CMakeJob::CMakeJob(QObject* parent)
     : OutputExecuteJob(parent)
     , m_project(nullptr)
 {
     setCapabilities( Killable );
     setFilteringStrategy( OutputModel::CompilerFilter );
     setProperties( NeedWorkingDirectory | PortableMessages | DisplayStderr | IsBuilderHint );
     setToolTitle( i18n("CMake") );
     setStandardToolView( KDevelop::IOutputView::BuildView );
     setBehaviours(KDevelop::IOutputView::AllowUserClose | KDevelop::IOutputView::AutoScroll );
 }
 
 void CMakeJob::start()
 {
     qCDebug(CMAKEBUILDER) << "Configuring cmake" << workingDirectory();
 
     if( !m_project ) {
         setError(NoProjectError);
         setErrorText("Internal error: no project specified to configure.");
         emitResult();
         return;
     }
 
     QDir::temp().mkpath(workingDirectory().toLocalFile());
     CMake::updateConfig( m_project, CMake::currentBuildDirIndex(m_project) );
 
     OutputExecuteJob::start();
 }
 
 QUrl CMakeJob::workingDirectory() const
 {
     KDevelop::Path path = CMake::currentBuildDir( m_project );
     qCDebug(CMAKEBUILDER) << "builddir: " << path;
     Q_ASSERT(path.isValid()); //We cannot get the project folder as a build directory!
     return path.toUrl();
 }
 
 QStringList CMakeJob::commandLine() const
 {
     QStringList args;
     args << CMake::currentCMakeExecutable(m_project).toLocalFile();
     args << "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON";
 
     QString installDir = CMake::currentInstallDir( m_project ).toLocalFile();
     if( !installDir.isEmpty() )
     {
         args << QStringLiteral("-DCMAKE_INSTALL_PREFIX=%1").arg(installDir);
     }
     QString buildType = CMake::currentBuildType( m_project );
     if( !buildType.isEmpty() )
     {
         args << QStringLiteral("-DCMAKE_BUILD_TYPE=%1").arg(buildType);
     }
     QVariantMap cacheArgs = property("extraCMakeCacheValues").toMap();
     for( auto it = cacheArgs.constBegin(), itEnd = cacheArgs.constEnd(); it!=itEnd; ++it) {
         args << QStringLiteral("-D%1=%2").arg(it.key()).arg(it.value().toString());
     }
 
     //if we are creating a new build directory, we'll want to specify the generator
     QDir builddir(CMake::currentBuildDir( m_project ).toLocalFile());
     if(!builddir.exists() || !builddir.exists("CMakeCache.txt")) {
         CMakeBuilderSettings::self()->load();
         args << QString("-G") << CMake::defaultGenerator();
     }
     QString cmakeargs = CMake::currentExtraArguments( m_project );
     if( !cmakeargs.isEmpty() ) {
         KShell::Errors err;
         QStringList tmp = KShell::splitArgs( cmakeargs, KShell::TildeExpand | KShell::AbortOnMeta, &err );
         if( err == KShell::NoError ) {
             args += tmp;
         } else {
             qWarning() << "Ignoring cmake Extra arguments";
             if( err == KShell::BadQuoting ) {
                 qWarning() << "CMake arguments badly quoted:" << cmakeargs;
             } else {
                 qWarning() << "CMake arguments had meta character:" << cmakeargs;
             }
         }
     }
     args << CMake::projectRoot( m_project ).toLocalFile();
 
     return args;
 }
 
 QString CMakeJob::environmentProfile() const
 {
     return CMake::currentEnvironment( m_project );
 }
 
 void CMakeJob::setProject(KDevelop::IProject* project)
 {
     m_project = project;
 
     if (m_project)
         setJobName( i18n("CMake: %1", m_project->name()) );
 }
 
diff --git a/projectbuilders/cmakebuilder/cmakejob.h b/projectbuilders/cmakebuilder/cmakejob.h
index b6e51466f4..407f2d3e24 100644
--- a/projectbuilders/cmakebuilder/cmakejob.h
+++ b/projectbuilders/cmakebuilder/cmakejob.h
@@ -1,70 +1,68 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006-2007 Andreas Pakulat <apaku@gmx.de>
  * Copyright 2008 Hamish Rodda <rodda@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.
  */
 
 #ifndef CMAKEJOB_H
 #define CMAKEJOB_H
 
 #include <outputview/outputexecutejob.h>
-#include <QProcess>
-#include <QString>
 
 #include <util/path.h>
 
 namespace KDevelop {
 class IProject;
 class ProjectBaseItem;
 class CommandExecutor;
 }
 
 class CMakeJob: public KDevelop::OutputExecuteJob
 {
     Q_OBJECT
 
 public:
     enum ErrorTypes
     {
         NoProjectError = UserDefinedError,
         FailedError
     };
 
     explicit CMakeJob(QObject* parent = nullptr);
     
     void setProject(KDevelop::IProject* project);
 
     void start() override;
 
     // This returns the build directory for registered item.
     QUrl workingDirectory() const override;
 
     // This returns the "cmake" command line.
     QStringList commandLine() const override;
 
     // This returns the configured global environment profile.
     QString environmentProfile() const override;
 
 private:
     QStringList cmakeArguments( KDevelop::IProject* project );
     KDevelop::Path buildDir( KDevelop::IProject* project );
 
     KDevelop::IProject* m_project;
 };
 
 #endif // CMAKEJOB_H
diff --git a/projectbuilders/makebuilder/makebuilder.cpp b/projectbuilders/makebuilder/makebuilder.cpp
index d1e2e6fe8b..196c58d095 100644
--- a/projectbuilders/makebuilder/makebuilder.cpp
+++ b/projectbuilders/makebuilder/makebuilder.cpp
@@ -1,157 +1,156 @@
 /* This file is part of KDevelop
     Copyright 2004 Roberto Raggi <roberto@kdevelop.org>
     Copyright 2007 Andreas Pakulat <apaku@gmx.de>
     Copyright 2007 Dukju Ahn <dukjuahn@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 "makebuilder.h"
 #include "debug.h"
 #include "makebuilderpreferences.h"
 
 #include <project/projectmodel.h>
 #include <project/builderjob.h>
 
 #include <interfaces/iproject.h>
 
 #include <KPluginFactory>
-#include <KAboutData>
 #include <KConfigGroup>
 
 Q_LOGGING_CATEGORY(MAKEBUILDER, "kdevelop.projectbuilders.makebuilder")
 K_PLUGIN_FACTORY_WITH_JSON(MakeBuilderFactory, "kdevmakebuilder.json", registerPlugin<MakeBuilder>(); )
 
 MakeBuilder::MakeBuilder(QObject *parent, const QVariantList &)
     : KDevelop::IPlugin("kdevmakebuilder", parent)
 {
 }
 
 MakeBuilder::~MakeBuilder()
 {
 }
 
 KJob* MakeBuilder::build( KDevelop::ProjectBaseItem *dom )
 {
     return runMake( dom, MakeJob::BuildCommand );
 }
 
 KJob* MakeBuilder::clean( KDevelop::ProjectBaseItem *dom )
 {
     return runMake( dom, MakeJob::CleanCommand, QStringList("clean") );
 }
 
 KJob* MakeBuilder::install(KDevelop::ProjectBaseItem *dom, const QUrl &installPath)
 {
     KSharedConfigPtr configPtr = dom->project()->projectConfiguration();
     KConfigGroup builderGroup( configPtr, "MakeBuilder" );
     bool installAsRoot = builderGroup.readEntry("Install As Root", false);
 
     QStringList args("install");
     if (!installPath.isEmpty())
         args << "DESTDIR="+installPath.toLocalFile();
 
     if(installAsRoot) {
         KDevelop::BuilderJob* job = new KDevelop::BuilderJob;
         job->addCustomJob( KDevelop::BuilderJob::Build, build(dom), dom );
         job->addCustomJob( KDevelop::BuilderJob::Install, runMake( dom, MakeJob::InstallCommand, args ), dom );
         job->updateJobName();
         return job;
     } else
         return runMake( dom, MakeJob::InstallCommand, args );
 }
 
 void MakeBuilder::jobFinished(KJob* job)
 {
     MakeJob* mj = dynamic_cast<MakeJob*>(job);
 
     if( !mj )
         return;
 
     if (mj->error())
     {
         emit failed( mj->item() );
 
     } else
     {
         switch( mj->commandType() )
         {
             case MakeJob::BuildCommand:
                 emit built( mj->item() );
                 break;
             case MakeJob::InstallCommand:
                 emit installed( mj->item() );
                 break;
             case MakeJob::CleanCommand:
                 emit cleaned( mj->item() );
                 break;
             case MakeJob::CustomTargetCommand:
                 foreach( const QString& target, mj->customTargets() ) {
                     emit makeTargetBuilt( mj->item(), target );
                 }
                 break;
         }
     }
 }
 
 KJob* MakeBuilder::executeMakeTarget(KDevelop::ProjectBaseItem* item,
                                     const QString& targetname )
 {
     return executeMakeTargets( item, QStringList(targetname) );
 }
 
 KJob* MakeBuilder::executeMakeTargets(KDevelop::ProjectBaseItem* item,
                                     const QStringList& targetnames,
                                     const MakeVariables& variables )
 {
     return runMake( item, MakeJob::CustomTargetCommand, targetnames, variables );
 }
 
 KJob* MakeBuilder::runMake( KDevelop::ProjectBaseItem* item, MakeJob::CommandType c,
                             const QStringList& overrideTargets,
                             const MakeVariables& variables )
 {
     ///Running the same builder twice may result in serious problems,
     ///so kill jobs already running on the same project
     foreach (MakeJob* makeJob, m_activeMakeJobs.data())
     {
         if(item && makeJob->item() && makeJob->item()->project() == item->project() && makeJob->commandType() == c) {
             qCDebug(MAKEBUILDER) << "killing running make job, due to new started build on same project:" << makeJob;
             makeJob->kill(KJob::EmitResult);
         }
     }
 
     MakeJob* job = new MakeJob(this, item, c, overrideTargets, variables);
     m_activeMakeJobs.append(job);
 
     connect(job, &MakeJob::finished, this, &MakeBuilder::jobFinished);
     return job;
 }
 
 int MakeBuilder::perProjectConfigPages() const
 {
     return 1;
 }
 
 KDevelop::ConfigPage* MakeBuilder::perProjectConfigPage(int number, const KDevelop::ProjectConfigOptions& options, QWidget* parent)
 {
     if (number == 0) {
         return new MakeBuilderPreferences(this, options, parent);
     }
     return nullptr;
 }
 
 #include "makebuilder.moc"
diff --git a/projectbuilders/makebuilder/makebuilder.h b/projectbuilders/makebuilder/makebuilder.h
index c3c8f102cc..af682c9107 100644
--- a/projectbuilders/makebuilder/makebuilder.h
+++ b/projectbuilders/makebuilder/makebuilder.h
@@ -1,96 +1,94 @@
 /* This file is part of KDevelop
     Copyright 2004 Roberto Raggi <roberto@kdevelop.org>
     Copyright 2007 Andreas Pakulat <apaku@gmx.de>
     Copyright 2007 Dukju Ahn <dukjuahn@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.
 */
 #ifndef MAKEBUILDER_H
 #define MAKEBUILDER_H
 
 #include <interfaces/iplugin.h>
 
-#include <QtCore/QList>
-#include <QtCore/QPair>
-#include <QtCore/QVariant>
+#include <QVariantList>
 
 #include "imakebuilder.h"
 #include "makejob.h"
 
 #include <util/objectlist.h>
 
 namespace KDevelop {
 class ProjectBaseItem;
 }
 
 /**
 @author Roberto Raggi
 */
 class MakeBuilder: public KDevelop::IPlugin, public IMakeBuilder
 {
     Q_OBJECT
     Q_INTERFACES( IMakeBuilder )
     Q_INTERFACES( KDevelop::IProjectBuilder )
 public:
     explicit MakeBuilder(QObject *parent = nullptr, const QVariantList &args = QVariantList());
     ~MakeBuilder() override;
 
     /**
      * If argument is ProjectItem, invoke "make" in IBuildSystemManager::buildDirectory(), with
      * specified target in project setting.
      *
      * If argument is ProjectTargetItem, invoke "make" with targetname QStandardItem::text(). In this case,
      * it tries its best to fetch ProjectItem, which is the argument of IBuildSystemManager::buildDirectory()
      * If it fails to fetch ProjectItem, the top build directory is defaulted to project directory.
      * Based on top build directory, the actual build_dir is computed and handed to outputview
      *
      * If argument is ProjectBuildFolderItem, invoke "make" with specified target in project setting.
      * To determine the build directory, first calculates rel_dir between
      * top_project_dir(ProjectItem::url()) and ProjectBuildFolderItem::url().
      * Then invokes make in top_build_dir/rel_dir.
      * If this fails to fetch top_build_dir, just invoke "make" in ProjectBuildFolderItem::url().
      *
      * @TODO: Work on any project item, for fileitems you may find a target.
      */
     KJob* build(KDevelop::ProjectBaseItem *dom) override;
     KJob* clean(KDevelop::ProjectBaseItem *dom) override;
     KJob* install(KDevelop::ProjectBaseItem *dom, const QUrl &installPath) override;
 
     KJob* executeMakeTarget(KDevelop::ProjectBaseItem* item, const QString& targetname ) override;
     KJob* executeMakeTargets(KDevelop::ProjectBaseItem* item, const QStringList& targetnames,
                                      const MakeVariables& variables = MakeVariables() ) override;
     KJob* runMake( KDevelop::ProjectBaseItem*, MakeJob::CommandType, const QStringList& = QStringList(),
                    const MakeVariables& variables = MakeVariables() );
 
     int perProjectConfigPages() const override;
     KDevelop::ConfigPage* perProjectConfigPage(int number, const KDevelop::ProjectConfigOptions& options, QWidget* parent) override;
 
 Q_SIGNALS:
     void built( KDevelop::ProjectBaseItem* );
     void failed( KDevelop::ProjectBaseItem* );
     void installed(KDevelop::ProjectBaseItem*);
     void cleaned(KDevelop::ProjectBaseItem*);
     void makeTargetBuilt( KDevelop::ProjectBaseItem* item, const QString& targetname );
 
 private Q_SLOTS:
     void jobFinished(KJob* job);
 
 private:
     KDevelop::ObjectList<MakeJob> m_activeMakeJobs;
 };
 
 #endif // KDEVMAKEBUILDER_H
 
diff --git a/projectbuilders/makebuilder/makebuilderpreferences.h b/projectbuilders/makebuilder/makebuilderpreferences.h
index fec1f3dd34..e10eb9e56e 100644
--- a/projectbuilders/makebuilder/makebuilderpreferences.h
+++ b/projectbuilders/makebuilder/makebuilderpreferences.h
@@ -1,53 +1,52 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@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.
  */
 
 #ifndef MAKEBUILDERPREFERENCES_H
 #define MAKEBUILDERPREFERENCES_H
 
 #include <project/projectconfigpage.h>
 
 #include "makebuilderconfig.h"
 
 class QWidget;
-class QStringList;
 namespace Ui { class MakeConfig; }
 
 class MakeBuilderPreferences : public ProjectConfigPage<MakeBuilderSettings>
 {
     Q_OBJECT
 
 public:
     explicit MakeBuilderPreferences(KDevelop::IPlugin* plugin, const KDevelop::ProjectConfigOptions& options, QWidget* parent = nullptr);
     ~MakeBuilderPreferences() override;
     void reset() override;
     void apply() override;
     void defaults() override;
 
     QString name() const override;
     QString fullName() const override;
     QIcon icon() const override;
 
     static QString standardMakeExecutable();
 
 private:
     Ui::MakeConfig* m_prefsUi;
 };
 
 #endif
diff --git a/projectbuilders/makebuilder/makejob.cpp b/projectbuilders/makebuilder/makejob.cpp
index f0c703cbad..b8d0e4fa70 100644
--- a/projectbuilders/makebuilder/makejob.cpp
+++ b/projectbuilders/makebuilder/makejob.cpp
@@ -1,286 +1,284 @@
 /* This file is part of KDevelop
     Copyright 2004 Roberto Raggi <roberto@kdevelop.org>
     Copyright 2007 Andreas Pakulat <apaku@gmx.de>
     Copyright 2007 Dukju Ahn <dukjuahn@gmail.com>
     Copyright 2008 Hamish Rodda <rodda@kde.org>
     Copyright 2012 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 "makejob.h"
 
 #include <QFileInfo>
 #include <QRegularExpression>
 #include <QThread>
-#include <QFileInfo>
 
 #include <KShell>
-#include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 #include <project/projectmodel.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <outputview/outputfilteringstrategies.h>
 
 #include "makebuilder.h"
 #include "makebuilderpreferences.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 class MakeJobCompilerFilterStrategy : public CompilerFilterStrategy
 {
 public:
     using CompilerFilterStrategy::CompilerFilterStrategy;
 
     IFilterStrategy::Progress progressInLine(const QString& line) override;
 };
 
 IFilterStrategy::Progress MakeJobCompilerFilterStrategy::progressInLine(const QString& line)
 {
     // example string: [ 97%] Built target clang-parser
     static const QRegularExpression re("^\\[([\\d ][\\d ]\\d)%\\] (.*)");
 
     QRegularExpressionMatch match = re.match(line);
     if (match.hasMatch()) {
         bool ok;
         const int percent = match.capturedRef(1).toInt(&ok);
         if (ok) {
             // this is output from make, likely
             const QString action = match.captured(2);
             return {action, percent};
         }
     }
 
     return {};
 }
 
 MakeJob::MakeJob(QObject* parent, KDevelop::ProjectBaseItem* item,
                  CommandType c,  const QStringList& overrideTargets,
                  const MakeVariables& variables )
     : OutputExecuteJob(parent)
     , m_idx(item->index())
     , m_command(c)
     , m_overrideTargets(overrideTargets)
     , m_variables(variables)
 {
     auto bsm = item->project()->buildSystemManager();
     auto buildDir = bsm->buildDirectory(item);
 
     Q_ASSERT(item && item->model() && m_idx.isValid() && this->item() == item);
     setCapabilities( Killable );
     setFilteringStrategy(new MakeJobCompilerFilterStrategy(buildDir.toUrl()));
     setProperties( NeedWorkingDirectory | PortableMessages | DisplayStderr | IsBuilderHint );
 
     QString title;
     if( !m_overrideTargets.isEmpty() )
         title = i18n("Make (%1): %2", item->text(), m_overrideTargets.join(" "));
     else
         title = i18n("Make (%1)", item->text());
     setJobName( title );
     setToolTitle( i18n("Make") );
 }
 
 MakeJob::~MakeJob()
 {
 }
 
 void MakeJob::start()
 {
     ProjectBaseItem* it = item();
     qCDebug(MAKEBUILDER) << "Building with make" << m_command << m_overrideTargets.join(" ");
     if (!it)
     {
         setError(ItemNoLongerValidError);
         setErrorText(i18n("Build item no longer available"));
         return emitResult();
     }
 
     if( it->type() == KDevelop::ProjectBaseItem::File ) {
         setError(IncorrectItemError);
         setErrorText(i18n("Internal error: cannot build a file item"));
         return emitResult();
     }
 
     setStandardToolView(IOutputView::BuildView);
     setBehaviours(KDevelop::IOutputView::AllowUserClose | KDevelop::IOutputView::AutoScroll);
 
     OutputExecuteJob::start();
 }
 
 KDevelop::ProjectBaseItem * MakeJob::item() const
 {
     return ICore::self()->projectController()->projectModel()->itemFromIndex(m_idx);
 }
 
 MakeJob::CommandType MakeJob::commandType() const
 {
     return m_command;
 }
 
 QStringList MakeJob::customTargets() const
 {
     return m_overrideTargets;
 }
 
 QUrl MakeJob::workingDirectory() const
 {
     ProjectBaseItem* it = item();
     if(!it)
         return QUrl();
 
     KDevelop::IBuildSystemManager *bldMan = it->project()->buildSystemManager();
     if( bldMan )
         return bldMan->buildDirectory( it ).toUrl(); // the correct build dir
     else
     {
         // Just build in-source, where the build directory equals the one with particular target/source.
         for( ProjectBaseItem* item = it; item; item = item->parent() ) {
             switch( item->type() ) {
             case KDevelop::ProjectBaseItem::Folder:
             case KDevelop::ProjectBaseItem::BuildFolder:
                 return static_cast<KDevelop::ProjectFolderItem*>(item)->path().toUrl();
                 break;
             case KDevelop::ProjectBaseItem::Target:
             case KDevelop::ProjectBaseItem::File:
                 break;
             }
         }
         return QUrl();
     }
 }
 
 QStringList MakeJob::privilegedExecutionCommand() const
 {
     ProjectBaseItem* it = item();
     if(!it)
         return QStringList();
     KSharedConfigPtr configPtr = it->project()->projectConfiguration();
     KConfigGroup builderGroup( configPtr, "MakeBuilder" );
 
     bool runAsRoot = builderGroup.readEntry( "Install As Root", false );
     if ( runAsRoot && m_command == InstallCommand )
     {
         int suCommand = builderGroup.readEntry( "Su Command", 0 );
         QStringList arguments;
         QString suCommandName;
         switch( suCommand ) {
             case 1:
                 return QStringList() << "kdesudo" << "-t";
 
             case 2:
                 return QStringList() << "sudo";
 
             default:
                 return QStringList() << "kdesu" << "-t";
         }
     }
     return QStringList();
 }
 
 QStringList MakeJob::commandLine() const
 {
     ProjectBaseItem* it = item();
     if(!it)
         return QStringList();
     QStringList cmdline;
 
     KSharedConfigPtr configPtr = it->project()->projectConfiguration();
     KConfigGroup builderGroup( configPtr, "MakeBuilder" );
 
     // TODO: migrate to more generic key term "Make Executable"
     QString makeBin = builderGroup.readEntry("Make Binary", MakeBuilderPreferences::standardMakeExecutable());
     cmdline << makeBin;
 
     if( ! builderGroup.readEntry("Abort on First Error", true))
     {
         cmdline << (isNMake(makeBin) ? "/K" : "-k");
     }
 
     // note: nmake does not support the -j flag
     if (!isNMake(makeBin)) {
         if (builderGroup.readEntry("Override Number Of Jobs", false)) {
             int jobCount = builderGroup.readEntry("Number Of Jobs", 1);
             if (jobCount > 0) {
                 cmdline << QString("-j%1").arg(jobCount);
             }
         } else {
             // use the ideal thread count by default
             cmdline << QString("-j%1").arg(QThread::idealThreadCount());
         }
     }
 
     if( builderGroup.readEntry("Display Only", false) )
     {
         cmdline << (isNMake(makeBin) ? "/N" : "-n");
     }
 
     QString extraOptions = builderGroup.readEntry("Additional Options", QString());
     if( ! extraOptions.isEmpty() )
     {
         foreach(const QString& option, KShell::splitArgs( extraOptions ) )
             cmdline << option;
     }
 
     for (MakeVariables::const_iterator it = m_variables.constBegin(); it != m_variables.constEnd(); ++it)
     {
         cmdline += QString("%1=%2").arg(it->first).arg(it->second);
     }
 
     if( m_overrideTargets.isEmpty() )
     {
         QString target;
         switch (it->type()) {
             case KDevelop::ProjectBaseItem::Target:
             case KDevelop::ProjectBaseItem::ExecutableTarget:
             case KDevelop::ProjectBaseItem::LibraryTarget:
                 Q_ASSERT(it->target());
                 cmdline << it->target()->text();
                 break;
             case KDevelop::ProjectBaseItem::BuildFolder:
                 target = builderGroup.readEntry("Default Target", QString());
                 if( !target.isEmpty() )
                     cmdline << target;
                 break;
             default: break;
         }
     }else
     {
         cmdline += m_overrideTargets;
     }
 
     return cmdline;
 }
 
 QString MakeJob::environmentProfile() const
 {
     ProjectBaseItem* it = item();
     if(!it)
         return QString();
     KSharedConfigPtr configPtr = it->project()->projectConfiguration();
     KConfigGroup builderGroup( configPtr, "MakeBuilder" );
     return builderGroup.readEntry( "Default Make Environment Profile", QString() );
 }
 
 bool MakeJob::isNMake(const QString& makeBin)
 {
     return !QFileInfo(makeBin).baseName().compare(QStringLiteral("nmake"), Qt::CaseInsensitive);
 }
diff --git a/projectbuilders/makebuilder/makejob.h b/projectbuilders/makebuilder/makejob.h
index 1d00ac46bc..3efe236145 100644
--- a/projectbuilders/makebuilder/makejob.h
+++ b/projectbuilders/makebuilder/makejob.h
@@ -1,97 +1,96 @@
 /* This file is part of KDevelop
     Copyright 2004 Roberto Raggi <roberto@kdevelop.org>
     Copyright 2007 Andreas Pakulat <apaku@gmx.de>
     Copyright 2007 Dukju Ahn <dukjuahn@gmail.com>
     Copyright 2008 Hamish Rodda <rodda@kde.org>
     Copyright 2012 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.
 */
 
 #ifndef MAKEJOB_H
 #define MAKEJOB_H
 
 #include <outputview/outputexecutejob.h>
 
 #include <QString>
-#include <QProcess>
 
 #include "imakebuilder.h"
 
 namespace KDevelop {
 class OutputModel;
 class ProjectBaseItem;
 class ProcessLineMaker;
 }
 
 class QUrl;
 
 class MakeJob: public KDevelop::OutputExecuteJob
 {
     Q_OBJECT
 
 public:
     enum CommandType
     {
         BuildCommand,
         CleanCommand,
         CustomTargetCommand,
         InstallCommand
     };
 
     enum ErrorTypes
     {
         IncorrectItemError = UserDefinedError,
         ItemNoLongerValidError,
         BuildCommandError,
         FailedError = FailedShownError
     };
 
     MakeJob( QObject* parent, KDevelop::ProjectBaseItem* item,
              CommandType command, const QStringList& overrideTargets = QStringList(),
              const MakeVariables& variables = MakeVariables() );
     ~MakeJob() override;
 
     void start() override;
 
     KDevelop::ProjectBaseItem* item() const;
     CommandType commandType() const;
     QStringList customTargets() const;
 
 
     // This returns the build directory for registered item.
     QUrl workingDirectory() const override;
 
     // This returns the "make" command line.
     QStringList commandLine() const override;
 
     // This returns the configured privileged execution command (if specified by user).
     QStringList privilegedExecutionCommand() const override;
 
     // This returns the configured global environment profile.
     QString environmentProfile() const override;
 
 private:
     static bool isNMake(const QString& makeBin);
     
     QPersistentModelIndex m_idx;
     CommandType m_command;
     QStringList m_overrideTargets;
     MakeVariables m_variables;
 };
 
 #endif // MAKEJOB_H
 
diff --git a/projectbuilders/ninjabuilder/ninjabuilder.cpp b/projectbuilders/ninjabuilder/ninjabuilder.cpp
index d08ac6be3f..99799317e6 100644
--- a/projectbuilders/ninjabuilder/ninjabuilder.cpp
+++ b/projectbuilders/ninjabuilder/ninjabuilder.cpp
@@ -1,211 +1,210 @@
 /* This file is part of KDevelop
     Copyright 2012 Aleix Pol Gonzalez <aleixpol@kde.org>
     Copyright 2017 Kevin Funk <kfunk@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
 
 #include "ninjabuilder.h"
 
 #include "ninjajob.h"
 #include "ninjabuilderpreferences.h"
 
-#include <KAboutData>
 #include <KPluginFactory>
 #include <KConfigGroup>
 #include <KShell>
 #include <project/projectmodel.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <project/builderjob.h>
 #include <interfaces/iproject.h>
 
 #include <QFile>
 #include <QLoggingCategory>
 
 Q_DECLARE_LOGGING_CATEGORY(NINJABUILDER)
 
 Q_LOGGING_CATEGORY(NINJABUILDER, "kdevelop.projectbuilders.ninjabuilder")
 K_PLUGIN_FACTORY_WITH_JSON(NinjaBuilderFactory, "kdevninja.json", registerPlugin<NinjaBuilder>(); )
 
 NinjaBuilder::NinjaBuilder(QObject* parent, const QVariantList&)
     : KDevelop::IPlugin("kdevninja", parent)
 {
     if (NinjaJob::ninjaExecutable().isEmpty()) {
         setErrorDescription(i18n("Unable to find ninja executable. Is it installed on the system?"));
     }
 }
 
 static QStringList targetsInFolder(KDevelop::ProjectFolderItem* item)
 {
     QStringList ret;
     foreach (KDevelop::ProjectTargetItem* target, item->targetList()) {
         ret += target->text();
     }
 
     return ret;
 }
 
 /**
  * Returns the first non-empty list of targets in folder @p item
  * or any of its ancestors if possible
  */
 static QStringList closestTargetsForFolder(KDevelop::ProjectFolderItem* item)
 {
     KDevelop::ProjectFolderItem* current = item;
     while (current) {
         const QStringList targets = targetsInFolder(current);
         if (!targets.isEmpty()) {
             return targets;
         }
         current = (current->parent() ? current->parent()->folder() : nullptr);
     }
     return QStringList();
 }
 
 static QStringList argumentsForItem(KDevelop::ProjectBaseItem* item)
 {
     if (!item->parent() &&
         QFile::exists(item->project()->buildSystemManager()->buildDirectory(item->project()->projectItem()).toLocalFile())) {
         return QStringList();
     }
 
     switch (item->type()) {
     case KDevelop::ProjectBaseItem::File:
         return QStringList(item->path().toLocalFile() + '^');
     case KDevelop::ProjectBaseItem::Target:
     case KDevelop::ProjectBaseItem::ExecutableTarget:
     case KDevelop::ProjectBaseItem::LibraryTarget:
         return QStringList(item->target()->text());
     case KDevelop::ProjectBaseItem::Folder:
     case KDevelop::ProjectBaseItem::BuildFolder:
         return closestTargetsForFolder(item->folder());
     }
     return QStringList();
 }
 
 NinjaJob* NinjaBuilder::runNinja(KDevelop::ProjectBaseItem* item, NinjaJob::CommandType commandType,
                                            const QStringList& args, const QByteArray& signal)
 {
     ///Running the same builder twice may result in serious problems,
     ///so kill jobs already running on the same project
     foreach (NinjaJob* ninjaJob, m_activeNinjaJobs.data()) {
         if (item && ninjaJob->item() && ninjaJob->item()->project() == item->project() && ninjaJob->commandType() == commandType) {
             qCDebug(NINJABUILDER) << "killing running ninja job, due to new started build on same project:" << ninjaJob;
             ninjaJob->kill(KJob::EmitResult);
         }
     }
 
     // Build arguments using data from KCM
     QStringList jobArguments;
     KSharedConfigPtr config = item->project()->projectConfiguration();
     KConfigGroup group = config->group("NinjaBuilder");
 
     if (!group.readEntry("Abort on First Error", true)) {
         jobArguments << "-k";
     }
     if (group.readEntry("Override Number Of Jobs", false)) {
         int jobCount = group.readEntry("Number Of Jobs", 1);
         if (jobCount > 0) {
             jobArguments << QString("-j%1").arg(jobCount);
         }
     }
     int errorCount = group.readEntry("Number Of Errors", 1);
     if (errorCount > 1) {
         jobArguments << QString("-k%1").arg(errorCount);
     }
     if (group.readEntry("Display Only", false)) {
         jobArguments << "-n";
     }
     QString extraOptions = group.readEntry("Additional Options", QString());
     if (!extraOptions.isEmpty()) {
         foreach (const QString& option, KShell::splitArgs(extraOptions)) {
             jobArguments << option;
         }
     }
     jobArguments << args;
 
     NinjaJob* job = new NinjaJob(item, commandType, jobArguments, signal, this);
     m_activeNinjaJobs.append(job);
     return job;
 }
 
 KJob* NinjaBuilder::build(KDevelop::ProjectBaseItem* item)
 {
     return runNinja(item, NinjaJob::BuildCommand, argumentsForItem(item), "built");
 }
 
 KJob* NinjaBuilder::clean(KDevelop::ProjectBaseItem* item)
 {
     return runNinja(item, NinjaJob::CleanCommand, QStringList("-t") << "clean", "cleaned");
 }
 
 KJob* NinjaBuilder::install(KDevelop::ProjectBaseItem* item)
 {
     NinjaJob* installJob = runNinja(item, NinjaJob::InstallCommand, QStringList("install"), "installed");
     installJob->setIsInstalling(true);
 
     KSharedConfigPtr configPtr = item->project()->projectConfiguration();
     KConfigGroup builderGroup(configPtr, "NinjaBuilder");
     bool installAsRoot = builderGroup.readEntry("Install As Root", false);
     if (installAsRoot) {
         KDevelop::BuilderJob* job = new KDevelop::BuilderJob;
         job->addCustomJob(KDevelop::BuilderJob::Build, build(item), item);
         job->addCustomJob(KDevelop::BuilderJob::Install, installJob, item);
         job->updateJobName();
         return job;
     } else {
         return installJob;
     }
 }
 
 int NinjaBuilder::perProjectConfigPages() const
 {
     return 1;
 }
 
 KDevelop::ConfigPage* NinjaBuilder::perProjectConfigPage(int number, const KDevelop::ProjectConfigOptions& options, QWidget* parent)
 {
     if (number == 0) {
         return new NinjaBuilderPreferences(this, options, parent);
     }
     return nullptr;
 }
 
 class ErrorJob
     : public KJob
 {
 public:
     ErrorJob(QObject* parent, const QString& error)
         : KJob(parent)
         , m_error(error)
     {}
 
     void start() override
     {
         setError(!m_error.isEmpty());
         setErrorText(m_error);
         emitResult();
     }
 
 private:
     QString m_error;
 };
 
 KJob* NinjaBuilder::install(KDevelop::ProjectBaseItem* dom, const QUrl& installPath)
 {
     return installPath.isEmpty() ? install(dom) : new ErrorJob(nullptr, i18n("Cannot specify prefix in %1, on ninja", installPath.toDisplayString()));
 }
 
 #include "ninjabuilder.moc"
diff --git a/projectbuilders/ninjabuilder/ninjabuilderpreferences.cpp b/projectbuilders/ninjabuilder/ninjabuilderpreferences.cpp
index 965e23bbc5..5adc9ee81f 100644
--- a/projectbuilders/ninjabuilder/ninjabuilderpreferences.cpp
+++ b/projectbuilders/ninjabuilder/ninjabuilderpreferences.cpp
@@ -1,64 +1,60 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@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 "ninjabuilderpreferences.h"
 
-#include <kpluginfactory.h>
-#include <kpluginloader.h>
-#include <KAboutData>
-
 #include "ui_ninjaconfig.h"
 #include "ninjabuilderconfig.h"
 
 using namespace KDevelop;
 
 NinjaBuilderPreferences::NinjaBuilderPreferences(IPlugin* plugin,
                                                  const ProjectConfigOptions& options,
                                                  QWidget* parent)
     : ProjectConfigPage<NinjaBuilderSettings>(plugin, options, parent)
 {
     m_prefsUi = new Ui::NinjaConfig;
     m_prefsUi->setupUi(this);
 
     connect(m_prefsUi->configureEnvironment, &EnvironmentConfigureButton::environmentConfigured,
             this, &NinjaBuilderPreferences::changed);
 
     m_prefsUi->configureEnvironment->setSelectionWidget(m_prefsUi->kcfg_environmentProfile);
 }
 
 NinjaBuilderPreferences::~NinjaBuilderPreferences()
 {
     delete m_prefsUi;
 }
 
 QString NinjaBuilderPreferences::name() const
 {
     return i18n("Ninja");
 }
 
 QString NinjaBuilderPreferences::fullName() const
 {
     return i18n("Configure Ninja settings");
 }
 
 QIcon NinjaBuilderPreferences::icon() const
 {
     return QIcon::fromTheme(QStringLiteral("run-build"));
 }
diff --git a/projectbuilders/ninjabuilder/ninjabuilderpreferences.h b/projectbuilders/ninjabuilder/ninjabuilderpreferences.h
index aa36965d78..0559f7183f 100644
--- a/projectbuilders/ninjabuilder/ninjabuilderpreferences.h
+++ b/projectbuilders/ninjabuilder/ninjabuilderpreferences.h
@@ -1,51 +1,50 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@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.
  */
 
 #ifndef NINJABUILDERPREFERENCES_H
 #define NINJABUILDERPREFERENCES_H
 
 #include <project/projectconfigpage.h>
 
 #include "ninjabuilderconfig.h"
 
 class QWidget;
-class QStringList;
 namespace Ui {
 class NinjaConfig;
 }
 
 class NinjaBuilderPreferences
     : public ProjectConfigPage<NinjaBuilderSettings>
 {
     Q_OBJECT
 
 public:
     explicit NinjaBuilderPreferences(KDevelop::IPlugin* plugin, const KDevelop::ProjectConfigOptions& options, QWidget* parent = nullptr);
     ~NinjaBuilderPreferences() override;
 
     QString name() const override;
     QString fullName() const override;
     QIcon icon() const override;
 
 private:
     Ui::NinjaConfig* m_prefsUi;
 };
 
 #endif
diff --git a/projectbuilders/qmakebuilder/qmakebuilder.cpp b/projectbuilders/qmakebuilder/qmakebuilder.cpp
index 86cc41449e..b15bb40b00 100644
--- a/projectbuilders/qmakebuilder/qmakebuilder.cpp
+++ b/projectbuilders/qmakebuilder/qmakebuilder.cpp
@@ -1,182 +1,180 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006-2007 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 "qmakebuilder.h"
 
 #include "qmakebuilderpreferences.h"
 #include "qmakeconfig.h"
 #include "qmakeutils.h"
 
-#include <QtCore/QStringList>
 #include <QDebug>
 #include <project/projectmodel.h>
 
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <outputview/ioutputview.h>
 #include <makebuilder/imakebuilder.h>
 #include <util/commandexecutor.h>
 
 #include <kpluginfactory.h>
-#include <kaboutdata.h>
 
 #include "qmakejob.h"
 #include "qmakebuilderdebug.h"
 
 using namespace KDevelop;
 
 K_PLUGIN_FACTORY_WITH_JSON(QMakeBuilderFactory, "kdevqmakebuilder.json", registerPlugin<QMakeBuilder>();)
 
 QMakeBuilder::QMakeBuilder(QObject* parent, const QVariantList&)
     : KDevelop::IPlugin("kdevqmakebuilder", parent)
 {
     m_makeBuilder = core()->pluginController()->pluginForExtension("org.kdevelop.IMakeBuilder");
     if (m_makeBuilder) {
         IMakeBuilder* mbuilder = m_makeBuilder->extension<IMakeBuilder>();
         if (mbuilder) {
             connect(m_makeBuilder, SIGNAL(built(KDevelop::ProjectBaseItem*)), this,
                     SIGNAL(built(KDevelop::ProjectBaseItem*)));
             connect(m_makeBuilder, SIGNAL(cleaned(KDevelop::ProjectBaseItem*)), this,
                     SIGNAL(cleaned(KDevelop::ProjectBaseItem*)));
             connect(m_makeBuilder, SIGNAL(installed(KDevelop::ProjectBaseItem*)), this,
                     SIGNAL(installed(KDevelop::ProjectBaseItem*)));
             connect(m_makeBuilder, SIGNAL(failed(KDevelop::ProjectBaseItem*)), this,
                     SIGNAL(failed(KDevelop::ProjectBaseItem*)));
             connect(m_makeBuilder, SIGNAL(makeTargetBuilt(KDevelop::ProjectBaseItem*, const QString&)), this,
                     SIGNAL(pruned(KDevelop::ProjectBaseItem*)));
         }
     }
 }
 
 QMakeBuilder::~QMakeBuilder()
 {
 }
 
 KJob* QMakeBuilder::prune(KDevelop::IProject* project)
 {
     qCDebug(KDEV_QMAKEBUILDER) << "Distcleaning";
     if (m_makeBuilder) {
         IMakeBuilder* builder = m_makeBuilder->extension<IMakeBuilder>();
         if (builder) {
             qCDebug(KDEV_QMAKEBUILDER) << "Distcleaning with make";
             return builder->executeMakeTarget(project->projectItem(), "distclean");
         }
     }
     return nullptr;
 }
 
 KJob* QMakeBuilder::build(KDevelop::ProjectBaseItem* dom)
 {
     qCDebug(KDEV_QMAKEBUILDER) << "Building";
     if (m_makeBuilder) {
         IMakeBuilder* builder = m_makeBuilder->extension<IMakeBuilder>();
         if (builder) {
             qCDebug(KDEV_QMAKEBUILDER) << "Building with make";
             return maybePrependConfigureJob(dom, builder->build(dom), BuilderJob::Build);
         }
     }
     return nullptr;
 }
 
 KJob* QMakeBuilder::configure(KDevelop::IProject* project)
 {
     auto job = new QMakeJob(this);
     job->setProject(project);
     return job;
 }
 
 KJob* QMakeBuilder::clean(KDevelop::ProjectBaseItem* dom)
 {
     qCDebug(KDEV_QMAKEBUILDER) << "Cleaning";
     if (m_makeBuilder) {
         IMakeBuilder* builder = m_makeBuilder->extension<IMakeBuilder>();
         if (builder) {
             qCDebug(KDEV_QMAKEBUILDER) << "Cleaning with make";
             return maybePrependConfigureJob(dom, builder->clean(dom), BuilderJob::Clean);
         }
     }
     return nullptr;
 }
 
 KJob* QMakeBuilder::install(KDevelop::ProjectBaseItem* dom, const QUrl& /* prefix */)
 {
     qCDebug(KDEV_QMAKEBUILDER) << "Installing";
     if (m_makeBuilder) {
         IMakeBuilder* builder = m_makeBuilder->extension<IMakeBuilder>();
         if (builder) {
             qCDebug(KDEV_QMAKEBUILDER) << "Installing with make";
             return maybePrependConfigureJob(dom, builder->install(dom), BuilderJob::Install);
         }
     }
     return nullptr;
 }
 
 int QMakeBuilder::perProjectConfigPages() const
 {
     return 1;
 }
 
 KDevelop::ConfigPage* QMakeBuilder::perProjectConfigPage(int number, const KDevelop::ProjectConfigOptions& options,
                                                          QWidget* parent)
 {
     switch (number) {
     case 0:
         return new QMakeBuilderPreferences(this, options, parent);
     default:
         return nullptr;
     }
 }
 
 QList<IProjectBuilder*> QMakeBuilder::additionalBuilderPlugins(KDevelop::IProject* project) const
 {
     Q_UNUSED(project);
 
     if (IMakeBuilder* makeBuilder = m_makeBuilder->extension<IMakeBuilder>()) {
         return QList<KDevelop::IProjectBuilder*>() << makeBuilder;
     }
 
     return QList<IProjectBuilder*>();
 }
 
 KJob* QMakeBuilder::maybePrependConfigureJob(ProjectBaseItem* dom, KJob* job, BuilderJob::BuildType type)
 {
     Q_ASSERT(dom);
 
     if (!job) {
         qCDebug(KDEV_QMAKEBUILDER) << "Null job passed";
         return nullptr;
     }
 
     const bool needsConfigure = QMakeUtils::checkForNeedingConfigure(dom->project());
     if (needsConfigure) {
         qCDebug(KDEV_QMAKEBUILDER) << "Project" << dom->project()->name() << "needs configure";
 
         auto builderJob = new BuilderJob;
         builderJob->addCustomJob(BuilderJob::Configure, configure(dom->project()), dom);
         builderJob->addCustomJob(type, job, dom);
         builderJob->updateJobName();
         return builderJob;
     }
 
     return job;
 }
 
 #include "qmakebuilder.moc"
diff --git a/projectbuilders/qmakebuilder/qmakebuilder.h b/projectbuilders/qmakebuilder/qmakebuilder.h
index f58900852b..f2ae6545f6 100644
--- a/projectbuilders/qmakebuilder/qmakebuilder.h
+++ b/projectbuilders/qmakebuilder/qmakebuilder.h
@@ -1,75 +1,75 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006-2007 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.
  */
 
 #ifndef QMAKEBUILDER_H
 #define QMAKEBUILDER_H
 
 #include <interfaces/iplugin.h>
 #include "iqmakebuilder.h"
 
 #include <project/builderjob.h>
 
-#include <QtCore/QVariant>
+#include <QVariantList>
 
 /**
 @author Andreas Pakulat
 */
 class QMakeBuilder : public KDevelop::IPlugin, public IQMakeBuilder
 {
     Q_OBJECT
     Q_INTERFACES( IQMakeBuilder )
     Q_INTERFACES( KDevelop::IProjectBuilder )
 
 public:
     explicit QMakeBuilder(QObject *parent = nullptr, const QVariantList &args = QVariantList());
     ~QMakeBuilder() override;
 
     KJob* build(KDevelop::ProjectBaseItem *dom) override;
     KJob* clean(KDevelop::ProjectBaseItem *dom) override;
     KJob* install(KDevelop::ProjectBaseItem *dom, const QUrl& /* prefix */) override;
     KJob* configure(KDevelop::IProject *dom) override;
     KJob* prune(KDevelop::IProject *dom) override;
 
     int perProjectConfigPages() const override;
     KDevelop::ConfigPage* perProjectConfigPage(int number, const KDevelop::ProjectConfigOptions& options, QWidget* parent) override;
 
     QList<IProjectBuilder*> additionalBuilderPlugins(KDevelop::IProject* project) const override;
 
 Q_SIGNALS:
     void built(KDevelop::ProjectBaseItem*);
     void failed(KDevelop::ProjectBaseItem*);
     void installed(KDevelop::ProjectBaseItem*);
     void cleaned(KDevelop::ProjectBaseItem*);
     void configured(KDevelop::ProjectBaseItem*);
     void pruned(KDevelop::ProjectBaseItem*);
 
 private:
     /**
      * If @p dom needs a configure run, return a composite job consisting of configure job + @p job
      *
      * Otherwise just return @p job
      */
     KJob* maybePrependConfigureJob(KDevelop::ProjectBaseItem* project, KJob* job, KDevelop::BuilderJob::BuildType type);
 
     KDevelop::IPlugin* m_makeBuilder;
 };
 
 #endif // QMAKEBUILDER_H
 
diff --git a/projectbuilders/qmakebuilder/qmakebuilderpreferences.cpp b/projectbuilders/qmakebuilder/qmakebuilderpreferences.cpp
index 99e97d4e11..db89066273 100644
--- a/projectbuilders/qmakebuilder/qmakebuilderpreferences.cpp
+++ b/projectbuilders/qmakebuilder/qmakebuilderpreferences.cpp
@@ -1,171 +1,169 @@
 /* KDevelop QMake Support
  *
  * Copyright 2007 Andreas Pakulat <apaku@gmx.de>
  * Copyright 2014 Kevin Funk <kfunk@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 "qmakebuilderpreferences.h"
 
 #include <QIcon>
 #include <QDebug>
 
 #include <kio/deletejob.h>
-#include <kaboutdata.h>
 #include <klocalizedstring.h>
-#include <kurlrequester.h>
 #include <KMessageBox>
 #include <KJobWidgets>
 
 #include "ui_qmakeconfig.h"
 #include "qmakebuilddirchooser.h"
 #include "qmakebuilddirchooserdialog.h"
 #include "qmakeconfig.h"
 #include "qmakebuilderconfig.h"
 #include "qmakebuilderdebug.h"
 
 #include <interfaces/iproject.h>
 
 QMakeBuilderPreferences::QMakeBuilderPreferences(KDevelop::IPlugin* plugin,
                                                  const KDevelop::ProjectConfigOptions& options, QWidget* parent)
     : KDevelop::ConfigPage(plugin, nullptr, parent)
     , m_project(options.project)
 {
     m_prefsUi = new Ui::QMakeConfig;
     m_prefsUi->setupUi(this);
 
     // display icons instead of text
     m_prefsUi->addButton->setIcon(QIcon::fromTheme("list-add"));
     m_prefsUi->addButton->setText(QString());
     m_prefsUi->removeButton->setIcon(QIcon::fromTheme("list-remove"));
     m_prefsUi->removeButton->setText(QString());
 
     m_chooserUi = new QMakeBuildDirChooser(m_project);
     auto groupBoxLayout = new QVBoxLayout(m_prefsUi->groupBox);
     groupBoxLayout->addWidget(m_chooserUi);
 
     m_chooserUi->kcfg_buildDir->setEnabled(false); // build directory MUST NOT be changed here
     connect(m_chooserUi, &QMakeBuildDirChooser::changed, this, &QMakeBuilderPreferences::changed);
     connect(m_chooserUi, &QMakeBuildDirChooser::changed, this, &QMakeBuilderPreferences::validate);
 
     connect(m_prefsUi->buildDirCombo, SIGNAL(currentIndexChanged(QString)), this, SLOT(loadOtherConfig(QString)));
     connect(m_prefsUi->buildDirCombo, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
             &QMakeBuilderPreferences::changed);
     connect(m_prefsUi->addButton, SIGNAL(pressed()), this, SLOT(addBuildConfig()));
     connect(m_prefsUi->removeButton, SIGNAL(pressed()), this, SLOT(removeBuildConfig()));
 
     reset(); // load initial values
 }
 
 QMakeBuilderPreferences::~QMakeBuilderPreferences()
 {
     // not a QObject !
     delete m_chooserUi;
 }
 
 void QMakeBuilderPreferences::reset()
 {
     qCDebug(KDEV_QMAKEBUILDER) << "loading data";
     // refresh combobox
     KConfigGroup cg(m_project->projectConfiguration(), QMakeConfig::CONFIG_GROUP);
     const QString buildPath = cg.readEntry(QMakeConfig::BUILD_FOLDER, QString());
 
     // update build list (this will trigger loadOtherConfig if signals are still connected)
     disconnect(m_prefsUi->buildDirCombo, SIGNAL(currentIndexChanged(QString)), this, SLOT(loadOtherConfig(QString)));
     m_prefsUi->buildDirCombo->clear();
     m_prefsUi->buildDirCombo->insertItems(0, cg.groupList());
     if (m_prefsUi->buildDirCombo->contains(buildPath)) {
         m_prefsUi->buildDirCombo->setCurrentItem(buildPath);
         m_chooserUi->loadConfig(buildPath);
     }
     qCDebug(KDEV_QMAKEBUILDER) << "Loaded" << cg.groupList() << buildPath;
     m_prefsUi->removeButton->setEnabled(m_prefsUi->buildDirCombo->count() > 1);
     connect(m_prefsUi->buildDirCombo, SIGNAL(currentIndexChanged(QString)), this, SLOT(loadOtherConfig(QString)));
 
     validate();
 }
 
 QString QMakeBuilderPreferences::name() const
 {
     return i18n("QMake");
 }
 
 void QMakeBuilderPreferences::apply()
 {
     qCDebug(KDEV_QMAKEBUILDER) << "Saving data";
     QString errormsg;
 
     if (m_chooserUi->validate(&errormsg)) {
         // data is valid: save, once in the build dir's data and also as current data
         m_chooserUi->saveConfig();
         KConfigGroup config(m_project->projectConfiguration(), QMakeConfig::CONFIG_GROUP);
         m_chooserUi->saveConfig(config);
         config.writeEntry(QMakeConfig::BUILD_FOLDER, m_chooserUi->buildDir());
     } else {
         // invalid data: message box
         KMessageBox::error(nullptr, errormsg, "Data is invalid!");
         // FIXME dialog behaves like if save really happened (dialog closes if user click ok) even if changed signal is
         // emitted
     }
 }
 
 void QMakeBuilderPreferences::validate()
 {
     m_chooserUi->validate();
 }
 
 void QMakeBuilderPreferences::loadOtherConfig(const QString& config)
 {
     qCDebug(KDEV_QMAKEBUILDER) << "Loading config " << config;
     m_chooserUi->loadConfig(config);
     apply(); // since current config has changed, it must be saved immediateley
 }
 
 void QMakeBuilderPreferences::addBuildConfig()
 {
     qCDebug(KDEV_QMAKEBUILDER) << "Adding a new config.";
     // for more simpicity, just launch regular dialog
     auto dlg = new QMakeBuildDirChooserDialog(m_project);
     if (dlg->exec() == QDialog::Accepted) {
         m_prefsUi->buildDirCombo->setCurrentItem(dlg->buildDir(), true);
         m_prefsUi->removeButton->setEnabled(m_prefsUi->buildDirCombo->count() > 1);
         // TODO run qmake
     }
 }
 
 void QMakeBuilderPreferences::removeBuildConfig()
 {
     qCDebug(KDEV_QMAKEBUILDER) << "Removing config" << m_prefsUi->buildDirCombo->currentText();
     QString removed = m_prefsUi->buildDirCombo->currentText();
     KConfigGroup cg(m_project->projectConfiguration(), QMakeConfig::CONFIG_GROUP);
 
     m_prefsUi->buildDirCombo->removeItem(m_prefsUi->buildDirCombo->currentIndex());
     m_prefsUi->removeButton->setEnabled(m_prefsUi->buildDirCombo->count() > 1);
     cg.group(removed).deleteGroup(KConfigBase::Persistent);
 
     if (QDir(removed).exists()) {
         int ret = KMessageBox::warningYesNo(this, i18n("The %1 directory is about to be removed in KDevelop's list.\n"
                                                        "Do you want KDevelop to remove it in the file system as well?",
                                                        removed));
         if (ret == KMessageBox::Yes) {
             auto deleteJob = KIO::del(QUrl::fromLocalFile(removed));
             KJobWidgets::setWindow(deleteJob, this);
             if (!deleteJob->exec())
                 KMessageBox::error(this, i18n("Could not remove: %1.", removed));
         }
     }
 }
diff --git a/projectbuilders/qmakebuilder/qmakebuilderpreferences.h b/projectbuilders/qmakebuilder/qmakebuilderpreferences.h
index 4d0cad01f6..4060b6ceac 100644
--- a/projectbuilders/qmakebuilder/qmakebuilderpreferences.h
+++ b/projectbuilders/qmakebuilder/qmakebuilderpreferences.h
@@ -1,64 +1,63 @@
 /* KDevelop QMake Support
  *
  * Copyright 2007 Andreas Pakulat <apaku@gmx.de>
  * Copyright 2014 Kevin Funk <kfunk@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.
  */
 
 #ifndef QMAKEBUILDERPREFERENCES_H
 #define QMAKEBUILDERPREFERENCES_H
 
 #include <project/projectconfigpage.h>
 
 class QWidget;
-class QStringList;
 class QMakeBuilderSettings;
 class QMakeBuildDirChooser;
 namespace Ui {
     class QMakeConfig;
     class QMakeBuildDirChooser;
 }
 
 /**
  * @author Andreas Pakulat <apaku@gmx.de>
  */
 class QMakeBuilderPreferences : public KDevelop::ConfigPage
 {
     Q_OBJECT
 
 public:
     explicit QMakeBuilderPreferences(KDevelop::IPlugin* plugin, const KDevelop::ProjectConfigOptions& options, QWidget* parent = nullptr);
     ~QMakeBuilderPreferences() override;
 
 public slots:
     void apply() override;
     void reset() override;
     QString name() const override;
 
     void loadOtherConfig(const QString &config);
     void addBuildConfig();
     void removeBuildConfig();
     void validate();
 
 private:
     KDevelop::IProject* m_project;
 
     Ui::QMakeConfig* m_prefsUi;
     QMakeBuildDirChooser* m_chooserUi;
 };
 
 #endif
diff --git a/projectmanagers/cmake/cmakebuilddirchooser.cpp b/projectmanagers/cmake/cmakebuilddirchooser.cpp
index 733592cbc9..6f398f1a2a 100644
--- a/projectmanagers/cmake/cmakebuilddirchooser.cpp
+++ b/projectmanagers/cmake/cmakebuilddirchooser.cpp
@@ -1,311 +1,308 @@
 /* KDevelop CMake Support
  *
  * Copyright 2007 Aleix Pol <aleixpol@gmail.com>
  *
  * 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 "cmakebuilddirchooser.h"
 #include "ui_cmakebuilddirchooser.h"
 #include "cmakeutils.h"
 #include "debug.h"
 
 #include <project/helper.h>
 
 #include <KColorScheme>
 #include <KLocalizedString>
-#include <KSharedConfig>
-#include <KConfigGroup>
 
 #include <QDir>
-#include <QStandardPaths>
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 
 using namespace KDevelop;
 
 CMakeBuildDirChooser::CMakeBuildDirChooser(QWidget* parent)
     : QDialog(parent)
 {
     setWindowTitle(i18n("Configure a build directory"));
 
     m_buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     m_buttonBox->button(QDialogButtonBox::Ok)->setDefault(true);
     connect(m_buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
     connect(m_buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
     auto mainWidget = new QWidget(this);
     auto mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
     mainLayout->addWidget(mainWidget);
 
     m_chooserUi = new Ui::CMakeBuildDirChooser;
     m_chooserUi->setupUi(mainWidget);
     mainLayout->addWidget(m_buttonBox);
 
     m_chooserUi->buildFolder->setMode(KFile::Directory|KFile::ExistingOnly);
     m_chooserUi->installPrefix->setMode(KFile::Directory|KFile::ExistingOnly);
 
     setCMakeExecutable(Path(CMake::findExecutable()));
 
     m_extraArgumentsHistory = new CMakeExtraArgumentsHistory(m_chooserUi->extraArguments);
 
     connect(m_chooserUi->cmakeExecutable, &KUrlRequester::textChanged, this, &CMakeBuildDirChooser::updated);
     connect(m_chooserUi->buildFolder, &KUrlRequester::textChanged, this, &CMakeBuildDirChooser::updated);
     connect(m_chooserUi->buildType, static_cast<void(QComboBox::*)(const QString&)>(&QComboBox::currentIndexChanged), this, &CMakeBuildDirChooser::updated);
     connect(m_chooserUi->extraArguments, &KComboBox::editTextChanged, this, &CMakeBuildDirChooser::updated);
 
     updated();
 }
 
 CMakeBuildDirChooser::~CMakeBuildDirChooser()
 {
     delete m_extraArgumentsHistory;
 
     delete m_chooserUi;
 }
 
 void CMakeBuildDirChooser::setSourceFolder( const Path &srcFolder )
 {
     m_srcFolder = srcFolder;
 
     m_chooserUi->buildFolder->setUrl(KDevelop::proposedBuildFolder(srcFolder).toUrl());
     setWindowTitle(i18n("Configure a build directory for %1", srcFolder.toLocalFile()));
     update();
 }
 
 void CMakeBuildDirChooser::buildDirSettings(
     const KDevelop::Path& buildDir,
     QString& srcDir,
     QString& installDir,
     QString& buildType)
 {
     static const QString srcLine = QStringLiteral("CMAKE_HOME_DIRECTORY:INTERNAL=");
     static const QString installLine = QStringLiteral("CMAKE_INSTALL_PREFIX:PATH=");
     static const QString buildLine = QStringLiteral("CMAKE_BUILD_TYPE:STRING=");
 
     const Path cachePath(buildDir, "CMakeCache.txt");
     QFile file(cachePath.toLocalFile());
 
     srcDir.clear();
     installDir.clear();
     buildType.clear();
 
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
     {
         qCWarning(CMAKE) << "Something really strange happened reading" << cachePath;
         return;
     }
 
     int cnt = 0;
     while (cnt != 3 && !file.atEnd())
     {
         // note: CMakeCache.txt is UTF8-encoded, also see bug 329305
         QString line = QString::fromUtf8(file.readLine().trimmed());
 
         if (line.startsWith(srcLine))
         {
             srcDir = line.mid(srcLine.count());
             ++cnt;
         }
 
         if (line.startsWith(installLine))
         {
             installDir = line.mid(installLine.count());
             ++cnt;
         }
 
         if (line.startsWith(buildLine))
         {
             buildType = line.mid(buildLine.count());
             ++cnt;
         }
     }
 
     qCDebug(CMAKE) << "The source directory for " << file.fileName() << "is" << srcDir;
     qCDebug(CMAKE) << "The install directory for " << file.fileName() << "is" << installDir;
     qCDebug(CMAKE) << "The build type for " << file.fileName() << "is" << buildType;
 }
 
 void CMakeBuildDirChooser::updated()
 {
     bool haveCMake=QFile::exists(m_chooserUi->cmakeExecutable->url().toLocalFile());
     StatusTypes st;
     if( haveCMake ) st |= HaveCMake;
 
     m_chooserUi->buildFolder->setEnabled(haveCMake);
     m_chooserUi->installPrefix->setEnabled(haveCMake);
     m_chooserUi->buildType->setEnabled(haveCMake);
 //  m_chooserUi->generator->setEnabled(haveCMake);
     if(!haveCMake)
     {
         setStatus(i18n("You need to select a CMake executable."), false);
         return;
     }
 
     Path chosenBuildFolder(m_chooserUi->buildFolder->url());
     bool emptyUrl = chosenBuildFolder.isEmpty();
     if( emptyUrl ) st |= BuildFolderEmpty;
 
     bool dirEmpty = false, dirExists= false, dirRelative = false;
     QString srcDir;
     QString installDir;
     QString buildType;
     if(!emptyUrl)
     {
         QDir d(chosenBuildFolder.toLocalFile());
         dirExists = d.exists();
         dirEmpty = dirExists && d.count()<=2;
         dirRelative = d.isRelative();
         if(!dirEmpty && dirExists && !dirRelative)
         {
             bool hasCache=QFile::exists(Path(chosenBuildFolder, "CMakeCache.txt").toLocalFile());
             if(hasCache)
             {
                 QString proposed=m_srcFolder.toLocalFile();
 
                 buildDirSettings(chosenBuildFolder, srcDir, installDir, buildType);
                 if(!srcDir.isEmpty())
                 {
                     if(QDir(srcDir).canonicalPath()==QDir(proposed).canonicalPath())
                     {
                             st |= CorrectBuildDir | BuildDirCreated;
                     }
                 }
                 else
                 {
                     qCWarning(CMAKE) << "maybe you are trying a damaged CMakeCache.txt file. Proper: ";
                 }
 
                 if(!installDir.isEmpty() && QDir(installDir).exists())
                 {
                     m_chooserUi->installPrefix->setUrl(QUrl::fromLocalFile(installDir));
                 }
 
                 m_chooserUi->buildType->setCurrentText(buildType);
             }
         }
 
         if(m_alreadyUsed.contains(chosenBuildFolder.toLocalFile())) {
             st=DirAlreadyCreated;
         }
     }
     else
     {
         setStatus(i18n("You need to specify a build directory."), false);
         return;
     }
 
 
     if(st & (BuildDirCreated | CorrectBuildDir))
     {
         setStatus(i18n("Using an already created build directory."), true);
         m_chooserUi->installPrefix->setEnabled(false);
         m_chooserUi->buildType->setEnabled(false);
     }
     else
     {
         bool correct = (dirEmpty || !dirExists) && !(st & DirAlreadyCreated) && !dirRelative;
 
         if(correct)
         {
             st |= CorrectBuildDir;
             setStatus(i18n("Creating a new build directory."), true);
         }
         else
         {
             //Useful to explain what's going wrong
             if(st & DirAlreadyCreated)
                 setStatus(i18n("Build directory already configured."), false);
             else if (!srcDir.isEmpty())
                 setStatus(i18n("This build directory is for %1, "
                                "but the project directory is %2.", srcDir, m_srcFolder.toLocalFile()), false);
             else if(dirRelative)
                 setStatus(i18n("You may not select a relative build directory."), false);
             else if(!dirEmpty)
                 setStatus(i18n("The selected build directory is not empty."), false);
         }
 
         m_chooserUi->installPrefix->setEnabled(correct);
         m_chooserUi->buildType->setEnabled(correct);
     }
 }
 
 void CMakeBuildDirChooser::setCMakeExecutable(const Path& path)
 {
     m_chooserUi->cmakeExecutable->setUrl(path.toUrl());
     updated();
 }
 
 void CMakeBuildDirChooser::setInstallPrefix(const Path& path)
 {
     m_chooserUi->installPrefix->setUrl(path.toUrl());
     updated();
 }
 
 void CMakeBuildDirChooser::setBuildFolder(const Path& path)
 {
     m_chooserUi->buildFolder->setUrl(path.toUrl());
     updated();
 }
 
 void CMakeBuildDirChooser::setBuildType(const QString& s)
 {
     m_chooserUi->buildType->addItem(s);
     m_chooserUi->buildType->setCurrentIndex(m_chooserUi->buildType->findText(s));
     updated();
 }
 
 void CMakeBuildDirChooser::setAlreadyUsed (const QStringList & used)
 {
     m_alreadyUsed = used;
     updated();
 }
 
 void CMakeBuildDirChooser::setExtraArguments(const QString& args)
 {
     m_chooserUi->extraArguments->setEditText(args);
     updated();
 }
 
 void CMakeBuildDirChooser::setStatus(const QString& message, bool canApply)
 {
     KColorScheme scheme(QPalette::Normal);
     KColorScheme::ForegroundRole role;
     if (canApply) {
         role = KColorScheme::PositiveText;
     } else {
         role = KColorScheme::NegativeText;
     }
     m_chooserUi->status->setText(QString("<i><font color='%1'>%2</font></i>").arg(scheme.foreground(role).color().name()).arg(message));
 
     auto okButton = m_buttonBox->button(QDialogButtonBox::Ok);
     okButton->setEnabled(canApply);
     if (canApply) {
         auto cancelButton = m_buttonBox->button(QDialogButtonBox::Cancel);
         cancelButton->clearFocus();
     }
 }
 
 Path CMakeBuildDirChooser::cmakeExecutable() const { return Path(m_chooserUi->cmakeExecutable->url()); }
 
 Path CMakeBuildDirChooser::installPrefix() const { return Path(m_chooserUi->installPrefix->url()); }
 
 Path CMakeBuildDirChooser::buildFolder() const { return Path(m_chooserUi->buildFolder->url()); }
 
 QString CMakeBuildDirChooser::buildType() const { return m_chooserUi->buildType->currentText(); }
 
 QString CMakeBuildDirChooser::extraArguments() const { return m_chooserUi->extraArguments->currentText(); }
diff --git a/projectmanagers/cmake/cmakedocumentation.cpp b/projectmanagers/cmake/cmakedocumentation.cpp
index 709bc842e7..3d67b6c15f 100644
--- a/projectmanagers/cmake/cmakedocumentation.cpp
+++ b/projectmanagers/cmake/cmakedocumentation.cpp
@@ -1,205 +1,203 @@
 /* KDevelop CMake Support
  *
  * Copyright 2009 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 "cmakedocumentation.h"
 #include "cmakeutils.h"
 
 #include <QProcess>
 #include <QString>
-#include <QTextDocument>
 #include <QStringListModel>
 #include <QMimeDatabase>
-#include <QFontDatabase>
 #include <QStandardPaths>
 #include <KLocalizedString>
 
 #include <interfaces/iproject.h>
 #include <KPluginFactory>
 #include <documentation/standarddocumentationview.h>
 #include <language/duchain/declaration.h>
 #include <serialization/indexedstring.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/icore.h>
 #include "cmakemanager.h"
 #include "cmakehelpdocumentation.h"
 #include "cmakedoc.h"
 #include "debug.h"
 
 K_PLUGIN_FACTORY_WITH_JSON(CMakeSupportDocFactory, "kdevcmakedocumentation.json", registerPlugin<CMakeDocumentation>(); )
 
 CMakeDocumentation* CMakeDoc::s_provider=nullptr;
 KDevelop::IDocumentationProvider* CMakeDoc::provider() const { return s_provider; }
 
 CMakeDocumentation::CMakeDocumentation(QObject* parent, const QVariantList&)
     : KDevelop::IPlugin( "kdevcmakedocumentation", parent )
     , m_cmakeExecutable(CMake::findExecutable())
     , m_index(nullptr)
 {
     if (m_cmakeExecutable.isEmpty()) {
         setErrorDescription(i18n("Unable to find a CMake executable. Is one installed on the system?"));
         return;
     }
 
     CMakeDoc::s_provider=this;
     m_index= new QStringListModel(this);
     initializeModel();
 }
 
 static const char* const args[] = { "--help-command", "--help-variable", "--help-module", "--help-property", nullptr, nullptr };
 
 void CMakeDocumentation::delayedInitialization()
 {
     for(int i=0; i<=Property; i++) {
         collectIds(QString(args[i])+"-list", (Type) i);
     }
 
     m_index->setStringList(m_typeForName.keys());
 }
 
 void CMakeDocumentation::collectIds(const QString& param, Type type)
 {
     QStringList ids = CMake::executeProcess(m_cmakeExecutable, QStringList(param)).split(QLatin1Char('\n'));
     ids.takeFirst();
     foreach(const QString& name, ids)
     {
         m_typeForName[name]=type;
     }
 }
 
 QStringList CMakeDocumentation::names(CMakeDocumentation::Type t) const
 {
     return m_typeForName.keys(t);
 }
 
 QString CMakeDocumentation::descriptionForIdentifier(const QString& id, Type t) const
 {
     QString desc;
     if(args[t]) {
         desc = CMake::executeProcess(m_cmakeExecutable, { args[t], id.simplified() });
         desc = desc.remove(":ref:");
 
         const QString rst2html = QStandardPaths::findExecutable(QStringLiteral("rst2html"));
         if (rst2html.isEmpty()) {
             desc = ("<html><body style='background:#fff'><pre><code>" + desc.toHtmlEscaped() + "</code></pre>"
                 + i18n("<p>For better cmake documentation rendering, install rst2html</p>")
                 + "</body></html>");
         } else {
             QProcess p;
             p.start(rst2html, { "--no-toc-backlinks" });
             p.write(desc.toUtf8());
             p.closeWriteChannel();
             p.waitForFinished();
             desc = QString::fromUtf8(p.readAllStandardOutput());
         }
     }
 
     return desc;
 }
 
 KDevelop::IDocumentation::Ptr CMakeDocumentation::description(const QString& identifier, const QUrl &file) const
 {
     initializeModel(); //make it not queued
     if (!file.isEmpty() && !QMimeDatabase().mimeTypeForUrl(file).inherits("text/x-cmake")) {
         return KDevelop::IDocumentation::Ptr();
     }
 
     QString desc;
 
     if(m_typeForName.contains(identifier)) {
         desc=descriptionForIdentifier(identifier, m_typeForName[identifier]);
     } else if(m_typeForName.contains(identifier.toLower())) {
         desc=descriptionForIdentifier(identifier, m_typeForName[identifier.toLower()]);
     } else if(m_typeForName.contains(identifier.toUpper())) {
         desc=descriptionForIdentifier(identifier, m_typeForName[identifier.toUpper()]);
     }
 
     KDevelop::IProject* p=KDevelop::ICore::self()->projectController()->findProjectForUrl(file);
     ICMakeManager* m=nullptr;
     if(p)
         m=p->managerPlugin()->extension<ICMakeManager>();
     if(m)
     {
         QPair<QString, QString> entry = m->cacheValue(p, identifier);
         if(!entry.first.isEmpty())
             desc += i18n("<br /><em>Cache Value:</em> %1\n", entry.first);
 
         if(!entry.second.isEmpty())
             desc += i18n("<br /><em>Cache Documentation:</em> %1\n", entry.second);
     }
 
     if(desc.isEmpty())
         return KDevelop::IDocumentation::Ptr();
     else
         return KDevelop::IDocumentation::Ptr(new CMakeDoc(identifier, desc));
 }
 
 KDevelop::IDocumentation::Ptr CMakeDocumentation::documentationForDeclaration(KDevelop::Declaration* decl) const
 {
     return description(decl->identifier().toString(), decl->url().toUrl());
 }
 
 KDevelop::IDocumentation::Ptr CMakeDocumentation::documentationForIndex(const QModelIndex& idx) const
 {
     return description(idx.data().toString(), QUrl());
 }
 
 QAbstractListModel* CMakeDocumentation::indexModel() const
 {
     initializeModel();
     return m_index;
 }
 
 QIcon CMakeDocumentation::icon() const
 {
     return QIcon::fromTheme("cmake");
 }
 
 QString CMakeDocumentation::name() const
 {
     return "CMake";
 }
 
 KDevelop::IDocumentation::Ptr CMakeDocumentation::homePage() const
 {
     if(m_typeForName.isEmpty())
         const_cast<CMakeDocumentation*>(this)->delayedInitialization();
 //     initializeModel();
     return KDevelop::IDocumentation::Ptr(new CMakeHomeDocumentation);
 }
 
 void CMakeDocumentation::initializeModel() const
 {
     if(!m_typeForName.isEmpty())
         return;
 
     QMetaObject::invokeMethod(const_cast<CMakeDocumentation*>(this), "delayedInitialization", Qt::QueuedConnection);
 }
 
 //////////CMakeDoc
 
 QWidget* CMakeDoc::documentationWidget(KDevelop::DocumentationFindWidget* findWidget, QWidget* parent)
 {
     KDevelop::StandardDocumentationView* view = new KDevelop::StandardDocumentationView(findWidget, parent);
     view->setHtml(mDesc);
     return view;
 }
 
 #include "cmakedocumentation.moc"
diff --git a/projectmanagers/cmake/cmakedocumentation.h b/projectmanagers/cmake/cmakedocumentation.h
index b81c2f8e47..51a334433d 100644
--- a/projectmanagers/cmake/cmakedocumentation.h
+++ b/projectmanagers/cmake/cmakedocumentation.h
@@ -1,72 +1,71 @@
 /* KDevelop CMake Support
  *
  * Copyright 2009 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.
  */
 
 #ifndef CMAKEDOCUMENTATION_H
 #define CMAKEDOCUMENTATION_H
 
 #include <QString>
 #include <QMap>
-#include <QStringList>
 #include <QVariantList>
 #include <interfaces/iplugin.h>
 #include "icmakedocumentation.h"
 
 class QStringListModel;
 namespace KDevelop { class Declaration; }
 class CMakeManager;
 class QUrl;
 
 class CMakeDocumentation : public KDevelop::IPlugin, public ICMakeDocumentation
 {
     Q_OBJECT
     Q_INTERFACES( ICMakeDocumentation )
     Q_INTERFACES( KDevelop::IDocumentationProvider )
     public:
         explicit CMakeDocumentation( QObject* parent = nullptr, const QVariantList& args = QVariantList() );
 
         KDevelop::IDocumentation::Ptr description(const QString& identifier, const QUrl &file) const override;
         KDevelop::IDocumentation::Ptr documentationForDeclaration(KDevelop::Declaration* declaration) const override;
         
         QStringList names(Type t) const override;
         
         QAbstractListModel* indexModel() const override;
         KDevelop::IDocumentation::Ptr documentationForIndex(const QModelIndex& idx) const override;
         
         QIcon icon() const override;
         QString name() const override;
         KDevelop::IDocumentation::Ptr homePage() const override;
         
         QString descriptionForIdentifier(const QString& identifier, Type t) const;
     public slots:
         void delayedInitialization();
         
     Q_SIGNALS:
         void addHistory(const KDevelop::IDocumentation::Ptr& doc) const override;
     
     private:
         void initializeModel() const;
         void collectIds(const QString& param, Type type);
         
         QMap<QString, Type> m_typeForName;
         const QString m_cmakeExecutable;
         QStringListModel* m_index;
 };
 
 #endif // CMAKEDOCUMENTATION_H
diff --git a/projectmanagers/cmake/cmakeextraargumentshistory.cpp b/projectmanagers/cmake/cmakeextraargumentshistory.cpp
index 72c1eef7ef..a4b6ad91f1 100644
--- a/projectmanagers/cmake/cmakeextraargumentshistory.cpp
+++ b/projectmanagers/cmake/cmakeextraargumentshistory.cpp
@@ -1,71 +1,70 @@
 /* KDevelop CMake Support
  *
  * Copyright 2016 René J.V. Bertin <rjvbertin@gmail.com>
  *
  * 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 <QObject>
 #include <KSharedConfig>
 #include <KConfigGroup>
 
 #include "cmakeextraargumentshistory.h"
 
 namespace {
 
 const int maxExtraArgumentsInHistory = 15;
 
 }
 
 CMakeExtraArgumentsHistory::CMakeExtraArgumentsHistory(KComboBox* widget)
     : m_arguments(widget)
 {
     if (m_arguments) {
         KConfigGroup config = KSharedConfig::openConfig()->group("CMakeBuildDirChooser");
         QStringList lastExtraArguments = config.readEntry("LastExtraArguments", QStringList());;
         m_arguments->addItem("");
         m_arguments->addItems(lastExtraArguments);
         m_arguments->setInsertPolicy(QComboBox::InsertAtTop);
         KCompletion *comp = m_arguments->completionObject();
         KComboBox::connect(m_arguments, static_cast<void(KComboBox::*)(const QString&)>(&KComboBox::returnPressed),
                 comp, static_cast<void(KCompletion::*)(const QString&)>(&KCompletion::addItem));
         comp->insertItems(lastExtraArguments);
     } else {
         qFatal("CMakeExtraArgumentsHistory initialised with invalid widget");
     }
 }
 
 CMakeExtraArgumentsHistory::~CMakeExtraArgumentsHistory()
 {
     KConfigGroup config = KSharedConfig::openConfig()->group("CMakeBuildDirChooser");
     config.writeEntry("LastExtraArguments", list());
     config.sync();
 }
 
 QStringList CMakeExtraArgumentsHistory::list() const
 {
     QStringList list;
     if (!m_arguments->currentText().isEmpty()) {
         list << m_arguments->currentText();
     }
     for (int i = 0; i < qMin(maxExtraArgumentsInHistory, m_arguments->count()); ++i) {
         if (!m_arguments->itemText(i).isEmpty() &&
             (m_arguments->currentText() != m_arguments->itemText(i))) {
             list << m_arguments->itemText(i);
         }
     }
     return list;
 }
diff --git a/projectmanagers/cmake/cmakeextraargumentshistory.h b/projectmanagers/cmake/cmakeextraargumentshistory.h
index 6b5834f0b3..bce78d72df 100644
--- a/projectmanagers/cmake/cmakeextraargumentshistory.h
+++ b/projectmanagers/cmake/cmakeextraargumentshistory.h
@@ -1,51 +1,50 @@
 /* KDevelop CMake Support
  *
  * Copyright 2016 René J.V. Bertin <rjvbertin@gmail.com>
  *
  * 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 CMAKEEXTRAARGUMENTS_H
 #define CMAKEEXTRAARGUMENTS_H
 
-#include <QString>
-#include <QStringList>
-
 #include <KComboBox>
 
 #include "cmakecommonexport.h"
 
+class QStringList;
+
 namespace Ui {
     class CMakeExtraArgumentsHistory;
 }
 
 /**
 * This class augments CMake's extra arguments widget with a history feature.
 * @author René Bertin
 */
 class KDEVCMAKECOMMON_EXPORT CMakeExtraArgumentsHistory
 {
     public:
         explicit CMakeExtraArgumentsHistory(KComboBox* widget);
         ~CMakeExtraArgumentsHistory();
 
         QStringList list() const;
 
     private:
         KComboBox* m_arguments;
 };
 
 #endif
diff --git a/projectmanagers/cmake/cmakemanager.cpp b/projectmanagers/cmake/cmakemanager.cpp
index 04e26f6478..6c426ae3a6 100644
--- a/projectmanagers/cmake/cmakemanager.cpp
+++ b/projectmanagers/cmake/cmakemanager.cpp
@@ -1,922 +1,918 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@kde.org>
  * Copyright 2007-2013 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 "cmakemanager.h"
 #include "cmakeedit.h"
 #include "cmakeutils.h"
 #include "cmakeprojectdata.h"
 #include "duchain/cmakeparsejob.h"
 #include "cmakeimportjsonjob.h"
 #include "debug.h"
 #include "settings/cmakepreferences.h"
 #include <projectmanagers/custommake/makefileresolver/makefileresolver.h>
 #include "cmakecodecompletionmodel.h"
 #include "cmakenavigationwidget.h"
 #include "icmakedocumentation.h"
 #include "cmakemodelitems.h"
 #include "testing/ctestutils.h"
 #include "cmakeserverimportjob.h"
 #include "cmakeserver.h"
 
 #include <QDir>
 #include <QReadWriteLock>
 #include <QThread>
 #include <QFileSystemWatcher>
 #include <QTimer>
-#include <qjsondocument.h>
 
 #include <KPluginFactory>
-#include <KPluginLoader>
-#include <KAboutData>
 #include <QUrl>
 #include <QAction>
 #include <KMessageBox>
 #include <ktexteditor/document.h>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/context.h>
 #include <interfaces/idocumentation.h>
 #include <util/executecompositejob.h>
 #include <language/highlighting/codehighlighting.h>
 #include <project/projectmodel.h>
 #include <project/helper.h>
 #include <project/interfaces/iprojectbuilder.h>
 #include <project/projectfiltermanager.h>
 #include <language/codecompletion/codecompletion.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/use.h>
 #include <language/duchain/duchain.h>
-#include <QStandardPaths>
 
 Q_DECLARE_METATYPE(KDevelop::IProject*);
 
 using namespace KDevelop;
 
 K_PLUGIN_FACTORY_WITH_JSON(CMakeSupportFactory, "kdevcmakemanager.json", registerPlugin<CMakeManager>(); )
 
 const QString DIALOG_CAPTION = i18n("KDevelop - CMake Support");
 
 CMakeManager::CMakeManager( QObject* parent, const QVariantList& )
     : KDevelop::AbstractFileManagerPlugin( "kdevcmakemanager", parent )
     , m_filter( new ProjectFilterManager( this ) )
 {
     if (CMake::findExecutable().isEmpty()) {
         setErrorDescription(i18n("Unable to find a CMake executable. Is one installed on the system?"));
         m_highlight = nullptr;
         return;
     }
 
     m_highlight = new KDevelop::CodeHighlighting(this);
 
     new CodeCompletion(this, new CMakeCodeCompletionModel(this), name());
 
     connect(ICore::self()->projectController(), &IProjectController::projectClosing, this, &CMakeManager::projectClosing);
     connect(this, &KDevelop::AbstractFileManagerPlugin::folderAdded, this, &CMakeManager::folderAdded);
 
 //     m_fileSystemChangeTimer = new QTimer(this);
 //     m_fileSystemChangeTimer->setSingleShot(true);
 //     m_fileSystemChangeTimer->setInterval(100);
 //     connect(m_fileSystemChangeTimer,SIGNAL(timeout()),SLOT(filesystemBuffererTimeout()));
 }
 
 CMakeManager::~CMakeManager()
 {
     parseLock()->lockForWrite();
     // By locking the parse-mutexes, we make sure that parse jobs get a chance to finish in a good state
     parseLock()->unlock();
 }
 
 bool CMakeManager::hasBuildInfo(ProjectBaseItem* item) const
 {
     return m_projects[item->project()].compilationData.files.contains(item->path());
 }
 
 Path CMakeManager::buildDirectory(KDevelop::ProjectBaseItem *item) const
 {
 //     CMakeFolderItem *fi=dynamic_cast<CMakeFolderItem*>(item);
 //     Path ret;
 //     ProjectBaseItem* parent = fi ? fi->formerParent() : item->parent();
 //     if (parent)
 //         ret=buildDirectory(parent);
 //     else
 //         ret=Path(CMake::currentBuildDir(item->project()));
 //
 //     if(fi)
 //         ret.addPath(fi->buildDir());
 //     return ret;
     return Path(CMake::currentBuildDir(item->project()));
 }
 
 KDevelop::ProjectFolderItem* CMakeManager::import( KDevelop::IProject *project )
 {
     CMake::checkForNeedingConfigure(project);
 
     return AbstractFileManagerPlugin::import(project);
 }
 
 class ChooseCMakeInterfaceJob : public ExecuteCompositeJob
 {
     Q_OBJECT
 public:
     ChooseCMakeInterfaceJob(IProject* project, CMakeManager* manager)
         : ExecuteCompositeJob(manager, {})
         , project(project)
         , manager(manager)
     {
     }
 
     void start() override {
         server = new CMakeServer(project);
         connect(server, &CMakeServer::connected, this, &ChooseCMakeInterfaceJob::successfulConnection);
         connect(server, &CMakeServer::finished, this, &ChooseCMakeInterfaceJob::failedConnection);
     }
 
 private:
     void successfulConnection() {
         auto job = new CMakeServerImportJob(project, server, this);
         connect(job, &CMakeServerImportJob::result, this, [this, job](){
             if (job->error() == 0) {
                 manager->integrateData(job->projectData(), job->project());
             }
         });
         addSubjob(job);
         ExecuteCompositeJob::start();
     }
 
     void failedConnection(int code) {
         Q_ASSERT(code > 0);
         Q_ASSERT(!server->isServerAvailable());
 
         server->deleteLater();
         server = nullptr;
 
         // parse the JSON file
         CMakeImportJsonJob* job = new CMakeImportJsonJob(project, this);
 
         // create the JSON file if it doesn't exist
         auto commandsFile = CMake::commandsFile(project);
         if (!QFileInfo::exists(commandsFile.toLocalFile())) {
             qCDebug(CMAKE) << "couldn't find commands file:" << commandsFile << "- now trying to reconfigure";
             addSubjob(manager->builder()->configure(project));
         }
 
         connect(job, &CMakeImportJsonJob::result, this, [this, job](){
             if (job->error() == 0) {
                 manager->integrateData(job->projectData(), job->project());
             }
         });
         addSubjob(job);
         ExecuteCompositeJob::start();
     }
 
     CMakeServer* server = nullptr;
     IProject* const project;
     CMakeManager* const manager;
 };
 
 KJob* CMakeManager::createImportJob(ProjectFolderItem* item)
 {
     auto project = item->project();
 
     auto job = new ChooseCMakeInterfaceJob(project, this);
     connect(job, &CMakeImportJsonJob::result, this, [this, job, project](){
         if (job->error() != 0) {
             qCWarning(CMAKE) << "couldn't load json successfully" << project->name();
             m_projects.remove(project);
         }
     });
 
     const QList<KJob*> jobs = {
         job,
         KDevelop::AbstractFileManagerPlugin::createImportJob(item) // generate the file system listing
     };
 
     Q_ASSERT(!jobs.contains(nullptr));
     ExecuteCompositeJob* composite = new ExecuteCompositeJob(this, jobs);
 //     even if the cmake call failed, we want to load the project so that the project can be worked on
     composite->setAbortOnError(false);
     return composite;
 }
 
 // QList<ProjectFolderItem*> CMakeManager::parse(ProjectFolderItem*)
 // { return QList< ProjectFolderItem* >(); }
 //
 //
 
 QList<KDevelop::ProjectTargetItem*> CMakeManager::targets() const
 {
     QList<KDevelop::ProjectTargetItem*> ret;
     foreach(IProject* p, m_projects.keys())
     {
         ret+=p->projectItem()->targetList();
     }
     return ret;
 }
 
 CMakeFile CMakeManager::fileInformation(KDevelop::ProjectBaseItem* item) const
 {
     const auto & data = m_projects[item->project()].compilationData;
     QHash<KDevelop::Path, CMakeFile>::const_iterator it = data.files.constFind(item->path());
 
     if (it == data.files.constEnd()) {
         // if the item path contains a symlink, then we will not find it in the lookup table
         // as that only only stores canonicalized paths. Thus, we fallback to
         // to the canonicalized path and see if that brings up any matches
         const auto canonicalized = Path(QFileInfo(item->path().toLocalFile()).canonicalFilePath());
         it = data.files.constFind(canonicalized);
     }
 
     if (it != data.files.constEnd()) {
         return *it;
     } else {
         // otherwise look for siblings and use the include paths of any we find
         const Path folder = item->folder() ? item->path() : item->path().parent();
 
         for( it = data.files.constBegin(); it != data.files.constEnd(); ++it) {
             if (folder.isDirectParentOf(it.key())) {
                 return *it;
             }
         }
     }
 
     // last-resort fallback: bubble up the parent chain, and keep looking for include paths
     if (auto parent = item->parent()) {
         return fileInformation(parent);
     }
 
     return {};
 }
 
 Path::List CMakeManager::includeDirectories(KDevelop::ProjectBaseItem *item) const
 {
     return fileInformation(item).includes;
 }
 
 Path::List CMakeManager::frameworkDirectories(KDevelop::ProjectBaseItem *item) const
 {
     return fileInformation(item).frameworkDirectories;
 }
 
 QHash<QString, QString> CMakeManager::defines(KDevelop::ProjectBaseItem *item ) const
 {
     return fileInformation(item).defines;
 }
 
 KDevelop::IProjectBuilder * CMakeManager::builder() const
 {
     IPlugin* i = core()->pluginController()->pluginForExtension( "org.kdevelop.IProjectBuilder", "KDevCMakeBuilder");
     Q_ASSERT(i);
     KDevelop::IProjectBuilder* _builder = i->extension<KDevelop::IProjectBuilder>();
     Q_ASSERT(_builder );
     return _builder ;
 }
 
 bool CMakeManager::reload(KDevelop::ProjectFolderItem* folder)
 {
     qCDebug(CMAKE) << "reloading" << folder->path();
 
     IProject* project = folder->project();
     if (!project->isReady())
         return false;
 
     KJob *job = createImportJob(folder);
     project->setReloadJob(job);
     ICore::self()->runController()->registerJob( job );
     return true;
 }
 
 static void populateTargets(ProjectFolderItem* folder, const QHash<KDevelop::Path, QStringList>& targets)
 {
     QStringList dirTargets = targets[folder->path()];
 
     foreach (ProjectTargetItem* item, folder->targetList()) {
         if(!dirTargets.contains(item->text())) {
             delete item;
         } else {
             dirTargets.removeAll(item->text());
         }
     }
 
     static QSet<QString> standardTargets = {
         QStringLiteral("edit_cache"), QStringLiteral("rebuild_cache"),
         QStringLiteral("list_install_components"),
         QStringLiteral("test"), //not really standard, but applicable for make and ninja
         QStringLiteral("install")
 
     };
 
     foreach (const QString& name, dirTargets) {
         if (!name.endsWith(QLatin1String("_automoc"))
             && !standardTargets.contains(name)
             && !name.startsWith(QLatin1String("install/"))
         )
             new CMakeTargetItem(folder, name);
     }
 
     foreach (ProjectFolderItem* children, folder->folderList()) {
         populateTargets(children, targets);
     }
 }
 
 void CMakeManager::integrateData(const CMakeProjectData &data, KDevelop::IProject* project)
 {
     connect(data.watcher.data(), &QFileSystemWatcher::fileChanged, this, &CMakeManager::dirtyFile);
     connect(data.watcher.data(), &QFileSystemWatcher::directoryChanged, this, &CMakeManager::dirtyFile);
     m_projects[project] = data;
 
     populateTargets(project->projectItem(), data.targets);
     CTestUtils::createTestSuites(data.m_testSuites, project);
 }
 
 // void CMakeManager::deletedWatchedDirectory(IProject* p, const QUrl &dir)
 // {
 //     if(p->folder().equals(dir, QUrl::CompareWithoutTrailingSlash)) {
 //         ICore::self()->projectController()->closeProject(p);
 //     } else {
 //         if(dir.fileName()=="CMakeLists.txt") {
 //             QList<ProjectFolderItem*> folders = p->foldersForUrl(dir.upUrl());
 //             foreach(ProjectFolderItem* folder, folders)
 //                 reload(folder);
 //         } else {
 //             qDeleteAll(p->itemsForUrl(dir));
 //         }
 //     }
 // }
 
 // void CMakeManager::directoryChanged(const QString& dir)
 // {
 //     m_fileSystemChangedBuffer << dir;
 //     m_fileSystemChangeTimer->start();
 // }
 
 // void CMakeManager::filesystemBuffererTimeout()
 // {
 //     Q_FOREACH(const QString& file, m_fileSystemChangedBuffer) {
 //         realDirectoryChanged(file);
 //     }
 //     m_fileSystemChangedBuffer.clear();
 // }
 
 // void CMakeManager::realDirectoryChanged(const QString& dir)
 // {
 //     QUrl path(dir);
 //     IProject* p=ICore::self()->projectController()->findProjectForUrl(dir);
 //     if(!p || !p->isReady()) {
 //         if(p) {
 //             m_fileSystemChangedBuffer << dir;
 //             m_fileSystemChangeTimer->start();
 //         }
 //         return;
 //     }
 //
 //     if(!QFile::exists(dir)) {
 //         path.adjustPath(QUrl::AddTrailingSlash);
 //         deletedWatchedDirectory(p, path);
 //     } else
 //         dirtyFile(dir);
 // }
 
 QList< KDevelop::ProjectTargetItem * > CMakeManager::targets(KDevelop::ProjectFolderItem * folder) const
 {
     return folder->targetList();
 }
 
 QString CMakeManager::name() const
 {
     return languageName().str();
 }
 
 IndexedString CMakeManager::languageName()
 {
     static IndexedString name("CMake");
     return name;
 }
 
 KDevelop::ParseJob * CMakeManager::createParseJob(const IndexedString &url)
 {
     return new CMakeParseJob(url, this);
 }
 
 KDevelop::ICodeHighlighting* CMakeManager::codeHighlighting() const
 {
     return m_highlight;
 }
 
 // ContextMenuExtension CMakeManager::contextMenuExtension( KDevelop::Context* context )
 // {
 //     if( context->type() != KDevelop::Context::ProjectItemContext )
 //         return IPlugin::contextMenuExtension( context );
 //
 //     KDevelop::ProjectItemContext* ctx = dynamic_cast<KDevelop::ProjectItemContext*>( context );
 //     QList<KDevelop::ProjectBaseItem*> items = ctx->items();
 //
 //     if( items.isEmpty() )
 //         return IPlugin::contextMenuExtension( context );
 //
 //     m_clickedItems = items;
 //     ContextMenuExtension menuExt;
 //     if(items.count()==1 && dynamic_cast<DUChainAttatched*>(items.first()))
 //     {
 //         QAction * action = new QAction( i18n( "Jump to Target Definition" ), this );
 //         connect( action, SIGNAL(triggered()), this, SLOT(jumpToDeclaration()) );
 //         menuExt.addAction( ContextMenuExtension::ProjectGroup, action );
 //     }
 //
 //     return menuExt;
 // }
 //
 // void CMakeManager::jumpToDeclaration()
 // {
 //     DUChainAttatched* du=dynamic_cast<DUChainAttatched*>(m_clickedItems.first());
 //     if(du)
 //     {
 //         KTextEditor::Cursor c;
 //         QUrl url;
 //         {
 //             KDevelop::DUChainReadLocker lock;
 //             Declaration* decl = du->declaration().data();
 //             if(!decl)
 //                 return;
 //             c = decl->rangeInCurrentRevision().start();
 //             url = decl->url().toUrl();
 //         }
 //
 //         ICore::self()->documentController()->openDocument(url, c);
 //     }
 // }
 //
 // // TODO: Port to Path API
 // bool CMakeManager::moveFilesAndFolders(const QList< ProjectBaseItem* > &items, ProjectFolderItem* toFolder)
 // {
 //     using namespace CMakeEdit;
 //
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Move files and folders within CMakeLists as follows:"));
 //
 //     bool cmakeSuccessful = true;
 //     CMakeFolderItem *nearestCMakeFolderItem = nearestCMakeFolder(toFolder);
 //     IProject* project=toFolder->project();
 //
 //     QList<QUrl> movedUrls;
 //     QList<QUrl> oldUrls;
 //     foreach(ProjectBaseItem *movedItem, items)
 //     {
 //         QList<ProjectBaseItem*> dirtyItems = cmakeListedItemsAffectedByUrlChange(project, movedItem->url());
 //         QUrl movedItemNewUrl = toFolder->url();
 //         movedItemNewUrl.addPath(movedItem->baseName());
 //         if (movedItem->folder())
 //             movedItemNewUrl.adjustPath(QUrl::AddTrailingSlash);
 //         foreach(ProjectBaseItem* dirtyItem, dirtyItems)
 //         {
 //             QUrl dirtyItemNewUrl = afterMoveUrl(dirtyItem->url(), movedItem->url(), movedItemNewUrl);
 //             if (CMakeFolderItem* folder = dynamic_cast<CMakeFolderItem*>(dirtyItem))
 //             {
 //                 cmakeSuccessful &= changesWidgetRemoveCMakeFolder(folder, &changesWidget);
 //                 cmakeSuccessful &= changesWidgetAddFolder(dirtyItemNewUrl, nearestCMakeFolderItem, &changesWidget);
 //             }
 //             else if (dirtyItem->parent()->target())
 //             {
 //                 cmakeSuccessful &= changesWidgetMoveTargetFile(dirtyItem, dirtyItemNewUrl, &changesWidget);
 //             }
 //         }
 //
 //         oldUrls += movedItem->url();
 //         movedUrls += movedItemNewUrl;
 //     }
 //
 //     if (changesWidget.hasDocuments() && cmakeSuccessful)
 //         cmakeSuccessful &= changesWidget.exec() && changesWidget.applyAllChanges();
 //
 //     if (!cmakeSuccessful)
 //     {
 //         if (KMessageBox::questionYesNo( QApplication::activeWindow(),
 //                                         i18n("Changes to CMakeLists failed, abort move?"),
 //                                         DIALOG_CAPTION ) == KMessageBox::Yes)
 //             return false;
 //     }
 //
 //     QList<QUrl>::const_iterator it1=oldUrls.constBegin(), it1End=oldUrls.constEnd();
 //     QList<QUrl>::const_iterator it2=movedUrls.constBegin();
 //     Q_ASSERT(oldUrls.size()==movedUrls.size());
 //     for(; it1!=it1End; ++it1, ++it2)
 //     {
 //         if (!KDevelop::renameUrl(project, *it1, *it2))
 //             return false;
 //
 //         QList<ProjectBaseItem*> renamedItems = project->itemsForUrl(*it2);
 //         bool dir = QFileInfo(it2->toLocalFile()).isDir();
 //         foreach(ProjectBaseItem* item, renamedItems) {
 //             if(dir)
 //                 emit folderRenamed(Path(*it1), item->folder());
 //             else
 //                 emit fileRenamed(Path(*it1), item->file());
 //         }
 //     }
 //
 //     return true;
 // }
 //
 // bool CMakeManager::copyFilesAndFolders(const KDevelop::Path::List &items, KDevelop::ProjectFolderItem* toFolder)
 // {
 //     IProject* project = toFolder->project();
 //     foreach(const Path& path, items) {
 //         if (!KDevelop::copyUrl(project, path.toUrl(), toFolder->url()))
 //             return false;
 //     }
 //
 //     return true;
 // }
 //
 // bool CMakeManager::removeFilesAndFolders(const QList<KDevelop::ProjectBaseItem*> &items)
 // {
 //     using namespace CMakeEdit;
 //
 //     IProject* p = 0;
 //     QList<QUrl> urls;
 //     foreach(ProjectBaseItem* item, items)
 //     {
 //         Q_ASSERT(item->folder() || item->file());
 //
 //         urls += item->url();
 //         if(!p)
 //             p = item->project();
 //     }
 //
 //     //First do CMakeLists changes
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Remove files and folders from CMakeLists as follows:"));
 //
 //     bool cmakeSuccessful = changesWidgetRemoveItems(cmakeListedItemsAffectedByItemsChanged(items).toSet(), &changesWidget);
 //
 //     if (changesWidget.hasDocuments() && cmakeSuccessful)
 //         cmakeSuccessful &= changesWidget.exec() && changesWidget.applyAllChanges();
 //
 //     if (!cmakeSuccessful)
 //     {
 //         if (KMessageBox::questionYesNo( QApplication::activeWindow(),
 //                                         i18n("Changes to CMakeLists failed, abort deletion?"),
 //                                         DIALOG_CAPTION ) == KMessageBox::Yes)
 //             return false;
 //     }
 //
 //     bool ret = true;
 //     //Then delete the files/folders
 //     foreach(const QUrl& file, urls)
 //     {
 //         ret &= KDevelop::removeUrl(p, file, QDir(file.toLocalFile()).exists());
 //     }
 //
 //     return ret;
 // }
 
 bool CMakeManager::removeFilesFromTargets(const QList<ProjectFileItem*> &/*files*/)
 {
 //     using namespace CMakeEdit;
 //
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Modify project targets as follows:"));
 //
 //     if (!files.isEmpty() &&
 //         changesWidgetRemoveFilesFromTargets(files, &changesWidget) &&
 //         changesWidget.exec() &&
 //         changesWidget.applyAllChanges()) {
 //         return true;
 //     }
     return false;
 }
 
 // ProjectFolderItem* CMakeManager::addFolder(const Path& folder, ProjectFolderItem* parent)
 // {
 //     using namespace CMakeEdit;
 //
 //     CMakeFolderItem *cmakeParent = nearestCMakeFolder(parent);
 //     if(!cmakeParent)
 //         return 0;
 //
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Create folder '%1':", folder.lastPathSegment()));
 //
 //     ///FIXME: use path in changes widget
 //     changesWidgetAddFolder(folder.toUrl(), cmakeParent, &changesWidget);
 //
 //     if(changesWidget.exec() && changesWidget.applyAllChanges())
 //     {
 //         if(KDevelop::createFolder(folder.toUrl())) { //If saved we create the folder then the CMakeLists.txt file
 //             Path newCMakeLists(folder, "CMakeLists.txt");
 //             KDevelop::createFile( newCMakeLists.toUrl() );
 //         } else
 //             KMessageBox::error(0, i18n("Could not save the change."),
 //                                   DIALOG_CAPTION);
 //     }
 //
 //     return 0;
 // }
 //
 // KDevelop::ProjectFileItem* CMakeManager::addFile( const Path& file, KDevelop::ProjectFolderItem* parent)
 // {
 //     KDevelop::ProjectFileItem* created = 0;
 //     if ( KDevelop::createFile(file.toUrl()) ) {
 //         QList< ProjectFileItem* > files = parent->project()->filesForPath(IndexedString(file.pathOrUrl()));
 //         if(!files.isEmpty())
 //             created = files.first();
 //         else
 //             created = new KDevelop::ProjectFileItem( parent->project(), file, parent );
 //     }
 //     return created;
 // }
 
 bool CMakeManager::addFilesToTarget(const QList< ProjectFileItem* > &/*_files*/, ProjectTargetItem* /*target*/)
 {
     return false;
 //     using namespace CMakeEdit;
 //
 //     const QSet<QString> headerExt = QSet<QString>() << ".h" << ".hpp" << ".hxx";
 //     QList< ProjectFileItem* > files = _files;
 //     for (int i = files.count() - 1; i >= 0; --i)
 //     {
 //         QString fileName = files[i]->fileName();
 //         QString fileExt = fileName.mid(fileName.lastIndexOf('.'));
 //         QList<ProjectBaseItem*> sameUrlItems = files[i]->project()->itemsForUrl(files[i]->url());
 //         if (headerExt.contains(fileExt))
 //             files.removeAt(i);
 //         else foreach(ProjectBaseItem* item, sameUrlItems)
 //         {
 //             if (item->parent() == target)
 //             {
 //                 files.removeAt(i);
 //                 break;
 //             }
 //         }
 //     }
 //
 //     if(files.isEmpty())
 //         return true;
 //
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Modify target '%1' as follows:", target->baseName()));
 //
 //     bool success = changesWidgetAddFilesToTarget(files, target, &changesWidget) &&
 //                    changesWidget.exec() &&
 //                    changesWidget.applyAllChanges();
 //
 //     if(!success)
 //         KMessageBox::error(0, i18n("CMakeLists changes failed."), DIALOG_CAPTION);
 //
 //     return success;
 }
 
 // bool CMakeManager::renameFileOrFolder(ProjectBaseItem *item, const Path &newPath)
 // {
 //     using namespace CMakeEdit;
 //
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Rename '%1' to '%2':", item->text(),
 //                                       newPath.lastPathSegment()));
 //
 //     bool cmakeSuccessful = true, changedCMakeLists=false;
 //     IProject* project=item->project();
 //     const Path oldPath=item->path();
 //     QUrl oldUrl=oldPath.toUrl();
 //     if (item->file())
 //     {
 //         QList<ProjectBaseItem*> targetFiles = cmakeListedItemsAffectedByUrlChange(project, oldUrl);
 //         foreach(ProjectBaseItem* targetFile, targetFiles)
 //             ///FIXME: use path in changes widget
 //             cmakeSuccessful &= changesWidgetMoveTargetFile(targetFile, newPath.toUrl(), &changesWidget);
 //     }
 //     else if (CMakeFolderItem *folder = dynamic_cast<CMakeFolderItem*>(item))
 //         ///FIXME: use path in changes widget
 //         cmakeSuccessful &= changesWidgetRenameFolder(folder, newPath.toUrl(), &changesWidget);
 //
 //     item->setPath(newPath);
 //     if (changesWidget.hasDocuments() && cmakeSuccessful) {
 //         changedCMakeLists = changesWidget.exec() && changesWidget.applyAllChanges();
 //         cmakeSuccessful &= changedCMakeLists;
 //     }
 //
 //     if (!cmakeSuccessful)
 //     {
 //         if (KMessageBox::questionYesNo( QApplication::activeWindow(),
 //             i18n("Changes to CMakeLists failed, abort rename?"),
 //                                         DIALOG_CAPTION ) == KMessageBox::Yes)
 //             return false;
 //     }
 //
 //     bool ret = KDevelop::renameUrl(project, oldUrl, newPath.toUrl());
 //     if(!ret) {
 //         item->setPath(oldPath);
 //     }
 //     return ret;
 // }
 //
 // bool CMakeManager::renameFile(ProjectFileItem *item, const Path &newPath)
 // {
 //     return renameFileOrFolder(item, newPath);
 // }
 //
 // bool CMakeManager::renameFolder(ProjectFolderItem* item, const Path &newPath)
 // {
 //     return renameFileOrFolder(item, newPath);
 // }
 
 QWidget* CMakeManager::specialLanguageObjectNavigationWidget(const QUrl &url, const KTextEditor::Cursor& position)
 {
     KDevelop::TopDUContextPointer top= TopDUContextPointer(KDevelop::DUChain::self()->chainForDocument(url));
     Declaration *decl=nullptr;
     if(top)
     {
         int useAt=top->findUseAt(top->transformToLocalRevision(position));
         if(useAt>=0)
         {
             Use u=top->uses()[useAt];
             decl=u.usedDeclaration(top->topContext());
         }
     }
 
     CMakeNavigationWidget* doc=nullptr;
     if(decl)
     {
         doc=new CMakeNavigationWidget(top, decl);
     }
     else
     {
         const IDocument* d=ICore::self()->documentController()->documentForUrl(url);
         const KTextEditor::Document* e=d->textDocument();
         KTextEditor::Cursor start=position, end=position, step(0,1);
         for(QChar i=e->characterAt(start); i.isLetter() || i=='_'; i=e->characterAt(start-=step))
         {}
         start+=step;
 
         for(QChar i=e->characterAt(end); i.isLetter() || i=='_'; i=e->characterAt(end+=step))
         {}
 
         QString id=e->text(KTextEditor::Range(start, end));
         ICMakeDocumentation* docu=CMake::cmakeDocumentation();
         if( docu )
         {
             IDocumentation::Ptr desc=docu->description(id, url);
             if(desc)
             {
                 doc=new CMakeNavigationWidget(top, desc);
             }
         }
     }
 
     return doc;
 }
 
 QPair<QString, QString> CMakeManager::cacheValue(KDevelop::IProject* /*project*/, const QString& /*id*/) const
 { return QPair<QString, QString>(); }
 // {
 //     QPair<QString, QString> ret;
 //     if(project==0 && !m_projectsData.isEmpty())
 //     {
 //         project=m_projectsData.keys().first();
 //     }
 //
 // //     qCDebug(CMAKE) << "cache value " << id << project << (m_projectsData.contains(project) && m_projectsData[project].cache.contains(id));
 //     CMakeProjectData* data = m_projectsData[project];
 //     if(data && data->cache.contains(id))
 //     {
 //         const CacheEntry& e=data->cache.value(id);
 //         ret.first=e.value;
 //         ret.second=e.doc;
 //     }
 //     return ret;
 // }Add
 //
 void CMakeManager::projectClosing(IProject* p)
 {
     m_projects.remove(p);
 //     delete m_projectsData.take(p);
 //     delete m_watchers.take(p);
 //
 //     m_filter->remove(p);
 //
 //     qCDebug(CMAKE) << "Project closed" << p;
 }
 //
 // QStringList CMakeManager::processGeneratorExpression(const QStringList& expr, IProject* project, ProjectTargetItem* target) const
 // {
 //     QStringList ret;
 //     const CMakeProjectData* data = m_projectsData[project];
 //     GenerationExpressionSolver exec(data->properties, data->targetAlias);
 //     if(target)
 //         exec.setTargetName(target->text());
 //
 //     exec.defineVariable("INSTALL_PREFIX", data->vm.value("CMAKE_INSTALL_PREFIX").join(QString()));
 //     for(QStringList::const_iterator it = expr.constBegin(), itEnd = expr.constEnd(); it!=itEnd; ++it) {
 //         QStringList val = exec.run(*it).split(';');
 //         ret += val;
 //     }
 //     return ret;
 // }
 /*
 void CMakeManager::addPending(const Path& path, CMakeFolderItem* folder)
 {
     m_pending.insert(path, folder);
 }
 
 CMakeFolderItem* CMakeManager::takePending(const Path& path)
 {
     return m_pending.take(path);
 }
 
 void CMakeManager::addWatcher(IProject* p, const QString& path)
 {
     if (QFileSystemWatcher* watcher = m_watchers.value(p)) {
         watcher->addPath(path);
     } else {
         qWarning() << "Could not find a watcher for project" << p << p->name() << ", path " << path;
         Q_ASSERT(false);
     }
 }*/
 
 // CMakeProjectData CMakeManager::projectData(IProject* project)
 // {
 //     Q_ASSERT(QThread::currentThread() == project->thread());
 //     CMakeProjectData* data = m_projectsData[project];
 //     if(!data) {
 //         data = new CMakeProjectData;
 //         m_projectsData[project] = data;
 //     }
 //     return *data;
 // }
 
 ProjectFilterManager* CMakeManager::filterManager() const
 {
     return m_filter;
 }
 
 void CMakeManager::dirtyFile(const QString& path)
 {
     qCDebug(CMAKE) << "dirty!" << path;
 
     //we initialize again hte project that sent the signal
     for(QHash<IProject*, CMakeProjectData>::const_iterator it = m_projects.constBegin(), itEnd = m_projects.constEnd(); it!=itEnd; ++it) {
         if(it->watcher == sender()) {
             reload(it.key()->projectItem());
             break;
         }
     }
 }
 
 void CMakeManager::folderAdded(KDevelop::ProjectFolderItem* folder)
 {
     populateTargets(folder, m_projects[folder->project()].targets);
 }
 
 ProjectFolderItem* CMakeManager::createFolderItem(IProject* project, const Path& path, ProjectBaseItem* parent)
 {
 //     TODO: when we have data about targets, use folders with targets or similar
     if (QFile::exists(path.toLocalFile()+"/CMakeLists.txt"))
         return new KDevelop::ProjectBuildFolderItem( project, path, parent );
     else
         return KDevelop::AbstractFileManagerPlugin::createFolderItem(project, path, parent);
 }
 
 int CMakeManager::perProjectConfigPages() const
 {
     return 1;
 }
 
 ConfigPage* CMakeManager::perProjectConfigPage(int number, const ProjectConfigOptions& options, QWidget* parent)
 {
     if (number == 0) {
         return new CMakePreferences(this, options, parent);
     }
     return nullptr;
 }
 
 #include "cmakemanager.moc"
diff --git a/projectmanagers/cmake/cmakemanager.h b/projectmanagers/cmake/cmakemanager.h
index 6720441b51..f719b94911 100644
--- a/projectmanagers/cmake/cmakemanager.h
+++ b/projectmanagers/cmake/cmakemanager.h
@@ -1,168 +1,166 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@kde.org>
  * Copyright 2007-2009 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.
  */
 
 #ifndef CMAKEMANAGER_H
 #define CMAKEMANAGER_H
 
 #include <QList>
 #include <QString>
 #include <QtCore/QVariant>
 
 #include <project/interfaces/iprojectfilemanager.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <project/abstractfilemanagerplugin.h>
 #include <language/interfaces/ilanguagesupport.h>
 #include <language/codegen/applychangeswidget.h>
 #include <interfaces/iplugin.h>
 #include <interfaces/idocumentationprovider.h>
 
 #include "cmakeprojectdata.h"
 #include "icmakemanager.h"
 
 class WaitAllJobs;
 class CMakeCommitChangesJob;
 struct CMakeProjectData;
-class QStandardItem;
-class QDir;
 class QObject;
 class CMakeHighlighting;
 class CMakeDocumentation;
 
 namespace KDevelop
 {
     class IProject;
     class IProjectBuilder;
     class ICodeHighlighting;
     class ProjectFolderItem;
     class ProjectBaseItem;
     class ProjectFileItem;
     class ProjectTargetItem;
     class ProjectFilterManager;
     class IProjectFilter;
     class ParseJob;
     class ContextMenuExtension;
     class Context;
 }
 
 class CMakeFolderItem;
 
 class CMakeManager
     : public KDevelop::AbstractFileManagerPlugin
     , public KDevelop::IBuildSystemManager
     , public KDevelop::ILanguageSupport
     , public ICMakeManager
 {
 Q_OBJECT
 Q_INTERFACES( KDevelop::IBuildSystemManager )
 Q_INTERFACES( KDevelop::IProjectFileManager )
 Q_INTERFACES( KDevelop::ILanguageSupport )
 Q_INTERFACES( ICMakeManager )
 public:
     explicit CMakeManager( QObject* parent = nullptr, const QVariantList& args = QVariantList() );
 
     ~CMakeManager() override;
 
     Features features() const override { return Features(Folders | Targets | Files ); }
     KDevelop::IProjectBuilder* builder() const override;
     bool hasBuildInfo(KDevelop::ProjectBaseItem*) const override;
     KDevelop::Path buildDirectory(KDevelop::ProjectBaseItem*) const override;
     KDevelop::Path::List includeDirectories(KDevelop::ProjectBaseItem *) const override;
     KDevelop::Path::List frameworkDirectories(KDevelop::ProjectBaseItem *item) const override;
     QHash<QString, QString> defines(KDevelop::ProjectBaseItem *) const override;
 
     KDevelop::ProjectTargetItem* createTarget( const QString&, KDevelop::ProjectFolderItem* ) override { return nullptr; }
 
     virtual QList<KDevelop::ProjectTargetItem*> targets() const;
     QList<KDevelop::ProjectTargetItem*> targets(KDevelop::ProjectFolderItem* folder) const override;
 //     virtual KDevelop::ProjectFolderItem* addFolder( const KDevelop::Path& folder, KDevelop::ProjectFolderItem* parent );
 //     virtual KDevelop::ProjectFileItem* addFile( const KDevelop::Path&, KDevelop::ProjectFolderItem* );
     bool addFilesToTarget( const QList<KDevelop::ProjectFileItem*> &files, KDevelop::ProjectTargetItem* target) override;
 
     bool removeTarget( KDevelop::ProjectTargetItem* ) override { return false; }
     bool removeFilesFromTargets( const QList<KDevelop::ProjectFileItem*> &files ) override;
 //     virtual bool removeFilesAndFolders( const QList<KDevelop::ProjectBaseItem*> &items);
 //
 //     virtual bool renameFile(KDevelop::ProjectFileItem*, const KDevelop::Path&);
 //     virtual bool renameFolder(KDevelop::ProjectFolderItem*, const KDevelop::Path&);
 //     virtual bool moveFilesAndFolders(const QList< KDevelop::ProjectBaseItem* > &items, KDevelop::ProjectFolderItem *newParent);
 //     virtual bool copyFilesAndFolders(const KDevelop::Path::List &items, KDevelop::ProjectFolderItem* newParent);
 //
 //     virtual QList<KDevelop::ProjectFolderItem*> parse( KDevelop::ProjectFolderItem* dom );
     KDevelop::ProjectFolderItem* import( KDevelop::IProject *project ) override;
 
     KJob* createImportJob(KDevelop::ProjectFolderItem* item) override;
 //
     bool reload(KDevelop::ProjectFolderItem*) override;
 //
 //     virtual KDevelop::ContextMenuExtension contextMenuExtension( KDevelop::Context* context );
 
 
     KDevelop::ProjectFolderItem* createFolderItem(KDevelop::IProject* project, const KDevelop::Path& path, KDevelop::ProjectBaseItem* parent = nullptr) override;
     QPair<QString, QString> cacheValue(KDevelop::IProject* project, const QString& id) const override;
     
     //LanguageSupport
     QString name() const override;
     KDevelop::ParseJob *createParseJob(const KDevelop::IndexedString &url) override;
     KDevelop::ICodeHighlighting* codeHighlighting() const override;
     QWidget* specialLanguageObjectNavigationWidget(const QUrl &url, const KTextEditor::Cursor& position) override;
     
 //     void addPending(const KDevelop::Path& path, CMakeFolderItem* folder);
 //     CMakeFolderItem* takePending(const KDevelop::Path& path);
 //     void addWatcher(KDevelop::IProject* p, const QString& path);
     
 //     CMakeProjectData projectData(KDevelop::IProject* project);
 
     KDevelop::ProjectFilterManager* filterManager() const;
 
     static KDevelop::IndexedString languageName();
 
     int perProjectConfigPages() const override;
     KDevelop::ConfigPage* perProjectConfigPage(int number, const KDevelop::ProjectConfigOptions& options, QWidget* parent) override;
 
     void integrateData(const CMakeProjectData &data, KDevelop::IProject* project);
 
 signals:
     void folderRenamed(const KDevelop::Path& oldFolder, KDevelop::ProjectFolderItem* newFolder);
     void fileRenamed(const KDevelop::Path& oldFile, KDevelop::ProjectFileItem* newFile);
 
 private slots:
 //     void dirtyFile(const QString& file);
 //
 //     void jumpToDeclaration();
     void projectClosing(KDevelop::IProject*);
     void dirtyFile(const QString& file);
 //
 //     void directoryChanged(const QString& dir);
 //     void filesystemBuffererTimeout();
 
 private:
     CMakeFile fileInformation(KDevelop::ProjectBaseItem* item) const;
 
     void folderAdded(KDevelop::ProjectFolderItem* folder);
 
     QHash<KDevelop::IProject*, CMakeProjectData> m_projects;
     KDevelop::ProjectFilterManager* m_filter;
     KDevelop::ICodeHighlighting* m_highlight;
 };
 
 #endif
 
 
diff --git a/projectmanagers/cmake/cmakemodelitems.h b/projectmanagers/cmake/cmakemodelitems.h
index 43e08a1c2c..05c009b574 100644
--- a/projectmanagers/cmake/cmakemodelitems.h
+++ b/projectmanagers/cmake/cmakemodelitems.h
@@ -1,43 +1,41 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@kde.org>
  * Copyright 2007-2008 Aleix Pol <aleixpol@gmail.com>
  *
  * 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 CMAKEMODELITEMS_H
 #define CMAKEMODELITEMS_H
 
-#include <QHash>
-
 #include <project/projectmodel.h>
 #include <interfaces/iproject.h>
 #include <language/duchain/topducontext.h>
 #include <parser/cmakelistsparser.h>
 #include <parser/cmaketypes.h>
 #include <util/path.h>
 
 class CMakeTargetItem : public KDevelop::ProjectExecutableTargetItem
 {
     public:
         CMakeTargetItem(KDevelop::ProjectFolderItem* parent, const QString& name);
 
         QUrl builtUrl() const override;
         QUrl installedUrl() const override;
 };
 
 #endif
diff --git a/projectmanagers/cmake/cmakeprojectdata.cpp b/projectmanagers/cmake/cmakeprojectdata.cpp
index ae8418ff12..ae32091f87 100644
--- a/projectmanagers/cmake/cmakeprojectdata.cpp
+++ b/projectmanagers/cmake/cmakeprojectdata.cpp
@@ -1,34 +1,30 @@
 /* KDevelop CMake Support
  *
  * Copyright 2017 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 "cmakeprojectdata.h"
 #include "cmakeutils.h"
-#include <QJsonDocument>
-#include <QJsonObject>
-#include <QJsonArray>
-#include <QFileInfo>
 
 CMakeProjectData::CMakeProjectData(const QHash<KDevelop::Path, QStringList>& targets, const CMakeFilesCompilationData& data, const QVector<Test>& tests)
     : compilationData(data)
     , targets(targets)
     , watcher(new QFileSystemWatcher)
     , m_testSuites(tests)
 {
 }
diff --git a/projectmanagers/cmake/cmakeprojectdata.h b/projectmanagers/cmake/cmakeprojectdata.h
index dec1ff4bbd..bfab88997b 100644
--- a/projectmanagers/cmake/cmakeprojectdata.h
+++ b/projectmanagers/cmake/cmakeprojectdata.h
@@ -1,74 +1,71 @@
 /* KDevelop CMake Support
  *
  * Copyright 2013-2017 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.
  */
 
 #ifndef CMAKEPROJECTDATA_H
 #define CMAKEPROJECTDATA_H
 
-#include <QPointer>
 #include <QSharedPointer>
 #include <QStringList>
-#include <QJsonObject>
-#include <QProcess>
 #include <QFileSystemWatcher>
 #include "cmaketypes.h"
 #include <util/path.h>
 
 class CMakeServer;
 
 /**
  * Represents any file in a cmake project that has been added
  * to the project.
  *
  * Contains the required information to compile it properly
  */
 struct CMakeFile
 {
     KDevelop::Path::List includes;
     KDevelop::Path::List frameworkDirectories;
     QHash<QString, QString> defines;
 };
 inline QDebug &operator<<(QDebug debug, const CMakeFile& file)
 {
     debug << "CMakeFile(-I" << file.includes << ", -F" << file.frameworkDirectories << ", -D" << file.defines << ")";
     return debug.maybeSpace();
 }
 
 struct CMakeFilesCompilationData
 {
     QHash<KDevelop::Path, CMakeFile> files;
     bool isValid = false;
 };
 
 struct CMakeProjectData
 {
     CMakeProjectData(const QHash<KDevelop::Path, QStringList> &targets, const CMakeFilesCompilationData &data, const QVector<Test> &tests);
 
     CMakeProjectData() : watcher(new QFileSystemWatcher) {}
     ~CMakeProjectData() {}
 
     CMakeFilesCompilationData compilationData;
     QHash<KDevelop::Path, QStringList> targets;
     QSharedPointer<QFileSystemWatcher> watcher;
     QSharedPointer<CMakeServer> m_server;
 
     QVector<Test> m_testSuites;
 };
 
 #endif
diff --git a/projectmanagers/cmake/cmakeserverimportjob.cpp b/projectmanagers/cmake/cmakeserverimportjob.cpp
index 5fd7fbe525..c455db4bb6 100644
--- a/projectmanagers/cmake/cmakeserverimportjob.cpp
+++ b/projectmanagers/cmake/cmakeserverimportjob.cpp
@@ -1,168 +1,169 @@
 /* KDevelop CMake Support
  *
  * Copyright 2017 Aleix Pol Gonzalez <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 "cmakeserverimportjob.h"
 #include "cmakeutils.h"
 #include "cmakeserver.h"
 #include <interfaces/iproject.h>
+#include <QJsonObject>
 #include <QJsonArray>
 #include <QRegularExpression>
 #include "debug.h"
 #include <projectmanagers/custommake/makefileresolver/makefileresolver.h>
 
 template <typename T, typename Q, typename W>
 static T kTransform(const Q& list, W func)
 {
     T ret;
     ret.reserve(list.size());
     for (auto it = list.constBegin(), itEnd = list.constEnd(); it!=itEnd; ++it)
         ret += func(*it);
     return ret;
 }
 
 static QString unescape(const QStringRef& input)
 {
   QString output;
   output.reserve(input.length());
   bool isEscaped = false;
   for (auto it = input.data(), end = it + input.length(); it != end; ++it) {
     QChar c = *it;
     if (!isEscaped && c == '\\') {
       isEscaped = true;
     } else {
       output.append(c);
       isEscaped = false;
     }
   }
   return output;
 }
 
 static QHash<QString, QString> processDefines(const QString &compileFlags, const QJsonArray &defines)
 {
     QHash<QString, QString> ret;
     const auto& defineRx = MakeFileResolver::defineRegularExpression();
     auto it = defineRx.globalMatch(compileFlags);
     while (it.hasNext()) {
       const auto match = it.next();
       QString value;
       if (match.lastCapturedIndex() > 1) {
         value = unescape(match.capturedRef(match.lastCapturedIndex()));
       }
       ret[match.captured(1)] = value;
     }
 
     for (const QJsonValue& defineValue: defines) {
         const QString define = defineValue.toString();
         const int eqIdx = define.indexOf(QLatin1Char('='));
         if (eqIdx<0) {
             ret[define] = QString();
         } else {
             ret[define.left(eqIdx)] = define.mid(eqIdx+1);
         }
     }
     return ret;
 }
 
 static void processFileData(const QJsonObject &response, CMakeProjectData &data)
 {
     const auto configs = response.value(QLatin1String("configurations")).toArray();
     qCDebug(CMAKE) << "process response" << response;
     for (const auto &config: configs) {
         const auto projects = config.toObject().value(QLatin1String("projects")).toArray();
         for (const auto &project: projects) {
             const auto targets = project.toObject().value(QLatin1String("targets")).toArray();
             for (const auto &targetObject: targets) {
                 const auto target = targetObject.toObject();
                 const KDevelop::Path targetDir(target.value(QLatin1String("sourceDirectory")).toString());
 
                 data.targets[targetDir] += target.value(QLatin1String("name")).toString();
 
                 const auto fileGroups = target.value(QLatin1String("fileGroups")).toArray();
                 for (const auto &fileGroupValue: fileGroups) {
                     const auto fileGroup = fileGroupValue.toObject();
                     CMakeFile file;
                     file.includes = kTransform<KDevelop::Path::List>(fileGroup.value(QLatin1String("includePath")).toArray(), [](const QJsonValue& val) { return KDevelop::Path(val.toObject().value(QLatin1String("path")).toString()); });
                     file.defines = processDefines(fileGroup.value(QLatin1String("compileFlags")).toString(), fileGroup.value(QLatin1String("defines")).toArray());
 
                     const auto sourcesArray = fileGroup.value(QLatin1String("sources")).toArray();
                     const KDevelop::Path::List sources = kTransform<KDevelop::Path::List>(sourcesArray, [targetDir](const QJsonValue& val) { return KDevelop::Path(targetDir, val.toString()); });
                     for (const auto& source: sources) {
                         data.compilationData.files[source] = file;
                     }
                     qCDebug(CMAKE) << "registering..." << sources << file;
                 }
             }
         }
     }
 }
 
 CMakeServerImportJob::CMakeServerImportJob(KDevelop::IProject* project, CMakeServer* server, QObject* parent)
     : KJob(parent)
     , m_server(server)
     , m_project(project)
 {
     connect(m_server.data(), &CMakeServer::disconnected, this, [this]() {
         setError(UnexpectedDisconnect);
         emitResult();
     });
 }
 
 void CMakeServerImportJob::start()
 {
     if (m_server->isServerAvailable())
         doStart();
     else
         connect(m_server.data(), &CMakeServer::connected, this, &CMakeServerImportJob::doStart);
 }
 
 void CMakeServerImportJob::doStart()
 {
     connect(m_server.data(), &CMakeServer::response, this, &CMakeServerImportJob::processResponse);
 
     m_server->handshake(m_project->path(), CMake::currentBuildDir(m_project));
 }
 
 void CMakeServerImportJob::processResponse(const QJsonObject& response)
 {
     const auto responseType = response.value(QLatin1String("type"));
     if (responseType == QLatin1String("reply")) {
         const auto inReplyTo = response.value(QLatin1String("inReplyTo"));
         qCDebug(CMAKE) << "replying..." << inReplyTo;
         if (inReplyTo == QLatin1String("handshake")) {
             m_server->configure({});
         } else if (inReplyTo == QLatin1String("configure")) {
             m_server->compute();
         } else if (inReplyTo == QLatin1String("compute")) {
             m_server->codemodel();
         } else if(inReplyTo == QLatin1String("codemodel")) {
             processFileData(response, m_data);
             emitResult();
         } else {
             qWarning() << "unhandled reply" << response;
         }
     } else if(responseType == QLatin1String("error")) {
         setError(ErrorResponse);
         setErrorText(response.value(QLatin1String("errorMessage")).toString());
         qWarning() << "error!!" << response;
         emitResult();
     } else {
         qWarning() << "unhandled message" << response;
     }
 }
diff --git a/projectmanagers/cmake/cmakeserverimportjob.h b/projectmanagers/cmake/cmakeserverimportjob.h
index 4ed483a4e2..059d249453 100644
--- a/projectmanagers/cmake/cmakeserverimportjob.h
+++ b/projectmanagers/cmake/cmakeserverimportjob.h
@@ -1,56 +1,57 @@
 /* KDevelop CMake Support
  *
  * Copyright 2017 Aleix Pol Gonzalez <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.
  */
 
 #ifndef CMAKESERVERIMPORTJOB_H
 #define CMAKESERVERIMPORTJOB_H
 
+#include <QPointer>
 #include <KJob>
 #include "cmakeprojectdata.h"
 
 namespace KDevelop
 {
 class IProject;
 }
 
 class CMakeServerImportJob : public KJob
 {
     Q_OBJECT
 public:
     CMakeServerImportJob(KDevelop::IProject* project, CMakeServer* server, QObject* parent);
 
     enum Error { NoError, UnexpectedDisconnect, ErrorResponse };
 
     void start() override;
 
     KDevelop::IProject* project() const { return m_project; }
 
     CMakeProjectData projectData() const { return m_data; }
 
 private:
     void doStart();
     void processResponse(const QJsonObject &response);
 
     QPointer<CMakeServer> m_server;
     KDevelop::IProject* m_project;
 
     CMakeProjectData m_data;
 };
 
 #endif // CMAKESERVERIMPORTJOB_H
diff --git a/projectmanagers/cmake/cmakeutils.cpp b/projectmanagers/cmake/cmakeutils.cpp
index 749abc6bf2..9643fe1270 100644
--- a/projectmanagers/cmake/cmakeutils.cpp
+++ b/projectmanagers/cmake/cmakeutils.cpp
@@ -1,641 +1,639 @@
 /* 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 <QtCore/QFileInfo>
 #include <QtCore/QDir>
 #include <QProcess>
 #include <QTemporaryDir>
 #include <QRegularExpression>
 
-#include <kconfig.h>
 #include <KLocalizedString>
 #include <kconfiggroup.h>
-#include <kparts/mainwindow.h>
 
 #include <project/projectmodel.h>
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/idocumentationcontroller.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>
 
 using namespace KDevelop;
 
 namespace Config
 {
 namespace Old
 {
 static const QString currentBuildDirKey = "CurrentBuildDir";
 static const QString currentCMakeBinaryKey = "Current CMake Binary";
 static const QString currentBuildTypeKey = "CurrentBuildType";
 static const QString currentInstallDirKey = "CurrentInstallDir";
 static const QString currentEnvironmentKey = "CurrentEnvironment";
 static const QString currentExtraArgumentsKey = "Extra Arguments";
 static const QString projectRootRelativeKey = "ProjectRootRelative";
 static const QString projectBuildDirs = "BuildDirs";
 }
 
 static const QString buildDirIndexKey = "Current Build Directory Index";
 static const QString buildDirOverrideIndexKey = "Temporary Build Directory Index";
 static const QString buildDirCountKey = "Build Directory Count";
 
 namespace Specific
 {
 static const QString buildDirPathKey = "Build Directory Path";
 // TODO: migrate to more generic & consistent key term "CMake Executable"
 static const QString cmakeExecutableKey = "CMake Binary";
 static const QString cmakeBuildTypeKey = "Build Type";
 static const QString cmakeInstallDirKey = "Install Directory";
 static const QString cmakeEnvironmentKey = "Environment Profile";
 static const QString cmakeArgumentsKey = "Extra Arguments";
 }
 
 static const QString groupNameBuildDir = "CMake Build Directory %1";
 static const QString groupName = "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) );
 }
 
 int currentBuildDirIndex( KDevelop::IProject* project )
 {
     KConfigGroup baseGrp = baseGroup(project);
 
     if ( baseGrp.hasKey( Config::buildDirOverrideIndexKey ) )
         return baseGrp.readEntry<int>( Config::buildDirOverrideIndexKey, 0 );
 
     else
         return baseGrp.readEntry<int>( Config::buildDirIndexKey, 0 ); // default is 0 because QString::number(0) apparently returns an empty string
 }
 
 QString readProjectParameter( KDevelop::IProject* project, const QString& key, const QString& aDefault )
 {
     int buildDirIndex = currentBuildDirIndex(project);
     if (buildDirIndex >= 0)
         return buildDirGroup( project, buildDirIndex ).readEntry( key, aDefault );
 
     else
         return aDefault;
 }
 
 void writeProjectParameter( KDevelop::IProject* project, const QString& key, const QString& value )
 {
     int buildDirIndex = currentBuildDirIndex(project);
     if (buildDirIndex >= 0)
     {
         KConfigGroup buildDirGrp = buildDirGroup( project, buildDirIndex );
         buildDirGrp.writeEntry( key, value );
     }
 
     else
     {
         qWarning() << "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 );
 }
 
 } // 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());
     foreach(const QString& s, dirs)
     {
         KDevelop::Path dir;
         if(s.startsWith(QString::fromUtf8("#[bin_dir]")))
         {
             dir = KDevelop::Path(buildDir, s);
         }
         else if(s.startsWith(QString::fromUtf8("#[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 )
 {
     const KDevelop::Path builddir = currentBuildDir(project);
     if( !builddir.isValid() )
     {
         CMakeBuildDirChooser bd;
 
         KDevelop::Path folder = project->path();
         QString relative=CMake::projectRootRelative(project);
         folder.cd(relative);
 
         bd.setSourceFolder( folder );
         bd.setAlreadyUsed( CMake::allBuildDirs(project) );
         bd.setCMakeExecutable(currentCMakeExecutable(project));
 
         if( !bd.exec() )
         {
             return false;
         }
 
         QString newbuilddir = bd.buildFolder().toLocalFile();
         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 " << bd.buildFolder();
         qCDebug(CMAKE) << "adding to cmake config: installdir " << bd.installPrefix();
         qCDebug(CMAKE) << "adding to cmake config: extra args" << bd.extraArguments();
         qCDebug(CMAKE) << "adding to cmake config: build type " << bd.buildType();
         qCDebug(CMAKE) << "adding to cmake config: cmake executable " << bd.cmakeExecutable();
         qCDebug(CMAKE) << "adding to cmake config: environment <null>";
         CMake::setBuildDirCount( project, addedBuildDirIndex + 1 );
         CMake::setCurrentBuildDirIndex( project, addedBuildDirIndex );
         CMake::setCurrentBuildDir( project, bd.buildFolder() );
         CMake::setCurrentInstallDir( project, bd.installPrefix() );
         CMake::setCurrentExtraArguments( project, bd.extraArguments() );
         CMake::setCurrentBuildType( project, bd.buildType() );
         CMake::setCurrentCMakeExecutable(project, bd.cmakeExecutable());
         CMake::setCurrentEnvironment( project, QString() );
 
         return true;
     } else if( !QFile::exists( KDevelop::Path(builddir, "CMakeCache.txt").toLocalFile() ) ||
                 //TODO: maybe we could use the builder for that?
                !(QFile::exists( KDevelop::Path(builddir, "Makefile").toLocalFile() ) ||
                     QFile::exists( KDevelop::Path(builddir, "build.ninja").toLocalFile() ) ) )
     {
         // User entered information already, but cmake hasn't actually been run yet.
         return true;
     }
     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 )
 {
     return KDevelop::Path(readProjectParameter( project, Config::Specific::buildDirPathKey, QString() ));
 }
 
 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 )
 {
     return readProjectParameter( project, Config::Specific::cmakeBuildTypeKey, "Release" );
 }
 
 QString findExecutable()
 {
     auto cmake = QStandardPaths::findExecutable("cmake");
 #ifdef Q_OS_WIN
     if (cmake.isEmpty())
         cmake = QStandardPaths::findExecutable("cmake",{
             "C:\\Program Files (x86)\\CMake\\bin",
             "C:\\Program Files\\CMake\\bin",
             "C:\\Program Files (x86)\\CMake 2.8\\bin",
             "C:\\Program Files\\CMake 2.8\\bin"});
 #endif
     return cmake;
 }
 
 KDevelop::Path currentCMakeExecutable(KDevelop::IProject* project)
 {
     const auto systemExecutable = findExecutable();
     auto path = readProjectParameter(project, Config::Specific::cmakeExecutableKey, systemExecutable);
     if (path != systemExecutable) {
         QFileInfo info(path);
         if (!info.isExecutable()) {
             path = systemExecutable;
         }
     }
     return KDevelop::Path(path);
 }
 
 KDevelop::Path currentInstallDir( KDevelop::IProject* project )
 {
     return KDevelop::Path(readProjectParameter( project, Config::Specific::cmakeInstallDirKey, "/usr/local" ));
 }
 
 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 )
 {
     return readProjectParameter( project, Config::Specific::cmakeArgumentsKey, QString() );
 }
 
 void setCurrentInstallDir( KDevelop::IProject* project, const KDevelop::Path& path )
 {
     writeProjectParameter( project, Config::Specific::cmakeInstallDirKey, path.toLocalFile() );
 }
 
 void setCurrentBuildType( KDevelop::IProject* project, const QString& type )
 {
     writeProjectParameter( project, Config::Specific::cmakeBuildTypeKey, type );
 }
 
 void setCurrentCMakeExecutable(KDevelop::IProject* project, const KDevelop::Path& path)
 {
     writeProjectParameter(project, Config::Specific::cmakeExecutableKey, path.toLocalFile());
 }
 
 void setCurrentBuildDir( KDevelop::IProject* project, const KDevelop::Path& path )
 {
     writeProjectParameter( 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)
 {
     writeProjectParameter( project, Config::Specific::cmakeArgumentsKey, string );
 }
 
 QString currentEnvironment(KDevelop::IProject* project)
 {
     return readProjectParameter( project, Config::Specific::cmakeEnvironmentKey, QString() );
 }
 
 
 int currentBuildDirIndex( KDevelop::IProject* project )
 {
     KConfigGroup baseGrp = baseGroup(project);
 
     if ( baseGrp.hasKey( Config::buildDirOverrideIndexKey ) )
         return baseGrp.readEntry<int>( Config::buildDirOverrideIndexKey, 0 );
 
     else
         return baseGrp.readEntry<int>( Config::buildDirIndexKey, 0 ); // default is 0 because QString::number(0) apparently returns an empty string
 }
 
 void setCurrentBuildDirIndex( KDevelop::IProject* project, int buildDirIndex )
 {
     writeProjectBaseParameter( project, Config::buildDirIndexKey, QString::number (buildDirIndex) );
 }
 
 void setCurrentEnvironment( KDevelop::IProject* project, const QString& environment )
 {
     writeProjectParameter( 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 ) )
     {
         qWarning() << "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].isLetterOrNumber())
         {
             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());
     for(auto it = cacheValues.constBegin(), itEnd = cacheValues.constEnd(); it!=itEnd; ++it) {
         const QString key = keys.value(it.key());
         Q_ASSERT(!key.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::currentCMakeBinaryKey );
     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>("org.kdevelop.ICMakeDocumentation");
 }
 
 QStringList allBuildDirs(KDevelop::IProject* project)
 {
     QStringList result;
     int bdCount = buildDirCount(project);
     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("kdevcmakemanager");
     p.setWorkingDirectory( tmp.path() );
     p.start(execName, args, QIODevice::ReadOnly);
 
     if(!p.waitForFinished())
     {
         qCDebug(CMAKE) << "failed to execute:" << execName;
     }
 
     QByteArray b = p.readAllStandardOutput();
     QString t;
     t.prepend(b.trimmed());
     return t;
 }
 
 QStringList supportedGenerators()
 {
     QStringList generatorNames;
 
     bool hasNinja = ICore::self() && ICore::self()->pluginController()->pluginForExtension("org.kdevelop.IProjectBuilder", "KDevNinjaBuilder");
     if (hasNinja)
         generatorNames << "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 << "NMake Makefiles";
 #endif
     generatorNames << "Unix Makefiles";
 
     return generatorNames;
 }
 
 QString defaultGenerator()
 {
     const QStringList generatorNames = supportedGenerators();
 
     QString defGen = generatorNames.value(CMakeBuilderSettings::self()->generator());
     if (defGen.isEmpty())
     {
         qWarning() << "Couldn't find builder with index " << CMakeBuilderSettings::self()->generator()
                    << ", defaulting to 0";
         CMakeBuilderSettings::self()->setGenerator(0);
         defGen = generatorNames.at(0);
     }
     return defGen;
 }
 
 }
 
diff --git a/projectmanagers/cmake/parser/cmakecachereader.cpp b/projectmanagers/cmake/parser/cmakecachereader.cpp
index bdf801ce86..195e10efc8 100644
--- a/projectmanagers/cmake/parser/cmakecachereader.cpp
+++ b/projectmanagers/cmake/parser/cmakecachereader.cpp
@@ -1,67 +1,65 @@
 /* KDevelop CMake Support
  *
  * Copyright 2008 Aleix Pol <aleixpol@gmail.com>
  *
  * 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 "cmakecachereader.h"
 
 #include <QString>
-#include <QFile>
-#include <QUrl>
 
 void CacheLine::readLine(const QString& line)
 {
     m_line=line;
     int i;
     for(i=0; i<line.count() && line[i]!='='; i++)
     {
         if(line[i]==':')
         {
             colon=i;
             if(endName<0)
                 endName=i;
         }
         else if(line[i]=='-')
         {
             dash=i;
                 endName=i;
         }
     }
     equal=i;
 }
 
 QString CacheLine::name() const
 { return m_line.left( endName ); }
 
 QString CacheLine::flag() const
 {
     if(dash>0)
         return m_line.mid( dash+1, colon-dash-1 );
     else
         return QString();
 }
 
 QString CacheLine::type() const
 {
     return m_line.mid(colon+1, equal-colon-1);
 }
 
 QString CacheLine::value() const
 {
     return m_line.right(m_line.size()-equal-1);
 }
diff --git a/projectmanagers/cmake/parser/cmakecondition.cpp b/projectmanagers/cmake/parser/cmakecondition.cpp
index cbbbac1389..2391c38ea6 100644
--- a/projectmanagers/cmake/parser/cmakecondition.cpp
+++ b/projectmanagers/cmake/parser/cmakecondition.cpp
@@ -1,402 +1,401 @@
 /* KDevelop CMake Support
  *
  * Copyright 2007-2008 Aleix Pol <aleixpol@gmail.com>
  *
  * 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 "cmakecondition.h"
 #include "cmakeprojectvisitor.h"
 #include <language/duchain/declaration.h>
 #include <QFileInfo>
-#include <QDateTime>
 
 #include "astfactory.h"
 #include "cmakeparserutils.h"
 #include "../debug.h"
 #include <QtCore/QRegExp>
 
 QMap<QString, CMakeCondition::conditionToken> initNameToToken()
 {
     QMap<QString, CMakeCondition::conditionToken> ret;
     ret["NOT"]=CMakeCondition::NOT;
     ret["AND"]=CMakeCondition::AND;
     ret["OR"]=CMakeCondition::OR;
     ret["COMMAND"]=CMakeCondition::COMMAND;
     ret["EXISTS"]=CMakeCondition::EXISTS;
     ret["IS_NEWER_THAN"]=CMakeCondition::IS_NEWER_THAN;
     ret["IS_DIRECTORY"]=CMakeCondition::IS_DIRECTORY;
     ret["IS_ABSOLUTE"]=CMakeCondition::IS_ABSOLUTE;
     ret["MATCHES"]=CMakeCondition::MATCHES;
     ret["LESS"]=CMakeCondition::LESS;
     ret["GREATER"]=CMakeCondition::GREATER;
     ret["EQUAL"]=CMakeCondition::EQUAL;
     ret["STRLESS"]=CMakeCondition::STRLESS;
     ret["STRGREATER"]=CMakeCondition::STRGREATER;
     ret["STREQUAL"]=CMakeCondition::STREQUAL;
     ret["DEFINED"]=CMakeCondition::DEFINED;
     ret["VERSION_LESS"]=CMakeCondition::VERSION_LESS;
     ret["VERSION_GREATER"]=CMakeCondition::VERSION_GREATER;
     ret["VERSION_EQUAL"]=CMakeCondition::VERSION_EQUAL;
     ret["("]=CMakeCondition::LPR;
     ret[")"]=CMakeCondition::RPR;
     return ret;
 }
 
 static int compareVersions(const QList<int>& v1, const QList<int>& v2)
 {
     QList<int>::const_iterator it1=v1.constBegin(), it2=v2.constBegin();
     QList<int>::const_iterator itEnd1=v1.constEnd(), itEnd2=v2.constEnd();
 
     int dif=0;
     for(; it1!=itEnd1 && it2!=itEnd2 && !dif; ++it1, ++it2) { dif=*it1-*it2; }
 
     if(dif==0 && it1!=itEnd1) ++dif;
     if(dif==0 && it2!=itEnd2) --dif;
 
     return dif;
 }
 
 QMap<QString, CMakeCondition::conditionToken> CMakeCondition::nameToToken=initNameToToken();
 QSet<QString> CMakeCondition::s_falseDefinitions=QSet<QString>() << "" << "0" << "N" << "NO" << "OFF" << "FALSE" << "NOTFOUND" ;
 QSet<QString> CMakeCondition::s_trueDefinitions=QSet<QString>() << "1" << "ON" << "YES" << "TRUE" << "Y";
 
 CMakeCondition::CMakeCondition(const CMakeProjectVisitor* v)
     : m_vars(v->variables()), m_cache(v->cache()), m_visitor(v)
     , m_numberRx(" *-?[0-9]+")
 {
 }
 
 CMakeCondition::conditionToken CMakeCondition::typeName(const QString& _name)
 {
     if(nameToToken.contains(_name))
         return nameToToken[_name];
     else
         return variable;
 }
 
 bool CMakeCondition::textIsTrue(const QString& text)
 {
     QString valUpper = text.toUpper();
     return s_trueDefinitions.contains(valUpper);
 }
 
 bool CMakeCondition::isTrue(const QStringList::const_iterator& it)
 {
     QString val = *it;
     QString valUpper = val.toUpper();
     bool ret;
 //     qCDebug(CMAKE) << "+++++++ isTrue: " << val;
 //         Documentation currently say
 //         * if(<constant>)
 //         *    True if the constant is 1, ON, YES, TRUE, Y, or a non-zero number. False if the constant is 0, OFF, NO, FALSE, N, IGNORE, "", or ends in the suffix '-NOTFOUND'. Named boolean constants are case-insensitive.
 //         Then, if not one of the named constant, it is apparently treated as a variables or an expression.
     if (s_trueDefinitions.contains(valUpper))
     {
         // TODO Don't go here if CMP0012 is OLD
         ret = true;
     }
     else if (s_falseDefinitions.contains(valUpper) || valUpper.endsWith("-NOTFOUND"))
     {
         // TODO Don't go here if CMP0012 is OLD
         ret = false;
     }
     else if (m_numberRx.exactMatch(val))
     {
         // Number case
         bool ok;
         int n = val.toInt(&ok);
         ret = ok && n!=0;
     }
     else
     {
         QString value;
         if(m_vars->contains(val))
         {
             //         A variable is expanded (dereferenced) and then checked if it equals one of the above
             //         FALSE constants.
             value = m_vars->value(*it).join(";").toUpper();
     //         qCDebug(CMAKE) << "Checking" << varName << "is true ? >>>" << m_vars->value(varName) << "<<<";
         }
         else if(m_cache->contains(val))
         {
             value = m_cache->value(*it).value.toUpper();
         }
 
         if(!value.isEmpty()) {
             m_varUses.append(it);
             ret = !s_falseDefinitions.contains(value) && !value.endsWith("-NOTFOUND");
         } else
             ret = false;
     }
 
     return ret;
 }
 
 QStringList::const_iterator CMakeCondition::prevOperator(QStringList::const_iterator it, QStringList::const_iterator itStop) const
 {
     bool done=false;
     --it;
 
     while(!done && it!=itStop)
     {
         conditionToken c = typeName(*it);
         done = c>variable;
         if(!done)
             --it;
     }
     return it;
 }
 
 #define CHECK_PREV(it) if((it)==this->conditionBegin) return false
 #define CHECK_NEXT(it) if((it+1)!=itEnd) return false
 
 bool CMakeCondition::evaluateCondition(QStringList::const_iterator itBegin, QStringList::const_iterator itEnd)
 {
     if(itBegin==itEnd)
     {
         return isTrue(itBegin);
     }
 
     bool last = false, done=false;
     last = isTrue(prevOperator(itEnd, itBegin)+1);
     while(!done && itBegin!=itEnd)
     {
         QStringList::const_iterator it2 = prevOperator(itEnd, itBegin);
 
         done=(itBegin==it2);
         conditionToken c = typeName(*it2);
 
         switch(c)
         {
             case NOT:
                 last = !last;
                 itEnd=it2;
                 break;
             case COMMAND:
                 last = AstFactory::self()->contains((it2+1)->toLower()) || m_visitor->hasMacro((it2+1)->toLower());
                 itEnd=it2;
                 break;
             case EXISTS:
             {
                 last=false;
                 QString v=value(it2+1);
 
                 if(v.isEmpty())
                     qCDebug(CMAKE) << "error: no parameter to exist";
                 else if(v.startsWith("/.."))
                     last=false;
                 else
                 {
                     Q_ASSERT(m_vars->contains("CMAKE_CURRENT_SOURCE_DIR"));
                     QString dir=m_vars->value("CMAKE_CURRENT_SOURCE_DIR").first();
                     QFileInfo f(dir, v);
                     last=f.exists();
                 }
                 itEnd=it2;
             }   break;
             case IS_DIRECTORY: {
                 CHECK_NEXT(it2);
                 QFileInfo f(value(it2+1));
                 last = f.isDir();
                 itEnd=it2;
             }   break;
             case IS_ABSOLUTE: {
                 CHECK_NEXT(it2);
                 QFileInfo f(value(it2+1));
                 last = f.isAbsolute();
                 itEnd=it2;
             }   break;
             case DEFINED:
                 CHECK_NEXT(it2);
                 last=m_vars->contains(*(it2+1));
                 itEnd=it2;
                 break;
             case AND:
                 CHECK_PREV(it2);
 //                 qCDebug(CMAKE) << "AND" << last;
                 return evaluateCondition(itBegin, it2-1) && last;
             case OR:
                 CHECK_PREV(it2);
 //                 qCDebug(CMAKE) << "OR" << last;
                 return evaluateCondition(itBegin, it2-1) || last;
             case MATCHES: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 QRegExp rx(value(it2+1));
                 rx.indexIn(value(it2-1));
                 last=rx.matchedLength()>0;
                 m_matches = rx.capturedTexts();
                 itEnd=it2-1;
             }   break;
             case LESS: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 QString strA=value(it2-1);
                 QString strB=value(it2+1);
                 int a=strA.toInt(), b=strB.toInt();
                 last= (a<b);
                 itEnd=it2-1;
             }   break;
             case GREATER: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 QString strA=value(it2-1);
                 QString strB=value(it2+1);
                 int a=strA.toInt(), b=strB.toInt();
                 last= (a>b);
                 itEnd=it2-1;
             }   break;
             case EQUAL: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 QString strA=value(it2-1);
                 QString strB=value(it2+1);
                 int a=strA.toInt(), b=strB.toInt();
                 last= (a==b);
                 itEnd=it2-1;
             }   break;
             case STRLESS: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 QString strA=value(it2-1);
                 QString strB=value(it2+1);
                 last= (strA<strB);
                 itEnd=it2-1;
             }   break;
             case STRGREATER: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 QString strA=value(it2-1);
                 QString strB=value(it2+1);
                 last= (strA>strB);
                 itEnd=it2-1;
             }   break;
             case STREQUAL: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 QString strA=value(it2-1);
                 QString strB=value(it2+1);
 
                 last= (strA==strB);
 
                 itEnd=it2-1;
             }   break;
             case IS_NEWER_THAN: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 QFileInfo pathA(*(it2-1));
                 QFileInfo pathB(*(it2+1));
 //                 qCDebug(CMAKE) << "newer" << strA << strB;
                 last= (pathA.lastModified()>pathB.lastModified());
                 itEnd=it2-1;
             }   break;
             case VERSION_EQUAL: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 bool ok;
                 int cmp = compareVersion(it2-1, it2+1, &ok);
                 last = ok && cmp == 0;
                 itEnd=it2-1;
             }   break;
             case VERSION_LESS: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 bool ok;
                 int cmp = compareVersion(it2-1, it2+1, &ok);
                 last = ok && cmp < 0;
                 itEnd=it2-1;
             }   break;
             case VERSION_GREATER: {
                 CHECK_PREV(it2);
                 CHECK_NEXT(it2);
                 bool ok;
                 int cmp = compareVersion(it2-1, it2+1, &ok);
                 last = ok && cmp > 0;
                 itEnd=it2-1;
             }   break;
             case LPR: {
                 itEnd=it2;
             } break;
             case RPR: {
                 QStringList::const_iterator itL=it2;
                 int ind=0;
                 while(it2!=itBegin)
                 {
                     if(*itL=="(") ind--;
                     else if(*itL==")") ind++;
 
                     if(ind==0)
                         break;
                     --itL;
                 }
                 last=evaluateCondition(itL, it2-1);
                 itEnd=itL;
             } break;
             case variable:
                 last = isTrue(it2);
                 break;
             default:
                 qCWarning(CMAKE) << "no support for operator:" << *it2;
                 break;
         }
     }
 
     return last;
 }
 
 bool CMakeCondition::condition(const QStringList &expression)
 {
     if( expression.isEmpty() )
     {
         return false;
     }
     QStringList::const_iterator it = expression.constBegin(), itEnd=expression.constEnd();
     conditionBegin=it;
 
     bool ret = evaluateCondition(it, itEnd-1);
     uint i=0;
     m_argUses.clear();
     for(; it!=itEnd; ++it, ++i)
     {
         if(m_varUses.contains(it))
             m_argUses.append(i);
     }
 
 //     qCDebug(CMAKE) << "condition" << expression << "=>" << ret;
     return ret;
 }
 
 int CMakeCondition::compareVersion(QStringList::const_iterator left,
                                    QStringList::const_iterator right,
                                    bool* ok)
 {
     QList<int> versionA(CMakeParserUtils::parseVersion(value(left), ok));
     if (!ok) {
         return 0;
     }
 
     QList<int> versionB(CMakeParserUtils::parseVersion(value(right), ok));
     if (!ok) {
         return 0;
     }
     return compareVersions(versionA, versionB);
 }
 
 QString CMakeCondition::value(QList< QString >::const_iterator it)
 {
     QString value = *it;
     if (m_vars->contains(value)) {
         value = m_vars->value(value).join(";");
         m_varUses.append(it);
     }
     return value;
 }
diff --git a/projectmanagers/cmake/parser/cmakelistsparser.h b/projectmanagers/cmake/parser/cmakelistsparser.h
index 2ba0c56b23..4cb700de25 100644
--- a/projectmanagers/cmake/parser/cmakelistsparser.h
+++ b/projectmanagers/cmake/parser/cmakelistsparser.h
@@ -1,130 +1,130 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@kde.org>
  * Copyright 2007 Aleix Pol Gonzalez <aleixpol@gmail.com>
  *
  * 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 CMAKELISTSPARSER_H
 #define CMAKELISTSPARSER_H
 
 #include <QList>
-#include <QObject>
 #include <QMetaType>
-#include <QStringList>
 #include <QString>
 
 // #include "cmakemodelitems.h"
 #include "cmListFileLexer.h"
 #include <cmakecommonexport.h>
 #include <language/editor/rangeinrevision.h>
 
+class QStringList;
+
 struct CMakeFunctionArgument
 {
     CMakeFunctionArgument(): value(), quoted(false), line(0), column(0) {}
     explicit CMakeFunctionArgument(const QString& v);
     CMakeFunctionArgument(const QString& v, bool q, quint32 l = 0, quint32 c=0);
     inline bool operator == (const CMakeFunctionArgument& r) const
     {
         return (this->value == r.value) && (this->quoted == r.quoted);
     }
 
     inline bool operator != (const CMakeFunctionArgument& r) const
     {
         return (this->value != r.value) || (this->quoted != r.quoted);
     }
 
     bool operator==( const QString& rhs )
     {
         return ( this->value == rhs );
     }
 
     bool isCorrect() const { return column>0; }
 
     static QString unescapeValue(const QString& value);
     
     KDevelop::RangeInRevision range() const
     { return KDevelop::RangeInRevision(line-1, column-1, line-1, column+value.length()-1); }
 
     bool isValid() const { return quoted || !value.isEmpty(); }
     
     QString value;
     bool quoted;
     quint32 line;
     quint32 column;
     static const QMap<QChar, QChar> scapings;
 };
 Q_DECLARE_METATYPE( CMakeFunctionArgument )
 
 
 class KDEVCMAKECOMMON_EXPORT CMakeFunctionDesc
 {
 public:
     CMakeFunctionDesc();
     
     ///useful when writing unit tests mostly
     CMakeFunctionDesc(const QString& name, const QStringList& args);
 
     QString name;
     QList<CMakeFunctionArgument> arguments;
     QString filePath;
     quint32 line;
     quint32 column;
     quint32 endLine;
     quint32 endColumn;
 /*  int numSpacesBeforeLeftParen;
     int numSpacesAfterLeftParen;
     int numSpacesBeforeRightParen; */
 
     KDevelop::RangeInRevision nameRange() const
     { return KDevelop::RangeInRevision(line-1, column-1, line-1, column-1+name.length()); }
 
     KDevelop::RangeInRevision range() const
     { return KDevelop::RangeInRevision(line-1, column-1, endLine-1, endColumn); }
     
     KDevelop::RangeInRevision argRange() const
     { 
         if( !arguments.isEmpty() ) 
         { 
             return KDevelop::RangeInRevision(arguments.first().range().start,
                                    arguments.last().range().end); 
         } else 
         { 
             return KDevelop::RangeInRevision( line-1, column-1, endLine-1, endColumn); 
         }
     }
 
     bool operator==(const CMakeFunctionDesc &other) const;
     void addArguments( const QStringList&, bool addEvenIfEmpty=true );
     QString writeBack() const;
 };
 Q_DECLARE_METATYPE( CMakeFunctionDesc )
 
 /**
  * CMake files function descriptor collector
  * @author Matt Rogers <mattr@kde.org>
  * @author Aleix Pol <aleixpol@gmail.com>
  */
 
 typedef QList<CMakeFunctionDesc> CMakeFileContent;
 
 namespace CMakeListsParser
 {
     KDEVCMAKECOMMON_EXPORT CMakeFileContent readCMakeFile(const QString& fileName);
 }
 
 #endif
diff --git a/projectmanagers/cmake/settings/cmakecachedelegate.cpp b/projectmanagers/cmake/settings/cmakecachedelegate.cpp
index 5be957f4aa..8167205022 100644
--- a/projectmanagers/cmake/settings/cmakecachedelegate.cpp
+++ b/projectmanagers/cmake/settings/cmakecachedelegate.cpp
@@ -1,191 +1,190 @@
 /* KDevelop CMake Support
  *
  * Copyright 2008 Aleix Pol <aleixpol@gmail.com>
  *
  * 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 "cmakecachedelegate.h"
 #include "../debug.h"
 
 #include <QLineEdit>
 #include <QCheckBox>
-#include <QEvent>
 #include <KUrlRequester>
 #include <QtCore/QUrl>
 
 CMakeCacheDelegate::CMakeCacheDelegate(QObject * parent)
     : QItemDelegate(parent)
 {
     m_sample=new KUrlRequester();
 }
 
 CMakeCacheDelegate::~CMakeCacheDelegate()
 {
     delete m_sample;
 }
 
 QWidget * CMakeCacheDelegate::createEditor(QWidget * parent, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     QWidget *ret=nullptr;
     if(index.column()==2)
     {
         QModelIndex typeIdx=index.sibling(index.row(), 1);
         QString type=typeIdx.model()->data(typeIdx, Qt::DisplayRole).toString();
         if(type=="BOOL")
         {
             QCheckBox* box=new QCheckBox(parent);
             connect(box, &QCheckBox::toggled, this, &CMakeCacheDelegate::checkboxToggled);
             ret = box;
         }
         else if(type=="PATH" || type=="FILEPATH")
         {
             KUrlRequester *r=new KUrlRequester(parent);
             if(type=="FILEPATH")
                 r->setMode(KFile::File);
             else
                 r->setMode(KFile::Directory | KFile::ExistingOnly);
             emit const_cast<CMakeCacheDelegate*>(this)->sizeHintChanged ( index );
             qCDebug(CMAKE) << "EMITINT!" << index;
             ret=r;
         }
         else
         {
             ret=QItemDelegate::createEditor(parent, option, index);
         }
 
         if(!ret) qCDebug(CMAKE) << "Did not recognize type " << type;
     }
     return ret;
 }
 
 void CMakeCacheDelegate::setEditorData(QWidget * editor, const QModelIndex & index) const
 {
     if(index.column()==2)
     {
         QModelIndex typeIdx=index.sibling(index.row(), 1);
         QString type=index.model()->data(typeIdx, Qt::DisplayRole).toString();
         QString value=index.model()->data(index, Qt::DisplayRole).toString();
         if(type=="BOOL")
         {
             QCheckBox *boolean=qobject_cast<QCheckBox*>(editor);
             boolean->setCheckState(value=="ON" ? Qt::Checked : Qt::Unchecked);
         }
         else if(type=="PATH" || type=="FILEPATH")
         {
             KUrlRequester *url=qobject_cast<KUrlRequester*>(editor);
             url->setUrl(QUrl(value));
         }
         else
         {
             QItemDelegate::setEditorData(editor, index);
         }
     }
     else
         qCDebug(CMAKE) << "Error. trying to edit a read-only field";
 }
 
 void CMakeCacheDelegate::setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index) const
 {
     if(index.column()==2)
     {
         QModelIndex typeIdx=index.sibling(index.row(), 1);
         QString type=model->data(typeIdx, Qt::DisplayRole).toString();
         QString value;
         if(type=="BOOL")
         {
             QCheckBox *boolean=qobject_cast<QCheckBox*>(editor);
             value = boolean->isChecked() ? "ON" : "OFF";
         }
         else if(type=="PATH" || type=="FILEPATH")
         {
             KUrlRequester *urlreq=qobject_cast<KUrlRequester*>(editor);
             value = urlreq->url().toDisplayString(QUrl::StripTrailingSlash | QUrl::PreferLocalFile); //CMake usually don't put it
         }
         else
         {
             QItemDelegate::setModelData(editor, model, index);
             return;
         }
         model->setData(index, value, Qt::DisplayRole);
     }
     else
         qCDebug(CMAKE) << "Error. trying to edit a read-only field";
 }
 
 void CMakeCacheDelegate::paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     if(index.column()==2)
     {
         QModelIndex typeIdx=index.sibling(index.row(), 1);
         QString type=index.model()->data(typeIdx, Qt::DisplayRole).toString();
         if(type=="BOOL")
             return;
     }
     QItemDelegate::paint(painter, option, index);
 }
 
 QSize CMakeCacheDelegate::sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index ) const
 {
 //     qCDebug(CMAKE) << "calculant" << index << bool(option.state & QStyle::State_Editing);
     QSize ret=QItemDelegate::sizeHint(option, index);
     if(index.column()==2 && option.state & QStyle::State_Editing)
     {
         QModelIndex typeIdx=index.sibling(index.row(), 1);
         QString type=index.model()->data(typeIdx, Qt::DisplayRole).toString();
         if(type=="PATH")
         {
             ret.setHeight(m_sample->sizeHint().height());
         }
     }
     return ret;
 }
 
 void CMakeCacheDelegate::checkboxToggled()
 {
     // whenever the check box gets toggled, we directly want to set the
     // model data which is done by closing the editor which in turn
     // calls setModelData. otherwise, the behavior is quite confusing, see e.g.
     // https://bugs.kde.org/show_bug.cgi?id=304352
     QCheckBox* editor = qobject_cast<QCheckBox*>(sender());
     Q_ASSERT(editor);
     closeEditor(editor);
 }
 
 void CMakeCacheDelegate::closingEditor(QWidget * editor, QAbstractItemDelegate::EndEditHint hint)
 {
     Q_UNUSED(editor);
     Q_UNUSED(hint);
     qCDebug(CMAKE) << "closing...";
 }
 
 // void CMakeCacheDelegate::updateEditorGeometry ( QWidget * editor, const QStyleOptionViewItem & option,
 //                     const QModelIndex & index ) const
 // {
 //     if(index.column()==2)
 //     {
 //         QModelIndex typeIdx=index.sibling(index.row(), 1);
 //         QString type=index.model()->data(typeIdx, Qt::DisplayRole).toString();
 //         if(type=="PATH")
 //         {
 //             KUrlRequester* urlreq=qobject_cast<KUrlRequester*>(editor);
 //             urlreq->setGeometry(QRect(option.rect.topLeft(), urlreq->sizeHint()));
 //             return;
 //         }
 //     }
 //     QItemDelegate::updateEditorGeometry( editor, option, index );
 // }
 
diff --git a/projectmanagers/cmake/settings/cmakepreferences.cpp b/projectmanagers/cmake/settings/cmakepreferences.cpp
index 518a1e5410..257ef6fed7 100644
--- a/projectmanagers/cmake/settings/cmakepreferences.cpp
+++ b/projectmanagers/cmake/settings/cmakepreferences.cpp
@@ -1,408 +1,406 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@kde.org>
  * Copyright 2007-2008 Aleix Pol <aleixpol@gmail.com>
  *
  * 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 "cmakepreferences.h"
 
 #include <interfaces/icore.h>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KJobWidgets>
 #include <kio/deletejob.h>
 
 #include <QFile>
 #include <QDir>
 #include <QHeaderView>
 #include <QComboBox>
 
 #include "ui_cmakebuildsettings.h"
 #include "cmakecachedelegate.h"
 #include "cmakebuilddirchooser.h"
 #include "../debug.h"
 #include <cmakeutils.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <project/interfaces/iprojectbuilder.h>
 #include <interfaces/iruncontroller.h>
-#include <KAboutData>
-#include <QStandardPaths>
 
 using namespace KDevelop;
 
 CMakePreferences::CMakePreferences(IPlugin* plugin, const ProjectConfigOptions& options, QWidget* parent)
     : ConfigPage(plugin, nullptr, parent), m_project(options.project), m_currentModel(nullptr)
 {
     m_prefsUi = new Ui::CMakeBuildSettings;
     m_prefsUi->setupUi(this);
 
     m_prefsUi->addBuildDir->setIcon(QIcon::fromTheme( "list-add" ));
     m_prefsUi->removeBuildDir->setIcon(QIcon::fromTheme( "list-remove" ));
 
     m_prefsUi->addBuildDir->setText(QString());
     m_prefsUi->removeBuildDir->setText(QString());
     m_prefsUi->cacheList->setItemDelegate(new CMakeCacheDelegate(m_prefsUi->cacheList));
     m_prefsUi->cacheList->setSelectionMode(QAbstractItemView::SingleSelection);
     m_prefsUi->cacheList->horizontalHeader()->setStretchLastSection(true);
     m_prefsUi->cacheList->verticalHeader()->hide();
 
     // configure the extraArguments widget to span the advanced box width but not
     // expand the dialog to the width of the longest element in the argument history.
     m_prefsUi->extraArguments->setMinimumWidth(dynamic_cast<QComboBox*>(m_prefsUi->extraArguments)->minimumSizeHint().width());
     m_extraArgumentsHistory = new CMakeExtraArgumentsHistory(m_prefsUi->extraArguments);
 
     connect(m_prefsUi->buildDirs, static_cast<void(KComboBox::*)(int)>(&KComboBox::currentIndexChanged),
             this, &CMakePreferences::buildDirChanged);
     connect(m_prefsUi->showInternal, &QCheckBox::stateChanged,
             this, &CMakePreferences::showInternal);
     connect(m_prefsUi->addBuildDir, &QPushButton::pressed, this, &CMakePreferences::createBuildDir);
     connect(m_prefsUi->removeBuildDir, &QPushButton::pressed, this, &CMakePreferences::removeBuildDir);
     connect(m_prefsUi->showAdvanced, &QPushButton::toggled, this, &CMakePreferences::showAdvanced);
     connect(m_prefsUi->environment, &EnvironmentSelectionWidget::currentProfileChanged,
             this, &CMakePreferences::changed);
     connect(m_prefsUi->configureEnvironment, &EnvironmentConfigureButton::environmentConfigured,
             this, &CMakePreferences::changed);
 
     connect(m_prefsUi->installationPrefix, &KUrlRequester::textChanged,
             this, &CMakePreferences::changed);
     connect(m_prefsUi->buildType, static_cast<void(QComboBox::*)(const QString&)>(&QComboBox::currentIndexChanged),
             this, &CMakePreferences::changed);
     connect(m_prefsUi->buildType, &QComboBox::currentTextChanged,
             this, &CMakePreferences::changed);
     connect(m_prefsUi->extraArguments, &KComboBox::currentTextChanged,
             this, &CMakePreferences::changed);
     connect(m_prefsUi->extraArguments, &KComboBox::editTextChanged,
             this, &CMakePreferences::changed);
     connect(m_prefsUi->cMakeExecutable, &KUrlRequester::textChanged,
             this, &CMakePreferences::changed);
 
     showInternal(m_prefsUi->showInternal->checkState());
     m_subprojFolder = Path(options.projectTempFile).parent();
 
     qCDebug(CMAKE) << "Source folder: " << m_srcFolder << options.projectTempFile;
 //     foreach(const QVariant &v, args)
 //     {
 //         qCDebug(CMAKE) << "arg: " << v.toString();
 //     }
 
     m_prefsUi->configureEnvironment->setSelectionWidget(m_prefsUi->environment);
 
     m_prefsUi->showAdvanced->setChecked(false);
     showAdvanced(false);
     reset(); // load the initial values
 }
 
 CMakePreferences::~CMakePreferences()
 {
     CMake::removeOverrideBuildDirIndex(m_project);
     delete m_extraArgumentsHistory;
     delete m_prefsUi;
 }
 
 void CMakePreferences::initAdvanced()
 {
     m_prefsUi->environment->setCurrentProfile( CMake::currentEnvironment(m_project) );
     m_prefsUi->installationPrefix->setText(CMake::currentInstallDir(m_project).toLocalFile());
     const QString buildType = CMake::currentBuildType(m_project);
     if (m_prefsUi->buildType->findText(buildType) == -1) {
         m_prefsUi->buildType->addItem(buildType);
     }
     m_prefsUi->buildType->setCurrentIndex(m_prefsUi->buildType->findText(buildType));
     m_prefsUi->extraArguments->setEditText(CMake::currentExtraArguments(m_project));
     m_prefsUi->cMakeExecutable->setText(CMake::currentCMakeExecutable(m_project).toLocalFile());
 }
 
 void CMakePreferences::reset()
 {
     qCDebug(CMAKE) << "********loading";
     m_prefsUi->buildDirs->clear();
     m_prefsUi->buildDirs->addItems( CMake::allBuildDirs(m_project) );
     CMake::removeOverrideBuildDirIndex(m_project); // addItems() triggers buildDirChanged(), compensate for it
     m_prefsUi->buildDirs->setCurrentIndex( CMake::currentBuildDirIndex(m_project) );
 
     initAdvanced();
 
     m_srcFolder = m_project->path();
 
     m_prefsUi->removeBuildDir->setEnabled(m_prefsUi->buildDirs->count()!=0);
 //     QString cmDir=group.readEntry("CMakeDirectory");
 //     m_prefsUi->kcfg_cmakeDir->setUrl(QUrl(cmDir));
 //     qCDebug(CMAKE) << "cmakedir" << cmDir;
 }
 
 void CMakePreferences::apply()
 {
     qCDebug(CMAKE) << "*******saving";
 
     // the build directory list is incrementally maintained through createBuildDir() and removeBuildDir().
     // We won't rewrite it here based on the data from m_prefsUi->buildDirs.
     CMake::removeOverrideBuildDirIndex( m_project, true ); // save current selection
     int savedBuildDir = CMake::currentBuildDirIndex(m_project);
     if (savedBuildDir < 0) {
         // no build directory exists: skip any writing to config file as well as configuring
         return;
     }
 
     CMake::setCurrentEnvironment( m_project, m_prefsUi->environment->currentProfile() );
 
     CMake::setCurrentInstallDir( m_project, Path(m_prefsUi->installationPrefix->text()) );
     const QString buildType = m_prefsUi->buildType->currentText();
     if (m_prefsUi->buildType->findText(buildType) == -1) {
         m_prefsUi->buildType->addItem(buildType);
     }
     CMake::setCurrentBuildType( m_project, buildType );
     CMake::setCurrentExtraArguments( m_project, m_prefsUi->extraArguments->currentText() );
     CMake::setCurrentCMakeExecutable(m_project, Path(m_prefsUi->cMakeExecutable->text()));
 
     qCDebug(CMAKE) << "writing to cmake config: using builddir " << CMake::currentBuildDirIndex(m_project);
     qCDebug(CMAKE) << "writing to cmake config: builddir path " << CMake::currentBuildDir(m_project);
     qCDebug(CMAKE) << "writing to cmake config: installdir " << CMake::currentInstallDir(m_project);
     qCDebug(CMAKE) << "writing to cmake config: build type " << CMake::currentBuildType(m_project);
     qCDebug(CMAKE) << "writing to cmake config: cmake executable " << CMake::currentCMakeExecutable(m_project);
     qCDebug(CMAKE) << "writing to cmake config: environment " << CMake::currentEnvironment(m_project);
 
     //We run cmake on the builddir to generate it
     configure();
 }
 
 void CMakePreferences::defaults()
 {
     // do nothing
 }
 
 void CMakePreferences::configureCacheView()
 {
     // Sets up the cache view after model re-creation/reset.
     // Emits changed(false) because model re-creation probably means
     // mass programmatical invocation of itemChanged(), which invokes changed(true) - which is not what we want.
     m_prefsUi->cacheList->setModel(m_currentModel);
     m_prefsUi->cacheList->hideColumn(1);
     m_prefsUi->cacheList->hideColumn(3);
     m_prefsUi->cacheList->hideColumn(4);
     m_prefsUi->cacheList->horizontalHeader()->resizeSection(0, 200);
 
     if( m_currentModel ) {
         m_prefsUi->cacheList->setEnabled( true );
         foreach(const QModelIndex & idx, m_currentModel->persistentIndices()) {
             m_prefsUi->cacheList->openPersistentEditor(idx);
         }
     } else {
         m_prefsUi->cacheList->setEnabled( false );
     }
 
     showInternal(m_prefsUi->showInternal->checkState());
 }
 
 void CMakePreferences::updateCache(const Path &newBuildDir)
 {
     const Path file = newBuildDir.isValid() ? Path(newBuildDir, "CMakeCache.txt") : Path();
     if(QFile::exists(file.toLocalFile()))
     {
         if (m_currentModel) {
             m_currentModel->deleteLater();
         }
         m_currentModel = new CMakeCacheModel(this, file);
 
         configureCacheView();
         connect(m_currentModel, &CMakeCacheModel::itemChanged,
                 this, &CMakePreferences::cacheEdited);
         connect(m_currentModel, &CMakeCacheModel::modelReset,
                 this, &CMakePreferences::configureCacheView);
         connect(m_prefsUi->cacheList->selectionModel(), &QItemSelectionModel::currentChanged,
                 this, &CMakePreferences::listSelectionChanged);
     }
     else
     {
         disconnect(m_prefsUi->cacheList->selectionModel(), &QItemSelectionModel::currentChanged, this, nullptr);
         if (m_currentModel) {
             m_currentModel->deleteLater();
             m_currentModel = nullptr;
         }
         configureCacheView();
     }
 
     if( !m_currentModel )
         emit changed();
 }
 
 void CMakePreferences::listSelectionChanged(const QModelIndex & index, const QModelIndex& )
 {
     qCDebug(CMAKE) << "item " << index << " selected";
     QModelIndex idx = index.sibling(index.row(), 3);
     QModelIndex idxType = index.sibling(index.row(), 1);
     QString comment=QString("%1. %2")
             .arg(m_currentModel->itemFromIndex(idxType)->text())
             .arg(m_currentModel->itemFromIndex(idx)->text());
     m_prefsUi->commentText->setText(comment);
 }
 
 void CMakePreferences::showInternal(int state)
 {
     if(!m_currentModel)
         return;
 
     bool showAdv=(state == Qt::Checked);
     for(int i=0; i<m_currentModel->rowCount(); i++)
     {
         bool hidden=m_currentModel->isInternal(i) || (!showAdv && m_currentModel->isAdvanced(i));
         m_prefsUi->cacheList->setRowHidden(i, hidden);
     }
 }
 
 void CMakePreferences::buildDirChanged(int index)
 {
     CMake::setOverrideBuildDirIndex( m_project, index );
     const Path buildDir = CMake::currentBuildDir(m_project);
     initAdvanced();
     updateCache(buildDir);
     qCDebug(CMAKE) << "builddir Changed" << buildDir;
     emit changed();
 }
 
 void CMakePreferences::cacheUpdated()
 {
     const Path buildDir = CMake::currentBuildDir(m_project);
     updateCache(buildDir);
     qCDebug(CMAKE) << "cache updated for" << buildDir;
 }
 
 void CMakePreferences::createBuildDir()
 {
     CMakeBuildDirChooser bdCreator;
     bdCreator.setSourceFolder( m_srcFolder );
 
     // NOTE: (on removing the trailing slashes)
     // Generally, we have no clue about how shall a trailing slash look in the current system.
     // Moreover, the slash may be a part of the filename.
     // It may be '/' or '\', so maybe should we rely on CMake::allBuildDirs() for returning well-formed paths?
     QStringList used = CMake::allBuildDirs( m_project );
     bdCreator.setAlreadyUsed(used);
     bdCreator.setCMakeExecutable(Path(CMake::findExecutable()));
 
     if(bdCreator.exec())
     {
         int addedBuildDirIndex = m_prefsUi->buildDirs->count();
 
         // 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 " << bdCreator.buildFolder();
         qCDebug(CMAKE) << "adding to cmake config: installdir " << bdCreator.installPrefix();
         qCDebug(CMAKE) << "adding to cmake config: extra args" << bdCreator.extraArguments();
         qCDebug(CMAKE) << "adding to cmake config: build type " << bdCreator.buildType();
         qCDebug(CMAKE) << "adding to cmake config: cmake executable " << bdCreator.cmakeExecutable();
         qCDebug(CMAKE) << "adding to cmake config: environment empty";
         CMake::setOverrideBuildDirIndex( m_project, addedBuildDirIndex );
         CMake::setBuildDirCount( m_project, addedBuildDirIndex + 1 );
         CMake::setCurrentBuildDir( m_project, bdCreator.buildFolder() );
         CMake::setCurrentInstallDir( m_project, bdCreator.installPrefix() );
         CMake::setCurrentExtraArguments( m_project, bdCreator.extraArguments() );
         CMake::setCurrentBuildType( m_project, bdCreator.buildType() );
         CMake::setCurrentCMakeExecutable(m_project, bdCreator.cmakeExecutable());
         CMake::setCurrentEnvironment( m_project, QString() );
 
         QString newbuilddir = bdCreator.buildFolder().toLocalFile();
         m_prefsUi->buildDirs->addItem( newbuilddir );
         m_prefsUi->buildDirs->setCurrentIndex( addedBuildDirIndex );
         m_prefsUi->removeBuildDir->setEnabled( true );
 
         qCDebug(CMAKE) << "Emitting changed signal for cmake kcm";
         emit changed();
     }
     //TODO: Save it for next runs
 }
 
 void CMakePreferences::removeBuildDir()
 {
     int curr=m_prefsUi->buildDirs->currentIndex();
     if(curr < 0)
         return;
 
     Path removedPath = CMake::currentBuildDir( m_project );
     QString removed = removedPath.toLocalFile();
     if(QDir(removed).exists())
     {
         KMessageBox::ButtonCode ret = KMessageBox::warningYesNo(this,
                 i18n("The %1 directory is about to be removed in KDevelop's list.\n"
                     "Do you want KDevelop to remove it in the file system as well?", removed));
         if(ret == KMessageBox::Yes)
         {
             auto deleteJob = KIO::del(removedPath.toUrl());
             KJobWidgets::setWindow(deleteJob, this);
             if (!deleteJob->exec())
                 KMessageBox::error(this, i18n("Could not remove: %1", removed));
         }
     }
 
     qCDebug(CMAKE) << "removing from cmake config: using builddir " << curr;
     qCDebug(CMAKE) << "removing from cmake config: builddir path " << removedPath;
     qCDebug(CMAKE) << "removing from cmake config: installdir " << CMake::currentInstallDir( m_project );
     qCDebug(CMAKE) << "removing from cmake config: extra args" << CMake::currentExtraArguments( m_project );
     qCDebug(CMAKE) << "removing from cmake config: buildtype " << CMake::currentBuildType( m_project );
     qCDebug(CMAKE) << "removing from cmake config: cmake executable " << CMake::currentCMakeExecutable(m_project);
     qCDebug(CMAKE) << "removing from cmake config: environment " << CMake::currentEnvironment( m_project );
 
     CMake::removeBuildDirConfig(m_project);
     m_prefsUi->buildDirs->removeItem( curr ); // this triggers buildDirChanged()
     if(m_prefsUi->buildDirs->count()==0)
         m_prefsUi->removeBuildDir->setEnabled(false);
 
     emit changed();
 }
 
 void CMakePreferences::configure()
 {
     IProjectBuilder *b=m_project->buildSystemManager()->builder();
     KJob* job=b->configure(m_project);
     if( m_currentModel ) {
         QVariantMap map = m_currentModel->changedValues();
         job->setProperty("extraCMakeCacheValues", map);
         connect(job, &KJob::finished, m_currentModel, &CMakeCacheModel::reset);
     } else {
         connect(job, &KJob::finished, this, &CMakePreferences::cacheUpdated);
     }
 
     connect(job, &KJob::finished, m_project, &IProject::reloadModel);
     ICore::self()->runController()->registerJob(job);
 }
 
 void CMakePreferences::showAdvanced(bool v)
 {
     qCDebug(CMAKE) << "toggle pressed: " << v;
     m_prefsUi->advancedBox->setHidden(!v);
 }
 
 
 QString CMakePreferences::name() const
 {
     return i18n("CMake");
 }
 
 QString CMakePreferences::fullName() const
 {
     return i18n("Configure CMake settings");
 }
 
 QIcon CMakePreferences::icon() const
 {
     return QIcon::fromTheme("cmake");
 }
 
diff --git a/projectmanagers/cmake/settings/cmakepreferences.h b/projectmanagers/cmake/settings/cmakepreferences.h
index cc1dac3f9a..3e6bbef4f4 100644
--- a/projectmanagers/cmake/settings/cmakepreferences.h
+++ b/projectmanagers/cmake/settings/cmakepreferences.h
@@ -1,78 +1,77 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@kde.org>
  * Copyright 2007 Aleix Pol <aleixpol@gmail.com>
  *
  * 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 CMAKEPREFERENCES_H
 #define CMAKEPREFERENCES_H
 
 #include "cmakecachemodel.h"
 #include "cmakeextraargumentshistory.h"
 
 #include <project/projectconfigpage.h>
 #include <util/path.h>
 
-class QItemSelection;
 class CMakeSettings;
 
 namespace Ui { class CMakeBuildSettings; }
 
 /**
  * @author Matt Rogers <mattr@kde.org>
  * @author Aleix Pol <aleixpol@gmail.com>
  */
 class CMakePreferences : public KDevelop::ConfigPage
 {
     Q_OBJECT
     public:
         explicit CMakePreferences(KDevelop::IPlugin* plugin, const KDevelop::ProjectConfigOptions& options, QWidget* parent = nullptr);
         ~CMakePreferences() override;
 
         QString name() const override;
         QString fullName() const override;
         QIcon icon() const override;
 
         void apply() override;
         void reset() override;
         void defaults() override;
 
     private slots:
         void listSelectionChanged ( const QModelIndex& current, const QModelIndex& );
         void showInternal(int state);
         void cacheEdited(QStandardItem * ) { emit changed(); }
         void buildDirChanged(int index);
         void cacheUpdated();
         void createBuildDir();
         void removeBuildDir();
         void showAdvanced(bool v);
         void configureCacheView();
     private:
         void configure();
         void initAdvanced();
         
         KDevelop::IProject* m_project;
         KDevelop::Path m_srcFolder;
         KDevelop::Path m_subprojFolder;
         void updateCache( const KDevelop::Path & );
         Ui::CMakeBuildSettings* m_prefsUi;
         CMakeCacheModel* m_currentModel;
         CMakeExtraArgumentsHistory* m_extraArgumentsHistory;
 };
 
 #endif
diff --git a/projectmanagers/cmake/testing/ctestfindjob.cpp b/projectmanagers/cmake/testing/ctestfindjob.cpp
index f97a4151d1..b453264275 100644
--- a/projectmanagers/cmake/testing/ctestfindjob.cpp
+++ b/projectmanagers/cmake/testing/ctestfindjob.cpp
@@ -1,92 +1,91 @@
 /*  This file is part of KDevelop
     Copyright 2012 Miha Čančula <miha@noughmad.eu>
 
     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; see the file COPYING.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "ctestfindjob.h"
 #include "ctestsuite.h"
 #include "../debug.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/itestcontroller.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <language/duchain/duchain.h>
 #include <language/backgroundparser/backgroundparser.h>
 
-#include <QFileInfo>
 #include <KLocalizedString>
 
 CTestFindJob::CTestFindJob(CTestSuite* suite, QObject* parent)
 : KJob(parent)
 , m_suite(suite)
 {
     qCDebug(CMAKE) << "Created a CTestFindJob";
     setObjectName(i18n("Parse test suite %1", suite->name()));
     setCapabilities(Killable);
 }
 
 void CTestFindJob::start()
 {
     qCDebug(CMAKE);
     QMetaObject::invokeMethod(this, "findTestCases", Qt::QueuedConnection);
 }
 
 void CTestFindJob::findTestCases()
 {
     qCDebug(CMAKE);
 
     if (!m_suite->arguments().isEmpty())
     {
         KDevelop::ICore::self()->testController()->addTestSuite(m_suite);
         emitResult();
         return;
     }
 
     m_pendingFiles = m_suite->sourceFiles();
     qCDebug(CMAKE) << "Source files to update:" << m_pendingFiles;
 
     if (m_pendingFiles.isEmpty())
     {
         KDevelop::ICore::self()->testController()->addTestSuite(m_suite);
         emitResult();
         return;
     }
 
     foreach (const KDevelop::Path &file, m_pendingFiles)
     {
         KDevelop::DUChain::self()->updateContextForUrl(KDevelop::IndexedString(file.toUrl()), KDevelop::TopDUContext::AllDeclarationsAndContexts, this);
     }
 }
 
 void CTestFindJob::updateReady(const KDevelop::IndexedString& document, const KDevelop::ReferencedTopDUContext& context)
 {
     qCDebug(CMAKE) << m_pendingFiles << document.str();
     m_suite->loadDeclarations(document, context);
     m_pendingFiles.removeAll(KDevelop::Path(document.toUrl()));
 
     if (m_pendingFiles.isEmpty())
     {
         KDevelop::ICore::self()->testController()->addTestSuite(m_suite);
         emitResult();
     }
 }
 
 bool CTestFindJob::doKill()
 {
     KDevelop::ICore::self()->languageController()->backgroundParser()->revertAllRequests(this);
     return true;
 }
diff --git a/projectmanagers/cmake/testing/ctestrunjob.cpp b/projectmanagers/cmake/testing/ctestrunjob.cpp
index c272af7650..228557af3a 100644
--- a/projectmanagers/cmake/testing/ctestrunjob.cpp
+++ b/projectmanagers/cmake/testing/ctestrunjob.cpp
@@ -1,222 +1,221 @@
 /*  This file is part of KDevelop
     Copyright 2012 Miha Čančula <miha@noughmad.eu>
 
     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; see the file COPYING.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "ctestrunjob.h"
 #include "ctestsuite.h"
 #include "qttestdelegate.h"
 #include "../debug.h"
 
 #include <interfaces/ilaunchconfiguration.h>
 #include <interfaces/icore.h>
 #include <interfaces/itestcontroller.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/ilauncher.h>
 #include <interfaces/launchconfigurationtype.h>
 #include <interfaces/ilaunchmode.h>
 #include <interfaces/iprojectcontroller.h>
 #include <util/processlinemaker.h>
 #include <util/executecompositejob.h>
 #include <outputview/outputmodel.h>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
-#include <KCompositeJob>
 
 using namespace KDevelop;
 
 CTestRunJob::CTestRunJob(CTestSuite* suite, const QStringList& cases, OutputJob::OutputJobVerbosity verbosity, bool expectFail, QObject* parent)
 : KJob(parent)
 , m_suite(suite)
 , m_cases(cases)
 , m_job(nullptr)
 , m_outputJob(nullptr)
 , m_verbosity(verbosity)
 , m_expectFail(expectFail)
 {
     foreach (const QString& testCase, cases)
     {
         m_caseResults[testCase] = TestResult::NotRun;
     }
 
     setCapabilities(Killable);
 }
 
 
 KJob* createTestJob(QString launchModeId, QStringList arguments )
 {
     LaunchConfigurationType* type = ICore::self()->runController()->launchConfigurationTypeForId( "Native Application" );
     ILaunchMode* mode = ICore::self()->runController()->launchModeForId( launchModeId );
 
     qCDebug(CMAKE) << "got mode and type:" << type << type->id() << mode << mode->id();
     Q_ASSERT(type && mode);
 
     ILauncher* launcher = nullptr;
     foreach (ILauncher *l, type->launchers())
     {
         //qCDebug(CMAKE) << "available launcher" << l << l->id() << l->supportedModes();
         if (l->supportedModes().contains(mode->id())) {
             launcher = l;
             break;
         }
     }
     Q_ASSERT(launcher);
 
     ILaunchConfiguration* ilaunch = nullptr;
     QList<ILaunchConfiguration*> launchConfigurations = ICore::self()->runController()->launchConfigurations();
     foreach (ILaunchConfiguration *l, launchConfigurations) {
         if (l->type() == type && l->config().readEntry("ConfiguredByCTest", false)) {
             ilaunch = l;
             break;
         }
     }
     if (!ilaunch) {
         ilaunch = ICore::self()->runController()->createLaunchConfiguration( type,
                                                 qMakePair( mode->id(), launcher->id() ),
                                                 nullptr, //TODO add project
                                                 i18n("CTest") );
         ilaunch->config().writeEntry("ConfiguredByCTest", true);
         //qCDebug(CMAKE) << "created config, launching";
     } else {
         //qCDebug(CMAKE) << "reusing generated config, launching";
     }
     type->configureLaunchFromCmdLineArguments( ilaunch->config(), arguments );
     return ICore::self()->runController()->execute(launchModeId, ilaunch);
 }
 
 void CTestRunJob::start()
 {
 //     if (!m_suite->cases().isEmpty())
 //     {
         // TODO: Find a better way of determining whether QTestLib is used by this test
 //         qCDebug(CMAKE) << "Setting a QtTestDelegate";
 //         setDelegate(new QtTestDelegate);
 //     }
 //     setStandardToolView(IOutputView::RunView);
 
     QStringList arguments = m_cases;
     if (m_cases.isEmpty() && !m_suite->arguments().isEmpty())
     {
         arguments = m_suite->arguments();
     }
 
     QStringList cases_selected = arguments;
     arguments.prepend(m_suite->executable().toLocalFile());
     m_job = createTestJob("execute", arguments);
 
     if (ExecuteCompositeJob* cjob = qobject_cast<ExecuteCompositeJob*>(m_job)) {
         m_outputJob = cjob->findChild<OutputJob*>();
         Q_ASSERT(m_outputJob);
         m_outputJob->setVerbosity(m_verbosity);
 
         QString testName = arguments.value(0).split('/').last();
         QString title;
         if (cases_selected.count() == 1)
             title = i18nc("running test %1, %2 test case", "CTest %1: %2", testName, cases_selected.value(0));
         else
             title = i18ncp("running test %1, %2 number of test cases", "CTest %2 (%1)", "CTest %2 (%1)", cases_selected.count(), testName);
 
         m_outputJob->setTitle(title);
 
         connect(m_outputJob->model(), SIGNAL(rowsInserted(QModelIndex,int,int)), SLOT(rowsInserted(QModelIndex,int,int)));
     }
     connect(m_job, SIGNAL(finished(KJob*)), SLOT(processFinished(KJob*)));
 
     ICore::self()->testController()->notifyTestRunStarted(m_suite, cases_selected);
 }
 
 bool CTestRunJob::doKill()
 {
     if (m_job)
     {
         m_job->kill();
     }
     return true;
 }
 
 void CTestRunJob::processFinished(KJob* job)
 {
     TestResult result;
     result.testCaseResults = m_caseResults;
     if (job->error() == OutputJob::FailedShownError) {
         result.suiteResult = TestResult::Failed;
     } else if (job->error() == KJob::NoError) {
         result.suiteResult = TestResult::Passed;
     } else {
         result.suiteResult = TestResult::Error;
     }
 
     // in case the job was killed, mark this job as killed as well
     if (job->error() == KJob::KilledJobError) {
         setError(KJob::KilledJobError);
         setErrorText("Child job was killed.");
     }
 
     qCDebug(CMAKE) << result.suiteResult << result.testCaseResults;
     ICore::self()->testController()->notifyTestRunFinished(m_suite, result);
     emitResult();
 }
 
 void CTestRunJob::rowsInserted(const QModelIndex &parent, int startRow, int endRow)
 {
     // This regular expresion matches the name of the testcase (whatever between "::" and "(", indeed )
     // For example, from:
     //      PASS   : ExpTest::testExp(sum)
     // matches "testExp"
     static QRegExp caseRx("::(.*)\\(", Qt::CaseSensitive, QRegExp::RegExp2);
     for (int row = startRow; row <= endRow; ++row)
     {
         QString line = m_outputJob->model()->data(m_outputJob->model()->index(row, 0, parent), Qt::DisplayRole).toString();
 
         QString testCase;
         if (caseRx.indexIn(line) >= 0) {
             testCase = caseRx.cap(1);
         }
 
         TestResult::TestCaseResult prevResult = m_caseResults.value(testCase, TestResult::NotRun);
         if (prevResult == TestResult::Passed || prevResult == TestResult::NotRun)
         {
             TestResult::TestCaseResult result = TestResult::NotRun;
             if (line.startsWith("PASS   :"))
             {
                 result = m_expectFail ? TestResult::UnexpectedPass : TestResult::Passed;
             }
             else if (line.startsWith("FAIL!  :"))
             {
                 result = m_expectFail ? TestResult::ExpectedFail : TestResult::Failed;
             }
             else if (line.startsWith("XFAIL  :"))
             {
                 result = TestResult::ExpectedFail;
             }
             else if (line.startsWith("XPASS  :"))
             {
                 result = TestResult::UnexpectedPass;
             }
             else if (line.startsWith("SKIP   :"))
             {
                 result = TestResult::Skipped;
             }
 
             if (result != TestResult::NotRun)
             {
                 m_caseResults[testCase] = result;
             }
         }
     }
 }
diff --git a/projectmanagers/cmake/testing/ctestsuite.cpp b/projectmanagers/cmake/testing/ctestsuite.cpp
index fb0a6b5559..5f107d1ad0 100644
--- a/projectmanagers/cmake/testing/ctestsuite.cpp
+++ b/projectmanagers/cmake/testing/ctestsuite.cpp
@@ -1,198 +1,196 @@
 /*  This file is part of KDevelop
     Copyright 2012 Miha Čančula <miha@noughmad.eu>
 
     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; see the file COPYING.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "ctestsuite.h"
 #include "ctestrunjob.h"
 #include "../debug.h"
 
-#include <QFileInfo>
-
 #include <interfaces/itestcontroller.h>
 #include <interfaces/iproject.h>
 #include <language/duchain/indexeddeclaration.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/use.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/classfunctiondeclaration.h>
 #include <language/duchain/functiondeclaration.h>
 #include <language/duchain/functiondefinition.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/types/structuretype.h>
 #include <project/projectmodel.h>
 
 
 using namespace KDevelop;
 
 CTestSuite::CTestSuite(const QString& name, const KDevelop::Path &executable, const QList<KDevelop::Path>& files, IProject* project, const QStringList& args, bool expectFail):
 m_executable(executable),
 m_name(name),
 m_args(args),
 m_files(files),
 m_project(project),
 m_expectFail(expectFail)
 {
     Q_ASSERT(project);
     qCDebug(CMAKE) << m_name << m_executable << m_project->name();
 }
 
 CTestSuite::~CTestSuite()
 {
 
 }
 
 void CTestSuite::loadDeclarations(const IndexedString& document, const KDevelop::ReferencedTopDUContext& ref)
 {
     DUChainReadLocker locker(DUChain::lock());
     TopDUContext* topContext = DUChainUtils::contentContextFromProxyContext(ref.data());
     if (!topContext)
     {
         qCDebug(CMAKE) << "No top context in" << document.str();
         return;
     }
 
     Declaration* testClass = nullptr;
     Identifier testCaseIdentifier("tc");
     foreach (Declaration* declaration, topContext->findLocalDeclarations(Identifier("main")))
     {
         if (declaration->isDefinition())
         {
             qCDebug(CMAKE) << "Found a definition for a function 'main()' ";
             FunctionDefinition* def = dynamic_cast<FunctionDefinition*>(declaration);
             DUContext* main = def->internalContext();
             foreach (Declaration* mainDeclaration, main->localDeclarations(topContext))
             {
                 if (mainDeclaration->identifier() == testCaseIdentifier)
                 {
                     qCDebug(CMAKE) << "Found tc declaration in main:" << mainDeclaration->identifier().toString();
                     qCDebug(CMAKE) << "Its type is" << mainDeclaration->abstractType()->toString();
                     if (StructureType::Ptr type = mainDeclaration->abstractType().cast<StructureType>())
                     {
                         testClass = type->declaration(topContext);
                     }
                 }
             }
         }
     }
 
     if (!testClass || !testClass->internalContext())
     {
         qCDebug(CMAKE) << "No test class found or internal context missing in " << document.str();
         return;
     }
 
     if (!m_suiteDeclaration.data())
     {
         m_suiteDeclaration = IndexedDeclaration(testClass);
     }
 
     foreach (Declaration* decl, testClass->internalContext()->localDeclarations(topContext))
     {
         qCDebug(CMAKE) << "Found declaration" << decl->toString() << decl->identifier().identifier().byteArray();
         if (ClassFunctionDeclaration* function = dynamic_cast<ClassFunctionDeclaration*>(decl))
         {
             if (function->accessPolicy() == Declaration::Private && function->isSlot())
             {
                 QString name = function->qualifiedIdentifier().last().toString();
                 qCDebug(CMAKE) << "Found private slot in test" << name;
 
                 if (name.endsWith("_data"))
                 {
                     continue;
                 }
 
                 if (name != "initTestCase" && name != "cleanupTestCase"
                     && name != "init" && name != "cleanup")
                 {
                     m_cases << name;
                 }
                 qCDebug(CMAKE) << "Found test case function declaration" << function->identifier().toString();
 
                 FunctionDefinition* def = FunctionDefinition::definition(decl);
                 m_declarations[name] = def ? IndexedDeclaration(def) : IndexedDeclaration(function);
             }
         }
     }
 }
 
 KJob* CTestSuite::launchCase(const QString& testCase, TestJobVerbosity verbosity)
 {
     return launchCases(QStringList() << testCase, verbosity);
 }
 
 KJob* CTestSuite::launchCases(const QStringList& testCases, ITestSuite::TestJobVerbosity verbosity)
 {
     qCDebug(CMAKE) << "Launching test run" << m_name << "with cases" << testCases;
 
     OutputJob::OutputJobVerbosity outputVerbosity = (verbosity == Verbose) ? OutputJob::Verbose : OutputJob::Silent;
     return new CTestRunJob(this, testCases, outputVerbosity, m_expectFail);
 }
 
 KJob* CTestSuite::launchAllCases(TestJobVerbosity verbosity)
 {
     return launchCases(cases(), verbosity);
 }
 
 KDevelop::Path CTestSuite::executable() const
 {
     return m_executable;
 }
 
 QStringList CTestSuite::cases() const
 {
     return m_cases;
 }
 
 QString CTestSuite::name() const
 {
     return m_name;
 }
 
 KDevelop::IProject* CTestSuite::project() const
 {
     return m_project;
 }
 
 QStringList CTestSuite::arguments() const
 {
     return m_args;
 }
 
 IndexedDeclaration CTestSuite::declaration() const
 {
     return m_suiteDeclaration;
 }
 
 IndexedDeclaration CTestSuite::caseDeclaration(const QString& testCase) const
 {
     return m_declarations.value(testCase, IndexedDeclaration(nullptr));
 }
 
 void CTestSuite::setTestCases(const QStringList& cases)
 {
     m_cases = cases;
 }
 
 QList<KDevelop::Path> CTestSuite::sourceFiles() const
 {
     return m_files;
 }
 
 
 
diff --git a/projectmanagers/cmake/testing/ctestutils.h b/projectmanagers/cmake/testing/ctestutils.h
index e194c05fba..b33148a809 100644
--- a/projectmanagers/cmake/testing/ctestutils.h
+++ b/projectmanagers/cmake/testing/ctestutils.h
@@ -1,38 +1,35 @@
 /*  This file is part of KDevelop
     Copyright 2012 Miha Čančula <miha@noughmad.eu>
 
     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; see the file COPYING.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #ifndef CTESTUTILS_H
 #define CTESTUTILS_H
 
-#include <QtCore/QStringList>
 #include <cmaketypes.h>
 
 namespace KDevelop
 {
-class ProjectFolderItem;
-class Path;
 class IProject;
 }
 
 namespace CTestUtils
 {
     void createTestSuites(const QVector<Test>& testSuites, KDevelop::IProject* project);
 }
 
 #endif // CTESTUTILS_H
diff --git a/projectmanagers/cmake/tests/cmakeastfactorytest.h b/projectmanagers/cmake/tests/cmakeastfactorytest.h
index 22b6aca0b8..73811d8631 100644
--- a/projectmanagers/cmake/tests/cmakeastfactorytest.h
+++ b/projectmanagers/cmake/tests/cmakeastfactorytest.h
@@ -1,41 +1,41 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@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.
  */
 #ifndef CMAKEASTFACTORYTEST_H
 #define CMAKEASTFACTORYTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 class CMakeAstFactoryTest : public QObject
 {
 Q_OBJECT
 public:
     CMakeAstFactoryTest();
     ~CMakeAstFactoryTest();
 
 private slots:
     void testNonRegisteredObject();
     void testUnregisterObject();
     void testRegisteredObject();
     void testCaseSensitivity();
     void testCreateObject();
 
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/cmakeasttest.h b/projectmanagers/cmake/tests/cmakeasttest.h
index 2c5e34bbe1..58cd3aee1b 100644
--- a/projectmanagers/cmake/tests/cmakeasttest.h
+++ b/projectmanagers/cmake/tests/cmakeasttest.h
@@ -1,398 +1,398 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@kde.org>
  * Copyright 2008 Aleix Pol <aleixpol@gmail.com>
  *
  * 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 CMAKEASTTEST_H
 #define CMAKEASTTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 class CMakeAstTest : public QObject
 {
     Q_OBJECT
 public:
     CMakeAstTest() {}
     virtual ~CMakeAstTest() {}
 
 private slots:
     void testAddDefinitionsGoodParse();
     void testAddDefinitionsGoodParse_data();
     void testAddDefinitionsBadParse();
     void testAddDefinitionsBadParse_data();
     void testAddDependenciesGoodParse();
     void testAddDependenciesGoodParse_data();
     void testAddDependenciesBadParse();
     void testAddDependenciesBadParse_data();
     void testAddExecutableGoodParse();
     void testAddExecutableGoodParse_data();
     void testAddExecutableBadParse();
     void testAddExecutableBadParse_data();
     void testAddLibraryGoodParse();
     void testAddLibraryGoodParse_data();
     void testAddLibraryBadParse();
     void testAddLibraryBadParse_data();
     void testAddSubdirectoryGoodParse();
     void testAddSubdirectoryGoodParse_data();
     void testAddSubdirectoryBadParse();
     void testAddSubdirectoryBadParse_data();
     void testAddTestGoodParse();
     void testAddTestGoodParse_data();
     void testAddTestBadParse();
     void testAddTestBadParse_data();
     void testAuxSourceDirectoryGoodParse();
     void testAuxSourceDirectoryGoodParse_data();
     void testAuxSourceDirectoryBadParse();
     void testAuxSourceDirectoryBadParse_data();
     void testBreakGoodParse();
     void testBreakGoodParse_data();
     void testBreakBadParse();
     void testBreakBadParse_data();
     void testBuildCommandGoodParse();
     void testBuildCommandGoodParse_data();
     void testBuildCommandBadParse();
     void testBuildCommandBadParse_data();
     void testBuildNameGoodParse();
     void testBuildNameGoodParse_data();
     void testBuildNameBadParse();
     void testBuildNameBadParse_data();
     void testCMakeMinimumRequiredGoodParse();
     void testCMakeMinimumRequiredGoodParse_data();
     void testCMakeMinimumRequiredBadParse();
     void testCMakeMinimumRequiredBadParse_data();
     void testCMakePolicyGoodParse();
     void testCMakePolicyGoodParse_data();
     void testCMakePolicyBadParse();
     void testCMakePolicyBadParse_data();
     void testConfigureFileGoodParse();
     void testConfigureFileGoodParse_data();
     void testConfigureFileBadParse();
     void testConfigureFileBadParse_data();
     void testCustomCommandGoodParse();
     void testCustomCommandGoodParse_data();
     void testCustomCommandBadParse();
     void testCustomCommandBadParse_data();
     void testCustomTargetGoodParse();
     void testCustomTargetGoodParse_data();
     void testCustomTargetBadParse();
     void testCustomTargetBadParse_data();
     void testCreateTestSourcelistGoodParse();
     void testCreateTestSourcelistGoodParse_data();
     void testCreateTestSourcelistBadParse();
     void testCreateTestSourcelistBadParse_data();
     void testEnableLanguageGoodParse();
     void testEnableLanguageGoodParse_data();
     void testEnableLanguageBadParse();
     void testEnableLanguageBadParse_data();
     void testEnableTestingGoodParse();
     void testEnableTestingGoodParse_data();
     void testEnableTestingBadParse();
     void testEnableTestingBadParse_data();
     void testExecProgramGoodParse();
     void testExecProgramGoodParse_data();
     void testExecProgramBadParse();
     void testExecProgramBadParse_data();
     void testExecuteProcessGoodParse();
     void testExecuteProcessGoodParse_data();
     void testExecuteProcessBadParse();
     void testExecuteProcessBadParse_data();
     void testExportGoodParse();
     void testExportGoodParse_data();
     void testExportBadParse();
     void testExportBadParse_data();
     void testExportLibraryDepsGoodParse();
     void testExportLibraryDepsGoodParse_data();
     void testExportLibraryDepsBadParse();
     void testExportLibraryDepsBadParse_data();
     void testFileGoodParse();
     void testFileGoodParse_data();
     void testFileBadParse();
     void testFileBadParse_data();
     void testFindFileGoodParse();
     void testFindFileGoodParse_data();
     void testFindFileBadParse();
     void testFindFileBadParse_data();
     void testFindLibraryGoodParse();
     void testFindLibraryGoodParse_data();
     void testFindLibraryBadParse();
     void testFindLibraryBadParse_data();
     void testFindPackageGoodParse();
     void testFindPackageGoodParse_data();
     void testFindPackageBadParse();
     void testFindPackageBadParse_data();
     void testFindPathGoodParse();
     void testFindPathGoodParse_data();
     void testFindPathBadParse();
     void testFindPathBadParse_data();
     void testFindProgramGoodParse();
     void testFindProgramGoodParse_data();
     void testFindProgramBadParse();
     void testFindProgramBadParse_data();
     void testFltkWrapUiGoodParse();
     void testFltkWrapUiGoodParse_data();
     void testFltkWrapUiBadParse();
     void testFltkWrapUiBadParse_data();
     void testForeachGoodParse();
     void testForeachGoodParse_data();
     void testForeachBadParse();
     void testForeachBadParse_data();
     void testGetCMakePropertyGoodParse();
     void testGetCMakePropertyGoodParse_data();
     void testGetCMakePropertyBadParse();
     void testGetCMakePropertyBadParse_data();
     void testGetDirPropertyGoodParse();
     void testGetDirPropertyGoodParse_data();
     void testGetDirPropertyBadParse();
     void testGetDirPropertyBadParse_data();
     void testGetFilenameComponentGoodParse();
     void testGetFilenameComponentGoodParse_data();
     void testGetFilenameComponentBadParse();
     void testGetFilenameComponentBadParse_data();
     void testGetPropertyGoodParse();
     void testGetPropertyGoodParse_data();
     void testGetPropertyBadParse();
     void testGetPropertyBadParse_data();
     void testGetSourceFilePropGoodParse();
     void testGetSourceFilePropGoodParse_data();
     void testGetSourceFilePropBadParse();
     void testGetSourceFilePropBadParse_data();
     void testGetTargetPropGoodParse();
     void testGetTargetPropGoodParse_data();
     void testGetTargetPropBadParse();
     void testGetTargetPropBadParse_data();
     void testGetTestPropGoodParse();
     void testGetTestPropGoodParse_data();
     void testGetTestPropBadParse();
     void testGetTestPropBadParse_data();
     void testIfGoodParse();
     void testIfGoodParse_data();
     void testIfBadParse();
     void testIfBadParse_data();
     void testIncludeGoodParse();
     void testIncludeGoodParse_data();
     void testIncludeBadParse();
     void testIncludeBadParse_data();
     void testIncludeDirectoriesGoodParse();
     void testIncludeDirectoriesGoodParse_data();
     void testIncludeDirectoriesBadParse();
     void testIncludeDirectoriesBadParse_data();
     void testIncludeExternalMsProjectGoodParse();
     void testIncludeExternalMsProjectGoodParse_data();
     void testIncludeExternalMsProjectBadParse();
     void testIncludeExternalMsProjectBadParse_data();
     void testIncludeRegularExpressionGoodParse();
     void testIncludeRegularExpressionGoodParse_data();
     void testIncludeRegularExpressionBadParse();
     void testIncludeRegularExpressionBadParse_data();
     void testInstallGoodParse();
     void testInstallGoodParse_data();
     void testInstallBadParse();
     void testInstallBadParse_data();
     void testInstallFilesGoodParse();
     void testInstallFilesGoodParse_data();
     void testInstallFilesBadParse();
     void testInstallFilesBadParse_data();
     void testInstallProgramsGoodParse();
     void testInstallProgramsGoodParse_data();
     void testInstallProgramsBadParse();
     void testInstallProgramsBadParse_data();
     void testInstallTargetsGoodParse();
     void testInstallTargetsGoodParse_data();
     void testInstallTargetsBadParse();
     void testInstallTargetsBadParse_data();
     void testLinkDirectoriesGoodParse();
     void testLinkDirectoriesGoodParse_data();
     void testLinkDirectoriesBadParse();
     void testLinkDirectoriesBadParse_data();
     void testLinkLibrariesGoodParse();
     void testLinkLibrariesGoodParse_data();
     void testLinkLibrariesBadParse();
     void testLinkLibrariesBadParse_data();
     void testListGoodParse();
     void testListGoodParse_data();
     void testListBadParse();
     void testListBadParse_data();
     void testLoadCacheGoodParse();
     void testLoadCacheGoodParse_data();
     void testLoadCacheBadParse();
     void testLoadCacheBadParse_data();
     void testLoadCommandGoodParse();
     void testLoadCommandGoodParse_data();
     void testLoadCommandBadParse();
     void testLoadCommandBadParse_data();
     void testMacroGoodParse();
     void testMacroGoodParse_data();
     void testMacroBadParse();
     void testMacroBadParse_data();
     void testFunctionGoodParse();
     void testFunctionGoodParse_data();
     void testFunctionBadParse();
     void testFunctionBadParse_data();
     void testMakeDirectoryGoodParse();
     void testMakeDirectoryGoodParse_data();
     void testMakeDirectoryBadParse();
     void testMakeDirectoryBadParse_data();
     void testMarkAsAdvancedGoodParse();
     void testMarkAsAdvancedGoodParse_data();
     void testMarkAsAdvancedBadParse();
     void testMarkAsAdvancedBadParse_data();
     void testMathGoodParse();
     void testMathGoodParse_data();
     void testMathBadParse();
     void testMathBadParse_data();
     void testMessageGoodParse();
     void testMessageGoodParse_data();
     void testMessageBadParse();
     void testMessageBadParse_data();
     void testOptionGoodParse();
     void testOptionGoodParse_data();
     void testOptionBadParse();
     void testOptionBadParse_data();
     void testOutputRequiredFilesGoodParse();
     void testOutputRequiredFilesGoodParse_data();
     void testOutputRequiredFilesBadParse();
     void testOutputRequiredFilesBadParse_data();
     void testProjectGoodParse();
     void testProjectGoodParse_data();
     void testProjectBadParse();
     void testProjectBadParse_data();
     void testQtWrapCppGoodParse();
     void testQtWrapCppGoodParse_data();
     void testQtWrapCppBadParse();
     void testQtWrapCppBadParse_data();
     void testQtWrapUiGoodParse();
     void testQtWrapUiGoodParse_data();
     void testQtWrapUiBadParse();
     void testQtWrapUiBadParse_data();
     void testRemoveGoodParse();
     void testRemoveGoodParse_data();
     void testRemoveBadParse();
     void testRemoveBadParse_data();
     void testRemoveDefinitionsGoodParse();
     void testRemoveDefinitionsGoodParse_data();
     void testRemoveDefinitionsBadParse();
     void testRemoveDefinitionsBadParse_data();
     void testReturnGoodParse();
     void testReturnGoodParse_data();
     void testReturnBadParse();
     void testReturnBadParse_data();
     void testSeparateArgumentsGoodParse();
     void testSeparateArgumentsGoodParse_data();
     void testSeparateArgumentsBadParse();
     void testSeparateArgumentsBadParse_data();
     void testSetGoodParse();
     void testSetGoodParse_data();
     void testSetBadParse();
     void testSetBadParse_data();
     void testSetDirectoryPropsGoodParse();
     void testSetDirectoryPropsGoodParse_data();
     void testSetDirectoryPropsBadParse();
     void testSetDirectoryPropsBadParse_data();
     void testSetPropertyGoodParse();
     void testSetPropertyGoodParse_data();
     void testSetPropertyBadParse();
     void testSetPropertyBadParse_data();
     void testSetSourceFilesPropsGoodParse();
     void testSetSourceFilesPropsGoodParse_data();
     void testSetSourceFilesPropsBadParse();
     void testSetSourceFilesPropsBadParse_data();
     void testSetTargetPropsGoodParse();
     void testSetTargetPropsGoodParse_data();
     void testSetTargetPropsBadParse();
     void testSetTargetPropsBadParse_data();
     void testSetTestsPropsGoodParse();
     void testSetTestsPropsGoodParse_data();
     void testSetTestsPropsBadParse();
     void testSetTestsPropsBadParse_data();
     void testSiteNameGoodParse();
     void testSiteNameGoodParse_data();
     void testSiteNameBadParse();
     void testSiteNameBadParse_data();
     void testSourceGroupGoodParse();
     void testSourceGroupGoodParse_data();
     void testSourceGroupBadParse();
     void testSourceGroupBadParse_data();
     void testStringGoodParse();
     void testStringGoodParse_data();
     void testStringBadParse();
     void testStringBadParse_data();
     void testSubdirDependsGoodParse();
     void testSubdirDependsGoodParse_data();
     void testSubdirDependsBadParse();
     void testSubdirDependsBadParse_data();
     void testSubdirsGoodParse();
     void testSubdirsGoodParse_data();
     void testSubdirsBadParse();
     void testSubdirsBadParse_data();
     void testTargetLinkLibrariesGoodParse();
     void testTargetLinkLibrariesGoodParse_data();
     void testTargetLinkLibrariesBadParse();
     void testTargetLinkLibrariesBadParse_data();
     void testTargetLinkLibrariesMembers();
     void testTryCompileGoodParse();
     void testTryCompileGoodParse_data();
     void testTryCompileBadParse();
     void testTryCompileBadParse_data();
     void testTryRunGoodParse();
     void testTryRunGoodParse_data();
     void testTryRunBadParse();
     void testTryRunBadParse_data();
     void testUnsetGoodParse();
     void testUnsetGoodParse_data();
     void testUnsetBadParse();
     void testUnsetBadParse_data();
     void testUseMangledMesaGoodParse();
     void testUseMangledMesaGoodParse_data();
     void testUseMangledMesaBadParse();
     void testUseMangledMesaBadParse_data();
     void testUtilitySourceGoodParse();
     void testUtilitySourceGoodParse_data();
     void testUtilitySourceBadParse();
     void testUtilitySourceBadParse_data();
     void testVariableRequiresGoodParse();
     void testVariableRequiresGoodParse_data();
     void testVariableRequiresBadParse();
     void testVariableRequiresBadParse_data();
     void testVtkMakeInstantiatorGoodParse();
     void testVtkMakeInstantiatorGoodParse_data();
     void testVtkMakeInstantiatorBadParse();
     void testVtkMakeInstantiatorBadParse_data();
     void testVtkWrapJavaGoodParse();
     void testVtkWrapJavaGoodParse_data();
     void testVtkWrapJavaBadParse();
     void testVtkWrapJavaBadParse_data();
     void testVtkWrapPythonGoodParse();
     void testVtkWrapPythonGoodParse_data();
     void testVtkWrapPythonBadParse();
     void testVtkWrapPythonBadParse_data();
     void testVtkWrapTclGoodParse();
     void testVtkWrapTclGoodParse_data();
     void testVtkWrapTclBadParse();
     void testVtkWrapTclBadParse_data();
     void testWhileGoodParse();
     void testWhileGoodParse_data();
     void testWhileBadParse();
     void testWhileBadParse_data();
     void testWriteFileGoodParse();
     void testWriteFileGoodParse_data();
     void testWriteFileBadParse();
     void testWriteFileBadParse_data();
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/cmakecompliance.cpp b/projectmanagers/cmake/tests/cmakecompliance.cpp
index e9ebfbd918..81da78f38e 100644
--- a/projectmanagers/cmake/tests/cmakecompliance.cpp
+++ b/projectmanagers/cmake/tests/cmakecompliance.cpp
@@ -1,179 +1,178 @@
 /* KDevelop CMake Support
  *
  * Copyright 2007 Aleix Pol Gonzalez <aleixpol@gmail.com>
  *
  * 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 "cmakecompliance.h"
 #include "cmakeast.h"
 #include "cmakeprojectvisitor.h"
 #include "astfactory.h"
 #include "cmake-test-paths.h"
 #include "../debug.h"
 
 #include <QProcess>
-#include <QFile>
 
 #include <cmakeparserutils.h>
 #include <language/duchain/duchain.h>
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <cmakeprojectdata.h>
 
 using namespace KDevelop;
 
 QTEST_MAIN( CMakeCompliance )
 
 QString CMakeCompliance::output;
 
 //Copied from CMakeManager
 QString executeProcess(const QString& execName, const QStringList& args=QStringList())
 {
     QProcess p;
     p.setProcessChannelMode(QProcess::MergedChannels);
     p.setProgram(execName, args);
     p.start();
 
     if(!p.waitForFinished())
     {
         qCDebug(CMAKE) << "failed to execute:" << execName;
     }
 
     QByteArray b = p.readAllStandardOutput();
     QString t;
     t.prepend(b.trimmed());
 
     return t;
 }
 
 void CMakeCompliance::testEnumerate()
 {
     QFETCH( QString, exe);
 
     QStringList commands=executeProcess(exe, QStringList("--help-command-list")).split("\n");
     commands.erase(commands.begin());
     commands.sort();
     foreach(const QString& cmd, commands)
     {
         if(cmd.toLower().startsWith("end") || cmd.toLower()=="else" || cmd.toLower()=="elseif")
             continue;
         CMakeAst* element = AstFactory::self()->createAst(cmd);
         if(!element)
             qDebug() << cmd << "is not supported";
         delete element;
     }
 }
 
 void CMakeCompliance::testEnumerate_data()
 {
     QTest::addColumn<QString>( "exe" );
     QStringList cmakes;
     KStandardDirs::findAllExe(cmakes, "cmake");
 
     foreach(const QString& path, cmakes)
     {
         QTest::newRow( qPrintable(path) ) << (path);
     }
 }
 
 CMakeProjectVisitor CMakeCompliance::parseFile( const QString& sourcefile )
 {
     CMakeProjectVisitor::setMessageCallback(CMakeCompliance::addOutput);
     QString projectfile = sourcefile;
 
     CMakeFileContent code=CMakeListsParser::readCMakeFile(projectfile);
 
     static QPair<VariableMap,QStringList> initials = CMakeParserUtils::initialVariables();
     CMakeProjectData data;
     data.vm = initials.first;
     QString sourcedir=sourcefile.left(sourcefile.lastIndexOf('/'));
     data.vm.insert("CMAKE_SOURCE_DIR", QStringList(sourcedir));
 
     KDevelop::ReferencedTopDUContext buildstrapContext=new TopDUContext(IndexedString("buildstrap"), RangeInRevision(0,0, 0,0));
     DUChain::self()->addDocumentChain(buildstrapContext);
     ReferencedTopDUContext ref=buildstrapContext;
     QStringList modulesPath = data.vm["CMAKE_MODULE_PATH"];
 
     foreach(const QString& script, initials.second)
     {
         ref = CMakeParserUtils::includeScript(CMakeProjectVisitor::findFile(script, modulesPath, QStringList()),
                                               ref, &data, sourcedir, QMap<QString,QString>());
     }
 
     data.vm.insert("CMAKE_CURRENT_BINARY_DIR", QStringList(sourcedir));
     data.vm.insert("CMAKE_CURRENT_LIST_FILE", QStringList(projectfile));
     data.vm.insert("CMAKE_CURRENT_SOURCE_DIR", QStringList(sourcedir));
 
     CMakeProjectVisitor v(projectfile, ref);
     v.setVariableMap(&data.vm);
     v.setMacroMap(&data.mm);
     v.setCacheValues(&data.cache);
     v.setModulePath(modulesPath);
     output.clear();
     v.walk(code, 0);
 
     ReferencedTopDUContext ctx=v.context();
     return v;
 }
 
 void CMakeCompliance::testCMakeTests()
 {
     QFETCH(QString, exe);
     QFETCH(QString, file);
 
     CMakeProjectVisitor v = parseFile(file);
 
     QString ret=executeProcess(exe, QStringList("-P") << file);
 
     QStringList outputList = output.split('\n'), cmakeList=ret.split('\n');
     for(int i=0; i<outputList.size(); i++) {
         QCOMPARE(outputList[i], cmakeList[i]);
     }
 }
 
 void CMakeCompliance::testCMakeTests_data()
 {
     QTest::addColumn<QString>("exe");
     QTest::addColumn<QString>("file");
 
     QStringList files=QStringList()
 //         << "/CMakeTests/IfTest.cmake.in"
         << "/CMakeTests/ListTest.cmake.in"
     ;
 
     QStringList cmakes;
     KStandardDirs::findAllExe(cmakes, "cmake");
     foreach(const QString& exe, cmakes) {
         foreach(const QString& file, files)
             QTest::newRow( qPrintable(QString(exe+file)) ) << exe << QString(CMAKE_TESTS_PROJECTS_DIR + file);
     }
 }
 
 void CMakeCompliance::addOutput(const QString& msg)
 {
     output += "-- "+msg+'\n';
 }
 
 CMakeCompliance::CMakeCompliance() {
     AutoTestShell::init();
     KDevelop::TestCore::initialize( Core::NoUi );
 }
 
 CMakeCompliance::~CMakeCompliance() {
     KDevelop::TestCore::shutdown();
 }
 
diff --git a/projectmanagers/cmake/tests/cmakecompliance.h b/projectmanagers/cmake/tests/cmakecompliance.h
index ea991d01cc..4b9f412828 100644
--- a/projectmanagers/cmake/tests/cmakecompliance.h
+++ b/projectmanagers/cmake/tests/cmakecompliance.h
@@ -1,47 +1,47 @@
 /* KDevelop CMake Support
  *
  * Copyright 2007 Aleix Pol Gonzalez <aleixpol@gmail.com>
  *
  * 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 CMAKEMESSAGEASTTEST_H
 #define CMAKEMESSAGEASTTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 class CMakeProjectVisitor;
 class CMakeCompliance : public QObject
 {
     Q_OBJECT
     public:
         CMakeCompliance();
         virtual ~CMakeCompliance();
         static void addOutput(const QString& msg);
 
     private slots:
         void testEnumerate();
         void testEnumerate_data();
         
         void testCMakeTests();
         void testCMakeTests_data();
         
     private:
         CMakeProjectVisitor parseFile( const QString& sourcefile );
         static QString output;
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/cmakeconditiontest.h b/projectmanagers/cmake/tests/cmakeconditiontest.h
index d05a6fec6c..53b1625bc0 100644
--- a/projectmanagers/cmake/tests/cmakeconditiontest.h
+++ b/projectmanagers/cmake/tests/cmakeconditiontest.h
@@ -1,48 +1,48 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@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.
  */
 
 #ifndef CMAKECMAKECONDITIONTEST_H
 #define CMAKECMAKECONDITIONTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 #include "cmaketypes.h"
 
 class CMakeConditionTest : public QObject
 {
     Q_OBJECT
 public:
     CMakeConditionTest();
     virtual ~CMakeConditionTest();
 
 private slots:
     void testGoodParse();
     void testGoodParse_data();
 
     void testBadParse();
     void testBadParse_data();
     
 private:
     VariableMap m_vars;
     MacroMap m_macros;
     CacheValues m_cache;
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/cmakeduchaintest.h b/projectmanagers/cmake/tests/cmakeduchaintest.h
index 63639d7d52..ff2c1bb71f 100644
--- a/projectmanagers/cmake/tests/cmakeduchaintest.h
+++ b/projectmanagers/cmake/tests/cmakeduchaintest.h
@@ -1,46 +1,46 @@
 /* KDevelop CMake Support
  *
  * Copyright 2008 Aleix Pol Gonzalez <aleixpol@gmail.com>
  *
  * 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 CMAKEDUCHAINTEST_H
 #define CMAKEDUCHAINTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 #include <language/duchain/topducontext.h>
 
 /**
  * A test for the CMake DUChain builder.
  * @author Aleix Pol <aleixpol@gmail.com>
  */
 
 
 class CMakeDUChainTest : public QObject
 {
     Q_OBJECT
     private slots:
         void initTestCase();
         void cleanupTestCase();
 
         void testUses_data();
         void testUses();
         void testDUChainWalk_data();
         void testDUChainWalk();
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/cmakeloadprojecttest.h b/projectmanagers/cmake/tests/cmakeloadprojecttest.h
index cb19525d5f..8c8f36c189 100644
--- a/projectmanagers/cmake/tests/cmakeloadprojecttest.h
+++ b/projectmanagers/cmake/tests/cmakeloadprojecttest.h
@@ -1,59 +1,59 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@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.
  */
 
 #ifndef CMAKELOADPROJECTTEST_H
 #define CMAKELOADPROJECTTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 struct CMakeProjectData;
 class CMakeProjectVisitor;
 class CMakeAst;
 
 /**
  * A test for the CMake parser and lexer loading three different real projects
  * Useful for doing call-analyzation and memory checking with valgrind
  * @author Matt Rogers <mattr@kde.org>
  */
 class CMakeLoadProjectTest : public QObject
 {
 Q_OBJECT
 private slots:
     void initTestCase();
     void cleanupTestCase();
 
     //Note: These could be done as data-driven tests, but they are separate so that one can
     // more easily profile a plain-cmake vs. qt4-only vs. kde4 project
     void testTinyCMakeProject();
     void testSmallProjectWithTests();
 
 #if QT_VERSION <= 0x050000
 //  TODO KF5: Port me?
     void testSmallQt4Project();
     void testSmallKDE4Project();
     void testKDE4ProjectWithTests();
     void testBug335803();
 #endif
 
 private:
     CMakeProjectData parseProject( const QString& sourcedir );
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/cmakeparsertest.h b/projectmanagers/cmake/tests/cmakeparsertest.h
index 0da0612304..eaed39c991 100644
--- a/projectmanagers/cmake/tests/cmakeparsertest.h
+++ b/projectmanagers/cmake/tests/cmakeparsertest.h
@@ -1,54 +1,54 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@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.
  */
 
 #ifndef CMAKELEXERTEST_H
 #define CMAKELEXERTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 class CMakeAst;
 
 /**
  * A test for the CMake parser and lexer
  * @author Matt Rogers <mattr@kde.org>
  */
 class CMakeParserTest : public QObject
 {
 Q_OBJECT
 public:
     CMakeParserTest();
     ~CMakeParserTest();
 
 private slots:
     void testLexerCreation();
     void testLexerWithFile();
 
     void testParserWithGoodData();
     void testParserWithGoodData_data();
 
     void testParserWithBadData();
     void testParserWithBadData_data();
 
     //void testAstCreation();
 
     // void testWhitespaceHandling();
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/cmakeparserutilstest.h b/projectmanagers/cmake/tests/cmakeparserutilstest.h
index fa30710557..ae7cf2bb78 100644
--- a/projectmanagers/cmake/tests/cmakeparserutilstest.h
+++ b/projectmanagers/cmake/tests/cmakeparserutilstest.h
@@ -1,40 +1,40 @@
 /* KDevelop CMake Support
  *
  * Copyright 2008 Matt Rogers <mattr@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.
  */
 
 #ifndef CMAKECMAKEPARSERUTILSTEST_H
 #define CMAKECMAKEPARSERUTILSTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 class CMakeParserUtilsTest : public QObject
 {
     Q_OBJECT
 public:
     CMakeParserUtilsTest() {}
     virtual ~CMakeParserUtilsTest() {}
 
 private slots:
     void validVersionsTest();
     void validVersionsTest_data();
     void invalidVersionsTest();
     void invalidVersionsTest_data();
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/cmakeprojectvisitortest.h b/projectmanagers/cmake/tests/cmakeprojectvisitortest.h
index 582081f623..b01ebd1316 100644
--- a/projectmanagers/cmake/tests/cmakeprojectvisitortest.h
+++ b/projectmanagers/cmake/tests/cmakeprojectvisitortest.h
@@ -1,75 +1,75 @@
 /* KDevelop CMake Support
  *
  * Copyright 2008 Aleix Pol Gonzalez <aleixpol@gmail.com>
  *
  * 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 CMAKECMAKEPROJECTVISITORTEST_H
 #define CMAKECMAKEPROJECTVISITORTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 #include <QString>
 #include <language/duchain/topducontext.h>
 #include "cmakelistsparser.h"
 #include "cmakeprojectvisitor.h"
 
 
 class CMakeProjectVisitorTest : public QObject, public CMakeProjectVisitor
 {
     Q_OBJECT
 public:
     CMakeProjectVisitorTest();
 
 private slots:
     void initTestCase();
     void cleanupTestCase();
 
     void init();
     void cleanup();
 
     void testVariables();
     void testVariables_data();
 
     void testRun();
     void testRun_data();
 
     void testFinder_init();
     void testFinder();
     void testFinder_data();
 
     void testGlobs();
     void testGlobs_data();
 
     void testForeachLines();
 
     void testTargetProperties();
     void testTargetProperties_data();
 
     void testSetProperty();
     void testSetProperty_data();
 
     // function scope variables not being unset at exit
     void testBug335803_data();
     void testBug335803();
 private:
     QStringList modulePath;    
     QStringList buildstrap;
     VariableMap initialVariables;
     KDevelop::ReferencedTopDUContext fakeContext;
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/create_test.rb b/projectmanagers/cmake/tests/create_test.rb
index c77378daa3..8b35393b96 100755
--- a/projectmanagers/cmake/tests/create_test.rb
+++ b/projectmanagers/cmake/tests/create_test.rb
@@ -1,173 +1,173 @@
 #!/usr/bin/ruby
 # Copyright 2006 by Matt Rogers <mattr@kde.org>
 # Licensed under the GNU LGPL
 # I don't really care what you do with 
 
 className = ARGV[0]
 
 # Takes a class name as the first and only parameter
 if className.nil?
 	puts "Need a class name to generate the test. aborting"
 	exit
 end
 
 hBase = "cmake_#{className.downcase}_test.h"
 cppBase = hBase.gsub(/.h/, ".cpp")
 mocBase = hBase.gsub(/.h/, ".moc")
 license = <<LICENSE_EOF
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@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.
  */
 LICENSE_EOF
 
 fileH = <<HEADER_EOF
 #{license}
 #ifndef CMAKE#{className.upcase}TEST_H
 #define CMAKE#{className.upcase}TEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 class #{className}Test : public QObject
 {
     Q_OBJECT
 public:
     #{className}Test() {}
     virtual ~#{className}Test() {}
 
 private slots:
     void testGoodParse();
     void testGoodParse_data();
 
     void testBadParse();
     void testBadParse_data();
 };
 
 #endif
 HEADER_EOF
 
 fileCpp = <<CPP_EOF
 #{license}
 #include "#{hBase}"
 #include "cmakeast.h"
 #include "cmakelistsparser.h"
 
 QTEST_MAIN( #{className}Test )
 
 void #{className}Test::testGoodParse()
 {
     QFETCH( CMakeFunctionDesc, function );
     #{className}* ast = new #{className}();
     QVERIFY( ast->parseFunctionInfo( function ) == true );
     delete ast;
 }
 
 void #{className}Test::testGoodParse_data()
 {
 }
 
 void #{className}Test::testBadParse()
 {
     QFETCH( CMakeFunctionDesc, function );
     AddExecutableAst* ast = new AddExecutableAst();
     QVERIFY( ast->parseFunctionInfo( function ) == false );
     delete ast;
 }
 
 void #{className}Test::testBadParse_data()
 {
 }
 
 #include "#{mocBase}"
 CPP_EOF
 
 puts "Creating test for class #{className}"
 
 
 
 sourceVar = "#{className.downcase}test_SRCS"
 targetName = "cmake-#{className.downcase}test"
 cmakeText = <<CMAKE_EOF
 set ( #{sourceVar} #{cppBase} )
 kde4_automoc( #{targetName} ${#{sourceVar}} )
 kde4_add_executable( #{targetName} NOGUI RUN_UNINSTALLED ${#{sourceVar}} )
 target_link_libraries( #{targetName} 
   ${QT_QTTEST_LIBRARY}
   ${KDE_KDECORE_LIBS}
   kdevplatform
   kdevcmakecommon )
 add_test( #{targetName} ${EXECUTABLE_OUTPUT_PATH}/#{targetName} )
 endif(KDE4_BUILD_TESTS)
 
 CMAKE_EOF
 
 hOut = File.new(hBase, "w")
 cppOut = File.new(cppBase, "w")
 
 hOut.write(fileH)
 cppOut.write(fileCpp)
 
 puts "#{hBase} and #{cppBase} written."
 
 puts "Adding build system bits to CMakeLists.txt"
 cmakeList = File.new("CMakeLists.txt", "r+")
 oldCMakeText = cmakeList.read;
 cmakeList.close;
 oldCMakeText.gsub!(/endif\(KDE4_BUILD_TESTS\)/, cmakeText)
 cmakeList = File.new("CMakeLists.txt", "w")
 cmakeList.write(oldCMakeText)
 
 puts "Appending AST definition to cmakeast.h"
 cmakeAst = File.new("../parser/cmakeast.h", "r+")
 oldAstText = cmakeAst.read;
 cmakeAst.close;
 astDecl =<<AST_EOF
 
 CMAKE_BEGIN_AST_CLASS( #{className} )
 CMAKE_END_AST_CLASS( #{className} )
 
 #endif
 AST_EOF
 oldAstText.gsub!(/#endif/, astDecl)
 cmakeAst = File.new("../parser/cmakeast.h", "w")
 cmakeAst.write(oldAstText)
 cmakeAst.close
 
 puts "Appending AST implementation to cmakeast.cpp"
 cmakeAst = File.new("../parser/cmakeast.cpp", "a")
 astDef =<<AST_EOF
 #{className}::#{className}()
 {
 }
 
 #{className}::~#{className}()
 {
 }
 
 void #{className}::writeBack( QString& ) const
 {
 }
 
 bool #{className}::parseFunctionInfo( const CMakeFunctionDesc& func )
 {
     return false;
 }
 
 AST_EOF
 cmakeAst.write(astDef);
 cmakeAst.close
diff --git a/projectmanagers/cmake/tests/ctestfindsuitestest.h b/projectmanagers/cmake/tests/ctestfindsuitestest.h
index 3c9b1c1213..bfd899288e 100644
--- a/projectmanagers/cmake/tests/ctestfindsuitestest.h
+++ b/projectmanagers/cmake/tests/ctestfindsuitestest.h
@@ -1,44 +1,44 @@
 /* KDevelop CMake Support
  *
  * Copyright 2012 Miha Čančula <miha@noughmad.eu>
  *
  * 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 CTESTFINDSUITESTEST_H
 #define CTESTFINDSUITESTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 namespace KDevelop {
 class IProject;
 }
 
 class CTestFindSuitesTest : public QObject
 {
     Q_OBJECT
 
 private slots:
     void cleanup();
     
     void initTestCase();
     void cleanupTestCase();
     
     void testCTestSuite();
     void testQtTestSuite();
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/generationexpressionsolvertest.h b/projectmanagers/cmake/tests/generationexpressionsolvertest.h
index abdf234d1a..727b5fc7a2 100644
--- a/projectmanagers/cmake/tests/generationexpressionsolvertest.h
+++ b/projectmanagers/cmake/tests/generationexpressionsolvertest.h
@@ -1,34 +1,34 @@
 /* KDevelop CMake Support
  *
  * Copyright 2013 Aleix Pol Gonzalez <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.
  */
 
 #ifndef GENERATIONEXPRESSIONSOLVERTEST_H
 #define GENERATIONEXPRESSIONSOLVERTEST_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 class GenerationExpressionSolverTest : public QObject
 {
 Q_OBJECT
 private slots:
     void testRun();
     void testRun_data();
 };
 
 #endif
diff --git a/projectmanagers/cmake/tests/manual/unit_tests_kde/test.cpp b/projectmanagers/cmake/tests/manual/unit_tests_kde/test.cpp
index ad707658b6..05321c8821 100644
--- a/projectmanagers/cmake/tests/manual/unit_tests_kde/test.cpp
+++ b/projectmanagers/cmake/tests/manual/unit_tests_kde/test.cpp
@@ -1,44 +1,44 @@
 #include "test.h"
 
-#include <QtTest>
+#include <QTest>
 
 void KdeTest::initTestCase()
 {
 
 }
 
 void KdeTest::passingTestCase()
 {
     QCOMPARE(1+1, 2);
 }
 
 void KdeTest::failingTestCase()
 {
     QCOMPARE(2+2, 5);
 }
 
 void KdeTest::expectedFailTestCase()
 {
     QEXPECT_FAIL("", "Apparently, everything Physics teachers told me was a lie", Continue);
     QCOMPARE(3*3, 10);
 }
 
 void KdeTest::unexpectedPassTestCase()
 {
     QEXPECT_FAIL("", "Well, not everything", Continue);
     QCOMPARE(5*2, 10);
 }
 
 void KdeTest::skippedTestCase()
 {
     QSKIP("Don't argue with calculators", SkipAll);
     QCOMPARE(2+2*2, 8);
 }
 
 
 void KdeTest::cleanupTestCase()
 {
     
 }
 
 QTEST_KDEMAIN( KdeTest, NoGUI )
diff --git a/projectmanagers/cmake/tests/test_cmakemanager.cpp b/projectmanagers/cmake/tests/test_cmakemanager.cpp
index c9ba69fc5c..10b74d994c 100644
--- a/projectmanagers/cmake/tests/test_cmakemanager.cpp
+++ b/projectmanagers/cmake/tests/test_cmakemanager.cpp
@@ -1,349 +1,350 @@
 /* This file is part of KDevelop
     Copyright 2010 Esben Mose Hansen<kde@mosehansen.dk>
 
     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 "test_cmakemanager.h"
 #include "testhelpers.h"
 #include "cmakemodelitems.h"
 #include "cmakeutils.h"
 #include "cmakeimportjsonjob.h"
 #include <icmakemanager.h>
 
-#include <qtest.h>
+#include <QLoggingCategory>
+#include <QTemporaryFile>
 
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/icore.h>
 #include <project/interfaces/iprojectfilemanager.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <tests/autotestshell.h>
 #include <tests/testproject.h>
 #include <tests/testcore.h>
 
 QTEST_MAIN(TestCMakeManager)
 
 using namespace KDevelop;
 
 void TestCMakeManager::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.projectmanagers.cmake.debug=true\n"));
 
     AutoTestShell::init();
     TestCore::initialize();
 
     cleanup();
 }
 
 void TestCMakeManager::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestCMakeManager::cleanup()
 {
     foreach(IProject* p, ICore::self()->projectController()->projects()) {
         ICore::self()->projectController()->closeProject(p);
     }
     QVERIFY(ICore::self()->projectController()->projects().isEmpty());
 }
 
 void TestCMakeManager::testWithBuildDirProject()
 {
     loadProject("with_build_dir");
 }
 
 void TestCMakeManager::testIncludePaths()
 {
     IProject* project = loadProject("single_subdirectory");
     Path sourceDir = project->path();
 
     Path fooCpp(sourceDir, "subdir/foo.cpp");
     QVERIFY(QFile::exists(fooCpp.toLocalFile()));
     QList< ProjectBaseItem* > items = project->itemsForPath(IndexedString(fooCpp.pathOrUrl()));
     QEXPECT_FAIL("", "Will fix soon, hopefully", Continue);
     QCOMPARE(items.size(), 2); // once the target, once the plain file
     ProjectBaseItem* fooCppItem = items.first();
 
     Path::List includeDirs = project->buildSystemManager()->includeDirectories(fooCppItem);
     QVERIFY(includeDirs.size() >= 3);
 
     Path buildDir(sourceDir, "build/");
     QVERIFY(includeDirs.contains(buildDir));
 
     Path subBuildDir(sourceDir, "build/subdir/");
     QVERIFY(includeDirs.contains(subBuildDir));
 
     Path subDir(sourceDir, "subdir/");
     QVERIFY(includeDirs.contains(subDir));
 }
 
 void TestCMakeManager::testRelativePaths()
 {
     IProject* project = loadProject("relative_paths", "/out");
 
     Path codeCpp(project->path(), "../src/code.cpp");
     QVERIFY(QFile::exists( codeCpp.toLocalFile()));
     QList< ProjectBaseItem* > items = project->itemsForPath(IndexedString(codeCpp.pathOrUrl()));
     QEXPECT_FAIL("", "Will fix soon, hopefully", Abort);
     QCOMPARE(items.size(), 1); // once in the target
     ProjectBaseItem* fooCppItem = items.first();
 
     Path::List includeDirs = project->buildSystemManager()->includeDirectories(fooCppItem);
 
     Path incDir(project->path(), "../inc/");
     QVERIFY(includeDirs.contains( incDir ));
 }
 
 void TestCMakeManager::testTargetIncludePaths()
 {
     IProject* project = loadProject("target_includes");
 
     Path mainCpp(project->path(), "main.cpp");
     QVERIFY(QFile::exists(mainCpp.toLocalFile()));
     QList< ProjectBaseItem* > items = project->itemsForPath(IndexedString(mainCpp.pathOrUrl()));
     QEXPECT_FAIL("", "Will fix soon, hopefully", Continue);
     QCOMPARE(items.size(), 2); // once the plain file, once the target
 
     bool foundInTarget = false;
     foreach(ProjectBaseItem* mainCppItem, items) {
         ProjectBaseItem* mainContainer = mainCppItem->parent();
 
         Path::List includeDirs = project->buildSystemManager()->includeDirectories(mainCppItem);
 
         if (mainContainer->target()) {
             foundInTarget = true;
             Path targetIncludesDir(project->path(), "includes/");
             QVERIFY(includeDirs.contains(targetIncludesDir));
         }
     }
     QEXPECT_FAIL("", "Will fix soon, hopefully", Continue);
     QVERIFY(foundInTarget);
 }
 
 void TestCMakeManager::testTargetIncludeDirectories()
 {
     IProject* project = loadProject("target_include_directories");
 
     Path mainCpp(project->path(), "main.cpp");
     QVERIFY(QFile::exists(mainCpp.toLocalFile()));
     QList< ProjectBaseItem* > items = project->itemsForPath(IndexedString(mainCpp.pathOrUrl()));
     QEXPECT_FAIL("", "Will fix soon, hopefully", Continue);
     QCOMPARE(items.size(), 2); // once the plain file, once the target
 
     bool foundInTarget = false;
     foreach(ProjectBaseItem* mainCppItem, items) {
         ProjectBaseItem* mainContainer = mainCppItem->parent();
 
         Path::List includeDirs = project->buildSystemManager()->includeDirectories(mainCppItem);
 
         if (mainContainer->target()) {
             foundInTarget = true;
             QVERIFY(includeDirs.contains(Path(project->path(), "includes/")));
             QVERIFY(includeDirs.contains(Path(project->path(), "libincludes/")));
         }
     }
     QEXPECT_FAIL("", "files aren't being added to the target", Continue);
     QVERIFY(foundInTarget);
 }
 
 void TestCMakeManager::testQt5App()
 {
     IProject* project = loadProject("qt5_app");
 
     Path mainCpp(project->path(), "main.cpp");
     QVERIFY(QFile::exists(mainCpp.toLocalFile()));
     QList< ProjectBaseItem* > items = project->itemsForPath(IndexedString(mainCpp.pathOrUrl()));
     QEXPECT_FAIL("", "Will fix soon, hopefully", Continue);
     QCOMPARE(items.size(), 2); // once the plain file, once the target
 
     bool foundCore = false, foundGui = false, foundWidgets = false;
     foreach(ProjectBaseItem* mainCppItem, items) {
         Path::List includeDirs = project->buildSystemManager()->includeDirectories(mainCppItem);
         foreach(const Path& include, includeDirs) {
             QString filename = include.lastPathSegment();
             foundCore |= filename == "QtCore";
             foundGui |= filename == "QtGui";
             foundWidgets |= filename == "QtWidgets";
         }
     }
     QVERIFY(foundCore);
     QVERIFY(foundGui);
     QVERIFY(foundWidgets);
 }
 
 void TestCMakeManager::testQt5AppOld()
 {
     IProject* project = loadProject("qt5_app_old");
 
     Path mainCpp(project->path(), "main.cpp");
     QVERIFY(QFile::exists(mainCpp.toLocalFile()));
     QList< ProjectBaseItem* > items = project->itemsForPath(IndexedString(mainCpp.pathOrUrl()));
     QEXPECT_FAIL("", "Will fix soon, hopefully", Continue);
     QCOMPARE(items.size(), 2); // once the plain file, once the target
 
     bool foundCore = false, foundGui = false, foundWidgets = false;
     foreach(ProjectBaseItem* mainCppItem, items) {
         Path::List includeDirs = project->buildSystemManager()->includeDirectories(mainCppItem);
         foreach(const Path& include, includeDirs) {
             QString filename = include.lastPathSegment();
             foundCore |= filename == "QtCore";
             foundGui |= filename == "QtGui";
             foundWidgets |= filename == "QtWidgets";
         }
     }
     QVERIFY(foundCore);
     QVERIFY(foundGui);
     QVERIFY(foundWidgets);
 }
 
 void TestCMakeManager::testKF5App()
 {
     IProject* project = loadProject("kf5_app");
 
     Path mainCpp(project->path(), "main.cpp");
     QVERIFY(QFile::exists(mainCpp.toLocalFile()));
     QList< ProjectBaseItem* > items = project->itemsForPath(IndexedString(mainCpp.pathOrUrl()));
     QEXPECT_FAIL("", "Will fix soon, hopefully", Continue);
     QCOMPARE(items.size(), 2); // once the plain file, once the target
 
     bool foundCore = false, foundGui = false, foundWidgets = false, foundWidgetsAddons = false;
     foreach(ProjectBaseItem* mainCppItem, items) {
         Path::List includeDirs = project->buildSystemManager()->includeDirectories(mainCppItem);
         qDebug() << "xxxxxxxxx" << includeDirs;
         foreach(const Path& include, includeDirs) {
             QString filename = include.lastPathSegment();
             foundCore |= filename == "QtCore";
             foundGui |= filename == "QtGui";
             foundWidgets |= filename == "QtWidgets";
             foundWidgetsAddons |= filename == "KWidgetsAddons";
         }
     }
     QVERIFY(foundCore);
     QVERIFY(foundGui);
     QVERIFY(foundWidgets);
     QVERIFY(foundWidgetsAddons);
 }
 
 void TestCMakeManager::testDefines()
 {
     IProject* project = loadProject("defines");
 
     Path mainCpp(project->path(), "main.cpp");
     QVERIFY(QFile::exists(mainCpp.toLocalFile()));
     QList< ProjectBaseItem* > items = project->itemsForPath(IndexedString(mainCpp.pathOrUrl()));
     QEXPECT_FAIL("", "Will fix soon, hopefully", Continue);
     QCOMPARE(items.size(), 2); // once the plain file, once the target
 
     bool foundInTarget = false;
     foreach(ProjectBaseItem* mainCppItem, items) {
         QHash<QString, QString> defines = project->buildSystemManager()->defines(mainCppItem);
 
         QCOMPARE(defines.value("B", QStringLiteral("not found")), QString());
         QCOMPARE(defines.value("BV", QStringLiteral("not found")), QStringLiteral("1"));
         QCOMPARE(defines.value("BV2", QStringLiteral("not found")), QStringLiteral("2"));
 
 //         QCOMPARE(defines.value("BAR", QStringLiteral("not found")), QStringLiteral("foo"));
 //         QCOMPARE(defines.value("FOO", QStringLiteral("not found")), QStringLiteral("bar"));
 //         QCOMPARE(defines.value("BLA", QStringLiteral("not found")), QStringLiteral("blub"));
         QCOMPARE(defines.value("ASDF", QStringLiteral("not found")), QStringLiteral("asdf"));
         QCOMPARE(defines.value("XYZ", QStringLiteral("not found")), QString());
         QCOMPARE(defines.value("A", QStringLiteral("not found")), QString());
         QCOMPARE(defines.value("AV", QStringLiteral("not found")), QStringLiteral("1"));
         QCOMPARE(defines.value("AV2", QStringLiteral("not found")), QStringLiteral("2"));
         QCOMPARE(defines.value("C", QStringLiteral("not found")), QString());
         QCOMPARE(defines.value("CV", QStringLiteral("not found")), QStringLiteral("1"));
         QCOMPARE(defines.value("CV2", QStringLiteral("not found")), QStringLiteral("2"));
         QCOMPARE(defines.size(), 13);
         foundInTarget = true;
     }
     QVERIFY(foundInTarget);
 }
 
 void TestCMakeManager::testCustomTargetSources()
 {
     IProject* project = loadProject("custom_target_sources");
 
     QList<ProjectTargetItem*> targets = project->buildSystemManager()->targets(project->projectItem());
     QVERIFY(targets.size() == 1);
 
     QEXPECT_FAIL("", "Will fix soon, hopefully", Abort);
     ProjectTargetItem *target = targets.first();
     QCOMPARE(target->fileList().size(), 1);
     QCOMPARE(target->fileList().first()->baseName(), QStringLiteral("foo.cpp"));
 }
 
 void TestCMakeManager::testConditionsInSubdirectoryBasedOnRootVariables()
 {
     IProject* project = loadProject("conditions_in_subdirectory_based_on_root_variables");
 
     Path rootFooCpp(project->path(), "foo.cpp");
     QVERIFY(QFile::exists(rootFooCpp.toLocalFile()));
     QList< ProjectBaseItem* > rootFooItems = project->itemsForPath(IndexedString(rootFooCpp.pathOrUrl()));
     QEXPECT_FAIL("", "files aren't being added to the target", Continue);
     QCOMPARE(rootFooItems.size(), 4); // three items for the targets, one item for the plain file
 
     Path subdirectoryFooCpp(project->path(), "subdirectory/foo.cpp");
     QVERIFY(QFile::exists(subdirectoryFooCpp.toLocalFile()));
     QList< ProjectBaseItem* > subdirectoryFooItems = project->itemsForPath(IndexedString(subdirectoryFooCpp.pathOrUrl()));
 
     QEXPECT_FAIL("", "files aren't being added to the target", Continue);
     QCOMPARE(subdirectoryFooItems.size(), 4); // three items for the targets, one item for the plain file
 }
 
 void TestCMakeManager::testEnumerateTargets()
 {
     QString tempDir = QDir::tempPath();
 
     QTemporaryFile targetDirectoriesFile;
     QTemporaryDir subdir;
 
     auto opened = targetDirectoriesFile.open();
     QVERIFY(opened);
     QVERIFY(subdir.isValid());
 
     const QString targetDirectoriesContent = tempDir + "/CMakeFiles/first_target.dir\n" +
                                              tempDir + "/CMakeFiles/second_target.dir\r\n" +
                                              tempDir + "/" + subdir.path() + "/CMakeFiles/third_target.dir";
 
     targetDirectoriesFile.write(targetDirectoriesContent.toLatin1());
     targetDirectoriesFile.close();
 
     QHash<KDevelop::Path, QStringList> targets = 
         CMake::enumerateTargets(Path(targetDirectoriesFile.fileName()),
             tempDir, Path(tempDir));
 
     QCOMPARE(targets.value(Path(tempDir)).value(0), QStringLiteral("first_target"));
     QCOMPARE(targets.value(Path(tempDir)).value(1), QStringLiteral("second_target"));
     QCOMPARE(targets.value(Path(tempDir + "/" + subdir.path())).value(0), QStringLiteral("third_target"));
 }
 
 void TestCMakeManager::testFaultyTarget()
 {
     loadProject("faulty_target");
 }
 
 void TestCMakeManager::testParenthesesInTestArguments()
 {
     IProject* project = loadProject("parentheses_in_test_arguments");
 
     Path sourceDir = project->path();
     Path buildDir(sourceDir, "build/");
 
     auto job = new CMakeImportJsonJob(project, this);
     job->start();
 
 }
diff --git a/projectmanagers/cmake/tests/test_cmakemanager.h b/projectmanagers/cmake/tests/test_cmakemanager.h
index 9c374ee480..7e2adc1c86 100644
--- a/projectmanagers/cmake/tests/test_cmakemanager.h
+++ b/projectmanagers/cmake/tests/test_cmakemanager.h
@@ -1,57 +1,57 @@
 /* This file is part of KDevelop
     Copyright 2010 Esben Mose Hansen<kde@mosehansen.dk>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #ifndef TEST_CMAKEMANAGER_H
 #define TEST_CMAKEMANAGER_H
 
-#include <QtTest/QtTest>
+#include <QTest>
 
 namespace KDevelop {
 class IProject;
 }
 
 /**
  *  Test of the cmake manager.
  *   + Test that CMakeCache.txt is found, loaded and parsed
  * @author Esben Mose Hansen <kde@mosehansen.dk>
  **/
 class TestCMakeManager : public QObject {
     Q_OBJECT
 private slots:
     void initTestCase();
     void cleanupTestCase();
     void cleanup();
 
     void testWithBuildDirProject();
     void testIncludePaths();
     void testRelativePaths();
     void testTargetIncludeDirectories();
     void testTargetIncludePaths();
     void testDefines();
     void testCustomTargetSources();
     void testConditionsInSubdirectoryBasedOnRootVariables();
     void testQt5App();
     void testQt5AppOld();
     void testKF5App();
     void testEnumerateTargets();
     void testFaultyTarget();
     void testParenthesesInTestArguments();
 };
 
 #endif // TEST_CMAKEMANAGER_H
diff --git a/projectmanagers/cmake/tests/test_cmakeserver.cpp b/projectmanagers/cmake/tests/test_cmakeserver.cpp
index 7ee51b42ed..2a13a0c739 100644
--- a/projectmanagers/cmake/tests/test_cmakeserver.cpp
+++ b/projectmanagers/cmake/tests/test_cmakeserver.cpp
@@ -1,74 +1,76 @@
 /* KDevelop CMake Support
  *
  * Copyright 2017 Aleix Pol Gonzalez <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 <cmakeserver.h>
 #include "testhelpers.h"
-#include <QtTest>
+
+#include <QTest>
+#include <QJsonObject>
 
 using namespace KDevelop;
 
 class CMakeServerTest : public QObject
 {
     Q_OBJECT
 private slots:
     void testRun()
     {
         CMakeServer server(this);
         QSignalSpy spyConnected(&server, &CMakeServer::connected);
         QVERIFY(server.isServerAvailable() || spyConnected.wait());
 
         QSignalSpy spy(&server, &CMakeServer::response);
 
         QJsonObject codeModel;
         int errors = 0;
         connect(&server, &CMakeServer::response, this, [&errors, &codeModel, &server](const QJsonObject &response) {
             if (response.value("type") == QLatin1String("reply")) {
                 if (response.value("inReplyTo") == QLatin1String("configure"))
                     server.compute();
                 else if (response.value("inReplyTo") == QLatin1String("compute"))
                     server.codemodel();
                 else if(response.value("inReplyTo") == QLatin1String("codemodel"))
                     codeModel = response;
             } else if(response.value("type") == QLatin1String("error")) {
                 ++errors;
             }
         });
 
         const QString name = "single_subdirectory";
         const auto paths = projectPaths(name);
         const QString builddir = QStringLiteral(CMAKE_TESTS_BINARY_DIR "/cmake-server-test-builddir/") + name;
         QVERIFY(QDir(builddir).removeRecursively());
         QVERIFY(QDir(builddir).mkpath(builddir));
 
         QVERIFY(spy.wait());
         server.handshake(paths.sourceDir, Path(builddir));
         QVERIFY(spy.wait());
         server.configure({});
         while(codeModel.isEmpty())
             QVERIFY(spy.wait());
         QCOMPARE(errors, 0);
         QVERIFY(!codeModel.isEmpty());
         qDebug() << "codemodel" << codeModel;
     }
 };
 
 QTEST_MAIN( CMakeServerTest )
 
 #include "test_cmakeserver.moc"
diff --git a/projectmanagers/custom-buildsystem/configwidget.cpp b/projectmanagers/custom-buildsystem/configwidget.cpp
index 2c9865a3e8..3722004706 100644
--- a/projectmanagers/custom-buildsystem/configwidget.cpp
+++ b/projectmanagers/custom-buildsystem/configwidget.cpp
@@ -1,158 +1,155 @@
 /************************************************************************
  * KDevelop4 Custom Buildsystem Support                                 *
  *                                                                      *
  * Copyright 2010 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #include "configwidget.h"
 
-#include <QToolButton>
-#include <QLayout>
-
 #include <KLocalizedString>
 #include <KLineEdit>
 #include <QAction>
 
 #include "ui_configwidget.h"
 #include <interfaces/iproject.h>
 
 using namespace KDevelop;
 
 ConfigWidget::ConfigWidget( QWidget* parent )
     : QWidget ( parent ), ui( new Ui::ConfigWidget )
 {
     ui->setupUi( this );
 
     ui->buildAction->insertItem( CustomBuildSystemTool::Build, i18n("Build"), QVariant() );
     ui->buildAction->insertItem( CustomBuildSystemTool::Configure, i18n("Configure"), QVariant() );
     ui->buildAction->insertItem( CustomBuildSystemTool::Install, i18n("Install"), QVariant() );
     ui->buildAction->insertItem( CustomBuildSystemTool::Clean, i18n("Clean"), QVariant() );
     ui->buildAction->insertItem( CustomBuildSystemTool::Prune, i18n("Prune"), QVariant() );
 
     connect( ui->buildAction, static_cast<void(KComboBox::*)(int)>(&KComboBox::activated), this, &ConfigWidget::changeAction );
 
     connect( ui->enableAction, &QCheckBox::toggled, this, &ConfigWidget::toggleActionEnablement );
     connect( ui->actionArguments, &QLineEdit::textEdited, this, &ConfigWidget::actionArgumentsEdited );
     connect( ui->actionEnvironment, &EnvironmentSelectionWidget::currentProfileChanged, this, &ConfigWidget::actionEnvironmentChanged );
     connect( ui->buildDir, &KUrlRequester::urlSelected, this, static_cast<void(ConfigWidget::*)()>(&ConfigWidget::changed) );
     connect( ui->buildDir->lineEdit(), &KLineEdit::textEdited, this, static_cast<void(ConfigWidget::*)()>(&ConfigWidget::changed) );
     connect( ui->actionExecutable, &KUrlRequester::urlSelected, this, static_cast<void(ConfigWidget::*)(const QUrl&)>(&ConfigWidget::actionExecutableChanged) );
     connect( ui->actionExecutable->lineEdit(), &KLineEdit::textEdited, this, static_cast<void(ConfigWidget::*)(const QString&)>(&ConfigWidget::actionExecutableChanged) );
 }
 
 CustomBuildSystemConfig ConfigWidget::config() const
 {
     CustomBuildSystemConfig c;
     c.buildDir = ui->buildDir->url();
     c.tools = m_tools;
     return c;
 }
 
 void ConfigWidget::loadConfig( CustomBuildSystemConfig cfg )
 {
     bool b = blockSignals( true );
     clear();
     ui->buildDir->setUrl( cfg.buildDir );
     m_tools = cfg.tools;
     blockSignals( b );
     changeAction( ui->buildAction->currentIndex() );
     m_tools = cfg.tools;
 }
 
 void ConfigWidget::setTool(const CustomBuildSystemTool& tool)
 {
     bool b = ui->enableAction->blockSignals( true );
     ui->enableAction->setChecked( tool.enabled );
     ui->enableAction->blockSignals( b );
 
     ui->actionArguments->setText( tool.arguments );
     ui->actionArguments->setEnabled( tool.enabled );
     ui->actionExecutable->setUrl( tool.executable );
     ui->actionExecutable->setEnabled( tool.enabled );
     ui->actionEnvironment->setCurrentProfile( tool.envGrp );
     ui->actionEnvironment->setEnabled( tool.enabled );
     ui->execLabel->setEnabled( tool.enabled );
     ui->argLabel->setEnabled( tool.enabled );
     ui->envLabel->setEnabled( tool.enabled );
 }
 
 void ConfigWidget::changeAction( int idx )
 {
     if (idx < 0 || idx >= m_tools.count() ) {
         CustomBuildSystemTool emptyTool;
         emptyTool.type = CustomBuildSystemTool::Build;
         emptyTool.enabled = false;
         setTool(emptyTool);
     } else {
         // create copy to avoid crash, see https://bugs.kde.org/show_bug.cgi?id=335470
         const CustomBuildSystemTool selectedTool = m_tools[idx];
         setTool(selectedTool);
     }
 }
 
 void ConfigWidget::toggleActionEnablement( bool enable )
 {
     applyChange([=] (CustomBuildSystemTool* tool) {
         tool->enabled = enable;
     });
 }
 
 void ConfigWidget::actionArgumentsEdited( const QString& txt )
 {
     applyChange([=] (CustomBuildSystemTool* tool) {
         tool->arguments = txt;
     });
 }
 
 void ConfigWidget::actionEnvironmentChanged(const QString& profile)
 {
     applyChange([=] (CustomBuildSystemTool* tool) {
         tool->envGrp = profile;
     });
 }
 
 void ConfigWidget::actionExecutableChanged( const QUrl &url )
 {
     applyChange([=] (CustomBuildSystemTool* tool) {
         tool->executable = url;
     });
 }
 
 void ConfigWidget::actionExecutableChanged(const QString& txt )
 {
     applyChange([=] (CustomBuildSystemTool* tool) {
         tool->executable = QUrl::fromLocalFile(txt);
     });
 }
 
 void ConfigWidget::clear()
 {
     ui->buildAction->setCurrentIndex( int( CustomBuildSystemTool::Build ) );
     changeAction( ui->buildAction->currentIndex() );
     ui->buildDir->setText({});
 }
 
 template<typename F>
 void ConfigWidget::applyChange(F toolChanger)
 {
     const auto idx = ui->buildAction->currentIndex();
     if (idx < 0 || idx >= m_tools.count()) {
         // happens for the empty tool
         return;
     }
     toolChanger(&m_tools[idx]);
     emit changed();
 }
diff --git a/projectmanagers/custom-buildsystem/custombuildsystemconfig.h b/projectmanagers/custom-buildsystem/custombuildsystemconfig.h
index 8818283169..911987786f 100644
--- a/projectmanagers/custom-buildsystem/custombuildsystemconfig.h
+++ b/projectmanagers/custom-buildsystem/custombuildsystemconfig.h
@@ -1,62 +1,59 @@
 /************************************************************************
  * KDevelop4 Custom Buildsystem Support                                 *
  *                                                                      *
  * Copyright 2010 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #ifndef CUSTOMBUILDSYSTEMCONFIG_H
 #define CUSTOMBUILDSYSTEMCONFIG_H
 
-#include <QMap>
 #include <QVector>
-#include <QList>
-#include <QStringList>
 #include <QUrl>
 #include <QMetaType>
 
 struct CustomBuildSystemTool
 {
     enum ActionType { Build = 0, Configure, Install, Clean, Prune, Undefined };
     static QString toolName(ActionType type);
 
     CustomBuildSystemTool() : enabled( false ), type( Undefined ) {}
     bool enabled;
     QUrl executable;
     QString arguments;
     QString envGrp;
     ActionType type;
 };
 
 Q_DECLARE_METATYPE( CustomBuildSystemTool )
 
 struct CustomBuildSystemConfig
 {
     QString title;
     QUrl buildDir;
     QVector<CustomBuildSystemTool> tools;
 
     CustomBuildSystemConfig()
     {
         for (int i = CustomBuildSystemTool::Build; i < CustomBuildSystemTool::Undefined; ++i) {
             CustomBuildSystemTool tool;
             tool.type = CustomBuildSystemTool::ActionType(i);
             tool.enabled = false;
             tools << tool;
         }
     }
 };
 
 #endif
diff --git a/projectmanagers/custom-buildsystem/custombuildsystemplugin.cpp b/projectmanagers/custom-buildsystem/custombuildsystemplugin.cpp
index f74b29409c..ecc17bc44e 100644
--- a/projectmanagers/custom-buildsystem/custombuildsystemplugin.cpp
+++ b/projectmanagers/custom-buildsystem/custombuildsystemplugin.cpp
@@ -1,198 +1,197 @@
 /************************************************************************
  * KDevelop4 Custom Buildsystem Support                                 *
  *                                                                      *
  * Copyright 2010 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #include "custombuildsystemplugin.h"
 
 #include <KPluginFactory>
 #include <KLocalizedString>
-#include <KAboutData>
 
 #include <project/projectmodel.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include "configconstants.h"
 #include "kcm_custombuildsystem.h"
 #include "config.h"
 
 #include "custombuildjob.h"
 
 using KDevelop::ProjectTargetItem;
 using KDevelop::ProjectFolderItem;
 using KDevelop::ProjectBuildFolderItem;
 using KDevelop::ProjectBaseItem;
 using KDevelop::ProjectFileItem;
 using KDevelop::IPlugin;
 using KDevelop::ICore;
 using KDevelop::IOutputView;
 using KDevelop::IProjectFileManager;
 using KDevelop::IProjectBuilder;
 using KDevelop::IProject;
 using KDevelop::Path;
 
 K_PLUGIN_FACTORY_WITH_JSON(CustomBuildSystemFactory, "kdevcustombuildsystem.json", registerPlugin<CustomBuildSystem>(); )
 
 CustomBuildSystem::CustomBuildSystem( QObject *parent, const QVariantList & )
     : AbstractFileManagerPlugin( "kdevcustombuildsystem", parent )
 {
 }
 
 CustomBuildSystem::~CustomBuildSystem()
 {
 }
 
 bool CustomBuildSystem::addFilesToTarget( const QList<ProjectFileItem*>&, ProjectTargetItem* )
 {
     return false;
 }
 
 bool CustomBuildSystem::hasBuildInfo( ProjectBaseItem* ) const
 {
     return false;
 }
 
 KJob* CustomBuildSystem::build( ProjectBaseItem* dom )
 {
     return new CustomBuildJob( this, dom, CustomBuildSystemTool::Build );
 }
 
 Path CustomBuildSystem::buildDirectory( ProjectBaseItem*  item ) const
 {
     Path p;
     if( item->folder() ) {
         p = item->path();
     } else {
         ProjectBaseItem* parent = item;
         while( !parent->folder() ) {
             parent = parent->parent();
         }
         p = parent->path();
     }
     const QString relative = item->project()->path().relativePath(p);
     KConfigGroup grp = configuration( item->project() );
     if(!grp.isValid()) {
         return Path();
     }
 
     Path builddir(grp.readEntry(ConfigConstants::buildDirKey(), QUrl()));
     if(!builddir.isValid() )  // set builddir to default if project contains a buildDirKey that does not have a value
     {
         builddir = item->project()->path();
     }
     builddir.addPath( relative );
     return builddir;
 }
 
 IProjectBuilder* CustomBuildSystem::builder() const
 {
     return const_cast<IProjectBuilder*>(dynamic_cast<const IProjectBuilder*>(this));
 }
 
 KJob* CustomBuildSystem::clean( ProjectBaseItem* dom )
 {
     return new CustomBuildJob( this, dom, CustomBuildSystemTool::Clean );
 }
 
 KJob* CustomBuildSystem::configure( IProject* project )
 {
     return new CustomBuildJob( this, project->projectItem(), CustomBuildSystemTool::Configure );
 }
 
 ProjectTargetItem* CustomBuildSystem::createTarget( const QString&, ProjectFolderItem* )
 {
     return nullptr;
 }
 
 QHash<QString, QString> CustomBuildSystem::defines( ProjectBaseItem* ) const
 {
     return {};
 }
 
 IProjectFileManager::Features CustomBuildSystem::features() const
 {
     return IProjectFileManager::Files | IProjectFileManager::Folders;
 }
 
 ProjectFolderItem* CustomBuildSystem::createFolderItem( IProject* project,
                     const Path& path, ProjectBaseItem* parent )
 {
     return new ProjectBuildFolderItem( project, path, parent );
 }
 
 Path::List CustomBuildSystem::includeDirectories( ProjectBaseItem* ) const
 {
     return {};
 }
 
 Path::List CustomBuildSystem::frameworkDirectories( ProjectBaseItem* ) const
 {
     return {};
 }
 
 KJob* CustomBuildSystem::install( KDevelop::ProjectBaseItem* item, const QUrl &installPrefix )
 {
     auto job = new CustomBuildJob( this, item, CustomBuildSystemTool::Install );
     job->setInstallPrefix(installPrefix);
     return job;
 }
 
 KJob* CustomBuildSystem::prune( IProject* project )
 {
     return new CustomBuildJob( this, project->projectItem(), CustomBuildSystemTool::Prune );
 }
 
 bool CustomBuildSystem::removeFilesFromTargets( const QList<ProjectFileItem*>& )
 {
     return false;
 }
 
 bool CustomBuildSystem::removeTarget( ProjectTargetItem* )
 {
     return false;
 }
 
 QList<ProjectTargetItem*> CustomBuildSystem::targets( ProjectFolderItem* ) const
 {
     return QList<ProjectTargetItem*>();
 }
 
 KConfigGroup CustomBuildSystem::configuration( IProject* project ) const
 {
     KConfigGroup grp = project->projectConfiguration()->group(ConfigConstants::customBuildSystemGroup());
     if (grp.isValid() && grp.hasKey(ConfigConstants::currentConfigKey()))
         return grp.group(grp.readEntry(ConfigConstants::currentConfigKey()));
     else
         return KConfigGroup();
 }
 
 int CustomBuildSystem::perProjectConfigPages() const
 {
     return 1;
 }
 
 KDevelop::ConfigPage* CustomBuildSystem::perProjectConfigPage(int number, const KDevelop::ProjectConfigOptions& options, QWidget* parent)
 {
     if (number == 0) {
         return new CustomBuildSystemKCModule(this, options, parent);
     }
     return nullptr;
 }
 
 #include "custombuildsystemplugin.moc"
diff --git a/projectmanagers/custom-buildsystem/kcm_custombuildsystem.cpp b/projectmanagers/custom-buildsystem/kcm_custombuildsystem.cpp
index 19a33875c7..3c2aab6268 100644
--- a/projectmanagers/custom-buildsystem/kcm_custombuildsystem.cpp
+++ b/projectmanagers/custom-buildsystem/kcm_custombuildsystem.cpp
@@ -1,79 +1,77 @@
 /************************************************************************
  * KDevelop4 Custom Buildsystem Support                                 *
  *                                                                      *
  * Copyright 2010 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #include "kcm_custombuildsystem.h"
 
-#include <KPluginFactory>
-#include <KAboutData>
 #include <QVBoxLayout>
 
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 
 #include "custombuildsystemconfigwidget.h"
 
 CustomBuildSystemKCModule::CustomBuildSystemKCModule(KDevelop::IPlugin* plugin, const KDevelop::ProjectConfigOptions& options, QWidget* parent)
     : ProjectConfigPage<CustomBuildSystemSettings>(plugin, options, parent)
 {
     QVBoxLayout* layout = new QVBoxLayout( this );
     configWidget = new CustomBuildSystemConfigWidget( this );
     connect(configWidget, &CustomBuildSystemConfigWidget::changed, this, &ConfigPage::changed);
     layout->addWidget( configWidget );
 }
 
 CustomBuildSystemKCModule::~CustomBuildSystemKCModule()
 {
 }
 
 void CustomBuildSystemKCModule::reset()
 {
     ProjectConfigPage::reset();
     configWidget->loadFrom(CustomBuildSystemSettings::self()->config());
 }
 
 void CustomBuildSystemKCModule::apply()
 {
     configWidget->saveTo(CustomBuildSystemSettings::self()->config(), project());
     ProjectConfigPage::apply();
     if (KDevelop::IProjectController::parseAllProjectSources()) {
         KDevelop::ICore::self()->projectController()->reparseProject(project());
     }
 }
 
 void CustomBuildSystemKCModule::defaults()
 {
     ProjectConfigPage::defaults();
     configWidget->loadDefaults();
 }
 
 QString CustomBuildSystemKCModule::name() const
 {
     return i18n("Custom BuildSystem");
 }
 
 QString CustomBuildSystemKCModule::fullName() const
 {
     return i18n("Configure a projects custom build tool and includes/defines for the language support.");
 }
 
 QIcon CustomBuildSystemKCModule::icon() const
 {
     return QIcon::fromTheme("kdevelop");
 }
 
diff --git a/projectmanagers/custom-buildsystem/tests/kcmuitestmain.cpp b/projectmanagers/custom-buildsystem/tests/kcmuitestmain.cpp
index b0e07c7cf2..597e1767dd 100644
--- a/projectmanagers/custom-buildsystem/tests/kcmuitestmain.cpp
+++ b/projectmanagers/custom-buildsystem/tests/kcmuitestmain.cpp
@@ -1,144 +1,142 @@
 /************************************************************************
  * KDevelop4 Custom Buildsystem Support                                 *
  *                                                                      *
  * Copyright 2012 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #include <KLocalizedString>
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 #include <QTemporaryDir>
-#include <qfile.h>
-#include <qtextstream.h>
 #include <qdir.h>
 #include <QPushButton>
 #include <QStandardPaths>
 
 #include <tests/testproject.h>
 #include <QApplication>
 #include <KAboutData>
 #include <QCommandLineParser>
-#include <KConfigGroup>
+#include <KConfig>
 
 #include "custombuildsystemconfigwidget.h"
 #include "../debug.h"
 
 static const char description[] =
     I18N_NOOP("CustomBuildSystem Config Ui Test App");
 
 static const char version[] = "0.1";
 
 class State : public QObject
 {
 Q_OBJECT
 public:
     State( QDialogButtonBox* buttonBox, CustomBuildSystemConfigWidget* cfgWidget, KConfig* config, KDevelop::IProject* proj )
         : buttonBox(buttonBox), configWidget(cfgWidget), cfg(config), project(proj)
     {
         connect(buttonBox, &QDialogButtonBox::clicked, this, &State::buttonClicked);
         connect(configWidget, &CustomBuildSystemConfigWidget::changed, this, &State::configChanged);
     }
 public slots:
     void buttonClicked(QAbstractButton* button)
     {
         if (button == buttonBox->button(QDialogButtonBox::Apply)) {
             apply();
         } else if (button == buttonBox->button(QDialogButtonBox::Ok)) {
             ok();
         } else if (button == buttonBox->button(QDialogButtonBox::Cancel)) {
             qApp->quit();
         }
     }
 
     void apply() {
         configWidget->saveTo(cfg, project);
         buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
         buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
     }
     void ok() {
         apply();
         qApp->quit();
     }
     void configChanged() {
         buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
         buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
     }
 private:
     QDialogButtonBox* buttonBox;
     CustomBuildSystemConfigWidget* configWidget;
     KConfig* cfg;
     KDevelop::IProject* project;
 };
 
 int main(int argc, char **argv)
 {
     KAboutData aboutData("kcm_uitest", i18n("kcm_uitest"), version, i18n(description),
                      KAboutLicense::GPL, i18n("(C) 2012 Andreas Pakulat"));
     aboutData.addAuthor( i18n("Andreas Pakulat"), QString(), "apaku@gmx.de" );
     QApplication app(argc, argv);
     QCommandLineParser parser;
     KAboutData::setApplicationData(aboutData);
     parser.addVersionOption();
     parser.addHelpOption();
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     QTemporaryDir tempdir(QStandardPaths::writableLocation(QStandardPaths::TempLocation)+"/kdev-custom-uitest");
 
     qCDebug(CUSTOMBUILDSYSTEM) << "created tempdir:" << tempdir.path();
 
     KConfig projkcfg( tempdir.path() + "/kdev-custom-uitest.kdev4" );
 
     QDir projdir(tempdir.path());
     projdir.mkdir("includedir");
     projdir.mkdir("subtree");
     projdir.mkpath("subtree/includedir");
     projdir.mkpath("subtree/deeptree");
     projdir.mkpath("subtree/deeptree/includedir");
 
     qCDebug(CUSTOMBUILDSYSTEM) << "project config:" << projkcfg.name();
 
     QDialog dlg;
 
     QVBoxLayout mainLayout;
     dlg.setLayout(&mainLayout);
 
     KDevelop::TestProject proj;
     proj.setPath( KDevelop::Path(projkcfg.name()));
 
     CustomBuildSystemConfigWidget widget(nullptr);
     widget.loadFrom(&projkcfg);
     mainLayout.addWidget(&widget);
 
     dlg.setWindowTitle("Ui Test App for Config Widget");
 
     QDialogButtonBox buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Apply | QDialogButtonBox::Cancel);
     buttonBox.button(QDialogButtonBox::Apply)->setEnabled(false);
     buttonBox.button(QDialogButtonBox::Ok)->setEnabled(false);
 
     State state(&buttonBox, &widget, &projkcfg, &proj );
 
     dlg.resize(800, 600);
 
     dlg.show();
 
     return app.exec();
 
 }
 
 #include "kcmuitestmain.moc"
diff --git a/projectmanagers/custom-buildsystem/tests/test_custombuildsystemplugin.cpp b/projectmanagers/custom-buildsystem/tests/test_custombuildsystemplugin.cpp
index 711a1d6ebf..67585ed4a8 100644
--- a/projectmanagers/custom-buildsystem/tests/test_custombuildsystemplugin.cpp
+++ b/projectmanagers/custom-buildsystem/tests/test_custombuildsystemplugin.cpp
@@ -1,113 +1,112 @@
 /************************************************************************
  * KDevelop4 Custom Buildsystem Support                                 *
  *                                                                      *
  * Copyright 2010 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 or version 3 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, see <http://www.gnu.org/licenses/>. *
  ************************************************************************/
 
 #include "test_custombuildsystemplugin.h"
 
-#include <QtTest/QtTest>
+#include <QTest>
 #include <QDebug>
 
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <tests/kdevsignalspy.h>
 #include <shell/sessioncontroller.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/isession.h>
 #include <interfaces/iproject.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <project/projectmodel.h>
-#include <kconfiggroup.h>
 
 #include <serialization/indexedstring.h>
 
 #include "testconfig.h"
 
 using KDevelop::Core;
 using KDevelop::ICore;
 using KDevelop::IProject;
 using KDevelop::TestCore;
 using KDevelop::AutoTestShell;
 using KDevelop::KDevSignalSpy;
 using KDevelop::Path;
 
 QTEST_MAIN(TestCustomBuildSystemPlugin)
 
 void TestCustomBuildSystemPlugin::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 void TestCustomBuildSystemPlugin::initTestCase()
 {
     AutoTestShell::init({"kdevcustombuildsystem"});
     TestCore::initialize();
 }
 
 void TestCustomBuildSystemPlugin::loadSimpleProject()
 {
     QUrl projecturl = QUrl::fromLocalFile( PROJECTS_SOURCE_DIR"/simpleproject/simpleproject.kdev4" );
     KDevSignalSpy* projectSpy = new KDevSignalSpy( ICore::self()->projectController(), SIGNAL( projectOpened( KDevelop::IProject* ) ) );
     ICore::self()->projectController()->openProject( projecturl );
     // Wait for the project to be opened
     QVERIFY(projectSpy->wait(10000));
     IProject* project = ICore::self()->projectController()->findProjectByName( "SimpleProject" );
     QVERIFY( project );
 
     QCOMPARE( project->buildSystemManager()->buildDirectory( project->projectItem() ),
               Path( "file:///home/andreas/projects/testcustom/build/" ) );
 }
 
 void TestCustomBuildSystemPlugin::buildDirProject()
 {
     QUrl projecturl = QUrl::fromLocalFile( PROJECTS_SOURCE_DIR"/builddirproject/builddirproject.kdev4" );
     KDevSignalSpy* projectSpy = new KDevSignalSpy( ICore::self()->projectController(), SIGNAL( projectOpened( KDevelop::IProject* ) ) );
     ICore::self()->projectController()->openProject( projecturl );
     // Wait for the project to be opened
     QVERIFY(projectSpy->wait(10000));
     IProject* project = ICore::self()->projectController()->findProjectByName( "BuilddirProject" );
     QVERIFY( project );
 
     Path currentBuilddir = project->buildSystemManager()->buildDirectory( project->projectItem() );
 
     QCOMPARE( currentBuilddir, Path( projecturl ).parent() );
 }
 
 
 void TestCustomBuildSystemPlugin::loadMultiPathProject()
 {
     QUrl projecturl = QUrl::fromLocalFile( PROJECTS_SOURCE_DIR"/multipathproject/multipathproject.kdev4" );
     KDevSignalSpy* projectSpy = new KDevSignalSpy( ICore::self()->projectController(), SIGNAL( projectOpened( KDevelop::IProject* ) ) );
     ICore::self()->projectController()->openProject( projecturl );
     // Wait for the project to be opened
     QVERIFY(projectSpy->wait(10000));
     IProject* project = ICore::self()->projectController()->findProjectByName( "MultiPathProject" );
     QVERIFY( project );
     KDevelop::ProjectBaseItem* mainfile = nullptr;
     for (const auto& file: project->fileSet() ) {
         for (auto i: project->filesForPath(file)) {
             if( i->text() == "main.cpp" ) {
                 mainfile = i;
                 break;
             }
         }
     }
     QVERIFY(mainfile);
 
     QCOMPARE( project->buildSystemManager()->buildDirectory( mainfile ),
               Path( "file:///home/andreas/projects/testcustom/build2/src" ) );
 }
 
diff --git a/projectmanagers/custommake/custommakemanager.cpp b/projectmanagers/custommake/custommakemanager.cpp
index 196a57e264..015b133838 100644
--- a/projectmanagers/custommake/custommakemanager.cpp
+++ b/projectmanagers/custommake/custommakemanager.cpp
@@ -1,334 +1,327 @@
 /* KDevelop Custom Makefile Support
  *
  * Copyright 2007 Dukju Ahn <dukjuahn@gmail.com>
  * Copyright 2011 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) any later version.
  */
 
 #include "custommakemanager.h"
 #include "custommakemodelitems.h"
 #include <interfaces/icore.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include <makebuilder/imakebuilder.h>
 #include <kpluginfactory.h>
-#include <kaboutdata.h>
-#include <kpluginloader.h>
 #include <project/projectmodel.h>
 #include <project/helper.h>
 #include <serialization/indexedstring.h>
 
-#include <QDir>
-#include <QFileInfoList>
 #include <QFile>
-#include <QApplication>
 #include <QReadWriteLock>
 #include <QReadLocker>
 #include <QWriteLocker>
-#include <QUrl>
 #include <QLoggingCategory>
 Q_DECLARE_LOGGING_CATEGORY(CUSTOMMAKE)
 Q_LOGGING_CATEGORY(CUSTOMMAKE, "kdevelop.projectmanagers.custommake")
 
 #include <KLocalizedString>
-#include <KDirWatch>
 
 #include <algorithm>
 
 #include "../../languages/plugins/custom-definesandincludes/idefinesandincludesmanager.h"
 #include "makefileresolver/makefileresolver.h"
 
 using namespace KDevelop;
 
 class CustomMakeProvider : public IDefinesAndIncludesManager::BackgroundProvider
 {
 public:
     explicit CustomMakeProvider(CustomMakeManager* manager)
         : m_customMakeManager(manager)
         , m_resolver(new MakeFileResolver())
     {}
 
     // NOTE: Fixes build failures for GCC versions <4.8.
     // cf. https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53613
     ~CustomMakeProvider() Q_DECL_NOEXCEPT override;
 
     QHash< QString, QString > definesInBackground(const QString&) const override
     {
         return {};
     }
 
     Path::List resolvePathInBackground(const QString& path, const bool isFrameworks) const
     {
         {
             QReadLocker lock(&m_lock);
 
             bool inProject = std::any_of(m_customMakeManager->m_projectPaths.constBegin(), m_customMakeManager->m_projectPaths.constEnd(), [&path](const QString& projectPath)
             {
                 return path.startsWith(projectPath);
             } );
 
             if (!inProject) {
                 return {};
             }
         }
 
         if (isFrameworks) {
             return m_resolver->resolveIncludePath(path).frameworkDirectories;
         } else {
             return m_resolver->resolveIncludePath(path).paths;
         }
     }
 
     Path::List includesInBackground(const QString& path) const override
     {
         return resolvePathInBackground(path, false);
     }
 
     Path::List frameworkDirectoriesInBackground(const QString& path) const override
     {
         return resolvePathInBackground(path, true);
     }
 
     IDefinesAndIncludesManager::Type type() const override
     {
         return IDefinesAndIncludesManager::ProjectSpecific;
     }
 
     CustomMakeManager* m_customMakeManager;
     QScopedPointer<MakeFileResolver> m_resolver;
     mutable QReadWriteLock m_lock;
 };
 
 // NOTE: Fixes build failures for GCC versions <4.8.
 // See above.
 CustomMakeProvider::~CustomMakeProvider() Q_DECL_NOEXCEPT
 {}
 
 K_PLUGIN_FACTORY_WITH_JSON(CustomMakeSupportFactory, "kdevcustommakemanager.json", registerPlugin<CustomMakeManager>(); )
 
 CustomMakeManager::CustomMakeManager( QObject *parent, const QVariantList& args )
 : KDevelop::AbstractFileManagerPlugin( "kdevcustommakemanager", parent )
     , m_builder( nullptr )
     , m_provider(new CustomMakeProvider(this))
 {
     Q_UNUSED(args)
 
     setXMLFile( "kdevcustommakemanager.rc" );
 
     // TODO use CustomMakeBuilder
     IPlugin* i = core()->pluginController()->pluginForExtension( "org.kdevelop.IMakeBuilder" );
     Q_ASSERT(i);
     m_builder = i->extension<IMakeBuilder>();
     Q_ASSERT(m_builder);
 
     connect(this, &CustomMakeManager::reloadedFileItem,
             this, &CustomMakeManager::reloadMakefile);
 
     connect(ICore::self()->projectController(), &IProjectController::projectClosing,
             this, &CustomMakeManager::projectClosing);
 
 
     IDefinesAndIncludesManager::manager()->registerBackgroundProvider(m_provider.data());
 }
 
 CustomMakeManager::~CustomMakeManager()
 {
 }
 
 IProjectBuilder* CustomMakeManager::builder() const
 {
     Q_ASSERT(m_builder);
     return m_builder;
 }
 
 Path::List CustomMakeManager::includeDirectories(KDevelop::ProjectBaseItem*) const
 {
     return Path::List();
 }
 
 Path::List CustomMakeManager::frameworkDirectories(KDevelop::ProjectBaseItem*) const
 {
     return Path::List();
 }
 
 QHash<QString,QString> CustomMakeManager::defines(KDevelop::ProjectBaseItem*) const
 {
     return QHash<QString,QString>();
 }
 
 ProjectTargetItem* CustomMakeManager::createTarget(const QString& target, KDevelop::ProjectFolderItem *parent)
 {
     Q_UNUSED(target)
     Q_UNUSED(parent)
     return nullptr;
 }
 
 bool CustomMakeManager::addFilesToTarget(const QList< ProjectFileItem* > &files, ProjectTargetItem* parent)
 {
     Q_UNUSED( files )
     Q_UNUSED( parent )
     return false;
 }
 
 bool CustomMakeManager::removeTarget(KDevelop::ProjectTargetItem *target)
 {
     Q_UNUSED( target )
     return false;
 }
 
 bool CustomMakeManager::removeFilesFromTargets(const QList< ProjectFileItem* > &targetFiles)
 {
     Q_UNUSED( targetFiles )
     return false;
 }
 
 bool CustomMakeManager::hasBuildInfo(KDevelop::ProjectBaseItem* item) const
 {
     Q_UNUSED(item);
     return false;
 }
 
 Path CustomMakeManager::buildDirectory(KDevelop::ProjectBaseItem* item) const
 {
     ProjectFolderItem *fi=dynamic_cast<ProjectFolderItem*>(item);
     for(; !fi && item; )
     {
         item=item->parent();
         fi=dynamic_cast<ProjectFolderItem*>(item);
     }
     if(!fi) {
         return item->project()->path();
     }
     return fi->path();
 }
 
 QList<ProjectTargetItem*> CustomMakeManager::targets(KDevelop::ProjectFolderItem*) const
 {
     QList<ProjectTargetItem*> ret;
     return ret;
 }
 
 static bool isMakefile(const QString& fileName)
 {
     return  ( fileName == QLatin1String("Makefile")
         || fileName == QLatin1String("makefile")
         || fileName == QLatin1String("GNUmakefile")
         || fileName == QLatin1String("BSDmakefile") );
 }
 
 void CustomMakeManager::createTargetItems(IProject* project, const Path& path, ProjectBaseItem* parent)
 {
     Q_ASSERT(isMakefile(path.lastPathSegment()));
     foreach(const QString& target, parseCustomMakeFile( path ))
     {
         if (!isValid(Path(parent->path(), target), false, project)) {
             continue;
         }
         new CustomMakeTargetItem( project, target, parent );
     }
 }
 
 ProjectFileItem* CustomMakeManager::createFileItem(IProject* project, const Path& path, ProjectBaseItem* parent)
 {
     ProjectFileItem* item = new ProjectFileItem(project, path, parent);
     if (isMakefile(path.lastPathSegment())){
         createTargetItems(project, path, parent);
     }
     return item;
 }
 
 void CustomMakeManager::reloadMakefile(ProjectFileItem* file)
 {
     if( !isMakefile(file->path().lastPathSegment())){
         return;
     }
     ProjectBaseItem* parent = file->parent();
     // remove the items that are Makefile targets
     foreach(ProjectBaseItem* item, parent->children()){
         if (item->target()){
             delete item;
         }
     }
     // Recreate the targets.
     createTargetItems(parent->project(), file->path(), parent);
 }
 
 ProjectFolderItem* CustomMakeManager::createFolderItem(IProject* project, const Path& path, ProjectBaseItem* parent)
 {
     // TODO more faster algorithm. should determine whether this directory
     // contains makefile or not.
     return new KDevelop::ProjectBuildFolderItem( project, path, parent );
 }
 
 KDevelop::ProjectFolderItem* CustomMakeManager::import(KDevelop::IProject *project)
 {
     if( project->path().isRemote() )
     {
         //FIXME turn this into a real warning
         qCWarning(CUSTOMMAKE) << project->path() << "not a local file. Custom make support doesn't handle remote projects";
         return nullptr;
     }
 
     {
         QWriteLocker lock(&m_provider->m_lock);
         m_projectPaths.insert(project->path().path());
     }
 
     return AbstractFileManagerPlugin::import( project );
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // private slots
 
 ///TODO: move to background thread, probably best would be to use a proper ParseJob
 QStringList CustomMakeManager::parseCustomMakeFile( const Path &makefile )
 {
     if( !makefile.isValid() )
         return QStringList();
 
     QStringList ret; // the list of targets
     QFile f( makefile.toLocalFile() );
     if ( !f.open( QIODevice::ReadOnly | QIODevice::Text ) )
     {
         qCDebug(CUSTOMMAKE) << "could not open" << makefile;
         return ret;
     }
 
     QRegExp targetRe( "^ *([^\\t$.#]\\S+) *:?:(?!=).*$" );
     targetRe.setMinimal( true );
 
     QString str;
     QTextStream stream( &f );
     while ( !stream.atEnd() )
     {
         str = stream.readLine();
 
         if ( targetRe.indexIn( str ) != -1 )
         {
             QString tmpTarget = targetRe.cap( 1 ).simplified();
             if ( ! ret.contains( tmpTarget ) )
                 ret.append( tmpTarget );
         }
     }
     f.close();
     return ret;
 }
 
 void CustomMakeManager::projectClosing(IProject* project)
 {
     QWriteLocker lock(&m_provider->m_lock);
     m_projectPaths.remove(project->path().path());
 }
 
 void CustomMakeManager::unload()
 {
   IDefinesAndIncludesManager::manager()->unregisterBackgroundProvider(m_provider.data());
 }
 
 #include "custommakemanager.moc"
 
diff --git a/projectmanagers/custommake/makefileresolver/tests/test_custommake.cpp b/projectmanagers/custommake/makefileresolver/tests/test_custommake.cpp
index 87799f28ba..ae9eefaf14 100644
--- a/projectmanagers/custommake/makefileresolver/tests/test_custommake.cpp
+++ b/projectmanagers/custommake/makefileresolver/tests/test_custommake.cpp
@@ -1,123 +1,123 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2014 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * 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 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 "test_custommake.h"
 
 #include <QFile>
 #include <QTextStream>
 #include <QDebug>
 #include <QTemporaryDir>
 
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 
 #include "../makefileresolver.h"
 
-#include <QtTest>
+#include <QTest>
 
 using namespace KDevelop;
 
 namespace {
 void createFile( QFile& file )
 {
     file.remove();
     if ( !file.open( QIODevice::ReadWrite ) ) {
         qFatal("Cannot create the file %s", file.fileName().toUtf8().data());
     }
 }
 }
 
 void TestCustomMake::initTestCase()
 {
     AutoTestShell::init();
     TestCore::initialize(Core::NoUi);
 }
 
 void TestCustomMake::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestCustomMake::testIncludeDirectories()
 {
     QTemporaryDir tempDir;
     {
         QFile file( tempDir.path() + "/Makefile" );
         createFile( file );
         QFile testfile( tempDir.path() + "/testfile.cpp" );
         createFile(testfile);
         QTextStream stream1( &file );
         stream1 << "testfile.o:\n\t g++ testfile.cpp -I/testFile1 -I /testFile2 -isystem /testFile3 --include-dir=/testFile4 -o testfile";
     }
 
     MakeFileResolver mf;
     auto result = mf.resolveIncludePath(tempDir.path() + "/testfile.cpp");
     if (!result.success) {
       qDebug() << result.errorMessage << result.longErrorMessage;
       QFAIL("Failed to resolve include path.");
     }
     QCOMPARE(result.paths.size(), 4);
     QVERIFY(result.paths.contains(Path("/testFile1")));
     QVERIFY(result.paths.contains(Path("/testFile2")));
     QVERIFY(result.paths.contains(Path("/testFile3")));
     QVERIFY(result.paths.contains(Path("/testFile4")));
 }
 
 void TestCustomMake::testFrameworkDirectories()
 {
     QTemporaryDir tempDir;
     int expectedPaths = 2;
     {
         QFile file( tempDir.path() + "/Makefile" );
         createFile( file );
         QFile testfile( tempDir.path() + "/testfile.cpp" );
         createFile(testfile);
         QTextStream stream1( &file );
         stream1 << "testfile.o:\n\t clang++ testfile.cpp -iframework /System/Library/Frameworks -F/Library/Frameworks -o testfile";
     }
 
     MakeFileResolver mf;
     auto result = mf.resolveIncludePath(tempDir.path() + "/testfile.cpp");
     if (!result.success) {
       qDebug() << result.errorMessage << result.longErrorMessage;
       QFAIL("Failed to resolve include path.");
     }
     QCOMPARE(result.frameworkDirectories.size(), expectedPaths);
     QVERIFY(result.frameworkDirectories.contains(Path("/System/Library/Frameworks")));
     QVERIFY(result.frameworkDirectories.contains(Path("/Library/Frameworks")));
 }
 
 void TestCustomMake::testDefines()
 {
     MakeFileResolver mf;
     const auto result = mf.processOutput("-DFOO  -DFOO=\\\"foo\\\" -DBAR=ASDF -DLALA=1 -DMEH="
                                          " -DSTR=\"\\\"foo \\\\\\\" bar\\\"\" -DEND", QString());
     QCOMPARE(result.defines.value("FOO", "not found"), QString("\"foo\""));
     QCOMPARE(result.defines.value("BAR", "not found"), QString("ASDF"));
     QCOMPARE(result.defines.value("LALA", "not found"), QString("1"));
     QCOMPARE(result.defines.value("MEH", "not found"), QString());
     QCOMPARE(result.defines.value("STR", "not found"), QString("\"foo \\\" bar\""));
     QCOMPARE(result.defines.value("END", "not found"), QString());
 }
 
 QTEST_GUILESS_MAIN(TestCustomMake)
 
 #include "moc_test_custommake.cpp"
diff --git a/projectmanagers/qmake/parser/buildastvisitor.cpp b/projectmanagers/qmake/parser/buildastvisitor.cpp
index a20e1582bf..fba26dda7d 100644
--- a/projectmanagers/qmake/parser/buildastvisitor.cpp
+++ b/projectmanagers/qmake/parser/buildastvisitor.cpp
@@ -1,294 +1,293 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright 2007 Andreas Pakulat <apaku@gmx.de>                         *
  *                                                                         *
  *   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.         *
  ***************************************************************************/
 
 #include "buildastvisitor.h"
 
 #include "qmakeast.h"
 #include "qmakeparser.h"
 #include "ast.h"
 
-#include <QtCore/QPair>
 #include <QDebug>
 
 #include "../debug.h"
 
 namespace QMake {
 
 void setIdentifierForStatement(StatementAST* stmt, ValueAST* val)
 {
     if (OrAST* orop = dynamic_cast<OrAST*>(stmt)) {
         setIdentifierForStatement(orop->scopes.at(0), val);
     } else if (AssignmentAST* assign = dynamic_cast<AssignmentAST*>(stmt)) {
         assign->identifier = val;
     } else if (FunctionCallAST* funcall = dynamic_cast<FunctionCallAST*>(stmt)) {
         funcall->identifier = val;
     } else if (SimpleScopeAST* simple = dynamic_cast<SimpleScopeAST*>(stmt)) {
         simple->identifier = val;
     }
 }
 
 BuildASTVisitor::BuildASTVisitor(Parser* parser, ProjectAST* project)
     : m_parser(parser)
 {
     aststack.push(project);
 }
 
 BuildASTVisitor::~BuildASTVisitor()
 {
     aststack.clear();
     m_parser = nullptr;
 }
 
 void BuildASTVisitor::visitArgumentList(ArgumentListAst* node)
 {
     // Nothing to be done here as we just need to iterate through the items
     DefaultVisitor::visitArgumentList(node);
 }
 
 void BuildASTVisitor::visitFunctionArguments(FunctionArgumentsAst* node)
 {
     // Nothing to be done here as we just need to iterate through the items
     DefaultVisitor::visitFunctionArguments(node);
 }
 
 void BuildASTVisitor::visitOrOperator(OrOperatorAst* node)
 {
     // Nothing to be done here as we just need to iterate through the items
     DefaultVisitor::visitOrOperator(node);
 }
 
 void BuildASTVisitor::visitItem(ItemAst* node)
 {
     if (node->functionArguments) {
         FunctionCallAST* call = createAst<FunctionCallAST>(node, aststack.top());
         ValueAST* val = createAst<ValueAST>(node, call);
         val->value = getTokenString(node->id);
         setPositionForToken(node->id, val);
         call->identifier = val;
         OrAST* orast = stackTop<OrAST>();
         orast->scopes.append(call);
         aststack.push(call);
         DefaultVisitor::visitItem(node);
         aststack.pop();
     } else {
         SimpleScopeAST* simple = createAst<SimpleScopeAST>(node, aststack.top());
         ValueAST* val = createAst<ValueAST>(node, simple);
         val->value = getTokenString(node->id);
         setPositionForToken(node->id, val);
         simple->identifier = val;
         OrAST* orast = stackTop<OrAST>();
         orast->scopes.append(simple);
         DefaultVisitor::visitItem(node);
     }
 }
 
 void BuildASTVisitor::visitScope(ScopeAst* node)
 {
     if (node->orOperator) {
         OrAST* orast = createAst<OrAST>(node, aststack.top());
         // qCDebug(KDEV_QMAKE) << "created orast:" << orast;
         if (node->functionArguments) {
             FunctionCallAST* ast = createAst<FunctionCallAST>(node, orast);
             aststack.push(ast);
             // qCDebug(KDEV_QMAKE) << "creating function call as first or-op" << ast;
             visitNode(node->functionArguments);
             // qCDebug(KDEV_QMAKE) << "function call done";
             aststack.pop();
             orast->scopes.append(ast);
         } else {
             SimpleScopeAST* simple = createAst<SimpleScopeAST>(node, orast);
             // qCDebug(KDEV_QMAKE) << "creating simple scope as first or-op";
             orast->scopes.append(simple);
         }
         aststack.push(orast);
         visitNode(node->orOperator);
     } else {
         if (node->functionArguments) {
             FunctionCallAST* call = createAst<FunctionCallAST>(node, aststack.top());
             aststack.push(call);
             visitNode(node->functionArguments);
         } else {
             SimpleScopeAST* simple = createAst<SimpleScopeAST>(node, aststack.top());
             aststack.push(simple);
         }
     }
     if (node->scopeBody) {
         ScopeBodyAST* scopebody = createAst<ScopeBodyAST>(node, aststack.top());
         ScopeAST* scope = stackTop<ScopeAST>();
         scope->body = scopebody;
         aststack.push(scopebody);
         visitNode(node->scopeBody);
         aststack.pop();
     }
 }
 
 void BuildASTVisitor::visitOp(OpAst* node)
 {
     AssignmentAST* assign = stackTop<AssignmentAST>();
     ValueAST* val = createAst<ValueAST>(node, assign);
     val->value = getTokenString(node->optoken);
     setPositionForToken(node->optoken, val);
     assign->op = val;
     DefaultVisitor::visitOp(node);
 }
 
 void BuildASTVisitor::visitProject(ProjectAst* node)
 {
     DefaultVisitor::visitProject(node);
 }
 
 void BuildASTVisitor::visitScopeBody(ScopeBodyAst* node)
 {
     DefaultVisitor::visitScopeBody(node);
 }
 
 void BuildASTVisitor::visitStatement(StatementAst* node)
 {
     DefaultVisitor::visitStatement(node);
     if (!node->isNewline) {
         StatementAST* stmt = stackPop<StatementAST>();
         // qCDebug(KDEV_QMAKE) << "got statement ast, setting value" << stmt;
         ValueAST* val = createAst<ValueAST>(node, stmt);
         // qCDebug(KDEV_QMAKE) << "created value ast:" << val;
         val->value = getTokenString(node->id);
         // qCDebug(KDEV_QMAKE) << "set value" << val << val->value;
         setPositionForToken(node->id, val);
         if (node->isExclam) {
             // qCDebug(KDEV_QMAKE) << "found exclam";
             val->value = '!' + val->value;
         }
         setIdentifierForStatement(stmt, val);
 
         ScopeBodyAST* scope = stackTop<ScopeBodyAST>();
         //         qCDebug(KDEV_QMAKE) << "scope:" << scope;
         scope->statements.append(stmt);
     }
 }
 
 void BuildASTVisitor::visitValue(ValueAst* node)
 {
     AssignmentAST* assign = dynamic_cast<AssignmentAST*>(aststack.top());
     if (assign) {
         ValueAST* value = createAst<ValueAST>(node, assign);
         value->value = getTokenString(node->value);
         assign->values.append(value);
     } else {
         FunctionCallAST* call = stackTop<FunctionCallAST>();
         ValueAST* value = createAst<ValueAST>(node, call);
         value->value = getTokenString(node->value);
         setPositionForToken(node->value, value);
         call->args.append(value);
     }
     DefaultVisitor::visitValue(node);
 }
 
 void BuildASTVisitor::visitValueList(ValueListAst* node)
 {
     DefaultVisitor::visitValueList(node);
 }
 
 void BuildASTVisitor::visitVariableAssignment(VariableAssignmentAst* node)
 {
     AssignmentAST* assign = createAst<AssignmentAST>(node, aststack.top());
     aststack.push(assign);
     DefaultVisitor::visitVariableAssignment(node);
 }
 
 template <typename T>
 T* BuildASTVisitor::createAst(AstNode* node, AST* parent)
 {
     if (!node) {
         return nullptr;
     }
     auto ast = new T(parent);
     setPositionForAst(node, ast);
     return ast;
 }
 
 template <typename T>
 T* BuildASTVisitor::stackTop()
 {
     if (aststack.isEmpty()) {
         qCDebug(KDEV_QMAKE);
         qCCritical(KDEV_QMAKE) << "ERROR: AST stack is empty, this should never happen";
         exit(255);
     }
     T* ast = dynamic_cast<T*>(aststack.top());
     if (!ast) {
         qCDebug(KDEV_QMAKE);
         qCCritical(KDEV_QMAKE) << "ERROR: AST stack is screwed, doing a hard exit" << aststack.top()->type;
         exit(255);
     }
     return ast;
 }
 
 template <typename T>
 T* BuildASTVisitor::stackPop()
 {
     if (aststack.isEmpty()) {
         qCDebug(KDEV_QMAKE);
         qCCritical(KDEV_QMAKE) << "ERROR: AST stack is empty, this should never happen";
         exit(255);
     }
     AST* tmp = aststack.pop();
     T* ast = dynamic_cast<T*>(tmp);
     if (!ast) {
         qCDebug(KDEV_QMAKE);
         qCCritical(KDEV_QMAKE) << "ERROR: AST stack is screwed, doing a hard exit" << tmp->type;
         exit(255);
     }
     return ast;
 }
 
 QString BuildASTVisitor::getTokenString(qint64 idx)
 {
     QMake::Parser::Token token = m_parser->tokenStream->at(idx);
     return m_parser->tokenText(token.begin, token.end).replace('\n', "\\n");
 }
 
 void BuildASTVisitor::setPositionForAst(AstNode* node, AST* ast)
 {
     qint64 line, col;
     m_parser->tokenStream->startPosition(node->startToken, &line, &col);
     ast->startLine = line;
     ast->startColumn = col;
     QMake::Parser::Token tok = m_parser->tokenStream->at(node->startToken);
     ast->start = tok.begin;
     m_parser->tokenStream->endPosition(node->endToken, &line, &col);
     ast->endLine = line;
     ast->endColumn = col;
     tok = m_parser->tokenStream->at(node->endToken);
     ast->end = tok.end;
 }
 
 void BuildASTVisitor::setPositionForToken(qint64 idx, ValueAST* ast)
 {
     qint64 line, col;
     QMake::Parser::Token token = m_parser->tokenStream->at(idx);
     m_parser->tokenStream->startPosition(idx, &line, &col);
     ast->startLine = line;
     ast->startColumn = col;
     ast->start = token.begin;
     ast->end = token.end;
     m_parser->tokenStream->endPosition(idx, &line, &col);
     ast->endLine = line;
     ast->endColumn = col;
 }
 }
diff --git a/projectmanagers/qmake/parser/qmakeast.cpp b/projectmanagers/qmake/parser/qmakeast.cpp
index b6a9ca7b12..0a9ee098e5 100644
--- a/projectmanagers/qmake/parser/qmakeast.cpp
+++ b/projectmanagers/qmake/parser/qmakeast.cpp
@@ -1,138 +1,139 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006 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 "ast.h"
 
 namespace QMake {
 
 AST::AST(AST* parent, AST::Type type)
     : type(type)
     , startLine(-1)
     , endLine(-1)
     , startColumn(-1)
     , endColumn(-1)
     , start(-1)
     , end(-1)
     , parent(parent)
 {
 }
 
 AST::~AST()
 {
 }
 
 ValueAST::ValueAST(AST* parent)
     : AST(parent, AST::Value)
 {
 }
 
 StatementAST::StatementAST(AST* parent, AST::Type type)
     : AST(parent, type)
 {
 }
 
 StatementAST::~StatementAST()
 {
 }
 
 AssignmentAST::AssignmentAST(AST* parent)
     : StatementAST(parent, AST::Assignment)
     , identifier(nullptr)
+    , op(nullptr)
 {
 }
 
 AssignmentAST::~AssignmentAST()
 {
     delete identifier;
     identifier = nullptr;
     qDeleteAll(values);
     values.clear();
     delete op;
 }
 
 ScopeBodyAST::ScopeBodyAST(AST* parent, AST::Type type)
     : AST(parent, type)
 {
 }
 
 ScopeBodyAST::~ScopeBodyAST()
 {
     qDeleteAll(statements);
     statements.clear();
 }
 
 FunctionCallAST::FunctionCallAST(AST* parent)
     : ScopeAST(parent, AST::FunctionCall)
     , identifier(nullptr)
 {
 }
 
 FunctionCallAST::~FunctionCallAST()
 {
     delete identifier;
     identifier = nullptr;
     qDeleteAll(args);
     args.clear();
 }
 
 OrAST::OrAST(AST* parent)
     : ScopeAST(parent, AST::Or)
 {
 }
 
 OrAST::~OrAST()
 {
     qDeleteAll(scopes);
     scopes.clear();
 }
 
 ProjectAST::ProjectAST()
     : ScopeBodyAST(nullptr, AST::Project)
 {
 }
 
 ProjectAST::~ProjectAST()
 {
 }
 
 ScopeAST::ScopeAST(AST* parent, AST::Type type)
     : StatementAST(parent, type)
     , body(nullptr)
 {
 }
 
 ScopeAST::~ScopeAST()
 {
     delete body;
     body = nullptr;
 }
 
 SimpleScopeAST::SimpleScopeAST(AST* parent)
     : ScopeAST(parent, AST::SimpleScope)
     , identifier(nullptr)
 {
 }
 
 SimpleScopeAST::~SimpleScopeAST()
 {
     delete identifier;
     identifier = nullptr;
 }
 }
diff --git a/projectmanagers/qmake/parser/qmakelexer.cpp b/projectmanagers/qmake/parser/qmakelexer.cpp
index af7749645d..db2954e533 100644
--- a/projectmanagers/qmake/parser/qmakelexer.cpp
+++ b/projectmanagers/qmake/parser/qmakelexer.cpp
@@ -1,344 +1,342 @@
 /* KDevelop QMake Support
  *
  * Copyright 2007 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 "qmakelexer.h"
 
 #include <QtCore/QString>
-#include <QtCore/QStringList>
-#include <QtCore/QRegExp>
 #include <QtCore/QDebug>
 #include "qmakeparser.h"
 #include <kdev-pg-location-table.h>
 #include <kdev-pg-token-stream.h>
 
 namespace QMake {
 
 bool isIdentifierCharacter(QChar* c, bool canLookAhead)
 {
     return (c->isLetter() || c->isDigit() || c->unicode() == '_' || c->unicode() == '.' || c->unicode() == '-'
             || c->unicode() == '$' || c->unicode() == '*'
             || (canLookAhead && (c + 1)->unicode() != '=' && (c->unicode() == '+')));
 }
 
 bool isBeginIdentifierCharacter(QChar* c)
 {
     return (c->isLetter() || c->isDigit() || c->unicode() == '_' || c->unicode() == '.' || c->unicode() == '$');
 }
 
 bool isEndIdentifierCharacter(QChar* c)
 {
     return (c->isLetter() || c->isDigit() || c->unicode() == '_' || c->unicode() == '.' || c->unicode() == '$'
             || c->unicode() == '*');
 }
 
 bool isCont(QChar* c)
 {
     if (c->unicode() == '\\') {
         c++;
         while (c->isSpace() && c->unicode() != '\n') {
             c++;
         }
         if (c->unicode() == '\n' || c->unicode() == '#') {
             return true;
         }
     }
     return false;
 }
 
 Lexer::Lexer(Parser* _parser, QString content)
     : m_content(std::move(content))
     , m_parser(_parser)
     , m_curpos(0)
     , m_contentSize(m_content.size())
     , m_tokenBegin(0)
     , m_tokenEnd(0)
 {
     pushState(ErrorState);
     pushState(DefaultState);
 }
 
 int Lexer::state() const
 {
     return mState.top();
 }
 
 void Lexer::pushState(int state)
 {
     mState.push(state);
 }
 
 void Lexer::popState()
 {
     mState.pop();
 }
 
 int Lexer::nextTokenKind()
 {
     int token = Parser::Token_INVALID;
     if (m_curpos >= m_contentSize) {
         return 0;
     }
     QChar* it = m_content.data();
     it += m_curpos;
     switch (state()) {
     case VariableValueState:
         it = ignoreWhitespaceAndComment(it);
         m_tokenBegin = m_curpos;
         if (m_curpos < m_contentSize) {
             if (it->unicode() == '\n') {
                 popState();
                 createNewline(m_curpos);
                 token = Parser::Token_NEWLINE;
             } else if (it->unicode() == '\\' && isCont(it))
 
             {
                 pushState(ContState);
                 token = Parser::Token_CONT;
             } else if (it->unicode() == '"') {
                 it++;
                 m_curpos++;
                 QChar* lastit = it;
                 while ((it->unicode() != '"' || (lastit->unicode() == '\\' && it->unicode() == '"'))
                        && it->unicode() != '\n' && it->unicode() != '#' && !isCont(it) && m_curpos < m_contentSize) {
                     lastit = it;
                     it++;
                     m_curpos++;
                 }
                 if (it->unicode() != '"' && it->unicode() != '#') {
                     m_curpos--;
                 }
                 token = Parser::Token_VALUE;
                 if (it->unicode() == '#') {
                     m_tokenEnd = m_curpos - 1;
                     do {
                         it++;
                         m_curpos++;
                     } while (it->unicode() != '\n' && m_curpos < m_contentSize);
                     if (it->unicode() == '\n') {
                         m_curpos--;
                     }
                     return token;
                 }
             } else if (it->unicode() == '(') {
                 unsigned int bracecount = 0;
                 while ((it->unicode() != ';' || bracecount > 0) && it->unicode() != '\n' && !isCont(it)
                        && m_curpos < m_contentSize) {
                     if (it->unicode() == '(') {
                         bracecount++;
                     } else if (it->unicode() == ')' && bracecount > 0) {
                         bracecount--;
                     }
                     ++it;
                     ++m_curpos;
                 }
                 if (it->unicode() != ';') {
                     m_curpos--;
                 }
                 token = Parser::Token_VALUE;
             } else {
                 while (!it->isSpace() && !isCont(it) && it->unicode() != '#' && m_curpos < m_contentSize) {
                     it++;
                     m_curpos++;
                 }
                 m_curpos--;
                 token = Parser::Token_VALUE;
             }
         }
         break;
     case FunctionArgState:
         m_tokenBegin = m_curpos;
         if (it->unicode() == '\n') {
             createNewline(m_curpos);
             token = Parser::Token_NEWLINE;
         } else if (it->unicode() == '\\' && isCont(it)) {
             pushState(ContState);
             token = Parser::Token_CONT;
         } else if (it->unicode() == ',') {
             token = Parser::Token_COMMA;
         } else if (it->unicode() == ')') {
             popState();
             token = Parser::Token_RPAREN;
         } else {
             unsigned int parentCount = 0;
             while (parentCount > 0 || (it->unicode() != ')' && it->unicode() != ',' && m_curpos < m_contentSize)) {
                 if (it->unicode() == ')') {
                     parentCount--;
                 } else if (it->unicode() == '(') {
                     parentCount++;
                 }
                 ++it;
                 ++m_curpos;
             }
             m_curpos--;
             token = Parser::Token_VALUE;
         }
         break;
     case ContState:
         it = ignoreWhitespaceAndComment(it);
         m_tokenBegin = m_curpos;
         if (m_curpos < m_contentSize) {
             if (it->unicode() == '\n') {
                 createNewline(m_curpos);
                 token = Parser::Token_NEWLINE;
                 m_tokenEnd = m_curpos;
                 popState();
                 QChar* temp = it;
                 int newpos = m_curpos;
                 do {
                     temp++;
                     newpos++;
                     if (temp->unicode() == '#') {
                         while (temp->unicode() != '\n' && newpos < m_contentSize) {
                             temp++;
                             newpos++;
                         }
                         createNewline(m_curpos);
                         temp++;
                         m_curpos = newpos;
                         newpos++;
                     }
                 } while (m_curpos < m_contentSize && temp->isSpace() && temp->unicode() != '\n');
                 m_curpos++;
                 return token;
             }
         }
         break;
     case DefaultState:
         it = ignoreWhitespaceAndComment(it);
         m_tokenBegin = m_curpos;
         if (m_curpos < m_contentSize) {
             if (isBeginIdentifierCharacter(it)) {
                 token = Parser::Token_IDENTIFIER;
                 while (!it->isSpace() && isIdentifierCharacter(it, m_curpos + 1 < m_contentSize)
                        && m_curpos < m_contentSize) {
                     it++;
                     m_curpos++;
                 }
                 if (!isEndIdentifierCharacter((it - 1))) {
                     token = Parser::Token_INVALID;
                 }
                 m_curpos--;
             } else {
                 // Now the stuff that will generate a proper token
                 QChar* c2 = m_curpos < m_contentSize ? it + 1 : nullptr;
                 switch (it->unicode()) {
                 case '|':
                     token = Parser::Token_OR;
                     break;
                 case '!':
                     token = Parser::Token_EXCLAM;
                     break;
                 case '(':
                     pushState(FunctionArgState);
                     token = Parser::Token_LPAREN;
                     break;
                 case '{':
                     token = Parser::Token_LBRACE;
                     break;
                 case '}':
                     token = Parser::Token_RBRACE;
                     break;
                 case ':':
                     token = Parser::Token_COLON;
                     break;
                 case '~':
                     if (c2 && c2->unicode() == '=') {
                         pushState(VariableValueState);
                         m_curpos++;
                         token = Parser::Token_TILDEEQ;
                     }
                     break;
                 case '*':
                     if (c2 && c2->unicode() == '=') {
                         pushState(VariableValueState);
                         m_curpos++;
                         token = Parser::Token_STAREQ;
                     }
                     break;
                 case '-':
                     if (c2 && c2->unicode() == '=') {
                         pushState(VariableValueState);
                         m_curpos++;
                         token = Parser::Token_MINUSEQ;
                     }
                     break;
                 case '+':
                     if (c2 && c2->unicode() == '=') {
                         pushState(VariableValueState);
                         m_curpos++;
                         token = Parser::Token_PLUSEQ;
                     }
                     break;
                 case '=':
                     pushState(VariableValueState);
                     token = Parser::Token_EQUAL;
                     break;
                 case '\n':
                     createNewline(m_curpos);
                     token = Parser::Token_NEWLINE;
                     break;
                 default:
                     break;
                 }
             }
         }
         break;
     default:
         token = Parser::Token_INVALID;
         break;
     }
     if (m_curpos >= m_contentSize) {
         return 0;
     }
     m_tokenEnd = m_curpos;
     m_curpos++;
     return token;
 }
 
 qint64 Lexer::tokenBegin() const
 {
     return m_tokenBegin;
 }
 
 qint64 Lexer::tokenEnd() const
 {
     return m_tokenEnd;
 }
 
 QChar* Lexer::ignoreWhitespaceAndComment(QChar* it)
 {
     // Ignore whitespace, but preserve the newline
     bool comment = false;
     while (m_curpos < m_contentSize && (it->isSpace() || comment || it->unicode() == '#') && it->unicode() != '\n') {
         if (it->unicode() == '#') {
             comment = true;
         }
         ++it;
         ++m_curpos;
     }
     return it;
 }
 
 void Lexer::createNewline(int pos)
 {
     if (m_parser)
         m_parser->tokenStream->locationTable()->newline(pos);
 }
 }
diff --git a/projectmanagers/qmake/parser/tests/assignmenttest.h b/projectmanagers/qmake/parser/tests/assignmenttest.h
index 0bd51b1911..f2571121b3 100644
--- a/projectmanagers/qmake/parser/tests/assignmenttest.h
+++ b/projectmanagers/qmake/parser/tests/assignmenttest.h
@@ -1,105 +1,104 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006 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.
  */
 
 #ifndef ASSIGNMENTTEST_H
 #define ASSIGNMENTTEST_H
 
 #include <QtCore/QObject>
-#include <QtTest/QtTest>
-#include <QtCore/QList>
+#include <QTest>
 
 namespace QMake
 {
     class StatementAST;
     class ProjectAST;
 }
 
 class AssignmentTest : public QObject
 {
         Q_OBJECT
     public:
         explicit AssignmentTest( QObject* parent = nullptr );
         ~AssignmentTest() override;
     private slots:
         void init();
         void cleanup();
         void simpleParsed();
         void simpleParsed_data();
         void assignInValue();
         void assignInValue_data();
         void commentCont();
         void commentCont_data();
         void quotedBrace();
         void quotedBrace_data();
         void quotedVal();
         void quotedVal_data();
         void quotedValEscapeQuote();
         void quotedValEscapeQuote_data();
         void dotVariable();
         void dotVariable_data();
         void underscoreVariable();
         void underscoreVariable_data();
         void dashVariable();
         void dashVariable_data();
         void opNoSpace();
         void opNoSpace_data();
         void opPlusEq();
         void opPlusEq_data();
         void opTildeEq();
         void opTildeEq_data();
         void opMinusEq();
         void opMinusEq_data();
         void opStarEq();
         void opStarEq_data();
         void opEqual();
         void opEqual_data();
         void otherVarSimple();
         void otherVarSimple_data();
         void otherVarBrace();
         void otherVarBrace_data();
         void otherVarBracket();
         void otherVarBracket_data();
         void shellVar();
         void shellVar_data();
         void commandExec();
         void commandExec_data();
         void bracketVarQuote();
         void bracketVarQuote_data();
         void pathValue();
         void pathValue_data();
         void varNameDollar();
         void varNameDollar_data();
         void commentInMultiline();
         void commentInMultiline_data();
         void commandExecQMakeVar();
         void commandExecQMakeVar_data();
         void varComment();
         void varComment_data();
 
         void noDashEndVar();
         void noDashEndVar_data();
         void contAfterComment();
         void contAfterComment_data();
     private:
         QMake::ProjectAST* ast;
 };
 
 #endif
 
diff --git a/projectmanagers/qmake/parser/tests/functionscopetest.h b/projectmanagers/qmake/parser/tests/functionscopetest.h
index a3c1ff949f..d79f54ad5e 100644
--- a/projectmanagers/qmake/parser/tests/functionscopetest.h
+++ b/projectmanagers/qmake/parser/tests/functionscopetest.h
@@ -1,88 +1,86 @@
 /* KDevelop
  *
  * Copyright 2007 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.
  */
 
 #ifndef FUNCTIONSCOPETEST_H
 #define FUNCTIONSCOPETEST_H
 
 #include <QtCore/QObject>
-#include <QtTest/QtTest>
-#include <QtCore/QList>
-
+#include <QTest>
 
 namespace QMake
 {
     class StatementAST;
     class ProjectAST;
     class FunctionArgAST;
 }
 
 class FunctionScopeTest : public QObject
 {
         Q_OBJECT
     public:
         explicit FunctionScopeTest( QObject* parent = nullptr );
         ~FunctionScopeTest() override;
     private slots:
         void init();
         void cleanup();
         void execSimpleFunc();
         void execSimpleFunc_data();
         void execBasicFunc();
         void execBasicFunc_data();
         void evalQMakeSyntax();
         void evalQMakeSyntax_data();
         void simpleVarArg();
         void simpleVarArg_data();
         void argWithEqual();
         void argWithEqual_data();
         void partlyQuotedArg();
         void partlyQuotedArg_data();
         void slashArg();
         void slashArg_data();
         void oneStatementScope();
         void oneStatementScope_data();
         void nestedFunccalls();
         void nestedFunccalls_data();
         void multiLineScope();
         void multiLineScope_data();
         void multiLineScopeFuncCall();
         void multiLineScopeFuncCall_data();
         void oneStatementSubScope();
         void oneStatementSubScope_data();
         void notFunc();
         void notFunc_data();
         void orOperator();
         void orOperator_data();
         void spaceBeforeBrace();
         void spaceBeforeBrace_data();
 
         void missingStatement();
         void missingStatement_data();
         void missingBrace();
         void missingBrace_data();
         void missingParenthesis();
         void missingParenthesis_data();
     private:
         QMake::ProjectAST* ast;
 
 };
 
 #endif
 
diff --git a/projectmanagers/qmake/parser/tests/lexertest.h b/projectmanagers/qmake/parser/tests/lexertest.h
index d98ec8ef72..d008f3705d 100644
--- a/projectmanagers/qmake/parser/tests/lexertest.h
+++ b/projectmanagers/qmake/parser/tests/lexertest.h
@@ -1,50 +1,48 @@
 /* KDevelop
  *
  * Copyright 2007 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.
  */
 
 #ifndef LEXERTEST_H
 #define LEXERTEST_H
 
 #include <QtCore/QObject>
-#include <QtTest/QtTest>
-#include <QtCore/QList>
-
+#include <QTest>
 
 class LexerTest : public QObject
 {
         Q_OBJECT
     public:
         explicit LexerTest( QObject* parent = nullptr );
         ~LexerTest() override;
     private slots:
         void init();
         void cleanup();
         void varAssignment();
         void varAssignment_data();
         void operators();
         void operators_data();
         void scope();
         void scope_data();
         void functions();
         void functions_data();
 
 };
 
 #endif
 
diff --git a/projectmanagers/qmake/parser/tests/parsetest.h b/projectmanagers/qmake/parser/tests/parsetest.h
index db5fb2e6ef..8be3c05d57 100644
--- a/projectmanagers/qmake/parser/tests/parsetest.h
+++ b/projectmanagers/qmake/parser/tests/parsetest.h
@@ -1,54 +1,54 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006 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.
  */
 
 #ifndef PARSETEST_H
 #define PARSETEST_H
 
 #include <QtCore/QObject>
-#include <QtTest/QtTest>
+#include <QTest>
 
 namespace QMake
 {
     class ProjectAST;
 }
 
 class ParseTest : public QObject
 {
         Q_OBJECT
     public:
         explicit ParseTest( QObject* parent = nullptr );
         ~ParseTest() override;
     private slots:
         void init();
         void cleanup();
         void successSimpleProject();
         void successSimpleProject_data();
         void failSimpleProject();
         void failSimpleProject_data();
         void successFullProject();
         void successFullProject_data();
         void failFullProject();
         void failFullProject_data();
     private:
         QMake::ProjectAST* ast;
 };
 
 #endif
 
diff --git a/projectmanagers/qmake/parser/tests/scopetest.h b/projectmanagers/qmake/parser/tests/scopetest.h
index 06619e1357..a050f7dd7d 100644
--- a/projectmanagers/qmake/parser/tests/scopetest.h
+++ b/projectmanagers/qmake/parser/tests/scopetest.h
@@ -1,62 +1,61 @@
 /* KDevelop
  *
  * Copyright 2007 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.
  */
 
 #ifndef SCOPETEST_H
 #define SCOPETEST_H
 
 #include <QtCore/QObject>
-#include <QtTest/QtTest>
-#include <QtCore/QList>
+#include <QTest>
 
 
 namespace QMake
 {
     class StatementAST;
     class ProjectAST;
     class FunctionArgAST;
 }
 
 class ScopeTest : public QObject
 {
         Q_OBJECT
     public:
         explicit ScopeTest( QObject* parent = nullptr );
         ~ScopeTest() override;
     private slots:
         void init();
         void cleanup();
         void basicScope();
         void basicScope_data();
         void basicScopeBrace();
         void basicScopeBrace_data();
         void nestedScope();
         void nestedScope_data();
         void missingStatement();
         void missingStatement_data();
         void missingColon();
         void missingColon_data();
         void strangeScopeNames();
     private:
         QMake::ProjectAST* ast;
 
 };
 
 #endif
 
diff --git a/projectmanagers/qmake/parser/tests/testhelpers.cpp b/projectmanagers/qmake/parser/tests/testhelpers.cpp
index 7e99e5e1ec..e565be83b7 100644
--- a/projectmanagers/qmake/parser/tests/testhelpers.cpp
+++ b/projectmanagers/qmake/parser/tests/testhelpers.cpp
@@ -1,71 +1,71 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006 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 "testhelpers.h"
 
 #include <QtCore/QList>
-#include <QtTest/QtTest>
+#include <QTest>
 #include "ast.h"
 
 void matchScopeBodies(QList<QMake::StatementAST*> realbody, QList<QMake::StatementAST*> testbody)
 {
     QVERIFY(realbody.count() == testbody.count());
     int i = 0;
     QMake::AssignmentAST* assign;
     QMake::ScopeAST* scope;
     QMake::AssignmentAST* testassign;
     QMake::ScopeAST* testscope;
 
     foreach (QMake::StatementAST* ast, realbody) {
         scope = dynamic_cast<QMake::ScopeAST*>(ast);
         testscope = dynamic_cast<QMake::ScopeAST*>(testbody.at(i));
 
         if (scope && testscope) {
             QMake::FunctionCallAST* call = dynamic_cast<QMake::FunctionCallAST*>(scope);
             QMake::FunctionCallAST* testcall = dynamic_cast<QMake::FunctionCallAST*>(testscope);
             QMake::SimpleScopeAST* simple = dynamic_cast<QMake::SimpleScopeAST*>(scope);
             QMake::SimpleScopeAST* testsimple = dynamic_cast<QMake::SimpleScopeAST*>(testscope);
             QMake::OrAST* orop = dynamic_cast<QMake::OrAST*>(scope);
             QMake::OrAST* testorop = dynamic_cast<QMake::OrAST*>(testscope);
             QVERIFY((call && testcall) || (simple && testsimple) || (orop && testorop));
             if (call && testcall) {
                 TESTFUNCNAME(call, testcall->identifier->value)
             } else if (simple && testsimple) {
 
             } else if (orop && testorop) {
                 TESTOROPAST(orop, testorop)
             }
             QVERIFY((scope->body && testscope->body) || (!scope->body && !testscope->body));
             if (scope->body && testscope->body) {
                 QList<QMake::StatementAST*> bodylist;
                 QList<QMake::StatementAST*> testbodylist;
                 bodylist = scope->body->statements;
                 testbodylist = testscope->body->statements;
                 matchScopeBodies(bodylist, testbodylist);
             }
         }
         assign = dynamic_cast<QMake::AssignmentAST*>(ast);
         testassign = dynamic_cast<QMake::AssignmentAST*>(testbody.at(i));
         if (assign && testassign) {
             TESTASSIGNMENT(assign, testassign->identifier->value, testassign->op->value, testassign->values.count())
         }
         i++;
     }
 }
diff --git a/projectmanagers/qmake/qmakecache.cpp b/projectmanagers/qmake/qmakecache.cpp
index ed8f96cfb6..98d6462a6d 100644
--- a/projectmanagers/qmake/qmakecache.cpp
+++ b/projectmanagers/qmake/qmakecache.cpp
@@ -1,44 +1,42 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright (C) 2007 Andreas Pakulat <apaku@gmx.de>                     *
  *                                                                         *
  *   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.         *
  ***************************************************************************/
 
 #include "qmakecache.h"
 
-#include <QtCore/QStringList>
-
 #include "qmakemkspecs.h"
 
 QMakeCache::QMakeCache(const QString& cachefile)
     : QMakeFile(cachefile)
     , m_mkspecs(nullptr)
 {
 }
 
 void QMakeCache::setMkSpecs(QMakeMkSpecs* specs)
 {
     m_mkspecs = specs;
 }
 
 bool QMakeCache::read()
 {
     foreach (const QString& var, m_mkspecs->variables()) {
         m_variableValues[var] = m_mkspecs->variableValues(var);
     }
     return QMakeFile::read();
 }
diff --git a/projectmanagers/qmake/qmakefile.cpp b/projectmanagers/qmake/qmakefile.cpp
index 78113432c3..cd510d2d19 100644
--- a/projectmanagers/qmake/qmakefile.cpp
+++ b/projectmanagers/qmake/qmakefile.cpp
@@ -1,212 +1,211 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright 2007 Andreas Pakulat <apaku@gmx.de>                         *
  *                                                                         *
  *   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.         *
  ***************************************************************************/
 
 #include "qmakefile.h"
 
 #include <QtCore/QDir>
 #include <QtCore/QFileInfo>
-#include <QtCore/QProcessEnvironment>
 #include <QDebug>
 
 #include "debug.h"
 #include "parser/ast.h"
 #include "qmakedriver.h"
 
 #define ifDebug(x)
 
 //@TODO: Make the globbing stuff work with drives on win32
 
 void resolveShellGlobbingInternal(QStringList& entries, const QStringList& segments, const QFileInfo& match, QDir& dir,
                                   int offset);
 
 QStringList resolveShellGlobbingInternal(const QStringList& segments, QDir& dir, int offset = 0)
 {
     if (offset >= segments.size()) {
         return QStringList();
     }
 
     const QString& pathPattern = segments.at(offset);
 
     QStringList entries;
     if (pathPattern.contains('*') || pathPattern.contains('?') || pathPattern.contains('[')) {
         // pattern contains globbing chars
         foreach (const QFileInfo& match, dir.entryInfoList(QStringList() << pathPattern,
                                                            QDir::AllEntries | QDir::NoDotAndDotDot, QDir::Unsorted)) {
             resolveShellGlobbingInternal(entries, segments, match, dir, offset);
         }
     } else {
         // pattern is "simple" hence be fast, but make sure the file exists
         QFileInfo info(dir.filePath(pathPattern));
         if (info.exists()) {
             resolveShellGlobbingInternal(entries, segments, info, dir, offset);
         }
     }
 
     return entries;
 }
 
 void resolveShellGlobbingInternal(QStringList& entries, const QStringList& segments, const QFileInfo& match, QDir& dir,
                                   int offset)
 {
     if (match.isDir() && offset + 1 < segments.size()) {
         dir.cd(match.fileName());
         entries += resolveShellGlobbingInternal(segments, dir, offset + 1);
         dir.cdUp();
     } else {
         entries << match.canonicalFilePath();
     }
 }
 
 QStringList resolveShellGlobbingInternal(const QString& pattern, const QString& dir)
 {
     if (pattern.isEmpty()) {
         return QStringList();
     }
 
     QDir dir_(pattern.startsWith('/') ? QLatin1String("/") : dir);
 
     // break up pattern into path segments
     return resolveShellGlobbingInternal(pattern.split(QLatin1Char('/'), QString::SkipEmptyParts), dir_);
 }
 
 QMakeFile::QMakeFile(QString file)
     : m_ast(nullptr)
     , m_projectFile(std::move(file))
     , m_project(nullptr)
 {
     Q_ASSERT(!m_projectFile.isEmpty());
 }
 
 bool QMakeFile::read()
 {
     Q_ASSERT(!m_projectFile.isEmpty());
     QFileInfo fi(m_projectFile);
     ifDebug(qCDebug(KDEV_QMAKE) << "Is" << m_projectFile << "a dir?" << fi.isDir();) if (fi.isDir())
     {
         QDir dir(m_projectFile);
         QStringList l = dir.entryList(QStringList() << "*.pro");
 
         QString projectfile;
 
         if (!l.count() || (l.count() && l.indexOf(fi.baseName() + ".pro") != -1)) {
             projectfile = fi.baseName() + ".pro";
         } else {
             projectfile = l.first();
         }
         m_projectFile += '/' + projectfile;
     }
     QMake::Driver d;
     d.readFile(m_projectFile);
 
     if (!d.parse(&m_ast)) {
         qCWarning(KDEV_QMAKE) << "Couldn't parse project:" << m_projectFile;
         delete m_ast;
         m_ast = nullptr;
         m_projectFile = QString();
         return false;
     } else {
         ifDebug(qCDebug(KDEV_QMAKE) << "found ast:" << m_ast->statements.count();) QMakeFileVisitor visitor(this, this);
         /// TODO: cleanup, re-use m_variableValues directly in the visitor
         visitor.setVariables(m_variableValues);
         m_variableValues = visitor.visitFile(m_ast);
         ifDebug(qCDebug(KDEV_QMAKE) << "Variables found:" << m_variableValues;)
     }
     return true;
 }
 
 QMakeFile::~QMakeFile()
 {
     delete m_ast;
     m_ast = nullptr;
 }
 
 QString QMakeFile::absoluteDir() const
 {
     return QFileInfo(m_projectFile).absoluteDir().canonicalPath();
 }
 
 QString QMakeFile::absoluteFile() const
 {
     return m_projectFile;
 }
 
 QMake::ProjectAST* QMakeFile::ast() const
 {
     return m_ast;
 }
 
 QStringList QMakeFile::variables() const
 {
     return m_variableValues.keys();
 }
 
 QStringList QMakeFile::variableValues(const QString& variable) const
 {
     return m_variableValues.value(variable, QStringList());
 }
 
 bool QMakeFile::containsVariable(const QString& variable) const
 {
     return m_variableValues.contains(variable);
 }
 
 QMakeFile::VariableMap QMakeFile::variableMap() const
 {
     return m_variableValues;
 }
 
 QStringList QMakeFile::resolveVariable(const QString& variable, VariableInfo::VariableType type) const
 {
     if (type == VariableInfo::QMakeVariable && m_variableValues.contains(variable)) {
         return m_variableValues.value(variable);
     } else {
         qCWarning(KDEV_QMAKE) << "unresolved variable:" << variable << "type:" << type;
         return QStringList();
     }
 }
 
 QStringList QMakeFile::resolveShellGlobbing(const QString& pattern) const
 {
     return resolveShellGlobbingInternal(pattern, absoluteDir());
 }
 
 QString QMakeFile::resolveToSingleFileName(const QString& file) const
 {
     QStringList l = resolveFileName(file);
     if (l.isEmpty())
         return QString();
     else
         return l.first();
 }
 
 QStringList QMakeFile::resolveFileName(const QString& file) const
 {
     return resolveShellGlobbing(file);
 }
 
 void QMakeFile::setProject(KDevelop::IProject* project)
 {
     m_project = project;
 }
 
 KDevelop::IProject* QMakeFile::project() const
 {
     return m_project;
 }
diff --git a/projectmanagers/qmake/qmakefile.h b/projectmanagers/qmake/qmakefile.h
index 6ecfa583a5..9bb97cae8a 100644
--- a/projectmanagers/qmake/qmakefile.h
+++ b/projectmanagers/qmake/qmakefile.h
@@ -1,78 +1,79 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright 2007 Andreas Pakulat <apaku@gmx.de>                         *
  *                                                                         *
  *   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 QMAKEFILE_H
 #define QMAKEFILE_H
 
 
 #include <util/stack.h>
-#include <QtCore/QStringList>
 
 #include "qmakefilevisitor.h"
 
+class QStringList;
+
 namespace KDevelop
 {
 class IProject;
 }
 
 namespace QMake
 {
     class ProjectAST;
 }
 
 class Scope;
 class QMakeMkSpecs;
 
 class QMakeFile : public QMakeVariableResolver
 {
 public:
     explicit QMakeFile( QString  file );
     virtual ~QMakeFile();
     virtual bool read();
     QString absoluteDir() const;
     QString absoluteFile() const;
     QMake::ProjectAST* ast() const;
 
     QStringList variableValues(const QString&) const;
     QStringList variables() const;
     VariableMap variableMap() const;
 
     bool containsVariable( const QString& ) const;
 
     QStringList resolveVariable( const QString& variable, VariableInfo::VariableType type) const override;
 
     /// required for proper build-dir resolution
     void setProject(KDevelop::IProject* project);
     KDevelop::IProject* project() const;
 protected:
     VariableMap m_variableValues;
 
     QStringList resolveShellGlobbing( const QString& pattern ) const;
     QStringList resolveFileName( const QString& file ) const;
     QString resolveToSingleFileName( const QString& file ) const;
 private:
     QMake::ProjectAST* m_ast;
     QString m_projectFile;
     KDevelop::IProject* m_project;
 };
 
 #endif
 
 //kate: hl c++;
diff --git a/projectmanagers/qmake/qmakefilevisitor.cpp b/projectmanagers/qmake/qmakefilevisitor.cpp
index b7579c7a1a..c537fa5314 100644
--- a/projectmanagers/qmake/qmakefilevisitor.cpp
+++ b/projectmanagers/qmake/qmakefilevisitor.cpp
@@ -1,249 +1,249 @@
 /*****************************************************************************
  * Copyright (c) 2010 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) 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, see <http://www.gnu.org/licenses/>.     *
  *****************************************************************************/
 
 #include "qmakefilevisitor.h"
 
 #include "qmakefile.h"
 #include "qmakeincludefile.h"
 
 #include "parser/ast.h"
 
 #include <QtCore/QStringList>
-#include <QtCore/QDir>
+#include <QFileInfo>
 #include <QDebug>
 #include <QProcessEnvironment>
 
 #include "debug.h"
 #define ifDebug(x)
 
 // BEGIN QMakeFileVisitor
 
 QMakeFileVisitor::QMakeFileVisitor(const QMakeVariableResolver* resolver, QMakeFile* baseFile)
     : m_resolver(resolver)
     , m_baseFile(baseFile)
 {
 }
 
 QMakeFileVisitor::~QMakeFileVisitor()
 {
 }
 
 void QMakeFileVisitor::setVariables(const VariableMap& vars)
 {
     m_variableValues = vars;
 }
 
 QMakeVariableResolver::VariableMap QMakeFileVisitor::visitFile(QMake::ProjectAST* node)
 {
     visitProject(node);
     return m_variableValues;
 }
 
 QStringList QMakeFileVisitor::visitMacro(QMake::ScopeBodyAST* node, const QStringList& arguments)
 {
     m_arguments = arguments;
     visitScopeBody(node);
     return m_lastReturn;
 }
 
 QStringList QMakeFileVisitor::resolveVariable(const QString& variable, VariableInfo::VariableType type) const
 {
     if (type == VariableInfo::QMakeVariable && m_variableValues.contains(variable)) {
         return m_variableValues.value(variable);
     } else {
         return m_resolver->resolveVariable(variable, type);
     }
 }
 
 QStringList QMakeFileVisitor::getValueList(const QList<QMake::ValueAST*>& list) const
 {
     QStringList result;
     foreach (QMake::ValueAST* v, list) {
         result += resolveVariables(v->value);
     }
     return result;
 }
 
 void QMakeFileVisitor::visitFunctionCall(QMake::FunctionCallAST* node)
 {
     if (node->identifier->value == "include" || node->identifier->value == "!include") {
         if (node->args.isEmpty())
             return;
         QStringList arguments = getValueList(node->args);
 
         ifDebug(qCDebug(KDEV_QMAKE) << "found include" << node->identifier->value << arguments;) QString argument
             = arguments.join("").trimmed();
         if (!argument.isEmpty() && QFileInfo(argument).isRelative()) {
             argument = QFileInfo(m_baseFile->absoluteDir() + '/' + argument).canonicalFilePath();
         }
         if (argument.isEmpty()) {
             qCWarning(KDEV_QMAKE) << "empty include file detected in line" << node->startLine;
             if (node->identifier->value.startsWith('!')) {
                 visitNode(node->body);
             }
             return;
         }
         ifDebug(qCDebug(KDEV_QMAKE) << "Reading Include file:" << argument;)
             QMakeIncludeFile includefile(argument, m_baseFile, m_variableValues);
         bool read = includefile.read();
         ifDebug(qCDebug(KDEV_QMAKE) << "successfully read:" << read;) if (read)
         {
             // TODO: optimize by using variableMap and iterator, don't compare values
             foreach (const QString& var, includefile.variables()) {
                 if (m_variableValues.value(var) != includefile.variableValues(var)) {
                     m_variableValues[var] = includefile.variableValues(var);
                 }
             }
             if (!node->identifier->value.startsWith('!')) {
                 visitNode(node->body);
             }
         }
         else if (node->identifier->value.startsWith('!')) { visitNode(node->body); }
     } else if (node->body && (node->identifier->value == "defineReplace"
                               || node->identifier->value
                                   == "defineTest")) { // TODO: differentiate between replace and test functions?
         QStringList args = getValueList(node->args);
         if (!args.isEmpty()) {
             m_userMacros[args.first()] = node->body;
         } // TODO: else return error
     } else if (node->identifier->value == "return") {
         m_lastReturn = getValueList(node->args);
     } else { // TODO: only visit when test function returned true?
         qCWarning(KDEV_QMAKE) << "unhandled function call" << node->identifier->value;
         visitNode(node->body);
     }
 }
 
 void QMakeFileVisitor::visitAssignment(QMake::AssignmentAST* node)
 {
     QString op = node->op->value;
     QStringList values = getValueList(node->values);
     if (op == "=") {
         m_variableValues[node->identifier->value] = values;
     } else if (op == "+=") {
         m_variableValues[node->identifier->value] += values;
     } else if (op == "-=") {
         foreach (const QString& value, values) {
             m_variableValues[node->identifier->value].removeAll(value);
         }
     } else if (op == "*=") {
         foreach (const QString& value, values) {
             if (!m_variableValues.value(node->identifier->value).contains(value)) {
                 m_variableValues[node->identifier->value].append(value);
             }
         }
     } else if (op == "~=") {
         if (values.isEmpty())
             return;
         QString value = values.first().trimmed();
         QString regex = value.mid(2, value.indexOf("/", 2));
         QString replacement = value.mid(value.indexOf("/", 2) + 1, value.lastIndexOf("/"));
         m_variableValues[node->identifier->value].replaceInStrings(QRegExp(regex), replacement);
     }
 }
 
 /// return 1-n for numeric variable, 0 otherwise
 int functionArgument(const QString& var)
 {
     bool ok;
     int arg = var.toInt(&ok);
     if (!ok) {
         return 0;
     } else {
         return arg;
     }
 }
 
 QStringList QMakeFileVisitor::resolveVariables(const QString& var) const
 {
     VariableReferenceParser parser;
     parser.setContent(var);
     if (!parser.parse()) {
         qCWarning(KDEV_QMAKE) << "Couldn't parse" << var << "to replace variables in it";
         return QStringList() << var;
     }
     if (parser.variableReferences().isEmpty()) {
         return QStringList() << var;
     }
 
     /// TODO: multiple vars in one place will make the offsets go bonkers
     QString value = var;
     foreach (const QString& variable, parser.variableReferences()) {
         VariableInfo vi = parser.variableInfo(variable);
         QString varValue;
 
         switch (vi.type) {
         case VariableInfo::QMakeVariable:
             if (int arg = functionArgument(variable)) {
                 if (arg > 0 && arg <= m_arguments.size()) {
                     varValue = m_arguments.at(arg - 1);
                 } else {
                     qCWarning(KDEV_QMAKE) << "undefined macro argument:" << variable;
                 }
             } else {
                 varValue = resolveVariable(variable, vi.type).join(" ");
             }
             break;
         case VariableInfo::ShellVariableResolveQMake:
         case VariableInfo::ShellVariableResolveMake:
             /// TODO: make vs qmake time
             varValue = QProcessEnvironment::systemEnvironment().value(variable);
             break;
         case VariableInfo::QtConfigVariable:
             varValue = resolveVariable(variable, vi.type).join(" ");
             break;
         case VariableInfo::FunctionCall: {
             QStringList arguments;
             foreach (const VariableInfo::Position& pos, vi.positions) {
                 int start = pos.start + 3 + variable.length();
                 QString args = value.mid(start, pos.end - start);
                 varValue = resolveVariables(args).join(" ");
                 arguments << varValue;
             }
             varValue = evaluateMacro(variable, arguments).join(" ");
             break;
         }
         case VariableInfo::Invalid:
             qCWarning(KDEV_QMAKE) << "invalid qmake variable:" << variable;
             continue;
         }
 
         foreach (const VariableInfo::Position& pos, vi.positions) {
             value.replace(pos.start, pos.end - pos.start + 1, varValue);
         }
     }
 
     QStringList ret = value.split(" ", QString::SkipEmptyParts);
     ifDebug(qCDebug(KDEV_QMAKE) << "resolved variable" << var << "to" << ret;) return ret;
 }
 
 QStringList QMakeFileVisitor::evaluateMacro(const QString& function, const QStringList& arguments) const
 {
     if (function == QLatin1String("qtLibraryTarget")) {
         return QStringList() << arguments.first();
     } ///  TODO: support more built-in qmake functions
 
     QHash<QString, QMake::ScopeBodyAST*>::const_iterator it = m_userMacros.find(function);
     if (it != m_userMacros.constEnd()) {
         qCDebug(KDEV_QMAKE) << "calling user macro:" << function << arguments;
         QMakeFileVisitor visitor(this, m_baseFile);
         return visitor.visitMacro(it.value(), arguments);
     } else {
         qCWarning(KDEV_QMAKE) << "unhandled macro call:" << function << arguments;
     }
     return QStringList();
 }
diff --git a/projectmanagers/qmake/qmakeincludefile.cpp b/projectmanagers/qmake/qmakeincludefile.cpp
index 66ef5f9a8a..854f0700d9 100644
--- a/projectmanagers/qmake/qmakeincludefile.cpp
+++ b/projectmanagers/qmake/qmakeincludefile.cpp
@@ -1,68 +1,66 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright (C) 2007 Andreas Pakulat <apaku@gmx.de>                     *
  *                                                                         *
  *   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.         *
  ***************************************************************************/
 
 #include "qmakeincludefile.h"
 #include "qmakemkspecs.h"
-#include <QtCore/QMap>
 #include <QtCore/QString>
-#include <QtCore/QStringList>
 
 QMakeIncludeFile::QMakeIncludeFile(const QString& incfile, QMakeFile* parent, const VariableMap& variables)
     : QMakeProjectFile(incfile)
     , m_parent(parent)
 {
     m_variableValues = variables;
 
     setProject(parent->project());
 
     QMakeProjectFile* pro = dynamic_cast<QMakeProjectFile*>(parent);
     if (pro) {
         setMkSpecs(pro->mkSpecs());
         setQMakeCache(pro->qmakeCache());
     } else {
         QMakeMkSpecs* specs = dynamic_cast<QMakeMkSpecs*>(parent);
         setMkSpecs(specs);
     }
 }
 
 QString QMakeIncludeFile::pwd() const
 {
     return absoluteDir();
 }
 
 QString QMakeIncludeFile::outPwd() const
 {
     QMakeProjectFile* pro = dynamic_cast<QMakeProjectFile*>(m_parent);
     if (pro) {
         return pro->outPwd();
     } else {
         return absoluteDir();
     }
 }
 
 QString QMakeIncludeFile::proFile() const
 {
     return m_parent->absoluteFile();
 }
 
 QString QMakeIncludeFile::proFilePwd() const
 {
     return m_parent->absoluteDir();
 }
diff --git a/projectmanagers/qmake/qmakejob.cpp b/projectmanagers/qmake/qmakejob.cpp
index ae69208120..d84c5d2949 100644
--- a/projectmanagers/qmake/qmakejob.cpp
+++ b/projectmanagers/qmake/qmakejob.cpp
@@ -1,161 +1,160 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright 2010 Milian Wolff <mail@milianw.de>                         *
  *                                                                         *
  *   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.         *
  ***************************************************************************/
 
 #include "qmakejob.h"
-#include <QtCore/QFileInfo>
 #include <QtCore/QDir>
 #include <QDebug>
 #include <QProcess>
 #include <KLocalizedString>
 #include <KShell>
 #include <util/processlinemaker.h>
 #include <outputview/outputmodel.h>
 #include <outputview/ioutputview.h>
 #include "debug.h"
 
 using namespace KDevelop;
 
 QMakeJob::QMakeJob(QString srcDir, QString buildDir, QObject* parent)
     : OutputJob(parent)
     , m_srcDir(std::move(srcDir))
     , m_buildDir(std::move(buildDir))
     , m_qmakePath("qmake")
     , m_buildType(0)
     , m_process(nullptr)
     , m_model(nullptr)
 
 {
     setCapabilities(Killable);
     setStandardToolView(IOutputView::RunView);
     setBehaviours(IOutputView::AllowUserClose | IOutputView::AutoScroll);
 
     setObjectName(i18n("Run QMake in %1", m_buildDir));
 }
 
 QMakeJob::~QMakeJob()
 {
 }
 
 void QMakeJob::setQMakePath(const QString& path)
 {
     m_qmakePath = path;
 }
 
 void QMakeJob::setInstallPrefix(const QString& prefix)
 {
     m_installPrefix = prefix;
 }
 
 void QMakeJob::setBuildType(int comboboxSelectedIndex)
 {
     m_buildType = comboboxSelectedIndex;
 }
 
 void QMakeJob::setExtraArguments(const QString& args)
 {
     m_extraArguments = args;
 }
 
 void QMakeJob::start()
 {
     static const char* const BUILD_TYPES[] = { "debug", "build", "(don't specify)" };
 
     m_model = new OutputModel;
     setModel(m_model);
 
     startOutput();
 
     QStringList args;
     if (m_buildType < 2)
         args << QString("CONFIG+=") + BUILD_TYPES[m_buildType];
     if (!m_installPrefix.isEmpty())
         args << "target.path=" + m_installPrefix;
     if (!m_extraArguments.isEmpty()) {
         KShell::Errors err;
         QStringList tmp = KShell::splitArgs(m_extraArguments, KShell::TildeExpand | KShell::AbortOnMeta, &err);
         if (err == KShell::NoError) {
             args += tmp;
         } else {
             qCWarning(KDEV_QMAKE) << "Ignoring qmake Extra arguments";
             if (err == KShell::BadQuoting) {
                 qCWarning(KDEV_QMAKE) << "QMake arguments badly quoted:" << m_extraArguments;
             } else {
                 qCWarning(KDEV_QMAKE) << "QMake arguments had meta character:" << m_extraArguments;
             }
         }
     }
     args << "-r" << m_srcDir;
 
     m_model->appendLine(m_buildDir + ": " + args.join(" "));
 
     QDir build(m_buildDir);
     if (!build.exists()) {
         build.mkpath(build.absolutePath());
     }
 
     m_process = new QProcess(this);
     m_process->setWorkingDirectory(m_buildDir);
     m_process->setProgram(m_qmakePath);
     m_process->setArguments(args);
     m_process->setProcessChannelMode(QProcess::MergedChannels);
     auto lineMaker = new KDevelop::ProcessLineMaker(m_process, this);
 
     connect(lineMaker, SIGNAL(receivedStdoutLines(QStringList)), m_model, SLOT(appendLines(QStringList)));
     connect(lineMaker, SIGNAL(receivedStderrLines(QStringList)), m_model, SLOT(appendLines(QStringList)));
     connect(m_process, SIGNAL(error(QProcess::ProcessError)), SLOT(processError(QProcess::ProcessError)));
     connect(m_process, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(processFinished(int, QProcess::ExitStatus)));
 
     m_process->start();
 }
 
 bool QMakeJob::doKill()
 {
     if (!m_process) {
         return true;
     }
 
     m_process->kill();
     return m_process->state() == m_process->NotRunning;
 }
 
 QString QMakeJob::errorString() const
 {
     return m_process->errorString();
 }
 
 void QMakeJob::processError(QProcess::ProcessError error)
 {
     m_model->appendLine(errorString());
     setError(error);
     emitResult();
 }
 
 void QMakeJob::processFinished(int exitCode, QProcess::ExitStatus status)
 {
     if (status == QProcess::NormalExit) {
         m_model->appendLine(i18n("*** Exited with return code: %1 ***", exitCode));
     } else if (error() == KJob::KilledJobError) {
         m_model->appendLine(i18n("*** Process aborted ***"));
     } else {
         m_model->appendLine(i18n("*** Crashed with return code: %1 ***", exitCode));
     }
 
     emitResult();
 }
diff --git a/projectmanagers/qmake/qmakemanager.cpp b/projectmanagers/qmake/qmakemanager.cpp
index f6a6e881c0..7820610987 100644
--- a/projectmanagers/qmake/qmakemanager.cpp
+++ b/projectmanagers/qmake/qmakemanager.cpp
@@ -1,519 +1,518 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006 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 "qmakemanager.h"
 
 #include <QAction>
 #include <QDebug>
 #include <QDir>
 #include <QIcon>
 #include <QFileInfo>
 #include <QHash>
 #include <QList>
 #include <QUrl>
 
 #include <kio/global.h>
 #include <KConfigGroup>
 #include <KDirWatch>
 #include <KLocalizedString>
 #include <KPluginFactory>
-#include <KPluginLoader>
 
 #include <interfaces/icore.h>
 #include <interfaces/iproject.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/context.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include <project/projectmodel.h>
 #include <serialization/indexedstring.h>
 
 #include <projectbuilders/qmakebuilder/iqmakebuilder.h>
 
 #include "qmakemodelitems.h"
 #include "qmakeprojectfile.h"
 #include "qmakecache.h"
 #include "qmakemkspecs.h"
 #include "qmakejob.h"
 #include "qmakebuilddirchooserdialog.h"
 #include "qmakeconfig.h"
 #include "qmakeutils.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 // BEGIN Helpers
 
 QMakeFolderItem* findQMakeFolderParent(ProjectBaseItem* item)
 {
     QMakeFolderItem* p = nullptr;
     while (!p && item) {
         p = dynamic_cast<QMakeFolderItem*>(item);
         item = item->parent();
     }
     return p;
 }
 
 // END Helpers
 
 K_PLUGIN_FACTORY_WITH_JSON(QMakeSupportFactory, "kdevqmakemanager.json", registerPlugin<QMakeProjectManager>();)
 
 QMakeProjectManager* QMakeProjectManager::m_self = nullptr;
 
 QMakeProjectManager* QMakeProjectManager::self()
 {
     return m_self;
 }
 
 QMakeProjectManager::QMakeProjectManager(QObject* parent, const QVariantList&)
     : AbstractFileManagerPlugin("kdevqmakemanager", parent)
     , IBuildSystemManager()
     , m_builder(nullptr)
     , m_runQMake(nullptr)
 {
     Q_ASSERT(!m_self);
     m_self = this;
 
     IPlugin* i = core()->pluginController()->pluginForExtension("org.kdevelop.IQMakeBuilder");
     Q_ASSERT(i);
     m_builder = i->extension<IQMakeBuilder>();
     Q_ASSERT(m_builder);
 
     connect(this, SIGNAL(folderAdded(KDevelop::ProjectFolderItem*)), this,
             SLOT(slotFolderAdded(KDevelop::ProjectFolderItem*)));
 
     m_runQMake = new QAction(QIcon::fromTheme("qtlogo"), i18n("Run QMake"), this);
     connect(m_runQMake, SIGNAL(triggered(bool)), this, SLOT(slotRunQMake()));
 }
 
 QMakeProjectManager::~QMakeProjectManager()
 {
     m_self = nullptr;
 }
 
 IProjectFileManager::Features QMakeProjectManager::features() const
 {
     return Features(Folders | Targets | Files);
 }
 
 bool QMakeProjectManager::isValid(const Path& path, const bool isFolder, IProject* project) const
 {
     if (!isFolder && path.lastPathSegment().startsWith("Makefile")) {
         return false;
     }
     return AbstractFileManagerPlugin::isValid(path, isFolder, project);
 }
 
 Path QMakeProjectManager::buildDirectory(ProjectBaseItem* item) const
 {
     /// TODO: support includes by some other parent or sibling in a different file-tree-branch
     QMakeFolderItem* qmakeItem = findQMakeFolderParent(item);
     Path dir;
     if (qmakeItem) {
         if (!qmakeItem->parent()) {
             // build root item
             dir = QMakeConfig::buildDirFromSrc(qmakeItem->project(), qmakeItem->path());
         } else {
             // build sub-item
             foreach (QMakeProjectFile* pro, qmakeItem->projectFiles()) {
                 if (QDir(pro->absoluteDir()) == QFileInfo(qmakeItem->path().toUrl().toLocalFile() + '/').absoluteDir()
                     || pro->hasSubProject(qmakeItem->path().toUrl().toLocalFile())) {
                     // get path from project root and it to buildDir
                     dir = QMakeConfig::buildDirFromSrc(qmakeItem->project(), Path(pro->absoluteDir()));
                     break;
                 }
             }
         }
     }
 
     qCDebug(KDEV_QMAKE) << "build dir for" << item->text() << item->path() << "is:" << dir;
     return dir;
 }
 
 ProjectFolderItem* QMakeProjectManager::createFolderItem(IProject* project, const Path& path, ProjectBaseItem* parent)
 {
     if (!parent) {
         return projectRootItem(project, path);
     } else if (ProjectFolderItem* buildFolder = buildFolderItem(project, path, parent)) {
         // child folder in a qmake folder
         return buildFolder;
     } else {
         return AbstractFileManagerPlugin::createFolderItem(project, path, parent);
     }
 }
 
 ProjectFolderItem* QMakeProjectManager::projectRootItem(IProject* project, const Path& path)
 {
     QFileInfo fi(path.toLocalFile());
     QDir dir(path.toLocalFile());
     QStringList l = dir.entryList(QStringList() << "*.pro");
 
     QString projectfile;
 
     if (l.count() && l.indexOf(project->name() + ".pro") != -1)
         projectfile = project->name() + ".pro";
     if (l.isEmpty() || (l.count() && l.indexOf(fi.baseName() + ".pro") != -1)) {
         projectfile = fi.baseName() + ".pro";
     } else {
         projectfile = l.first();
     }
 
     QHash<QString, QString> qmvars = QMakeUtils::queryQMake(project);
     const QString mkSpecFile = QMakeConfig::findBasicMkSpec(qmvars);
     Q_ASSERT(!mkSpecFile.isEmpty());
     QMakeMkSpecs* mkspecs = new QMakeMkSpecs(mkSpecFile, qmvars);
     mkspecs->setProject(project);
     mkspecs->read();
     QMakeCache* cache = findQMakeCache(project);
     if (cache) {
         cache->setMkSpecs(mkspecs);
         cache->read();
     }
     Path proPath(path, projectfile);
     /// TODO: use Path in QMakeProjectFile
     QMakeProjectFile* scope = new QMakeProjectFile(proPath.toLocalFile());
     scope->setProject(project);
     scope->setMkSpecs(mkspecs);
     if (cache) {
         scope->setQMakeCache(cache);
     }
     scope->read();
     qCDebug(KDEV_QMAKE) << "top-level scope with variables:" << scope->variables();
     auto item = new QMakeFolderItem(project, path);
     item->addProjectFile(scope);
     return item;
 }
 
 ProjectFolderItem* QMakeProjectManager::buildFolderItem(IProject* project, const Path& path, ProjectBaseItem* parent)
 {
     // find .pro or .pri files in dir
     QDir dir(path.toLocalFile());
     QStringList projectFiles = dir.entryList(QStringList() << "*.pro"
                                                            << "*.pri",
                                              QDir::Files);
     if (projectFiles.isEmpty()) {
         return nullptr;
     }
 
     auto folderItem = new QMakeFolderItem(project, path, parent);
 
     // TODO: included by not-parent file (in a nother file-tree-branch).
     QMakeFolderItem* qmakeParent = findQMakeFolderParent(parent);
     if (!qmakeParent) {
         // happens for bad qmake configurations
         return nullptr;
     }
 
     foreach (const QString& file, projectFiles) {
         const QString absFile = dir.absoluteFilePath(file);
 
         // TODO: multiple includes by different .pro's
         QMakeProjectFile* parentPro = nullptr;
         foreach (QMakeProjectFile* p, qmakeParent->projectFiles()) {
             if (p->hasSubProject(absFile)) {
                 parentPro = p;
                 break;
             }
         }
         if (!parentPro && file.endsWith(".pri")) {
             continue;
         }
         qCDebug(KDEV_QMAKE) << "add project file:" << absFile;
         if (parentPro) {
             qCDebug(KDEV_QMAKE) << "parent:" << parentPro->absoluteFile();
         } else {
             qCDebug(KDEV_QMAKE) << "no parent, assume project root";
         }
 
         auto qmscope = new QMakeProjectFile(absFile);
         qmscope->setProject(project);
 
         const QFileInfo info(absFile);
         const QDir d = info.dir();
         /// TODO: cleanup
         if (parentPro) {
             // subdir
             if (QMakeCache* cache = findQMakeCache(project, Path(d.canonicalPath()))) {
                 cache->setMkSpecs(parentPro->mkSpecs());
                 cache->read();
                 qmscope->setQMakeCache(cache);
             } else {
                 qmscope->setQMakeCache(parentPro->qmakeCache());
             }
 
             qmscope->setMkSpecs(parentPro->mkSpecs());
         } else {
             // new project
             QMakeFolderItem* root = dynamic_cast<QMakeFolderItem*>(project->projectItem());
             Q_ASSERT(root);
             qmscope->setMkSpecs(root->projectFiles().first()->mkSpecs());
             if (root->projectFiles().first()->qmakeCache()) {
                 qmscope->setQMakeCache(root->projectFiles().first()->qmakeCache());
             }
         }
 
         if (qmscope->read()) {
             // TODO: only on read?
             folderItem->addProjectFile(qmscope);
         } else {
             delete qmscope;
             return nullptr;
         }
     }
 
     return folderItem;
 }
 
 void QMakeProjectManager::slotFolderAdded(ProjectFolderItem* folder)
 {
     QMakeFolderItem* qmakeParent = dynamic_cast<QMakeFolderItem*>(folder);
     if (!qmakeParent) {
         return;
     }
 
     qCDebug(KDEV_QMAKE) << "adding targets for" << folder->path();
     foreach (QMakeProjectFile* pro, qmakeParent->projectFiles()) {
         foreach (const QString& s, pro->targets()) {
             if (!isValid(Path(folder->path(), s), false, folder->project())) {
                 continue;
             }
             qCDebug(KDEV_QMAKE) << "adding target:" << s;
             Q_ASSERT(!s.isEmpty());
             auto target = new QMakeTargetItem(pro, folder->project(), s, folder);
             foreach (const QString& path, pro->filesForTarget(s)) {
                 new ProjectFileItem(folder->project(), Path(path), target);
                 /// TODO: signal?
             }
         }
     }
 }
 
 ProjectFolderItem* QMakeProjectManager::import(IProject* project)
 {
     const Path dirName = project->path();
     if (dirName.isRemote()) {
         // FIXME turn this into a real warning
         qCWarning(KDEV_QMAKE) << "not a local file. QMake support doesn't handle remote projects";
         return nullptr;
     }
 
     QMakeUtils::checkForNeedingConfigure(project);
 
     ProjectFolderItem* ret = AbstractFileManagerPlugin::import(project);
     connect(projectWatcher(project), SIGNAL(dirty(QString)), this, SLOT(slotDirty(QString)));
     return ret;
 }
 
 void QMakeProjectManager::slotDirty(const QString& path)
 {
     if (!path.endsWith(".pro") && !path.endsWith(".pri")) {
         return;
     }
 
     QFileInfo info(path);
     if (!info.isFile()) {
         return;
     }
 
     const QUrl url = QUrl::fromLocalFile(path);
     if (!isValid(Path(url), false, nullptr)) {
         return;
     }
 
     IProject* project = ICore::self()->projectController()->findProjectForUrl(url);
     if (!project) {
         // this can happen when we create/remove lots of files in a
         // sub dir of a project - ignore such cases for now
         return;
     }
 
     bool finished = false;
     foreach (ProjectFolderItem* folder, project->foldersForPath(IndexedString(KIO::upUrl(url)))) {
         if (QMakeFolderItem* qmakeFolder = dynamic_cast<QMakeFolderItem*>(folder)) {
             foreach (QMakeProjectFile* pro, qmakeFolder->projectFiles()) {
                 if (pro->absoluteFile() == path) {
                     // TODO: children
                     // TODO: cache added
                     qDebug() << "reloading" << pro << path;
                     pro->read();
                 }
             }
             finished = true;
         } else if (ProjectFolderItem* newFolder = buildFolderItem(project, folder->path(), folder->parent())) {
             qDebug() << "changing from normal folder to qmake project folder:" << folder->path().toUrl();
             // .pro / .pri file did not exist before
             while (folder->rowCount()) {
                 newFolder->appendRow(folder->takeRow(0));
             }
             folder->parent()->removeRow(folder->row());
             folder = newFolder;
             finished = true;
         }
         if (finished) {
             // remove existing targets and readd them
             for (int i = 0; i < folder->rowCount(); ++i) {
                 if (folder->child(i)->target()) {
                     folder->removeRow(i);
                 }
             }
             /// TODO: put into it's own function once we add more stuff to that slot
             slotFolderAdded(folder);
             break;
         }
     }
 }
 
 QList<ProjectTargetItem*> QMakeProjectManager::targets(ProjectFolderItem* item) const
 {
     Q_UNUSED(item)
     return QList<ProjectTargetItem*>();
 }
 
 IProjectBuilder* QMakeProjectManager::builder() const
 {
     Q_ASSERT(m_builder);
     return m_builder;
 }
 
 Path::List QMakeProjectManager::collectDirectories(ProjectBaseItem* item, const bool collectIncludes) const
 {
     Path::List list;
     QMakeFolderItem* folder = findQMakeFolderParent(item);
     if (folder) {
         foreach (QMakeProjectFile* pro, folder->projectFiles()) {
             if (pro->files().contains(item->path().toLocalFile())) {
                 const QStringList directories = collectIncludes ? pro->includeDirectories() : pro->frameworkDirectories();
                 foreach (const QString& dir, directories) {
                     Path path(dir);
                     if (!list.contains(path)) {
                         list << path;
                     }
                 }
             }
         }
         if (list.isEmpty()) {
             // fallback for new files, use all possible include dirs
             foreach (QMakeProjectFile* pro, folder->projectFiles()) {
                 const QStringList directories = collectIncludes ? pro->includeDirectories() : pro->frameworkDirectories();
                 foreach (const QString& dir, directories) {
                     Path path(dir);
                     if (!list.contains(path)) {
                         list << path;
                     }
                 }
             }
         }
         // make sure the base dir is included
         if (!list.contains(folder->path())) {
             list << folder->path();
         }
         // qCDebug(KDEV_QMAKE) << "include dirs for" << item->path() << ":" << list;
     }
     return list;
 }
 
 Path::List QMakeProjectManager::includeDirectories(ProjectBaseItem* item) const
 {
     return collectDirectories(item);
 }
 
 Path::List QMakeProjectManager::frameworkDirectories(ProjectBaseItem* item) const
 {
     return collectDirectories(item, false);
 }
 
 QHash<QString, QString> QMakeProjectManager::defines(ProjectBaseItem* item) const
 {
     QHash<QString, QString> d;
     QMakeFolderItem* folder = findQMakeFolderParent(item);
     if (!folder) {
         // happens for bad qmake configurations
         return d;
     }
     foreach (QMakeProjectFile* pro, folder->projectFiles()) {
         foreach (QMakeProjectFile::DefinePair def, pro->defines()) {
             d.insert(def.first, def.second);
         }
     }
     return d;
 }
 
 bool QMakeProjectManager::hasBuildInfo(KDevelop::ProjectBaseItem* item) const
 {
     return findQMakeFolderParent(item);
 }
 
 QMakeCache* QMakeProjectManager::findQMakeCache(IProject* project, const Path& path) const
 {
     QDir curdir(QMakeConfig::buildDirFromSrc(project, !path.isValid() ? project->path() : path).toLocalFile());
     curdir.makeAbsolute();
     while (!curdir.exists(".qmake.cache") && !curdir.isRoot() && curdir.cdUp()) {
         qDebug() << curdir;
     }
 
     if (curdir.exists(".qmake.cache")) {
         qDebug() << "Found QMake cache in " << curdir.absolutePath();
         return new QMakeCache(curdir.canonicalPath() + "/.qmake.cache");
     }
     return nullptr;
 }
 
 ContextMenuExtension QMakeProjectManager::contextMenuExtension(Context* context)
 {
     ContextMenuExtension ext;
 
     if (context->hasType(Context::ProjectItemContext)) {
         ProjectItemContext* pic = dynamic_cast<ProjectItemContext*>(context);
         Q_ASSERT(pic);
         if (pic->items().isEmpty()) {
             return ext;
         }
 
         m_actionItem = dynamic_cast<QMakeFolderItem*>(pic->items().first());
         if (m_actionItem) {
             ext.addAction(ContextMenuExtension::ProjectGroup, m_runQMake);
         }
     }
 
     return ext;
 }
 
 void QMakeProjectManager::slotRunQMake()
 {
     Q_ASSERT(m_actionItem);
 
     Path srcDir = m_actionItem->path();
     Path buildDir = QMakeConfig::buildDirFromSrc(m_actionItem->project(), srcDir);
     QMakeJob* job = new QMakeJob(srcDir.toLocalFile(), buildDir.toLocalFile(), this);
 
     job->setQMakePath(QMakeConfig::qmakeExecutable(m_actionItem->project()));
 
     KConfigGroup cg(m_actionItem->project()->projectConfiguration(), QMakeConfig::CONFIG_GROUP);
     QString installPrefix = cg.readEntry(QMakeConfig::INSTALL_PREFIX, QString());
     if (!installPrefix.isEmpty())
         job->setInstallPrefix(installPrefix);
     job->setBuildType(cg.readEntry<int>(QMakeConfig::BUILD_TYPE, 0));
     job->setExtraArguments(cg.readEntry(QMakeConfig::EXTRA_ARGUMENTS, QString()));
 
     KDevelop::ICore::self()->runController()->registerJob(job);
 }
 
 #include "qmakemanager.moc"
diff --git a/projectmanagers/qmake/qmakemodelitems.cpp b/projectmanagers/qmake/qmakemodelitems.cpp
index 9385a56efb..3193101115 100644
--- a/projectmanagers/qmake/qmakemodelitems.cpp
+++ b/projectmanagers/qmake/qmakemodelitems.cpp
@@ -1,69 +1,67 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006 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 "qmakemodelitems.h"
 
-#include <QtCore/QHash>
-#include <QtCore/QPair>
 #include <QtCore/QList>
 
 #include "qmakeprojectfile.h"
 
 QMakeFolderItem::QMakeFolderItem(KDevelop::IProject* project, const KDevelop::Path& path,
                                  KDevelop::ProjectBaseItem* parent)
     : KDevelop::ProjectBuildFolderItem(project, path, parent)
 {
 }
 
 QList<QMakeProjectFile*> QMakeFolderItem::projectFiles() const
 {
     return m_projectFiles;
 }
 
 void QMakeFolderItem::addProjectFile(QMakeProjectFile* file)
 {
     m_projectFiles << file;
 }
 
 QMakeFolderItem::~QMakeFolderItem()
 {
     qDeleteAll(m_projectFiles);
 }
 
 QMakeTargetItem::QMakeTargetItem(QMakeProjectFile* pro, KDevelop::IProject* project, const QString& s,
                                  KDevelop::ProjectBaseItem* parent)
     : KDevelop::ProjectExecutableTargetItem(project, s, parent)
     , m_pro(pro)
 {
 }
 
 QMakeTargetItem::~QMakeTargetItem()
 {
 }
 
 QUrl QMakeTargetItem::builtUrl() const
 {
     return QUrl::fromLocalFile(m_pro->outPwd().append('/' + text()));
 }
 
 QUrl QMakeTargetItem::installedUrl() const
 {
     return QUrl();
 }
diff --git a/projectmanagers/qmake/qmakeprojectfile.cpp b/projectmanagers/qmake/qmakeprojectfile.cpp
index c952bf407b..1d4b3a07f7 100644
--- a/projectmanagers/qmake/qmakeprojectfile.cpp
+++ b/projectmanagers/qmake/qmakeprojectfile.cpp
@@ -1,428 +1,426 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006 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 "qmakeprojectfile.h"
 
 #include <QtCore/QList>
 #include <QtCore/QStringList>
 #include <QtCore/QDir>
 
-#include <kprocess.h>
-
 #include "debug.h"
 #include "parser/ast.h"
 #include "qmakecache.h"
 #include "qmakemkspecs.h"
 #include "qmakeconfig.h"
 
 #include <interfaces/iproject.h>
 #include <util/path.h>
 
 #define ifDebug(x)
 
 QHash<QString, QHash<QString, QString>> QMakeProjectFile::m_qmakeQueryCache;
 
 const QStringList QMakeProjectFile::FileVariables = QStringList() << "IDLS"
                                                                   << "RESOURCES"
                                                                   << "IMAGES"
                                                                   << "LEXSOURCES"
                                                                   << "DISTFILES"
                                                                   << "YACCSOURCES"
                                                                   << "TRANSLATIONS"
                                                                   << "HEADERS"
                                                                   << "SOURCES"
                                                                   << "INTERFACES"
                                                                   << "FORMS";
 
 QMakeProjectFile::QMakeProjectFile(const QString& projectfile)
     : QMakeFile(projectfile)
     , m_mkspecs(nullptr)
     , m_cache(nullptr)
 {
 }
 
 void QMakeProjectFile::setQMakeCache(QMakeCache* cache)
 {
     m_cache = cache;
 }
 
 void QMakeProjectFile::setMkSpecs(QMakeMkSpecs* mkspecs)
 {
     m_mkspecs = mkspecs;
 }
 
 bool QMakeProjectFile::read()
 {
     // default values
     // NOTE: if we already have such a var, e.g. in an include file, we must not overwrite it here!
     if (!m_variableValues.contains("QT")) {
         m_variableValues["QT"] = QStringList() << "core"
                                                << "gui";
     }
     if (!m_variableValues.contains("CONFIG")) {
         m_variableValues["CONFIG"] = QStringList() << "qt";
     }
 
     Q_ASSERT(m_mkspecs);
     foreach (const QString& var, m_mkspecs->variables()) {
         if (!m_variableValues.contains(var)) {
             m_variableValues[var] = m_mkspecs->variableValues(var);
         }
     }
     if (m_cache) {
         foreach (const QString& var, m_cache->variables()) {
             if (!m_variableValues.contains(var)) {
                 m_variableValues[var] = m_cache->variableValues(var);
             }
         }
     }
 
     /// TODO: more special variables
     m_variableValues["PWD"] = QStringList() << pwd();
     m_variableValues["_PRO_FILE_"] = QStringList() << proFile();
     m_variableValues["_PRO_FILE_PWD_"] = QStringList() << proFilePwd();
     m_variableValues["OUT_PWD"] = QStringList() << outPwd();
 
     const QString qtInstallHeaders = QStringLiteral("QT_INSTALL_HEADERS");
     const QString qtVersion = QStringLiteral("QT_VERSION");
     const QString qtInstallLibs = QStringLiteral("QT_INSTALL_LIBS");
 
     const QString executable = QMakeConfig::qmakeExecutable(project());
     if (!m_qmakeQueryCache.contains(executable)) {
         const auto queryResult = QMakeConfig::queryQMake(executable, {qtInstallHeaders, qtVersion, qtInstallLibs});
         if (queryResult.isEmpty()) {
             qCWarning(KDEV_QMAKE) << "Failed to query qmake - bad qmake executable configured?" << executable;
         }
         m_qmakeQueryCache[executable] = queryResult;
     }
 
     const auto cachedQueryResult = m_qmakeQueryCache.value(executable);
     m_qtIncludeDir = cachedQueryResult.value(qtInstallHeaders);
     m_qtVersion = cachedQueryResult.value(qtVersion);
     m_qtLibDir = cachedQueryResult.value(qtInstallLibs);
 
     return QMakeFile::read();
 }
 
 QStringList QMakeProjectFile::subProjects() const
 {
     ifDebug(qCDebug(KDEV_QMAKE) << "Fetching subprojects";) QStringList list;
     foreach (QString subdir, variableValues("SUBDIRS")) {
         QString fileOrPath;
         ifDebug(qCDebug(KDEV_QMAKE) << "Found value:" << subdir;) if (containsVariable(subdir + ".file")
                                                                       && !variableValues(subdir + ".file").isEmpty())
         {
             subdir = variableValues(subdir + ".file").first();
         }
         else if (containsVariable(subdir + ".subdir") && !variableValues(subdir + ".subdir").isEmpty())
         {
             subdir = variableValues(subdir + ".subdir").first();
         }
         if (subdir.endsWith(".pro")) {
             fileOrPath = resolveToSingleFileName(subdir.trimmed());
         } else {
             fileOrPath = resolveToSingleFileName(subdir.trimmed());
         }
         if (fileOrPath.isEmpty()) {
             qCWarning(KDEV_QMAKE) << "could not resolve subdir" << subdir << "to file or path, skipping";
             continue;
         }
         list << fileOrPath;
     }
 
     ifDebug(qCDebug(KDEV_QMAKE) << "found" << list.size() << "subprojects";) return list;
 }
 
 bool QMakeProjectFile::hasSubProject(const QString& file) const
 {
     foreach (const QString& sub, subProjects()) {
         if (sub == file) {
             return true;
         } else if (QFileInfo(file).absoluteDir() == sub) {
             return true;
         }
     }
     return false;
 }
 
 void QMakeProjectFile::addPathsForVariable(const QString& variable, QStringList* list) const
 {
     const QStringList values = variableValues(variable);
     ifDebug(qCDebug(KDEV_QMAKE) << variable << values;) foreach (const QString& val, values)
     {
         QString path = resolveToSingleFileName(val);
         if (!path.isEmpty() && !list->contains(val)) {
             list->append(path);
         }
     }
 }
 
 QStringList QMakeProjectFile::includeDirectories() const
 {
     ifDebug(qCDebug(KDEV_QMAKE) << "Fetching include dirs" << m_qtIncludeDir;)
         ifDebug(qCDebug(KDEV_QMAKE) << "CONFIG" << variableValues("CONFIG");)
 
             QStringList list;
     addPathsForVariable("INCLUDEPATH", &list);
     addPathsForVariable("QMAKE_INCDIR", &list);
     if (variableValues("CONFIG").contains("opengl")) {
         addPathsForVariable("QMAKE_INCDIR_OPENGL", &list);
     }
     if (variableValues("CONFIG").contains("qt")) {
         if (!list.contains(m_qtIncludeDir))
             list << m_qtIncludeDir;
 
         QDir incDir(m_qtIncludeDir);
         auto modules = variableValues("QT");
         if (!modules.isEmpty() && !modules.contains("core")) {
             // TODO: proper dependency tracking of modules
             // for now, at least include core if we include any other module
             modules << "core";
         }
 
         // TODO: This is all very fragile, should rather read QMake module .pri files (e.g. qt_lib_core_private.pri)
         foreach (const QString& module, modules) {
             QString pattern = module;
 
             bool isPrivate = false;
             if (module.endsWith("-private")) {
                 pattern.chop(qstrlen("-private"));
                 isPrivate = true;
             } else if (module.endsWith("_private")) {
                 // _private is less common, but still a valid suffix
                 pattern.chop(qstrlen("_private"));
                 isPrivate = true;
             }
 
             if (pattern == "qtestlib" || pattern == "testlib") {
                 pattern = "QtTest";
             } else if (pattern == "qaxcontainer") {
                 pattern = "ActiveQt";
             } else if (pattern == "qaxserver") {
                 pattern = "ActiveQt";
             }
 
             QFileInfoList match = incDir.entryInfoList({QString("Qt%1").arg(pattern)}, QDir::Dirs);
             if (match.isEmpty()) {
                 // try non-prefixed pattern
                 match = incDir.entryInfoList({pattern}, QDir::Dirs);
                 if (match.isEmpty()) {
                     qCWarning(KDEV_QMAKE) << "unhandled Qt module:" << module << pattern;
                     continue;
                 }
             }
 
             QString path = match.first().canonicalFilePath();
             if (isPrivate) {
                 path += '/' + m_qtVersion + '/' + match.first().fileName() + "/private/";
             }
             if (!list.contains(path)) {
                 list << path;
             }
         }
     }
 
     if (variableValues("CONFIG").contains("thread")) {
         addPathsForVariable("QMAKE_INCDIR_THREAD", &list);
     }
     if (variableValues("CONFIG").contains("x11")) {
         addPathsForVariable("QMAKE_INCDIR_X11", &list);
     }
 
     addPathsForVariable("MOC_DIR", &list);
     addPathsForVariable("OBJECTS_DIR", &list);
     addPathsForVariable("UI_DIR", &list);
 
     ifDebug(qCDebug(KDEV_QMAKE) << "final list:" << list;) return list;
 }
 
 // Scan QMAKE_C*FLAGS for -F and -iframework and QMAKE_LFLAGS for good measure. Time will
 // tell if we need to scan the release/debug/... specific versions of QMAKE_C*FLAGS.
 // Also include QT_INSTALL_LIBS which corresponds to Qt's framework directory on OS X.
 QStringList QMakeProjectFile::frameworkDirectories() const
 {
     const auto variablesToCheck = {QStringLiteral("QMAKE_CFLAGS"),
                                     QStringLiteral("QMAKE_CXXFLAGS"),
                                     QStringLiteral("QMAKE_LFLAGS")};
     const QLatin1String fOption("-F");
     const QLatin1String iframeworkOption("-iframework");
     QStringList fwDirs;
     foreach (const auto& var, variablesToCheck) {
         bool storeArg = false;
         foreach (const auto& arg, variableValues(var)) {
             if (arg == fOption || arg == iframeworkOption) {
                 // detached -F/-iframework arg; set a warrant to store the next argument
                 storeArg = true;
             } else {
                 if (arg.startsWith(fOption)) {
                     fwDirs << arg.mid(fOption.size());
                 } else if (arg.startsWith(iframeworkOption)) {
                     fwDirs << arg.mid(iframeworkOption.size());
                 } else if (storeArg) {
                     fwDirs << arg;
                 }
                 // cancel any outstanding warrants to store the next argument
                 storeArg = false;
             }
         }
     }
 #ifdef Q_OS_OSX
     fwDirs << m_qtLibDir;
 #endif
     return fwDirs;
 }
 
 QStringList QMakeProjectFile::files() const
 {
     ifDebug(qCDebug(KDEV_QMAKE) << "Fetching files";)
 
         QStringList list;
     foreach (const QString& variable, QMakeProjectFile::FileVariables) {
         foreach (const QString& value, variableValues(variable)) {
             list += resolveFileName(value);
         }
     }
     ifDebug(qCDebug(KDEV_QMAKE) << "found" << list.size() << "files";) return list;
 }
 
 QStringList QMakeProjectFile::filesForTarget(const QString& s) const
 {
     ifDebug(qCDebug(KDEV_QMAKE) << "Fetching files";)
 
         QStringList list;
     if (variableValues("INSTALLS").contains(s)) {
         const QStringList files = variableValues(s + ".files");
         if (!files.isEmpty()) {
             foreach (const QString& val, files) {
                 list += QStringList(resolveFileName(val));
             }
         }
     }
     if (!variableValues("INSTALLS").contains(s) || s == "target") {
         foreach (const QString& variable, QMakeProjectFile::FileVariables) {
             foreach (const QString& value, variableValues(variable)) {
                 list += QStringList(resolveFileName(value));
             }
         }
     }
     ifDebug(qCDebug(KDEV_QMAKE) << "found" << list.size() << "files";) return list;
 }
 
 QString QMakeProjectFile::getTemplate() const
 {
     QString templ = "app";
     if (!variableValues("TEMPLATE").isEmpty()) {
         templ = variableValues("TEMPLATE").first();
     }
     return templ;
 }
 
 QStringList QMakeProjectFile::targets() const
 {
     ifDebug(qCDebug(KDEV_QMAKE) << "Fetching targets";)
 
         QStringList list;
 
     list += variableValues("TARGET");
     if (list.isEmpty() && getTemplate() != "subdirs") {
         list += QFileInfo(absoluteFile()).baseName();
     }
 
     foreach (const QString& target, variableValues("INSTALLS")) {
         if (!target.isEmpty() && target != "target")
             list << target;
     }
 
     if (list.removeAll(QString())) {
         // remove empty targets - which is probably a bug...
         qCWarning(KDEV_QMAKE) << "got empty entry in TARGET of file" << absoluteFile();
     }
 
     ifDebug(qCDebug(KDEV_QMAKE) << "found" << list.size() << "targets";) return list;
 }
 
 QMakeProjectFile::~QMakeProjectFile()
 {
     // TODO: delete cache, specs, ...?
 }
 
 QStringList QMakeProjectFile::resolveVariable(const QString& variable, VariableInfo::VariableType type) const
 {
     if (type == VariableInfo::QtConfigVariable) {
         if (m_mkspecs->isQMakeInternalVariable(variable)) {
             return QStringList() << m_mkspecs->qmakeInternalVariable(variable);
         } else {
             qCWarning(KDEV_QMAKE) << "unknown QtConfig Variable:" << variable;
             return QStringList();
         }
     }
 
     return QMakeFile::resolveVariable(variable, type);
 }
 
 QMakeMkSpecs* QMakeProjectFile::mkSpecs() const
 {
     return m_mkspecs;
 }
 
 QMakeCache* QMakeProjectFile::qmakeCache() const
 {
     return m_cache;
 }
 
 QList<QMakeProjectFile::DefinePair> QMakeProjectFile::defines() const
 {
     QList<DefinePair> d;
     foreach (QString def, variableMap()["DEFINES"]) {
         int pos = def.indexOf('=');
         if (pos >= 0) {
             // a value is attached to define
             d.append(DefinePair(def.left(pos), def.right(def.length() - (pos + 1))));
         } else {
             // a value-less define
             d.append(DefinePair(def, ""));
         }
     }
     return d;
 }
 
 QString QMakeProjectFile::pwd() const
 {
     return absoluteDir();
 }
 
 QString QMakeProjectFile::outPwd() const
 {
     if (!project()) {
         return absoluteDir();
     } else {
         return QMakeConfig::buildDirFromSrc(project(), KDevelop::Path(absoluteDir())).toLocalFile();
     }
 }
 
 QString QMakeProjectFile::proFile() const
 {
     return absoluteFile();
 }
 
 QString QMakeProjectFile::proFilePwd() const
 {
     return absoluteDir();
 }
diff --git a/projectmanagers/qmake/tests/test_qmakeproject.cpp b/projectmanagers/qmake/tests/test_qmakeproject.cpp
index 15cbe6b5ac..ff4b247acb 100644
--- a/projectmanagers/qmake/tests/test_qmakeproject.cpp
+++ b/projectmanagers/qmake/tests/test_qmakeproject.cpp
@@ -1,145 +1,145 @@
 /* KDevelop QMake Support
  *
  * Copyright 2011 Julien Desgats <julien.desgats@gmail.com>
  *
  * 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 "test_qmakeproject.h"
 #include "../qmakeconfig.h"
 #include "qmaketestconfig.h"
 
 #include <shell/core.h>
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <project/interfaces/iprojectbuilder.h>
 #include <project/projectmodel.h>
 #include <serialization/indexedstring.h>
 
 #include <QFileInfo>
 #include <QTest>
 #include <QSignalSpy>
 #include <KConfigGroup>
-#include <kio/deletejob.h>
+#include <KJob>
 
 QTEST_MAIN(TestQMakeProject);
 
 using namespace KDevelop;
 
 TestQMakeProject::TestQMakeProject(QObject* parent)
     : QObject(parent)
 {
     qRegisterMetaType<IProject*>();
 }
 
 TestQMakeProject::~TestQMakeProject()
 {
 }
 
 void TestQMakeProject::initTestCase()
 {
     AutoTestShell::init({ "kdevqmakemanager" });
     TestCore::initialize();
 }
 
 void TestQMakeProject::cleanupTestCase()
 {
     Core::self()->cleanup();
 }
 
 void TestQMakeProject::testBuildDirectory_data()
 {
     QTest::addColumn<QString>("projectName"); // name of the project (both directory and .kde4 file)
     QTest::addColumn<QString>("target"); // directory to compile from project root
     QTest::addColumn<QString>("expected"); // expected build directory from build dir
 
     QTest::newRow("Basic Project") << "basic_project"
                                    << ""
                                    << "";
     QTest::newRow("Subdirs Project (root)") << "subdirs_project"
                                             << ""
                                             << "";
     QTest::newRow("Subdirs Project (dir_a)") << "subdirs_project"
                                              << "dir_a"
                                              << "dir_a";
 }
 
 void TestQMakeProject::testBuildDirectory()
 {
     QFETCH(QString, projectName);
     QFETCH(QString, target);
     QFETCH(QString, expected);
 
     const QString buildDir = "/tmp/some/path"; // some dummy directory to build (nothing will be built anyway)
 
     foreach (IProject* p, ICore::self()->projectController()->projects()) {
         ICore::self()->projectController()->closeProject(p);
     }
 
     // setup project config, to avoid build dir chooser dialog popping up
     {
         // note: all checks from QMakeProjectManager::projectNeedsConfiguration must be satisfied
         const QString fileName
             = QString("%1/%2/.kdev4/%3.kdev4").arg(QMAKE_TESTS_PROJECTS_DIR).arg(projectName).arg(projectName);
 
         KConfig cfg(fileName);
         KConfigGroup group(&cfg, QMakeConfig::CONFIG_GROUP);
 
         group.writeEntry(QMakeConfig::BUILD_FOLDER, buildDir);
         group.writeEntry(QMakeConfig::QMAKE_EXECUTABLE, QMAKE_TESTS_QMAKE_EXECUTABLE);
         group.sync();
 
         /// create subgroup for one build dir
         KConfigGroup buildDirGroup = KConfigGroup(&cfg, QMakeConfig::CONFIG_GROUP).group(buildDir);
         buildDirGroup.writeEntry(QMakeConfig::QMAKE_EXECUTABLE, QMAKE_TESTS_QMAKE_EXECUTABLE);
         buildDirGroup.sync();
 
         QVERIFY(QFileInfo::exists(fileName));
     }
 
     // opens project with kdevelop
     const QUrl projectUrl = QUrl::fromLocalFile(
         QString("%1/%2/%3.kdev4").arg(QMAKE_TESTS_PROJECTS_DIR).arg(projectName).arg(projectName));
     ICore::self()->projectController()->openProject(projectUrl);
 
     // wait for loading finished
     QSignalSpy spy(ICore::self()->projectController(), SIGNAL(projectOpened(KDevelop::IProject*)));
     bool gotSignal = spy.wait(30000);
     QVERIFY2(gotSignal, "Timeout while waiting for opened signal");
 
     IProject* project = ICore::self()->projectController()->findProjectByName(projectName);
 
     // adds expected directory to our base path
     Path expectedPath(Path(buildDir), expected);
 
     // path for files to build
     Path buildUrl(QString("%1/%2/%3").arg(QMAKE_TESTS_PROJECTS_DIR).arg(projectName).arg(target));
     QList<ProjectFolderItem*> buildItems = project->foldersForPath(IndexedString(buildUrl.pathOrUrl()));
     QCOMPARE(buildItems.size(), 1);
     IBuildSystemManager* buildManager = project->buildSystemManager();
     const auto buildFolder = buildItems.first();
 
     const Path actual = buildManager->buildDirectory(buildFolder);
 
     QCOMPARE(actual, expectedPath);
 
     auto buildJob = buildManager->builder()->configure(project);
     QVERIFY(buildJob->exec());
 }
diff --git a/projectmanagers/qmake/variablereferenceparser.h b/projectmanagers/qmake/variablereferenceparser.h
index e7531b7520..98761ccd06 100644
--- a/projectmanagers/qmake/variablereferenceparser.h
+++ b/projectmanagers/qmake/variablereferenceparser.h
@@ -1,71 +1,72 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright (C) 2007 Andreas Pakulat <apaku@gmx.de>                     *
  *                                                                         *
  *   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 VARIABLEREFERENCEPARSER_H
 #define VARIABLEREFERENCEPARSER_H
 
 #include <QList>
 #include <QMap>
 #include <QString>
-#include <QStringList>
+
+class QStringList;
 
 class VariableInfo
 {
 public:
     enum VariableType
     {
         QMakeVariable,
         QtConfigVariable,
         ShellVariableResolveQMake,
         ShellVariableResolveMake,
         FunctionCall,
         Invalid
     };
 
     struct Position {
         Position(int start_, int end_)
             : start(start_), end(end_)
         {
         }
         int start;
         int end;
     };
 
     VariableInfo();
     QList< Position > positions;
     VariableType type;
 };
 
 class VariableReferenceParser
 {
     public:
         VariableReferenceParser();
         void setContent( const QString& );
         bool parse();
         QStringList variableReferences() const;
         VariableInfo variableInfo( const QString& ) const;
     private:
         void appendPosition( const QString&, int, int, VariableInfo::VariableType );
         QString m_content;
         QMap< QString, VariableInfo > m_variables;
 };
 
 #endif
 
diff --git a/providers/ghprovider/ghaccount.cpp b/providers/ghprovider/ghaccount.cpp
index 7eb12d1c6f..9a17e9b838 100644
--- a/providers/ghprovider/ghaccount.cpp
+++ b/providers/ghprovider/ghaccount.cpp
@@ -1,90 +1,89 @@
 /* This file is part of KDevelop
  *
  * Copyright (C) 2012-2013 Miquel Sabaté <mikisabate@gmail.com>
  *
  * 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 <KConfig>
-#include <KSharedConfig>
-
 #include <ghaccount.h>
+
 #include <ghresource.h>
 #include <ghproviderplugin.h>
 
+#include <KSharedConfig>
 
 namespace gh
 {
 
 Account::Account(Resource *resource)
 {
     m_group = KConfigGroup(KSharedConfig::openConfig(), "ghprovider");
     m_resource = resource;
 }
 
 void Account::invalidate(const QString &password)
 {
     const QString &id = m_group.readEntry("id", QString());
     if (!id.isEmpty())
         m_resource->revokeAccess(id, name(), password);
     m_group.writeEntry("name", "");
     m_group.writeEntry("id", "");
     m_group.writeEntry("token", "");
     m_group.writeEntry("created_at", "");
     m_group.writeEntry("orgs", "");
 }
 
 bool Account::validAccount() const
 {
     return !m_group.readEntry("id", QString()).isEmpty();
 }
 
 void Account::setName(const QString &name)
 {
     m_group.writeEntry("name", name);
 }
 
 const QString Account::name() const
 {
     return m_group.readEntry("name", QString());
 }
 
 void Account::setOrgs(const QStringList &orgs)
 {
     QString res = orgs.join(",");
     m_group.writeEntry("orgs", orgs);
 }
 
 const QStringList Account::orgs() const
 {
     const QString orgs = m_group.readEntry("orgs", QString());
     if (orgs.isEmpty())
         return QStringList();
     return orgs.split(",");
 }
 
 void Account::saveToken(const QByteArray &id, const QByteArray &token)
 {
     m_group.writeEntry("id", id);
     m_group.writeEntry("token", token);
 }
 
 const QString Account::token() const
 {
     return m_group.readEntry("token", QString());
 }
 
 } // End of namespace gh
diff --git a/providers/ghprovider/ghdialog.cpp b/providers/ghprovider/ghdialog.cpp
index ae8634cb49..44b5e996a9 100644
--- a/providers/ghprovider/ghdialog.cpp
+++ b/providers/ghprovider/ghdialog.cpp
@@ -1,184 +1,183 @@
 /* This file is part of KDevelop
  *
  * Copyright (C) 2012-2013 Miquel Sabaté <mikisabate@gmail.com>
  *
  * 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 <QLabel>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
-#include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KPasswordDialog>
 
 #include <ghdialog.h>
 #include <ghaccount.h>
 #include <ghresource.h>
 
 static QString invalidAccountText()
 {
     return i18n("You have not authorized KDevelop to use your GitHub account. "
                 "If you authorize KDevelop, you will be able to fetch your "
                 "public/private repositories and the repositories from your "
                 "organizations.");
 }
 
 static QString tokenLinkStatementText()
 {
     return i18nc("%1 is the URL with the GitHub token settings",
                  "You can check the authorization for this application and "
                  "others at %1",
                  QStringLiteral("https://github.com/settings/tokens."));
 }
 
 namespace gh
 {
 
 Dialog::Dialog(QWidget *parent, Account *account)
     : QDialog(parent)
     , m_account(account)
 {
     auto mainWidget = new QWidget(this);
     auto mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
     mainLayout->addWidget(mainWidget);
 
     auto buttonBox = new QDialogButtonBox();
 
     if (m_account->validAccount()) {
         m_text = new QLabel(i18n("You are logged in as <b>%1</b>.<br/>%2",
                                  m_account->name(), tokenLinkStatementText()), this);
 
         auto logOutButton = new QPushButton;
         logOutButton->setText(i18n("Log Out"));
         logOutButton->setIcon(QIcon::fromTheme("dialog-cancel"));
         buttonBox->addButton(logOutButton, QDialogButtonBox::ActionRole);
         connect(logOutButton, &QPushButton::clicked, this, &Dialog::revokeAccess);
 
         auto forceSyncButton = new QPushButton;
         forceSyncButton->setText(i18n("Force Sync"));
         forceSyncButton->setIcon(QIcon::fromTheme("view-refresh"));
         buttonBox->addButton(forceSyncButton, QDialogButtonBox::ActionRole);
         connect(forceSyncButton, &QPushButton::clicked, this, &Dialog::syncUser);
 
         connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
         connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
     } else {
         m_text = new QLabel(invalidAccountText(), this);
 
         buttonBox->addButton(QDialogButtonBox::Cancel);
 
         auto authorizeButton = new QPushButton;
         buttonBox->addButton(authorizeButton, QDialogButtonBox::ActionRole);
         authorizeButton->setText(i18n("Authorize"));
         authorizeButton->setIcon(QIcon::fromTheme("dialog-ok"));
         connect(authorizeButton, &QPushButton::clicked, this, &Dialog::authorizeClicked);
     }
 
     m_text->setWordWrap(true);
     m_text->setOpenExternalLinks(true);
     setMinimumWidth(350);
     mainLayout->addWidget(m_text);
 
     mainLayout->addWidget(buttonBox);
     connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
     connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
 
     setWindowTitle(i18n("GitHub Account"));
 }
 
 void Dialog::authorizeClicked()
 {
     KPasswordDialog dlg(this, KPasswordDialog::ShowUsernameLine);
     dlg.setPrompt(i18n("Enter a login and a password"));
     if(!dlg.exec())
         return;
 
     m_text->setAlignment(Qt::AlignCenter);
     m_text->setText(i18n("Waiting for response"));
     m_account->setName(dlg.username());
 
     Resource *rs = m_account->resource();
     rs->authenticate(dlg.username(), dlg.password());
     connect(rs, &Resource::authenticated,
             this, &Dialog::authorizeResponse);
 }
 
 void Dialog::authorizeResponse(const QByteArray &id, const QByteArray &token, const QString &tokenName)
 {
     Q_UNUSED(tokenName);
 
     Resource *rs = m_account->resource();
     disconnect(rs, &Resource::authenticated,
                this, &Dialog::authorizeResponse);
 
     if (id.isEmpty()) {
         m_text->setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
         m_text->setText(invalidAccountText());
         m_account->setName(QString());
         KMessageBox::sorry(this, i18n("Authentication failed. Please try again.\n\n"
                                       "Could not create token: \"%1\"\n%2", tokenName,
                                       tokenLinkStatementText()),
                                  i18n("GitHub Authorization Failed"));
         return;
     }
     else{
         KMessageBox::information(this, i18n("Authentication succeeded.\n\n"
                                             "Created token: \"%1\"\n%2", tokenName,
                                             tokenLinkStatementText()),
                                        i18n("GitHub Account Authorized"));
     }
     m_account->saveToken(id, token);
     syncUser();
 }
 
 void Dialog::syncUser()
 {
     Resource *rs = m_account->resource();
     connect(rs, &Resource::orgsUpdated,
             this, &Dialog::updateOrgs);
     m_text->setAlignment(Qt::AlignCenter);
     m_text->setText(i18n("Waiting for response"));
     rs->getOrgs(m_account->token());
 }
 
 void Dialog::updateOrgs(const QStringList orgs)
 {
     Resource *rs = m_account->resource();
     disconnect(rs, &Resource::orgsUpdated,
               this, &Dialog::updateOrgs);
 
     if (!orgs.isEmpty())
         m_account->setOrgs(orgs);
     emit shouldUpdate();
     close();
 }
 
 void Dialog::revokeAccess()
 {
     KPasswordDialog dlg(this);
     dlg.setPrompt(i18n("Please, write your password here."));
     if(!dlg.exec())
         return;
     m_account->invalidate(dlg.password());
     emit shouldUpdate();
     close();
 }
 
 } // End of namespace gh
diff --git a/providers/ghprovider/ghproviderplugin.cpp b/providers/ghprovider/ghproviderplugin.cpp
index 698398597c..26640bcc54 100644
--- a/providers/ghprovider/ghproviderplugin.cpp
+++ b/providers/ghprovider/ghproviderplugin.cpp
@@ -1,61 +1,60 @@
 /* This file is part of KDevelop
  *
  * Copyright (C) 2012-2013 Miquel Sabaté <mikisabate@gmail.com>
  *
  * 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 <KLocalizedString>
-#include <KAboutData>
 #include <KPluginFactory>
 
 #include "debug.h"
 #include <ghproviderplugin.h>
 #include <ghproviderwidget.h>
 
 using namespace KDevelop;
 
 K_PLUGIN_FACTORY_WITH_JSON(KDevGHProviderFactory, "kdevghprovider.json", registerPlugin<gh::ProviderPlugin>();)
 
 Q_LOGGING_CATEGORY(GHPROVIDER, "kdevelop.providers.ghprovider")
 
 namespace gh
 {
 
 ProviderPlugin::ProviderPlugin(QObject *parent, const QList<QVariant> &args)
     : IPlugin("kdevghprovider", parent)
 {
     Q_UNUSED(args);
 }
 
 ProviderPlugin::~ProviderPlugin()
 {
     /* There's nothing to do here! */
 }
 
 QString ProviderPlugin::name() const
 {
     return i18n("GitHub");
 }
 
 IProjectProviderWidget * ProviderPlugin::providerWidget(QWidget *parent)
 {
     return new ProviderWidget(parent);
 }
 
 } // End of namespace gh
 
 #include "ghproviderplugin.moc"
diff --git a/providers/kdeprovider/kdeprojectsmodel.cpp b/providers/kdeprovider/kdeprojectsmodel.cpp
index 3ef6342cfa..c1f8a05b68 100644
--- a/providers/kdeprovider/kdeprojectsmodel.cpp
+++ b/providers/kdeprovider/kdeprojectsmodel.cpp
@@ -1,52 +1,51 @@
 /* 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 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 "kdeprojectsmodel.h"
 #include <QIcon>
-#include <QUrl>
 #include <vcs/vcslocation.h>
 
 using namespace KDevelop;
 
 SourceItem::SourceItem(const Source& s)
     : QStandardItem(QIcon::fromTheme(s.icon), s.name), m_s(s)
 {
     Q_ASSERT(!m_s.name.isEmpty());
 }
 
 QVariant SourceItem::data(int role) const
 {
     switch(role)
     {
         case KDEProjectsModel::IdentifierRole:
             return m_s.identifier;
         case KDEProjectsModel::VcsLocationRole:
             return QVariantMap(m_s.m_urls);
         default:
             return QStandardItem::data(role);
     }
 }
 
 Source::Source(const SourceType& aType, const QString& anIcon, const QString& aName, const QPair<QString, QString>& aUrl)
     : type(aType), name(aName), icon(anIcon)
 {
     m_urls[aUrl.first] = aUrl.second;
 }
 
 KDEProjectsModel::KDEProjectsModel(QObject* parent): QStandardItemModel(parent)
 {}
diff --git a/providers/kdeprovider/kdeproviderplugin.cpp b/providers/kdeprovider/kdeproviderplugin.cpp
index 72c77ba85b..183415ddd6 100644
--- a/providers/kdeprovider/kdeproviderplugin.cpp
+++ b/providers/kdeprovider/kdeproviderplugin.cpp
@@ -1,52 +1,50 @@
 /*
  * This file is part of KDevelop
  * Copyright 2010 Aleix Pol Gonzalez <aleixpol@kde.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 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 "kdeproviderplugin.h"
 #include <QVariantList>
 
 #include <kpluginfactory.h>
-#include <kpluginloader.h>
-#include <kaboutdata.h>
 #include <KLocalizedString>
 #include "kdeproviderwidget.h"
 
 using namespace KDevelop;
 
 K_PLUGIN_FACTORY_WITH_JSON(KDevKDEProviderFactory, "kdevkdeprovider.json", registerPlugin<KDEProviderPlugin>(); )
 
 KDEProviderPlugin::KDEProviderPlugin ( QObject* parent, const QVariantList& ) 
     : IPlugin ( "kdevkdeprovider", parent )
 {
 }
 
 KDEProviderPlugin::~KDEProviderPlugin()
 {}
 
 QString KDEProviderPlugin::name() const
 {
     return i18n("KDE");
 }
 
 KDevelop::IProjectProviderWidget* KDEProviderPlugin::providerWidget(QWidget* parent)
 {
     return new KDEProviderWidget(parent);
 }
 
 #include "kdeproviderplugin.moc"
diff --git a/providers/kdeprovider/kdeproviderwidget.cpp b/providers/kdeprovider/kdeproviderwidget.cpp
index b80cce1042..d885ba488e 100644
--- a/providers/kdeprovider/kdeproviderwidget.cpp
+++ b/providers/kdeprovider/kdeproviderwidget.cpp
@@ -1,135 +1,134 @@
 /*
  * This file is part of KDevelop
  * Copyright 2010 Aleix Pol Gonzalez <aleixpol@kde.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 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 "kdeproviderwidget.h"
 #include <QVBoxLayout>
 #include <QListView>
 #include <QPushButton>
 #include <KConfigDialog>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <vcs/interfaces/ibasicversioncontrol.h>
 #include "ui_kdeconfig.h"
 #include "kdeconfig.h"
-#include <QStandardItemModel>
 #include "kdeprojectsmodel.h"
 #include "kdeprojectsreader.h"
 #include <QSortFilterProxyModel>
 #include <KFilterProxySearchLine>
 #include <KMessageBox>
 #include <KLocalizedString>
 
 using namespace KDevelop;
 
 KDEProviderWidget::KDEProviderWidget(QWidget* parent)
     : IProjectProviderWidget(parent)
 {
     setLayout(new QVBoxLayout);
     m_projects = new QListView(this);
     QHBoxLayout* topLayout = new QHBoxLayout;
     KFilterProxySearchLine* filterLine = new KFilterProxySearchLine(this);
     KDEProjectsModel* model = new KDEProjectsModel(this);
     KDEProjectsReader* reader = new KDEProjectsReader(model, model);
     connect(reader, &KDEProjectsReader::downloadDone, reader, &KDEProjectsReader::deleteLater);
     connect(m_projects, &QListView::clicked, this, &KDEProviderWidget::projectIndexChanged);
 
     topLayout->addWidget(filterLine);
 
     
     QPushButton* settings=new QPushButton(QIcon::fromTheme("configure"), i18n("Settings"), this);
     settings->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
     connect(settings, &QPushButton::clicked, this, &KDEProviderWidget::showSettings);
 
     topLayout->addWidget(settings);
     
     layout()->addItem(topLayout);
     layout()->addWidget(m_projects);
     
     QSortFilterProxyModel* proxyModel = new QSortFilterProxyModel(this);
     proxyModel->setSourceModel(model);
     proxyModel->setDynamicSortFilter(true);
     proxyModel->sort(0);
     proxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
     m_projects->setModel(proxyModel);
     m_projects->setEditTriggers(QAbstractItemView::NoEditTriggers);
     filterLine->setProxy(proxyModel);
 }
 
 VcsLocation extractLocation(const QModelIndex& pos)
 {
     QString gitUrl=KDEProviderSettings::self()->gitProtocol();
     if(gitUrl=="kde:") {
         return VcsLocation(QUrl("kde:"+pos.data(KDEProjectsModel::IdentifierRole).toString()));
     } else {
         QMap<QString, QVariant> urls = pos.data(KDEProjectsModel::VcsLocationRole).toMap();
         return VcsLocation(urls[gitUrl].toUrl());
     }
 }
 
 VcsJob* KDEProviderWidget::createWorkingCopy(const QUrl &destinationDirectory)
 {
     QModelIndex pos = m_projects->currentIndex();
     if(!pos.isValid())
         return nullptr;
     
     IPlugin* plugin = ICore::self()->pluginController()->pluginForExtension("org.kdevelop.IBasicVersionControl", "kdevgit");
     if (!plugin) {
         KMessageBox::error(nullptr, i18n("The Git plugin could not be loaded which is required to download a KDE project."), i18n("KDE Provider Error"));
         return nullptr;
     }
     IBasicVersionControl* vcIface = plugin->extension<IBasicVersionControl>();
     VcsJob* ret = vcIface->createWorkingCopy(extractLocation(pos), destinationDirectory);
     
     return ret;
 }
 
 bool KDEProviderWidget::isCorrect() const
 {
     return m_projects->currentIndex().isValid();
 }
 
 void KDEProviderWidget::showSettings()
 {
     KConfigDialog* dialog = new KConfigDialog(this, "settings", KDEProviderSettings::self());
     dialog->setFaceType(KPageDialog::Auto);
     QWidget* page = new QWidget(dialog);
 
     Ui::KDEConfig configUi;
     configUi.setupUi(page);
     configUi.kcfg_gitProtocol->setProperty("kcfg_property", QByteArray("currentText"));
     int idx = configUi.kcfg_gitProtocol->findText(KDEProviderSettings::self()->gitProtocol());
     if(idx>=0) {
         configUi.kcfg_gitProtocol->setCurrentIndex(idx);
     }
     
 //     TODO port to KF5
 //     dialog->button(KDialog::Default)->setVisible(false);
     dialog->addPage(page, i18n("General") );
     dialog->show();
 }
 
 void KDEProviderWidget::projectIndexChanged(const QModelIndex& currentIndex)
 {
     if (currentIndex.isValid()) {
         QString currentProjectName = currentIndex.data(Qt::DisplayRole).toString();
 
         emit changed(currentProjectName);
     }
 }
diff --git a/providers/kdeprovider/kdeproviderwidget.h b/providers/kdeprovider/kdeproviderwidget.h
index 081d7a4604..95eb6005d6 100644
--- a/providers/kdeprovider/kdeproviderwidget.h
+++ b/providers/kdeprovider/kdeproviderwidget.h
@@ -1,47 +1,46 @@
 /*
  * This file is part of KDevelop
  * Copyright 2010 Aleix Pol Gonzalez <aleixpol@kde.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 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 KDEPROVIDERWIDGET_H
 #define KDEPROVIDERWIDGET_H
 
 #include <interfaces/iprojectprovider.h>
 
 class QModelIndex;
-class KConfigDialog;
 class KFilterProxySearchLine;
 class QListView;
 class KDEProviderWidget : public KDevelop::IProjectProviderWidget
 {
     Q_OBJECT
     public:
         explicit KDEProviderWidget(QWidget* parent = nullptr);
         
         KDevelop::VcsJob* createWorkingCopy(const QUrl &destinationDirectory) override;
         bool isCorrect() const override;
         
     private slots:
         void showSettings();
         void projectIndexChanged(const QModelIndex& currentIndex);
         
     private:
         QListView* m_projects;
 };
 
 #endif // KDEPROVIDERWIDGET_H
diff --git a/utils/okteta/oktetadocument.h b/utils/okteta/oktetadocument.h
index c1f0f4953f..2b823ab9e4 100644
--- a/utils/okteta/oktetadocument.h
+++ b/utils/okteta/oktetadocument.h
@@ -1,100 +1,98 @@
 /*
     This file is part of the KDevelop Okteta module, part of the KDE project.
 
     Copyright 2010 Friedrich W. H. Kossebau <kossebau@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 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 6 of version 3 of the license.
 
     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
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef OKTETADOCUMENT_H
 #define OKTETADOCUMENT_H
 
 // Kasten core
 #include <kasten/kastencore.h>
 // KDevPlatform
 #include <sublime/urldocument.h>
 #include <interfaces/idocument.h>
-//Qt
-#include <QtCore/QList>
 
 namespace Kasten {
 class ByteArrayDocument;
 class AbstractDocument;
 }
 
 namespace KDevelop
 {
 class ICore;
 class OktetaPlugin;
 
 
 class OktetaDocument : public Sublime::UrlDocument, public IDocument
 {
     Q_OBJECT
 
   public:
     OktetaDocument( const QUrl &url, ICore* core );
 
     ~OktetaDocument() override;
 
   public: // KDevelop::IDocument API
     KTextEditor::Cursor cursorPosition() const override;
     bool isActive() const override;
     QMimeType mimeType() const override;
     KParts::Part* partForView( QWidget* widget ) const override;
     DocumentState state() const override;
     KTextEditor::Document* textDocument() const override;
     QUrl url() const override;
 
     void activate( Sublime::View* view, KParts::MainWindow* mainWindow ) override;
     bool close( IDocument::DocumentSaveMode = IDocument::Default ) override;
     void reload() override;
     bool save( IDocument::DocumentSaveMode = IDocument::Default ) override;
     void setCursorPosition( const KTextEditor::Cursor& cursor ) override;
     void setTextSelection( const KTextEditor::Range& range ) override;
 
   public: // Sublime::Document API
     bool closeDocument(bool silent) override;
 
   public:
     OktetaPlugin* plugin() const;
     Kasten::ByteArrayDocument* byteArrayDocument() const;
 
   public:
     void setPlugin( OktetaPlugin* plugin );
 
   protected Q_SLOTS: // Sublime::Document API
     Sublime::View* newView( Sublime::Document* document ) override;
 
   protected Q_SLOTS:
     void onByteArrayDocumentChanged();
     // Moc is too primitive to know about namespace aliase
     void onByteArrayDocumentLoaded( Kasten::AbstractDocument* document );
 
   private:
     OktetaPlugin* mPlugin;
 
     Kasten::ByteArrayDocument* mByteArrayDocument;
 };
 
 
 inline OktetaPlugin* OktetaDocument::plugin() const { return mPlugin; }
 inline Kasten::ByteArrayDocument* OktetaDocument::byteArrayDocument() const { return mByteArrayDocument; }
 
 }
 
 #endif
diff --git a/utils/okteta/oktetaplugin.cpp b/utils/okteta/oktetaplugin.cpp
index 07cd1a68ee..43d9b35084 100644
--- a/utils/okteta/oktetaplugin.cpp
+++ b/utils/okteta/oktetaplugin.cpp
@@ -1,154 +1,154 @@
 /*
     This file is part of the KDevelop Okteta module, part of the KDE project.
 
     Copyright 2010 Friedrich W. H. Kossebau <kossebau@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 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 6 of version 3 of the license.
 
     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
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "oktetaplugin.h"
 
 // plugin
 #include "oktetadocumentfactory.h"
 #include "oktetatoolviewfactory.h"
 #include "oktetadocument.h"
 // Okteta Kasten tools
 #include <kasten/okteta/stringsextracttoolviewfactory.h>
 #include <kasten/okteta/stringsextracttoolfactory.h>
 #include <kasten/okteta/infotoolviewfactory.h>
 #include <kasten/okteta/infotoolfactory.h>
 #include <kasten/okteta/filtertoolviewfactory.h>
 #include <kasten/okteta/filtertoolfactory.h>
 #include <kasten/okteta/checksumtoolviewfactory.h>
 #include <kasten/okteta/checksumtoolfactory.h>
 // #include <documentinfotoolview.h>
 // #include <documentinfotool.h>
 #include <kasten/okteta/poddecodertoolviewfactory.h>
 #include <kasten/okteta/poddecodertoolfactory.h>
 #include <kasten/okteta/bytetabletoolviewfactory.h>
 #include <kasten/okteta/bytetabletoolfactory.h>
 #include <kasten/okteta/bookmarkstoolviewfactory.h>
 #include <kasten/okteta/bookmarkstoolfactory.h>
 #ifndef BIG_ENDIAN
 #include <kasten/okteta/structurestoolviewfactory.h>
 #include <kasten/okteta/structurestoolfactory.h>
 #endif
 // Okteta Kasten
 #include <kasten/okteta/bytearrayviewprofilemanager.h>
 // KDev
 #include <project/projectmodel.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/context.h>
 // KDE
-#include <KAboutData>
 #include <KPluginFactory>
 #include <KLocalizedString>
 
+#include <QMimeType>
 #include <QAction>
 
 K_PLUGIN_FACTORY_WITH_JSON(OktetaPluginFactory, "kdevokteta.json", registerPlugin<KDevelop::OktetaPlugin>(); )
 
 namespace KDevelop
 {
 
 static inline
 void addTool( IUiController* uiController,
               Kasten::AbstractToolViewFactory* toolViewFactory,
               Kasten::AbstractToolFactory* toolFactory )
 {
     OktetaToolViewFactory* factory =
         new OktetaToolViewFactory( toolViewFactory, toolFactory );
 
     uiController->addToolView( toolViewFactory->title(), factory );
 }
 
 
 OktetaPlugin::OktetaPlugin( QObject* parent, const QVariantList& args )
   : IPlugin( "kdevokteta", parent )
   , mDocumentFactory( new OktetaDocumentFactory(this) )
   , mViewProfileManager( new Kasten::ByteArrayViewProfileManager() )
 {
     Q_UNUSED(args)
 
     IUiController* uiController = core()->uiController();
     addTool( uiController, new Kasten::ChecksumToolViewFactory(), new Kasten::ChecksumToolFactory() );
     addTool( uiController, new Kasten::FilterToolViewFactory(), new Kasten::FilterToolFactory() );
     addTool( uiController, new Kasten::StringsExtractToolViewFactory, new Kasten::StringsExtractToolFactory() );
     addTool( uiController, new Kasten::ByteTableToolViewFactory(), new Kasten::ByteTableToolFactory() );
     addTool( uiController, new Kasten::InfoToolViewFactory(), new Kasten::InfoToolFactory() );
     addTool( uiController, new Kasten::PodDecoderToolViewFactory(), new Kasten::PodDecoderToolFactory() );
 // disable Okteta Structures tool on big-endian as it's disable in kdesdk
 #ifndef BIG_ENDIAN
     addTool( uiController, new Kasten::StructuresToolViewFactory(), new Kasten::StructuresToolFactory() );
 #endif
     addTool( uiController, new Kasten::BookmarksToolViewFactory, new Kasten::BookmarksToolFactory() );
 
     KDevelop::IDocumentController* documentController = core()->documentController();
     documentController->registerDocumentForMimetype("application/octet-stream", mDocumentFactory);
 }
 
 ContextMenuExtension OktetaPlugin::contextMenuExtension( Context* context )
 {
     OpenWithContext* openWithContext = dynamic_cast<OpenWithContext*>( context );
 
     if( openWithContext && !openWithContext->mimeType().inherits("inode/directory"))
     {
         QAction* openAction = new QAction( i18n("Hex Editor"), this );
         openAction->setIcon( QIcon::fromTheme("document-open") );
         openAction->setData( QVariant::fromValue(openWithContext->urls()) );
         connect( openAction, &QAction::triggered, this, &OktetaPlugin::onOpenTriggered );
 
         KDevelop::ContextMenuExtension contextMenuExtension;
         contextMenuExtension.addAction( KDevelop::ContextMenuExtension::OpenEmbeddedGroup, openAction );
         return contextMenuExtension;
     }
 
     return KDevelop::IPlugin::contextMenuExtension( context );
 }
 
 void OktetaPlugin::onOpenTriggered()
 {
     QAction* action = qobject_cast<QAction*>(sender());
     Q_ASSERT(action);
 
     KDevelop::ICore* core = KDevelop::ICore::self();
     IDocumentController* documentController = core->documentController();
 
     foreach( const QUrl &url, action->data().value<QList<QUrl>>() )
     {
         IDocument* existingDocument = documentController->documentForUrl(url);
         if( existingDocument )
             if( ! existingDocument->close() )
                 continue;
 
         IDocument* createdDocument = mDocumentFactory->create( url, core );
         if( createdDocument )
             documentController->openDocument( createdDocument );
     }
 }
 
 OktetaPlugin::~OktetaPlugin()
 {
     delete mDocumentFactory;
 }
 
 }
 
 #include "oktetaplugin.moc"
diff --git a/utils/okteta/oktetaplugin.h b/utils/okteta/oktetaplugin.h
index c8f03df516..a04b632f8b 100644
--- a/utils/okteta/oktetaplugin.h
+++ b/utils/okteta/oktetaplugin.h
@@ -1,67 +1,65 @@
 /*
     This file is part of the KDevelop Okteta module, part of the KDE project.
 
     Copyright 2010 Friedrich W. H. Kossebau <kossebau@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 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 6 of version 3 of the license.
 
     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
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef OKTETAPLUGIN_H
 #define OKTETAPLUGIN_H
 
 // KDev
 #include <interfaces/iplugin.h>
 // Qt
 #include <QtCore/QVariantList>
 
-class QUrl;
-
 namespace Kasten
 {
 class ByteArrayViewProfileManager;
 }
 
 namespace KDevelop
 {
 class OktetaDocumentFactory;
 
 
 class OktetaPlugin: public IPlugin
 {
     Q_OBJECT
 
   public:
     explicit OktetaPlugin( QObject* parent, const QVariantList& args = QVariantList() );
 
     ~OktetaPlugin() override;
 
   public: // KDevelop::IPlugin API
     ContextMenuExtension contextMenuExtension( Context* context ) override;
 
   public:
     Kasten::ByteArrayViewProfileManager* viewProfileManager() const { return mViewProfileManager; }
 
   private Q_SLOTS:
     void onOpenTriggered();
 
   protected:
     OktetaDocumentFactory* mDocumentFactory;
     Kasten::ByteArrayViewProfileManager* const mViewProfileManager;
 };
 
 }
 #endif