diff --git a/kdevplatform/language/duchain/tests/test_duchain.cpp b/kdevplatform/language/duchain/tests/test_duchain.cpp
index e43663fa0f..d2b188ade3 100644
--- a/kdevplatform/language/duchain/tests/test_duchain.cpp
+++ b/kdevplatform/language/duchain/tests/test_duchain.cpp
@@ -1,1034 +1,1034 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2011-2013 Milian Wolff <mail@milianw.de>
  * Copyright 2006 Hamish Rodda <rodda@kde.org>
  * Copyright 2007-2009 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU 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_duchain.h"
 
 #include <QTest>
 #include <QElapsedTimer>
 
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/persistentsymboltable.h>
 #include <language/duchain/codemodel.h>
 #include <language/duchain/types/typesystemdata.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/typeregister.h>
 #include <language/duchain/declarationdata.h>
 #include <language/duchain/duchainregister.h>
 #include <language/duchain/problem.h>
 #include <language/duchain/parsingenvironment.h>
 
 #include <language/codegen/coderepresentation.h>
 
 #include <language/util/setrepository.h>
 #include <language/util/basicsetrepository.h>
 
 // #include <typeinfo>
 #include <set>
 #include <algorithm>
 #include <iterator> // needed for std::insert_iterator on windows
 #include <QThread>
 
 //Extremely slow
 // #define TEST_NORMAL_IMPORTS
 
 QTEST_MAIN(TestDUChain)
 
 using namespace KDevelop;
 using namespace Utils;
 
 typedef BasicSetRepository::Index Index;
 
 struct Timer
 {
   Timer()
   {
     m_timer.start();
   }
   qint64 elapsed()
   {
     return m_timer.nsecsElapsed();
   }
   QElapsedTimer m_timer;
 };
 
 void TestDUChain::initTestCase()
 {
   AutoTestShell::init();
   TestCore::initialize(Core::NoUi);
 
   DUChain::self()->disablePersistentStorage();
   CodeRepresentation::setDiskChangesForbidden(true);
 }
 
 void TestDUChain::cleanupTestCase()
 {
   TestCore::shutdown();
 }
 
 #ifndef Q_OS_WIN
 void TestDUChain::testStringSets() {
 
   const unsigned int setCount = 8;
   const unsigned int choiceCount = 40;
   const unsigned int itemCount = 120;
 
   BasicSetRepository rep(QStringLiteral("test repository"));
 
 //  qDebug() << "Start repository-layout: \n" << rep.dumpDotGraph();
 
   qint64 repositoryTime = 0; //Time spent on repository-operations
   qint64 genericTime = 0; //Time spend on equivalent operations with generic sets
 
   qint64 repositoryIntersectionTime = 0; //Time spent on repository-operations
   qint64 genericIntersectionTime = 0; //Time spend on equivalent operations with generic sets
   qint64 qsetIntersectionTime = 0; //Time spend on equivalent operations with generic sets
 
   qint64 repositoryUnionTime = 0; //Time spent on repository-operations
   qint64 genericUnionTime = 0; //Time spend on equivalent operations with generic sets
 
   qint64 repositoryDifferenceTime = 0; //Time spent on repository-operations
   qint64 genericDifferenceTime = 0; //Time spend on equivalent operations with generic sets
 
   Set sets[setCount];
   std::set<Index> realSets[setCount];
   for(unsigned int a = 0; a < setCount; a++)
   {
     std::set<Index> chosenIndices;
     unsigned int thisCount = rand() % choiceCount;
     if(thisCount == 0)
       thisCount = 1;
 
     for(unsigned int b = 0; b < thisCount; b++)
     {
       Index choose = (rand() % itemCount) + 1;
       while(chosenIndices.find(choose) != chosenIndices.end()) {
         choose = (rand() % itemCount) + 1;
       }
 
       Timer t;
       chosenIndices.insert(chosenIndices.end(), choose);
       genericTime += t.elapsed();
     }
 
     {
       Timer t;
       sets[a] = rep.createSet(chosenIndices);
       repositoryTime += t.elapsed();
     }
 
     realSets[a] = chosenIndices;
 
     std::set<Index> tempSet = sets[a].stdSet();
 
     if(tempSet != realSets[a]) {
       QString dbg = QStringLiteral("created set: ");
       for(std::set<Index>::const_iterator it = realSets[a].begin(); it != realSets[a].end(); ++it)
         dbg += QStringLiteral("%1 ").arg(*it);
       qDebug() << dbg;
 
       dbg = QStringLiteral("repo.   set: ");
       for(std::set<Index>::const_iterator it = tempSet.begin(); it != tempSet.end(); ++it)
         dbg += QStringLiteral("%1 ").arg(*it);
       qDebug() << dbg;
 
       qDebug() << "DOT-Graph:\n\n" << sets[a].dumpDotGraph() << "\n\n";
       QFAIL("sets are not the same!");
     }
   }
 
   for(int cycle = 0; cycle < 100; ++cycle) {
       if(cycle % 10 == 0)
          qDebug() << "cycle" << cycle;
 
     for(unsigned int a = 0; a < setCount; a++) {
       for(unsigned int b = 0; b < setCount; b++) {
         /// ----- SUBTRACTION/DIFFERENCE
         std::set<Index> _realDifference;
         {
           Timer t;
           std::set_difference(realSets[a].begin(), realSets[a].end(), realSets[b].begin(), realSets[b].end(), std::insert_iterator<std::set<Index> >(_realDifference, _realDifference.begin()));
           genericDifferenceTime += t.elapsed();
         }
 
         Set _difference;
         {
           Timer t;
           _difference = sets[a] - sets[b];
           repositoryDifferenceTime += t.elapsed();
         }
 
         if(_difference.stdSet() != _realDifference)
         {
           {
             qDebug() << "SET a:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[a].begin(); it != realSets[a].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[a].dumpDotGraph() << "\n\n";
           }
           {
             qDebug() << "SET b:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[b].begin(); it != realSets[b].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[b].dumpDotGraph() << "\n\n";
           }
 
           {
             std::set<Index> tempSet = _difference.stdSet();
 
             qDebug() << "SET difference:";
             QString dbg = QStringLiteral("real    set: ");
             for(std::set<Index>::const_iterator it = _realDifference.begin(); it != _realDifference.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             dbg = QStringLiteral("repo.   set: ");
             for(std::set<Index>::const_iterator it = tempSet.begin(); it != tempSet.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << _difference.dumpDotGraph() << "\n\n";
           }
           QFAIL("difference sets are not the same!");
         }
 
 
         /// ------ UNION
 
         std::set<Index> _realUnion;
         {
           Timer t;
           std::set_union(realSets[a].begin(), realSets[a].end(), realSets[b].begin(), realSets[b].end(), std::insert_iterator<std::set<Index> >(_realUnion, _realUnion.begin()));
           genericUnionTime += t.elapsed();
         }
 
         Set _union;
         {
           Timer t;
           _union = sets[a] + sets[b];
           repositoryUnionTime += t.elapsed();
         }
 
         if(_union.stdSet() != _realUnion)
         {
           {
             qDebug() << "SET a:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[a].begin(); it != realSets[a].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[a].dumpDotGraph() << "\n\n";
           }
           {
             qDebug() << "SET b:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[b].begin(); it != realSets[b].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[b].dumpDotGraph() << "\n\n";
           }
 
           {
             std::set<Index> tempSet = _union.stdSet();
 
             qDebug() << "SET union:";
             QString dbg = QStringLiteral("real    set: ");
             for(std::set<Index>::const_iterator it = _realUnion.begin(); it != _realUnion.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             dbg = QStringLiteral("repo.   set: ");
             for(std::set<Index>::const_iterator it = tempSet.begin(); it != tempSet.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << _union.dumpDotGraph() << "\n\n";
           }
 
           QFAIL("union sets are not the same");
         }
 
         std::set<Index> _realIntersection;
 
         /// -------- INTERSECTION
         {
           Timer t;
           std::set_intersection(realSets[a].begin(), realSets[a].end(), realSets[b].begin(), realSets[b].end(), std::insert_iterator<std::set<Index> >(_realIntersection, _realIntersection.begin()));
           genericIntersectionTime += t.elapsed();
         }
 
         //Just for fun: Test how fast QSet intersections are
         QSet<Index> first, second;
         for(std::set<Index>::const_iterator it = realSets[a].begin(); it != realSets[a].end(); ++it) {
           first.insert(*it);
         }
         for(std::set<Index>::const_iterator it = realSets[b].begin(); it != realSets[b].end(); ++it) {
           second.insert(*it);
         }
         {
           Timer t;
-          QSet<Index> i = first.intersect(second);
+          QSet<Index> i = first.intersect(second); // clazy:exclude=unused-non-trivial-variable
           qsetIntersectionTime += t.elapsed();
         }
 
         Set _intersection;
         {
           Timer t;
           _intersection = sets[a] & sets[b];
           repositoryIntersectionTime += t.elapsed();
         }
 
         if(_intersection.stdSet() != _realIntersection)
         {
           {
             qDebug() << "SET a:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[a].begin(); it != realSets[a].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[a].dumpDotGraph() << "\n\n";
           }
           {
             qDebug() << "SET b:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[b].begin(); it != realSets[b].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[b].dumpDotGraph() << "\n\n";
           }
 
           {
             std::set<Index> tempSet = _intersection.stdSet();
 
             qDebug() << "SET intersection:";
             QString dbg = QStringLiteral("real    set: ");
             for(std::set<Index>::const_iterator it = _realIntersection.begin(); it != _realIntersection.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             dbg = QStringLiteral("repo.   set: ");
             for(std::set<Index>::const_iterator it = tempSet.begin(); it != tempSet.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << _intersection.dumpDotGraph() << "\n\n";
           }
           QFAIL("intersection sets are not the same");
         }
       }
     }
 
     qDebug() << "cycle " << cycle;
     qDebug() << "ns needed for set-building: repository-set: " << float(repositoryTime)
              << " generic-set: " << float(genericTime);
     qDebug() << "ns needed for intersection: repository-sets: " << float(repositoryIntersectionTime)
              << " generic-set: " << float(genericIntersectionTime) << " QSet: " << float(qsetIntersectionTime);
     qDebug() << "ns needed for union: repository-sets: " << float(repositoryUnionTime)
              << " generic-set: " << float(genericUnionTime);
     qDebug() << "ns needed for difference: repository-sets: " << float(repositoryDifferenceTime)
              << " generic-set: " << float(genericDifferenceTime);
   }
 }
 #endif
 
 void TestDUChain::testSymbolTableValid() {
   DUChainReadLocker lock(DUChain::lock());
   PersistentSymbolTable::self().dump(QTextStream(stdout));
 }
 
 void TestDUChain::testIndexedStrings() {
 
   int testCount  = 600000;
 
   QHash<QString, IndexedString> knownIndices;
   int a = 0;
   for(a = 0; a < testCount; ++a) {
     QString testString;
     int length = rand() % 10;
     for(int b = 0; b < length; ++b)
       testString.append((char)(rand() % 6) + 'a');
     QByteArray array = testString.toUtf8();
     //qDebug() << "checking with" << testString;
     //qDebug() << "checking" << a;
     IndexedString indexed(array.constData(), array.size(), IndexedString::hashString(array.constData(), array.size()));
 
     QCOMPARE(indexed.str(), testString);
     if(knownIndices.contains(testString)) {
       QCOMPARE(indexed.index(), knownIndices[testString].index());
     } else {
       knownIndices[testString] = indexed;
     }
 
     if(a % (testCount/10) == 0)
       qDebug() << a << "of" << testCount;
   }
   qDebug() << a << "successful tests";
 }
 
 struct TestContext {
   TestContext() {
     static int number = 0;
     ++number;
     DUChainWriteLocker lock(DUChain::lock());
     m_context = new TopDUContext(IndexedString(QStringLiteral("/test1/%1").arg(number)), RangeInRevision());
     m_normalContext = new DUContext(RangeInRevision(), m_context);
     DUChain::self()->addDocumentChain(m_context);
     Q_ASSERT(IndexedDUContext(m_context).context() == m_context);
   }
 
   ~TestContext() {
     foreach(TestContext* importer, importers)
       importer->unImport(QList<TestContext*>() << this);
     unImport(imports);
 
     DUChainWriteLocker lock(DUChain::lock());
     TopDUContextPointer tp(m_context);
     DUChain::self()->removeDocumentChain(static_cast<TopDUContext*>(m_context));
     Q_ASSERT(!tp);
   }
 
   void verify(QList<TestContext*> allContexts) {
 
     {
       DUChainReadLocker lock(DUChain::lock());
       QCOMPARE(m_context->importedParentContexts().count(), imports.count());
     }
     //Compute a closure of all children, and verify that they are imported.
     QSet<TestContext*> collected;
     collectImports(collected);
     collected.remove(this);
 
     DUChainReadLocker lock(DUChain::lock());
     foreach(TestContext* context, collected) {
       QVERIFY(m_context->imports(context->m_context, CursorInRevision::invalid()));
 #ifdef TEST_NORMAL_IMPORTS
       QVERIFY(m_normalContext->imports(context->m_normalContext));
 #endif
     }
     //Verify that no other contexts are imported
 
     foreach(TestContext* context, allContexts)
       if(context != this) {
         QVERIFY(collected.contains(context) || !m_context->imports(context->m_context, CursorInRevision::invalid()));
 #ifdef TEST_NORMAL_IMPORTS
         QVERIFY(collected.contains(context) || !m_normalContext->imports(context->m_normalContext, CursorInRevision::invalid()));
 #endif
       }
   }
 
   void collectImports(QSet<TestContext*>& collected) {
     if(collected.contains(this))
       return;
     collected.insert(this);
     foreach(TestContext* context, imports)
       context->collectImports(collected);
   }
   void import(TestContext* ctx) {
     if(imports.contains(ctx) || ctx == this)
       return;
     imports << ctx;
     ctx->importers << this;
     DUChainWriteLocker lock(DUChain::lock());
     m_context->addImportedParentContext(ctx->m_context);
 #ifdef TEST_NORMAL_IMPORTS
     m_normalContext->addImportedParentContext(ctx->m_normalContext);
 #endif
   }
 
   void unImport(QList<TestContext*> ctxList) {
     QList<TopDUContext*> list;
     QList<DUContext*> normalList;
 
     foreach(TestContext* ctx, ctxList) {
       if(!imports.contains(ctx))
         continue;
       list << ctx->m_context;
       normalList << ctx->m_normalContext;
 
       imports.removeAll(ctx);
       ctx->importers.removeAll(this);
     }
     DUChainWriteLocker lock(DUChain::lock());
     m_context->removeImportedParentContexts(list);
 
 #ifdef TEST_NORMAL_IMPORTS
     foreach(DUContext* ctx, normalList)
       m_normalContext->removeImportedParentContext(ctx);
 #endif
   }
 
   void clearImports() {
 
     {
       DUChainWriteLocker lock(DUChain::lock());
 
       m_context->clearImportedParentContexts();
       m_normalContext->clearImportedParentContexts();
     }
     foreach(TestContext* ctx, imports) {
       imports.removeAll(ctx);
       ctx->importers.removeAll(this);
     }
   }
 
   QList<TestContext*> imports;
 
   private:
 
   TopDUContext* m_context;
   DUContext* m_normalContext;
   QList<TestContext*> importers;
 };
 
 void collectReachableNodes(QSet<uint>& reachableNodes, uint currentNode) {
   if(!currentNode)
     return;
   reachableNodes.insert(currentNode);
   const Utils::SetNodeData* node = KDevelop::RecursiveImportRepository::repository()->nodeFromIndex(currentNode);
   Q_ASSERT(node);
   collectReachableNodes(reachableNodes, node->leftNode());
   collectReachableNodes(reachableNodes, node->rightNode());
 }
 
 uint collectNaiveNodeCount(uint currentNode) {
   if(!currentNode)
     return 0;
   uint ret = 1;
   const Utils::SetNodeData* node = KDevelop::RecursiveImportRepository::repository()->nodeFromIndex(currentNode);
   Q_ASSERT(node);
   ret += collectNaiveNodeCount(node->leftNode());
   ret += collectNaiveNodeCount(node->rightNode());
   return ret;
 }
 
 void TestDUChain::testImportStructure()
 {
   Timer total;
   qDebug() << "before: " << KDevelop::RecursiveImportRepository::repository()->getDataRepository().statistics().print();
 
   ///Maintains a naive import-structure along with a real top-context import structure, and allows comparing both.
   int cycles = 5;
   //int cycles = 100;
   //srand(time(NULL));
   for(int t = 0; t < cycles; ++t) {
     QList<TestContext*> allContexts;
     //Create a random structure
     int contextCount = 50;
     int verifyOnceIn = contextCount/*((contextCount*contextCount)/20)+1*/; //Verify once in every chances(not in all cases, because else the import-structure isn't built on-demand!)
     int clearOnceIn = contextCount;
     for(int a = 0; a < contextCount; a++)
       allContexts << new TestContext();
     for(int c = 0; c < cycles; ++c) {
       //qDebug() << "main-cycle" << t  << "sub-cycle" << c;
       //Add random imports and compare
       for(int a = 0; a < contextCount; a++) {
         //Import up to 5 random other contexts into each context
         int importCount = rand() % 5;
         //qDebug()   << "cnt> " << importCount;
         for(int i = 0; i < importCount; ++i)
         {
           //int importNr = rand() % contextCount;
           //qDebug() << "nmr > " << importNr;
           //allContexts[a]->import(allContexts[importNr]);
           allContexts[a]->import(allContexts[rand() % contextCount]);
         }
         for(int b = 0; b < contextCount; b++)
           if(rand() % verifyOnceIn == 0)
             allContexts[b]->verify(allContexts);
       }
 
       //Remove random imports and compare
       for(int a = 0; a < contextCount; a++) {
         //Import up to 5 random other contexts into each context
         int removeCount = rand() % 3;
         QSet<TestContext*> removeImports;
         for(int i = 0; i < removeCount; ++i)
           if(!allContexts[a]->imports.isEmpty())
             removeImports.insert(allContexts[a]->imports[rand() % allContexts[a]->imports.count()]);
         allContexts[a]->unImport(removeImports.toList());
 
         for(int b = 0; b < contextCount; b++)
           if(rand() % verifyOnceIn == 0)
             allContexts[b]->verify(allContexts);
       }
 
       for(int a = 0; a < contextCount; a++) {
         if(rand() % clearOnceIn == 0) {
           allContexts[a]->clearImports();
           allContexts[a]->verify(allContexts);
         }
       }
     }
 
     qDebug() << "after: " << KDevelop::RecursiveImportRepository::repository()->getDataRepository().statistics().print();
 
     for(int a = 0; a < contextCount; ++a)
       delete allContexts[a];
     allContexts.clear();
     qDebug() << "after cleanup: " << KDevelop::RecursiveImportRepository::repository()->getDataRepository().statistics().print();
   }
   qDebug() << "total ns needed for import-structure test:" << float(total.elapsed());
 }
 
 class TestWorker : public QObject
 {
   Q_OBJECT
 public Q_SLOTS:
   void lockForWrite()
   {
     for(int i = 0; i < 10000; ++i) {
       DUChainWriteLocker lock;
     }
   }
   void lockForRead()
   {
     for(int i = 0; i < 10000; ++i) {
       DUChainReadLocker lock;
     }
   }
   void lockForReadWrite()
   {
     for(int i = 0; i < 10000; ++i) {
       {
         DUChainReadLocker lock;
       }
       {
         DUChainWriteLocker lock;
       }
     }
   }
   static QSharedPointer<QThread> createWorkerThread(const char* workerSlot)
   {
     QThread* thread = new QThread;
     TestWorker* worker = new TestWorker;
     connect(thread, SIGNAL(started()), worker, workerSlot);
     connect(thread, &QThread::finished, worker, &TestWorker::deleteLater);
     worker->moveToThread(thread);
     return QSharedPointer<QThread>(thread);
   }
 };
 
 class ThreadList : public QVector< QSharedPointer<QThread> >
 {
 public:
   bool join(int timeout)
   {
     foreach(const QSharedPointer<QThread>& thread, *this) {
       // quit event loop
       Q_ASSERT(thread->isRunning());
       thread->quit();
       // wait for finish
       if (!thread->wait(timeout)) {
         return false;
       }
       Q_ASSERT(thread->isFinished());
     }
     return true;
   }
   void start()
   {
     foreach(const QSharedPointer<QThread>& thread, *this) {
       thread->start();
     }
   }
 };
 
 void TestDUChain::testLockForWrite()
 {
   ThreadList threads;
   for(int i = 0; i < 10; ++i) {
     threads << TestWorker::createWorkerThread(SLOT(lockForWrite()));
   }
   threads.start();
   QBENCHMARK {
     {
       DUChainWriteLocker lock;
     }
     {
       DUChainReadLocker lock;
     }
   }
   QVERIFY(threads.join(1000));
 }
 
 void TestDUChain::testLockForRead()
 {
   ThreadList threads;
   for(int i = 0; i < 10; ++i) {
     threads << TestWorker::createWorkerThread(SLOT(lockForRead()));
   }
   threads.start();
   QBENCHMARK {
     DUChainReadLocker lock;
   }
   QVERIFY(threads.join(1000));
 }
 
 void TestDUChain::testLockForReadWrite()
 {
   ThreadList threads;
   for(int i = 0; i < 10; ++i) {
     threads << TestWorker::createWorkerThread(SLOT(lockForReadWrite()));
   }
   threads.start();
   QBENCHMARK {
     DUChainWriteLocker lock;
   }
   QVERIFY(threads.join(1000));
 }
 
 void TestDUChain::testProblemSerialization()
 {
   DUChain::self()->disablePersistentStorage(false);
 
   auto parent = ProblemPointer{new Problem};
   parent->setDescription(QStringLiteral("parent"));
 
   auto child = ProblemPointer{new Problem};
   child->setDescription(QStringLiteral("child"));
   parent->addDiagnostic(child);
 
   const IndexedString url("/my/test/file");
 
   TopDUContextPointer smartTop;
 
   { // serialize
     DUChainWriteLocker lock;
     auto file = new ParsingEnvironmentFile(url);
     auto top = new TopDUContext(url, {}, file);
 
     top->addProblem(parent);
     QCOMPARE(top->problems().size(), 1);
     auto p = top->problems().at(0);
     QCOMPARE(p->description(), QStringLiteral("parent"));
     QCOMPARE(p->diagnostics().size(), 1);
     auto c = p->diagnostics().first();
     QCOMPARE(c->description(), QStringLiteral("child"));
 
     DUChain::self()->addDocumentChain(top);
     QVERIFY(DUChain::self()->chainForDocument(url));
     smartTop = top;
   }
 
   DUChain::self()->storeToDisk();
 
   ProblemPointer parent_deserialized;
   IProblem::Ptr child_deserialized;
 
   { // deserialize
     DUChainWriteLocker lock;
     QVERIFY(!smartTop);
     auto top = DUChain::self()->chainForDocument(url);
     QVERIFY(top);
     smartTop = top;
     QCOMPARE(top->problems().size(), 1);
     parent_deserialized = top->problems().at(0);
     QCOMPARE(parent_deserialized->diagnostics().size(), 1);
     child_deserialized = parent_deserialized->diagnostics().first();
 
     QCOMPARE(parent_deserialized->description(), QStringLiteral("parent"));
     QCOMPARE(child_deserialized->description(), QStringLiteral("child"));
 
     top->clearProblems();
     QVERIFY(top->problems().isEmpty());
 
     QCOMPARE(parent_deserialized->description(), QStringLiteral("parent"));
     QCOMPARE(child_deserialized->description(), QStringLiteral("child"));
 
     DUChain::self()->removeDocumentChain(top);
 
     QCOMPARE(parent_deserialized->description(), QStringLiteral("parent"));
     QCOMPARE(child_deserialized->description(), QStringLiteral("child"));
 
     QVERIFY(!smartTop);
   }
 
   DUChain::self()->disablePersistentStorage(true);
 
   QCOMPARE(parent->description(), QStringLiteral("parent"));
   QCOMPARE(child->description(), QStringLiteral("child"));
   QCOMPARE(parent_deserialized->description(), QStringLiteral("parent"));
   QCOMPARE(child_deserialized->description(), QStringLiteral("child"));
 
   parent->clearDiagnostics();
   QVERIFY(parent->diagnostics().isEmpty());
 }
 
 void TestDUChain::testIdentifiers()
 {
   QualifiedIdentifier aj(QStringLiteral("::Area::jump"));
   QCOMPARE(aj.count(), 2);
   QCOMPARE(aj.explicitlyGlobal(), true);
   QCOMPARE(aj.at(0), Identifier(QStringLiteral("Area")));
   QCOMPARE(aj.at(1), Identifier(QStringLiteral("jump")));
 
   QualifiedIdentifier aj2 = QualifiedIdentifier(QStringLiteral("Area::jump"));
   QCOMPARE(aj2.count(), 2);
   QCOMPARE(aj2.explicitlyGlobal(), false);
   QCOMPARE(aj2.at(0), Identifier(QStringLiteral("Area")));
   QCOMPARE(aj2.at(1), Identifier(QStringLiteral("jump")));
   QVERIFY(aj != aj2);
 
   QVERIFY(QualifiedIdentifier(QString()) == QualifiedIdentifier());
   QVERIFY(QualifiedIdentifier(QString()).index() == QualifiedIdentifier().index());
 
   QualifiedIdentifier ajt(QStringLiteral("Area::jump::test"));
   QualifiedIdentifier jt(QStringLiteral("jump::test"));
   QualifiedIdentifier ajt2(QStringLiteral("Area::jump::tes"));
 
   QualifiedIdentifier t(QStringLiteral(" Area<A,B>::jump <F> ::tes<C>"));
   QCOMPARE(t.count(), 3);
   QCOMPARE(t.at(0).templateIdentifiersCount(), 2u);
   QCOMPARE(t.at(1).templateIdentifiersCount(), 1u);
   QCOMPARE(t.at(2).templateIdentifiersCount(), 1u);
   QCOMPARE(t.at(0).identifier().str(), QStringLiteral("Area"));
   QCOMPARE(t.at(1).identifier().str(), QStringLiteral("jump"));
   QCOMPARE(t.at(2).identifier().str(), QStringLiteral("tes"));
 
   QualifiedIdentifier op1(QStringLiteral("operator<"));
   QualifiedIdentifier op2(QStringLiteral("operator<="));
   QualifiedIdentifier op3(QStringLiteral("operator>"));
   QualifiedIdentifier op4(QStringLiteral("operator>="));
   QualifiedIdentifier op5(QStringLiteral("operator()"));
   QualifiedIdentifier op6(QStringLiteral("operator( )"));
   QCOMPARE(op1.count(), 1);
   QCOMPARE(op2.count(), 1);
   QCOMPARE(op3.count(), 1);
   QCOMPARE(op4.count(), 1);
   QCOMPARE(op5.count(), 1);
   QCOMPARE(op6.count(), 1);
   QCOMPARE(op4.toString(), QStringLiteral("operator>="));
   QCOMPARE(op3.toString(), QStringLiteral("operator>"));
   QCOMPARE(op1.toString(), QStringLiteral("operator<"));
   QCOMPARE(op2.toString(), QStringLiteral("operator<="));
   QCOMPARE(op5.toString(), QStringLiteral("operator()"));
   QCOMPARE(op6.toString(), QStringLiteral("operator( )"));
   QCOMPARE(QualifiedIdentifier(QStringLiteral("Area<A,B>::jump <F> ::tes<C>")).index(), t.index());
   QCOMPARE(op4.index(), QualifiedIdentifier(QStringLiteral("operator>=")).index());
 
   QualifiedIdentifier pushTest(QStringLiteral("foo"));
   QCOMPARE(pushTest.count(), 1);
   QCOMPARE(pushTest.toString(), QStringLiteral("foo"));
   pushTest.push(Identifier(QStringLiteral("bar")));
   QCOMPARE(pushTest.count(), 2);
   QCOMPARE(pushTest.toString(), QStringLiteral("foo::bar"));
   pushTest.push(QualifiedIdentifier(QStringLiteral("baz::asdf")));
   QCOMPARE(pushTest.count(), 4);
   QCOMPARE(pushTest.toString(), QStringLiteral("foo::bar::baz::asdf"));
   QualifiedIdentifier mergeTest = pushTest.merge(QualifiedIdentifier(QStringLiteral("meh::muh")));
   QCOMPARE(mergeTest.count(), 6);
   QCOMPARE(mergeTest.toString(), QStringLiteral("meh::muh::foo::bar::baz::asdf"));
   QualifiedIdentifier plusTest = QualifiedIdentifier(QStringLiteral("la::lu")) + QualifiedIdentifier(QStringLiteral("ba::bu"));
   QCOMPARE(plusTest.count(), 4);
   QCOMPARE(plusTest.toString(), QStringLiteral("la::lu::ba::bu"));
   ///@todo create a big randomized test for the identifier repository(check that indices are the same)
 }
 
 #if 0
 
 ///NOTE: the "unit tests" below are not automated, they - so far - require
 ///      human interpretation which is not useful for a unit test!
 ///      someone should investigate what the expected output should be
 ///      and add proper QCOMPARE/QVERIFY checks accordingly
 
 ///FIXME: this needs to be rewritten in order to remove dependencies on formerly run unit tests
 void TestDUChain::testImportCache()
 {
   KDevelop::globalItemRepositoryRegistry().printAllStatistics();
 
   KDevelop::RecursiveImportRepository::repository()->printStatistics();
 
   //Analyze the whole existing import-cache
   //This is very expensive, since it involves loading all existing top-contexts
   uint topContextCount = DUChain::self()->newTopContextIndex();
 
   uint analyzedCount = 0;
   uint totalImportCount = 0;
   uint naiveNodeCount = 0;
   QSet<uint> reachableNodes;
 
   DUChainReadLocker lock(DUChain::lock());
   for(uint a = 0; a < topContextCount; ++a) {
     if(a % qMax(1u, topContextCount / 100) == 0) {
       qDebug() << "progress:" << (a * 100) / topContextCount;
     }
     TopDUContext* context = DUChain::self()->chainForIndex(a);
     if(context) {
       TopDUContext::IndexedRecursiveImports imports = context->recursiveImportIndices();
       ++analyzedCount;
       totalImportCount += imports.set().count();
       collectReachableNodes(reachableNodes, imports.setIndex());
       naiveNodeCount += collectNaiveNodeCount(imports.setIndex());
     }
   }
 
   QVERIFY(analyzedCount);
   qDebug() << "average total count of imports:" << totalImportCount / analyzedCount;
   qDebug() << "count of reachable nodes:" << reachableNodes.size();
   qDebug() << "naive node-count:" << naiveNodeCount << "sharing compression factor:" << ((float)reachableNodes.size()) / ((float)naiveNodeCount);
 }
 
 #endif
 
 void TestDUChain::benchCodeModel()
 {
   const IndexedString file("testFile");
 
   QVERIFY(!QTypeInfo< KDevelop::CodeModelItem >::isStatic);
 
   int i = 0;
   QBENCHMARK {
     CodeModel::self().addItem(file, QualifiedIdentifier("testQID" + QString::number(i++)),
                               KDevelop::CodeModelItem::Class);
   }
 }
 
 void TestDUChain::benchTypeRegistry()
 {
   IntegralTypeData data;
   data.m_dataType = IntegralType::TypeInt;
   data.typeClassId = IntegralType::Identity;
   data.inRepository = false;
   data.m_modifiers = 42;
   data.m_dynamic = false;
   data.refCount = 1;
 
   IntegralTypeData to;
 
   QFETCH(int, func);
 
   QBENCHMARK {
     switch(func) {
       case 0:
         TypeSystem::self().dataClassSize(data);
         break;
       case 1:
         TypeSystem::self().dynamicSize(data);
         break;
       case 2:
         TypeSystem::self().create(&data);
         break;
       case 3:
         TypeSystem::self().isFactoryLoaded(data);
         break;
       case 4:
         TypeSystem::self().copy(data, to, !data.m_dynamic);
         break;
       case 5:
         TypeSystem::self().copy(data, to, data.m_dynamic);
         break;
       case 6:
         TypeSystem::self().callDestructor(&data);
         break;
     }
   }
 }
 
 void TestDUChain::benchTypeRegistry_data()
 {
   QTest::addColumn<int>("func");
   QTest::newRow("dataClassSize") << 0;
   QTest::newRow("dynamicSize") << 1;
   QTest::newRow("create") << 2;
   QTest::newRow("isFactoryLoaded") << 3;
   QTest::newRow("copy") << 4;
   QTest::newRow("copyNonDynamic") << 5;
   QTest::newRow("callDestructor") << 6;
 }
 
 void TestDUChain::benchDuchainReadLocker()
 {
   QBENCHMARK {
     DUChainReadLocker lock;
   }
 }
 
 void TestDUChain::benchDuchainWriteLocker()
 {
   QBENCHMARK {
     DUChainWriteLocker lock;
   }
 }
 
 void TestDUChain::benchDUChainItemFactory_copy()
 {
   DUChainItemFactory<Declaration, DeclarationData> factory;
   DeclarationData from, to;
   from.classId = Declaration::Identity;
 
   QFETCH(int, constant);
 
   bool c = constant;
 
   QBENCHMARK {
     factory.copy(from, to, c);
     if (constant == 2) {
       c = !c;
     }
   }
 }
 
 void TestDUChain::benchDUChainItemFactory_copy_data()
 {
   QTest::addColumn<int>("constant");
   QTest::newRow("non-const") << 0;
   QTest::newRow("const") << 1;
   QTest::newRow("flip") << 2;
 }
 
 void TestDUChain::benchDeclarationQualifiedIdentifier()
 {
   QVector<DUContext*> contexts;
   contexts.reserve(10);
   DUChainWriteLocker lock;
   contexts << new TopDUContext(IndexedString("/tmp/something"), {0, 0, INT_MAX, INT_MAX});
   for (int i = 1; i < contexts.capacity(); ++i) {
     contexts << new DUContext({0, 0, INT_MAX, INT_MAX}, contexts.at(i-1));
     contexts.last()->setLocalScopeIdentifier(QualifiedIdentifier(QString::number(i)));
   }
   auto dec = new Declaration({0, 0, 0, 1}, contexts.last());
   dec->setIdentifier(Identifier(QStringLiteral("myDecl")));
 
   qDebug() << "start benchmark!";
   qint64 count = 0;
   QBENCHMARK {
     count += dec->qualifiedIdentifier().count();
   }
   QVERIFY(count > 0);
 }
 
 #include "test_duchain.moc"
 #include "moc_test_duchain.cpp"
diff --git a/kdevplatform/shell/statusbar.cpp b/kdevplatform/shell/statusbar.cpp
index 4f28deebb6..25d4c12b6f 100644
--- a/kdevplatform/shell/statusbar.cpp
+++ b/kdevplatform/shell/statusbar.cpp
@@ -1,256 +1,255 @@
 /* This file is part of the KDE project
    Copyright 2007 Hamish Rodda <rodda@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 "statusbar.h"
 #include "progresswidget/statusbarprogresswidget.h"
 #include "progresswidget/progressmanager.h"
 #include "progresswidget/progressdialog.h"
 
 #include <QTimer>
 
 #include <KColorScheme>
 #include <KSqueezedTextLabel>
 
 #include <interfaces/istatus.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <language/backgroundparser/backgroundparser.h>
 
 #include <sublime/view.h>
 
 #include "plugincontroller.h"
 #include "core.h"
 
 namespace KDevelop
 {
 
 StatusBar::StatusBar(QWidget* parent)
     : QStatusBar(parent)
     , m_timer(new QTimer(this))
     , m_currentView(nullptr)
 {
 #ifdef Q_OS_MAC
     /* At time of writing this is only required for OSX and only has effect on OSX. 
        ifdef for robustness to future platform dependent theme/widget changes
        https://phabricator.kde.org/D656 
     */
     setStyleSheet("QStatusBar{background:transparent;}");
 #endif
 
     m_timer->setSingleShot(true);
     connect(m_timer, &QTimer::timeout, this, &StatusBar::slotTimeout);
     connect(Core::self()->pluginController(), &IPluginController::pluginLoaded, this, &StatusBar::pluginLoaded);
     const QList<IPlugin*> plugins = Core::self()->pluginControllerInternal()->allPluginsForExtension(QStringLiteral("IStatus"));
 
     for (IPlugin* plugin : plugins) {
         registerStatus(plugin);
     }
 
     registerStatus(Core::self()->languageController()->backgroundParser());
 
     m_progressController = Core::self()->progressController();
     m_progressDialog = new ProgressDialog(this, parent); // construct this first, then progressWidget
     m_progressDialog->setVisible(false);
     m_progressWidget = new StatusbarProgressWidget(m_progressDialog, this);
 
     addPermanentWidget(m_progressWidget, 0);
 }
 
 void StatusBar::removeError(QWidget* w)
 {
     removeWidget(w);
     w->deleteLater();
 }
 
 void StatusBar::viewChanged(Sublime::View* view)
 {
     if (m_currentView)
         m_currentView->disconnect(this);
 
     m_currentView = view;
 
     if (view) {
         connect(view, &Sublime::View::statusChanged, this, &StatusBar::viewStatusChanged);
         QStatusBar::showMessage(view->viewStatus(), 0);
 
     }
 }
 
 void StatusBar::viewStatusChanged(Sublime::View* view)
 {
     QStatusBar::showMessage(view->viewStatus(), 0);
 }
 
 void StatusBar::pluginLoaded(IPlugin* plugin)
 {
     if (qobject_cast<IStatus*>(plugin))
         registerStatus(plugin);
 }
 
 void StatusBar::registerStatus(QObject* status)
 {
     Q_ASSERT(qobject_cast<IStatus*>(status));
     // can't convert this to new signal slot syntax, IStatus is not a QObject
     connect(status, SIGNAL(clearMessage(KDevelop::IStatus*)),
             SLOT(clearMessage(KDevelop::IStatus*)),
             Qt::QueuedConnection);
     connect(status, SIGNAL(showMessage(KDevelop::IStatus*,QString,int)),
             SLOT(showMessage(KDevelop::IStatus*,QString,int)),
             Qt::QueuedConnection);
     connect(status, SIGNAL(hideProgress(KDevelop::IStatus*)),
             SLOT(hideProgress(KDevelop::IStatus*)),
             Qt::QueuedConnection);
     connect(status, SIGNAL(showProgress(KDevelop::IStatus*,int,int,int)),
             SLOT(showProgress(KDevelop::IStatus*,int,int,int)),
             Qt::QueuedConnection);
     connect(status, SIGNAL(showErrorMessage(QString,int)),
             SLOT(showErrorMessage(QString,int)),
             Qt::QueuedConnection);
 }
 
 QWidget* errorMessage(QWidget* parent, const QString& text)
 {
     KSqueezedTextLabel* label = new KSqueezedTextLabel(parent);
     KStatefulBrush red(KColorScheme::Window, KColorScheme::NegativeText);
     QPalette pal = label->palette();
     pal.setBrush(QPalette::WindowText, red.brush(label));
     label->setPalette(pal);
     label->setAlignment(Qt::AlignRight);
     label->setText(text);
     label->setToolTip(text);
     return label;
 }
 
 QTimer* StatusBar::errorTimeout(QWidget* error, int timeout)
 {
     QTimer* timer = new QTimer(error);
     timer->setSingleShot(true);
     timer->setInterval(1000*timeout);
     connect(timer, &QTimer::timeout, this, [this, error](){ removeError(error); });
     return timer;
 }
 
 void StatusBar::showErrorMessage(const QString& message, int timeout)
 {
     QWidget* error = errorMessage(this, message);
     QTimer* timer = errorTimeout(error, timeout);
     addWidget(error);
     timer->start(); // triggers removeError()
 }
 
 void StatusBar::slotTimeout()
 {
     QMutableMapIterator<IStatus*, Message> it = m_messages;
 
     while (it.hasNext()) {
         it.next();
         if (it.value().timeout) {
             it.value().timeout -= m_timer->interval();
             if (it.value().timeout == 0)
                 it.remove();
         }
     }
 
     updateMessage();
 }
 
 void StatusBar::updateMessage()
 {
     if (m_timer->isActive()) {
         m_timer->stop();
         m_timer->setInterval(m_time.elapsed());
         slotTimeout();
     }
 
-    QString ret;
     int timeout = 0;
 
     QStringList messages;
     messages.reserve(m_messages.size());
     foreach (const Message& m, m_messages) {
         messages.append(m.text);
 
         if (timeout)
             timeout = qMin(timeout, m.timeout);
         else
             timeout = m.timeout;
     }
 
     if (!messages.isEmpty())
         QStatusBar::showMessage(messages.join(QLatin1String("; ")));
     else
         QStatusBar::clearMessage();
 
     if (timeout) {
         m_time.start();
         m_timer->start(timeout);
     }
 }
 
 void StatusBar::clearMessage( IStatus* status )
 {
     if (m_messages.contains(status)) {
         m_messages.remove(status);
         updateMessage();
     }
 }
 
 void StatusBar::showMessage( IStatus* status, const QString & message, int timeout)
 {
     if ( m_progressItems.contains(status) ) {
         ProgressItem* i = m_progressItems[status];
         i->setStatus(message);
     } else {
         Message m;
         m.text = message;
         m.timeout = timeout;
         m_messages.insert(status, m);
         updateMessage();
     }
 }
 
 void StatusBar::hideProgress( IStatus* status )
 {
    if (m_progressItems.contains(status)) {
         m_progressItems[status]->setComplete();
         m_progressItems.remove(status);
    }
 
 }
 
 void StatusBar::showProgress( IStatus* status, int minimum, int maximum, int value)
 {
     if (!m_progressItems.contains(status)) {
         bool canBeCanceled = false;
         m_progressItems[status] = m_progressController->createProgressItem(
             ProgressManager::createUniqueID(), status->statusName(), QString(), canBeCanceled);
     }
     
     ProgressItem* i = m_progressItems[status];
     m_progressWidget->raise();
     m_progressDialog->raise();
     if( minimum == 0 && maximum == 0 ) {
         i->setUsesBusyIndicator( true );
     } else {
         i->setUsesBusyIndicator( false );
         i->setProgress( 100*value/maximum );
     }
 }
 
 }
 
diff --git a/kdevplatform/tests/modeltest.cpp b/kdevplatform/tests/modeltest.cpp
index 92bdfd6c8f..cef567f32a 100644
--- a/kdevplatform/tests/modeltest.cpp
+++ b/kdevplatform/tests/modeltest.cpp
@@ -1,526 +1,525 @@
 /****************************************************************************
 **
 ** Copyright (C) 2007 Trolltech ASA. All rights reserved.
 **
 ** This file is part of the Qt Concurrent project on Trolltech Labs.
 **
 ** This file may be used under the terms of the GNU General Public
 ** License version 2.0 as published by the Free Software Foundation
 ** and appearing in the file LICENSE.GPL included in the packaging of
 ** this file.  Please review the following information to ensure GNU
 ** General Public Licensing requirements will be met:
 ** http://www.trolltech.com/products/qt/opensource.html
 **
 ** If you are unsure which license is appropriate for your use, please
 ** review the following information:
 ** http://www.trolltech.com/products/qt/licensing.html or contact the
 ** sales department at sales@trolltech.com.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ****************************************************************************/
 
 #include "modeltest.h"
 
 #include <QtGui>
 #include <project/tests/test_projectmodel.h>
 
 // always enable assertions here
 #undef Q_ASSERT
 #define Q_ASSERT(cond) ((!(cond)) ? qt_assert(#cond,__FILE__,__LINE__) : qt_noop())
 
 /*!
     Connect to all of the models signals.  Whenever anything happens recheck everything.
 */
 ModelTest::ModelTest(QAbstractItemModel *_model, QObject *parent) : QObject(parent), model(_model), fetchingMore(false)
 {
     Q_ASSERT(model);
 
     connect(model, &QAbstractItemModel::columnsAboutToBeInserted,
             this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::columnsAboutToBeRemoved,
             this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::columnsInserted,
             this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::columnsRemoved,
             this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::dataChanged,
             this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::headerDataChanged,
             this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::layoutAboutToBeChanged, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::layoutChanged, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::modelReset, this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::rowsAboutToBeInserted,
             this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::rowsAboutToBeRemoved,
             this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::rowsInserted,
             this, &ModelTest::runAllTests);
     connect(model, &QAbstractItemModel::rowsRemoved,
             this, &ModelTest::runAllTests);
 
     // Special checks for inserting/removing
     connect(model, &QAbstractItemModel::layoutAboutToBeChanged,
             this, &ModelTest::layoutAboutToBeChanged);
     connect(model, &QAbstractItemModel::layoutChanged,
             this, &ModelTest::layoutChanged);
 
     connect(model, &QAbstractItemModel::rowsAboutToBeInserted,
             this, &ModelTest::rowsAboutToBeInserted);
     connect(model, &QAbstractItemModel::rowsAboutToBeRemoved,
             this, &ModelTest::rowsAboutToBeRemoved);
     connect(model, &QAbstractItemModel::rowsInserted,
             this, &ModelTest::rowsInserted);
     connect(model, &QAbstractItemModel::rowsRemoved,
             this, &ModelTest::rowsRemoved);
 
     runAllTests();
 }
 
 void ModelTest::runAllTests()
 {
     if (fetchingMore)
         return;
     nonDestructiveBasicTest();
     rowCount();
     columnCount();
     hasIndex();
     index();
     parent();
     data();
 }
 
 /*!
     nonDestructiveBasicTest tries to call a number of the basic functions (not all)
     to make sure the model doesn't outright segfault, testing the functions that makes sense.
 */
 void ModelTest::nonDestructiveBasicTest()
 {
     Q_ASSERT(model->buddy(QModelIndex()) == QModelIndex());
     model->canFetchMore(QModelIndex());
     Q_ASSERT(model->columnCount(QModelIndex()) >= 0);
     Q_ASSERT(model->data(QModelIndex()) == QVariant());
     fetchingMore = true;
     model->fetchMore(QModelIndex());
     fetchingMore = false;
     Qt::ItemFlags flags = model->flags(QModelIndex());
     Q_ASSERT(flags == Qt::ItemIsDropEnabled || flags == 0);
     model->hasChildren(QModelIndex());
     model->hasIndex(0, 0);
     model->headerData(0, Qt::Horizontal);
     model->index(0, 0);
     model->itemData(QModelIndex());
     QVariant cache;
     model->match(QModelIndex(), -1, cache);
     model->mimeTypes();
     Q_ASSERT(model->parent(QModelIndex()) == QModelIndex());
     Q_ASSERT(model->rowCount() >= 0);
     QVariant variant;
     model->setData(QModelIndex(), variant, -1);
     model->setHeaderData(-1, Qt::Horizontal, QVariant());
     model->setHeaderData(999999, Qt::Horizontal, QVariant());
-    QMap<int, QVariant> roles;
     model->sibling(0, 0, QModelIndex());
     model->span(QModelIndex());
     model->supportedDropActions();
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::rowCount() and hasChildren()
 
     Models that are dynamically populated are not as fully tested here.
  */
 void ModelTest::rowCount()
 {
     // check top row
     QModelIndex topIndex = model->index(0, 0, QModelIndex());
     int rows = model->rowCount(topIndex);
     Q_ASSERT(rows >= 0);
     if (rows > 0)
         Q_ASSERT(model->hasChildren(topIndex) == true);
 
     QModelIndex secondLevelIndex = model->index(0, 0, topIndex);
     if (secondLevelIndex.isValid()) { // not the top level
         // check a row count where parent is valid
         rows = model->rowCount(secondLevelIndex);
         Q_ASSERT(rows >= 0);
         if (rows > 0)
             Q_ASSERT(model->hasChildren(secondLevelIndex) == true);
     }
 
     // The models rowCount() is tested more extensively in checkChildren(),
     // but this catches the big mistakes
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::columnCount() and hasChildren()
  */
 void ModelTest::columnCount()
 {
     // check top row
     QModelIndex topIndex = model->index(0, 0, QModelIndex());
     Q_ASSERT(model->columnCount(topIndex) >= 0);
 
     // check a column count where parent is valid
     QModelIndex childIndex = model->index(0, 0, topIndex);
     if (childIndex.isValid())
         Q_ASSERT(model->columnCount(childIndex) >= 0);
 
     // columnCount() is tested more extensively in checkChildren(),
     // but this catches the big mistakes
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::hasIndex()
  */
 void ModelTest::hasIndex()
 {
     // Make sure that invalid values returns an invalid index
     Q_ASSERT(model->hasIndex(-2, -2) == false);
     Q_ASSERT(model->hasIndex(-2, 0) == false);
     Q_ASSERT(model->hasIndex(0, -2) == false);
 
     int rows = model->rowCount();
     int columns = model->columnCount();
 
     // check out of bounds
     Q_ASSERT(model->hasIndex(rows, columns) == false);
     Q_ASSERT(model->hasIndex(rows + 1, columns + 1) == false);
 
     if (rows > 0)
         Q_ASSERT(model->hasIndex(0, 0) == true);
 
     // hasIndex() is tested more extensively in checkChildren(),
     // but this catches the big mistakes
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::index()
  */
 void ModelTest::index()
 {
     // Make sure that invalid values returns an invalid index
     Q_ASSERT(model->index(-2, -2) == QModelIndex());
     Q_ASSERT(model->index(-2, 0) == QModelIndex());
     Q_ASSERT(model->index(0, -2) == QModelIndex());
 
     int rows = model->rowCount();
     int columns = model->columnCount();
 
     if (rows == 0)
         return;
 
     // Catch off by one errors
     Q_ASSERT(model->index(rows, columns) == QModelIndex());
     Q_ASSERT(model->index(0, 0).isValid() == true);
 
     // Make sure that the same index is *always* returned
     QModelIndex a = model->index(0, 0);
     QModelIndex b = model->index(0, 0);
     Q_ASSERT(a == b);
 
     // index() is tested more extensively in checkChildren(),
     // but this catches the big mistakes
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::parent()
  */
 void ModelTest::parent()
 {
     // Make sure the model wont crash and will return an invalid QModelIndex
     // when asked for the parent of an invalid index.
     Q_ASSERT(model->parent(QModelIndex()) == QModelIndex());
 
     if (model->rowCount() == 0)
         return;
 
     // Column 0                | Column 1    |
     // QModelIndex()           |             |
     //    \- topIndex          | topIndex1   |
     //         \- childIndex   | childIndex1 |
 
     // Common error test #1, make sure that a top level index has a parent
     // that is a invalid QModelIndex.
     QModelIndex topIndex = model->index(0, 0, QModelIndex());
     Q_ASSERT(model->parent(topIndex) == QModelIndex());
 
     // Common error test #2, make sure that a second level index has a parent
     // that is the first level index.
     if (model->rowCount(topIndex) > 0) {
         QModelIndex childIndex = model->index(0, 0, topIndex);
         Q_ASSERT(model->parent(childIndex) == topIndex);
     }
 
     // Common error test #3, the second column should NOT have the same children
     // as the first column in a row.
     // Usually the second column shouldn't have children.
     QModelIndex topIndex1 = model->index(0, 1, QModelIndex());
     if (model->rowCount(topIndex1) > 0) {
         QModelIndex childIndex = model->index(0, 0, topIndex);
         QModelIndex childIndex1 = model->index(0, 0, topIndex1);
         Q_ASSERT(childIndex != childIndex1);
     }
 
     // Full test, walk n levels deep through the model making sure that all
     // parent's children correctly specify their parent.
     checkChildren(QModelIndex());
 }
 
 /*!
     Called from the parent() test.
 
     A model that returns an index of parent X should also return X when asking
     for the parent of the index.
 
     This recursive function does pretty extensive testing on the whole model in an
     effort to catch edge cases.
 
     This function assumes that rowCount(), columnCount() and index() already work.
     If they have a bug it will point it out, but the above tests should have already
     found the basic bugs because it is easier to figure out the problem in
     those tests then this one.
  */
 void ModelTest::checkChildren(const QModelIndex &parent, int currentDepth)
 {
     // First just try walking back up the tree.
     QModelIndex p = parent;
     while (p.isValid())
         p = p.parent();
 
     // For models that are dynamically populated
     if (model->canFetchMore(parent)) {
         fetchingMore = true;
         model->fetchMore(parent);
         fetchingMore = false;
     }
 
     int rows = model->rowCount(parent);
     int columns = model->columnCount(parent);
 
     if (rows > 0)
         Q_ASSERT(model->hasChildren(parent));
 
     // Some further testing against rows(), columns(), and hasChildren()
     Q_ASSERT(rows >= 0);
     Q_ASSERT(columns >= 0);
     if (rows > 0)
         Q_ASSERT(model->hasChildren(parent) == true);
 
     //qDebug() << "parent:" << model->data(parent).toString() << "rows:" << rows
     //         << "columns:" << columns << "parent column:" << parent.column();
 
     Q_ASSERT(model->hasIndex(rows + 1, 0, parent) == false);
     for (int r = 0; r < rows; ++r) {
         if (model->canFetchMore(parent)) {
             fetchingMore = true;
             model->fetchMore(parent);
             fetchingMore = false;
         }
         Q_ASSERT(model->hasIndex(r, columns + 1, parent) == false);
         for (int c = 0; c < columns; ++c) {
             Q_ASSERT(model->hasIndex(r, c, parent) == true);
             QModelIndex index = model->index(r, c, parent);
             // rowCount() and columnCount() said that it existed...
             Q_ASSERT(index.isValid() == true);
 
             // index() should always return the same index when called twice in a row
             QModelIndex modifiedIndex = model->index(r, c, parent);
             Q_ASSERT(index == modifiedIndex);
 
             // Make sure we get the same index if we request it twice in a row
             QModelIndex a = model->index(r, c, parent);
             QModelIndex b = model->index(r, c, parent);
             Q_ASSERT(a == b);
 
             // Some basic checking on the index that is returned
             Q_ASSERT(index.model() == model);
             Q_ASSERT(index.row() == r);
             Q_ASSERT(index.column() == c);
             // While you can technically return a QVariant usually this is a sign
             // of an bug in data()  Disable if this really is ok in your model.
             Q_ASSERT(model->data(index, Qt::DisplayRole).isValid() == true);
 
             // If the next test fails here is some somewhat useful debug you play with.
             /*
             if (model->parent(index) != parent) {
                 qDebug() << r << c << currentDepth << model->data(index).toString()
                          << model->data(parent).toString();
                 qDebug() << index << parent << model->parent(index);
                 // And a view that you can even use to show the model.
                 //QTreeView view;
                 //view.setModel(model);
                 //view.show();
             }*/
 
             // Check that we can get back our real parent.
             Q_ASSERT(model->parent(index) == parent);
 
             // recursively go down the children
             if (model->hasChildren(index) && currentDepth < 10 ) {
                 //qDebug() << r << c << "has children" << model->rowCount(index);
                 checkChildren(index, ++currentDepth);
             }/* else { if (currentDepth >= 10) qDebug() << "checked 10 deep"; };*/
 
             // make sure that after testing the children that the index doesn't change.
             QModelIndex newerIndex = model->index(r, c, parent);
             Q_ASSERT(index == newerIndex);
         }
     }
 }
 
 /*!
     Tests model's implementation of QAbstractItemModel::data()
  */
 void ModelTest::data()
 {
     // Invalid index should return an invalid qvariant
     Q_ASSERT(!model->data(QModelIndex()).isValid());
 
     if (model->rowCount() == 0)
         return;
 
     // A valid index should have a valid QVariant data
     Q_ASSERT(model->index(0, 0).isValid());
 
     // shouldn't be able to set data on an invalid index
     Q_ASSERT(model->setData(QModelIndex(), QLatin1String("foo"), Qt::DisplayRole) == false);
 
     // General Purpose roles that should return a QString
     QVariant variant = model->data(model->index(0, 0), Qt::ToolTipRole);
     if (variant.isValid()) {
         Q_ASSERT(variant.canConvert<QString>());
     }
     variant = model->data(model->index(0, 0), Qt::StatusTipRole);
     if (variant.isValid()) {
         Q_ASSERT(variant.canConvert<QString>());
     }
     variant = model->data(model->index(0, 0), Qt::WhatsThisRole);
     if (variant.isValid()) {
         Q_ASSERT(variant.canConvert<QString>());
     }
 
     // General Purpose roles that should return a QSize
     variant = model->data(model->index(0, 0), Qt::SizeHintRole);
     if (variant.isValid()) {
         Q_ASSERT(variant.canConvert<QSize>());
     }
 
     // General Purpose roles that should return a QFont
     QVariant fontVariant = model->data(model->index(0, 0), Qt::FontRole);
     if (fontVariant.isValid()) {
         Q_ASSERT(fontVariant.canConvert<QFont>());
     }
 
     // Check that the alignment is one we know about
     QVariant textAlignmentVariant = model->data(model->index(0, 0), Qt::TextAlignmentRole);
     if (textAlignmentVariant.isValid()) {
         int alignment = textAlignmentVariant.toInt();
        Q_ASSERT(alignment == (alignment & (Qt::AlignHorizontal_Mask | Qt::AlignVertical_Mask)));
     }
 
     // General Purpose roles that should return a QColor
     QVariant colorVariant = model->data(model->index(0, 0), Qt::BackgroundColorRole);
     if (colorVariant.isValid()) {
         Q_ASSERT(colorVariant.canConvert<QColor>());
     }
 
     colorVariant = model->data(model->index(0, 0), Qt::TextColorRole);
     if (colorVariant.isValid()) {
         Q_ASSERT(colorVariant.canConvert<QColor>());
     }
 
     // Check that the "check state" is one we know about.
     QVariant checkStateVariant = model->data(model->index(0, 0), Qt::CheckStateRole);
     if (checkStateVariant.isValid()) {
         int state = checkStateVariant.toInt();
         Q_ASSERT(state == Qt::Unchecked ||
                  state == Qt::PartiallyChecked ||
                  state == Qt::Checked);
     }
 }
 
 /*!
     Store what is about to be inserted to make sure it actually happens
 
     \sa rowsInserted()
  */
 void ModelTest::rowsAboutToBeInserted(const QModelIndex &parent, int start, int end)
 {
     Q_UNUSED(end);
     Changing c;
     c.parent = parent;
     c.oldSize = model->rowCount(parent);
     c.last = model->data(model->index(start - 1, 0, parent));
     c.next = model->data(model->index(start, 0, parent));
     insert.push(c);
 }
 
 /*!
     Confirm that what was said was going to happen actually did
 
     \sa rowsAboutToBeInserted()
  */
 void ModelTest::rowsInserted(const QModelIndex & parent, int start, int end)
 {
     Changing c = insert.pop();
     Q_ASSERT(c.parent == parent);
     Q_ASSERT(c.oldSize + (end - start + 1) == model->rowCount(parent));
     Q_ASSERT(c.last == model->data(model->index(start - 1, 0, c.parent)));
     /*
     if (c.next != model->data(model->index(end + 1, 0, c.parent))) {
         qDebug() << start << end;
         for (int i=0; i < model->rowCount(); ++i)
             qDebug() << model->index(i, 0).data().toString();
         qDebug() << c.next << model->data(model->index(end + 1, 0, c.parent));
     }
     */
     Q_ASSERT(c.next == model->data(model->index(end + 1, 0, c.parent)));
 }
 
 void ModelTest::layoutAboutToBeChanged()
 {
     for (int i = 0; i < qBound(0, model->rowCount(), 100); ++i)
         changing.append(QPersistentModelIndex(model->index(i, 0)));
 }
 
 void ModelTest::layoutChanged()
 {
     for (int i = 0; i < changing.count(); ++i) {
         QPersistentModelIndex p = changing[i];
         Q_ASSERT(p == model->index(p.row(), p.column(), p.parent()));
     }
     changing.clear();
 }
 
 /*!
     Store what is about to be inserted to make sure it actually happens
 
     \sa rowsRemoved()
  */
 void ModelTest::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
 {
     Changing c;
     c.parent = parent;
     c.oldSize = model->rowCount(parent);
     c.last = model->data(model->index(start - 1, 0, parent));
     c.next = model->data(model->index(end + 1, 0, parent));
     remove.push(c);
 }
 
 /*!
     Confirm that what was said was going to happen actually did
 
     \sa rowsAboutToBeRemoved()
  */
 void ModelTest::rowsRemoved(const QModelIndex & parent, int start, int end)
 {
     Changing c = remove.pop();
     Q_ASSERT(c.parent == parent);
     Q_ASSERT(c.oldSize - (end - start + 1) == model->rowCount(parent));
     Q_ASSERT(c.last == model->data(model->index(start - 1, 0, c.parent)));
     Q_ASSERT(c.next == model->data(model->index(start, 0, c.parent)));
 }
 
diff --git a/plugins/cmake/cmakecommandscontents.cpp b/plugins/cmake/cmakecommandscontents.cpp
index d6d99c6216..59f6a04037 100644
--- a/plugins/cmake/cmakecommandscontents.cpp
+++ b/plugins/cmake/cmakecommandscontents.cpp
@@ -1,182 +1,181 @@
 /* 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 "cmakecommandscontents.h"
 #include <interfaces/iruntimecontroller.h>
 #include <interfaces/iruntime.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentation.h>
 #include <interfaces/idocumentationcontroller.h>
 #include "cmakebuilderconfig.h"
 #include "cmakedoc.h"
 #include <QProcess>
 #include <KLocalizedString>
 
 static const QVector<QString> args = {
     QLatin1String("--help-command"), QLatin1String("--help-variable"), QLatin1String("--help-module"), QLatin1String("--help-property"), QString(), QString()
 };
 static QString modules [] = {
     i18n("Commands"), i18n("Variables"), i18n("Modules"), i18n("Properties"), i18n("Policies")
 };
 
 CMakeCommandsContents::CMakeCommandsContents(QObject* parent)
      : QAbstractItemModel(parent)
      , m_namesForType(CMakeDocumentation::EOType)
 {
-    QVector<QProcess*> processes;
     for(int i=0; i<=CMakeDocumentation::Property; i++) {
         const QStringList params = { args[i]+QStringLiteral("-list") };
 
         QProcess* process = new QProcess(this);
         process->setProperty("type", i);
         process->setProgram(CMakeBuilderSettings::self()->cmakeExecutable().toLocalFile());
         process->setArguments(params);
         KDevelop::ICore::self()->runtimeController()->currentRuntime()->startProcess(process);
 
         connect(process, static_cast<void(QProcess::*)(int)>(&QProcess::finished), this, &CMakeCommandsContents::processOutput);
     }
 }
 
 void CMakeCommandsContents::processOutput(int code)
 {
     QProcess* process = qobject_cast<QProcess*>(sender());
     if (code!=0) {
         qDebug() << "failed" << process;
         return;
     }
 
     const CMakeDocumentation::Type type = CMakeDocumentation::Type(process->property("type").toInt());
 
     QTextStream stream(process);
     QString line = stream.readLine(); //discard first line
     QMap<QString, CMakeDocumentation::Type> newEntries;
     QVector<QString> names;
     while(stream.readLineInto(&line)) {
         newEntries[line]=type;
         names += line;
     }
 
     beginInsertRows(index(type, 0, {}), 0, names.count()-1);
     m_typeForName.unite(newEntries);
     m_namesForType[type] = names;
     endInsertRows();
 }
 
 CMakeDocumentation::Type CMakeCommandsContents::typeFor(const QString& identifier) const
 {
     //TODO can do much better
     if(m_typeForName.contains(identifier)) {
         return m_typeForName[identifier];
     } else if(m_typeForName.contains(identifier.toLower())) {
         return m_typeForName[identifier.toLower()];
     } else if(m_typeForName.contains(identifier.toUpper())) {
         return m_typeForName[identifier.toUpper()];
     }
     return CMakeDocumentation::EOType;
 }
 
 QString CMakeCommandsContents::descriptionForIdentifier(const QString& id, CMakeDocumentation::Type t) const
 {
     QString desc;
     if(args[t].size() != 0) {
         desc = CMake::executeProcess(CMakeBuilderSettings::self()->cmakeExecutable().toLocalFile(), { args[t], id.simplified() });
         desc = desc.remove(QStringLiteral(":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;
 }
 
 
 void CMakeCommandsContents::showItemAt(const QModelIndex& idx) const
 {
     if(idx.isValid() && int(idx.internalId())>=0) {
         QString desc=CMakeDoc::s_provider->descriptionForIdentifier(idx.data().toString(),
                                                                     (ICMakeDocumentation::Type) idx.parent().row());
         CMakeDoc::Ptr doc(new CMakeDoc(idx.data().toString(), desc));
 
         KDevelop::ICore::self()->documentationController()->showDocumentation(doc);
     }
 }
 
 QModelIndex CMakeCommandsContents::parent(const QModelIndex& child) const
 {
     if(child.isValid() && child.column()==0 && int(child.internalId())>=0)
         return createIndex(child.internalId(),0, -1);
     return QModelIndex();
 }
 
 QModelIndex CMakeCommandsContents::index(int row, int column, const QModelIndex& parent) const
 {
     if(row<0 || column!=0)
         return QModelIndex();
     if(!parent.isValid() && row==ICMakeDocumentation::EOType)
         return QModelIndex();
 
     return createIndex(row,column, int(parent.isValid() ? parent.row() : -1));
 }
 
 int CMakeCommandsContents::rowCount(const QModelIndex& parent) const
 {
     if(!parent.isValid())
         return ICMakeDocumentation::EOType;
     else if(int(parent.internalId())<0) {
         int ss=names((ICMakeDocumentation::Type) parent.row()).size();
         return ss;
     }
     return 0;
 }
 
 QVariant CMakeCommandsContents::data(const QModelIndex& index, int role) const
 {
     if (index.isValid()) {
         if(role==Qt::DisplayRole) {
             int internal(index.internalId());
             if(internal>=0)
                 return m_namesForType[internal].count() > index.row() ? QVariant(m_namesForType[internal].at(index.row())) : QVariant();
             else
                 return modules[index.row()];
         }
     }
     return QVariant();
 }
 
 int CMakeCommandsContents::columnCount(const QModelIndex& /*parent*/) const
 {
     return 1;
 }
 
 QVector<QString> CMakeCommandsContents::names(ICMakeDocumentation::Type t) const
 {
     return m_namesForType[t];
 }
diff --git a/plugins/cmake/cmakeutils.cpp b/plugins/cmake/cmakeutils.cpp
index 75319dbf66..59780325ad 100644
--- a/plugins/cmake/cmakeutils.cpp
+++ b/plugins/cmake/cmakeutils.cpp
@@ -1,731 +1,729 @@
 /* KDevelop CMake Support
  *
  * Copyright 2009 Andreas Pakulat <apaku@gmx.de>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  */
 
 #include "cmakeutils.h"
 #include "cmakeprojectdata.h"
 
 #include <QFileInfo>
 #include <QDir>
 #include <QProcess>
 #include <QTemporaryDir>
 #include <QRegularExpression>
 
 #include <KShell>
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <project/projectmodel.h>
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iruntimecontroller.h>
 #include <interfaces/iruntime.h>
 #include <interfaces/iplugincontroller.h>
 #include <QStandardPaths>
 
 #include "icmakedocumentation.h"
 #include "cmakebuilddirchooser.h"
 #include "settings/cmakecachemodel.h"
 #include "debug.h"
 #include "cmakebuilderconfig.h"
 #include <cmakecachereader.h>
 #include "parser/cmakelistsparser.h"
 
 using namespace KDevelop;
 
 namespace Config
 {
 namespace Old
 {
 static const QString currentBuildDirKey = QStringLiteral("CurrentBuildDir");
 static const QString oldcmakeExecutableKey = QStringLiteral("CMake Binary"); // Todo: Remove at some point
 static const QString currentBuildTypeKey = QStringLiteral("CurrentBuildType");
 static const QString currentInstallDirKey = QStringLiteral("CurrentInstallDir");
 static const QString currentEnvironmentKey = QStringLiteral("CurrentEnvironment");
 static const QString currentExtraArgumentsKey = QStringLiteral("Extra Arguments");
 static const QString currentCMakeExecutableKey = QStringLiteral("Current CMake Binary");
 static const QString projectRootRelativeKey = QStringLiteral("ProjectRootRelative");
 static const QString projectBuildDirs = QStringLiteral("BuildDirs");
 }
 
 static const QString buildDirIndexKey_ = QStringLiteral("Current Build Directory Index");
 static const QString buildDirOverrideIndexKey = QStringLiteral("Temporary Build Directory Index");
 static const QString buildDirCountKey = QStringLiteral("Build Directory Count");
 
 //the used builddir will change for every runtime
 static QString buildDirIndexKey() {
     const QString currentRuntime = ICore::self()->runtimeController()->currentRuntime()->name();
     return buildDirIndexKey_ + '-' + currentRuntime;
 }
 
 namespace Specific
 {
 static const QString buildDirPathKey = QStringLiteral("Build Directory Path");
 // TODO: migrate to more generic & consistent key term "CMake Executable"
 // Support the old "CMake Binary" key too for backwards compatibility during
 // a reasonable transition period. Both keys are saved at least until 5.2.0
 // is released. Import support for the old key will need to remain for a
 // considably longer period, ideally.
 static const QString cmakeBinaryKey = QStringLiteral("CMake Binary");
 static const QString cmakeExecutableKey = QStringLiteral("CMake Executable");
 static const QString cmakeBuildTypeKey = QStringLiteral("Build Type");
 static const QString cmakeInstallDirKey = QStringLiteral("Install Directory");
 static const QString cmakeEnvironmentKey = QStringLiteral("Environment Profile");
 static const QString cmakeArgumentsKey = QStringLiteral("Extra Arguments");
 static const QString buildDirRuntime = QStringLiteral("Runtime");
 }
 
 static const QString groupNameBuildDir = QStringLiteral("CMake Build Directory %1");
 static const QString groupName = QStringLiteral("CMake");
 
 } // namespace Config
 
 namespace
 {
 
 KConfigGroup baseGroup( KDevelop::IProject* project )
 {
     if (!project)
         return KConfigGroup();
 
     return project->projectConfiguration()->group( Config::groupName );
 }
 
 KConfigGroup buildDirGroup( KDevelop::IProject* project, int buildDirIndex )
 {
     return baseGroup(project).group( Config::groupNameBuildDir.arg(buildDirIndex) );
 }
 
 bool buildDirGroupExists( KDevelop::IProject* project, int buildDirIndex )
 {
     return baseGroup(project).hasGroup( Config::groupNameBuildDir.arg(buildDirIndex) );
 }
 
 QString readBuildDirParameter( KDevelop::IProject* project, const QString& key, const QString& aDefault, int buildDirectory )
 {
     const int buildDirIndex = buildDirectory<0 ? CMake::currentBuildDirIndex(project) : buildDirectory;
     if (buildDirIndex >= 0)
         return buildDirGroup( project, buildDirIndex ).readEntry( key, aDefault );
 
     else
         return aDefault;
 }
 
 void writeBuildDirParameter( KDevelop::IProject* project, const QString& key, const QString& value )
 {
     int buildDirIndex = CMake::currentBuildDirIndex(project);
     if (buildDirIndex >= 0)
     {
         KConfigGroup buildDirGrp = buildDirGroup( project, buildDirIndex );
         buildDirGrp.writeEntry( key, value );
     }
 
     else
     {
         qCWarning(CMAKE) << "cannot write key" << key << "(" << value << ")" << "when no builddir is set!";
     }
 }
 
 void writeProjectBaseParameter( KDevelop::IProject* project, const QString& key, const QString& value )
 {
     KConfigGroup baseGrp = baseGroup(project);
     baseGrp.writeEntry( key, value );
 }
 
 void setBuildDirRuntime( KDevelop::IProject* project, const QString& name)
 {
     writeBuildDirParameter(project, Config::Specific::buildDirRuntime, name);
 }
 
 QString buildDirRuntime( KDevelop::IProject* project, int builddir)
 {
     return readBuildDirParameter(project, Config::Specific::buildDirRuntime, QString(), builddir);
 }
 
 } // namespace
 
 namespace CMake
 {
 
 KDevelop::Path::List resolveSystemDirs(KDevelop::IProject* project, const QStringList& dirs)
 {
     const KDevelop::Path buildDir(CMake::currentBuildDir(project));
     const KDevelop::Path installDir(CMake::currentInstallDir(project));
 
     KDevelop::Path::List newList;
     newList.reserve(dirs.size());
     for (const QString& s : dirs) {
         KDevelop::Path dir;
         if(s.startsWith(QLatin1String("#[bin_dir]")))
         {
             dir = KDevelop::Path(buildDir, s);
         }
         else if(s.startsWith(QLatin1String("#[install_dir]")))
         {
             dir = KDevelop::Path(installDir, s);
         }
         else
         {
             dir = KDevelop::Path(s);
         }
 
 //         qCDebug(CMAKE) << "resolved" << s << "to" << d;
 
         if (!newList.contains(dir))
         {
             newList.append(dir);
         }
     }
     return newList;
 }
 
 ///NOTE: when you change this, update @c defaultConfigure in cmakemanagertest.cpp
 bool checkForNeedingConfigure( KDevelop::IProject* project )
 {
     const QString currentRuntime = ICore::self()->runtimeController()->currentRuntime()->name();
     const KDevelop::Path builddir = currentBuildDir(project);
     const bool isValid = (buildDirRuntime(project, -1) == currentRuntime || buildDirRuntime(project, -1).isEmpty()) && builddir.isValid();
 
     if( !isValid )
     {
         CMakeBuildDirChooser bd;
 
         bd.setProject( project );
         const auto builddirs = CMake::allBuildDirs(project);
         bd.setAlreadyUsed( builddirs );
         bd.setShowAvailableBuildDirs(!builddirs.isEmpty());
         bd.setCMakeExecutable(currentCMakeExecutable(project));
 
         if( !bd.exec() )
         {
             return false;
         }
 
         if (bd.reuseBuilddir())
         {
             CMake::setCurrentBuildDirIndex( project, bd.alreadyUsedIndex() );
         }
         else
         {
-
-            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() );
         }
         setBuildDirRuntime( project, currentRuntime );
 
         return true;
     } else if( !QFile::exists( KDevelop::Path(builddir, QStringLiteral("CMakeCache.txt")).toLocalFile() ) ||
                 //TODO: maybe we could use the builder for that?
                !(QFile::exists( KDevelop::Path(builddir, QStringLiteral("Makefile")).toLocalFile() ) ||
                     QFile::exists( KDevelop::Path(builddir, QStringLiteral("build.ninja")).toLocalFile() ) ) )
     {
         // User entered information already, but cmake hasn't actually been run yet.
         setBuildDirRuntime( project, currentRuntime );
         return true;
     }
     setBuildDirRuntime( project, currentRuntime );
     return false;
 }
 
 QHash<KDevelop::Path, QStringList> enumerateTargets(const KDevelop::Path& targetsFilePath, const QString& sourceDir, const KDevelop::Path &buildDir)
 {
     const QString buildPath = buildDir.toLocalFile();
     QHash<KDevelop::Path, QStringList> targets;
     QFile targetsFile(targetsFilePath.toLocalFile());
     if (!targetsFile.open(QIODevice::ReadOnly)) {
         qCDebug(CMAKE) << "Couldn't find the Targets file in" << targetsFile.fileName();
     }
 
     QTextStream targetsFileStream(&targetsFile);
     const QRegularExpression rx(QStringLiteral("^(.*)/CMakeFiles/(.*).dir$"));
     while (!targetsFileStream.atEnd()) {
         const QString line = targetsFileStream.readLine();
         auto match = rx.match(line);
         if (!match.isValid())
             qCDebug(CMAKE) << "invalid match for" << line;
         const QString sourcePath = match.captured(1).replace(buildPath, sourceDir);
         targets[KDevelop::Path(sourcePath)].append(match.captured(2));
     }
     return targets;
 }
 
 KDevelop::Path projectRoot(KDevelop::IProject* project)
 {
     if (!project) {
         return {};
     }
 
     return project->path().cd(CMake::projectRootRelative(project));
 }
 
 KDevelop::Path currentBuildDir( KDevelop::IProject* project, int builddir )
 {
     return KDevelop::Path(readBuildDirParameter( project, Config::Specific::buildDirPathKey, QString(), builddir ));
 }
 
 KDevelop::Path commandsFile(KDevelop::IProject* project)
 {
     auto currentBuildDir = CMake::currentBuildDir(project);
     if (currentBuildDir.isEmpty()) {
         return {};
     }
 
     return KDevelop::Path(currentBuildDir, QStringLiteral("compile_commands.json"));
 }
 
 KDevelop::Path targetDirectoriesFile(KDevelop::IProject* project)
 {
     auto currentBuildDir = CMake::currentBuildDir(project);
     if (currentBuildDir.isEmpty()) {
         return {};
     }
 
     return KDevelop::Path(currentBuildDir, QStringLiteral("CMakeFiles/TargetDirectories.txt"));
 }
 
 QString currentBuildType( KDevelop::IProject* project, int builddir )
 {
     return readBuildDirParameter( project, Config::Specific::cmakeBuildTypeKey, QStringLiteral("Release"), builddir );
 }
 
 QString findExecutable()
 {
     auto cmake = QStandardPaths::findExecutable(QStringLiteral("cmake"));
 #ifdef Q_OS_WIN
     if (cmake.isEmpty())
         cmake = QStandardPaths::findExecutable("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, int builddir)
 {
     auto defaultCMakeExecutable = CMakeBuilderSettings::self()->cmakeExecutable().toLocalFile();
 
     if (!QFileInfo::exists(ICore::self()->runtimeController()->currentRuntime()->pathInHost(KDevelop::Path(defaultCMakeExecutable)).toLocalFile()))
         defaultCMakeExecutable = CMake::findExecutable();
 
     if (project) {
         // check for "CMake Executable" but for now also "CMake Binary", falling back to the default.
         auto projectCMakeExecutable = readBuildDirParameter( project, Config::Specific::cmakeExecutableKey,
             readBuildDirParameter( project, Config::Specific::cmakeBinaryKey, defaultCMakeExecutable, builddir),
             builddir );
         if (projectCMakeExecutable != defaultCMakeExecutable) {
             QFileInfo info(projectCMakeExecutable);
             if (!info.isExecutable()) {
                 projectCMakeExecutable = defaultCMakeExecutable;
             }
         }
         return KDevelop::Path(projectCMakeExecutable);
     }
     return KDevelop::Path(defaultCMakeExecutable);
 }
 
 KDevelop::Path currentInstallDir( KDevelop::IProject* project, int builddir )
 {
     const QString defaultInstallDir =
 #ifdef Q_OS_WIN
         QStringLiteral("C:\\Program Files");
 #else
         QStringLiteral("/usr/local");
 #endif
     return KDevelop::Path(readBuildDirParameter( project, Config::Specific::cmakeInstallDirKey, defaultInstallDir, builddir ));
 }
 
 QString projectRootRelative( KDevelop::IProject* project )
 {
     return baseGroup(project).readEntry( Config::Old::projectRootRelativeKey, "." );
 }
 
 bool hasProjectRootRelative(KDevelop::IProject* project)
 {
     return baseGroup(project).hasKey( Config::Old::projectRootRelativeKey );
 }
 
 QString currentExtraArguments( KDevelop::IProject* project, int builddir )
 {
     return readBuildDirParameter( project, Config::Specific::cmakeArgumentsKey, QString(), builddir );
 }
 
 void setCurrentInstallDir( KDevelop::IProject* project, const KDevelop::Path& path )
 {
     writeBuildDirParameter( project, Config::Specific::cmakeInstallDirKey, path.toLocalFile() );
 }
 
 void setCurrentBuildType( KDevelop::IProject* project, const QString& type )
 {
     writeBuildDirParameter( project, Config::Specific::cmakeBuildTypeKey, type );
 }
 
 void setCurrentCMakeExecutable(KDevelop::IProject* project, const KDevelop::Path& path)
 {
     // maintain compatibility with older versions for now
     writeBuildDirParameter(project, Config::Specific::cmakeBinaryKey, path.toLocalFile());
     writeBuildDirParameter(project, Config::Specific::cmakeExecutableKey, path.toLocalFile());
 }
 
 void setCurrentBuildDir( KDevelop::IProject* project, const KDevelop::Path& path )
 {
     writeBuildDirParameter( project, Config::Specific::buildDirPathKey, path.toLocalFile() );
 }
 
 void setProjectRootRelative( KDevelop::IProject* project, const QString& relative)
 {
     writeProjectBaseParameter( project, Config::Old::projectRootRelativeKey, relative );
 }
 
 void setCurrentExtraArguments( KDevelop::IProject* project, const QString& string)
 {
     writeBuildDirParameter( project, Config::Specific::cmakeArgumentsKey, string );
 }
 
 QString currentEnvironment(KDevelop::IProject* project, int builddir)
 {
     return readBuildDirParameter( project, Config::Specific::cmakeEnvironmentKey, QString(), builddir );
 }
 
 int currentBuildDirIndex( KDevelop::IProject* project )
 {
     KConfigGroup baseGrp = baseGroup(project);
 
     if ( baseGrp.hasKey( Config::buildDirOverrideIndexKey ) )
         return baseGrp.readEntry<int>( Config::buildDirOverrideIndexKey, -1 );
 
     else if (baseGrp.hasKey(Config::buildDirIndexKey()))
         return baseGrp.readEntry<int>( Config::buildDirIndexKey(), -1 );
     else
         return baseGrp.readEntry<int>( Config::buildDirIndexKey_, -1 ); // backwards compatibility
 }
 
 void setCurrentBuildDirIndex( KDevelop::IProject* project, int buildDirIndex )
 {
     writeProjectBaseParameter( project, Config::buildDirIndexKey(), QString::number (buildDirIndex) );
 }
 
 void setCurrentEnvironment( KDevelop::IProject* project, const QString& environment )
 {
     writeBuildDirParameter( project, Config::Specific::cmakeEnvironmentKey, environment );
 }
 
 void initBuildDirConfig( KDevelop::IProject* project )
 {
     int buildDirIndex = currentBuildDirIndex( project );
     if (buildDirCount(project) <= buildDirIndex )
         setBuildDirCount( project, buildDirIndex + 1 );
 }
 
 int buildDirCount( KDevelop::IProject* project )
 {
     return baseGroup(project).readEntry<int>( Config::buildDirCountKey, 0 );
 }
 
 void setBuildDirCount( KDevelop::IProject* project, int count )
 {
     writeProjectBaseParameter( project, Config::buildDirCountKey, QString::number(count) );
 }
 
 void removeBuildDirConfig( KDevelop::IProject* project )
 {
     int buildDirIndex = currentBuildDirIndex( project );
     if ( !buildDirGroupExists( project, buildDirIndex ) )
     {
         qCWarning(CMAKE) << "build directory config" << buildDirIndex << "to be removed but does not exist";
         return;
     }
 
     int bdCount = buildDirCount(project);
     setBuildDirCount( project, bdCount - 1 );
     removeOverrideBuildDirIndex( project );
     setCurrentBuildDirIndex( project, -1 );
 
     // move (rename) the upper config groups to keep the numbering
     // if there's nothing to move, just delete the group physically
     if (buildDirIndex + 1 == bdCount)
         buildDirGroup( project, buildDirIndex ).deleteGroup();
 
     else for (int i = buildDirIndex + 1; i < bdCount; ++i)
     {
         KConfigGroup src = buildDirGroup( project, i );
         KConfigGroup dest = buildDirGroup( project, i - 1 );
         dest.deleteGroup();
         src.copyTo(&dest);
         src.deleteGroup();
     }
 }
 
 QHash<QString, QString> readCacheValues(const KDevelop::Path& cmakeCachePath, QSet<QString> variables)
 {
     QHash<QString, QString> ret;
     QFile file(cmakeCachePath.toLocalFile());
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         qCWarning(CMAKE) << "couldn't open CMakeCache.txt" << cmakeCachePath;
         return ret;
     }
 
     QTextStream in(&file);
     while (!in.atEnd() && !variables.isEmpty())
     {
         QString line = in.readLine().trimmed();
         if(!line.isEmpty() && line[0].isLetter())
         {
             CacheLine c;
             c.readLine(line);
 
             if(!c.isCorrect())
                 continue;
 
             if (variables.remove(c.name())) {
                 ret[c.name()] = c.value();
             }
         }
     }
     return ret;
 }
 
 void updateConfig( KDevelop::IProject* project, int buildDirIndex)
 {
     if (buildDirIndex < 0)
         return;
 
     KConfigGroup buildDirGrp = buildDirGroup( project, buildDirIndex );
     const KDevelop::Path builddir(buildDirGrp.readEntry( Config::Specific::buildDirPathKey, QString() ));
     const KDevelop::Path cacheFilePath( builddir, QStringLiteral("CMakeCache.txt"));
 
     const QMap<QString, QString> keys = {
         { QStringLiteral("CMAKE_COMMAND"), Config::Specific::cmakeExecutableKey },
         { QStringLiteral("CMAKE_INSTALL_PREFIX"), Config::Specific::cmakeInstallDirKey },
         { QStringLiteral("CMAKE_BUILD_TYPE"), Config::Specific::cmakeBuildTypeKey }
     };
 
     const QHash<QString, QString> cacheValues = readCacheValues(cacheFilePath, keys.keys().toSet());
     for(auto it = cacheValues.constBegin(), itEnd = cacheValues.constEnd(); it!=itEnd; ++it) {
         const QString key = keys.value(it.key());
         Q_ASSERT(!key.isEmpty());
 
         // Use cache only when the config value is not set. Without this check we will always
         // overwrite values provided by the user in config dialog.
         if (buildDirGrp.readEntry(key).isEmpty() && !it.value().isEmpty())
         {
             buildDirGrp.writeEntry( key, it.value() );
         }
     }
 }
 
 void attemptMigrate( KDevelop::IProject* project )
 {
     if ( !baseGroup(project).hasKey( Config::Old::projectBuildDirs ) )
     {
         qCDebug(CMAKE) << "CMake settings migration: already done, exiting";
         return;
     }
 
     KConfigGroup baseGrp = baseGroup(project);
 
     KDevelop::Path buildDir( baseGrp.readEntry( Config::Old::currentBuildDirKey, QString() ) );
     int buildDirIndex = -1;
     const QStringList existingBuildDirs = baseGrp.readEntry( Config::Old::projectBuildDirs, QStringList() );
     {
         // also, find current build directory in this list (we need an index, not path)
         QString currentBuildDirCanonicalPath = QDir( buildDir.toLocalFile() ).canonicalPath();
 
         for( int i = 0; i < existingBuildDirs.count(); ++i )
         {
             const QString& nextBuildDir = existingBuildDirs.at(i);
             if( QDir(nextBuildDir).canonicalPath() == currentBuildDirCanonicalPath )
             {
                 buildDirIndex = i;
             }
         }
     }
     int buildDirsCount = existingBuildDirs.count();
 
     qCDebug(CMAKE) << "CMake settings migration: existing build directories" << existingBuildDirs;
     qCDebug(CMAKE) << "CMake settings migration: build directory count" << buildDirsCount;
     qCDebug(CMAKE) << "CMake settings migration: current build directory" << buildDir << "(index" << buildDirIndex << ")";
 
     baseGrp.writeEntry( Config::buildDirCountKey, buildDirsCount );
     baseGrp.writeEntry( Config::buildDirIndexKey(), buildDirIndex );
 
     for (int i = 0; i < buildDirsCount; ++i)
     {
         qCDebug(CMAKE) << "CMake settings migration: writing group" << i << ": path" << existingBuildDirs.at(i);
 
         KConfigGroup buildDirGrp = buildDirGroup( project, i );
         buildDirGrp.writeEntry( Config::Specific::buildDirPathKey, existingBuildDirs.at(i) );
     }
 
     baseGrp.deleteEntry( Config::Old::currentBuildDirKey );
     baseGrp.deleteEntry( Config::Old::currentCMakeExecutableKey );
     baseGrp.deleteEntry( Config::Old::currentBuildTypeKey );
     baseGrp.deleteEntry( Config::Old::currentInstallDirKey );
     baseGrp.deleteEntry( Config::Old::currentEnvironmentKey );
     baseGrp.deleteEntry( Config::Old::currentExtraArgumentsKey );
     baseGrp.deleteEntry( Config::Old::projectBuildDirs );
 }
 
 void setOverrideBuildDirIndex( KDevelop::IProject* project, int overrideBuildDirIndex )
 {
     writeProjectBaseParameter( project, Config::buildDirOverrideIndexKey, QString::number(overrideBuildDirIndex) );
 }
 
 void removeOverrideBuildDirIndex( KDevelop::IProject* project, bool writeToMainIndex )
 {
     KConfigGroup baseGrp = baseGroup(project);
 
     if( !baseGrp.hasKey(Config::buildDirOverrideIndexKey) )
         return;
     if( writeToMainIndex )
         baseGrp.writeEntry( Config::buildDirIndexKey(), baseGrp.readEntry(Config::buildDirOverrideIndexKey) );
 
     baseGrp.deleteEntry(Config::buildDirOverrideIndexKey);
 }
 
 ICMakeDocumentation* cmakeDocumentation()
 {
     return KDevelop::ICore::self()->pluginController()->extensionForPlugin<ICMakeDocumentation>(QStringLiteral("org.kdevelop.ICMakeDocumentation"));
 }
 
 QStringList allBuildDirs(KDevelop::IProject* project)
 {
     QStringList result;
     int bdCount = buildDirCount(project);
     result.reserve(bdCount);
     for (int i = 0; i < bdCount; ++i)
         result += buildDirGroup( project, i ).readEntry( Config::Specific::buildDirPathKey );
     return result;
 }
 
 QString executeProcess(const QString& execName, const QStringList& args)
 {
     Q_ASSERT(!execName.isEmpty());
     qCDebug(CMAKE) << "Executing:" << execName << "::" << args;
 
     QProcess p;
     QTemporaryDir tmp(QStringLiteral("kdevcmakemanager"));
     p.setWorkingDirectory( tmp.path() );
     p.start(execName, args, QIODevice::ReadOnly);
 
     if(!p.waitForFinished())
     {
         qCDebug(CMAKE) << "failed to execute:" << execName << args << p.exitStatus() << p.readAllStandardError();
     }
 
     QByteArray b = p.readAllStandardOutput();
     QString t;
     t.prepend(b.trimmed());
     return t;
 }
 
 QStringList supportedGenerators()
 {
     QStringList generatorNames;
 
     bool hasNinja = ICore::self() && ICore::self()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IProjectBuilder"), QStringLiteral("KDevNinjaBuilder"));
     if (hasNinja)
         generatorNames << QStringLiteral("Ninja");
 
 #ifdef Q_OS_WIN
     // Visual Studio solution is the standard generator under windows, but we don't want to use
     // the VS IDE, so we need nmake makefiles
     generatorNames << QStringLiteral("NMake Makefiles") << QStringLiteral("MinGW Makefiles");
 #endif
     generatorNames << QStringLiteral("Unix Makefiles");
 
     return generatorNames;
 }
 
 QString defaultGenerator()
 {
     const QStringList generatorNames = supportedGenerators();
 
     QString defGen = generatorNames.value(CMakeBuilderSettings::self()->generator());
     if (defGen.isEmpty())
     {
         qCWarning(CMAKE) << "Couldn't find builder with index " << CMakeBuilderSettings::self()->generator()
                    << ", defaulting to 0";
         CMakeBuilderSettings::self()->setGenerator(0);
         defGen = generatorNames.at(0);
     }
     return defGen;
 }
 
 QVector<Test> importTestSuites(const Path &buildDir)
 {
     const auto contents = CMakeListsParser::readCMakeFile(buildDir.toLocalFile() + "/CTestTestfile.cmake");
 
     QVector<Test> tests;
     for (const auto& entry: contents) {
         if (entry.name == QLatin1String("add_test")) {
             auto args = entry.arguments;
 
             Test test;
             test.name = args.takeFirst().value;
             test.executable = args.takeFirst().value;
             test.arguments = kTransform<QStringList>(args, [](const CMakeFunctionArgument& arg) { return arg.value; });
             tests += test;
         } else if (entry.name == QLatin1String("subdirs")) {
             tests += importTestSuites(Path(buildDir, entry.arguments.first().value));
         } else if (entry.name == QLatin1String("set_tests_properties")) {
             if(entry.arguments.count() < 4 || entry.arguments.count() % 2) {
                 qCWarning(CMAKE) << "found set_tests_properties() with unexpected number of arguments:"
                                  << entry.arguments.count();
                 continue;
             }
             if (tests.isEmpty() || entry.arguments.first().value != tests.last().name) {
                 qCWarning(CMAKE) << "found set_tests_properties(" << entry.arguments.first().value
                                  << " ...), but expected test " << tests.last().name;
                 continue;
             }
             if (entry.arguments[1].value != QLatin1String("PROPERTIES")) {
                 qCWarning(CMAKE) << "found set_tests_properties(" << entry.arguments.first().value
                                  << entry.arguments.at(1).value << "...), but expected PROPERTIES as second argument";
                 continue;
             }
             Test &test = tests.last();
             for (int i = 2; i < entry.arguments.count(); i += 2)
                 test.properties[entry.arguments[i].value] = entry.arguments[i + 1].value;
         }
     }
 
     return tests;
 }
 
 }
diff --git a/plugins/cmake/tests/cmakeparsertest.cpp b/plugins/cmake/tests/cmakeparsertest.cpp
index 5c165ef9e6..3ce516110f 100644
--- a/plugins/cmake/tests/cmakeparsertest.cpp
+++ b/plugins/cmake/tests/cmakeparsertest.cpp
@@ -1,127 +1,127 @@
 /* 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 "cmakeparsertest.h"
 
 #include <QTemporaryFile>
 #include "cmListFileLexer.h"
 #include "cmakelistsparser.h"
 
 CMakeParserTest::CMakeParserTest()
 {}
 
 CMakeParserTest::~CMakeParserTest()
 {}
 
 void CMakeParserTest::testLexerCreation()
 {
     cmListFileLexer* lexer = cmListFileLexer_New();
     QVERIFY( lexer != nullptr );
     cmListFileLexer_Delete( lexer );
 }
 
 void CMakeParserTest::testLexerWithFile()
 {
     QTemporaryFile tempFile;
     tempFile.setAutoRemove( false );
     tempFile.open();
     if ( !QFile::exists( tempFile.fileName() ) )
          QFAIL( "Unable to open temporary file" );
 
     QString tempName = tempFile.fileName();
     tempFile.close(); //hacks to the get name of the file
 
     cmListFileLexer* lexer = cmListFileLexer_New();
     if ( !lexer )
         QFAIL( "unable to create lexer" );
     QVERIFY( cmListFileLexer_SetFileName( lexer, qPrintable( tempName ), nullptr ) );
     cmListFileLexer_Delete( lexer );
     tempFile.remove();
 }
 
 void CMakeParserTest::testParserWithGoodData()
 {
 //    QFAIL( "the magic is missing" );
     QFETCH( QString, text );
     QTemporaryFile tempFile;
     tempFile.setAutoRemove( false );
     tempFile.open();
     if ( !QFile::exists( tempFile.fileName() ) )
         QFAIL( "Unable to open temporary file" );
 
     tempFile.write( text.toUtf8() );
     QString tempName = tempFile.fileName();
     tempFile.close(); //hacks to the get name of the file
     const bool parseError = CMakeListsParser::readCMakeFile( tempName ).isEmpty();
     QVERIFY( parseError == false );
     tempFile.remove();
 }
 
 void CMakeParserTest::testParserWithGoodData_data()
 {
     QTest::addColumn<QString>( "text" );
     QTest::newRow( "good data1" ) << "project(foo)\nset(foobar_SRCS foo.h foo.c)";
     QTest::newRow( "good data2" ) << "set(foobar_SRCS foo.h foo.c)\n"
                                      "add_executable( foo ${foobar_SRCS})";
     QTest::newRow( "test data" ) << "add_test(mytest \"mytest\")\n";
 }
 
 void CMakeParserTest::testParserWithBadData()
 {
     QFETCH( QString, text );
     QTemporaryFile tempFile;
     tempFile.setAutoRemove( false );
     tempFile.open();
     if ( !QFile::exists( tempFile.fileName() ) )
         QFAIL( "Unable to open temporary file" );
 
     tempFile.write( text.toUtf8() );
-    QString tempName = tempFile.fileName();
     tempFile.close(); //hacks to the get name of the file
 //    CMakeAst* ast = new CMakeAst;
+//    QString tempName = tempFile.fileName();
 //    bool parseError = CMakeListsParser::parseCMakeFile( ast, qPrintable( tempName ) );
 //    delete ast;
 //    QVERIFY( parseError == true );
     tempFile.remove();
 }
 
 void CMakeParserTest::testParserWithBadData_data()
 {
     QTest::addColumn<QString>( "text" );
 
     //just plain wrong. :)
     QTest::newRow( "bad data 1" ) << "foo bar baz zippedy do dah";
 
     //missing right parenthesis
     QTest::newRow( "bad data 2" ) << "set(mysrcs_SRCS foo.c\n\n\n";
 
     //extra identifiers between functions. cmake doesn't allow plain identifiers
     QTest::newRow( "bad data 3" ) << "the(quick) brown fox jumped(over) the lazy dog";
 
     //invalid due to no newline before next command
     QTest::newRow( "bad data 4" ) << "project(foo) set(mysrcs_SRCS foo.c)";
 }
 
 // void CMakeParserTest::testAstCreation()
 // {
 
 // }
 
 QTEST_GUILESS_MAIN( CMakeParserTest )
diff --git a/plugins/debuggercommon/midebugsession.cpp b/plugins/debuggercommon/midebugsession.cpp
index 5c8013b030..919f8bea62 100644
--- a/plugins/debuggercommon/midebugsession.cpp
+++ b/plugins/debuggercommon/midebugsession.cpp
@@ -1,1304 +1,1302 @@
 /*
  * 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/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 <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_debuggerState(s_dbgNotStarted | s_appNotStarted)
     , m_tty(nullptr)
     , 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(QStringLiteral("[\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.truncate(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 << QStringLiteral("--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());
 #ifndef Q_OS_WIN
     if (tty.isEmpty()) {
         KMessageBox::information(qApp->activeWindow(), m_tty->lastError(), i18n("warning"));
 
         m_tty.reset(nullptr);
         return false;
     }
 #endif
     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 == QLatin1String("GdbConsole")) {
         emit raiseDebuggerConsoleViews();
     } else if (config_startWith == QLatin1String("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 == QLatin1String("error")) {
         KMessageBox::error(
             qApp->activeWindow(),
             i18n("<b>Could not attach debugger:</b><br />")+
             r[QStringLiteral("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) ? " +" : " -") + QString::number(i);
             }
         }
     }
 }
 
 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 << "- changes:" << changedState;
 
     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, QStringLiteral("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 - interrupting";
         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(QStringLiteral("(gdb) detach\n"));
     }
 
     // Now try to stop debugger running.
     addCommand(GdbExit);
     emit debuggerUserCommandOutput(QStringLiteral("(gdb) quit"));
 
     // We cannot wait forever, kill gdb after 5 seconds if it's not yet quit
     QTimer::singleShot(5000, this, [this]() {
         if (!debuggerStateIsOn(s_programExited) && debuggerStateIsOn(s_shuttingDown)) {
             qCDebug(DEBUGGERCOMMON) << "debugger not shutdown - killing";
             m_debugger->kill();
             setDebuggerState(s_dbgNotStarted | s_appNotStarted);
             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,
                    QStringLiteral("%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, QStringLiteral("*%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, QStringLiteral("tbreak %1:%2").arg(url.toLocalFile()).arg(line));
         addCommand(NonMI, QStringLiteral("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, QStringLiteral("tbreak *%1").arg(address));
         addCommand(NonMI, QStringLiteral("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, QLatin1Char(' ') + 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 = QStringLiteral("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(QStringLiteral("reason"))) reason = r[QStringLiteral("reason")].literal();
 
     if (reason == QLatin1String("exited-normally") || reason == QLatin1String("exited")) {
         if (r.hasField(QStringLiteral("exit-code"))) {
             programNoApp(i18n("Exited with return code: %1", r["exit-code"].literal()));
         } else {
             programNoApp(i18n("Exited normally"));
         }
         m_stateReloadNeeded = false;
         return;
     }
 
     if (reason == QLatin1String("exited-signalled")) {
         programNoApp(i18n("Exited on signal %1", r["signal-name"].literal()));
         m_stateReloadNeeded = false;
         return;
     }
 
     if (reason == QLatin1String("watchpoint-scope")) {
-        QString number = r[QStringLiteral("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 == QLatin1String("signal-received")) {
         QString name = r[QStringLiteral("signal-name")].literal();
         QString user_name = r[QStringLiteral("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 == QLatin1String("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(QLatin1String("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(QStringLiteral("frame"))) {
             const MI::Value& frame = r[QStringLiteral("frame")];
             QString file, line, addr;
 
             if (frame.hasField(QStringLiteral("fullname"))) file = frame[QStringLiteral("fullname")].literal();
             if (frame.hasField(QStringLiteral("line")))     line = frame[QStringLiteral("line")].literal();
             if (frame.hasField(QStringLiteral("addr")))     addr = frame[QStringLiteral("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 == QLatin1String("thread-group-started")) {
         setDebuggerStateOff(s_appNotStarted | s_programExited);
     } else if (async.reason == QLatin1String("thread-group-exited")) {
         setDebuggerStateOn(s_programExited);
     } else if (async.reason == QLatin1String("library-loaded")) {
         // do nothing
     } else if (async.reason == QLatin1String("breakpoint-created")) {
         breakpointController()->notifyBreakpointCreated(async);
     } else if (async.reason == QLatin1String("breakpoint-modified")) {
         breakpointController()->notifyBreakpointModified(async);
     } else if (async.reason == QLatin1String("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 = 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);
 }
 
 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[QStringLiteral("msg")].literal();
 
     if (msg.contains(QLatin1String("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/plugins/debuggercommon/tests/debuggees/qdatetime.cpp b/plugins/debuggercommon/tests/debuggees/qdatetime.cpp
index ff2e24ccb4..4ae8ce5d13 100644
--- a/plugins/debuggercommon/tests/debuggees/qdatetime.cpp
+++ b/plugins/debuggercommon/tests/debuggees/qdatetime.cpp
@@ -1,6 +1,7 @@
 #include <QDateTime>
 int main()
 {
     QDateTime dt(QDate(2010, 1, 20), QTime(15, 31, 13));
     return 0;
 }
+// clazy:skip
diff --git a/plugins/debuggercommon/tests/debuggees/qurl.cpp b/plugins/debuggercommon/tests/debuggees/qurl.cpp
index 218a683161..92ba5daa22 100644
--- a/plugins/debuggercommon/tests/debuggees/qurl.cpp
+++ b/plugins/debuggercommon/tests/debuggees/qurl.cpp
@@ -1,6 +1,7 @@
 #include <QUrl>
 int main()
 {
     QUrl u(QStringLiteral("http://user@www.kdevelop.org:12345/foo?xyz=bar#asdf"));
     return 0;
 }
+// clazy:skip
diff --git a/plugins/gdb/unittests/test_gdb.cpp b/plugins/gdb/unittests/test_gdb.cpp
index d83b8575be..8f292a84d6 100644
--- a/plugins/gdb/unittests/test_gdb.cpp
+++ b/plugins/gdb/unittests/test_gdb.cpp
@@ -1,2121 +1,2119 @@
 /*
    Copyright 2009 Niko Sams <niko.sams@gmail.com>
    Copyright 2013 Vlas Puhov <vlas.puhov@mail.ru>
 
    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_gdb.h"
 
 #include "debugsession.h"
 #include "gdbframestackmodel.h"
 #include "mi/micommand.h"
 #include "mi/milexer.h"
 #include "mi/miparser.h"
 #include "tests/debuggers-tests-config.h"
 #include "tests/testhelper.h"
 
 #include <execute/iexecuteplugin.h>
 #include <debugger/breakpoint/breakpoint.h>
 #include <debugger/breakpoint/breakpointmodel.h>
 #include <debugger/framestack/framestackmodel.h>
 #include <debugger/interfaces/ivariablecontroller.h>
 #include <debugger/variable/variablecollection.h>
 #include <interfaces/idebugcontroller.h>
 #include <interfaces/ilaunchconfiguration.h>
 #include <interfaces/iplugincontroller.h>
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <shell/shellextension.h>
 #include <util/environmentprofilelist.h>
 
 #include <KIO/Global>
 #include <KProcess>
 #include <KSharedConfig>
 #include <KShell>
 
 #include <QApplication>
 #include <QDebug>
 #include <QDir>
 #include <QFileInfo>
 #include <QStandardPaths>
 #include <QSignalSpy>
 #include <QTest>
 #include <QTemporaryFile>
 
 #define SKIP_IF_ATTACH_FORBIDDEN() \
     do { \
         if (KDevMI::isAttachForbidden(__FILE__, __LINE__)) \
             return; \
     } while(0)
 
 using KDevelop::AutoTestShell;
 using KDevMI::findExecutable;
 using KDevMI::findSourceFile;
 using KDevMI::findFile;
 
 namespace KDevMI { namespace GDB {
 
 void GdbTest::initTestCase()
 {
     AutoTestShell::init();
     KDevelop::TestCore::initialize(KDevelop::Core::NoUi);
 
     m_iface = KDevelop::ICore::self()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IExecutePlugin"), QStringLiteral("kdevexecute"))->extension<IExecutePlugin>();
     Q_ASSERT(m_iface);
 }
 
 void GdbTest::cleanupTestCase()
 {
     KDevelop::TestCore::shutdown();
 }
 
 void GdbTest::init()
 {
     //remove all breakpoints - so we can set our own in the test
     KConfigGroup breakpoints = KSharedConfig::openConfig()->group("breakpoints");
     breakpoints.writeEntry("number", 0);
     breakpoints.sync();
 
     KDevelop::BreakpointModel* m = KDevelop::ICore::self()->debugController()->breakpointModel();
     m->removeRows(0, m->rowCount());
 
     KDevelop::VariableCollection *vc = KDevelop::ICore::self()->debugController()->variableCollection();
     for (int i=0; i < vc->watches()->childCount(); ++i) {
         delete vc->watches()->child(i);
     }
     vc->watches()->clear();
 }
 
 class WritableEnvironmentProfileList : public KDevelop::EnvironmentProfileList
 {
 public:
     explicit WritableEnvironmentProfileList(KConfig* config) : EnvironmentProfileList(config) {}
 
     using EnvironmentProfileList::variables;
     using EnvironmentProfileList::saveSettings;
     using EnvironmentProfileList::removeProfile;
 };
 
 class TestLaunchConfiguration : public KDevelop::ILaunchConfiguration
 {
 public:
     explicit TestLaunchConfiguration(const QUrl& executable = findExecutable(QStringLiteral("debuggee_debugee")),
                             const QUrl& workingDirectory = QUrl()) {
         qDebug() << "FIND" << executable;
         c = KSharedConfig::openConfig();
         c->deleteGroup("launch");
         cfg = c->group("launch");
         cfg.writeEntry("isExecutable", true);
         cfg.writeEntry("Executable", executable);
         cfg.writeEntry("Working Directory", workingDirectory);
     }
     const KConfigGroup config() const override { return cfg; }
     KConfigGroup config() override { return cfg; };
     QString name() const override { return QStringLiteral("Test-Launch"); }
     KDevelop::IProject* project() const override { return nullptr; }
     KDevelop::LaunchConfigurationType* type() const override { return nullptr; }
 
     KConfig* rootConfig() { return c.data(); }
 private:
     KConfigGroup cfg;
     KSharedConfigPtr c;
 };
 
 class TestFrameStackModel : public GdbFrameStackModel
 {
 public:
 
     explicit TestFrameStackModel(DebugSession* session)
         : GdbFrameStackModel(session), fetchFramesCalled(0), fetchThreadsCalled(0) {}
 
     int fetchFramesCalled;
     int fetchThreadsCalled;
     void fetchFrames(int threadNumber, int from, int to) override
     {
         fetchFramesCalled++;
         GdbFrameStackModel::fetchFrames(threadNumber, from, to);
     }
 
     void fetchThreads() override
     {
         fetchThreadsCalled++;
         GdbFrameStackModel::fetchThreads();
     }
 };
 
 class TestDebugSession : public DebugSession
 {
     Q_OBJECT
 public:
     TestDebugSession() : DebugSession()
     {
         setSourceInitFile(false);
         setAutoDisableASLR(false);
         m_frameStackModel = new TestFrameStackModel(this);
         KDevelop::ICore::self()->debugController()->addSession(this);
     }
 
     QUrl url() { return currentUrl(); }
     int line() { return currentLine(); }
 
     TestFrameStackModel* frameStackModel() const override
     {
         return m_frameStackModel;
     }
 
 private:
     TestFrameStackModel* m_frameStackModel;
 };
 
 class TestWaiter
 {
 public:
     TestWaiter(DebugSession * session_, const char * condition_, const char * file_, int line_)
         : session(session_)
         , condition(condition_)
         , file(file_)
         , line(line_)
     {
         stopWatch.start();
     }
 
     bool waitUnless(bool ok)
     {
         if (ok) {
             qDebug() << "Condition " << condition << " reached in " << file << ':' << line;
             return false;
         }
 
         if (stopWatch.elapsed() > 5000) {
             QTest::qFail(qPrintable(QString("Timeout before reaching condition %0").arg(condition)),
                 file, line);
             return false;
         }
 
         QTest::qWait(100);
 
         if (!session) {
             QTest::qFail(qPrintable(QString("Session ended without reaching condition %0").arg(condition)),
                 file, line);
             return false;
         }
 
         return true;
     }
 
 private:
     QTime stopWatch;
     QPointer<DebugSession> session;
     const char * condition;
     const char * file;
     int line;
 };
 
 #define WAIT_FOR_STATE(session, state) \
     do { if (!waitForState((session), (state), __FILE__, __LINE__)) return; } while (0)
 
 #define WAIT_FOR_STATE_AND_IDLE(session, state) \
     do { if (!waitForState((session), (state), __FILE__, __LINE__, true)) return; } while (0)
 
 #define WAIT_FOR(session, condition) \
     do { \
         TestWaiter w((session), #condition, __FILE__, __LINE__); \
         while (w.waitUnless((condition))) /* nothing */ ; \
     } while(0)
 
 #define COMPARE_DATA(index, expected) \
     do { if(!compareData((index), (expected), __FILE__, __LINE__)) return; } while (0)
 
 bool compareData(const QModelIndex& index, const QString& expected, const char *file, int line)
 {
     QString s = index.model()->data(index, Qt::DisplayRole).toString();
     if (s != expected) {
         QTest::qFail(qPrintable(QString("'%0' didn't match expected '%1' in %2:%3")
                                 .arg(s, expected, file).arg(line)),
                      file, line);
         return false;
     }
     return true;
 }
 
 static const QString debugeeFileName = findSourceFile(QStringLiteral("debugee.cpp"));
 
 KDevelop::BreakpointModel* breakpoints()
 {
     return KDevelop::ICore::self()->debugController()->breakpointModel();
 }
 
 void GdbTest::testStdOut()
 {
     TestDebugSession *session = new TestDebugSession;
 
     QSignalSpy outputSpy(session, &TestDebugSession::inferiorStdoutLines);
 
     TestLaunchConfiguration cfg;
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, KDevelop::IDebugSession::EndedState);
 
     {
         QCOMPARE(outputSpy.count(), 1);
         QList<QVariant> arguments = outputSpy.takeFirst();
         QCOMPARE(arguments.count(), 1);
         QCOMPARE(arguments.first().toStringList(), QStringList() << "Hello, world!" << "Hello");
     }
 }
 
 void GdbTest::testEnvironmentSet()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeechoenv")));
 
     cfg.config().writeEntry("EnvironmentGroup", "GdbTestGroup");
 
     WritableEnvironmentProfileList envProfiles(cfg.rootConfig());
     envProfiles.removeProfile(QStringLiteral("GdbTestGroup"));
     auto &envs = envProfiles.variables(QStringLiteral("GdbTestGroup"));
     envs[QStringLiteral("VariableA")] = QStringLiteral("-A' \" complex --value");
     envs[QStringLiteral("VariableB")] = QStringLiteral("-B' \" complex --value");
     envProfiles.saveSettings(cfg.rootConfig());
 
     QSignalSpy outputSpy(session, &TestDebugSession::inferiorStdoutLines);
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, KDevelop::IDebugSession::EndedState);
 
     QVERIFY(outputSpy.count() > 0);
 
     QStringList outputLines;
     while (outputSpy.count() > 0) {
         QList<QVariant> arguments = outputSpy.takeFirst();
         for (const auto &item : arguments) {
             outputLines.append(item.toStringList());
         }
     }
     QCOMPARE(outputLines, QStringList() << "-A' \" complex --value"
                                        << "-B' \" complex --value");
 }
 
 void GdbTest::testBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint * b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28);
     QCOMPARE(b->state(), KDevelop::Breakpoint::NotStartedState);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(b->state(), KDevelop::Breakpoint::CleanState);
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     QCOMPARE(b->state(), KDevelop::Breakpoint::NotStartedState);
 }
 
 void GdbTest::testDisableBreakpoint()
 {
     //Description: We must stop only on the third breakpoint
 
     int firstBreakLine=28;
     int secondBreakLine=23;
     int thirdBreakLine=24;
     int fourthBreakLine=31;
 
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint *b;
 
     b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), firstBreakLine);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
 
 
     //this is needed to emulate debug from GUI. If we are in edit mode, the debugSession doesn't exist.
     KDevelop::ICore::self()->debugController()->breakpointModel()->blockSignals(true);
     b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), secondBreakLine);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
     //all disabled breakpoints were added
 
     KDevelop::Breakpoint * thirdBreak = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), thirdBreakLine);
     KDevelop::ICore::self()->debugController()->breakpointModel()->blockSignals(false);
 
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->currentLine(), thirdBreak->line());
 
     //disable existing breakpoint
     thirdBreak->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
 
     //add another disabled breakpoint
     b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), fourthBreakLine);
     QTest::qWait(300);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
 
     QTest::qWait(300);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testChangeLocationBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint *b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 27);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 27);
 
     QTest::qWait(100);
     b->setLine(28);
     QTest::qWait(100);
     session->run();
 
     QTest::qWait(100);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 28);
     QTest::qWait(500);
     breakpoints()->setData(breakpoints()->index(0, KDevelop::Breakpoint::LocationColumn), QString(debugeeFileName+":30"));
     QCOMPARE(b->line(), 29);
     QTest::qWait(100);
     QCOMPARE(b->line(), 29);
     session->run();
     QTest::qWait(100);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 29);
     session->run();
 
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testDeleteBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     QCOMPARE(breakpoints()->rowCount(), 0);
     //add breakpoint before startDebugging
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 21);
     QCOMPARE(breakpoints()->rowCount(), 1);
     breakpoints()->removeRow(0);
     QCOMPARE(breakpoints()->rowCount(), 0);
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 22);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     breakpoints()->removeRow(0);
     session->run();
 
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testPendingBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28);
 
     KDevelop::Breakpoint * b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile(QStringLiteral("debugeeqt.cpp"))), 10);
     QCOMPARE(b->state(), KDevelop::Breakpoint::NotStartedState);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(b->state(), KDevelop::Breakpoint::PendingState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testUpdateBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     // breakpoint 1: real line 29: foo();
     KDevelop::Breakpoint * b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28);
     QCOMPARE(breakpoints()->rowCount(), 1);
 
     session->startDebugging(&cfg, m_iface);
 
     // breakpoint 2: real line 32: const char *x = "Hello";
     //insert custom command as user might do it using GDB console
     session->addCommand(new MI::UserCommand(MI::NonMI, "break "+debugeeFileName+":32"));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState); // stop at breakpoint 1, with custom command handled
     QCOMPARE(session->currentLine(), 28);
 
     // check breakpoint 2 got picked up
     QCOMPARE(breakpoints()->rowCount(), 2);
     b = breakpoints()->breakpoint(1);
     QCOMPARE(b->url(), QUrl::fromLocalFile(debugeeFileName));
     QCOMPARE(b->line(), 31);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState); // stop at breakpoint 2
     QCOMPARE(session->currentLine(), 31);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testIgnoreHitsBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint * b1 = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 21);
     b1->setIgnoreHits(1);
 
     KDevelop::Breakpoint * b2 = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 22);
 
     session->startDebugging(&cfg, m_iface);
 
     //WAIT_FOR_STATE(session, DebugSession::PausedState);
     WAIT_FOR(session, session->state() == DebugSession::PausedState && b2->hitCount() == 1);
     b2->setIgnoreHits(1);
     session->run();
     //WAIT_FOR_STATE(session, DebugSession::PausedState);
     WAIT_FOR(session, session->state() == DebugSession::PausedState && b1->hitCount() == 1);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testConditionBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint * b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 39);
     b->setCondition(QStringLiteral("x[0] == 'H'"));
 
     b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 23);
     b->setCondition(QStringLiteral("i==2"));
 
     b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR(session, session->state() == DebugSession::PausedState && session->line() == 24);
     b->setCondition(QStringLiteral("i == 0"));
     QTest::qWait(100);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 23);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 39);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBreakOnWriteBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     breakpoints()->addWatchpoint(QStringLiteral("i"));
     QTest::qWait(100);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // line 23: ++i; int j = i;
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBreakOnWriteWithConditionBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     KDevelop::Breakpoint *b = breakpoints()->addWatchpoint(QStringLiteral("i"));
     b->setCondition(QStringLiteral("i==2"));
     QTest::qWait(100);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // line 23: ++i; int j = i;
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBreakOnReadBreakpoint()
 {
     /*
     test disabled because of gdb bug: http://sourceware.org/bugzilla/show_bug.cgi?id=10136
 
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     KDevelop::Breakpoint *b = breakpoints()->addReadWatchpoint("foo::i");
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 23);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
     */
 }
 
 void GdbTest::testBreakOnReadBreakpoint2()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     breakpoints()->addReadWatchpoint(QStringLiteral("i"));
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // ++i
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // int j = i
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     if(session->line() == 22) { // some GDB versions break 3 times on this line
         session->run();
         WAIT_FOR_STATE(session, DebugSession::PausedState);
     }
     QCOMPARE(session->line(), 24);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBreakOnAccessBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     breakpoints()->addAccessWatchpoint(QStringLiteral("i"));
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // line 23: ++i (read)
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // line 23: ++i (write)
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 22); // line 23: int j = i (read)
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testInsertBreakpointWhileRunning()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeslow")));
     QString fileName = findSourceFile(QStringLiteral("debugeeslow.cpp"));
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE(session, DebugSession::ActiveState);
     QTest::qWait(2000);
     qDebug() << "adding breakpoint";
     KDevelop::Breakpoint *b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 30); // ++i;
     QTest::qWait(500);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(500);
     QCOMPARE(session->line(), 30); // ++i;
     b->setDeleted();
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testInsertBreakpointWhileRunningMultiple()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeslow")));
     QString fileName = findSourceFile(QStringLiteral("debugeeslow.cpp"));
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE(session, DebugSession::ActiveState);
     QTest::qWait(2000);
     qDebug() << "adding breakpoint";
     KDevelop::Breakpoint *b1 = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 29); // static int i=0;
     KDevelop::Breakpoint *b2 = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 30); // ++i;
     QTest::qWait(500);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(500);
     QCOMPARE(session->line(), 29); // static int i=0;
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(500);
     QCOMPARE(session->line(), 30); // ++i;
     b1->setDeleted();
     b2->setDeleted();
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testInsertBreakpointFunctionName()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QStringLiteral("main"));
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 27);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testManualBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QStringLiteral("main"));
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 27);
 
     breakpoints()->removeRows(0, 1);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(breakpoints()->rowCount(), 0);
 
     session->addCommand(MI::NonMI, QStringLiteral("break debugee.cpp:23"));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(breakpoints()->rowCount(), 1);
 
     KDevelop::Breakpoint* b = breakpoints()->breakpoint(0);
     QCOMPARE(b->line(), 22);
 
     session->addCommand(MI::NonMI, QStringLiteral("disable 2"));
     session->addCommand(MI::NonMI, QStringLiteral("condition 2 i == 1"));
     session->addCommand(MI::NonMI, QStringLiteral("ignore 2 1"));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(b->enabled(), false);
     QCOMPARE(b->condition(), QString("i == 1"));
     QCOMPARE(b->ignoreHits(), 1);
 
     session->addCommand(MI::NonMI, QStringLiteral("delete 2"));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(breakpoints()->rowCount(), 0);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testShowStepInSource()
 {
     TestDebugSession *session = new TestDebugSession;
 
     QSignalSpy showStepInSourceSpy(session, &TestDebugSession::showStepInSource);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 29);
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     {
         QCOMPARE(showStepInSourceSpy.count(), 3);
         QList<QVariant> arguments = showStepInSourceSpy.takeFirst();
         QCOMPARE(arguments.first().toUrl(), QUrl::fromLocalFile(debugeeFileName));
         QCOMPARE(arguments.at(1).toInt(), 29);
 
         arguments = showStepInSourceSpy.takeFirst();
         QCOMPARE(arguments.first().toUrl(), QUrl::fromLocalFile(debugeeFileName));
         QCOMPARE(arguments.at(1).toInt(), 22);
 
         arguments = showStepInSourceSpy.takeFirst();
         QCOMPARE(arguments.first().toUrl(), QUrl::fromLocalFile(debugeeFileName));
         QCOMPARE(arguments.at(1).toInt(), 23);
     }
 }
 
 void GdbTest::testStack()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 21);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QModelIndex tIdx = stackModel->index(0,0);
     QCOMPARE(stackModel->rowCount(QModelIndex()), 1);
     QCOMPARE(stackModel->columnCount(QModelIndex()), 3);
     COMPARE_DATA(tIdx, "#1 at foo");
 
     QCOMPARE(stackModel->rowCount(tIdx), 2);
     QCOMPARE(stackModel->columnCount(tIdx), 3);
     COMPARE_DATA(stackModel->index(0, 0, tIdx), "0");
     COMPARE_DATA(stackModel->index(0, 1, tIdx), "foo");
     COMPARE_DATA(stackModel->index(0, 2, tIdx), debugeeFileName+":23");
     COMPARE_DATA(stackModel->index(1, 0, tIdx), "1");
     COMPARE_DATA(stackModel->index(1, 1, tIdx), "main");
     COMPARE_DATA(stackModel->index(1, 2, tIdx), debugeeFileName+":29");
 
 
     session->stepOut();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     COMPARE_DATA(tIdx, "#1 at main");
     QCOMPARE(stackModel->rowCount(tIdx), 1);
     COMPARE_DATA(stackModel->index(0, 0, tIdx), "0");
     COMPARE_DATA(stackModel->index(0, 1, tIdx), "main");
     COMPARE_DATA(stackModel->index(0, 2, tIdx), debugeeFileName+":30");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testStackFetchMore()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeerecursion")));
     QString fileName = findSourceFile(QStringLiteral("debugeerecursion.cpp"));
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 25);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->frameStackModel()->fetchFramesCalled, 1);
 
     QModelIndex tIdx = stackModel->index(0,0);
     QCOMPARE(stackModel->rowCount(QModelIndex()), 1);
     QCOMPARE(stackModel->columnCount(QModelIndex()), 3);
     COMPARE_DATA(tIdx, "#1 at foo");
 
     QCOMPARE(stackModel->rowCount(tIdx), 21);
     COMPARE_DATA(stackModel->index(0, 0, tIdx), "0");
     COMPARE_DATA(stackModel->index(0, 1, tIdx), "foo");
     COMPARE_DATA(stackModel->index(0, 2, tIdx), fileName+":26");
     COMPARE_DATA(stackModel->index(1, 0, tIdx), "1");
     COMPARE_DATA(stackModel->index(1, 1, tIdx), "foo");
     COMPARE_DATA(stackModel->index(1, 2, tIdx), fileName+":24");
     COMPARE_DATA(stackModel->index(2, 0, tIdx), "2");
     COMPARE_DATA(stackModel->index(2, 1, tIdx), "foo");
     COMPARE_DATA(stackModel->index(2, 2, tIdx), fileName+":24");
     COMPARE_DATA(stackModel->index(19, 0, tIdx), "19");
     COMPARE_DATA(stackModel->index(20, 0, tIdx), "20");
 
     stackModel->fetchMoreFrames();
     QTest::qWait(200);
     QCOMPARE(stackModel->fetchFramesCalled, 2);
     QCOMPARE(stackModel->rowCount(tIdx), 41);
     COMPARE_DATA(stackModel->index(20, 0, tIdx), "20");
     COMPARE_DATA(stackModel->index(21, 0, tIdx), "21");
     COMPARE_DATA(stackModel->index(22, 0, tIdx), "22");
     COMPARE_DATA(stackModel->index(39, 0, tIdx), "39");
     COMPARE_DATA(stackModel->index(40, 0, tIdx), "40");
 
     stackModel->fetchMoreFrames();
     QTest::qWait(200);
     QCOMPARE(stackModel->fetchFramesCalled, 3);
     QCOMPARE(stackModel->rowCount(tIdx), 121);
     COMPARE_DATA(stackModel->index(40, 0, tIdx), "40");
     COMPARE_DATA(stackModel->index(41, 0, tIdx), "41");
     COMPARE_DATA(stackModel->index(42, 0, tIdx), "42");
     COMPARE_DATA(stackModel->index(119, 0, tIdx), "119");
     COMPARE_DATA(stackModel->index(120, 0, tIdx), "120");
 
     stackModel->fetchMoreFrames();
     QTest::qWait(200);
     QCOMPARE(stackModel->fetchFramesCalled, 4);
     QCOMPARE(stackModel->rowCount(tIdx), 299);
     COMPARE_DATA(stackModel->index(120, 0, tIdx), "120");
     COMPARE_DATA(stackModel->index(121, 0, tIdx), "121");
     COMPARE_DATA(stackModel->index(122, 0, tIdx), "122");
     COMPARE_DATA(stackModel->index(298, 0, tIdx), "298");
     COMPARE_DATA(stackModel->index(298, 1, tIdx), "main");
     COMPARE_DATA(stackModel->index(298, 2, tIdx), fileName+":30");
 
     stackModel->fetchMoreFrames(); //nothing to fetch, we are at the end
     QTest::qWait(200);
     QCOMPARE(stackModel->fetchFramesCalled, 4);
     QCOMPARE(stackModel->rowCount(tIdx), 299);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testStackDeactivateAndActive()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 21);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QModelIndex tIdx = stackModel->index(0,0);
 
     session->stepOut();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(200);
     COMPARE_DATA(tIdx, "#1 at main");
     QCOMPARE(stackModel->rowCount(tIdx), 1);
     COMPARE_DATA(stackModel->index(0, 0, tIdx), "0");
     COMPARE_DATA(stackModel->index(0, 1, tIdx), "main");
     COMPARE_DATA(stackModel->index(0, 2, tIdx), debugeeFileName+":30");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testStackSwitchThread()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeethreads")));
     QString fileName = findSourceFile(QStringLiteral("debugeethreads.cpp"));
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 40); // t3.start();
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QVERIFY(stackModel->rowCount() > 2);
 
     QModelIndex tIdx = stackModel->index(0,0);
     COMPARE_DATA(tIdx, "#1 at main");
     QCOMPARE(stackModel->rowCount(tIdx), 1);
     COMPARE_DATA(stackModel->index(0, 0, tIdx), "0");
     COMPARE_DATA(stackModel->index(0, 1, tIdx), "main");
     COMPARE_DATA(stackModel->index(0, 2, tIdx), fileName+":41"); // QThread::usleep(500000);
 
     tIdx = stackModel->index(1,0);
     QVERIFY(stackModel->data(tIdx).toString().startsWith("#2 at "));
     stackModel->setCurrentThread(2);
     QTest::qWait(200);
     int rows = stackModel->rowCount(tIdx);
     QVERIFY(rows > 3);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testAttach()
 {
     SKIP_IF_ATTACH_FORBIDDEN();
 #ifdef Q_OS_FREEBSD
     // Despite successful attach GDB MI spits out a error message "Can't allocate registers". This gets caught by KDevMI layer and gets interpreted as error.
     // Upstream PR: https://sourceware.org/bugzilla/show_bug.cgi?id=23464
     QSKIP("GDB on FreeBSD produces an unexpected error message, on which KDevelop chokes");
 #endif
 
     QString fileName = findSourceFile(QStringLiteral("debugeeslow.cpp"));
 
     KProcess debugeeProcess;
     debugeeProcess << QStringLiteral("nice") << findExecutable(QStringLiteral("debuggee_debugeeslow")).toLocalFile();
     debugeeProcess.start();
     QVERIFY(debugeeProcess.waitForStarted());
     QTest::qWait(100);
 
     TestDebugSession *session = new TestDebugSession;
     session->attachToProcess(debugeeProcess.pid());
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 39); // } after foo();
     QTest::qWait(100);
     session->run();
     QTest::qWait(2000);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     if (session->line() < 39 || session->line() < 40) {
         QCOMPARE(session->line(), 39);
     }
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testManualAttach()
 {
     SKIP_IF_ATTACH_FORBIDDEN();
 #ifdef Q_OS_FREEBSD
     // Despite successful attach GDB MI spits out a error message "Can't allocate registers". This gets caught by KDevMI layer and gets interpreted as error.
     // Upstream PR: https://sourceware.org/bugzilla/show_bug.cgi?id=23464
     QSKIP("GDB on FreeBSD produces an unexpected error message, on which KDevelop chokes");
 #endif
 
-    QString fileName = findSourceFile(QStringLiteral("debugeeslow.cpp"));
-
     KProcess debugeeProcess;
     debugeeProcess << QStringLiteral("nice") << findExecutable(QStringLiteral("debuggee_debugeeslow")).toLocalFile();
     debugeeProcess.start();
     QVERIFY(debugeeProcess.waitForStarted());
 
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
     cfg.config().writeEntry(Config::RemoteGdbRunEntry,
                             QUrl::fromLocalFile(findFile(GDB_SRC_DIR,
                                                          QStringLiteral("unittests/gdb_script_empty"))));
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     session->addCommand(MI::NonMI, QStringLiteral("attach %0").arg(debugeeProcess.pid()));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     session->run();
     QTest::qWait(2000); // give the slow inferior some extra time to run
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testCoreFile()
 {
     QFileInfo f(QStringLiteral("core"));
     f.setCaching(false); // don't cache information
     if (f.exists()) {
         QVERIFY(QFile::remove(f.canonicalFilePath()));
     }
 
     KProcess debugeeProcess;
     debugeeProcess.setOutputChannelMode(KProcess::MergedChannels);
     debugeeProcess << QStringLiteral("bash") << QStringLiteral("-c")
                    << "ulimit -c unlimited; "
                       + findExecutable(QStringLiteral("debuggee_crash")).toLocalFile();
     debugeeProcess.start();
     debugeeProcess.waitForFinished();
     qDebug() << "Debuggee output:\n" << debugeeProcess.readAll();
 
     bool coreFileFound = f.exists();
     if (!coreFileFound) {
         // Try to use coredumpctl
         auto coredumpctl = QStandardPaths::findExecutable(QStringLiteral("coredumpctl"));
         if (!coredumpctl.isEmpty()) {
             KProcess::execute(coredumpctl, {"-1", "-o", f.absoluteFilePath(), "dump", "debuggee_crash"}, 5000);
             // coredumpctl seems to create an empty file "core" even if no cores can be delivered
             // (like when run inside docker containers as on KDE CI or with kernel.core_pattern=|/dev/null)
             // so also check for size != 0
             coreFileFound = f.exists() && (f.size() > 0);
         }
     }
     if (!coreFileFound)
         QSKIP("no core dump found, check your system configuration (see /proc/sys/kernel/core_pattern).", SkipSingle);
 
     TestDebugSession *session = new TestDebugSession;
     session->examineCoreFile(findExecutable(QStringLiteral("debuggee_crash")),
                              QUrl::fromLocalFile(f.canonicalFilePath()));
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     WAIT_FOR_STATE(session, DebugSession::StoppedState);
 
     QModelIndex tIdx = stackModel->index(0,0);
     QCOMPARE(stackModel->rowCount(QModelIndex()), 1);
     QCOMPARE(stackModel->columnCount(QModelIndex()), 3);
     COMPARE_DATA(tIdx, "#1 at foo");
 
     session->stopDebugger();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 
 KDevelop::VariableCollection *variableCollection()
 {
     return KDevelop::ICore::self()->debugController()->variableCollection();
 }
 
 void GdbTest::testVariablesLocals()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 22);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(1000);
 
     QCOMPARE(variableCollection()->rowCount(), 2);
     QModelIndex i = variableCollection()->index(1, 0);
     COMPARE_DATA(i, "Locals");
     QCOMPARE(variableCollection()->rowCount(i), 2);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "i");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "0");
     COMPARE_DATA(variableCollection()->index(1, 0, i), "j");
     // COMPARE_DATA(variableCollection()->index(1, 1, i), "1"); // j is not initialized yet
     session->run();
     QTest::qWait(1000);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "i");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "1");
     COMPARE_DATA(variableCollection()->index(1, 0, i), "j");
     COMPARE_DATA(variableCollection()->index(1, 1, i), "1");
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesLocalsStruct()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(1000);
 
     QModelIndex i = variableCollection()->index(1, 0);
     QCOMPARE(variableCollection()->rowCount(i), 4);
 
     int structIndex = 0;
     for(int j=0; j<3; ++j) {
         if (variableCollection()->index(j, 0, i).data().toString() == QLatin1String("ts")) {
             structIndex = j;
         }
     }
 
     COMPARE_DATA(variableCollection()->index(structIndex, 0, i), "ts");
     COMPARE_DATA(variableCollection()->index(structIndex, 1, i), "{...}");
     QModelIndex ts = variableCollection()->index(structIndex, 0, i);
     COMPARE_DATA(variableCollection()->index(0, 0, ts), "...");
     variableCollection()->expanded(ts);
     QTest::qWait(100);
     COMPARE_DATA(variableCollection()->index(0, 0, ts), "a");
     COMPARE_DATA(variableCollection()->index(0, 1, ts), "0");
     COMPARE_DATA(variableCollection()->index(1, 0, ts), "b");
     COMPARE_DATA(variableCollection()->index(1, 1, ts), "1");
     COMPARE_DATA(variableCollection()->index(2, 0, ts), "c");
     COMPARE_DATA(variableCollection()->index(2, 1, ts), "2");
 
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(1000);
     COMPARE_DATA(variableCollection()->index(structIndex, 0, i), "ts");
     COMPARE_DATA(variableCollection()->index(structIndex, 1, i), "{...}");
     COMPARE_DATA(variableCollection()->index(0, 1, ts), "1");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesWatches()
 {
     TestDebugSession *session = new TestDebugSession;
     KDevelop::ICore::self()->debugController()->variableCollection()->variableWidgetShown();
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     variableCollection()->watches()->add(QStringLiteral("ts"));
     QTest::qWait(300);
 
     QModelIndex i = variableCollection()->index(0, 0);
     QCOMPARE(variableCollection()->rowCount(i), 1);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "ts");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "{...}");
     QModelIndex ts = variableCollection()->index(0, 0, i);
     COMPARE_DATA(variableCollection()->index(0, 0, ts), "...");
     variableCollection()->expanded(ts);
     QTest::qWait(100);
     COMPARE_DATA(variableCollection()->index(0, 0, ts), "a");
     COMPARE_DATA(variableCollection()->index(0, 1, ts), "0");
     COMPARE_DATA(variableCollection()->index(1, 0, ts), "b");
     COMPARE_DATA(variableCollection()->index(1, 1, ts), "1");
     COMPARE_DATA(variableCollection()->index(2, 0, ts), "c");
     COMPARE_DATA(variableCollection()->index(2, 1, ts), "2");
 
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(100);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "ts");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "{...}");
     COMPARE_DATA(variableCollection()->index(0, 1, ts), "1");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesWatchesQuotes()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateWatches);
 
     TestLaunchConfiguration cfg;
 
     // the unquoted string (the actual content):               t\"t
     // quoted string (what we would write as a c string):     "t\\\"t"
     // written in source file:                             R"("t\\\"t")"
     const QString testString(QStringLiteral("t\\\"t")); // the actual content
     const QString quotedTestString(QStringLiteral(R"("t\\\"t")"));
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     variableCollection()->watches()->add(quotedTestString); //just a constant string
     QTest::qWait(300);
 
     QModelIndex i = variableCollection()->index(0, 0);
     QCOMPARE(variableCollection()->rowCount(i), 1);
     COMPARE_DATA(variableCollection()->index(0, 0, i), quotedTestString);
     COMPARE_DATA(variableCollection()->index(0, 1, i), "[" + QString::number(testString.length() + 1) + "]");
 
     QModelIndex testStr = variableCollection()->index(0, 0, i);
     COMPARE_DATA(variableCollection()->index(0, 0, testStr), "...");
     variableCollection()->expanded(testStr);
     QTest::qWait(100);
     int len = testString.length();
     for (int ind = 0; ind < len; ind++)
     {
         COMPARE_DATA(variableCollection()->index(ind, 0, testStr), QString::number(ind));
         QChar c = testString.at(ind);
         QString value = QString::number(c.toLatin1()) + " '";
         if (c == '\\')
             value += QLatin1String("\\\\");
         else if (c == '\'')
             value += QLatin1String("\\'");
         else
             value += c;
         value += QLatin1String("'");
         COMPARE_DATA(variableCollection()->index(ind, 1, testStr), value);
     }
     COMPARE_DATA(variableCollection()->index(len, 0, testStr), QString::number(len));
     COMPARE_DATA(variableCollection()->index(len, 1, testStr), "0 '\\000'");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesWatchesTwoSessions()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateWatches);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     variableCollection()->watches()->add(QStringLiteral("ts"));
     QTest::qWait(300);
 
     QModelIndex ts = variableCollection()->index(0, 0, variableCollection()->index(0, 0));
     variableCollection()->expanded(ts);
     QTest::qWait(100);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     //check if variable is marked as out-of-scope
     QCOMPARE(variableCollection()->watches()->childCount(), 1);
     KDevelop::Variable* v = dynamic_cast<KDevelop::Variable*>(variableCollection()->watches()->child(0));
     QVERIFY(v);
     QVERIFY(!v->inScope());
     QCOMPARE(v->childCount(), 3);
     v = dynamic_cast<KDevelop::Variable*>(v->child(0));
     QVERIFY(!v->inScope());
 
     //start a second debug session
     session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateWatches);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(300);
 
     QCOMPARE(variableCollection()->watches()->childCount(), 1);
     ts = variableCollection()->index(0, 0, variableCollection()->index(0, 0));
     v = dynamic_cast<KDevelop::Variable*>(variableCollection()->watches()->child(0));
     QVERIFY(v);
     QVERIFY(v->inScope());
     QCOMPARE(v->childCount(), 3);
 
     v = dynamic_cast<KDevelop::Variable*>(v->child(0));
     QVERIFY(v->inScope());
     QCOMPARE(v->data(1, Qt::DisplayRole).toString(), QString::number(0));
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     //check if variable is marked as out-of-scope
     v = dynamic_cast<KDevelop::Variable*>(variableCollection()->watches()->child(0));
     QVERIFY(!v->inScope());
     QVERIFY(!dynamic_cast<KDevelop::Variable*>(v->child(0))->inScope());
 }
 
 void GdbTest::testVariablesStopDebugger()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     session->stopDebugger();
     QTest::qWait(300);
 }
 
 
 void GdbTest::testVariablesStartSecondSession()
 {
     QPointer<TestDebugSession> session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QPointer<TestDebugSession> session2 = new TestDebugSession;
     session2->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 38);
     QVERIFY(session2->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session2, DebugSession::PausedState);
 
     session2->run();
     WAIT_FOR_STATE(session2, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesSwitchFrame()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(500);
 
     QModelIndex i = variableCollection()->index(1, 0);
     COMPARE_DATA(i, "Locals");
     QCOMPARE(variableCollection()->rowCount(i), 2);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "i");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "1");
     COMPARE_DATA(variableCollection()->index(1, 0, i), "j");
 
     stackModel->setCurrentFrame(1);
     QTest::qWait(200);
 
     i = variableCollection()->index(1, 0);
     QCOMPARE(variableCollection()->rowCount(i), 4);
     COMPARE_DATA(variableCollection()->index(2, 0, i), "argc");
     COMPARE_DATA(variableCollection()->index(2, 1, i), "1");
     COMPARE_DATA(variableCollection()->index(3, 0, i), "argv");
 
     breakpoints()->removeRow(0);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testVariablesQuicklySwitchFrame()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg;
 
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(500);
 
     QModelIndex i = variableCollection()->index(1, 0);
     COMPARE_DATA(i, "Locals");
     QCOMPARE(variableCollection()->rowCount(i), 2);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "i");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "1");
     COMPARE_DATA(variableCollection()->index(1, 0, i), "j");
 
     stackModel->setCurrentFrame(1);
     QTest::qWait(300);
     stackModel->setCurrentFrame(0);
     QTest::qWait(1);
     stackModel->setCurrentFrame(1);
     QTest::qWait(1);
     stackModel->setCurrentFrame(0);
     QTest::qWait(1);
     stackModel->setCurrentFrame(1);
     QTest::qWait(500);
 
     i = variableCollection()->index(1, 0);
     QCOMPARE(variableCollection()->rowCount(i), 4);
     QStringList locs;
     for (int j = 0; j < variableCollection()->rowCount(i); ++j) {
         locs << variableCollection()->index(j, 0, i).data().toString();
     }
     QVERIFY(locs.contains("argc"));
     QVERIFY(locs.contains("argv"));
     QVERIFY(locs.contains("x"));
 
     breakpoints()->removeRow(0);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 
 void GdbTest::testSegfaultDebugee()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_crash")));
     QString fileName = findSourceFile(QStringLiteral("debugeecrash.cpp"));
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 23);
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 23);
     session->run();
 
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 24);
 
     session->stopDebugger();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testSwitchFrameGdbConsole()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     TestFrameStackModel *stackModel = session->frameStackModel();
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 24);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(stackModel->currentFrame(), 0);
     stackModel->setCurrentFrame(1);
     QCOMPARE(stackModel->currentFrame(), 1);
     QTest::qWait(500);
     QCOMPARE(stackModel->currentFrame(), 1);
 
     session->addUserCommand(QStringLiteral("print x"));
     QTest::qWait(500);
     //currentFrame must not reset to 0; Bug 222882
     QCOMPARE(stackModel->currentFrame(), 1);
 
 }
 
 //Bug 201771
 void GdbTest::testInsertAndRemoveBreakpointWhileRunning()
 {
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeslow")));
     QString fileName = findSourceFile(QStringLiteral("debugeeslow.cpp"));
 
     session->startDebugging(&cfg, m_iface);
 
     WAIT_FOR_STATE(session, DebugSession::ActiveState);
     QTest::qWait(2000);
     qDebug() << "adding breakpoint";
     KDevelop::Breakpoint *b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 30); // ++i;
     b->setDeleted();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 //Bug 274390
 void GdbTest::testCommandOrderFastStepping()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeqt")));
 
     breakpoints()->addCodeBreakpoint(QStringLiteral("main"));
     QVERIFY(session->startDebugging(&cfg, m_iface));
     for(int i=0; i<20; i++) {
         session->stepInto();
     }
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testPickupManuallyInsertedBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QStringLiteral("main"));
     QVERIFY(session->startDebugging(&cfg, m_iface));
     session->addCommand(MI::NonMI, QStringLiteral("break debugee.cpp:32"));
     session->stepInto();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(1000); //wait for breakpoints update
     QCOMPARE(breakpoints()->breakpoints().count(), 2);
     QCOMPARE(breakpoints()->rowCount(), 2);
     KDevelop::Breakpoint *b = breakpoints()->breakpoint(1);
     QVERIFY(b);
     QCOMPARE(b->line(), 31); //we start with 0, gdb with 1
     QCOMPARE(b->url().fileName(), QString("debugee.cpp"));
 }
 
 //Bug 270970
 void GdbTest::testPickupManuallyInsertedBreakpointOnlyOnce()
 {
     TestDebugSession *session = new TestDebugSession;
 
     //inject here, so it behaves similar like a command from .gdbinit
     QTemporaryFile configScript;
     configScript.open();
     configScript.write(QStringLiteral("file %0\n").arg(findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile()).toLocal8Bit());
     configScript.write("break debugee.cpp:32\n");
     configScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbConfigEntry, QUrl::fromLocalFile(configScript.fileName()));
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(QStringLiteral("debugee.cpp")), 31);
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(breakpoints()->breakpoints().count(), 1);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testPickupCatchThrowOnlyOnce()
 {
     QTemporaryFile configScript;
     configScript.open();
     configScript.write("catch throw\n");
     configScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbConfigEntry, QUrl::fromLocalFile(configScript.fileName()));
 
 
     for (int i = 0; i < 2; ++i) {
         TestDebugSession* session = new TestDebugSession;
         QVERIFY(session->startDebugging(&cfg, m_iface));
         WAIT_FOR_STATE(session, DebugSession::EndedState);
     }
 
     QCOMPARE(breakpoints()->rowCount(), 1); //one from kdevelop, one from runScript
 }
 
 void GdbTest::testRunGdbScript()
 {
     TestDebugSession *session = new TestDebugSession;
 
     QTemporaryFile runScript;
     runScript.open();
 
     runScript.write("file " + KShell::quoteArg(findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile()).toUtf8() + "\n");
     runScript.write("break main\n");
     runScript.write("run\n");
     runScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbRunEntry, QUrl::fromLocalFile(runScript.fileName()));
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 27);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testRemoteDebug()
 {
     const QString gdbserverExecutable = QStandardPaths::findExecutable(QStringLiteral("gdbserver"));
     if (gdbserverExecutable.isEmpty()) {
         QSKIP("Skipping, gdbserver not available", SkipSingle);
     }
 
     TestDebugSession *session = new TestDebugSession;
 
     QTemporaryFile shellScript(QDir::currentPath()+"/shellscript");
     shellScript.open();
     shellScript.write("gdbserver localhost:2345 " + findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toUtf8() + "\n");
     shellScript.close();
     shellScript.setPermissions(shellScript.permissions() | QFile::ExeUser);
     QFile::copy(shellScript.fileName(), shellScript.fileName()+"-copy"); //to avoid "Text file busy" on executing (why?)
 
     QTemporaryFile runScript(QDir::currentPath()+"/runscript");
     runScript.open();
     runScript.write("file " + findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toUtf8() + "\n");
     runScript.write("target remote localhost:2345\n");
     runScript.write("break debugee.cpp:30\n");
     runScript.write("continue\n");
     runScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbShellEntry, QUrl::fromLocalFile((shellScript.fileName()+"-copy")));
     grp.writeEntry(Config::RemoteGdbRunEntry, QUrl::fromLocalFile(runScript.fileName()));
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 29);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     QFile::remove(shellScript.fileName()+"-copy");
 }
 
 void GdbTest::testRemoteDebugInsertBreakpoint()
 {
     const QString gdbserverExecutable = QStandardPaths::findExecutable(QStringLiteral("gdbserver"));
     if (gdbserverExecutable.isEmpty()) {
         QSKIP("Skipping, gdbserver not available", SkipSingle);
     }
 
     TestDebugSession *session = new TestDebugSession;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 29);
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 35);
 
     QTemporaryFile shellScript(QDir::currentPath()+"/shellscript");
     shellScript.open();
     shellScript.write("gdbserver localhost:2345 " + findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toUtf8() + "\n");
     shellScript.close();
     shellScript.setPermissions(shellScript.permissions() | QFile::ExeUser);
     QFile::copy(shellScript.fileName(), shellScript.fileName()+"-copy"); //to avoid "Text file busy" on executing (why?)
 
     QTemporaryFile runScript(QDir::currentPath()+"/runscript");
     runScript.open();
     runScript.write("file " + findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toUtf8() + '\n');
     runScript.write("target remote localhost:2345\n");
     runScript.write("break debugee.cpp:30\n");
     runScript.write("continue\n");
     runScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbShellEntry, QUrl::fromLocalFile(shellScript.fileName()+"-copy"));
     grp.writeEntry(Config::RemoteGdbRunEntry, QUrl::fromLocalFile(runScript.fileName()));
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 29);
 
     QCOMPARE(breakpoints()->breakpoints().count(), 2); //one from kdevelop, one from runScript
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 35);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     QFile::remove(shellScript.fileName()+"-copy");
 }
 
 
 void GdbTest::testRemoteDebugInsertBreakpointPickupOnlyOnce()
 {
     const QString gdbserverExecutable = QStandardPaths::findExecutable(QStringLiteral("gdbserver"));
     if (gdbserverExecutable.isEmpty()) {
         QSKIP("Skipping, gdbserver not available", SkipSingle);
     }
 
     TestDebugSession *session = new TestDebugSession;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 35);
 
     QTemporaryFile shellScript(QDir::currentPath()+"/shellscript");
     shellScript.open();
     shellScript.write("gdbserver localhost:2345 "+findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toLatin1()+"\n");
     shellScript.close();
     shellScript.setPermissions(shellScript.permissions() | QFile::ExeUser);
     QFile::copy(shellScript.fileName(), shellScript.fileName()+"-copy"); //to avoid "Text file busy" on executing (why?)
 
     QTemporaryFile runScript(QDir::currentPath()+"/runscript");
     runScript.open();
     runScript.write("file "+findExecutable(QStringLiteral("debuggee_debugee")).toLocalFile().toLatin1()+"\n");
     runScript.write("target remote localhost:2345\n");
     runScript.write("break debugee.cpp:30\n");
     runScript.write("continue\n");
     runScript.close();
 
     TestLaunchConfiguration cfg;
     KConfigGroup grp = cfg.config();
     grp.writeEntry(Config::RemoteGdbShellEntry, QUrl::fromLocalFile((shellScript.fileName()+"-copy")));
     grp.writeEntry(Config::RemoteGdbRunEntry, QUrl::fromLocalFile(runScript.fileName()));
 
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 29);
 
     QCOMPARE(breakpoints()->breakpoints().count(), 2); //one from kdevelop, one from runScript
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 35);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     //************************** second session
     session = new TestDebugSession;
     QVERIFY(session->startDebugging(&cfg, m_iface));
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 29);
 
     QCOMPARE(breakpoints()->breakpoints().count(), 2); //one from kdevelop, one from runScript
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QCOMPARE(session->line(), 35);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     QFile::remove(shellScript.fileName()+"-copy");
 }
 
 void GdbTest::testBreakpointWithSpaceInPath()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeespace")));
     KConfigGroup grp = cfg.config();
     QString fileName = findSourceFile(QStringLiteral("debugee space.cpp"));
 
     KDevelop::Breakpoint * b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 20);
     QCOMPARE(b->state(), KDevelop::Breakpoint::NotStartedState);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 20);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBreakpointDisabledOnStart()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28)
         ->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 29);
     KDevelop::Breakpoint* b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 31);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 29);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Checked);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 31);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testCatchpoint()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateLocals);
 
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeeexception")));
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(findSourceFile(QStringLiteral("debugeeexception.cpp"))), 29);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QTest::qWait(1000);
     TestFrameStackModel* fsModel = session->frameStackModel();
     QCOMPARE(fsModel->currentFrame(), 0);
     QCOMPARE(session->line(), 29);
 
     session->addCommand(MI::NonMI, QStringLiteral("catch throw"));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     session->run();
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QTest::qWait(1000);
 
     const QVector<KDevelop::FrameStackModel::FrameItem> frames = fsModel->frames(fsModel->currentThread());
     QVERIFY(frames.size() >= 2);
     // frame 0 is somewhere inside libstdc++
     QCOMPARE(frames[1].file, QUrl::fromLocalFile(findSourceFile("debugeeexception.cpp")));
     QCOMPARE(frames[1].line, 22);
 
     QCOMPARE(breakpoints()->rowCount(),2);
     QVERIFY(!breakpoints()->breakpoint(0)->location().isEmpty());
     QVERIFY(!breakpoints()->breakpoint(1)->location().isEmpty());
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testThreadAndFrameInfo()
 {
     // Check if --thread is added to user commands
 
     TestDebugSession *session = new TestDebugSession;
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeethreads")));
     QString fileName = findSourceFile(QStringLiteral("debugeethreads.cpp"));
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(fileName), 38);
     QVERIFY(session->startDebugging(&cfg, m_iface));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
 
     QSignalSpy outputSpy(session, &TestDebugSession::debuggerUserCommandOutput);
 
     session->addCommand(new MI::UserCommand(MI::ThreadInfo, QString()));
     session->addCommand(new MI::UserCommand(MI::StackListLocals, QStringLiteral("0")));
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState); // wait for command finish
 
     // outputs should be
     // 1. -thread-info
     // 2. ^done for thread-info
     // 3. -stack-list-locals
     // 4. ^done for -stack-list-locals
     QCOMPARE(outputSpy.count(), 4);
     QVERIFY(outputSpy.at(2).at(0).toString().contains(QLatin1String("--thread 1")));
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::parseBug304730()
 {
     MI::FileSymbol file;
     file.contents = QByteArray("^done,bkpt={"
         "number=\"1\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"<MULTIPLE>\",times=\"0\","
         "original-location=\"/media/portable/Projects/BDSInpainting/PatchMatch/PatchMatch.hpp:231\"},"
         "{number=\"1.1\",enabled=\"y\",addr=\"0x081d84aa\","
         "func=\"PatchMatch<itk::Image<itk::CovariantVector<unsigned char, 3u>, 2u> >"
         "::Propagation<ForwardPropagationNeighbors>(ForwardPropagationNeighbors)\","
         "file=\"/media/portable/Projects/BDSInpainting/Drivers/../PatchMatch/PatchMatch.hpp\","
         "fullname=\"/media/portable/Projects/BDSInpainting/PatchMatch/PatchMatch.hpp\",line=\"231\"},"
         "{number=\"1.2\",enabled=\"y\",addr=\"0x081d8ae2\","
         "func=\"PatchMatch<itk::Image<itk::CovariantVector<unsigned char, 3u>, 2u> >"
         "::Propagation<BackwardPropagationNeighbors>(BackwardPropagationNeighbors)\","
         "file=\"/media/portable/Projects/BDSInpainting/Drivers/../PatchMatch/PatchMatch.hpp\","
         "fullname=\"/media/portable/Projects/BDSInpainting/PatchMatch/PatchMatch.hpp\",line=\"231\"},"
         "{number=\"1.3\",enabled=\"y\",addr=\"0x081d911a\","
         "func=\"PatchMatch<itk::Image<itk::CovariantVector<unsigned char, 3u>, 2u> >"
         "::Propagation<AllowedPropagationNeighbors>(AllowedPropagationNeighbors)\","
         "file=\"/media/portable/Projects/BDSInpainting/Drivers/../PatchMatch/PatchMatch.hpp\","
         "fullname=\"/media/portable/Projects/BDSInpainting/PatchMatch/PatchMatch.hpp\",line=\"231\"}");
 
     MI::MIParser parser;
 
     std::unique_ptr<MI::Record> record(parser.parse(&file));
     QVERIFY(record.get() != nullptr);
 }
 
 void GdbTest::testMultipleLocationsBreakpoint()
 {
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration cfg(findExecutable(QStringLiteral("debuggee_debugeemultilocbreakpoint")));
 
     breakpoints()->addCodeBreakpoint(QStringLiteral("aPlusB"));
 
     //TODO check if the additional location breakpoint is added
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 19);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(session->line(), 23);
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testBug301287()
 {
     TestDebugSession *session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateWatches);
 
     TestLaunchConfiguration cfg;
 
     breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     variableCollection()->watches()->add(QStringLiteral("argc"));
     QTest::qWait(300);
 
     QModelIndex i = variableCollection()->index(0, 0);
     QCOMPARE(variableCollection()->rowCount(i), 1);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "argc");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "1");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 
     //start second debug session (same cfg)
     session = new TestDebugSession;
     session->variableController()->setAutoUpdate(KDevelop::IVariableController::UpdateWatches);
 
     session->startDebugging(&cfg, m_iface);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
 
     QTest::qWait(300);
 
     i = variableCollection()->index(0, 0);
     QCOMPARE(variableCollection()->rowCount(i), 1);
     COMPARE_DATA(variableCollection()->index(0, 0, i), "argc");
     COMPARE_DATA(variableCollection()->index(0, 1, i), "1");
 
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testMultipleBreakpoint()
 {
         TestDebugSession *session = new TestDebugSession;
 
         //there'll be about 3-4 breakpoints, but we treat it like one.
         TestLaunchConfiguration c(findExecutable(QStringLiteral("debuggee_debugeemultiplebreakpoint")));
         KDevelop::Breakpoint *b = breakpoints()->addCodeBreakpoint(QStringLiteral("debugeemultiplebreakpoint.cpp:52"));
         session->startDebugging(&c, m_iface);
         WAIT_FOR_STATE(session, DebugSession::PausedState);
         QCOMPARE(breakpoints()->breakpoints().count(), 1);
 
         b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
         session->run();
         WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testRegularExpressionBreakpoint()
 {
         TestDebugSession *session = new TestDebugSession;
 
         TestLaunchConfiguration c(findExecutable(QStringLiteral("debuggee_debugeemultilocbreakpoint")));
         breakpoints()->addCodeBreakpoint(QStringLiteral("main"));
         session->startDebugging(&c, m_iface);
         WAIT_FOR_STATE(session, DebugSession::PausedState);
         session->addCommand(MI::NonMI, QStringLiteral("rbreak .*aPl.*B"));
         QTest::qWait(100);
         session->run();
         WAIT_FOR_STATE(session, DebugSession::PausedState);
         QCOMPARE(breakpoints()->breakpoints().count(), 3);
 
         session->addCommand(MI::BreakDelete, QString());
         session->run();
         WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testChangeBreakpointWhileRunning() {
 
     TestDebugSession *session = new TestDebugSession;
 
     TestLaunchConfiguration c(findExecutable(QStringLiteral("debuggee_debugeeslow")));
     KDevelop::Breakpoint* b = breakpoints()->addCodeBreakpoint(QStringLiteral("debugeeslow.cpp:30"));
     session->startDebugging(&c, m_iface);
 
     WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
     QVERIFY(session->currentLine() >= 29 && session->currentLine() <= 31 );
     session->run();
     WAIT_FOR_STATE(session, DebugSession::ActiveState);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
     //to make one loop
     QTest::qWait(2000);
     WAIT_FOR_STATE(session, DebugSession::ActiveState);
 
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Checked);
     QTest::qWait(100);
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     b->setData(KDevelop::Breakpoint::EnableColumn, Qt::Unchecked);
     session->run();
     QTest::qWait(100);
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 void GdbTest::testDebugInExternalTerminal()
 {
     TestLaunchConfiguration cfg;
 
     foreach (const QString & console, QStringList() << "konsole" << "xterm" << "xfce4-terminal" << "gnome-terminal") {
 
         TestDebugSession* session = nullptr;
         if (QStandardPaths::findExecutable(console).isEmpty()) {
             continue;
         }
 
         session = new TestDebugSession();
 
         cfg.config().writeEntry("External Terminal"/*ExecutePlugin::terminalEntry*/, console);
         cfg.config().writeEntry("Use External Terminal"/*ExecutePlugin::useTerminalEntry*/, true);
 
         KDevelop::Breakpoint* b = breakpoints()->addCodeBreakpoint(QUrl::fromLocalFile(debugeeFileName), 28);
 
         session->startDebugging(&cfg, m_iface);
         WAIT_FOR_STATE_AND_IDLE(session, DebugSession::PausedState);
         QCOMPARE(b->state(), KDevelop::Breakpoint::CleanState);
         session->stepInto();
         WAIT_FOR_STATE(session, DebugSession::PausedState);
         session->run();
         WAIT_FOR_STATE(session, DebugSession::EndedState);
     }
 }
 
 // see: https://bugs.kde.org/show_bug.cgi?id=339231
 void GdbTest::testPathWithSpace()
 {
     TestDebugSession* session = new TestDebugSession;
 
     auto debugee = findExecutable(QStringLiteral("path with space/debuggee_spacedebugee"));
     TestLaunchConfiguration c(debugee, KIO::upUrl(debugee));
     KDevelop::Breakpoint* b = breakpoints()->addCodeBreakpoint(QStringLiteral("spacedebugee.cpp:30"));
     QCOMPARE(b->state(), KDevelop::Breakpoint::NotStartedState);
     session->startDebugging(&c, m_iface);
 
     WAIT_FOR_STATE(session, DebugSession::PausedState);
     QCOMPARE(b->state(), KDevelop::Breakpoint::CleanState);
     session->run();
     WAIT_FOR_STATE(session, DebugSession::EndedState);
 }
 
 bool GdbTest::waitForState(DebugSession *session, DebugSession::DebuggerState state,
                             const char *file, int line, bool waitForIdle)
 {
     QPointer<MIDebugSession> s(session); //session can get deleted in DebugController
     QTime stopWatch;
     stopWatch.start();
 
     // legacy behavior for tests that implicitly may require waiting for idle,
     // but which were written before waitForIdle was added
     waitForIdle = waitForIdle || state != MIDebugSession::EndedState;
 
     while (s && (s->state() != state || (waitForIdle && s->debuggerStateIsOn(s_dbgBusy)))) {
         if (stopWatch.elapsed() > 5000) {
             qWarning() << "current state" << s->state() << "waiting for" << state;
             QTest::qFail(qPrintable(QString("Timeout before reaching state %0").arg(state)),
                          file, line);
             return false;
         }
         QTest::qWait(20);
     }
 
     // NOTE: don't wait anymore after leaving the loop. Waiting re-enters event loop and
     // may change session state.
 
     if (!s && state != MIDebugSession::EndedState) {
         QTest::qFail(qPrintable(QString("Session ended before reaching state %0").arg(state)),
                      file, line);
         return false;
     }
 
     qDebug() << "Reached state " << state << " in " << file << ':' << line;
     return true;
 }
 } // end of namespace GDB
 } // end of namespace KDevMI
 
 QTEST_MAIN(KDevMI::GDB::GdbTest)
 
 
 #include "test_gdb.moc"
 #include "moc_test_gdb.cpp"
 
diff --git a/plugins/ghprovider/ghaccount.cpp b/plugins/ghprovider/ghaccount.cpp
index 6535f39758..0c20cc65a5 100644
--- a/plugins/ghprovider/ghaccount.cpp
+++ b/plugins/ghprovider/ghaccount.cpp
@@ -1,89 +1,88 @@
 /* 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 <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(QLatin1Char(','));
     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(QLatin1Char(','));
 }
 
 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/plugins/ninjabuilder/ninjajob.cpp b/plugins/ninjabuilder/ninjajob.cpp
index 2bc10fe738..9514224fe8 100644
--- a/plugins/ninjabuilder/ninjajob.cpp
+++ b/plugins/ninjabuilder/ninjajob.cpp
@@ -1,239 +1,238 @@
 /* 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 "ninjajob.h"
 
 #include "ninjabuilder.h"
 
 #include <outputview/outputfilteringstrategies.h>
 #include <project/interfaces/ibuildsystemmanager.h>
 #include <project/projectmodel.h>
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <QFile>
 #include <QRegularExpression>
 #include <QStandardPaths>
 #include <QUrl>
 
 using namespace KDevelop;
 
 class NinjaJobCompilerFilterStrategy
     : public CompilerFilterStrategy
 {
 public:
     using CompilerFilterStrategy::CompilerFilterStrategy;
 
     IFilterStrategy::Progress progressInLine(const QString& line) override;
 };
 
 IFilterStrategy::Progress NinjaJobCompilerFilterStrategy::progressInLine(const QString& line)
 {
     // example string: [87/88] Building CXX object projectbuilders/ninjabuilder/CMakeFiles/kdevninja.dir/ninjajob.cpp.o
     static const QRegularExpression re(QStringLiteral("^\\[([0-9]+)\\/([0-9]+)\\] (.*)"));
 
     QRegularExpressionMatch match = re.match(line);
     if (match.hasMatch()) {
         const int current = match.capturedRef(1).toInt();
         const int total = match.capturedRef(2).toInt();
         if (current && total) {
             // this is output from ninja
             const QString action = match.captured(3);
             const int percent = qRound(( float )current / total * 100);
             return {
                        action, percent
             };
         }
     }
 
     return {};
 }
 
 NinjaJob::NinjaJob(KDevelop::ProjectBaseItem* item, CommandType commandType,
                    const QStringList& arguments, const QByteArray& signal, NinjaBuilder* parent)
     : OutputExecuteJob(parent)
     , m_isInstalling(false)
     , m_idx(item->index())
     , m_commandType(commandType)
     , m_signal(signal)
     , m_plugin(parent)
 {
     auto bsm = item->project()->buildSystemManager();
     auto buildDir = bsm->buildDirectory(item);
 
     setToolTitle(i18n("Ninja"));
     setCapabilities(Killable);
     setStandardToolView(KDevelop::IOutputView::BuildView);
     setBehaviours(KDevelop::IOutputView::AllowUserClose | KDevelop::IOutputView::AutoScroll);
     setFilteringStrategy(new NinjaJobCompilerFilterStrategy(buildDir.toUrl()));
     setProperties(NeedWorkingDirectory | PortableMessages | DisplayStderr | IsBuilderHint | PostProcessOutput);
 
     // hardcode the ninja output format so we can parse it reliably
     addEnvironmentOverride(QStringLiteral("NINJA_STATUS"), QStringLiteral("[%s/%t] "));
 
     *this << ninjaExecutable();
     *this << arguments;
 
     QStringList targets;
     for (const QString& arg : arguments) {
         if (!arg.startsWith('-')) {
             targets << arg;
         }
     }
 
     QString title;
     if (!targets.isEmpty()) {
         title = i18n("Ninja (%1): %2", item->text(), targets.join(QLatin1Char(' ')));
     } else {
         title = i18n("Ninja (%1)", item->text());
     }
     setJobName(title);
 
     connect(this, &NinjaJob::finished, this, &NinjaJob::emitProjectBuilderSignal);
 }
 
 NinjaJob::~NinjaJob()
 {
     // prevent crash when emitting KJob::finished from ~KJob
     // (=> at this point NinjaJob is already destructed...)
     disconnect(this, &NinjaJob::finished, this, &NinjaJob::emitProjectBuilderSignal);
 }
 
 void NinjaJob::setIsInstalling(bool isInstalling)
 {
     m_isInstalling = isInstalling;
 }
 
 QString NinjaJob::ninjaExecutable()
 {
     QString path = QStandardPaths::findExecutable(QStringLiteral("ninja-build"));
     if (path.isEmpty()) {
         path = QStandardPaths::findExecutable(QStringLiteral("ninja"));
     }
     return path;
 }
 
 QUrl NinjaJob::workingDirectory() const
 {
     KDevelop::ProjectBaseItem* it = item();
     if (!it) {
         return QUrl();
     }
     KDevelop::IBuildSystemManager* bsm = it->project()->buildSystemManager();
     KDevelop::Path workingDir = bsm->buildDirectory(it);
     while (!QFile::exists(workingDir.toLocalFile() + "build.ninja")) {
         KDevelop::Path upWorkingDir = workingDir.parent();
         if (!upWorkingDir.isValid() || upWorkingDir == workingDir) {
             return bsm->buildDirectory(it->project()->projectItem()).toUrl();
         }
         workingDir = upWorkingDir;
     }
     return workingDir.toUrl();
 }
 
 QStringList NinjaJob::privilegedExecutionCommand() const
 {
     KDevelop::ProjectBaseItem* it = item();
     if (!it) {
         return QStringList();
     }
     KSharedConfigPtr configPtr = it->project()->projectConfiguration();
     KConfigGroup builderGroup(configPtr, "NinjaBuilder");
 
     bool runAsRoot = builderGroup.readEntry("Install As Root", false);
     if (runAsRoot && m_isInstalling) {
         int suCommand = builderGroup.readEntry("Su Command", 0);
         QStringList arguments;
-        QString suCommandName;
         switch (suCommand) {
         case 1:
             return QStringList{QStringLiteral("kdesudo"), QStringLiteral("-t")};
 
         case 2:
             return QStringList{QStringLiteral("sudo")};
 
         default:
             return QStringList{QStringLiteral("kdesu"), QStringLiteral("-t")};
         }
     }
     return QStringList();
 }
 
 void NinjaJob::emitProjectBuilderSignal(KJob* job)
 {
     if (!m_plugin) {
         return;
     }
 
     KDevelop::ProjectBaseItem* it = item();
     if (!it) {
         return;
     }
 
     if (job->error() == 0) {
         Q_ASSERT(!m_signal.isEmpty());
         QMetaObject::invokeMethod(m_plugin, m_signal, Q_ARG(KDevelop::ProjectBaseItem*, it));
     } else {
         QMetaObject::invokeMethod(m_plugin, "failed", Q_ARG(KDevelop::ProjectBaseItem*, it));
     }
 }
 
 void NinjaJob::postProcessStderr(const QStringList& lines)
 {
     appendLines(lines);
 }
 
 void NinjaJob::postProcessStdout(const QStringList& lines)
 {
     appendLines(lines);
 }
 
 void NinjaJob::appendLines(const QStringList& lines)
 {
     if (lines.isEmpty()) {
         return;
     }
 
     QStringList ret(lines);
     bool prev = false;
     for (QStringList::iterator it = ret.end(); it != ret.begin(); ) {
         --it;
         bool curr = it->startsWith('[');
         if ((prev && curr) || it->endsWith(QLatin1String("] "))) {
             it = ret.erase(it);
         }
         prev = curr;
     }
 
     model()->appendLines(ret);
 }
 
 KDevelop::ProjectBaseItem* NinjaJob::item() const
 {
     return KDevelop::ICore::self()->projectController()->projectModel()->itemFromIndex(m_idx);
 }
 
 NinjaJob::CommandType NinjaJob::commandType() const
 {
     return m_commandType;
 }
diff --git a/plugins/qmakemanager/parser/tests/scopetest.cpp b/plugins/qmakemanager/parser/tests/scopetest.cpp
index 84e5b863d1..7c799d1d09 100644
--- a/plugins/qmakemanager/parser/tests/scopetest.cpp
+++ b/plugins/qmakemanager/parser/tests/scopetest.cpp
@@ -1,137 +1,136 @@
 /* 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.
  */
 
 #include "scopetest.h"
 #include "ast.h"
 #include "qmakedriver.h"
 #include "testhelpers.h"
 
 QTEST_MAIN(ScopeTest)
 
 ScopeTest::ScopeTest(QObject* parent)
     : QObject(parent)
 {
 }
 
 ScopeTest::~ScopeTest()
 {
 }
 
 void ScopeTest::init()
 {
     ast = new QMake::ProjectAST();
     QVERIFY(ast != nullptr);
 }
 
 void ScopeTest::cleanup()
 {
     delete ast;
     ast = nullptr;
     QVERIFY(ast == nullptr);
 }
 
 BEGINTESTFUNCIMPL(ScopeTest, basicScope, 1)
     QMake::SimpleScopeAST* scope = dynamic_cast<QMake::SimpleScopeAST*>(ast->statements.first());
     TESTSCOPENAME(scope, "foobar")
     QList<QMake::StatementAST*> testlist;
     auto tst = new QMake::AssignmentAST(scope->body);
     auto val = new QMake::ValueAST(tst);
     val->value = QStringLiteral("VARIABLE");
     tst->identifier = val;
     val = new QMake::ValueAST(tst);
     val->value = QStringLiteral("=");
     tst->op = val;
     val = new QMake::ValueAST(tst);
     val->value = QStringLiteral("FOO");
     tst->values.append(val);
     testlist.append(tst);
     TESTSCOPEBODY(scope, testlist, 1)
 ENDTESTFUNCIMPL
 
 DATAFUNCIMPL(ScopeTest, basicScope, "foobar : VARIABLE = FOO\n")
 
 BEGINTESTFUNCIMPL(ScopeTest, basicScopeBrace, 1)
     QMake::SimpleScopeAST* scope = dynamic_cast<QMake::SimpleScopeAST*>(ast->statements.first());
     TESTSCOPENAME(scope, "foobar")
     QList<QMake::StatementAST*> testlist;
     auto tst = new QMake::AssignmentAST(scope->body);
     auto val = new QMake::ValueAST(tst);
     val->value = QStringLiteral("VARIABLE");
     tst->identifier = val;
     val = new QMake::ValueAST(tst);
     val->value = QStringLiteral("=");
     tst->op = val;
     val = new QMake::ValueAST(tst);
     val->value = QStringLiteral("FOO");
     tst->values.append(val);
     testlist.append(tst);
     TESTSCOPEBODY(scope, testlist, 1)
 ENDTESTFUNCIMPL
 
 DATAFUNCIMPL(ScopeTest, basicScopeBrace, "foobar {\n  VARIABLE = FOO\n}\n")
 
 BEGINTESTFUNCIMPL(ScopeTest, nestedScope, 1)
     QMake::SimpleScopeAST* scope = dynamic_cast<QMake::SimpleScopeAST*>(ast->statements.first());
     TESTSCOPENAME(scope, "foobar")
     QList<QMake::StatementAST*> testlist;
     auto simple = new QMake::SimpleScopeAST(scope->body);
     auto val = new QMake::ValueAST(simple);
     val->value = QStringLiteral("barfoo");
     simple->identifier = val;
     auto body = new QMake::ScopeBodyAST(simple);
-    QList<QMake::StatementAST*> sublist;
     auto tst = new QMake::AssignmentAST(body);
     val = new QMake::ValueAST(tst);
     val->value = QStringLiteral("VARIABLE");
     tst->identifier = val;
     val = new QMake::ValueAST(tst);
     val->value = QStringLiteral("=");
     tst->op = val;
     val = new QMake::ValueAST(tst);
     val->value = QStringLiteral("FOO");
     tst->values.append(val);
     body->statements.append(tst);
     simple->body = body;
     testlist.append(simple);
 
     TESTSCOPEBODY(scope, testlist, 1)
 ENDTESTFUNCIMPL
 
 DATAFUNCIMPL(ScopeTest, nestedScope, "foobar :barfoo : VARIABLE = FOO\n")
 
 BEGINTESTFUNCIMPL(ScopeTest, missingStatement, 1)
     QMake::SimpleScopeAST* scope = dynamic_cast<QMake::SimpleScopeAST*>(ast->statements.first());
     TESTSCOPENAME(scope, "eval")
 ENDTESTFUNCIMPL
 
 DATAFUNCIMPL(ScopeTest, missingStatement, "eval :\n")
 
 BEGINTESTFAILFUNCIMPL(ScopeTest, missingColon, "No colon")
 ENDTESTFUNCIMPL
 
 DATAFUNCIMPL(ScopeTest, missingColon, "eval \n")
 
 void ScopeTest::strangeScopeNames()
 {
     QMake::Driver d;
     d.setContent(QStringLiteral("linux-gcc++-* {\n  VARIABLE = FOO\n}\n"));
     bool ret = d.parse(&ast);
     QVERIFY(ret);
 }
diff --git a/plugins/qmakemanager/parser/tests/testhelpers.h b/plugins/qmakemanager/parser/tests/testhelpers.h
index 0d5c2f5952..6166e390c8 100644
--- a/plugins/qmakemanager/parser/tests/testhelpers.h
+++ b/plugins/qmakemanager/parser/tests/testhelpers.h
@@ -1,134 +1,132 @@
 /* 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 QMAKETESTMACROS_H
 #define QMAKETESTMACROS_H
 
 namespace QMake{
     class StatementAST;
 }
 
 template <typename T> class QList;
 
 #define FUNCDEF( funcname )\
         void  funcname();\
         void  funcname##_data();
 
 #define DATAFUNCIMPL( classname, funcname, data ) \
 void classname::funcname##_data()\
 {\
     QTest::addColumn<QString>( "project" );\
     QTest::addColumn<QString>( "output" );\
     QTest::newRow( "row1" ) << data << data; \
 }
 
 #define BEGINTESTFUNCIMPL( classname, funcname, astcount ) \
 void classname::funcname()\
 {\
     qDebug() << "Beginning Test Function"; \
     QFETCH( QString, project );\
-    QFETCH( QString, output );\
     QMake::Driver d; \
     d.setContent( project ); \
     bool ret = d.parse( &ast );\
     QVERIFY( ret );\
     QVERIFY( ast->statements.count() == astcount );
 
 #define BEGINTESTFAILFUNCIMPL( classname, funcname, comment ) \
 void classname::funcname()\
 {\
     qDebug() << "Beginning Test FAIL Function"; \
     QFETCH( QString, project );\
-    QFETCH( QString, output );\
     QMake::Driver d; \
     d.setContent( project ); \
     bool ret = d.parse( &ast );\
     QEXPECT_FAIL( "", comment, Continue );\
     QVERIFY( ret );
 
 
 #define ENDTESTFUNCIMPL }
 
 #define TESTASSIGNMENT( ast, var, opval, valcount ) \
     QVERIFY( ast != nullptr );\
     QVERIFY( ast->identifier->value == var );\
     QVERIFY( ast->op->value == opval );\
     QVERIFY( ast->values.count() == valcount );
 
 #define TESTFUNCNAME( scopeast, funcname ) \
     QVERIFY( scopeast ); \
     if( QMake::SimpleScopeAST* simpleast = dynamic_cast<QMake::SimpleScopeAST*>( scopeast ) ) \
     { \
         QVERIFY( simpleast->identifier->value == funcname );\
     } else if( QMake::FunctionCallAST* funast = dynamic_cast<QMake::FunctionCallAST*>( scopeast ) ) \
     { \
         QVERIFY( funast->identifier->value == funcname );\
     }
 
 #define TESTSCOPENAME( scopeast, scopename ) \
     QVERIFY( scopeast ); \
     QVERIFY( scopeast->identifier->value == scopename );
 
 #define TESTOROP( scopeast, funclist ) \
     for( int i = 0; i < funclist.size(); i++) \
     {\
         QVERIFY( i < scopeast->scopes.count() );\
         if( QMake::SimpleScopeAST* simpleast = dynamic_cast<QMake::SimpleScopeAST*>( scopeast->scopes.at(i) ) ) \
         { \
             QVERIFY( simpleast->identifier->value == funclist.at(i) );\
         } else if( QMake::FunctionCallAST* funast = dynamic_cast<QMake::FunctionCallAST*>( scopeast->scopes.at(i) ) ) \
         { \
             QVERIFY( funast->identifier->value == funclist.at(i) );\
         } \
     }
 
 #define TESTSCOPEBODY( scope, teststmts, stmtcount ) \
     QVERIFY( scope->body != nullptr ); \
     QVERIFY( scope->body->statements.count() == stmtcount ); \
     matchScopeBodies(scope->body->statements, teststmts);
 
 #define TESTSCOPEAST( scope, testscope ) \
     QVERIFY( scope ); \
     QVERIFY( testscope ); \
     QMake::SimpleScopeAST* simple = dynamic_cast<QMake::SimpleScopeAST*>( scope ); \
     QMake::SimpleScopeAST* testsimple = dynamic_cast<QMake::SimpleScopeAST*>( scope ); \
     QMake::FunctionCallAST* fun = dynamic_cast<QMake::FunctionCallAST*>( scope ); \
     QMake::FunctionCallAST* testfun = dynamic_cast<QMake::FunctionCallAST*>( scope ); \
     QVERIFY( ( simple && testsimple ) || ( fun && testfun ) ); \
     if( simple ) \
     { \
         QVERIFY( simple->identifier->value == testsimple->identifier->value ); \
     } else \
     { \
         QVERIFY( fun->identifier->value == testfun->identifier->value ); \
     }
 
 #define TESTOROPAST(orop,testorop) \
     for(int i = 0; i < orop->scopes.count(); i++ ) \
     { \
         QVERIFY( i < testorop->scopes.count() ); \
         TESTSCOPEAST( orop->scopes.at(i), testorop->scopes.at(i) ) \
     }
 
 void matchScopeBodies(const QList<QMake::StatementAST*>&,
                              const QList<QMake::StatementAST*>& );
 
 #endif
 
diff --git a/plugins/qmakemanager/qmakemanager.cpp b/plugins/qmakemanager/qmakemanager.cpp
index 9f73463c86..491bf4d8ef 100644
--- a/plugins/qmakemanager/qmakemanager.cpp
+++ b/plugins/qmakemanager/qmakemanager.cpp
@@ -1,514 +1,513 @@
 /* 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 <QDir>
 #include <QIcon>
 #include <QFileInfo>
 #include <QHash>
 #include <QList>
 #include <QUrl>
 
 #include <KIO/Global>
 #include <KConfigGroup>
 #include <KDirWatch>
 #include <KLocalizedString>
 #include <KPluginFactory>
 
 #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 <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(QObject* parent, const QVariantList&)
     : AbstractFileManagerPlugin(QStringLiteral("kdevqmakemanager"), parent)
     , IBuildSystemManager()
 {
     IPlugin* i = core()->pluginController()->pluginForExtension(QStringLiteral("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(QStringLiteral("qtlogo")), i18n("Run QMake"), this);
     connect(m_runQMake, &QAction::triggered, this, &QMakeProjectManager::slotRunQMake);
 }
 
 QMakeProjectManager::~QMakeProjectManager()
 {
 }
 
 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(QLatin1String("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());
 
     auto item = new QMakeFolderItem(project, path);
 
     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();
     }
 
     QStringList projectfiles = dir.entryList(QStringList() << QStringLiteral("*.pro"));
     for (const auto& projectfile : projectfiles) {
         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();
         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());
     const QStringList projectFiles = dir.entryList(QStringList{QStringLiteral("*.pro"), QStringLiteral("*.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;
     }
 
     for (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(QLatin1String(".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), &KDirWatch::dirty, this, &QMakeProjectManager::slotDirty);
     return ret;
 }
 
 void QMakeProjectManager::slotDirty(const QString& path)
 {
     if (!path.endsWith(QLatin1String(".pro")) && !path.endsWith(QLatin1String(".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
                     qCDebug(KDEV_QMAKE) << "reloading" << pro << path;
                     pro->read();
                 }
             }
             finished = true;
         } else if (ProjectFolderItem* newFolder = buildFolderItem(project, folder->path(), folder->parent())) {
             qCDebug(KDEV_QMAKE) << "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();
                 for (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();
                 for (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;
 }
 
 QString QMakeProjectManager::extraArguments(KDevelop::ProjectBaseItem *item) const
 {
     QMakeFolderItem* folder = findQMakeFolderParent(item);
     if (!folder) {
         // happens for bad qmake configurations
         return {};
     }
 
     QStringList d;
     foreach (QMakeProjectFile* pro, folder->projectFiles()) {
         d << pro->extraArguments();
     }
     return d.join(QLatin1Char(' '));
 }
 
 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(QStringLiteral(".qmake.cache")) && !curdir.isRoot() && curdir.cdUp()) {
         qCDebug(KDEV_QMAKE) << curdir;
     }
 
     if (curdir.exists(QStringLiteral(".qmake.cache"))) {
         qCDebug(KDEV_QMAKE) << "Found QMake cache in " << curdir.absolutePath();
         return new QMakeCache(curdir.canonicalPath() + "/.qmake.cache");
     }
     return nullptr;
 }
 
 ContextMenuExtension QMakeProjectManager::contextMenuExtension(Context* context, QWidget* parent)
 {
     Q_UNUSED(parent);
 
     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/plugins/qmljs/duchain/declarationbuilder.cpp b/plugins/qmljs/duchain/declarationbuilder.cpp
index 228cde9b36..3d455848f8 100644
--- a/plugins/qmljs/duchain/declarationbuilder.cpp
+++ b/plugins/qmljs/duchain/declarationbuilder.cpp
@@ -1,1543 +1,1542 @@
 /*************************************************************************************
  *  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 <QFileInfo>
 #include <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,
                                                  const ReferencedTopDUContext& updateContext_)
 {
     Q_ASSERT(m_session->url() == url);
 
     ReferencedTopDUContext updateContext(updateContext_);
     // 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(QLatin1String("__builtin_qml.qml"))) {
         builtinQmlContext = m_session->contextOfFile(
             QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("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 Identifier& 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,
         QualifiedIdentifier(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 != Identifier(QStringLiteral("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,
         QualifiedIdentifier(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 Identifier 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
         Identifier(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,
         Identifier(),
         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 Identifier 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;
     Identifier 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
     // TODO check if we can make getDeclaration receive an Identifier directly
     if (QmlJS::getDeclaration(QualifiedIdentifier(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>(
             Identifier(),
             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));
     Identifier 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 Identifier &name)
 {
     QString baseClass = QmlJS::getQMLAttributeValue(node->members, QStringLiteral("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.isEmpty()) {
             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 Identifier &name,
                                        bool isSlot,
                                        bool isSignal)
 {
     QString type_name = QmlJS::getQMLAttributeValue(node->members, QStringLiteral("type")).value;
     QmlJS::FunctionType::Ptr type(new QmlJS::FunctionType);
 
     if (type_name.isEmpty()) {
         type->setReturnType(typeFromName(QStringLiteral("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 Identifier &name)
 {
     AbstractType::Ptr type = typeFromName(QmlJS::getQMLAttributeValue(node->members, QStringLiteral("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 Identifier &name)
 {
     QmlJS::FunctionType::Ptr function = currentType<QmlJS::FunctionType>();
     AbstractType::Ptr type = typeFromName(QmlJS::getQMLAttributeValue(node->members, QStringLiteral("type")).value);
 
     Q_ASSERT(function);
     function->addArgument(type);
 
     {
         DUChainWriteLocker lock;
         openDeclaration<Declaration>(name, range);
     }
     openType(type);
 }
 
 void DeclarationBuilder::declareEnum(const RangeInRevision &range,
                                      const Identifier &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)
 {
     Identifier name(
         QmlJS::getQMLAttributeValue(node->members, QStringLiteral("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 = Identifier();   // 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 = Identifier();
 
         // 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 ?
                     Identifier(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,
         QualifiedIdentifier(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>(
             Identifier(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) : QStringLiteral("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>(
             Identifier(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)),
                 QStringLiteral("*.qmltypes"),
                 QStringLiteral("*.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
         Identifier 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, QualifiedIdentifier(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.isEmpty() && 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, QStringLiteral("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);
     Identifier 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,
             Identifier(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(QStringLiteral("void")));
         }
     } else {
         AbstractType::Ptr type;
 
         if (typeName == QLatin1String("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/plugins/quickopen/tests/bench_quickopen.cpp b/plugins/quickopen/tests/bench_quickopen.cpp
index e731c70ec4..4134348697 100644
--- a/plugins/quickopen/tests/bench_quickopen.cpp
+++ b/plugins/quickopen/tests/bench_quickopen.cpp
@@ -1,161 +1,160 @@
 /*
  * Copyright <year> Milian Wolff <mail@milianw.de>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "bench_quickopen.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 
 #include <QIcon>
 #include <QTest>
 
 QTEST_MAIN(BenchQuickOpen)
 
 using namespace KDevelop;
 
 BenchQuickOpen::BenchQuickOpen(QObject* parent)
     : QuickOpenTestBase(Core::NoUi, parent)
 {
 }
 
 void BenchQuickOpen::getData()
 {
     QTest::addColumn<int>("files");
     QTest::addColumn<QString>("filter");
 
     QTest::newRow("0100-___") << 100  << "";
     QTest::newRow("0500-___") << 500  << "";
     QTest::newRow("0100-bar") << 100  << "bar";
     QTest::newRow("0500-bar") << 500  << "bar";
     QTest::newRow("0100-1__") << 100  << "1";
     QTest::newRow("0500-1__") << 500  << "1";
     QTest::newRow("0100-f/b") << 100  << "f/b";
     QTest::newRow("0500-f/b") << 500  << "f/b";
 }
 
 void BenchQuickOpen::benchProjectFileFilter_addRemoveProject()
 {
     QFETCH(int, files);
-    QFETCH(QString, filter);
 
     ProjectFileDataProvider provider;
     QScopedPointer<TestProject> project(getProjectWithFiles(files));
 
     QBENCHMARK {
         projectController->addProject(project.data());
         projectController->takeProject(project.data());
     }
 }
 
 void BenchQuickOpen::benchProjectFileFilter_addRemoveProject_data()
 {
     getData();
 }
 
 void BenchQuickOpen::benchProjectFileFilter_reset()
 {
     QFETCH(int, files);
     QFETCH(QString, filter);
 
     ProjectFileDataProvider provider;
     TestProject* project = getProjectWithFiles(files);
     provider.setFilterText(filter);
 
     projectController->addProject(project);
     QBENCHMARK {
         provider.reset();
     }
 }
 
 void BenchQuickOpen::benchProjectFileFilter_reset_data()
 {
     getData();
 }
 
 void BenchQuickOpen::benchProjectFileFilter_setFilter()
 {
     QFETCH(int, files);
     QFETCH(QString, filter);
 
     ProjectFileDataProvider provider;
     TestProject* project = getProjectWithFiles(files);
 
     projectController->addProject(project);
 
     provider.reset();
 
     QBENCHMARK {
         provider.setFilterText(filter);
         provider.setFilterText(QString());
     }
 }
 
 void BenchQuickOpen::benchProjectFileFilter_setFilter_data()
 {
     getData();
 }
 
 void BenchQuickOpen::benchProjectFileFilter_providerData()
 {
     QFETCH(int, files);
     QFETCH(QString, filter);
 
     ProjectFileDataProvider provider;
     TestProject* project = getProjectWithFiles(files);
     projectController->addProject(project);
     provider.reset();
     QCOMPARE(provider.itemCount(), uint(files));
     provider.setFilterText(filter);
     QVERIFY(provider.itemCount());
     const int itemIdx = provider.itemCount() - 1;
     QBENCHMARK {
         QuickOpenDataPointer data = provider.data(itemIdx);
         data->text();
     }
 }
 
 void BenchQuickOpen::benchProjectFileFilter_providerData_data()
 {
     getData();
 }
 
 void BenchQuickOpen::benchProjectFileFilter_providerDataIcon()
 {
     QFETCH(int, files);
     QFETCH(QString, filter);
 
     ProjectFileDataProvider provider;
     TestProject* project = getProjectWithFiles(files);
     projectController->addProject(project);
     provider.reset();
     QCOMPARE(provider.itemCount(), uint(files));
     provider.setFilterText(filter);
     QVERIFY(provider.itemCount());
     const int itemIdx = provider.itemCount() - 1;
     QBENCHMARK {
         QuickOpenDataPointer data = provider.data(itemIdx);
         data->icon();
     }
 }
 
 void BenchQuickOpen::benchProjectFileFilter_providerDataIcon_data()
 {
     getData();
 }
diff --git a/plugins/standardoutputview/tests/test_standardoutputview.cpp b/plugins/standardoutputview/tests/test_standardoutputview.cpp
index b0ba6f2f16..c75ff97757 100644
--- a/plugins/standardoutputview/tests/test_standardoutputview.cpp
+++ b/plugins/standardoutputview/tests/test_standardoutputview.cpp
@@ -1,230 +1,228 @@
 /*
     Copyright (C) 2011  Silvère Lestang <silvere.lestang@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 <QAction>
 #include <QStackedWidget>
 #include <QStandardItemModel>
 #include <QItemDelegate>
 #include <QTreeView>
 #include <QTest>
 
 #include <KLocalizedString>
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <sublime/view.h>
 #include <sublime/controller.h>
 #include <sublime/area.h>
 #include <sublime/tooldocument.h>
 #include <interfaces/iplugincontroller.h>
 #include <outputview/ioutputview.h>
 
 #include "test_standardoutputview.h"
 #include "../outputwidget.h"
 #include "../toolviewdata.h"
 
 namespace KDevelop
 {
     class IUiController;
 }
 
 QTEST_MAIN(StandardOutputViewTest)
 
 const QString StandardOutputViewTest::toolViewTitle = QStringLiteral("my_toolview");
 
 void StandardOutputViewTest::initTestCase()
 {
     KDevelop::AutoTestShell::init({QStringLiteral("KDevStandardOutputView")});
     m_testCore = new KDevelop::TestCore();
     m_testCore->initialize(KDevelop::Core::Default);
 
     m_controller = m_testCore->uiControllerInternal();
 
     QTest::qWait(500); // makes sure that everything is loaded (don't know if it's required)
 
     m_stdOutputView = nullptr;
     KDevelop::IPluginController* plugin_controller = m_testCore->pluginController();
 
-
-    QList<KDevelop::IPlugin*> plugins = plugin_controller->loadedPlugins();
     // make sure KDevStandardOutputView is loaded
     KDevelop::IPlugin* plugin = plugin_controller->loadPlugin(QStringLiteral("KDevStandardOutputView"));
     QVERIFY(plugin);
     m_stdOutputView =  dynamic_cast<KDevelop::IOutputView*>(plugin);
     QVERIFY(m_stdOutputView);
 }
 
 void StandardOutputViewTest::cleanupTestCase()
 {
      m_testCore->cleanup();
      delete m_testCore;
 }
 
 OutputWidget* StandardOutputViewTest::toolViewPointer(const QString& toolViewTitle)
 {
     const QList< Sublime::View* > views = m_controller->activeArea()->toolViews();
     for (Sublime::View* view : views) {
         Sublime::ToolDocument *doc = dynamic_cast<Sublime::ToolDocument*>(view->document());
         if(doc) {
             if(doc->title() == toolViewTitle && view->hasWidget()) {
                 return dynamic_cast<OutputWidget*>(view->widget());
             }
         }
     }
     return nullptr;
 }
 
 void StandardOutputViewTest::testRegisterAndRemoveToolView()
 {
     toolViewId = m_stdOutputView->registerToolView(toolViewTitle, KDevelop::IOutputView::HistoryView);
     QVERIFY(toolViewPointer(toolViewTitle));
 
     // re-registering should return the same tool view instead of creating a new one
     QCOMPARE(toolViewId, m_stdOutputView->registerToolView(toolViewTitle, KDevelop::IOutputView::HistoryView));
 
     m_stdOutputView->removeToolView(toolViewId);
     QVERIFY(!toolViewPointer(toolViewTitle));
 }
 
 void StandardOutputViewTest::testActions()
 {
     toolViewId = m_stdOutputView->registerToolView(toolViewTitle, KDevelop::IOutputView::MultipleView, QIcon());
     OutputWidget* outputWidget = toolViewPointer(toolViewTitle);
     QVERIFY(outputWidget);
 
     QList<QAction*> actions = outputWidget->actions();
     QCOMPARE(actions.size(), 11);
 
     m_stdOutputView->removeToolView(toolViewId);
     QVERIFY(!toolViewPointer(toolViewTitle));
 
     QList<QAction*> addedActions;
     addedActions.append(new QAction(QStringLiteral("Action1"), nullptr));
     addedActions.append(new QAction(QStringLiteral("Action2"), nullptr));
     toolViewId = m_stdOutputView->registerToolView(toolViewTitle, KDevelop::IOutputView::HistoryView,
                                                    QIcon(),
                                                    KDevelop::IOutputView::ShowItemsButton | KDevelop::IOutputView::AddFilterAction,
                                                    addedActions);
     outputWidget = toolViewPointer(toolViewTitle);
     QVERIFY(outputWidget);
 
     actions = outputWidget->actions();
     QCOMPARE(actions.size(), 16);
     QCOMPARE(actions[actions.size()-2]->text(), addedActions[0]->text());
     QCOMPARE(actions[actions.size()-1]->text(), addedActions[1]->text());
 
     m_stdOutputView->removeToolView(toolViewId);
     QVERIFY(!toolViewPointer(toolViewTitle));
 }
 
 void StandardOutputViewTest::testRegisterAndRemoveOutput()
 {
     toolViewId = m_stdOutputView->registerToolView(toolViewTitle, KDevelop::IOutputView::MultipleView, QIcon());
     OutputWidget* outputWidget = toolViewPointer(toolViewTitle);
     QVERIFY(outputWidget);
 
     for(int i = 0; i < 5; i++)
     {
         outputId[i] = m_stdOutputView->registerOutputInToolView(toolViewId, QStringLiteral("output%1").arg(i));
     }
     for(int i = 0; i < 5; i++)
     {
         QCOMPARE(outputWidget->data->outputdata.value(outputId[i])->title, QStringLiteral("output%1").arg(i));
         QCOMPARE(outputWidget->m_tabwidget->tabText(i), QStringLiteral("output%1").arg(i));
     }
     for(int i = 0; i < 5; i++)
     {
         m_stdOutputView->removeOutput(outputId[i]);
         QVERIFY(!outputWidget->data->outputdata.contains(outputId[i]));
     }
     QCOMPARE(outputWidget->m_tabwidget->count(), 0);
 
     m_stdOutputView->removeToolView(toolViewId);
     QVERIFY(!toolViewPointer(toolViewTitle));
 
     toolViewId = m_stdOutputView->registerToolView(toolViewTitle, KDevelop::IOutputView::HistoryView,
                                                     QIcon(), KDevelop::IOutputView::ShowItemsButton | KDevelop::IOutputView::AddFilterAction);
     outputWidget = toolViewPointer(toolViewTitle);
     QVERIFY(outputWidget);
 
     for(int i = 0; i < 5; i++)
     {
         outputId[i] = m_stdOutputView->registerOutputInToolView(toolViewId, QStringLiteral("output%1").arg(i));
     }
     for(int i = 0; i < 5; i++)
     {
         QCOMPARE(outputWidget->data->outputdata.value(outputId[i])->title, QStringLiteral("output%1").arg(i));
     }
     for(int i = 0; i < 5; i++)
     {
         m_stdOutputView->removeOutput(outputId[i]);
         QVERIFY(!outputWidget->data->outputdata.contains(outputId[i]));
     }
     QCOMPARE(outputWidget->m_stackwidget->count(), 0);
 
     m_stdOutputView->removeToolView(toolViewId);
     QVERIFY(!toolViewPointer(toolViewTitle));
 }
 
 void StandardOutputViewTest::testSetModelAndDelegate()
 {
     toolViewId = m_stdOutputView->registerToolView(toolViewTitle, KDevelop::IOutputView::MultipleView, QIcon());
     OutputWidget* outputWidget = toolViewPointer(toolViewTitle);
     QVERIFY(outputWidget);
 
     QAbstractItemModel* model = new QStandardItemModel;
     QPointer<QAbstractItemModel> checkModel(model);
     QAbstractItemDelegate* delegate = new QItemDelegate;
     QPointer<QAbstractItemDelegate> checkDelegate(delegate);
 
     outputId[0] = m_stdOutputView->registerOutputInToolView(toolViewId, QStringLiteral("output"));
     m_stdOutputView->setModel(outputId[0], model);
     m_stdOutputView->setDelegate(outputId[0], delegate);
 
     QCOMPARE(outputWidget->m_views.value(outputId[0])->model(), model);
     QCOMPARE(outputWidget->m_views.value(outputId[0])->itemDelegate(), delegate);
 
     QVERIFY(model->parent()); // they have a parent (the outputdata), so parent() != 0x0
     QVERIFY(delegate->parent());
 
     m_stdOutputView->removeToolView(toolViewId);
     QVERIFY(!toolViewPointer(toolViewTitle));
 
     // view deleted, hence model + delegate deleted
     QVERIFY(!checkModel.data());
     QVERIFY(!checkDelegate.data());
 }
 
 void StandardOutputViewTest::testStandardToolViews()
 {
     QFETCH(KDevelop::IOutputView::StandardToolView, view);
     int id = m_stdOutputView->standardToolView(view);
     QVERIFY(id);
     QCOMPARE(id, m_stdOutputView->standardToolView(view));
 }
 
 void StandardOutputViewTest::testStandardToolViews_data()
 {
     QTest::addColumn<KDevelop::IOutputView::StandardToolView>("view");
 
     QTest::newRow("build") << KDevelop::IOutputView::BuildView;
     QTest::newRow("run") << KDevelop::IOutputView::RunView;
     QTest::newRow("debug") << KDevelop::IOutputView::DebugView;
     QTest::newRow("test") << KDevelop::IOutputView::TestView;
     QTest::newRow("vcs") << KDevelop::IOutputView::VcsView;
 }