diff --git a/kdevplatform/language/duchain/duchain.cpp b/kdevplatform/language/duchain/duchain.cpp
index 269ebd1b95..7622ffe5c1 100644
--- a/kdevplatform/language/duchain/duchain.cpp
+++ b/kdevplatform/language/duchain/duchain.cpp
@@ -1,1732 +1,1744 @@
 /* This  is part of KDevelop
     Copyright 2006-2008 Hamish Rodda <rodda@kde.org>
     Copyright 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "duchain.h"
 #include "duchainlock.h"
 
 #include <QApplication>
 #include <QHash>
 #include <QMultiMap>
+#include <QProcessEnvironment>
 #include <QReadWriteLock>
 #include <QAtomicInt>
 #include <QThread>
+#include <QStandardPaths>
 #include <QMutex>
 #include <QTimer>
 
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/isession.h>
 
 #include "../interfaces/ilanguagesupport.h"
 #include "../interfaces/icodehighlighting.h"
 #include "../backgroundparser/backgroundparser.h"
 #include <debug.h>
 
 #include "language-features.h"
 #include "topducontext.h"
 #include "topducontextdata.h"
 #include "topducontextdynamicdata.h"
 #include "parsingenvironment.h"
 #include "declaration.h"
 #include "definitions.h"
 #include "duchainutils.h"
 #include "use.h"
 #include "uses.h"
 #include "abstractfunctiondeclaration.h"
 #include "duchainregister.h"
 #include "persistentsymboltable.h"
 #include "serialization/itemrepository.h"
 #include "waitforupdate.h"
 #include "importers.h"
 
 #if HAVE_MALLOC_TRIM
 #include "malloc.h"
 #endif
 
 namespace {
 //Additional "soft" cleanup steps that are done before the actual cleanup.
 //During "soft" cleanup, the consistency is not guaranteed. The repository is
 //marked to be updating during soft cleanup, so if kdevelop crashes, it will be cleared.
 //The big advantage of the soft cleanup steps is, that the duchain is always only locked for
 //short times, which leads to no lockup in the UI.
 const int SOFT_CLEANUP_STEPS = 1;
 
 // seconds to wait before trying to cleanup the DUChain
 const uint cleanupEverySeconds = 200;
 
 ///Approximate maximum count of top-contexts that are checked during final cleanup
 const uint maxFinalCleanupCheckContexts = 2000;
 const uint minimumFinalCleanupCheckContextsPercentage = 10; //Check at least n% of all top-contexts during cleanup
 //Set to true as soon as the duchain is deleted
 }
 
 namespace KDevelop
 {
 bool DUChain::m_deleted = false;
 
 ///Must be locked through KDevelop::SpinLock before using chainsByIndex
 ///This lock should be locked only for very short times
 QMutex DUChain::chainsByIndexLock;
 std::vector<TopDUContext*> DUChain::chainsByIndex;
 
 //This thing is not actually used, but it's needed for compiling
 DEFINE_LIST_MEMBER_HASH(EnvironmentInformationListItem, items, uint)
 
 //An entry for the item-repository that holds some meta-data. Behind this entry, the actual ParsingEnvironmentFileData is stored.
 class EnvironmentInformationItem {
   public:
   EnvironmentInformationItem(uint topContext, uint size) : m_topContext(topContext), m_size(size) {
   }
 
   ~EnvironmentInformationItem() {
   }
 
   unsigned int hash() const {
     return m_topContext;
   }
 
   unsigned int itemSize() const {
     return sizeof(*this) + m_size;
   }
 
   uint m_topContext;
   uint m_size;//Size of the data behind, that holds the actual item
 };
 
 struct ItemRepositoryIndexHash
 {
   uint
   operator()(unsigned int __x) const
   { return 173*(__x>>2) + 11 * (__x >> 16); }
 };
 
 
 class EnvironmentInformationRequest {
   public:
 
   ///This constructor should only be used for lookup
   EnvironmentInformationRequest(uint topContextIndex) : m_file(nullptr), m_index(topContextIndex) {
   }
 
   EnvironmentInformationRequest(const ParsingEnvironmentFile* file) : m_file(file), m_index(file->indexedTopContext().index()) {
   }
 
   enum {
     AverageSize = 32 //This should be the approximate average size of an Item
   };
 
   unsigned int hash() const {
     return m_index;
   }
 
   uint itemSize() const {
     return sizeof(EnvironmentInformationItem) + DUChainItemSystem::self().dynamicSize(*m_file->d_func());
   }
 
   void createItem(EnvironmentInformationItem* item) const {
     new (item) EnvironmentInformationItem(m_index, DUChainItemSystem::self().dynamicSize(*m_file->d_func()));
     Q_ASSERT(m_file->d_func()->m_dynamic);
     DUChainBaseData* data = reinterpret_cast<DUChainBaseData*>(reinterpret_cast<char*>(item) + sizeof(EnvironmentInformationItem));
     DUChainItemSystem::self().copy(*m_file->d_func(), *data, true);
     Q_ASSERT(data->m_range == m_file->d_func()->m_range);
     Q_ASSERT(data->classId == m_file->d_func()->classId);
     Q_ASSERT(data->m_dynamic == false);
   }
 
   static void destroy(EnvironmentInformationItem* item, KDevelop::AbstractItemRepository&) {
     item->~EnvironmentInformationItem();
     //We don't need to call the destructor, because that's done in DUChainBase::makeDynamic()
     //We just need to make sure that every environment-file is dynamic when it's deleted
 //     DUChainItemSystem::self().callDestructor((DUChainBaseData*)(((char*)item) + sizeof(EnvironmentInformationItem)));
   }
 
   static bool persistent(const EnvironmentInformationItem* ) {
     //Cleanup done separately
     return true;
   }
 
   bool equals(const EnvironmentInformationItem* item) const {
     return m_index == item->m_topContext;
   }
 
   const ParsingEnvironmentFile* m_file;
   uint m_index;
 };
 
 ///A list of environment-information/top-contexts mapped to a file-name
 class EnvironmentInformationListItem {
   public:
   EnvironmentInformationListItem() {
     initializeAppendedLists(true);
   }
 
   EnvironmentInformationListItem(const EnvironmentInformationListItem& rhs, bool dynamic = true) {
     initializeAppendedLists(dynamic);
     m_file = rhs.m_file;
     copyListsFrom(rhs);
   }
 
   ~EnvironmentInformationListItem() {
     freeAppendedLists();
   }
 
   unsigned int hash() const {
     //We only compare the declaration. This allows us implementing a map, although the item-repository
     //originally represents a set.
     return m_file.hash();
   }
 
   unsigned short int itemSize() const {
     return dynamicSize();
   }
 
   IndexedString m_file;
 
   uint classSize() const {
     return sizeof(*this);
   }
 
   START_APPENDED_LISTS(EnvironmentInformationListItem);
   ///Contains the index of each contained environment-item
   APPENDED_LIST_FIRST(EnvironmentInformationListItem, uint, items);
   END_APPENDED_LISTS(EnvironmentInformationListItem, items);
 };
 
 class EnvironmentInformationListRequest {
   public:
 
   ///This constructor should only be used for lookup
   EnvironmentInformationListRequest(const IndexedString& file) : m_file(file), m_item(nullptr) {
   }
   ///This is used to actually construct the information in the repository
   EnvironmentInformationListRequest(const IndexedString& file, const EnvironmentInformationListItem& item) : m_file(file), m_item(&item) {
   }
 
   enum {
     AverageSize = 160 //This should be the approximate average size of an Item
   };
 
   unsigned int hash() const {
     return m_file.hash();
   }
 
   uint itemSize() const {
     return m_item->itemSize();
   }
 
   void createItem(EnvironmentInformationListItem* item) const {
     Q_ASSERT(m_item->m_file == m_file);
     new (item) EnvironmentInformationListItem(*m_item, false);
   }
 
   static void destroy(EnvironmentInformationListItem* item, KDevelop::AbstractItemRepository&) {
     item->~EnvironmentInformationListItem();
   }
 
   static bool persistent(const EnvironmentInformationListItem*) {
     //Cleanup is done separately
     return true;
   }
 
   bool equals(const EnvironmentInformationListItem* item) const {
     return m_file == item->m_file;
   }
 
   IndexedString m_file;
   const EnvironmentInformationListItem* m_item;
 };
 
 class DUChainPrivate;
 static DUChainPrivate* duChainPrivateSelf = nullptr;
 class DUChainPrivate
 {
   class CleanupThread : public QThread {
     public:
       explicit CleanupThread(DUChainPrivate* data)
         : m_data(data)
       {
       }
 
       void stopThread()
       {
         quit();
         wait();
       }
 
     private:
       void run() override {
         QTimer timer;
         connect(&timer, &QTimer::timeout, [this]() {
           //Just to make sure the cache is cleared periodically
           ModificationRevisionSet::clearCache();
 
           m_data->doMoreCleanup(SOFT_CLEANUP_STEPS, TryLock);
         });
         timer.start(cleanupEverySeconds * 1000);
         exec();
       }
       DUChainPrivate* m_data;
   };
 public:
   DUChainPrivate() : m_chainsMutex(QMutex::Recursive), m_cleanupMutex(QMutex::Recursive), instance(nullptr), m_cleanupDisabled(false), m_destroyed(false), m_environmentListInfo(QStringLiteral("Environment Lists")), m_environmentInfo(QStringLiteral("Environment Information"))
   {
 #if defined(TEST_NO_CLEANUP)
     m_cleanupDisabled = true;
 #endif
 
     duChainPrivateSelf = this;
     qRegisterMetaType<DUChainBasePointer>("KDevelop::DUChainBasePointer");
     qRegisterMetaType<DUContextPointer>("KDevelop::DUContextPointer");
     qRegisterMetaType<TopDUContextPointer>("KDevelop::TopDUContextPointer");
     qRegisterMetaType<DeclarationPointer>("KDevelop::DeclarationPointer");
     qRegisterMetaType<FunctionDeclarationPointer>("KDevelop::FunctionDeclarationPointer");
     qRegisterMetaType<KDevelop::IndexedString>("KDevelop::IndexedString");
     qRegisterMetaType<KDevelop::IndexedTopDUContext>("KDevelop::IndexedTopDUContext");
     qRegisterMetaType<KDevelop::ReferencedTopDUContext>("KDevelop::ReferencedTopDUContext");
 
     instance = new DUChain();
     m_cleanup = new CleanupThread(this);
     m_cleanup->start();
 
     DUChain::m_deleted = false;
 
     ///Loading of some static data:
     {
       ///@todo Solve this more duchain-like
       QFile f(globalItemRepositoryRegistry().path() + QLatin1String("/parsing_environment_data"));
       bool opened = f.open(QIODevice::ReadOnly);
       ///FIXME: ugh, so ugly
       ParsingEnvironmentFile::m_staticData = reinterpret_cast<StaticParsingEnvironmentData*>( new char[sizeof(StaticParsingEnvironmentData)]);
       if(opened) {
         qCDebug(LANGUAGE) << "reading parsing-environment static data";
         //Read
         f.read((char*)ParsingEnvironmentFile::m_staticData, sizeof(StaticParsingEnvironmentData));
       }else{
         qCDebug(LANGUAGE) << "creating new parsing-environment static data";
         //Initialize
         new (ParsingEnvironmentFile::m_staticData) StaticParsingEnvironmentData();
       }
     }
 
     ///Read in the list of available top-context indices
     {
       QFile f(globalItemRepositoryRegistry().path() + QLatin1String("/available_top_context_indices"));
       bool opened = f.open(QIODevice::ReadOnly);
       if(opened)
       {
         Q_ASSERT( (f.size() % sizeof(uint)) == 0);
         m_availableTopContextIndices.resize(f.size()/(int)sizeof(uint));
         f.read((char*)m_availableTopContextIndices.data(), f.size());
       }
     }
   }
   ~DUChainPrivate() {
     qCDebug(LANGUAGE) << "Destroying";
     DUChain::m_deleted = true;
     m_cleanup->stopThread();
     delete m_cleanup;
     delete instance;
   }
 
   void clear() {
 
     if(!m_cleanupDisabled)
       doMoreCleanup();
 
     DUChainWriteLocker writeLock(DUChain::lock());
 
     QMutexLocker l(&m_chainsMutex);
 
     foreach(TopDUContext* top, m_chainsByUrl)
       removeDocumentChainFromMemory(top);
 
     m_indexEnvironmentInformations.clear();
     m_fileEnvironmentInformations.clear();
 
     Q_ASSERT(m_fileEnvironmentInformations.isEmpty());
     Q_ASSERT(m_chainsByUrl.isEmpty());
   }
 
   ///DUChain must be write-locked
   ///Also removes from the environment-manager if the top-context is not on disk
   void removeDocumentChainFromMemory(TopDUContext* context) {
     QMutexLocker l(&m_chainsMutex);
 
     {
       QMutexLocker l(&m_referenceCountsMutex);
 
       if(m_referenceCounts.contains(context)) {
       //This happens during shutdown, since everything is unloaded
       qCDebug(LANGUAGE) << "removed a top-context that was reference-counted:" << context->url().str() << context->ownIndex();
       m_referenceCounts.remove(context);
       }
     }
 
     uint index = context->ownIndex();
 
     // qCDebug(LANGUAGE) << "duchain: removing document" << context->url().str();
     Q_ASSERT(hasChainForIndex(index));
     Q_ASSERT(m_chainsByUrl.contains(context->url(), context));
 
     m_chainsByUrl.remove(context->url(), context);
 
     if(!context->isOnDisk())
       instance->removeFromEnvironmentManager(context);
 
     l.unlock();
     //DUChain is write-locked, so we can do whatever we want on the top-context, including deleting it
     context->deleteSelf();
     l.relock();
 
     Q_ASSERT(hasChainForIndex(index));
 
     QMutexLocker lock(&DUChain::chainsByIndexLock);
     DUChain::chainsByIndex[index] = nullptr;
   }
 
   ///Must be locked before accessing content of this class.
   ///Should be released during expensive disk-operations and such.
   QMutex m_chainsMutex;
 
   QMutex m_cleanupMutex;
 
   CleanupThread* m_cleanup;
 
   DUChain* instance;
   DUChainLock lock;
   QMultiMap<IndexedString, TopDUContext*> m_chainsByUrl;
 
   //Must be locked before accessing m_referenceCounts
   QMutex m_referenceCountsMutex;
   QHash<TopDUContext*, uint> m_referenceCounts;
 
   Definitions m_definitions;
   Uses m_uses;
   QSet<uint> m_loading;
   bool m_cleanupDisabled;
 
   //List of available top-context indices, protected by m_chainsMutex
   QVector<uint> m_availableTopContextIndices;
 
   ///Used to keep alive the top-context that belong to documents loaded in the editor
   QSet<ReferencedTopDUContext> m_openDocumentContexts;
 
   bool m_destroyed;
 
   ///The item must not be stored yet
   ///m_chainsMutex should not be locked, since this can trigger I/O
   void addEnvironmentInformation(ParsingEnvironmentFilePointer info) {
     Q_ASSERT(!findInformation(info->indexedTopContext().index()));
     Q_ASSERT(m_environmentInfo.findIndex(info->indexedTopContext().index()) == 0);
 
     QMutexLocker lock(&m_chainsMutex);
     m_fileEnvironmentInformations.insert(info->url(), info);
 
     m_indexEnvironmentInformations.insert(info->indexedTopContext().index(), info);
 
     Q_ASSERT(info->d_func()->classId);
   }
 
   ///The item must be managed currently
   ///m_chainsMutex does not need to be locked
   void removeEnvironmentInformation(ParsingEnvironmentFilePointer info) {
 
     info->makeDynamic(); //By doing this, we make sure the data is actually being destroyed in the destructor
 
     bool removed = false;
     bool removed2 = false;
     {
       QMutexLocker lock(&m_chainsMutex);
       removed = m_fileEnvironmentInformations.remove(info->url(), info);
       removed2 = m_indexEnvironmentInformations.remove(info->indexedTopContext().index());
     }
 
     {
       //Remove it from the environment information lists if it was there
       QMutexLocker lock(m_environmentListInfo.mutex());
       uint index = m_environmentListInfo.findIndex(info->url());
 
       if(index) {
         EnvironmentInformationListItem item(*m_environmentListInfo.itemFromIndex(index));
         if(item.itemsList().removeOne(info->indexedTopContext().index())) {
           m_environmentListInfo.deleteItem(index);
           if(!item.itemsList().isEmpty())
             m_environmentListInfo.index(EnvironmentInformationListRequest(info->url(), item));
         }
       }
     }
 
     QMutexLocker lock(m_environmentInfo.mutex());
     uint index = m_environmentInfo.findIndex(info->indexedTopContext().index());
     if(index) {
       m_environmentInfo.deleteItem(index);
     }
 
     Q_UNUSED(removed);
     Q_UNUSED(removed2);
     Q_ASSERT(index || (removed && removed2));
     Q_ASSERT(!findInformation(info->indexedTopContext().index()));
   }
 
   ///m_chainsMutex should _not_ be locked, because this may trigger I/O
   QList<ParsingEnvironmentFilePointer> getEnvironmentInformation(const IndexedString& url) {
     QList<ParsingEnvironmentFilePointer> ret;
     uint listIndex = m_environmentListInfo.findIndex(url);
 
     if(listIndex) {
       KDevVarLengthArray<uint> topContextIndices;
 
       {
         //First store all the possible intices into the KDevVarLengthArray, so we can unlock the mutex before processing them.
 
         QMutexLocker lock(m_environmentListInfo.mutex()); //Lock the mutex to make sure the item isn't changed while it's being iterated
         const EnvironmentInformationListItem* item = m_environmentListInfo.itemFromIndex(listIndex);
         FOREACH_FUNCTION(uint topContextIndex, item->items)
           topContextIndices << topContextIndex;
       }
 
       //Process the indices in a separate step after copying them from the array, so we don't need m_environmentListInfo.mutex locked,
       //and can call loadInformation(..) safely, which else might lead to a deadlock.
       foreach (uint topContextIndex, topContextIndices) {
         QExplicitlySharedDataPointer< ParsingEnvironmentFile > p = ParsingEnvironmentFilePointer(loadInformation(topContextIndex));
         if(p) {
          ret << p;
         }else{
           qCDebug(LANGUAGE) << "Failed to load enviromment-information for" << TopDUContextDynamicData::loadUrl(topContextIndex).str();
         }
       }
     }
 
     QMutexLocker l(&m_chainsMutex);
 
     //Add those information that have not been added to the stored lists yet
     foreach(const ParsingEnvironmentFilePointer& file, m_fileEnvironmentInformations.values(url))
       if(!ret.contains(file))
         ret << file;
 
     return ret;
   }
 
   ///Must be called _without_ the chainsByIndex spin-lock locked
   static inline bool hasChainForIndex(uint index) {
     QMutexLocker lock(&DUChain::chainsByIndexLock);
     return (DUChain::chainsByIndex.size() > index) && DUChain::chainsByIndex[index];
   }
 
   ///Must be called _without_ the chainsByIndex spin-lock locked. Returns the top-context if it is loaded.
   static inline TopDUContext* readChainForIndex(uint index) {
     QMutexLocker lock(&DUChain::chainsByIndexLock);
     if(DUChain::chainsByIndex.size() > index)
       return DUChain::chainsByIndex[index];
     else
       return nullptr;
   }
 
   ///Makes sure that the chain with the given index is loaded
   ///@warning m_chainsMutex must NOT be locked when this is called
   void loadChain(uint index, QSet<uint>& loaded) {
 
     QMutexLocker l(&m_chainsMutex);
 
     if(!hasChainForIndex(index)) {
 
       if(m_loading.contains(index)) {
         //It's probably being loaded by another thread. So wait until the load is ready
         while(m_loading.contains(index)) {
           l.unlock();
           qCDebug(LANGUAGE) << "waiting for another thread to load index" << index;
           QThread::usleep(50000);
           l.relock();
         }
         loaded.insert(index);
         return;
       }
       m_loading.insert(index);
       loaded.insert(index);
 
       l.unlock();
       qCDebug(LANGUAGE) << "loading top-context" << index;
       TopDUContext* chain = TopDUContextDynamicData::load(index);
       if(chain) {
         chain->setParsingEnvironmentFile(loadInformation(chain->ownIndex()));
 
         if(!chain->usingImportsCache()) {
           //Eventually also load all the imported chains, so the import-structure is built
           foreach(const DUContext::Import &import, chain->DUContext::importedParentContexts()) {
             if(!loaded.contains(import.topContextIndex())) {
               loadChain(import.topContextIndex(), loaded);
             }
           }
          }
         chain->rebuildDynamicImportStructure();
 
         chain->setInDuChain(true);
         instance->addDocumentChain(chain);
       }
 
       l.relock();
       m_loading.remove(index);
     }
   }
 
 
   ///Stores all environment-information
   ///Also makes sure that all information that stays is referenced, so it stays alive.
   ///@param atomic If this is false, the write-lock will be released time by time
   void storeAllInformation(bool atomic, DUChainWriteLocker& locker) {
 
     uint cnt = 0;
 
     QList<IndexedString> urls;
     {
       QMutexLocker lock(&m_chainsMutex);
       urls += m_fileEnvironmentInformations.keys();
     }
 
     foreach(const IndexedString &url, urls) {
       QList<ParsingEnvironmentFilePointer> check;
       {
         QMutexLocker lock(&m_chainsMutex);
         check = m_fileEnvironmentInformations.values(url);
       }
 
       foreach(ParsingEnvironmentFilePointer file, check) {
 
         EnvironmentInformationRequest req(file.data());
         QMutexLocker lock(m_environmentInfo.mutex());
         uint index = m_environmentInfo.findIndex(req);
 
         if(file->d_func()->isDynamic()) {
           //This item has been changed, or isn't in the repository yet
 
           //Eventually remove an old entry
           if(index)
             m_environmentInfo.deleteItem(index);
 
           //Add the new entry to the item repository
           index = m_environmentInfo.index(req);
           Q_ASSERT(index);
 
           EnvironmentInformationItem* item = const_cast<EnvironmentInformationItem*>(m_environmentInfo.itemFromIndex(index));
           DUChainBaseData* theData = reinterpret_cast<DUChainBaseData*>(reinterpret_cast<char*>(item) + sizeof(EnvironmentInformationItem));
 
           Q_ASSERT(theData->m_range == file->d_func()->m_range);
           Q_ASSERT(theData->m_dynamic == false);
           Q_ASSERT(theData->classId == file->d_func()->classId);
 
           file->setData( theData );
 
           ++cnt;
         }else{
           m_environmentInfo.itemFromIndex(index); //Prevent unloading of the data, by accessing the item
         }
       }
 
       ///We must not release the lock while holding a reference to a ParsingEnvironmentFilePointer, else we may miss the deletion of an
       ///information, and will get crashes.
       if(!atomic && (cnt % 100 == 0)) {
           //Release the lock on a regular basis
           locker.unlock();
           locker.lock();
       }
 
       storeInformationList(url);
 
       //Access the data in the repository, so the bucket isn't unloaded
       uint index = m_environmentListInfo.findIndex(EnvironmentInformationListRequest(url));
       if(index) {
         m_environmentListInfo.itemFromIndex(index);
       }else{
         QMutexLocker lock(&m_chainsMutex);
         qCDebug(LANGUAGE) << "Did not find stored item for" << url.str() << "count:" << m_fileEnvironmentInformations.values(url);
       }
       if(!atomic) {
         locker.unlock();
         locker.lock();
       }
     }
   }
 
   QMutex& cleanupMutex() {
     return m_cleanupMutex;
   }
 
   /// defines how we interact with the ongoing language parse jobs
   enum LockFlag {
     /// no locking required, only used when we locked previously
     NoLock = 0,
     /// lock all parse jobs and block until we succeeded. required at shutdown
     BlockingLock = 1,
     /// only try to lock and abort on failure, good for the intermittent cleanups
     TryLock = 2,
   };
   ///@param retries When this is nonzero, then doMoreCleanup will do the specified amount of cycles
   ///doing the cleanup without permanently locking the du-chain. During these steps the consistency
   ///of the disk-storage is not guaranteed, but only few changes will be done during these steps,
   ///so the final step where the duchain is permanently locked is much faster.
   void doMoreCleanup(int retries = 0, LockFlag lockFlag = BlockingLock) {
 
     if(m_cleanupDisabled)
       return;
 
     //This mutex makes sure that there's never 2 threads at he same time trying to clean up
     QMutexLocker lockCleanupMutex(&cleanupMutex());
 
     if(m_destroyed || m_cleanupDisabled)
       return;
 
     Q_ASSERT(!instance->lock()->currentThreadHasReadLock() && !instance->lock()->currentThreadHasWriteLock());
     DUChainWriteLocker writeLock(instance->lock());
 
     //This is used to stop all parsing before starting to do the cleanup. This way less happens during the
     //soft cleanups, and we have a good chance that during the "hard" cleanup only few data has to be written.
     QList<QReadWriteLock*> locked;
 
     if (lockFlag != NoLock) {
       QList<ILanguageSupport*> languages;
       if (ICore* core = ICore::self())
         if (ILanguageController* lc = core->languageController())
           languages = lc->loadedLanguages();
 
       writeLock.unlock();
 
       //Here we wait for all parsing-threads to stop their processing
       foreach(const auto language, languages) {
         if (lockFlag == TryLock) {
           if (!language->parseLock()->tryLockForWrite()) {
             qCDebug(LANGUAGE) << "Aborting cleanup because language plugin is still parsing:" << language->name();
             // some language is still parsing, don't interfere with the cleanup
             foreach(auto* lock, locked) {
               lock->unlock();
             }
             return;
           }
         } else {
           language->parseLock()->lockForWrite();
         }
         locked << language->parseLock();
       }
 
       writeLock.lock();
 
       globalItemRepositoryRegistry().lockForWriting();
       qCDebug(LANGUAGE) << "starting cleanup";
     }
 
     QTime startTime = QTime::currentTime();
     PersistentSymbolTable::self().clearCache();
 
     storeAllInformation(!retries, writeLock); //Puts environment-information into a repository
 
     //We don't need to increase the reference-count, since the cleanup-mutex is locked
     QSet<TopDUContext*> workOnContexts;
 
     {
       QMutexLocker l(&m_chainsMutex);
 
       workOnContexts.reserve(m_chainsByUrl.size());
       foreach(TopDUContext* top, m_chainsByUrl) {
         workOnContexts << top;
         Q_ASSERT(hasChainForIndex(top->ownIndex()));
       }
     }
 
     foreach(TopDUContext* context, workOnContexts) {
 
       context->m_dynamicData->store();
 
       if(retries) {
         //Eventually give other threads a chance to access the duchain
         writeLock.unlock();
         //Sleep to give the other threads a realistic chance to get a read-lock in between
         QThread::usleep(500);
         writeLock.lock();
       }
     }
 
       //Unload all top-contexts that don't have a reference-count and that are not imported by a referenced one
 
       QSet<IndexedString> unloadedNames;
       bool unloadedOne = true;
 
       bool unloadAllUnreferenced = !retries;
 
       //Now unload contexts, but only ones that are not imported by any other currently loaded context
       //The complication: Since during the lock-break new references may be added, we must never keep
       //the du-chain in an invalid state. Thus we can only unload contexts that are not imported by any
       //currently loaded contexts. In case of loops, we have to unload everything at once.
       while(unloadedOne) {
         unloadedOne = false;
         int hadUnloadable = 0;
 
         unloadContexts:
 
         foreach(TopDUContext* unload, workOnContexts) {
 
           bool hasReference = false;
 
           {
             QMutexLocker l(&m_referenceCountsMutex);
             //Test if the context is imported by a referenced one
             for (auto it = m_referenceCounts.constBegin(), end = m_referenceCounts.constEnd(); it != end; ++it) {
               auto* context = it.key();
               if(context == unload || context->imports(unload, CursorInRevision())) {
                 workOnContexts.remove(unload);
                 hasReference = true;
               }
             }
           }
 
           if(!hasReference)
             ++hadUnloadable; //We have found a context that is not referenced
           else
             continue; //This context is referenced
 
           bool isImportedByLoaded = !unload->loadedImporters().isEmpty();
 
           //If we unload a context that is imported by other contexts, we create a bad loaded state
           if(isImportedByLoaded && !unloadAllUnreferenced)
             continue;
 
           unloadedNames.insert(unload->url());
           //Since we've released the write-lock in between, we've got to call store() again to be sure that none of the data is dynamic
           //If nothing has changed, it is only a low-cost call.
           unload->m_dynamicData->store();
           Q_ASSERT(!unload->d_func()->m_dynamic);
           removeDocumentChainFromMemory(unload);
           workOnContexts.remove(unload);
           unloadedOne = true;
 
           if(!unloadAllUnreferenced) {
             //Eventually give other threads a chance to access the duchain
             writeLock.unlock();
             //Sleep to give the other threads a realistic chance to get a read-lock in between
             QThread::usleep(500);
             writeLock.lock();
           }
         }
         if(hadUnloadable && !unloadedOne) {
           Q_ASSERT(!unloadAllUnreferenced);
           //This can happen in case of loops. We have o unload everything at one time.
           qCDebug(LANGUAGE) << "found" << hadUnloadable << "unloadable contexts, but could not unload separately. Unloading atomically.";
           unloadAllUnreferenced = true;
           hadUnloadable = 0; //Reset to 0, so we cannot loop forever
           goto unloadContexts;
         }
       }
 
 
       if(retries == 0) {
         QMutexLocker lock(&m_chainsMutex);
         //Do this atomically, since we must be sure that _everything_ is already saved
         for(QMultiMap<IndexedString, ParsingEnvironmentFilePointer>::iterator it = m_fileEnvironmentInformations.begin(); it != m_fileEnvironmentInformations.end(); ) {
           ParsingEnvironmentFile* f = it->data();
           Q_ASSERT(f->d_func()->classId);
           if(f->ref.load() == 1) {
             Q_ASSERT(!f->d_func()->isDynamic()); //It cannot be dynamic, since we have stored before
             //The ParsingEnvironmentFilePointer is only referenced once. This means that it does not belong to any
             //loaded top-context, so just remove it to save some memory and processing time.
             ///@todo use some kind of timeout before removing
             it = m_fileEnvironmentInformations.erase(it);
           }else{
             ++it;
           }
         }
       }
 
       if(retries)
         writeLock.unlock();
 
       //This must be the last step, due to the on-disk reference counting
       globalItemRepositoryRegistry().store(); //Stores all repositories
 
       {
         //Store the static parsing-environment file data
         ///@todo Solve this more elegantly, using a general mechanism to store static duchain-like data
         Q_ASSERT(ParsingEnvironmentFile::m_staticData);
         QFile f(globalItemRepositoryRegistry().path() + QLatin1String("/parsing_environment_data"));
         bool opened = f.open(QIODevice::WriteOnly);
         Q_ASSERT(opened);
         Q_UNUSED(opened);
         f.write((char*)ParsingEnvironmentFile::m_staticData, sizeof(StaticParsingEnvironmentData));
       }
 
       ///Write out the list of available top-context indices
       {
         QMutexLocker lock(&m_chainsMutex);
 
         QFile f(globalItemRepositoryRegistry().path() + QLatin1String("/available_top_context_indices"));
         bool opened = f.open(QIODevice::WriteOnly);
         Q_ASSERT(opened);
         Q_UNUSED(opened);
 
         f.write((char*)m_availableTopContextIndices.data(), m_availableTopContextIndices.size() * sizeof(uint));
       }
 
 
       if(retries) {
         doMoreCleanup(retries-1, NoLock);
         writeLock.lock();
       }
 
       if(lockFlag != NoLock) {
         globalItemRepositoryRegistry().unlockForWriting();
 
         const auto elapsedMS = startTime.msecsTo(QTime::currentTime());
         qCDebug(LANGUAGE) << "time spent doing cleanup:" << elapsedMS << "ms - top-contexts still open:" << m_chainsByUrl.size() << "- retries" << retries;
       }
 
       foreach(QReadWriteLock* lock, locked)
         lock->unlock();
 
 #if HAVE_MALLOC_TRIM
     // trim unused memory but keep a pad buffer of about 50 MB
     // this can greatly decrease the perceived memory consumption of kdevelop
     // see: https://sourceware.org/bugzilla/show_bug.cgi?id=14827
     malloc_trim(50 * 1024 * 1024);
 #endif
   }
 
   ///Checks whether the information is already loaded.
   ParsingEnvironmentFile* findInformation(uint topContextIndex) {
     QMutexLocker lock(&m_chainsMutex);
     QHash<uint, ParsingEnvironmentFilePointer>::iterator it = m_indexEnvironmentInformations.find(topContextIndex);
     if(it != m_indexEnvironmentInformations.end())
       return (*it).data();
     return nullptr;
   }
 
   ///Loads/gets the environment-information for the given top-context index, or returns zero if none exists
   ///@warning m_chainsMutex should NOT be locked when this is called, because it triggers I/O
   ///@warning no other mutexes should be locked, as that may lead to a dedalock
   ParsingEnvironmentFile* loadInformation(uint topContextIndex) {
 
     ParsingEnvironmentFile* alreadyLoaded = findInformation(topContextIndex);
     if(alreadyLoaded)
       return alreadyLoaded;
 
     //Step two: Check if it is on disk, and if is, load it
     uint dataIndex = m_environmentInfo.findIndex(EnvironmentInformationRequest(topContextIndex));
     if(!dataIndex) {
       //No environment-information stored for this top-context
       return nullptr;
     }
 
     const EnvironmentInformationItem& item(*m_environmentInfo.itemFromIndex(dataIndex));
 
     QMutexLocker lock(&m_chainsMutex);
 
     //Due to multi-threading, we must do this check after locking the mutex, so we can be sure we don't create the same item twice at the same time
     alreadyLoaded = findInformation(topContextIndex);
     if(alreadyLoaded)
       return alreadyLoaded;
 
     ///FIXME: ugly, and remove const_cast
     ParsingEnvironmentFile* ret = dynamic_cast<ParsingEnvironmentFile*>(DUChainItemSystem::self().create(
       const_cast<DUChainBaseData*>(reinterpret_cast<const DUChainBaseData*>(reinterpret_cast<const char*>(&item) + sizeof(EnvironmentInformationItem)))
     ));
     if(ret) {
       Q_ASSERT(ret->d_func()->classId);
       Q_ASSERT(ret->indexedTopContext().index() == topContextIndex);
       ParsingEnvironmentFilePointer retPtr(ret);
 
       m_fileEnvironmentInformations.insert(ret->url(), retPtr);
 
       Q_ASSERT(!m_indexEnvironmentInformations.contains(ret->indexedTopContext().index()));
       m_indexEnvironmentInformations.insert(ret->indexedTopContext().index(), retPtr);
     }
     return ret;
   }
 
   struct CleanupListVisitor {
     QList<uint> checkContexts;
     bool operator()(const EnvironmentInformationItem* item) {
       checkContexts << item->m_topContext;
       return true;
     }
   };
 
   ///Will check a selection of all top-contexts for up-to-date ness, and remove them if out of date
   void cleanupTopContexts() {
     DUChainWriteLocker lock( DUChain::lock() );
     qCDebug(LANGUAGE) << "cleaning top-contexts";
     CleanupListVisitor visitor;
     uint startPos = 0;
     m_environmentInfo.visitAllItems(visitor);
 
     int checkContextsCount = maxFinalCleanupCheckContexts;
     int percentageOfContexts = (visitor.checkContexts.size() * 100) / minimumFinalCleanupCheckContextsPercentage;
 
     if(checkContextsCount < percentageOfContexts)
       checkContextsCount = percentageOfContexts;
 
     if(visitor.checkContexts.size() > (int)checkContextsCount)
       startPos = qrand() % (visitor.checkContexts.size() - checkContextsCount);
 
     int endPos = startPos + maxFinalCleanupCheckContexts;
     if(endPos > visitor.checkContexts.size())
       endPos = visitor.checkContexts.size();
     QSet< uint > check;
     for(int a = startPos; a < endPos && check.size() < checkContextsCount; ++a)
       if(check.size() < checkContextsCount)
         addContextsForRemoval(check, IndexedTopDUContext(visitor.checkContexts[a]));
 
     foreach(uint topIndex, check) {
       IndexedTopDUContext top(topIndex);
       if(top.data()) {
         qCDebug(LANGUAGE) << "removing top-context for" << top.data()->url().str() << "because it is out of date";
         instance->removeDocumentChain(top.data());
       }
     }
     qCDebug(LANGUAGE) << "check ready";
   }
 
 private:
 
   void addContextsForRemoval(QSet<uint>& topContexts, IndexedTopDUContext top) {
     if(topContexts.contains(top.index()))
       return;
 
     QExplicitlySharedDataPointer<ParsingEnvironmentFile> info( instance->environmentFileForDocument(top) );
     ///@todo Also check if the context is "useful"(Not a duplicate context, imported by a useful one, ...)
     if(info && info->needsUpdate()) {
       //This context will be removed
     }else{
       return;
     }
 
     topContexts.insert(top.index());
 
     if(info) {
       //Check whether importers need to be removed as well
       QList< QExplicitlySharedDataPointer<ParsingEnvironmentFile> > importers = info->importers();
 
       QSet< QExplicitlySharedDataPointer<ParsingEnvironmentFile> > checkNext;
 
       //Do breadth first search, so less imports/importers have to be loaded, and a lower depth is reached
 
       for(QList< QExplicitlySharedDataPointer<ParsingEnvironmentFile> >::iterator it = importers.begin(); it != importers.end(); ++it) {
         IndexedTopDUContext c = (*it)->indexedTopContext();
         if(!topContexts.contains(c.index())) {
           topContexts.insert(c.index()); //Prevent useless recursion
           checkNext.insert(*it);
         }
       }
 
       for(QSet< QExplicitlySharedDataPointer<ParsingEnvironmentFile> >::const_iterator it = checkNext.begin(); it != checkNext.end(); ++it) {
         topContexts.remove((*it)->indexedTopContext().index()); //Enable full check again
         addContextsForRemoval(topContexts, (*it)->indexedTopContext());
       }
     }
   }
 
   ///Stores the environment-information for the given url
   void storeInformationList(const IndexedString& url) {
 
     QMutexLocker lock(m_environmentListInfo.mutex());
 
     EnvironmentInformationListItem newItem;
     newItem.m_file = url;
 
     QSet<uint> newItems;
 
     {
       QMutexLocker lock(&m_chainsMutex);
       QMultiMap<IndexedString, ParsingEnvironmentFilePointer>::iterator start = m_fileEnvironmentInformations.lowerBound(url);
       QMultiMap<IndexedString, ParsingEnvironmentFilePointer>::iterator end = m_fileEnvironmentInformations.upperBound(url);
 
       for(QMultiMap<IndexedString, ParsingEnvironmentFilePointer>::iterator it = start; it != end; ++it) {
         uint topContextIndex = (*it)->indexedTopContext().index();
         newItems.insert(topContextIndex);
         newItem.itemsList().append(topContextIndex);
       }
     }
 
     uint index = m_environmentListInfo.findIndex(url);
 
     if(index) {
       //We only handle adding items here, since we can never be sure whether everything is loaded
       //Removal is handled directly in removeEnvironmentInformation
 
       const EnvironmentInformationListItem* item = m_environmentListInfo.itemFromIndex(index);
       QSet<uint> oldItems;
       FOREACH_FUNCTION(uint topContextIndex, item->items) {
         oldItems.insert(topContextIndex);
         if(!newItems.contains(topContextIndex)) {
           newItems.insert(topContextIndex);
           newItem.itemsList().append(topContextIndex);
         }
       }
 
       if(oldItems == newItems)
         return;
 
       ///Update/insert a new list
       m_environmentListInfo.deleteItem(index); //Remove the previous item
     }
 
     Q_ASSERT(m_environmentListInfo.findIndex(EnvironmentInformationListRequest(url)) == 0);
 
     //Insert the new item
     m_environmentListInfo.index(EnvironmentInformationListRequest(url, newItem));
 
     Q_ASSERT(m_environmentListInfo.findIndex(EnvironmentInformationListRequest(url)));
   }
 
   //Loaded environment information. Protected by m_chainsMutex
   QMultiMap<IndexedString, ParsingEnvironmentFilePointer> m_fileEnvironmentInformations;
   QHash<uint, ParsingEnvironmentFilePointer> m_indexEnvironmentInformations;
 
   ///The following repositories are thread-safe, and m_chainsMutex should not be locked when using them, because
   ///they may trigger I/O. Still it may be required to lock their local mutexes.
   ///Maps filenames to a list of top-contexts/environment-information.
   ItemRepository<EnvironmentInformationListItem, EnvironmentInformationListRequest> m_environmentListInfo;
   ///Maps top-context-indices to environment-information item.
   ItemRepository<EnvironmentInformationItem, EnvironmentInformationRequest> m_environmentInfo;
 };
 
 Q_GLOBAL_STATIC(DUChainPrivate, sdDUChainPrivate)
 
 
 DUChain::DUChain()
 {
   Q_ASSERT(ICore::self());
 
   connect(ICore::self()->documentController(), &IDocumentController::documentLoadedPrepare, this, &DUChain::documentLoadedPrepare);
   connect(ICore::self()->documentController(), &IDocumentController::documentUrlChanged, this, &DUChain::documentRenamed);
   connect(ICore::self()->documentController(), &IDocumentController::documentActivated, this, &DUChain::documentActivated);
   connect(ICore::self()->documentController(), &IDocumentController::documentClosed, this, &DUChain::documentClosed);
 }
 
 DUChain::~DUChain()
 {
   DUChain::m_deleted = true;
 }
 
 DUChain* DUChain::self()
 {
   return sdDUChainPrivate->instance;
 }
 
 extern void initModificationRevisionSetRepository();
 extern void initDeclarationRepositories();
 extern void initIdentifierRepository();
 extern void initTypeRepository();
 extern void initInstantiationInformationRepository();
 
+QString DUChain::repositoryPathForSession(const KDevelop::ISessionLock::Ptr& session)
+{
+  QString cacheDir = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation);
+  cacheDir += QStringLiteral("/kdevduchain");
+  QString baseDir = QProcessEnvironment::systemEnvironment().value(QStringLiteral("KDEV_DUCHAIN_DIR"), cacheDir);
+  baseDir += QStringLiteral("/%1-%2").arg(qApp->applicationName(), session->id());
+  return baseDir;
+}
+
 void DUChain::initialize()
 {
   // Initialize the global item repository as first thing after loading the session
   Q_ASSERT(ICore::self());
   Q_ASSERT(ICore::self()->activeSession());
-  ItemRepositoryRegistry::initialize(ICore::self()->activeSessionLock());
+
+  ItemRepositoryRegistry::initialize(repositoryPathForSession(ICore::self()->activeSessionLock()));
 
   initReferenceCounting();
 
   // This needs to be initialized here too as the function is not threadsafe, but can
   // sometimes be called from different threads. This results in the underlying QFile
   // being 0 and hence crashes at some point later when accessing the contents via
   // read. See https://bugs.kde.org/show_bug.cgi?id=250779
   RecursiveImportRepository::repository();
   RecursiveImportCacheRepository::repository();
 
   // similar to above, see https://bugs.kde.org/show_bug.cgi?id=255323
   initDeclarationRepositories();
 
   initModificationRevisionSetRepository();
   initIdentifierRepository();
   initTypeRepository();
   initInstantiationInformationRepository();
 
   Importers::self();
 
   globalImportIdentifier();
   globalIndexedImportIdentifier();
   globalAliasIdentifier();
   globalIndexedAliasIdentifier();
 }
 
 DUChainLock* DUChain::lock()
 {
   return &sdDUChainPrivate->lock;
 }
 
 QList<TopDUContext*> DUChain::allChains() const
 {
   QMutexLocker l(&sdDUChainPrivate->m_chainsMutex);
   return sdDUChainPrivate->m_chainsByUrl.values();
 }
 
 void DUChain::updateContextEnvironment( TopDUContext* context, ParsingEnvironmentFile* file ) {
 
   QMutexLocker l(&sdDUChainPrivate->m_chainsMutex);
 
   removeFromEnvironmentManager( context );
 
   context->setParsingEnvironmentFile( file );
 
   addToEnvironmentManager( context );
 }
 
 void DUChain::removeDocumentChain( TopDUContext* context )
 {
   ENSURE_CHAIN_WRITE_LOCKED;
   IndexedTopDUContext indexed(context->indexed());
   Q_ASSERT(indexed.data() == context); ///This assertion fails if you call removeDocumentChain(..) on a document that has not been added to the du-chain
   context->m_dynamicData->deleteOnDisk();
   Q_ASSERT(indexed.data() == context);
   sdDUChainPrivate->removeDocumentChainFromMemory(context);
   Q_ASSERT(!indexed.data());
   Q_ASSERT(!environmentFileForDocument(indexed));
 
   QMutexLocker lock(&sdDUChainPrivate->m_chainsMutex);
   sdDUChainPrivate->m_availableTopContextIndices.push_back(indexed.index());
 }
 
 void DUChain::addDocumentChain( TopDUContext * chain )
 {
   QMutexLocker l(&sdDUChainPrivate->m_chainsMutex);
 
 //   qCDebug(LANGUAGE) << "duchain: adding document" << chain->url().str() << " " << chain;
   Q_ASSERT(chain);
 
   Q_ASSERT(!sdDUChainPrivate->hasChainForIndex(chain->ownIndex()));
 
   {
     QMutexLocker lock(&DUChain::chainsByIndexLock);
     if(DUChain::chainsByIndex.size() <= chain->ownIndex())
       DUChain::chainsByIndex.resize(chain->ownIndex() + 100, nullptr);
 
     DUChain::chainsByIndex[chain->ownIndex()] = chain;
   }
   {
     Q_ASSERT(DUChain::chainsByIndex[chain->ownIndex()]);
   }
   Q_ASSERT(sdDUChainPrivate->hasChainForIndex(chain->ownIndex()));
 
   sdDUChainPrivate->m_chainsByUrl.insert(chain->url(), chain);
 
   Q_ASSERT(sdDUChainPrivate->hasChainForIndex(chain->ownIndex()));
 
   chain->setInDuChain(true);
 
   l.unlock();
 
   addToEnvironmentManager(chain);
 
   // This function might be called during shutdown by stale parse jobs
   // Make sure we don't access null-pointers here
   if (ICore::self() && ICore::self()->languageController() &&
       ICore::self()->languageController()->backgroundParser()->trackerForUrl(chain->url()))
   {
     //Make sure the context stays alive at least as long as the context is open
     ReferencedTopDUContext ctx(chain);
     sdDUChainPrivate->m_openDocumentContexts.insert(ctx);
   }
 }
 
 void DUChain::addToEnvironmentManager( TopDUContext * chain ) {
 
   ParsingEnvironmentFilePointer file = chain->parsingEnvironmentFile();
   if( !file )
     return; //We don't need to manage
 
   Q_ASSERT(file->indexedTopContext().index() == chain->ownIndex());
 
   if(ParsingEnvironmentFile* alreadyHave = sdDUChainPrivate->findInformation(file->indexedTopContext().index()))
   {
     ///If this triggers, there has already been another environment-information registered for this top-context.
     ///removeFromEnvironmentManager should have been called before to remove the old environment-information.
     Q_ASSERT(alreadyHave == file.data());
     Q_UNUSED(alreadyHave);
     return;
   }
 
   sdDUChainPrivate->addEnvironmentInformation(file);
 }
 
 void DUChain::removeFromEnvironmentManager( TopDUContext * chain ) {
 
   ParsingEnvironmentFilePointer file = chain->parsingEnvironmentFile();
   if( !file )
     return; //We don't need to manage
 
   sdDUChainPrivate->removeEnvironmentInformation(file);
 }
 
 TopDUContext* DUChain::chainForDocument(const QUrl& document, bool proxyContext) const {
   return chainForDocument(IndexedString(document), proxyContext);
 }
 
 bool DUChain::isInMemory(uint topContextIndex) const {
   return DUChainPrivate::hasChainForIndex(topContextIndex);
 }
 
 IndexedString DUChain::urlForIndex(uint index) const {
   {
     TopDUContext* chain = DUChainPrivate::readChainForIndex(index);
     if(chain)
       return chain->url();
   }
 
   return TopDUContextDynamicData::loadUrl(index);
 }
 
 TopDUContext* DUChain::loadChain(uint index)
 {
   QSet<uint> loaded;
   sdDUChainPrivate->loadChain(index, loaded);
 
   {
     QMutexLocker lock(&chainsByIndexLock);
 
     if(chainsByIndex.size() > index)
     {
       TopDUContext* top = chainsByIndex[index];
       if(top)
         return top;
     }
   }
 
   return nullptr;
 }
 
 TopDUContext* DUChain::chainForDocument(const KDevelop::IndexedString& document, bool proxyContext) const
 {
   ENSURE_CHAIN_READ_LOCKED;
 
   if(sdDUChainPrivate->m_destroyed)
     return nullptr;
 
   QList<ParsingEnvironmentFilePointer> list = sdDUChainPrivate->getEnvironmentInformation(document);
 
   foreach(const ParsingEnvironmentFilePointer &file, list)
     if(isInMemory(file->indexedTopContext().index()) && file->isProxyContext() == proxyContext) {
       return file->topContext();
     }
 
   foreach(const ParsingEnvironmentFilePointer &file, list)
     if(proxyContext == file->isProxyContext()) {
       return file->topContext();
     }
 
   //Allow selecting a top-context even if there is no ParsingEnvironmentFile
   QList< TopDUContext* > ret = chainsForDocument(document);
   foreach(TopDUContext* ctx, ret) {
     if(!ctx->parsingEnvironmentFile() || (ctx->parsingEnvironmentFile()->isProxyContext() == proxyContext))
       return ctx;
   }
 
   return nullptr;
 }
 
 QList<TopDUContext*> DUChain::chainsForDocument(const QUrl& document) const
 {
   return chainsForDocument(IndexedString(document));
 }
 
 QList<TopDUContext*> DUChain::chainsForDocument(const IndexedString& document) const
 {
   QList<TopDUContext*> chains;
 
   if(sdDUChainPrivate->m_destroyed)
     return chains;
 
   QMutexLocker l(&sdDUChainPrivate->m_chainsMutex);
 
   // Match all parsed versions of this document
   for (auto it = sdDUChainPrivate->m_chainsByUrl.lowerBound(document); it != sdDUChainPrivate->m_chainsByUrl.end(); ++it) {
     if (it.key() == document)
       chains << it.value();
     else
       break;
   }
 
   return chains;
 }
 
 TopDUContext* DUChain::chainForDocument( const QUrl& document, const KDevelop::ParsingEnvironment* environment, bool proxyContext ) const {
   return chainForDocument( IndexedString(document), environment, proxyContext );
 }
 
 ParsingEnvironmentFilePointer DUChain::environmentFileForDocument( const IndexedString& document, const ParsingEnvironment* environment, bool proxyContext ) const {
 
   ENSURE_CHAIN_READ_LOCKED;
 
   if(sdDUChainPrivate->m_destroyed)
     return ParsingEnvironmentFilePointer();
   QList< ParsingEnvironmentFilePointer> list = sdDUChainPrivate->getEnvironmentInformation(document);
 
 //    qCDebug(LANGUAGE) << document.str() << ": matching" << list.size() << (onlyProxyContexts ? "proxy-contexts" : (noProxyContexts ? "content-contexts" : "contexts"));
 
   auto it = list.constBegin();
   while(it != list.constEnd()) {
     if(*it && ((*it)->isProxyContext() == proxyContext) && (*it)->matchEnvironment(environment) &&
       // Verify that the environment-file and its top-context are "good": The top-context must exist,
       // and there must be a content-context associated to the proxy-context.
       (*it)->topContext() && (!proxyContext || DUChainUtils::contentContextFromProxyContext((*it)->topContext())) ) {
       return *it;
     }
     ++it;
   }
   return ParsingEnvironmentFilePointer();
 }
 
 QList<ParsingEnvironmentFilePointer> DUChain::allEnvironmentFiles(const IndexedString& document) {
   return sdDUChainPrivate->getEnvironmentInformation(document);
 }
 
 ParsingEnvironmentFilePointer DUChain::environmentFileForDocument(IndexedTopDUContext topContext) const {
    if(topContext.index() == 0)
      return ParsingEnvironmentFilePointer();
 
    return ParsingEnvironmentFilePointer(sdDUChainPrivate->loadInformation(topContext.index()));
 }
 
 TopDUContext* DUChain::chainForDocument( const IndexedString& document, const ParsingEnvironment* environment, bool proxyContext ) const {
 
   if(sdDUChainPrivate->m_destroyed)
     return nullptr;
   ParsingEnvironmentFilePointer envFile = environmentFileForDocument(document, environment, proxyContext);
   if(envFile) {
     return envFile->topContext();
   }else{
     return nullptr;
   }
 }
 
 QList<QUrl> DUChain::documents() const
 {
   QMutexLocker l(&sdDUChainPrivate->m_chainsMutex);
 
   QList<QUrl> ret;
   ret.reserve(sdDUChainPrivate->m_chainsByUrl.count());
   foreach(TopDUContext* top, sdDUChainPrivate->m_chainsByUrl) {
     ret << top->url().toUrl();
   }
 
   return ret;
 }
 
 QList<IndexedString> DUChain::indexedDocuments() const
 {
   QMutexLocker l(&sdDUChainPrivate->m_chainsMutex);
 
   QList<IndexedString> ret;
   ret.reserve(sdDUChainPrivate->m_chainsByUrl.count());
   foreach(TopDUContext* top, sdDUChainPrivate->m_chainsByUrl) {
     ret << top->url();
   }
 
   return ret;
 }
 
 void DUChain::documentActivated(KDevelop::IDocument* doc)
 {
   if(sdDUChainPrivate->m_destroyed)
     return;
 
   DUChainReadLocker lock( DUChain::lock() );
   QMutexLocker l(&sdDUChainPrivate->m_chainsMutex);
 
   auto backgroundParser = ICore::self()->languageController()->backgroundParser();
   auto addWithHighPriority = [backgroundParser, doc]() {
     backgroundParser->addDocument(IndexedString(doc->url()),
                                   TopDUContext::VisibleDeclarationsAndContexts,
                                   BackgroundParser::BestPriority);
   };
 
   TopDUContext* ctx = DUChainUtils::standardContextForUrl(doc->url(), true);
   //Check whether the document has an attached environment-manager, and whether that one thinks the document needs to be updated.
   //If yes, update it.
   if (ctx && ctx->parsingEnvironmentFile() && ctx->parsingEnvironmentFile()->needsUpdate()) {
     qCDebug(LANGUAGE) << "Document needs update, using best priority since it just got activated:" << doc->url();
     addWithHighPriority();
   } else if (backgroundParser->managedDocuments().contains(IndexedString(doc->url()))) {
     // increase priority if there's already parse job of this document in the queue
     qCDebug(LANGUAGE) << "Prioritizing activated document:" << doc->url();
     addWithHighPriority();
   }
 }
 
 void DUChain::documentClosed(IDocument* document)
 {
   if(sdDUChainPrivate->m_destroyed)
     return;
 
   IndexedString url(document->url());
 
   foreach(const ReferencedTopDUContext &top, sdDUChainPrivate->m_openDocumentContexts)
     if(top->url() == url)
       sdDUChainPrivate->m_openDocumentContexts.remove(top);
 }
 
 void DUChain::documentLoadedPrepare(KDevelop::IDocument* doc)
 {
   if(sdDUChainPrivate->m_destroyed)
     return;
 
   const IndexedString url(doc->url());
   DUChainWriteLocker lock( DUChain::lock() );
   QMutexLocker l(&sdDUChainPrivate->m_chainsMutex);
 
   TopDUContext* standardContext = DUChainUtils::standardContextForUrl(doc->url());
   QList<TopDUContext*> chains = chainsForDocument(url);
 
   auto languages = ICore::self()->languageController()->languagesForUrl(doc->url());
 
   if(standardContext) {
     Q_ASSERT(chains.contains(standardContext)); //We have just loaded it
     Q_ASSERT((standardContext->url() == url));
 
     sdDUChainPrivate->m_openDocumentContexts.insert(standardContext);
 
     bool needsUpdate = standardContext->parsingEnvironmentFile() && standardContext->parsingEnvironmentFile()->needsUpdate();
     if(!needsUpdate) {
 
         //Only apply the highlighting if we don't need to update, else we might highlight total crap
         //Do instant highlighting only if all imports are loaded, to make sure that we don't block the user-interface too long
         //Else the highlighting will be done in the background-thread
         //This is not exactly right, as the direct imports don't necessarily equal the real imports used by uses
         //but it approximates the correct behavior.
         bool allImportsLoaded = true;
         foreach(const DUContext::Import& import, standardContext->importedParentContexts())
           if(!import.indexedContext().indexedTopContext().isLoaded())
             allImportsLoaded = false;
 
         if(allImportsLoaded) {
           l.unlock();
           lock.unlock();
           foreach(const auto language, languages) {
             if(language->codeHighlighting()) {
               language->codeHighlighting()->highlightDUChain(standardContext);
             }
           }
           qCDebug(LANGUAGE) << "highlighted" << doc->url() << "in foreground";
           return;
         }
     }else{
       qCDebug(LANGUAGE) << "not highlighting the duchain because the documents needs an update";
     }
 
     if(needsUpdate || !(standardContext->features() & TopDUContext::AllDeclarationsContextsAndUses)) {
       ICore::self()->languageController()->backgroundParser()->addDocument(IndexedString(doc->url()), (TopDUContext::Features)(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdate));
       return;
     }
   }
 
   //Add for highlighting etc.
   ICore::self()->languageController()->backgroundParser()->addDocument(IndexedString(doc->url()), TopDUContext::AllDeclarationsContextsAndUses);
 }
 
 void DUChain::documentRenamed(KDevelop::IDocument* doc)
 {
   if(sdDUChainPrivate->m_destroyed)
     return;
 
   if(!doc->url().isValid()) {
     ///Maybe this happens when a file was deleted?
     qCWarning(LANGUAGE) << "Strange, url of renamed document is invalid!";
   }else{
     ICore::self()->languageController()->backgroundParser()->addDocument(IndexedString(doc->url()), (TopDUContext::Features)(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdate));
   }
 }
 
 Uses* DUChain::uses()
 {
   return &sdDUChainPrivate->m_uses;
 }
 
 Definitions* DUChain::definitions()
 {
   return &sdDUChainPrivate->m_definitions;
 }
 
 static void finalCleanup()
 {
   DUChainWriteLocker writeLock(DUChain::lock());
   qCDebug(LANGUAGE) << "doing final cleanup";
 
   int cleaned = 0;
   while((cleaned = globalItemRepositoryRegistry().finalCleanup())) {
     qCDebug(LANGUAGE) << "cleaned" << cleaned << "B";
     if(cleaned < 1000) {
       qCDebug(LANGUAGE) << "cleaned enough";
       break;
     }
   }
   qCDebug(LANGUAGE) << "final cleanup ready";
 }
 
 void DUChain::shutdown()
 {
   // if core is not shutting down, we can end up in deadlocks or crashes
   // since language plugins might still try to access static duchain stuff
   Q_ASSERT(!ICore::self() || ICore::self()->shuttingDown());
 
   qCDebug(LANGUAGE) << "Cleaning up and shutting down DUChain";
 
   QMutexLocker lock(&sdDUChainPrivate->cleanupMutex());
 
   {
     //Acquire write-lock of the repository, so when kdevelop crashes in that process, the repository is discarded
     //Crashes here may happen in an inconsistent state, thus this makes sense, to protect the user from more crashes
     globalItemRepositoryRegistry().lockForWriting();
     sdDUChainPrivate->cleanupTopContexts();
     globalItemRepositoryRegistry().unlockForWriting();
   }
 
   sdDUChainPrivate->doMoreCleanup(); //Must be done _before_ finalCleanup, else we may be deleting yet needed data
 
   sdDUChainPrivate->m_openDocumentContexts.clear();
   sdDUChainPrivate->m_destroyed = true;
   sdDUChainPrivate->clear();
 
   {
     //Acquire write-lock of the repository, so when kdevelop crashes in that process, the repository is discarded
     //Crashes here may happen in an inconsistent state, thus this makes sense, to protect the user from more crashes
     globalItemRepositoryRegistry().lockForWriting();
     finalCleanup();
     globalItemRepositoryRegistry().unlockForWriting();
   }
 
   globalItemRepositoryRegistry().shutdown();
 }
 
 uint DUChain::newTopContextIndex() {
   {
     QMutexLocker lock(&sdDUChainPrivate->m_chainsMutex);
     if(!sdDUChainPrivate->m_availableTopContextIndices.isEmpty())
     {
       uint ret = sdDUChainPrivate->m_availableTopContextIndices.back();
       sdDUChainPrivate->m_availableTopContextIndices.pop_back();
       if(TopDUContextDynamicData::fileExists(ret))
       {
         qCWarning(LANGUAGE) << "Problem in the management of availalbe top-context indices";
         return newTopContextIndex();
       }
       return ret;
     }
   }
   static QAtomicInt& currentId( globalItemRepositoryRegistry().getCustomCounter(QStringLiteral("Top-Context Counter"), 1) );
   return currentId.fetchAndAddRelaxed(1);
 }
 
 void DUChain::refCountUp(TopDUContext* top) {
   QMutexLocker l(&sdDUChainPrivate->m_referenceCountsMutex);
   // note: value is default-constructed to zero if it does not exist
   ++sdDUChainPrivate->m_referenceCounts[top];
 }
 
 bool DUChain::deleted() {
   return m_deleted;
 }
 
 void DUChain::refCountDown(TopDUContext* top) {
   QMutexLocker l(&sdDUChainPrivate->m_referenceCountsMutex);
   auto it = sdDUChainPrivate->m_referenceCounts.find(top);
   if (it == sdDUChainPrivate->m_referenceCounts.end()) {
     //qCWarning(LANGUAGE) << "tried to decrease reference-count for" << top->url().str() << "but this top-context is not referenced";
     return;
   }
   auto& refCount = *it;
   --refCount;
   if (!refCount) {
     sdDUChainPrivate->m_referenceCounts.erase(it);
   }
 }
 
 void DUChain::emitDeclarationSelected(const DeclarationPointer& decl)
 {
   if(sdDUChainPrivate->m_destroyed)
     return;
 
   emit declarationSelected(decl);
 }
 
 void DUChain::emitUpdateReady(const IndexedString& url, const ReferencedTopDUContext& topContext)
 {
   if(sdDUChainPrivate->m_destroyed)
     return;
 
   emit updateReady(url, topContext);
 }
 
 KDevelop::ReferencedTopDUContext DUChain::waitForUpdate(const KDevelop::IndexedString& document, KDevelop::TopDUContext::Features minFeatures, bool proxyContext) {
   Q_ASSERT(!lock()->currentThreadHasReadLock() && !lock()->currentThreadHasWriteLock());
 
   WaitForUpdate waiter;
   updateContextForUrl(document, minFeatures, &waiter);
 
   while(!waiter.m_ready) {
     // we might have been shut down in the meanwhile
     if (!ICore::self()) {
       return nullptr;
     }
 
     QMetaObject::invokeMethod(ICore::self()->languageController()->backgroundParser(), "parseDocuments");
     QApplication::processEvents();
     QThread::usleep(1000);
   }
 
   if(!proxyContext) {
     DUChainReadLocker readLock(DUChain::lock());
     return DUChainUtils::contentContextFromProxyContext(waiter.m_topContext);
   }
 
   return waiter.m_topContext;
 }
 
 void DUChain::updateContextForUrl(const IndexedString& document, TopDUContext::Features minFeatures, QObject* notifyReady, int priority) const {
   DUChainReadLocker lock( DUChain::lock() );
   TopDUContext* standardContext = DUChainUtils::standardContextForUrl(document.toUrl());
   if(standardContext && standardContext->parsingEnvironmentFile() && !standardContext->parsingEnvironmentFile()->needsUpdate() && standardContext->parsingEnvironmentFile()->featuresSatisfied(minFeatures)) {
     lock.unlock();
     if(notifyReady)
     QMetaObject::invokeMethod(notifyReady, "updateReady", Qt::DirectConnection, Q_ARG(KDevelop::IndexedString, document), Q_ARG(KDevelop::ReferencedTopDUContext, ReferencedTopDUContext(standardContext)));
   }else{
     ///Start a parse-job for the given document
     ICore::self()->languageController()->backgroundParser()->addDocument(document, minFeatures, priority, notifyReady);
   }
 }
 
 void DUChain::disablePersistentStorage(bool disable) {
   sdDUChainPrivate->m_cleanupDisabled = disable;
 }
 
 void DUChain::storeToDisk() {
   bool wasDisabled = sdDUChainPrivate->m_cleanupDisabled;
   sdDUChainPrivate->m_cleanupDisabled = false;
 
   sdDUChainPrivate->doMoreCleanup();
 
   sdDUChainPrivate->m_cleanupDisabled = wasDisabled;
 }
 
 bool DUChain::compareToDisk() {
 
   DUChainWriteLocker writeLock(DUChain::lock());
 
   ///Step 1: Compare the repositories
   return true;
 }
 
 }
 
diff --git a/kdevplatform/language/duchain/duchain.h b/kdevplatform/language/duchain/duchain.h
index 8393b05c20..1004a6a8dc 100644
--- a/kdevplatform/language/duchain/duchain.h
+++ b/kdevplatform/language/duchain/duchain.h
@@ -1,315 +1,319 @@
 /* This file is part of KDevelop
     Copyright 2006-2008 Hamish Rodda <rodda@kde.org>
     Copyright 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KDEVPLATFORM_DUCHAIN_H
 #define KDEVPLATFORM_DUCHAIN_H
 
 #include <QObject>
 
 #include "topducontext.h"
 #include "parsingenvironment.h"
 
+#include <interfaces/isessionlock.h>
+
 class QUrl;
 
 namespace KDevelop
 {
 
 class IDocument;
 class TopDUContext;
 class DUChainLock;
 
 class ParsingEnvironmentManager;
 class ParsingEnvironment;
 class ParsingEnvironmentFile;
 typedef QExplicitlySharedDataPointer<ParsingEnvironmentFile> ParsingEnvironmentFilePointer;
 class Definitions;
 class Uses;
 
 /**
  * \short Holds references to all top level source file contexts.
  *
  * The DUChain is a global static class which manages the definition-use
  * chains.  It performs the following functions:
  * \li registers chains with addDocumentChain() and deregisters with removeDocumentChain()
  * \li allows querying for existing chains
  * \li watches text editors, registering and deregistering them with the BackgroundParser when files
  *     are opened and closed.
  */
 class KDEVPLATFORMLANGUAGE_EXPORT DUChain : public QObject
 {
   Q_OBJECT
 
 public:
   /**
    * Initializes common static item repositories.
    * Must be called once for multi threaded applications to work reliably.
    */
   static void initialize();
 
   /**
    * Return a list of all chains available
    */
   QList<TopDUContext*> allChains() const;
 
   /**
    * Makes sure the standard-context for the given url is up-to-date.
    * This may trigger a parsing in background, so a QObject can be given that will be notified
    * asyonchronously once the update is ready.
    * If the context is already up to date, the given QObject is notified directly.
    *
    * @param document Document to update
    * @param minFeatures The requested features. If you want to force a full update of the context, give TopDUContext::ForceUpdate.
    *                 If you want to force an update including all imports, use TopDUContext::ForceUpdateRecursive.
    * @param notifyReady An optional pointer to a QObject that should contain a slot
    *                    "void updateReady(KDevelop::IndexedString url, KDevelop::ReferencedTopDUContext topContext)".
    *                    The notification is guaranteed to be called once for each call to updateContextForUrl. The given top-context
    *                    may be invalid if the update failed. A queued connection is used if a re-parse has to be done. The duchain
    *                    will _not_ be locked when updateReady is called.
    * @param priority An optional priority for the job. The lower the value, the higher it's priority.
    * @note The duchain must _not_ be locked when this is called!
    */
    void updateContextForUrl(const IndexedString& document, TopDUContext::Features minFeatures, QObject* notifyReady = nullptr, int priority = 1) const;
   
    /**
     * Convenience-function similar to updateContextForUrl that blocks this thread until the update of the given document is ready,
     * and returns the top-context.
     * @param document The document to update
     * @param minFeatures The requested features. If you want to force a full update of the context, give TopDUContext::ForceUpdate.
     *                 If you want to force an update including all imports, use TopDUContext::ForceUpdateRecursive.
     * @return The up-to-date top-context, or zero if the update failed
     *
     * @note The duchain must _not_ be locked when this is called!
     *
     */
    KDevelop::ReferencedTopDUContext waitForUpdate(const KDevelop::IndexedString& document, KDevelop::TopDUContext::Features minFeatures, bool proxyContext = false);
    
   /**
    * Return any chain for the given document
    * If available, the version accepting IndexedString should be used instead of this, for performance reasons.
    * When no fitting chain is in memory, one may be loaded from disk.
    *
    * @note The duchain must be at least read-locked locked when this is called!
    * */
   TopDUContext* chainForDocument(const QUrl& document, bool proxyContext = false) const;
   TopDUContext* chainForDocument(const IndexedString& document, bool proxyContext = false) const;
 
   /**
    * Return all chains for the given document that are currently in memory.
    * This does not load any chains from disk.
    * */
   QList<TopDUContext*> chainsForDocument(const QUrl& document) const;
 
   /**
    * Return all chains for the given document that are currently in memory.
    * This does not load any chains from disk.
    * Should be preferred over the QUrl version.
    * */
   QList<TopDUContext*> chainsForDocument(const IndexedString& document) const;
 
   /**
    * Find a chain that fits into the given environment. If no fitting chain is found, 0 is returned.
    * When no fitting chain is in memory, one may be loaded from disk.
    * @param proxyContext If this is true, only contexts are found that have an ParsingEnvironmentFile that has the proxy-flag set. Else, only content-contexts will be returned.
    *
    * @note The duchain must be at least read-locked locked when this is called!
    * */
   TopDUContext* chainForDocument(const QUrl& document, const ParsingEnvironment* environment, bool proxyContext = false) const;
 
   /**
    * Find a chain that fits into the given environment. If no fitting chain is found, 0 is returned.
    * When no fitting chain is in memory, one may be loaded from disk.
    * @param proxyContext If this is true, only contexts are found that have an ParsingEnvironmentFile that has the proxy-flag set. Else, only content-contexts will be returned.
    *
    * Prefer this over the QUrl version.
    *
    * @note The duchain must be at least read-locked locked when this is called!
    * */
   TopDUContext* chainForDocument(const IndexedString& document, const ParsingEnvironment* environment, bool proxyContext = false) const;
 
   /**
    * Find the environment-file of a chain that fits into the given environment. If no fitting chain is found, 0 is returned.
    * When no fitting chain is in memory, one may be loaded from disk.
    *
    * This should be preferred over chainForDocument when only the environment-info is needed, because the TopDUContext is not loaded in this function.
    * 
    ** @param proxyContext If this is true, only contexts are found that have an ParsingEnvironmentFile that has the proxy-flag set. Else, only content-contexts will be returned.
    *
    * Prefer this over the QUrl version.
    *
    * @note The duchain must be at least read-locked locked when this is called!
    * */
   ParsingEnvironmentFilePointer environmentFileForDocument(const IndexedString& document, const ParsingEnvironment* environment, bool proxyContext = false) const;
 
   ParsingEnvironmentFilePointer environmentFileForDocument(IndexedTopDUContext topContext) const;
   
   /**
    * Returns the list of the environment-infos of all versions of the given document.
    */
   QList<ParsingEnvironmentFilePointer> allEnvironmentFiles(const IndexedString& document);
   
   ///Returns the top-context that has the given index assigned, or zero if it doesn't exist. @see TopDUContext::ownIndex
   ///The duchain must be read-locked when this is called
   ///This function is inlined because it is called in a very high frequency
   inline TopDUContext* chainForIndex(uint index)
   {
     if(m_deleted)
       return nullptr;
 
     {
       QMutexLocker lock(&chainsByIndexLock);
 
       if(chainsByIndex.size() > index)
       {
         TopDUContext* top = chainsByIndex[index];
         if(top)
           return top;
       }
     }
     
     //Load the top-context
     return loadChain(index);
   }
 
   ///Returns the url for the given top-context index if available. This does have some cost, so avoid it when possible.
   IndexedString urlForIndex(uint index) const;
   
   /// Only used for debugging at the moment
   QList<QUrl> documents() const;
 
   /// Only used for debugging at the moment
   /// Prefer that over the QUrl version for performance reasons
   QList<IndexedString> indexedDocuments() const;
 
   /**
    * Registers a new definition-use \a chain for the given \a document.
    */
   void addDocumentChain(TopDUContext* chain);
 
   /// Returns true if the global duchain instance has already been deleted
   static bool deleted();
   
   /// Returns the global static instance.
   static DUChain* self();
 
   /// Returns the structure that manages mapping between definitions and declarations
   static Definitions* definitions();
 
   /// Returns the structure that manages mapping between declarations, and which top level contexts contain uses of them.
   static Uses* uses();
 
+  static QString repositoryPathForSession(const KDevelop::ISessionLock::Ptr& session);
+
   /**
    * Retrieve the read write lock for the entire definition-use chain.
    * To call non-const methods, you must be holding a write lock.
    *
    * Evaluations made prior to holding a lock (including which objects
    * exist) must be verified once the lock is held, as they may have changed
    * or been deleted.
    *
    * \threadsafe
    */
   static DUChainLock* lock();
 
   /// Returns whether the top-context with the given index is currently loaded in memory
   bool isInMemory(uint topContextIndex) const;
   
   /**
    * Changes the environment attached to the given top-level context, and updates the management-structures to reflect that
    * */
   void updateContextEnvironment( TopDUContext* context, ParsingEnvironmentFile* file );
 
   ///Allocates a new identity for a new top-context, no lock needed. The returned value is never zero
   static uint newTopContextIndex();
   
   ///If you call this, the persistent disk-storage structure will stay unaffected, and no duchain cleanup will be done.
   ///Call this from within tests.
   void disablePersistentStorage(bool disable = true);
   
   ///Stores the whole duchain and all its repositories in the current state to disk
   ///The duchain must not be locked in any way
   void storeToDisk();
   
   ///Compares the whole duchain and all its repositories in the current state to disk
   ///When the comparison fails, debug-output will show why
   ///The duchain must not be locked when calling this
   ///@return true If the current memory state equals the disk state, else false
   bool compareToDisk();
 
 Q_SIGNALS:
   ///Is emitted when the declaration has been selected somewhere in the user-interface, for example in the completion-list
   void declarationSelected(const KDevelop::DeclarationPointer& decl);
 
   /**
    * This signal is emitted whenever the DUChain data associated with @p url was updated.
    *
    * You can connect to this signal to get notified when the DUChain for a given file was updated.
    */
   void updateReady(const KDevelop::IndexedString& url, const KDevelop::ReferencedTopDUContext& topContext);
 
 public Q_SLOTS:
   ///Removes the given top-context from the duchain, and deletes it.
   void removeDocumentChain(KDevelop::TopDUContext* document);
   ///Emits the declarationSelected signal, so other parties can notice it.
   void emitDeclarationSelected(const KDevelop::DeclarationPointer& decl);
 
   /**
    * Call this after you have modified the DUChain data associated with the file @p url.
    *
    * This triggers an emit of the @c updateReady signal.
    */
   void emitUpdateReady(const KDevelop::IndexedString& url, const KDevelop::ReferencedTopDUContext& topContext);
 
   /**
    * Shutdown and cleanup the DUChain.
    */
   void shutdown();
 
 private Q_SLOTS:
   void documentActivated(KDevelop::IDocument* doc);
   void documentLoadedPrepare(KDevelop::IDocument* document);
   void documentRenamed(KDevelop::IDocument* document);
   void documentClosed(KDevelop::IDocument*);
 
 private:
   TopDUContext* loadChain(uint index);
   //These two are exported here so that the extremely frequently called chainForIndex(..) can be inlined
   static bool m_deleted;
   static std::vector<TopDUContext*> chainsByIndex;
   static QMutex chainsByIndexLock;
   
   /// Increases the reference-count for the given top-context. The result: It will not be unloaded.
   /// Do this to prevent KDevelop from unloading a top-context that you plan to use. Don't forget calling unReferenceToContext again,
   /// else the top-context will stay in memory for ever.
   void refCountUp(TopDUContext* top);
 
   /// Decreases the reference-count for the given top-context. When it reaches zero, KDevelop is free to unload it at any time,
   /// also invalidating all the contained declarations and contexts.
   void refCountDown(TopDUContext* top);
   
   void addToEnvironmentManager( TopDUContext * chain );
   void removeFromEnvironmentManager( TopDUContext * chain );
   DUChain();
   ~DUChain() override;
 
   friend class DUChainPrivate;
   friend class ReferencedTopDUContext;
 };
 
 }
 
 #endif // KDEVPLATFORM_DUCHAIN_H
diff --git a/kdevplatform/serialization/CMakeLists.txt b/kdevplatform/serialization/CMakeLists.txt
index 83d6319021..2d52259c7b 100644
--- a/kdevplatform/serialization/CMakeLists.txt
+++ b/kdevplatform/serialization/CMakeLists.txt
@@ -1,37 +1,35 @@
 add_definitions(-DTRANSLATION_DOMAIN=\"kdevplatform\")
 
 set(KDevPlatformSerialization_LIB_SRCS
     abstractitemrepository.cpp
     indexedstring.cpp
     itemrepositoryregistry.cpp
     referencecounting.cpp
 )
 
 ecm_qt_declare_logging_category(KDevPlatformSerialization_LIB_SRCS
     HEADER debug.h
     IDENTIFIER SERIALIZATION
     CATEGORY_NAME "kdevplatform.serialization"
 )
 
 kdevplatform_add_library(KDevPlatformSerialization SOURCES ${KDevPlatformSerialization_LIB_SRCS})
 target_link_libraries(KDevPlatformSerialization
-LINK_PUBLIC
-    KDev::Interfaces
 LINK_PRIVATE
     KDev::Util
 )
 
 install(FILES
     abstractitemrepository.h
     referencecounting.h
     indexedstring.h
     itemrepositoryexampleitem.h
     itemrepository.h
     itemrepositoryregistry.h
     repositorymanager.h
     DESTINATION ${KDE_INSTALL_INCLUDEDIR}/kdevplatform/serialization COMPONENT Devel
 )
 
 if(BUILD_TESTING)
     add_subdirectory(tests)
 endif()
diff --git a/kdevplatform/serialization/itemrepositoryregistry.cpp b/kdevplatform/serialization/itemrepositoryregistry.cpp
index cf66b880d9..f37350acd3 100644
--- a/kdevplatform/serialization/itemrepositoryregistry.cpp
+++ b/kdevplatform/serialization/itemrepositoryregistry.cpp
@@ -1,412 +1,401 @@
 /*
    Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "itemrepositoryregistry.h"
 
 #include <QDir>
 #include <QProcessEnvironment>
 #include <QCoreApplication>
 #include <QDataStream>
 #include <QStandardPaths>
 
 #include <KLocalizedString>
 
 #include <util/shellutils.h>
 
 #include "abstractitemrepository.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 namespace {
 
 //If KDevelop crashed this many times consicutively, clean up the repository
 const int crashesBeforeCleanup = 1;
 
 void setCrashCounter(QFile& crashesFile, int count)
 {
   crashesFile.close();
   crashesFile.open(QIODevice::WriteOnly | QIODevice::Truncate);
   QDataStream writeStream(&crashesFile);
   writeStream << count;
 }
 
-QString repositoryPathForSession(const KDevelop::ISessionLock::Ptr& session)
-{
-  QString cacheDir = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation);
-  cacheDir += QStringLiteral("/kdevduchain");
-  QString baseDir = QProcessEnvironment::systemEnvironment().value(QStringLiteral("KDEV_DUCHAIN_DIR"), cacheDir);
-  baseDir += QStringLiteral("/%1-%2").arg(qApp->applicationName(), session->id());
-  return baseDir;
-}
-
 bool shouldClear(const QString& path)
 {
   QDir dir(path);
 
   if (!dir.exists()) {
     return false;
   }
 
   if (getenv("CLEAR_DUCHAIN_DIR")) {
     qCDebug(SERIALIZATION) << "clearing duchain directory because CLEAR_DUCHAIN_DIR is set";
     return true;
   }
 
   if (dir.exists(QStringLiteral("is_writing"))) {
     qCWarning(SERIALIZATION) << "repository" << path << "was write-locked, it probably is inconsistent";
     return true;
   }
 
   if (!dir.exists(QStringLiteral("version_%1").arg(staticItemRepositoryVersion()))) {
     qCWarning(SERIALIZATION) << "version mismatch or no version hint; expected version:" << staticItemRepositoryVersion();
     return true;
   }
 
   QFile crashesFile(dir.filePath(QStringLiteral("crash_counter")));
   if (crashesFile.open(QIODevice::ReadOnly)) {
     int count;
     QDataStream stream(&crashesFile);
     stream >> count;
 
     qCDebug(SERIALIZATION) << "current count of crashes: " << count;
 
     if (count >= crashesBeforeCleanup && !getenv("DONT_CLEAR_DUCHAIN_DIR")) {
       bool userAnswer = askUser(i18np("The previous session crashed", "Session crashed %1 times in a row", count),
                                 i18nc("@action", "Clear cache"),
                                 i18nc("@title", "Session crashed"),
                                 i18n("The crash may be caused by a corruption of cached data.\n\n"
                                       "Press Clear if you want KDevelop to clear the cache, otherwise press Continue if you are sure the crash has another origin."),
                                 i18nc("@action", "Clear Cache"),
                                 i18n("Continue"));
       if (userAnswer) {
         qCDebug(SERIALIZATION) << "User chose to clean repository";
         return true;
       } else {
         setCrashCounter(crashesFile, 1);
         qCDebug(SERIALIZATION) << "User chose to reset crash counter";
       }
     } else {
       ///Increase the crash-count. It will be reset if kdevelop is shut down cleanly.
       setCrashCounter(crashesFile, ++count);
     }
   } else {
     setCrashCounter(crashesFile, 1);
   }
 
   return false;
 }
 
 }
 
 namespace KDevelop {
 
 class ItemRepositoryRegistryPrivate
 {
 public:
   ItemRepositoryRegistry* m_owner;
   bool m_shallDelete;
   QString m_path;
-  ISessionLock::Ptr m_sessionLock;
   QMap<AbstractItemRepository*, AbstractRepositoryManager*> m_repositories;
   QMap<QString, QAtomicInt*> m_customCounters;
   mutable QMutex m_mutex;
 
   explicit ItemRepositoryRegistryPrivate(ItemRepositoryRegistry* owner)
   : m_owner(owner)
   , m_shallDelete(false)
   , m_mutex(QMutex::Recursive)
   {
   }
 
   void lockForWriting();
   void unlockForWriting();
   void deleteDataDirectory(const QString& path, bool recreate = true);
 
   /// @param path  A shared directory-path that the item-repositories are to be loaded from.
   /// @returns     Whether the repository registry has been opened successfully.
   ///              If @c false, then all registered repositories should have been deleted.
   /// @note        Currently the given path must reference a hidden directory, just to make sure we're
   ///              not accidentally deleting something important.
   bool open(const QString& path);
 
   /// Close all contained repositories.
   /// @warning The current state is not stored to disk.
   void close();
 };
 
 //The global item-reposity registry
 ItemRepositoryRegistry* ItemRepositoryRegistry::m_self = nullptr;
 
-ItemRepositoryRegistry::ItemRepositoryRegistry(const ISessionLock::Ptr& session)
+ItemRepositoryRegistry::ItemRepositoryRegistry(const QString& repositoryPath)
 : d(new ItemRepositoryRegistryPrivate(this))
 {
-  Q_ASSERT(session);
-  d->open(repositoryPathForSession(session));
+  Q_ASSERT(!repositoryPath.isEmpty());
+  d->open(repositoryPath);
 }
 
-void ItemRepositoryRegistry::initialize(const ISessionLock::Ptr& session)
+void ItemRepositoryRegistry::initialize(const QString& repositoryPath)
 {
   if (!m_self) {
     ///We intentionally leak the registry, to prevent problems in the destruction order, where
     ///the actual repositories might get deleted later than the repository registry.
-    m_self = new ItemRepositoryRegistry(session);
+    m_self = new ItemRepositoryRegistry(repositoryPath);
   }
 }
 
 ItemRepositoryRegistry* ItemRepositoryRegistry::self()
 {
   Q_ASSERT(m_self);
   return m_self;
 }
 
-void ItemRepositoryRegistry::deleteRepositoryFromDisk(const ISessionLock::Ptr& session)
+void ItemRepositoryRegistry::deleteRepositoryFromDisk(const QString& repositoryPath)
 {
   // Now, as we have only the global item-repository registry, assume that if and only if
   // the given session is ours, its cache path is used by the said global item-repository registry.
-  const QString repositoryPath = repositoryPathForSession(session);
   if(m_self && m_self->d->m_path == repositoryPath) {
     // remove later
     m_self->d->m_shallDelete = true;
   } else {
     // Otherwise, given session is not ours.
     // remove its item-repository directory directly.
     QDir(repositoryPath).removeRecursively();
   }
 }
 
 QMutex& ItemRepositoryRegistry::mutex()
 {
   return d->m_mutex;
 }
 
 QAtomicInt& ItemRepositoryRegistry::getCustomCounter(const QString& identity, int initialValue)
 {
   if(!d->m_customCounters.contains(identity))
     d->m_customCounters.insert(identity, new QAtomicInt(initialValue));
   return *d->m_customCounters[identity];
 }
 
 ///The global item-repository registry that is used by default
 ItemRepositoryRegistry& globalItemRepositoryRegistry()
 {
   return *ItemRepositoryRegistry::self();
 }
 
 void ItemRepositoryRegistry::registerRepository(AbstractItemRepository* repository, AbstractRepositoryManager* manager)
 {
   QMutexLocker lock(&d->m_mutex);
   d->m_repositories.insert(repository, manager);
   if(!d->m_path.isEmpty()) {
     if(!repository->open(d->m_path)) {
       d->deleteDataDirectory(d->m_path);
       qCritical() << "failed to open a repository";
       abort();
     }
   }
 }
 
 QString ItemRepositoryRegistry::path() const
 {
   //We cannot lock the mutex here, since this may be called with one of the repositories locked,
   //and that may lead to a deadlock when at the same time a storing is requested
   return d->m_path;
 }
 
 void ItemRepositoryRegistryPrivate::lockForWriting()
 {
   QMutexLocker lock(&m_mutex);
   //Create is_writing
   QFile f(m_path + QLatin1String("/is_writing"));
   f.open(QIODevice::WriteOnly);
   f.close();
 }
 
 void ItemRepositoryRegistry::lockForWriting()
 {
   d->lockForWriting();
 }
 
 void ItemRepositoryRegistryPrivate::unlockForWriting()
 {
   QMutexLocker lock(&m_mutex);
   //Delete is_writing
   QFile::remove(m_path + QLatin1String("/is_writing"));
 }
 
 void ItemRepositoryRegistry::unlockForWriting()
 {
   d->unlockForWriting();
 }
 
 void ItemRepositoryRegistry::unRegisterRepository(AbstractItemRepository* repository)
 {
   QMutexLocker lock(&d->m_mutex);
   Q_ASSERT(d->m_repositories.contains(repository));
   repository->close();
   d->m_repositories.remove(repository);
 }
 
 //After calling this, the data-directory may be a new one
 void ItemRepositoryRegistryPrivate::deleteDataDirectory(const QString& path, bool recreate)
 {
   QMutexLocker lock(&m_mutex);
 
   //lockForWriting creates a file, that prevents any other KDevelop instance from using the directory as it is.
   //Instead, the other instance will try to delete the directory as well.
   lockForWriting();
 
   bool result = QDir(path).removeRecursively();
   Q_ASSERT(result);
   Q_UNUSED(result);
   // Just recreate the directory then; leave old path (as it is dependent on appname and session only).
   if(recreate) {
     QDir().mkpath(path);
   }
 }
 
 bool ItemRepositoryRegistryPrivate::open(const QString& path)
 {
   QMutexLocker mlock(&m_mutex);
   if(m_path == path) {
     return true;
   }
 
   // Check if the repository shall be cleared
   if (shouldClear(path)) {
     qCWarning(SERIALIZATION) << QStringLiteral("The data-repository at %1 has to be cleared.").arg(path);
     deleteDataDirectory(path);
   }
 
   QDir().mkpath(path);
 
   foreach(AbstractItemRepository* repository, m_repositories.keys()) {
     if(!repository->open(path)) {
       deleteDataDirectory(path);
       qCritical() << "failed to open a repository";
       abort();
     }
   }
 
   QFile f(path + QLatin1String("/Counters"));
   if(f.open(QIODevice::ReadOnly)) {
     QDataStream stream(&f);
 
     while(!stream.atEnd()) {
       //Read in all custom counter values
       QString counterName;
       stream >> counterName;
       int counterValue;
       stream >> counterValue;
       m_owner->getCustomCounter(counterName, 0) = counterValue;
     }
   }
 
   m_path = path;
 
   return true;
 }
 
 void ItemRepositoryRegistry::store()
 {
   QMutexLocker lock(&d->m_mutex);
   foreach(AbstractItemRepository* repository, d->m_repositories.keys()) {
     repository->store();
   }
 
   QFile versionFile(d->m_path + QStringLiteral("/version_%1").arg(staticItemRepositoryVersion()));
   if(versionFile.open(QIODevice::WriteOnly)) {
     versionFile.close();
   } else {
     qCWarning(SERIALIZATION) << "Could not open version file for writing";
   }
 
   //Store all custom counter values
   QFile f(d->m_path + QLatin1String("/Counters"));
   if(f.open(QIODevice::WriteOnly)) {
     f.resize(0);
     QDataStream stream(&f);
     for(QMap<QString, QAtomicInt*>::const_iterator it = d->m_customCounters.constBegin();
         it != d->m_customCounters.constEnd();
         ++it) {
       stream << it.key();
       stream << it.value()->fetchAndAddRelaxed(0);
     }
   } else {
     qCWarning(SERIALIZATION) << "Could not open counter file for writing";
   }
 }
 
 void ItemRepositoryRegistry::printAllStatistics() const
 {
   QMutexLocker lock(&d->m_mutex);
   foreach(AbstractItemRepository* repository, d->m_repositories.keys()) {
     qCDebug(SERIALIZATION) << "statistics in" << repository->repositoryName() << ":";
     qCDebug(SERIALIZATION) << repository->printStatistics();
   }
 }
 
 int ItemRepositoryRegistry::finalCleanup()
 {
   QMutexLocker lock(&d->m_mutex);
   int changed = false;
   foreach(AbstractItemRepository* repository, d->m_repositories.keys()) {
     int added = repository->finalCleanup();
     changed += added;
     qCDebug(SERIALIZATION) << "cleaned in" << repository->repositoryName() << ":" << added;
   }
   return changed;
 }
 
 void ItemRepositoryRegistryPrivate::close()
 {
   QMutexLocker lock(&m_mutex);
 
   foreach(AbstractItemRepository* repository, m_repositories.keys()) {
     repository->close();
   }
 
   m_path.clear();
 }
 
 ItemRepositoryRegistry::~ItemRepositoryRegistry()
 {
   QMutexLocker lock(&d->m_mutex);
   d->close();
   foreach(QAtomicInt * counter, d->m_customCounters) {
     delete counter;
   }
 }
 
 void ItemRepositoryRegistry::shutdown()
 {
   QMutexLocker lock(&d->m_mutex);
   QString path = d->m_path;
 
   // FIXME: we don't close since this can trigger crashes at shutdown
   //        since some items are still referenced, e.g. in static variables
 //   d->close();
 
   if(d->m_shallDelete) {
     d->deleteDataDirectory(path, false);
   } else {
     QFile::remove(path + QLatin1String("/crash_counter"));
   }
 }
 
 }
diff --git a/kdevplatform/serialization/itemrepositoryregistry.h b/kdevplatform/serialization/itemrepositoryregistry.h
index 66b10bc007..4997ed5fc4 100644
--- a/kdevplatform/serialization/itemrepositoryregistry.h
+++ b/kdevplatform/serialization/itemrepositoryregistry.h
@@ -1,112 +1,112 @@
 /*
    Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef ITEMREPOSITORYREGISTRY_H
 #define ITEMREPOSITORYREGISTRY_H
 
 #include "serializationexport.h"
 
-#include <interfaces/isessionlock.h>
+#include <QScopedPointer>
 
 class QString;
 class QMutex;
 class QAtomicInt;
 
 namespace KDevelop {
 
 class ISession;
 class AbstractRepositoryManager;
 class AbstractItemRepository;
 
 /**
  * Manages a set of item-repositores and allows loading/storing them all at once from/to disk.
  * Does not automatically store contained repositories on destruction.
  * For the global registry, the storing is triggered from within duchain, so you don't need to care about it.
  */
 class KDEVPLATFORMSERIALIZATION_EXPORT ItemRepositoryRegistry {
   public:
     ~ItemRepositoryRegistry();
 
     /**
      * Initialize the global item-repository registry for the given @p session.
      */
-    static void initialize(const ISessionLock::Ptr& session);
+    static void initialize(const QString& repositoryPath);
 
     /// @returns The global item-repository registry.
     static ItemRepositoryRegistry* self();
 
     /// Deletes the item-repository of a specified session; or, if it is currently used, marks it for deletion at exit.
-    static void deleteRepositoryFromDisk(const ISessionLock::Ptr& sessionLock);
+    static void deleteRepositoryFromDisk(const QString& repositoryPath);
 
     /// Add a new repository.
     /// It will automatically be opened with the current path, if one is set.
     void registerRepository(AbstractItemRepository* repository, AbstractRepositoryManager* manager);
 
     /// Remove a repository.
     /// It will automatically be closed (if it was open).
     void unRegisterRepository(AbstractItemRepository* repository);
 
     /// @returns The path to item-repositories.
     QString path() const;
 
     /// Stores all repositories to disk, eventually unloading unused data to save memory.
     /// @note Should be called on a regular basis.
     void store();
 
     /// Indicates that the application has been closed gracefully.
     /// @note Must be called somewhere at the end of the shutdown sequence.
     void shutdown();
 
     /// Does a big cleanup, removing all non-persistent items in the repositories.
     /// @returns Count of bytes of data that have been removed.
     int finalCleanup();
 
     /// Prints the statistics of all registered item-repositories to the command line using qDebug().
     void printAllStatistics() const;
 
     /// Marks the directory as inconsistent, so it will be discarded
     /// on next startup if the application crashes during the write process.
     void lockForWriting();
 
     /// Removes the inconsistency mark set by @ref lockForWriting().
     void unlockForWriting();
 
     /// Returns a custom counter persistently stored as part of item-repositories in the
     /// same directory, possibly creating it.
     /// @param identity     The string used to identify a counter.
     /// @param initialValue Value to initialize a previously inexistent counter with.
     QAtomicInt& getCustomCounter(const QString& identity, int initialValue);
 
     /// @returns The global item-repository mutex.
     /// @note    Can be used to protect the initialization.
     QMutex& mutex();
 
   private:
-    explicit ItemRepositoryRegistry(const ISessionLock::Ptr& session);
+    explicit ItemRepositoryRegistry(const QString& repositoryPath);
 
     const QScopedPointer<class ItemRepositoryRegistryPrivate> d;
 
     static ItemRepositoryRegistry* m_self;
 };
 
 /// @returns The global item-repository registry (now it is @ref ItemRepositoryRegistry::self()).
 KDEVPLATFORMSERIALIZATION_EXPORT ItemRepositoryRegistry& globalItemRepositoryRegistry();
 
 }
 
 #endif // ITEMREPOSITORYREGISTRY_H
diff --git a/kdevplatform/serialization/tests/test_itemrepository.cpp b/kdevplatform/serialization/tests/test_itemrepository.cpp
index f2ba120ed6..377bc54894 100644
--- a/kdevplatform/serialization/tests/test_itemrepository.cpp
+++ b/kdevplatform/serialization/tests/test_itemrepository.cpp
@@ -1,367 +1,369 @@
 #include <QObject>
 #include <QTest>
 #include <serialization/itemrepository.h>
 #include <serialization/indexedstring.h>
 #include <stdlib.h>
 #include <time.h>
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 
 struct TestItem {
   TestItem(uint hash, uint dataSize) : m_hash(hash), m_dataSize(dataSize) {
   }
   //Every item has to implement this function, and return a valid hash.
   //Must be exactly the same hash value as ExampleItemRequest::hash() has returned while creating the item.
   unsigned int hash() const {
     return m_hash;
   }
 
   //Every item has to implement this function, and return the complete size this item takes in memory.
   //Must be exactly the same value as ExampleItemRequest::itemSize() has returned while creating the item.
   unsigned int itemSize() const {
     return sizeof(TestItem) + m_dataSize;
   }
 
   bool equals(const TestItem* rhs) const
   {
     return rhs->m_hash == m_hash
         && itemSize() == rhs->itemSize()
         && memcmp((char*)this, rhs, itemSize()) == 0;
   }
 
   uint m_hash;
   uint m_dataSize;
 };
 
 struct TestItemRequest {
   TestItem& m_item;
   bool m_compareData;
 
   TestItemRequest(TestItem& item, bool compareData = false)
     : m_item(item)
     , m_compareData(compareData)
   {
   }
   enum {
     AverageSize = 700 //This should be the approximate average size of an Item
   };
 
   uint hash() const {
     return m_item.hash();
   }
 
   //Should return the size of an item created with createItem
   size_t itemSize() const {
       return m_item.itemSize();
   }
 
   void createItem(TestItem* item) const {
     memcpy(item, &m_item, m_item.itemSize());
   }
 
   static void destroy(TestItem* /*item*/, KDevelop::AbstractItemRepository&) {
     //Nothing to do
   }
 
   static bool persistent(const TestItem* /*item*/) {
     return true;
   }
 
   //Should return whether the here requested item equals the given item
   bool equals(const TestItem* item) const {
     return hash() == item->hash() && (!m_compareData || m_item.equals(item));
   }
 };
 
 uint smallItemsFraction = 20; //Fraction of items betwen 0 and 1 kb
 uint largeItemsFraction = 1; //Fraction of items between 0 and 200 kb
 uint cycles = 10000;
 uint deletionProbability = 1; //Percentual probability that a checked item is deleted. Per-cycle probability must be multiplied with checksPerCycle.
 uint checksPerCycle = 10;
 
 TestItem* createItem(uint id, uint size) {
   TestItem* ret;
   char* data = new char[size];
   uint dataSize = size - sizeof(TestItem);
   ret = new (data) TestItem(id, dataSize);
 
   //Fill in same random pattern
   for(uint a = 0; a < dataSize; ++a)
     data[sizeof(TestItem) + a] = (char)(a + id);
 
   return ret;
 }
 
 ///@todo Add a test where the complete content is deleted again, and make sure the result has a nice structure
 ///@todo More consistency and lost-space tests, especially about monster-buckets. Make sure their space is re-claimed
 class TestItemRepository : public QObject {
   Q_OBJECT
   private Q_SLOTS:
     void initTestCase() {
-      KDevelop::AutoTestShell::init({{}}); // don't load any plugins
-      KDevelop::TestCore* core = new KDevelop::TestCore();
-      core->initialize(KDevelop::Core::NoUi);
+      KDevelop::ItemRepositoryRegistry::initialize(m_repositoryPath);
     }
     void cleanupTestCase() {
-        KDevelop::TestCore::shutdown();
+      KDevelop::ItemRepositoryRegistry::deleteRepositoryFromDisk(m_repositoryPath);
     }
+
     void testItemRepository() {
       KDevelop::ItemRepository<TestItem, TestItemRequest> repository(QStringLiteral("TestItemRepository"));
       uint itemId = 0;
       QHash<uint, TestItem*> realItemsByIndex;
       QHash<uint, TestItem*> realItemsById;
       uint totalInsertions = 0, totalDeletions = 0;
       uint maxSize = 0;
       uint totalSize = 0;
       srand(time(nullptr));
       uint highestSeenIndex = 0;
 
       for(uint a = 0; a < cycles; ++a) {
 
         {
           //Insert an item
           uint itemDecision = rand() % (smallItemsFraction + largeItemsFraction);
           uint itemSize;
           if(itemDecision < largeItemsFraction) {
             //Create a large item: Up to 200kb
             itemSize = (rand() % 200000) + sizeof(TestItem);
           } else
             itemSize = (rand() % 1000) + sizeof(TestItem);
           TestItem* item = createItem(++itemId, itemSize);
           Q_ASSERT(item->hash() == itemId);
           QVERIFY(item->equals(item));
           uint index = repository.index(TestItemRequest(*item));
           if(index > highestSeenIndex)
             highestSeenIndex = index;
           Q_ASSERT(index);
           realItemsByIndex.insert(index, item);
           realItemsById.insert(itemId, item);
           ++totalInsertions;
           totalSize += itemSize;
           if(itemSize > maxSize)
             maxSize = itemSize;
         }
 
         for(uint a = 0; a < checksPerCycle; ++a) {
             //Check an item
             uint pick = rand() % itemId;
             if(realItemsById.contains(pick)) {
               uint index = repository.findIndex(*realItemsById[pick]);
               QVERIFY(index);
               QVERIFY(realItemsByIndex.contains(index));
               QVERIFY(realItemsByIndex[index]->equals(repository.itemFromIndex(index)));
 
               if((uint) (rand() % 100) < deletionProbability) {
                 ++totalDeletions;
                 //Delete the item
                 repository.deleteItem(index);
                 QVERIFY(!repository.findIndex(*realItemsById[pick]));
                 uint newIndex = repository.index(*realItemsById[pick]);
                 QVERIFY(newIndex);
                 QVERIFY(realItemsByIndex[index]->equals(repository.itemFromIndex(newIndex)));
 
 #ifdef POSITION_TEST
                 //Since we have previously deleted the item, there must be enough space
                 if(!((newIndex >> 16) <= (highestSeenIndex >> 16))) {
                   qDebug() << "size:" << realItemsById[pick]->itemSize();
                   qDebug() << "previous highest seen bucket:" << (highestSeenIndex >> 16);
                   qDebug() << "new bucket:" << (newIndex >> 16);
                 }
                 QVERIFY((newIndex >> 16) <= (highestSeenIndex >> 16));
 #endif
                 repository.deleteItem(newIndex);
                 QVERIFY(!repository.findIndex(*realItemsById[pick]));
                 delete[] realItemsById[pick];
                 realItemsById.remove(pick);
                 realItemsByIndex.remove(index);
               }
            }
         }
       }
 
       // cleanup
       {
         for (auto it = realItemsByIndex.constBegin(); it != realItemsByIndex.constEnd(); ++it) {
           repository.deleteItem(it.key());
           delete[] it.value();
         }
         realItemsById.clear();
         realItemsByIndex.clear();
       }
 
       qDebug() << "total insertions:" << totalInsertions << "total deletions:" << totalDeletions << "average item size:" << (totalSize / totalInsertions) << "biggest item size:" << maxSize;
 
       KDevelop::ItemRepository<TestItem, TestItemRequest>::Statistics stats = repository.statistics();
       qDebug() << stats;
       QVERIFY(stats.freeUnreachableSpace < stats.freeSpaceInBuckets/100); // < 1% of the free space is unreachable
       QVERIFY(stats.freeSpaceInBuckets < stats.usedSpaceForBuckets); // < 20% free space
     }
     void testLeaks()
     {
       KDevelop::ItemRepository<TestItem, TestItemRequest> repository(QStringLiteral("TestItemRepository"));
       QList<TestItem*> items;
       for(int i = 0; i < 10000; ++i) {
         TestItem* item = createItem(i, (rand() % 1000) + sizeof(TestItem));
         items << item;
         repository.index(TestItemRequest(*item));
       }
       foreach(auto item, items) {
           delete[] item;
       }
     }
     void testStringSharing()
     {
       QString qString;
         qString.fill('.', 1000);
       KDevelop::IndexedString indexedString(qString);
       const int repeat = 10000;
       QVector<QString> strings;
       strings.resize(repeat);
       for(int i = 0; i < repeat; ++i) {
         strings[i] = indexedString.str();
         QCOMPARE(qString, strings[i]);
       }
     }
     void deleteClashingMonsterBucket()
     {
       KDevelop::ItemRepository<TestItem, TestItemRequest> repository(QStringLiteral("TestItemRepository"));
       const uint hash = 1235;
 
       QScopedArrayPointer<TestItem> monsterItem(createItem(hash, KDevelop::ItemRepositoryBucketSize + 10));
       QScopedArrayPointer<TestItem> smallItem(createItem(hash, 20));
       QVERIFY(!monsterItem->equals(smallItem.data()));
 
       uint smallIndex = repository.index(TestItemRequest(*smallItem, true));
       uint monsterIndex = repository.index(TestItemRequest(*monsterItem, true));
       QVERIFY(monsterIndex != smallIndex);
 
       repository.deleteItem(smallIndex);
       QVERIFY(!repository.findIndex(TestItemRequest(*smallItem, true)));
       QCOMPARE(monsterIndex, repository.findIndex(TestItemRequest(*monsterItem, true)));
       repository.deleteItem(monsterIndex);
 
       // now in reverse order, with different data see: https://bugs.kde.org/show_bug.cgi?id=272408
 
       monsterItem.reset(createItem(hash + 1, KDevelop::ItemRepositoryBucketSize + 10));
       smallItem.reset(createItem(hash + 1, 20));
       QVERIFY(!monsterItem->equals(smallItem.data()));
       monsterIndex = repository.index(TestItemRequest(*monsterItem, true));
       smallIndex = repository.index(TestItemRequest(*smallItem, true));
 
       repository.deleteItem(monsterIndex);
       QCOMPARE(smallIndex, repository.findIndex(TestItemRequest(*smallItem, true)));
       QVERIFY(!repository.findIndex(TestItemRequest(*monsterItem, true)));
       repository.deleteItem(smallIndex);
     }
     void usePermissiveModuloWhenRemovingClashLinks()
     {
       KDevelop::ItemRepository<TestItem, TestItemRequest> repository(QStringLiteral("PermissiveModulo"));
 
       const uint bucketHashSize = decltype(repository)::bucketHashSize;
       const uint nextBucketHashSize = decltype(repository)::MyBucket::NextBucketHashSize;
       auto bucketNumberForIndex = [](const uint index) {
         return index >> 16;
       };
 
       const uint clashValue = 2;
 
       // Choose sizes that ensure that the items fit in the desired buckets
       const uint bigItemSize = KDevelop::ItemRepositoryBucketSize * 0.55 - 1;
       const uint smallItemSize = KDevelop::ItemRepositoryBucketSize * 0.25 - 1;
 
       // Will get placed in bucket 1 (bucket zero is invalid), so the root bucket table at position 'clashValue' will be '1'
       const QScopedArrayPointer<TestItem> firstChainFirstLink(createItem(clashValue, bigItemSize));
       const uint firstChainFirstLinkIndex = repository.index(*firstChainFirstLink);
       QCOMPARE(bucketNumberForIndex(firstChainFirstLinkIndex), 1u);
 
       // Will also get placed in bucket 1, so root bucket table at position 'nextBucketHashSize + clashValue' will be '1'
       const QScopedArrayPointer<TestItem> secondChainFirstLink(createItem(nextBucketHashSize + clashValue, smallItemSize));
       const uint secondChainFirstLinkIndex = repository.index(*secondChainFirstLink);
       QCOMPARE(bucketNumberForIndex(secondChainFirstLinkIndex), 1u);
 
       // Will get placed in bucket 2, so bucket 1's next hash table at position 'clashValue' will be '2'
       const QScopedArrayPointer<TestItem> firstChainSecondLink(createItem(bucketHashSize + clashValue, bigItemSize));
       const uint firstChainSecondLinkIndex = repository.index(*firstChainSecondLink);
       QCOMPARE(bucketNumberForIndex(firstChainSecondLinkIndex), 2u);
 
       // Will also get placed in bucket 2, reachable since bucket 1's next hash table at position 'clashValue' is '2'
       const QScopedArrayPointer<TestItem> secondChainSecondLink(createItem(bucketHashSize + nextBucketHashSize + clashValue, smallItemSize));
       const uint secondChainSecondLinkIndex = repository.index(*secondChainSecondLink);
       QCOMPARE(bucketNumberForIndex(secondChainSecondLinkIndex), 2u);
 
       /*
        * At this point we have two chains in the repository, rooted at 'clashValue' and 'nextBucketHashSize + clashValue'
        * Both of the chains start in bucket 1 and end in bucket 2, but both chains share the same link to bucket 2
        * This is because two of the hashes clash the other two when % bucketHashSize, but all of them clash % nextBucketHashSize
        */
 
       repository.deleteItem(firstChainSecondLinkIndex);
 
       /*
        * Now we've deleted the second item in the first chain, this means the first chain no longer requires a link to the
        * second bucket where that item was... but the link must remain, since it's shared (clashed) by the second chain.
        *
        * When cutting a link out of the middle of the chain, we need to check if its items clash using the "permissive"
        * modulus (the size of the /next/ buckets map), which is always a factor of the "stricter" modulus (the size of the
        * /root/ buckets map).
        *
        * This behavior implies that there will sometimes be useless buckets in the bucket chain for a given hash, so when
        * cutting out the root link, it's safe to skip over them to the first clash with the 'stricter' modulus.
        */
 
       // The second item of the second chain must still be reachable
       QCOMPARE(repository.findIndex(*secondChainSecondLink), secondChainSecondLinkIndex);
 
       /*
        * As a memo to anyone who's still reading this, this also means the following situation can exist:
        *
        * bucketHashSize == 8
        * nextBucketHashSize == 4
        * U is a link table
        * B is a bucket
        * [...] are the hashes of the contained items
        *
        * U
        * U
        * U -> B1
        * U
        * U
        * U
        * U -> B2
        * U
        *
        * B0 (Invalid)
        * B1 -> [2, 6]
        *   U
        *   U
        *   U -> B3
        *   U
        * B2 -> [14]
        *   U
        *   U
        *   U -> B1
        *   U
        * B3 -> [10]
        *   U
        *   U
        *   U
        *   U
        *
        * The chain for hash 6 is:
        * Root[6] -> B2[2] -> B1[2] -> B3
        *
        * If you remove the item with hash 6, 6 and 2 will clash with mod 4 (permissive)
        *
        * So the useless link `B2[2] -> B1` will be preserved, even though its useless
        * as the item with hash 2 is reachable directly from the root.
        *
        * So TODO: Don't preserve links to items accessible from root buckets. This cannot
        * be done correctly using only Bucket::hasClashingItem as of now.
        */
     }
+
+private:
+    QString m_repositoryPath = QDir::tempPath() + QStringLiteral("/test_itemrepository");
 };
 
 #include "test_itemrepository.moc"
 
 QTEST_MAIN(TestItemRepository)
diff --git a/kdevplatform/shell/sessioncontroller.cpp b/kdevplatform/shell/sessioncontroller.cpp
index a32f68bcb2..9a90324e5b 100644
--- a/kdevplatform/shell/sessioncontroller.cpp
+++ b/kdevplatform/shell/sessioncontroller.cpp
@@ -1,651 +1,652 @@
 /* This file is part of KDevelop
 Copyright 2008 Andreas Pakulat <apaku@gmx.de>
 Copyright 2010 David Nolden <david.nolden.kdevelop@art-master.de>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License 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 "sessioncontroller.h"
 
 #include <QDir>
 #include <QHash>
 #include <QStringList>
 #include <QAction>
 #include <QApplication>
 #include <QDBusConnection>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLineEdit>
 #include <QListView>
 #include <QSortFilterProxyModel>
 #include <QStandardItemModel>
 #include <QVBoxLayout>
 
 #include <KActionCollection>
 #include <KConfigGroup>
 #include <KIO/CopyJob>
 #include <KJobWidgets>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KProcess>
 #include <KStringHandler>
 
 #include "session.h"
 #include "core.h"
 #include "uicontroller.h"
 #include "shellextension.h"
 #include "sessionlock.h"
 #include "sessionchooserdialog.h"
 #include "debug.h"
+
 #include <sublime/mainwindow.h>
 #include <serialization/itemrepositoryregistry.h>
-
+#include <duchain/duchain.h>
 
 namespace KDevelop
 {
 
 namespace {
     int argc = 0;
     char** argv = nullptr;
 };
 
 void SessionController::setArguments(int _argc, char** _argv)
 {
     argc = _argc;
     argv = _argv;
 }
 
 static QStringList standardArguments()
 {
     QStringList ret;
     for(int a = 0; a < argc; ++a)
     {
         QString arg = QString::fromLocal8Bit(argv[a]);
         if(arg.startsWith(QLatin1String("-graphicssystem")) || arg.startsWith(QLatin1String("-style")))
         {
             ret << QLatin1Char('-') + arg;
             if(a+1 < argc)
                 ret << QString::fromLocal8Bit(argv[a+1]);
         }
     }
     return ret;
 }
 
 class SessionControllerPrivate : public QObject
 {
     Q_OBJECT
 public:
     explicit SessionControllerPrivate( SessionController* s )
         : q(s)
         , activeSession(nullptr)
         , grp(nullptr)
     {
     }
 
     ~SessionControllerPrivate() override {
     }
 
     Session* findSessionForName( const QString& name ) const
     {
         foreach( Session* s, sessionActions.keys() )
         {
             if( s->name() == name )
                 return s;
         }
         return nullptr;
     }
 
     Session* findSessionForId(const QString& idString)
     {
         QUuid id(idString);
 
         foreach( Session* s, sessionActions.keys() )
         {
             if( s->id() == id)
                 return s;
         }
         return nullptr;
     }
 
     void newSession()
     {
         qsrand(QDateTime::currentDateTimeUtc().toTime_t());
         Session* session = new Session( QUuid::createUuid().toString() );
 
         KProcess::startDetached(ShellExtension::getInstance()->executableFilePath(), QStringList() << QStringLiteral("-s") << session->id().toString() << standardArguments());
         delete session;
 #if 0
         //Terminate this instance of kdevelop if the user agrees
         foreach(Sublime::MainWindow* window, Core::self()->uiController()->controller()->mainWindows())
             window->close();
 #endif
     }
 
     void deleteCurrentSession()
     {
         int choice = KMessageBox::warningContinueCancel(Core::self()->uiController()->activeMainWindow(), i18n("The current session and all contained settings will be deleted. The projects will stay unaffected. Do you really want to continue?"));
 
         if(choice == KMessageBox::Continue)
         {
             q->deleteSessionFromDisk(sessionLock);
             q->emitQuitSession();
         }
     }
 
     void renameSession()
     {
         bool ok;
         auto newSessionName = QInputDialog::getText(Core::self()->uiController()->activeMainWindow(),
                                                     i18n("Rename Session"), i18n("New Session Name:"),
                                                     QLineEdit::Normal, q->activeSession()->name(), &ok);
         if (ok) {
             static_cast<Session*>(q->activeSession())->setName(newSessionName);
         }
 
         q->updateXmlGuiActionList(); // resort
     }
 
     bool loadSessionExternally( Session* s )
     {
         Q_ASSERT( s );
         KProcess::startDetached(ShellExtension::getInstance()->executableFilePath(), QStringList() << QStringLiteral("-s") << s->id().toString() << standardArguments());
         return true;
     }
 
     TryLockSessionResult activateSession( Session* s )
     {
         Q_ASSERT( s );
 
         activeSession = s;
         TryLockSessionResult result = SessionController::tryLockSession( s->id().toString());
         if( !result.lock ) {
             activeSession = nullptr;
             return result;
         }
         Q_ASSERT(s->id().toString() == result.lock->id());
         sessionLock = result.lock;
 
         KConfigGroup grp = KSharedConfig::openConfig()->group( SessionController::cfgSessionGroup() );
         grp.writeEntry( SessionController::cfgActiveSessionEntry(), s->id().toString() );
         grp.sync();
         if (Core::self()->setupFlags() & Core::NoUi) return result;
 
         QHash<Session*,QAction*>::iterator it = sessionActions.find(s);
         Q_ASSERT( it != sessionActions.end() );
         (*it)->setCheckable(true);
         (*it)->setChecked(true);
 
         for(it = sessionActions.begin(); it != sessionActions.end(); ++it)
         {
             if(it.key() != s)
                 (*it)->setCheckable(false);
         }
 
         return result;
     }
 
     void loadSessionFromAction(QAction* action)
     {
         auto session = action->data().value<Session*>();
         loadSessionExternally(session);
     }
 
     void addSession( Session* s )
     {
         if (Core::self()->setupFlags() & Core::NoUi) {
             sessionActions[s] = nullptr;
             return;
         }
 
         QAction* a = new QAction( grp );
         a->setText( s->description() );
         a->setCheckable( false );
         a->setData(QVariant::fromValue<Session*>(s));
 
         sessionActions[s] = a;
         q->actionCollection()->addAction(QLatin1String("session_") + s->id().toString(), a);
         connect( s, &Session::sessionUpdated, this, &SessionControllerPrivate::sessionUpdated );
         sessionUpdated( s );
     }
 
     SessionController* q;
 
     QHash<Session*, QAction*> sessionActions;
     ISession* activeSession;
     QActionGroup* grp;
 
     ISessionLock::Ptr sessionLock;
 
     static QString sessionBaseDirectory()
     {
         return QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation)
             + QLatin1Char('/') + qApp->applicationName() + QLatin1String("/sessions/");
     }
 
     QString ownSessionDirectory() const
     {
         Q_ASSERT(activeSession);
         return q->sessionDirectory( activeSession->id().toString() );
     }
 
 private Q_SLOTS:
     void sessionUpdated( KDevelop::ISession* s )
     {
         sessionActions[static_cast<Session*>( s )]->setText( KStringHandler::rsqueeze(s->description()) );
     }
 };
 
 
 SessionController::SessionController( QObject *parent )
         : QObject( parent ), d(new SessionControllerPrivate(this))
 {
     setObjectName(QStringLiteral("SessionController"));
     setComponentName(QStringLiteral("kdevsession"), i18n("Session Manager"));
 
     setXMLFile(QStringLiteral("kdevsessionui.rc"));
 
     QDBusConnection::sessionBus().registerObject( QStringLiteral("/org/kdevelop/SessionController"),
         this, QDBusConnection::ExportScriptableSlots );
 
     if (Core::self()->setupFlags() & Core::NoUi) return;
 
     QAction* action = actionCollection()->addAction(QStringLiteral("new_session"));
     connect(action, &QAction::triggered, this, [&] { d->newSession(); });
     action->setText( i18nc("@action:inmenu", "Start New Session") );
     action->setToolTip( i18nc("@info:tooltip", "Start a new KDevelop instance with an empty session") );
     action->setIcon(QIcon::fromTheme(QStringLiteral("window-new")));
 
     action = actionCollection()->addAction(QStringLiteral("rename_session"));
     connect(action, &QAction::triggered, this, [&] { d->renameSession(); });
     action->setText( i18n("Rename Current Session...") );
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-rename")));
 
     action = actionCollection()->addAction(QStringLiteral("delete_session"));
     connect(action, &QAction::triggered, this, [&] { d->deleteCurrentSession(); });
     action->setText( i18n("Delete Current Session...") );
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
 
     action = actionCollection()->addAction( QStringLiteral("quit"), this, SIGNAL(quitSession()) );
     action->setText( i18n("Quit") );
     action->setMenuRole( QAction::NoRole ); // OSX: prevent QT from hiding this due to conflict with 'Quit KDevelop...'
     actionCollection()->setDefaultShortcut( action, Qt::CTRL | Qt::Key_Q );
     action->setIcon(QIcon::fromTheme(QStringLiteral("application-exit")));
 
     d->grp = new QActionGroup( this );
     connect( d->grp, &QActionGroup::triggered, this, [&] (QAction* a) { d->loadSessionFromAction(a); } );
 }
 
 SessionController::~SessionController() = default;
 
 void SessionController::startNewSession()
 {
     d->newSession();
 }
 
 void SessionController::cleanup()
 {
     if (d->activeSession) {
         Q_ASSERT(d->activeSession->id().toString() == d->sessionLock->id());
 
         if (d->activeSession->isTemporary()) {
             deleteSessionFromDisk(d->sessionLock);
         }
         d->activeSession = nullptr;
     }
 
     d->sessionLock.clear();
     qDeleteAll(d->sessionActions);
     d->sessionActions.clear();
 }
 
 void SessionController::initialize( const QString& session )
 {
     QDir sessiondir( SessionControllerPrivate::sessionBaseDirectory() );
 
     foreach( const QString& s, sessiondir.entryList( QDir::AllDirs | QDir::NoDotAndDotDot ) )
     {
         QUuid id( s );
         if( id.isNull() )
             continue;
         // Only create sessions for directories that represent proper uuid's
         Session* ses = new Session( id.toString(), this );
 
         //Delete sessions that have no name and are empty
         if( ses->containedProjects().isEmpty() && ses->name().isEmpty()
             && (session.isEmpty() || (ses->id().toString() != session && ses->name() != session)) )
         {
             TryLockSessionResult result = tryLockSession(s);
             if (result.lock) {
                 deleteSessionFromDisk(result.lock);
             }
             delete ses;
         } else {
             d->addSession( ses );
         }
     }
 
     loadDefaultSession( session );
 
     updateXmlGuiActionList();
 }
 
 
 ISession* SessionController::activeSession() const
 {
     return d->activeSession;
 }
 
 ISessionLock::Ptr SessionController::activeSessionLock() const
 {
     return d->sessionLock;
 }
 
 void SessionController::loadSession( const QString& nameOrId )
 {
     d->loadSessionExternally( session( nameOrId ) );
 }
 
 QList<QString> SessionController::sessionNames() const
 {
     QStringList l;
     foreach( const Session* s, d->sessionActions.keys() )
     {
         l << s->name();
     }
     return l;
 }
 
 QList< const KDevelop::Session* > SessionController::sessions() const
 {
     QList< const KDevelop::Session* > ret;
     foreach( const Session* s, d->sessionActions.keys() )
     {
         ret << s;
     }
     return ret;
 }
 
 Session* SessionController::createSession( const QString& name )
 {
     Session* s;
     if(name.startsWith(QLatin1Char('{'))) {
         s = new Session( QUuid(name).toString(), this );
     }else{
         qsrand(QDateTime::currentDateTimeUtc().toTime_t());
         s = new Session( QUuid::createUuid().toString(), this );
         s->setName( name );
     }
     d->addSession( s );
     updateXmlGuiActionList();
     return s;
 }
 
 void SessionController::deleteSession( const ISessionLock::Ptr& lock )
 {
     Session* s  = session(lock->id());
 
     QHash<Session*,QAction*>::iterator it = d->sessionActions.find(s);
     Q_ASSERT( it != d->sessionActions.end() );
 
     unplugActionList( QStringLiteral("available_sessions") );
     actionCollection()->removeAction(*it);
     if (d->grp) { // happens in unit tests
         d->grp->removeAction(*it);
         plugActionList( QStringLiteral("available_sessions"), d->grp->actions() );
     }
 
     if (s == d->activeSession) {
         d->activeSession = nullptr;
     }
     deleteSessionFromDisk(lock);
 
     emit sessionDeleted( s->id().toString() );
     d->sessionActions.remove(s);
     delete s;
 }
 
 void SessionController::deleteSessionFromDisk( const ISessionLock::Ptr& lock )
 {
     qCDebug(SHELL) << "Deleting session:" << lock->id();
 
     static_cast<SessionLock*>(lock.data())->removeFromDisk();
-    ItemRepositoryRegistry::deleteRepositoryFromDisk( lock );
+    ItemRepositoryRegistry::deleteRepositoryFromDisk(DUChain::repositoryPathForSession(lock));
 }
 
 void SessionController::loadDefaultSession( const QString& session )
 {
     QString load = session;
     if (load.isEmpty()) {
         KConfigGroup grp = KSharedConfig::openConfig()->group( cfgSessionGroup() );
         load = grp.readEntry( cfgActiveSessionEntry(), "default" );
     }
 
     // Iteratively try to load the session, asking user what to do in case of failure
     // If showForceOpenDialog() returns empty string, stop trying
     do
     {
         Session* s = this->session(load);
         if( !s ) {
             s = createSession( load );
         }
         TryLockSessionResult result = d->activateSession( s );
         if( result.lock ) {
             Q_ASSERT(d->activeSession == s);
             Q_ASSERT(d->sessionLock = result.lock);
             break;
         }
         load = handleLockedSession( s->name(), s->id().toString(), result.runInfo );
     } while( !load.isEmpty() );
 }
 
 Session* SessionController::session( const QString& nameOrId ) const
 {
     Session* ret = d->findSessionForName( nameOrId );
     if(ret)
         return ret;
 
     return d->findSessionForId( nameOrId );
 }
 
 QString SessionController::cloneSession( const QString& nameOrid )
 {
     Session* origSession = session( nameOrid );
     qsrand(QDateTime::currentDateTimeUtc().toTime_t());
     QUuid id = QUuid::createUuid();
     auto copyJob = KIO::copy(QUrl::fromLocalFile(sessionDirectory(origSession->id().toString())),
                              QUrl::fromLocalFile(sessionDirectory( id.toString())));
     KJobWidgets::setWindow(copyJob, Core::self()->uiController()->activeMainWindow());
     copyJob->exec();
 
     Session* newSession = new Session( id.toString() );
     newSession->setName( i18n( "Copy of %1", origSession->name() ) );
     d->addSession(newSession);
     updateXmlGuiActionList();
     return newSession->name();
 }
 
 void SessionController::updateXmlGuiActionList()
 {
     unplugActionList( QStringLiteral("available_sessions") );
 
     if (d->grp) {
         auto actions = d->grp->actions();
         std::sort(actions.begin(), actions.end(), [](const QAction* lhs, const QAction* rhs) {
             auto s1 = lhs->data().value<Session*>();
             auto s2 = rhs->data().value<Session*>();
             return QString::localeAwareCompare(s1->description(), s2->description()) < 0;
         });
         plugActionList(QStringLiteral("available_sessions"), actions);
     }
 }
 
 
 QString SessionController::cfgSessionGroup() { return QStringLiteral("Sessions"); }
 QString SessionController::cfgActiveSessionEntry() { return QStringLiteral("Active Session ID"); }
 
 SessionInfos SessionController::availableSessionInfos()
 {
     SessionInfos sessionInfos;
     foreach( const QString& sessionId, QDir( SessionControllerPrivate::sessionBaseDirectory() ).entryList( QDir::AllDirs ) ) {
         if( !QUuid( sessionId ).isNull() ) {
             sessionInfos << Session::parse( sessionId );
         }
     }
     return sessionInfos;
 }
 
 QString SessionController::sessionDirectory(const QString& sessionId)
 {
     return SessionControllerPrivate::sessionBaseDirectory() + sessionId;
 }
 
 TryLockSessionResult SessionController::tryLockSession(const QString& id, bool doLocking)
 {
     return SessionLock::tryLockSession(id, doLocking);
 }
 
 bool SessionController::isSessionRunning(const QString& id)
 {
     return sessionRunInfo(id).isRunning;
 }
 
 SessionRunInfo SessionController::sessionRunInfo(const QString& id)
 {
     return SessionLock::tryLockSession(id, false).runInfo;
 }
 
 QString SessionController::showSessionChooserDialog(const QString& headerText, bool onlyRunning)
 {
     ///FIXME: move this code into sessiondialog.cpp
     QListView* view = new QListView;
     QLineEdit* filter = new QLineEdit;
     filter->setClearButtonEnabled( true );
     filter->setPlaceholderText(i18n("Search"));
 
     QStandardItemModel* model = new QStandardItemModel(view);
 
     QSortFilterProxyModel *proxy = new QSortFilterProxyModel(model);
     proxy->setSourceModel(model);
     proxy->setFilterKeyColumn( 1 );
     proxy->setFilterCaseSensitivity( Qt::CaseInsensitive );
     connect(filter, &QLineEdit::textChanged, proxy, &QSortFilterProxyModel::setFilterFixedString);
 
     SessionChooserDialog dialog(view, proxy, filter);
     view->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
     QVBoxLayout layout(dialog.mainWidget());
     if(!headerText.isEmpty()) {
         QLabel* heading = new QLabel(headerText);
         QFont font = heading->font();
         font.setBold(true);
         heading->setFont(font);
         layout.addWidget(heading);
     }
 
     model->setColumnCount(3);
     model->setHeaderData(0, Qt::Horizontal,i18n("Identity"));
     model->setHeaderData(1, Qt::Horizontal, i18n("Contents"));
     model->setHeaderData(2, Qt::Horizontal,i18n("State"));
 
     view->setModel(proxy);
     view->setModelColumn(1);
 
     QHBoxLayout* filterLayout = new QHBoxLayout();
     filterLayout->addWidget(new QLabel(i18n("Filter:")));
     filterLayout->addWidget(filter);
     layout.addLayout(filterLayout);
     layout.addWidget(view);
     filter->setFocus();
 
     int row = 0;
 
     QString defaultSession = KSharedConfig::openConfig()->group( cfgSessionGroup() ).readEntry( cfgActiveSessionEntry(), "default" );
 
     foreach(const KDevelop::SessionInfo& si, KDevelop::SessionController::availableSessionInfos())
     {
         if ( si.name.isEmpty() && si.projects.isEmpty() ) {
             continue;
         }
 
         bool running = KDevelop::SessionController::isSessionRunning(si.uuid.toString());
 
         if(onlyRunning && !running)
             continue;
 
         model->setItem(row, 0, new QStandardItem(si.uuid.toString()));
         model->setItem(row, 1, new QStandardItem(si.description));
         model->setItem(row, 2, new QStandardItem);
 
         ++row;
     }
     model->sort(1);
 
     if(!onlyRunning) {
         model->setItem(row, 0, new QStandardItem);
         model->setItem(row, 1, new QStandardItem(QIcon::fromTheme(QStringLiteral("window-new")), i18n("Create New Session")));
     }
 
     dialog.updateState();
     dialog.mainWidget()->layout()->setContentsMargins(0,0,0,0);
 
     const QModelIndex defaultSessionIndex = model->match(model->index(0, 0), Qt::DisplayRole, defaultSession, 1, Qt::MatchExactly).value(0);
     view->selectionModel()->setCurrentIndex(proxy->mapFromSource(defaultSessionIndex), QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
     view->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
     ///@todo We need a way to get a proper size-hint from the view, but unfortunately, that only seems possible after the view was shown.
     dialog.resize(QSize(900, 600));
 
     if(dialog.exec() != QDialog::Accepted) // krazy:exclude=crashy
     {
         return QString();
     }
 
     QModelIndex selected = view->selectionModel()->currentIndex();
     if (!selected.isValid())
         return QString();
 
     const QString selectedSessionId = selected.sibling(selected.row(), 0).data().toString();
     if (selectedSessionId.isEmpty()) {
         // "Create New Session" item selected, return a fresh UUID
         qsrand(QDateTime::currentDateTimeUtc().toTime_t());
         return QUuid::createUuid().toString();
     }
     return selectedSessionId;
 }
 
 QString SessionController::handleLockedSession( const QString& sessionName, const QString& sessionId,
                                                 const SessionRunInfo& runInfo )
 {
     return SessionLock::handleLockedSession(sessionName, sessionId, runInfo);
 }
 
 QString SessionController::sessionDir()
 {
     if( !activeSession() )
         return QString();
     return d->ownSessionDirectory();
 }
 
 QString SessionController::sessionName()
 {
     if(!activeSession())
         return QString();
     return activeSession()->description();
 }
 
 
 }
 #include "sessioncontroller.moc"
 #include "moc_sessioncontroller.cpp"